@marimo-team/islands 0.25.3-dev34 → 0.25.3-dev349

package/src/core/network/requests-lazy.ts

@@ -1,226 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { NoKernelConnectedError } from "@/utils/errors";
-import { Logger } from "@/utils/Logger";
-import { Objects } from "@/utils/objects";
-import { memoizeLastValue } from "@/utils/once";
-import { waitForKernelToBeInstantiated } from "../kernel/state";
-import type { RuntimeManager } from "../runtime/runtime";
-import { store } from "../state/jotai";
-import { ConnectionState } from "../websocket/types";
-import { connectionAtom, waitForConnectionOpen } from "./connection";
-import type { EditRequests, RunRequests } from "./types";
-
-type AllRequests = EditRequests & RunRequests;
-
-// We have various requests that act differently when called and not connected to a Kernel:
-//
-// - throwError: Throws NoKernelConnectedError, caught by requests-toasting.tsx
-//   and shown as a toast with a "Connect" button. Use for operations that
-//   shouldn't silently fail but also shouldn't auto-start the kernel.
-//
-// - dropRequest: Silently returns undefined. Only for requests where failure is
-//   expected and doesn't matter (e.g., background polling).
-//
-// - startConnection: Initializes the runtime and waits for connection before
-//   executing. Use for user-initiated actions that should "just work" and
-//   kick off the kernel if needed (e.g., clicking Run).
-//
-// - startConnectionWithoutKernel: Initializes the runtime and waits for an open
-//   connection. Use for session-scoped server requests that do not need an
-//   instantiated kernel.
-//
-// - waitForConnectionOpen: Waits for an existing connection but won't start one.
-//   Use for operations that depend on a running kernel but shouldn't be the
-//   trigger to start it (e.g., saving, interrupting).
-//
-// - serverOnly: Calls the HTTP delegate directly without touching the kernel.
-//   Use for requests served by the marimo server itself, which resolve without
-//   a session (e.g., fetching environment diagnostics).
-
-type Action =
-  | "throwError"
-  | "dropRequest"
-  | "startConnection"
-  | "startConnectionWithoutKernel"
-  | "waitForConnectionOpen"
-  | "serverOnly";
-
-const ACTIONS: Record<keyof AllRequests, Action> = {
-  // These will start a connection if not already connected and then wait until the connection is open
-  sendComponentValues: "startConnection",
-  sendModelValue: "startConnection",
-  sendInstantiate: "startConnectionWithoutKernel",
-  sendRun: "startConnection",
-  sendDeleteCell: "startConnection",
-  sendRunScratchpad: "startConnection",
-  saveAppConfig: "startConnection",
-  saveCellConfig: "startConnection",
-  discoverDataSources: "startConnection",
-
-  // Export operations start a connection
-  exportAsHTML: "startConnection",
-  exportAsIPYNB: "startConnection",
-  exportAsMarkdown: "startConnection",
-  exportAsScript: "startConnection",
-  exportAsPDF: "startConnection",
-  readCode: "startConnection",
-  sendCopy: "throwError",
-
-  // Throw errors for operations that are not supported offline
-  sendFormat: "throwError",
-  sendRestart: "throwError",
-
-  // These wait until the connection is open, but don't start a connection
-  sendSave: "waitForConnectionOpen",
-  invokeAiTool: "waitForConnectionOpen",
-  sendFunctionRequest: "waitForConnectionOpen",
-
-  // Session-based operations that wait for connection
-  sendRename: "waitForConnectionOpen",
-  autoExportAsHTML: "waitForConnectionOpen",
-  autoExportAsMarkdown: "waitForConnectionOpen",
-  autoExportAsIPYNB: "waitForConnectionOpen",
-  updateCellOutputs: "waitForConnectionOpen",
-
-  // Sidebar operations that wait for connection
-  listSecretKeys: "throwError",
-  writeSecret: "throwError",
-  clearCache: "throwError",
-  getCacheInfo: "throwError",
-
-  // Operations that throw errors (sessionless but not supported offline)
-  saveUserConfig: "throwError",
-  sendShutdown: "throwError",
-  getPackageList: "throwError",
-  getSandbox: "serverOnly",
-  updateManifest: "serverOnly",
-  syncSandbox: "serverOnly",
-  getDependencyTree: "throwError",
-  addPackage: "throwError",
-  removePackage: "throwError",
-
-  // Folder and file operations throw errors
-  getFileRoots: "startConnection",
-  sendListFiles: "startConnection",
-  sendSearchFiles: "startConnection",
-  sendCreateFileOrFolder: "throwError",
-  sendDeleteFileOrFolder: "throwError",
-  sendCopyFileOrFolder: "throwError",
-  sendRenameFileOrFolder: "throwError",
-  sendUpdateFile: "throwError",
-  sendFileDetails: "throwError",
-  openFile: "throwError",
-
-  // Served by the marimo server without a kernel session
-  getEnvironmentInfo: "serverOnly",
-  getExportAvailability: "serverOnly",
-
-  // Session-scoped server operations
-  installExportRequirements: "startConnectionWithoutKernel",
-
-  // Home operations throw errors
-  getRecentFiles: "startConnection",
-  getWorkspaceFiles: "startConnection",
-  getRunningNotebooks: "startConnection",
-  shutdownSession: "startConnection",
-  openTutorial: "startConnection",
-  getUsageStats: "waitForConnectionOpen",
-
-  // These wait for connection
-  sendStdin: "waitForConnectionOpen",
-  sendInterrupt: "waitForConnectionOpen",
-  sendPdb: "waitForConnectionOpen",
-  sendSetBreakpoints: "waitForConnectionOpen",
-  sendInstallMissingPackages: "waitForConnectionOpen",
-  readSnippets: "waitForConnectionOpen",
-  previewDatasetColumn: "waitForConnectionOpen",
-  previewSQLTable: "waitForConnectionOpen",
-  previewSQLTableList: "waitForConnectionOpen",
-  previewSQLSchemaList: "waitForConnectionOpen",
-  previewDataSourceConnection: "waitForConnectionOpen",
-  validateSQL: "waitForConnectionOpen",
-  listStorageEntries: "waitForConnectionOpen",
-  downloadStorage: "waitForConnectionOpen",
-
-  // Sync operations that wait for connection
-  sendDocumentTransaction: "waitForConnectionOpen",
-  sendCodeCompletionRequest: "waitForConnectionOpen",
-};
-
-/**
- * Create a lazy requests client.
- * On any request, we will initialize the runtime manager (if not already initialized)
- * and handle it based on the action type defined in ACTIONS.
- */
-export function createLazyRequests(
-  delegate: AllRequests,
-  getRuntimeManager: () => RuntimeManager,
-): AllRequests {
-  // Memoize the init call, just once per runtime manager
-  const initOnce = memoizeLastValue(async (runtimeManager: RuntimeManager) => {
-    store.set(connectionAtom, { state: ConnectionState.CONNECTING });
-    await runtimeManager.init();
-  });
-
-  // oxlint-disable-next-line typescript/no-explicit-any
-  function wrapRequest<T extends (...args: any[]) => Promise<any>>(
-    request: T,
-    key: keyof AllRequests,
-  ): T {
-    const action = ACTIONS[key];
-
-    const wrapped = (async (...args) => {
-      const runtimeManager = getRuntimeManager();
-
-      if (!runtimeManager.isLazy) {
-        return request(...args);
-      }
-
-      switch (action) {
-        case "serverOnly":
-          // Served by the marimo server itself; no kernel required
-          return request(...args);
-
-        case "dropRequest":
-          Logger.debug(
-            `Dropping request: ${key}, since not connected to a kernel.`,
-          );
-          // Silently drop the request
-          return;
-
-        case "throwError":
-          throw new NoKernelConnectedError();
-
-        case "waitForConnectionOpen":
-          // Wait for connection but don't start it
-          await waitForConnectionOpen();
-          await waitForKernelToBeInstantiated();
-          return request(...args);
-
-        case "startConnectionWithoutKernel":
-        case "startConnection":
-          // Start connection and wait for it to be open
-          await initOnce(runtimeManager);
-          await waitForConnectionOpen();
-          if (action === "startConnection") {
-            await waitForKernelToBeInstantiated();
-          }
-          return request(...args);
-
-        default:
-          // This should never happen if ACTIONS is complete
-          throw new Error(`Unknown action for "${key}"`);
-      }
-    }) as T;
-    return wrapped;
-  }
-
-  return Objects.mapValues(delegate, (value, key) => {
-    return wrapRequest(value, key);
-  }) as AllRequests;
-}
-
-export const visibleForTesting = {
-  ACTIONS,
-};

