@marimo-team/islands 0.25.3-dev267 → 0.25.3-dev269

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

@@ -1,6 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 /* oxlint-disable typescript/no-explicit-any */
 import { describe, expect, it } from "vitest";
+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";
@@ -13,278 +14,105 @@ import {
   staleCellIds,
 } from "../utils";
 
-describe("staleCellIds", () => {
-  it("should return cell IDs that have not been instantiated when auto-instantiate is false", () => {
-    const state: NotebookState = {
-      cellIds: ["cell1", "cell2"],
-      cellData: {
-        cell1: {
-          lastExecutionTime: null,
-          edited: false,
-          config: { disabled: false },
-        },
-        cell2: {
-          lastExecutionTime: 123,
-          edited: false,
-          config: { disabled: false },
-        },
-      },
-      cellRuntime: {
-        cell1: {
-          runElapsedTimeMs: null,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-        cell2: {
-          runElapsedTimeMs: 456,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-      },
-    } as any;
-
-    const result = staleCellIds(state);
-
-    expect(result).toEqual(["cell1"]);
-  });
-
-  it("should use lastExecutionTime when runElapsedTimeMs is null", () => {
-    const state: NotebookState = {
-      cellIds: ["cell1", "cell2"],
-      cellData: {
-        cell1: {
-          lastExecutionTime: null,
-          edited: false,
-          config: { disabled: false },
-        },
-        cell2: {
-          lastExecutionTime: 123,
-          edited: false,
-          config: { disabled: false },
-        },
-      },
-      cellRuntime: {
-        cell1: {
-          runElapsedTimeMs: null,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-        cell2: {
-          runElapsedTimeMs: null,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-      },
-    } as any;
+function notebook(
+  cells: Record<
+    string,
+    { edited?: boolean; disabled?: boolean; staleInputs?: boolean }
+  >,
+): 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 },
+      ]),
+    ),
+  } as any;
+}
 
-    const result = staleCellIds(state);
+describe("staleCellIds", () => {
+  it("should return cell IDs that have never run", () => {
+    const state = notebook({ cell1: {}, cell2: {} });
+    const executions = MockExecutions.inputs([
+      MockExecutions.completed("cell2"),
+    ]);
 
-    expect(result).toEqual(["cell1"]);
+    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
   });
 
   it("should return cell IDs that are edited", () => {
-    const state: NotebookState = {
-      cellIds: ["cell1", "cell2"],
-      cellData: {
-        cell1: {
-          lastExecutionTime: 123,
-          edited: true,
-          config: { disabled: false },
-        },
-        cell2: {
-          lastExecutionTime: 123,
-          edited: false,
-          config: { disabled: false },
-        },
-      },
-      cellRuntime: {
-        cell1: {
-          runElapsedTimeMs: 456,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-        cell2: {
-          runElapsedTimeMs: 456,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-      },
-    } as any;
-
-    const result = staleCellIds(state);
+    const state = notebook({ cell1: { edited: true }, cell2: {} });
+    const executions = MockExecutions.inputs([
+      MockExecutions.completed("cell1"),
+      MockExecutions.completed("cell2"),
+    ]);
 
-    expect(result).toEqual(["cell1"]);
+    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
   });
 
   it("should return cell IDs that are interrupted", () => {
-    const state: NotebookState = {
-      cellIds: ["cell1", "cell2"],
-      cellData: {
-        cell1: {
-          lastExecutionTime: 123,
-          edited: false,
-          config: { disabled: false },
-        },
-        cell2: {
-          lastExecutionTime: 123,
-          edited: false,
-          config: { disabled: false },
-        },
-      },
-      cellRuntime: {
-        cell1: {
-          runElapsedTimeMs: 456,
-          status: "idle",
-          errored: false,
-          interrupted: true,
-          stopped: false,
-          staleInputs: false,
-        },
-        cell2: {
-          runElapsedTimeMs: 456,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-      },
-    } as any;
+    const state = notebook({ cell1: {}, cell2: {} });
+    const executions = MockExecutions.inputs([
+      MockExecutions.interrupted("cell1"),
+      MockExecutions.completed("cell2"),
+    ]);
+
+    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
+  });
 
-    const result = staleCellIds(state);
+  it("should return cell IDs with stale inputs", () => {
+    const state = notebook({ cell1: { staleInputs: true }, cell2: {} });
+    const executions = MockExecutions.inputs([
+      MockExecutions.completed("cell1"),
+      MockExecutions.completed("cell2"),
+    ]);
 
-    expect(result).toEqual(["cell1"]);
+    expect(staleCellIds(state, executions)).toEqual(["cell1"]);
   });
 
   it("should not return cell IDs that are disabled", () => {
-    const state: NotebookState = {
-      cellIds: ["cell1", "cell2"],
-      cellData: {
-        cell1: {
-          lastExecutionTime: 123,
-          edited: false,
-          config: { disabled: true },
-        },
-        cell2: {
-          lastExecutionTime: 123,
-          edited: false,
-          config: { disabled: false },
-        },
-      },
-      cellRuntime: {
-        cell1: {
-          runElapsedTimeMs: 456,
-          status: "disabled-transitively",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: true,
-        },
-        cell2: {
-          runElapsedTimeMs: 456,
-          status: "idle",
-          errored: false,
-          interrupted: false,
-          stopped: false,
-          staleInputs: false,
-        },
-      },
-    } as any;
-
-    const result = staleCellIds(state);
+    const state = notebook({
+      cell1: { disabled: true, staleInputs: true },
+      cell2: { staleInputs: true },
+    });
+    const executions = MockExecutions.inputs(
+      [MockExecutions.completed("cell1"), MockExecutions.completed("cell2")],
+      { blocked: new Set(["cell2"]) },
+    );
 
-    expect(result).toEqual([]);
+    expect(staleCellIds(state, executions)).toEqual([]);
   });
 });
 
 describe("isUninstantiated", () => {
-  it("should return true if autoInstantiate is false and cell has not run", () => {
-    const result = isUninstantiated({
-      executionTime: null,
-      status: "idle",
-      errored: false,
-      interrupted: false,
-      stopped: false,
-    });
-    expect(result).toBe(true);
+  it("should return true if the cell has not run", () => {
+    expect(isUninstantiated({ status: "idle", outcome: null })).toBe(true);
   });
 
-  it("should return false if cell has run", () => {
-    const result = isUninstantiated({
-      executionTime: 123,
-      status: "idle",
-      errored: false,
-      interrupted: false,
-      stopped: false,
-    });
-    expect(result).toBe(false);
+  it("should return false if the cell has run", () => {
+    expect(isUninstantiated({ status: "idle", outcome: "value" })).toBe(false);
   });
 
-  it("should return false if cell is currently queued or running", () => {
-    let result = isUninstantiated({
-      executionTime: null,
-      status: "queued",
-      errored: false,
-      interrupted: false,
-      stopped: false,
-    });
-    expect(result).toBe(false);
-
-    result = isUninstantiated({
-      executionTime: null,
-      status: "running",
-      errored: false,
-      interrupted: false,
-      stopped: false,
-    });
-    expect(result).toBe(false);
+  it("should return false if the cell is currently queued or running", () => {
+    expect(isUninstantiated({ status: "queued", outcome: null })).toBe(false);
+    expect(isUninstantiated({ status: "running", outcome: null })).toBe(false);
   });
 
-  it("should return false if cell is in an error state", () => {
-    let result = isUninstantiated({
-      executionTime: null,
-      status: "idle",
-      errored: true,
-      interrupted: false,
-      stopped: false,
-    });
-    expect(result).toBe(false);
-
-    result = isUninstantiated({
-      executionTime: null,
-      status: "idle",
-      errored: false,
-      interrupted: true,
-      stopped: false,
-    });
-    expect(result).toBe(false);
-
-    result = isUninstantiated({
-      executionTime: null,
-      status: "idle",
-      errored: false,
-      interrupted: false,
-      stopped: true,
-    });
-    expect(result).toBe(false);
+  it("should return false if the cell ended without a value", () => {
+    expect(isUninstantiated({ status: "idle", outcome: "error" })).toBe(false);
+    expect(isUninstantiated({ status: "idle", outcome: "interrupted" })).toBe(
+      false,
+    );
+    expect(isUninstantiated({ status: "idle", outcome: "skipped" })).toBe(
+      false,
+    );
   });
 });
 

package/src/core/cells/actions.ts

@@ -6,6 +6,7 @@ import { historyField } from "@codemirror/commands";
 import { atom, type Getter, type Setter, useSetAtom } from "jotai";
 import { useMemo } from "react";
 import { scrollAndHighlightCell } from "@/components/editor/links/cell-link";
+import { cellExecutionInputsAtom, runningCellIds } from "@/core/executions";
 import type { EditableDocument } from "@/core/notebook/document";
 import { Logger } from "@/utils/Logger";
 import { clamp } from "@/utils/math";
@@ -680,8 +681,10 @@ export type CellActions = ReturnType<typeof useCellActions>;
 
 /** Scroll to the first cell that is currently running. */
 export function notebookScrollToRunning() {
-  const { cellIds, cellRuntime } = store.get(notebookAtom);
-  const cellId = cellIds.find((id) => cellRuntime[id]?.status === "running");
+  const running = new Set(
+    runningCellIds(store.get(cellExecutionInputsAtom).executions),
+  );
+  const cellId = store.get(notebookAtom).cellIds.find((id) => running.has(id));
   if (!cellId) {
     return;
   }

package/src/core/cells/cell.ts

@@ -1,11 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-import { logNever } from "@/utils/assertNever";
-import { invariant } from "@/utils/invariant";
-import { type Seconds, Time } from "@/utils/time";
+import type { CellExecutionView, CellRunStatus } from "@/core/executions";
 import { extractAllTracebackInfo, type TracebackInfo } from "@/utils/traceback";
 import { parseOutline } from "../dom/outline";
 import type { CellMessage, OutputMessage } from "../kernel/messages";
-import type { RuntimeState } from "../network/types";
 import { collapseConsoleOutputs } from "./collapseConsoleOutputs";
 import type { CellRuntimeState, ConsoleOutputMessage } from "./types";
 
@@ -14,111 +11,44 @@ function nextConsoleOutputId(outputs: ConsoleOutputMessage[]): number {
   return (outputs.at(-1)?.id ?? 0) + 1;
 }
 
+function errorTypes(output: OutputMessage | null | undefined): string[] {
+  if (
+    output == null ||
+    output.mimetype !== "application/vnd.marimo+error" ||
+    !Array.isArray(output.data)
+  ) {
+    return [];
+  }
+  return output.data.map((error) => error.type);
+}
+
 export function transitionCell(
   cell: CellRuntimeState,
   message: CellMessage,
 ): CellRuntimeState {
   const nextCell = { ...cell };
 
-  // Handle status transition and update output; message.status !== null
-  // implies a status transition
-  switch (message.status) {
-    case "queued":
-      nextCell.interrupted = false;
-      nextCell.errored = false;
-      nextCell.runElapsedTimeMs = null;
-      nextCell.debuggerActive = false;
-      // We intentionally don't update lastCodeRun, since the kernel queues
-      // whatever code was last registered with it, which might not match
-      // the cell's current code if the user modified it.
-      break;
-    case "running":
-      // Clear interrupted here in case we start as "running"
-      // This can happen on a resumed session
-      nextCell.interrupted = false;
-      // If was previously stopped, clear the outputs
-      if (cell.stopped) {
-        nextCell.output = null;
-      }
-      // If it transitioned from queued to running, remove previous console outputs
-      if (nextCell.status === "queued") {
-        nextCell.consoleOutputs = [];
-      }
-      nextCell.stopped = false;
-      nextCell.runStartTimestamp = message.timestamp as Seconds;
-      // Store the last run timestamp, since this gets cleared once idle
-      nextCell.lastRunStartTimestamp = message.timestamp as Seconds;
-      break;
-    case "idle":
-      if (cell.runStartTimestamp) {
-        nextCell.runElapsedTimeMs = Time.fromSeconds(
-          ((message.timestamp ?? 0) - cell.runStartTimestamp) as Seconds,
-        ).toMilliseconds();
-        nextCell.runStartTimestamp = null;
-        nextCell.staleInputs = false;
-      }
-      // If last run start timestamp is not set, set it to the current timestamp
-      // This happens on a resumed session
-      if (!cell.lastRunStartTimestamp && message.timestamp) {
-        nextCell.lastRunStartTimestamp = message.timestamp as Seconds;
-      }
-      nextCell.debuggerActive = false;
-      break;
-    case null:
-      break;
-    case "disabled-transitively":
-      // Everything should already be up to date from prepareCellForExecution
-      break;
-    case undefined:
-      break;
-    default:
-      logNever(message.status);
+  if (message.status === "queued") {
+    nextCell.debuggerActive = false;
+  }
+  // A skipped cell's output is the notice that an ancestor stopped it, which
+  // has nothing to do with the run that is starting.
+  if (
+    message.status === "running" &&
+    errorTypes(cell.output).some((type) => type.includes("ancestor"))
+  ) {
+    nextCell.output = null;
   }
 
   nextCell.output = message.output ?? nextCell.output;
   nextCell.staleInputs = message.stale_inputs ?? nextCell.staleInputs;
-  nextCell.status = message.status ?? nextCell.status;
   // Tri-state partial update: an omitted field (undefined) leaves the hint
   // unchanged; null explicitly clears it; a string sets it.
   if (message.serialization !== undefined) {
     nextCell.serialization = message.serialization;
   }
 
-  let didInterruptFromThisMessage = false;
-
-  // Handle errors: marimo includes an error output when a cell is interrupted
-  // or errored
-  if (
-    message.output != null &&
-    message.output.mimetype === "application/vnd.marimo+error"
-  ) {
-    // The frontend manually sets status to queued when a user runs a cell,
-    // to give immediate feedback, but the kernel doesn't know that.
-    //
-    // TODO(akshayka): Move all status management to the backend.
-    if (nextCell.status === "queued" || nextCell.status === "running") {
-      nextCell.status = "idle";
-    }
-
-    invariant(
-      Array.isArray(message.output.data),
-      "Expected error output data to be an array",
-    );
-    if (message.output.data.some((error) => error.type === "interruption")) {
-      // Interrupted helps distinguish that the cell is stale
-      nextCell.interrupted = true;
-      didInterruptFromThisMessage = true;
-    } else if (
-      message.output.data.some((error) => error.type.includes("ancestor"))
-    ) {
-      // The cell didn't run, but it was intentional, so don't count as
-      // errored.
-      nextCell.stopped = true;
-    } else {
-      // Communicate that the cell errored (e.g., an exception was raised)
-      nextCell.errored = true;
-    }
-  }
+  const interrupted = errorTypes(message.output).includes("interruption");
 
   // Coalesce console outputs, which are streamed during execution.
   let consoleOutputs = cell.consoleOutputs;
@@ -127,7 +57,7 @@ export function transitionCell(
   // stdin/pdb session, so resolve any dangling stdin prompt. This removes the
   // debugger box — e.g. after quitting pdb with `q`, which stops the cell
   // (idle) rather than interrupting it.
-  if (didInterruptFromThisMessage || message.status === "idle") {
+  if (interrupted || message.status === "idle") {
     nextCell.debuggerActive = false;
     consoleOutputs = consoleOutputs.map((output) => {
       if (output.channel === "stdin") {
@@ -177,30 +107,10 @@ export function transitionCell(
   return nextCell;
 }
 
-// Should be called when a cell's code is registered with the kernel for
-// execution.
-export function prepareCellForExecution(
-  cell: CellRuntimeState,
-): CellRuntimeState {
-  const nextCell = { ...cell };
-
-  if (cell.status !== "disabled-transitively") {
-    // TODO(akshayka): Move this to the backend. It's in the FE right now
-    // to give the user immediate feedback.
-    nextCell.status = "queued";
-  }
-  nextCell.interrupted = false;
-  nextCell.errored = false;
-  nextCell.runElapsedTimeMs = null;
-  nextCell.debuggerActive = false;
-
-  return nextCell;
-}
-
 /**
  * A cell's output is loading if it is running or queued.
  */
-export function outputIsLoading(status: RuntimeState): boolean {
+export function outputIsLoading(status: CellRunStatus): boolean {
   return status === "running" || status === "queued";
 }
 
@@ -208,16 +118,14 @@ export function outputIsLoading(status: RuntimeState): boolean {
  * A cell's output is stale if it has been edited, is loading, or has errored.
  */
 export function outputIsStale(
-  cell: Pick<
-    CellRuntimeState,
-    "status" | "output" | "runStartTimestamp" | "interrupted" | "staleInputs"
-  >,
+  execution: Pick<CellExecutionView, "status" | "outcome" | "rendered">,
+  staleInputs: boolean,
   edited: boolean,
 ): boolean {
-  const { status, output, runStartTimestamp, interrupted, staleInputs } = cell;
+  const { status, outcome, rendered } = execution;
 
   // If interrupted, the output is not stale
-  if (interrupted) {
+  if (outcome === "interrupted") {
     return false;
   }
 
@@ -226,18 +134,8 @@ export function outputIsStale(
     return true;
   }
 
-  // The cell is loading
-  const loading = outputIsLoading(status);
-
-  // Output is received while the cell is running (e.g. mo.output.append())
-  const outputReceivedWhileRunning =
-    status === "running" &&
-    output !== null &&
-    runStartTimestamp !== null &&
-    (output.timestamp ?? 0) > runStartTimestamp;
-
-  // If loading and output has not been received while running
-  if (loading && !outputReceivedWhileRunning) {
+  // Loading, unless the running cell has shown output (e.g. mo.output.append())
+  if (outputIsLoading(status) && !(status === "running" && rendered)) {
     return true;
   }