@tscircuit/runframe 0.0.2947 → 0.0.2949

package/dist/{chunk-65VU5INM.js → chunk-T3FFIUMM.js}

@@ -2865,7 +2865,7 @@ var usePostHogActivity = (properties) => {
 };
 
 // package.json
-var version = "0.0.2946";
+var version = "0.0.2947";
 var package_default = {
   name: "@tscircuit/runframe",
   main: "dist/preview.js",

package/dist/preview.js

@@ -10,7 +10,7 @@ import {
   useOrderDialogCli,
   usePcbViewerController,
   useSchematicViewerController
-} from "./chunk-65VU5INM.js";
+} from "./chunk-T3FFIUMM.js";
 export {
   BomTable,
   CadViewer,

package/dist/runner.js

@@ -43,14 +43,14 @@ import {
   useRunnerStore,
   useSchematicViewerController,
   useStyles
-} from "./chunk-65VU5INM.js";
+} from "./chunk-T3FFIUMM.js";
 
 // lib/components/RunFrame/RunFrame.tsx
 import { createCircuitWebWorker } from "@tscircuit/eval/worker";
 import Debug from "debug";
 import { HTTPError } from "ky";
 import { Loader2, Play, Square } from "lucide-react";
-import { useEffect, useReducer, useRef as useRef2, useState } from "react";
+import { useEffect, useMemo as useMemo2, useReducer, useRef as useRef2, useState } from "react";
 import { ErrorBoundary } from "react-error-boundary";
 
 // lib/components/RunFrame/RunFrameErrorFallback.tsx
@@ -140,12 +140,12 @@ var useCircuitJsonFile = ({
   mainComponentPath,
   fsMap
 }) => {
+  const isStaticCircuitJson = mainComponentPath != null && isCircuitJsonFile(mainComponentPath);
+  const circuitJsonContent = mainComponentPath ? fsMap.get(mainComponentPath) : void 0;
   return useMemo(() => {
-    const isStaticCircuitJson = mainComponentPath != null && isCircuitJsonFile(mainComponentPath);
     if (!isStaticCircuitJson) {
       return { isStaticCircuitJson: false, circuitJson: null, error: null };
     }
-    const circuitJsonContent = fsMap.get(mainComponentPath);
     if (!circuitJsonContent) {
       return {
         isStaticCircuitJson: true,
@@ -163,7 +163,7 @@ var useCircuitJsonFile = ({
         error: `Failed to parse circuit.json: ${e instanceof Error ? e.message : String(e)}`
       };
     }
-  }, [mainComponentPath, fsMap]);
+  }, [mainComponentPath, circuitJsonContent]);
 };
 
 // lib/utils/getChangesBetweenFsMaps.tsx