package/src/core/rtc/state.ts

@@ -1,34 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-import { atomWithStorage } from "jotai/utils";
-import { SCRATCH_CELL_ID, type CellId } from "@/core/cells/ids";
-import { once } from "@/utils/once";
-import { jotaiJsonStorage } from "@/utils/storage/jotai";
-import { getFeatureFlag } from "../config/feature-flag";
-
-/**
- * The username for the current user when using real-time collaboration.
- * This is stored in localStorage.
- */
-export const usernameAtom = atomWithStorage<string>(
-  "marimo:rtc:username",
-  "",
-  jotaiJsonStorage,
-);
-
-/**
- * Whether RTC is enabled.
- *
- * This is cached on page-load because this UI can get into
- * weird states, so we require a page reload to take effect.
- */
-export const isRtcEnabled = once(() => {
-  return getFeatureFlag("rtc_v2");
-});
-
-/**
- * Whether this cell type can participate in real-time collaboration.
- * Scratchpad cells are local-only.
- */
-export function canUseRtc(cellId: CellId): boolean {
-  return cellId !== SCRATCH_CELL_ID;
-}

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

@@ -1,25 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { atom } from "jotai";
-import { describe, expect, it } from "vitest";
-import { store, waitFor } from "../jotai";
-
-describe("waitFor function", () => {
-  it("should resolve when the atom satisfies the predicate", async () => {
-    const testAtom = atom(0);
-    store.set(testAtom, 10);
-
-    const result = await waitFor(testAtom, (value) => value === 10);
-    expect(result).toBe(10);
-  });
-
-  it("should resolve when the atom changes to satisfy the predicate", async () => {
-    const testAtom = atom(0);
-
-    setTimeout(() => store.set(testAtom, 15), 5);
-    setTimeout(() => store.set(testAtom, 20), 10);
-
-    const result = await waitFor(testAtom, (value) => value === 20);
-    expect(result).toBe(20);
-  });
-});

