@marimo-team/islands 0.25.3-dev308 → 0.25.3-dev310

package/src/components/editor/output/ansi-reduce.ts

@@ -371,6 +371,8 @@ export class StatefulOutputMessage implements OutputMessage {
   public readonly timestamp: OutputMessage["timestamp"];
   public readonly code: OutputMessage["code"];
   public readonly id: StringOutputMessage["id"];
+  /** The prompt this entry is, when it asks for input. A reply names it. */
+  public readonly input_id: OutputMessage["input_id"];
   private ansiReducer = new AnsiReducer();
   private _data: string;
 
@@ -388,6 +390,7 @@ export class StatefulOutputMessage implements OutputMessage {
       ansiReducer,
       code: message.code,
       id: message.id,
+      input_id: message.input_id,
     });
   }
 
@@ -398,6 +401,7 @@ export class StatefulOutputMessage implements OutputMessage {
     ansiReducer,
     code,
     id,
+    input_id,
   }: {
     mimetype: OutputMessage["mimetype"];
     channel: OutputMessage["channel"];
@@ -405,12 +409,14 @@ export class StatefulOutputMessage implements OutputMessage {
     ansiReducer: AnsiReducer;
     code: OutputMessage["code"];
     id: StringOutputMessage["id"];
+    input_id: OutputMessage["input_id"];
   }) {
     this.mimetype = mimetype;
     this.channel = channel;
     this.timestamp = timestamp;
     this.code = code;
     this.id = id;
+    this.input_id = input_id;
     this.ansiReducer = ansiReducer;
     this._data = this.ansiReducer.render();
   }
@@ -424,6 +430,7 @@ export class StatefulOutputMessage implements OutputMessage {
       ansiReducer: this.ansiReducer,
       code: this.code,
       id: this.id,
+      input_id: this.input_id,
     });
   }
 

package/src/core/ai/__tests__/staged-cells.test.ts

@@ -47,7 +47,7 @@ vi.mock("@/components/editor/cell/useDeleteCell", () => ({
 }));
 
 vi.mock("@/core/network/requests", () => ({
-  getRequestClient: () => ({ sendRun: vi.fn() }),
+  getRequestClient: () => ({}),
 }));
 
 vi.mock("../../codemirror/language/cell-code", () => ({

package/src/core/cells/__tests__/__snapshots__/cells.test.ts.snap

@@ -92,6 +92,7 @@ exports[`cell reducer > can initialize stdin > second stdin requested 1`] = `
       "channel": "stdin",
       "data": "what is your name?",
       "id": 2,
+      "input_id": undefined,
       "mimetype": "text/plain",
       "response": "Marimo!",
       "timestamp": 2,
@@ -132,6 +133,7 @@ exports[`cell reducer > can initialize stdin > stdin answered 1`] = `
       "channel": "stdin",
       "data": "what is your name?",
       "id": 2,
+      "input_id": undefined,
       "mimetype": "text/plain",
       "response": "Marimo!",
       "timestamp": 2,

package/src/core/cells/__tests__/cells.test.ts

@@ -18,11 +18,6 @@ import {
   vi,
 } from "vitest";
 import { MockExecutions } from "@/__mocks__/executions";
-import {
-  notebookQueuedOrRunningCountAtom,
-  submitCells,
-} from "@/core/executions";
-import { store } from "@/core/state/jotai";
 import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
 import type { CellHandle } from "@/components/editor/notebook-cell";
@@ -1109,15 +1104,6 @@ describe("cell reducer", () => {
       expect(handleAtom2).toBe(handleAtom1);
     });
   });
-  it("withdraws the submission of a cell that leaves the document", () => {
-    MockExecutions.seed(store, []);
-    submitCells(store, [firstCellId]);
-    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(1);
-
-    actions.reconcileDocument({ order: [], cells: new Map() });
-
-    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
-  });
 });
 
 describe("createTracebackInfoAtom", () => {

package/src/core/cells/__tests__/collapseConsoleOutputs.test.ts

@@ -759,3 +759,18 @@ describe("collapseConsoleOutputs", () => {
     });
   });
 });
