@marimo-team/frontend 0.23.10-dev9 → 0.23.11-dev1

package/src/core/ai/strip-wrapping-backticks.ts

@@ -0,0 +1,88 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+const LANGS = ["python", "sql", "markdown"] as const;
+
+interface StripOptions {
+  /**
+   * When true, the text is treated as a partial stream:
+   * - the opening fence is only stripped once we can be sure of its language
+   *   identifier (e.g. "```py" is left untouched since it may still become
+   *   "```python"), and
+   * - the closing fence is left in place, since it may not have arrived yet (or
+   *   a trailing "```" may be part of the content).
+   */
+  streaming?: boolean;
+}
+
+/**
+ * Removes wrapping markdown code fences from a completion string.
+ */
+export function stripWrappingBackticks(
+  text: string,
+  opts: StripOptions = {},
+): string {
+  const { streaming = false } = opts;
+  const leadingWhitespace = text.match(/^\s*/)?.[0] ?? "";
+  const rest = text.slice(leadingWhitespace.length);
+
+  let body: string | null = null;
+  let strippedOpening = false;
+
+  for (const lang of LANGS) {
+    if (rest.startsWith(`\`\`\`${lang}`)) {
+      strippedOpening = true;
+      body = rest.slice(3 + lang.length);
+      if (body.startsWith("\n")) {
+        body = body.slice(1);
+      }
+      break;
+    }
+  }
+
+  if (!strippedOpening && rest.startsWith("```")) {
+    const afterFence = rest.slice(3);
+    if (streaming && isPartialLanguageFence(afterFence)) {
+      return text;
+    }
+    strippedOpening = true;
+    body = afterFence;
+    if (body.startsWith("\n")) {
+      body = body.slice(1);
+    }
+  }
+
+  if (!strippedOpening || body === null) {
+    return text;
+  }
+
+  // While streaming, the closing fence may not have arrived yet, so leave the
+  // body as-is once the opening fence is removed.
+  if (streaming) {
+    return body;
+  }
+
+  const strippedEnd = body.trimEnd();
+  const trailingSpace = body.slice(strippedEnd.length);
+
+  if (strippedEnd.endsWith("\n```")) {
+    return strippedEnd.slice(0, -4) + trailingSpace;
+  }
+  if (strippedEnd.endsWith("```")) {
+    return strippedEnd.slice(0, -3) + trailingSpace;
+  }
+
+  return body;
+}
+
+/**
+ * Returns true if the text after an opening "```" has no terminating newline
+ * yet and could still become a known language identifier.
+ */
+function isPartialLanguageFence(afterFence: string): boolean {
+  // Once the first line is terminated, we already know it is not a known
+  // language fence (those are handled above), so treat it as a plain fence.
+  if (afterFence.includes("\n")) {
+    return false;
+  }
+  return LANGS.some((lang) => lang.startsWith(afterFence));
+}

package/src/core/cells/__tests__/document-changes.test.ts