package/src/core/wasm/worker/message-buffer.ts

@@ -1,33 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-/**
- * A buffer for messages that are received before the worker is ready to process them.
- * Once the worker is ready, the buffer is flushed.
- */
-export class MessageBuffer<T> {
-  private buffer: T[];
-  private started = false;
-  private onMessage: (data: T) => void;
-  public constructor(onMessage: (data: T) => void) {
-    this.onMessage = onMessage;
-    this.buffer = [];
-  }
-
-  public push = (data: T) => {
-    if (this.started) {
-      this.onMessage(data);
-    } else {
-      this.buffer.push(data);
-    }
-  };
-
-  /**
-   * Start processing messages
-   */
-  public start = () => {
-    this.started = true;
-    // Flush the buffer
-    this.buffer.forEach((data) => this.onMessage(data));
-    this.buffer = [];
-  };
-}

package/src/core/websocket/__tests__/createConnectionTransport.test.ts

@@ -1,49 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { BasicTransport } from "../transports/basic";
-import { SseTransport } from "../transports/sse";
-import { WsTransport } from "../transports/ws";
-import { createConnectionTransport } from "../transports/create";
-
-vi.mock("../../wasm/utils", () => ({
-  isWasm: () => false,
-}));
-
-describe("createConnectionTransport", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  const options = {
-    url: () => "http://localhost/ws",
-    headers: () => ({}),
-  };
-
-  it("uses BasicTransport for static notebooks", () => {
-    const transport = createConnectionTransport({
-      ...options,
-      static: true,
-      transportType: "websocket",
-    });
-    expect(transport).toBeInstanceOf(BasicTransport);
-  });
-
-  it("uses WsTransport by default", () => {
-    const transport = createConnectionTransport({
-      ...options,
-      static: false,
-      transportType: "websocket",
-    });
-    expect(transport).toBeInstanceOf(WsTransport);
-  });
-
-  it("uses SseTransport when the transport type is sse", () => {
-    const transport = createConnectionTransport({
-      ...options,
-      static: false,
-      transportType: "sse",
-    });
-    expect(transport).toBeInstanceOf(SseTransport);
-  });
-});

