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

package/src/core/cells/document.ts

@@ -27,7 +27,6 @@ import {
   createCell,
   createCellConfig,
   createCellRuntimeState,
-  isEdited,
 } from "./types";
 
 // Following the document ----------------------------------------------------
@@ -49,13 +48,7 @@ function followCell(current: CellData, cell: EditableCell): CellData {
   if (code === current.code) {
     return { ...current, name: cell.name, config };
   }
-  return {
-    ...current,
-    code,
-    name: cell.name,
-    config,
-    edited: isEdited(current.lastCodeRun, code),
-  };
+  return { ...current, code, name: cell.name, config };
 }
 
 /**
@@ -83,17 +76,13 @@ export function applyDocument(
       continue;
     }
     if (current === undefined) {
-      // A new cell with code is stale until it runs. The kernel's last run
-      // settles it on kernel-ready.
-      const code = cell.code ?? "";
       cellData = {
         ...cellData,
         [id]: createCell({
           id,
-          code,
+          code: cell.code ?? "",
           name: cell.name,
           config: createCellConfig(cell.config),
-          edited: isEdited(null, code),
         }),
       };
       cellRuntime = {

package/src/core/cells/types.ts

@@ -6,18 +6,6 @@ import type { CellId } from "./ids";
 import { DEFAULT_CELL_NAME } from "./names";
 import type { Outline } from "./outline";
 
-/**
- * Whether a cell's code has changed since it last ran. A cell that never ran
- * is edited once it has code. Whitespace at the ends does not count.
- *
- * TODO(MO-8403): Delete with `lastCodeRun`.
- */
-export function isEdited(lastCodeRun: string | null, code: string): boolean {
-  return lastCodeRun === null
-    ? code.trim().length > 0
-    : lastCodeRun.trim() !== code.trim();
-}
-
 /**
  * Create a new cell with default state.
  */
