@marimo-team/islands 0.25.3-dev196 → 0.25.3-dev198

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

@@ -3,15 +3,25 @@
 import type * as Protocol from "@marimo-team/client/protocol";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { cellId } from "@/__tests__/branded";
-import { cell, CONFIG } from "@/core/notebook/document/__tests__/fixtures";
-import type { CellIndex } from "@/utils/id-tree";
+import {
+  cell,
+  CONFIG,
+  document as documentOf,
+  withCells,
+} from "@/core/notebook/document/__tests__/fixtures";
 import { collapseCellAtom, undoDeleteCellAtom } from "../actions";
 import {
+  addColumnAtom,
+  addColumnBreakpointAtom,
+  compactColumnsAtom,
+  deleteColumnAtom,
   dropCellOverCellAtom,
   dropCellOverColumnAtom,
+  mergeAllColumnsAtom,
   moveCellAtom,
   moveCellsRelativeToAtom,
   moveCellToIndexAtom,
+  moveColumnAtom,
   sendToBottomAtom,
   sendToTopAtom,
 } from "../arrange";
@@ -220,8 +230,8 @@ describe("moveCellsRelativeToAtom", () => {
       targetCellId: c3,
       position: "after",
       previousPlacements: [
-        { columnId: column, index: 0 as CellIndex },
-        { columnId: column, index: 1 as CellIndex },
+        { columnId: column, index: 0 },
+        { columnId: column, index: 1 },
       ],
     });
     expect(order()).toEqual([c3, c1, c2]);
@@ -261,3 +271,145 @@ describe("moveCellsRelativeToAtom", () => {
     expect(order()).toEqual([c2, c3, c1]);
   });
 });
