@marimo-team/islands 0.25.3-dev19 → 0.25.3-dev191

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

@@ -4,10 +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,
-  afterEach,
   beforeAll,
+  afterEach,
   beforeEach,
   describe,
   expect,
@@ -17,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,
@@ -34,13 +36,17 @@ import {
   type NotebookState,
   notebookAtom,
 } from "../cells";
-import { exportedForTesting as documentTransactionTestExports } from "../document-changes";
 import {
   focusAndScrollCellIntoView,
   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(),
@@ -121,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;
@@ -136,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);
@@ -152,193 +226,14 @@ 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];
   });
 
-  afterEach(() => {
-    documentTransactionTestExports.cancelPendingChanges();
-  });
-
   afterAll(() => {
     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,
@@ -353,7 +248,7 @@ describe("cell reducer", () => {
   });
 
   it("can move a cell", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
@@ -467,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,
     });
@@ -517,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,
     });
@@ -545,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,
     });
@@ -578,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,
     });
@@ -600,7 +495,7 @@ describe("cell reducer", () => {
   });
 
   it("moveCellToIndex is a no-op for an invalid columnId", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
@@ -617,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,
     });
@@ -652,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 = {
@@ -1172,7 +930,7 @@ describe("cell reducer", () => {
       formattingChange: false,
     });
     // Add cell
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
     });
@@ -1277,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({
@@ -1579,7 +1310,9 @@ describe("cell reducer", () => {
       response: secret,
     });
 
-    expect(cells[0].consoleOutputs).toEqual([{ ...prompt, response: "" }]);
+    expect(cells[0].consoleOutputs).toEqual([
+      { ...prompt, id: 1, response: "" },
+    ]);
     expect(JSON.stringify(cells[0].consoleOutputs)).not.toContain(secret);
   });
 