+
+it("keeps a prompt's input id when the entry becomes stateful", () => {
+  const prompt: OutputMessage = {
+    channel: "stdin",
+    mimetype: "text/plain",
+    data: "Name: ",
+    timestamp: 1,
+    input_id: "prompt-1",
+  };
+
+  const [collapsed] = collapseConsoleOutputs([prompt]);
+
+  expect(collapsed.input_id).toBe("prompt-1");
+  expect(collapsed.channel).toBe("stdin");
+});

package/src/core/cells/__tests__/utils.test.ts

@@ -131,7 +131,7 @@ describe("staleCellIds with a run in progress", () => {
     const state = notebook(cells);
     const ran = MockExecutions.completed("cell1");
     const executions = MockExecutions.inputs([ran], {
-      submissions: new Map([["cell1", ran.id]]),
+      requested: new Set(["cell1"]),
     });
 
     expect(staleCellIds(state, executions, freshness(cells))).toEqual([]);

package/src/core/cells/add-missing-import.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { getRequestClient } from "../network/requests";
+import { runCells } from "../executions";
 import { store } from "../state/jotai";
 import { variablesAtom } from "../variables/state";
 import { notebookAtom } from "./cells";
@@ -124,10 +124,7 @@ function addImport({
       });
       newCellId = created === null ? null : id;
       if (autoInstantiate && newCellId !== null) {
-        void getRequestClient().sendRun({
-          cellIds: [newCellId],
-          codes: [importStatement],
-        });
+        void runCells(store, [newCellId]);
       }
     },
   });

package/src/core/cells/cell.ts

@@ -72,6 +72,7 @@ export function transitionCell(
           data: output.data,
           timestamp: output.timestamp,
           id: output.id,
+          input_id: output.input_id,
           response: output.response ?? "",
         };
       }

package/src/core/cells/cells.ts

@@ -10,7 +10,6 @@ import {
   cellExecutionInputsAtom,
   cellExecutionView,
   cellFreshnessAtom,
-  withdrawCells,
 } from "@/core/executions";
 import type { CellColumnId } from "./layout";
 import { invariant } from "@/utils/invariant";
@@ -218,6 +217,7 @@ const {
           data: stdinOutput.data,
           timestamp: stdinOutput.timestamp,
           id: stdinOutput.id,
+          input_id: stdinOutput.input_id,
           // An empty response resolves the prompt without retaining the secret.
           response: stdinOutput.mimetype === "text/password" ? "" : response,
         };
@@ -550,7 +550,6 @@ export function releaseCellAtoms(cellId: CellId) {
   cellDataAtom.remove(cellId);
   cellRuntimeAtom.remove(cellId);
   cellHandleAtom.remove(cellId);
-  withdrawCells(store, [cellId]);
 }
 
 /** Subscribes to reactive updates of the cell's data. */

package/src/core/executions/__tests__/atoms.test.ts

@@ -4,16 +4,49 @@ import { createStore } from "jotai";
 import { describe, expect, it } from "vitest";
 import { MockExecutions } from "@/__mocks__/executions";
 import { cellId } from "@/__tests__/branded";
+import type * as Protocol from "@marimo-team/client/protocol";
 import type { CellMessage } from "@/core/kernel/messages";
 import {
+  document as documentOf,
+  withCells,
+} from "@/core/notebook/document/__tests__/fixtures";
+import type { Executions } from "@/core/notebook/replica";
+import {
+  acceptRun,
   cellExecutionInputsAtom,
   notebookQueuedOrRunningCountAtom,
   observeCellMessage,
-  submitCells,
+  requestRun,
+  type RunRequest,
+  withdrawRequest,
 } from "../atoms";
 import { cellExecutionView } from "../select";
 
 const C1 = cellId("c1");