+
+describe("columns", () => {
+  it("adds a column after another with a new cell, and names it", () => {
+    const { store, columns, columnIds, notebook, cellIn } = setup();
+    const [first] = columnIds();
+
+    store.set(addColumnAtom, { columnId: first });
+
+    const [left, right] = store.get(layoutAtom).columns;
+    expect(left.id).toBe(first);
+    expect(right.id).not.toBe(first);
+    expect(right.ids).toHaveLength(1);
+    const id = right.ids[0];
+    expect(columns()).toEqual([[c1, c2], [id]]);
+    expect(cellIn(id)?.config.column).toBe(1);
+    expect(notebook().scrollKey).toBe(id);
+  });
+
+  it("starts a column at a cell, but not at the first cell", () => {
+    const { store, model, columns, cellIn } = setup({
+      c3: cell("c3", "z = 3"),
+    });
+    const before = store.get(model.documentAtom);
+
+    store.set(addColumnBreakpointAtom, { cellId: c1 });
+    expect(store.get(model.documentAtom)).toBe(before);
+
+    store.set(addColumnBreakpointAtom, { cellId: c2 });
+    expect(columns()).toEqual([[c1], [c2, c3]]);
+    expect(cellIn(c2)?.config.column).toBe(1);
+  });
+
+  it("starts a column at a column's first cell, keeping the id with the cells", () => {
+    const { store, columns, columnIds } = twoColumns();
+    const [first, second] = columnIds();
+
+    store.set(addColumnBreakpointAtom, { cellId: c3 });
+
+    expect(columns()).toEqual([[c1, c2], [], [c3, c4]]);
+    const [left, , right] = columnIds();
+    expect(left).toBe(first);
+    expect(right).toBe(second);
+  });
+
+  it("deletes a column into the one before it, or after it for the first", () => {
+    const { store, columns, columnIds, cellIn } = twoColumns();
+    const [first, second] = columnIds();
+
+    store.set(deleteColumnAtom, { columnId: first });
+    expect(columns()).toEqual([[c1, c2, c3, c4]]);
+    expect(cellIn(c3)?.config.column).toBeNull();
+    expect(columnIds()).toEqual([second]);
+
+    store.set(deleteColumnAtom, { columnId: second });
+    expect(columns()).toEqual([[c1, c2, c3, c4]]);
+  });
+
+  it("merges every column into the first", () => {
+    const { store, columns, columnIds, cellIn } = twoColumns();
+    const [first] = columnIds();
+
+    store.set(mergeAllColumnsAtom);
+
+    expect(columns()).toEqual([[c1, c2, c3, c4]]);
+    expect(cellIn(c3)?.config.column).toBeNull();
+    expect(columnIds()).toEqual([first]);
+  });
+
+  it("keeps the column a drag emptied until a drop compacts it", () => {
+    const { store, columns, columnIds, cellIn } = twoColumns();
+    const [first, second] = columnIds();
+    store.set(dropCellOverColumnAtom, { cellId: c3, columnId: first });
+    store.set(dropCellOverColumnAtom, { cellId: c4, columnId: first });
+    expect(columns()).toEqual([[c4, c3, c1, c2], []]);
+    expect(columnIds()).toEqual([first, second]);
+    expect(cellIn(c4)?.config.column).toBeNull();
+
+    store.set(dropCellOverColumnAtom, { cellId: c3, columnId: second });
+    expect(columns()).toEqual([[c4, c1, c2], [c3]]);
+    expect(cellIn(c3)?.config.column).toBe(1);
+
+    store.set(dropCellOverColumnAtom, { cellId: c3, columnId: first });
+    store.set(compactColumnsAtom);
+
+    expect(columns()).toEqual([[c3, c4, c1, c2]]);
+    expect(columnIds()).toEqual([first]);
+  });
+
+  it("moves a column, keeping its id with it", () => {
+    const { store, columns, columnIds, cellIn } = twoColumns();
+    const [first, second] = columnIds();
+
+    store.set(moveColumnAtom, { column: first, overColumn: second });
+    expect(columns()).toEqual([
+      [c3, c4],
+      [c1, c2],
+    ]);
+    expect(columnIds()).toEqual([second, first]);
+    expect(cellIn(c3)?.config.column).toBe(0);
+    expect(cellIn(c1)?.config.column).toBe(1);
+
+    store.set(moveColumnAtom, { column: first, overColumn: "_left_" });
+    expect(columns()).toEqual([
+      [c1, c2],
+      [c3, c4],
+    ]);
+    expect(columnIds()).toEqual([first, second]);
+  });
+});
+
+describe("the host's columns", () => {
+  it("names a column the host adds, leaving the others as they are", () => {
+    const { host, columns, columnIds } = setup();
+    const [first] = columnIds();
+
+    host(
+      withCells(documentOf(), {
+        c3: cell("c3", "z = 3", { config: { ...CONFIG, column: 1 } }),
+      }),
+    );
+
+    expect(columns()).toEqual([[c1, c2], [c3]]);
+    const [left, right] = columnIds();
+    expect(left).toBe(first);
+    expect(right).not.toBe(first);
+  });
+
+  it("drops a column the host removed", () => {
+    const { host, columns, columnIds } = twoColumns();
+    const [first] = columnIds();
+
+    host(
+      withCells(documentOf(), {
+        c3: cell("c3", "z = 3"),
+        c4: cell("c4", "w = 4"),
+      }),
+    );
+
+    expect(columns()).toEqual([[c1, c2, c3, c4]]);
+    expect(columnIds()).toEqual([first]);
+  });
+});

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

@@ -24,11 +24,6 @@ import { adaptiveLanguageConfiguration } from "@/core/codemirror/language/extens
 import { OverridingHotkeyProvider } from "@/core/hotkeys/hotkeys";
 import type { OutputMessage } from "@/core/kernel/messages";
 import type { CellConfig } from "@/core/network/types";
-import {
-  type CollapsibleTree,
-  MultiColumn,
-  type CellColumnId,
-} from "@/utils/id-tree";
 import type { Seconds } from "@/utils/time";
 import {
   exportedForTesting,
@@ -61,8 +56,6 @@ vi.mock("../scrollCellIntoView", async (importOriginal) => {
   };
 });
 
