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

package/src/core/ai/tools/edit-notebook-tool.ts

@@ -9,7 +9,7 @@ import {
   notebookAtom,
 } from "@/core/cells/cells";
 import { CellId } from "@/core/cells/ids";
-import { updateEditorCodeFromPython } from "@/core/codemirror/language/utils";
+import { prepareCellCodeUpdate } from "@/core/codemirror/language/cell-code";
 import type { CellColumnId } from "@/utils/id-tree";
 import { stagedAICellsAtom } from "../staged-cells";
 import {
@@ -94,19 +94,17 @@ export class EditNotebookTool implements AiTool<
         const cellId = position.cellId as CellId | undefined;
 
         if (!cellId) {
-          throw new ToolExecutionError(
-            "Cell ID is required for update_cell",
-            "CELL_ID_REQUIRED_FOR_UPDATE_CELL",
-            true,
-            "Provide a cell ID to update",
-          );
+          throw new ToolExecutionError("Cell ID is required for update_cell", {
+            code: "CELL_ID_REQUIRED_FOR_UPDATE_CELL",
+            isRetryable: true,
+            suggestedFix: "Provide a cell ID to update",
+          });
         } else if (!code) {
-          throw new ToolExecutionError(
-            "Code is required for update_cell",
-            "CODE_REQUIRED_FOR_UPDATE_CELL",
-            true,
-            "Provide the new code to update the cell",
-          );
+          throw new ToolExecutionError("Code is required for update_cell", {
+            code: "CODE_REQUIRED_FOR_UPDATE_CELL",
+            isRetryable: true,
+            suggestedFix: "Provide the new code to update the cell",
+          });
         }
 
         const notebook = store.get(notebookAtom);
@@ -119,7 +117,12 @@ export class EditNotebookTool implements AiTool<
 
         // If previous edit was from a new cell, just replace editor code with the new code
         if (existingStagedCell?.type === "add_cell") {
-          updateEditorCodeFromPython(editorView, code);
+          const update = prepareCellCodeUpdate(editorView.state, code, {
+            initialize: true,
+          });
+          if (update) {
+            editorView.dispatch(update);
+          }
           break;
         }
 
@@ -139,7 +142,13 @@ export class EditNotebookTool implements AiTool<
           edit: { type: "update_cell", previousCode: previousCode },
         });
 
-        updateEditorCodeFromPython(editorView, code);
+        const update = prepareCellCodeUpdate(editorView.state, code, {
+          initialize: true,
+        });
+
+        if (update) {
+          editorView.dispatch(update);
+        }
 
         break;
       }
@@ -157,18 +166,22 @@ export class EditNotebookTool implements AiTool<
             if (!cellId) {
               throw new ToolExecutionError(
                 "Cell ID is required for add_cell with relative position",
-                "TOOL_ERROR",
-                true,
-                "Provide a cell ID to add the cell before",
+                {
+                  code: "TOOL_ERROR",
+                  isRetryable: true,
+                  suggestedFix: "Provide a cell ID to add the cell before",
+                },
               );
             }
 
             if (position.before === undefined) {
               throw new ToolExecutionError(
                 "Before is required for add_cell with relative position",
-                "TOOL_ERROR",
-                true,
-                `Provide a boolean value for before, true to add before cell ${cellId}, false to add after the cell`,
+                {
+                  code: "TOOL_ERROR",
+                  isRetryable: true,
+                  suggestedFix: `Provide a boolean value for before, true to add before cell ${cellId}, false to add after the cell`,
+                },
               );
             }
 
@@ -181,9 +194,12 @@ export class EditNotebookTool implements AiTool<
             if (!position.columnIndex) {
               throw new ToolExecutionError(
                 "Column index is required for add_cell with column_end position",
-                "TOOL_ERROR",
-                true,
-                "Provide a column index to add the cell at the end of",
+                {
+                  code: "TOOL_ERROR",
+                  isRetryable: true,
+                  suggestedFix:
+                    "Provide a column index to add the cell at the end of",
+                },
               );
             }
 
