@marimo-team/islands 0.23.10-dev9 → 0.23.10

package/src/core/codemirror/__tests__/editor-mount-scheduler.test.ts

@@ -0,0 +1,143 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import { createEditorMountScheduler } from "../editor-mount-scheduler";
+
+function makeManualSchedule() {
+  let pending: (() => void) | null = null;
+  const schedule = (cb: () => void) => {
+    pending = cb;
+  };
+  const flush = () => {
+    const cb = pending;
+    pending = null;
+    cb?.();
+  };
+  return { schedule, flush, hasPending: () => pending !== null };
+}
+
+describe("createEditorMountScheduler", () => {
+  it("builds one queued editor per tick in FIFO order, rescheduling between", () => {
+    const { schedule, flush, hasPending } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.request("b", () => built.push("b"));
+    flush();
+    expect(built).toEqual(["a"]);
+    expect(hasPending()).toBe(true);
+    flush();
+    expect(built).toEqual(["a", "b"]);
+  });
+
+  it("stops rescheduling once the queue is empty", () => {
+    const { schedule, flush, hasPending } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    flush();
+    expect(built).toEqual(["a"]);
+    expect(hasPending()).toBe(false);
+  });
+
+  it("promote builds immediately and removes from the queue", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.request("b", () => built.push("b"));
+    s.promote("b");
+    expect(built).toEqual(["b"]);
+    flush();
+    expect(built).toEqual(["b", "a"]);
+  });
+
+  it("cancel prevents a queued build", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.cancel("a");
+    flush();
+    expect(built).toEqual([]);
+  });
+
+  it("builds prioritized cells before earlier-queued ones", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.request("b", () => built.push("b"));
+    s.request("c", () => built.push("c"));
+    s.prioritize("c");
+    flush();
+    flush();
+    flush();
+    expect(built).toEqual(["c", "a", "b"]);
+  });
+
+  it("builds multiple prioritized cells in prioritization order, then FIFO", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.request("b", () => built.push("b"));
+    s.request("c", () => built.push("c"));
+    s.request("d", () => built.push("d"));
+    s.prioritize("d");
+    s.prioritize("b");
+    flush();
+    flush();
+    flush();
+    flush();
+    expect(built).toEqual(["d", "b", "a", "c"]);
+  });
+
+  it("ignores prioritize for a cell that is not queued", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.prioritize("not-queued");
+    flush();
+    expect(built).toEqual(["a"]);
+  });
+
+  it("deprioritize reverts a cell to FIFO order without dropping it", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.request("b", () => built.push("b"));
+    s.prioritize("b");
+    s.deprioritize("b");
+    flush();
+    flush();
+    expect(built).toEqual(["a", "b"]);
+  });
+
+  it("keeps draining the queue after a build throws", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => {
+      throw new Error("boom");
+    });
+    s.request("b", () => built.push("b"));
+    expect(() => flush()).toThrow("boom");
+    flush();
+    expect(built).toEqual(["b"]);
+  });
+
+  it("cancel removes a prioritized cell", () => {
+    const { schedule, flush } = makeManualSchedule();
+    const built: string[] = [];
+    const s = createEditorMountScheduler(schedule);
+    s.request("a", () => built.push("a"));
+    s.request("b", () => built.push("b"));
+    s.prioritize("b");
+    s.cancel("b");
+    flush();
+    flush();
+    expect(built).toEqual(["a"]);
+  });
+});

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

@@ -47,7 +47,9 @@ const notebookCellCodes = atom((get) => {
       const handle = notebook.cellHandles[id];
       return [
         id,
-        handle?.current ? getEditorCodeAsPython(handle.current.editorView) : "",
+        handle?.current?.editorView
+          ? getEditorCodeAsPython(handle.current.editorView)
+          : "",
       ];
     }),
   );

package/src/core/codemirror/editor-mount-scheduler.ts

