hyperframes 0.8.189 → 0.8.190

package/dist/{chunk-HXM2ISEK.js → chunk-OAPYPSEB.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-WYCFMNU3.js";
+} from "./chunk-56IOFIYB.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -63,7 +63,7 @@ import {
   sourceTimeAt,
   timeAtSourceTime,
   volumeSegmentSampleCount
-} from "./chunk-BPX7LZG6.js";
+} from "./chunk-DIV37NUE.js";
 import {
   clampAudioGain,
   clipGain,
@@ -1090,7 +1090,6 @@ var BEGINFRAME_ONLY_FLAGS = /* @__PURE__ */ new Set([
 function stripBeginFrameFlags(args) {
   return args.filter((a) => !BEGINFRAME_ONLY_FLAGS.has(a));
 }
-var BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS = 10;
 var BEGINFRAME_PROBE_TIMEOUT_MS = 2e3;
 var BEGINFRAME_PROBE_CLEANUP_TIMEOUT_MS = 250;
 async function awaitBeforeDeadline(operation, deadline, label) {
@@ -1174,7 +1173,8 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
     let bytes = Buffer.alloc(0);
     let isPng = false;
     let attempts = 0;
-    for (attempts = 1; attempts <= BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS; attempts += 1) {
+    while (!isPng && Date.now() < deadline) {
+      attempts += 1;
       const response = await awaitBeforeDeadline(
         client.send("HeadlessExperimental.beginFrame", {
           frameTimeTicks: 1e3 + (attempts - 1) * 33,
@@ -1187,7 +1187,7 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
       const screenshot = response.screenshotData ?? "";
       bytes = screenshot ? Buffer.from(screenshot, "base64") : Buffer.alloc(0);
       isPng = bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
-      if (isPng) break;
+      if (isPng || Date.now() + 10 >= deadline) break;
       await awaitBeforeDeadline(
         new Promise((resolveDelay) => setTimeout(resolveDelay, 10)),
         deadline,
@@ -1196,7 +1196,7 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
     }
     if (!isPng) {
       throw new Error(
-        `beginFrame screenshot returned ${bytes.length} bytes after ${BEGINFRAME_SCREENSHOT_PROBE_ATTEMPTS} attempts with signature ${bytes.length >= 4 ? bytes.subarray(0, 4).toString("hex") : "<empty>"}`
+        `beginFrame screenshot returned ${bytes.length} bytes after ${attempts} attempts in ${Date.now() - started}ms with signature ${bytes.length >= 4 ? bytes.subarray(0, 4).toString("hex") : "<empty>"}`
       );
     }
     await awaitBeforeDeadline(client.detach(), deadline, "CDP detach").catch(() => {
@@ -1691,6 +1691,24 @@ identically under Docker. Consider:
 import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
 import { join as join3 } from "path";
 
+// ../engine/src/services/renderFrameVideoHold.ts
+function holdRenderFrameVideos(ids, renderIdAttr) {
+  const held = new Set(ids);
+  window.__HF_RENDER_FRAME_VIDEO_IDS = ids;
+  const hold = (el) => {
+    if (el instanceof HTMLVideoElement && held.has(el.getAttribute(renderIdAttr) || el.id))
+      el.preload = "none";
+  };
+  new MutationObserver((records) => {
+    for (const record2 of records)
+      for (const node of record2.addedNodes) {
+        if (node.nodeType !== 1) continue;
+        hold(node);
+        for (const video of node.querySelectorAll("video")) hold(video);
+      }
+  }).observe(document, { childList: true, subtree: true });
+}
+
 // ../engine/src/services/drawElementCaptureError.ts
 var DrawElementCaptureError = class extends Error {
   frameIndex;
@@ -2548,15 +2566,17 @@ async function readPageMotionBlur(page) {
     const report = api && typeof api === "object" ? Reflect.get(api, "report") : null;
     const got = typeof report === "function" ? report() : null;
     if (!got || typeof got !== "object") return null;
+    const tier = Reflect.get(got, "tier");
     return {
       state: String(Reflect.get(got, "state")),
       code: String(Reflect.get(got, "reasonCode")),
       movers: Number(Reflect.get(got, "movers")),
-      failedFrames: Number(Reflect.get(got, "failedFrames")) || 0
+      failedFrames: Number(Reflect.get(got, "failedFrames")) || 0,
+      tier: typeof tier === "string" ? tier : null
     };
   });
 }
-var formatPageMotionBlur = (r) => `[motion-blur] ${r.state} reasonCode=${r.code} movers=${r.movers} failedFrames=${r.failedFrames}`;
+var formatPageMotionBlur = (r) => `[motion-blur] ${r.state} reasonCode=${r.code} movers=${r.movers} failedFrames=${r.failedFrames}${r.tier ? ` tier=${r.tier}` : ""}`;
 async function describePageMotionBlur(page) {
   const r = await readPageMotionBlur(page);
   return r && formatPageMotionBlur(r);
@@ -5488,6 +5508,13 @@ async function constructCaptureSession(input) {
     }
   });
   await installMediaRenderIdBridge(page);
+  if (options.skipReadinessVideoIds?.length) {
+    await page.evaluateOnNewDocument(
+      holdRenderFrameVideos,
+      options.skipReadinessVideoIds,
+      MEDIA_RENDER_ID_ATTR
+    );
+  }
   if (useDrawElement) {
     await page.evaluateOnNewDocument(instrumentAcceleratedCanvases);
   }
@@ -14021,6 +14048,9 @@ function clampFadesToDuration(fades, duration) {
   return { fadeIn: fadeIn * scale, fadeOut: fadeOut * scale };
 }
 
+// ../engine/src/services/audioMixer.ts
+import { cpus as cpus2 } from "os";
+
 // ../engine/src/services/aacEncode.ts
 import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname5, join as join11 } from "path";
@@ -15136,6 +15166,7 @@ function escapeExpressionCommas(expression) {
 function legacyFilterScriptOptionIsUnsupported(stderr) {
   return /filter_complex_script/i.test(stderr) && /(?:unrecognized option|option (?:was )?not found)/i.test(stderr);
 }
+var inPrepareSlot = createConcurrencyLimit(Math.max(2, Math.floor(cpus2().length / 2)));
 var MAX_VOLUME_SEGMENTS = 32;
 var VOLUME_SIMPLIFY_EPSILON = 5e-3;
 var STEREO_CHANNEL_FILTER = "pan=stereo|FL=FL+FC|FR=FR+FC";
@@ -15862,216 +15893,220 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
     else signal.addEventListener("abort", () => internalController.abort(), { once: true });
   }
   await Promise.all(
-    elements.map(async (element, index) => {
-      if (effectiveSignal.aborted) {
-        failures.push({
-          stage: "cancelled",
-          reason: "cancelled",
-          owner: "user",
-          retryable: false,
-          elementId: element.id,
-          detail: boundedDetail(`Cancelled audio element ${element.id}`)
-        });
-        return;
-      }
-      try {
-        let srcPath = element.src;
-        let readInPlace = false;
-        if (!isHttpUrl(srcPath)) {
-          srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
-          const remoteUrl = config?.urlByAbsentLocalPath?.get(srcPath);
-          if (remoteUrl) {
-            srcPath = remoteUrl;
-            readInPlace = true;
-          }
-        }
-        if (isHttpUrl(srcPath) && !readInPlace) {
-          try {
-            srcPath = await downloadToTemp(
-              srcPath,
-              workDir,
-              void 0,
-              effectiveSignal,
-              void 0,
-              {
-                onTelemetry: writeUrlDownloadTelemetry
-              }
-            );
-          } catch (err) {
-            failures.push(downloadFailure(err, element.id));
-            return;
-          }
-        }
-        if (!readInPlace && !existsSync11(srcPath)) {
+    elements.map(
+      (element, index) => inPrepareSlot(async () => {
+        if (effectiveSignal.aborted) {
           failures.push({
-            stage: "source",
-            reason: "source_not_found",
+            stage: "cancelled",
+            reason: "cancelled",
             owner: "user",
             retryable: false,
             elementId: element.id,
-            detail: boundedDetail(missingSourceMessage(element.id, element.src, baseDir, srcPath))
+            detail: boundedDetail(`Cancelled audio element ${element.id}`)
           });
           return;
         }
-        if (await isNotMediaPayload(srcPath)) {
-          failures.push({
-            stage: "source",
-            reason: "invalid_media",
-            owner: "user",
-            retryable: false,
-            elementId: element.id,
-            detail: boundedDetail(
-              `Audio element ${element.id} source is a text document (HTML/XML/JSON), not media`
-            )
-          });
-          return;
-        }
-        if (element.end - element.start <= 0) {
-          let metadata;
-          try {
-            metadata = await extractAudioMetadata(
+        try {
+          let srcPath = element.src;
+          let readInPlace = false;
+          if (!isHttpUrl(srcPath)) {
+            srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
+            const remoteUrl = config?.urlByAbsentLocalPath?.get(srcPath);
+            if (remoteUrl) {
+              srcPath = remoteUrl;
+              readInPlace = true;
+            }
+          }
+          if (isHttpUrl(srcPath) && !readInPlace) {
+            try {
+              srcPath = await downloadToTemp(
+                srcPath,
+                workDir,
+                void 0,
+                effectiveSignal,
+                void 0,
+                {
+                  onTelemetry: writeUrlDownloadTelemetry
+                }
+              );
+            } catch (err) {
+              failures.push(downloadFailure(err, element.id));
+              return;
+            }
+          }
+          if (!readInPlace && !existsSync11(srcPath)) {
+            failures.push({
+              stage: "source",
+              reason: "source_not_found",
+              owner: "user",
+              retryable: false,
+              elementId: element.id,
+              detail: boundedDetail(
+                missingSourceMessage(element.id, element.src, baseDir, srcPath)
+              )
+            });
+            return;
+          }
+          if (await isNotMediaPayload(srcPath)) {
+            failures.push({
+              stage: "source",
+              reason: "invalid_media",
+              owner: "user",
+              retryable: false,
+              elementId: element.id,
+              detail: boundedDetail(
+                `Audio element ${element.id} source is a text document (HTML/XML/JSON), not media`
+              )
+            });
+            return;
+          }
+          if (element.end - element.start <= 0) {
+            let metadata;
+            try {
+              metadata = await extractAudioMetadata(
+                srcPath,
+                readInPlace ? { signal: effectiveSignal } : void 0
+              );
+            } catch (err) {
+              failures.push(
+                probeFailure(err instanceof Error ? err.message : String(err), element.id)
+              );
+              return;
+            }
+            const effectiveDuration = timeAtSourceTime(
+              normalizeRateSpec(element.playbackRate),
+              metadata.durationSeconds - element.mediaStart
+            );
+            element.end = element.start + (effectiveDuration > 0 ? effectiveDuration : metadata.durationSeconds);
+          }
+          let audioSrcPath = srcPath;
+          if (element.type === "video") {
+            const extractedPath = join14(workDir, `${element.id}-extracted.wav`);
+            const extractResult = await extractAudioSegment(
               srcPath,
-              readInPlace ? { signal: effectiveSignal } : void 0
+              extractedPath,
+              "extract",
+              element.mediaStart,
+              element.end - element.start,
+              element.playbackRate,
+              effectiveSignal,
+              config
             );
-          } catch (err) {
-            failures.push(
-              probeFailure(err instanceof Error ? err.message : String(err), element.id)
+            if (!extractResult.success) {
+              failures.push(
+                extractResult.failure ? { ...extractResult.failure, elementId: element.id } : {
+                  stage: "extract",
+                  reason: "ffmpeg_failed",
+                  owner: "system",
+                  retryable: false,
+                  elementId: element.id,
+                  detail: boundedDetail(`Audio extract failed for element ${element.id}`)
+                }
+              );
+              return;
+            }
+            audioSrcPath = extractedPath;
+          } else {
+            const trimmedPath = join14(workDir, `${element.id}-trimmed.wav`);
+            const prepResult = await extractAudioSegment(
+              srcPath,
+              trimmedPath,
+              "prepare",
+              element.mediaStart,
+              element.end - element.start,
+              element.playbackRate,
+              effectiveSignal,
+              config
             );
-            return;
+            if (!prepResult.success) {
+              failures.push(
+                prepResult.failure ? { ...prepResult.failure, elementId: element.id } : {
+                  stage: "prepare",
+                  reason: "ffmpeg_failed",
+                  owner: "system",
+                  retryable: false,
+                  elementId: element.id,
+                  detail: boundedDetail(`Audio prepare failed for element ${element.id}`)
+                }
+              );
+              return;
+            }
+            audioSrcPath = trimmedPath;
           }
-          const effectiveDuration = timeAtSourceTime(
-            normalizeRateSpec(element.playbackRate),
-            metadata.durationSeconds - element.mediaStart
-          );
-          element.end = element.start + (effectiveDuration > 0 ? effectiveDuration : metadata.durationSeconds);
-        }
-        let audioSrcPath = srcPath;
-        if (element.type === "video") {
-          const extractedPath = join14(workDir, `${element.id}-extracted.wav`);
-          const extractResult = await extractAudioSegment(
-            srcPath,
-            extractedPath,
-            "extract",
-            element.mediaStart,
+          const chain = element.fxChain ? parseAudioFxChain(element.fxChain) : void 0;
+          const automation = element.automation ? resolveAutomation(parseAutomation(element.automation), chain) : null;
+          const gainBeforeFx = chain !== void 0 && enabledAudioFxNodes(chain).length > 0;
+          const laneKeyframes = automation ? volumeLaneKeyframes(
+            automation,
+            element.start,
             element.end - element.start,
-            element.playbackRate,
-            effectiveSignal,
-            config
-          );
-          if (!extractResult.success) {
-            failures.push(
-              extractResult.failure ? { ...extractResult.failure, elementId: element.id } : {
-                stage: "extract",
-                reason: "ffmpeg_failed",
-                owner: "system",
-                retryable: false,
-                elementId: element.id,
-                detail: boundedDetail(`Audio extract failed for element ${element.id}`)
+            element.volume ?? 1,
+            gainBeforeFx
+          ) : null;
+          const tweened = !laneKeyframes && (element.volumeKeyframes?.length ?? 0) > 0;
+          const envelopeKeyframes = laneKeyframes ?? element.volumeKeyframes;
+          const envelope = envelopeKeyframes && envelopeKeyframes.length > 0 ? {
+            keyframes: envelopeKeyframes,
+            trackStart: element.start,
+            baseVolume: element.volume ?? 1
+          } : null;
+          let bakedEnvelope = false;
+          let tailSeconds = 0;
+          if (chain) {
+            tailSeconds = chainTailSeconds(chain, automation ?? void 0);
+            const fxResult = await applyAudioFxChain(
+              audioSrcPath,
+              chain,
+              join14(workDir, `${element.id}-fx.wav`),
+              {
+                trackId: element.id,
+                signal: effectiveSignal,
+                ...automation ? { automation } : {},
+                ...envelope ? { envelope } : {},
+                ...gainBeforeFx ? { inputGain: clipGain(element.volume ?? 1, tweened) } : {}
               }
             );
-            return;
+            audioSrcPath = fxResult.path;
+            bakedEnvelope = fxResult.envelopeBaked;
           }
-          audioSrcPath = extractedPath;
-        } else {
-          const trimmedPath = join14(workDir, `${element.id}-trimmed.wav`);
-          const prepResult = await extractAudioSegment(
-            srcPath,
-            trimmedPath,
-            "prepare",
-            element.mediaStart,
-            element.end - element.start,
-            element.playbackRate,
-            effectiveSignal,
-            config
-          );
-          if (!prepResult.success) {
-            failures.push(
-              prepResult.failure ? { ...prepResult.failure, elementId: element.id } : {
-                stage: "prepare",
-                reason: "ffmpeg_failed",
-                owner: "system",
-                retryable: false,
-                elementId: element.id,
-                detail: boundedDetail(`Audio prepare failed for element ${element.id}`)
-              }
+          if (envelope && !bakedEnvelope) {
+            bakedEnvelope = applyVolumeEnvelopeToWav(
+              audioSrcPath,
+              envelope.keyframes,
+              envelope.trackStart,
+              envelope.baseVolume
             );
-            return;
           }
-          audioSrcPath = trimmedPath;
-        }
-        const chain = element.fxChain ? parseAudioFxChain(element.fxChain) : void 0;
-        const automation = element.automation ? resolveAutomation(parseAutomation(element.automation), chain) : null;
-        const gainBeforeFx = chain !== void 0 && enabledAudioFxNodes(chain).length > 0;
-        const laneKeyframes = automation ? volumeLaneKeyframes(
-          automation,
-          element.start,
-          element.end - element.start,
-          element.volume ?? 1,
-          gainBeforeFx
-        ) : null;
-        const tweened = !laneKeyframes && (element.volumeKeyframes?.length ?? 0) > 0;
-        const envelopeKeyframes = laneKeyframes ?? element.volumeKeyframes;
-        const envelope = envelopeKeyframes && envelopeKeyframes.length > 0 ? {
-          keyframes: envelopeKeyframes,
-          trackStart: element.start,
-          baseVolume: element.volume ?? 1
-        } : null;
-        let bakedEnvelope = false;
-        let tailSeconds = 0;
-        if (chain) {
-          tailSeconds = chainTailSeconds(chain, automation ?? void 0);
-          const fxResult = await applyAudioFxChain(
-            audioSrcPath,
-            chain,
-            join14(workDir, `${element.id}-fx.wav`),
-            {
-              trackId: element.id,
-              signal: effectiveSignal,
-              ...automation ? { automation } : {},
-              ...envelope ? { envelope } : {},
-              ...gainBeforeFx ? { inputGain: clipGain(element.volume ?? 1, tweened) } : {}
-            }
-          );
-          audioSrcPath = fxResult.path;
-          bakedEnvelope = fxResult.envelopeBaked;
-        }
-        if (envelope && !bakedEnvelope) {
-          bakedEnvelope = applyVolumeEnvelopeToWav(
-            audioSrcPath,
-            envelope.keyframes,
-            envelope.trackStart,
-            envelope.baseVolume
-          );
+          const track = {
+            id: element.id,
+            srcPath: audioSrcPath,
+            start: element.start,
+            end: element.end,
+            mediaStart: element.mediaStart,
+            duration: element.end - element.start,
+            // Gain is already in the samples when baked, so mix at unity.
+            volume: bakedEnvelope || gainBeforeFx && !tweened ? 1 : element.volume ?? 1,
+            volumeKeyframes: bakedEnvelope ? void 0 : envelopeKeyframes ?? void 0,
+            ...element.fadeIn ? { fadeIn: element.fadeIn } : {},
+            ...element.fadeOut ? { fadeOut: element.fadeOut } : {},
+            ...tailSeconds > 0 ? { tailSeconds } : {}
+          };
+          preparedTracks[index] = track;
+        } catch (err) {
+          if (err instanceof AudioFxRenderError) throw err;
+          failures.push({
+            stage: "internal",
+            reason: "internal",
+            owner: "system",
+            retryable: false,
+            elementId: element.id,
+            detail: boundedDetail(
+              `Audio processing failed for element ${element.id}: ${err instanceof Error ? err.message : String(err)}`
+            )
+          });
         }
-        const track = {
-          id: element.id,
-          srcPath: audioSrcPath,
-          start: element.start,
-          end: element.end,
-          mediaStart: element.mediaStart,
-          duration: element.end - element.start,
-          // Gain is already in the samples when baked, so mix at unity.
-          volume: bakedEnvelope || gainBeforeFx && !tweened ? 1 : element.volume ?? 1,
-          volumeKeyframes: bakedEnvelope ? void 0 : envelopeKeyframes ?? void 0,
-          ...element.fadeIn ? { fadeIn: element.fadeIn } : {},
-          ...element.fadeOut ? { fadeOut: element.fadeOut } : {},
-          ...tailSeconds > 0 ? { tailSeconds } : {}
-        };
-        preparedTracks[index] = track;
-      } catch (err) {
-        if (err instanceof AudioFxRenderError) throw err;
-        failures.push({
-          stage: "internal",
-          reason: "internal",
-          owner: "system",
-          retryable: false,
-          elementId: element.id,
-          detail: boundedDetail(
-            `Audio processing failed for element ${element.id}: ${err instanceof Error ? err.message : String(err)}`
-          )
-        });
-      }
-    })
+      }, effectiveSignal)
+    )
   ).catch((err) => {
     internalController.abort();
     try {
@@ -16254,7 +16289,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 }
 
 // ../engine/src/services/parallelCoordinator.ts
-import { cpus as cpus2, freemem } from "os";
+import { cpus as cpus3, freemem } from "os";
 import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
 import { join as join16 } from "path";
@@ -16369,7 +16404,7 @@ var MIN_WORKERS = 1;
 var MAX_WORKER_DIAGNOSTIC_LINES = 8;
 var ABSOLUTE_MAX_WORKERS = 24;
 function defaultSafeMaxWorkers() {
-  return Math.max(6, Math.min(16, Math.floor(cpus2().length / 8)));
+  return Math.max(6, Math.min(16, Math.floor(cpus3().length / 8)));
 }
 var MIN_FRAMES_PER_WORKER = 30;
 function shouldDisableBrowserPoolForParallelWorker({
@@ -16409,7 +16444,7 @@ function formatWorkerFailure(result) {
   return `${base}; diagnostics: ${diagnostics}`;
 }
 function computeWorkerSizing(totalFrames, requested, config) {
-  const cpuCount = cpus2().length;
+  const cpuCount = cpus3().length;
   const totalMemoryMb = getSystemTotalMb();
   const heapLimitMb = Math.round(getHeapStatistics().heap_size_limit / (1024 * 1024));
   const heapBasedWorkers = Math.max(
@@ -16964,7 +16999,7 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
 }
 function getSystemResources() {
   return {
-    cpuCores: cpus2().length,
+    cpuCores: cpus3().length,
     totalMemoryMB: getSystemTotalMb(),
     freeMemoryMB: Math.round(freemem() / (1024 * 1024)),
     recommendedWorkers: calculateOptimalWorkers(1e3)

package/dist/{chunk-IPEP346Y.js → chunk-OOAVKK2W.js}

@@ -8,7 +8,7 @@ import {
   flush,
   shouldTrack,
   trackEvent
-} from "./chunk-T37XXYRK.js";
+} from "./chunk-TTZTGXKG.js";
 import {
   CliRuntimeError
 } from "./chunk-JVBRJMOP.js";

package/dist/{chunk-37EPEFXM.js → chunk-OTQXYTQZ.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-K2FLNJVB.js";
 import {
   trackCommandFailure
-} from "./chunk-IPEP346Y.js";
+} from "./chunk-OOAVKK2W.js";
 import {
   failCommand
 } from "./chunk-JVBRJMOP.js";

package/dist/{chunk-JZDVIDFH.js → chunk-R4QASDTN.js}

@@ -20,7 +20,7 @@ import {
   typeDirPath,
   updateRecord,
   withFigmaErrors
-} from "./chunk-E7TI5PAQ.js";
+} from "./chunk-YT5VLUHM.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -229,7 +229,7 @@ var asset_default = defineCommand({
           rendered > 0 ? `(${results.length} nodes, ${rendered} rendered in 1 figma request)` : `(${results.length} nodes, all reused from cache \u2014 no figma request)`
         );
       }
-      const { trackFigmaImport } = await import("./telemetry-BEVI64BB.js");
+      const { trackFigmaImport } = await import("./telemetry-K3AFDKOP.js");
       trackFigmaImport({
         phase: "asset",
         reused: results.every((r) => r.reused),

package/dist/{chunk-TFUAKV6O.js → chunk-RBGNU7VD.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   setHostHandlesSigint
-} from "./chunk-HXM2ISEK.js";
+} from "./chunk-OAPYPSEB.js";
 import {
   processAncestorSnapshot,
   processIdentity,

package/dist/{chunk-2CYM34M7.js → chunk-RDHEG7RX.js}

@@ -11,13 +11,13 @@ import {
   isAllowedHtmlAttribute,
   isSafeAttributeValue,
   sanitizeRichTextChildren
-} from "./chunk-WYCFMNU3.js";
+} from "./chunk-56IOFIYB.js";
 import {
   EXCLUDED_TAGS,
   ensureHfIds,
   mintHfId,
   walkCompositionDescendants
-} from "./chunk-SMF6YAUL.js";
+} from "./chunk-TSQAPPRS.js";
 import {
   decodedUrlPath,
   removeElementWithGsapCascade