@@ -430,7 +430,7 @@ describe("toDocumentChanges", () => {
       const [a] = state.cellIds.inOrderIds;
 
       // Position cursor at end of "line1" (position 5)
-      const view = state.cellHandles[a].current!.editorView;
+      const view = state.cellHandles[a].current!.editorView!;
       view.dispatch({ selection: { anchor: 5 } });
 
       const { changes } = resolve(state, {
@@ -466,7 +466,7 @@ describe("toDocumentChanges", () => {
       const [a] = state.cellIds.inOrderIds;
 
       // Split the cell first
-      const view = state.cellHandles[a].current!.editorView;
+      const view = state.cellHandles[a].current!.editorView!;
       view.dispatch({ selection: { anchor: 5 } });
       const snapshot = view.state.doc.toString();
       state = dispatch(state, {

package/src/core/cells/__tests__/focus.test.ts

@@ -1,11 +1,17 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import type { EditorView } from "@codemirror/view";
+import { createStore } from "jotai";
 import { beforeEach, describe, expect, it } from "vitest";
+import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
+import type { CellHandle } from "@/components/editor/notebook-cell";
+import { notebookAtom } from "../cells";
 import type { CellFocusState } from "../focus";
-import { exportedForTesting } from "../focus";
+import { exportedForTesting, lastFocusedCellAtom } from "../focus";
 
-const { initialState, reducer, createActions } = exportedForTesting;
+const { initialState, reducer, createActions, cellFocusAtom } =
+  exportedForTesting;
 
 const CellIds = {
   a: cellId("a"),
@@ -270,3 +276,40 @@ describe("cell focus reducer", () => {
     });
   });
 });
+
+describe("lastFocusedCellAtom", () => {
+  it("returns null getEditorView when CodeMirror is not mounted", () => {
+    const store = createStore();
+    const markdownCellId = cellId("markdown");
+
+    const unmountedEditorHandle: CellHandle = {
+      get editorView(): EditorView {
+        throw new ReferenceError("Attempting to dereference null object.");
+      },
+      editorViewOrNull: null,
+    };
+
+    const notebook = MockNotebook.notebookState({
+      cellData: {
+        [markdownCellId]: {
+          config: { hide_code: true },
+        },
+      },
+    });
+    notebook.cellHandles[markdownCellId] = {
+      current: unmountedEditorHandle,
+    };
+
+    store.set(notebookAtom, notebook);
+    store.set(cellFocusAtom, {
+      focusedCellId: markdownCellId,
+      lastFocusedCellId: markdownCellId,
+    });
+
+    const lastFocusedCell = store.get(lastFocusedCellAtom);
+
+    expect(lastFocusedCell).not.toBeNull();
+    expect(lastFocusedCell?.cellId).toBe(markdownCellId);
+    expect(lastFocusedCell?.getEditorView()).toBeNull();
+  });
+});

package/src/core/cells/focus.ts

@@ -106,7 +106,7 @@ function cellFocusDetails(cellId: CellId, notebookState: NotebookState) {
   if (!data || !handle) {
     return null;
   }
-  const getEditorView = () => handle.editorView;
+  const getEditorView = () => handle.editorViewOrNull;
 
   return {
     cellId,

package/src/core/cells/scrollCellIntoView.ts

@@ -7,6 +7,7 @@ import {
 import type { CellHandle } from "@/components/editor/notebook-cell";
 import { retryWithTimeout } from "@/utils/timeout";
 import { Logger } from "../../utils/Logger";
+import { editorMountScheduler } from "../codemirror/editor-mount-scheduler";
 import { scrollActiveLineIntoView } from "../codemirror/extensions";
 import { goToVariableDefinition } from "../codemirror/go-to-definition/commands";
 import { getCellEditorView } from "./cells";
@@ -48,6 +49,9 @@ export function focusAndScrollCellIntoView({
     // https://github.com/marimo-team/marimo/issues/2940
     tryFocus(element);
   } else {
+    // Build this cell's editor now if it is still queued, so focus can land in
+    // it instead of the placeholder.
+    editorMountScheduler.promote(cellId);
     const editor = cell.current?.editorView;
     if (!editor) {
       Logger.warn("scrollCellIntoView: editor not found", cellId);

package/src/core/cells/utils.ts

@@ -29,7 +29,7 @@ export function notebookCells(state: NotebookState) {
 export function notebookCellEditorViews({ cellHandles }: NotebookState) {
   const views: Record<CellId, EditorView> = {};
   for (const [cell, ref] of Objects.entries(cellHandles)) {
-    if (!ref.current) {
+    if (!ref.current?.editorView) {
       continue;
     }
     views[cell] = ref.current.editorView;

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/ai/request.ts

@@ -2,6 +2,7 @@
 
 import { waitForConnectionOpen } from "@/core/network/connection";
 import type { AiCompletionRequest } from "@/core/network/types";
+import { streamCompletionText } from "@/core/ai/stream-completion-text";
 import { getRuntimeManager } from "@/core/runtime/config";
 import type { LanguageAdapterType } from "../language/types";
 
@@ -47,20 +48,7 @@ ${opts.codeAfter}
 
   const firstLineIndent = opts.selection.match(/^\s*/)?.[0] || "";
 
-  const reader = response.body?.getReader();
-  if (!reader) {
-    throw new Error("Failed to get response reader");
-  }
-
-  let result = "";
-  // oxlint-disable-next-line no-constant-condition
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    result += new TextDecoder().decode(value);
-  }
+  let result = await streamCompletionText(response);
 
   // Add back the indent if it was stripped, which can happen with
   // LLM responses

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>;