@marimo-team/islands 0.25.3-dev27 → 0.25.3-dev270

package/src/core/codemirror/__tests__/setup.test.ts

@@ -40,6 +40,7 @@ function getOpts() {
     enableAI: false,
     cellActions: {
       toggleHideCode: namedFunction("toggleHideCode"),
+      askAiAboutCell: namedFunction("askAiAboutCell"),
       aiCellCompletion: namedFunction("aiCellCompletion"),
       createManyBelow: namedFunction("createManyBelow"),
       onRun: namedFunction("onRun"),
@@ -100,7 +101,7 @@ function getDuplicateKeymaps(state: EditorState) {
     (keymap) => keymap,
   );
   const duplicates = Objects.fromEntries(
-    Object.entries(groupBy).filter(([key, value]) => value.length > 1),
+    Object.entries(groupBy).filter(([_key, value]) => value.length > 1),
   );
   return duplicates;
 }
@@ -198,22 +199,22 @@ test("go to definition falls through to lower-priority LSP keymap", () => {
 test("placeholder adds another extension", () => {
   const opts = getOpts();
   const withAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "marimo-import",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "marimo-import",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   const withoutAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "none",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "none",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   expect(withAI.length - 1).toBe(withoutAI.length);
 });
@@ -221,22 +222,53 @@ test("placeholder adds another extension", () => {
 test("ai adds more extensions", () => {
   const opts = getOpts();
   const withAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "ai",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "ai",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   const withoutAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "none",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "none",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   expect(withAI.length - 2).toBe(withoutAI.length);
 });
+
+test("empty-cell AI action opens chat without invoking the local refactor prompt", () => {
+  const askAiAboutCell = vi.fn();
+  const aiCellCompletion = vi.fn();
+  const view = new EditorView({
+    state: EditorState.create({
+      doc: "",
+      extensions: setup({
+        showPlaceholder: true,
+        enableAI: false,
+        enableAIChat: true,
+        cellActions: {
+          ...getOpts().cellActions,
+          askAiAboutCell,
+          aiCellCompletion,
+        },
+      }),
+    }),
+  });
+  try {
+    const button = view.dom.querySelector<HTMLButtonElement>(
+      ".cm-clickable-placeholder",
+    );
+    expect(button?.textContent).toBe("generate with AI");
+    button?.click();
+    expect(askAiAboutCell).toHaveBeenCalledOnce();
+    expect(aiCellCompletion).not.toHaveBeenCalled();
+  } finally {
+    view.destroy();
+  }
+});

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

@@ -8,7 +8,6 @@ import {
 } from "@codemirror/state";
 import { describe, expect, it } from "vitest";
 import { formattingChangeEffect } from "../../format";
-import { loroSyncAnnotation } from "../../rtc/loro/sync";
 import { exportedForTesting } from "../extensions";
 
 const { shouldAutorunMarkdownUpdate } = exportedForTesting;
@@ -50,13 +49,10 @@ describe("shouldAutorunMarkdownUpdate", () => {
     ).toBe(false);
   });
 
-  it("ignores RTC sync transactions", () => {
+  it("ignores remote transactions while focused", () => {
     const transaction = createTransaction({
       changes: { from: 0, insert: "#" },
-      annotations: [
-        Transaction.userEvent.of("input.type"),
-        loroSyncAnnotation.of(true),
-      ],
+      annotations: [Transaction.remote.of(true)],
     });
 
     expect(

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,
@@ -14,7 +14,6 @@ import {
   clearPendingCutAtom,
   pendingCutCellIdsAtom,
 } from "@/core/cells/pending-cut-service";
-import { loroSyncAnnotation } from "@/core/codemirror/rtc/loro/sync";
 import type { KeymapConfig } from "@/core/config/config-schema";
 import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
 import { getFeatureFlag } from "@/core/config/feature-flag";
@@ -24,7 +23,7 @@ import { createObservable } from "@/core/state/observable";
 import { formatKeymapExtension } from "../extensions";
 import { formattingChangeEffect } from "../format";
 import { goToDefinitionAtCursorPosition } from "../go-to-definition/utils";
-import { getEditorCodeAsPython } from "../language/utils";
+import { getCellCode } from "../language/cell-code";
 import { isAtEndOfEditor, isAtStartOfEditor } from "../utils";
 import {
   breakpointGutter,
@@ -190,7 +189,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 +206,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 +218,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 +228,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 +259,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 +270,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;
         },
       },
@@ -324,26 +323,28 @@ function cellKeymaps({
  */
 function cellCodeEditing(hotkeys: HotkeyProvider): Extension[] {
   const onChangePlugin = EditorView.updateListener.of((update) => {
-    if (update.docChanged) {
-      // Check if the doc update was a formatting change
-      // e.g. changing from python to markdown
-      const isFormattingChange = update.transactions.some((tr) =>
-        tr.effects.some((effect) => effect.is(formattingChangeEffect)),
-      );
-      const nextCode = getEditorCodeAsPython(update.view);
-      const cellActions = update.view.state.facet(cellActionsState);
-      const cellId = update.view.state.facet(cellIdState);
-      cellActions.updateCellCode({
+    if (!update.docChanged) {
+      return;
+    }
+    const cellId = update.view.state.facet(cellIdState);
+    // The code itself reaches the document through the editor's binding.
+    // Formatting, including a language switch, rewrites the code without
+    // editing it, so the cell stays as run or as edited as it was.
+    const formatted = update.transactions.some((tr) =>
+      tr.effects.some((effect) => effect.is(formattingChangeEffect)),
+    );
+    if (formatted) {
+      update.view.state.facet(cellActionsState).codeFormatted({
         cellId,
-        code: nextCode,
-        formattingChange: isFormattingChange,
+        before: getCellCode(update.startState),
+        after: getCellCode(update.state),
       });
+    }
 
-      // Clear pending cut state if this cell was marked for cut
-      const pendingCutCellIds = store.get(pendingCutCellIdsAtom);
-      if (pendingCutCellIds.has(cellId)) {
-        store.set(clearPendingCutAtom);
-      }
+    // Clear pending cut state if this cell was marked for cut
+    const pendingCutCellIds = store.get(pendingCutCellIdsAtom);
+    if (pendingCutCellIds.has(cellId)) {
+      store.set(clearPendingCutAtom);
     }
   });
 
@@ -382,8 +383,9 @@ 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)) {
       return false;
     }
 

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

@@ -1,18 +1,14 @@
 /* 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 {
   toggleHideCode: () => boolean;
+  askAiAboutCell: () => void;
   aiCellCompletion: () => boolean;
   createManyBelow: (content: string[]) => void;
-  /**
-   * Create the setup cell with the given code, or append the code to the
-   * existing setup cell if one already exists.
-   */
-  addOrAppendSetupCell: (code: string) => void;
   onRun: () => void;
   deleteCell: () => void;
   afterToggleMarkdown: () => void;

package/src/core/codemirror/cm.ts

@@ -74,6 +74,7 @@ export interface CodeMirrorSetupOpts {
   cellId: CellId;
   showPlaceholder: boolean;
   enableAI: boolean;
+  enableAIChat?: boolean;
   acceptCompletionOnEnter?: boolean;
   cellActions: CodemirrorCellActions;
   completionConfig: CompletionConfig;
@@ -92,7 +93,10 @@ export interface CodeMirrorSetupOpts {
 }
 
 function getPlaceholderType(opts: CodeMirrorSetupOpts) {
-  const { showPlaceholder, enableAI } = opts;
+  const { showPlaceholder, enableAI, enableAIChat } = opts;
+  if (enableAIChat) {
+    return "ai";
+  }
   return showPlaceholder ? "marimo-import" : enableAI ? "ai" : "none";
 }
 

package/src/core/codemirror/config/types.ts

@@ -4,7 +4,7 @@
  * The type of placeholder to use for the editor.
  *
  * - "marimo-import" -> Shows `import marimo as mo`
- * - "ai" -> Shows `Start coding or Generate with AI`
+ * - "ai" -> Shows `Start coding or generate with AI`
  * - "none" -> No placeholder
  */
 export type PlaceholderType = "marimo-import" | "ai" | "none";

package/src/core/codemirror/copilot/__tests__/getCodes.test.ts

@@ -9,7 +9,6 @@ import { createCell } from "@/core/cells/types";
 import { OverridingHotkeyProvider } from "@/core/hotkeys/hotkeys";
 import { store } from "@/core/state/jotai";
 import { variablesAtom } from "@/core/variables/state";
-import { MultiColumn } from "@/utils/id-tree";
 import { cellConfigExtension } from "../../config/extension";
 import { adaptiveLanguageConfiguration } from "../../language/extension";
 import {
@@ -159,7 +158,7 @@ describe("getCodes", () => {
     ];
     store.set(notebookAtom, {
       ...initialNotebookState(),
-      cellIds: MultiColumn.from([[Cells.cell1, Cells.cell2]]),
+      cellIds: [Cells.cell1, Cells.cell2],
       cellHandles: {
         [Cells.cell1]: { current: mockEditorViews[0] },
         [Cells.cell2]: { current: mockEditorViews[1] },
@@ -177,7 +176,7 @@ describe("getCodes", () => {
     ];
     store.set(notebookAtom, {
       ...initialNotebookState(),
-      cellIds: MultiColumn.from([[Cells.cell1, Cells.cell2]]),
+      cellIds: [Cells.cell1, Cells.cell2],
       cellHandles: {
         [Cells.cell1]: { current: mockEditorViews[0] },
         [Cells.cell2]: { current: mockEditorViews[1] },
@@ -196,7 +195,7 @@ describe("getCodes", () => {
     ];
     store.set(notebookAtom, {
       ...initialNotebookState(),
-      cellIds: MultiColumn.from([[Cells.cell1, Cells.cell2, Cells.cell3]]),
+      cellIds: [Cells.cell1, Cells.cell2, Cells.cell3],
       cellHandles: {
         [Cells.cell1]: { current: mockEditorViews[0] },
         [Cells.cell2]: { current: mockEditorViews[1] },
@@ -218,7 +217,7 @@ describe("getCodes", () => {
     const otherCode = "print('Hello World')";
     store.set(notebookAtom, {
       ...initialNotebookState(),
-      cellIds: MultiColumn.from([[Cells.cell1, Cells.cell2]]),
+      cellIds: [Cells.cell1, Cells.cell2],
       cellData: {
         [Cells.cell1]: createCell({ id: Cells.cell1, code: "import os" }),
         [Cells.cell2]: createCell({ id: Cells.cell2, code: "x = 1" }),
@@ -232,7 +231,7 @@ describe("getCodes", () => {
     const otherCode = "print('Hello World')";
     store.set(notebookAtom, {
       ...initialNotebookState(),
-      cellIds: MultiColumn.from([[Cells.cell1, Cells.cell2]]),
+      cellIds: [Cells.cell1, Cells.cell2],
       cellData: {
         [Cells.cell1]: createCell({ id: Cells.cell1, code: "import os" }),
         [Cells.cell2]: createCell({ id: Cells.cell2, code: "x = 1" }),
@@ -250,7 +249,7 @@ describe("topologicalCodesAtom", () => {
   it("should include every cell when no editor is mounted", () => {
     store.set(notebookAtom, {
       ...initialNotebookState(),
-      cellIds: MultiColumn.from([[Cells.cell1, Cells.cell2, Cells.cell3]]),
+      cellIds: [Cells.cell1, Cells.cell2, Cells.cell3],
       cellData: {
         [Cells.cell1]: createCell({ id: Cells.cell1, code: "import os" }),
         [Cells.cell2]: createCell({ id: Cells.cell2, code: "x = 1" }),

package/src/core/codemirror/copilot/getCodes.ts

@@ -12,7 +12,7 @@ import { getEditorCodeAsPython } from "../language/utils";
 const notebookCellCodes = atom((get) => {
   const notebook = get(notebookAtom);
   const codes = Objects.fromEntries(
-    notebook.cellIds.inOrderIds.map((id) => {
+    notebook.cellIds.map((id) => {
       // A cell editor mounts progressively, so the notebook store is the only
       // complete source of code until every editor is built.
       const editorView = notebook.cellHandles[id]?.current?.editorViewOrNull;
@@ -54,7 +54,7 @@ export function getOtherCellsCode(otherCode: string) {
 
 const inOrderCellIdsAtom = atom((get) => {
   const notebook = get(notebookAtom);
-  return notebook.cellIds.inOrderIds;
+  return notebook.cellIds;
 });
 const topologicalCellIdsAtom = atom((get) => {
   const cellIds = get(inOrderCellIdsAtom);

package/src/core/codemirror/format.ts

@@ -13,15 +13,11 @@ import { notebookCellEditorViews } from "../cells/utils";
 import { getResolvedMarimoConfig } from "../config/config";
 import type { ConnectionName } from "../datasets/engines";
 import { getRequestClient } from "../network/requests";
-import { cellActionsState } from "./cells/state";
-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>();
@@ -56,13 +52,10 @@ export async function formatEditorViews(views: Record<CellId, EditorView>) {
       continue;
     }
 
-    const actions = view.state.facet(cellActionsState);
-    actions.updateCellCode({
-      cellId,
-      code: formattedCode,
-      formattingChange: true,
-    });
-    updateEditorCodeFromPython(view, formattedCode);
+    const update = prepareCellCodeUpdate(view.state, formattedCode);
+    if (update) {
+      view.dispatch(update, { effects: formattingChangeEffect.of(true) });
+    }
   }
 }
 
@@ -110,16 +103,6 @@ export async function formatSQL(editor: EditorView, engine: ConnectionName) {
     return;
   }
 
-  // Update Python in the notebook state
-  const codeAsPython = languageAdapter.transformIn(formattedSQL)[0];
-  const actions = editor.state.facet(cellActionsState);
-  const cellId = editor.state.facet(cellIdState);
-  actions.updateCellCode({
-    cellId,
-    code: codeAsPython,
-    formattingChange: true,
-  });
-
   // Update editor with formatted SQL
   replaceEditorContent(editor, formattedSQL, {
     effects: [formattingChangeEffect.of(true)],

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",