@tscircuit/eval 0.0.287 → 0.0.288

package/dist/worker.d.ts

@@ -17,6 +17,13 @@ interface WebWorkerConfiguration extends CircuitRunnerConfiguration {
      */
     webWorkerUrl?: URL | string;
     webWorkerBlobUrl?: URL | string;
+    /**
+     * Enable fetch proxy to route worker fetch requests through parent thread.
+     * Useful when running in restricted environments (like ChatGPT) where
+     * worker fetch requests are blocked.
+     * Default: false
+     */
+    enableFetchProxy?: boolean;
 }
 type CircuitWebWorker = {
     execute: (code: string) => Promise<void>;

package/dist/worker.js

@@ -47,7 +47,7 @@ var createCircuitWebWorker = async (configuration) => {
   let workerBlobUrl = configuration.webWorkerBlobUrl ?? configuration.webWorkerUrl;
   if (!workerBlobUrl) {
     const cdnUrl = `https://cdn.jsdelivr.net/npm/@tscircuit/eval@${configuration.evalVersion ?? "latest"}/dist/webworker/entrypoint.js`;
-    const workerBlob = await fetch(cdnUrl).then((res) => res.blob());
+    const workerBlob = await globalThis.fetch(cdnUrl).then((res) => res.blob());
     workerBlobUrl = URL.createObjectURL(workerBlob);
   }
   const rawWorker = new Worker(workerBlobUrl, { type: "module" });
@@ -66,11 +66,50 @@ var createCircuitWebWorker = async (configuration) => {
     console.log("[Worker] Message in worker", event);
   };
   rawWorker.addEventListener("message", earlyMessageHandler);
+  rawWorker.addEventListener("message", async (event) => {
+    const data = event.data;
+    if (data?.type !== "worker_fetch") return;
+    try {
+      const response = await globalThis.fetch(data.input, data.init);
+      const body = await response.text();
+      rawWorker.postMessage({
+        type: "worker_fetch_result",
+        requestId: data.requestId,
+        success: true,
+        response: {
+          body,
+          status: response.status,
+          statusText: response.statusText,
+          headers: (() => {
+            const obj = {};
+            response.headers.forEach((value, key) => {
+              obj[key] = value;
+            });
+            return obj;
+          })()
+        }
+      });
+    } catch (err) {
+      rawWorker.postMessage({
+        type: "worker_fetch_result",
+        requestId: data.requestId,
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack
+        }
+      });
+    }
+  });
   if (workerInitError) {
     throw workerInitError;
   }
   const comlinkWorker = Comlink.wrap(rawWorker);
   rawWorker.removeEventListener("message", earlyMessageHandler);
+  if (configuration.enableFetchProxy) {
+    rawWorker.postMessage({ type: "override_global_fetch" });
+  }
   if (configuration.snippetsApiBaseUrl) {
     await comlinkWorker.setSnippetsApiBaseUrl(configuration.snippetsApiBaseUrl);
   }
@@ -110,6 +149,7 @@ var createCircuitWebWorker = async (configuration) => {
       }
     }
   };
+  wrapper.__rawWorker = rawWorker;
   globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = wrapper;
   return wrapper;
 };
