@marimo-team/islands 0.25.3-dev275 → 0.25.3-dev279

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.25.3-dev275",
+  "version": "0.25.3-dev279",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/__mocks__/executions.ts

@@ -8,6 +8,7 @@ import type { CellExecutionInputs } from "@/core/executions";
 import {
   ConnectionState,
   type ConnectionStatus,
+  type Document,
   type Execution,
   type Executions,
   type NotebookReplica,
@@ -162,16 +163,16 @@ export const MockExecutions = {
     };
   },
 
-  /** Make the store's active replica report `records` and `runtime`. */
+  /** Make the store's active replica report `records`, `runtime`, and `document`. */
   seed(
     store: Store,
     records: Protocol.Execution[],
     runtime: Protocol.Runtime | null = null,
+    document: Document | null = null,
   ) {
     const current = store.get(activeNotebookReplicaAtom);
     const replica = {
       connectionAtom: atom<ConnectionStatus>({ state: ConnectionState.OPEN }),
-      documentAtom: atom(null),
       backendAtom: atom(null),
       attachmentsAtom: atom([]),
       connect: () => () => undefined,
@@ -185,6 +186,7 @@ export const MockExecutions = {
         operations: [],
         updated_at: null,
       }),
+      documentAtom: atom<Document | null>(document),
       runtimeAtom: atom(runtime),
       executionsAtom: atom(mirror(records)),
       resultsAtom: atom(results(records)),

package/src/__mocks__/notebook.ts

@@ -39,8 +39,6 @@ export const MockNotebook = {
           expand_output: false,
           ...data.config,
         },
-        edited: false,
-        lastCodeRun: null,
         serializedEditorState: null,
         ...data,
       })),

package/src/__tests__/CellStatus.test.tsx

@@ -3,6 +3,7 @@
 import { render } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { TooltipProvider } from "@/components/ui/tooltip";