@@ -25,8 +13,6 @@ export function createCell({
   id,
   name = DEFAULT_CELL_NAME,
   code = "",
-  lastCodeRun = null,
-  edited = false,
   config,
 }: Partial<CellData> & { id: CellId }): CellData {
   return {
@@ -39,8 +25,6 @@ export function createCell({
     },
     name: name,
     code: code,
-    edited: edited,
-    lastCodeRun: lastCodeRun,
   };
 }
 
@@ -61,7 +45,6 @@ export function createCellRuntimeState(
     outline: null,
     output: null,
     consoleOutputs: [],
-    staleInputs: false,
     debuggerActive: false,
     ...state,
   };
@@ -76,10 +59,6 @@ export interface CellData {
   name: string;
   /** current contents of the editor */
   code: string;
-  /** whether this cell has been modified since its last run */
-  edited: boolean;
-  /** snapshot of code that was last run */
-  lastCodeRun: string | null;
   /** cell configuration */
   config: CellConfig;
 }
@@ -97,8 +76,6 @@ export interface CellRuntimeState {
   outline: Outline | null;
   /** messages encoding the cell's console outputs. TODO(MO-8405) */
   consoleOutputs: ConsoleOutputMessage[];
-  /** whether the cell has stale inputs. TODO(MO-8403) */
-  staleInputs: boolean;
   /** debugger active */
   debuggerActive: boolean;
   /** serialization message. TODO(MO-8414) */

package/src/core/cells/utils.ts

@@ -4,8 +4,11 @@ import type { EditorView } from "@codemirror/view";
 import {
   type CellExecutionInputs,
   type CellExecutionView,
+  type CellFreshness,
+  type CellFreshnessLookup,
   cellExecutionView,
 } from "@/core/executions";
+import type { Executions } from "@/core/notebook/replica";
 import { Objects } from "@/utils/objects";
 import type { MarimoError, OutputMessage } from "../kernel/messages";
 import { isErrorMime } from "../mime";
@@ -15,8 +18,9 @@ import type { CellId } from "./ids";
 export function notebookNeedsRun(
   state: NotebookState,
   executions: CellExecutionInputs,
+  freshness: CellFreshnessLookup,
 ) {
-  return staleCellIds(state, executions).length > 0;
+  return staleCellIds(state, executions, freshness).length > 0;
 }
 
 export function notebookCells(state: NotebookState) {
@@ -78,13 +82,13 @@ export function getUndoLabel(state: NotebookState): string {
  * errored, or running.
  */
 export function getDescendantsStatus(
-  state: NotebookState,
   executions: CellExecutionInputs,
+  freshness: CellFreshnessLookup,
   descendants: readonly CellId[],
 ) {
   const views = descendants.map((id) => cellExecutionView(executions, id));
   const stale = descendants.some(
-    (id) => state.cellRuntime[id]?.staleInputs || state.cellData[id]?.edited,
+    (id) => freshness(id).sourceChanged || freshness(id).inputsChanged,
   );
   const errored = views.some((view) => view.outcome === "error");
   const runningOrQueued = views.some(
@@ -104,21 +108,41 @@ export function getDescendantsStatus(
 export function staleCellIds(
   state: NotebookState,
   executions: CellExecutionInputs,
+  freshness: CellFreshnessLookup,
 ) {
-  const { cellIds, cellData, cellRuntime } = state;
+  const { cellIds, cellData } = state;
   return cellIds.filter((cellId) => {
     const execution = cellExecutionView(executions, cellId);
+    if (execution.status !== "idle") {
+      // A run in progress covers the source it was asked for. Only an edit
+      // since then, visible once the host has planned the run, needs another.
+      return (
+        inFlight(executions.executions, cellId) &&
+        freshness(cellId).sourceChanged
+      );
+    }
     return (
       isUninstantiated(execution) ||
-      cellData[cellId].edited ||
-      execution.outcome === "interrupted" ||
-      (cellRuntime[cellId].staleInputs &&
-        // if a cell is disabled, it can't be run ...
-        !(execution.blocked || cellData[cellId].config.disabled))
+      cellNeedsRun({
+        freshness: freshness(cellId),
+        interrupted: execution.outcome === "interrupted",
+        disabled: cellData[cellId].config.disabled,
+        blocked: execution.blocked,
+      })
     );
   });
 }
 
+/** Whether the host holds a planned or started execution of the cell that has not completed. */
+function inFlight(executions: Executions, cellId: CellId): boolean {
+  const latest = executions.latest.get(cellId);
+  const record =
+    latest === undefined
+      ? undefined
+      : executions.executions.get(latest)?.record;
+  return record !== undefined && record.status !== "completed";
+}
+
 /** Whether a cell has never run: no result to show and nothing in flight. */
 export function isUninstantiated({
   status,
@@ -128,24 +152,27 @@ export function isUninstantiated({
 }
 
 /**
- * Whether a cell needs to be run given its edited / interrupted / stale
- * inputs, while accounting for ancestor-disabled cells (which should not be
- * flagged as needing a run until re-enabled).
+ * Whether a cell needs to be run: its source changed, its last run was
+ * interrupted, or an input changed and the cell can run. A disabled cell,
+ * or one blocked by a disabled ancestor, is not flagged for changed inputs
+ * until it can run again.
  */
 export function cellNeedsRun({
-  edited,
+  freshness,
   interrupted,
-  staleInputs,
   disabled,
   blocked,
 }: {
-  edited: boolean;
+  freshness: CellFreshness;
   interrupted: boolean;
-  staleInputs: boolean;
   disabled: boolean | undefined;
   blocked: boolean;
 }): boolean {
-  return edited || interrupted || (staleInputs && !(disabled || blocked));
+  return (
+    freshness.sourceChanged ||
+    interrupted ||
+    (freshness.inputsChanged && !(disabled || blocked))
+  );
 }
 
 export function cellStatusClasses({

package/src/core/codemirror/cells/extensions.ts

@@ -23,7 +23,6 @@ import { createObservable } from "@/core/state/observable";
 import { formatKeymapExtension } from "../extensions";
 import { formattingChangeEffect } from "../format";
 import { goToDefinitionAtCursorPosition } from "../go-to-definition/utils";
-import { getCellCode } from "../language/cell-code";
 import { isAtEndOfEditor, isAtStartOfEditor } from "../utils";
 import {
   breakpointGutter,
@@ -327,19 +326,6 @@ function cellCodeEditing(hotkeys: HotkeyProvider): Extension[] {
       return;
     }
     const cellId = update.view.state.facet(cellIdState);
-    // The code itself reaches the document through the editor's binding.
-    // Formatting, including a language switch, rewrites the code without
-    // editing it, so the cell stays as run or as edited as it was.
-    const formatted = update.transactions.some((tr) =>
-      tr.effects.some((effect) => effect.is(formattingChangeEffect)),
-    );
-    if (formatted) {
-      update.view.state.facet(cellActionsState).codeFormatted({
-        cellId,
-        before: getCellCode(update.startState),
-        after: getCellCode(update.state),
-      });
-    }
 
     // Clear pending cut state if this cell was marked for cut
     const pendingCutCellIds = store.get(pendingCutCellIdsAtom);

package/src/core/errors/__tests__/error-entries.test.ts

@@ -1,8 +1,15 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import { createStore } from "jotai";
 import { describe, expect, it } from "vitest";
+import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
-import { type CellErrorEntry, formatCellError } from "../error-entries";
+import { notebookAtom } from "@/core/cells/cells";
+import {
+  type CellErrorEntry,
+  formatCellError,
+  getCellErrorEntries,
+} from "../error-entries";
 
 describe("formatCellError", () => {
   it("formats current tracebacks without notebook source", () => {
@@ -23,3 +30,35 @@ describe("formatCellError", () => {
     expect(text).not.toContain("<span");
   });
 });
+
+describe("getCellErrorEntries", () => {
+  it("pairs an error with the source that raised it, not a later edit", () => {
+    const id = cellId("c1");
+    const store = createStore();
+    store.set(
+      notebookAtom,
+      MockNotebook.notebookState({
+        cellData: { [id]: { code: "print('fixed')" } },
+        cellRuntime: {
+          [id]: {
+            output: {
+              channel: "marimo-error",
+              mimetype: "application/vnd.marimo+error",
+              data: [
+                {
+                  type: "exception",
+                  exception_type: "ZeroDivisionError",
+                  msg: "division by zero",
+                },
+              ],
+              timestamp: 0,
+              code: "1 / 0",
+            },
+          },
+        },
+      }),
+    );
+
+    expect(getCellErrorEntries(store)[0]?.cellCode).toBe("1 / 0");
+  });
+});

package/src/core/errors/error-entries.ts

@@ -93,9 +93,8 @@ export function getCellErrorEntries(store: JotaiStore): CellErrorEntry[] {
     }
 
     const cellName = displayCellName(cellData[cellId].name, cellIndex);
-    // Prefer the code from the last execution: runtime errors correspond to
-    // the previous run, while `code` may already contain unsaved edits.
-    const cellCode = cellData[cellId].lastCodeRun ?? cellData[cellId].code;
+    // The source that raised, since the cell may have been edited since.
+    const cellCode = output.code ?? cellData[cellId].code;
 
     entries.push({
       cellId,