@marimo-team/islands 0.25.3-dev322 → 0.25.3-dev348

package/src/core/notebook/document/__tests__/test-host.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { createHash } from "node:crypto";
-import type { Result } from "@marimo-team/client";
+import type { ProblemOf, ResultOf } from "@marimo-team/client";
 import * as Protocol from "@marimo-team/client/protocol";
 import type { Document } from "../../replica/resources/document";
 
@@ -12,7 +12,7 @@ export interface EditRequest {
 }
 
 interface Outcome {
-  readonly result: Result<Protocol.EditResponseOutput>;
+  readonly result: ResultOf<"notebook.edit">;
   /** Only a new commit produces a stream update; replaying a receipt does not. */
   readonly update?: Document;
 }
@@ -52,25 +52,8 @@ function record(
   };
 }
 
-function rejected(
-  status: number,
-  kind: string,
-  detail: string,
-  edit?: Protocol.Problem["edit"],
-): Outcome {
-  return {
-    result: {
-      ok: false,
-      status,
-      problem: {
-        type: `tag:marimo.io,2026:host/${kind}`,
-        title: kind === "conflict" ? "Conflict" : "Invalid request",
-        detail,
-        status,
-        ...(edit === undefined ? {} : { edit }),
-      },
-    },
-  };
+function rejected(problem: ProblemOf<"notebook.edit">): Outcome {
+  return { result: { ok: false, status: problem.status, problem } };
 }
 
 /** An independent implementation of the document edit protocol, without client draft logic. */
@@ -80,7 +63,7 @@ export function createTestHost(initial: Document) {
     string,
     {
       fingerprint: string;
-      result: Result<Protocol.EditResponseOutput>;
+      result: ResultOf<"notebook.edit">;
       expiresAt: number;
     }
   >();
@@ -92,9 +75,13 @@ export function createTestHost(initial: Document) {
     const version = current.revision.version + 1;
     const matches = (id: Protocol.CellId, etag: string) =>
       etag === "*" || current.cells.get(id)?.etag === etag;
-    const conflict = (change: number, id?: Protocol.CellId) =>
-      rejected(409, "conflict", `Edit conflict at change ${change}`, {
-        change,
+    const conflict = (index: number, id?: Protocol.CellId) =>
+      rejected({
+        type: "urn:marimo:problem:precondition-failed",
+        title: "Precondition failed",
+        status: 412,
+        detail: `Edit conflict at change ${index}`,
+        index,
         cell: id === undefined ? null : (current.cells.get(id) ?? null),
         document: current.revision,
       });
@@ -108,19 +95,21 @@ export function createTestHost(initial: Document) {
               return conflict(index, id);
             }
             if (change.after !== undefined && change.before !== undefined) {
-              return rejected(
-                400,
-                "invalid-request",
-                "A cell cannot name both before and after",
-              );
+              return rejected({
+                type: "urn:marimo:problem:invalid-request",
+                title: "Invalid request",
+                status: 400,
+                detail: "A cell cannot name both before and after",
+              });
             }
             const anchor = change.after ?? change.before;
             if (anchor !== undefined && !order.includes(anchor)) {
-              return rejected(
-                400,
-                "invalid-request",
-                "The placement anchor does not exist",
-              );
+              return rejected({
+                type: "urn:marimo:problem:invalid-request",
+                title: "Invalid request",
+                status: 400,
+                detail: "The placement anchor does not exist",
+              });
             }
             const position =
               anchor === undefined
@@ -157,11 +146,12 @@ export function createTestHost(initial: Document) {
             new Set(change.order).size !== cells.size ||
             change.order.some((id) => !cells.has(id))
           ) {
-            return rejected(
-              400,
-              "invalid-request",
-              "Order must name every cell exactly once",
-            );
+            return rejected({
+              type: "urn:marimo:problem:invalid-request",
+              title: "Invalid request",
+              status: 400,
+              detail: "Order must name every cell exactly once",
+            });
           }
           order = [...change.order];
           break;
@@ -226,16 +216,22 @@ export function createTestHost(initial: Document) {
       if (receipt !== undefined && Date.now() < receipt.expiresAt) {
         return receipt.fingerprint === fingerprint
           ? { result: receipt.result }
-          : rejected(
-              409,
-              "conflict",
-              "Idempotency key was used for another request",
-            );
+          : rejected({
+              type: "urn:marimo:problem:conflict",
+              title: "Conflict",
+              status: 409,
+              detail: "Idempotency key was used for another request",
+            });
       }
       const outcome =
         request.notebookId === current.revision.notebook_id
           ? apply(request.changes)
-          : rejected(404, "not-found", "Notebook does not exist");
+          : rejected({
+              type: "urn:marimo:problem:not-found",
+              title: "Not found",
+              status: 404,
+              detail: "Notebook does not exist",
+            });
       receipts.set(request.idempotencyKey, {
         fingerprint,
         result: outcome.result,

package/src/core/notebook/document/__tests__/test-notebook.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import type { Result } from "@marimo-team/client";
+import type { ResultOf } from "@marimo-team/client";
 import type * as Protocol from "@marimo-team/client/protocol";
 import { atom, type createStore } from "jotai/vanilla";
 import { vi } from "vitest";
@@ -41,8 +41,8 @@ export function createTestNotebook(
       "The test host answers edits that carry a key and a signal",
     );
     signal.throwIfAborted();
-    const reply = new Deferred<Result<Protocol.EditResponseOutput>>();
-    let outcome: Result<Protocol.EditResponseOutput> | undefined;
+    const reply = new Deferred<ResultOf<"notebook.edit">>();
+    let outcome: ResultOf<"notebook.edit"> | undefined;
     const abort = () => reply.reject(signal.reason);
     const finish = () => signal.removeEventListener("abort", abort);
     signal.addEventListener("abort", abort, { once: true });
@@ -112,8 +112,9 @@ export function createTestNotebook(
             kind: "put_cell",
             base_etag: cell.etag,
             cell: {
-              ...cell,
+              id,
               code: cell.code,
+              name: cell.name,
               ...patch,
               config: { ...cell.config, ...patch.config },
             },

package/src/core/notebook/document/sync.ts

@@ -1,6 +1,10 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { idempotencyKey, type Result } from "@marimo-team/client";
+import {
+  type ProblemOf,
+  idempotencyKey,
+  type ResultOf,
+} from "@marimo-team/client";
 import type * as Protocol from "@marimo-team/client/protocol";
 import { type Atom, atom, type createStore } from "jotai/vanilla";
 import type { Document, NotebookBackend } from "../replica";
@@ -18,7 +22,7 @@ export type DocumentSyncStatus =
   | {
       readonly status: "error";
       readonly error: Error;
-      readonly problem?: Protocol.Problem;
+      readonly problem?: ProblemOf<"notebook.edit">;
       readonly retryable: boolean;
     };
 
@@ -30,7 +34,7 @@ interface Submission {
   readonly startedAt: number;
   readonly controller: AbortController;
   response?: Protocol.Document;
-  problem?: Protocol.Problem;
+  problem?: ProblemOf<"notebook.edit">;
 }
 
 // The marimo host retains receipts for five minutes. Stop well before that,
@@ -167,7 +171,7 @@ export function createDocumentSync({
         () => controller.abort(new Error("The edit request timed out")),
         REQUEST_TIMEOUT_MS,
       );
-      let result: Result<Protocol.EditResponseOutput> | undefined;
+      let result: ResultOf<"notebook.edit"> | undefined;
       try {
         signal.throwIfAborted();
         request.controller.signal.throwIfAborted();
@@ -336,7 +340,10 @@ export function createDocumentSync({
     }
     if (active?.problem) {
       const current = store.get(source);
-      const rejectedAt = active.problem.edit?.document.version;
+      const rejectedAt =
+        active.problem.type === "urn:marimo:problem:precondition-failed"
+          ? active.problem.document.version
+          : undefined;
       if (
         !current ||
         current.revision.notebook_id !== active.submission.notebookId ||

package/src/core/notebook/replica/__tests__/fixtures.ts

@@ -30,6 +30,11 @@ export type FakeInput = (
   ...args: Parameters<Commands["input"]>
 ) => ReturnType<Commands["input"]>;
 
+export type FakeInterrupt = (
+  notebookId: Protocol.NotebookId,
+  ...args: Parameters<Commands["interrupt"]>
+) => ReturnType<Commands["interrupt"]>;
+
 /** A backend over `transport` whose commands go to the given fakes. */
 export function fakeBackend({
   transport = async () => undefined,
@@ -37,6 +42,7 @@ export function fakeBackend({
   save = vi.fn<FakeSave>(),
   run = vi.fn<FakeRun>(),
   input = vi.fn<FakeInput>(),
+  interrupt = vi.fn<FakeInterrupt>(),
   checkHealth,
 }: {
   transport?: NotebookTransport;
@@ -44,6 +50,7 @@ export function fakeBackend({
   save?: FakeSave;
   run?: FakeRun;
   input?: FakeInput;
+  interrupt?: FakeInterrupt;
   checkHealth?: () => Promise<boolean>;
 } = {}): NotebookBackend {
   return {
@@ -53,6 +60,7 @@ export function fakeBackend({
       save: (...args) => save(notebookId, ...args),
       run: (...args) => run(notebookId, ...args),
       input: (...args) => input(notebookId, ...args),
+      interrupt: (...args) => interrupt(notebookId, ...args),
     }),
     checkHealth,
   };

package/src/core/notebook/replica/backend.ts

@@ -15,7 +15,7 @@ export interface NotebookBackend {
    */
   notebook(
     id: NotebookId,
-  ): Pick<NotebookClient, "edit" | "save" | "run" | "input">;
+  ): Pick<NotebookClient, "edit" | "save" | "run" | "input" | "interrupt">;
   /** Whether the host is reachable before an explicit reconnect. Absent means always. */
   checkHealth?(): Promise<boolean>;
 }

package/src/core/saving/__tests__/document.test.tsx

@@ -102,7 +102,7 @@ describe("useNotebookDocumentSave", () => {
         ok: false,
         status: 409,
         problem: {
-          type: "about:blank",
+          type: "urn:marimo:problem:conflict",
           title: "Conflict",
           status: 409,
           detail: "storage full",

package/src/core/transports/__tests__/static.test.ts

@@ -199,7 +199,7 @@ describe("static notebook backend", () => {
         ok: false,
         status: 501,
         problem: {
-          type: "tag:marimo.io,2026:host/unsupported-operation",
+          type: "urn:marimo:problem:unsupported-operation",
           title: "Unsupported operation",
           status: 501,
           detail: "Static notebooks do not support mutations",

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

@@ -118,7 +118,7 @@ describe("WASM notebook backend", () => {
         body: operation === "edit" ? { changes: [] } : {},
       });
       const problem = {
-        type: "tag:marimo.io,2026:host/forbidden",
+        type: "urn:marimo:problem:forbidden",
         title: "Forbidden",
         status: 403,
       };

package/src/core/transports/static.ts

@@ -2,6 +2,7 @@
 
 /** A backend that serves a document snapshot without a host. */
 
+import type { Result } from "@marimo-team/client";
 import type * as Protocol from "@marimo-team/client/protocol";
 import type { NotebookBackend } from "../notebook/replica";
 
@@ -150,13 +151,17 @@ export function createStaticNotebookBackend(
         }
       }),
     notebook: () => {
-      const unsupported = async (options?: { signal?: AbortSignal }) => {
+      const unsupported = async (options?: {
+        signal?: AbortSignal;
+      }): Promise<
+        Result<never, Protocol.UnsupportedOperationProblemOutput>
+      > => {
         options?.signal?.throwIfAborted();
         return {
           ok: false as const,
           status: 501,
           problem: {
-            type: "tag:marimo.io,2026:host/unsupported-operation",
+            type: "urn:marimo:problem:unsupported-operation",
             title: "Unsupported operation",
             status: 501,
             detail: "Static notebooks do not support mutations",
@@ -168,6 +173,7 @@ export function createStaticNotebookBackend(
         save: unsupported,
         run: unsupported,
         input: (_inputId, _reply, options) => unsupported(options),
+        interrupt: unsupported,
       };
     },
   };

package/src/core/transports/wasm.ts

@@ -38,9 +38,7 @@ function abortable<T>(
   });
 }
 
-export function createWasmNotebookBackend(
-  bridge: WasmNotebookBridge,
-): NotebookBackend {
+export function createWasmNotebookBackend(bridge: WasmNotebookBridge) {
   return {
     transport: async ({ cursor, signal }, { open, message }) => {
       if (signal.aborted) {
@@ -93,5 +91,5 @@ export function createWasmNotebookBackend(
     },
     notebook: (notebookId) =>
       NotebookClient.unstable_over((call) => bridge.call(call), { notebookId }),
-  };
+  } satisfies NotebookBackend;
 }

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

@@ -16,6 +16,7 @@ const {
   rpcListeners,
   mockNotebookSubscribe,
   mockNotebookUnsubscribe,
+  workerState,
 } = vi.hoisted(() => ({
   mockBridge: vi.fn(),
   mockNotebookReadFile: vi.fn(),
@@ -36,10 +37,11 @@ const {
   >,
   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`
@@ -74,6 +76,9 @@ vi.mock("@/core/wasm/rpc", () => ({
           notebookUnsubscribe: mockNotebookUnsubscribe,
           notebookCall: mockNotebookCall,
           setNotebookLayout: mockSetNotebookLayout,
+          setInterruptBuffer: (buffer: Uint8Array) => {
+            workerState.interruptBuffer = buffer;
+          },
         },
       },
       addMessageListener: (
@@ -102,7 +107,6 @@ 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 { NotebookClient } from "@marimo-team/client";
 import type { NotebookReplica } from "@/core/notebook/replica";
 import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
 import { fallbackFileStore, notebookFileStore } from "../store";
@@ -262,7 +266,7 @@ it("cancels a pending notebook subscription before its RPC response", async () =
   }
 });
 
-it("raises the interrupt buffer for a running run before the worker takes the call", async () => {
+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();
@@ -284,35 +288,117 @@ it("raises the interrupt buffer for a running run before the worker takes the ca
         latest: new Map(),
       }),
     }) as unknown as NotebookReplica;
-  const interrupt = vi
-    .spyOn(PyodideBridge.INSTANCE, "sendInterrupt")
-    .mockResolvedValue(null);
+  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();
-    // The backend narrows the client to editing until the editor runs through the host.
-    const notebook = backend.notebook("n1") as unknown as NotebookClient;
+    const notebook = backend.notebook("n1");
 
     store.set(activeNotebookReplicaAtom, replicaWith("running"));
-    expect((await notebook.interrupt("run-1")).ok).toBe(true);
-    expect(interrupt).toHaveBeenCalledOnce();
+    expect((await notebook.cancel({ runId: "run-1" })).ok).toBe(true);
+    expect(buffer[0]).toBe(2);
     expect(mockNotebookCall).toHaveBeenCalledOnce();
-    expect(interrupt.mock.invocationCallOrder[0]).toBeLessThan(
-      mockNotebookCall.mock.invocationCallOrder[0],
-    );
 
+    buffer[0] = 0;
     store.set(activeNotebookReplicaAtom, replicaWith("queued"));
-    expect((await notebook.interrupt("run-1")).ok).toBe(true);
-    expect(interrupt).toHaveBeenCalledOnce();
+    expect((await notebook.cancel({ runId: "run-1" })).ok).toBe(true);
+    expect(buffer[0]).toBe(0);
     expect(mockNotebookCall).toHaveBeenCalledTimes(2);
   } finally {
-    interrupt.mockRestore();
+    buffer[0] = 0;
     store.set(activeNotebookReplicaAtom, null);
     store.set(initialModeAtom, undefined);
   }
 });
 
-it("raises the interrupt buffer once a run interrupted while queued starts", async () => {
+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;
+    });
+    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();
@@ -333,9 +419,8 @@ it("raises the interrupt buffer once a run interrupted while queued starts", asy
       latest: new Map(),
     }),
   } as unknown as NotebookReplica);
-  const interrupt = vi
-    .spyOn(PyodideBridge.INSTANCE, "sendInterrupt")
-    .mockResolvedValue(null);
+  const buffer = workerState.interruptBuffer!;
+  buffer[0] = 0;
   mockNotebookCall.mockResolvedValue({ status: 202, body: run });
   const deliver = (status: string) =>
     rpcListeners.notebookEvent({
@@ -347,18 +432,19 @@ it("raises the interrupt buffer once a run interrupted while queued starts", asy
     });
   try {
     const backend = await PyodideBridge.INSTANCE.createNotebookBackend();
-    const notebook = backend.notebook("n1") as unknown as NotebookClient;
-    expect((await notebook.interrupt("run-1")).ok).toBe(true);
-    expect(interrupt).not.toHaveBeenCalled();
+    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(interrupt).toHaveBeenCalledOnce();
+    expect(buffer[0]).toBe(2);
+    buffer[0] = 0;
     deliver("running");
     deliver("completed");
-    expect(interrupt).toHaveBeenCalledOnce();
+    expect(buffer[0]).toBe(0);
   } finally {
-    interrupt.mockRestore();
+    buffer[0] = 0;
     store.set(activeNotebookReplicaAtom, null);
     store.set(initialModeAtom, undefined);
   }
@@ -388,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);
+  }
+});