@@ -218,12 +234,11 @@ export class EditNotebookTool implements AiTool<
         const cellId = position.cellId as CellId | undefined;
 
         if (!cellId) {
-          throw new ToolExecutionError(
-            "Cell ID is required for delete_cell",
-            "CELL_ID_REQUIRED_FOR_DELETE_CELL",
-            true,
-            "Provide a cell ID to delete",
-          );
+          throw new ToolExecutionError("Cell ID is required for delete_cell", {
+            code: "CELL_ID_REQUIRED_FOR_DELETE_CELL",
+            isRetryable: true,
+            suggestedFix: "Provide a cell ID to delete",
+          });
         }
 
         const notebook = store.get(notebookAtom);
@@ -255,12 +270,11 @@ export class EditNotebookTool implements AiTool<
   private validateCellIdExists(cellId: CellId, notebook: NotebookState) {
     const cellIds = notebook.cellIds;
     if (!cellIds.getColumns().some((column) => column.idSet.has(cellId))) {
-      throw new ToolExecutionError(
-        "Cell not found",
-        "CELL_NOT_FOUND",
-        false,
-        "Check which cells exist in the notebook",
-      );
+      throw new ToolExecutionError("Cell not found", {
+        code: "CELL_NOT_FOUND",
+        isRetryable: false,
+        suggestedFix: "Check which cells exist in the notebook",
+      });
     }
   }
 
@@ -272,12 +286,12 @@ export class EditNotebookTool implements AiTool<
     const columns = cellIds.getColumns();
 
     if (columnIndex < 0 || columnIndex >= columns.length) {
-      throw new ToolExecutionError(
-        "Column index is out of range",
-        "COLUMN_INDEX_OUT_OF_RANGE",
-        true,
-        "Choose a column index between 0 and the number of columns in the notebook (0-based)",
-      );
+      throw new ToolExecutionError("Column index is out of range", {
+        code: "COLUMN_INDEX_OUT_OF_RANGE",
+        isRetryable: true,
+        suggestedFix:
+          "Choose a column index between 0 and the number of columns in the notebook (0-based)",
+      });
     }
     return columns[columnIndex].id;
   }
@@ -289,12 +303,11 @@ export class EditNotebookTool implements AiTool<
     const cellHandles = notebook.cellHandles;
     const cellHandle = cellHandles[cellId].current;
     if (!cellHandle?.editorView) {
-      throw new ToolExecutionError(
-        "Cell editor not found",
-        "CELL_EDITOR_NOT_FOUND",
-        false,
-        "Internal error, ask the user to report this error",
-      );
+      throw new ToolExecutionError("Cell editor not found", {
+        code: "CELL_EDITOR_NOT_FOUND",
+        isRetryable: false,
+        suggestedFix: "Internal error, ask the user to report this error",
+      });
     }
     return cellHandle.editorView;
   }

package/src/core/ai/tools/registry.ts

@@ -73,9 +73,11 @@ export class FrontendToolRegistry {
         const strError = z.prettifyError(inputResponse.error);
         throw new ToolExecutionError(
           `Tool ${toolName} returned invalid input: ${strError}`,
-          "INVALID_ARGUMENTS",
-          true,
-          "Please check the arguments and try again.",
+          {
+            code: "INVALID_ARGUMENTS",
+            isRetryable: true,
+            suggestedFix: "Please check the arguments and try again.",
+          },
         );
       }
       const args = inputResponse.data;
