@tscircuit/eval 0.0.288 → 0.0.290

package/dist/worker.d.ts

@@ -27,6 +27,7 @@ interface WebWorkerConfiguration extends CircuitRunnerConfiguration {
 }
 type CircuitWebWorker = {
     execute: (code: string) => Promise<void>;
+    executeComponent: (component: any) => Promise<void>;
     executeWithFsMap: (opts: {
         entrypoint?: string;
         mainComponentPath?: string;

package/dist/worker.js

@@ -107,6 +107,38 @@ var createCircuitWebWorker = async (configuration) => {
   }
   const comlinkWorker = Comlink.wrap(rawWorker);
   rawWorker.removeEventListener("message", earlyMessageHandler);
+  function serializeReactElement(element) {
+    if (!element || typeof element !== "object") {
+      return element;
+    }
+    if (element.type && element.props !== void 0) {
+      return {
+        __isSerializedReactElement: true,
+        type: element.type,
+        props: serializeProps(element.props),
+        key: element.key
+      };
+    }
+    return element;
+  }
+  function serializeProps(props) {
+    if (!props || typeof props !== "object") {
+      return props;
+    }
+    const serialized = {};
+    for (const [key, value] of Object.entries(props)) {
+      if (key === "children") {
+        if (Array.isArray(value)) {
+          serialized.children = value.map(serializeReactElement);
+        } else {
+          serialized.children = serializeReactElement(value);
+        }
+      } else {
+        serialized[key] = value;
+      }
+    }
+    return serialized;
+  }
   if (configuration.enableFetchProxy) {
     rawWorker.postMessage({ type: "override_global_fetch" });
   }
@@ -126,6 +158,23 @@ var createCircuitWebWorker = async (configuration) => {
       }
       return comlinkWorker.execute.bind(comlinkWorker)(...args);
     },
+    executeComponent: async (component) => {
+      if (isTerminated) {
+        throw new Error(
+          "CircuitWebWorker was terminated, can't executeComponent"
+        );
+      }
+      if (typeof component === "function") {
+        return comlinkWorker.executeComponent.bind(comlinkWorker)(component);
+      }
+      if (component && typeof component === "object" && component.type) {
+        const serializedElement = serializeReactElement(component);
+        return comlinkWorker.executeComponent.bind(comlinkWorker)(
+          serializedElement
+        );
+      }
+      return comlinkWorker.executeComponent.bind(comlinkWorker)(component);
+    },
     executeWithFsMap: async (...args) => {
       if (isTerminated) {
         throw new Error(
@@ -157,4 +206,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 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": []
}

+//# 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  // Helper to serialize React elements for cross-worker communication\n  function serializeReactElement(element: any): any {\n    if (!element || typeof element !== \"object\") {\n      return element\n    }\n\n    if (element.type && element.props !== undefined) {\n      // This is a React element\n      return {\n        __isSerializedReactElement: true,\n        type: element.type,\n        props: serializeProps(element.props),\n        key: element.key,\n      }\n    }\n\n    return element\n  }\n\n  function serializeProps(props: any): any {\n    if (!props || typeof props !== \"object\") {\n      return props\n    }\n\n    const serialized: any = {}\n    for (const [key, value] of Object.entries(props)) {\n      if (key === \"children\") {\n        if (Array.isArray(value)) {\n          serialized.children = value.map(serializeReactElement)\n        } else {\n          serialized.children = serializeReactElement(value)\n        }\n      } else {\n        serialized[key] = value\n      }\n    }\n    return serialized\n  }\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    executeComponent: async (component: any) => {\n      if (isTerminated) {\n        throw new Error(\n          \"CircuitWebWorker was terminated, can't executeComponent\",\n        )\n      }\n\n      // If it's a function, pass it as-is (will be proxied by Comlink)\n      if (typeof component === \"function\") {\n        return comlinkWorker.executeComponent.bind(comlinkWorker)(component)\n      }\n\n      // If it's a React element, serialize it to a reconstructable format\n      if (component && typeof component === \"object\" && component.type) {\n        const serializedElement = serializeReactElement(component)\n        return comlinkWorker.executeComponent.bind(comlinkWorker)(\n          serializedElement,\n        )\n      }\n\n      return comlinkWorker.executeComponent.bind(comlinkWorker)(component)\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/runner/CircuitRunner.ts

@@ -102,6 +102,25 @@ export class CircuitRunner implements CircuitRunnerApi {
     await importEvalPath("./entrypoint.tsx", this._executionContext)
   }
 
+  async executeComponent(component: any, opts: { name?: string } = {}) {
+    if (this._circuitRunnerConfiguration.verbose) {
+      console.log("[CircuitRunner] executeComponent called")
+    }
+
+    this._executionContext = createExecutionContext(
+      this._circuitRunnerConfiguration,
+      {
+        ...opts,
+        platform: this._circuitRunnerConfiguration.platform,
+      },
+    )
+    this._bindEventListeners(this._executionContext.circuit)
+    ;(globalThis as any).__tscircuit_circuit = this._executionContext.circuit
+
+    const element = typeof component === "function" ? component() : component
+    this._executionContext.circuit.add(element as any)
+  }
+
   on(event: string, callback: (...args: any[]) => void) {
     this._eventListeners[event] ??= []
     this._eventListeners[event].push(callback)

package/lib/shared/types.ts

@@ -36,6 +36,7 @@ export interface CircuitRunnerApi {
       name?: string
     },
   ) => Promise<void>
+  executeComponent: (component: any) => Promise<void>
   executeWithFsMap(opts: {
     entrypoint?: string
     fsMap: Record<string, string>
@@ -57,6 +58,7 @@ export type InternalWebWorkerApi = CircuitRunnerApi
 
 export type CircuitWebWorker = {
   execute: (code: string) => Promise<void>
+  executeComponent: (component: any) => Promise<void>
   executeWithFsMap: (opts: {
     entrypoint?: string
     mainComponentPath?: string

package/lib/worker.ts

@@ -122,6 +122,45 @@ export const createCircuitWebWorker = async (
 
   rawWorker.removeEventListener("message", earlyMessageHandler)
 
+  // Helper to serialize React elements for cross-worker communication
+  function serializeReactElement(element: any): any {
+    if (!element || typeof element !== "object") {
+      return element
+    }
+
+    if (element.type && element.props !== undefined) {
+      // This is a React element
+      return {
+        __isSerializedReactElement: true,
+        type: element.type,
+        props: serializeProps(element.props),
+        key: element.key,
+      }
+    }
+
+    return element
+  }
+
+  function serializeProps(props: any): any {
+    if (!props || typeof props !== "object") {
+      return props
+    }
+
+    const serialized: any = {}
+    for (const [key, value] of Object.entries(props)) {
+      if (key === "children") {
+        if (Array.isArray(value)) {
+          serialized.children = value.map(serializeReactElement)
+        } else {
+          serialized.children = serializeReactElement(value)
+        }
+      } else {
+        serialized[key] = value
+      }
+    }
+    return serialized
+  }
+
   // Conditionally override global fetch inside the worker to route through the parent
   // Only enable when explicitly requested via configuration
   if (configuration.enableFetchProxy) {
@@ -147,6 +186,28 @@ export const createCircuitWebWorker = async (
       }
       return comlinkWorker.execute.bind(comlinkWorker)(...args)
     },
+    executeComponent: async (component: any) => {
+      if (isTerminated) {
+        throw new Error(
+          "CircuitWebWorker was terminated, can't executeComponent",
+        )
+      }
+
+      // If it's a function, pass it as-is (will be proxied by Comlink)
+      if (typeof component === "function") {
+        return comlinkWorker.executeComponent.bind(comlinkWorker)(component)
+      }
+
+      // If it's a React element, serialize it to a reconstructable format
+      if (component && typeof component === "object" && component.type) {
+        const serializedElement = serializeReactElement(component)
+        return comlinkWorker.executeComponent.bind(comlinkWorker)(
+          serializedElement,
+        )
+      }
+
+      return comlinkWorker.executeComponent.bind(comlinkWorker)(component)
+    },
     executeWithFsMap: async (...args) => {
       if (isTerminated) {
         throw new Error(

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/eval",
   "main": "dist/lib/index.js",
-  "version": "0.0.288",
+  "version": "0.0.290",
   "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/execute-component-runner.test.tsx

@@ -0,0 +1,47 @@
+import { expect, test } from "bun:test"
+import * as React from "react"
+import { CircuitRunner } from "lib/runner/CircuitRunner"
+
+test("CircuitRunner.executeComponent with React element", async () => {
+  const runner = new CircuitRunner()
+  const element = React.createElement(
+    "board",
+    { width: "10mm", height: "10mm" },
+    React.createElement("resistor", {
+      name: "R1",
+      resistance: "1k",
+      footprint: "0402",
+    }),
+  )
+
+  await runner.executeComponent(element)
+  await runner.renderUntilSettled()
+  const circuitJson = await runner.getCircuitJson()
+  const r1 = circuitJson.find(
+    (el: any) => el.type === "source_component" && el.name === "R1",
+  )
+  expect(r1).toBeDefined()
+  await runner.kill()
+})
+
+test("CircuitRunner.executeComponent with factory function", async () => {
+  const runner = new CircuitRunner()
+  await runner.executeComponent(() =>
+    React.createElement(
+      "board",
+      { width: "10mm", height: "10mm" },
+      React.createElement("resistor", {
+        name: "R2",
+        resistance: "2k",
+        footprint: "0402",
+      }),
+    ),
+  )
+  await runner.renderUntilSettled()
+  const circuitJson = await runner.getCircuitJson()
+  const r2 = circuitJson.find(
+    (el: any) => el.type === "source_component" && el.name === "R2",
+  )
+  expect(r2).toBeDefined()
+  await runner.kill()
+})