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

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

@@ -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({
@@ -467,5 +480,6 @@ export function cellBundle({
 }
 
 export const exportedForTesting = {
+  isCollaboratorUpdate,
   shouldAutorunMarkdownUpdate,
 };

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/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", () => {

package/src/core/codemirror/language/cell-code.ts

@@ -0,0 +1,114 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { diff } from "@codemirror/merge";
+import {
+  type EditorState,
+  type StateEffect,
+  Transaction,
+  type TransactionSpec,
+} from "@codemirror/state";
+import { suppressSignatureHelp } from "@marimo-team/codemirror-languageserver";
+import { dequal } from "dequal";
+import {
+  languageAdapterFromCode,
+  languageAdapterState,
+  languageConfigurationEffects,
+} from "./extension";
+import { LanguageAdapters } from "./LanguageAdapters";
+import { sqlDialectEffect } from "./languages/sql/sql";
+import { languageMetadataField, setLanguageMetadata } from "./metadata";
+
+/** The Python source represented by the editor's text and language metadata. */
+export function getCellCode(state: EditorState): string {
+  const text = state.doc.toString();
+  const adapter = state.field(languageAdapterState, false);
+  return adapter
+    ? adapter.transformOut(
+        text,
+        state.field(languageMetadataField, false) ?? {},
+      )[0]
+    : text;
+}
+
+/** Account for adapters normalizing quotes and whitespace when reading source. */
+export function editorShowsCellCode(
+  state: EditorState,
+  source: string,
+): boolean {
+  if (getCellCode(state) === source) {
+    return true;
+  }
+  const adapter = state.field(languageAdapterState, false);
+  if (!adapter?.isSupported(source)) {
+    return false;
+  }
+  const [text, , metadata] = adapter.transformIn(source);
+  return (
+    text === state.doc.toString() &&
+    dequal(metadata, state.field(languageMetadataField, false))
+  );
+}
+
+/**
+ * Prepare one update to the editor's text, language, and metadata.
+ * Existing editors keep a compatible mode; only initial loading infers one.
+ * The caller decides whether this is a local edit or a remote synchronization.
+ */
+export function prepareCellCodeUpdate(
+  state: EditorState,
+  source: string,
+  { initialize = false }: { initialize?: boolean } = {},
+): TransactionSpec | null {
+  const current = state.field(languageAdapterState, false);
+  let target = current;
+  if (current) {
+    if (initialize) {
+      target = languageAdapterFromCode(source);
+    } else if (!current.isSupported(source)) {
+      target = LanguageAdapters.python;
+    }
+  }
+  const languageChanged = target?.type !== current?.type;
+  if (!languageChanged && editorShowsCellCode(state, source)) {
+    return null;
+  }
+
+  const effects: StateEffect<unknown>[] = [];
+  let text = source;
+  if (target) {
+    if (languageChanged) {
+      effects.push(...languageConfigurationEffects(state, target));
+    }
+    const [inner, , metadata] = target.transformIn(source);
+    text = inner;
+    const metadataChanged = !dequal(
+      metadata,
+      state.field(languageMetadataField, false),
+    );
+    if (metadataChanged) {
+      effects.push(setLanguageMetadata.of(metadata));
+    }
+    if (target.type === "sql" && (languageChanged || metadataChanged)) {
+      effects.push(sqlDialectEffect(metadata.engine));
+    }
+  }
+
+  // Match the merge view's scan limit so large rewrites stay bounded. The diff
+  // maps selections, folds, and diagnostics through each individual edit.
+  const changes = diff(state.doc.toString(), text, { scanLimit: 500 }).map(
+    (change) => ({
+      from: change.fromA,
+      to: change.toA,
+      insert: text.slice(change.fromB, change.toB),
+    }),
+  );
+  return {
+    changes,
+    effects,
+    annotations: [
+      suppressSignatureHelp.of(true),
+      // History was reset with the language; the previous text uses another representation.
+      ...(languageChanged ? [Transaction.addToHistory.of(false)] : []),
+    ],
+  };
+}

package/src/core/codemirror/language/extension.ts

@@ -1,11 +1,13 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { history } from "@codemirror/commands";
+import { history, historyField, invertedEffects } from "@codemirror/commands";
 import {
   Compartment,
   EditorSelection,
+  EditorState,
   StateEffect,
   StateField,
+  Transaction,
 } from "@codemirror/state";
 import { type EditorView, keymap, showPanel } from "@codemirror/view";
 import type { CellId } from "@/core/cells/ids";
@@ -25,11 +27,10 @@ import {
   placeholderState,
 } from "../config/extension";
 import type { PlaceholderType } from "../config/types";
-import { historyCompartment } from "../editing/extensions";
 import { formattingChangeEffect } from "../format";
 import { createPanel } from "../react-dom/createPanel";
 import { getLanguageAdapters, LanguageAdapters } from "./LanguageAdapters";
-import { initializeSQLDialect } from "./languages/sql/sql";
+import { sqlDialectEffect } from "./languages/sql/sql";
 import type { LanguageMetadata } from "./metadata";
 import { languageMetadataField, setLanguageMetadata } from "./metadata";
 import { LanguagePanelComponent } from "./panel/panel";
@@ -42,6 +43,32 @@ import { getEditorCodeAsPython } from "./utils";
  */
 const languageCompartment = new Compartment();
 
+/** Reconfigure a language and discard history written in its previous representation. */
+export function languageConfigurationEffects(
+  state: EditorState,
+  language: LanguageAdapter,
+): StateEffect<unknown>[] {
+  const extensions = language.getExtension({
+    cellId: state.facet(cellIdState),
+    completionConfig: state.facet(completionConfigState),
+    hotkeys: state.facet(hotkeysProviderState),
+    placeholderType: state.facet(placeholderState),
+    lspConfig: state.facet(lspConfigState),
+  });
+  if (state.field(historyField, false) !== undefined) {
+    // A fresh initializer resets the history in the same transaction as the language.
+    extensions.push(
+      historyField.init(() =>
+        EditorState.create({ extensions: [history()] }).field(historyField),
+      ),
+    );
+  }
+  return [
+    setLanguageAdapter.of(language),
+    languageCompartment.reconfigure(extensions),
+  ];
+}
+
 /**
  * State effect to set the language adapter.
  */
@@ -129,11 +156,6 @@ function updateLanguageAdapterAndCode({
 }) {
   const currentLanguage = view.state.field(languageAdapterState);
   const code = view.state.doc.toString();
-  const completionConfig = view.state.facet(completionConfigState);
-  const hotkeysProvider = view.state.facet(hotkeysProviderState);
-  const placeholderType = view.state.facet(placeholderState);
-  const cellId = view.state.facet(cellIdState);
-  const lspConfig = view.state.facet(lspConfigState);
   let metadata = view.state.field(languageMetadataField);
   let cursor = view.state.selection.main.head;
 
@@ -164,22 +186,15 @@ function updateLanguageAdapterAndCode({
   // Update the state
   view.dispatch({
     effects: [
-      setLanguageAdapter.of(nextLanguage),
+      ...languageConfigurationEffects(view.state, nextLanguage),
       setLanguageMetadata.of(metadata),
-      languageCompartment.reconfigure(
-        nextLanguage.getExtension({
-          cellId,
-          completionConfig,
-          hotkeys: hotkeysProvider,
-          placeholderType,
-          lspConfig,
-        }),
-      ),
-      // Clear history
-      historyCompartment.reconfigure([]),
+      ...(nextLanguage.type === "sql"
+        ? [sqlDialectEffect(metadata.engine)]
+        : []),
       // Let downstream extensions know that this is a formatting change
       formattingChangeEffect.of(true),
     ],
+    annotations: Transaction.addToHistory.of(false),
     changes: opts.keepCodeAsIs
       ? undefined
       : {
@@ -189,16 +204,6 @@ function updateLanguageAdapterAndCode({
         },
     selection: opts.keepCodeAsIs ? undefined : EditorSelection.cursor(cursor),
   });
-
-  // Add history back
-  view.dispatch({
-    effects: [historyCompartment.reconfigure([history()])],
-  });
-
-  // Initialize SQL dialect if switching to SQL
-  if (nextLanguage.type === "sql") {
-    initializeSQLDialect(view);
-  }
 }
 
 /**
@@ -228,6 +233,18 @@ export function adaptiveLanguageConfiguration(opts: {
     ),
     languageAdapterState,
     languageMetadataField,
+    invertedEffects.of((tr) => {
+      if (!tr.effects.some((effect) => effect.is(setLanguageMetadata))) {
+        return [];
+      }
+      const metadata = tr.startState.field(languageMetadataField);
+      return [
+        setLanguageMetadata.of(metadata),
+        ...(tr.startState.field(languageAdapterState).type === "sql"
+          ? [sqlDialectEffect(metadata.engine)]
+          : []),
+      ];
+    }),
   ];
 }
 

package/src/core/codemirror/language/languages/sql/sql.ts

@@ -2,7 +2,7 @@
 
 import { acceptCompletion, autocompletion } from "@codemirror/autocomplete";
 import { insertTab } from "@codemirror/commands";
-import { type SQLDialect, type SQLNamespace, sql } from "@codemirror/lang-sql";
+import { type SQLNamespace, sql } from "@codemirror/lang-sql";
 import type { EditorState, Extension } from "@codemirror/state";
 import { Compartment } from "@codemirror/state";
 import {
@@ -497,12 +497,12 @@ function isDuckDBConnection(
 }
 
 /**
- * Update the SQL dialect in the editor view.
+ * The effect that reconfigures the SQL language for the connection's dialect.
+ * Callers dispatch it, alone or with the change that selected the connection.
  */
-function updateSQLDialect(view: EditorView, dialect: SQLDialect) {
-  view.dispatch({
-    effects: sqlConfigCompartment.reconfigure(sql({ dialect })),
-  });
+export function sqlDialectEffect(connectionName: ConnectionName) {
+  const dialect = SCHEMA_CACHE.getDialect(connectionName);
+  return sqlConfigCompartment.reconfigure(sql({ dialect }));
 }
 
 // Helper functions to update the SQL dialect
@@ -511,17 +511,7 @@ export function updateSQLDialectFromConnection(
   view: EditorView,
   connectionName: ConnectionName,
 ) {
-  const dialect = SCHEMA_CACHE.getDialect(connectionName);
-  updateSQLDialect(view, dialect);
-}
-
-export function initializeSQLDialect(view: EditorView) {
-  // Get current engine and update dialect
-  const metadata = getSQLMetadata(view.state);
-  const connectionName = metadata.engine;
-  const dialect = SCHEMA_CACHE.getDialect(connectionName);
-
-  updateSQLDialect(view, dialect);
+  view.dispatch({ effects: sqlDialectEffect(connectionName) });
 }
 
 function getSQLMetadata(state: EditorState): SQLLanguageAdapterMetadata {

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

@@ -2,12 +2,8 @@
 
 import type { EditorState } from "@codemirror/state";
 import type { EditorView } from "@codemirror/view";
-import { replaceEditorContent } from "../replace-editor-content";
-import {
-  languageAdapterFromCode,
-  languageAdapterState,
-  switchLanguage,
-} from "./extension";
+import { getCellCode } from "./cell-code";
+import { languageAdapterState } from "./extension";
 import { languageMetadataField } from "./metadata";
 
 /**
@@ -19,42 +15,16 @@ export function getEditorCodeAsPython(
   fromPos?: number,
   toPos?: number,
 ): string {
+  if (fromPos === undefined) {
+    return getCellCode(editor.state);
+  }
   const languageAdapter = editor.state.field(languageAdapterState);
   const metadata = editor.state.field(languageMetadataField);
   const editorText = editor.state.doc.toString();
-  if (fromPos !== undefined) {
-    return languageAdapter.transformOut(
-      editorText.slice(fromPos, toPos),
-      metadata,
-    )[0];
-  }
-  return languageAdapter.transformOut(editorText, metadata)[0];
-}
-
-/**
- * Update the editor code from Python code
- * Handles when the editor is showing a different language (e.g. markdown)
- */
-export function updateEditorCodeFromPython(
-  editor: EditorView,
-  pythonCode: string,
-): string {
-  const currentAdapter = editor.state.field(languageAdapterState);
-  const correctAdapter = languageAdapterFromCode(pythonCode);
-
-  // If the language type changed (e.g., markdown → python), switch adapters
-  if (correctAdapter.type !== currentAdapter.type) {
-    switchLanguage(editor, {
-      language: correctAdapter.type,
-      keepCodeAsIs: true,
-    });
-  }
-
-  const languageAdapter = editor.state.field(languageAdapterState);
-  const [code] = languageAdapter.transformIn(pythonCode);
-  // Use replaceEditorContent which preserves cursor position when focused
-  replaceEditorContent(editor, code);
-  return code;
+  return languageAdapter.transformOut(
+    editorText.slice(fromPos, toPos),
+    metadata,
+  )[0];
 }
 
 /**

package/src/core/codemirror/lsp/notebook-lsp.ts

@@ -12,10 +12,8 @@ import { Objects } from "@/utils/objects";
 import { isRecord } from "@/utils/records";
 import { getPositionAtWordBounds } from "../completion/hints";
 import { topologicalCodesAtom } from "../copilot/getCodes";
-import {
-  getEditorCodeAsPython,
-  updateEditorCodeFromPython,
-} from "../language/utils";
+import { prepareCellCodeUpdate } from "../language/cell-code";
+import { getEditorCodeAsPython } from "../language/utils";
 import { createNotebookLens, type NotebookLens } from "./lens";
 import { normalizeLspDocumentation } from "./normalize-markdown-math";
 import {
@@ -770,7 +768,10 @@ export class NotebookLanguageServerClient implements ILanguageServerClient {
       // Only update if it has changed
       const code = getEditorCodeAsPython(ev);
       if (code !== newCode) {
-        updateEditorCodeFromPython(ev, newCode);
+        const update = prepareCellCodeUpdate(ev.state, newCode);
+        if (update) {
+          ev.dispatch(update);
+        }
         updatedCount++;
       }
     }

package/src/core/codemirror/rtc/extension.ts

@@ -172,7 +172,6 @@ awareness.addListener((updates, origin) => {
 
 export function realTimeCollaboration(
   cellId: CellId,
-  _updateCellCode: (code: string) => void,
   initialCode = "",
 ): { extension: Extension; code: string } {
   if (isWasm()) {