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

package/src/core/codemirror/ai/__tests__/resources.test.ts

@@ -0,0 +1,117 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { markdownLanguage } from "@codemirror/lang-markdown";
+import { hoverResource, type Resource } from "@marimo-team/codemirror-mcp";
+import { createStore } from "jotai";
+import { assert, beforeEach, describe, expect, it, vi } from "vitest";
+import { MockNotebook } from "@/__mocks__/notebook";
+import { getAIContextRegistry } from "@/core/ai/context/context";
+import { ErrorContextProvider } from "@/core/ai/context/providers/error";
+import { AIContextRegistry } from "@/core/ai/context/registry";
+import { notebookAtom } from "@/core/cells/cells";
+import { CellId } from "@/core/cells/ids";
+import { resourceExtension } from "../resources";
+
+vi.mock("@marimo-team/codemirror-mcp", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@marimo-team/codemirror-mcp")>()),
+  hoverResource: vi.fn(() => []),
+}));
+
+vi.mock("@/core/ai/context/context", () => ({
+  getAIContextRegistry: vi.fn(),
+}));
+
+describe("resource tooltips", () => {
+  const message = '<b>Unexpected response</b> &amp; "details"';
+  let provider: ErrorContextProvider;
+  let resource: Resource;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const store = createStore();
+    store.set(
+      notebookAtom,
+      MockNotebook.notebookStateWithErrors([
+        {
+          cellId: CellId.create(),
+          cellName: "Cell 1",
+          errorData: [MockNotebook.errors.exception(message)],
+        },
+      ]),
+    );
+    provider = new ErrorContextProvider(store);
+    resource = provider.getItems()[1];
+    vi.mocked(getAIContextRegistry).mockReturnValue(
+      new AIContextRegistry().register(provider),
+    );
+    resourceExtension({ language: markdownLanguage, store });
+  });
+
+  function renderTooltip(item = resource) {
+    const options = vi.mocked(hoverResource).mock.calls[0][0];
+    assert(options.createTooltip);
+    return options.createTooltip(item).dom;
+  }
+
+  it("preserves literal text in cell error descriptions", () => {
+    const dom = renderTooltip();
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal descriptions when a provider is unavailable", () => {
+    const dom = renderTooltip({ ...resource, type: "unknown" });
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("falls back to the literal resource name", () => {
+    const dom = renderTooltip({
+      ...resource,
+      description: undefined,
+      name: message,
+    });
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal text in completion info strings", () => {
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: message,
+    });
+    const dom = renderTooltip({ ...resource, description: "Fallback" });
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal fallback text when an info renderer returns null", () => {
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: () => null,
+    });
+    const dom = renderTooltip();
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal fallback text for async info renderers", () => {
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: async () => document.createElement("div"),
+    });
+    const dom = renderTooltip();
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it.each(["element", "tooltip"])("preserves custom %s renderers", (kind) => {
+    const dom = document.createElement("strong");
+    dom.textContent = "Details";
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: () => (kind === "element" ? dom : { dom }),
+    });
+    expect(renderTooltip()).toBe(dom);
+  });
+});

package/src/core/codemirror/ai/resources.ts