@@ -110,12 +112,15 @@ export class FrontendToolRegistry {
       // Handle unknown/generic errors
       const genericError = new ToolExecutionError(
         error instanceof Error ? error.message : String(error),
-        "TOOL_ERROR",
-        false,
-        "Check the error message and try again with valid arguments.",
         {
-          args: rawArgs,
-          errorType: error?.constructor?.name ?? typeof error,
+          code: "TOOL_ERROR",
+          isRetryable: false,
+          suggestedFix:
+            "Check the error message and try again with valid arguments.",
+          meta: {
+            args: rawArgs,
+            errorType: error?.constructor?.name ?? typeof error,
+          },
         },
       );
       return {

package/src/core/ai/tools/sample-tool.ts

@@ -50,13 +50,12 @@ export class TestFrontendTool implements AiTool<Input, Output> {
   public async handler({ name }: Input): Promise<Output> {
     // Example: Validate input and throw ToolExecutionError on invalid data
     if (!name.trim()) {
-      throw new ToolExecutionError(
-        "Name cannot be empty",
-        "INVALID_INPUT",
-        false,
-        "Please provide a non-empty name",
-        { field: "name", received: name },
-      );
+      throw new ToolExecutionError("Name cannot be empty", {
+        code: "INVALID_INPUT",
+        isRetryable: false,
+        suggestedFix: "Please provide a non-empty name",
+        meta: { field: "name", received: name },
+      });
     }
 
     return {

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

@@ -139,6 +139,7 @@ exports[`cell reducer > can initialize stdin > second stdin requested 1`] = `
     {
       "channel": "stdin",
       "data": "what is your name?",
+      "id": 2,
       "mimetype": "text/plain",
       "response": "Marimo!",
       "timestamp": 2,
@@ -146,6 +147,7 @@ exports[`cell reducer > can initialize stdin > second stdin requested 1`] = `
     {
       "channel": "stdin",
       "data": "how old are you?",
+      "id": 3,
       "mimetype": "text/plain",
       "timestamp": 3,
     },
@@ -189,6 +191,7 @@ exports[`cell reducer > can initialize stdin > stdin answered 1`] = `
     {
       "channel": "stdin",
       "data": "what is your name?",
+      "id": 2,
       "mimetype": "text/plain",
       "response": "Marimo!",
       "timestamp": 2,
@@ -233,6 +236,7 @@ exports[`cell reducer > can initialize stdin > stdin requested 1`] = `
     {
       "channel": "stdin",
       "data": "what is your name?",
+      "id": 2,
       "mimetype": "text/plain",
       "timestamp": 2,
     },

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

@@ -219,6 +219,45 @@ describe("transitionCell serialization", () => {
   });
 });
 
+describe("transitionCell console output ids", () => {
+  const output = (
+    data: string,
+    channel: OutputMessage["channel"] = "stdout",
+  ): OutputMessage => ({
+    channel,
+    mimetype: "text/plain",
+    data,
+    timestamp: 0,
+  });
+
+  it("assigns increasing ids to appended outputs", () => {
+    let cell = createCellRuntimeState({ status: "running" });
+    cell = transitionCell(cell, { console: output("a") } as CellMessage);
+    cell = transitionCell(cell, {
+      console: output("b", "stderr"),
+    } as CellMessage);
+    expect(cell.consoleOutputs.map((o) => o.id)).toEqual([1, 2]);
+  });
+
+  it("continues from the surviving maximum after a collapse", () => {
+    let cell = createCellRuntimeState({ status: "running" });
+    cell = transitionCell(cell, { console: output("a") } as CellMessage);
+    cell = transitionCell(cell, { console: output("b") } as CellMessage);
+    expect(cell.consoleOutputs.map((o) => o.id)).toEqual([1]);
+    cell = transitionCell(cell, {
+      console: output("c", "stderr"),
+    } as CellMessage);
+    expect(cell.consoleOutputs.map((o) => o.id)).toEqual([1, 2]);
+  });
+
+  it("assigns ids when the kernel replaces the whole console", () => {
+    const cell = transitionCell(createCellRuntimeState({ status: "running" }), {
+      console: [output("a"), output("b", "stderr")],
+    } as CellMessage);
+    expect(cell.consoleOutputs.map((o) => o.id)).toEqual([1, 2]);
+  });
+});
+
 describe("transitionCell stdin resolution", () => {
   describe.each([
     {

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

@@ -6,7 +6,6 @@ import { EditorView } from "@codemirror/view";
 import { createStore } from "jotai";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -34,7 +33,6 @@ import {
   type NotebookState,
   notebookAtom,
 } from "../cells";
-import { exportedForTesting as documentTransactionTestExports } from "../document-changes";
 import {
   focusAndScrollCellIntoView,
   scrollToBottom,
@@ -156,10 +154,6 @@ describe("cell reducer", () => {
     firstCellId = state.cellIds.inOrderIds[0];
   });
 
-  afterEach(() => {
-    documentTransactionTestExports.cancelPendingChanges();
-  });
-
   afterAll(() => {
     CellId.create = originalCreate;
   });
@@ -1579,7 +1573,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);
   });
 
@@ -1759,187 +1755,6 @@ describe("cell reducer", () => {
     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);
-
-    // 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();
@@ -2630,116 +2445,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({