build(kernel-test): Bundle test vats from typescript source (#801)

## refactor(kernel-test): Convert vat source files to TypeScript

### Summary

- Convert test vat source files from JavaScript to TypeScript with
proper type annotations
- Add `TestPowers` type and `unwrapTestLogger` utility for test vats
that need structured logging

### Changes

**ocap-kernel:**
- Add `buildRootObject` parameter types

**kernel-test:**
- Rename all 38 vat source files from `.js` to `.ts`
- Add TypeScript type annotations to all vat source files
- Create `test-powers.ts` with `TestPowers` type and `unwrapTestLogger`
utility
- Update vats to use `TestPowers` for typed logger access

**cli:**
- Update vat bundler glob pattern to include `.ts` files (still matches
`.js`, too)

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Mostly test and tooling changes, but it touches the CLI bundling glob
and exports new public types from `@MetaMask/ocap-kernel`, which could
affect downstream builds if assumptions about source extensions or type
exports differ.
> 
> **Overview**
> **Test vats are now authored in TypeScript and bundled from `.ts`
sources.** The CLI `bundleDir` command expands its glob to include
`*.{js,ts}` so vat bundles can be generated directly from TS
entrypoints.
> 
> **`kernel-test` vats were converted from `.js` to `.ts` with stronger
typing and standardized logging.** A new `TestPowers` type plus
`unwrapTestLogger` helper centralize structured test logging, and vats
add explicit parameter/service/baggage types (including durable
`Baggage` use).
> 
> **`ocap-kernel` exposes additional public types.** `VatPowers` and
`Baggage` are now exported from `@MetaMask/ocap-kernel` to support typed
vat power signatures in tests.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
30f557f. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: grypez

packages/cli/src/commands/bundle.ts

@@ -50,7 +50,7 @@ export async function bundleDir(
   const { logger } = options;
   logger.info('Bundling directory:', sourceDir);
   await Promise.all(
-    (await glob(join(sourceDir, '*.js'))).map(
+    (await glob(join(sourceDir, '*.{js,ts}'))).map(
       async (source) => await bundleFile(source, { logger }),
     ),
   );

packages/kernel-test/src/test-powers.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '@metamask/logger';
+import type { VatPowers } from '@metamask/ocap-kernel';
+
+/**
+ * Powers provided to test vats that need structured logging.
+ * Extends VatPowers to maintain type compatibility with production vat powers.
+ */
+export type TestPowers = VatPowers & {
+  logger: Logger;
+};
+
+/**
+ * Extract a tlog function from test vat powers.
+ *
+ * @param powers - The vat powers containing a logger.
+ * @param name - The vat name to include in log tags.
+ * @returns A function that logs with 'test' and name tags.
+ */
+export function unwrapTestLogger(
+  powers: TestPowers,
+  name: string,
+): (message: string, ...args: unknown[]) => void {
+  const logger = powers.logger.subLogger({ tags: ['test', name] });
+  return (message: string, ...args: unknown[]): void =>
+    logger.log(message, ...args);
+}

packages/kernel-test/src/vats/async-generator-iterator-vat.js

@@ -0,0 +1,53 @@
+import { E } from '@endo/eventual-send';
+import { makeDefaultExo } from '@metamask/kernel-utils/exo';
+import { makeEventualIterator, makeExoGenerator } from '@ocap/remote-iterables';
+
+import { unwrapTestLogger } from '../test-powers.ts';
+import type { TestPowers } from '../test-powers.ts';
+
+/**
+ * Build function for testing async generators.
+ *
+ * @param vatPowers - The powers of the vat.
+ * @param vatPowers.logger - The logger to use.
+ * @param parameters - The parameters of the vat.
+ * @param parameters.name - The name of the vat.
+ * @returns The root object for the vat.
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function buildRootObject(
+  vatPowers: TestPowers,
+  { name }: { name: string },
+) {
+  const tlog = unwrapTestLogger(vatPowers, name);
+
+  tlog(`${name} buildRootObject`);
+
+  return makeDefaultExo('root', {
+    async bootstrap(
+      { consumer, producer }: { consumer: unknown; producer: unknown },
+      _services: unknown,
+    ) {
+      tlog(`${name} is bootstrap`);
+      await E(consumer).iterate(producer);
+    },
+
+    generate: async (stop: number) =>
+      makeExoGenerator(
+        (async function* () {
+          for (let i = 0; i < stop; i++) {
+            tlog(`${name} generating ${i}`);
+            yield i;
+          }
+          // Note the IIFE.
+        })(),
+      ),
+
+    iterate: async (producer: unknown) => {
+      const remoteGenerator = await E(producer).generate(5);
+      for await (const value of makeEventualIterator(remoteGenerator)) {
+        tlog(`${name} iterating ${String(value)}`);
+      }
+    },
+  });
+}

packages/kernel-test/src/vats/async-generator-iterator-vat.ts

@@ -4,18 +4,23 @@ import { makeDefaultExo } from '@metamask/kernel-utils/exo';
 /**
  * Build function for a vat that exports a discoverable exo capability.
  *
- * @param {*} _vatPowers - Special powers granted to this vat (not used here).
- * @param {*} _parameters - Initialization parameters from the vat's config object.
- * @param {*} _baggage - Root of vat's persistent state (not used here).
- * @returns {*} The root object for the new vat.
+ * @param _vatPowers - Special powers granted to this vat (not used here).
+ * @param _parameters - Initialization parameters from the vat's config object.
+ * @param _baggage - Root of vat's persistent state (not used here).
+ * @returns The root object for the new vat.
  */
-export function buildRootObject(_vatPowers, _parameters, _baggage) {
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function buildRootObject(
+  _vatPowers: unknown,
+  _parameters: unknown = {},
+  _baggage: unknown = null,
+) {
   const calculator = makeDiscoverableExo(
     'Calculator',
     {
-      add: (a, b) => a + b,
-      multiply: (a, b) => a * b,
-      greet: (name) => `Hello, ${name}!`,
+      add: (a: number, b: number) => a + b,
+      multiply: (a: number, b: number) => a * b,
+      greet: (name: string) => `Hello, ${name}!`,
     },
     {
       add: {

…/src/vats/discoverable-capability-vat.js …/src/vats/discoverable-capability-vat.tspackages/kernel-test/src/vats/discoverable-capability-vat.js renamed to packages/kernel-test/src/vats/discoverable-capability-vat.ts packages/kernel-test/src/vats/discoverable-capability-vat.js renamed to packages/kernel-test/src/vats/discoverable-capability-vat.ts

@@ -0,0 +1,37 @@
+import { makeDefaultExo } from '@metamask/kernel-utils/exo';
+
+import { unwrapTestLogger } from '../test-powers.ts';
+import type { TestPowers } from '../test-powers.ts';
+
+/**
+ * Build a root object for a vat that uses the fetch capability.
+ *
+ * @param vatPowers - The powers of the vat.
+ * @param vatPowers.logger - The logger for the vat.
+ * @returns The root object.
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export async function buildRootObject(vatPowers: TestPowers) {
+  const tlog = unwrapTestLogger(vatPowers, 'endowment-user');
+
+  tlog('buildRootObject');
+
+  const root = makeDefaultExo('root', {
+    bootstrap: () => {
+      tlog('bootstrap');
+    },
+    hello: async (url: string) => {
+      try {
+        const response = await fetch(url);
+        const text = await response.text();
+        tlog(`response: ${text}`);
+        return text;
+      } catch (error) {
+        tlog(`error: ${String(error)}`);
+        throw error;
+      }
+    },
+  });
+
+  return root;
+}

packages/kernel-test/src/vats/endowment-fetch.js

@@ -1,16 +1,20 @@
 import { makeDefaultExo } from '@metamask/kernel-utils/exo';
 
+// eslint-disable-next-line no-console
 console.log('bootstrap throw');
 
 /**
  * Build function for vats that will throw an error during bootstrap.
  *
- * @returns {object} The root object for the new vat.
+ * @returns The root object for the new vat.
  */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function buildRootObject() {
+  // eslint-disable-next-line no-console
   console.log('buildRootObject');
   return makeDefaultExo('root', {
     bootstrap: () => {
+      // eslint-disable-next-line no-console
       console.log('bootstrap');
       throw new Error('from bootstrap');
     },

packages/kernel-test/src/vats/endowment-fetch.ts

@@ -1,17 +1,21 @@
 import { makePromiseKit } from '@endo/promise-kit';
 import { makeDefaultExo } from '@metamask/kernel-utils/exo';
 
+// eslint-disable-next-line no-console
 console.log('bootstrap uncaught rejection');
 
 /**
  * Build function for vats that will reject a promise during bootstrap.
  *
- * @returns {object} The root object for the new vat.
+ * @returns The root object for the new vat.
  */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function buildRootObject() {
+  // eslint-disable-next-line no-console
   console.log('buildRootObject');
   return makeDefaultExo('root', {
     bootstrap: () => {
+      // eslint-disable-next-line no-console
       console.log('bootstrap');
       const { reject } = makePromiseKit();
       reject('from bootstrap');

…l-test/src/vats/error-bootstrap-throw.js …l-test/src/vats/error-bootstrap-throw.tspackages/kernel-test/src/vats/error-bootstrap-throw.js renamed to packages/kernel-test/src/vats/error-bootstrap-throw.ts packages/kernel-test/src/vats/error-bootstrap-throw.js renamed to packages/kernel-test/src/vats/error-bootstrap-throw.ts

@@ -1,11 +1,12 @@
+// eslint-disable-next-line no-console
 console.log('build throw');
 
 /**
  * Build function for vats that will throw an error during buildRootObject.
- *
- * @returns {never} Always throws an error.
+ * This function always throws and never returns.
  */
-export function buildRootObject() {
+export function buildRootObject(): never {
+  // eslint-disable-next-line no-console
   console.log('buildRootObject');
   throw new Error('from buildRootObject');
 }