@marimo-team/islands 0.21.2-dev36 → 0.21.2-dev39

package/dist/main.js

@@ -27014,6 +27014,7 @@ ${c.sqlString}
   function indentOneTab(e) {
     return e.split("\n").map((e2) => (e2 == null ? void 0 : e2.trim()) ? `    ${e2}` : e2).join("\n");
   }
+  const loroSyncAnnotation = Annotation.define();
   function initialState$4() {
     return {};
   }
@@ -27609,9 +27610,23 @@ ${c.sqlString}
       }
     });
   }
+  var MARKDOWN_AUTORUN_USER_EVENTS = [
+    "input",
+    "delete",
+    "undo",
+    "redo"
+  ];
+  function shouldAutorunMarkdownUpdate({ docChanged: e, transactions: r, predicate: c = () => true, hasFocus: d = false }) {
+    return !e || !c() || r.some((e2) => e2.effects.some((e3) => e3.is(formattingChangeEffect))) ? false : r.some((e2) => e2.annotation(loroSyncAnnotation) === void 0 ? MARKDOWN_AUTORUN_USER_EVENTS.some((r2) => e2.isUserEvent(r2)) || d : false);
+  }
   function markdownAutoRunExtension({ predicate: e }) {
     return EditorView.updateListener.of((r) => {
-      r.docChanged && r.view.hasFocus && e() && (r.transactions.some((e2) => e2.effects.some((e3) => e3.is(formattingChangeEffect))) || r.view.state.facet(cellActionsState).onRun());
+      shouldAutorunMarkdownUpdate({
+        docChanged: r.docChanged,
+        transactions: r.transactions,
+        predicate: e,
+        hasFocus: r.view.hasFocus
+      }) && r.view.state.facet(cellActionsState).onRun();
     });
   }
   const pythonCompletionSource = async (e) => {
@@ -70858,7 +70873,7 @@ Image URL: ${r.imageUrl}`)), contextToXml({
       return Logger.warn("Failed to get version from mount config"), null;
     }
   }
-  const marimoVersionAtom = atom(getVersionFromMountConfig() || "0.21.2-dev36"), showCodeInRunModeAtom = atom(true);
+  const marimoVersionAtom = atom(getVersionFromMountConfig() || "0.21.2-dev39"), showCodeInRunModeAtom = atom(true);
   atom(null);
   var import_compiler_runtime$89 = require_compiler_runtime();
   function useKeydownOnElement(e, r) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.21.2-dev36",
+  "version": "0.21.2-dev39",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

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

@@ -0,0 +1,114 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+// @vitest-environment jsdom
+
+import {
+  EditorState,
+  Transaction,
+  type TransactionSpec,
+} 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;
+
+function createTransaction(spec: TransactionSpec) {
+  return EditorState.create({ doc: "" }).update(spec);
+}
+
+describe("shouldAutorunMarkdownUpdate", () => {
+  it.each([
+    "input.type",
+    "delete.backward",
+    "undo",
+    "redo",
+  ])("accepts local %s transactions", (userEvent) => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [Transaction.userEvent.of(userEvent)],
+    });
+
+    expect(
+      shouldAutorunMarkdownUpdate({
+        docChanged: transaction.docChanged,
+        transactions: [transaction],
+      }),
+    ).toBe(true);
+  });
+
+  it("ignores formatting changes", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [Transaction.userEvent.of("input.type")],
+      effects: [formattingChangeEffect.of(true)],
+    });
+
+    expect(
+      shouldAutorunMarkdownUpdate({
+        docChanged: transaction.docChanged,
+        transactions: [transaction],
+      }),
+    ).toBe(false);
+  });
+
+  it("ignores RTC sync transactions", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [
+        Transaction.userEvent.of("input.type"),
+        loroSyncAnnotation.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: "#" },
+    });
+
+    expect(
+      shouldAutorunMarkdownUpdate({
+        docChanged: transaction.docChanged,
+        transactions: [transaction],
+      }),
+    ).toBe(false);
+  });
+
+  it("allows focused local doc changes without user event annotations", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+    });
+
+    expect(
+      shouldAutorunMarkdownUpdate({
+        docChanged: transaction.docChanged,
+        transactions: [transaction],
+        hasFocus: true,
+      }),
+    ).toBe(true);
+  });
+
+  it("honors the predicate gate", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [Transaction.userEvent.of("input.type")],
+    });
+
+    expect(
+      shouldAutorunMarkdownUpdate({
+        docChanged: transaction.docChanged,
+        transactions: [transaction],
+        predicate: () => false,
+      }),
+    ).toBe(false);
+  });
+});

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

@@ -2,9 +2,15 @@
 
 import { closeCompletion, completionStatus } from "@codemirror/autocomplete";
 import { type Extension, Prec } from "@codemirror/state";
-import { EditorView, type KeyBinding, keymap } from "@codemirror/view";
+import {
+  EditorView,
+  type KeyBinding,
+  keymap,
+  type ViewUpdate,
+} from "@codemirror/view";
 import { createTracebackInfoAtom } from "@/core/cells/cells";
 import { type CellId, HTMLCellId, SCRATCH_CELL_ID } from "@/core/cells/ids";
+import { loroSyncAnnotation } from "@/core/codemirror/rtc/loro/sync";
 import type { KeymapConfig } from "@/core/config/config-schema";
 import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
 import { duplicateWithCtrlModifier } from "@/core/hotkeys/shortcuts";
@@ -330,6 +336,53 @@ function cellCodeEditing(hotkeys: HotkeyProvider): Extension[] {
   return [onChangePlugin, formatKeymapExtension(hotkeys)];
 }
 
+const MARKDOWN_AUTORUN_USER_EVENTS = ["input", "delete", "undo", "redo"];
+
+function shouldAutorunMarkdownUpdate({
+  docChanged,
+  transactions,
+  predicate = () => true,
+  hasFocus = false,
+}: Pick<ViewUpdate, "docChanged" | "transactions"> & {
+  predicate?: () => boolean;
+  hasFocus?: boolean;
+}): boolean {
+  // If the doc didn't change, ignore.
+  if (!docChanged) {
+    return false;
+  }
+
+  // The caller decides when markdown autorun is allowed, e.g. not for
+  // f-strings where rerunning on every keystroke is usually incorrect.
+  if (!predicate()) {
+    return false;
+  }
+
+  // This happens on mount when we start in markdown mode.
+  // Ignore formatting changes so language switches don't trigger autorun.
+  const isFormattingChange = transactions.some((tr) =>
+    tr.effects.some((effect) => effect.is(formattingChangeEffect)),
+  );
+  if (isFormattingChange) {
+    return false;
+  }
+
+  return transactions.some((tr) => {
+    // Ignore RTC sync changes to avoid duplicate runs from remote edits.
+    if (tr.annotation(loroSyncAnnotation) !== undefined) {
+      return false;
+    }
+
+    // Prefer explicit local edit transactions, but keep a focused fallback for
+    // local rewrite paths like split-cell, which can update markdown content
+    // without annotating a user event.
+    return (
+      MARKDOWN_AUTORUN_USER_EVENTS.some((kind) => tr.isUserEvent(kind)) ||
+      hasFocus
+    );
+  });
+}
+
 /**
  * Extension for auto-running markdown cells
  */
@@ -339,30 +392,16 @@ export function markdownAutoRunExtension({
   predicate: () => boolean;
 }): Extension {
   return EditorView.updateListener.of((update) => {
-    // If the doc didn't change, ignore
-    if (!update.docChanged) {
-      return;
-    }
-
-    // If not focused, ignore
-    // This can cause multiple runs when in RTC mode
-    if (!update.view.hasFocus) {
-      return;
-    }
-
-    if (!predicate()) {
+    if (
+      !shouldAutorunMarkdownUpdate({
+        docChanged: update.docChanged,
+        transactions: update.transactions,
+        predicate,
+        hasFocus: update.view.hasFocus,
+      })
+    ) {
       return;
     }
-
-    // This happens on mount when we start in markdown mode
-    const isFormattingChange = update.transactions.some((tr) =>
-      tr.effects.some((effect) => effect.is(formattingChangeEffect)),
-    );
-    if (isFormattingChange) {
-      // Ignore formatting changes
-      return;
-    }
-
     const actions = update.view.state.facet(cellActionsState);
     actions.onRun();
   });
@@ -388,3 +427,7 @@ export function cellBundle({
     ),
   ];
 }
+
+export const exportedForTesting = {
+  shouldAutorunMarkdownUpdate,
+};

package/src/core/codemirror/rtc/loro/__tests__/sync.test.ts

@@ -0,0 +1,52 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { EditorState } from "@codemirror/state";
+import type { EditorView } from "@codemirror/view";
+import { LoroDoc, LoroText } from "loro-crdt";
+import { describe, expect, it, vi } from "vitest";
+import { LoroSyncPluginValue, loroSyncAnnotation } from "../sync";
+
+describe("LoroSyncPluginValue", () => {
+  it("annotates the initial reconciliation dispatch as RTC sync", async () => {
+    const dispatch = vi.fn();
+    const view = {
+      state: EditorState.create({ doc: "local" }),
+      dispatch,
+    } as unknown as EditorView;
+
+    const doc = new LoroDoc();
+    const text = doc
+      .getMap("codes")
+      .getOrCreateContainer("cell-1", new LoroText());
+    text.insert(0, "remote");
+
+    const plugin = new LoroSyncPluginValue(
+      view,
+      doc,
+      ["codes", "cell-1"],
+      () => text,
+    );
+
+    await Promise.resolve();
+
+    expect(dispatch).toHaveBeenCalledTimes(1);
+    expect(dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        changes: [
+          {
+            from: 0,
+            to: view.state.doc.length,
+            insert: "remote",
+          },
+        ],
+        annotations: [
+          expect.objectContaining({
+            type: loroSyncAnnotation,
+          }),
+        ],
+      }),
+    );
+
+    plugin.destroy();
+  });
+});

package/src/core/codemirror/rtc/loro/sync.ts

@@ -72,6 +72,7 @@ export class LoroSyncPluginValue implements PluginValue {
             insert: text.toString(),
           },
         ],
+        annotations: [loroSyncAnnotation.of(this)],
       });
     });
   }