@@ -0,0 +1,101 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import {
+  scheduleTask as defaultScheduleTask,
+  type ScheduleTaskFn,
+} from "@/utils/schedule-task";
+
+type BuildFn = () => void;
+
+export interface EditorMountScheduler {
+  /** Queue a cell's editor build to run on a future task. */
+  request(cellId: string, build: BuildFn): void;
+  /** Build a queued cell's editor synchronously, right now (e.g. on focus). */
+  promote(cellId: string): void;
+  /**
+   * Mark a queued cell to build ahead of un-prioritized ones, keeping the
+   * one-build-per-task pacing (e.g. when the cell scrolls into view).
+   */
+  prioritize(cellId: string): void;
+  /** Drop a cell's prioritized mark, reverting it to plain FIFO order. */
+  deprioritize(cellId: string): void;
+  /** Remove a cell's queued build entirely. */
+  cancel(cellId: string): void;
+}
+
+/**
+ * Drains a FIFO queue of editor builds, one per macrotask, so constructing many
+ * CodeMirror instances never blocks the main thread in a single long task. The
+ * scheduler yields between every build to keep the page responsive. Cells can
+ * be prioritized (e.g. when they scroll into view) to jump ahead of the queue
+ * without breaking the one-build-per-macrotask pacing.
+ */
+export function createEditorMountScheduler(
+  scheduleTask: ScheduleTaskFn = defaultScheduleTask,
+): EditorMountScheduler {
+  const queue = new Map<string, BuildFn>();
+  const priority = new Set<string>();
+  let isProcessingScheduled = false;
+
+  function scheduleProcessing(): void {
+    if (isProcessingScheduled || queue.size === 0) {
+      return;
+    }
+    isProcessingScheduled = true;
+    scheduleTask(processNext);
+  }
+
+  // Prioritized cells first, in the order they were prioritized; then FIFO.
+  function nextCellId(): string | undefined {
+    for (const cellId of priority) {
+      if (queue.has(cellId)) {
+        return cellId;
+      }
+      priority.delete(cellId);
+    }
+    return queue.keys().next().value;
+  }
+
+  function processNext(): void {
+    isProcessingScheduled = false;
+    try {
+      const cellId = nextCellId();
+      if (cellId !== undefined) {
+        const build = queue.get(cellId);
+        queue.delete(cellId);
+        priority.delete(cellId);
+        build?.();
+      }
+    } finally {
+      scheduleProcessing();
+    }
+  }
+
+  return {
+    request(cellId, build) {
+      queue.set(cellId, build);
+      scheduleProcessing();
+    },
+    promote(cellId) {
+      const build = queue.get(cellId);
+      if (build) {
+        queue.delete(cellId);
+        priority.delete(cellId);
+        build();
+      }
+    },
+    prioritize(cellId) {
+      if (queue.has(cellId)) {
+        priority.add(cellId);
+      }
+    },
+    deprioritize(cellId) {
+      priority.delete(cellId);
+    },
+    cancel(cellId) {
+      queue.delete(cellId);
+      priority.delete(cellId);
+    },
+  };
+}
+
+export const editorMountScheduler = createEditorMountScheduler();

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

@@ -33,6 +33,7 @@ import { cellActionsState } from "../../cells/state";
 import { pythonCompletionSource } from "../../completion/completer";
 import type { PlaceholderType } from "../../config/types";
 import { FederatedLanguageServerClient } from "../../lsp/federated-lsp";
+import { createLspMarkdownRenderer } from "../../lsp/markdown-renderer";
 import { NotebookLanguageServerClient } from "../../lsp/notebook-lsp";
 import { createTransport } from "../../lsp/transports";
 import { CellDocumentUri, type ILanguageServerClient } from "../../lsp/types";
