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

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

@@ -173,7 +173,6 @@ describe("cell reducer", () => {
             ...config,
             ...(hideCode != null && { hide_code: hideCode }),
           }),
-          edited: Boolean(code),
         }),
       },
       cellRuntime: { ...state.cellRuntime, [id]: createCellRuntimeState() },
@@ -206,16 +205,6 @@ describe("cell reducer", () => {
     });
   }
 
-  /** Format a cell's code, as the editor reports it. */
-  function formatCode(cellId: CellId, code: string) {
-    actions.codeFormatted({
-      cellId,
-      before: state.cellData[cellId].code,
-      after: code,
-    });
-    editCode(cellId, code);
-  }
-
   let i = 0;
   const originalCreate = CellId.create.bind(CellId);
 
@@ -288,7 +277,6 @@ describe("cell reducer", () => {
       timestamp: 2,
     });
     const runtime = state.cellRuntime[firstCellId];
-    expect(state.cellData[firstCellId].lastCodeRun).toBe("print('new code')");
     expect(runtime.output).toEqual(output);
     expect(runtime.consoleOutputs[0].code).toBe(code);
     expect(runtime.consoleOutputs[0].data).toContain("old failure");
@@ -299,15 +287,11 @@ describe("cell reducer", () => {
     /////////////////
     // Initial state
     let cell = cells[0];
-    expect(cell.lastCodeRun).toBe(null);
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("initial state");
 
     // Update code
     editCode(firstCellId, "import marimo as mo");
     cell = cells[0];
-    expect(cell.lastCodeRun).toBe(null);
-    expect(cell.edited).toBe(true);
     expect(cell).toMatchSnapshot("code edited");
 
     // Prepare for run
@@ -315,8 +299,6 @@ describe("cell reducer", () => {
       cellId: firstCellId,
     });
     cell = cells[0];
-    expect(cell.lastCodeRun).toBe("import marimo as mo");
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("prepared for run");
 
     // Receive queued messages
@@ -329,8 +311,6 @@ describe("cell reducer", () => {
       timestamp: new Date(10).getTime() as Seconds,
     });
     cell = cells[0];
-    expect(cell.lastCodeRun).toBe("import marimo as mo");
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("queued message received");
 
     // Receive running messages
@@ -343,8 +323,6 @@ describe("cell reducer", () => {
       timestamp: new Date(20).getTime() as Seconds,
     });
     cell = cells[0];
-    expect(cell.lastCodeRun).toBe("import marimo as mo");
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("running message received");
 
     // Console messages shouldn't transition status
@@ -362,7 +340,6 @@ describe("cell reducer", () => {
       timestamp: new Date(22).getTime() as Seconds,
     });
     cell = cells[0];
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("console message received");
 
     // Receive output messages
@@ -385,7 +362,6 @@ describe("cell reducer", () => {
       timestamp: new Date(33).getTime() as Seconds,
     });
     cell = cells[0];
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("output received");
 
     // EDITING BACK AND FORTH
@@ -393,20 +369,16 @@ describe("cell reducer", () => {
     // Update code again
     editCode(firstCellId, "import marimo as mo\nimport numpy");
     cell = cells[0];
-    expect(cell.edited).toBe(true);
     expect(cell).toMatchSnapshot("code edited again");
 
     // Update code should be unedited
     editCode(firstCellId, "import marimo as mo");
     cell = cells[0];
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("code reverted");
 
     // Update code should be edited again
     editCode(firstCellId, "import marimo as mo\nimport numpy");
     cell = cells[0];
-    expect(cell.lastCodeRun).toBe("import marimo as mo");
-    expect(cell.edited).toBe(true);
     expect(cell).toMatchSnapshot("code changed after revert");
 
     // ERROR RESPONSE
@@ -457,8 +429,6 @@ describe("cell reducer", () => {
     });
     cell = cells[0];
     expect(cell.output).not.toBe(null); // keep old output
-    expect(cell.lastCodeRun).toBe("import marimo as mo\nimport numpy");
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("error response received");
 
     // INTERRUPT RESPONSE
@@ -506,8 +476,6 @@ describe("cell reducer", () => {
       timestamp: new Date(61).getTime() as Seconds,
     });
     cell = cells[0];
-    expect(cell.lastCodeRun).toBe(cell.code);
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("interruption response received");
   });
 
@@ -538,8 +506,6 @@ describe("cell reducer", () => {
       timestamp: new Date(10).getTime() as Seconds,
     });
     let cell = cells[1];
-    expect(cell.lastCodeRun).toBe("mo.slider()");
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("queued message received");
 
     // Receive stale message
@@ -552,53 +518,9 @@ describe("cell reducer", () => {
       timestamp: new Date(20).getTime() as Seconds,
     });
     cell = cells[1];
-    expect(cell.lastCodeRun).toBe("mo.slider()");
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("stale inputs received");
   });
 
