@marimo-team/islands 0.25.3-dev170 → 0.25.3-dev175

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

@@ -4,9 +4,11 @@ import { python } from "@codemirror/lang-python";
 import { EditorState } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
 import { createStore } from "jotai";
+import { createRef } from "react";
 import {
   afterAll,
   beforeAll,
+  afterEach,
   beforeEach,
   describe,
   expect,
@@ -16,11 +18,12 @@ import {
 import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
 import type { CellHandle } from "@/components/editor/notebook-cell";
-import { CellId, SCRATCH_CELL_ID, SETUP_CELL_ID } from "@/core/cells/ids";
+import { CellId, SCRATCH_CELL_ID } from "@/core/cells/ids";
 import { foldAllBulk, unfoldAllBulk } from "@/core/codemirror/editing/commands";
 import { adaptiveLanguageConfiguration } from "@/core/codemirror/language/extension";
 import { OverridingHotkeyProvider } from "@/core/hotkeys/hotkeys";
 import type { OutputMessage } from "@/core/kernel/messages";
+import type { CellConfig } from "@/core/network/types";
 import {
   type CollapsibleTree,
   MultiColumn,
@@ -38,7 +41,12 @@ import {
   scrollToBottom,
   scrollToTop,
 } from "../scrollCellIntoView";
-import type { CellData } from "../types";
+import {
+  type CellData,
+  createCell,
+  createCellConfig,
+  createCellRuntimeState,
+} from "../types";
 
 vi.mock("@/core/codemirror/editing/commands", () => ({
   foldAllBulk: vi.fn(),
@@ -119,8 +127,7 @@ describe("cell reducer", () => {
   let cells: ReturnType<typeof flattenTopLevelNotebookCells>;
   let firstCellId: CellId;
 
-  const actions = createActions((action) => {
-    state = reducer(state, action);
+  const mountEditors = () => {
     for (const [cellIdString, handle] of Object.entries(state.cellHandles)) {
       // @ts-expect-error - Typescript Object.entries doesn't know that keys are CellId
       const cid: CellId = cellIdString;
@@ -134,7 +141,76 @@ describe("cell reducer", () => {
       }
     }
     cells = flattenTopLevelNotebookCells(state);
-  });
+  };
+  const actions = createActions((action) => {
+    state = reducer(state, action);
+    mountEditors();
+  });
+
+  /** Put a cell into the notebook the way the document would. */
+  function seedCell({
+    cellId,
+    before,
+    code = "",
+    name,
+    config,
+    newCellId,
+    hideCode,
+    autoFocus = true,
+  }: {
+    cellId: CellId | "__end__" | { type: "__end__"; columnId: CellColumnId };
+    before: boolean;
+    code?: string;
+    name?: string;
+    config?: CellConfig;
+    newCellId?: CellId;
+    hideCode?: boolean;
+    autoFocus?: boolean;
+  }): CellId {
+    let column: CollapsibleTree<CellId>;
+    let cellIndex: number;
+    if (cellId === "__end__") {
+      column = state.cellIds.atOrThrow(0);
+      cellIndex = column.length;
+    } else if (typeof cellId === "string") {
+      column = state.cellIds.findWithId(cellId);
+      cellIndex = column.topLevelIds.indexOf(cellId);
+    } else {
+      column = state.cellIds.get(cellId.columnId) ?? state.cellIds.atOrThrow(0);
+      cellIndex = column.length;
+    }
+    const id = newCellId ?? CellId.create();
+    state = {
+      ...state,
+      cellIds: state.cellIds.insertId(
+        id,
+        column.id,
+        before ? cellIndex : cellIndex + 1,
+      ),
+      cellData: {
+        ...state.cellData,
+        [id]: createCell({
+          id,
+          code,
+          name,
+          config: createCellConfig({
+            ...config,
+            ...(hideCode != null && { hide_code: hideCode }),
+          }),
+          edited: Boolean(code),
+        }),
+      },
+      cellRuntime: { ...state.cellRuntime, [id]: createCellRuntimeState() },
+      cellHandles: { ...state.cellHandles, [id]: createRef() },
+      scrollKey: autoFocus ? id : null,
+      untouchedNewCells:
+        hideCode && autoFocus
+          ? new Set([...state.untouchedNewCells, id])
+          : state.untouchedNewCells,
+    };
+    mountEditors();
+    return id;
+  }
 
   let i = 0;
   const originalCreate = CellId.create.bind(CellId);
@@ -150,7 +226,7 @@ describe("cell reducer", () => {
 
     state = initialNotebookState();
     state.cellIds = MultiColumn.from([]);
-    actions.createNewCell({ cellId: "__end__", before: false });
+    seedCell({ cellId: "__end__", before: false });
     firstCellId = state.cellIds.inOrderIds[0];
   });
 
@@ -158,181 +234,6 @@ describe("cell reducer", () => {
     CellId.create = originalCreate;
   });
 
-  it("can add a cell after another cell", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [1] ''
-      "
-    `);
-  });
-
-  it("can add a cell to the end with code", () => {
-    actions.createNewCell({
-      cellId: "__end__",
-      code: "import numpy as np",
-      before: false,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [1] 'import numpy as np'
-      "
-    `);
-
-    // Cell should be added to the end and edited
-    expect(cells[1].code).toBe("import numpy as np");
-    expect(cells[1].edited).toBe(true);
-    expect(cells[1].lastCodeRun).toBe(null);
-  });
-
-  it("can add a cell before another cell", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: true,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [1] ''
-
-      [0] ''
-      "
-    `);
-  });
-
-  it("can add a cell with name and config", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-      code: "x = 1",
-      name: "My Cell",
-      config: { hide_code: true, disabled: false },
-    });
-    const newCellId = state.cellIds.inOrderIds[1];
-    expect(state.cellData[newCellId].name).toBe("My Cell");
-    expect(state.cellData[newCellId].config.hide_code).toBe(true);
-    expect(state.cellData[newCellId].config.disabled).toBe(false);
-  });
-
-  it("can delete a Python cell and undo delete", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-    });
-    actions.deleteCell({
-      cellId: firstCellId,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [1] ''
-      "
-    `);
-
-    // undo
-    actions.undoDeleteCell();
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [2] ''
-
-      [1] ''
-      "
-    `);
-
-    // Verify scrollKey is set to the restored cell
-    expect(state.scrollKey).toBe("2");
-  });
-
-  it("can delete a SQL cell and undo delete", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-      code: `df = mo.sql("""SELECT * FROM table""")`,
-    });
-    const newCellId = state.cellIds.getColumns()[0].atOrThrow(1);
-    actions.deleteCell({
-      cellId: newCellId,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-      "
-    `);
-
-    // undo
-    actions.undoDeleteCell();
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [2] 'df = mo.sql("""SELECT * FROM table""")'
-      "
-    `);
-  });
-
-  it("can delete a Markdown cell and undo delete", () => {
-    const text = "The quick brown fox jumps over the lazy dog.";
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-      code: `mo.md(r"""${text}""")`,
-    });
-    const newCellId = state.cellIds.getColumns()[0].atOrThrow(1);
-    actions.deleteCell({
-      cellId: newCellId,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-      "
-    `);
-
-    // undo
-    actions.undoDeleteCell();
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [2] 'mo.md(r"""The quick brown fox jumps over the lazy dog.""")'
-      "
-    `);
-  });
-
-  it("undo delete restores cell config (hide_code, disabled)", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-      code: "x = 1",
-    });
-    const newCellId = state.cellIds.getColumns()[0].atOrThrow(1);
-
-    // Set config to hidden and disabled
-    actions.updateCellConfig({
-      cellId: newCellId,
-      config: { hide_code: true, disabled: true },
-    });
-    expect(state.cellData[newCellId].config.hide_code).toBe(true);
-    expect(state.cellData[newCellId].config.disabled).toBe(true);
-
-    // Delete the cell
-    actions.deleteCell({ cellId: newCellId });
-    expect(state.cellIds.inOrderIds).not.toContain(newCellId);
-
-    // Undo delete
-    actions.undoDeleteCell();
-    const restoredCellId =
-      state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-
-    // Config should be preserved
-    expect(state.cellData[restoredCellId].config.hide_code).toBe(true);
-    expect(state.cellData[restoredCellId].config.disabled).toBe(true);
-  });
-
   it("can update a cell", () => {
     actions.updateCellCode({
       cellId: firstCellId,
@@ -347,7 +248,7 @@ describe("cell reducer", () => {
   });
 
   it("can move a cell", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
@@ -461,11 +362,11 @@ describe("cell reducer", () => {
   });
 
   it("can drag and drop a cell", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("1"),
       before: false,
     });
@@ -511,11 +412,11 @@ describe("cell reducer", () => {
   });
 
   it("can move a cell to an exact index within a column", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("1"),
       before: false,
     });
@@ -539,11 +440,11 @@ describe("cell reducer", () => {
   });
 
   it("can move a cell to an exact index across columns", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("1"),
       before: false,
     });
@@ -572,11 +473,11 @@ describe("cell reducer", () => {
   });
 
   it("moveCellToIndex is a no-op when moving to the same position", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("1"),
       before: false,
     });
@@ -594,7 +495,7 @@ describe("cell reducer", () => {
   });
 
   it("moveCellToIndex is a no-op for an invalid columnId", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
@@ -611,11 +512,11 @@ describe("cell reducer", () => {
   });
 
   it("can move multiple cells relative to target", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("1"),
       before: false,
     });
@@ -646,143 +547,6 @@ describe("cell reducer", () => {
     `);
   });
 
-  it("can undo cut-paste (move with previousPlacements)", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-    });
-    actions.createNewCell({
-      cellId: cellId("1"),
-      before: false,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [1] ''
-
-      [2] ''
-      "
-    `);
-
-    const col = state.cellIds.findWithId(firstCellId);
-    const previousPlacements = [
-      {
-        columnId: col.id,
-        index: col.indexOfOrThrow(
-          firstCellId,
-        ) as import("@/utils/id-tree").CellIndex,
-      },
-      {
-        columnId: col.id,
-        index: col.indexOfOrThrow(
-          cellId("1"),
-        ) as import("@/utils/id-tree").CellIndex,
-      },
-    ];
-
-    actions.moveCellsRelativeTo({
-      cellIds: [firstCellId, cellId("1")],
-      targetCellId: cellId("2"),
-      position: "after",
-      previousPlacements,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [2] ''
-
-      [0] ''
-
-      [1] ''
-      "
-    `);
-
-    actions.undoDeleteCell();
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [1] ''
-
-      [2] ''
-      "
-    `);
-  });
-
-  it("undo order: cut-paste then delete — first undo restores delete, second undo undoes move", () => {
-    actions.createNewCell({
-      cellId: firstCellId,
-      before: false,
-    });
-    actions.createNewCell({
-      cellId: cellId("1"),
-      before: false,
-    });
-
-    const col = state.cellIds.findWithId(firstCellId);
-    const previousPlacements = [
-      {
-        columnId: col.id,
-        index: col.indexOfOrThrow(
-          firstCellId,
-        ) as import("@/utils/id-tree").CellIndex,
-      },
-      {
-        columnId: col.id,
-        index: col.indexOfOrThrow(
-          cellId("1"),
-        ) as import("@/utils/id-tree").CellIndex,
-      },
-    ];
-
-    actions.moveCellsRelativeTo({
-      cellIds: [firstCellId, cellId("1")],
-      targetCellId: cellId("2"),
-      position: "after",
-      previousPlacements,
-    });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [2] ''
-
-      [0] ''
-
-      [1] ''
-      "
-    `);
-
-    actions.deleteCell({ cellId: cellId("2") });
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [1] ''
-      "
-    `);
-
-    actions.undoDeleteCell();
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [3] ''
-
-      [0] ''
-
-      [1] ''
-      "
-    `);
-
-    actions.undoDeleteCell();
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] ''
-
-      [1] ''
-
-      [3] ''
-      "
-    `);
-  });
-
   it("keeps error evidence after an edit and a new queued run", () => {
     const code = "raise ValueError('old failure')";
     const output: OutputMessage = {
@@ -1166,7 +930,7 @@ describe("cell reducer", () => {
       formattingChange: false,
     });
     // Add cell
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
@@ -1271,33 +1035,6 @@ describe("cell reducer", () => {
     expect(cell.edited).toBe(false);
   });
 
-  it("can update a cells config", () => {
-    const firstCellId = cells[0].id;
-    let cell = cells[0];
-    // Starts empty
-    expect(cell.config).toEqual({
-      disabled: false,
-      hide_code: false,
-      column: null,
-      expand_output: false,
-    });
-
-    actions.updateCellConfig({
-      cellId: firstCellId,
-      config: { disabled: true },
-    });
-    cell = cells[0];
-    expect(cell.config.disabled).toBe(true);
-
-    // Revert
-    actions.updateCellConfig({
-      cellId: firstCellId,
-      config: { disabled: false },
-    });
-    cell = cells[0];
-    expect(cell.config.disabled).toBe(false);
-  });
-
   it("can run a stopped cell", () => {
     // Update code of first cell
     actions.updateCellCode({
@@ -1703,8 +1440,8 @@ describe("cell reducer", () => {
   });
 
   it("can send a cell to the top", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
     actions.sendToTop({ cellId: cellId("2") });
     expect(formatCells(state)).toMatchInlineSnapshot(`
       "