@@ -342,6 +343,7 @@ export class PythonLanguageAdapter implements LanguageAdapter<{}> {
             client: client as unknown as LanguageServerClient,
             languageId: "python",
             allowHTMLContent: true,
+            markdownRenderer: createLspMarkdownRenderer(),
             useSnippetOnCompletion: true,
             hoverConfig: hoverOptions,
             completionConfig: autocompleteOptions,

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

@@ -14,6 +14,7 @@ import {
 } from "@codemirror/lang-sql";
 import {
   BigQueryDialect,
+  DremioDialect,
   DuckDBDialect,
 } from "@marimo-team/codemirror-sql/dialects";
 import type { DataSourceConnection } from "@/core/kernel/messages";
@@ -97,6 +98,8 @@ export function guessDialect(
       return PLSQL;
     case "bigquery":
       return BigQueryDialect;
+    case "dremio":
+      return DremioDialect;
     case "timescaledb":
       return PostgreSQL; // TimescaleDB is a PostgreSQL dialect
     case "awsathena":
@@ -116,7 +119,6 @@ export function guessDialect(
     case "spark":
     case "databricks":
     case "datafusion":
-    case "dremio":
       Logger.debug("Unsupported dialect", { dialect });
       return ModifiedStandardSQL;
     default:

package/src/core/codemirror/lsp/__tests__/markdown-renderer.test.ts

@@ -0,0 +1,41 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import { createLspMarkdownRenderer } from "../markdown-renderer";
+
+describe("createLspMarkdownRenderer", () => {
+  it("syntax-highlights python code blocks with tok-* span classes", () => {
+    const render = createLspMarkdownRenderer();
+    const result = render("```python\ndef foo():\n    pass\n```");
+    expect(result).toContain('class="language-python"');
+    expect(result).toContain("tok-keyword");
+    expect(result).toContain("<pre><code");
+  });
+
+  it("does not highlight non-python code blocks", () => {
+    const render = createLspMarkdownRenderer();
+    const result = render("```bash\necho hello\n```");
+    expect(result).not.toContain("tok-keyword");
+    expect(result).toContain("<code");
+  });
+
+  it("renders empty python code blocks as empty string", () => {
+    const render = createLspMarkdownRenderer();
+    const result = render("```python\n   \n```");
+    expect(result).toBe("");
+  });
+
+  it("renders markdown prose unchanged", () => {
+    const render = createLspMarkdownRenderer();
+    const result = render("## Examples\n\nSome text.");
+    expect(result).toContain("<h2");
+    expect(result).toContain("Examples");
+    expect(result).toContain("Some text.");
+  });
+
+  it("escapes HTML in highlighted code", () => {
+    const render = createLspMarkdownRenderer();
+    const result = render('```python\nx = "<div>"\n```');
+    expect(result).not.toContain("<div>");
+    expect(result).toContain("&lt;div&gt;");
+  });
+});

package/src/core/codemirror/lsp/markdown-renderer.ts

@@ -0,0 +1,59 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { classHighlighter, highlightCode } from "@lezer/highlight";
+import { parser as pythonParser } from "@lezer/python";
+import { marked } from "marked";
+
+/**
+ * Syntax-highlight a Python code string using the lezer Python parser.
+ * Returns an HTML string with tok-* span classes for styling.
+ */
+function highlightPython(code: string): string {
+  const tree = pythonParser.parse(code);
+  let html = "";
+  highlightCode(
+    code,
+    tree,
+    classHighlighter,
+    (text, classes) => {
+      const escaped = text
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+      html += classes ? `<span class="${classes}">${escaped}</span>` : escaped;
+    },
+    () => {
+      html += "\n";
+    },
+  );
+  return html;
+}
+
+/**
+ * A markdown renderer for LSP hover tooltips that adds syntax highlighting
+ * to Python code blocks using the lezer Python parser and classHighlighter.
+ * The tok-* CSS classes are defined in documentation.css.
+ */
+export function createLspMarkdownRenderer(): (markdown: string) => string {
+  const renderer = new marked.Renderer();
+  const prevCode = renderer.code.bind(renderer);
+
+  renderer.code = (token) => {
+    const { text, lang } = token;
+    if (!text.trim()) {
+      return "";
+    }
+    if (lang === "python" || lang === "py") {
+      const highlighted = highlightPython(text);
+      return `<pre><code class="language-python">${highlighted}</code></pre>\n`;
+    }
+    return prevCode(token);
+  };
+
+  return (markdown: string): string =>
+    marked(markdown, {
+      async: false,
+      gfm: true,
+      breaks: true,
+      renderer,
+    }) as string;
+}

package/src/core/datasets/data-source-connections.ts

@@ -169,6 +169,7 @@ const {
         return {
           ...db,
           schemas: schemas,
+          schemas_resolved: true,
         };
       }),
     };
@@ -213,6 +214,7 @@ const {
             return {
               ...schema,
               tables: tables,
+              tables_resolved: true,
             };
           }),
         };

