@marimo-team/islands 0.24.3-dev55 → 0.24.3-dev58

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

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import type { PyodideInterface } from "pyodide";
+import type { WasmRuntimeConfig } from "../runtime-config";
 import type { UserConfig } from "@/core/config/config-schema";
 import type {
   CommandMessage,
@@ -43,10 +44,12 @@ export interface WasmController {
    * Prepare the wasm environment
    * @param opts.version - The marimo version
    */
-  bootstrap(opts: {
-    version: string;
-    pyodideVersion: string;
-  }): Promise<PyodideInterface>;
+  bootstrap(
+    opts: WasmRuntimeConfig & {
+      version: string;
+      pyodideVersion: string;
+    },
+  ): Promise<PyodideInterface>;
   /**
    * Mount the filesystem
    * @param opts.code - The code to mount

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

@@ -22,6 +22,7 @@ import { prettyError } from "../../../utils/errors";
 import { invariant } from "../../../utils/invariant";
 import { Logger } from "../../../utils/Logger";
 import type { ParentSchema } from "../rpc";
+import type { WasmRuntimeConfig } from "../runtime-config";
 import { TRANSPORT_ID } from "./constants";
 import { WasmFileSystem } from "./fs";
 import { getController } from "./getController";
@@ -47,6 +48,8 @@ declare const self: Window & {
 
 const workerInitSpan = t.startSpan("worker:init");
 
+const runtimeConfig = new Deferred<WasmRuntimeConfig>();
+
 // Initialize pyodide
 async function loadPyodideAndPackages() {
   try {
@@ -58,6 +61,7 @@ async function loadPyodideAndPackages() {
       message: "Loading marimo...",
     });
     self.pyodide = await t.wrapAsync(controller.bootstrap.bind(controller))({
+      ...(await runtimeConfig.promise),
       version: marimoVersion,
       pyodideVersion: pyodideVersion,
     });
@@ -354,6 +358,8 @@ const rpc = createRPC<WorkerSchema, ParentSchema>({
   requestHandler,
 });
 
+rpc.addMessageListener("bootstrap", (config) => runtimeConfig.resolve(config));
+
 rpc.send("ready", {});
 
 /// Listeners

package/src/utils/__tests__/worker.test.ts

@@ -0,0 +1,81 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createModuleWorker } from "../worker";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe("createModuleWorker", () => {
+  it.each(["http", "blob"])(
+    "preserves caller-owned %s worker URLs",
+    (scheme) => {
+      const Worker = vi.fn(function (
+        _url: string | URL,
+        _options: WorkerOptions,
+      ) {
+        return {};
+      });
+      vi.stubGlobal("Worker", Worker);
+      const url = new URL(
+        scheme === "blob"
+          ? `blob:${location.origin}/worker`
+          : new URL("/worker.js", location.href),
+      );
+      const revoke = vi.spyOn(URL, "revokeObjectURL");
+      createModuleWorker(url, { name: "marimo" });
+      expect(Worker).toHaveBeenCalledWith(url.href, {
+        type: "module",
+        name: "marimo",
+      });
+      expect(revoke).not.toHaveBeenCalled();
+    },
+  );
+
+  it("preserves the page origin for hosted CDN workers", () => {
+    const Worker = vi.fn(function (
+      _url: string | URL,
+      _options: WorkerOptions,
+    ) {
+      return {};
+    });
+    vi.stubGlobal("Worker", Worker);
+    const create = vi
+      .spyOn(URL, "createObjectURL")
+      .mockReturnValue("blob:worker");
+    const revoke = vi
+      .spyOn(URL, "revokeObjectURL")
+      .mockImplementation(() => undefined);
+    createModuleWorker(new URL("https://cdn.example.com/worker.js"), {
+      name: "islands",
+    });
+    expect(create).toHaveBeenCalledWith(expect.any(Blob));
+    expect(Worker).toHaveBeenCalledWith("blob:worker", {
+      type: "module",
+      name: "islands",
+    });
+    expect(revoke).toHaveBeenCalledWith("blob:worker");
+  });
+
+  it("imports a CDN worker from an opaque origin", () => {
+    const Worker = vi.fn(function (
+      _url: string | URL,
+      _options: WorkerOptions,
+    ) {
+      return {};
+    });
+    vi.stubGlobal("Worker", Worker);
+    vi.stubGlobal("origin", "null");
+    const url = new URL("https://cdn.example.com/worker.js");
+    createModuleWorker(url, { name: "0.24.2::controller" });
+    const [source, options] = Worker.mock.calls[0];
+    expect(decodeURIComponent(String(source))).toBe(
+      'data:application/javascript,import "https://cdn.example.com/worker.js"',
+    );
+    expect(options).toEqual({
+      type: "module",
+      name: "0.24.2::controller",
+    });
+  });
+});

package/src/utils/worker.ts

@@ -0,0 +1,22 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+/** Load a module worker across origins, including from file:// pages. */
+export function createModuleWorker(url: URL, options: WorkerOptions): Worker {
+  if (url.origin === globalThis.origin) {
+    return new Worker(url.href, { ...options, type: "module" });
+  }
+  const js = `import ${JSON.stringify(url.href)}`;
+  // Blob workers preserve the page origin, but file:// needs a data URL.
+  const source =
+    globalThis.origin === "null"
+      ? `data:application/javascript,${encodeURIComponent(js)}`
+      : URL.createObjectURL(new Blob([js], { type: "application/javascript" }));
+  try {
+    return new Worker(source, { ...options, type: "module" });
+  } finally {
+    if (source.startsWith("blob:")) {
+      // Worker() captures the Blob before returning, even while imports load.
+      URL.revokeObjectURL(source);
+    }
+  }
+}

package/dist/assets/__vite-browser-external-BajL8aoc.js

@@ -1 +0,0 @@
-import{t as e}from"./worker-BemUy60C.js";var t=e(((e,t)=>{t.exports={}}));export default t();