@marimo-team/islands 0.25.3-dev34 → 0.25.3-dev349

package/src/core/wasm/__tests__/bridge.test.ts

@@ -1,27 +1,47 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { cellId } from "@/__tests__/branded";
 import { Deferred } from "@/utils/Deferred";
+import { atom } from "jotai";
 
 const {
   mockBridge,
   mockNotebookReadFile,
   mockReadNotebook,
-  mockSaveNotebook,
+  mockWriteNotebook,
+  mockNotebookCall,
+  mockSetNotebookLayout,
+  parentRequests,
   mockBootstrap,
   rpcListeners,
+  mockNotebookSubscribe,
+  mockNotebookUnsubscribe,
+  workerState,
 } = vi.hoisted(() => ({
   mockBridge: vi.fn(),
   mockNotebookReadFile: vi.fn(),
   mockReadNotebook: vi.fn(),
-  mockSaveNotebook: vi.fn(),
+  mockWriteNotebook: vi.fn(),
+  mockNotebookCall: vi.fn(),
+  mockSetNotebookLayout: vi.fn(),
+  parentRequests: {} as {
+    persistNotebook?: (snapshot: {
+      filename: string;
+      contents: string;
+    }) => Promise<void>;
+  },
   mockBootstrap: vi.fn(),
-  rpcListeners: {} as Record<string, () => void>,
+  rpcListeners: {} as Record<
+    string,
+    (message?: { id: string; event: string }) => void
+  >,
+  mockNotebookSubscribe: vi.fn(),
+  mockNotebookUnsubscribe: vi.fn(),
+  workerState: { interruptBuffer: undefined as Uint8Array | undefined },
 }));
 
 // Mock browser globals before any imports
