@marimo-team/islands 0.24.3-dev9 → 0.25.1-dev1

package/src/core/packages/useSandboxController.ts

@@ -0,0 +1,208 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { useEffect, useRef, useState } from "react";
+import useEvent from "react-use-event-hook";
+import { kernelStartupErrorAtom } from "@/core/errors/state";
+import { connectionAtom } from "@/core/network/connection";
+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 { HTTPError, prettyError } from "@/utils/errors";
+import { invalidatePackageData } from "./package-data";
+import {
+  sandboxActionsAtom,
+  sandboxAtom,
+  sandboxSyncAtom,
+} from "./sandbox-state";
+import {
+  RESTART_REQUIRED_DESCRIPTION,
+  showPackageRestartToast,
+  showSandboxSyncToast,
+} from "./toast-components";
+
+/** Mount once with the editor so manifest drafts survive closing Packages. */
+export function useSandboxController(onReconnect: () => Promise<void>) {
+  const requests = useRequestClient();
+  const filename = useFilename();
+  const connection = useAtomValue(connectionAtom);
+  const startupError = useAtomValue(kernelStartupErrorAtom);
+  const setSandbox = useSetAtom(sandboxAtom);
+  const [operation, setOperation] = useAtom(sandboxSyncAtom);
+  const setActions = useSetAtom(sandboxActionsAtom);
+  const [open, setOpen] = useState(false);
+  const [document, setDocument] = useState<{
+    original: string;
+    draft: string;
+  } | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [conflict, setConflict] = useState(false);
+  const inFlight = useRef(false);
+  const dirty = document !== null && document.original !== document.draft;
+
+  useEffect(() => {
+    if (isWasm()) {
+      return;
+    }
+    let cancelled = false;
+    requests
+      .getSandbox({ fileKey: filename })
+      .then((value) => {
+        if (!cancelled) {
+          setSandbox(value);
+        }
+      })
+      .catch(() => {
+        /* A connection error is already shown by the editor. */
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [requests, filename, connection.state, setSandbox]);
+
+  const sync = useEvent(async () => {
+    if (
+      inFlight.current ||
+      operation.kind === "running" ||
+      connection.state === WebSocketState.CONNECTING
+    ) {
+      return false;
+    }
+    inFlight.current = true;
+    setOperation({ kind: "running" });
+    try {
+      const result = await requests.syncSandbox({ fileKey: filename });
+      if (result.restartRequired) {
+        setOperation({
+          kind: "restart-required",
+          reason: result.error ?? RESTART_REQUIRED_DESCRIPTION,
+        });
+        showPackageRestartToast();
+        return false;
+      }
+      if (!result.success) {
+        throw new Error(result.error ?? "Sandbox sync failed.");
+      }
+      if (result.reconnect) {
+        await onReconnect();
+        const status = await waitFor(
+          connectionAtom,
+          (value) =>
+            value.state === WebSocketState.OPEN ||
+            value.state === WebSocketState.CLOSED,
+        );
+        if (status.state === WebSocketState.CLOSED) {
+          setOperation({ kind: "idle" });
+          return false;
+        }
+      }
+      if (!result.reconnect) {
+        invalidatePackageData();
+      }
+      showSandboxSyncToast();
+      setOperation({ kind: "succeeded" });
+      return true;
+    } catch (cause) {
+      setOperation({ kind: "failed", error: prettyError(cause) });
+      return false;
+    } finally {
+      inFlight.current = false;
+    }
+  });
+
+  const loadManifest = useEvent(async () => {
+    setLoading(true);
+    setError(null);
+    setConflict(false);
+    try {
+      const result = await requests.getSandbox({ fileKey: filename });
+      setSandbox(result);
+      if (result.manifest === null) {
+        throw new Error("No notebook manifest is available yet.");
+      }
+      setDocument({ original: result.manifest, draft: result.manifest });
+    } catch (cause) {
+      setError(prettyError(cause));
+    } finally {
+      setLoading(false);
+    }
+  });
+
+  const editManifest = useEvent(async () => {
+    setOpen(true);
+    if (!dirty) {
+      await loadManifest();
+    }
+  });
+
+  useEffect(() => {
+    setActions({ sync, editManifest });
+    return () => {
+      setActions(null);
+    };
+  }, [sync, editManifest, setActions]);
+
+  const saveAndSync = async () => {
+    if (!document || loading || saving || operation.kind === "running") {
+      return;
+    }
+    setSaving(true);
+    setError(null);
+    try {
+      if (dirty) {
+        const result = await requests.updateManifest({
+          fileKey: filename,
+          contents: document.draft,
+          previous: document.original,
+        });
+        setSandbox(result);
+        if (result.manifest !== null) {
+          setDocument({ original: result.manifest, draft: result.manifest });
+        }
+      }
+      if (await sync()) {
+        setOpen(false);
+      }
+    } catch (cause) {
+      setError(prettyError(cause));
+      setConflict(cause instanceof HTTPError && cause.status === 409);
+    } finally {
+      setSaving(false);
+    }
+  };
+  const pending =
+    saving ||
+    loading ||
+    operation.kind === "running" ||
+    connection.state === WebSocketState.CONNECTING;
+  const diagnostic =
+    error ??
+    (operation.kind === "failed"
+      ? operation.error
+      : operation.kind === "restart-required"
+        ? operation.reason
+        : operation.kind === "cancelled"
+          ? "Sandbox sync was interrupted."
+          : null) ??
+    startupError;
+  return {
+    filename,
+    open,
+    setOpen,
+    draft: document?.draft ?? null,
+    setDraft: (draft: string) =>
+      setDocument((value) => value && { ...value, draft }),
+    dirty,
+    loading,
+    saving,
+    pending,
+    error,
+    diagnostic,
+    conflict,
+    loadManifest,
+    saveAndSync,
+  };
+}

package/src/core/run-app.tsx

@@ -3,6 +3,7 @@
 import { atom, useAtomValue } from "jotai";
 import { ArrowLeftIcon } from "lucide-react";
 import { useEffect } from "react";
+import { KernelStartupErrorModal } from "@/components/editor/KernelStartupErrorModal";
 import { AppContainer } from "@/components/editor/app-container";
 import { AppHeader } from "@/components/editor/header/app-header";
 import { ProgressiveBoundary } from "@/components/lifecycle/ProgressiveBoundary";
@@ -78,6 +79,7 @@ export const RunApp: React.FC<AppProps> = ({ appConfig, hideHeader }) => {
       width={appConfig.width}
       onReconnect={reconnect}
     >
+      <KernelStartupErrorModal />
       <AppHeader
         connection={connection}
         className={hideHeader ? "hidden" : "sm:pt-8"}

package/src/core/static/__tests__/files.test.ts

@@ -291,14 +291,10 @@ describe("patchVegaLoader - loader.load", () => {
     const loader = createLoader();
     const unpatch = patchVegaLoader(loader, virtualFiles);
 
-    try {
-      const content = await loader.load("file:///path/to/@file/vega-data.json");
-      expect(content).toBe('{"values": [1, 2, 3]}');
-    } catch (error) {
-      // If it falls back to original loader and fails, that's expected for file:// URLs
-      // The important thing is that the virtual file lookup was attempted
-      expect(error).toBeDefined();
-    }
+    const content = await loader
+      .load("file:///path/to/@file/vega-data.json")
+      .catch(() => undefined);
+    expect([undefined, '{"values": [1, 2, 3]}']).toContain(content);
 
     unpatch();
   });
@@ -340,15 +336,10 @@ describe("patchVegaLoader - loader.load", () => {
     }
 
     // Test file:// URL separately since it might fallback
-    try {
-      const content = await loader.load(
-        "file:///local/path/@file/pattern-test.json",
-      );
-      expect(content).toBe('{"pattern": "test"}');
-    } catch (error) {
-      // Expected if it falls back to original loader
-      expect(error).toBeDefined();
-    }
+    const fileUrlContent = await loader
+      .load("file:///local/path/@file/pattern-test.json")
+      .catch(() => undefined);
+    expect([undefined, '{"pattern": "test"}']).toContain(fileUrlContent);
 
     unpatch();
   });
@@ -640,12 +631,9 @@ describe("error handling and edge cases", () => {
     expect(window.fetch).toBe(originalFetch);
 
     // Test that the loader functions are functional (they should work normally)
-    try {
-      await loader.load("http://example.com/test.json");
-    } catch (error) {
-      // Expected to fail for non-existent URLs, but the function should be callable
-      expect(error).toBeDefined();
-    }
+    // A network failure is expected for this non-existent URL. A custom loader
+    // may also handle it, so only verify that the restored method is callable.
+    await loader.load("http://example.com/test.json").catch(() => undefined);
   });
 
   it("should handle Request objects in patchFetch", async () => {
@@ -676,13 +664,7 @@ describe("error handling and edge cases", () => {
       .mockImplementation(Functions.NOOP);
 
     // This should catch the error and fallback to original fetch
-    try {
-      await window.fetch("not-a-valid-url");
-      // If it doesn't throw, that's also fine (fallback behavior)
-    } catch (error) {
-      // Expected behavior - invalid URLs should be handled gracefully
-      expect(error).toBeDefined();
-    }
+    await window.fetch("not-a-valid-url").catch(() => undefined);
 
     unpatch();
     loggerSpy.mockRestore();

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

@@ -0,0 +1,63 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { loadPyodide } from "pyodide";
+import type { PyodideInterface } from "pyodide";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DefaultWasmController } from "../worker/bootstrap";
+
+vi.mock("pyodide", () => ({ loadPyodide: vi.fn() }));
+vi.mock("../worker/getMarimoWheel", () => ({
+  getMarimoWheel: () => "marimo-base",
+}));
+
+const micropip = { set_index_urls: vi.fn(), destroy: vi.fn() };
+const pyodide = { pyimport: vi.fn(() => micropip) };
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(loadPyodide).mockResolvedValue(
+    pyodide as unknown as PyodideInterface,
+  );
+});
+
+describe("WASM runtime sources", () => {
+  it("preserves the default runtime sources", async () => {
+    await new DefaultWasmController().bootstrap({
+      version: "0.24.2",
+      pyodideVersion: "v314.0.0",
+    });
+    expect(loadPyodide).toHaveBeenCalledWith(
+      expect.objectContaining({
+        indexURL: "https://cdn.jsdelivr.net/pyodide/v314.0.0/full/",
+        packageBaseUrl: "https://cdn.jsdelivr.net/pyodide/v314.0.0/full/",
+        lockFileURL:
+          "https://wasm.marimo.app/pyodide-lock.json?v=0.24.2&pyodide=v314.0.0",
+      }),
+    );
+    expect(pyodide.pyimport).not.toHaveBeenCalled();
+  });
+
+  it("configures runtime and package sources before returning the interpreter", async () => {
+    const controller = new DefaultWasmController();
+    await controller.bootstrap({
+      version: "0.24.2",
+      pyodideVersion: "v314.0.0",
+      pyodideIndexUrl: "https://example.com/runtime/",
+      pyodideLockfileUrl: "https://example.com/lock.json",
+      pypiIndexUrl: "https://example.com/pypi/{package_name}/json",
+    });
+    expect(loadPyodide).toHaveBeenCalledWith(
+      expect.objectContaining({
+        indexURL: "https://example.com/runtime/",
+        packageBaseUrl: "https://example.com/runtime/",
+        lockFileURL: "https://example.com/lock.json",
+      }),
+    );
+    expect(pyodide.pyimport).toHaveBeenCalledWith("micropip");
+    expect(micropip.set_index_urls).toHaveBeenCalledWith(
+      "https://example.com/pypi/{package_name}/json",
+    );
+    expect(micropip.destroy).toHaveBeenCalledOnce();
+    expect(controller.requirePyodide).toBe(pyodide);
+  });
+});

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

@@ -9,12 +9,14 @@ const {
   mockNotebookReadFile,
   mockReadNotebook,
   mockSaveNotebook,
+  mockBootstrap,
   rpcListeners,
 } = vi.hoisted(() => ({
   mockBridge: vi.fn(),
   mockNotebookReadFile: vi.fn(),
   mockReadNotebook: vi.fn(),
   mockSaveNotebook: vi.fn(),
+  mockBootstrap: vi.fn(),
   rpcListeners: {} as Record<string, () => void>,
 }));
 
@@ -40,6 +42,7 @@ vi.stubGlobal("URL", MockURL);
 
 vi.mock("@/core/wasm/rpc", () => ({
   getWorkerRPC: () => ({
+    send: { bootstrap: mockBootstrap },
     proxy: {
       request: {
         bridge: mockBridge,
@@ -122,6 +125,12 @@ describe("PyodideBridge.readCode", () => {
 
     await PyodideBridge.INSTANCE.readCode();
 
+    expect(mockBootstrap).toHaveBeenCalledWith({
+      version: "0.0.0-test",
+      pyodideIndexUrl: undefined,
+      pyodideLockfileUrl: undefined,
+      pypiIndexUrl: undefined,
+    });
     expect(mockNotebookReadFile).not.toHaveBeenCalled();
   });
 });
@@ -215,21 +224,21 @@ describe("getWasmWorkerName", () => {
       .__MARIMO_HAS_WASM_CONTROLLER__;
   });
 
-  it("returns the version without suffix by default", () => {
-    expect(getWasmWorkerName()).toBe("0.0.0-test");
+  it("returns the default worker name without suffix", () => {
+    expect(getWasmWorkerName()).toBe("marimo");
   });
 
   it("appends ::controller when the host opts in", () => {
     (
       window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: boolean }
     ).__MARIMO_HAS_WASM_CONTROLLER__ = true;
-    expect(getWasmWorkerName()).toBe("0.0.0-test::controller");
+    expect(getWasmWorkerName()).toBe("marimo::controller");
   });
 
   it("does not append the suffix for non-true values", () => {
     (
       window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: unknown }
     ).__MARIMO_HAS_WASM_CONTROLLER__ = "true";
-    expect(getWasmWorkerName()).toBe("0.0.0-test");
+    expect(getWasmWorkerName()).toBe("marimo");
   });
 });

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

@@ -0,0 +1,22 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import type { PyodideInterface } from "pyodide";
+import { afterEach, expect, it, vi } from "vitest";
+import { WasmFileSystem } from "../worker/fs";
+
+afterEach(() => vi.unstubAllGlobals());
+
+it.each(["https://notebook.example", "null"])(
+  "mounts persistent storage only for a non-opaque origin: %s",
+  (origin) => {
+    vi.stubGlobal("origin", origin);
+    const mount = vi.fn();
+    const IDBFS = {};
+    const pyodide = {
+      FS: { mount, filesystems: { IDBFS } },
+    } as unknown as PyodideInterface;
+    WasmFileSystem.mountFS(pyodide);
+    expect(mount.mock.calls).toEqual(
+      origin === "null" ? [] : [[IDBFS, { root: "." }, "/marimo"]],
+    );
+  },
+);

package/src/core/wasm/__tests__/runtime-config.test.ts

@@ -0,0 +1,65 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { afterEach, assert, describe, expect, it, vi } from "vitest";
+import { getWasmRuntimeConfig } from "../runtime-config";
+
+vi.mock("@/core/meta/globals", () => ({
+  getMarimoVersion: () => "0.0.0-test",
+}));
+
+afterEach(() => {
+  document.head.innerHTML = "";
+});
+
+describe("getWasmRuntimeConfig", () => {
+  it("uses runtime defaults when no URLs are configured", () => {
+    expect(getWasmRuntimeConfig()).toEqual({
+      version: "0.0.0-test",
+      pyodideIndexUrl: undefined,
+      pyodideLockfileUrl: undefined,
+      pypiIndexUrl: undefined,
+    });
+  });
+
+  it("resolves URLs against the page base and preserves micropip placeholders", () => {
+    document.head.innerHTML = `
+      <base href="https://example.com/blog/post/">
+      <marimo-wasm
+        data-pyodide-index-url="../runtime/"
+        data-pyodide-lockfile-url="/locks/pyodide.json?v=1&amp;x=2"
+        data-pypi-index-url="https://packages.example.com/{package_name}/json"
+      ></marimo-wasm>`;
+    expect(getWasmRuntimeConfig()).toEqual({
+      version: "0.0.0-test",
+      pyodideIndexUrl: "https://example.com/blog/runtime/",
+      pyodideLockfileUrl: "https://example.com/locks/pyodide.json?v=1&x=2",
+      pypiIndexUrl: "https://packages.example.com/{package_name}/json",
+    });
+  });
+
+  it.each(["pyodideIndexUrl", "pyodideLockfileUrl", "pypiIndexUrl"])(
+    "ignores malformed %s while preserving valid overrides",
+    (key) => {
+      document.head.innerHTML = `
+        <base href="https://example.com/notebook/">
+        <marimo-wasm
+          data-pyodide-index-url="./pyodide/"
+          data-pyodide-lockfile-url="./lockfile/pyodide.json"
+          data-pypi-index-url="./packages/{package_name}.json"
+        ></marimo-wasm>`;
+      const element = document.querySelector<HTMLElement>("marimo-wasm");
+      assert(element);
+      element.dataset[key] = "https://invalid host/";
+
+      expect(getWasmRuntimeConfig()).toEqual({
+        version: "0.0.0-test",
+        pyodideIndexUrl: "https://example.com/notebook/pyodide/",
+        pyodideLockfileUrl:
+          "https://example.com/notebook/lockfile/pyodide.json",
+        pypiIndexUrl:
+          "https://example.com/notebook/packages/{package_name}.json",
+        [key]: undefined,
+      });
+    },
+  );
+});

package/src/core/wasm/bridge.ts

@@ -9,9 +9,9 @@ import { throwNotImplemented } from "@/utils/functions";
 import { Logger } from "@/utils/Logger";
 import { reloadSafe } from "@/utils/reload-safe";
 import { generateUUID } from "@/utils/uuid";
+import { createModuleWorker } from "@/utils/worker";
 import { notebookIsRunningAtom } from "../cells/cells";
 import type { CommandMessage } from "../kernel/messages";
-import { getMarimoVersion } from "../meta/globals";
 import { getInitialAppMode } from "../mode";
 import { API } from "../network/api";
 import type {
@@ -41,10 +41,14 @@ import { BasicTransport } from "../websocket/transports/basic";
 import type { IConnectionTransport } from "../websocket/transports/transport";
 import { PyodideRouter } from "./router";
 import { getWorkerRPC } from "./rpc";
+import { getWasmRuntimeConfig } from "./runtime-config";
 import { createShareableLink } from "./share";
 import { wasmInitStateAtom } from "./state";
 import { fallbackFileStore, notebookFileStore } from "./store";
 import { isWasm } from "./utils";
+import saveWorkerUrl from "./worker/save-worker.ts?worker&url";
+import workerUrl from "./worker/worker.ts?worker&url";
+import { CUSTOM_CONTROLLER_SUFFIX } from "./worker/constants";
 import type { SaveWorkerSchema } from "./worker/save-worker";
 import type { WorkerSchema } from "./worker/worker";
 
@@ -81,19 +85,20 @@ export class PyodideBridge implements RunRequests, EditRequests {
       };
     }
 
+    const runtimeConfig = getWasmRuntimeConfig();
+
     // Create save worker
-    const saveWorker = new Worker(
-      // oxlint-disable-next-line unicorn/relative-url-style
-      new URL("./worker/save-worker.ts", import.meta.url),
+    const saveWorker = createModuleWorker(
+      new URL(saveWorkerUrl, import.meta.url),
       {
-        type: "module",
-        // Pass the version (and optional capability suffix) to the worker
-        /* @vite-ignore */
+        // Pass the optional custom-controller capability to the worker.
         name: getWasmWorkerName(),
       },
     );
 
-    return getWorkerRPC<SaveWorkerSchema>(saveWorker).proxy.request;
+    const rpc = getWorkerRPC<SaveWorkerSchema>(saveWorker);
+    rpc.send.bootstrap(runtimeConfig);
+    return rpc.proxy.request;
   }
 
   private constructor() {
@@ -101,20 +106,17 @@ export class PyodideBridge implements RunRequests, EditRequests {
       return;
     }
 
+    const runtimeConfig = getWasmRuntimeConfig();
+
     // Create a worker
-    const worker = new Worker(
-      // oxlint-disable-next-line unicorn/relative-url-style
-      new URL("./worker/worker.ts", import.meta.url),
-      {
-        type: "module",
-        // Pass the version (and optional capability suffix) to the worker
-        /* @vite-ignore */
-        name: getWasmWorkerName(),
-      },
-    );
+    const worker = createModuleWorker(new URL(workerUrl, import.meta.url), {
+      // Pass the optional custom-controller capability to the worker.
+      name: getWasmWorkerName(),
+    });
 
     // Create the RPC
     this.rpc = getWorkerRPC<WorkerSchema>(worker);
+    this.rpc.send.bootstrap(runtimeConfig);
 
     // Listeners
     this.rpc.addMessageListener("ready", () => {
@@ -640,6 +642,17 @@ export class PyodideBridge implements RunRequests, EditRequests {
     return response;
   };
 
+  getSandbox: EditRequests["getSandbox"] = async () => ({
+    backend: null,
+    manifest: null,
+    filename: null,
+  });
+  updateManifest: EditRequests["updateManifest"] = async () => {
+    throw new Error("Sandboxes are not supported in WebAssembly");
+  };
+  syncSandbox: EditRequests["syncSandbox"] = async () => {
+    throw new Error("Sandboxes are not supported in WebAssembly");
+  };
   getDependencyTree: EditRequests["getDependencyTree"] = async () => {
     // WASM doesn't support dependency trees yet
     return {
@@ -713,10 +726,9 @@ export function createPyodideConnection(): IConnectionTransport {
   });
 }
 
-// Compose the worker name. The version prefix is read by getMarimoVersion()
-// in the worker; the optional "::controller" suffix tells getController.ts
-// that the host page provides a custom /wasm/controller.js and that the
-// dynamic import should be attempted. Hosts opt in by setting
+// Compose the worker name. The optional "::controller" suffix tells
+// getController.ts that the host page provides a custom /wasm/controller.js
+// and that the dynamic import should be attempted. Hosts opt in by setting
 // `window.__MARIMO_HAS_WASM_CONTROLLER__ = true` before
 // PyodideBridge/worker initialization.
 export function getWasmWorkerName(): string {
@@ -724,5 +736,5 @@ export function getWasmWorkerName(): string {
     typeof window !== "undefined" &&
     (window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: boolean })
       .__MARIMO_HAS_WASM_CONTROLLER__ === true;
-  return getMarimoVersion() + (hasCustomController ? "::controller" : "");
+  return `marimo${hasCustomController ? CUSTOM_CONTROLLER_SUFFIX : ""}`;
 }

package/src/core/wasm/rpc.ts

@@ -6,11 +6,13 @@ import {
   type RPCSchema,
 } from "rpc-anywhere";
 import { Logger } from "@/utils/Logger";
+import type { WasmRuntimeConfig } from "./runtime-config";
 import { TRANSPORT_ID } from "./worker/constants";
 
 export type ParentSchema = RPCSchema<{
   messages: {
     consumerReady: {};
+    bootstrap: WasmRuntimeConfig;
   };
 }>;
 

package/src/core/wasm/runtime-config.ts

@@ -0,0 +1,31 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { getMarimoVersion } from "@/core/meta/globals";
+
+export interface WasmRuntimeConfig {
+  version: string;
+  pyodideIndexUrl?: string;
+  pyodideLockfileUrl?: string;
+  pypiIndexUrl?: string;
+}
+
+export function getWasmRuntimeConfig(): WasmRuntimeConfig {
+  const element = document.querySelector<HTMLElement>("marimo-wasm");
+  const resolve = (url: string | undefined) => {
+    try {
+      return url ? new URL(url, document.baseURI).href : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  return {
+    version: getMarimoVersion(),
+    pyodideIndexUrl: resolve(element?.dataset.pyodideIndexUrl),
+    pyodideLockfileUrl: resolve(element?.dataset.pyodideLockfileUrl),
+    // URL serialization escapes the placeholder understood by micropip.
+    pypiIndexUrl: resolve(element?.dataset.pypiIndexUrl)?.replaceAll(
+      "%7Bpackage_name%7D",
+      "{package_name}",
+    ),
+  };
+}