@@ -1718,8 +1455,8 @@ describe("cell reducer", () => {
   });
 
   it("can send a cell to the bottom", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
     actions.sendToBottom({ cellId: firstCellId });
     expect(formatCells(state)).toMatchInlineSnapshot(`
       "
@@ -1733,8 +1470,8 @@ describe("cell reducer", () => {
   });
 
   it("can focus cells", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
 
     actions.focusCell({ cellId: cellId("1"), where: "before" });
     expect(focusAndScrollCellIntoView).toHaveBeenCalledWith(
@@ -1750,11 +1487,6 @@ describe("cell reducer", () => {
     expect(scrollToBottom).toHaveBeenCalled();
   });
 
-  it("can update cell name", () => {
-    actions.updateCellName({ cellId: firstCellId, name: "Test Cell" });
-    expect(state.cellData[firstCellId].name).toBe("Test Cell");
-  });
-
   it("can fold and unfold all cells", () => {
     actions.foldAll();
     expect(foldAllBulk).toHaveBeenCalled();
@@ -1783,13 +1515,13 @@ describe("cell reducer", () => {
   });
 
   it("can collapse and expand cells", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({
       cellId: cellId("1"),
       before: false,
       code: "# Header",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("2"),
       before: false,
       code: "## Subheader",
@@ -1811,13 +1543,13 @@ describe("cell reducer", () => {
   });
 
   it("can collapse and expand all cells in multiple columns", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({
       cellId: cellId("1"),
       before: false,
       code: "# First Column Header",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("2"),
       before: false,
       code: "## First Column Subheader",
@@ -1825,12 +1557,12 @@ describe("cell reducer", () => {
 
     actions.addColumnBreakpoint({ cellId: cellId("2") });
 
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("3"),
       before: false,
       code: "# Second Column Header",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("4"),
       before: false,
       code: "## Second Column Subheader",
@@ -1878,18 +1610,18 @@ describe("cell reducer", () => {
   });
 
   it("can collapse and expand nested cells in one call", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({
       cellId: cellId("1"),
       before: false,
       code: "# Header",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("2"),
       before: false,
       code: "## Subheader",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("3"),
       before: false,
       code: "### Subsubheader",
@@ -1933,18 +1665,18 @@ describe("cell reducer", () => {
   });
 
   it("can collapse all cells when nested heading ranges end at the same cell", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({
       cellId: cellId("1"),
       before: false,
       code: "# Header",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("2"),
       before: false,
       code: "## Subheader",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("3"),
       before: false,
       code: "### Subsubheader",
@@ -1998,23 +1730,23 @@ describe("cell reducer", () => {
   });
 
   it("can collapse all cells when a deep chain is followed by a later section", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({
       cellId: cellId("1"),
       before: false,
       code: "# Header",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("2"),
       before: false,
       code: "## Section A",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("3"),
       before: false,
       code: "### Sub of A",
     });
-    actions.createNewCell({
+    seedCell({
       cellId: cellId("4"),
       before: false,
       code: "## Section B",
@@ -2077,8 +1809,8 @@ describe("cell reducer", () => {
   });
 
   it("can show hidden cells", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
     actions.collapseCell({ cellId: firstCellId });
 
     actions.showCellIfHidden({ cellId: cellId("1") });
@@ -2088,7 +1820,7 @@ describe("cell reducer", () => {
   });
 
   it("can split and undo split cells", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
       code: "line1\nline2",
@@ -2155,9 +1887,9 @@ describe("cell reducer", () => {
   });
 
   it("can add a column breakpoint", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-    actions.createNewCell({ cellId: cellId("2"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: cellId("2"), before: false });
 
     expect(state.cellIds.getColumns().length).toBe(1);
     expect(formatCells(state)).toMatchInlineSnapshot(`
@@ -2202,16 +1934,16 @@ describe("cell reducer", () => {
 
   it("cannot add a column breakpoint before the first cell", () => {
     expect(state.cellIds.getColumns().length).toBe(1);
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
     actions.addColumnBreakpoint({ cellId: firstCellId });
     expect(state.cellIds.getColumns().length).toBe(1);
   });
 
   it("can delete a column", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-    actions.createNewCell({ cellId: cellId("2"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: cellId("2"), before: false });
     actions.addColumnBreakpoint({ cellId: cellId("2") });
 
     expect(state.cellIds.getColumns().length).toBe(2);
@@ -2255,8 +1987,8 @@ describe("cell reducer", () => {
   });
 
   it("deleting the last column does nothing", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
 
     const initialState = { ...state };
 
@@ -2267,9 +1999,9 @@ describe("cell reducer", () => {
   });
 
   it("can drop a cell over another cell", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-    actions.createNewCell({ cellId: cellId("2"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: cellId("2"), before: false });
 
     expect(formatCells(state)).toMatchInlineSnapshot(`
       "
@@ -2302,8 +2034,8 @@ describe("cell reducer", () => {
   });
 
   it("can drop a cell over a new column", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
 
     expect(state.cellIds.getColumns().length).toBe(1);
     expect(formatCells(state)).toMatchInlineSnapshot(`
@@ -2340,9 +2072,9 @@ describe("cell reducer", () => {
   });
 
   it("can drop a column over another column", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-    actions.createNewCell({ cellId: cellId("2"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: cellId("2"), before: false });
     actions.addColumnBreakpoint({ cellId: cellId("2") });
 
     expect(state.cellIds.getColumns().length).toBe(2);
@@ -2393,8 +2125,8 @@ describe("cell reducer", () => {
 
   it("can compact columns", () => {
     // Create initial state with 3 columns, including an empty one
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
+    seedCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: cellId("1"), before: false });
     actions.addColumnBreakpoint({ cellId: cellId("1") });
     actions.addColumnBreakpoint({ cellId: cellId("2") });
     actions.dropOverNewColumn({ cellId: cellId("2") });
@@ -2533,7 +2265,7 @@ describe("cell reducer", () => {
 
   it("can clear output of all cells", () => {
     // Create multiple cells with output
-    actions.createNewCell({ cellId: firstCellId, before: false });
+    seedCell({ cellId: firstCellId, before: false });
     const secondCellId = state.cellIds.atOrThrow(FIRST_COLUMN).atOrThrow(1);
 
     // Add output to both cells
@@ -2580,121 +2312,9 @@ describe("cell reducer", () => {
     expect(state.cellRuntime[secondCellId].consoleOutputs).toEqual([]);
   });
 
-  it("skips creating new cell if code exists and skipIfCodeExists is true", () => {
-    // Add initial cell with code
-    actions.updateCellCode({
-      cellId: firstCellId,
-      code: "import numpy as np",
-      formattingChange: false,
-    });
-
-    // Try to create new cell with same code and skipIfCodeExists
-    actions.createNewCell({
-      cellId: "__end__",
-      code: "import numpy as np",
-      before: false,
-      skipIfCodeExists: true,
-    });
-
-    // Should still only have one cell
-    expect(state.cellIds.inOrderIds.length).toBe(1);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] 'import numpy as np'
-      "
-    `);
-
-    // Verify we can still add cell with different code
-    actions.createNewCell({
-      cellId: "__end__",
-      code: "import pandas as pd",
-      before: false,
-      skipIfCodeExists: true,
-    });
-
-    expect(state.cellIds.inOrderIds.length).toBe(2);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [0] 'import numpy as np'
-
-      [1] 'import pandas as pd'
-      "
-    `);
-  });
-
-  it("can create and noop-update a setup cell", () => {
-    // Create the setup cell
-    actions.addSetupCellIfDoesntExist({ code: "# Setup code" });
-
-    // Check that setup cell was created
-    expect(state.cellData[SETUP_CELL_ID].id).toBe(SETUP_CELL_ID);
-    expect(state.cellData[SETUP_CELL_ID].name).toBe("setup");
-    expect(state.cellData[SETUP_CELL_ID].code).toBe("# Setup code");
-    expect(state.cellData[SETUP_CELL_ID].edited).toBe(true);
-    expect(state.cellIds.inOrderIds).toContain(SETUP_CELL_ID);
-
-    // Update the setup cell
-    actions.addSetupCellIfDoesntExist({ code: "# Updated setup code" });
-
-    // Check that the setup cell did not change, since it already exists
-    expect(state.cellData[SETUP_CELL_ID].code).toBe("# Setup code");
-    expect(state.cellData[SETUP_CELL_ID].edited).toBe(true);
-    expect(state.cellIds.inOrderIds).toContain(SETUP_CELL_ID);
-  });
-
-  it("can delete and undelete the setup cell", () => {
-    // Create the setup cell
-    actions.addSetupCellIfDoesntExist({ code: "# Setup code" });
-
-    // Check that setup cell was created
-    expect(state.cellData[SETUP_CELL_ID].id).toBe(SETUP_CELL_ID);
-    expect(state.cellData[SETUP_CELL_ID].name).toBe("setup");
-    expect(state.cellData[SETUP_CELL_ID].code).toBe("# Setup code");
-    expect(state.cellData[SETUP_CELL_ID].edited).toBe(true);
-    expect(state.cellIds.inOrderIds).toContain(SETUP_CELL_ID);
-
-    // Delete the setup cell
-    actions.deleteCell({ cellId: SETUP_CELL_ID });
-
-    // Check that setup cell was deleted
-    expect(state.cellData[SETUP_CELL_ID]).toBeDefined(); // we keep old state
-    expect(state.cellIds.inOrderIds).not.toContain(SETUP_CELL_ID);
-
-    // Undo delete the setup cell
-    actions.undoDeleteCell();
-
-    // Check that setup cell was restored
-    expect(state.cellData[SETUP_CELL_ID].id).toBe(SETUP_CELL_ID);
-    expect(state.cellData[SETUP_CELL_ID].name).toBe("setup");
-    expect(state.cellData[SETUP_CELL_ID].code).toBe("# Setup code");
-    expect(state.cellData[SETUP_CELL_ID].edited).toBe(true);
-    expect(state.cellIds.inOrderIds).toContain(SETUP_CELL_ID);
-
-    // Verify scrollKey is set to the restored setup cell
-    expect(state.scrollKey).toBe(SETUP_CELL_ID);
-  });
-
-  it("can delete and then create a new setup cell", () => {
-    // Create the setup cell
-    actions.addSetupCellIfDoesntExist({ code: "# Setup code" });
-
-    // Delete the setup cell
-    actions.deleteCell({ cellId: SETUP_CELL_ID });
-
-    // Create a new setup cell
-    actions.addSetupCellIfDoesntExist({ code: "# New code" });
-
-    // Check that the new setup cell was created
-    expect(state.cellData[SETUP_CELL_ID].id).toBe(SETUP_CELL_ID);
-    expect(state.cellData[SETUP_CELL_ID].name).toBe("setup");
-    expect(state.cellData[SETUP_CELL_ID].code).toBe("# New code");
-    expect(state.cellData[SETUP_CELL_ID].edited).toBe(true);
-    expect(state.cellIds.inOrderIds).toContain(SETUP_CELL_ID);
-  });
-
   it("can clear all outputs", () => {
     // Add a cell and give it output
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
@@ -2722,202 +2342,14 @@ describe("cell reducer", () => {
     expect(state.cellRuntime[cell2Id].output).toBeNull();
   });
 
-  describe("moveToNextCell", () => {
-    let cell1Id: CellId;
-    let cell2Id: CellId;
-    let cell3Id: CellId;
-
-    beforeEach(() => {
-      // Create a few cells to work with
-      actions.createNewCell({ cellId: "__end__", before: false });
-      actions.createNewCell({ cellId: "__end__", before: false });
-
-      cell1Id = state.cellIds.inOrderIds[0];
-      cell2Id = state.cellIds.inOrderIds[1];
-      cell3Id = state.cellIds.inOrderIds[2];
-    });
-
-    it("creates new cell when moving after last cell with noCreate=false", () => {
-      const initialCellCount = state.cellIds.inOrderIds.length;
-
-      actions.moveToNextCell({
-        cellId: cell3Id,
-        before: false,
-        noCreate: false,
-      });
-
-      expect(state.cellIds.inOrderIds.length).toBe(initialCellCount + 1);
-    });
-
-    it("creates new cell when moving before first cell with noCreate=false", () => {
-      const initialCellCount = state.cellIds.inOrderIds.length;
-
-      actions.moveToNextCell({
-        cellId: cell1Id,
-        before: true,
-        noCreate: false,
-      });
-
-      expect(state.cellIds.inOrderIds.length).toBe(initialCellCount + 1);
-    });
-
-    it("does not create new cell when moving after last cell with noCreate=true", () => {
-      const initialCellCount = state.cellIds.inOrderIds.length;
-      const initialState = { ...state };
-
-      actions.moveToNextCell({
-        cellId: cell3Id,
-        before: false,
-        noCreate: true,
-      });
-
-      // Should not create a new cell
-      expect(state.cellIds.inOrderIds.length).toBe(initialCellCount);
-      // Should not crash or throw an error
-      expect(state.cellIds.inOrderIds).toEqual(initialState.cellIds.inOrderIds);
-    });
-
-    it("does not create new cell when moving before first cell with noCreate=true", () => {
-      const initialCellCount = state.cellIds.inOrderIds.length;
-      const initialState = { ...state };
-
-      actions.moveToNextCell({ cellId: cell1Id, before: true, noCreate: true });
-
-      // Should not create a new cell
-      expect(state.cellIds.inOrderIds.length).toBe(initialCellCount);
-      // Should not crash or throw an error
-      expect(state.cellIds.inOrderIds).toEqual(initialState.cellIds.inOrderIds);
-    });
-
-    it("focuses next cell when moving within bounds", () => {
-      const focusSpy = vi.mocked(focusAndScrollCellIntoView);
-      focusSpy.mockClear();
-
-      actions.moveToNextCell({
-        cellId: cell1Id,
-        before: false,
-        noCreate: true,
-      });
-
-      expect(focusSpy).toHaveBeenCalledWith({
-        cellId: cell2Id,
-        cell: state.cellHandles[cell2Id],
-        isCodeHidden: false,
-        codeFocus: "top",
-        variableName: undefined,
-      });
-    });
-
-    it("focuses previous cell when moving backward within bounds", () => {
-      const focusSpy = vi.mocked(focusAndScrollCellIntoView);
-      focusSpy.mockClear();
-
-      actions.moveToNextCell({ cellId: cell2Id, before: true, noCreate: true });
-
-      expect(focusSpy).toHaveBeenCalledWith({
-        cellId: cell1Id,
-        cell: state.cellHandles[cell1Id],
-        isCodeHidden: false,
-        codeFocus: "bottom",
-        variableName: undefined,
-      });
-    });
-
-    it("does not move focus from scratch cell", () => {
-      const focusSpy = vi.mocked(focusAndScrollCellIntoView);
-      focusSpy.mockClear();
-      const initialState = { ...state };
-
-      actions.moveToNextCell({
-        cellId: SCRATCH_CELL_ID,
-        before: false,
-        noCreate: false,
-      });
-
-      expect(focusSpy).not.toHaveBeenCalled();
-      expect(state.cellIds.inOrderIds).toEqual(initialState.cellIds.inOrderIds);
-    });
-  });
-
   describe("untouched cells functionality", () => {
     it("starts with empty untouchedNewCells set", () => {
       expect(state.untouchedNewCells).toEqual(new Set());
     });
 
-    it("can create a new cell with hideCode option", () => {
-      const initialCellCount = state.cellIds.inOrderIds.length;
-
-      actions.createNewCell({
-        cellId: "__end__",
-        before: false,
-        hideCode: true,
-      });
-
-      expect(state.cellIds.inOrderIds.length).toBe(initialCellCount + 1);
-      const newCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(newCellId)).toBe(true);
-    });
-
-    it("adds interactively-created hidden cell with boilerplate code to untouchedNewCells", () => {
-      // Markdown cells are created with hideCode and non-empty default code
-      // (e.g. `mo.md(r"""\n""")`). They are user-initiated, so their editor
-      // should be shown until first blur.
-      actions.createNewCell({
-        cellId: "__end__",
-        before: false,
-        code: 'mo.md(r"""\n""")',
-        hideCode: true,
-        autoFocus: true,
-      });
-
-      const newCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(newCellId)).toBe(true);
-    });
-
-    it("does not add programmatically-created hidden cell with code to untouchedNewCells", () => {
-      // Cells created by the kernel (e.g. via code_mode) carry code and
-      // autoFocus=false; their hide_code must take effect immediately.
-      actions.createNewCell({
-        cellId: "__end__",
-        before: false,
-        code: "x = 1",
-        hideCode: true,
-        autoFocus: false,
-      });
-
-      const newCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(newCellId)).toBe(false);
-    });
-
-    it("does not add cell to untouchedNewCells when hideCode is false", () => {
-      actions.createNewCell({
-        cellId: "__end__",
-        before: false,
-        hideCode: false,
-      });
-
-      const newCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(newCellId)).toBe(false);
-    });
-
-    it("does not add cell to untouchedNewCells when hideCode is undefined", () => {
-      actions.createNewCell({
-        cellId: "__end__",
-        before: false,
-      });
-
-      const newCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(newCellId)).toBe(false);
-    });
-
     it("can mark a cell as touched", () => {
       // Create a cell with hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
@@ -2935,7 +2367,7 @@ describe("cell reducer", () => {
 
     it("markTouched is idempotent", () => {
       // Create a cell with hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
@@ -2965,17 +2397,17 @@ describe("cell reducer", () => {
 
     it("can handle multiple untouched cells", () => {
       // Create multiple cells with hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
       });
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
       });
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: false,
@@ -3000,12 +2432,12 @@ describe("cell reducer", () => {
 
     it("preserves untouched state when cells are moved", () => {
       // Create cells with hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
       });
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
@@ -3029,58 +2461,9 @@ describe("cell reducer", () => {
       expect(state.untouchedNewCells.has(cell2Id)).toBe(true);
     });
 
-    it("does not remove untouched state when cell is deleted", () => {
-      // We could implement this, but it doesn't actually affect downstream behavior.
-      // It is easier to leave it, so `undo` works as expected.
-
-      // Create a cell with hideCode
-      actions.createNewCell({
-        cellId: "__end__",
-        before: false,
-        hideCode: true,
-      });
-
-      const newCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(newCellId)).toBe(true);
-
-      // Delete the cell
-      actions.deleteCell({ cellId: newCellId });
-
-      // Does not actually remove untouched state
-      expect(state.untouchedNewCells.has(newCellId)).toBe(true);
-    });
-
-    it("restores untouched state when cell deletion is undone", () => {
-      // Create a cell with hideCode
-      actions.createNewCell({
-        cellId: "__end__",
-        before: false,
-        hideCode: true,
-      });
-
-      const newCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(newCellId)).toBe(true);
-
-      // Delete the cell
-      actions.deleteCell({ cellId: newCellId });
-      // Still exists in untouchedNewCells
-      expect(state.untouchedNewCells.has(newCellId)).toBe(true);
-
-      // Undo the deletion
-      actions.undoDeleteCell();
-
-      // The cell should be restored but no longer untouched
-      // (this is expected behavior - undoing doesn't restore untouched state)
-      const restoredCellId =
-        state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
-      expect(state.untouchedNewCells.has(restoredCellId)).toBe(false);
-    });
-
     it("untouched cell behavior with hide_code config", () => {
       // Create a cell with hideCode and hide_code config
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
@@ -3089,11 +2472,11 @@ describe("cell reducer", () => {
       const newCellId =
         state.cellIds.inOrderIds[state.cellIds.inOrderIds.length - 1];
 
-      // Update the cell config to hide code
-      actions.updateCellConfig({
-        cellId: newCellId,
-        config: { hide_code: true },
-      });
+      // The document hides the cell's code
+      state.cellData[newCellId] = {
+        ...state.cellData[newCellId],
+        config: { ...state.cellData[newCellId].config, hide_code: true },
+      };
 
       // Cell should be untouched and have hide_code config
       expect(state.untouchedNewCells.has(newCellId)).toBe(true);
@@ -3112,7 +2495,7 @@ describe("cell reducer", () => {
 
     it("can mark an existing cell as untouched", () => {
       // Create a cell without hideCode (not in untouchedNewCells)
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: false,
@@ -3130,7 +2513,7 @@ describe("cell reducer", () => {
 
     it("markUntouched is idempotent", () => {
       // Create a cell without hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: false,
@@ -3150,7 +2533,7 @@ describe("cell reducer", () => {
 
     it("markUntouched does not affect already untouched cells", () => {
       // Create a cell with hideCode (already in untouchedNewCells)
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
@@ -3168,7 +2551,7 @@ describe("cell reducer", () => {
 
     it("markTouched and markUntouched can toggle cell state", () => {
       // Create a cell without hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: false,
@@ -3196,7 +2579,7 @@ describe("cell reducer", () => {
     it("markUntouched works for markdown cell conversion scenario", () => {
       // Simulates converting a Python cell to Markdown
       // 1. Create a regular cell (no hideCode)
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: false,
@@ -3210,11 +2593,12 @@ describe("cell reducer", () => {
       expect(state.untouchedNewCells.has(cellId)).toBe(false);
       expect(exportedForTesting.isCellCodeHidden(state, cellId)).toBe(false);
 
-      // 2. Convert to markdown: set hide_code and mark as untouched
-      actions.updateCellConfig({
-        cellId,
-        config: { hide_code: true },
-      });
+      // 2. Convert to markdown: the document hides the code, and the cell
+      // is marked untouched
+      state.cellData[cellId] = {
+        ...state.cellData[cellId],
+        config: { ...state.cellData[cellId].config, hide_code: true },
+      };
       actions.markUntouched({ cellId });
 
       // Code should NOT be hidden because cell is untouched (user can edit)
@@ -3236,7 +2620,7 @@ describe("cell reducer", () => {
       const { cellDataAtom, cellRuntimeAtom, cellHandleAtom } =
         exportedForTesting;
 
-      actions.createNewCell({ cellId: firstCellId, before: false });
+      seedCell({ cellId: firstCellId, before: false });
       const newCellId = state.cellIds.inOrderIds[1];
 
       const dataAtom1 = cellDataAtom(newCellId);
@@ -3252,31 +2636,6 @@ describe("cell reducer", () => {
       expect(runtimeAtom2).toBe(runtimeAtom1);
       expect(handleAtom2).toBe(handleAtom1);
     });
-
-    it("cleans up atom family cache when cells are deleted", () => {
-      const { cellDataAtom, cellRuntimeAtom, cellHandleAtom } =
-        exportedForTesting;
-
-      actions.createNewCell({ cellId: firstCellId, before: false });
-      const newCellId = state.cellIds.inOrderIds[1];
-
-      // Access to create cache entries
-      const dataAtom1 = cellDataAtom(newCellId);
-      const runtimeAtom1 = cellRuntimeAtom(newCellId);
-      const handleAtom1 = cellHandleAtom(newCellId);
-
-      // Triggers purge
-      actions.deleteCell({ cellId: newCellId });
-
-      // Access again (should be new instances after cleanup)
-      const dataAtom2 = cellDataAtom(newCellId);
-      const runtimeAtom2 = cellRuntimeAtom(newCellId);
-      const handleAtom2 = cellHandleAtom(newCellId);
-
-      expect(dataAtom2).not.toBe(dataAtom1);
-      expect(runtimeAtom2).not.toBe(runtimeAtom1);
-      expect(handleAtom2).not.toBe(handleAtom1);
-    });
   });
 });
 
@@ -3591,31 +2950,9 @@ describe("createTracebackInfoAtom", () => {
   });
 });
 
-describe("setCells snapshot preservation", () => {
+describe("kernel-ready", () => {
   const CELL_A = cellId("A");
   const CELL_B = cellId("B");
-  const newCells: CellData[] = [
-    {
-      id: CELL_A,
-      name: "a",
-      code: "1",
-      edited: false,
-      lastCodeRun: null,
-      lastExecutionTime: null,
-      config: { hide_code: false, disabled: false, column: null },
-      serializedEditorState: null,
-    },
-    {
-      id: CELL_B,
-      name: "b",
-      code: "2",
-      edited: false,
-      lastCodeRun: null,
-      lastExecutionTime: null,
-      config: { hide_code: false, disabled: false, column: null },
-      serializedEditorState: null,
-    },
-  ];
 
   const hydratedState = () =>
     MockNotebook.notebookState({
@@ -3645,44 +2982,97 @@ describe("setCells snapshot preservation", () => {
       },
     });
 
-  beforeEach(async () => {
-    const { isWasm } = await import("@/core/wasm/utils");
-    vi.mocked(isWasm).mockReturnValue(true);
+  it("setLastRun records what the kernel last ran", () => {
+    const state = hydratedState();
+    const next = exportedForTesting.reducer(state, {
+      type: "setLastRun",
+      payload: {
+        lastCodeRun: { [CELL_A]: "0" },
+        lastExecutionTime: { [CELL_A]: 5 },
+      },
+    });
+
+    expect(next.cellData[CELL_A]).toMatchObject({
+      lastCodeRun: "0",
+      lastExecutionTime: 5,
+      edited: true,
+    });
+    expect(next.cellData[CELL_B]).toMatchObject({
+      lastCodeRun: null,
+      lastExecutionTime: null,
+      edited: false,
+    });
+    expect(next.cellRuntime).toBe(state.cellRuntime);
   });
 
-  it("preserves hydrated output in WASM", () => {
+  it("resetCellRuntimes starts every cell's runtime over", () => {
     const next = exportedForTesting.reducer(hydratedState(), {
-      type: "setCells",
-      payload: newCells,
+      type: "resetCellRuntimes",
+      payload: undefined,
     });
 
-    expect(next.cellRuntime[CELL_A].output).toMatchObject({
-      data: "hydrated-A",
+    expect(next.cellRuntime[CELL_A].output).toBeNull();
+    expect(next.cellRuntime[CELL_B].consoleOutputs).toEqual([]);
+  });
+
+  it("resetCellRuntimes starts the scratch cell over too", () => {
+    const state = MockNotebook.notebookState({
+      cellData: { [CELL_A]: { id: CELL_A, code: "1" } },
+      cellRuntime: {
+        [SCRATCH_CELL_ID]: {
+          output: {
+            channel: "output",
+            mimetype: "text/plain",
+            data: "scratch",
+            timestamp: 0,
+          },
+        },
+      },
     });
+    const next = exportedForTesting.reducer(state, {
+      type: "resetCellRuntimes",
+      payload: undefined,
+    });
+
+    expect(next.cellRuntime[SCRATCH_CELL_ID].output).toBeNull();
   });
 
-  it("preserves console-only hydration in WASM", () => {
-    const next = exportedForTesting.reducer(hydratedState(), {
-      type: "setCells",
-      payload: newCells,
+  describe("resetCellRuntimes in WASM", () => {
+    beforeEach(async () => {
+      const { isWasm } = await import("@/core/wasm/utils");
+      vi.mocked(isWasm).mockReturnValue(true);
     });
 
-    expect(next.cellRuntime[CELL_B].consoleOutputs).toHaveLength(1);
-    expect(next.cellRuntime[CELL_B].consoleOutputs[0]).toMatchObject({
-      data: "hydrated-B-stdout",
+    afterEach(async () => {
+      const { isWasm } = await import("@/core/wasm/utils");
+      vi.mocked(isWasm).mockReturnValue(false);
     });
-  });
 
-  it("resets cells with no prior runtime even in WASM", () => {
-    const empty = MockNotebook.notebookState({ cellData: {} });
-    const next = exportedForTesting.reducer(empty, {
-      type: "setCells",
-      payload: newCells,
+    it("keeps hydrated outputs and console", () => {
+      const next = exportedForTesting.reducer(hydratedState(), {
+        type: "resetCellRuntimes",
+        payload: undefined,
+      });
+
+      expect(next.cellRuntime[CELL_A].output).toMatchObject({
+        data: "hydrated-A",
+      });
+      expect(next.cellRuntime[CELL_B].consoleOutputs[0]).toMatchObject({
+        data: "hydrated-B-stdout",
+      });
     });
 
-    expect(next.cellRuntime[CELL_A].output).toBeNull();
-    expect(next.cellRuntime[CELL_A].consoleOutputs).toEqual([]);
-    expect(next.cellRuntime[CELL_B].output).toBeNull();
-    expect(next.cellRuntime[CELL_B].consoleOutputs).toEqual([]);
+    it("starts cells with no prior runtime over", () => {
+      const state = MockNotebook.notebookState({
+        cellData: { [CELL_A]: { id: CELL_A, code: "1" } },
+      });
+      const next = exportedForTesting.reducer(state, {
+        type: "resetCellRuntimes",
+        payload: undefined,
+      });
+
+      expect(next.cellRuntime[CELL_A].output).toBeNull();
+      expect(next.cellRuntime[CELL_A].consoleOutputs).toEqual([]);
+    });
   });
 });