-vi.stubGlobal("crossOriginIsolated", false);
+vi.stubGlobal("crossOriginIsolated", true);
 vi.stubGlobal(
   "Worker",
   // vitest 4 requires a `function` (not an arrow) for mocks called with `new`
@@ -41,22 +61,34 @@ class MockURL extends URL {
 vi.stubGlobal("URL", MockURL);
 
 vi.mock("@/core/wasm/rpc", () => ({
-  getWorkerRPC: () => ({
-    send: { bootstrap: mockBootstrap },
-    proxy: {
-      request: {
-        bridge: mockBridge,
-        startSession: vi.fn(),
-        readFile: vi.fn(),
-        readNotebook: mockReadNotebook,
-        saveNotebook: mockSaveNotebook,
+  getWorkerRPC: (_worker: Worker, handlers?: typeof parentRequests) => {
+    Object.assign(parentRequests, handlers);
+    return {
+      send: { bootstrap: mockBootstrap },
+      proxy: {
+        request: {
+          bridge: mockBridge,
+          startSession: vi.fn(),
+          readFile: vi.fn(),
+          readNotebook: mockReadNotebook,
+          writeNotebook: mockWriteNotebook,
+          notebookSubscribe: mockNotebookSubscribe,
+          notebookUnsubscribe: mockNotebookUnsubscribe,
+          notebookCall: mockNotebookCall,
+          setNotebookLayout: mockSetNotebookLayout,
+          setInterruptBuffer: (buffer: Uint8Array) => {
+            workerState.interruptBuffer = buffer;
+          },
+        },
       },
-      send: { consumerReady: vi.fn() },
-    },
-    addMessageListener: (event: string, cb: () => void) => {
-      rpcListeners[event] = cb;
-    },
-  }),
+      addMessageListener: (
+        event: string,
+        cb: (typeof rpcListeners)[string],
+      ) => {
+        rpcListeners[event] = cb;
+      },
+    };
+  },
 }));
 
 vi.mock("@/core/meta/globals", () => ({
@@ -75,11 +107,15 @@ vi.mock("@/core/wasm/store", () => ({
 // Import after all mocks are set up
 import { store } from "@/core/state/jotai";
 import { initialModeAtom } from "@/core/mode";
+import type { NotebookReplica } from "@/core/notebook/replica";
+import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
+import { fallbackFileStore, notebookFileStore } from "../store";
 import { getWasmWorkerName, PyodideBridge } from "../bridge";
 
-// Access INSTANCE once at module level so the constructor runs (and
-// addMessageListener populates rpcListeners) before any test executes.
-void PyodideBridge.INSTANCE;
+beforeEach(() => {
+  Reflect.deleteProperty(window, "_marimo_private_PyodideBridge");
+  void PyodideBridge.INSTANCE;
+});
 
 describe("PyodideBridge.readCode", () => {
   beforeEach(() => {
@@ -160,62 +196,258 @@ describe("PyodideBridge.exportAsScript", () => {
   });
 });
 
-describe("PyodideBridge.sendSave", () => {
-  const request = {
-    cellIds: [cellId("cell-1")],
-    codes: ['value = "NEW"'],
-    names: ["_"],
-    filename: "notebook.py",
-    configs: [{}],
-    layout: null,
-    persist: true,
-  };
-
+describe("PyodideBridge notebook persistence", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     store.set(initialModeAtom, "edit");
     rpcListeners.initialized();
-    mockSaveNotebook.mockResolvedValue(null);
-    mockReadNotebook.mockResolvedValue(
-      "import marimo\napp = marimo.App()\n# NEW",
-    );
+    mockWriteNotebook.mockResolvedValue(undefined);
   });
 
   afterEach(() => {
     store.set(initialModeAtom, undefined);
   });
 
-  it("waits for the session save before generating exports", async () => {
-    const mainSave = new Deferred<void>();
-    mockSaveNotebook
-      .mockResolvedValueOnce(null)
-      .mockReturnValueOnce(mainSave.promise);
+  it("persists exactly the host's content before acknowledging storage", async () => {
+    const durable = new Deferred<void>();
+    const snapshot = { filename: "notebook.py", contents: "# host revision" };
+    mockWriteNotebook.mockReturnValueOnce(durable.promise);
+    const writing = parentRequests.persistNotebook!(snapshot);
+    await Promise.resolve();
+    expect(mockWriteNotebook).toHaveBeenCalledWith(snapshot);
+    expect(notebookFileStore.saveFile).not.toHaveBeenCalled();
+    durable.resolve();
+    await writing;
+    expect(notebookFileStore.saveFile).toHaveBeenCalledWith(snapshot.contents);
+    expect(fallbackFileStore.saveFile).toHaveBeenCalledWith(snapshot.contents);
+  });
 
-    await PyodideBridge.INSTANCE.sendSave(request);
-    expect(mockSaveNotebook).toHaveBeenCalledTimes(2);
-    expect(mockSaveNotebook).toHaveBeenNthCalledWith(1, request);
-    expect(mockSaveNotebook).toHaveBeenNthCalledWith(2, request);
+  it("propagates storage failure without updating the URL", async () => {
+    mockWriteNotebook.mockRejectedValueOnce(new Error("IndexedDB failed"));
+    await expect(
+      parentRequests.persistNotebook!({
+        filename: "notebook.py",
+        contents: "# host",
+      }),
+    ).rejects.toThrow("IndexedDB failed");
+    expect(notebookFileStore.saveFile).not.toHaveBeenCalled();
+  });
+});
 
-    const markdown = PyodideBridge.INSTANCE.exportAsMarkdown({
-      download: false,
-    });
-    const script = PyodideBridge.INSTANCE.exportAsScript({
-      download: false,
-    });
-    await Promise.resolve();
-    expect(mockBridge).not.toHaveBeenCalled();
+it("cancels a pending notebook subscription before its RPC response", async () => {
+  vi.clearAllMocks();
+  store.set(initialModeAtom, "read");
+  rpcListeners.initialized();
+  const pending = new Deferred<void>();
+  mockNotebookSubscribe.mockReturnValue(pending.promise);
+  mockNotebookUnsubscribe.mockResolvedValue(undefined);
+  const controller = new AbortController();
+  try {
+    const backend = await PyodideBridge.INSTANCE.createNotebookBackend();
+    const following = backend.transport(
+      { cursor: null, signal: controller.signal },
+      { open: vi.fn(), message: vi.fn() },
+    );
+    await vi.waitFor(() =>
+      expect(mockNotebookSubscribe).toHaveBeenCalledOnce(),
+    );
+    const [{ id }] = mockNotebookSubscribe.mock.calls[0];
+    controller.abort();
+    await following;
+    expect(mockNotebookUnsubscribe.mock.calls).toEqual([[id]]);
+
+    pending.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(mockNotebookUnsubscribe.mock.calls).toEqual([[id]]);
+  } finally {
+    controller.abort();
+    pending.resolve();
+    store.set(initialModeAtom, undefined);
+  }
+});
 
-    mainSave.resolve();
-    await Promise.all([markdown, script]);
-    expect(mockBridge).toHaveBeenCalledWith({
-      functionName: "export_markdown",
-      payload: { download: false },
+it("raises the interrupt buffer for a cancelled running run before the worker takes the call", async () => {
+  vi.clearAllMocks();
+  store.set(initialModeAtom, "read");
+  rpcListeners.initialized();
+  const run = {
+    id: "run-1",
+    notebook_id: "n1",
+    runtime_id: "r1",
+    cells: [],
+    status: "running",
+    outcome: null,
+    started_at: "2026-10-01T09:20:11Z",
+    completed_at: null,
+  };
+  const replicaWith = (status: string) =>
+    ({
+      executionsAtom: atom({
+        runs: new Map([["run-1", { ...run, status }]]),
+        executions: new Map(),
+        latest: new Map(),
+      }),
+    }) as unknown as NotebookReplica;
+  const buffer = workerState.interruptBuffer!;
+  buffer[0] = 0;
+  mockNotebookCall.mockResolvedValue({ status: 202, body: run });
+  mockNotebookCall.mockImplementationOnce(async () => {
+    expect(buffer[0]).toBe(2);
+    return { status: 202, body: run };
+  });
+  try {
+    const backend = await PyodideBridge.INSTANCE.createNotebookBackend();
+    const notebook = backend.notebook("n1");
+
+    store.set(activeNotebookReplicaAtom, replicaWith("running"));
+    expect((await notebook.cancel({ runId: "run-1" })).ok).toBe(true);
+    expect(buffer[0]).toBe(2);
+    expect(mockNotebookCall).toHaveBeenCalledOnce();
+
+    buffer[0] = 0;
+    store.set(activeNotebookReplicaAtom, replicaWith("queued"));
+    expect((await notebook.cancel({ runId: "run-1" })).ok).toBe(true);
+    expect(buffer[0]).toBe(0);
+    expect(mockNotebookCall).toHaveBeenCalledTimes(2);
+  } finally {
+    buffer[0] = 0;
+    store.set(activeNotebookReplicaAtom, null);
+    store.set(initialModeAtom, undefined);
+  }
+});
+
+it.each(["running", "completed", null])(
+  "signals runtime work before the RPC with recorded run status %s",
+  async (status) => {
+    vi.clearAllMocks();
+    store.set(initialModeAtom, "read");
+    rpcListeners.initialized();
+    const run = {
+      id: "run-1",
+      notebook_id: "n1",
+      runtime_id: "r1",
+      cells: [],
+      status: "running",
+      outcome: null,
+      started_at: "2026-10-01T09:20:11Z",
+      completed_at: null,
+    };
+    const replicaWith = (status: string) =>
+      ({
+        executionsAtom: atom({
+          runs: new Map([["run-1", { ...run, status }]]),
+          executions: new Map(),
+          latest: new Map(),
+        }),
+      }) as unknown as NotebookReplica;
+    const buffer = workerState.interruptBuffer!;
+    buffer[0] = 0;
+    const accepted = {
+      status: 202,
+      body: {
+        id: "r1",
+        notebook_id: "n1",
+        status: "running",
+        message: null,
+        marimo_version: null,
+        started_at: "2026-10-01T09:20:11Z",
+      },
+    };
+    mockNotebookCall.mockImplementation(async () => {
+      expect(buffer[0]).toBe(2);
+      return accepted;
     });
-    expect(mockBridge).toHaveBeenCalledWith({
-      functionName: "export_script",
-      payload: { download: false },
+    try {
+      const backend = await PyodideBridge.INSTANCE.createNotebookBackend();
+      const notebook = backend.notebook("n1");
+
+      store.set(
+        activeNotebookReplicaAtom,
+        status === null ? null : replicaWith(status),
+      );
+      expect((await notebook.interrupt()).ok).toBe(true);
+      expect(buffer[0]).toBe(2);
+
+      // Nothing holds the worker, so it takes the call and ends queued runs.
+      buffer[0] = 0;
+      store.set(activeNotebookReplicaAtom, replicaWith("queued"));
+      expect((await notebook.interrupt()).ok).toBe(true);
+      expect(buffer[0]).toBe(2);
+      expect(mockNotebookCall).toHaveBeenCalledTimes(2);
+      buffer[0] = 0;
+
+      // The worker took the queued run before the interrupt reached it.
+      const deliver = (status: string) =>
+        rpcListeners.notebookEvent({
+          id: "sub",
+          event: JSON.stringify({
+            event: "run",
+            data: { run: { ...run, status } },
+          }),
+        });
+      deliver("running");
+      expect(buffer[0]).toBe(2);
+      buffer[0] = 0;
+      deliver("completed");
+      expect(buffer[0]).toBe(0);
+    } finally {
+      buffer[0] = 0;
+      store.set(activeNotebookReplicaAtom, null);
+      store.set(initialModeAtom, undefined);
+    }
+  },
+);
+
+it("raises the interrupt buffer once a run cancelled while queued starts", async () => {
+  vi.clearAllMocks();
+  store.set(initialModeAtom, "read");
+  rpcListeners.initialized();
+  const run = {
+    id: "run-1",
+    notebook_id: "n1",
+    runtime_id: "r1",
+    cells: [],
+    status: "queued",
+    outcome: null,
+    started_at: null,
+    completed_at: null,
+  };
+  store.set(activeNotebookReplicaAtom, {
+    executionsAtom: atom({
+      runs: new Map([["run-1", run]]),
+      executions: new Map(),
+      latest: new Map(),
+    }),
+  } as unknown as NotebookReplica);
+  const buffer = workerState.interruptBuffer!;
+  buffer[0] = 0;
+  mockNotebookCall.mockResolvedValue({ status: 202, body: run });
+  const deliver = (status: string) =>
+    rpcListeners.notebookEvent({
+      id: "sub",
+      event: JSON.stringify({
+        event: "run",
+        data: { run: { ...run, status } },
+      }),
     });
-  });
+  try {
+    const backend = await PyodideBridge.INSTANCE.createNotebookBackend();
+    const notebook = backend.notebook("n1");
+    expect((await notebook.cancel({ runId: "run-1" })).ok).toBe(true);
+    expect(buffer[0]).toBe(0);
+
+    // The worker took the run before the cancellation reached it.
+    deliver("running");
+    expect(buffer[0]).toBe(2);
+    buffer[0] = 0;
+    deliver("running");
+    deliver("completed");
+    expect(buffer[0]).toBe(0);
+  } finally {
+    buffer[0] = 0;
+    store.set(activeNotebookReplicaAtom, null);
+    store.set(initialModeAtom, undefined);
+  }
 });
 
 describe("getWasmWorkerName", () => {
@@ -242,3 +474,61 @@ describe("getWasmWorkerName", () => {
     expect(getWasmWorkerName()).toBe("marimo");
   });
 });
+
+it("signals an interrupt once across pending, completed, and lost-reply retries", async () => {
+  vi.clearAllMocks();
+  store.set(initialModeAtom, "read");
+  rpcListeners.initialized();
+  const buffer = workerState.interruptBuffer!;
+  buffer[0] = 0;
+  const clock = vi.spyOn(performance, "now").mockReturnValue(0);
+  const pending = new Deferred<unknown>();
+  const accepted = {
+    status: 202,
+    body: {
+      id: "r1",
+      notebook_id: "n1",
+      status: "running",
+      message: null,
+      marimo_version: null,
+      started_at: "2026-10-01T09:20:11Z",
+    },
+  };
+  mockNotebookCall.mockImplementation(() => pending.promise);
+  try {
+    const backend = await PyodideBridge.INSTANCE.createNotebookBackend();
+    const notebook = backend.notebook("n1");
+    const options = { idempotencyKey: "retry-interrupt" };
+    const first = notebook.interrupt(options);
+    expect(buffer[0]).toBe(2);
+    buffer[0] = 0;
+    const retry = notebook.interrupt(options);
+    expect(buffer[0]).toBe(0);
+    pending.resolve(accepted);
+    expect(await retry).toEqual(await first);
+    await notebook.interrupt(options);
+    expect(buffer[0]).toBe(0);
+    expect(mockNotebookCall).toHaveBeenCalledTimes(3);
+
+    mockNotebookCall.mockRejectedValueOnce(new Error("Lost reply"));
+    await expect(
+      notebook.interrupt({ idempotencyKey: "lost-interrupt" }),
+    ).rejects.toThrow("Lost reply");
+    expect(buffer[0]).toBe(2);
+    buffer[0] = 0;
+    await notebook.interrupt({ idempotencyKey: "lost-interrupt" });
+    expect(buffer[0]).toBe(0);
+
+    // A new user action still signals; settled receipts expire with the worker's.
+    await notebook.interrupt();
+    expect(buffer[0]).toBe(2);
+    buffer[0] = 0;
+    clock.mockReturnValue(300_001);
+    await notebook.interrupt(options);
+    expect(buffer[0]).toBe(2);
+  } finally {
+    buffer[0] = 0;
+    clock.mockRestore();
+    store.set(initialModeAtom, undefined);
+  }
+});

package/src/core/wasm/__tests__/worker.test.ts

@@ -0,0 +1,191 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { PyodideInterface } from "pyodide";
+import { loadPyodide } from "pyodide";
+import { afterEach, expect, it, vi } from "vitest";
+import { defaultUserConfig } from "@/core/config/config-schema";
+import { Deferred } from "@/utils/Deferred";
+import { DefaultWasmController } from "../worker/bootstrap";
+import { getController } from "../worker/getController";
+import type { WasmRuntimeConfig } from "../runtime-config";
+
+interface WorkerRequests {
+  startSession(opts: {
+    queryParameters: Record<string, string | string[]>;
+    code: string;
+    filename: string;
+    userConfig: ReturnType<typeof defaultUserConfig>;
+  }): Promise<void>;
+  notebookSubscribe(opts: { id: string; cursor: string | null }): Promise<void>;
+  notebookUnsubscribe(id: string): Promise<void>;
+}
+
+const { rpc, handlers } = vi.hoisted(() => ({
+  handlers: {} as {
+    requests: WorkerRequests;
+    bootstrap: (config: WasmRuntimeConfig) => void;
+  },
+  rpc: {
+    send: Object.assign(vi.fn(), {
+      initialized: vi.fn(),
+      initializedError: vi.fn(),
+      initializingMessage: vi.fn(),
+      notebookEvent: vi.fn(),
+    }),
+  },
+}));
+
+vi.mock("rpc-anywhere", () => ({
+  createRPCRequestHandler: (requests: WorkerRequests) => {
+    handlers.requests = requests;
+    return requests;
+  },
+  createWorkerParentTransport: vi.fn(),
+  createRPC: () => ({
+    ...rpc,
+    addMessageListener: (
+      _name: string,
+      listener: (config: WasmRuntimeConfig) => void,
+    ) => {
+      handlers.bootstrap = listener;
+    },
+  }),
+}));
+vi.mock("pyodide", () => ({ loadPyodide: vi.fn(), version: "314.0.0" }));
+vi.mock("../worker/getController", () => ({ getController: vi.fn() }));
+vi.mock("../worker/getMarimoWheel", () => ({
+  getMarimoWheel: () => "marimo-base",
+}));
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.clearAllMocks();
+  vi.resetModules();
+});
+
+async function startWorker(subscribing = Promise.resolve()) {
+  const subscribers = new Map<string, (event: string) => void>();
+  const event = JSON.stringify({
+    event: "marimo",
+    data: { marimo: { op: "query-params-set", key: "startup", value: "ran" } },
+  });
+  const notebook = {
+    subscribe: vi.fn(
+      async (id: string, _cursor: unknown, emit: (event: string) => void) => {
+        await subscribing;
+        subscribers.set(id, emit);
+      },
+    ),
+    unsubscribe: (id: string) => subscribers.delete(id),
+    set_persistence: vi.fn(),
+    set_package_loader: vi.fn(),
+    allow_input: vi.fn(),
+    destroy: vi.fn(),
+  };
+  const bridge = { notebook, destroy: vi.fn() };
+  const init = Object.assign(
+    vi.fn(() => subscribers.forEach((emit) => emit(event))),
+    { destroy: vi.fn() },
+  );
+  const stop = Object.assign(
+    vi.fn(async () => subscribers.clear()),
+    {
+      destroy: vi.fn(),
+    },
+  );
+  const packages = { toJs: () => [], destroy: vi.fn() };
+  const resources = Object.assign([bridge, init, packages, stop], {
+    destroy: vi.fn(),
+  });
+  const pyodide = {
+    runPython: vi.fn(() => resources),
+    loadPackagesFromImports: vi.fn(async () => undefined),
+    loadedPackages: {},
+  };
+  vi.mocked(loadPyodide).mockResolvedValue(
+    pyodide as unknown as PyodideInterface,
+  );
+  const controller = new DefaultWasmController();
+  vi.spyOn(controller, "mountFilesystem").mockResolvedValue({
+    code: "",
+    filename: "notebook.py",
+  });
+  vi.mocked(getController).mockResolvedValue(controller);
+  await import("../worker/worker");
+  handlers.bootstrap({ version: "0.25.1" });
+  await handlers.requests.startSession({
+    code: "",
+    filename: "notebook.py",
+    queryParameters: {},
+    userConfig: defaultUserConfig(),
+  });
+  return { controller, init, notebook, event, pyodide };
+}
+
+it("delivers startup notifications after a delayed first subscription, without rerunning on resubscribe", async () => {
+  const { controller, init, notebook, event, pyodide } = await startWorker();
+  try {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(rpc.send.initialized).toHaveBeenCalledOnce();
+    expect(notebook.set_persistence).toHaveBeenCalledExactlyOnceWith(
+      expect.any(Function),
+    );
+    // The editor's user can answer a prompt, so its runs may ask for one.
+    expect(notebook.allow_input).toHaveBeenCalledExactlyOnceWith(true);
+    expect(pyodide.loadPackagesFromImports).toHaveResolved();
+    expect(init).not.toHaveBeenCalled();
+
+    await handlers.requests.notebookSubscribe({ id: "first", cursor: null });
+    await vi.waitFor(() => expect(init).toHaveBeenCalledOnce());
+    expect(rpc.send.notebookEvent.mock.calls).toEqual([
+      [{ id: "first", event }],
+    ]);
+
+    await handlers.requests.notebookUnsubscribe("first");
+    await handlers.requests.notebookSubscribe({ id: "second", cursor: null });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(init).toHaveBeenCalledOnce();
+    expect(notebook.set_persistence).toHaveBeenCalledOnce();
+  } finally {
+    await controller.stopSession();
+  }
+});
+
+it("does not authorize startup through a subscription canceled while opening", async () => {
+  const subscribing = new Deferred<void>();
+  const { controller, init, notebook } = await startWorker(subscribing.promise);
+  try {
+    const opened = handlers.requests.notebookSubscribe({
+      id: "canceled",
+      cursor: null,
+    });
+    await vi.waitFor(() => expect(notebook.subscribe).toHaveBeenCalledOnce());
+    const closed = handlers.requests.notebookUnsubscribe("canceled");
+    subscribing.resolve();
+    await Promise.all([opened, closed]);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(init).not.toHaveBeenCalled();
+
+    await handlers.requests.notebookSubscribe({ id: "active", cursor: null });
+    await vi.waitFor(() => expect(init).toHaveBeenCalledOnce());
+  } finally {
+    await controller.stopSession();
+  }
+});
+
+it("waits for a successful subscription after an opening failure", async () => {
+  const { controller, init, notebook } = await startWorker();
+  try {
+    notebook.subscribe.mockRejectedValueOnce(new Error("Subscription failed"));
+    await expect(
+      handlers.requests.notebookSubscribe({ id: "failed", cursor: null }),
+    ).rejects.toThrow("Subscription failed");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(init).not.toHaveBeenCalled();
+
+    await handlers.requests.notebookSubscribe({ id: "active", cursor: null });
+    await vi.waitFor(() => expect(init).toHaveBeenCalledOnce());
+  } finally {
+    await controller.stopSession();
+  }
+});