+import type { CellFreshness } from "@/core/executions";
 import { formatElapsedTime, type Milliseconds } from "@/utils/time";
 import {
   CellStatusComponent,
@@ -70,9 +71,8 @@ describe("CellStatusComponent", () => {
   // Base props that will be modified for different test cases
   const baseProps = {
     editing: true,
-    edited: false,
     disabled: false,
-    staleInputs: false,
+    freshness: { sourceChanged: false, inputsChanged: false } as CellFreshness,
     status: "idle" as const,
     interrupted: false,
     elapsedTime: null,
@@ -94,7 +94,7 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       disabled: true,
-      staleInputs: true,
+      freshness: { sourceChanged: false, inputsChanged: true } as CellFreshness,
       startedAt: 1_704_096_000_000 as Milliseconds, // Jan 1, 2024 12:00:00
     };
 
@@ -140,7 +140,7 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       blocked: true,
-      staleInputs: true,
+      freshness: { sourceChanged: false, inputsChanged: true } as CellFreshness,
       startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
@@ -215,7 +215,7 @@ describe("CellStatusComponent", () => {
   test("renders edited state", () => {
     const props = {
       ...baseProps,
-      edited: true,
+      freshness: { sourceChanged: true, inputsChanged: false } as CellFreshness,
       elapsedTime: 1500 as Milliseconds,
       startedAt: 1_704_096_000_000 as Milliseconds,
     };
@@ -231,7 +231,7 @@ describe("CellStatusComponent", () => {
   test("renders stale inputs state", () => {
     const props = {
       ...baseProps,
-      staleInputs: true,
+      freshness: { sourceChanged: false, inputsChanged: true } as CellFreshness,
       elapsedTime: 1500 as Milliseconds,
       startedAt: 1_704_096_000_000 as Milliseconds,
     };

package/src/components/editor/__tests__/data-attributes.test.tsx

@@ -93,7 +93,6 @@ describe("Cell data attributes", () => {
           [cid]: {
             code: "",
             name: cellName,
-            edited: false,
             config: {
               disabled: false,
               hide_code: false,
@@ -106,7 +105,6 @@ describe("Cell data attributes", () => {
       notebook.cellRuntime[cid] = createCellRuntimeState({
         output: null,
         consoleOutputs: [],
-        staleInputs: false,
         debuggerActive: false,
         outline: null,
       });

package/src/components/editor/__tests__/output-persistence.test.tsx

@@ -11,6 +11,11 @@ import { cellId } from "@/__tests__/branded";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { notebookAtom } from "@/core/cells/cells";
 import { DocumentProvider } from "@/core/notebook/document";
+import {
+  cell,
+  document as documentOf,
+  withCells,
+} from "@/core/notebook/document/__tests__/fixtures";
 import type { CellRuntimeState } from "@/core/cells/types";
 import { createCellRuntimeState } from "@/core/cells/types";
 import { defaultUserConfig } from "@/core/config/config-schema";
@@ -41,7 +46,6 @@ function seedNotebook(
       [cid]: {
         code: "1 + 1",
         name: "test_cell",
-        edited: false,
         config: {
           disabled: false,
           hide_code: false,
@@ -188,11 +192,22 @@ describe("output persistence across mode changes", () => {
 
   it("does not dim edited-but-not-run outputs as stale while presenting", () => {
     const { store, wrapper } = createTestWrapper();
+    // The host holds newer source than the cell last ran with
+    MockExecutions.seed(
+      store,
+      [MockExecutions.completed(cid, { code_fingerprint: "ran" })],
+      null,
+      withCells(
+        documentOf(),
+        {
+          c1: null,
+          c2: null,
+          [cid]: cell(cid, "1 + 1", { code_fingerprint: "edited" }),
+        },
+        [cid],
+      ),
+    );
     seedNotebook(store);
-    // Mark the cell as edited without re-running it
-    const notebook = store.get(notebookAtom);
-    notebook.cellData[cid] = { ...notebook.cellData[cid], edited: true };
-    store.set(notebookAtom, { ...notebook });
 
     const { container, rerender } = render(renderCell("edit"), { wrapper });
     expect(container.querySelector(".marimo-output-stale")).toBeTruthy();

package/src/components/editor/cell/CellStatus.tsx

@@ -7,7 +7,7 @@ import {
 } from "lucide-react";
 import { useDateFormatter } from "react-aria";
 import { MultiIcon } from "@/components/icons/multi-icon";
-import type { CellRunStatus } from "@/core/executions";
+import type { CellFreshness, CellRunStatus } from "@/core/executions";
 import { Logger } from "@/utils/Logger";
 import { useElapsedTime } from "../../../hooks/useElapsedTime";
 import { Tooltip } from "../../ui/tooltip";
@@ -18,11 +18,11 @@ import { formatElapsedTime, type Milliseconds, Time } from "@/utils/time";
 
 export interface CellStatusComponentProps {
   editing: boolean;
-  edited: boolean;
   disabled: boolean;
   /** Whether a cell it depends on is disabled. */
   blocked: boolean;
-  staleInputs: boolean;
+  /** Whether the cell's result is current. */
+  freshness: CellFreshness;
   status: CellRunStatus;
   /** Whether the cell's last run was interrupted. */
   interrupted: boolean;
@@ -38,8 +38,7 @@ export const CellStatusComponent: React.FC<CellStatusComponentProps> = ({
   status,
   disabled,
   blocked,
-  staleInputs,
-  edited,
+  freshness,
   interrupted,
   elapsedTime,
   startedAt,
@@ -48,6 +47,8 @@ export const CellStatusComponent: React.FC<CellStatusComponentProps> = ({
   if (!editing) {
     return null;
   }
+  const edited = freshness.sourceChanged;
+  const staleInputs = freshness.inputsChanged;
 
   const lastRanTime = startedAt ? (
     <LastRanTime lastRanTime={startedAt} />

package/src/components/editor/cell/__tests__/useRunCells.test.tsx

@@ -0,0 +1,169 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { act, renderHook } from "@testing-library/react";
+import { Provider } from "jotai";
+import type { ReactNode } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { MockExecutions } from "@/__mocks__/executions";
+import { MockNotebook } from "@/__mocks__/notebook";
+import { MockRequestClient } from "@/__mocks__/requests";
+import { cellId } from "@/__tests__/branded";
+import { notebookAtom } from "@/core/cells/cells";
+import {
+  cellExecutionInputsAtom,
+  cellExecutionView,
+  notebookQueuedOrRunningCountAtom,
+} from "@/core/executions";
+import { requestClientAtom } from "@/core/network/requests";
+import type { DocumentModel } from "@/core/notebook/document";
+import {
+  cell,
+  document as documentOf,
+  withCells,
+} from "@/core/notebook/document/__tests__/fixtures";
+import { activeDocumentModelAtom } from "@/core/session/active-notebook";
+import { store } from "@/core/state/jotai";
+import { runCells, useRunStaleCells } from "../useRunCells";
+
+const ENABLED = cellId("enabled");
+const DISABLED = cellId("disabled");
+
+describe("runCells", () => {
+  it("sends a disabled cell to the kernel without reading it as queued", async () => {
+    MockExecutions.seed(store, []);
+    const notebook = MockNotebook.notebookState({
+      cellData: {
+        [ENABLED]: { code: "x = 1" },
+        [DISABLED]: { code: "y = 2", config: { disabled: true } },
+      },
+    });
+    const sendRun = vi.fn(async () => null);
+
+    await runCells({
+      cellIds: [ENABLED, DISABLED],
+      sendRun,
+      prepareForRun: vi.fn(),
+      notebook,
+    });
+
+    expect(sendRun).toHaveBeenCalledWith({
+      cellIds: [ENABLED, DISABLED],
+      codes: ["x = 1", "y = 2"],
+    });
+    const inputs = store.get(cellExecutionInputsAtom);
+    expect(cellExecutionView(inputs, ENABLED).status).toBe("queued");
+    expect(cellExecutionView(inputs, DISABLED).status).toBe("idle");
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(1);
+  });
+});
+
+describe("useRunStaleCells", () => {
+  const C1 = cellId("c1");
+  const C2 = cellId("c2");
+
+  afterEach(() => {
+    store.set(activeDocumentModelAtom, null);
+  });
+
+  it("flushes pending edits before choosing the stale cells", async () => {
+    const document = documentOf();
+    const replica = MockExecutions.seed(
+      store,
+      [
+        MockExecutions.completed(C1, { code_fingerprint: "c1-hash" }),
+        MockExecutions.completed(C2, { code_fingerprint: "c2-hash" }),
+      ],
+      null,
+      document,
+    );
+    store.set(
+      notebookAtom,
+      MockNotebook.notebookState({
+        cellData: { [C1]: { code: "x = 2" }, [C2]: { code: "y = 2" } },
+      }),
+    );
+    const client = MockRequestClient.create();
+    store.set(requestClientAtom, client);
+    // The edit to c1 is still in flight: the host confirms it on flush.
+    const flush = vi.fn(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      store.set(
+        replica.documentAtom,
+        withCells(document, {
+          [C1]: cell(C1, "x = 2", { code_fingerprint: "c1-hash-2" }),
+        }),
+      );
+    });
+    store.set(activeDocumentModelAtom, { flush } as unknown as DocumentModel);
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <Provider store={store}>{children}</Provider>
+    );
+    const { result } = renderHook(useRunStaleCells, { wrapper });
+
+    await act(() => result.current());
+
+    expect(flush).toHaveBeenCalledOnce();
+    expect(client.sendRun).toHaveBeenCalledWith({
+      cellIds: [C1],
+      codes: ["x = 2"],
+    });
+  });
+
+  it("does nothing when the notebook changed while the flush was pending", async () => {
+    MockExecutions.seed(
+      store,
+      [MockExecutions.completed(C1, { code_fingerprint: "stale" })],
+      null,
+      documentOf(),
+    );
+    store.set(
+      notebookAtom,
+      MockNotebook.notebookState({ cellData: { [C1]: { code: "x = 1" } } }),
+    );
+    const client = MockRequestClient.create();
+    store.set(requestClientAtom, client);
+    const flush = vi.fn(async () => {
+      store.set(activeDocumentModelAtom, null);
+      throw new Error("aborted");
+    });
+    store.set(activeDocumentModelAtom, { flush } as unknown as DocumentModel);
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <Provider store={store}>{children}</Provider>
+    );
+    const { result } = renderHook(useRunStaleCells, { wrapper });
+
+    await act(() => result.current());
+
+    expect(client.sendRun).not.toHaveBeenCalled();
+  });
+
+  it("still runs what is stale when the flush fails", async () => {
+    MockExecutions.seed(
+      store,
+      [MockExecutions.completed(C1, { code_fingerprint: "stale" })],
+      null,
+      documentOf(),
+    );
+    store.set(
+      notebookAtom,
+      MockNotebook.notebookState({ cellData: { [C1]: { code: "x = 1" } } }),
+    );
+    const client = MockRequestClient.create();
+    store.set(requestClientAtom, client);
+    const flush = vi.fn(async () => {
+      throw new Error("offline");
+    });
+    store.set(activeDocumentModelAtom, { flush } as unknown as DocumentModel);
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <Provider store={store}>{children}</Provider>
+    );
+    const { result } = renderHook(useRunStaleCells, { wrapper });
+
+    await act(() => result.current());
+
+    expect(client.sendRun).toHaveBeenCalledWith({
+      cellIds: [C1],
+      codes: ["x = 1"],
+    });
+  });
+});

package/src/components/editor/cell/collapse.tsx

@@ -14,11 +14,10 @@ import { memo } from "react";
 import { Toolbar } from "@/components/layout/toolbar";
 import { Button } from "@/components/ui/button";
 import { Tooltip } from "@/components/ui/tooltip";
-import { useNotebook } from "@/core/cells/cells";
 import { columnOf, useLayout } from "@/core/cells/layout";
 import type { CellId } from "@/core/cells/ids";
 import { getDescendantsStatus } from "@/core/cells/utils";
-import { cellExecutionInputsAtom } from "@/core/executions";
+import { cellExecutionInputsAtom, cellFreshnessAtom } from "@/core/executions";
 import { cn } from "@/utils/cn";
 
 interface Props {
@@ -66,12 +65,12 @@ export const CollapsedCellBanner: React.FC<{
   cellId: CellId;
   count: number;
 }> = memo(({ onClick, count, cellId }) => {
-  const notebook = useNotebook();
   const executions = useAtomValue(cellExecutionInputsAtom);
+  const freshness = useAtomValue(cellFreshnessAtom);
   const layout = useLayout();
   const states = getDescendantsStatus(
-    notebook,
     executions,
+    freshness,
     columnOf(layout, cellId).folds.get(cellId) ?? [],
   );
 

package/src/components/editor/cell/useRunCells.ts

@@ -3,12 +3,14 @@
 import { closeCompletion } from "@codemirror/autocomplete";
 import { atom, useSetAtom } from "jotai";
 import useEvent from "react-use-event-hook";
+import { toast } from "@/components/ui/use-toast";
 import { getNotebook, type NotebookState } from "@/core/cells/cells";
 import { useCellActions } from "@/core/cells/actions";
 import type { CellId } from "@/core/cells/ids";
 import { enabledCellIds, staleCellIds } from "@/core/cells/utils";
 import {
   cellExecutionInputsAtom,
+  cellFreshnessAtom,
   submitCells,
   withdrawCells,
 } from "@/core/executions";
@@ -16,6 +18,7 @@ import { getCurrentLanguageAdapter } from "@/core/codemirror/language/commands";
 import { getEditorCodeAsPython } from "@/core/codemirror/language/utils";
 import { useRequestClient } from "@/core/network/requests";
 import type { ExecuteCellsRequest } from "@/core/network/types";
+import { activeDocumentModelAtom } from "@/core/session/active-notebook";
 import { store } from "@/core/state/jotai";
 import { Logger } from "@/utils/Logger";
 
@@ -26,9 +29,35 @@ export const hasRunAnyCellAtom = atom<boolean>(false);
  */
 export function useRunStaleCells() {
   const runCells = useRunCells();
-  const runStaleCells = useEvent(() =>
-    runCells(staleCellIds(getNotebook(), store.get(cellExecutionInputsAtom))),
-  );
+  const runStaleCells = useEvent(async () => {
+    // Freshness reads the confirmed document, so an edit still in flight
+    // reaches the host before the stale cells are chosen.
+    const model = store.get(activeDocumentModelAtom);
+    try {
+      await model?.flush();
+    } catch (error) {
+      if (store.get(activeDocumentModelAtom) !== model) {
+        return;
+      }
+      Logger.warn("Running stale cells with unsynced edits", error);
+      toast({
+        title: "Edits not yet synced",
+        description: "Stale cells were chosen from the last synced source.",
+        variant: "danger",
+      });
+    }
+    // The request was for the notebook that was open when it was made.
+    if (store.get(activeDocumentModelAtom) !== model) {
+      return;
+    }
+    return runCells(
+      staleCellIds(
+        getNotebook(),
+        store.get(cellExecutionInputsAtom),
+        store.get(cellFreshnessAtom),
+      ),
+    );
+  });
   return runStaleCells;
 }
 

package/src/components/editor/errors/__tests__/send-error-report-button.test.tsx

@@ -418,7 +418,7 @@ describe("SendErrorReportButton", () => {
         store.set(
           notebookAtom,
           MockNotebook.notebookState({
-            cellData: { [CELL_ID]: { code: CODE, lastCodeRun: CODE } },
+            cellData: { [CELL_ID]: { code: CODE } },
             cellRuntime: { [CELL_ID]: { output } },
           }),
         );
@@ -429,7 +429,6 @@ describe("SendErrorReportButton", () => {
             [CELL_ID]: {
               ...state.cellData[CELL_ID],
               code: "print('edited')",
-              edited: true,
             },
           },
         }));
@@ -466,7 +465,7 @@ describe("SendErrorReportButton", () => {
       notebookAtom,
       MockNotebook.notebookState({
         cellData: {
-          [CELL_ID]: { code: "unrelated edit", lastCodeRun: "older run" },
+          [CELL_ID]: { code: "unrelated edit" },
         },
         cellRuntime: {
           [CELL_ID]: {