@@ -1707,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(`
       "
@@ -1722,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(`
       "
@@ -1737,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(
@@ -1754,199 +1487,13 @@ 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 set cell IDs and codes", () => {
-    const newIds = [cellId("3"), cellId("4"), cellId("5")];
-    const newCodes = ["code1", "code2", "code3"];
-
-    actions.setCellIds({ cellIds: newIds });
-    expect(state.cellIds.atOrThrow(FIRST_COLUMN).topLevelIds).toEqual(newIds);
+  it("can fold and unfold all cells", () => {
+    actions.foldAll();
+    expect(foldAllBulk).toHaveBeenCalled();
 
-    // When codeIsStale is false, lastCodeRun should match code
-    actions.setCellCodes({
-      codes: newCodes,
-      ids: newIds,
-      codeIsStale: false,
-    });
-    newIds.forEach((id, index) => {
-      expect(state.cellData[id].code).toBe(newCodes[index]);
-      expect(state.cellData[id].lastCodeRun).toBe(newCodes[index]);
-      expect(state.cellData[id].edited).toBe(false);
-    });
-
-    // When codeIsStale is true, lastCodeRun should not change
-    const staleCodes = ["stale1", "stale2", "stale3"];
-    actions.setCellCodes({
-      codes: staleCodes,
-      ids: newIds,
-      codeIsStale: true,
-    });
-    newIds.forEach((id, index) => {
-      expect(state.cellData[id].code).toBe(staleCodes[index]);
-      expect(state.cellData[id].lastCodeRun).toBe(newCodes[index]);
-      expect(state.cellData[id].edited).toBe(true);
-    });
-  });
-
-  it("can can add a new cell with/without stale code", () => {
-    actions.setCellCodes({
-      codes: ["new code"],
-      ids: [cellId("2")],
-      codeIsStale: false,
-    });
-
-    expect(state.cellData[cellId("2")].code).toBe("new code");
-    expect(state.cellData[cellId("2")].edited).toBe(false);
-    expect(state.cellData[cellId("2")].lastCodeRun).toBe("new code");
-
-    actions.setCellCodes({
-      codes: ["new code 2"],
-      ids: [cellId("9")],
-      codeIsStale: true,
-    });
-
-    expect(state.cellData[cellId("9")].code).toBe("new code 2");
-    expect(state.cellData[cellId("9")].edited).toBe(true);
-    expect(state.cellData[cellId("9")].lastCodeRun).toBe(null);
-  });
-
-  it("can partial update cell codes", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-
-    expect(state.cellIds.inOrderIds).toEqual([
-      cellId("0"),
-      cellId("1"),
-      cellId("2"),
-    ]);
-    expect(state.cellData[cellId("0")].code).toBe("");
-    expect(state.cellData[cellId("1")].code).toBe("");
-    expect(state.cellData[cellId("2")].code).toBe("");
-
-    // Update cell 1
-    actions.setCellCodes({
-      codes: ["new code 2"],
-      ids: [cellId("1")],
-      codeIsStale: false,
-    });
-
-    expect(state.cellIds.inOrderIds).toEqual([
-      cellId("0"),
-      cellId("1"),
-      cellId("2"),
-    ]);
-    expect(state.cellData[cellId("0")].code).toBe("");
-    expect(state.cellData[cellId("1")].code).toBe("new code 2");
-    expect(state.cellData[cellId("1")].edited).toBe(false);
-    expect(state.cellData[cellId("2")].code).toBe("");
-  });
-
-  it("can set cell codes with new cell ids, while preserving the old cell data", () => {
-    actions.setCellCodes({
-      codes: ["code1", "code2", "code3"],
-      ids: [cellId("3"), cellId("4"), cellId("5")],
-      codeIsStale: false,
-    });
-    expect(state.cellData[cellId("3")].code).toBe("code1");
-    expect(state.cellData[cellId("4")].code).toBe("code2");
-    expect(state.cellData[cellId("5")].code).toBe("code3");
-
-    // Update with some new cell ids and some old cell ids
-    actions.setCellIds({
-      cellIds: [cellId("1"), cellId("2"), cellId("3"), cellId("4")],
-    });
-    actions.setCellCodes({
-      codes: ["new1", "new2", "code1", "code2"],
-      ids: [cellId("1"), cellId("2"), cellId("3"), cellId("4")],
-      codeIsStale: false,
-    });
-    expect(state.cellData[cellId("1")].code).toBe("new1");
-    expect(state.cellData[cellId("2")].code).toBe("new2");
-    expect(state.cellData[cellId("3")].code).toBe("code1");
-    expect(state.cellData[cellId("4")].code).toBe("code2");
-    expect(state.cellIds.inOrderIds).toEqual([
-      cellId("1"),
-      cellId("2"),
-      cellId("3"),
-      cellId("4"),
-    ]);
-    // Cell 5 data is preserved (possibly used for tracing), but it's not in the cellIds
-    expect(state.cellData[cellId("5")]).not.toBeUndefined();
-  });
-
-  it("can set cell codes with names and configs", () => {
-    const newIds = [cellId("3"), cellId("4")];
-    actions.setCellIds({ cellIds: newIds });
-    actions.setCellCodes({
-      codes: ["code1", "code2"],
-      ids: newIds,
-      codeIsStale: false,
-      names: ["setup_cell", "analysis"],
-      configs: [
-        { hide_code: true, disabled: false, column: null },
-        { hide_code: false, disabled: true, column: null },
-      ],
-    });
-
-    expect(state.cellData[cellId("3")].name).toBe("setup_cell");
-    expect(state.cellData[cellId("3")].config.hide_code).toBe(true);
-    expect(state.cellData[cellId("3")].config.disabled).toBe(false);
-
-    expect(state.cellData[cellId("4")].name).toBe("analysis");
-    expect(state.cellData[cellId("4")].config.hide_code).toBe(false);
-    expect(state.cellData[cellId("4")].config.disabled).toBe(true);
-  });
-
-  it("can set cell codes without names/configs (backward compat)", () => {
-    const newIds = [cellId("3")];
-    actions.setCellIds({ cellIds: newIds });
-    actions.setCellCodes({
-      codes: ["code1"],
-      ids: newIds,
-      codeIsStale: false,
-    });
-
-    // Should use defaults when names/configs not provided
-    expect(state.cellData[cellId("3")].code).toBe("code1");
-    expect(state.cellData[cellId("3")].config.hide_code).toBe(false);
-    expect(state.cellData[cellId("3")].config.disabled).toBe(false);
-  });
-
-  it("can update names and configs on existing cells via setCellCodes", () => {
-    // Set initial state
-    actions.setCellCodes({
-      codes: ["x = 1"],
-      ids: [firstCellId],
-      codeIsStale: false,
-      names: ["old_name"],
-      configs: [{ hide_code: false, disabled: false, column: null }],
-    });
-    expect(state.cellData[firstCellId].name).toBe("old_name");
-    expect(state.cellData[firstCellId].config.hide_code).toBe(false);
-
-    // Update with new name and config (same code)
-    actions.setCellCodes({
-      codes: ["x = 1"],
-      ids: [firstCellId],
-      codeIsStale: true,
-      names: ["new_name"],
-      configs: [{ hide_code: true, disabled: false, column: null }],
-    });
-    expect(state.cellData[firstCellId].name).toBe("new_name");
-    expect(state.cellData[firstCellId].config.hide_code).toBe(true);
-  });
-
-  it("can fold and unfold all cells", () => {
-    actions.foldAll();
-    expect(foldAllBulk).toHaveBeenCalled();
-
-    actions.unfoldAll();
-    expect(unfoldAllBulk).toHaveBeenCalled();
-  });
+    actions.unfoldAll();
+    expect(unfoldAllBulk).toHaveBeenCalled();
+  });
 
   it("can clear logs", () => {
     state.cellLogs = [
@@ -1968,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",
@@ -1996,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",
@@ -2010,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",
@@ -2063,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",
@@ -2118,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",
@@ -2183,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",
@@ -2262,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") });
@@ -2273,7 +1820,7 @@ describe("cell reducer", () => {
   });
 
   it("can split and undo split cells", () => {
-    actions.createNewCell({
+    seedCell({
       cellId: firstCellId,
       before: false,
       code: "line1\nline2",
@@ -2340,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(`
@@ -2387,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);
@@ -2440,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 };
 
@@ -2452,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(`
       "
@@ -2487,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(`
@@ -2525,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);
@@ -2578,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") });
@@ -2630,116 +2177,6 @@ describe("cell reducer", () => {
     expect(state.cellIds.getColumns()[2].topLevelIds).toEqual([cellId("2")]);
   });
 
-  it("rebuildCellColumns regroups cells by config.column", () => {
-    // Create four cells in a single column.
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-    actions.createNewCell({ cellId: cellId("2"), before: false });
-    expect(state.cellIds.getColumns().length).toBe(1);
-
-    // Explicitly set config.column on each cell. This ONLY updates metadata —
-    // updateCellConfig does not touch the MultiColumn tree.
-    actions.updateCellConfig({
-      cellId: cellId("0"),
-      config: { column: 0 },
-    });
-    actions.updateCellConfig({
-      cellId: cellId("2"),
-      config: { column: 1 },
-    });
-
-    // Tree is still a single column at this point.
-    expect(state.cellIds.getColumns().length).toBe(1);
-
-    // Now rebuild the column tree from metadata.
-    actions.rebuildCellColumns({
-      cellIds: [cellId("0"), cellId("1"), cellId("2"), cellId("3")],
-    });
-
-    expect(state.cellIds.getColumns().length).toBe(2);
-    // Cell 1 inherits from 0 (col 0), cell 3 inherits from 2 (col 1).
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([
-      cellId("0"),
-      cellId("1"),
-    ]);
-    expect(state.cellIds.getColumns()[1].topLevelIds).toEqual([
-      cellId("2"),
-      cellId("3"),
-    ]);
-  });
-
-  it("rebuildCellColumns with explicit column on every cell", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-    actions.createNewCell({ cellId: cellId("2"), before: false });
-
-    for (const [id, col] of [
-      ["0", 1],
-      ["1", 0],
-      ["2", 1],
-      ["3", 0],
-    ] as const) {
-      actions.updateCellConfig({ cellId: cellId(id), config: { column: col } });
-    }
-
-    actions.rebuildCellColumns({
-      cellIds: [cellId("0"), cellId("1"), cellId("2"), cellId("3")],
-    });
-
-    expect(state.cellIds.getColumns().length).toBe(2);
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([
-      cellId("1"),
-      cellId("3"),
-    ]);
-    expect(state.cellIds.getColumns()[1].topLevelIds).toEqual([
-      cellId("0"),
-      cellId("2"),
-    ]);
-  });
-
-  it("rebuildCellColumns collapses to one column when all cells are col 0", () => {
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.addColumnBreakpoint({ cellId: cellId("1") });
-    expect(state.cellIds.getColumns().length).toBe(2);
-
-    // Wipe column metadata back to 0 for both cells.
-    actions.updateCellConfig({ cellId: cellId("0"), config: { column: 0 } });
-    actions.updateCellConfig({ cellId: cellId("1"), config: { column: 0 } });
-
-    actions.rebuildCellColumns({
-      cellIds: [cellId("0"), cellId("1")],
-    });
-
-    expect(state.cellIds.getColumns().length).toBe(1);
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([
-      cellId("0"),
-      cellId("1"),
-    ]);
-  });
-
-  it("rebuildCellColumns follows the provided order, not current tree order", () => {
-    // Start with a single column.
-    actions.createNewCell({ cellId: firstCellId, before: false });
-    actions.createNewCell({ cellId: cellId("1"), before: false });
-    actions.updateCellConfig({ cellId: cellId("0"), config: { column: 0 } });
-    actions.updateCellConfig({ cellId: cellId("2"), config: { column: 1 } });
-
-    // Pass the reversed order. The rebuild should honor it.
-    actions.rebuildCellColumns({
-      cellIds: [cellId("2"), cellId("1"), cellId("0")],
-    });
-
-    // cellIds iteration:
-    //   2 → col=1, pushed to col1, prev=1
-    //   1 → col=null, pushed to col[prev=1] = col1
-    //   0 → col=0, pushed to col0
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([cellId("0")]);
-    expect(state.cellIds.getColumns()[1].topLevelIds).toEqual([
-      cellId("2"),
-      cellId("1"),
-    ]);
-  });
-
   it("can clear output of a single cell", () => {
     // Set up initial state with output
     actions.handleCellMessage({
@@ -2828,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
@@ -2875,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,
     });
@@ -3017,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,
@@ -3230,7 +2367,7 @@ describe("cell reducer", () => {
 
     it("markTouched is idempotent", () => {
       // Create a cell with hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: true,
@@ -3260,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,
@@ -3295,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,
@@ -3324,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,
@@ -3384,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);
@@ -3407,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,
@@ -3425,7 +2513,7 @@ describe("cell reducer", () => {
 
     it("markUntouched is idempotent", () => {
       // Create a cell without hideCode
-      actions.createNewCell({
+      seedCell({
         cellId: "__end__",
         before: false,
         hideCode: false,
@@ -3445,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,
@@ -3463,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,
@@ -3491,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,
@@ -3505,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)
@@ -3531,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);
@@ -3547,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);
-    });
   });
 });
 
@@ -3886,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({
@@ -3940,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([]);
+    });
   });
 });