@tscircuit/eval 0.0.287 → 0.0.289

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": ";AAAA,YAAY,aAAa;;;ACAlB,IAAM,qBAAqB,CAAC,SAA2B;AAE5D,QAAM,cACJ;AACF,QAAM,UAAoB,CAAC;AAC3B,MAAI;AAGJ,UAAQ,QAAQ,YAAY,KAAK,IAAI,OAAO,MAAM;AAChD,YAAQ,KAAK,MAAM,CAAC,CAAC;AAAA,EACvB;AAGA,QAAM,gBACJ;AACF,MAAI;AAEJ,UAAQ,gBAAgB,cAAc,KAAK,IAAI,OAAO,MAAM;AAC1D,YAAQ,KAAK,cAAc,CAAC,CAAC;AAAA,EAC/B;AAEA,SAAO;AACT;;;ADJO,IAAM,yBAAyB,OACpC,kBAC8B;AAE9B,QAAM,iBAAiB,WAAW;AAClC,MAAI,kBAAkB,OAAO,eAAe,SAAS,YAAY;AAC/D,QAAI,cAAc,SAAS;AACzB,cAAQ,IAAI,qDAAqD;AAAA,IACnE;AACA,QAAI;AACF,YAAM,eAAe,KAAK;AAAA,IAC5B,SAAS,GAAG;AACV,UAAI,cAAc,SAAS;AACzB,gBAAQ;AAAA,UACN;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAEA,UAAI,WAAW,oCAAoC,gBAAgB;AACjE,mBAAW,kCAAkC;AAAA,MAC/C;AAAA,IACF;AAAA,EACF;AAEA,MAAI,cAAc,SAAS;AACzB,YAAQ;AAAA,MACN;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,MAAI,gBACF,cAAc,oBAAoB,cAAc;AAElD,MAAI,CAAC,eAAe;AAClB,UAAM,SAAS,gDAAgD,cAAc,eAAe,QAAQ;AAEpG,UAAM,aAAa,MAAM,MAAM,MAAM,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC;AAC/D,oBAAgB,IAAI,gBAAgB,UAAU;AAAA,EAChD;AAEA,QAAM,YAAY,IAAI,OAAO,eAAe,EAAE,MAAM,SAAS,CAAC;AAC9D,MAAI;AACJ,YAAU,iBAAiB,SAAS,CAAC,UAAU;AAC7C,YAAQ,MAAM,4BAA4B,KAAK;AAC/C,sBAAkB;AAAA,EACpB,CAAC;AACD,YAAU,iBAAiB,sBAAsB,CAAC,UAAU;AAC1D,YAAQ,MAAM,0CAA0C,KAAK;AAAA,EAC/D,CAAC;AACD,YAAU,iBAAiB,gBAAgB,CAAC,UAAU;AACpD,YAAQ,MAAM,oCAAoC,KAAK;AAAA,EACzD,CAAC;AACD,QAAM,sBAAsB,CAAC,UAAwB;AACnD,YAAQ,IAAI,8BAA8B,KAAK;AAAA,EACjD;AACA,YAAU,iBAAiB,WAAW,mBAAmB;AAEzD,MAAI,iBAAiB;AACnB,UAAM;AAAA,EACR;AAEA,QAAM,gBAAwB,aAA2B,SAAS;AAElE,YAAU,oBAAoB,WAAW,mBAAmB;AAE5D,MAAI,cAAc,oBAAoB;AACpC,UAAM,cAAc,sBAAsB,cAAc,kBAAkB;AAAA,EAC5E;AACA,MAAI,cAAc,UAAU;AAC1B,UAAM,cAAc,kBAAkB,cAAc,QAAQ;AAAA,EAC9D;AAEA,MAAI,eAAe;AAGnB,QAAM,UAA4B;AAAA,IAChC,qBAAqB,cAAc,oBAAoB,KAAK,aAAa;AAAA,IACzE,SAAS,cAAc,QAAQ,KAAK,aAAa;AAAA,IACjD,SAAS,UAAU,SAAS;AAC1B,UAAI,cAAc;AAChB,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE;AACA,aAAO,cAAc,QAAQ,KAAK,aAAa,EAAE,GAAG,IAAI;AAAA,IAC1D;AAAA,IACA,kBAAkB,UAAU,SAAS;AACnC,UAAI,cAAc;AAChB,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAAA,MACF;AACA,aAAO,cAAc,iBAAiB,KAAK,aAAa,EAAE,GAAG,IAAI;AAAA,IACnE;AAAA,IACA,oBAAoB,cAAc,mBAAmB,KAAK,aAAa;AAAA,IACvE,gBAAgB,cAAc,eAAe,KAAK,aAAa;AAAA,IAC/D,IAAI,CAAC,OAAe,aAAuC;AACzD,YAAM,kBAA0B,cAAM,QAAQ;AAC9C,oBAAc,GAAG,OAA+B,eAAe;AAAA,IACjE;AAAA,IACA,MAAM,YAAY;AAChB,oBAAsB,oBAAY,EAAE;AACpC,gBAAU,UAAU;AACpB,qBAAe;AACf,UAAI,WAAW,oCAAoC,SAAS;AAC1D,mBAAW,kCAAkC;AAAA,MAC/C;AAAA,IACF;AAAA,EACF;AACA,aAAW,kCAAkC;AAC7C,SAAO;AACT;",
  "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.289",
   "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",
