diff --git a/constraints.pro b/constraints.pro
index 64f16b016..bfe1280c9 100644
--- a/constraints.pro
+++ b/constraints.pro
@@ -208,10 +208,12 @@ gen_enforced_field(WorkspaceCwd, 'module', './dist/index.mjs') :-
   \+ workspace_field(WorkspaceCwd, 'private', true).
 % Non-published packages must not specify an entrypoint.
 gen_enforced_field(WorkspaceCwd, 'main', null) :-
-  WorkspaceCwd \= 'packages/shims'.
+  WorkspaceCwd \= 'packages/shims',
+  WorkspaceCwd \= 'packages/streams',
   workspace_field(WorkspaceCwd, 'private', true).
 gen_enforced_field(WorkspaceCwd, 'module', null) :-
-  WorkspaceCwd \= 'packages/shims'.
+  WorkspaceCwd \= 'packages/shims',
+  WorkspaceCwd \= 'packages/streams',
   workspace_field(WorkspaceCwd, 'private', true).
 
 % The type definitions entrypoint for all publishable packages must be the same.
@@ -219,7 +221,8 @@ gen_enforced_field(WorkspaceCwd, 'types', './dist/index.d.cts') :-
   \+ workspace_field(WorkspaceCwd, 'private', true).
 % Non-published packages must not specify a type definitions entrypoint.
 gen_enforced_field(WorkspaceCwd, 'types', null) :-
-  WorkspaceCwd \= 'packages/shims'.
+  WorkspaceCwd \= 'packages/shims',
+  WorkspaceCwd \= 'packages/streams',
   workspace_field(WorkspaceCwd, 'private', true).
 
 % The exports for all published packages must be the same.
@@ -246,7 +249,8 @@ gen_enforced_field(WorkspaceCwd, 'sideEffects', false) :-
   \+ workspace_field(WorkspaceCwd, 'private', true).
 % Non-published packages must not specify side effects.
 gen_enforced_field(WorkspaceCwd, 'sideEffects', null) :-
-  WorkspaceCwd \= 'packages/shims'.
+  WorkspaceCwd \= 'packages/shims',
+  WorkspaceCwd \= 'packages/streams',
   workspace_field(WorkspaceCwd, 'private', true).
 
 % The list of files included in published packages must only include files
diff --git a/package.json b/package.json
index 3b413a28d..7a56debe7 100644
--- a/package.json
+++ b/package.json
@@ -59,7 +59,7 @@
     "prettier-plugin-packagejson": "^2.3.0",
     "rimraf": "^6.0.1",
     "typedoc": "^0.24.8",
-    "typescript": "~5.5.4",
+    "typescript": "~4.9.5",
     "vite": "^5.3.5",
     "vite-tsconfig-paths": "^4.3.2",
     "vitest": "^2.0.5"
diff --git a/packages/extension/package.json b/packages/extension/package.json
index 192af388f..3fcdf03ac 100644
--- a/packages/extension/package.json
+++ b/packages/extension/package.json
@@ -31,6 +31,7 @@
     "@metamask/snaps-utils": "^7.8.0",
     "@metamask/utils": "^9.1.0",
     "@ocap/shims": "workspace:^",
