@marimo-team/islands 0.25.2-dev12 → 0.25.2-dev120

package/src/core/kernel/session.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { init } from "@paralleldrive/cuid2";
+import { atom } from "jotai";
 import { Logger } from "@/utils/Logger";
 import type { TypedString } from "@/utils/typed";
 import { updateQueryParams } from "@/utils/urls";
@@ -9,6 +10,14 @@ import { store } from "../state/jotai";
 
 export type SessionId = TypedString<"SessionId">;
 
+/**
+ * Server-owned identity of the notebook Session. It survives browser reloads
+ * and reconnects and ends with the Session.
+ */
+export type StableSessionId = TypedString<"StableSessionId">;
+
+export const stableSessionIdAtom = atom<StableSessionId | null>(null);
+
 const createId = init({ length: 6 });
 
 export function generateSessionId(): SessionId {

package/src/core/network/__tests__/api.test.ts

@@ -1,7 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { HTTPError } from "@/utils/errors";
+import { Logger } from "@/utils/Logger";
 import { API } from "../api";
 
 // Mock fetch globally
@@ -25,6 +26,118 @@ describe("API", () => {
     baseUrl = "http://localhost:8000";
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it.each(["before fetch", "during fetch"])(
+    "API.post propagates cancellation %s without logging it",
+    async (timing) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const controller = new AbortController();
+      mockFetch.mockImplementation(
+        (_url: string, { signal }: RequestInit) =>
+          new Promise<Response>((_resolve, reject) => {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            } else {
+              signal?.addEventListener("abort", () => reject(signal.reason), {
+                once: true,
+              });
+            }
+          }),
+      );
+      if (timing === "before fetch") {
+        controller.abort();
+      }
+
+      const response = API.post("/foo", {}, { signal: controller.signal });
+      controller.abort();
+
+      await expect(response).rejects.toBe(controller.signal.reason);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "http://localhost:8000/api/foo",
+        expect.objectContaining({ signal: controller.signal }),
+      );
+      expect(log).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(["application/json", "text/plain"])(
+    "API.post propagates an abort while reading %s without logging it",
+    async (contentType) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const error = new DOMException("Body read aborted", "AbortError");
+      const readBody = vi.fn().mockRejectedValue(error);
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ "Content-Type": contentType }),
+        json: readBody,
+        text: readBody,
+      });
+
+      await expect(API.post("/foo", {})).rejects.toBe(error);
+      expect(readBody).toHaveBeenCalledExactlyOnceWith();
+      expect(log).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each([new TypeError("Failed to fetch"), null, "Request failed"])(
+    "API.post logs and preserves non-abort fetch failures: %s",
+    async (error) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const controller = new AbortController();
+      controller.abort();
+      mockFetch.mockRejectedValue(error);
+
+      await expect(
+        API.post("/foo", {}, { signal: controller.signal }),
+      ).rejects.toBe(error);
+      expect(log).toHaveBeenCalledExactlyOnceWith(
+        "Error requesting http://localhost:8000/api/foo",
+        error,
+      );
+    },
+  );
+
+  it("API.post logs HTTP failures and preserves their status and body", async () => {
+    const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+    const body = { detail: "Service unavailable" };
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(body), {
+        status: 503,
+        statusText: "Service Unavailable",
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+
+    await expect(API.post("/foo", {})).rejects.toMatchObject({
+      name: "HTTPError",
+      status: 503,
+      message: "Service Unavailable",
+      cause: body,
+    });
+    expect(log).toHaveBeenCalledExactlyOnceWith(
+      "Error requesting http://localhost:8000/api/foo",
+      expect.any(HTTPError),
+    );
+  });
+
+  it("API.post logs malformed JSON responses", async () => {
+    const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+    mockFetch.mockResolvedValue(
+      new Response("invalid json", {
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+
+    await expect(API.post("/foo", {})).rejects.toBeInstanceOf(SyntaxError);
+    expect(log).toHaveBeenCalledExactlyOnceWith(
+      "Error requesting http://localhost:8000/api/foo",
+      expect.any(SyntaxError),
+    );
+  });
+
   it("API.post calls fetch with POST and correct URL", async () => {
     mockFetch.mockResolvedValue({
       ok: true,

package/src/core/network/__tests__/connection.test.ts

@@ -3,7 +3,7 @@
 import { afterEach, describe, expect, it } from "vitest";
 import { initialModeAtom } from "@/core/mode";
 import { store } from "@/core/state/jotai";
-import { WebSocketState } from "../../websocket/types";
+import { ConnectionState } from "../../websocket/types";
 import { connectionAtom, waitForConnectionOpenIfNotebook } from "../connection";
 
 const NEVER = Symbol("never");
@@ -20,7 +20,7 @@ function settledOrNever(promise: Promise<unknown>) {
 
 describe("waitForConnectionOpenIfNotebook", () => {
   afterEach(() => {
-    store.set(connectionAtom, { state: WebSocketState.NOT_STARTED });
+    store.set(connectionAtom, { state: ConnectionState.NOT_STARTED });
     store.set(initialModeAtom, undefined);
   });
 
@@ -39,7 +39,7 @@ describe("waitForConnectionOpenIfNotebook", () => {
     const promise = waitForConnectionOpenIfNotebook();
     await expect(settledOrNever(promise)).resolves.toBe(NEVER);
 
-    store.set(connectionAtom, { state: WebSocketState.OPEN });
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
     await expect(settledOrNever(promise)).resolves.not.toBe(NEVER);
   });
 });

package/src/core/network/api.ts

@@ -101,8 +101,9 @@ export const API = {
         return response.text() as unknown as RESP;
       })
       .catch((error) => {
-        // Catch and rethrow
-        Logger.error(`Error requesting ${fullUrl}`, error);
+        if (error?.name !== "AbortError") {
+          Logger.error(`Error requesting ${fullUrl}`, error);
+        }
         throw error;
       });
   },

package/src/core/network/connection-notice.ts

@@ -5,7 +5,7 @@ import { sandboxAtom, sandboxSyncAtom } from "@/core/packages/sandbox-state";
 import {
   type ConnectionPhase,
   WebSocketClosedReason,
-  WebSocketState,
+  ConnectionState,
 } from "@/core/websocket/types";
 import { connectionAtom } from "./connection";
 
@@ -37,7 +37,7 @@ export const connectionNoticeAtom = atom<ConnectionNotice | null>((get) => {
   if (
     sandbox &&
     (syncing || syncError !== null) &&
-    connection.state === WebSocketState.OPEN
+    connection.state === ConnectionState.OPEN
   ) {
     return {
       kind: "sync",
@@ -56,7 +56,7 @@ export const connectionNoticeAtom = atom<ConnectionNotice | null>((get) => {
       error: syncError,
     };
   }
-  if (connection.state === WebSocketState.CONNECTING) {
+  if (connection.state === ConnectionState.CONNECTING) {
     const messages = {
       "preparing-environment": {
         title: "Preparing environment…",
@@ -88,11 +88,11 @@ export const connectionNoticeAtom = atom<ConnectionNotice | null>((get) => {
       error: null,
     };
   }
-  if (connection.state === WebSocketState.CLOSED) {
+  if (connection.state === ConnectionState.CLOSED) {
     const startupFailed =
       connection.code === WebSocketClosedReason.KERNEL_STARTUP_ERROR;
     const environmentFailed =
-      startupFailed && connection.phase === "preparing-environment";
+      sandbox && startupFailed && connection.phase === "preparing-environment";
     return {
       kind: startupFailed ? "startup" : "connection",
       phase: connection.phase,

package/src/core/network/connection.ts

@@ -4,14 +4,14 @@ import { atomWithReducer } from "jotai/utils";
 import type { NotificationMessageData } from "../kernel/messages";
 import { isNotebookPage } from "../mode";
 import { waitFor } from "../state/jotai";
-import { type ConnectionStatus, WebSocketState } from "../websocket/types";
+import { type ConnectionStatus, ConnectionState } from "../websocket/types";
 
 /**
  * Atom for storing the connection status.
  * Initialized to NOT_STARTED.
  */
 export const connectionAtom = atom<ConnectionStatus>({
-  state: WebSocketState.NOT_STARTED,
+  state: ConnectionState.NOT_STARTED,
 });
 
 type StartupProgress = NotificationMessageData<"startup-progress">;
@@ -33,7 +33,7 @@ export const startupProgressAtom = atomWithReducer<
 
 export function waitForConnectionOpen() {
   return waitFor(connectionAtom, (value) => {
-    return value.state === WebSocketState.OPEN;
+    return value.state === ConnectionState.OPEN;
   });
 }
 
@@ -53,28 +53,28 @@ export function waitForConnectionOpenIfNotebook() {
 
 export const isConnectingAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.CONNECTING;
+  return connection.state === ConnectionState.CONNECTING;
 });
 
 export const isConnectedAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.OPEN;
+  return connection.state === ConnectionState.OPEN;
 });
 
 export const canInteractWithAppAtom = atom((get) => {
   const connection = get(connectionAtom);
   return (
-    connection.state === WebSocketState.OPEN ||
-    connection.state === WebSocketState.NOT_STARTED
+    connection.state === ConnectionState.OPEN ||
+    connection.state === ConnectionState.NOT_STARTED
   );
 });
 
 export const isClosedAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.CLOSED;
+  return connection.state === ConnectionState.CLOSED;
 });
 
 export const isNotStartedAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.NOT_STARTED;
+  return connection.state === ConnectionState.NOT_STARTED;
 });

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

@@ -7,7 +7,7 @@ import { memoizeLastValue } from "@/utils/once";
 import { waitForKernelToBeInstantiated } from "../kernel/state";
 import type { RuntimeManager } from "../runtime/runtime";
 import { store } from "../state/jotai";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { connectionAtom, waitForConnectionOpen } from "./connection";
 import type { EditRequests, RunRequests } from "./types";
 
@@ -159,7 +159,7 @@ export function createLazyRequests(
 ): AllRequests {
   // Memoize the init call, just once per runtime manager
   const initOnce = memoizeLastValue(async (runtimeManager: RuntimeManager) => {
-    store.set(connectionAtom, { state: WebSocketState.CONNECTING });
+    store.set(connectionAtom, { state: ConnectionState.CONNECTING });
     await runtimeManager.init();
   });
 

package/src/core/packages/__tests__/useSandboxController.test.tsx

@@ -17,7 +17,7 @@ import type {
 } from "@/core/network/types";
 import { filenameAtom } from "@/core/saving/file-state";
 import { store } from "@/core/state/jotai";
-import { WebSocketState } from "@/core/websocket/types";
+import { ConnectionState } from "@/core/websocket/types";
 import { HTTPError } from "@/utils/errors";
 import { packageDataVersionAtom } from "../package-data";
 import {
@@ -52,7 +52,7 @@ beforeEach(() => {
   store.set(sandboxAtom, null);
   store.set(sandboxSyncAtom, { kind: "succeeded" });
   store.set(sandboxActionsAtom, null);
-  store.set(connectionAtom, { state: WebSocketState.OPEN });
+  store.set(connectionAtom, { state: ConnectionState.OPEN });
   store.set(kernelStartupErrorAtom, null);
   store.set(filenameAtom, "notebook.py");
   store.set(packageDataVersionAtom, 0);

package/src/core/packages/useSandboxController.ts

@@ -8,7 +8,7 @@ import { useRequestClient } from "@/core/network/requests";
 import { useFilename } from "@/core/saving/filename";
 import { waitFor } from "@/core/state/jotai";
 import { isWasm } from "@/core/wasm/utils";
-import { WebSocketState } from "@/core/websocket/types";
+import { ConnectionState } from "@/core/websocket/types";
 import { HTTPError, prettyError } from "@/utils/errors";
 import { invalidatePackageData } from "./package-data";
 import {
@@ -67,7 +67,7 @@ export function useSandboxController(onReconnect: () => Promise<void>) {
     if (
       inFlight.current ||
       operation.kind === "running" ||
-      connection.state === WebSocketState.CONNECTING
+      connection.state === ConnectionState.CONNECTING
     ) {
       return false;
     }
@@ -91,10 +91,10 @@ export function useSandboxController(onReconnect: () => Promise<void>) {
         const status = await waitFor(
           connectionAtom,
           (value) =>
-            value.state === WebSocketState.OPEN ||
-            value.state === WebSocketState.CLOSED,
+            value.state === ConnectionState.OPEN ||
+            value.state === ConnectionState.CLOSED,
         );
-        if (status.state === WebSocketState.CLOSED) {
+        if (status.state === ConnectionState.CLOSED) {
           setOperation({ kind: "idle" });
           return false;
         }
@@ -177,7 +177,7 @@ export function useSandboxController(onReconnect: () => Promise<void>) {
     saving ||
     loading ||
     operation.kind === "running" ||
-    connection.state === WebSocketState.CONNECTING;
+    connection.state === ConnectionState.CONNECTING;
   const diagnostic =
     error ??
     (operation.kind === "failed"

package/src/core/runtime/__tests__/adapter.test.ts

@@ -6,7 +6,7 @@ import { islandsInitializedAtom } from "../../islands/state";
 import { kernelStateAtom } from "../../kernel/state";
 import { connectionAtom } from "../../network/connection";
 import { wasmInitStateAtom } from "../../wasm/state";
-import { WebSocketState } from "../../websocket/types";
+import { ConnectionState } from "../../websocket/types";
 import {
   canRunCellsAtom,
   islandsAdapter,
@@ -50,13 +50,13 @@ describe("wasmAdapter", () => {
 
 describe("remoteAdapter", () => {
   it.each([
-    [{ state: WebSocketState.OPEN }, { kind: "ready" }],
+    [{ state: ConnectionState.OPEN }, { kind: "ready" }],
     [
-      { state: WebSocketState.CONNECTING },
+      { state: ConnectionState.CONNECTING },
       { kind: "connecting", progress: { label: "Connecting…" } },
     ],
     [
-      { state: WebSocketState.NOT_STARTED },
+      { state: ConnectionState.NOT_STARTED },
       { kind: "connecting", progress: { label: "Not connected" } },
     ],
   ] as const)("maps %j to %j", (conn, expected) => {
@@ -68,7 +68,7 @@ describe("remoteAdapter", () => {
   it("surfaces the close reason when closed", () => {
     const store = createStore();
     store.set(connectionAtom, {
-      state: WebSocketState.CLOSED,
+      state: ConnectionState.CLOSED,
       code: "KERNEL_DISCONNECTED",
       reason: "Kernel went away",
     });
@@ -125,7 +125,7 @@ describe("canRunCellsAtom", () => {
   it("is false on a remote adapter until kernel acks", () => {
     const store = createStore();
     // Default adapter in test env is remote.
-    store.set(connectionAtom, { state: WebSocketState.OPEN });
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
     expect(store.get(canRunCellsAtom)).toBe(false);
 
     store.set(kernelStateAtom, { isInstantiated: true, error: null });

package/src/core/runtime/adapter.ts

@@ -8,7 +8,7 @@ import { connectionAtom } from "../network/connection";
 import { isStaticNotebook } from "../static/static-state";
 import { wasmInitStateAtom } from "../wasm/state";
 import { isWasm } from "../wasm/utils";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 
 export type RuntimeKind = "wasm" | "remote" | "static" | "islands";
 
@@ -76,19 +76,19 @@ export const wasmAdapter: RuntimeAdapter = {
 const remoteStateAtom = atom<AdapterState>((get) => {
   const conn = get(connectionAtom);
   switch (conn.state) {
-    case WebSocketState.OPEN:
+    case ConnectionState.OPEN:
       return { kind: "ready" };
-    case WebSocketState.CONNECTING:
+    case ConnectionState.CONNECTING:
       return { kind: "connecting", progress: { label: "Connecting…" } };
-    case WebSocketState.NOT_STARTED:
+    case ConnectionState.NOT_STARTED:
       return { kind: "connecting", progress: { label: "Not connected" } };
-    case WebSocketState.CLOSING:
-    case WebSocketState.CLOSED:
+    case ConnectionState.CLOSING:
+    case ConnectionState.CLOSED:
       return {
         kind: "failed",
         error: {
           message:
-            conn.state === WebSocketState.CLOSED
+            conn.state === ConnectionState.CLOSED
               ? conn.reason
               : "Disconnecting",
           errorKind: "runtime",

package/src/core/runtime/config.ts

@@ -5,7 +5,7 @@ import { Logger } from "@/utils/Logger";
 import { connectionAtom } from "../network/connection";
 import { store } from "../state/jotai";
 import { isAppNotStarted } from "../websocket/connection-utils";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { RuntimeManager } from "./runtime";
 import type { RuntimeConfig } from "./types";
 
@@ -36,7 +36,7 @@ export function useConnectToRuntime(): () => Promise<void> {
   const [connection, setConnection] = useAtom(connectionAtom);
   return useEvent(async () => {
     if (isAppNotStarted(connection.state)) {
-      setConnection({ state: WebSocketState.CONNECTING });
+      setConnection({ state: ConnectionState.CONNECTING });
       await runtimeManager.init();
     } else {
       Logger.log("Runtime already started or starting...");

package/src/core/saving/filename.ts

@@ -9,7 +9,7 @@ import { getAppConfig } from "../config/config";
 import { KnownQueryParams } from "../constants";
 import { connectionAtom } from "../network/connection";
 import { useRequestClient } from "../network/requests";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { filenameAtom } from "./file-state";
 
 export function useFilename() {
@@ -24,7 +24,7 @@ export function useUpdateFilename() {
 
   const handleFilenameChange = useEvent(async (name: string) => {
     const appConfig = getAppConfig();
-    if (connection.state !== WebSocketState.OPEN) {
+    if (connection.state !== ConnectionState.OPEN) {
       openAlert("Failed to save notebook: not connected to a kernel.");
       return null;
     }

package/src/core/saving/save-component.tsx

@@ -31,7 +31,7 @@ import { layoutStateAtom } from "../layout/state";
 import { kioskModeAtom } from "../mode";
 import { connectionAtom } from "../network/connection";
 import { useRequestClient } from "../network/requests";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { filenameAtom } from "./file-state";
 import { useFilename, useUpdateFilename } from "./filename";
 import { lastSavedNotebookAtom, needsSaveAtom } from "./state";
@@ -55,7 +55,7 @@ export function enqueueNotebookSave<T>(save: () => Promise<T>): Promise<T> {
 export const SaveComponent = ({ kioskMode }: SaveNotebookProps) => {
   const filename = useFilename();
   const needsSave = useAtomValue(needsSaveAtom);
-  const closed = useAtomValue(connectionAtom).state === WebSocketState.CLOSED;
+  const closed = useAtomValue(connectionAtom).state === ConnectionState.CLOSED;
   const { saveOrNameNotebook, saveIfNotebookIsPersistent } = useSaveNotebook();
   useAutoSaveNotebook({ onSave: saveIfNotebookIsPersistent, kioskMode });
 
@@ -120,7 +120,7 @@ export function useSaveNotebook() {
       }
 
       // Don't save if we are not connected to a kernel
-      if (connection.state !== WebSocketState.OPEN) {
+      if (connection.state !== ConnectionState.OPEN) {
         openAlert("Failed to save notebook: not connected to a kernel.");
         return;
       }
@@ -168,7 +168,7 @@ export function useSaveNotebook() {
     const connection = store.get(connectionAtom);
     if (
       isNamedPersistentFile(filename) &&
-      connection.state === WebSocketState.OPEN
+      connection.state === ConnectionState.OPEN
     ) {
       saveNotebook(filename, userInitiated);
     }
@@ -191,7 +191,7 @@ export function useSaveNotebook() {
     // Filename does not exist and we are connected to a kernel
     if (
       !isNamedPersistentFile(filename) &&
-      connection.state !== WebSocketState.CLOSED
+      connection.state !== ConnectionState.CLOSED
     ) {
       openModal(<SaveDialog onClose={closeModal} onSave={handleSaveDialog} />);
     }

package/src/core/saving/useAutoSave.ts

@@ -2,7 +2,7 @@
 import { useEffect, useRef } from "react";
 import type { UserConfig } from "../config/config-schema";
 import type { CellConfig } from "../network/types";
-import { type ConnectionStatus, WebSocketState } from "../websocket/types";
+import { type ConnectionStatus, ConnectionState } from "../websocket/types";
 
 export function useAutoSave(opts: {
   codes: string[];
@@ -43,7 +43,7 @@ export function useAutoSave(opts: {
         clearTimeout(autosaveTimeoutId.current);
       }
 
-      if (needsSave && connStatus.state === WebSocketState.OPEN) {
+      if (needsSave && connStatus.state === ConnectionState.OPEN) {
         autosaveTimeoutId.current = setTimeout(onSave, config.autosave_delay);
       }
     }

package/src/core/wasm/__tests__/bootstrap.test.ts

@@ -3,7 +3,7 @@
 import { loadPyodide } from "pyodide";
 import type { PyodideInterface } from "pyodide";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { DefaultWasmController } from "../worker/bootstrap";
+import { DefaultWasmController, requirementName } from "../worker/bootstrap";
 
 vi.mock("pyodide", () => ({ loadPyodide: vi.fn() }));
 vi.mock("../worker/getMarimoWheel", () => ({
@@ -61,3 +61,35 @@ describe("WASM runtime sources", () => {
     expect(controller.requirePyodide).toBe(pyodide);
   });
 });
+
+describe("requirementName", () => {
+  it("returns the distribution name for a bare requirement", () => {
+    expect(requirementName("pandas")).toBe("pandas");
+  });
+
+  it.each([
+    ["pandas==2.1.0", "pandas"],
+    ["pandas>=2", "pandas"],
+    ["pandas<=2", "pandas"],
+    ["pandas~=2.1", "pandas"],
+    ["pandas!=2.0", "pandas"],
+    ["nltools===0.6.0.dev2", "nltools"],
+  ])("cuts the specifier off %s", (requirement, expected) => {
+    expect(requirementName(requirement)).toBe(expected);
+  });
+
+  it("cuts extras and markers", () => {
+    expect(requirementName("rich[jupyter]>=13")).toBe("rich");
+    expect(requirementName('cowsay==6.1; sys_platform == "emscripten"')).toBe(
+      "cowsay",
+    );
+  });
+
+  it("cuts a URL requirement at the name", () => {
+    expect(requirementName("pkg @ https://example.com/pkg.whl")).toBe("pkg");
+  });
+
+  it("tolerates surrounding whitespace", () => {
+    expect(requirementName("  pandas >= 2  ")).toBe("pandas");
+  });
+});

package/src/core/wasm/worker/bootstrap.ts

@@ -30,6 +30,17 @@ type SessionResources = [
 //   3.b Install from micropip
 // 4. Initialize the notebook
 
+/**
+ * The distribution name of a PEP 508 requirement: "pandas>=2" -> "pandas".
+ *
+ * Extras, markers and URL forms are all cut at their first delimiter, which is
+ * enough for the "already installed" lookups this is used for.
+ */
+export function requirementName(requirement: string): string {
+  // Trim first: a leading space would otherwise split into an empty name.
+  return requirement.trim().split(/[[<>=!~;@\s]/)[0];
+}
+
 export class DefaultWasmController implements WasmController {
   protected pyodide: PyodideInterface | null = null;
   private packageLoadQueue = Promise.resolve();
@@ -314,18 +325,26 @@ export class DefaultWasmController implements WasmController {
     });
     loadSpan.end();
 
-    // Load from micropip
+    // Load from micropip.
+    //
+    // `imports` are PEP 508 requirements and may carry a version specifier
+    // ("pandas>=2", "nltools==0.6.0.dev2"). micropip wants them whole, but the
+    // "do we already have this?" checks below are keyed by name, so compare on
+    // the name and install the requirement.
     loadSpan = t.startSpan("micropip.install");
     const missingPackages = imports.filter(
-      (pkg) => !pyodide.loadedPackages[pkg],
+      (pkg) => !pyodide.loadedPackages[requirementName(pkg)],
     );
     if (missingPackages.length > 0) {
+      const byName = missingPackages.map(
+        (pkg) => [requirementName(pkg), pkg] as const,
+      );
       await pyodide
         .runPythonAsync(`
         import micropip
         import sys
         # Filter out builtins
-        missing = [p for p in ${JSON.stringify(missingPackages)} if p not in sys.modules]
+        missing = [req for name, req in ${JSON.stringify(byName)} if name not in sys.modules]
         if len(missing) > 0:
           print("Loading from micropip:", missing)
           await micropip.install(missing)