+const C2 = cellId("c2");
+
+type Store = ReturnType<typeof createStore>;
+
+function run(
+  cells: Protocol.CellId[],
+  status: Protocol.Run["status"] = "queued",
+  id = "run-1",
+): Protocol.Run {
+  return {
+    id,
+    notebook_id: "n1",
+    runtime_id: "r1",
+    cells,
+    status,
+    outcome: status === "completed" ? "succeeded" : null,
+    started_at: null,
+    completed_at: null,
+  };
+}
+
+function withRuns(executions: Executions, runs: Protocol.Run[]): Executions {
+  return { ...executions, runs: new Map(runs.map((r) => [r.id, r])) };
+}
 
 function cellOp(status: CellMessage["status"]): CellMessage {
   return {
@@ -25,14 +58,83 @@ function cellOp(status: CellMessage["status"]): CellMessage {
   };
 }
 
-describe("observeCellMessage", () => {
-  it("withdraws a submission once the kernel reports the cell blocked", () => {
+/** A store whose replica shows the two-cell fixture document. */
+function shown() {
+  const store = createStore();
+  const replica = MockExecutions.seed(store, [], null, documentOf());
+  return { store, replica };
+}
+
+function request(store: Store, cells: Protocol.CellId[]): RunRequest {
+  const made = requestRun(store, cells);
+  if (made === null) {
+    throw new Error("no notebook is shown");
+  }
+  return made;
+}
+
+function statusOf(store: Store, id = C1) {
+  return cellExecutionView(store.get(cellExecutionInputsAtom), id).status;
+}
+
+function requested(store: Store) {
+  return [...store.get(cellExecutionInputsAtom).requested];
+}
+
+describe("requestRun", () => {
+  it("reads the cells as queued until the request is withdrawn", () => {
+    const { store } = shown();
+    const made = request(store, [C1, C2]);
+    expect(statusOf(store, C1)).toBe("queued");
+    expect(statusOf(store, C2)).toBe("queued");
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(2);
+
+    withdrawRequest(store, made);
+
+    expect(statusOf(store, C1)).toBe("idle");
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+
+  it("records nothing while no notebook is shown", () => {
     const store = createStore();
-    MockExecutions.seed(store, []);
-    submitCells(store, [C1]);
-    expect(
-      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
-    ).toBe("queued");
+    const replica = MockExecutions.seed(store, [], null, documentOf());
+    store.set(replica.notebookAtom, null);
+
+    expect(requestRun(store, [C1])).toBeNull();
+    expect(statusOf(store)).toBe("idle");
+  });
+
+  it("stops showing a requested cell that leaves the document", () => {
+    const { store, replica } = shown();
+    request(store, [C1]);
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(1);
+
+    store.set(replica.documentAtom, withCells(documentOf(), { c1: null }));
+
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+
+  it("forgets requests and blocked cells with the notebook they were made in", () => {
+    const { store, replica } = shown();
+    request(store, [C1]);
+    observeCellMessage(store, {
+      ...cellOp("disabled-transitively"),
+      cell_id: C2,
+    });
+
+    store.set(replica.notebookAtom, MockExecutions.notebook("n2"));
+
+    expect(requested(store)).toEqual([]);
+    expect(statusOf(store)).toBe("idle");
+    expect(store.get(cellExecutionInputsAtom).blocked.size).toBe(0);
+  });
+});
+
+describe("observeCellMessage", () => {
+  it("does not show a requested cell as queued once the kernel reports it blocked", () => {
+    const { store } = shown();
+    request(store, [C1]);
+    expect(statusOf(store)).toBe("queued");
 
     observeCellMessage(store, cellOp("disabled-transitively"));
 
@@ -42,13 +144,12 @@ describe("observeCellMessage", () => {
     expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
   });
 
-  it("forgets submissions and blocked cells with the replica they were made for", () => {
-    const store = createStore();
-    MockExecutions.seed(store, []);
-    submitCells(store, [C1]);
+  it("forgets requests and blocked cells with the replica they were made for", () => {
+    const { store } = shown();
+    request(store, [C1]);
     observeCellMessage(store, cellOp("disabled-transitively"));
 
-    MockExecutions.seed(store, []);
+    MockExecutions.seed(store, [], null, documentOf());
 
     const view = cellExecutionView(store.get(cellExecutionInputsAtom), C1);
     expect(view.status).toBe("idle");
@@ -56,43 +157,126 @@ describe("observeCellMessage", () => {
     expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
   });
 
-  it("keeps a submission while the cell is merely queued", () => {
-    const store = createStore();
-    MockExecutions.seed(store, []);
-    submitCells(store, [C1]);
+  it("keeps a request while the cell is merely queued", () => {
+    const { store } = shown();
+    request(store, [C1]);
 
     observeCellMessage(store, cellOp("queued"));
 
-    expect(
-      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
-    ).toBe("queued");
+    expect(statusOf(store)).toBe("queued");
   });
+});
 
-  it("forgets acknowledged submissions and blocked cells when the replica follows a new notebook", () => {
-    const store = createStore();
-    const replica = MockExecutions.seed(store, []);
-    submitCells(store, [C1]);
-    observeCellMessage(store, {
-      ...cellOp("disabled-transitively"),
-      cell_id: cellId("c2"),
-    });
+describe("acceptRun", () => {
+  it("hands the request over to the run once the stream shows it", () => {
+    const { store, replica } = shown();
+    const made = request(store, [C1]);
+    acceptRun(store, made, run([C1]));
+    expect(statusOf(store)).toBe("queued");
+    expect(requested(store)).toEqual([C1]);
 
-    const completed = MockExecutions.inputs([MockExecutions.completed(C1)]);
-    store.set(replica.executionsAtom, completed.executions);
-    store.set(replica.resultsAtom, completed.results);
-    expect(
-      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
-    ).toBe("idle");
-
-    const empty = MockExecutions.inputs([]);
-    store.set(replica.executionsAtom, empty.executions);
-    store.set(replica.resultsAtom, empty.results);
-    store.set(replica.notebookAtom, {
-      ...store.get(replica.notebookAtom),
-      id: "n2",
-    });
+    // The response landed first, and the run event follows.
+    const stream = store.get(replica.executionsAtom);
+    store.set(replica.executionsAtom, withRuns(stream, [run([C1])]));
+    expect(requested(store)).toEqual([]);
+    expect(statusOf(store)).toBe("queued");
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(1);
 
-    expect(store.get(cellExecutionInputsAtom)).toEqual(empty);
+    // The run ends without ever planning the cell.
+    store.set(
+      replica.executionsAtom,
+      withRuns(stream, [run([C1], "completed")]),
+    );
+    expect(statusOf(store)).toBe("idle");
     expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
   });
+
+  it("hands over at once when the stream showed the run first", () => {
+    const { store, replica } = shown();
+    const made = request(store, [C1]);
+    const stream = store.get(replica.executionsAtom);
+    store.set(replica.executionsAtom, withRuns(stream, [run([C1])]));
+
+    acceptRun(store, made, run([C1]));
+
+    expect(requested(store)).toEqual([]);
+    expect(statusOf(store)).toBe("queued");
+  });
+
+  it("leaves a later request for the same cell when an earlier run ends", () => {
+    const { store, replica } = shown();
+    const first = request(store, [C1]);
+    const second = request(store, [C1]);
+    acceptRun(store, first, run([C1]));
+
+    const stream = store.get(replica.executionsAtom);
+    store.set(replica.executionsAtom, withRuns(stream, [run([C1])]));
+    expect(requested(store)).toEqual([C1]);
+    store.set(
+      replica.executionsAtom,
+      withRuns(stream, [run([C1], "completed")]),
+    );
+    expect(statusOf(store)).toBe("queued");
+
+    acceptRun(store, second, run([C1], "queued", "run-2"));
+    store.set(
+      replica.executionsAtom,
+      withRuns(stream, [run([C1], "completed"), run([C1], "queued", "run-2")]),
+    );
+    expect(requested(store)).toEqual([]);
+    expect(statusOf(store)).toBe("queued");
+
+    store.set(
+      replica.executionsAtom,
+      withRuns(stream, [run([C1], "completed", "run-2")]),
+    );
+    expect(statusOf(store)).toBe("idle");
+  });
+
+  it("keeps waiting while the stream is between a reset and its snapshot", () => {
+    const { store, replica } = shown();
+    const made = request(store, [C1]);
+    acceptRun(store, made, run([C1]));
+
+    const notebook = store.get(replica.notebookAtom);
+    store.set(replica.notebookAtom, null);
+    const stream = store.get(replica.executionsAtom);
+    store.set(replica.executionsAtom, { ...stream });
+    store.set(replica.notebookAtom, notebook);
+    expect(requested(store)).toEqual([C1]);
+    expect(statusOf(store)).toBe("queued");
+
+    store.set(replica.executionsAtom, withRuns(stream, [run([C1])]));
+    expect(requested(store)).toEqual([]);
+    expect(statusOf(store)).toBe("queued");
+  });
+
+  it("drops the request once the replica shows another notebook", () => {
+    const { store, replica } = shown();
+    const made = request(store, [C1]);
+    acceptRun(store, made, run([C1]));
+
+    store.set(replica.notebookAtom, MockExecutions.notebook("n2"));
+    const stream = store.get(replica.executionsAtom);
+    store.set(replica.executionsAtom, withRuns(stream, [run([C1])]));
+    store.set(replica.notebookAtom, MockExecutions.notebook("n1"));
+
+    expect(requested(store)).toEqual([]);
+  });
+
+  it("stops following a run once the replica changes", () => {
+    const { store, replica } = shown();
+    const made = request(store, [C1]);
+    acceptRun(store, made, run([C1]));
+
+    MockExecutions.seed(store, [], null, documentOf());
+    request(store, [C1]);
+    const stream = store.get(replica.executionsAtom);
+    store.set(
+      replica.executionsAtom,
+      withRuns(stream, [run([C1], "completed")]),
+    );
+
+    expect(statusOf(store)).toBe("queued");
+  });
 });

package/src/core/executions/__tests__/hooks.test.tsx

@@ -143,8 +143,7 @@ describe("useCellOutput", () => {
     expect(result.current).toBeNull();
 
     act(() => {
-      const notebook = store.get(replica.notebookAtom);
-      store.set(replica.notebookAtom, { ...notebook, id: "n2" });
+      store.set(replica.notebookAtom, MockExecutions.notebook("n2"));
     });
     expect(result.current?.data).toBe("c1 value");
   });

package/src/core/executions/__tests__/input.test.ts

@@ -0,0 +1,86 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { MockExecutions } from "@/__mocks__/executions";
+import { document as documentOf } from "@/core/notebook/document/__tests__/fixtures";
+import {
+  type FakeInput,
+  fakeBackend,
+} from "@/core/notebook/replica/__tests__/fixtures";
+import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
+import { store } from "@/core/state/jotai";
+import { replyInput } from "../input";
+
+const toast = vi.fn();
+vi.mock("@/components/ui/use-toast", () => ({
+  toast: (...args: unknown[]) => toast(...args),
+}));
+
+describe("replyInput", () => {
+  let input: ReturnType<typeof vi.fn<FakeInput>>;
+
+  beforeEach(() => {
+    toast.mockClear();
+    input = vi.fn<FakeInput>(async (_notebookId, inputId) => ({
+      ok: true,
+      status: 200,
+      data: {
+        id: inputId,
+        execution_id: "e1",
+        seq: 0,
+        prompt: "Name: ",
+        password: false,
+        status: "answered",
+      },
+    }));
+    const replica = MockExecutions.seed(
+      store,
+      [],
+      MockExecutions.runtime("running"),
+      documentOf(),
+    );
+    store.set(replica.backendAtom, fakeBackend({ input }));
+  });
+
+  afterEach(() => {
+    store.set(activeNotebookReplicaAtom, null);
+  });
+
+  it("answers the prompt by id in the connected notebook", async () => {
+    await replyInput(store, "prompt-1", "marimo");
+
+    expect(input).toHaveBeenCalledWith("n1", "prompt-1", { value: "marimo" });
+    expect(toast).not.toHaveBeenCalled();
+  });
+
+  it("reports a reply the host refuses", async () => {
+    input.mockResolvedValue({
+      ok: false,
+      status: 409,
+      problem: {
+        type: "tag:marimo.io,2026:host/conflict",
+        title: "Conflict",
+        status: 409,
+        detail: "input prompt-1 has already ended.",
+      },
+    });
+
+    await replyInput(store, "prompt-1", "marimo");
+
+    expect(toast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Failed to send input",
+        description: "input prompt-1 has already ended.",
+      }),
+    );
+  });
+
+  it("does nothing without a connected notebook", async () => {
+    store.set(activeNotebookReplicaAtom, null);
+
+    await replyInput(store, "prompt-1", "marimo");
+
+    expect(input).not.toHaveBeenCalled();
+    expect(toast).not.toHaveBeenCalled();
+  });
+});