package/src/core/websocket/__tests__/useNotebookClient.hook.test.tsx

@@ -1,170 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-// @vitest-environment jsdom
-
-import { act, renderHook } from "@testing-library/react";
-import { createStore, Provider } from "jotai";
-import type { PropsWithChildren } from "react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ConnectionState } from "../types";
-import { createConnectionTransport } from "../transports/create";
-import type { IConnectionTransport } from "../transports/transport";
-import { useNotebookClient } from "../useNotebookClient";
-import { fixtureMessages } from "../../host/__tests__/fixtures";
-import { agentAttachmentsAtom } from "../../attachments/state";
-import { notebookClientAtom } from "../state";
-
-vi.mock("../transports/create", () => ({ createConnectionTransport: vi.fn() }));
-
-function makeTransport() {
-  const events = new EventTarget();
-  const transport: IConnectionTransport = {
-    readyState: WebSocket.CLOSED,
-    reconnect: vi.fn(() => {
-      transport.readyState = WebSocket.OPEN;
-      events.dispatchEvent(new Event("open"));
-    }),
-    close: vi.fn(() => {
-      transport.readyState = WebSocket.CLOSED;
-      events.dispatchEvent(new CloseEvent("close"));
-    }),
-    send: vi.fn(),
-    addEventListener: events.addEventListener.bind(events),
-    removeEventListener: events.removeEventListener.bind(events),
-  };
-  return {
-    transport,
-    receive: (message: unknown) =>
-      events.dispatchEvent(
-        new MessageEvent("message", { data: JSON.stringify(message) }),
-      ),
-    notify: () =>
-      events.dispatchEvent(
-        new MessageEvent("message", {
-          data: JSON.stringify({
-            event: "marimo",
-            data: { marimo: { op: "reconnected" } },
-          }),
-        }),
-      ),
-  };
-}
-
-function setup(strict = false) {
-  const store = createStore();
-  const options = {
-    sessionId: "first",
-    static: false,
-    transportType: "websocket" as const,
-    messageFormat: "host" as const,
-    url: () => "ws://localhost/ws",
-    headers: () => ({}),
-    waitUntilReady: async () => undefined,
-    checkHealth: async () => true,
-    onNotification: vi.fn(),
-    onMessageError: vi.fn(),
-  };
-  const wrapper = ({ children }: PropsWithChildren) => (
-    <Provider store={store}>{children}</Provider>
-  );
-  const hook = renderHook((props) => useNotebookClient(props), {
-    initialProps: options,
-    reactStrictMode: strict,
-    wrapper,
-  });
-  return { ...hook, options, store };
-}
-
-beforeEach(() => {
-  vi.mocked(createConnectionTransport).mockReset();
-});
-
-describe("useNotebookClient", () => {
-  it("exposes host presence to the UI without waiting for kernel-ready", async () => {
-    const transport = makeTransport();
-    vi.mocked(createConnectionTransport).mockReturnValue(transport.transport);
-    const { result, store, unmount } = setup();
-    await act(async () => Promise.resolve());
-    expect(store.get(notebookClientAtom)).toBe(result.current);
-    act(() =>
-      fixtureMessages("notebook-events.sse").forEach(transport.receive),
-    );
-    expect(store.get(agentAttachmentsAtom)).toEqual([
-      {
-        id: "a2",
-        notebook_id: "n1",
-        kind: "agent",
-        name: "Notebook CLI",
-        since: "2026-10-01T09:20:03Z",
-      },
-    ]);
-    unmount();
-    expect(store.get(notebookClientAtom)).toBeNull();
-    expect(store.get(agentAttachmentsAtom)).toEqual([]);
-  });
-
-  it("uses current callbacks and URL providers without reconnecting on a rerender", async () => {
-    const first = makeTransport();
-    vi.mocked(createConnectionTransport).mockReturnValue(first.transport);
-    const { rerender, options, unmount } = setup();
-    await act(async () => Promise.resolve());
-    const onNotification = vi.fn();
-    rerender({ ...options, onNotification, url: () => "ws://redirected/ws" });
-    act(() => first.notify());
-    expect(options.onNotification).not.toHaveBeenCalled();
-    expect(onNotification).toHaveBeenCalledExactlyOnceWith({
-      data: { op: "reconnected" },
-    });
-    expect(createConnectionTransport).toHaveBeenCalledOnce();
-    expect(vi.mocked(createConnectionTransport).mock.calls[0][0].url()).toBe(
-      "ws://redirected/ws",
-    );
-    unmount();
-  });
-
-  it("replaces the transport when session identity changes and ignores old messages", async () => {
-    const first = makeTransport();
-    const second = makeTransport();
-    vi.mocked(createConnectionTransport)
-      .mockReturnValueOnce(first.transport)
-      .mockReturnValueOnce(second.transport);
-    const { rerender, options, unmount } = setup();
-    await act(async () => Promise.resolve());
-    rerender({ ...options, sessionId: "second" });
-    await act(async () => Promise.resolve());
-    expect(first.transport.close).toHaveBeenCalledOnce();
-    act(() => {
-      first.notify();
-      second.notify();
-    });
-    expect(options.onNotification).toHaveBeenCalledOnce();
-    unmount();
-  });
-
-  it("cleans up every transport under Strict Mode and only connects the active lifetime", async () => {
-    const transports: ReturnType<typeof makeTransport>[] = [];
-    vi.mocked(createConnectionTransport).mockImplementation(() => {
-      const next = makeTransport();
-      transports.push(next);
-      return next.transport;
-    });
-    const { result, store, options, unmount } = setup(true);
-    await act(async () => Promise.resolve());
-    expect(transports).toHaveLength(2);
-    expect(transports[0].transport.reconnect).not.toHaveBeenCalled();
-    expect(transports[0].transport.close).toHaveBeenCalledOnce();
-    expect(transports[1].transport.reconnect).toHaveBeenCalledOnce();
-    expect(store.get(result.current.connectionAtom)).toEqual({
-      state: ConnectionState.OPEN,
-    });
-    act(() => {
-      for (const transport of transports) {
-        transport.notify();
-      }
-    });
-    expect(options.onNotification).toHaveBeenCalledOnce();
-    unmount();
-    expect(transports[1].transport.close).toHaveBeenCalledOnce();
-    await result.current.reconnect();
-    expect(transports[1].transport.reconnect).toHaveBeenCalledOnce();
-  });
-});

package/src/core/websocket/state.ts

@@ -1,7 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { atom } from "jotai";
-import type { NotebookClient } from "../host/notebook-client";
-
-/** The client owned by the mounted notebook session. */
-export const notebookClientAtom = atom<NotebookClient | null>(null);