+    "@ocap/streams": "workspace:^",
     "ses": "^1.7.0"
   },
   "devDependencies": {
@@ -46,7 +47,7 @@
     "rimraf": "^6.0.1",
     "typedoc": "^0.24.8",
     "typedoc-plugin-missing-exports": "^2.0.0",
-    "typescript": "~5.5.4",
+    "typescript": "~4.9.5",
     "vite": "^5.3.5",
     "vite-plugin-static-copy": "^1.0.6",
     "vitest": "^2.0.5"
diff --git a/packages/extension/src/iframe-manager.test.ts b/packages/extension/src/iframe-manager.test.ts
index c2a00c5e5..6c3d4c9a1 100644
--- a/packages/extension/src/iframe-manager.test.ts
+++ b/packages/extension/src/iframe-manager.test.ts
@@ -1,54 +1,21 @@
-import type { makePromiseKit } from '@endo/promise-kit';
 import * as snapsUtils from '@metamask/snaps-utils';
-import { vi, beforeEach, describe, it, expect } from 'vitest';
+import { delay, makePromiseKitMock } from '@ocap/test-utils';
+import { vi, describe, it, expect } from 'vitest';
 
+import { IframeManager } from './iframe-manager.js';
 import { Command } from './shared.js';
 
-vi.mock('@endo/promise-kit', () => ({
-  makePromiseKit: (): ReturnType<typeof makePromiseKit> => {
-    let resolve: (value: unknown) => void, reject: (reason?: unknown) => void;
-    const promise = new Promise((_resolve, _reject) => {
-      resolve = _resolve;
-      reject = _reject;
-    });
-    // @ts-expect-error We have in fact assigned resolve and reject.
-    return { promise, resolve, reject };
-  },
-}));
+vi.mock('@endo/promise-kit', () => makePromiseKitMock());
 
 vi.mock('@metamask/snaps-utils', () => ({
   createWindow: vi.fn(),
 }));
 
 describe('IframeManager', () => {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
-  let IframeManager: typeof import('./iframe-manager.js').IframeManager;
-
-  beforeEach(async () => {
-    vi.resetModules();
-    IframeManager = (await import('./iframe-manager.js')).IframeManager;
-  });
-
-  describe('getInstance', () => {
-    it('is a singleton', () => {
-      expect(IframeManager.getInstance()).toBe(IframeManager.getInstance());
-    });
-
-    it('sets up event listener on construction', () => {
-      const addEventListenerSpy = vi.spyOn(window, 'addEventListener');
-      let manager = IframeManager.getInstance();
-
-      expect(manager).toBeInstanceOf(IframeManager);
-      expect(addEventListenerSpy).toHaveBeenCalledOnce();
-      expect(addEventListenerSpy).toHaveBeenCalledWith(
-        'message',
-        expect.any(Function),
-      );
-
-      manager = IframeManager.getInstance();
-      expect(addEventListenerSpy).toHaveBeenCalledOnce();
-    });
-  });
+  const makeGetPort =
+    (port: MessagePort = new MessageChannel().port1) =>
+    async (_window: Window): Promise<MessagePort> =>
+      Promise.resolve(port);
 
   describe('create', () => {
     it('creates a new iframe', async () => {
@@ -56,12 +23,11 @@ describe('IframeManager', () => {
       vi.mocked(snapsUtils.createWindow).mockResolvedValueOnce(
         mockWindow as Window,
       );
-
-      const manager = IframeManager.getInstance();
+      const manager = new IframeManager();
       const sendMessageSpy = vi
         .spyOn(manager, 'sendMessage')
         .mockImplementation(vi.fn());
-      const [newWindow, id] = await manager.create();
+      const [newWindow, id] = await manager.create({ getPort: makeGetPort() });
 
       expect(newWindow).toBe(mockWindow);
       expect(id).toBeTypeOf('string');
@@ -78,12 +44,15 @@ describe('IframeManager', () => {
         mockWindow as Window,
       );
 
-      const manager = IframeManager.getInstance();
+      const manager = new IframeManager();
       const sendMessageSpy = vi
         .spyOn(manager, 'sendMessage')
         .mockImplementation(vi.fn());
       const id = 'foo';
-      const [newWindow, returnedId] = await manager.create(id);
+      const [newWindow, returnedId] = await manager.create({
+        id,
+        getPort: makeGetPort(),
+      });
 
       expect(newWindow).toBe(mockWindow);
       expect(returnedId).toBe(id);
@@ -93,6 +62,36 @@ describe('IframeManager', () => {
         data: null,
       });
     });
+
+    it('creates a new iframe with the default getPort function', async () => {
+      vi.resetModules();
+      vi.doMock('@ocap/streams', () => ({
+        initializeMessageChannel: vi.fn(),
+        makeMessagePortStreamPair: vi.fn(() => ({ reader: {}, writer: {} })),
+        MessagePortReader: class Mock1 {},
+        MessagePortWriter: class Mock2 {},
+      }));
+      const IframeManager2 = (await import('./iframe-manager.js'))
+        .IframeManager;
+
+      const mockWindow = {};
+      vi.mocked(snapsUtils.createWindow).mockResolvedValueOnce(
+        mockWindow as Window,
+      );
+      const manager = new IframeManager2();
+      const sendMessageSpy = vi
+        .spyOn(manager, 'sendMessage')
+        .mockImplementation(vi.fn());
+      const [newWindow, id] = await manager.create();
+
+      expect(newWindow).toBe(mockWindow);
+      expect(id).toBeTypeOf('string');
+      expect(sendMessageSpy).toHaveBeenCalledOnce();
+      expect(sendMessageSpy).toHaveBeenCalledWith(id, {
+        type: 'ping',
+        data: null,
+      });
+    });
   });
 
   describe('delete', () => {
@@ -107,22 +106,22 @@ describe('IframeManager', () => {
         return iframe.contentWindow as Window;
       });
 
-      const manager = IframeManager.getInstance();
+      const manager = new IframeManager();
       vi.spyOn(manager, 'sendMessage').mockImplementation(vi.fn());
 
-      await manager.create(id);
-      manager.delete(id);
+      await manager.create({ id, getPort: makeGetPort() });
+      await manager.delete(id);
 
       expect(removeSpy).toHaveBeenCalledOnce();
     });
 
     it('ignores attempt to delete unrecognized iframe', async () => {
       const id = 'foo';
-      const manager = IframeManager.getInstance();
+      const manager = new IframeManager();
       const iframe = document.createElement('iframe');
 
       const removeSpy = vi.spyOn(iframe, 'remove');
-      manager.delete(id);
+      await manager.delete(id);
 
       expect(removeSpy).not.toHaveBeenCalled();
     });
@@ -130,72 +129,107 @@ describe('IframeManager', () => {
 
   describe('sendMessage', () => {
     it('sends a message to an iframe', async () => {
-      const iframeWindow = { postMessage: vi.fn() };
-      vi.mocked(snapsUtils.createWindow).mockResolvedValueOnce(
-        iframeWindow as unknown as Window,
-      );
+      vi.mocked(snapsUtils.createWindow).mockResolvedValueOnce({} as Window);
 
-      const manager = IframeManager.getInstance();
+      const manager = new IframeManager();
       const sendMessageSpy = vi.spyOn(manager, 'sendMessage');
+      // Intercept the ping message in create()
       sendMessageSpy.mockImplementationOnce(async () => Promise.resolve());
 
+      const { port1, port2 } = new MessageChannel();
+      const portPostMessageSpy = vi.spyOn(port1, 'postMessage');
       const id = 'foo';
-      await manager.create(id);
+      await manager.create({ id, getPort: makeGetPort(port1) });
 
       const message = { type: Command.Evaluate, data: '2+2' };
 
       const messagePromise = manager.sendMessage(id, message);
       const messageId: string | undefined =
-        iframeWindow.postMessage.mock.lastCall?.[0]?.id;
+        portPostMessageSpy.mock.lastCall?.[0]?.value?.id;
       expect(messageId).toBeTypeOf('string');
 
-      window.dispatchEvent(
-        new MessageEvent('message', {
-          data: {
-            id: messageId,
-            message: {
-              type: Command.Evaluate,
-              data: '4',
-            },
+      port2.postMessage({
+        done: false,
+        value: {
+          id: messageId,
+          message: {
+            type: Command.Evaluate,
+            data: '4',
           },
-        }),
-      );
+        },
+      });
 
-      expect(iframeWindow.postMessage).toHaveBeenCalledOnce();
-      expect(iframeWindow.postMessage).toHaveBeenCalledWith(
-        { id: messageId, message },
-        '*',
-      );
+      expect(portPostMessageSpy).toHaveBeenCalledOnce();
+      expect(portPostMessageSpy).toHaveBeenCalledWith({
+        done: false,
+        value: {
+          id: messageId,
+          message,
+        },
+      });
       expect(await messagePromise).toBe('4');
     });
 
     it('throws if iframe not found', async () => {
-      const manager = IframeManager.getInstance();
+      const manager = new IframeManager();
       const id = 'foo';
       const message = { type: Command.Ping, data: null };
 
       await expect(manager.sendMessage(id, message)).rejects.toThrow(
-        `No iframe with id "${id}"`,
+        `No vat with id "${id}"`,
       );
     });
   });
 
-  describe('warnings', () => {
-    it('calls console.warn when receiving unexpected message', () => {
-      // Initialize manager
-      IframeManager.getInstance();
+  describe('miscellaneous', () => {
+    it('calls console.warn when receiving unexpected message', async () => {
+      vi.mocked(snapsUtils.createWindow).mockResolvedValueOnce({} as Window);
+
+      const manager = new IframeManager();
       const warnSpy = vi.spyOn(console, 'warn');
+      const sendMessageSpy = vi.spyOn(manager, 'sendMessage');
+      // Intercept the ping message in create()
+      sendMessageSpy.mockImplementationOnce(async () => Promise.resolve());
 
-      window.dispatchEvent(
-        new MessageEvent('message', {
-          data: 'foo',
-        }),
-      );
+      const { port1, port2 } = new MessageChannel();
+      await manager.create({ getPort: makeGetPort(port1) });
+
+      port2.postMessage({ done: false, value: 'foo' });
+      await delay(10);
 
       expect(warnSpy).toHaveBeenCalledWith(
         'Offscreen received message with unexpected format',
         'foo',
       );
     });
+
+    it('calls console.error when receiving message with unknown id', async () => {
+      vi.mocked(snapsUtils.createWindow).mockResolvedValueOnce({} as Window);
+
+      const manager = new IframeManager();
+      const errorSpy = vi.spyOn(console, 'error');
+      const sendMessageSpy = vi.spyOn(manager, 'sendMessage');
+      // Intercept the ping message in create()
+      sendMessageSpy.mockImplementationOnce(async () => Promise.resolve());
+
+      const { port1, port2 } = new MessageChannel();
+      await manager.create({ getPort: makeGetPort(port1) });
+
+      port2.postMessage({
+        done: false,
+        value: {
+          id: 'foo',
+          message: {
+            type: Command.Evaluate,
+            data: '"bar"',
+          },
+        },
+      });
+      await delay(10);
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        'No unresolved message with id "foo".',
+      );
+    });
   });
 });
diff --git a/packages/extension/src/iframe-manager.ts b/packages/extension/src/iframe-manager.ts
index 4ccfd0f80..5e5c1866d 100644
--- a/packages/extension/src/iframe-manager.ts
+++ b/packages/extension/src/iframe-manager.ts
@@ -1,99 +1,102 @@
 import type { PromiseKit } from '@endo/promise-kit';
 import { makePromiseKit } from '@endo/promise-kit';
 import { createWindow } from '@metamask/snaps-utils';
+import type { MessagePortReader, MessagePortStreamPair } from '@ocap/streams';
+import {
+  initializeMessageChannel,
+  makeMessagePortStreamPair,
+} from '@ocap/streams';
 
-import type { IframeMessage } from './shared.js';
+import type { IframeMessage, WrappedIframeMessage } from './shared.js';
 import { Command, isWrappedIframeMessage } from './shared.js';
 
 const IFRAME_URI = 'iframe.html';
 
-// The actual <iframe> id, for greater collision resistance.
+/**
+ * Get a DOM id for our iframes, for greater collision resistance.
+ *
+ * @param id - The id to base the DOM id on.
+ * @returns The DOM id.
+ */
 const getHtmlId = (id: string): string => `ocap-iframe-${id}`;
 
 type PromiseCallbacks = Omit<PromiseKit<unknown>, 'promise'>;
 
+type GetPort = (targetWindow: Window) => Promise<MessagePort>;
+
 /**
  * A singleton class to manage and message iframes.
  */
 export class IframeManager {
-  static #instance: IframeManager;
-
   #currentId: number;
 
   readonly #unresolvedMessages: Map<string, PromiseCallbacks>;
 
-  readonly #iframes: Map<string, Window>;
+  readonly #vats: Map<string, MessagePortStreamPair<WrappedIframeMessage>>;
 
   /**
    * Create a new IframeManager.
    */
-  // Our lint config wants #-private, but we can't do that to the constructor.
-  // eslint-disable-next-line no-restricted-syntax
-  private constructor() {
-    /* v8 ignore next 3: We're just not going to do this to ourselves. */
-    if (IframeManager.#instance !== undefined) {
-      throw new Error('IframeManager is a singleton');
-    }
-
+  constructor() {
     this.#currentId = 0;
-    this.#iframes = new Map();
+    this.#vats = new Map();
     this.#unresolvedMessages = new Map();
-
-    window.addEventListener('message', (event: MessageEvent) =>
-      this.#handleMessage(event),
-    );
-
-    IframeManager.#instance = this;
   }
 
   /**
-   * Get the singleton instance of IframeManager.
+   * Create a new vat, in the form of an iframe.
    *
-   * @returns The singleton instance of IframeManager.
+   * @param args - Options bag.
+   * @param args.id - The id of the vat to create.
+   * @param args.getPort - A function to get the message port for the iframe.
+   * @returns The iframe's content window, and its internal id.
    */
-  public static getInstance(): IframeManager {
-    if (!IframeManager.#instance) {
-      IframeManager.#instance = new IframeManager();
-    }
-    return IframeManager.#instance;
-  }
-
-  /**
-   * Create a new iframe.
-   *
-   * @param id - The id of the iframe to create.
-   * @returns The iframe's content window, and its id.
-   */
-  async create(id?: string): Promise<readonly [Window, string]> {
-    const actualId = id ?? this.#nextId();
-    const newWindow = await createWindow(IFRAME_URI, getHtmlId(actualId));
-    this.#iframes.set(actualId, newWindow);
-    await this.sendMessage(actualId, { type: Command.Ping, data: null });
-    console.debug(`Created iframe with id "${actualId}"`);
-    return [newWindow, actualId] as const;
+  async create(
+    args: { id?: string; getPort?: GetPort } = {},
+  ): Promise<readonly [Window, string]> {
+    const id = args.id ?? this.#nextId();
+    const getPort = args.getPort ?? initializeMessageChannel;
+
+    const newWindow = await createWindow(IFRAME_URI, getHtmlId(id));
+    const port = await getPort(newWindow);
+    const streams = makeMessagePortStreamPair<WrappedIframeMessage>(port);
+    this.#vats.set(id, streams);
+    /* v8 ignore next 4: Not known to be possible. */
+    this.#receiveMessages(streams.reader).catch((error) => {
+      console.error(`Unexpected read error from vat "${id}"`, error);
+      this.delete(id).catch(() => undefined);
+    });
+
+    await this.sendMessage(id, { type: Command.Ping, data: null });
+    console.debug(`Created vat with id "${id}"`);
+    return [newWindow, id] as const;
   }
 
   /**
    * Delete an iframe.
    *
    * @param id - The id of the iframe to delete.
+   * @returns A promise that resolves when the iframe is deleted.
    */
-  delete(id: string): void {
-    if (this.#iframes.has(id)) {
-      // TODO: Handle orphaned messages
-      this.#iframes.delete(id);
-
-      const iframe = document.getElementById(getHtmlId(id));
-      /* v8 ignore next 6: Currently impossible. */
-      if (iframe === null) {
-        console.error(
-          `Registered iframe with id "${id}" already removed from DOM`,
-        );
-        return;
-      }
+  async delete(id: string): Promise<void> {
+    const streams = this.#vats.get(id);
+    if (streams === undefined) {
+      return undefined;
+    }
+
+    const closeP = streams.return();
+    // TODO: Handle orphaned messages
+    this.#vats.delete(id);
 
-      iframe.remove();
+    const iframe = document.getElementById(getHtmlId(id));
+    /* v8 ignore next 6: Not known to be possible. */
+    if (iframe === null) {
+      console.error(`iframe of vat with id "${id}" already removed from DOM`);
+      return undefined;
     }
+    iframe.remove();
+
+    return closeP;
   }
 
   /**
@@ -107,37 +110,41 @@ export class IframeManager {
     id: string,
     message: IframeMessage<Command, string | null>,
   ): Promise<unknown> {
-    const iframeWindow = this.#get(id);
-    if (iframeWindow === undefined) {
-      throw new Error(`No iframe with id "${id}"`);
+    const streams = this.#vats.get(id);
+    if (streams === undefined) {
+      throw new Error(`No vat with id "${id}"`);
     }
 
     const { promise, reject, resolve } = makePromiseKit();
     const messageId = this.#nextId();
     this.#unresolvedMessages.set(messageId, { reject, resolve });
-    iframeWindow.postMessage({ id: messageId, message }, '*');
+    await streams.writer.next({ id: messageId, message });
     return promise;
   }
 
-  #handleMessage(event: MessageEvent): void {
-    console.debug('Offscreen received message', event);
+  async #receiveMessages(
+    reader: MessagePortReader<WrappedIframeMessage>,
+  ): Promise<void> {
+    for await (const rawMessage of reader) {
+      console.debug('Offscreen received message', rawMessage);
 
-    if (!isWrappedIframeMessage(event.data)) {
-      console.warn(
-        'Offscreen received message with unexpected format',
-        event.data,
-      );
-      return;
-    }
+      if (!isWrappedIframeMessage(rawMessage)) {
+        console.warn(
+          'Offscreen received message with unexpected format',
+          rawMessage,
+        );
+        return;
+      }
 
-    const { id, message } = event.data;
-    const promiseCallbacks = this.#unresolvedMessages.get(id);
-    if (promiseCallbacks === undefined) {
-      console.error(`No unresolved message with id "${id}".`);
-      return;
-    }
+      const { id, message } = rawMessage;
+      const promiseCallbacks = this.#unresolvedMessages.get(id);
+      if (promiseCallbacks === undefined) {
+        console.error(`No unresolved message with id "${id}".`);
+        continue;
+      }
 
-    promiseCallbacks.resolve(message.data);
+      promiseCallbacks.resolve(message.data);
+    }
   }
 
   #nextId(): string {
@@ -145,8 +152,4 @@ export class IframeManager {
     this.#currentId += 1;
     return String(id);
   }
-
-  #get(id: string): Window | undefined {
-    return this.#iframes.get(id);
-  }
 }
diff --git a/packages/extension/src/iframe.ts b/packages/extension/src/iframe.ts
index 59d68f19b..e5940f27c 100644
--- a/packages/extension/src/iframe.ts
+++ b/packages/extension/src/iframe.ts
@@ -1,94 +1,102 @@
+import { receiveMessagePort, makeMessagePortStreamPair } from '@ocap/streams';
+
+import type { WrappedIframeMessage } from './shared.js';
 import { Command, isWrappedIframeMessage } from './shared.js';
 
 const defaultCompartment = new Compartment({ URL });
 
-type MessageEventWithSource = Omit<MessageEvent, 'source'> & {
-  source: NonNullable<MessageEvent['source']>;
-};
+main().catch(console.error);
 
-const isEventWithSource = (
-  event: MessageEvent,
-): event is MessageEventWithSource => event.source !== null;
+/**
+ * The main function for the iframe.
+ */
+async function main(): Promise<void> {
+  const port = await receiveMessagePort();
+  const streams = makeMessagePortStreamPair<WrappedIframeMessage>(port);
 
-window.addEventListener('message', (event: MessageEvent) => {
-  console.debug('iframe received message', event);
+  for await (const wrappedMessage of streams.reader) {
+    console.debug('iframe received message', wrappedMessage);
 
-  if (!isEventWithSource(event)) {
-    console.warn('iframe received message with null source');
-    return;
-  }
-  if (!isWrappedIframeMessage(event.data)) {
-    console.warn('iframe received message with unexpected format', event.data);
-    return;
-  }
+    if (!isWrappedIframeMessage(wrappedMessage)) {
+      console.error(
+        'iframe received message with unexpected format',
+        wrappedMessage,
+      );
+      return;
+    }
 
-  const { id, message } = event.data;
+    const { id, message } = wrappedMessage;
 
-  switch (message.type) {
-    case Command.Evaluate: {
-      const result = safelyEvaluate(message.data);
-      reply(event, id, Command.Evaluate, stringifyResult(result));
-      break;
+    switch (message.type) {
+      case Command.Evaluate: {
+        if (typeof message.data !== 'string') {
+          console.error(
+            'iframe received message with unexpected data type',
+            message.data,
+          );
+          return;
+        }
+        const result = safelyEvaluate(message.data);
+        await reply(id, Command.Evaluate, stringifyResult(result));
+        break;
+      }
+      case Command.Ping:
+        await reply(id, Command.Ping, 'pong');
+        break;
+      default:
+        console.error(
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `iframe received unexpected message type: "${message.type}"`,
+        );
     }
-    case Command.Ping:
-      reply(event, id, Command.Ping, 'pong');
-      break;
-    default:
-      console.error(
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        `iframe received unexpected message type: "${message.type}"`,
-      );
   }
-});
 
-/**
- * Evaluate a string in the default compartment.
- *
- * @param source - The source string to evaluate.
- * @returns The result of the evaluation, or an error message.
- */
-function safelyEvaluate(source: string): string {
-  try {
-    return defaultCompartment.evaluate(source);
-  } catch (error) {
-    if (error instanceof Error) {
-      return `Error: ${error.message}`;
-    }
-    return `Error: Unknown error during evaluation.`;
+  await streams.return();
+  throw new Error('MessagePortReader ended unexpectedly.');
+
+  /**
+   * Reply to the parent window.
+   *
+   * @param id - The id of the message to reply to.
+   * @param messageType - The message type.
+   * @param data - The message data.
+   */
+  async function reply(
+    id: string,
+    messageType: Command,
+    data: string,
+  ): Promise<void> {
+    await streams.writer.next({ id, message: { type: messageType, data } });
   }
-}
 
-/**
- * Stringify an evaluation result.
- *
- * @param result - The result to stringify.
- * @returns The stringified result.
- */
-function stringifyResult(result: unknown): string {
-  try {
-    return JSON.stringify(result, null, 2);
-  } catch {
-    return String(result);
+  /**
+   * Evaluate a string in the default compartment.
+   *
+   * @param source - The source string to evaluate.
+   * @returns The result of the evaluation, or an error message.
+   */
+  function safelyEvaluate(source: string): string {
+    try {
+      return defaultCompartment.evaluate(source);
+    } catch (error) {
+      if (error instanceof Error) {
+        return `Error: ${error.message}`;
+      }
+      return `Error: Unknown error during evaluation.`;
+    }
   }
-}
 
-/**
- * Reply to the parent window.
- *
- * @param event - The message event to respond to.
- * @param id - The id of the message to reply to.
- * @param messageType - The message type.
- * @param data - The message data.
- */
-function reply(
-  event: MessageEventWithSource,
-  id: string,
-  messageType: Command,
-  data: string,
-): void {
-  event.source.postMessage(
-    { id, message: { type: messageType, data } },
-    // @ts-expect-error Incorrect DOM types
-    event.origin,
-  );
+  /**
+   * Stringify an evaluation result.
+   *
+   * @param result - The result to stringify.
+   * @returns The stringified result.
+   */
+  function stringifyResult(result: unknown): string {
+    try {
+      return JSON.stringify(result, null, 2);
+    } catch {
+      return String(result);
+    }
+  }
 }
diff --git a/packages/extension/src/offscreen.ts b/packages/extension/src/offscreen.ts
index a15ee4524..5c48b8d13 100644
--- a/packages/extension/src/offscreen.ts
+++ b/packages/extension/src/offscreen.ts
@@ -2,70 +2,77 @@ import { IframeManager } from './iframe-manager.js';
 import type { ExtensionMessage } from './shared.js';
 import { Command, makeHandledCallback } from './shared.js';
 
-// Handle messages from the background service worker
-chrome.runtime.onMessage.addListener(
-  makeHandledCallback(async (message: ExtensionMessage<Command, string>) => {
-    if (message.target !== 'offscreen') {
-      console.warn(
-        `Offscreen received message with unexpected target: "${message.target}"`,
-      );
-      return;
-    }
+main().catch(console.error);
+
+/**
+ * The main function for the offscreen script.
+ */
+async function main(): Promise<void> {
+  // Hard-code a single iframe for now.
+  const IFRAME_ID = 'default';
+  const iframeManager = new IframeManager();
+  const iframeReadyP = iframeManager.create({ id: IFRAME_ID });
 
-    switch (message.type) {
-      case Command.Evaluate:
-        await reply(Command.Evaluate, await evaluate(message.data));
-        break;
-      case Command.Ping:
-        await reply(Command.Ping, 'pong');
-        break;
-      default:
-        console.error(
-          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-          `Offscreen received unexpected message type: "${message.type}"`,
+  // Handle messages from the background service worker
+  chrome.runtime.onMessage.addListener(
+    makeHandledCallback(async (message: ExtensionMessage<Command, string>) => {
+      if (message.target !== 'offscreen') {
+        console.warn(
+          `Offscreen received message with unexpected target: "${message.target}"`,
         );
-    }
-  }),
-);
+        return;
+      }
 
-// Hard-code a single iframe for now.
-const IFRAME_ID = 'default';
-const iframeManager = IframeManager.getInstance();
-iframeManager.create(IFRAME_ID).catch((error) => {
-  throw error;
-});
+      await iframeReadyP;
 
-/**
- * Reply to the background script.
- *
- * @param type - The message type.
- * @param data - The message data.
- */
-async function reply(type: Command, data?: string): Promise<void> {
-  await chrome.runtime.sendMessage({
-    data: data ?? null,
-    target: 'background',
-    type,
-  });
-}
+      switch (message.type) {
+        case Command.Evaluate:
+          await reply(Command.Evaluate, await evaluate(message.data));
+          break;
+        case Command.Ping:
+          await reply(Command.Ping, 'pong');
+          break;
+        default:
+          console.error(
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `Offscreen received unexpected message type: "${message.type}"`,
+          );
+      }
+    }),
+  );
 
-/**
- * Evaluate a string in the default iframe.
- *
- * @param source - The source string to evaluate.
- * @returns The result of the evaluation, or an error message.
- */
-async function evaluate(source: string): Promise<string> {
-  try {
-    const result = await iframeManager.sendMessage(IFRAME_ID, {
-      type: Command.Evaluate,
-      data: source,
+  /**
+   * Reply to the background script.
+   *
+   * @param type - The message type.
+   * @param data - The message data.
+   */
+  async function reply(type: Command, data?: string): Promise<void> {
+    await chrome.runtime.sendMessage({
+      data: data ?? null,
+      target: 'background',
+      type,
     });
-    return String(result);
-  } catch (error) {
-    if (error instanceof Error) {
-      return `Error: ${error.message}`;
+  }
+
+  /**
+   * Evaluate a string in the default iframe.
+   *
+   * @param source - The source string to evaluate.
+   * @returns The result of the evaluation, or an error message.
+   */
+  async function evaluate(source: string): Promise<string> {
+    try {
+      const result = await iframeManager.sendMessage(IFRAME_ID, {
+        type: Command.Evaluate,
+        data: source,
+      });
+      return String(result);
+    } catch (error) {
+      if (error instanceof Error) {
+        return `Error: ${error.message}`;
+      }
+      return `Error: Unknown error during evaluation.`;
     }
-    return `Error: Unknown error during evaluation.`;
   }
 }
diff --git a/packages/extension/src/shared.test.ts b/packages/extension/src/shared.test.ts
index fb96f0987..2412a8716 100644
--- a/packages/extension/src/shared.test.ts
+++ b/packages/extension/src/shared.test.ts
@@ -1,3 +1,4 @@
+import { delay } from '@ocap/test-utils';
 import { vi, describe, it, expect } from 'vitest';
 
 import { isWrappedIframeMessage, makeHandledCallback } from './shared.js';
@@ -52,8 +53,7 @@ describe('shared', () => {
 
       // eslint-disable-next-line n/callback-return
       callback();
-      // eslint-disable-next-line @typescript-eslint/await-thenable
-      await null;
+      await delay();
 
       expect(consoleErrorSpy).toHaveBeenCalledOnce();
       expect(consoleErrorSpy).toHaveBeenCalledWith(
diff --git a/packages/extension/src/shared.ts b/packages/extension/src/shared.ts
index bec740312..99c82f6b9 100644
--- a/packages/extension/src/shared.ts
+++ b/packages/extension/src/shared.ts
@@ -24,7 +24,7 @@ export type IframeMessage<
 
 export type WrappedIframeMessage = {
   id: string;
-  message: IframeMessage<Command, string>;
+  message: IframeMessage<Command, string | null>;
 };
 
 export const isWrappedIframeMessage = (
diff --git a/packages/extension/tsconfig.build.json b/packages/extension/tsconfig.build.json
index eccdcd4a5..ab2ce37fb 100644
--- a/packages/extension/tsconfig.build.json
+++ b/packages/extension/tsconfig.build.json
@@ -4,11 +4,14 @@
     "allowJs": true,
     "baseUrl": "./",
     "emitDeclarationOnly": false,
-    "lib": ["DOM", "ES2020"],
+    "lib": ["DOM", "ES2022"],
     "noEmit": true,
     "rootDir": "./src",
     "types": ["chrome", "ses"]
   },
-  "references": [{ "path": "../shims/tsconfig.build.json" }],
+  "references": [
+    { "path": "../shims/tsconfig.build.json" },
+    { "path": "../streams/tsconfig.build.json" }
+  ],
   "include": ["./src/**/*.ts", "./src/dev-console.js"]
 }
diff --git a/packages/extension/tsconfig.json b/packages/extension/tsconfig.json
index 026e18577..060acd4ab 100644
--- a/packages/extension/tsconfig.json
+++ b/packages/extension/tsconfig.json
@@ -4,11 +4,11 @@
     "allowJs": true,
     "baseUrl": "./",
     "isolatedModules": true,
-    "lib": ["DOM", "ES2020"],
+    "lib": ["DOM", "ES2022"],
     "noEmit": true,
     "skipLibCheck": true,
     "types": ["chrome", "ses", "vitest", "vitest/jsdom"]
   },
-  "references": [{ "path": "../test-utils" }],
-  "include": ["./src/**/*.ts", "src/dev-console.js"]
+  "references": [{ "path": "../streams" }, { "path": "../test-utils" }],
+  "include": ["./src/**/*.ts", "./src/dev-console.js"]
 }
diff --git a/packages/streams/CHANGELOG.md b/packages/streams/CHANGELOG.md
new file mode 100644
index 000000000..0c82cb1ed
--- /dev/null
+++ b/packages/streams/CHANGELOG.md
@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+[Unreleased]: https://github.com/MetaMask/ocap-kernel/
diff --git a/packages/streams/README.md b/packages/streams/README.md
new file mode 100644
index 000000000..c0aa9d831
--- /dev/null
+++ b/packages/streams/README.md
@@ -0,0 +1,7 @@
+# `streams`
+
+Ocap Kernel streams, compatible with `@endo/stream`, and therefore assumed to run under SES.
+
+## Contributing
+
+This package is part of a monorepo. Instructions for contributing can be found in the [monorepo README](https://github.com/MetaMask/ocap-kernel#readme).
diff --git a/packages/streams/package.json b/packages/streams/package.json
new file mode 100644
index 000000000..8fb920b07
--- /dev/null
+++ b/packages/streams/package.json
@@ -0,0 +1,68 @@
+{
+  "name": "@ocap/streams",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Ocap Kernel streams",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MetaMask/ocap-kernel.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "ts-bridge --project tsconfig.build.json --clean",
+    "build:docs": "typedoc",
+    "changelog:validate": "../../scripts/validate-changelog.sh streams",
+    "clean": "rimraf --glob ./dist './*.tsbuildinfo'",
+    "publish:preview": "yarn npm publish --tag preview",
+    "test": "vitest run --config vitest.config.ts",
+    "test:clean": "yarn test --no-cache --coverage.clean",
+    "test:dev": "yarn test --coverage false",
+    "test:verbose": "yarn test --reporter verbose",
+    "test:watch": "vitest --config vitest.config.ts"
+  },
+  "dependencies": {
+    "@endo/promise-kit": "^1.1.4",
+    "@endo/stream": "^1.2.2",
+    "@metamask/utils": "^9.1.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.15.3",
+    "@metamask/auto-changelog": "^3.4.4",
+    "@ocap/test-utils": "workspace:^",
+    "@ts-bridge/cli": "^0.3.0",
+    "@ts-bridge/shims": "^0.1.1",
+    "@types/jsdom": "^21.1.7",
+    "@vitest/coverage-v8": "^2.0.5",
+    "deepmerge": "^4.3.1",
+    "jsdom": "^24.1.1",
+    "rimraf": "^6.0.1",
+    "typedoc": "^0.24.8",
+    "typedoc-plugin-missing-exports": "^2.0.0",
+    "typescript": "~4.9.5",
+    "vite": "^5.3.5",
+    "vitest": "^2.0.5"
+  },
+  "engines": {
+    "node": "^18.18 || >=20"
+  }
+}
diff --git a/packages/streams/src/index.test.ts b/packages/streams/src/index.test.ts
new file mode 100644
index 000000000..3ddc0dee0
--- /dev/null
+++ b/packages/streams/src/index.test.ts
@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+
+import * as indexModule from './index.js';
+
+describe('index', () => {
+  it('has the expected exports', () => {
+    expect(Object.keys(indexModule)).toStrictEqual(
+      expect.arrayContaining([
+        'makeMessagePortStreamPair',
+        'MessagePortReader',
+        'MessagePortWriter',
+        'initializeMessageChannel',
+        'receiveMessagePort',
+      ]),
+    );
+  });
+});
diff --git a/packages/streams/src/index.ts b/packages/streams/src/index.ts
new file mode 100644
index 000000000..7fbe64309
--- /dev/null
+++ b/packages/streams/src/index.ts
@@ -0,0 +1,10 @@
+export {
+  initializeMessageChannel,
+  receiveMessagePort,
+} from './message-channel.js';
+export type { MessagePortStreamPair } from './streams.js';
+export {
+  makeMessagePortStreamPair,
+  MessagePortReader,
+  MessagePortWriter,
+} from './streams.js';
diff --git a/packages/streams/src/message-channel.test.ts b/packages/streams/src/message-channel.test.ts
new file mode 100644
index 000000000..d05d2ab6b
--- /dev/null
+++ b/packages/streams/src/message-channel.test.ts
@@ -0,0 +1,216 @@
+import { delay, makePromiseKitMock } from '@ocap/test-utils';
+import { JSDOM } from 'jsdom';
+import { vi, describe, it, beforeEach, afterEach, beforeAll } from 'vitest';
+
+import {
+  initializeMessageChannel,
+  MessageType,
+  receiveMessagePort,
+} from './message-channel.js';
+
+vi.mock('@endo/promise-kit', () => makePromiseKitMock());
+
+describe.concurrent('initializeMessageChannel', () => {
+  it('calls targetWindow.postMessage', async ({ expect }) => {
+    const targetWindow = new JSDOM().window;
+    const postMessageSpy = vi.spyOn(targetWindow, 'postMessage');
+    // We intentionally let this one go. It will never settle.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    initializeMessageChannel(targetWindow as unknown as Window);
+
+    expect(postMessageSpy).toHaveBeenCalledOnce();
+    expect(postMessageSpy).toHaveBeenCalledWith(
+      {
+        type: MessageType.Initialize,
+      },
+      '*',
+      [expect.any(MessagePort)],
+    );
+  });
+
+  it('resolves a port with no message handler once sent acknowledgment via message channel', async ({
+    expect,
+  }) => {
+    const targetWindow = new JSDOM().window;
+    const postMessageSpy = vi.spyOn(targetWindow, 'postMessage');
+    const messageChannelP = initializeMessageChannel(
+      targetWindow as unknown as Window,
+    );
+
+    // @ts-expect-error Wrong types for window.postMessage()
+    const remotePort: MessagePort = postMessageSpy.mock.lastCall[2][0];
+    remotePort.postMessage({ type: MessageType.Acknowledge });
+
+    const resolvedValue = await messageChannelP;
+    expect(resolvedValue).toBeInstanceOf(MessagePort);
+    expect(resolvedValue.onmessage).toBe(null);
+  });
+
+  it.for([
+    { type: MessageType.Initialize },
+    { type: 'foo' },
+    { foo: 'bar' },
+    {},
+    [],
+    'foo',
+    400,
+    null,
+    undefined,
+  ])(
+    'rejects if sent unexpected message via message channel: %#',
+    async (unexpectedMessage, { expect }) => {
+      const targetWindow = new JSDOM().window;
+      const postMessageSpy = vi.spyOn(targetWindow, 'postMessage');
+      const messageChannelP = initializeMessageChannel(
+        targetWindow as unknown as Window,
+      );
+
+      // @ts-expect-error Wrong types for window.postMessage()
+      const remotePort: MessagePort = postMessageSpy.mock.lastCall[2][0];
+      remotePort.postMessage(unexpectedMessage);
+
+      await expect(messageChannelP).rejects.toThrow(
+        /^Received unexpected message via message port/u,
+      );
+    },
+  );
+});
+
+describe('receiveMessagePort', () => {
+  let messageEventListeners: [string, EventListenerOrEventListenerObject][] =
+    [];
+  let originalAddEventListener: typeof window.addEventListener;
+
+  beforeAll(() => {
+    originalAddEventListener = window.addEventListener;
+  });
+
+  beforeEach(() => {
+    // JSDOM apparently affords no way to clear all event listeners between test runs,
+    // so we have to do it manually.
+    window.addEventListener = (
+      ...args: Parameters<typeof window.addEventListener>
+    ): void => {
+      messageEventListeners.push([args[0], args[1]]);
+      originalAddEventListener.call(window, ...args);
+    };
+  });
+
+  afterEach(() => {
+    messageEventListeners.forEach(([messageType, listener]) => {
+      window.removeEventListener(messageType, listener);
+    });
+    messageEventListeners = [];
+    window.addEventListener = originalAddEventListener;
+  });
+
+  it('receives and acknowledges a message port', async ({ expect }) => {
+    const messagePortP = receiveMessagePort();
+
+    const { port2 } = new MessageChannel();
+    const portPostMessageSpy = vi.spyOn(port2, 'postMessage');
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: { type: MessageType.Initialize },
+        ports: [port2],
+      }),
+    );
+
+    const resolvedValue = await messagePortP;
+
+    expect(resolvedValue).toBe(port2);
+    expect(portPostMessageSpy).toHaveBeenCalledOnce();
+    expect(portPostMessageSpy).toHaveBeenCalledWith({
+      type: MessageType.Acknowledge,
+    });
+  });
+
+  it('cleans up event listeners', async ({ expect }) => {
+    const addEventListenerSpy = vi.spyOn(window, 'addEventListener');
+    const removeEventListenerSpy = vi.spyOn(window, 'removeEventListener');
+
+    const messagePortP = receiveMessagePort();
+
+    const { port2 } = new MessageChannel();
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: { type: MessageType.Initialize },
+        ports: [port2],
+      }),
+    );
+
+    await messagePortP;
+
+    expect(addEventListenerSpy).toHaveBeenCalledOnce();
+    expect(addEventListenerSpy).toHaveBeenCalledWith(
+      'message',
+      expect.any(Function),
+    );
+    expect(removeEventListenerSpy).toHaveBeenCalledOnce();
+    expect(removeEventListenerSpy).toHaveBeenCalledWith(
+      'message',
+      expect.any(Function),
+    );
+  });
+
+  it.for([
+    { type: MessageType.Acknowledge },
+    { type: 'foo' },
+    { foo: 'bar' },
+    {},
+    [],
+    'foo',
+    400,
+    null,
+    undefined,
+  ])(
+    'ignores message events with unexpected data dispatched on window: %#',
+    async (unexpectedMessage, { expect }) => {
+      const messagePortP = receiveMessagePort();
+
+      const { port2 } = new MessageChannel();
+      const portPostMessageSpy = vi.spyOn(port2, 'postMessage');
+
+      const fulfillmentDetector = vi.fn();
+      messagePortP.then(fulfillmentDetector, fulfillmentDetector);
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: unexpectedMessage,
+        }),
+      );
+
+      await delay();
+
+      expect(fulfillmentDetector).not.toHaveBeenCalled();
+      expect(portPostMessageSpy).not.toHaveBeenCalled();
+    },
+  );
+
+  it.for([{}, { ports: [] }, { ports: [{}, {}] }])(
+    'ignores message events with unexpected ports dispatched on window: %#',
+    async (unexpectedPorts, { expect }) => {
+      const messagePortP = receiveMessagePort();
+
+      const { port2 } = new MessageChannel();
+      const portPostMessageSpy = vi.spyOn(port2, 'postMessage');
+
+      const fulfillmentDetector = vi.fn();
+      messagePortP.then(fulfillmentDetector, fulfillmentDetector);
+
+      window.dispatchEvent(
+        // @ts-expect-error Intentionally destructive testing.
+        new MessageEvent('message', {
+          data: { type: MessageType.Initialize },
+          ...unexpectedPorts,
+        }),
+      );
+
+      await delay();
+
+      expect(fulfillmentDetector).not.toHaveBeenCalled();
+      expect(portPostMessageSpy).not.toHaveBeenCalled();
+    },
+  );
+});
diff --git a/packages/streams/src/message-channel.ts b/packages/streams/src/message-channel.ts
new file mode 100644
index 000000000..42ce3f1cd
--- /dev/null
+++ b/packages/streams/src/message-channel.ts
@@ -0,0 +1,112 @@
+/**
+ * This module establishes a simple protocol for creating a MessageChannel between a
+ * window and one of its iframes, as follows:
+ * 1. The parent window creates an iframe and appends it to the DOM. The iframe must be
+ * loaded and the `contentWindow` property must be accessible.
+ * 2. The iframe calls `receiveMessagePort()` on startup in one of its scripts. The script
+ * element in question should not have the `async` attribute.
+ * 3. The parent window calls `initializeMessageChannel()` which sends a message port to
+ * the iframe. When the returned promise resolves, the parent window and the iframe have
+ * established a message channel.
+ *
+ * @module MessageChannel utilities
+ */
+
+import { makePromiseKit } from '@endo/promise-kit';
+import { isObject } from '@metamask/utils';
+
+export enum MessageType {
+  Initialize = 'INIT_MESSAGE_CHANNEL',
+  Acknowledge = 'ACK_MESSAGE_CHANNEL',
+}
+
+type InitializeMessage = { type: MessageType.Initialize };
+type AcknowledgeMessage = { type: MessageType.Acknowledge };
+
+const isInitMessage = (
+  event: MessageEvent,
+): event is MessageEvent<InitializeMessage> =>
+  isObject(event.data) &&
+  event.data.type === MessageType.Initialize &&
+  Array.isArray(event.ports) &&
+  event.ports.length === 1 &&
+  event.ports[0] instanceof MessagePort;
+
+const isAckMessage = (value: unknown): value is AcknowledgeMessage =>
+  isObject(value) && value.type === MessageType.Acknowledge;
+
+const stringify = (value: unknown): string => JSON.stringify(value, null, 2);
+
+/**
+ * Creates a message channel and sends one of the ports to the target window. The iframe
+ * associated with the target window must be loaded, and it must have called
+ * {@link receiveMessagePort} to receive the remote message port. Rejects if the first
+ * message received over the channel is not an {@link AcknowledgeMessage}.
+ *
+ * @param targetWindow - The iframe window to send the message port to.
+ * @returns A promise that resolves with the local message port, once the target window
+ * has acknowledged its receipt of the remote port.
+ */
+export async function initializeMessageChannel(
+  targetWindow: Window,
+): Promise<MessagePort> {
+  const { port1, port2 } = new MessageChannel();
+
+  const { promise, resolve, reject } = makePromiseKit<MessagePort>();
+  // Assigning to the `onmessage` property initializes the port's message queue.
+  port1.onmessage = (message: MessageEvent): void => {
+    if (!isAckMessage(message.data)) {
+      reject(
+        new Error(
+          `Received unexpected message via message port:\n${stringify(
+            message.data,
+          )}`,
+        ),
+      );
+      return;
+    }
+
+    resolve(port1);
+  };
+
+  const initMessage: InitializeMessage = {
+    type: MessageType.Initialize,
+  };
+  targetWindow.postMessage(initMessage, '*', [port2]);
+
+  return promise
+    .catch((error) => {
+      port1.close();
+      throw error;
+    })
+    .finally(() => (port1.onmessage = null));
+}
+
+/**
+ * Receives a message port from the parent window, and sends an {@link AcknowledgeMessage}
+ * over the port. Should be called in a script _without_ the `async` attribute on startup.
+ * The parent window must call {@link initializeMessageChannel} to send the message port
+ * after this iframe has loaded. Ignores any message events dispatched on the local
+ * `window` that are not an {@link InitializeMessage}.
+ *
+ * @returns A promise that resolves with a message port that can be used to communicate
+ * with the parent window.
+ */
+export async function receiveMessagePort(): Promise<MessagePort> {
+  const { promise, resolve } = makePromiseKit<MessagePort>();
+
+  const listener = (message: MessageEvent): void => {
+    if (!isInitMessage(message)) {
+      return;
+    }
+    window.removeEventListener('message', listener);
+
+    const port = message.ports[0] as MessagePort;
+    const ackMessage: AcknowledgeMessage = { type: MessageType.Acknowledge };
+    port.postMessage(ackMessage);
+    resolve(port);
+  };
+
+  window.addEventListener('message', listener);
+  return promise;
+}
diff --git a/packages/streams/src/streams.test.ts b/packages/streams/src/streams.test.ts
new file mode 100644
index 000000000..f2375fe25
--- /dev/null
+++ b/packages/streams/src/streams.test.ts
@@ -0,0 +1,330 @@
+import { delay, makePromiseKitMock } from '@ocap/test-utils';
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  makeDoneResult,
+  makeMessagePortStreamPair,
+  MessagePortReader,
+  MessagePortWriter,
+} from './streams.js';
+
+vi.mock('@endo/promise-kit', () => makePromiseKitMock());
+
+describe.concurrent('MessagePortReader', () => {
+  it('constructs a MessagePortReader', () => {
+    const { port1 } = new MessageChannel();
+    const reader = new MessagePortReader(port1);
+
+    expect(reader).toBeInstanceOf(MessagePortReader);
+    expect(reader[Symbol.asyncIterator]()).toBe(reader);
+    expect(port1.onmessage).toBeInstanceOf(Function);
+  });
+
+  describe('next and iteration', () => {
+    it('emits message port message received before next()', async () => {
+      const { port1, port2 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      const message = { foo: 'bar' };
+      port2.postMessage({ done: false, value: message });
+      await delay(100);
+
+      expect(await reader.next()).toStrictEqual({
+        done: false,
+        value: message,
+      });
+    });
+
+    it('emits message port message received after next()', async () => {
+      const { port1, port2 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      const nextP = reader.next();
+      const message = { foo: 'bar' };
+      port2.postMessage({ done: false, value: message });
+
+      expect(await nextP).toStrictEqual({ done: false, value: message });
+    });
+
+    it('iterates over multiple port messages', async () => {
+      const { port1, port2 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      const messages = [{ foo: 'bar' }, { bar: 'baz' }, { baz: 'qux' }];
+      messages.forEach((message) =>
+        port2.postMessage({ done: false, value: message }),
+      );
+
+      let index = 0;
+      for await (const message of reader) {
+        expect(message).toStrictEqual(messages[index]);
+
+        index += 1;
+        if (index >= messages.length) {
+          break;
+        }
+      }
+    });
+
+    it('throws when receiving unexpected message from port', async () => {
+      const { port1, port2 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      const nextP = reader.next();
+      const unexpectedMessage = { foo: 'bar' };
+      port2.postMessage(unexpectedMessage);
+
+      await expect(nextP).rejects.toThrow(
+        'Received unexpected message via message port',
+      );
+    });
+
+    it('ends if receiving final iterator result from port', async () => {
+      const { port1, port2 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      const nextP = reader.next();
+      port2.postMessage(makeDoneResult());
+
+      expect(await nextP).toStrictEqual(makeDoneResult());
+      expect(port1.onmessage).toBeNull();
+      expect(await reader.next()).toStrictEqual(makeDoneResult());
+    });
+  });
+
+  describe('return', () => {
+    it('ends the stream', async () => {
+      const { port1 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      expect(await reader.return()).toStrictEqual(makeDoneResult());
+      expect(port1.onmessage).toBeNull();
+      expect(await reader.next()).toStrictEqual(makeDoneResult());
+    });
+
+    it('is idempotent', async () => {
+      const { port1 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      expect(await reader.return()).toStrictEqual(makeDoneResult());
+      expect(await reader.return()).toStrictEqual(makeDoneResult());
+    });
+
+    it('resolves pending read promises', async () => {
+      const { port1 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      const nextP1 = reader.next();
+      const nextP2 = reader.next();
+      const returnP = reader.return();
+
+      expect(await nextP1).toStrictEqual(makeDoneResult());
+      expect(await nextP2).toStrictEqual(makeDoneResult());
+      expect(await returnP).toStrictEqual(makeDoneResult());
+    });
+  });
+
+  describe('throw', () => {
+    it('ends the stream', async () => {
+      const { port1 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      expect(await reader.throw(new Error())).toStrictEqual(makeDoneResult());
+      expect(port1.onmessage).toBeNull();
+      expect(await reader.next()).toStrictEqual(makeDoneResult());
+    });
+
+    it('is idempotent', async () => {
+      const { port1 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      expect(await reader.throw(new Error())).toStrictEqual(makeDoneResult());
+      expect(await reader.throw(new Error())).toStrictEqual(makeDoneResult());
+    });
+
+    it('rejects pending read promises', async () => {
+      const { port1 } = new MessageChannel();
+      const reader = new MessagePortReader(port1);
+
+      const nextP1 = reader.next();
+      const nextP2 = reader.next();
+      const throwP = reader.throw(new Error('foo'));
+
+      await expect(nextP1).rejects.toThrow(new Error('foo'));
+      await expect(nextP2).rejects.toThrow(new Error('foo'));
+      expect(await throwP).toStrictEqual(makeDoneResult());
+    });
+  });
+});
+
+describe.concurrent('MessagePortWriter', () => {
+  it('constructs a MessagePortWriter', () => {
+    const { port1 } = new MessageChannel();
+    const writer = new MessagePortWriter(port1);
+
+    expect(writer).toBeInstanceOf(MessagePortWriter);
+    expect(writer[Symbol.asyncIterator]()).toBe(writer);
+  });
+
+  describe('next and sending messages', () => {
+    it('posts messages to the port', async () => {
+      const { port1, port2 } = new MessageChannel();
+      const writer = new MessagePortWriter(port1);
+
+      const message = { foo: 'bar' };
+      const messageP = new Promise((resolve) => {
+        port2.onmessage = (messageEvent): void => resolve(messageEvent.data);
+      });
+      const nextP = writer.next(message);
+
+      expect(await nextP).toStrictEqual({
+        done: false,
+        value: undefined,
+      });
+      expect(await messageP).toStrictEqual({ done: false, value: message });
+    });
+
+    it('throws if failing to send a message', async () => {
+      const { port1 } = new MessageChannel();
+      const postMessageSpy = vi
+        .spyOn(port1, 'postMessage')
+        .mockImplementationOnce(() => {
+          throw new Error('foo');
+        });
+      const writer = new MessagePortWriter(port1);
+
+      expect(await writer.next(null)).toStrictEqual(makeDoneResult());
+      expect(postMessageSpy).toHaveBeenCalledTimes(2);
+      expect(postMessageSpy).toHaveBeenNthCalledWith(1, {
+        done: false,
+        value: null,
+      });
+      expect(postMessageSpy).toHaveBeenNthCalledWith(2, new Error('foo'));
+    });
+
+    it('failing to send a message logs the error', async () => {
+      const { port1 } = new MessageChannel();
+      vi.spyOn(port1, 'postMessage').mockImplementationOnce(() => {
+        throw new Error('foo');
+      });
+      const consoleErrorSpy = vi.spyOn(console, 'error');
+      const writer = new MessagePortWriter(port1);
+
+      expect(await writer.next(null)).toStrictEqual(makeDoneResult());
+      expect(consoleErrorSpy).toHaveBeenCalledOnce();
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'MessagePortWriter experienced a send failure:',
+        new Error('foo'),
+      );
+    });
+
+    it('handles repeated failures to send messages', async () => {
+      const { port1 } = new MessageChannel();
+      const postMessageSpy = vi
+        .spyOn(port1, 'postMessage')
+        .mockImplementationOnce(() => {
+          throw new Error('foo');
+        })
+        .mockImplementationOnce(() => {
+          throw new Error('foo');
+        });
+      const writer = new MessagePortWriter(port1);
+
+      await expect(writer.next(null)).rejects.toThrow(
+        'MessagePortWriter experienced repeated send failures.',
+      );
+      expect(postMessageSpy).toHaveBeenCalledTimes(3);
+      expect(postMessageSpy).toHaveBeenNthCalledWith(1, {
+        done: false,
+        value: null,
+      });
+      expect(postMessageSpy).toHaveBeenNthCalledWith(2, new Error('foo'));
+      expect(postMessageSpy).toHaveBeenNthCalledWith(
+        3,
+        new Error('MessagePortWriter experienced repeated send failures.'),
+      );
+    });
+  });
+
+  describe('return', () => {
+    it('ends the stream', async () => {
+      const { port1 } = new MessageChannel();
+      const writer = new MessagePortWriter(port1);
+
+      expect(await writer.return()).toStrictEqual(makeDoneResult());
+      expect(await writer.next(null)).toStrictEqual(makeDoneResult());
+    });
+
+    it('is idempotent', async () => {
+      const { port1 } = new MessageChannel();
+      const writer = new MessagePortWriter(port1);
+
+      expect(await writer.return()).toStrictEqual(makeDoneResult());
+      expect(await writer.return()).toStrictEqual(makeDoneResult());
+    });
+  });
+
+  describe('throw', () => {
+    it('ends the stream', async () => {
+      const { port1 } = new MessageChannel();
+      const writer = new MessagePortWriter(port1);
+
+      expect(await writer.throw(new Error())).toStrictEqual(makeDoneResult());
+      expect(await writer.next(null)).toStrictEqual(makeDoneResult());
+    });
+
+    it('is idempotent', async () => {
+      const { port1 } = new MessageChannel();
+      const writer = new MessagePortWriter(port1);
+
+      expect(await writer.throw(new Error())).toStrictEqual(makeDoneResult());
+      expect(await writer.throw(new Error())).toStrictEqual(makeDoneResult());
+    });
+  });
+});
+
+describe('makeMessagePortStreamPair', () => {
+  it('returns a pair of message ports', () => {
+    const { port1 } = new MessageChannel();
+    const { reader, writer } = makeMessagePortStreamPair(port1);
+
+    expect(reader).toBeInstanceOf(MessagePortReader);
+    expect(writer).toBeInstanceOf(MessagePortWriter);
+  });
+
+  it('return() calls return() on both streams', async () => {
+    const { port1, port2 } = new MessageChannel();
+    const streamPair = makeMessagePortStreamPair(port1);
+    const remoteReader = new MessagePortReader(port2);
+    const remoteReadP = remoteReader.next();
+
+    expect(port1.onmessage).toBeDefined();
+    expect(port2.onmessage).toBeDefined();
+
+    await streamPair.return();
+
+    expect(port1.onmessage).toBeNull();
+
+    expect(await remoteReadP).toStrictEqual(makeDoneResult());
+    expect(port2.onmessage).toBeNull();
+  });
+
+  it('throw() calls throw() on the writer but return on the reader', async () => {
+    const { port1, port2 } = new MessageChannel();
+    const streamPair = makeMessagePortStreamPair(port1);
+    const remoteReader = new MessagePortReader(port2);
+    const localReadP = streamPair.reader.next();
+    const remoteReadP = remoteReader.next();
+
+    expect(port1.onmessage).toBeDefined();
+    expect(port2.onmessage).toBeDefined();
+
+    await streamPair.throw(new Error('foo'));
+
+    expect(await localReadP).toStrictEqual(makeDoneResult());
+    expect(port1.onmessage).toBeNull();
+
+    await expect(remoteReadP).rejects.toThrow(new Error('foo'));
+    expect(port2.onmessage).toBeNull();
+  });
+});
diff --git a/packages/streams/src/streams.ts b/packages/streams/src/streams.ts
new file mode 100644
index 000000000..f7a13109a
--- /dev/null
+++ b/packages/streams/src/streams.ts
@@ -0,0 +1,358 @@
+/**
+ * This module provides a pair of classes for creating readable and writable streams
+ * over a [MessagePort](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort).
+ * The classes are naive passthrough mechanisms for data that assume exclusive access
+ * to their ports. The lifetime of the underlying message port is expected to be
+ * coextensive with "the other side".
+ *
+ * At the time of writing, there is no ergonomic way to detect the closure of a port. For
+ * this reason, ports have to be ended manually via `.return()` or `.throw()`. Ending a
+ * {@link MessagePortWriter} will end any {@link MessagePortReader} reading from the
+ * remote port and close the entangled ports, but it will not affect any other streams
+ * connected to the remote or local port, which must also be ended manually.
+ *
+ * Regarding limitations around detecting `MessagePort` closure, see:
+ * - https://github.com/fergald/explainer-messageport-close
+ * - https://github.com/whatwg/html/issues/10201
+ *
+ * @module MessagePort streams
+ */
+
+import { makePromiseKit } from '@endo/promise-kit';
+import type { Reader, Writer } from '@endo/stream';
+import { hasProperty, isObject } from '@metamask/utils';
+
+type PromiseCallbacks = {
+  resolve: (value: unknown) => void;
+  reject: (reason: unknown) => void;
+};
+
+const isIteratorResult = (
+  value: unknown,
+): value is IteratorResult<unknown, unknown> =>
+  isObject(value) &&
+  (!hasProperty(value, 'done') || typeof value.done === 'boolean') &&
+  hasProperty(value, 'value');
+
+export const makeDoneResult = (): { done: true; value: undefined } => ({
+  done: true,
+  value: undefined,
+});
+
+/**
+ * A readable stream over a {@link MessagePort}.
+ *
+ * This class is a naive passthrough mechanism for data over a pair of linked message
+ * ports. Expects exclusive access to its port.
+ *
+ * @see
+ * - {@link MessagePortWriter} for the corresponding writable stream.
+ * - The module-level documentation for more details.
+ */
+export class MessagePortReader<Yield> implements Reader<Yield> {
+  #isDone: boolean;
+
+  readonly #port: MessagePort;
+
+  /**
+   * For buffering messages to manage backpressure, i.e. the input rate exceeding the
+   * read rate.
+   */
+  #messageQueue: MessageEvent<IteratorResult<unknown, unknown>>[];
+
+  /**
+   * For buffering reads to manage "suction", i.e. the read rate exceeding the input rate.
+   */
+  readonly #readQueue: PromiseCallbacks[];
+
+  constructor(port: MessagePort) {
+    this.#isDone = false;
+    this.#port = port;
+    this.#messageQueue = [];
+    this.#readQueue = [];
+
+    // Assigning to the `onmessage` property initializes the port's message queue.
+    // https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/message_event
+    this.#port.onmessage = this.#handleMessage.bind(this);
+    harden(this);
+  }
+
+  [Symbol.asyncIterator](): MessagePortReader<Yield> {
+    return this;
+  }
+
+  #handleMessage(message: MessageEvent): void {
+    if (message.data instanceof Error) {
+      this.#throw(message.data);
+      return;
+    }
+
+    if (!isIteratorResult(message.data)) {
+      this.#throw(
+        new Error(
+          `Received unexpected message via message port:\n${JSON.stringify(
+            message.data,
+            null,
+            2,
+          )}`,
+        ),
+      );
+      return;
+    }
+
+    if (message.data.done === true) {
+      this.#return();
+      return;
+    }
+
+    if (this.#readQueue.length > 0) {
+      const { resolve } = this.#readQueue.shift() as PromiseCallbacks;
+      resolve({ ...message.data });
+    } else {
+      this.#messageQueue.push(message);
+    }
+  }
+
+  /**
+   * Reads the next message from the port.
+   *
+   * @returns The next message from the port.
+   */
+  async next(): Promise<IteratorResult<Yield, undefined>> {
+    if (this.#isDone) {
+      return makeDoneResult();
+    }
+
+    const { promise, resolve, reject } = makePromiseKit();
+    if (this.#messageQueue.length > 0) {
+      const message = this.#messageQueue.shift() as MessageEvent<
+        IteratorResult<unknown, unknown>
+      >;
+      resolve({ ...message.data });
+    } else {
+      this.#readQueue.push({ resolve, reject });
+    }
+    return promise as Promise<IteratorResult<Yield, undefined>>;
+  }
+
+  /**
+   * Closes the underlying port and returns. Any unread messages will be lost.
+   *
+   * @returns The final result for this stream.
+   */
+  async return(): Promise<IteratorResult<Yield, undefined>> {
+    if (!this.#isDone) {
+      this.#return();
+    }
+    return makeDoneResult();
+  }
+
+  #return(): void {
+    while (this.#readQueue.length > 0) {
+      const { resolve } = this.#readQueue.shift() as PromiseCallbacks;
+      resolve(makeDoneResult());
+    }
+    this.#end();
+  }
+
+  /**
+   * Rejects all pending reads with the specified error, closes the underlying port,
+   * and returns.
+   *
+   * @param error - The error to reject pending reads with.
+   * @returns The final result for this stream.
+   */
+  async throw(error: Error): Promise<IteratorResult<Yield, undefined>> {
+    if (!this.#isDone) {
+      this.#throw(error);
+    }
+    return makeDoneResult();
+  }
+
+  #throw(error: Error): void {
+    while (this.#readQueue.length > 0) {
+      const { reject } = this.#readQueue.shift() as PromiseCallbacks;
+      reject(error);
+    }
+    this.#end();
+  }
+
+  #end(): void {
+    this.#isDone = true;
+    this.#messageQueue = [];
+    this.#port.close();
+    this.#port.onmessage = null;
+  }
+}
+harden(MessagePortReader);
+
+/**
+ * A writable stream over a {@link MessagePort}.
+ *
+ * This class is a naive passthrough mechanism for data over a pair of linked message
+ * ports. The message port mechanism is assumed to be completely reliable, and this
+ * class therefore has no concept of errors or error handling. Errors and closure
+ * are expected to be handled at a higher level of abstraction.
+ *
+ * @see
+ * - {@link MessagePortReader} for the corresponding readable stream.
+ * - The module-level documentation for more details.
+ */
+export class MessagePortWriter<Yield> implements Writer<Yield> {
+  #isDone: boolean;
+
+  readonly #port: MessagePort;
+
+  constructor(port: MessagePort) {
+    this.#isDone = false;
+    this.#port = port;
+    harden(this);
+  }
+
+  [Symbol.asyncIterator](): MessagePortWriter<Yield> {
+    return this;
+  }
+
+  /**
+   * Writes the next message to the port.
+   *
+   * @param value - The next message to write to the port.
+   * @returns The result of writing the message.
+   */
+  async next(value: Yield): Promise<IteratorResult<undefined, undefined>> {
+    if (this.#isDone) {
+      return makeDoneResult();
+    }
+    return this.#send({ done: false, value });
+  }
+
+  /**
+   * Closes the underlying port and returns. Idempotent.
+   *
+   * @returns The final result for this stream.
+   */
+  async return(): Promise<IteratorResult<undefined, undefined>> {
+    if (!this.#isDone) {
+      this.#send(makeDoneResult());
+      this.#end();
+    }
+    return makeDoneResult();
+  }
+
+  /**
+   * Forwards the error to the port and closes this stream. Idempotent.
+   *
+   * @param error - The error to forward to the port.
+   * @returns The final result for this stream.
+   */
+  async throw(error: Error): Promise<IteratorResult<undefined, undefined>> {
+    if (!this.#isDone) {
+      this.#throw(error);
+    }
+    return makeDoneResult();
+  }
+
+  /**
+   * Forwards the error the port and calls `#finish()`. Mutually recursive with `#send()`.
+   * For this reason, includes a flag indicating past failure, so that `#send()` can avoid
+   * infinite recursion. See `#send()` for more details.
+   *
+   * @param error - The error to forward.
+   * @param hasFailed - Whether sending has failed previously.
+   * @returns The final result for this stream.
+   */
+  #throw(
+    error: Error,
+    hasFailed = false,
+  ): IteratorResult<undefined, undefined> {
+    const result = this.#send(error, hasFailed);
+    !this.#isDone && this.#end();
+    return result;
+  }
+
+  /**
+   * Sends the value over the port. If sending the value fails, calls `#throw()`, and is
+   * therefore mutually recursive with this method. For this reason, includes a flag
+   * indicating past failure to send a value, which is used to avoid infinite recursion.
+   * If sending the value succeeds, returns a finished result (`{ done: true }`) if the
+   * value was an {@link Error} or itself a finished result, otherwise returns an
+   * unfinished result (`{ done: false }`).
+   *
+   * @param value - The value to send over the port.
+   * @param hasFailed - Whether sending has failed previously.
+   * @returns The result of sending the value.
+   */
+  #send(
+    value: IteratorResult<Yield, undefined> | Error,
+    hasFailed = false,
+  ): IteratorResult<undefined, undefined> {
+    try {
+      this.#port.postMessage(value);
+      return value instanceof Error || value.done === true
+        ? makeDoneResult()
+        : { done: false, value: undefined };
+    } catch (error) {
+      console.error('MessagePortWriter experienced a send failure:', error);
+
+      if (hasFailed) {
+        // Break out of repeated failure to send an error. It is unclear how this would occur
+        // in practice, but it's the kind of failure mode where it's better to be sure.
+        const repeatedFailureError = new Error(
+          'MessagePortWriter experienced repeated send failures.',
+          { cause: error },
+        );
+        this.#port.postMessage(repeatedFailureError);
+        throw repeatedFailureError;
+      } else {
+        // postMessage throws only DOMExceptions, which inherit from Error
+        this.#throw(error as Error, true);
+      }
+      return makeDoneResult();
+    }
+  }
+
+  #end(): void {
+    this.#isDone = true;
+    this.#port.close();
+  }
+}
+harden(MessagePortWriter);
+
+export type MessagePortStreamPair<Value> = Readonly<{
+  reader: MessagePortReader<Value>;
+  writer: MessagePortWriter<Value>;
+  /**
+   * Calls `.return()` on both streams.
+   */
+  return: () => Promise<void>;
+  /**
+   * Calls `.throw()` on the writer, forwarding the error to the other side. Returns
+   * the reader.
+   *
+   * @param error - The error to forward.
+   */
+  throw: (error: Error) => Promise<void>;
+}>;
+
+/**
+ * Makes a reader / writer pair over the same port, and provides convenience methods
+ * for cleaning them up.
+ *
+ * @param port - The message port to make the streams over.
+ * @returns The reader and writer streams, and cleanup methods.
+ */
+export const makeMessagePortStreamPair = <Value>(
+  port: MessagePort,
+): MessagePortStreamPair<Value> => {
+  const reader = new MessagePortReader<Value>(port);
+  const writer = new MessagePortWriter<Value>(port);
+
+  return harden({
+    reader,
+    writer,
+    return: async () =>
+      Promise.all([writer.return(), reader.return()]).then(() => undefined),
+    throw: async (error: Error) =>
+      Promise.all([writer.throw(error), reader.return()]).then(() => undefined),
+  });
+};
diff --git a/packages/streams/tsconfig.build.json b/packages/streams/tsconfig.build.json
new file mode 100644
index 000000000..e600b10be
--- /dev/null
+++ b/packages/streams/tsconfig.build.json
@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.packages.build.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "lib": ["DOM", "ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["ses"]
+  },
+  "references": [],
+  "include": ["./src"]
+}
diff --git a/packages/streams/tsconfig.json b/packages/streams/tsconfig.json
new file mode 100644
index 000000000..85b667185
--- /dev/null
+++ b/packages/streams/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.packages.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "lib": ["DOM", "ES2022"],
+    "types": ["ses", "vitest", "vitest/jsdom"]
+  },
+  "references": [{ "path": "../test-utils" }],
+  "include": ["./src"]
+}
diff --git a/packages/streams/typedoc.json b/packages/streams/typedoc.json
new file mode 100644
index 000000000..3d60644d9
--- /dev/null
+++ b/packages/streams/typedoc.json
@@ -0,0 +1,7 @@
+{
+  "entryPoints": ["./src/streams.ts", "./src/message-channel.ts"],
+  "excludePrivate": true,
+  "hideGenerator": true,
+  "out": "docs",
+  "tsconfig": "./tsconfig.build.json"
+}
diff --git a/packages/streams/vitest.config.ts b/packages/streams/vitest.config.ts
new file mode 100644
index 000000000..68aa3a1b5
--- /dev/null
+++ b/packages/streams/vitest.config.ts
@@ -0,0 +1,17 @@
+// eslint-disable-next-line spaced-comment
+/// <reference types="vitest" />
+
+import { defineConfig, mergeConfig } from 'vite';
+
+import { getDefaultConfig } from '../../vitest.config.packages.js';
+
+const defaultConfig = getDefaultConfig();
+
+export default mergeConfig(
+  defaultConfig,
+  defineConfig({
+    test: {
+      setupFiles: '../test-utils/src/env/mock-endo.ts',
+    },
+  }),
+);
diff --git a/packages/test-utils/package.json b/packages/test-utils/package.json
index b4d43eb12..c239be901 100644
--- a/packages/test-utils/package.json
+++ b/packages/test-utils/package.json
@@ -19,7 +19,7 @@
   "devDependencies": {
     "rimraf": "^6.0.1",
     "ses": "^1.7.0",
-    "typescript": "~5.5.4",
+    "typescript": "~4.9.5",
     "vitest": "^2.0.5"
   },
   "engines": {
diff --git a/tsconfig.build.json b/tsconfig.build.json
index 5107ebe6e..34acb2854 100644
--- a/tsconfig.build.json
+++ b/tsconfig.build.json
@@ -3,6 +3,7 @@
   "include": [],
   "references": [
     { "path": "./packages/extension/tsconfig.build.json" },
-    { "path": "./packages/shims/tsconfig.build.json" }
+    { "path": "./packages/shims/tsconfig.build.json" },
+    { "path": "./packages/streams/tsconfig.build.json" }
   ]
 }
diff --git a/tsconfig.json b/tsconfig.json
index b2cf5851c..2cd76ded6 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -11,6 +11,7 @@
   "references": [
     { "path": "./packages/extension" },
     { "path": "./packages/shims" },
+    { "path": "./packages/streams" },
     { "path": "./packages/test-utils" }
   ]
 }
diff --git a/tsconfig.packages.json b/tsconfig.packages.json
index 0dd744a1e..31f77b215 100644
--- a/tsconfig.packages.json
+++ b/tsconfig.packages.json
@@ -3,7 +3,7 @@
     "composite": true,
     "exactOptionalPropertyTypes": true,
     "forceConsistentCasingInFileNames": true,
-    "lib": ["ES2020"],
+    "lib": ["ES2022"],
     "module": "Node16",
     "moduleResolution": "Node16",
     "noErrorTruncation": true,
diff --git a/yarn.lock b/yarn.lock
index 0102093e0..d5df286f8 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -334,7 +334,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@endo/eventual-send@npm:^1.2.3, @endo/eventual-send@npm:^1.2.4":
+"@endo/eventual-send@npm:^1.2.2, @endo/eventual-send@npm:^1.2.3, @endo/eventual-send@npm:^1.2.4":
   version: 1.2.4
   resolution: "@endo/eventual-send@npm:1.2.4"
   dependencies:
@@ -377,7 +377,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@endo/promise-kit@npm:^1.1.3, @endo/promise-kit@npm:^1.1.4":
+"@endo/promise-kit@npm:^1.1.2, @endo/promise-kit@npm:^1.1.3, @endo/promise-kit@npm:^1.1.4":
   version: 1.1.4
   resolution: "@endo/promise-kit@npm:1.1.4"
   dependencies:
@@ -386,6 +386,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@endo/stream@npm:^1.2.2":
+  version: 1.2.2
+  resolution: "@endo/stream@npm:1.2.2"
+  dependencies:
+    "@endo/eventual-send": "npm:^1.2.2"
+    "@endo/promise-kit": "npm:^1.1.2"
+    ses: "npm:^1.5.0"
+  checksum: 10/2c0ebea133c7a184672679dd1597903fd14df1d6ddd3103f44ef476d9b86a58a8c04ecf42f960a79c8ba85f138e2020bf86ae1cd9a483633326bfc2d874473a4
+  languageName: node
+  linkType: hard
+
 "@endo/where@npm:^1.0.6":
   version: 1.0.6
   resolution: "@endo/where@npm:1.0.6"
@@ -1246,6 +1257,7 @@ __metadata:
     "@metamask/snaps-utils": "npm:^7.8.0"
     "@metamask/utils": "npm:^9.1.0"
     "@ocap/shims": "workspace:^"
+    "@ocap/streams": "workspace:^"
     "@ocap/test-utils": "workspace:^"
     "@types/chrome": "npm:^0.0.268"
     "@vitest/coverage-v8": "npm:^2.0.5"
@@ -1257,7 +1269,7 @@ __metadata:
     ses: "npm:^1.7.0"
     typedoc: "npm:^0.24.8"
     typedoc-plugin-missing-exports: "npm:^2.0.0"
-    typescript: "npm:~5.5.4"
+    typescript: "npm:~4.9.5"
     vite: "npm:^5.3.5"
     vite-plugin-static-copy: "npm:^1.0.6"
     vitest: "npm:^2.0.5"
@@ -1294,7 +1306,7 @@ __metadata:
     prettier-plugin-packagejson: "npm:^2.3.0"
     rimraf: "npm:^6.0.1"
     typedoc: "npm:^0.24.8"
-    typescript: "npm:~5.5.4"
+    typescript: "npm:~4.9.5"
     vite: "npm:^5.3.5"
     vite-tsconfig-paths: "npm:^4.3.2"
     vitest: "npm:^2.0.5"
@@ -1316,13 +1328,38 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"@ocap/streams@workspace:^, @ocap/streams@workspace:packages/streams":
+  version: 0.0.0-use.local
+  resolution: "@ocap/streams@workspace:packages/streams"
+  dependencies:
+    "@arethetypeswrong/cli": "npm:^0.15.3"
+    "@endo/promise-kit": "npm:^1.1.4"
+    "@endo/stream": "npm:^1.2.2"
+    "@metamask/auto-changelog": "npm:^3.4.4"
+    "@metamask/utils": "npm:^9.1.0"
+    "@ocap/test-utils": "workspace:^"
+    "@ts-bridge/cli": "npm:^0.3.0"
+    "@ts-bridge/shims": "npm:^0.1.1"
+    "@types/jsdom": "npm:^21.1.7"
+    "@vitest/coverage-v8": "npm:^2.0.5"
+    deepmerge: "npm:^4.3.1"
+    jsdom: "npm:^24.1.1"
+    rimraf: "npm:^6.0.1"
+    typedoc: "npm:^0.24.8"
+    typedoc-plugin-missing-exports: "npm:^2.0.0"
+    typescript: "npm:~4.9.5"
+    vite: "npm:^5.3.5"
+    vitest: "npm:^2.0.5"
+  languageName: unknown
+  linkType: soft
+
 "@ocap/test-utils@workspace:^, @ocap/test-utils@workspace:packages/test-utils":
   version: 0.0.0-use.local
   resolution: "@ocap/test-utils@workspace:packages/test-utils"
   dependencies:
     rimraf: "npm:^6.0.1"
     ses: "npm:^1.7.0"
-    typescript: "npm:~5.5.4"
+    typescript: "npm:~4.9.5"
     vitest: "npm:^2.0.5"
   languageName: unknown
   linkType: soft
@@ -1682,6 +1719,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/jsdom@npm:^21.1.7":
+  version: 21.1.7
+  resolution: "@types/jsdom@npm:21.1.7"
+  dependencies:
+    "@types/node": "npm:*"
+    "@types/tough-cookie": "npm:*"
+    parse5: "npm:^7.0.0"
+  checksum: 10/a5ee54aec813ac928ef783f69828213af4d81325f584e1fe7573a9ae139924c40768d1d5249237e62d51b9a34ed06bde059c86c6b0248d627457ec5e5d532dfa
+  languageName: node
+  linkType: hard
+
 "@types/minimatch@npm:^3.0.3":
   version: 3.0.5
   resolution: "@types/minimatch@npm:3.0.5"
@@ -1730,6 +1778,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/tough-cookie@npm:*":
+  version: 4.0.5
+  resolution: "@types/tough-cookie@npm:4.0.5"
+  checksum: 10/01fd82efc8202670865928629697b62fe9bf0c0dcbc5b1c115831caeb073a2c0abb871ff393d7df1ae94ea41e256cb87d2a5a91fd03cdb1b0b4384e08d4ee482
+  languageName: node
+  linkType: hard
+
 "@typescript-eslint/eslint-plugin@npm:^8.1.0":
   version: 8.1.0
   resolution: "@typescript-eslint/eslint-plugin@npm:8.1.0"
@@ -5853,7 +5908,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ses@npm:^1.1.0, ses@npm:^1.7.0":
+"ses@npm:^1.1.0, ses@npm:^1.5.0, ses@npm:^1.7.0":
   version: 1.7.0
   resolution: "ses@npm:1.7.0"
   dependencies:
@@ -6437,13 +6492,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:~5.5.4":
-  version: 5.5.4
-  resolution: "typescript@npm:5.5.4"
+"typescript@npm:~4.9.5":
+  version: 4.9.5
+  resolution: "typescript@npm:4.9.5"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: 10/1689ccafef894825481fc3d856b4834ba3cc185a9c2878f3c76a9a1ef81af04194849840f3c69e7961e2312771471bb3b460ca92561e1d87599b26c37d0ffb6f
+  checksum: 10/458f7220ab11e0fc191514cc41be1707645ec9a8c2d609448a448e18c522cef9646f58728f6811185a4c35613dacdf6c98cf8965c88b3541d0288c47291e4300
   languageName: node
   linkType: hard
 
@@ -6457,13 +6512,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A~5.5.4#optional!builtin<compat/typescript>":
-  version: 5.5.4
-  resolution: "typescript@patch:typescript@npm%3A5.5.4#optional!builtin<compat/typescript>::version=5.5.4&hash=b45daf"
+"typescript@patch:typescript@npm%3A~4.9.5#optional!builtin<compat/typescript>":
+  version: 4.9.5
+  resolution: "typescript@patch:typescript@npm%3A4.9.5#optional!builtin<compat/typescript>::version=4.9.5&hash=289587"
   bin:
     tsc: bin/tsc
     tsserver: bin/tsserver
-  checksum: 10/2c065f0ef81855eac25c9b658a3c9da65ffc005260c12854c2286f40f3667e1b1ecf8bdbdd37b59aa0397920378ce7900bff8cb32e0f1c7af6fd86efc676718c
+  checksum: 10/5659316360b5cc2d6f5931b346401fa534107b68b60179cf14970e27978f0936c1d5c46f4b5b8175f8cba0430f522b3ce355b4b724c0ea36ce6c0347fab25afd
   languageName: node
   linkType: hard