-const FIRST_COLUMN = 0;
-
 const { initialNotebookState, reducer, createActions } = exportedForTesting;
 
 function formatCells(notebook: NotebookState) {
@@ -78,14 +71,7 @@ function formatCells(notebook: NotebookState) {
     const cells = cellsId.map((cellId) => cellData[cellId]);
     return cells.map((cell) => printCell(cell)).join("\n\n");
   };
-  const printColumn = (column: CollapsibleTree<CellId>, columnIdx: number) => {
-    return `> col ${columnIdx}\n${printCells(column.inOrderIds)}`;
-  };
-  const columns = cellIds.getColumns();
-  if (columns.length > 1) {
-    return wrap(columns.map(printColumn).join("\n\n"));
-  }
-  return wrap(printCells(cellIds.inOrderIds));
+  return wrap(printCells(cellIds));
 }
 
 function createEditor(content: string) {
@@ -152,7 +138,7 @@ describe("cell reducer", () => {
     hideCode,
     autoFocus = true,
   }: {
-    cellId: CellId | "__end__" | { type: "__end__"; columnId: CellColumnId };
+    cellId: CellId | "__end__";
     before: boolean;
     code?: string;
     name?: string;
@@ -161,26 +147,16 @@ describe("cell reducer", () => {
     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 cellIndex =
+      cellId === "__end__"
+        ? state.cellIds.length
+        : state.cellIds.indexOf(cellId);
     const id = newCellId ?? CellId.create();
+    const cellIds = [...state.cellIds];
+    cellIds.splice(before ? cellIndex : cellIndex + 1, 0, id);
     state = {
       ...state,
-      cellIds: state.cellIds.insertId(
-        id,
-        column.id,
-        before ? cellIndex : cellIndex + 1,
-      ),
+      cellIds,
       cellData: {
         ...state.cellData,
         [id]: createCell({
@@ -215,9 +191,8 @@ describe("cell reducer", () => {
     i = 0;
 
     state = initialNotebookState();
-    state.cellIds = MultiColumn.from([]);
     seedCell({ cellId: "__end__", before: false });
-    firstCellId = state.cellIds.inOrderIds[0];
+    firstCellId = state.cellIds[0];
   });
 
   afterAll(() => {
@@ -1156,37 +1131,6 @@ describe("cell reducer", () => {
     expect(state.cellLogs).toEqual([]);
   });
 
-  it("can split and undo split cells", () => {
-    seedCell({
-      cellId: firstCellId,
-      before: false,
-      code: "line1\nline2",
-    });
-    const nextCellId = state.cellIds.atOrThrow(FIRST_COLUMN).atOrThrow(1);
-
-    const originalCellCount = state.cellIds.atOrThrow(FIRST_COLUMN).length;
-    // Move cursor to the second line
-    const editor = state.cellHandles[nextCellId].current?.editorView;
-    if (!editor) {
-      throw new Error("Editor not found");
-    }
-    editor.dispatch({ selection: { anchor: 5, head: 5 } });
-    actions.splitCell({ cellId: nextCellId });
-    expect(state.cellIds.atOrThrow(FIRST_COLUMN).length).toBe(
-      originalCellCount + 1,
-    );
-    expect(state.cellData[nextCellId].code).toBe("line1");
-    expect(
-      state.cellData[state.cellIds.atOrThrow(FIRST_COLUMN).atOrThrow(2)].code,
-    ).toBe("line2");
-
-    actions.undoSplitCell({ cellId: nextCellId, snapshot: "line1\nline2" });
-    expect(state.cellIds.atOrThrow(FIRST_COLUMN).length).toBe(
-      originalCellCount,
-    );
-    expect(state.cellData[nextCellId].code).toBe("line1\nline2");
-  });
-
   it("can handle multiple console outputs", () => {
     const STDOUT1: OutputMessage = {
       channel: "stdout",
@@ -1223,228 +1167,6 @@ describe("cell reducer", () => {
     `);
   });
 
-  it("can add a column breakpoint", () => {
-    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(`
-      "
-      [0] ''
-
-      [1] ''
-
-      [2] ''
-
-      [3] ''
-      "
-    `);
-
-    actions.addColumnBreakpoint({ cellId: cellId("2") });
-
-    expect(state.cellIds.getColumns().length).toBe(2);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      > col 0
-      [0] ''
-
-      [1] ''
-
-      > col 1
-      [2] ''
-
-      [3] ''
-      "
-    `);
-
-    // Check that the cells are in the correct columns
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([
-      cellId("0"),
-      cellId("1"),
-    ]);
-    expect(state.cellIds.getColumns()[1].topLevelIds).toEqual([
-      cellId("2"),
-      cellId("3"),
-    ]);
-  });
-
-  it("cannot add a column breakpoint before the first cell", () => {
-    expect(state.cellIds.getColumns().length).toBe(1);
-    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", () => {
-    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);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      > col 0
-      [0] ''
-
-      [1] ''
-
-      > col 1
-      [2] ''
-
-      [3] ''
-      "
-    `);
-
-    const columnId = state.cellIds.atOrThrow(0).id;
-    actions.deleteColumn({ columnId: columnId });
-
-    expect(state.cellIds.getColumns().length).toBe(1);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      [2] ''
-
-      [3] ''
-
-      [0] ''
-
-      [1] ''
-      "
-    `);
-
-    // Check that all cells are now in the remaining column
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([
-      "2",
-      "3",
-      "0",
-      "1",
-    ]);
-  });
-
-  it("deleting the last column does nothing", () => {
-    seedCell({ cellId: firstCellId, before: false });
-    seedCell({ cellId: cellId("1"), before: false });
-
-    const initialState = { ...state };
-
-    actions.deleteColumn({ columnId: initialState.cellIds.atOrThrow(0).id });
-
-    // State should not change
-    expect(state).toEqual(initialState);
-  });
-
-  it("can drop a column over another column", () => {
-    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);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      > col 0
-      [0] ''
-
-      [1] ''
-
-      > col 1
-      [2] ''
-
-      [3] ''
-      "
-    `);
-
-    const columnId0 = state.cellIds.atOrThrow(0).id;
-    const columnId1 = state.cellIds.atOrThrow(1).id;
-    expect(columnId0).not.toBe(columnId1);
-    actions.moveColumn({ column: columnId1, overColumn: columnId0 });
-
-    expect(state.cellIds.getColumns().length).toBe(2);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      > col 0
-      [2] ''
-
-      [3] ''
-
-      > col 1
-      [0] ''
-
-      [1] ''
-      "
-    `);
-
-    // Check that the columns have swapped positions
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([
-      cellId("2"),
-      cellId("3"),
-    ]);
-    expect(state.cellIds.getColumns()[1].topLevelIds).toEqual([
-      cellId("0"),
-      cellId("1"),
-    ]);
-  });
-
-  it("can compact columns", () => {
-    // Create initial state with 3 columns, including an empty one
-    seedCell({ cellId: firstCellId, before: false });
-    seedCell({ cellId: cellId("1"), before: false });
-    actions.addColumnBreakpoint({ cellId: cellId("1") });
-    actions.addColumnBreakpoint({ cellId: cellId("2") });
-    // A column emptied by a drag stays until the drop compacts it.
-    state = {
-      ...state,
-      cellIds: state.cellIds.addColumn(state.cellIds.getColumnIds()[1]),
-    };
-
-    expect(state.cellIds.getColumns().length).toBe(4);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      > col 0
-      [0] ''
-
-      > col 1
-      [1] ''
-
-      > col 2
-
-
-      > col 3
-      [2] ''
-      "
-    `);
-
-    // Check initial column structure
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([cellId("0")]);
-    expect(state.cellIds.getColumns()[1].topLevelIds).toEqual([cellId("1")]);
-    expect(state.cellIds.getColumns()[2].topLevelIds).toEqual([]);
-    expect(state.cellIds.getColumns()[3].topLevelIds).toEqual([cellId("2")]);
-
-    // Compact columns
-    actions.compactColumns();
-
-    expect(state.cellIds.getColumns().length).toBe(3);
-    expect(formatCells(state)).toMatchInlineSnapshot(`
-      "
-      > col 0
-      [0] ''
-
-      > col 1
-      [1] ''
-
-      > col 2
-      [2] ''
-      "
-    `);
-
-    // Check compacted column structure
-    expect(state.cellIds.getColumns()[0].topLevelIds).toEqual([cellId("0")]);
-    expect(state.cellIds.getColumns()[1].topLevelIds).toEqual([cellId("1")]);
-    expect(state.cellIds.getColumns()[2].topLevelIds).toEqual([cellId("2")]);
-  });
-
   it("can clear output of a single cell", () => {
     // Set up initial state with output
     actions.handleCellMessage({
@@ -1534,7 +1256,7 @@ describe("cell reducer", () => {
   it("can clear output of all cells", () => {
     // Create multiple cells with output
     seedCell({ cellId: firstCellId, before: false });
-    const secondCellId = state.cellIds.atOrThrow(FIRST_COLUMN).atOrThrow(1);
+    const secondCellId = state.cellIds[1];
 
     // Add output to both cells
     const outputMessage = {
@@ -1616,7 +1338,7 @@ describe("cell reducer", () => {
         exportedForTesting;
 
       seedCell({ cellId: firstCellId, before: false });
-      const newCellId = state.cellIds.inOrderIds[1];
+      const newCellId = state.cellIds[1];
 
       const dataAtom1 = cellDataAtom(newCellId);
       const runtimeAtom1 = cellRuntimeAtom(newCellId);

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

@@ -46,7 +46,6 @@ const { initialNotebookState } = exportedForTesting;
 const a = cellId("a");
 const b = cellId("b");
 const c = cellId("c");
-const d = cellId("d");
 
 function cell(id: CellId, patch: Partial<EditableCell> = {}): EditableCell {
   return {
@@ -102,7 +101,7 @@ describe("applyDocument", () => {
   it("adds the document's cells to an empty notebook", () => {
     const state = notebookOf([cell(a), cell(b, { code: "" })]);
 
-    expect(state.cellIds.inOrderIds).toEqual([a, b]);
+    expect(state.cellIds).toEqual([a, b]);
     expect(state.cellData[a]).toMatchObject({
       code: "a = 1",
       name: "_",
@@ -199,42 +198,11 @@ describe("applyDocument", () => {
 
     const next = applyDocument(state, documentOf([cell(a), cell(c)]));
 
-    expect(next.cellIds.inOrderIds).toEqual([a, c]);
+    expect(next.cellIds).toEqual([a, c]);
     expect(next.cellData[b]).toBeUndefined();
     expect(next.cellRuntime[b]).toBeUndefined();
     expect(next.cellHandles[b]).toBeUndefined();
   });
-
-  it("regroups columns from the cells' configs, keeping column ids", () => {
-    const column1 = { ...cell(d).config, column: 1 };
-    const state = notebookOf([
-      cell(a),
-      cell(b),
-      cell(c),
-      cell(d, { config: column1 }),
-    ]);
-    const next = applyDocument(
-      state,
-      documentOf([cell(c), cell(a), cell(b), cell(d, { config: column1 })]),
-    );
-
-    expect(next.cellIds.inOrderIds).toEqual([c, a, b, d]);
-    expect(next.cellIds.getColumnIds()).toEqual(state.cellIds.getColumnIds());
-    expect(next.cellIds.atOrThrow(1).inOrderIds).toEqual([d]);
-  });
-
-  it("keeps a trailing empty column", () => {
-    const state = notebookOf([cell(a)]);
-    const withEmpty = {
-      ...state,
-      cellIds: state.cellIds.addColumn(state.cellIds.atOrThrow(0).id),
-    };
-
-    const next = applyDocument(withEmpty, documentOf([cell(a, { code: "" })]));
-
-    expect(next.cellIds.colLength).toBe(2);
-    expect(next.cellData[a].code).toBe("");
-  });
 });
 
 describe("documentEditMiddleware", () => {
@@ -283,18 +251,6 @@ describe("documentEditMiddleware", () => {
     expect(calls).toEqual([["setCode", a, "a = 2"]]);
   });
 
-  it("clears columns merged into one", () => {
-    state = notebookOf([
-      cell(a),
-      cell(b),
-      cell(c, { config: { ...cell(c).config, column: 1 } }),
-    ]);
-
-    actions.mergeAllColumns();
-
-    expect(calls).toEqual([["updateConfig", c, { column: null }]]);
-  });
-
   it("ignores the document and the kernel's run state", () => {
     actions.prepareForRun({ cellId: a });
     actions.setLastRun({

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

@@ -3,15 +3,20 @@
 /** A store whose notebook follows a document model, as the session wires it. */
 
 import { history } from "@codemirror/commands";
+import { python } from "@codemirror/lang-python";
 import { EditorState } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
 import type * as Protocol from "@marimo-team/client/protocol";
 import { createStore } from "jotai";
 import { mockDocumentModel } from "@/__mocks__/document";
+import type { CellId } from "@/core/cells/ids";
+import { adaptiveLanguageConfiguration } from "@/core/codemirror/language/extension";
+import { OverridingHotkeyProvider } from "@/core/hotkeys/hotkeys";
 import {
   document as documentOf,
   withCells,
 } from "@/core/notebook/document/__tests__/fixtures";
+import type { Document } from "@/core/notebook/replica";
 import { exportedForTesting, notebookAtom, notebookReducer } from "../cells";
 import { followDocument } from "../document";
 import { layoutAtom } from "../layout";
@@ -22,7 +27,7 @@ export function setupNotebook(
 ) {
   const store = createStore();
   store.set(notebookAtom, exportedForTesting.initialNotebookState());
-  const { model, stop } = mockDocumentModel(
+  const { model, documentAtom, stop } = mockDocumentModel(
     store,
     cells ? withCells(documentOf(), cells) : documentOf(),
   );
@@ -43,17 +48,36 @@ export function setupNotebook(
   return {
     store,
     model,
-    order: () => store.get(notebookAtom).cellIds.inOrderIds,
+    /** Deliver a document from the host. Edits pending here stay on top. */
+    host: (document: Document) => store.set(documentAtom, document),
+    order: () => store.get(notebookAtom).cellIds,
     /** The cells of each column, as the page lays them out. */
     columns: () => store.get(layoutAtom).columns.map((column) => column.ids),
+    /** The columns' ids, as the page keys them. */
+    columnIds: () => store.get(layoutAtom).columns.map((column) => column.id),
     notebook: () => store.get(notebookAtom),
     cellIn: (id: string) => store.get(model.documentAtom)?.cells.get(id),
-    /** Give a cell an editor, as mounting it would. */
+    /** Give a cell an editor, as mounting it would, with a cell's language setup. */
     mountEditor: (id: string) => {
       const view = new EditorView({
         state: EditorState.create({
           doc: store.get(model.documentAtom)?.cells.get(id)?.code ?? "",
-          extensions: [history()],
+          extensions: [
+            history(),
+            python(),
+            adaptiveLanguageConfiguration({
+              cellId: id as CellId,
+              completionConfig: {
+                activate_on_typing: true,
+                signature_hint_on_typing: false,
+                copilot: false,
+                codeium_api_key: null,
+              },
+              hotkeys: new OverridingHotkeyProvider({}),
+              placeholderType: "marimo-import",
+              lspConfig: {},
+            }),
+          ],
         }),
       });
       store.get(notebookAtom).cellHandles[id as never].current = {