@@ -117,4 +157,4 @@ export {
   createCircuitWebWorker,
   getImportsFromCode
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../lib/worker.ts", "../lib/utils/get-imports-from-code.ts"],
  "sourcesContent": ["import * as Comlink from \"comlink\"\nexport * from \"./utils/index\"\nimport type {\n  InternalWebWorkerApi,\n  WebWorkerConfiguration,\n  CircuitWebWorker,\n} from \"./shared/types\"\nimport type { RootCircuitEventName } from \"@tscircuit/core\"\n\nexport type { CircuitWebWorker, WebWorkerConfiguration }\n\ndeclare global {\n  interface Window {\n    TSCIRCUIT_GLOBAL_CIRCUIT_WORKER: CircuitWebWorker | undefined\n  }\n  var TSCIRCUIT_GLOBAL_CIRCUIT_WORKER: CircuitWebWorker | undefined\n}\n\nexport const createCircuitWebWorker = async (\n  configuration: Partial<WebWorkerConfiguration>,\n): Promise<CircuitWebWorker> => {\n  // Kill existing global worker instance if present\n  const existingWorker = globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER\n  if (existingWorker && typeof existingWorker.kill === \"function\") {\n    if (configuration.verbose) {\n      console.log(\"[Worker] Killing previous global worker instance...\")\n    }\n    try {\n      await existingWorker.kill()\n    } catch (e) {\n      if (configuration.verbose) {\n        console.warn(\n          \"[Worker] Error killing previous global worker instance:\",\n          e,\n        )\n      }\n      // Ensure the key is cleared even if kill throws an error\n      if (globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER === existingWorker) {\n        globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = undefined\n      }\n    }\n  }\n\n  if (configuration.verbose) {\n    console.log(\n      \"[Worker] Creating circuit web worker with config:\",\n      configuration,\n    )\n  }\n\n  let workerBlobUrl =\n    configuration.webWorkerBlobUrl ?? configuration.webWorkerUrl\n\n  if (!workerBlobUrl) {\n    const cdnUrl = `https://cdn.jsdelivr.net/npm/@tscircuit/eval@${configuration.evalVersion ?? \"latest\"}/dist/webworker/entrypoint.js`\n\n    const workerBlob = await fetch(cdnUrl).then((res) => res.blob())\n    workerBlobUrl = URL.createObjectURL(workerBlob)\n  }\n\n  const rawWorker = new Worker(workerBlobUrl, { type: \"module\" })\n  let workerInitError: any\n  rawWorker.addEventListener(\"error\", (event) => {\n    console.error(\"[Worker] Error in worker\", event)\n    workerInitError = event\n  })\n  rawWorker.addEventListener(\"unhandledrejection\", (event) => {\n    console.error(\"[Worker] Unhandled rejection in worker\", event)\n  })\n  rawWorker.addEventListener(\"messageerror\", (event) => {\n    console.error(\"[Worker] Message error in worker\", event)\n  })\n  const earlyMessageHandler = (event: MessageEvent) => {\n    console.log(\"[Worker] Message in worker\", event)\n  }\n  rawWorker.addEventListener(\"message\", earlyMessageHandler)\n\n  if (workerInitError) {\n    throw workerInitError\n  }\n\n  const comlinkWorker = Comlink.wrap<InternalWebWorkerApi>(rawWorker)\n\n  rawWorker.removeEventListener(\"message\", earlyMessageHandler)\n\n  if (configuration.snippetsApiBaseUrl) {\n    await comlinkWorker.setSnippetsApiBaseUrl(configuration.snippetsApiBaseUrl)\n  }\n  if (configuration.platform) {\n    await comlinkWorker.setPlatformConfig(configuration.platform)\n  }\n\n  let isTerminated = false\n\n  // Create a wrapper that handles events directly through circuit instance\n  const wrapper: CircuitWebWorker = {\n    clearEventListeners: comlinkWorker.clearEventListeners.bind(comlinkWorker),\n    version: comlinkWorker.version.bind(comlinkWorker),\n    execute: async (...args) => {\n      if (isTerminated) {\n        throw new Error(\"CircuitWebWorker was terminated, can't execute\")\n      }\n      return comlinkWorker.execute.bind(comlinkWorker)(...args)\n    },\n    executeWithFsMap: async (...args) => {\n      if (isTerminated) {\n        throw new Error(\n          \"CircuitWebWorker was terminated, can't executeWithFsMap\",\n        )\n      }\n      return comlinkWorker.executeWithFsMap.bind(comlinkWorker)(...args)\n    },\n    renderUntilSettled: comlinkWorker.renderUntilSettled.bind(comlinkWorker),\n    getCircuitJson: comlinkWorker.getCircuitJson.bind(comlinkWorker),\n    on: (event: string, callback: (...args: any[]) => void) => {\n      const proxiedCallback = Comlink.proxy(callback)\n      comlinkWorker.on(event as RootCircuitEventName, proxiedCallback)\n    },\n    kill: async () => {\n      comlinkWorker[Comlink.releaseProxy]()\n      rawWorker.terminate()\n      isTerminated = true\n      if (globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER === wrapper) {\n        globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = undefined\n      }\n    },\n  }\n  globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = wrapper\n  return wrapper\n}\n", "export const getImportsFromCode = (code: string): string[] => {\n  // Match basic import patterns including combined default and namespace imports\n  const importRegex =\n    /^\\s*import\\s+(?:(?:[\\w\\s]+,\\s*)?(?:\\*\\s+as\\s+[\\w\\s]+|\\{[\\s\\w,]+\\}|\\w+)\\s+from\\s+)?['\"](.+?)['\"]/gm\n  const imports: string[] = []\n  let match: RegExpExecArray | null\n\n  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>\n  while ((match = importRegex.exec(code)) !== null) {\n    imports.push(match[1])\n  }\n\n  // Match re-exports\n  const reExportRegex =\n    /^\\s*export\\s+(?:\\*|(?:\\{[\\s\\w,]+\\}))\\s+from\\s+['\"](.+?)['\"]/gm\n  let reExportMatch: RegExpExecArray | null\n  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>\n  while ((reExportMatch = reExportRegex.exec(code)) !== null) {\n    imports.push(reExportMatch[1])\n  }\n\n  return imports\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../lib/worker.ts", "../lib/utils/get-imports-from-code.ts"],
  "sourcesContent": ["import * as Comlink from \"comlink\"\nexport * from \"./utils/index\"\nimport type {\n  InternalWebWorkerApi,\n  WebWorkerConfiguration,\n  CircuitWebWorker,\n} from \"./shared/types\"\nimport type { RootCircuitEventName } from \"@tscircuit/core\"\n\nexport type { CircuitWebWorker, WebWorkerConfiguration }\n\ndeclare global {\n  interface Window {\n    TSCIRCUIT_GLOBAL_CIRCUIT_WORKER: CircuitWebWorker | undefined\n  }\n  var TSCIRCUIT_GLOBAL_CIRCUIT_WORKER: CircuitWebWorker | undefined\n}\n\nexport const createCircuitWebWorker = async (\n  configuration: Partial<WebWorkerConfiguration>,\n): Promise<CircuitWebWorker> => {\n  // Kill existing global worker instance if present\n  const existingWorker = globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER\n  if (existingWorker && typeof existingWorker.kill === \"function\") {\n    if (configuration.verbose) {\n      console.log(\"[Worker] Killing previous global worker instance...\")\n    }\n    try {\n      await existingWorker.kill()\n    } catch (e) {\n      if (configuration.verbose) {\n        console.warn(\n          \"[Worker] Error killing previous global worker instance:\",\n          e,\n        )\n      }\n      // Ensure the key is cleared even if kill throws an error\n      if (globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER === existingWorker) {\n        globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = undefined\n      }\n    }\n  }\n\n  if (configuration.verbose) {\n    console.log(\n      \"[Worker] Creating circuit web worker with config:\",\n      configuration,\n    )\n  }\n\n  let workerBlobUrl =\n    configuration.webWorkerBlobUrl ?? configuration.webWorkerUrl\n\n  if (!workerBlobUrl) {\n    const cdnUrl = `https://cdn.jsdelivr.net/npm/@tscircuit/eval@${configuration.evalVersion ?? \"latest\"}/dist/webworker/entrypoint.js`\n\n    const workerBlob = await globalThis.fetch(cdnUrl).then((res) => res.blob())\n    workerBlobUrl = URL.createObjectURL(workerBlob)\n  }\n\n  const rawWorker = new Worker(workerBlobUrl, { type: \"module\" })\n  let workerInitError: any\n  rawWorker.addEventListener(\"error\", (event) => {\n    console.error(\"[Worker] Error in worker\", event)\n    workerInitError = event\n  })\n  rawWorker.addEventListener(\"unhandledrejection\", (event) => {\n    console.error(\"[Worker] Unhandled rejection in worker\", event)\n  })\n  rawWorker.addEventListener(\"messageerror\", (event) => {\n    console.error(\"[Worker] Message error in worker\", event)\n  })\n  const earlyMessageHandler = (event: MessageEvent) => {\n    console.log(\"[Worker] Message in worker\", event)\n  }\n  rawWorker.addEventListener(\"message\", earlyMessageHandler)\n\n  // Handle fetch requests from the worker\n  rawWorker.addEventListener(\"message\", async (event: MessageEvent) => {\n    const data = event.data\n    if (data?.type !== \"worker_fetch\") return\n\n    try {\n      const response = await globalThis.fetch(data.input, data.init)\n      const body = await response.text()\n      rawWorker.postMessage({\n        type: \"worker_fetch_result\",\n        requestId: data.requestId,\n        success: true,\n        response: {\n          body,\n          status: response.status,\n          statusText: response.statusText,\n          headers: (() => {\n            const obj: Record<string, string> = {}\n            response.headers.forEach((value, key) => {\n              obj[key] = value\n            })\n            return obj\n          })(),\n        },\n      })\n    } catch (err: any) {\n      rawWorker.postMessage({\n        type: \"worker_fetch_result\",\n        requestId: data.requestId,\n        success: false,\n        error: {\n          name: err.name,\n          message: err.message,\n          stack: err.stack,\n        },\n      })\n    }\n  })\n\n  if (workerInitError) {\n    throw workerInitError\n  }\n\n  const comlinkWorker = Comlink.wrap<InternalWebWorkerApi>(rawWorker)\n\n  rawWorker.removeEventListener(\"message\", earlyMessageHandler)\n\n  // Conditionally override global fetch inside the worker to route through the parent\n  // Only enable when explicitly requested via configuration\n  if (configuration.enableFetchProxy) {\n    rawWorker.postMessage({ type: \"override_global_fetch\" })\n  }\n\n  if (configuration.snippetsApiBaseUrl) {\n    await comlinkWorker.setSnippetsApiBaseUrl(configuration.snippetsApiBaseUrl)\n  }\n  if (configuration.platform) {\n    await comlinkWorker.setPlatformConfig(configuration.platform)\n  }\n\n  let isTerminated = false\n\n  // Create a wrapper that handles events directly through circuit instance\n  const wrapper: CircuitWebWorker = {\n    clearEventListeners: comlinkWorker.clearEventListeners.bind(comlinkWorker),\n    version: comlinkWorker.version.bind(comlinkWorker),\n    execute: async (...args) => {\n      if (isTerminated) {\n        throw new Error(\"CircuitWebWorker was terminated, can't execute\")\n      }\n      return comlinkWorker.execute.bind(comlinkWorker)(...args)\n    },\n    executeWithFsMap: async (...args) => {\n      if (isTerminated) {\n        throw new Error(\n          \"CircuitWebWorker was terminated, can't executeWithFsMap\",\n        )\n      }\n      return comlinkWorker.executeWithFsMap.bind(comlinkWorker)(...args)\n    },\n    renderUntilSettled: comlinkWorker.renderUntilSettled.bind(comlinkWorker),\n    getCircuitJson: comlinkWorker.getCircuitJson.bind(comlinkWorker),\n    on: (event: string, callback: (...args: any[]) => void) => {\n      const proxiedCallback = Comlink.proxy(callback)\n      comlinkWorker.on(event as RootCircuitEventName, proxiedCallback)\n    },\n    kill: async () => {\n      comlinkWorker[Comlink.releaseProxy]()\n      rawWorker.terminate()\n      isTerminated = true\n      if (globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER === wrapper) {\n        globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = undefined\n      }\n    },\n  }\n  ;(wrapper as any).__rawWorker = rawWorker\n  globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = wrapper\n  return wrapper\n}\n", "export const getImportsFromCode = (code: string): string[] => {\n  // Match basic import patterns including combined default and namespace imports\n  const importRegex =\n    /^\\s*import\\s+(?:(?:[\\w\\s]+,\\s*)?(?:\\*\\s+as\\s+[\\w\\s]+|\\{[\\s\\w,]+\\}|\\w+)\\s+from\\s+)?['\"](.+?)['\"]/gm\n  const imports: string[] = []\n  let match: RegExpExecArray | null\n\n  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>\n  while ((match = importRegex.exec(code)) !== null) {\n    imports.push(match[1])\n  }\n\n  // Match re-exports\n  const reExportRegex =\n    /^\\s*export\\s+(?:\\*|(?:\\{[\\s\\w,]+\\}))\\s+from\\s+['\"](.+?)['\"]/gm\n  let reExportMatch: RegExpExecArray | null\n  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>\n  while ((reExportMatch = reExportRegex.exec(code)) !== null) {\n    imports.push(reExportMatch[1])\n  }\n\n  return imports\n}\n"],
  "mappings": "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",
  "names": []
}