@@ -142,7 +142,7 @@ export function resourceExtension(opts: {
 
 function asDom(value: string): TooltipView {
   const tooltip = document.createElement("div");
-  tooltip.innerHTML = value;
+  tooltip.textContent = value;
   return {
     dom: tooltip,
   };

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

@@ -11,7 +11,8 @@ import { formattingChangeEffect } from "../../format";
 import { loroSyncAnnotation } from "../../rtc/loro/sync";
 import { exportedForTesting } from "../extensions";
 
-const { shouldAutorunMarkdownUpdate } = exportedForTesting;
+const { isCollaboratorUpdate, shouldAutorunMarkdownUpdate } =
+  exportedForTesting;
 
 function createTransaction(spec: TransactionSpec) {
   return EditorState.create({ doc: "" }).update(spec);
@@ -68,6 +69,21 @@ describe("shouldAutorunMarkdownUpdate", () => {
     ).toBe(false);
   });
 
+  it("ignores remote transactions while focused", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [Transaction.remote.of(true)],
+    });
+
+    expect(
+      shouldAutorunMarkdownUpdate({
+        docChanged: transaction.docChanged,
+        transactions: [transaction],
+        hasFocus: true,
+      }),
+    ).toBe(false);
+  });
+
   it("ignores programmatic doc changes without a user event", () => {
     const transaction = createTransaction({
       changes: { from: 0, insert: "#" },
@@ -110,3 +126,28 @@ describe("shouldAutorunMarkdownUpdate", () => {
     ).toBe(false);
   });
 });
+
+describe("isCollaboratorUpdate", () => {
+  it("recognizes an update made only of Loro sync transactions", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [loroSyncAnnotation.of(true)],
+    });
+
+    expect(isCollaboratorUpdate([transaction])).toBe(true);
+  });
+
+  it("treats typing beside a Loro sync transaction as local", () => {
+    const remote = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [loroSyncAnnotation.of(true)],
+    });
+    const local = createTransaction({
+      changes: { from: 0, insert: "x" },
+      annotations: [Transaction.userEvent.of("input.type")],
+    });
+
+    expect(isCollaboratorUpdate([remote, local])).toBe(false);
+    expect(isCollaboratorUpdate([])).toBe(false);
+  });
+});