-  it("can format code and update cell", () => {
-    const firstCellId = cells[0].id;
-    editCode(firstCellId, "import marimo as    mo");
-    let cell = cells[0];
-    expect(cell.lastCodeRun).toBe(null);
-    expect(cell.edited).toBe(true);
-
-    // Run
-    actions.prepareForRun({
-      cellId: firstCellId,
-    });
-    actions.handleCellMessage({
-      cell_id: firstCellId,
-      output: {
-        channel: "output",
-        mimetype: "text/plain",
-        data: "ok",
-        timestamp: 0,
-      },
-      console: {
-        channel: "stdout",
-        mimetype: "text/plain",
-        data: "hello!",
-        timestamp: 0,
-      },
-      status: "idle",
-      stale_inputs: null,
-      timestamp: new Date(33).getTime() as Seconds,
-    });
-
-    // Check steady state
-    cell = cells[0];
-    expect(cell.edited).toBe(false);
-    expect(cell.lastCodeRun).toBe("import marimo as    mo");
-
-    // Format code
-    formatCode(firstCellId, "import marimo as mo");
-    cell = cells[0];
-    expect(cell.lastCodeRun).toBe("import marimo as mo");
-    expect(cell.edited).toBe(false);
-  });
-
   it("can run a stopped cell", () => {
     // Update code of first cell
     editCode(firstCellId, "mo.md('This has an ancestor that was stopped')");
@@ -618,10 +540,6 @@ describe("cell reducer", () => {
       timestamp: new Date(10).getTime() as Seconds,
     });
     let cell = cells[0];
-    expect(cell.lastCodeRun).toBe(
-      "mo.md('This has an ancestor that was stopped')",
-    );
-    expect(cell.edited).toBe(false);
     expect(cell).toMatchSnapshot("queued message received");
 
     // Receive idle message
@@ -1494,24 +1412,6 @@ describe("kernel-ready", () => {
       },
     });
 
-  it("setLastRun records what the kernel last ran", () => {
-    const state = hydratedState();
-    const next = exportedForTesting.reducer(state, {
-      type: "setLastRun",
-      payload: { lastCodeRun: { [CELL_A]: "0" } },
-    });
-
-    expect(next.cellData[CELL_A]).toMatchObject({
-      lastCodeRun: "0",
-      edited: true,
-    });
-    expect(next.cellData[CELL_B]).toMatchObject({
-      lastCodeRun: null,
-      edited: false,
-    });
-    expect(next.cellRuntime).toBe(state.cellRuntime);
-  });
-
   it("resetCellRuntimes starts every cell's runtime over", () => {
     const next = exportedForTesting.reducer(hydratedState(), {
       type: "resetCellRuntimes",

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

@@ -53,13 +53,8 @@ describe("applyDocument", () => {
     const state = notebookOf([cell(a), cell(b, { code: "" })]);
 
     expect(state.cellIds).toEqual([a, b]);
-    expect(state.cellData[a]).toMatchObject({
-      code: "a = 1",
-      name: "_",
-      edited: true,
-      lastCodeRun: null,
-    });
-    expect(state.cellData[b].edited).toBe(false);
+    expect(state.cellData[a]).toMatchObject({ code: "a = 1", name: "_" });
+    expect(state.cellData[b]).toMatchObject({ code: "", name: "_" });
     expect(state.cellRuntime[a]).toBeDefined();
     expect(state.cellHandles[a]).toBeDefined();
     expect(state.cellData[SCRATCH_CELL_ID]).toBeDefined();
@@ -96,7 +91,6 @@ describe("applyDocument", () => {
     expect(next.cellData[a]).toMatchObject({
       name: "renamed",
       config: { hide_code: true },
-      edited: true,
     });
   });
 

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

@@ -5,8 +5,10 @@ import { MockExecutions } from "@/__mocks__/executions";
 import { initialNotebookState, type NotebookState } from "@/core/cells/cells";
 import { CellId } from "@/core/cells/ids";
 import type { CellData } from "@/core/cells/types";
+import type { CellFreshnessLookup } from "@/core/executions";
 import type { OutputMessage } from "@/core/kernel/messages";
 import {
+  cellNeedsRun,
   disabledCellIds,
   enabledCellIds,
   isUninstantiated,
@@ -14,80 +16,147 @@ import {
   staleCellIds,
 } from "../utils";
 
-function notebook(
-  cells: Record<
-    string,
-    { edited?: boolean; disabled?: boolean; staleInputs?: boolean }
-  >,
-): NotebookState {
+type Cells = Record<
+  string,
+  { edited?: boolean; disabled?: boolean; staleInputs?: boolean }
+>;
+
+function notebook(cells: Cells): NotebookState {
   return {
     cellIds: Object.keys(cells),
     cellData: Object.fromEntries(
       Object.entries(cells).map(([id, cell]) => [
         id,
-        { edited: cell.edited ?? false, config: { disabled: cell.disabled } },
-      ]),
-    ),
-    cellRuntime: Object.fromEntries(
-      Object.entries(cells).map(([id, cell]) => [
-        id,
-        { staleInputs: cell.staleInputs ?? false },
+        { config: { disabled: cell.disabled } },
       ]),
     ),
+    cellRuntime: Object.fromEntries(Object.keys(cells).map((id) => [id, {}])),
   } as any;
 }
 
+/** Freshness as the host would report it for `cells`. */
+function freshness(cells: Cells): CellFreshnessLookup {
+  return (id) => {
+    const cell = cells[id];
+    return {
+      sourceChanged: cell?.edited ?? false,
+      inputsChanged: cell?.staleInputs ?? false,
+    };
+  };
+}
+
 describe("staleCellIds", () => {
   it("should return cell IDs that have never run", () => {
-    const state = notebook({ cell1: {}, cell2: {} });
+    const cells: Cells = { cell1: {}, cell2: {} };
+    const state = notebook(cells);
     const executions = MockExecutions.inputs([
       MockExecutions.completed("cell2"),
     ]);
 
-    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
+    expect(staleCellIds(state, executions, freshness(cells))).toEqual([
+      "cell1",
+    ]);
   });
 
   it("should return cell IDs that are edited", () => {
-    const state = notebook({ cell1: { edited: true }, cell2: {} });
+    const cells: Cells = { cell1: { edited: true }, cell2: {} };
+    const state = notebook(cells);
     const executions = MockExecutions.inputs([
       MockExecutions.completed("cell1"),
       MockExecutions.completed("cell2"),
     ]);
 
-    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
+    expect(staleCellIds(state, executions, freshness(cells))).toEqual([
+      "cell1",
+    ]);
   });
 
   it("should return cell IDs that are interrupted", () => {
-    const state = notebook({ cell1: {}, cell2: {} });
+    const cells: Cells = { cell1: {}, cell2: {} };
+    const state = notebook(cells);
     const executions = MockExecutions.inputs([
       MockExecutions.interrupted("cell1"),
       MockExecutions.completed("cell2"),
     ]);
 
-    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
+    expect(staleCellIds(state, executions, freshness(cells))).toEqual([
+      "cell1",
+    ]);
   });
 
   it("should return cell IDs with stale inputs", () => {
-    const state = notebook({ cell1: { staleInputs: true }, cell2: {} });
+    const cells: Cells = { cell1: { staleInputs: true }, cell2: {} };
+    const state = notebook(cells);
     const executions = MockExecutions.inputs([
       MockExecutions.completed("cell1"),
       MockExecutions.completed("cell2"),
     ]);
 
-    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
+    expect(staleCellIds(state, executions, freshness(cells))).toEqual([
+      "cell1",
+    ]);
   });
 
   it("should not return cell IDs that are disabled", () => {
-    const state = notebook({
+    const cells: Cells = {
       cell1: { disabled: true, staleInputs: true },
       cell2: { staleInputs: true },
-    });
+    };
+    const state = notebook(cells);
     const executions = MockExecutions.inputs(
       [MockExecutions.completed("cell1"), MockExecutions.completed("cell2")],
       { blocked: new Set(["cell2"]) },
     );
 
-    expect(staleCellIds(state, executions)).toEqual([]);
+    expect(staleCellIds(state, executions, freshness(cells))).toEqual([]);
+  });
+});
+
+describe("staleCellIds with a run in progress", () => {
+  it("leaves a running cell alone unless its source changed since", () => {
+    const cells: Cells = { cell1: {}, cell2: { edited: true } };
+    const state = notebook(cells);
+    const executions = MockExecutions.inputs([
+      MockExecutions.running("cell1"),
+      MockExecutions.running("cell2"),
+    ]);
+
+    expect(staleCellIds(state, executions, freshness(cells))).toEqual([
+      "cell2",
+    ]);
+  });
+
+  it("leaves a submitted cell alone until the host has planned its run", () => {
+    const cells: Cells = { cell1: { edited: true } };
+    const state = notebook(cells);
+    const ran = MockExecutions.completed("cell1");
+    const executions = MockExecutions.inputs([ran], {
+      submissions: new Map([["cell1", ran.id]]),
+    });
+
+    expect(staleCellIds(state, executions, freshness(cells))).toEqual([]);
+  });
+});
+
+describe("cellNeedsRun", () => {
+  const blocked = { interrupted: false, disabled: false, blocked: true };
+
+  it("flags a blocked cell whose source changed, whatever its inputs did", () => {
+    expect(
+      cellNeedsRun({
+        ...blocked,
+        freshness: freshness({ c: { edited: true, staleInputs: true } })("c"),
+      }),
+    ).toBe(true);
+  });
+
+  it("does not flag a blocked cell for changed inputs alone", () => {
+    expect(
+      cellNeedsRun({
+        ...blocked,
+        freshness: freshness({ c: { staleInputs: true } })("c"),
+      }),
+    ).toBe(false);
   });
 });
 

package/src/core/cells/actions.ts

@@ -603,7 +603,6 @@ export function useCellActions() {
     handleCellMessage: _handleCellMessage,
     addLogs: _addLogs,
     reconcileDocument: _reconcileDocument,
-    setLastRun: _setLastRun,
     resetCellRuntimes: _resetCellRuntimes,
     ...operations
   } = useReducerActions();

package/src/core/cells/cell.ts

@@ -1,5 +1,9 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-import type { CellExecutionView, CellRunStatus } from "@/core/executions";
+import type {
+  CellExecutionView,
+  CellFreshness,
+  CellRunStatus,
+} from "@/core/executions";
 import { extractAllTracebackInfo, type TracebackInfo } from "@/utils/traceback";
 import { parseOutline } from "../dom/outline";
 import type { CellMessage, OutputMessage } from "../kernel/messages";
@@ -41,7 +45,6 @@ export function transitionCell(
   }
 
   nextCell.output = message.output ?? nextCell.output;
-  nextCell.staleInputs = message.stale_inputs ?? nextCell.staleInputs;
   // Tri-state partial update: an omitted field (undefined) leaves the hint
   // unchanged; null explicitly clears it; a string sets it.
   if (message.serialization !== undefined) {
@@ -115,31 +118,51 @@ export function outputIsLoading(status: CellRunStatus): boolean {
 }
 
 /**
- * A cell's output is stale if it has been edited, is loading, or has errored.
+ * A cell's output is stale if it is loading, an input it read has changed,
+ * or, while `editing`, its source has changed. A read view keeps showing
+ * the last result of edited source.
  */
 export function outputIsStale(
   execution: Pick<CellExecutionView, "status" | "outcome" | "rendered">,
-  staleInputs: boolean,
-  edited: boolean,
+  freshness: CellFreshness,
+  editing: boolean,
 ): boolean {
   const { status, outcome, rendered } = execution;
 
-  // If interrupted, the output is not stale
+  // A run in progress owns the output area: loading until the running cell
+  // has shown output (e.g. mo.output.append()), whatever the last result was.
+  if (outputIsLoading(status)) {
+    return !(status === "running" && rendered);
+  }
+  if (editing && freshness.sourceChanged) {
+    return true;
+  }
+  // An interrupted run's partial output stands as the record of that run.
   if (outcome === "interrupted") {
     return false;
   }
+  return freshness.inputsChanged;
+}
 
-  // If edited, the cell's output is stale
-  if (edited) {
-    return true;
+/**
+ * Console output is stale while a run is queued, since the run will clear
+ * it, and once a settled result is outdated. A run in progress owns it.
+ */
+export function consoleOutputIsStale(
+  execution: Pick<CellExecutionView, "status" | "outcome">,
+  freshness: CellFreshness,
+): boolean {
+  const { status, outcome } = execution;
+  if (outcome === "interrupted") {
+    return false;
   }
-
-  // Loading, unless the running cell has shown output (e.g. mo.output.append())
-  if (outputIsLoading(status) && !(status === "running" && rendered)) {
+  if (status === "queued") {
     return true;
   }
-
-  return staleInputs;
+  if (status === "running") {
+    return false;
+  }
+  return freshness.sourceChanged || freshness.inputsChanged;
 }
 
 /**

package/src/core/cells/cells.ts

@@ -9,6 +9,7 @@ import type { EditableDocument, Placement } from "@/core/notebook/document";
 import {
   cellExecutionInputsAtom,
   cellExecutionView,
+  cellFreshnessAtom,
   withdrawCells,
 } from "@/core/executions";
 import type { CellColumnId } from "./layout";
@@ -38,7 +39,6 @@ import {
   type CellRuntimeState,
   createCell,
   createCellRuntimeState,
-  isEdited,
 } from "./types";
 import {
   canUndoDeletes,
@@ -161,76 +161,21 @@ const {
   useActions,
   valueAtom: notebookAtom,
 } = createReducerAndAtoms(initialNotebookState, {
-  /**
-   * Keep a cell as run, or as edited, as it was before formatting rewrote
-   * its code from `before` to `after`. The code itself arrives through the
-   * document.
-   */
-  codeFormatted: (
-    state,
-    action: { cellId: CellId; before: string; after: string },
-  ) => {
-    const { cellId, before, after } = action;
-    if (!state.cellData[cellId]) {
-      return state;
-    }
-    return updateCellData({
-      state,
-      cellId,
-      cellReducer: (cell) => {
-        const lastCodeRun = isEdited(cell.lastCodeRun, before)
-          ? cell.lastCodeRun
-          : after;
-        return {
-          ...cell,
-          lastCodeRun,
-          edited: isEdited(lastCodeRun, cell.code),
-        };
-      },
-    });
-  },
-  prepareForRun: (state, action: { cellId: CellId }) => {
-    const newState = updateCellRuntimeState({
+  prepareForRun: (state, action: { cellId: CellId }) =>
+    updateCellRuntimeState({
       state,
       cellId: action.cellId,
       cellReducer: (cell) => ({ ...cell, debuggerActive: false }),
-    });
-    return updateCellData({
-      state: newState,
-      cellId: action.cellId,
-      cellReducer: (cell) => {
-        return {
-          ...cell,
-          edited: false,
-          lastCodeRun: cell.code.trim(),
-        };
-      },
-    });
-  },
+    }),
   handleCellMessage: (state, message: CellMessage) => {
     const cellId = message.cell_id;
-    let nextState = updateCellRuntimeState({
+    const nextState = updateCellRuntimeState({
       state,
       cellId,
       cellReducer: (cell) => {
         return transitionCell(cell, message);
       },
     });
-    // When a cell is queued for execution, snapshot the current code
-    // as lastCodeRun. This clears staleness for cells executed by the
-    // kernel (e.g. via code_mode). If the user edits during execution,
-    // code !== lastCodeRun keeps the cell stale.
-    if (message.status === "queued") {
-      nextState = updateCellData({
-        state: nextState,
-        cellId,
-        cellReducer: (cell) => ({
-          ...cell,
-          lastCodeRun: cell.code.trim(),
-          edited: false,
-        }),
-      });
-    }
     return {
       ...nextState,
       cellLogs: [...nextState.cellLogs, ...getCellLogsForMessage(message)],
@@ -286,21 +231,6 @@ const {
       },
     });
   },
-  /** Record what the kernel last ran for each cell. */
-  setLastRun: (state, action: { lastCodeRun: Record<CellId, string> }) => {
-    const cellData = { ...state.cellData };
-    for (const cellId of state.cellIds) {
-      const cell = state.cellData[cellId];
-      const lastCodeRun = action.lastCodeRun[cellId] ?? null;
-      cellData[cellId] = {
-        ...cell,
-        lastCodeRun,
-        // A cell the kernel never ran is not stale on load.
-        edited: lastCodeRun !== null && isEdited(lastCodeRun, cell.code),
-      };
-    }
-    return { ...state, cellData };
-  },
   /**
    * Start each cell's runtime over for a new kernel. WASM keeps the outputs
    * its mount-time snapshot gave it.
@@ -429,29 +359,6 @@ function updateCellRuntimeState({
   };
 }
 
-function updateCellData({
-  state,
-  cellId,
-  cellReducer,
-}: {
-  state: NotebookState;
-  cellId: CellId;
-  cellReducer: ReducerWithoutAction<CellData>;
-}) {
-  if (!(cellId in state.cellData)) {
-    Logger.warn(`Cell ${cellId} not found in state`);
-    return state;
-  }
-
-  return {
-    ...state,
-    cellData: {
-      ...state.cellData,
-      [cellId]: cellReducer(state.cellData[cellId]),
-    },
-  };
-}
-
 /** Each cell's config in order. The document's `column` configs are canonical. */
 export function getCellConfigs(state: NotebookState): CellConfig[] {
   return state.cellIds.map((cellId) => ({
@@ -492,7 +399,11 @@ export const canUndoDeletesAtom = atom((get) =>
 export const undoLabelAtom = atom((get) => getUndoLabel(get(notebookAtom)));
 
 export const needsRunAtom = atom((get) =>
-  notebookNeedsRun(get(notebookAtom), get(cellExecutionInputsAtom)),
+  notebookNeedsRun(
+    get(notebookAtom),
+    get(cellExecutionInputsAtom),
+    get(cellFreshnessAtom),
+  ),
 );
 
 export const cellErrorsAtom = atom((get) => {