@@ -337,11 +337,14 @@ var resolveEvalVersion = async (evalVersionProp, forceLatest) => {
 };
 var RunFrame = (props) => {
   useStyles();
+  const isStaticCircuitJson = props.mainComponentPath != null && isCircuitJsonFile(props.mainComponentPath);
   const circuitJson = useRunFrameStore((s) => s.circuitJson);
   const setCircuitJson = useRunFrameStore((s) => s.setCircuitJson);
   const [error, setError] = useState(null);
   const [componentStack, setComponentStack] = useState(null);
   const cancelExecutionRef = useRef2(null);
+  const componentActiveRef = useRef2(true);
+  const workerCreationRef = useRef2(null);
   const [autoroutingGraphics, setAutoroutingGraphics] = useState(null);
   const [runCountTrigger, incRunCountTrigger] = useReducer(
     (acc, s) => acc + 1,
@@ -356,6 +359,58 @@ var RunFrame = (props) => {
   const [currentDebugOption, setCurrentDebugOption] = useState("");
   const [showSchematicDebugGrid, setShowSchematicDebugGrid] = useState(false);
   const [showSchematicPorts, setShowSchematicPorts] = useState(false);
+  useEffect(() => {
+    componentActiveRef.current = true;
+    return () => {
+      componentActiveRef.current = false;
+      cancelExecutionRef.current?.();
+      const pending = workerCreationRef.current;
+      void pending?.then(({ worker }) => {
+        if (!componentActiveRef.current && globalThis.runFrameWorker !== worker) {
+          return worker.kill();
+        }
+      }).catch(() => {
+      });
+    };
+  }, []);
+  const getWorker = () => {
+    if (workerCreationRef.current) return workerCreationRef.current;
+    const pending = (async () => {
+      const evalVersion = await resolveEvalVersion(
+        props.evalVersion,
+        !globalThis.runFrameWorker && props.forceLatestEvalVersion
+      );
+      const worker = globalThis.runFrameWorker ?? await createCircuitWebWorker({
+        evalVersion,
+        webWorkerBlobUrl: props.evalWebWorkerBlobUrl,
+        projectConfig: getRunFrameProjectConfig({
+          projectBaseUrl: props.projectBaseUrl || `${API_BASE}/files/static`
+        }),
+        ...props.platformConfig && { platform: props.platformConfig },
+        verbose: true,
+        ...props.enableFetchProxy && {
+          enableFetchProxy: props.enableFetchProxy
+        },
+        ...window.TSCIRCUIT_USE_RUNFRAME_FOR_CLI && {
+          disableCdnLoading: true
+        },
+        ...props.tscircuitSessionToken && {
+          tscircuitSessionToken: props.tscircuitSessionToken
+        },
+        ...props.easyEdaProxyConfig && {
+          easyEdaProxyConfig: props.easyEdaProxyConfig
+        }
+      });
+      return { worker, evalVersion };
+    })();
+    workerCreationRef.current = pending;
+    const clearPending = () => {
+      if (workerCreationRef.current === pending)
+        workerCreationRef.current = null;
+    };
+    void pending.then(clearPending, clearPending);
+    return pending;
+  };
   const activeEffectName = Object.values(activeAsyncEffects).sort(
     (a, b) => a.startTime - b.startTime
   )[0]?.effectName;
@@ -363,6 +418,7 @@ var RunFrame = (props) => {
     props.onRunCompleted?.(payload);
   };
   useEffect(() => {
+    if (isStaticCircuitJson) return;
     const handleKeyDown = (e) => {
       if ((e.ctrlKey || e.metaKey) && e.key === "Enter" && !isRunning) {
         e.preventDefault();
@@ -372,46 +428,23 @@ var RunFrame = (props) => {
     };
     window.addEventListener("keydown", handleKeyDown, { capture: true });
     return () => window.removeEventListener("keydown", handleKeyDown, { capture: true });
-  }, [isRunning]);
+  }, [isRunning, isStaticCircuitJson]);
   useEffect(() => {
+    if (isStaticCircuitJson) return;
     let cancelled = false;
     const load = async () => {
       try {
         if (!globalThis.runFrameWorker) {
-          const evalVersion = await resolveEvalVersion(
-            props.evalVersion,
-            props.forceLatestEvalVersion
-          );
-          const worker = await createCircuitWebWorker({
-            evalVersion,
-            webWorkerBlobUrl: props.evalWebWorkerBlobUrl,
-            projectConfig: getRunFrameProjectConfig({
-              projectBaseUrl: props.projectBaseUrl || `${API_BASE}/files/static`
-            }),
-            ...props.platformConfig && {
-              platform: props.platformConfig
-            },
-            verbose: true,
-            ...props.enableFetchProxy && {
-              enableFetchProxy: props.enableFetchProxy
-            },
-            ...window.TSCIRCUIT_USE_RUNFRAME_FOR_CLI && {
-              disableCdnLoading: true
-            },
-            ...props.tscircuitSessionToken && {
-              tscircuitSessionToken: props.tscircuitSessionToken
-            },
-            ...props.easyEdaProxyConfig && {
-              easyEdaProxyConfig: props.easyEdaProxyConfig
-            }
-          });
-          if (cancelled) return;
+          const { worker, evalVersion } = await getWorker();
+          if (cancelled || !componentActiveRef.current) return;
           globalThis.runFrameWorker = worker;
           setLastRunEvalVersion(evalVersion);
         }
         if (!cancelled) setDependenciesLoaded(true);
       } catch (err) {
-        console.error("Failed to preload eval worker", err);
+        if (!cancelled && componentActiveRef.current) {
+          console.error("Failed to preload eval worker", err);
+        }
       }
     };
     load();
@@ -419,6 +452,7 @@ var RunFrame = (props) => {
       cancelled = true;
     };
   }, [
+    isStaticCircuitJson,
     props.evalVersion,
     props.evalWebWorkerBlobUrl,
     props.forceLatestEvalVersion,
@@ -441,14 +475,14 @@ var RunFrame = (props) => {
   useEffect(() => {
     if (props.debug) Debug.enable("run-frame*");
   }, [props.debug]);
-  const fsMap = props.fsMap instanceof Map ? props.fsMap : Object.entries(props.fsMap ?? {}).reduce(
-    (m, [k, v]) => m.set(k, v),
-    /* @__PURE__ */ new Map()
+  const fsMap = useMemo2(
+    () => props.fsMap instanceof Map ? props.fsMap : new Map(Object.entries(props.fsMap ?? {})),
+    [props.fsMap]
   );
   const lastFsMapRef = useRef2(null);
   const lastEntrypointRef = useRef2(null);
+  const lastStaticResultRef = useRef2(null);
   const {
-    isStaticCircuitJson,
     circuitJson: circuitJsonFileParsedContent,
     error: circuitJsonFileError
   } = useCircuitJsonFile({
@@ -456,19 +490,50 @@ var RunFrame = (props) => {
     fsMap
   });
   useEffect(() => {
-    if (!isStaticCircuitJson) return;
+    if (!isStaticCircuitJson) {
+      lastStaticResultRef.current = null;
+      return;
+    }
+    if (props.isLoadingFiles) return;
+    const result = circuitJsonFileParsedContent ?? circuitJsonFileError;
+    if (result === lastStaticResultRef.current) return;
+    lastStaticResultRef.current = result;
     if (circuitJsonFileParsedContent) {
+      props.onRenderStarted?.();
       setCircuitJson(circuitJsonFileParsedContent);
       setError(null);
+      props.onCircuitJsonChange?.(circuitJsonFileParsedContent);
+      props.onInitialRender?.({ circuitJson: circuitJsonFileParsedContent });
+      emitRunCompleted(
+        buildRunCompletedPayload({ circuitJson: circuitJsonFileParsedContent })
+      );
+      props.onRenderFinished?.({ circuitJson: circuitJsonFileParsedContent });
     } else if (circuitJsonFileError) {
+      setCircuitJson(null);
       setError({ error: circuitJsonFileError, stack: "" });
+      const error2 = new Error(circuitJsonFileError);
+      props.onError?.(error2);
+      emitRunCompleted(buildRunCompletedPayload({ executionError: error2 }));
     }
-  }, [isStaticCircuitJson, circuitJsonFileParsedContent, circuitJsonFileError]);
+  }, [
+    isStaticCircuitJson,
+    circuitJsonFileParsedContent,
+    circuitJsonFileError,
+    props.isLoadingFiles
+  ]);
   useEffect(() => {
-    if (props.isLoadingFiles) return;
-    if (isStaticCircuitJson) return;
+    if (isStaticCircuitJson || props.isLoadingFiles) {
+      autoroutingCaptureGeneration.current += 1;
+      cancelExecutionRef.current?.();
+      cancelExecutionRef.current = null;
+      setIsRunning(false);
+      setActiveAsyncEffects({});
+      if (props.isLoadingFiles) setCircuitJson(null);
+      return;
+    }
     const fsMapObj = fsMap instanceof Map ? Object.fromEntries(fsMap.entries()) : fsMap;
     if (!fsMapObj || Object.keys(fsMapObj).length === 0) {
+      setCircuitJson(null);
       setError({
         error: "No files provided. Please provide at least one file with code to execute.",
         stack: ""
@@ -495,50 +560,29 @@ var RunFrame = (props) => {
     lastEntrypointRef.current = props.entrypoint ?? null;
     lastRunCountTriggerRef.current = runCountTrigger;
     setIsRunning(true);
+    let cancelled = false;
+    const captureGeneration = ++autoroutingCaptureGeneration.current;
+    const isCurrentRun = () => componentActiveRef.current && !cancelled && captureGeneration === autoroutingCaptureGeneration.current;
+    let renderResult;
     const runWorker = async () => {
+      if (!isCurrentRun()) return;
       debug("running render worker");
       setError(null);
       setRenderLog(null);
       setActiveAsyncEffects({});
       setSolverEvents([]);
       setAutoroutingPhases([]);
-      const captureGeneration = ++autoroutingCaptureGeneration.current;
       const renderLog2 = { progress: 0, debugOutputs: [] };
-      let cancelled = false;
       cancelExecutionRef.current = () => {
         cancelled = true;
       };
-      const resolvedEvalVersion = await resolveEvalVersion(
-        props.evalVersion,
-        !globalThis.runFrameWorker && props.forceLatestEvalVersion
-      );
+      const { worker, evalVersion: resolvedEvalVersion } = await getWorker();
+      if (!isCurrentRun()) return;
       debug("resolvedEvalVersion", resolvedEvalVersion);
-      const worker = globalThis.runFrameWorker ?? await createCircuitWebWorker({
-        evalVersion: resolvedEvalVersion,
-        webWorkerBlobUrl: props.evalWebWorkerBlobUrl,
-        verbose: true,
-        projectConfig: getRunFrameProjectConfig({
-          projectBaseUrl: props.projectBaseUrl || `${API_BASE}/files/static`
-        }),
-        ...props.platformConfig && {
-          platform: props.platformConfig
-        },
-        ...props.enableFetchProxy && {
-          enableFetchProxy: props.enableFetchProxy
-        },
-        ...window.TSCIRCUIT_USE_RUNFRAME_FOR_CLI && {
-          disableCdnLoading: true
-        },
-        ...props.tscircuitSessionToken && {
-          tscircuitSessionToken: props.tscircuitSessionToken
-        },
-        ...props.easyEdaProxyConfig && {
-          easyEdaProxyConfig: props.easyEdaProxyConfig
-        }
-      });
       globalThis.runFrameWorker = worker;
       setLastRunEvalVersion(resolvedEvalVersion);
       await worker.clearEventListeners();
+      if (!isCurrentRun()) return;
       if (currentDebugOption?.trim()) {
         worker.enableDebug(currentDebugOption.replace("DEBUG=", ""));
       }
@@ -638,48 +682,32 @@ var RunFrame = (props) => {
         }
       });
       debug("Executing fsMap...");
-      const evalResult = await worker.executeWithFsMap({
+      await worker.executeWithFsMap({
         entrypoint: props.entrypoint,
         fsMap: fsMapObj2,
         ...props.mainComponentPath ? { mainComponentPath: props.mainComponentPath } : {}
-      }).then(() => {
-        return { success: true };
-      }).catch((e) => {
-        const message = e.message.replace("Error: ", "");
-        debug(`eval error: ${message}`);
-        props.onError?.(e);
-        emitRunCompleted(buildRunCompletedPayload({ executionError: e }));
-        setError({ error: message, stack: e.stack });
-        setRenderLog(null);
-        console.error(e);
-        return { success: false };
       });
+      if (!isCurrentRun()) return;
       debug("worker call started");
-      if (!evalResult.success) {
-        setIsRunning(false);
-        setActiveAsyncEffects({});
-        return;
-      }
-      const $renderResult = worker.renderUntilSettled();
+      const settlement = worker.renderUntilSettled().then(
+        () => ({ success: true }),
+        (error2) => ({ success: false, error: error2 })
+      );
+      renderResult = settlement;
       debug("waiting for initial circuit json...");
-      let circuitJson2 = await worker.getCircuitJson().catch((e) => {
-        debug("error getting initial circuit json", e);
-        props.onError?.(e);
-        emitRunCompleted(buildRunCompletedPayload({ executionError: e }));
-        setError({ error: e.message, stack: e.stack });
-        setRenderLog(null);
-        setIsRunning(false);
-        setActiveAsyncEffects({});
-        return null;
-      });
-      if (!circuitJson2) return;
+      let circuitJson2 = await worker.getCircuitJson();
+      if (!isCurrentRun()) return;
+      if (!circuitJson2) throw new Error("Eval worker returned no Circuit JSON");
       debug("got initial circuit json");
       setCircuitJson(circuitJson2);
       props.onCircuitJsonChange?.(circuitJson2);
       props.onInitialRender?.({ circuitJson: circuitJson2 });
-      await $renderResult;
+      const settled = await settlement;
+      if (!isCurrentRun()) return;
+      if (!settled.success) throw settled.error;
       debug("getting final circuit json");
       circuitJson2 = await worker.getCircuitJson();
+      if (!isCurrentRun()) return;
       props.onCircuitJsonChange?.(circuitJson2);
       setCircuitJson(circuitJson2);
       emitRunCompleted(buildRunCompletedPayload({ circuitJson: circuitJson2 }));
@@ -699,7 +727,29 @@ var RunFrame = (props) => {
       setCurrentDebugOption("");
       cancelExecutionRef.current = null;
     };
-    runMutex.runWithMutex(runWorker);
+    void runMutex.runWithMutex(async () => {
+      try {
+        await runWorker();
+      } finally {
+        await renderResult;
+      }
+    }).catch((failure) => {
+      if (!isCurrentRun()) return;
+      const error2 = failure instanceof Error ? failure : new Error(String(failure));
+      debug("worker execution failed", error2);
+      props.onError?.(error2);
+      emitRunCompleted(buildRunCompletedPayload({ executionError: error2 }));
+      setCircuitJson(null);
+      setError({
+        error: error2.message.replace("Error: ", ""),
+        stack: error2.stack
+      });
+      setRenderLog(null);
+      setIsRunning(false);
+      setActiveAsyncEffects({});
+      setCurrentDebugOption("");
+      cancelExecutionRef.current = null;
+    });
   }, [
     props.fsMap,
     props.entrypoint,
@@ -803,7 +853,7 @@ var RunFrame = (props) => {
       children: /* @__PURE__ */ jsx3(
         CircuitJsonPreview,
         {
-          code: fsMap.get(props.entrypoint ?? props.mainComponentPath),
+          code: fsMap.get(props.entrypoint ?? props.mainComponentPath ?? ""),
           fsMap,
           defaultActiveTab: props.defaultActiveTab ?? props.defaultTab,
           defaultTab: props.defaultTab,
@@ -1050,7 +1100,7 @@ var useSyncPageTitle = () => {
 };
 
 // lib/components/RunFrameWithApi/RunFrameWithApi.tsx
-import { useCallback as useCallback4, useEffect as useEffect7, useMemo as useMemo4, useState as useState6 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect7, useMemo as useMemo5, useState as useState6 } from "react";
 
 // lib/utils/get-board-files-from-config.ts
 import { projectConfig } from "@tscircuit/props";
@@ -1094,7 +1144,7 @@ import {
   Folder,
   Save
 } from "lucide-react";
-import { useCallback as useCallback3, useEffect as useEffect6, useMemo as useMemo3, useRef as useRef3, useState as useState5 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect6, useMemo as useMemo4, useRef as useRef3, useState as useState5 } from "react";
 
 // lib/components/ui/command.tsx
 import * as React from "react";
@@ -1536,7 +1586,7 @@ var EnhancedFileSelectorCombobox = ({
       }
     }
   }, [currentFiles, currentFile]);
-  const recentFiles = useMemo3(() => {
+  const recentFiles = useMemo4(() => {
     const validSavedFiles = recentlySavedFiles.filter(
       (file2) => filteredFiles.includes(file2)
     );
@@ -1853,12 +1903,12 @@ var RunFrameWithApi = (props) => {
   const hasReceivedInitialFiles = useHasReceivedInitialFilesLoaded();
   const fsMap = useRunFrameStore((s) => s.fsMap);
   const recentlySavedFiles = useRunFrameStore((s) => s.recentlySavedFiles);
-  const allFiles = useMemo4(() => Array.from(fsMap.keys()), [fsMap]);
-  const projectConfigContent = useMemo4(() => {
+  const allFiles = useMemo5(() => Array.from(fsMap.keys()), [fsMap]);
+  const projectConfigContent = useMemo5(() => {
     const rawConfig = fsMap.get("tscircuit.config.json");
     return typeof rawConfig === "string" ? rawConfig : void 0;
   }, [fsMap]);
-  const boardFiles = useMemo4(
+  const boardFiles = useMemo5(
     () => getBoardFilesFromConfig(allFiles, projectConfigContent),
     [allFiles, projectConfigContent]
   );
@@ -1883,7 +1933,7 @@ var RunFrameWithApi = (props) => {
     [setFavorites]
   );
   const activeFileFilter = props.fileFilter ?? DEFAULT_UI_FILE_FILTER;
-  const visibleBoardFiles = useMemo4(
+  const visibleBoardFiles = useMemo5(
     () => boardFiles.filter(activeFileFilter),
     [boardFiles, activeFileFilter]
   );
@@ -1959,7 +2009,7 @@ var RunFrameWithApi = (props) => {
     startPolling();
     return () => stopPolling();
   }, [startPolling, stopPolling]);
-  const componentProp = useMemo4(
+  const componentProp = useMemo5(
     () => String(componentPath).length > 0 ? {
       mainComponentPath: componentPath
     } : {},
@@ -2068,7 +2118,7 @@ var RunFrameWithApi = (props) => {
 };
 
 // lib/components/RunFrameForCli/RunFrameForCli.tsx
-import { useCallback as useCallback6, useMemo as useMemo5, useState as useState8 } from "react";
+import { useCallback as useCallback6, useMemo as useMemo6, useState as useState8 } from "react";
 
 // lib/components/RunFrameForCli/LoginDialog.tsx
 import { useCallback as useCallback5, useEffect as useEffect8, useRef as useRef4, useState as useState7 } from "react";
@@ -2295,7 +2345,7 @@ var RunFrameForCli = (props) => {
   );
   const evalWebWorkerBlobUrl = props.evalWebWorkerBlobUrl ?? props.workerBlobUrl;
   const cacheApiBaseUrl = props.apiBaseUrl ?? API_BASE;
-  const platformConfig = useMemo5(
+  const platformConfig = useMemo6(
     () => ({
       ...props.platformConfig,
       localCacheEngine: props.platformConfig?.localCacheEngine ?? createCliLocalCacheEngine({ apiBaseUrl: cacheApiBaseUrl })