@marimo-team/islands 0.23.15-dev4 → 0.23.15-dev40

package/dist/{toDate-CWNNlFEX.js → toDate-BRJgtOGm.js}

@@ -5,8 +5,7 @@ import { t as __commonJSMin } from "./chunk-BNovOVIE.js";
 import { _ as Logger } from "./button-BacYv-bE.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
 import { u as createLucideIcon } from "./dist--2Bqjvs0.js";
-import { r as KnownQueryParams } from "./constants-T20xxyNf.js";
-import { S as atom, g as isIslands, h as waitFor, p as store } from "./useTheme-6eZ3GOTS.js";
+import { T as atom, a as KnownQueryParams, g as store, v as waitFor, y as isIslands } from "./useTheme-Df_vGflw.js";
 import { t as invariant } from "./invariant-wRzNXIsJ.js";
 var CircleQuestionMark = createLucideIcon("circle-question-mark", [
   ["circle", {
@@ -516,18 +515,28 @@ var RuntimeManager = class {
     return isWasm() || isIslands() || isStaticNotebook();
   }
   formatHttpURL({ path: e = "", searchParams: b, restrictToKnownQueryParams: x = true }) {
-    let S = this.httpURL, w = new URLSearchParams(window.location.search);
+    let S = this.httpURL, C = new URLSearchParams(window.location.search);
     if (b) for (let [e2, x2] of b.entries()) S.searchParams.set(e2, x2);
-    for (let [e2, b2] of w.entries()) x && !Object.values(KnownQueryParams).includes(e2) || S.searchParams.set(e2, b2);
+    for (let [e2, b2] of C.entries()) x && !Object.values(KnownQueryParams).includes(e2) || S.searchParams.set(e2, b2);
     return S.pathname = `${S.pathname.replace(/\/$/, "")}/${e.replace(/^\//, "")}`, S.hash = "", S;
   }
+  appendCrossOriginAuth(e) {
+    return !this.isSameOrigin && this.config.authToken && e.searchParams.set(KnownQueryParams.accessToken, this.config.authToken), e;
+  }
+  formatNavigableHttpURL(e, b) {
+    let x = this.formatHttpURL({
+      path: e,
+      searchParams: b
+    });
+    return x.searchParams.delete(KnownQueryParams.accessToken), this.appendCrossOriginAuth(x);
+  }
   formatWsURL(e, b) {
     let x = this.formatHttpURL({
       path: e,
       searchParams: b,
       restrictToKnownQueryParams: false
     });
-    return !this.isSameOrigin && this.config.authToken && x.searchParams.set(KnownQueryParams.accessToken, this.config.authToken), asWsUrl(x.toString());
+    return asWsUrl(this.appendCrossOriginAuth(x).toString());
   }
   getSessionSearchParams(e) {
     let b = new URL(this.config.url), x = new URLSearchParams(b.search);

package/dist/{useAsyncData-KfHB8wQR.js → useAsyncData-BSOyAbac.js}

@@ -1,7 +1,7 @@
 import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { D as useEvent_default } from "./useTheme-6eZ3GOTS.js";
+import { A as useEvent_default } from "./useTheme-Df_vGflw.js";
 import { t as invariant } from "./invariant-wRzNXIsJ.js";
 var import_compiler_runtime = require_compiler_runtime(), import_react = /* @__PURE__ */ __toESM(require_react(), 1), Result = {
   error(e, s) {

package/dist/{useDeepCompareMemoize-nJMtxhm4.js → useDeepCompareMemoize-BTLeWzuR.js}

@@ -1,6 +1,6 @@
 import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
-import { E as dequal } from "./useTheme-6eZ3GOTS.js";
+import { k as dequal } from "./useTheme-Df_vGflw.js";
 var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
 function useDeepCompareMemoize(e) {
   let i = import_react.useRef(e);

package/dist/{useLifecycle-DegSo0lV.js → useLifecycle-C6wHjkhW.js}

@@ -4,7 +4,7 @@ import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
 import { u as createLucideIcon } from "./dist--2Bqjvs0.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";
-import { S as atom, b as useSetAtom } from "./useTheme-6eZ3GOTS.js";
+import { C as useSetAtom, T as atom } from "./useTheme-Df_vGflw.js";
 var Calendar = createLucideIcon("calendar", [
   ["path", {
     d: "M8 2v4",

package/dist/{useTheme-6eZ3GOTS.js → useTheme-Df_vGflw.js}

@@ -736,7 +736,39 @@ atom((e) => e(appConfigAtom).width), atom((e) => {
   var _a;
   return ((_a = e(resolvedMarimoConfigAtom).server) == null ? void 0 : _a.disable_file_downloads) ?? false;
 });
-var import_compiler_runtime = require_compiler_runtime(), themeAtom = atom((e) => {
+const Constants = {
+  githubPage: "https://github.com/marimo-team/marimo",
+  releasesPage: "https://github.com/marimo-team/marimo/releases",
+  issuesPage: "https://github.com/marimo-team/marimo/issues",
+  feedbackForm: "https://marimo.io/feedback",
+  discordLink: "https://marimo.io/discord?ref=notebook",
+  docsPage: "https://docs.marimo.io",
+  youtube: "https://www.youtube.com/@marimo-team",
+  molab: "https://molab.marimo.io"
+}, KnownQueryParams = {
+  showCode: "show-code",
+  includeCode: "include-code",
+  sessionId: "session_id",
+  kiosk: "kiosk",
+  vscode: "vscode",
+  filePath: "file",
+  accessToken: "access_token",
+  viewAs: "view-as",
+  showChrome: "show-chrome",
+  theme: "theme"
+}, CSSClasses = { outputArea: "output-area" };
+var import_compiler_runtime = require_compiler_runtime();
+const THEMES = [
+  "light",
+  "dark",
+  "system"
+];
+function themeFromQueryParam() {
+  if (typeof window > "u") return;
+  let e = new URLSearchParams(window.location.search).get(KnownQueryParams.theme);
+  return THEMES.includes(e) ? e : void 0;
+}
+var themeAtom = atom((e) => {
   if (isIslands()) {
     if (document.body.classList.contains("dark-mode") || document.body.classList.contains("dark") || document.body.dataset.theme === "dark" || document.body.dataset.mode === "dark" || getVsCodeTheme() === "dark") return "dark";
     let e2 = window.getComputedStyle(document.body), A = e2.getPropertyValue("color-scheme").trim();
@@ -748,7 +780,7 @@ var import_compiler_runtime = require_compiler_runtime(), themeAtom = atom((e) =
     }
     return "light";
   }
-  return e(resolvedMarimoConfigAtom).display.theme;
+  return themeFromQueryParam() ?? e(resolvedMarimoConfigAtom).display.theme;
 }), prefersDarkModeAtom = atom(false);
 function setupThemeListener() {
   if (typeof window > "u" || !window.matchMedia) return;
@@ -793,31 +825,34 @@ function useTheme() {
   return e[1] === j ? M = e[2] : (M = { theme: j }, e[1] = j, e[2] = M), M;
 }
 export {
-  createStore as C,
-  useEvent_default as D,
-  dequal as E,
-  atom as S,
-  getBuildingBlocks as T,
-  Provider as _,
-  autoInstantiateAtom as a,
-  useSetAtom as b,
-  resolvedMarimoConfigAtom as c,
-  AppConfigSchema as d,
-  createDeepEqualAtom as f,
-  isIslands as g,
-  waitFor as h,
-  aiModelConfiguredAtom as i,
-  useResolvedMarimoConfig as l,
-  useJotaiEffect as m,
+  useEvent_default as A,
+  useSetAtom as C,
+  buildStore as D,
+  createStore as E,
+  getBuildingBlocks as O,
+  useAtomValue as S,
+  atom as T,
+  useJotaiEffect as _,
+  KnownQueryParams as a,
+  Provider as b,
+  autoInstantiateAtom as c,
+  resolvedMarimoConfigAtom as d,
+  useResolvedMarimoConfig as f,
+  store as g,
+  createDeepEqualAtom as h,
+  Constants as i,
+  dequal as k,
+  getResolvedMarimoConfig as l,
+  AppConfigSchema as m,
   useTheme as n,
-  getResolvedMarimoConfig as o,
-  store as p,
-  aiFeaturesEnabledAtom as r,
-  localeAtom as s,
+  aiFeaturesEnabledAtom as o,
+  userConfigAtom as p,
+  CSSClasses as r,
+  aiModelConfiguredAtom as s,
   resolvedThemeAtom as t,
-  userConfigAtom as u,
-  useAtom as v,
-  buildStore as w,
-  useStore as x,
-  useAtomValue as y
+  localeAtom as u,
+  waitFor as v,
+  useStore as w,
+  useAtom as x,
+  isIslands as y
 };

package/dist/{vega-component-DzyyM9fc.js → vega-component-BAvmvTjO.js}

@@ -2,23 +2,23 @@ import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { _ as Logger, c as Objects, g as cn, h as Events } from "./button-BacYv-bE.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { c as asRemoteURL, v as CircleQuestionMark } from "./toDate-CWNNlFEX.js";
+import { c as asRemoteURL, v as CircleQuestionMark } from "./toDate-BRJgtOGm.js";
 import "./react-dom-BTJzcVJ9.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";
 import "./zod-CijjQh4u.js";
 import { n as ErrorBanner } from "./error-banner-DFPfz_Qf.js";
 import { t as Tooltip } from "./tooltip-Czds6Qr8.js";
-import { i as debounce_default } from "./constants-T20xxyNf.js";
-import { D as useEvent_default, n as useTheme } from "./useTheme-6eZ3GOTS.js";
+import { t as debounce_default } from "./debounce-BOD3DbfP.js";
+import { A as useEvent_default, n as useTheme } from "./useTheme-Df_vGflw.js";
 import { s as uniq } from "./arrays-sEtDRoG4.js";
-import { a as isValid, i as AlertTitle, n as Alert, t as arrow } from "./formats-Dzx4J_z1.js";
+import { a as isValid, i as AlertTitle, n as Alert, t as arrow } from "./formats-CitsMtUm.js";
 import { n as formats } from "./vega-loader.browser-CZ-J8Py3.js";
 import { a as getContainerWidth, n as vegaLoadData, s as tooltipHandler } from "./loader-Boph2xIS.js";
 import { t as j } from "./react-vega-B0sAlDTL.js";
 import "./defaultLocale-u-3osm0P.js";
 import "./defaultLocale-BoHTsDG6.js";
-import { t as useAsyncData } from "./useAsyncData-KfHB8wQR.js";
-import { t as useDeepCompareMemoize } from "./useDeepCompareMemoize-nJMtxhm4.js";
+import { t as useAsyncData } from "./useAsyncData-BSOyAbac.js";
+import { t as useDeepCompareMemoize } from "./useDeepCompareMemoize-BTLeWzuR.js";
 import { t as Semaphore } from "./semaphore-CNDGTzkX.js";
 var import_compiler_runtime = require_compiler_runtime(), import_react = /* @__PURE__ */ __toESM(require_react(), 1);
 function fixRelativeUrl(e) {

package/package.json

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

package/src/components/chat/__tests__/chat-utils.test.ts

@@ -2,7 +2,11 @@
 
 import type { UIMessage } from "ai";
 import { describe, expect, it } from "vitest";
-import { hasPendingToolCalls } from "../chat-utils";
+import {
+  hasPendingToolCalls,
+  hasUnresolvedToolCalls,
+  shouldFlushQueue,
+} from "../chat-utils";
 
 /**
  * `hasPendingToolCalls` powers `sendAutomaticallyWhen` in `mo.ui.chat`:
@@ -81,6 +85,23 @@ describe("hasPendingToolCalls", () => {
     ).toBe(true);
   });
 
+  it("returns true when the user denied a tool approval", () => {
+    expect(
+      hasPendingToolCalls([
+        userMessage("delete it"),
+        assistantToolMessage([
+          {
+            type: "tool-delete_file",
+            toolCallId: "call-1",
+            state: "output-denied",
+            input: { path: "secrets.env" },
+            approval: { id: "approval-1", approved: false },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(true);
+  });
+
   it("returns true when a tool reached a terminal output state", () => {
     expect(
       hasPendingToolCalls([
@@ -267,3 +288,225 @@ describe("hasPendingToolCalls", () => {
     ).toBe(true);
   });
 });
+
+describe("hasUnresolvedToolCalls", () => {
+  it("returns false when there are no messages", () => {
+    expect(hasUnresolvedToolCalls([])).toBe(false);
+  });
+
+  it("returns true while approval is still requested", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("delete it"),
+        assistantToolMessage([
+          {
+            type: "tool-delete_file",
+            toolCallId: "call-1",
+            state: "approval-requested",
+            input: { path: "secrets.env" },
+            approval: { id: "approval-1" },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(true);
+  });
+
+  it("returns true while a tool is still running", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("run it"),
+        assistantToolMessage([
+          {
+            type: "tool-run_query",
+            toolCallId: "call-1",
+            state: "input-available",
+            input: { sql: "select 1" },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(true);
+  });
+
+  it("returns false once tools are ready to round-trip", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("run it"),
+        assistantToolMessage([
+          {
+            type: "tool-run_query",
+            toolCallId: "call-1",
+            state: "output-available",
+            input: { sql: "select 1" },
+            output: 1,
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(false);
+  });
+
+  it("returns false once the user denied a tool approval", () => {
+    expect(
+      hasUnresolvedToolCalls([
+        userMessage("delete it"),
+        assistantToolMessage([
+          {
+            type: "tool-delete_file",
+            toolCallId: "call-1",
+            state: "output-denied",
+            input: { path: "secrets.env" },
+            approval: { id: "approval-1", approved: false },
+          } as unknown as UIMessage["parts"][number],
+        ]),
+      ]),
+    ).toBe(false);
+  });
+});
+
+describe("shouldFlushQueue", () => {
+  it("flushes when the turn completed without error or pending tools", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: false,
+      }),
+    ).toBe(true);
+  });
+
+  it("does not flush on error", () => {
+    expect(
+      shouldFlushQueue({
+        isError: true,
+        isAbort: false,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("does not flush while a tool round-trip is still pending", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: true,
+        hasUnresolvedToolCalls: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("does not flush while approval is still requested", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("flushes on abort even when a tool is still streaming", () => {
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: true,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(true);
+  });
+
+  it("does not flush on abort when the run ended in error", () => {
+    expect(
+      shouldFlushQueue({
+        isError: true,
+        isAbort: true,
+        hasPendingToolCalls: false,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("flushes once trailing text is present and tools are resolved", () => {
+    const messages = [
+      userMessage("run it"),
+      assistantToolMessage([
+        {
+          type: "tool-run_query",
+          toolCallId: "call-1",
+          state: "output-available",
+          input: {},
+          output: 1,
+        } as unknown as UIMessage["parts"][number],
+        { type: "text", text: "Done." },
+      ]),
+    ];
+
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: hasPendingToolCalls(messages),
+        hasUnresolvedToolCalls: hasUnresolvedToolCalls(messages),
+      }),
+    ).toBe(true);
+  });
+
+  it("blocks flush while text trails a still-running tool, then allows it after resolution", () => {
+    const running = [
+      userMessage("run it"),
+      assistantToolMessage([
+        {
+          type: "tool-run_query",
+          toolCallId: "call-1",
+          state: "input-available",
+          input: {},
+        } as unknown as UIMessage["parts"][number],
+        { type: "text", text: "Running your query..." },
+      ]),
+    ];
+    const resolved = [
+      userMessage("run it"),
+      assistantToolMessage([
+        {
+          type: "tool-run_query",
+          toolCallId: "call-1",
+          state: "output-available",
+          input: {},
+          output: 1,
+        } as unknown as UIMessage["parts"][number],
+        { type: "text", text: "Running your query..." },
+      ]),
+    ];
+
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: hasPendingToolCalls(running),
+        hasUnresolvedToolCalls: hasUnresolvedToolCalls(running),
+      }),
+    ).toBe(false);
+    expect(
+      shouldFlushQueue({
+        isError: false,
+        isAbort: false,
+        hasPendingToolCalls: hasPendingToolCalls(resolved),
+        hasUnresolvedToolCalls: hasUnresolvedToolCalls(resolved),
+      }),
+    ).toBe(true);
+  });
+
+  it("does not flush on error even when tools are also pending", () => {
+    expect(
+      shouldFlushQueue({
+        isError: true,
+        isAbort: false,
+        hasPendingToolCalls: true,
+        hasUnresolvedToolCalls: true,
+      }),
+    ).toBe(false);
+  });
+});

package/src/components/chat/__tests__/message-queue.test.tsx

@@ -0,0 +1,121 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { type ChatMessagePart, useMessageQueue } from "../chat-utils";
+
+function textPart(text: string): ChatMessagePart {
+  return { type: "text", text };
+}
+
+describe("useMessageQueue", () => {
+  it("initializes empty", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("enqueues messages in order with unique ids", () => {
+    const { result } = renderHook(() => useMessageQueue());
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+
+    const [a, b] = result.current.messages;
+    expect(a.parts).toEqual([textPart("first")]);
+    expect(b.parts).toEqual([textPart("second")]);
+    expect(a.id).toBeTypeOf("string");
+    expect(a.id).not.toBe(b.id);
+  });
+
+  it("flushNext sends the oldest message's parts and dequeues it", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+    act(() => result.current.flushNext(send));
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledWith([textPart("first")]);
+    expect(result.current.messages).toEqual([
+      expect.objectContaining({ parts: [textPart("second")] }),
+    ]);
+  });
+
+  it("flushNext sees a message enqueued in the same act (before re-render)", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    // Mirrors enqueue + onFinish in the same tick: the ref must be updated
+    // synchronously inside enqueue, not only on the next render.
+    act(() => {
+      result.current.enqueue([textPart("queued while finishing")]);
+      result.current.flushNext(send);
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledWith([textPart("queued while finishing")]);
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("drains sequentially, even across synchronous flushNext calls", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+
+    // Two flushes in the same act: the ref must stay in sync so the second
+    // flush releases the next message rather than re-sending the first.
+    act(() => {
+      result.current.flushNext(send);
+      result.current.flushNext(send);
+    });
+
+    expect(send).toHaveBeenNthCalledWith(1, [textPart("first")]);
+    expect(send).toHaveBeenNthCalledWith(2, [textPart("second")]);
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("flushNext on an empty queue is a no-op", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => result.current.flushNext(send));
+
+    expect(send).not.toHaveBeenCalled();
+    expect(result.current.messages).toEqual([]);
+  });
+
+  it("clear empties the queue", () => {
+    const { result } = renderHook(() => useMessageQueue());
+
+    act(() => result.current.enqueue([textPart("first")]));
+    act(() => result.current.enqueue([textPart("second")]));
+    act(() => result.current.clear());
+
+    expect(result.current.messages).toEqual([]);
+    expect(result.current.hasQueuedRef.current).toBe(false);
+  });
+
+  it("hasQueuedRef stays in sync when enqueue and flush run in the same act", () => {
+    const { result } = renderHook(() => useMessageQueue());
+    const send = vi.fn();
+
+    act(() => {
+      result.current.enqueue([textPart("first")]);
+      result.current.enqueue([textPart("second")]);
+    });
+    expect(result.current.hasQueuedRef.current).toBe(true);
+
+    act(() => {
+      result.current.flushNext(send);
+    });
+    expect(result.current.hasQueuedRef.current).toBe(true);
+
+    act(() => {
+      result.current.flushNext(send);
+    });
+    expect(result.current.hasQueuedRef.current).toBe(false);
+  });
+});