package/src/core/codemirror/cells/extensions.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { closeCompletion, completionStatus } from "@codemirror/autocomplete";
-import { type Extension, Prec } from "@codemirror/state";
+import { type Extension, Prec, Transaction } from "@codemirror/state";
 import {
   EditorView,
   type KeyBinding,
@@ -190,7 +190,7 @@ function cellKeymaps({
 
           if (isAtStartOfEditor(ev)) {
             const actions = ev.state.facet(cellActionsState);
-            actions.moveToNextCell({ cellId, before: true, noCreate: true });
+            actions.moveToNextCell({ cellId, before: true, create: false });
             return true;
           }
           return false;
@@ -207,7 +207,7 @@ function cellKeymaps({
 
           if (isAtEndOfEditor(ev)) {
             const actions = ev.state.facet(cellActionsState);
-            actions.moveToNextCell({ cellId, before: false, noCreate: true });
+            actions.moveToNextCell({ cellId, before: false, create: false });
             return true;
           }
           return false;
@@ -219,7 +219,7 @@ function cellKeymaps({
         stopPropagation: true,
         run: (ev) => {
           const actions = ev.state.facet(cellActionsState);
-          actions.moveToNextCell({ cellId, before: false, noCreate: true });
+          actions.moveToNextCell({ cellId, before: false, create: false });
           return true;
         },
       },
@@ -229,7 +229,7 @@ function cellKeymaps({
         stopPropagation: true,
         run: (ev) => {
           const actions = ev.state.facet(cellActionsState);
-          actions.moveToNextCell({ cellId, before: true, noCreate: true });
+          actions.moveToNextCell({ cellId, before: true, create: false });
           return true;
         },
       },
@@ -260,7 +260,7 @@ function cellKeymaps({
         run: (ev) => {
           ev.contentDOM.blur();
           const actions = ev.state.facet(cellActionsState);
-          actions.createNewCell({ cellId, before: true });
+          actions.createCell({ before: cellId });
           return true;
         },
       },
@@ -271,7 +271,7 @@ function cellKeymaps({
         run: (ev) => {
           ev.contentDOM.blur();
           const actions = ev.state.facet(cellActionsState);
-          actions.createNewCell({ cellId, before: false });
+          actions.createCell({ after: cellId });
           return true;
         },
       },
@@ -325,6 +325,11 @@ function cellKeymaps({
 function cellCodeEditing(hotkeys: HotkeyProvider): Extension[] {
   const onChangePlugin = EditorView.updateListener.of((update) => {
     if (update.docChanged) {
+      // Loro already applied a collaborator's change here. The client that
+      // typed it syncs it to the document.
+      if (isCollaboratorUpdate(update.transactions)) {
+        return;
+      }
       // Check if the doc update was a formatting change
       // e.g. changing from python to markdown
       const isFormattingChange = update.transactions.some((tr) =>
@@ -350,6 +355,14 @@ function cellCodeEditing(hotkeys: HotkeyProvider): Extension[] {
   return [onChangePlugin, formatKeymapExtension(hotkeys)];
 }
 
+/** Whether every transaction in an update arrived from a collaborator through Loro. */
+function isCollaboratorUpdate(transactions: readonly Transaction[]): boolean {
+  return (
+    transactions.length > 0 &&
+    transactions.every((tr) => tr.annotation(loroSyncAnnotation) !== undefined)
+  );
+}
+
 const MARKDOWN_AUTORUN_USER_EVENTS = ["input", "delete", "undo", "redo"];
 
 function shouldAutorunMarkdownUpdate({
@@ -382,8 +395,12 @@ function shouldAutorunMarkdownUpdate({
   }
 
   return transactions.some((tr) => {
-    // Ignore RTC sync changes to avoid duplicate runs from remote edits.
-    if (tr.annotation(loroSyncAnnotation) !== undefined) {
+    // Ignore remote changes to avoid duplicate runs. The client that made the
+    // edit runs it.
+    if (
+      tr.annotation(Transaction.remote) ||
+      tr.annotation(loroSyncAnnotation) !== undefined
+    ) {
       return false;
     }
 
@@ -463,5 +480,6 @@ export function cellBundle({
 }
 
 export const exportedForTesting = {
+  isCollaboratorUpdate,
   shouldAutorunMarkdownUpdate,
 };

package/src/core/codemirror/cells/state.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { Facet } from "@codemirror/state";
-import type { CellActions } from "@/core/cells/cells";
+import type { CellActions } from "@/core/cells/actions";
 import type { CellId } from "@/core/cells/ids";
 
 export interface CodemirrorCellActions extends CellActions {

package/src/core/codemirror/format.ts

@@ -18,10 +18,8 @@ import { cellIdState } from "./config/extension";
 import { languageAdapterState } from "./language/extension";
 import { SCHEMA_CACHE } from "./language/languages/sql/completion-store";
 import { isKnownDialect } from "./language/languages/sql/utils";
-import {
-  getEditorCodeAsPython,
-  updateEditorCodeFromPython,
-} from "./language/utils";
+import { prepareCellCodeUpdate } from "./language/cell-code";
+import { getEditorCodeAsPython } from "./language/utils";
 import { replaceEditorContent } from "./replace-editor-content";
 
 export const formattingChangeEffect = StateEffect.define<boolean>();
@@ -62,7 +60,10 @@ export async function formatEditorViews(views: Record<CellId, EditorView>) {
       code: formattedCode,
       formattingChange: true,
     });
-    updateEditorCodeFromPython(view, formattedCode);
+    const update = prepareCellCodeUpdate(view.state, formattedCode);
+    if (update) {
+      view.dispatch(update);
+    }
   }
 }
 

package/src/core/codemirror/keymaps/vim.ts

@@ -37,7 +37,7 @@ export function vimKeymapExtension(): Extension[] {
           if (isAtEndOfEditor(ev, true) && isInVimNormalMode(ev)) {
             const actions = ev.state.facet(cellActionsState);
             const cellId = ev.state.facet(cellIdState);
-            actions.moveToNextCell({ cellId, before: false, noCreate: true });
+            actions.moveToNextCell({ cellId, before: false, create: false });
             return true;
           }
           return false;
@@ -51,7 +51,7 @@ export function vimKeymapExtension(): Extension[] {
           if (isAtStartOfEditor(ev) && isInVimNormalMode(ev)) {
             const actions = ev.state.facet(cellActionsState);
             const cellId = ev.state.facet(cellIdState);
-            actions.moveToNextCell({ cellId, before: true, noCreate: true });
+            actions.moveToNextCell({ cellId, before: true, create: false });
             return true;
           }
           return false;
@@ -369,7 +369,7 @@ class CodeMirrorVimSync {
       // We use onIdle to keep the focused editor snappy
       onIdle(() => {
         if (!skipBroadcast) {
-          this.broadcastModeChange(instance, e.mode, e.subMode);
+          this.broadcastModeChange(instance, e.mode);
         }
         this.isBroadcasting = false;
       });
@@ -380,11 +380,7 @@ class CodeMirrorVimSync {
     this.instances.delete(instance);
   }
 
-  public broadcastModeChange(
-    originInstance: EditorView,
-    mode: string,
-    subMode?: string,
-  ) {
+  public broadcastModeChange(originInstance: EditorView, mode: string) {
     invariant(
       "exitInsertMode" in Vim,
       "Vim does not have an exitInsertMode method",

package/src/core/codemirror/language/__tests__/sql.test.ts

@@ -42,12 +42,14 @@ const adapter = new SQLLanguageAdapter();
 const TEST_ENGINE = "test_engine" as ConnectionName;
 
 const TEST_EXTENSION_ARGS = [
-  {} as CellId,
-  {} as CompletionConfig,
-  {} as HotkeyProvider,
-  {} as PlaceholderType,
-  {} as LSPConfig & {
-    diagnostics: DiagnosticsConfig;
+  {
+    cellId: {} as CellId,
+    completionConfig: {} as CompletionConfig,
+    hotkeys: {} as HotkeyProvider,
+    placeholderType: {} as PlaceholderType,
+    lspConfig: {} as LSPConfig & {
+      diagnostics: DiagnosticsConfig;
+    },
   },
 ] as const;
 
@@ -930,15 +932,15 @@ describe("SQL analysis features", () => {
 
   it("reports semantic diagnostics as warnings", async () => {
     const adapter = new SQLLanguageAdapter();
-    const extensions = adapter.getExtension(
-      {} as CellId,
-      {} as CompletionConfig,
-      {} as HotkeyProvider,
-      {} as PlaceholderType,
-      {
+    const extensions = adapter.getExtension({
+      cellId: {} as CellId,
+      completionConfig: {} as CompletionConfig,
+      hotkeys: {} as HotkeyProvider,
+      placeholderType: {} as PlaceholderType,
+      lspConfig: {
         diagnostics: { sql_linter: true },
       } as LSPConfig & { diagnostics: DiagnosticsConfig },
-    );
+    });
     const state = EditorState.create({
       doc: "SELECT missing FROM users",
       extensions: [languageMetadataField.init(() => metadata), ...extensions],
@@ -963,15 +965,15 @@ describe("SQL analysis features", () => {
 
   it("does not report unknown tables", async () => {
     const adapter = new SQLLanguageAdapter();
-    const extensions = adapter.getExtension(
-      {} as CellId,
-      {} as CompletionConfig,
-      {} as HotkeyProvider,
-      {} as PlaceholderType,
-      {
+    const extensions = adapter.getExtension({
+      cellId: {} as CellId,
+      completionConfig: {} as CompletionConfig,
+      hotkeys: {} as HotkeyProvider,
+      placeholderType: {} as PlaceholderType,
+      lspConfig: {
         diagnostics: { sql_linter: true },
       } as LSPConfig & { diagnostics: DiagnosticsConfig },
-    );
+    });
     const state = EditorState.create({
       doc: "SELECT missing FROM users; SELECT * FROM unknown_table",
       extensions: [languageMetadataField.init(() => metadata), ...extensions],

package/src/core/codemirror/language/__tests__/utils.test.ts

@@ -1,23 +1,35 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { EditorState } from "@codemirror/state";
+import { history, redo, undo } from "@codemirror/commands";
+import { EditorSelection, EditorState, StateEffect } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it } from "vitest";
 import { cellId } from "@/__tests__/branded";
 import { OverridingHotkeyProvider } from "@/core/hotkeys/hotkeys";
 import { cellConfigExtension } from "../../config/extension";
-import { adaptiveLanguageConfiguration, switchLanguage } from "../extension";
+import { prepareCellCodeUpdate } from "../cell-code";
+import { languageMetadataField } from "../metadata";
 import {
-  getEditorCodeAsPython,
-  splitEditor,
-  updateEditorCodeFromPython,
-} from "../utils";
+  adaptiveLanguageConfiguration,
+  languageAdapterState,
+  switchLanguage,
+} from "../extension";
+import { getEditorCodeAsPython, splitEditor } from "../utils";
+
+const views: EditorView[] = [];
+
+afterEach(() => {
+  for (const view of views.splice(0)) {
+    view.destroy();
+  }
+});
 
 function createEditor(doc: string) {
-  return new EditorView({
+  const view = new EditorView({
     state: EditorState.create({
       doc,
       extensions: [
+        history(),
         adaptiveLanguageConfiguration({
           completionConfig: {
             activate_on_typing: true,
@@ -50,6 +62,8 @@ function createEditor(doc: string) {
       ],
     }),
   });
+  views.push(view);
+  return view;
 }
 
 describe("getEditorCodeAsPython", () => {
@@ -72,14 +86,172 @@ describe("getEditorCodeAsPython", () => {
   });
 });
 
-describe("updateEditorCodeFromPython", () => {
-  it("should update the editor code with the provided Python code", () => {
-    const mockEditor = createEditor("");
-    const pythonCode = "print('Hello, World!')";
-    const result = updateEditorCodeFromPython(mockEditor, pythonCode);
-    expect(result).toEqual(pythonCode);
-    expect(mockEditor.state.doc.toString()).toEqual(pythonCode);
+describe("prepareCellCodeUpdate transactions", () => {
+  it("applies text and metadata together, including metadata-only undo", () => {
+    const view = createEditor('mo.md(r"hi")');
+    switchLanguage(view, { language: "markdown" });
+    const observed: Array<{ text: string; prefix: string }> = [];
+    view.dispatch({
+      effects: StateEffect.appendConfig.of(
+        EditorView.updateListener.of((update) => {
+          if (
+            update.transactions.some(
+              (tr) => tr.effects.length > 0 || tr.docChanged,
+            )
+          ) {
+            observed.push({
+              text: update.state.doc.toString(),
+              prefix: update.state.field(languageMetadataField).quotePrefix,
+            });
+          }
+        }),
+      ),
+    });
+    observed.length = 0;
+
+    view.dispatch(prepareCellCodeUpdate(view.state, 'mo.md(f"hi")')!);
+    expect(observed).toEqual([{ text: "hi", prefix: "f" }]);
+    expect(undo(view)).toBe(true);
+    expect(view.state.field(languageMetadataField).quotePrefix).toBe("r");
+    expect(redo(view)).toBe(true);
+    expect(view.state.field(languageMetadataField).quotePrefix).toBe("f");
+  });
+
+  it("clears incompatible history while applying a language fallback atomically", () => {
+    const view = createEditor('mo.md("hi")');
+    switchLanguage(view, { language: "markdown" });
+    view.dispatch({ changes: { from: 2, insert: "!" } });
+    const observed: Array<{ text: string; language: string }> = [];
+    view.dispatch({
+      effects: StateEffect.appendConfig.of(
+        EditorView.updateListener.of((update) => {
+          observed.push({
+            text: update.state.doc.toString(),
+            language: update.state.field(languageAdapterState).type,
+          });
+        }),
+      ),
+    });
+    observed.length = 0;
+
+    view.dispatch(prepareCellCodeUpdate(view.state, "x = 1")!);
+    expect(observed).toEqual([{ text: "x = 1", language: "python" }]);
+    expect(undo(view)).toBe(false);
+    view.dispatch({ changes: { from: 5, insert: "0" } });
+    expect(undo(view)).toBe(true);
+    expect(view.state.doc.toString()).toBe("x = 1");
   });
+
+  it("maps the selection through separate edits and keeps the update undoable", () => {
+    const view = createEditor("a = 1\nb = 2\nc = 3");
+    view.dispatch({ selection: EditorSelection.range(6, 11) });
+    view.dispatch(
+      prepareCellCodeUpdate(view.state, "alpha = 1\nb = 2\ncharlie = 3")!,
+    );
+    expect(
+      view.state.sliceDoc(
+        view.state.selection.main.from,
+        view.state.selection.main.to,
+      ),
+    ).toBe("b = 2");
+    expect(undo(view)).toBe(true);
+    expect(view.state.doc.toString()).toBe("a = 1\nb = 2\nc = 3");
+  });
+
+  it.each(["mo.md()", 'mo.md("hi")', 'df = mo.sql("SELECT 1")'])(
+    "keeps Python mode when receiving %s",
+    (code) => {
+      const view = createEditor("mo.md");
+      view.dispatch(prepareCellCodeUpdate(view.state, code)!);
+      expect({
+        language: view.state.field(languageAdapterState).type,
+        code: view.state.doc.toString(),
+      }).toEqual({ language: "python", code });
+    },
+  );
+
+  it.each([
+    {
+      language: "markdown",
+      initial: 'mo.md("hi")',
+      next: 'mo.md("bye")',
+      text: "bye",
+    },
+    {
+      language: "sql",
+      initial: 'df = mo.sql("SELECT 1")',
+      next: 'df = mo.sql("SELECT 2")',
+      text: "SELECT 2",
+    },
+  ] as const)(
+    "preserves compatible $language mode",
+    ({ language, initial, next, text }) => {
+      const view = createEditor(initial);
+      switchLanguage(view, { language });
+      view.dispatch(prepareCellCodeUpdate(view.state, next)!);
+      expect({
+        language: view.state.field(languageAdapterState).type,
+        code: view.state.doc.toString(),
+      }).toEqual({ language, code: text });
+    },
+  );
+
+  it.each([
+    {
+      language: "markdown",
+      initial: 'mo.md("hi")',
+      next: 'df = mo.sql("SELECT 1")',
+    },
+    {
+      language: "sql",
+      initial: 'df = mo.sql("SELECT 1")',
+      next: 'mo.md("hi")',
+    },
+    { language: "markdown", initial: 'mo.md("hi")', next: "x = 1" },
+  ] as const)(
+    "falls back from $language to Python for $next",
+    ({ language, initial, next }) => {
+      const view = createEditor(initial);
+      switchLanguage(view, { language });
+      view.dispatch(prepareCellCodeUpdate(view.state, next)!);
+      expect({
+        language: view.state.field(languageAdapterState).type,
+        code: view.state.doc.toString(),
+      }).toEqual({ language: "python", code: next });
+    },
+  );
+});
+
+describe("prepareCellCodeUpdate", () => {
+  it("does not normalize an editor that already represents the source", () => {
+    const view = createEditor('mo.md("hi")');
+    switchLanguage(view, { language: "markdown" });
+    expect(prepareCellCodeUpdate(view.state, 'mo.md("hi")')).toBeNull();
+    view.dispatch({ changes: { from: 2, insert: "\n " } });
+    const source = getEditorCodeAsPython(view);
+    expect(prepareCellCodeUpdate(view.state, source)).toBeNull();
+    expect(view.state.doc.toString()).toBe("hi\n ");
+  });
+
+  it.each(["", 'mo.md(f"hi {x}")'])(
+    "prepares initialization from %j without mutating the editor",
+    (initial) => {
+      const view = createEditor(initial);
+      const update = prepareCellCodeUpdate(view.state, 'mo.md(f"hi {x}")', {
+        initialize: true,
+      });
+      expect(view.state.doc.toString()).toBe(initial);
+      expect(view.state.field(languageAdapterState).type).toBe("python");
+      expect(update).not.toBeNull();
+      if (update) {
+        view.dispatch(update);
+      }
+      expect(view.state.doc.toString()).toBe("hi {x}");
+      expect(view.state.field(languageAdapterState).type).toBe("markdown");
+      expect(view.state.field(languageMetadataField).quotePrefix).toBe("f");
+      expect(undo(view)).toBe(false);
+    },
+  );
 });
 
 describe("splitEditor", () => {