@@ -16,6 +16,7 @@
     "format:check": "biome format .",
     "test:playwright": "playwright test",
     "test": "bun test tests",
+    "test:validate-matrix": "bun run scripts/validate-test-matrix.js",
     "copy-core-versions": "bun run scripts/copy-core-versions.ts && bun install --ignore-scripts"
   },
   "exports": {
@@ -53,20 +54,20 @@
     "@biomejs/biome": "^1.8.3",
     "@playwright/test": "^1.50.1",
     "@tscircuit/capacity-autorouter": "^0.0.100",
-    "@tscircuit/checks": "^0.0.68",
+    "@tscircuit/checks": "^0.0.71",
     "@tscircuit/circuit-json-flex": "^0.0.3",
     "@tscircuit/circuit-json-util": "^0.0.65",
-    "@tscircuit/core": "^0.0.631",
+    "@tscircuit/core": "^0.0.641",
     "@tscircuit/footprinter": "^0.0.208",
     "@tscircuit/import-snippet": "^0.0.4",
     "@tscircuit/infgrid-ijump-astar": "^0.0.33",
     "@tscircuit/layout": "^0.0.28",
     "@tscircuit/log-soup": "^1.0.2",
-    "@tscircuit/matchpack": "^0.0.4",
+    "@tscircuit/matchpack": "^0.0.9",
     "@tscircuit/math-utils": "^0.0.18",
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/parts-engine": "^0.0.8",
-    "@tscircuit/props": "^0.0.286",
+    "@tscircuit/props": "^0.0.287",
     "@tscircuit/schematic-autolayout": "^0.0.6",
     "@tscircuit/schematic-corpus": "^0.0.110",
     "@tscircuit/schematic-match-adapt": "^0.0.16",
@@ -81,7 +82,7 @@
     "bun-match-svg": "0.0.12",
     "calculate-elbow": "^0.0.9",
     "chokidar-cli": "^3.0.0",
-    "circuit-json": "^0.0.228",
+    "circuit-json": "^0.0.232",
     "circuit-json-to-bpc": "^0.0.13",
     "circuit-json-to-connectivity-map": "^0.0.22",
     "circuit-json-to-simple-3d": "^0.0.6",
@@ -99,7 +100,8 @@
     "react-dom": "^19.1.0",
     "schematic-symbols": "^0.0.180",
     "ts-expect": "^1.3.0",
-    "tsup": "^8.2.4"
+    "tsup": "^8.2.4",
+    "minicssgrid": "^0.0.8"
   },
   "peerDependencies": {
     "typescript": "^5.0.0",

package/scripts/validate-test-matrix.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+import { readdirSync, statSync, readFileSync } from "fs"
+import { join } from "path"
+import { fileURLToPath } from "url"
+import { dirname } from "path"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const testsDir = join(__dirname, "..", "tests")
+const workflowFile = join(
+  __dirname,
+  "..",
+  ".github",
+  "workflows",
+  "bun-test.yml",
+)
+
+// Get all directories in tests/ that contain test files
+function getTestDirectories() {
+  const entries = readdirSync(testsDir)
+  const testDirs = []
+
+  for (const entry of entries) {
+    const fullPath = join(testsDir, entry)
+
+    // Skip non-directories
+    if (!statSync(fullPath).isDirectory()) continue
+
+    // Skip hidden directories like .claude
+    if (entry.startsWith(".")) continue
+
+    // Check if directory contains test files
+    if (hasTestFiles(fullPath)) {
+      testDirs.push(entry)
+    }
+  }
+
+  return testDirs.sort()
+}
+
+// Check if a directory contains test files (recursively)
+function hasTestFiles(dirPath) {
+  try {
+    const entries = readdirSync(dirPath)
+
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry)
+      const stat = statSync(fullPath)
+
+      if (
+        stat.isFile() &&
+        (entry.endsWith(".test.ts") || entry.endsWith(".test.tsx"))
+      ) {
+        return true
+      }
+
+      if (stat.isDirectory() && hasTestFiles(fullPath)) {
+        return true
+      }
+    }
+
+    return false
+  } catch (error) {
+    console.warn(`Warning: Could not read directory ${dirPath}`)
+    return false
+  }
+}
+
+// Extract test directories from workflow file
+function getWorkflowTestDirectories() {
+  const workflowContent = readFileSync(workflowFile, "utf8")
+
+  // Look for the matrix test-dir configuration
+  const matrixMatch = workflowContent.match(/test-dir:\s*\[(.*?)\]/s)
+
+  if (!matrixMatch) {
+    throw new Error(
+      "Could not find test-dir matrix configuration in workflow file",
+    )
+  }
+
+  const matrixContent = matrixMatch[1]
+  const dirs = matrixContent
+    .split(",")
+    .map((dir) => dir.trim().replace(/['"]/g, ""))
+    .filter((dir) => dir.length > 0)
+    .sort()
+
+  return dirs
+}
+
+function main() {
+  console.log("🔍 Validating test matrix configuration...")
+
+  const actualTestDirs = getTestDirectories()
+  const workflowTestDirs = getWorkflowTestDirectories()
+
+  console.log(
+    `Found ${actualTestDirs.length} test directories:`,
+    actualTestDirs,
+  )
+  console.log(
+    `Workflow covers ${workflowTestDirs.length} directories:`,
+    workflowTestDirs,
+  )
+
+  const missing = actualTestDirs.filter(
+    (dir) => !workflowTestDirs.includes(dir),
+  )
+  const extra = workflowTestDirs.filter((dir) => !actualTestDirs.includes(dir))
+
+  if (missing.length > 0) {
+    console.error(
+      "❌ ERROR: The following test directories are NOT covered by the workflow matrix:",
+    )
+    for (const dir of missing) {
+      console.error(`  - ${dir}`)
+    }
+    console.error(
+      "\nPlease add these directories to the test-dir matrix in .github/workflows/bun-test.yml",
+    )
+  }
+
+  if (extra.length > 0) {
+    console.warn(
+      "⚠️  WARNING: The following directories in the workflow matrix do not contain test files:",
+    )
+    for (const dir of extra) {
+      console.warn(`  - ${dir}`)
+    }
+    console.warn(
+      "\nConsider removing these from the test-dir matrix in .github/workflows/bun-test.yml",
+    )
+  }
+
+  if (missing.length === 0 && extra.length === 0) {
+    console.log(
+      "✅ All test directories are properly covered by the workflow matrix!",
+    )
+    process.exit(0)
+  } else {
+    process.exit(1)
+  }
+}
+
+main()

package/tests/{example1-readme-example.test.tsx → examples/example01-readme-example.test.tsx}

@@ -3,7 +3,7 @@ import { expect, test } from "bun:test"
 
 test("example1-readme-example", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   await circuitWebWorker.executeWithFsMap({

package/tests/{example2-multiple-files.test.tsx → examples/example02-multiple-files.test.tsx}

@@ -3,7 +3,7 @@ import { expect, test } from "bun:test"
 
 test("virtual filesystem with components", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   await circuitWebWorker.executeWithFsMap({

package/tests/{example3-encoded-url.test.tsx → examples/example03-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/{example4-root-child-issue.test.tsx → examples/example04-root-child-issue.test.tsx}

@@ -15,7 +15,7 @@ test(
   "example4-root-child-issue",
   async () => {
     const circuitWebWorker = await createCircuitWebWorker({
-      webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+      webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
     })
 
     await circuitWebWorker.executeWithFsMap({

package/tests/{example5-event-recording.test.tsx → examples/example05-event-recording.test.tsx}

@@ -4,7 +4,7 @@ import { createCircuitWebWorker } from "lib/index"
 // Skipped for flakiness, re-enable when flakiness is solved
 test.skip("example5-event-recording", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   let eventCount = 0

package/tests/{example7-import-default-and-namespace.test.tsx → examples/example07-import-default-and-namespace.test.tsx}

@@ -3,7 +3,7 @@ import { expect, test } from "bun:test"
 
 test("namespace import syntax", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   await circuitWebWorker.executeWithFsMap({
@@ -39,7 +39,7 @@ test("namespace import syntax", async () => {
 
 test("combined default and namespace import with fallback", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   await circuitWebWorker.executeWithFsMap({

package/tests/{example8-footprinter-to220.test.tsx → examples/example08-footprinter-to220.test.tsx}

@@ -3,7 +3,7 @@ import { expect, test } from "bun:test"
 
 test("example8-footprinter-to220", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   await circuitWebWorker.execute(`  

package/tests/{example9-not-defined-component.test.tsx → examples/example09-not-defined-component.test.tsx}

@@ -3,7 +3,7 @@ import { expect, test } from "bun:test"
 
 test("example9-not-defined-component", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   expect(async () => {

package/tests/{example13-webworker-without-entrypoint.test.tsx → examples/example13-webworker-without-entrypoint.test.tsx}

@@ -4,7 +4,7 @@ import type { SourceSimpleResistor } from "circuit-json"
 
 test("example13-webworker-without-entrypoint", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   try {

package/tests/{example16-parts-engine.test.tsx → examples/example16-parts-engine.test.tsx}

@@ -4,7 +4,7 @@ import type { SourceComponentBase } from "circuit-json"
 
 test("example16-jlc-parts-engine with entrypoint", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
     verbose: true,
   })
 

package/tests/{example17-parse-tscircuit-config.test.tsx → examples/example17-parse-tscircuit-config.test.tsx}

@@ -3,7 +3,7 @@ import { expect, test } from "bun:test"
 
 test("parse tscircuit.config.js with mainEntrypoint", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   await circuitWebWorker.executeWithFsMap({

package/tests/{circuit-event-forwarding.test.tsx → features/circuit-event-forwarding.test.tsx}

@@ -6,7 +6,7 @@ test("circuit-web-worker-events", async () => {
   const capturedEvents: string[] = []
 
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/entrypoint.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/entrypoint.ts", import.meta.url),
   })
 
   await circuitWebWorker.execute(`

package/tests/features/fetch-proxy/fetch-override.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "bun:test"
+import { createCircuitWebWorker } from "lib"
+import { repoFileUrl } from "tests/fixtures/resourcePaths"
+
+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: repoFileUrl("dist/webworker/entrypoint.js").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
+  })
+})