@tscircuit/runframe 0.0.438 → 0.0.439

package/dist/{chunk-DLF7C7PM.js → chunk-UDQFHNUB.js}

@@ -1092,7 +1092,7 @@ var RenderLogViewer = ({
 };
 
 // package.json
-var version = "0.0.437";
+var version = "0.0.438";
 
 // lib/components/CircuitJsonPreview/CircuitJsonPreview.tsx
 import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
@@ -1194,7 +1194,7 @@ var CircuitJsonPreview = ({
                       !leftHeaderContent && isRunningCode && /* @__PURE__ */ jsx16(Loader2, { className: "rf-w-4 rf-h-4 rf-animate-spin" }),
                       !leftHeaderContent && /* @__PURE__ */ jsx16("div", { className: "rf-flex-grow" }),
                       renderLog && renderLog.progress !== 1 && /* @__PURE__ */ jsxs12("div", { className: "rf-flex rf-items-center rf-gap-2", children: [
-                        renderLog.lastRenderEvent && /* @__PURE__ */ jsx16("div", { className: "rf-text-xs rf-text-gray-500", children: renderLog.lastRenderEvent?.type.split("renderable:renderLifecycle:")[1].split(":")[0] }),
+                        renderLog.lastRenderEvent && /* @__PURE__ */ jsx16("div", { className: "rf-text-xs rf-text-gray-500", children: renderLog.lastRenderEvent?.phase ?? "" }),
                         /* @__PURE__ */ jsx16("div", { className: "rf-w-4 rf-h-4 rf-bg-blue-500 rf-opacity-50 rf-rounded-full rf-text-white", children: /* @__PURE__ */ jsx16(LoaderCircleIcon, { className: "rf-w-4 rf-h-4 rf-animate-spin" }) }),
                         /* @__PURE__ */ jsxs12("div", { className: "rf-text-xs rf-font-bold rf-text-gray-700 rf-tabular-nums", children: [
                           ((renderLog.progress ?? 0) * 100).toFixed(1),

package/dist/preview.d.ts

@@ -9,13 +9,14 @@ export { CadViewer } from '@tscircuit/3d-viewer';
 export { SchematicViewer } from '@tscircuit/schematic-viewer';
 
 type RenderEvent = {
-    type: `renderable:renderLifecycle:${string}:start` | `renderable:renderLifecycle:${string}:end`;
+    type: `renderable:renderLifecycle:${string}:start` | `renderable:renderLifecycle:${string}:end` | `board:renderPhaseStarted`;
     /**
      * Corresponds to the element that was rendered
      */
     renderId: string;
     eventsProcessed: number;
     createdAt: number;
+    phase?: string;
 };
 interface RenderLog {
     lastRenderEvent?: RenderEvent;

package/dist/preview.js

@@ -8,7 +8,7 @@ import {
   linkify,
   useOrderDialog,
   useOrderDialogCli
-} from "./chunk-DLF7C7PM.js";
+} from "./chunk-UDQFHNUB.js";
 export {
   BomTable,
   CadViewer,

package/dist/runner.js

@@ -26,13 +26,16 @@ import {
   useOrderDialog,
   useOrderDialogCli,
   useRunFrameStore
-} from "./chunk-DLF7C7PM.js";
+} from "./chunk-UDQFHNUB.js";
 
 // lib/components/RunFrame/RunFrame.tsx
 import { createCircuitWebWorker } from "@tscircuit/eval/worker";
 import Debug from "debug";
 import { Loader2, Play, Square } from "lucide-react";
 import { useEffect, useReducer, useRef as useRef2, useState } from "react";
+import {
+  orderedRenderPhases as orderedRenderPhases2
+} from "@tscircuit/core";
 
 // lib/render-logging/getPhaseTimingsFromRenderEvents.ts
 import { orderedRenderPhases } from "@tscircuit/core";
@@ -235,23 +238,17 @@ var RunFrame = (props) => {
           }
         });
       });
-      worker.on("renderable:renderLifecycle:anyEvent", (event) => {
+      worker.on("board:renderPhaseStarted", (event) => {
         renderLog2.lastRenderEvent = event;
         renderLog2.eventsProcessed = (renderLog2.eventsProcessed ?? 0) + 1;
-        if (!renderIds.has(event.renderId)) {
-          renderIds.add(event.renderId);
-        }
-        const estTotalRenderEvents = renderIds.size * numRenderPhases * 2;
-        const hasProcessedEnoughToEstimateProgress = renderLog2.eventsProcessed > renderIds.size * 2;
-        const estProgressLinear = renderLog2.eventsProcessed / estTotalRenderEvents;
+        const hasProcessedEnoughToEstimateProgress = renderLog2.eventsProcessed > 2;
+        const estProgressLinear = orderedRenderPhases2.indexOf(event.phase) / numRenderPhases * 0.75 + renderLog2.eventsProcessed / 1e3 * 0.25;
         const estProgress = 1 - Math.exp(-estProgressLinear * 3);
-        renderLog2.progress = hasProcessedEnoughToEstimateProgress ? estProgress : (
-          // Until we have enough events to estimate progress, we use the 0-5%
-          // range and assume that there are ~500 renderIds, this will usually
-          // be an underestimate.
-          (1 - Math.exp(-(renderLog2.eventsProcessed ?? 0) / 1e3)) * 0.05
-        );
-        if (activeTab === "render_log") {
+        renderLog2.progress = estProgress;
+        setRenderLog({ ...renderLog2 });
+      });
+      if (activeTab === "render_log") {
+        worker.on("renderable:renderLifecycle:anyEvent", (event) => {
           renderLog2.renderEvents = renderLog2.renderEvents ?? [];
           event.createdAt = Date.now();
           renderLog2.renderEvents.push(event);
@@ -261,9 +258,9 @@ var RunFrame = (props) => {
             );
             lastRenderLogSet = Date.now();
           }
-        }
-        setRenderLog({ ...renderLog2 });
-      });
+          setRenderLog({ ...renderLog2 });
+        });
+      }
       worker.on("autorouting:progress", (event) => {
         setAutoroutingGraphics(event.debugGraphics);
       });