package/lib/shared/types.ts

@@ -16,6 +16,13 @@ export interface WebWorkerConfiguration extends CircuitRunnerConfiguration {
    */
   webWorkerUrl?: URL | string
   webWorkerBlobUrl?: URL | string
+  /**
+   * Enable fetch proxy to route worker fetch requests through parent thread.
+   * Useful when running in restricted environments (like ChatGPT) where
+   * worker fetch requests are blocked.
+   * Default: false
+   */
+  enableFetchProxy?: boolean
 }
 
 /**

package/lib/worker.ts

@@ -54,7 +54,7 @@ export const createCircuitWebWorker = async (
   if (!workerBlobUrl) {
     const cdnUrl = `https://cdn.jsdelivr.net/npm/@tscircuit/eval@${configuration.evalVersion ?? "latest"}/dist/webworker/entrypoint.js`
 
-    const workerBlob = await fetch(cdnUrl).then((res) => res.blob())
+    const workerBlob = await globalThis.fetch(cdnUrl).then((res) => res.blob())
     workerBlobUrl = URL.createObjectURL(workerBlob)
   }
 
@@ -75,6 +75,45 @@ export const createCircuitWebWorker = async (
   }
   rawWorker.addEventListener("message", earlyMessageHandler)
 
+  // Handle fetch requests from the worker
+  rawWorker.addEventListener("message", async (event: MessageEvent) => {
+    const data = event.data
+    if (data?.type !== "worker_fetch") return
+
+    try {
+      const response = await globalThis.fetch(data.input, data.init)
+      const body = await response.text()
+      rawWorker.postMessage({
+        type: "worker_fetch_result",
+        requestId: data.requestId,
+        success: true,
+        response: {
+          body,
+          status: response.status,
+          statusText: response.statusText,
+          headers: (() => {
+            const obj: Record<string, string> = {}
+            response.headers.forEach((value, key) => {
+              obj[key] = value
+            })
+            return obj
+          })(),
+        },
+      })
+    } catch (err: any) {
+      rawWorker.postMessage({
+        type: "worker_fetch_result",
+        requestId: data.requestId,
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      })
+    }
+  })
+
   if (workerInitError) {
     throw workerInitError
   }
@@ -83,6 +122,12 @@ export const createCircuitWebWorker = async (
 
   rawWorker.removeEventListener("message", earlyMessageHandler)
 
+  // Conditionally override global fetch inside the worker to route through the parent
+  // Only enable when explicitly requested via configuration
+  if (configuration.enableFetchProxy) {
+    rawWorker.postMessage({ type: "override_global_fetch" })
+  }
+
   if (configuration.snippetsApiBaseUrl) {
     await comlinkWorker.setSnippetsApiBaseUrl(configuration.snippetsApiBaseUrl)
   }
@@ -125,6 +170,7 @@ export const createCircuitWebWorker = async (
       }
     },
   }
+  ;(wrapper as any).__rawWorker = rawWorker
   globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = wrapper
   return wrapper
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/eval",
   "main": "dist/lib/index.js",
-  "version": "0.0.287",
+  "version": "0.0.288",
   "type": "module",
   "scripts": {
     "build": "bun run build:lib && bun run build:webworker && bun run build:blob-url && bun run build:runner && bun run build:worker-wrapper",

package/tests/example3-encoded-url.test.tsx

@@ -1,7 +1,7 @@
 import { createCircuitWebWorker } from "lib"
 import { expect, test } from "bun:test"
 // @ts-ignore
-import blobUrl from "dist/blob-url"
+import blobUrl from "../dist/blob-url"
 
 test("example3-encoded-worker-url", async () => {
   const circuitWebWorker = await createCircuitWebWorker({

package/tests/fetch-override.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "bun:test"
+import { createCircuitWebWorker } from "../lib"
+
+describe("fetch override", () => {
+  it("allows worker to fetch via parent and propagates errors", async () => {
+    const originalFetch = globalThis.fetch
+    const fakeFetch = async (input: RequestInfo, init?: RequestInit) => {
+      if (typeof input === "string" && input.includes("cjs.tscircuit.com")) {
+        return new Response("module.exports = { default: 123 };", {
+          status: 200,
+        })
+      }
+      throw new Error("fake fail")
+    }
+    globalThis.fetch = fakeFetch as any
+
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: new URL("../dist/webworker/entrypoint.js", import.meta.url)
+        .href,
+      enableFetchProxy: true,
+    })
+
+    const rawWorker: Worker = (worker as any).__rawWorker
+    const messages: any[] = []
+    rawWorker.addEventListener("message", (event) => {
+      if (event.data?.type === "fetch_error") messages.push(event.data)
+    })
+
+    await worker.execute(`
+import val from "@tsci/test.snippet";
+if (val !== 123) { throw new Error("snippet failed"); }
+fetch("https://fail.test").catch(e => {
+  postMessage({ type: "fetch_error", name: e.name, message: e.message });
+});
+`)
+
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(messages).toEqual([
+      { type: "fetch_error", name: "Error", message: "fake fail" },
+    ])
+
+    await worker.kill()
+    globalThis.fetch = originalFetch
+  })
+})

package/tests/fetch-proxy-validation.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "bun:test"
+import { createCircuitWebWorker } from "../lib"
+
+describe("fetch proxy validation", () => {
+  it("should NOT proxy fetch requests when enableFetchProxy is false (default)", async () => {
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: new URL("../dist/webworker/entrypoint.js", import.meta.url)
+        .href,
+      // enableFetchProxy not set, should default to false
+    })
+
+    const rawWorker: Worker = (worker as any).__rawWorker
+    const messages: any[] = []
+    rawWorker.addEventListener("message", (event) => {
+      if (event.data?.type === "worker_fetch") messages.push(event.data)
+    })
+
+    await worker.execute(`
+// Test that fetch calls are NOT proxied when enableFetchProxy is false
+fetch("https://example.com/test")
+  .catch(() => {}); // Ignore errors, we just want to see if it's proxied
+`)
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    // Should NOT have received any worker_fetch messages
+    expect(messages.length).toBe(0)
+
+    await worker.kill()
+  })
+
+  it("should proxy fetch requests when enableFetchProxy is true", async () => {
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: new URL("../dist/webworker/entrypoint.js", import.meta.url)
+        .href,
+      enableFetchProxy: true,
+    })
+
+    const rawWorker: Worker = (worker as any).__rawWorker
+    const messages: any[] = []
+    rawWorker.addEventListener("message", (event) => {
+      if (event.data?.type === "worker_fetch") messages.push(event.data)
+    })
+
+    await worker.execute(`
+// Test that fetch calls are proxied when enableFetchProxy is true
+fetch("https://example.com/test")
+  .catch(() => {}); // Ignore errors, we just want to see if it's proxied
+`)
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    // Should have received a worker_fetch message indicating the proxy is working
+    expect(messages.length).toBeGreaterThan(0)
+    expect(messages[0].type).toBe("worker_fetch")
+    expect(messages[0].input).toBe("https://example.com/test")
+
+    await worker.kill()
+  })
+
+  it("should handle fetch errors properly through proxy when enabled", async () => {
+    // This test verifies that the fetch proxy correctly handles and forwards errors
+    const originalFetch = globalThis.fetch
+    const fakeFetch = async () => {
+      throw new Error("Network error")
+    }
+    globalThis.fetch = fakeFetch as any
+
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: new URL("../dist/webworker/entrypoint.js", import.meta.url)
+        .href,
+      enableFetchProxy: true,
+    })
+
+    const rawWorker: Worker = (worker as any).__rawWorker
+    const messages: any[] = []
+    rawWorker.addEventListener("message", (event) => {
+      if (event.data?.type === "fetch_error") messages.push(event.data)
+    })
+
+    await worker.execute(`
+fetch("https://example.com/test")
+  .catch(e => {
+    postMessage({ type: "fetch_error", name: e.name, message: e.message });
+  });
+`)
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    expect(messages).toEqual([
+      { type: "fetch_error", name: "Error", message: "Network error" },
+    ])
+
+    await worker.kill()
+    globalThis.fetch = originalFetch
+  })
+})

package/webworker/entrypoint.ts

@@ -14,8 +14,10 @@ import { importEvalPath } from "./import-eval-path"
 import { normalizeFsMap } from "../lib/runner/normalizeFsMap"
 import type { RootCircuit } from "@tscircuit/core"
 import { setupDefaultEntrypointIfNeeded } from "lib/runner/setupDefaultEntrypointIfNeeded"
+import { setupFetchProxy } from "./fetchProxy"
 
 globalThis.React = React
+setupFetchProxy()
 
 let executionContext: ExecutionContext | null = null
 
@@ -124,7 +126,10 @@ const webWorkerApi = {
       for (const event in eventListeners) {
         for (const listener of eventListeners[event]) {
           const circuit = executionContext.circuit as unknown as {
-            removeListener?: (event: string, listener: Function) => void
+            removeListener?: (
+              event: string,
+              listener: (...args: any[]) => void,
+            ) => void
           }
           if (typeof circuit.removeListener === "function") {
             circuit.removeListener(event, listener)

package/webworker/fetchProxy.ts

@@ -0,0 +1,83 @@
+export const setupFetchProxy = () => {
+  const pendingRequests = new Map<
+    number,
+    { resolve: (value: Response) => void; reject: (reason: any) => void }
+  >()
+  let requestCounter = 0
+
+  function fetchProxy(
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> {
+    const requestId = ++requestCounter
+    return new Promise((resolve, reject) => {
+      pendingRequests.set(requestId, { resolve, reject })
+      let url: string
+      let requestInit: any = init ? { ...init } : {}
+
+      if (typeof input === "string" || input instanceof URL) {
+        url = input.toString()
+      } else {
+        url = input.url
+        requestInit = {
+          ...requestInit,
+          method: input.method,
+          headers: (() => {
+            const obj: Record<string, string> = {}
+            input.headers.forEach((value, key) => {
+              obj[key] = value
+            })
+            return obj
+          })(),
+          body: input.bodyUsed ? undefined : (input as any).body,
+        }
+      }
+
+      if (requestInit.headers instanceof Headers) {
+        const obj: Record<string, string> = {}
+        requestInit.headers.forEach((value: string, key: string) => {
+          obj[key] = value
+        })
+        requestInit.headers = obj
+      }
+      ;(globalThis as any).postMessage({
+        type: "worker_fetch",
+        requestId,
+        input: url,
+        init: requestInit,
+      })
+    })
+  }
+
+  function handleMessage(event: MessageEvent) {
+    const data = event.data
+    if (!data) return
+
+    if (data.type === "override_global_fetch") {
+      ;(globalThis as any).fetch = fetchProxy
+      return
+    }
+
+    if (data.type === "worker_fetch_result") {
+      const handlers = pendingRequests.get(data.requestId)
+      if (!handlers) return
+      pendingRequests.delete(data.requestId)
+
+      if (data.success) {
+        const resp = new Response(data.response.body, {
+          status: data.response.status,
+          statusText: data.response.statusText,
+          headers: data.response.headers,
+        })
+        handlers.resolve(resp)
+      } else {
+        const err = new Error(data.error.message)
+        if (data.error.name) err.name = data.error.name
+        if (data.error.stack) err.stack = data.error.stack
+        handlers.reject(err)
+      }
+    }
+  }
+
+  globalThis.addEventListener("message", handleMessage)
+}

package/webworker/import-snippet.ts

@@ -1,8 +1,5 @@
 import { evalCompiledJs } from "./eval-compiled-js"
 import type { ExecutionContext } from "./execution-context"
-import * as Babel from "@babel/standalone"
-import { importLocalFile } from "./import-local-file"
-import { importEvalPath } from "./import-eval-path"
 
 export async function importSnippet(
   importName: string,
@@ -12,7 +9,8 @@ export async function importSnippet(
   const { preSuppliedImports } = ctx
   const fullSnippetName = importName.replace("@tsci/", "").replace(".", "/")
 
-  const { cjs, error } = await fetch(`${ctx.cjsRegistryUrl}/${fullSnippetName}`)
+  const { cjs, error } = await globalThis
+    .fetch(`${ctx.cjsRegistryUrl}/${fullSnippetName}`)
     .then(async (res) => ({ cjs: await res.text(), error: null }))
     .catch((e) => ({ error: e, cjs: null }))