package/src/core/errors/errors.ts

@@ -18,7 +18,7 @@ export interface AutoFix {
   fixType: "manual" | "ai";
   onFix: (ctx: {
     addCodeBelow: (code: string) => void;
-    editor: EditorView | undefined;
+    editor: EditorView | null | undefined;
     cellId: CellId;
     aiFix?: AIFix;
   }) => Promise<void>;

package/src/core/storage/__tests__/state.test.ts

@@ -48,6 +48,7 @@ describe("storage state", () => {
       expect(state).toEqual({
         namespaces: [],
         entriesByPath: new Map(),
+        pageMetadataByPath: new Map(),
       });
     });
   });
@@ -134,6 +135,49 @@ describe("storage state", () => {
       expect(state.entriesByPath.get("my_s3::data/")).toEqual(entries);
     });
 
+    it("should store next page tokens keyed by namespace and prefix", () => {
+      const entries = [makeEntry({ path: "a.txt" })];
+
+      actions.setEntries({
+        namespace: "my_s3",
+        prefix: "data/",
+        entries,
+        nextPageToken: "150",
+      });
+
+      expect(state.entriesByPath.get("my_s3::data/")).toEqual(entries);
+      expect(state.pageMetadataByPath.get("my_s3::data/")?.nextPageToken).toBe(
+        "150",
+      );
+    });
+
+    it("should append entries when requested", () => {
+      const firstPage = [makeEntry({ path: "a.txt" })];
+      const secondPage = [makeEntry({ path: "b.txt" })];
+
+      actions.setEntries({
+        namespace: "my_s3",
+        prefix: "data/",
+        entries: firstPage,
+        nextPageToken: "150",
+      });
+      actions.setEntries({
+        namespace: "my_s3",
+        prefix: "data/",
+        entries: secondPage,
+        nextPageToken: null,
+        append: true,
+      });
+
+      expect(state.entriesByPath.get("my_s3::data/")).toEqual([
+        ...firstPage,
+        ...secondPage,
+      ]);
+      expect(
+        state.pageMetadataByPath.get("my_s3::data/")?.nextPageToken,
+      ).toBeNull();
+    });
+
     it("should use empty string for null prefix", () => {
       const entries = [makeEntry({ path: "root.txt" })];
 
@@ -251,6 +295,11 @@ describe("storage state", () => {
       expect(state.entriesByPath.get("my_s3::")).toBeUndefined();
       expect(state.entriesByPath.get("my_s3::data/")).toBeUndefined();
       expect(state.entriesByPath.get("my_s3::data/nested/")).toBeUndefined();
+      expect(state.pageMetadataByPath.get("my_s3::")).toBeUndefined();
+      expect(state.pageMetadataByPath.get("my_s3::data/")).toBeUndefined();
+      expect(
+        state.pageMetadataByPath.get("my_s3::data/nested/"),
+      ).toBeUndefined();
     });
 
     it("should not affect entries from other namespaces", () => {