hyperframes 0.8.72 → 0.8.74

package/dist/fontLocalizeCli.js

@@ -17022,7 +17022,7 @@ var require_util = __commonJS({
       return path;
     }
     exports.normalize = normalize;
-    function join62(aRoot, aPath) {
+    function join63(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -17054,7 +17054,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join62;
+    exports.join = join63;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -17227,7 +17227,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join62(urlGenerate(parsed), sourceURL);
+        sourceURL = join63(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -60748,7 +60748,7 @@ async function pollHfReady(page, timeoutMs, intervalMs = 100) {
   State: __hf=${diag.hasHf}, seek=${diag.hasSeek}, player=${diag.hasPlayer}, renderReady=${diag.renderReady}, duration=${diag.duration}`
   );
 }
-async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2e3) {
+async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2e3, onPending) {
   const expression = `(function() {
     var hosts = document.querySelectorAll("[data-composition-id]");
     if (hosts.length === 0) return true;
@@ -60788,7 +60788,7 @@ async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, ge
     })()`);
     return "ready";
   }
-  const missing = await page.evaluate(`(function() {
+  const evaluated = await page.evaluate(`(function() {
     var hosts = document.querySelectorAll("[data-composition-id]");
     var timelines = window.__timelines || {};
     var m = [];
@@ -60797,8 +60797,11 @@ async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, ge
       var id = hosts[i].getAttribute("data-composition-id");
       if (id && !timelines[id]) m.push(id);
     }
-    return m.join(", ");
+    return m;
   })()`);
+  const pendingIds = Array.isArray(evaluated) ? evaluated.map((id) => String(id)) : [];
+  onPending?.(pendingIds);
+  const missing = pendingIds.join(", ");
   if (scriptFailureBail) {
     console.warn(`[FrameCapture] Composition(s) still waiting on the failed script: ${missing}.`);
   } else {
@@ -60912,11 +60915,17 @@ function recordSubTimelineWarning(session, timeoutMs) {
   if (session.subTimelineWaitOutcome === "ready" || !session.subTimelineWaitOutcome) return;
   const scriptFailure = session.subTimelineWaitOutcome === "script_failure";
   const hasRuntimeErrors = session.scriptLoadFailures.some((f) => f.startsWith("runtime-error:"));
+  const pending = session.pendingTimelineIds ?? [];
+  const pendingSuffix = pending.length > 0 ? ` (still unregistered: ${pending.join(", ")})` : "";
   recordCaptureWarnings(session, [
     {
       code: scriptFailure ? "sub_timeline_script_failure" : "sub_timeline_readiness_timeout",
-      message: scriptFailure ? hasRuntimeErrors ? `A sub-composition script threw during execution \u2014 timeline registration never arrived (${session.scriptLoadFailures.join(", ")})` : `A sub-composition timeline script failed to load (${session.scriptLoadFailures.join(", ")})` : `Sub-composition timelines did not become ready within ${timeoutMs}ms`,
-      details: { timeoutMs, sources: [...session.scriptLoadFailures] }
+      message: scriptFailure ? hasRuntimeErrors ? `A sub-composition script threw during execution \u2014 timeline registration never arrived (${session.scriptLoadFailures.join(", ")})` : `A sub-composition timeline script failed to load (${session.scriptLoadFailures.join(", ")})` : `Sub-composition timelines did not become ready within ${timeoutMs}ms${pendingSuffix}. This can be intentional: a composition driven by CSS animations or rAF never registers window.__timelines[id], and marking its host with data-no-timeline skips the wait entirely. Otherwise, a composition that sets up asynchronously must register window.__timelines[id] once setup completes.`,
+      details: {
+        timeoutMs,
+        sources: [...session.scriptLoadFailures],
+        pendingCompositionIds: [...pending]
+      }
     }
   ]);
 }
@@ -61105,7 +61114,11 @@ async function initializeSession(session) {
       page,
       pageReadyTimeout2,
       void 0,
-      () => session.scriptLoadFailures
+      () => session.scriptLoadFailures,
+      void 0,
+      (ids) => {
+        session.pendingTimelineIds = [...ids];
+      }
     );
     logInitPhase(`pollSubCompositionTimelines complete (${session.subTimelineWaitOutcome})`);
     recordSubTimelineWarning(session, pageReadyTimeout2);
@@ -61219,7 +61232,11 @@ async function initializeSession(session) {
     page,
     pageReadyTimeout,
     void 0,
-    () => session.scriptLoadFailures
+    () => session.scriptLoadFailures,
+    void 0,
+    (ids) => {
+      session.pendingTimelineIds = [...ids];
+    }
   );
   logInitPhase(`pollSubCompositionTimelines complete (${session.subTimelineWaitOutcome})`);
   recordSubTimelineWarning(session, pageReadyTimeout);
@@ -63808,13 +63825,42 @@ var init_ffprobe = __esm({
 });
 
 // ../engine/src/utils/renderProvenance.ts
-import { createRequire } from "module";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function resolveOwnVersionFrom(startDir) {
+  let dir = startDir;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    const candidate = join7(dir, "package.json");
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync3(candidate, "utf8"));
+    } catch {
+      pkg = void 0;
+    }
+    if (pkg && typeof pkg.name === "string" && OWN_PACKAGE_NAME.test(pkg.name)) {
+      if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+      reportUnresolved(`found ${pkg.name} at ${candidate} but it declares no version`);
+      return UNRESOLVED_VERSION;
+    }
+    const parent = dirname4(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  reportUnresolved(`no package.json matching ${OWN_PACKAGE_NAME} within ${MAX_WALK_DEPTH} levels`);
+  return UNRESOLVED_VERSION;
+}
+function reportUnresolved(reason) {
+  console.warn(
+    `[renderProvenance] could not resolve the engine version (${reason}); stamping ${PROVENANCE_VERSION_TAG}="${UNRESOLVED_VERSION}". This is a lookup failure, not a version - do not treat it as one.`
+  );
+}
 function readEngineVersion() {
   try {
-    const version2 = createRequire(import.meta.url)("../../package.json").version;
-    return typeof version2 === "string" && version2.length > 0 ? version2 : UNKNOWN_VERSION;
+    return resolveOwnVersionFrom(dirname4(fileURLToPath2(import.meta.url)));
   } catch {
-    return UNKNOWN_VERSION;
+    reportUnresolved("import.meta.url is not a file URL");
+    return UNRESOLVED_VERSION;
   }
 }
 function isMovFamilyContainer(outputPath) {
@@ -63841,7 +63887,7 @@ function readRenderProvenance(tags) {
   if (renderer === "") return null;
   return { renderer, version: readTagCI(tags, PROVENANCE_VERSION_TAG) };
 }
-var PROVENANCE_RENDERER_TAG, PROVENANCE_VERSION_TAG, PROVENANCE_RENDERER_NAME, UNKNOWN_VERSION, PROVENANCE_VERSION;
+var PROVENANCE_RENDERER_TAG, PROVENANCE_VERSION_TAG, PROVENANCE_RENDERER_NAME, UNRESOLVED_VERSION, OWN_PACKAGE_NAME, MAX_WALK_DEPTH, PROVENANCE_VERSION;
 var init_renderProvenance = __esm({
   "../engine/src/utils/renderProvenance.ts"() {
     "use strict";
@@ -63849,7 +63895,9 @@ var init_renderProvenance = __esm({
     PROVENANCE_RENDERER_TAG = "hyperframes_renderer";
     PROVENANCE_VERSION_TAG = "hyperframes_version";
     PROVENANCE_RENDERER_NAME = "hyperframes";
-    UNKNOWN_VERSION = "0.0.0-dev";
+    UNRESOLVED_VERSION = "unresolved";
+    OWN_PACKAGE_NAME = /^(?:hyperframes|@hyperframes\/[^/]+)$/;
+    MAX_WALK_DEPTH = 12;
     PROVENANCE_VERSION = readEngineVersion();
   }
 });
@@ -63863,13 +63911,13 @@ import {
   mkdirSync as mkdirSync2,
   mkdtempSync,
   openSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   readdirSync as readdirSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync2,
   writeSync
 } from "fs";
-import { join as join7, dirname as dirname4, extname } from "path";
+import { join as join8, dirname as dirname5, extname } from "path";
 function appendEncodeTimeoutMessage(error, timedOut, timeoutMs) {
   if (!timedOut) return error;
   return `${error}
@@ -64110,7 +64158,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
 }
 async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config) {
   const startTime = Date.now();
-  const outputDir = dirname4(outputPath);
+  const outputDir = dirname5(outputPath);
   if (!existsSync6(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const files = readdirSync2(framesDir).filter((f) => f.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
@@ -64128,7 +64176,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   if (options.useGpu) {
     gpuEncoder = await getCachedGpuEncoder();
   }
-  const inputPath = join7(framesDir, framePattern);
+  const inputPath = join8(framesDir, framePattern);
   const inputArgs = ["-framerate", fpsToFfmpegArg(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
   const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG.ffmpegEncodeTimeout;
@@ -64175,7 +64223,7 @@ function buildConcatArgs(concatListPath, outputPath) {
 }
 function writeConcatList(dir, inputPaths) {
   concatListSeq += 1;
-  const listPath = join7(dir, `concat-list-${process.pid}-${concatListSeq}.txt`);
+  const listPath = join8(dir, `concat-list-${process.pid}-${concatListSeq}.txt`);
   const body = inputPaths.map((p) => `file '${p.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync2(listPath, body, "utf-8");
   return listPath;
@@ -64185,8 +64233,8 @@ async function concatVideoFiles(inputPaths, outputPath, signal, config) {
   if (firstInput === void 0) {
     return { success: false, error: "concatVideoFiles: no inputs", externalInterruption: false };
   }
-  mkdirSync2(dirname4(outputPath), { recursive: true });
-  const listPath = writeConcatList(dirname4(firstInput), inputPaths);
+  mkdirSync2(dirname5(outputPath), { recursive: true });
+  const listPath = writeConcatList(dirname5(firstInput), inputPaths);
   const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG.ffmpegEncodeTimeout;
   const result = await runFfmpeg(buildConcatArgs(listPath, outputPath), {
     signal,
@@ -64218,8 +64266,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
   }
   const chunkSize = Math.max(30, Math.floor(chunkSizeFrames));
   const chunkCount = Math.ceil(files.length / chunkSize);
-  mkdirSync2(dirname4(outputPath), { recursive: true });
-  const chunkDir = mkdtempSync(join7(dirname4(outputPath), "chunk-encode-"));
+  mkdirSync2(dirname5(outputPath), { recursive: true });
+  const chunkDir = mkdtempSync(join8(dirname5(outputPath), "chunk-encode-"));
   const chunkPaths = [];
   for (let i = 0; i < chunkCount; i++) {
     if (signal?.aborted) {
@@ -64235,8 +64283,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     const startNumber = i * chunkSize;
     const framesInChunk = Math.min(chunkSize, files.length - startNumber);
     const ext = outputPath.endsWith(".webm") ? ".webm" : outputPath.endsWith(".mov") ? ".mov" : ".mp4";
-    const chunkPath = join7(chunkDir, `chunk_${String(i).padStart(4, "0")}${ext}`);
-    const inputPath = join7(framesDir, framePattern);
+    const chunkPath = join8(chunkDir, `chunk_${String(i).padStart(4, "0")}${ext}`);
+    const inputPath = join8(framesDir, framePattern);
     const inputArgs = [
       "-framerate",
       fpsToFfmpegArg(options.fps),
@@ -64295,7 +64343,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
   };
 }
 async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config, fps) {
-  const outputDir = dirname4(outputPath);
+  const outputDir = dirname5(outputPath);
   if (!existsSync6(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const isMov = outputPath.endsWith(".mov");
@@ -64384,14 +64432,14 @@ async function packageHls(videoPath, audioPath, outputDir, options) {
     "-master_pl_name",
     HLS_MASTER_PLAYLIST,
     "-hls_segment_filename",
-    join7(outputDir, "%v_%05d.ts"),
+    join8(outputDir, "%v_%05d.ts"),
     // Without these the mpegts muxer starts the stream at PTS 1.4 s.
     "-muxdelay",
     "0",
     "-muxpreload",
     "0"
   );
-  args.push("-y", join7(outputDir, "%v.m3u8"));
+  args.push("-y", join8(outputDir, "%v.m3u8"));
   const processTimeout = options.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const result = await runFfmpeg(args, { signal, timeout: processTimeout });
   if (signal?.aborted) {
@@ -64403,7 +64451,7 @@ async function packageHls(videoPath, audioPath, outputDir, options) {
     };
   }
   if (result.success && hasAudio) {
-    const masterPath = join7(outputDir, HLS_MASTER_PLAYLIST);
+    const masterPath = join8(outputDir, HLS_MASTER_PLAYLIST);
     let master;
     try {
       master = openSync(masterPath, "r+", 384);
@@ -64412,7 +64460,7 @@ async function packageHls(videoPath, audioPath, outputDir, options) {
     }
     if (master !== void 0) {
       try {
-        const stripped = stripAudioOnlyVariants(readFileSync3(master, "utf-8"));
+        const stripped = stripAudioOnlyVariants(readFileSync4(master, "utf-8"));
         ftruncateSync(master, 0);
         writeSync(master, stripped, 0, "utf-8");
       } finally {
@@ -64546,7 +64594,7 @@ var init_jpegInput = __esm({
 import { spawn as spawn4 } from "child_process";
 import { once } from "events";
 import { existsSync as existsSync7, mkdirSync as mkdirSync3, statSync as statSync3 } from "fs";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname6 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
   let aborted = null;
@@ -64788,7 +64836,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
   return args;
 }
 async function spawnStreamingEncoder(outputPath, options, signal, config) {
-  const outputDir = dirname5(outputPath);
+  const outputDir = dirname6(outputPath);
   if (!existsSync7(outputDir)) mkdirSync3(outputDir, { recursive: true });
   let gpuEncoder = null;
   if (options.useGpu) {
@@ -64950,7 +64998,7 @@ var init_streamingEncoder = __esm({
 
 // ../parsers/dist/assetResolution.js
 import { existsSync as existsSync8 } from "fs";
-import { isAbsolute, join as join8, posix as posix2, relative, resolve as resolve5, sep as sep2 } from "path";
+import { isAbsolute, join as join9, posix as posix2, relative, resolve as resolve5, sep as sep2 } from "path";
 function decodeUrlPathVariants2(path) {
   const variants = [path];
   try {
@@ -64976,11 +65024,11 @@ function isWithinProjectRoot(projectDir, candidate, pathModule = { resolve: reso
 }
 function reanchoredCandidates(variant, baseDir, compiledDir) {
   const baseAbs = resolve5(baseDir);
-  const joinedAbs = resolve5(join8(baseDir, variant));
+  const joinedAbs = resolve5(join9(baseDir, variant));
   if (joinedAbs === baseAbs || joinedAbs.startsWith(baseAbs + sep2)) return [];
   const stripped = posix2.normalize(variant.replace(/\\/g, "/")).replace(/^(\.\.\/)+/, "");
   if (!stripped || stripped === variant || stripped.startsWith("..")) return [];
-  return compiledDir ? [join8(compiledDir, stripped), join8(baseDir, stripped)] : [join8(baseDir, stripped)];
+  return compiledDir ? [join9(compiledDir, stripped), join9(baseDir, stripped)] : [join9(baseDir, stripped)];
 }
 function resolveProjectRelativeSrc(src, baseDir, compiledDir) {
   const cleanSrc = cleanAssetUrl(src);
@@ -64990,10 +65038,10 @@ function resolveProjectRelativeSrc(src, baseDir, compiledDir) {
     for (const candidate of reanchoredCandidates(variant, baseDir, compiledDir)) {
       candidates.add(candidate);
     }
-    if (compiledDir) candidates.add(join8(compiledDir, variant));
-    candidates.add(join8(baseDir, variant));
+    if (compiledDir) candidates.add(join9(compiledDir, variant));
+    candidates.add(join9(baseDir, variant));
   }
-  return [...candidates].find(existsSync8) ?? join8(baseDir, cleanSrc);
+  return [...candidates].find(existsSync8) ?? join9(baseDir, cleanSrc);
 }
 var init_assetResolution = __esm({
   "../parsers/dist/assetResolution.js"() {
@@ -65087,7 +65135,7 @@ import {
 } from "fs";
 import { createHash, randomUUID } from "crypto";
 import { BlockList, isIP } from "net";
-import { dirname as dirname6, extname as extname2, join as join9 } from "path";
+import { dirname as dirname7, extname as extname2, join as join10 } from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 function signalScopeKey(signal) {
@@ -65139,7 +65187,7 @@ function classifyDownloadFailure(error) {
       return new UrlDownloadError(
         "network",
         true,
-        "Download failed due to a transient network error"
+        `Download failed due to a transient network error${describeCause(current2)}`
       );
     }
     current2 = typeof current2 === "object" && current2 !== null && "cause" in current2 ? current2.cause : void 0;
@@ -65147,9 +65195,16 @@ function classifyDownloadFailure(error) {
   return new UrlDownloadError(
     "filesystem",
     false,
-    "Download failed while writing the local artifact"
+    `Download failed while writing the local artifact${describeCause(error)}`
   );
 }
+function describeCause(error) {
+  const name = error instanceof Error && /^[A-Za-z]{1,40}$/.test(error.name) ? error.name : "";
+  const rawCode = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+  const code = typeof rawCode === "string" && /^[A-Z0-9_]{1,40}$/.test(rawCode) ? rawCode : "";
+  const tag = [name, code].filter(Boolean).join(" ");
+  return tag ? ` (${tag})` : "";
+}
 function isRetryableNetworkCause(error) {
   const message = error instanceof Error ? error.message : String(error);
   const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "";
@@ -65215,7 +65270,7 @@ function removeCacheLockDirectoryIfEmpty(lockPath) {
 }
 function releaseOwnedCachePathLock(lockPath, owner) {
   try {
-    rmdirSync(join9(lockPath, owner));
+    rmdirSync(join10(lockPath, owner));
   } catch (error) {
     if (error.code === "ENOENT") return;
     throw error;
@@ -65256,12 +65311,12 @@ async function acquireCachePathLock(localPath, timeoutMs, signal) {
     if (createdLock) {
       const owner = `${CACHE_LOCK_OWNER_PREFIX}${randomUUID()}`;
       try {
-        mkdirSync4(join9(lockPath, owner));
+        mkdirSync4(join10(lockPath, owner));
         const entries2 = readdirSync3(lockPath);
         if (entries2.length === 1 && entries2[0] === owner) {
           return () => releaseOwnedCachePathLock(lockPath, owner);
         }
-        rmdirSync(join9(lockPath, owner));
+        rmdirSync(join10(lockPath, owner));
         removeCacheLockDirectoryIfEmpty(lockPath);
         continue;
       } catch (error) {
@@ -65279,7 +65334,7 @@ async function acquireCachePathLock(localPath, timeoutMs, signal) {
     if (Date.now() - observedLock.stats.mtimeMs > CACHE_LOCK_STALE_MS) {
       if (observedLock.owner) {
         try {
-          rmdirSync(join9(lockPath, observedLock.owner));
+          rmdirSync(join10(lockPath, observedLock.owner));
         } catch (error) {
           if (error.code === "ENOENT") continue;
           throw error;
@@ -65287,7 +65342,7 @@ async function acquireCachePathLock(localPath, timeoutMs, signal) {
         removeCacheLockDirectoryIfEmpty(lockPath);
         continue;
       }
-      const reclaimPath = join9(lockPath, CACHE_LOCK_RECLAIM_NAME);
+      const reclaimPath = join10(lockPath, CACHE_LOCK_RECLAIM_NAME);
       try {
         mkdirSync4(reclaimPath);
       } catch (error) {
@@ -65725,8 +65780,8 @@ function emitDownloadTelemetry(options, event) {
   }
 }
 async function runDownloadAttempt(url, localPath, timeoutMs, attempt, options, signal) {
-  const attemptDir = mkdtempSync2(join9(dirname6(localPath), ".hf-download-"));
-  const partialPath = join9(attemptDir, "payload");
+  const attemptDir = mkdtempSync2(join10(dirname7(localPath), ".hf-download-"));
+  const partialPath = join10(attemptDir, "payload");
   const controller = new AbortController();
   let timedOut = false;
   let callerAborted = signal?.aborted ?? false;
@@ -65962,7 +66017,7 @@ async function downloadToTemp(url, destDir, timeoutMs = 3e5, signal, onTransient
     mkdirSync4(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url, validationScope);
-  const localPath = join9(destDir, filename);
+  const localPath = join10(destDir, filename);
   const downloadPromise = (async () => {
     const cacheStartedAt = Date.now();
     const reused = await reuseOrInvalidateCachedFile(
@@ -74060,6 +74115,80 @@ function rootClassStyledSelectors(styles, rootClasses) {
   }
   return offenders;
 }
+function isIdentityZoom(rawValue) {
+  const value = rawValue.trim().replace(/!\s*important\s*$/i, "").trim().toLowerCase();
+  return value === "" || value === "normal" || value === "unset" || value === "initial" || value === "revert" || value === "1" || value === "1.0" || value === "100%";
+}
+function firstRescalingZoom(css) {
+  ZOOM_DECLARATION.lastIndex = 0;
+  let match;
+  while ((match = ZOOM_DECLARATION.exec(css)) !== null) {
+    const value = (match[1] ?? "").trim();
+    if (!isIdentityZoom(value)) return value.replace(/!\s*important\s*$/i, "").trim();
+  }
+  return null;
+}
+function targetsCanvasRoot(selector, rootId, rootClasses) {
+  const leftmost = selector.trim().split(/[\s>+~]+/)[0] ?? "";
+  const bare = leftmost.toLowerCase();
+  if (bare === "html" || bare === "body" || bare === ":root" || bare === "*") return true;
+  if (rootId && leftmostCompoundId(selector) === rootId) return true;
+  return leftmostCompoundClasses(selector).some((cls) => rootClasses.includes(cls));
+}
+function inlineCanvasZoomHits(rootTag, tags) {
+  const hits = [];
+  const htmlTag = findHtmlTag(tags);
+  const bodyTag = tags.find((tag) => tag.name.toLowerCase() === "body");
+  for (const [label, tag] of [
+    ["the root element's inline style", rootTag],
+    ["<html>'s inline style", htmlTag],
+    ["<body>'s inline style", bodyTag]
+  ]) {
+    if (!tag) continue;
+    const inline = readAttr(tag.raw, "style");
+    const value = inline ? firstRescalingZoom(inline) : null;
+    if (value) hits.push({ where: label, value, snippet: truncateSnippet(tag.raw) });
+  }
+  return hits;
+}
+function firstCanvasSelector(header, rootId, rootClasses) {
+  for (const selector of header.split(",")) {
+    const trimmed = selector.trim();
+    if (trimmed && targetsCanvasRoot(trimmed, rootId, rootClasses)) return trimmed;
+  }
+  return null;
+}
+function canvasZoomInRule(header, body, rootId, rootClasses) {
+  const trimmedHeader = header.trim();
+  if (!trimmedHeader || trimmedHeader.startsWith("@")) return null;
+  const value = firstRescalingZoom(body);
+  if (!value) return null;
+  const selector = firstCanvasSelector(trimmedHeader, rootId, rootClasses);
+  if (!selector) return null;
+  return {
+    where: `\`${selector}\``,
+    value,
+    snippet: truncateSnippet(`${selector} { zoom: ${value} }`)
+  };
+}
+function stylesheetCanvasZoomHits(styles, rootId, rootClasses) {
+  const hits = [];
+  for (const style of styles) {
+    const ruleWithBody = /([^{}]+)\{([^{}]*)\}/g;
+    let match;
+    while ((match = ruleWithBody.exec(stripCssComments(style.content))) !== null) {
+      const hit = canvasZoomInRule(match[1] ?? "", match[2] ?? "", rootId, rootClasses);
+      if (hit) hits.push(hit);
+    }
+  }
+  return hits;
+}
+function canvasZoomHits(rootTag, tags, styles, rootId, rootClasses) {
+  return [
+    ...inlineCanvasZoomHits(rootTag, tags),
+    ...stylesheetCanvasZoomHits(styles, rootId, rootClasses)
+  ];
+}
 function collectDeclaredVariableIds(htmlTagRaw) {
   const declared = /* @__PURE__ */ new Set();
   const raw = readJsonAttr(htmlTagRaw, "data-composition-variables");
@@ -74098,6 +74227,28 @@ function isInsideInertTemplate(tag, tags) {
     (candidate) => candidate.name === "template" && candidate.closeIndex != null && tag.index > candidate.index && tag.index < candidate.closeIndex
   );
 }
+function cssOwnerSelector(content, matchIndex) {
+  const blockStart = content.lastIndexOf("{", matchIndex);
+  if (blockStart === -1) return void 0;
+  const previousBlockEnd = content.lastIndexOf("}", blockStart);
+  const lines = content.slice(previousBlockEnd + 1, blockStart).trim().split("\n");
+  return lines[lines.length - 1]?.trim() || void 0;
+}
+function elementSelector(tag) {
+  const elementId = readAttr(tag.raw, "id");
+  return elementId ? `#${elementId}` : void 0;
+}
+function negativeZIndexFinding(match, selector) {
+  const level = match[1] ?? "";
+  return {
+    code: "negative_z_index",
+    severity: "warning",
+    ...selector ? { selector } : {},
+    message: `\`z-index: -${level}\` paints the element behind its nearest stacking context's own content. With no stacking-context ancestor that context is the composition root itself, so an opaque background there hides it entirely: in the DOM, laid out, and absent from the picture. A transparent root leaves it visible. Siblings at \`z-index: 0\` or above are unaffected.`,
+    fixHint: "Give the element's parent a stacking context - `isolation: isolate` is the cheapest, and `transform`, `filter`, `opacity` below 1, `contain: paint` and `will-change` all work too. The negative-z child then paints above that parent's background and renders normally. Or express paint order through DOM order - an earlier sibling paints behind a later one - and raise the elements that should sit in front rather than lowering this one.",
+    snippet: truncateSnippet(match[0])
+  };
+}
 function deriveDurationFromClips(tags, rootTag) {
   const clipEnds = [];
   for (const tag of tags) {
@@ -75173,7 +75324,7 @@ async function lintHyperframeHtml(html, options = {}) {
     timings: { totalMs: performance.now() - startedAt, ...timings }
   };
 }
-var import_postcss_selector_parser, COMPOSITION_ID_IN_CSS_PATTERN, TIMELINE_REGISTRY_INIT_PATTERN, TIMELINE_REGISTRY_OBJECT_LITERAL_PATTERN, TIMELINE_REGISTRY_ASSIGN_PATTERN, WINDOW_TIMELINE_ASSIGN_PATTERN, INVALID_SCRIPT_CLOSE_PATTERN, TIMELINE_REGISTRY_KEY_PATTERN, TIMELINE_REGISTRY_OBJECT_OPEN_PATTERN, TIMELINE_REGISTRY_OBJECT_ENTRY_PATTERN, REGEX_ALLOWED_BEFORE, REGEX_ALLOWED_KEYWORDS, WORD_CHAR, CodeContext, VISIBLE_MARKUP_COMMENT_PATTERN, VISIBLE_MARKUP_COMMENT_PROTECTED_BLOCK_PATTERN, coreRules, IMAGE_SRC_EXT, VIDEO_SRC_EXT, AUDIO_SRC_EXT, SRC_KIND_NOUN, mediaRules, AUDIO_GROUP_TIMING_ATTRS, callIndexes, MAX_COMPOSITION_LINES, MAX_TIMED_ELEMENTS_PER_TRACK, TRACK_DENSITY_EXEMPT_TAGS, CAPTION_CUE_TOKEN, HEAVY_OVERLAY_ELEMENT_COUNT_WARN, HEAVY_OVERLAY_EXEMPT_TAGS, HEAVY_OVERLAY_CSS_PATTERN, INLINE_STYLE_DISPLAY_NONE_PATTERN, compositionRules, CLIP_MEDIA_TAGS, SCENE_BOUNDARY_EPSILON_SECONDS, UNRESOLVED_TARGET, gsapWindowsCache, CONFLICTING_TRANSLATE_PROPS, CONFLICTING_SCALE_PROPS, RELATIVE_TWEEN_VALUE, TRANSFORM_SENSITIVE_READ, TRANSFORM_INVARIANT_READ, CALLBACK_MEASUREMENT_PATTERN, NUMBER_METHODS, gsapRules, captionRules, adapterRules, TEXTURE_BASE_CLASS, TEXTURE_CLASS_PREFIX, textureRules, GENERIC_FAMILIES, fontRules, slideshowRules, INLINE_TEXT_TAGS, OPAQUE_TAGS, NON_LAYOUT_TAGS, MEDIA_TAGS2, NODE_ATTRS, describe, structureRules, RULE_GROUPS, LINT_RULE_COUNT, LINT_RULE_GROUP_COUNTS;
+var import_postcss_selector_parser, COMPOSITION_ID_IN_CSS_PATTERN, TIMELINE_REGISTRY_INIT_PATTERN, TIMELINE_REGISTRY_OBJECT_LITERAL_PATTERN, TIMELINE_REGISTRY_ASSIGN_PATTERN, WINDOW_TIMELINE_ASSIGN_PATTERN, INVALID_SCRIPT_CLOSE_PATTERN, TIMELINE_REGISTRY_KEY_PATTERN, TIMELINE_REGISTRY_OBJECT_OPEN_PATTERN, TIMELINE_REGISTRY_OBJECT_ENTRY_PATTERN, REGEX_ALLOWED_BEFORE, REGEX_ALLOWED_KEYWORDS, WORD_CHAR, CodeContext, VISIBLE_MARKUP_COMMENT_PATTERN, VISIBLE_MARKUP_COMMENT_PROTECTED_BLOCK_PATTERN, coreRules, IMAGE_SRC_EXT, VIDEO_SRC_EXT, AUDIO_SRC_EXT, SRC_KIND_NOUN, mediaRules, AUDIO_GROUP_TIMING_ATTRS, callIndexes, INSPECTION_VIEWPORT_CAP, MAX_COMPOSITION_LINES, MAX_TIMED_ELEMENTS_PER_TRACK, TRACK_DENSITY_EXEMPT_TAGS, CAPTION_CUE_TOKEN, HEAVY_OVERLAY_ELEMENT_COUNT_WARN, HEAVY_OVERLAY_EXEMPT_TAGS, HEAVY_OVERLAY_CSS_PATTERN, INLINE_STYLE_DISPLAY_NONE_PATTERN, ZOOM_DECLARATION, NEGATIVE_Z_INDEX, compositionRules, CLIP_MEDIA_TAGS, SCENE_BOUNDARY_EPSILON_SECONDS, UNRESOLVED_TARGET, gsapWindowsCache, CONFLICTING_TRANSLATE_PROPS, CONFLICTING_SCALE_PROPS, RELATIVE_TWEEN_VALUE, TRANSFORM_SENSITIVE_READ, TRANSFORM_INVARIANT_READ, CALLBACK_MEASUREMENT_PATTERN, NUMBER_METHODS, gsapRules, captionRules, adapterRules, TEXTURE_BASE_CLASS, TEXTURE_CLASS_PREFIX, textureRules, GENERIC_FAMILIES, fontRules, slideshowRules, INLINE_TEXT_TAGS, OPAQUE_TAGS, NON_LAYOUT_TAGS, MEDIA_TAGS2, NODE_ATTRS, describe, structureRules, RULE_GROUPS, LINT_RULE_COUNT, LINT_RULE_GROUP_COUNTS;
 var init_dist3 = __esm({
   "../lint/dist/index.js"() {
     "use strict";
@@ -76054,6 +76205,7 @@ var init_dist3 = __esm({
     ];
     AUDIO_GROUP_TIMING_ATTRS = ["data-start", "data-duration", "data-track-index"];
     callIndexes = /* @__PURE__ */ new WeakMap();
+    INSPECTION_VIEWPORT_CAP = 4096;
     MAX_COMPOSITION_LINES = 300;
     MAX_TIMED_ELEMENTS_PER_TRACK = 3;
     TRACK_DENSITY_EXEMPT_TAGS = /* @__PURE__ */ new Set(["audio", "script", "style", "video"]);
@@ -76079,6 +76231,8 @@ var init_dist3 = __esm({
     ]);
     HEAVY_OVERLAY_CSS_PATTERN = /(?:filter\s*:[^;}]*\bblur\s*\()|(?:clip-path\s*:(?!\s*(?:none|inherit|initial|unset)\b)\s*[^;}]+)|(?:radial-gradient\s*\()/i;
     INLINE_STYLE_DISPLAY_NONE_PATTERN = /(?:^|;)\s*display\s*:\s*none\b/i;
+    ZOOM_DECLARATION = /(?<![\w-])zoom\s*:\s*([^;}]+)/gi;
+    NEGATIVE_Z_INDEX = /(?<![\w-])z-index\s*:\s*-(?!0(?:\s*[;}]|\s*$))([\d.]+)/g;
     compositionRules = [
       // duplicate_composition_id catches meta-tag/root collisions that create duplicate composition entries.
       ({ tags }) => {
@@ -76369,6 +76523,59 @@ var init_dist3 = __esm({
           }
         ];
       },
+      // negative_z_index
+      // An element at a negative z-index is silently absent from both `snapshot`
+      // and `render`, while siblings differing only in the sign of z-index render
+      // exactly (heygen-com/hyperframes#4366). lint, validate and render all exit 0
+      // and report nothing, so the first suspicion falls on the author's own CSS.
+      // NOT A RENDERER DEFECT -- ORDINARY CSS PAINTING ORDER, measured at 0.8.72.
+      // The element is PAINTED; it is simply painted beneath something opaque. Remove
+      // every opaque background above it and the same `z-index: -1` band renders at
+      // full coverage, identically to the same band with `z-index` deleted. A negative-z
+      // descendant paints at step 2 of its nearest stacking context -- above that
+      // context root's own background, but below the context's positioned in-flow
+      // content -- so a `position: relative` composition root with an opaque background
+      // paints over it. That is the shape #4366 reports; nothing is dropped and the
+      // renderer has no say in it.
+      //
+      // Kept as a warning because authors hit it and nothing explains why: the element
+      // is in the DOM, laid out, and invisible. The message therefore names the CAUSE
+      // and the remedy rather than implying the tool failed.
+      //
+      // THE CONDITION IS LOAD-BEARING AND THE MESSAGE STATES IT. The element is only
+      // dropped when its nearest ancestor stacking context is the composition root,
+      // which is the shape #4366 reports. Give any ancestor a stacking context and it
+      // renders correctly: measured at 0.8.72 on ONE frame carrying the same
+      // `z-index: -1` band under six triggers -- isolation:isolate, transform,
+      // opacity below 1, filter, contain:paint, will-change -- all six PRESENT at full
+      // coverage, against the no-stacking-context control ABSENT at zero coverage.
+      // That is ordinary CSS painting order: a negative-z child paints above its
+      // stacking context root's own background, so only the root case is hidden.
+      //
+      // This rule matches CSS TEXT and does not resolve the cascade, so it cannot know
+      // whether an ancestor forms a stacking context and fires on both shapes. That is
+      // why the message is CONDITIONAL rather than an assertion of absence: an
+      // unconditional "silently dropped" is false for every isolated case, and a lint
+      // message that overclaims is how authors learn to disregard the rule.
+      ({ tags, styles }) => {
+        const findings = [];
+        for (const style of styles) {
+          const content = stripCssComments(style.content);
+          NEGATIVE_Z_INDEX.lastIndex = 0;
+          let match;
+          while ((match = NEGATIVE_Z_INDEX.exec(content)) !== null) {
+            findings.push(negativeZIndexFinding(match, cssOwnerSelector(content, match.index)));
+          }
+        }
+        for (const tag of tags) {
+          const inline = readAttr(tag.raw, "style");
+          if (!inline) continue;
+          NEGATIVE_Z_INDEX.lastIndex = 0;
+          const match = NEGATIVE_Z_INDEX.exec(inline);
+          if (match) findings.push(negativeZIndexFinding(match, elementSelector(tag)));
+        }
+        return findings;
+      },
       // requestanimationframe_in_composition
       ({ scripts, rawSource, options }) => {
         if (isRegistrySourceFile(options.filePath) || isRegistryInstalledFile(rawSource)) return [];
@@ -76788,6 +76995,96 @@ ${allInlineStyles}`.replace(/\/\*[\s\S]*?\*\//g, "");
             fixHint: `${splitTarget} and concat the pieces (FFmpeg or the runtime's slideshow) so each capture only sees a small subset of heavy overlays at once. Even hidden overlays (opacity:0 / visibility:hidden) contribute \u2014 either remove truly unused ones from the source or scope them into their own per-transition sub-composition. If an overlay is genuinely inert for the whole clip, use display:none so it never enters the render tree. Field ref ts=1784040753 (#hyperframes-cli-feedback).`
           }
         ];
+      },
+      // root_zoom_rescales_a_fixed_canvas
+      //
+      // The capture frame is sized from the root's data-width/data-height, which are
+      // LAYOUT pixels. CSS `zoom` on the canvas itself (the root, or html/body above
+      // it) rescales the painted content inside that frame without changing the frame,
+      // so the two disagree and the author gets neither of the two things they might
+      // have meant.
+      //
+      // Measured at 0.8.71 on an 800x400 composition holding two 100x100 boxes at
+      // left:100 and left:600, rendered to a PNG sequence and the boxes located by
+      // colour:
+      //
+      //   root zoom:0.5  canvas stays 800x400; boxes paint at (50,25) and (300,25),
+      //                  each 50x50 -- the composition occupies the top-left quarter
+      //                  and the rest of every frame is dead space.
+      //   root zoom:2    canvas stays 800x400; the left:100 box paints at (200,100)
+      //                  at 200x200, and the left:600 box renders ZERO PIXELS --
+      //                  scaled to x=1200, outside a frame that is still 800 wide.
+      //
+      // The second case is the one worth an error: content that is inside the declared
+      // composition silently does not exist in the output, with nothing else in lint,
+      // check or the render log naming it.
+      //
+      // Deliberately NOT flagged: `zoom` on a descendant. Measured in the same run --
+      // a child at left:100 with zoom:2 paints at (200,100) at 200x200, which is
+      // exactly what CSS `zoom` specifies. It is honoured, not ignored, so a rule that
+      // fired on every `zoom` would be flagging correct authoring.
+      ({ rootTag, tags, styles }) => {
+        if (!rootTag) return [];
+        const rootId = readAttr(rootTag.raw, "id");
+        const rootClasses = (readAttr(rootTag.raw, "class") || "").split(/\s+/).filter(Boolean);
+        const hits = canvasZoomHits(rootTag, tags, styles, rootId, rootClasses);
+        const hit = hits[0];
+        if (!hit) return [];
+        const enlarging = !hit.value.startsWith("-") && parseFloat(hit.value) > (hit.value.includes("%") ? 100 : 1);
+        return [
+          {
+            code: "root_zoom_rescales_a_fixed_canvas",
+            severity: "error",
+            message: `\`zoom: ${hit.value}\` on ${hit.where} rescales the painted composition inside a frame that does not rescale with it. The capture frame is sized from the root's data-width/data-height in LAYOUT pixels, and \`zoom\` changes only what is painted inside it, so ` + (enlarging ? `content past the frame's edge renders zero pixels \u2014 it is inside the declared composition and absent from the output, with nothing else reporting it.` : `the composition paints into part of the frame and the remainder of every output frame is dead space.`),
+            fixHint: `Author the composition at its real size \u2014 set data-width/data-height (and the root's width/height) to the dimensions you want \u2014 and drop the canvas-level \`zoom\`. To scale the OUTPUT without changing layout, pass \`--output-resolution\` to render, which supersamples. \`zoom\` on descendants is fine and is not flagged: it is honoured exactly as specified.`,
+            snippet: hit.snippet
+          }
+        ];
+      },
+      // composition_exceeds_inspection_viewport_cap
+      //
+      // packages/cli/src/utils/compositionViewport.ts caps a parsed data-width /
+      // data-height at MAX_VIEWPORT_DIMENSION (4096) with a plain Math.min and no
+      // warning. captureCompositionFrame resolves its viewport through that helper,
+      // and check, validate, snapshot, compare and layout all capture through it;
+      // layout and motionShot carry their own independent Math.min(..., 4096).
+      //
+      // `render` does NOT go through it, and that asymmetry is the whole finding.
+      // Measured at 0.8.71 on a 5000x400 composition with 100x100 boxes at left:100
+      // and left:4500:
+      //
+      //   render    -> 5000x400 output, both boxes present.
+      //   snapshot  -> 4096x400 frame, the left:4500 box ABSENT.
+      //
+      // So the video is correct and the tools an author would reach for to check it
+      // silently cannot see the last 904 px. The failure direction is the awkward
+      // one: `check` comes back clean on a region it never rendered, and someone
+      // debugging a missing element through `snapshot` chases a difference that
+      // exists only in the instrument.
+      //
+      // A warning, not an error: the deliverable is fine, and a composition wider
+      // than 4096 can be entirely deliberate.
+      ({ rootTag }) => {
+        if (!rootTag) return [];
+        const over = [];
+        for (const attr of ["data-width", "data-height"]) {
+          const raw = readAttr(rootTag.raw, attr);
+          if (!raw) continue;
+          const value = Number.parseInt(raw, 10);
+          if (Number.isFinite(value) && value > INSPECTION_VIEWPORT_CAP) {
+            over.push(`${attr}=${value}`);
+          }
+        }
+        if (over.length === 0) return [];
+        return [
+          {
+            code: "composition_exceeds_inspection_viewport_cap",
+            severity: "warning",
+            message: `${over.join(" and ")} exceeds the ${INSPECTION_VIEWPORT_CAP}px viewport cap that check, validate, snapshot, compare and layout clamp to. render is unaffected and produces the full size, so the video is correct \u2014 but every inspection command captures a ${INSPECTION_VIEWPORT_CAP}px-wide frame, and anything beyond that is missing from what they report. Measured at 0.8.71: a 5000x400 composition renders 5000x400 with all content, while snapshot returns 4096x400 with the element at left:4500 absent.`,
+            fixHint: `Keep the authored size if the output needs it, and verify the region past ${INSPECTION_VIEWPORT_CAP}px from a render rather than from check/snapshot/compare \u2014 a clean inspection result does not cover it. If the large canvas is only there to gain resolution, author at the layout size and pass \`--output-resolution\` to render instead, which supersamples without changing layout.`,
+            snippet: truncateSnippet(rootTag.raw)
+          }
+        ];
       }
     ];
     CLIP_MEDIA_TAGS = /* @__PURE__ */ new Set(["img", "video", "audio"]);
@@ -78900,7 +79197,7 @@ var init_htmlTemplate = __esm({
 
 // ../engine/src/services/extractedFrameIndex.ts
 import { readdirSync as readdirSync4 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function extractedFrameIndex(file, format) {
   const match = new RegExp(`^${FRAME_FILENAME_PREFIX}(\\d+)\\.${format}$`).exec(file);
   if (!match) {
@@ -78923,7 +79220,7 @@ function framePathsFromDirectory(outputDir, format) {
         `Duplicate extracted frame index ${index}: ${indexed.get(index)} and ${file}`
       );
     }
-    indexed.set(index, join10(outputDir, file));
+    indexed.set(index, join11(outputDir, file));
   }
   const ordered = /* @__PURE__ */ new Map();
   for (let index = 0; index < indexed.size; index += 1) {
@@ -78964,7 +79261,7 @@ import {
   utimesSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function readKeyStat(videoPath) {
   try {
     const stat = statSync5(videoPath);
@@ -79002,8 +79299,8 @@ function hasFrameFiles(dir) {
 }
 function lookupCacheEntry(rootDir, input) {
   const keyHash = computeCacheKey(input);
-  const dir = join11(rootDir, cacheEntryDirName(keyHash));
-  const complete = existsSync10(join11(dir, COMPLETE_SENTINEL)) && hasFrameFiles(dir);
+  const dir = join12(rootDir, cacheEntryDirName(keyHash));
+  const complete = existsSync10(join12(dir, COMPLETE_SENTINEL)) && hasFrameFiles(dir);
   return { entry: { dir, keyHash }, hit: complete };
 }
 function partialCacheEntryDir(entry) {
@@ -79014,13 +79311,13 @@ function isTargetExistsRenameError(err) {
   return code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM";
 }
 function adoptPublishedWinner(entry, partialDir) {
-  if (!existsSync10(join11(entry.dir, COMPLETE_SENTINEL))) return null;
+  if (!existsSync10(join12(entry.dir, COMPLETE_SENTINEL))) return null;
   removeDir(partialDir);
   return { dir: entry.dir, published: true };
 }
 function publishCacheEntry(entry, partialDir) {
   try {
-    writeFileSync3(join11(partialDir, COMPLETE_SENTINEL), "", "utf-8");
+    writeFileSync3(join12(partialDir, COMPLETE_SENTINEL), "", "utf-8");
   } catch {
     return { dir: partialDir, published: false };
   }
@@ -79051,7 +79348,7 @@ function touchCacheDir(dir) {
   } catch {
   }
   try {
-    utimesSync(join11(dir, COMPLETE_SENTINEL), now, now);
+    utimesSync(join12(dir, COMPLETE_SENTINEL), now, now);
   } catch {
   }
 }
@@ -79079,7 +79376,7 @@ function directorySizeBytes(path) {
     return 0;
   }
   for (const child of children) {
-    const childPath = join11(path, child);
+    const childPath = join12(path, child);
     try {
       const stat = lstatSync3(childPath);
       if (stat.isDirectory()) {
@@ -79108,7 +79405,7 @@ function collectGcEntry(dir, name, now, minAgeMs, stats) {
     }
     let lastUseMs = dirStat.mtimeMs;
     try {
-      lastUseMs = statSync5(join11(dir, COMPLETE_SENTINEL)).mtimeMs;
+      lastUseMs = statSync5(join12(dir, COMPLETE_SENTINEL)).mtimeMs;
     } catch {
     }
     return { dir, size: directorySizeBytes(dir), lastUseMs, ageMs: now - lastUseMs };
@@ -79118,7 +79415,7 @@ function collectGcEntry(dir, name, now, minAgeMs, stats) {
 }
 function gcSweepDue(rootDir, maxAgeMs) {
   try {
-    return Date.now() - statSync5(join11(rootDir, GC_MARKER)).mtimeMs > maxAgeMs;
+    return Date.now() - statSync5(join12(rootDir, GC_MARKER)).mtimeMs > maxAgeMs;
   } catch {
     return true;
   }
@@ -79126,7 +79423,7 @@ function gcSweepDue(rootDir, maxAgeMs) {
 function gcExtractionCache(rootDir, opts) {
   const stats = { evictedEntries: 0, evictedBytes: 0, agedPartialsRemoved: 0 };
   try {
-    writeFileSync3(join11(rootDir, GC_MARKER), "", "utf-8");
+    writeFileSync3(join12(rootDir, GC_MARKER), "", "utf-8");
   } catch {
   }
   try {
@@ -79135,7 +79432,7 @@ function gcExtractionCache(rootDir, opts) {
     for (const child of readdirSync5(rootDir, { withFileTypes: true })) {
       if (!child.isDirectory() || !isCacheLikeChild(child.name)) continue;
       const entry = collectGcEntry(
-        join11(rootDir, child.name),
+        join12(rootDir, child.name),
         child.name,
         now,
         opts.minAgeMs,
@@ -79188,7 +79485,7 @@ var init_extractionCache = __esm({
 
 // ../engine/src/services/videoFrameExtractor.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync11, linkSync as linkSync2, mkdirSync as mkdirSync6, rmSync as rmSync3 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function isVideoFrameFormat(value) {
   return typeof value === "string" && VIDEO_FRAME_FORMATS.includes(value);
 }
@@ -79534,7 +79831,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const normalizedFps = toFps(options.fps);
   const fps = fpsToNumber(normalizedFps);
   const ffmpegFps = fpsToFfmpegArg(normalizedFps);
-  const videoOutputDir = outputDirOverride ?? join12(outputDir, videoId);
+  const videoOutputDir = outputDirOverride ?? join13(outputDir, videoId);
   if (!existsSync11(videoOutputDir)) mkdirSync6(videoOutputDir, { recursive: true });
   let metadata;
   try {
@@ -79561,7 +79858,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   }
   const format = resolveFrameFormat(metadata, options.format);
   const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${format}`;
-  const outputPattern = join12(videoOutputDir, framePattern);
+  const outputPattern = join13(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
   const args = [];
@@ -79994,7 +80291,7 @@ function sliceSupersetMember(member, superset, outputDir, fps, configuredFps) {
   for (let i = 0; i < frameCount; i += 1) {
     const sourceFrame = superset.framePaths.get(member.offsetFrames + i);
     if (!sourceFrame) throw new Error(`superset frame ${member.offsetFrames + i} missing`);
-    linkOrCopyFrame(sourceFrame, join12(outputDir, frameFileName(i + 1, work.format)));
+    linkOrCopyFrame(sourceFrame, join13(outputDir, frameFileName(i + 1, work.format)));
   }
   return extractedFramesFromDirectory(work, outputDir, work.videoPath, fps);
 }
@@ -80043,7 +80340,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
         videoPath = resolveProjectRelativeSrc(video.src, baseDir, compiledDir);
       }
       if (isHttpUrl(videoPath)) {
-        const downloadDir = join12(options.outputDir, "_downloads");
+        const downloadDir = join13(options.outputDir, "_downloads");
         mkdirSync6(downloadDir, { recursive: true });
         videoPath = await downloadToTemp(
           videoPath,
@@ -80254,7 +80551,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   async function extractDirectMiss(miss, maxTransientRetries = options.maxTransientRetries ?? 0) {
     const { work, cacheTarget } = miss;
     if (!cacheTarget) {
-      const outputDir = join12(options.outputDir, work.video.id);
+      const outputDir = join13(options.outputDir, work.video.id);
       const attempted2 = await runVideoExtractionWithRetry(
         () => extractVideoFramesRange(
           work.videoPath,
@@ -80322,7 +80619,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       return sliceSupersetMember(
         member,
         superset,
-        join12(options.outputDir, work.video.id),
+        join13(options.outputDir, work.video.id),
         fps,
         configuredFps
       );
@@ -80339,7 +80636,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   async function executeSupersetGroup(group) {
     const first = group.members[0]?.miss.work;
     if (!first) return [];
-    const tempDir = cacheRootDir ? join12(cacheRootDir, `${group.groupId}.partial-${process.pid}`) : join12(options.outputDir, group.groupId);
+    const tempDir = cacheRootDir ? join13(cacheRootDir, `${group.groupId}.partial-${process.pid}`) : join13(options.outputDir, group.groupId);
     try {
       rmSync3(tempDir, { recursive: true, force: true });
       const superset = await extractVideoFramesRange(
@@ -80719,7 +81016,7 @@ var init_videoFrameExtractor = __esm({
 
 // ../engine/src/services/videoFrameInjector.ts
 import { promises as fs } from "fs";
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 function createFrameSourceCache(entryLimit, bytesLimit, frameSrcResolver) {
   const cache2 = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
@@ -80801,7 +81098,7 @@ function createVideoFrameInjector(frameLookup, config) {
   const lastInjectedFrameByVideo = /* @__PURE__ */ new Map();
   const lastCacheTouchByDir = /* @__PURE__ */ new Map();
   function renewCacheLease(framePath) {
-    const cacheDir = dirname7(framePath);
+    const cacheDir = dirname8(framePath);
     const now = Date.now();
     const lastTouch = lastCacheTouchByDir.get(cacheDir);
     if (lastTouch !== void 0 && now - lastTouch < CACHE_TOUCH_THROTTLE_MS) return;
@@ -81344,8 +81641,8 @@ var init_wavChunks = __esm({
 });
 
 // ../engine/src/services/audioVolumeEnvelope.ts
-import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname8, join as join13 } from "path";
+import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname9, join as join14 } from "path";
 function readFmtChunk(buffer, body, size) {
   const format = wavFormatTag(buffer, body, size);
   const bits = buffer.readUInt16LE(body + 14);
@@ -81413,12 +81710,12 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
   if (!gainAt) return false;
   let stagingDir;
   try {
-    const buffer = readFileSync4(wavPath);
+    const buffer = readFileSync5(wavPath);
     const layout2 = parseWavLayout(buffer);
     if (!layout2) return false;
     scaleSamples(buffer, layout2, gainAt);
-    stagingDir = mkdtempSync3(join13(dirname8(wavPath), ".hf-volume-"));
-    const tempPath = join13(stagingDir, "audio.wav");
+    stagingDir = mkdtempSync3(join14(dirname9(wavPath), ".hf-volume-"));
+    const tempPath = join14(stagingDir, "audio.wav");
     writeFileSync4(tempPath, buffer, { flag: "wx" });
     renameSync2(tempPath, wavPath);
     return true;
@@ -81519,9 +81816,9 @@ var init_audio_fx_runtime_inline = __esm({
 });
 
 // ../engine/src/services/audioFxRender.ts
-import { existsSync as existsSync12, mkdtempSync as mkdtempSync4, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync12, mkdtempSync as mkdtempSync4, readFileSync as readFileSync6, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { pathToFileURL } from "url";
 function readWavChunks(buf) {
   const head = { format: 1, channels: 1, sampleRate: 48e3, bits: 16 };
@@ -81542,7 +81839,7 @@ function readWavChunks(buf) {
   return { ...head, data: data2 };
 }
 function readWav(path) {
-  const buf = readFileSync5(path);
+  const buf = readFileSync6(path);
   if (buf.length < 44 || buf.toString("ascii", 0, 4) !== "RIFF") {
     throw new AudioFxRenderError(`Not a WAV file: ${path}`);
   }
@@ -81636,7 +81933,7 @@ async function applyAudioFxChain(inputWav, chain, outputWav, options) {
   const { samples, sampleRate, channels, float } = readWav(inputWav);
   const planes = deinterleave(samples, channels);
   if ((planes[0]?.length ?? 0) === 0) return { path: inputWav, envelopeBaked: false };
-  const hostDir = mkdtempSync4(join14(tmpdir2(), "hf-fx-host-"));
+  const hostDir = mkdtempSync4(join15(tmpdir2(), "hf-fx-host-"));
   let lease = null;
   try {
     if (options.signal?.aborted) {
@@ -81645,7 +81942,7 @@ async function applyAudioFxChain(inputWav, chain, outputWav, options) {
     lease = await acquireBrowser(["--no-sandbox", "--autoplay-policy=no-user-gesture-required"]);
     const page = await lease.browser.newPage();
     try {
-      const hostPage = join14(hostDir, "audio-fx.html");
+      const hostPage = join15(hostDir, "audio-fx.html");
       writeFileSync5(hostPage, "<!doctype html><meta charset=utf-8><title>audio fx</title>");
       await page.goto(pathToFileURL(hostPage).href, { waitUntil: "domcontentloaded" });
       await page.addScriptTag({ content: getAudioFxRuntimeScript() });
@@ -81782,7 +82079,7 @@ var init_audioFxRender = __esm({
 
 // ../engine/src/services/audioMixer.ts
 import { closeSync as closeSync3, existsSync as existsSync13, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync5, openSync as openSync3, rmSync as rmSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join15, dirname as dirname9, isAbsolute as isAbsolute2, relative as relative2 } from "path";
+import { join as join16, dirname as dirname10, isAbsolute as isAbsolute2, relative as relative2 } from "path";
 function memberGroupKey(el) {
   return el.getAttribute(AUDIO_GROUP_RENDER_ID_ATTR) ?? el.getAttribute(HF_AUDIO_GROUP_ATTR);
 }
@@ -82139,7 +82436,7 @@ function parseAudioElements(html) {
 }
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync13(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const playbackRate = normalizeRateSpec(options?.playbackRate);
   const args = [];
@@ -82185,7 +82482,7 @@ async function extractAudioFromVideo(videoPath, outputPath, options, signal, con
 }
 async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, playbackRate = 1, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync13(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
   const outputArgs = await preparedAudioOutputArgs(srcPath, normalizedPlaybackRate, duration);
@@ -82232,7 +82529,7 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, play
 }
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync13(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const args = [
     "-f",
@@ -82286,7 +82583,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
       failures: result2.failure ? [result2.failure] : void 0
     };
   }
-  const outputDir = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync13(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildFilterComplex = (ignoreAutomation) => {
     const filterParts = [];
@@ -82303,8 +82600,8 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
   const runMix = async (ignoreAutomation) => {
     const inputs = [];
     tracks.forEach((track) => inputs.push("-i", track.srcPath));
-    const scriptDir = mkdtempSync5(join15(outputDir, ".filter-complex-"));
-    const scriptPath = join15(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync5(join16(outputDir, ".filter-complex-"));
+    const scriptPath = join16(scriptDir, "graph.txt");
     const fd = openSync3(scriptPath, "wx", 384);
     try {
       writeFileSync6(fd, buildFilterComplex(ignoreAutomation));
@@ -82390,7 +82687,7 @@ function groupNormalizeOptionUnsupported(stderr) {
 }
 async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname9(outputPath);
+  const outputDir = dirname10(outputPath);
   if (!existsSync13(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildInputFilters = (ignoreKeyframes) => memberTracks.map((track, i) => {
     const volumeFilter = buildVolumeExpression(track, ignoreKeyframes);
@@ -82408,8 +82705,8 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
       `${mixInputs}amix=inputs=${memberTracks.length}:duration=longest:dropout_transition=0[mixed];[mixed]volume=${formatFilterNumber(memberTracks.length)}[out]`
     );
     const filterComplex = [...inputFilters, mixFilter].join(";");
-    const scriptDir = mkdtempSync5(join15(outputDir, ".group-filter-complex-"));
-    const scriptPath = join15(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync5(join16(outputDir, ".group-filter-complex-"));
+    const scriptPath = join16(scriptDir, "graph.txt");
     const fd = openSync3(scriptPath, "wx", 384);
     try {
       writeFileSync6(fd, filterComplex);
@@ -82562,7 +82859,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join15(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join16(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -82589,7 +82886,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join15(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join16(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -82633,7 +82930,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           const fxResult = await applyAudioFxChain(
             audioSrcPath,
             chain,
-            join15(workDir, `${element.id}-fx.wav`),
+            join16(workDir, `${element.id}-fx.wav`),
             {
               trackId: element.id,
               signal: effectiveSignal,
@@ -82726,7 +83023,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
     const meta = groupMeta.get(groupId);
     if (!meta) continue;
     const pathId = safePathSegment(groupId, groupIndex);
-    const groupWavPath = join15(workDir, `group-${pathId}.wav`);
+    const groupWavPath = join16(workDir, `group-${pathId}.wav`);
     try {
       const subMix = await mixGroupMembers(
         memberTracks,
@@ -82762,7 +83059,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         const fxResult = await applyAudioFxChain(
           groupSrcPath,
           chain,
-          join15(workDir, `group-${pathId}-fx.wav`),
+          join16(workDir, `group-${pathId}-fx.wav`),
           {
             trackId: groupId,
             signal: effectiveSignal,
@@ -82863,14 +83160,14 @@ var init_audioMixer = __esm({
 import { execFile as execFile3 } from "child_process";
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { promisify as promisify3 } from "util";
 async function psnrDb(a, b) {
   const execFileP = promisify3(execFile3);
-  const dir = await mkdtemp(join16(tmpdir3(), "hf-de-verify-"));
+  const dir = await mkdtemp(join17(tmpdir3(), "hf-de-verify-"));
   try {
-    const pa = join16(dir, "a.jpg");
-    const pb = join16(dir, "b.jpg");
+    const pa = join17(dir, "a.jpg");
+    const pb = join17(dir, "b.jpg");
     await Promise.all([writeFile(pa, a), writeFile(pb, b)]);
     const { stderr } = await execFileP(
       getFfmpegBinary(),
@@ -82981,7 +83278,7 @@ var init_readWebGlVendorInfoFromCanvas = __esm({
 import { cpus, freemem } from "os";
 import { existsSync as existsSync14, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { getHeapStatistics } from "v8";
 function defaultSafeMaxWorkers() {
   return Math.max(6, Math.min(16, Math.floor(cpus().length / 8)));
@@ -83110,7 +83407,7 @@ function distributeFrames(totalFrames, workerCount, workDir, rangeStart = 0) {
       workerId: i,
       startFrame,
       endFrame,
-      outputDir: join17(workDir, `worker-${i}`),
+      outputDir: join18(workDir, `worker-${i}`),
       outputFrameOffset: rangeStart
     });
   }
@@ -83124,7 +83421,7 @@ function distributeFramesInterleaved(totalFrames, workerCount, workDir, rangeSta
       startFrame: rangeStart + i,
       endFrame: rangeStart + totalFrames,
       frameStride: workerCount,
-      outputDir: join17(workDir, `worker-${i}`),
+      outputDir: join18(workDir, `worker-${i}`),
       outputFrameOffset: rangeStart
     });
   }
@@ -83323,7 +83620,7 @@ async function verifyDiskDrawElementSamples(session, task, streaming) {
   for (const idx of selectVerifySampleIndicesForTask(truths.keys(), task)) {
     const truth = truths.get(idx);
     if (!truth) continue;
-    const framePath = join17(task.outputDir, `frame_${String(idx - offset3).padStart(6, "0")}.${ext}`);
+    const framePath = join18(task.outputDir, `frame_${String(idx - offset3).padStart(6, "0")}.${ext}`);
     const db = await psnrForDiskSample(framePath, truth, task.workerId, idx);
     if (db === null) continue;
     assertDiskSampleAboveFloor(db, verifyMinDb, idx, task.workerId);
@@ -83560,8 +83857,8 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
     }
     const files = readdirSync6(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
-      const sourcePath = join17(task.outputDir, file);
-      const targetPath = join17(outputDir, file);
+      const sourcePath = join18(task.outputDir, file);
+      const targetPath = join18(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -83606,8 +83903,8 @@ var init_parallelCoordinator = __esm({
 // ../engine/src/services/fileServer.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync6, openSync as openSync4, fstatSync, closeSync as closeSync4, statSync as statSync6, constants as constants2 } from "fs";
-import { join as join18, extname as extname3 } from "path";
+import { readFileSync as readFileSync7, openSync as openSync4, fstatSync, closeSync as closeSync4, statSync as statSync6, constants as constants2 } from "fs";
+import { join as join19, extname as extname3 } from "path";
 function readRegularFile(filePath) {
   let fd;
   try {
@@ -83620,16 +83917,16 @@ function readRegularFile(filePath) {
   }
   try {
     if (!fstatSync(fd).isFile()) return null;
-    return readFileSync6(fd);
+    return readFileSync7(fd);
   } finally {
     closeSync4(fd);
   }
 }
 function resolveContainedPaths(projectDir, compiledDir, relativePath) {
-  const projectPath = join18(projectDir, relativePath);
+  const projectPath = join19(projectDir, relativePath);
   if (!isWithinProjectRoot(projectDir, projectPath)) return null;
   if (!compiledDir) return { projectPath, compiledPath: null };
-  const compiledPath = join18(compiledDir, relativePath);
+  const compiledPath = join19(compiledDir, relativePath);
   if (!isWithinProjectRoot(compiledDir, compiledPath)) return null;
   return { projectPath, compiledPath };
 }
@@ -84543,7 +84840,7 @@ var init_shaderTransitions = __esm({
 
 // ../engine/src/services/hdrCapture.ts
 import { existsSync as existsSync15, readdirSync as readdirSync7 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { homedir as homedir2 } from "os";
 function linearToPQ(L) {
   const Lp = Math.max(0, L * SDR_NITS / PQ_MAX_NITS);
@@ -84659,12 +84956,12 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   return output;
 }
 function resolveHeadedChromePath() {
-  const baseDir = join19(homedir2(), ".cache", "puppeteer", "chrome");
+  const baseDir = join20(homedir2(), ".cache", "puppeteer", "chrome");
   if (!existsSync15(baseDir)) return void 0;
   const versions = readdirSync7(baseDir).sort().reverse();
   for (const version2 of versions) {
     const candidates = [
-      join19(
+      join20(
         baseDir,
         version2,
         "chrome-mac-arm64",
@@ -84673,7 +84970,7 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join19(
+      join20(
         baseDir,
         version2,
         "chrome-mac-x64",
@@ -84682,8 +84979,8 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join19(baseDir, version2, "chrome-linux64", "chrome"),
-      join19(baseDir, version2, "chrome-win64", "chrome.exe")
+      join20(baseDir, version2, "chrome-linux64", "chrome"),
+      join20(baseDir, version2, "chrome-win64", "chrome.exe")
     ];
     for (const binary of candidates) {
       if (existsSync15(binary)) return binary;
@@ -88189,13 +88486,13 @@ import {
   existsSync as existsSync23,
   mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync8,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   renameSync as renameSync5,
   rmSync as rmSync11,
   writeFileSync as writeFileSync9
 } from "fs";
 import { homedir as homedir4, tmpdir as tmpdir5 } from "os";
-import { dirname as dirname13, join as join31 } from "path";
+import { dirname as dirname14, join as join32 } from "path";
 async function compressToWoff2(input) {
   return Buffer.from(await compress(input));
 }
@@ -88203,17 +88500,17 @@ function rawMimeType(format) {
   return RAW_MIME_TYPES[format] ?? "font/ttf";
 }
 function defaultCacheDir() {
-  const root = process.env.HYPERFRAMES_FONT_CACHE_DIR ?? (process.env.AWS_LAMBDA_FUNCTION_NAME ? join31(tmpdir5(), "hyperframes", "fonts") : join31(homedir4(), ".cache", "hyperframes", "fonts"));
-  return join31(root, "local-compression-v1");
+  const root = process.env.HYPERFRAMES_FONT_CACHE_DIR ?? (process.env.AWS_LAMBDA_FUNCTION_NAME ? join32(tmpdir5(), "hyperframes", "fonts") : join32(homedir4(), ".cache", "hyperframes", "fonts"));
+  return join32(root, "local-compression-v1");
 }
 function cachedCompressionPath(input, originalFormat, cacheDir) {
   const digest = createHash7("sha256").update("hyperframes-local-font-compression-v1\0").update(originalFormat).update("\0").update(input).digest("hex");
-  return join31(cacheDir, `${digest}.woff2`);
+  return join32(cacheDir, `${digest}.woff2`);
 }
 function readCachedCompression(path) {
   try {
     if (!existsSync23(path)) return null;
-    const cached2 = readFileSync10(path);
+    const cached2 = readFileSync11(path);
     return cached2.length > 0 ? cached2 : null;
   } catch {
     return null;
@@ -88222,9 +88519,9 @@ function readCachedCompression(path) {
 function cacheCompression(path, compressed) {
   let tempDir;
   try {
-    mkdirSync13(dirname13(path), { recursive: true });
-    tempDir = mkdtempSync8(join31(dirname13(path), ".compression-"));
-    const tmpPath = join31(tempDir, "font.woff2");
+    mkdirSync13(dirname14(path), { recursive: true });
+    tempDir = mkdtempSync8(join32(dirname14(path), ".compression-"));
+    const tmpPath = join32(tempDir, "font.woff2");
     writeFileSync9(tmpPath, compressed, { flag: "wx", mode: 420 });
     renameSync5(tmpPath, path);
   } catch {
@@ -88283,7 +88580,7 @@ import {
   existsSync as existsSync33,
   mkdirSync as mkdirSync19,
   mkdtempSync as mkdtempSync11,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   readdirSync as readdirSync12,
   rmSync as rmSync15,
   statSync as statSync12,
@@ -88292,10 +88589,10 @@ import {
   appendFileSync
 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join47, dirname as dirname19, resolve as resolve13 } from "path";
+import { join as join48, dirname as dirname20, resolve as resolve13 } from "path";
 import { totalmem as totalmem3 } from "os";
 import { randomUUID as randomUUID3 } from "crypto";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { fileURLToPath as fileURLToPath6 } from "url";
 
 // ../producer/src/services/fileServer.ts
 init_compiler();
@@ -88315,14 +88612,14 @@ import {
 } from "fs";
 import { promisify as promisify4 } from "util";
 import { Readable as Readable2 } from "stream";
-import { join as join20, extname as extname4, resolve as resolve7, sep as sep3 } from "path";
+import { join as join21, extname as extname4, resolve as resolve7, sep as sep3 } from "path";
 
 // ../producer/src/services/hyperframeRuntimeLoader.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync16, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname10, resolve as resolve6 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var PRODUCER_DIR = dirname10(fileURLToPath2(import.meta.url));
+import { existsSync as existsSync16, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname11, resolve as resolve6 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var PRODUCER_DIR = dirname11(fileURLToPath3(import.meta.url));
 var SIBLING_MANIFEST_PATH = resolve6(PRODUCER_DIR, "hyperframe.manifest.json");
 var MODULE_RELATIVE_MANIFEST_PATH = resolve6(
   PRODUCER_DIR,
@@ -88357,7 +88654,7 @@ function resolveVerifiedHyperframeRuntime() {
       `[HyperframeRuntimeLoader] Missing manifest. Tried: ${tried}. Searched from cwd=${process.cwd()}. Build core runtime artifacts before rendering.`
     );
   }
-  const manifestRaw = readFileSync7(manifestPath, "utf8");
+  const manifestRaw = readFileSync8(manifestPath, "utf8");
   const manifest = JSON.parse(manifestRaw);
   const runtimeFileName = manifest.artifacts?.iife;
   if (!runtimeFileName || !manifest.sha256) {
@@ -88365,11 +88662,11 @@ function resolveVerifiedHyperframeRuntime() {
       `[HyperframeRuntimeLoader] Invalid manifest at ${manifestPath}; missing iife artifact or sha256.`
     );
   }
-  const runtimePath = resolve6(dirname10(manifestPath), runtimeFileName);
+  const runtimePath = resolve6(dirname11(manifestPath), runtimeFileName);
   if (!existsSync16(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
-  const runtimeSource = readFileSync7(runtimePath, "utf8");
+  const runtimeSource = readFileSync8(runtimePath, "utf8");
   const runtimeSha = createHash4("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
@@ -88931,7 +89228,7 @@ function createFileServer2(options) {
     }).join("/");
     let file = null;
     for (const root of compiledDir ? [compiledDir, projectDir] : [projectDir]) {
-      const candidate = join20(root, relativePath);
+      const candidate = join21(root, relativePath);
       if (isPathInside2(candidate, root)) file = openRegularFile(candidate);
       if (file) break;
     }
@@ -89078,20 +89375,20 @@ import {
   symlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename4, dirname as dirname11, isAbsolute as isAbsolute3, join as join22, relative as relative3, resolve as resolve8 } from "path";
+import { basename as basename4, dirname as dirname12, isAbsolute as isAbsolute3, join as join23, relative as relative3, resolve as resolve8 } from "path";
 
 // ../producer/src/utils/paths.ts
 import {
   basename as basename3,
-  join as join21,
+  join as join22,
   resolve as nodeResolve,
   relative as nodeRelative,
   isAbsolute as nodeIsAbsolute
 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 var DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? // fileURLToPath (not URL.pathname): on Windows .pathname is "/D:/..." which
 // resolves to a bogus renders dir.
-nodeResolve(fileURLToPath3(import.meta.url), "../../..", "renders");
+nodeResolve(fileURLToPath4(import.meta.url), "../../..", "renders");
 function isPathInside3(childPath, parentPath, options = {}) {
   const resolvePath = options.pathModule?.resolve ?? nodeResolve;
   const relativePath = options.pathModule?.relative ?? nodeRelative;
@@ -89121,7 +89418,7 @@ function formatExportFrameName(index, ext) {
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
   const absoluteProjectDir = nodeResolve(projectDir);
   const projectName = basename3(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join21(rendersDir, `${projectName}.mp4`);
+  const resolvedOutputPath = outputPath ?? join22(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = nodeResolve(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
@@ -89158,21 +89455,21 @@ function resolveDeviceScaleFactor(input) {
   return target.width / input.compositionWidth;
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join22(workDir, "compiled");
+  const compileDir = join23(workDir, "compiled");
   mkdirSync9(compileDir, { recursive: true });
-  writeFileSync7(join22(compileDir, "index.html"), compiled.html, "utf-8");
+  writeFileSync7(join23(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join22(compileDir, srcPath);
-    mkdirSync9(dirname11(outPath), { recursive: true });
+    const outPath = join23(compileDir, srcPath);
+    mkdirSync9(dirname12(outPath), { recursive: true });
     writeFileSync7(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve8(join22(compileDir, relativePath));
+    const outPath = resolve8(join23(compileDir, relativePath));
     if (!isPathInside3(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
     }
-    mkdirSync9(dirname11(outPath), { recursive: true });
+    mkdirSync9(dirname12(outPath), { recursive: true });
     copyFileSync3(absolutePath, outPath);
   }
   if (includeSummary) {
@@ -89198,7 +89495,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       renderModeHints: compiled.renderModeHints,
       hasShaderTransitions: compiled.hasShaderTransitions
     };
-    writeFileSync7(join22(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync7(join23(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(alreadyForced, compiled, log = defaultLogger) {
@@ -89223,10 +89520,42 @@ function updateJobStatus(job, status, stage, progress, onProgress) {
   }
   if (onProgress) void onProgress(job, stage);
 }
+var PROGRESS_REPORT_INTERVAL_MS = 250;
+var lastFrameReportAt = /* @__PURE__ */ new WeakMap();
+var lastStartupReportAt = /* @__PURE__ */ new WeakMap();
+function reportThrottled(lastReportAt, job, stage, progress, onProgress, force) {
+  const now = Date.now();
+  const last = lastReportAt.get(job);
+  const due = force || last === void 0 || now - last >= PROGRESS_REPORT_INTERVAL_MS;
+  if (due) lastReportAt.set(job, now);
+  updateJobStatus(job, "rendering", stage, progress, due ? onProgress : void 0);
+}
+function reportFrameProgress(job, stage, progress, onProgress, isLastFrame) {
+  reportThrottled(lastFrameReportAt, job, stage, progress, onProgress, isLastFrame);
+}
+var workerPhasesByJob = /* @__PURE__ */ new WeakMap();
+function reportWorkerStartup(job, progress, onProgress) {
+  const phase = progress.latestWorkerPhase;
+  if (!phase) return;
+  const phases = workerPhasesByJob.get(job) ?? /* @__PURE__ */ new Map();
+  workerPhasesByJob.set(job, phases);
+  phases.set(phase.workerId, phase.phase);
+  const ready = [...phases].filter(
+    ([id, p]) => id < progress.activeWorkers && (p === "frame_capture" || p === "frame_encode")
+  ).length;
+  reportThrottled(
+    lastStartupReportAt,
+    job,
+    `Starting browsers (${ready}/${progress.activeWorkers} ready)`,
+    job.progress,
+    onProgress,
+    false
+  );
+}
 var materializePathModule = {
   resolve: resolve8,
-  join: join22,
-  dirname: dirname11,
+  join: join23,
+  dirname: dirname12,
   basename: basename4,
   relative: relative3,
   isAbsolute: isAbsolute3
@@ -89529,7 +89858,7 @@ import {
   renameSync as renameSync3,
   rmSync as rmSync8
 } from "fs";
-import { basename as basename5, dirname as dirname12, extname as extname5, join as join23, resolve as resolve9 } from "path";
+import { basename as basename5, dirname as dirname13, extname as extname5, join as join24, resolve as resolve9 } from "path";
 
 // ../producer/src/utils/ffprobe.ts
 init_src();
@@ -89563,10 +89892,10 @@ function buildArtifactExpectation(input) {
   };
 }
 function createSiblingTransactionDirectory(destination) {
-  const parent = dirname12(destination);
+  const parent = dirname13(destination);
   const extension = extname5(destination);
   const stem = extension ? basename5(destination, extension) : basename5(destination);
-  return mkdtempSync6(join23(parent, `.${stem}.hf-transaction-`));
+  return mkdtempSync6(join24(parent, `.${stem}.hf-transaction-`));
 }
 function assertReadableNonEmptyFile(path) {
   const fd = openSync6(path, "r");
@@ -89584,7 +89913,7 @@ function collectDirectoryFiles(root) {
   const files = [];
   const visit = (directory) => {
     for (const entry of readdirSync8(directory, { withFileTypes: true })) {
-      const path = join23(directory, entry.name);
+      const path = join24(directory, entry.name);
       if (entry.isDirectory()) visit(path);
       else if (entry.isFile()) files.push(path);
     }
@@ -89627,8 +89956,8 @@ var ArtifactTransaction = class {
     this.fileSystem = fileSystem;
     this.destinationPath = resolve9(destinationPath);
     this.transactionDirectory = createSiblingTransactionDirectory(this.destinationPath);
-    this.stagingPath = join23(this.transactionDirectory, basename5(this.destinationPath));
-    this.backupPath = join23(this.transactionDirectory, "backup");
+    this.stagingPath = join24(this.transactionDirectory, basename5(this.destinationPath));
+    this.backupPath = join24(this.transactionDirectory, "backup");
     this.durationProbe = durationProbe;
   }
   kind;
@@ -89669,14 +89998,14 @@ var ArtifactTransaction = class {
    */
   async assertDirectoryExpectation(expected) {
     for (const required of expected.requiredFiles ?? []) {
-      const path = join23(this.stagingPath, required);
+      const path = join24(this.stagingPath, required);
       if (!existsSync19(path)) {
         throw new Error(`Render artifact directory is missing ${required}: ${this.stagingPath}`);
       }
       assertReadableNonEmptyFile(path);
     }
     if (expected.probeTarget === void 0) return;
-    await this.assertArtifactDuration(expected, join23(this.stagingPath, expected.probeTarget));
+    await this.assertArtifactDuration(expected, join24(this.stagingPath, expected.probeTarget));
   }
   async assertArtifactDuration(expected, probePath = this.stagingPath) {
     const expectedSeconds = expected.expectedDurationSeconds;
@@ -89890,7 +90219,7 @@ function replanAfterFailure(plan2, failure) {
 // ../producer/src/services/render/stages/captureSegmentedStage.ts
 init_src();
 import { existsSync as existsSync20, mkdirSync as mkdirSync11, rmSync as rmSync10, statSync as statSync8 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 
 // ../producer/src/services/render/captureStageError.ts
 init_src();
@@ -89926,7 +90255,7 @@ init_src();
 // ../producer/src/services/hdrCompositor.ts
 init_src();
 import { readSync as readSync2, closeSync as closeSync7 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // ../producer/src/services/render/hdrPerf.ts
 function createHdrPerfCollector() {
@@ -90438,7 +90767,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
         if (shouldLog && debugDumpDir) {
           const after2 = countNonZeroRgb48(canvas);
           const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
-          const dumpPath = join24(debugDumpDir, dumpName);
+          const dumpPath = join25(debugDumpDir, dumpName);
           writeFileExclusiveSync(dumpPath, domPng);
           log.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
@@ -90482,11 +90811,11 @@ import {
   mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync7,
   openSync as openSync7,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   rmSync as rmSync9,
   statfsSync
 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var NO_FOLLOW_FLAG = constants4.O_NOFOLLOW ?? 0;
 function tempDirSafePrefix(id) {
   const safe = id.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80);
@@ -90730,10 +91059,10 @@ async function extractHdrVideoFrames(args) {
       const window3 = extractionWindows.get(videoId);
       if (!video || !window3) continue;
       mkdirSync10(framesDir, { recursive: true });
-      const frameDir = mkdtempSync7(join25(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
+      const frameDir = mkdtempSync7(join26(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
       createdFrameDirs.add(frameDir);
       const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
-      const rawPath = join25(frameDir, "frames.rgb48le");
+      const rawPath = join26(frameDir, "frames.rgb48le");
       const extractionStart = String(window3.extractionMediaStart ?? window3.mediaStart);
       const ffmpegArgs = [];
       if (window3.finalFrameOnly) {
@@ -90819,7 +91148,7 @@ function decodeHdrImageBuffers(args) {
   const out = /* @__PURE__ */ new Map();
   for (const [imageId, srcPath] of hdrImageSrcPaths) {
     try {
-      const decoded = decodePngToRgb48le(readFileSync8(srcPath));
+      const decoded = decodePngToRgb48le(readFileSync9(srcPath));
       const layout2 = prep.hdrExtractionDims.get(imageId);
       const fitInfo = prep.hdrImageFitInfo.get(imageId);
       if (layout2 && (layout2.width !== decoded.width || layout2.height !== decoded.height)) {
@@ -91148,7 +91477,7 @@ function isTargetLossError(error) {
 init_src();
 import { mkdtemp as mkdtemp2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 
 // ../producer/src/services/render/perfSummary.ts
 init_dist2();
@@ -91496,11 +91825,11 @@ function createDrainFrameGuard(args) {
         return buf;
       }
       if (db < verifyMinDb) {
-        const dumpDir = await mkdtemp2(join26(tmpdir4(), "hf-de-verify-fail-")).catch(() => null);
+        const dumpDir = await mkdtemp2(join27(tmpdir4(), "hf-de-verify-fail-")).catch(() => null);
         if (dumpDir) {
           await Promise.all([
-            writeFile2(join26(dumpDir, `frame-${idx}-de.jpg`), buf),
-            writeFile2(join26(dumpDir, `frame-${idx}-truth.jpg`), truth)
+            writeFile2(join27(dumpDir, `frame-${idx}-de.jpg`), buf),
+            writeFile2(join27(dumpDir, `frame-${idx}-truth.jpg`), truth)
           ]).catch(() => {
           });
         }
@@ -91541,12 +91870,12 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
     reorderBuffer.advanceTo(prev.idx + 1);
     job.framesRendered = prev.idx + 1;
     lastProgressAt = Date.now();
-    updateJobStatus(
+    reportFrameProgress(
       job,
-      "rendering",
       `Streaming frame ${prev.idx + 1}/${totalFrames}`,
       Math.round(25 + (prev.idx + 1) / totalFrames * 55),
-      onProgress
+      onProgress,
+      prev.idx + 1 === totalFrames
     );
   };
   const batchNRaw = Number(process.env.HF_DE_BATCH ?? "4");
@@ -91560,12 +91889,12 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
       reorderBuffer.advanceTo(item.idx + 1);
       job.framesRendered = item.idx + 1;
       lastProgressAt = Date.now();
-      updateJobStatus(
+      reportFrameProgress(
         job,
-        "rendering",
         `Streaming frame ${item.idx + 1}/${totalFrames}`,
         Math.round(25 + (item.idx + 1) / totalFrames * 55),
-        onProgress
+        onProgress,
+        item.idx + 1 === totalFrames
       );
     }
   };
@@ -91762,6 +92091,7 @@ async function runCaptureStreamingStage(input) {
                 canvasDrawElement: phase.canvasDrawElement,
                 gpuBackend: phase.gpuBackend
               });
+              if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
               return;
             }
             if (progress.capturedFrames > lastCapturedFrames) {
@@ -91771,16 +92101,13 @@ async function runCaptureStreamingStage(input) {
             }
             job.framesRendered = progress.capturedFrames;
             const frameProgress = progress.capturedFrames / progress.totalFrames;
-            const progressPct = 25 + frameProgress * 55;
-            if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
-              updateJobStatus(
-                job,
-                "rendering",
-                `Streaming frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
-                Math.round(progressPct),
-                onProgress
-              );
-            }
+            reportFrameProgress(
+              job,
+              `Streaming frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
+              Math.round(25 + frameProgress * 55),
+              onProgress,
+              progress.capturedFrames === progress.totalFrames
+            );
           },
           onFrameBuffer,
           // Interleaved DE workers each need their own browser PROCESS:
@@ -91892,12 +92219,12 @@ async function runCaptureStreamingStage(input) {
             lastProgressAt = Date.now();
             const frameProgress = (i + 1) / totalFrames;
             const progress = 25 + frameProgress * 55;
-            updateJobStatus(
+            reportFrameProgress(
               job,
-              "rendering",
               `Streaming frame ${i + 1}/${totalFrames}`,
               Math.round(progress),
-              onProgress
+              onProgress,
+              i + 1 === totalFrames
             );
           }
         }
@@ -91940,7 +92267,7 @@ async function runCaptureStreamingStage(input) {
 
 // ../producer/src/services/render/stages/captureSegmentedStage.ts
 function segmentOutputPath(segmentDir, index) {
-  return join27(segmentDir, `segment_${String(index).padStart(5, "0")}.mp4`);
+  return join28(segmentDir, `segment_${String(index).padStart(5, "0")}.mp4`);
 }
 function segmentEncoderOptions(base2, segment) {
   return {
@@ -91976,12 +92303,12 @@ async function captureSegmentFrames(ctx, segment, encoder) {
     ensureFrameWritten(await encoder.writeFrame(buffer), i, encoder);
     ctx.job.framesRendered = i + 1;
     lastProgressAt = Date.now();
-    updateJobStatus(
+    reportFrameProgress(
       ctx.job,
-      "rendering",
       `Streaming frame ${i + 1}/${ctx.totalFrames} (segment ${segment.index + 1}/${ctx.segmentCount}` + (ctx.skipped > 0 ? `, skipped ${ctx.skipped}` : "") + ")",
       Math.round(25 + (i + 1) / ctx.totalFrames * 55),
-      ctx.onProgress
+      ctx.onProgress,
+      i + 1 === ctx.totalFrames
     );
   }
 }
@@ -92186,7 +92513,7 @@ async function runCaptureSegmentedStage(input) {
   const { log, dedupPerfs, assertNotAborted } = input;
   const deps = { ...DEFAULT_DEPS, ...input.deps };
   const segments = planSegments(input.totalFrames, input.segmentFrames);
-  const segmentDir = input.segmentDir ?? join27(input.workDir, "segments");
+  const segmentDir = input.segmentDir ?? join28(input.workDir, "segments");
   mkdirSync11(segmentDir, { recursive: true });
   const skip = input.completedSegments ?? /* @__PURE__ */ new Set();
   const pending = segments.filter((s) => !skip.has(s.index));
@@ -92258,8 +92585,8 @@ async function runCaptureSegmentedStage(input) {
 
 // ../producer/src/services/render/segmentManifest.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync9, renameSync as renameSync4, statSync as statSync9, writeFileSync as writeFileSync8 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync10, renameSync as renameSync4, statSync as statSync9, writeFileSync as writeFileSync8 } from "fs";
+import { join as join29 } from "path";
 var MANIFEST_FILENAME = "segments.json";
 function computeSegmentPlanHash(input) {
   const ordered = [
@@ -92282,7 +92609,7 @@ function computeSegmentPlanHash(input) {
   return createHash5("sha256").update(ordered).digest("hex").slice(0, 16);
 }
 function segmentDirFor(projectRendersDir, planHash) {
-  return join28(projectRendersDir, ".hf-segments", planHash);
+  return join29(projectRendersDir, ".hf-segments", planHash);
 }
 function hasNumber(value, key2) {
   return key2 in value && typeof Reflect.get(value, key2) === "number";
@@ -92300,10 +92627,10 @@ function isManifest2(value) {
   return Reflect.get(value, "version") === 1 && hasString(value, "planHash") && hasNumber(value, "totalFrames") && hasNumber(value, "segmentFrames") && Array.isArray(completed) && completed.every(isEntry);
 }
 function readSegmentManifest(segmentDir) {
-  const path = join28(segmentDir, MANIFEST_FILENAME);
+  const path = join29(segmentDir, MANIFEST_FILENAME);
   if (!existsSync21(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync10(path, "utf-8"));
     return isManifest2(parsed) ? parsed : null;
   } catch {
     return null;
@@ -92311,9 +92638,9 @@ function readSegmentManifest(segmentDir) {
 }
 function writeSegmentManifest(segmentDir, manifest) {
   mkdirSync12(segmentDir, { recursive: true });
-  const tmp = join28(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
+  const tmp = join29(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
   writeFileSync8(tmp, JSON.stringify(manifest, null, 2), "utf-8");
-  renameSync4(tmp, join28(segmentDir, MANIFEST_FILENAME));
+  renameSync4(tmp, join29(segmentDir, MANIFEST_FILENAME));
 }
 async function probeSegmentFrameCount(path, probe2) {
   try {
@@ -92421,7 +92748,7 @@ function resolveVideoCaptureBeyondViewport(videoCount) {
 // ../producer/src/services/render/captureCost.ts
 init_dist2();
 init_src();
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var CAPTURE_CALIBRATION_TARGET_MS = 600;
 var MAX_MEASURED_CAPTURE_COST_MULTIPLIER = 8;
 var CAPTURE_CALIBRATION_PROTOCOL_TIMEOUT_MS = 3e4;
@@ -92657,7 +92984,7 @@ async function runCaptureCalibration(input) {
   });
   let calibration;
   try {
-    calibration = await runOneCalibration(join29(workDir, "capture-calibration"), calibrationCfg);
+    calibration = await runOneCalibration(join30(workDir, "capture-calibration"), calibrationCfg);
   } catch (error) {
     const shouldFallback = !forceScreenshot && shouldFallbackToScreenshotAfterCalibrationError(error);
     if (!shouldFallback) {
@@ -92690,7 +93017,7 @@ async function runCaptureCalibration(input) {
       const screenshotCfg = createCaptureCalibrationConfig({ ...cfg, forceScreenshot: true });
       try {
         calibration = await runOneCalibration(
-          join29(workDir, "capture-calibration-screenshot"),
+          join30(workDir, "capture-calibration-screenshot"),
           screenshotCfg
         );
       } catch (fallbackError) {
@@ -93115,7 +93442,7 @@ function countAuthoredTimedClips(html) {
 
 // ../producer/src/services/render/stages/compileStage.ts
 init_dist2();
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 
 // ../producer/src/services/htmlCompiler.ts
 init_esm10();
@@ -93125,8 +93452,8 @@ init_compiler();
 init_subCompositionValidity();
 init_assetResolution();
 import { createHash as createHash10 } from "crypto";
-import { createReadStream as createReadStream4, existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync13 } from "fs";
-import { join as join34, dirname as dirname15, resolve as resolve12, basename as basename6, relative as relative4 } from "path";
+import { createReadStream as createReadStream4, existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync14 } from "fs";
+import { join as join35, dirname as dirname16, resolve as resolve12, basename as basename6, relative as relative4 } from "path";
 
 // ../producer/src/services/renderMediaCollector.ts
 init_esm10();
@@ -93229,9 +93556,9 @@ init_src();
 
 // ../producer/src/services/deterministicFonts.ts
 import { createHash as createHash8 } from "crypto";
-import { existsSync as existsSync24, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir5, tmpdir as tmpdir6 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // ../core/dist/fonts/aliases.js
 init_dist();
@@ -93240,7 +93567,7 @@ init_dist();
 import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync22, lstatSync as lstatSync4, readdirSync as readdirSync9, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir3, platform as platform2 } from "os";
-import { join as join30, resolve as resolve10 } from "path";
+import { join as join31, resolve as resolve10 } from "path";
 var SYSTEM_FONT_SIZE_LIMIT = 5 * 1024 * 1024;
 var PROFILER_TIMEOUT_MS = 5e3;
 var FONT_EXT_RE = /\.(otf|ttf|ttc|woff2?)$/i;
@@ -93337,7 +93664,7 @@ function fontDirectories() {
   const home = homedir3();
   if (platform2() === "darwin") {
     return [
-      join30(home, "Library", "Fonts"),
+      join31(home, "Library", "Fonts"),
       "/Library/Fonts",
       "/System/Library/Fonts",
       "/System/Library/Fonts/Supplemental"
@@ -93345,13 +93672,13 @@ function fontDirectories() {
   }
   if (platform2() === "win32") {
     return [
-      join30(process.env.WINDIR || "C:\\Windows", "Fonts"),
-      join30(process.env.LOCALAPPDATA || join30(homedir3(), "AppData", "Local"), "Microsoft", "Windows", "Fonts")
+      join31(process.env.WINDIR || "C:\\Windows", "Fonts"),
+      join31(process.env.LOCALAPPDATA || join31(homedir3(), "AppData", "Local"), "Microsoft", "Windows", "Fonts")
     ];
   }
   return [
-    join30(home, ".fonts"),
-    join30(home, ".local", "share", "fonts"),
+    join31(home, ".fonts"),
+    join31(home, ".local", "share", "fonts"),
     "/usr/local/share/fonts",
     "/usr/share/fonts"
   ];
@@ -93362,7 +93689,7 @@ function collectFontFileEntries(dir, depth = 0) {
   const entries2 = [];
   try {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const fullPath = join30(dir, entry.name);
+      const fullPath = join31(dir, entry.name);
       if (entry.isDirectory()) {
         entries2.push(...collectFontFileEntries(fullPath, depth + 1));
         continue;
@@ -93989,7 +94316,7 @@ async function buildFontFaceCss(requestedFamilies, options, fontText) {
       if (variants.length > 0) {
         let totalBytes = 0;
         for (const variant of variants) {
-          const fontBuffer = readFileSync11(variant.path);
+          const fontBuffer = readFileSync12(variant.path);
           totalBytes += fontBuffer.length;
           const dataUri = await fontToDataUri(fontBuffer, variant.format);
           rules.push(buildFontFaceRule(originalCaseFamily, dataUri, variant.weight, variant.style));
@@ -94035,10 +94362,10 @@ function resolveFontCacheRoot() {
     return process.env.HYPERFRAMES_FONT_CACHE_DIR;
   }
   if (process.env.AWS_LAMBDA_FUNCTION_NAME) {
-    lambdaFontCacheRoot ??= mkdtempSync9(join32(tmpdir6(), "hyperframes-fonts-"));
+    lambdaFontCacheRoot ??= mkdtempSync9(join33(tmpdir6(), "hyperframes-fonts-"));
     return lambdaFontCacheRoot;
   }
-  return join32(homedir5(), ".cache", "hyperframes", "fonts");
+  return join33(homedir5(), ".cache", "hyperframes", "fonts");
 }
 var WOFF2_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
 function fontSlug(familyName) {
@@ -94046,14 +94373,14 @@ function fontSlug(familyName) {
 }
 var ephemeralFontCacheRoot;
 function fontCacheDir(slug) {
-  const dir = join32(resolveFontCacheRoot(), slug);
+  const dir = join33(resolveFontCacheRoot(), slug);
   if (!existsSync24(dir)) {
     try {
       mkdirSync14(dir, { recursive: true });
     } catch {
       const firstFallback = ephemeralFontCacheRoot === void 0;
-      ephemeralFontCacheRoot ??= mkdtempSync9(join32(tmpdir6(), "hyperframes-fonts-"));
-      const fallback = join32(ephemeralFontCacheRoot, slug);
+      ephemeralFontCacheRoot ??= mkdtempSync9(join33(tmpdir6(), "hyperframes-fonts-"));
+      const fallback = join33(ephemeralFontCacheRoot, slug);
       mkdirSync14(fallback, { recursive: true });
       if (firstFallback) {
         defaultLogger.warn(
@@ -94069,7 +94396,7 @@ function subsetToken(woff2Url) {
   return createHash8("sha1").update(woff2Url).digest("hex").slice(0, 12);
 }
 function cachedWoff2Path(slug, weight, style, subset) {
-  return join32(fontCacheDir(slug), `${weight}-${style}-${subset}.woff2`);
+  return join33(fontCacheDir(slug), `${weight}-${style}-${subset}.woff2`);
 }
 var FONT_FETCH_FAILED = "FONT_FETCH_FAILED";
 var FONT_FETCH_UNAVAILABLE = "FONT_FETCH_UNAVAILABLE";
@@ -94196,7 +94523,7 @@ async function fetchFontResource(url, init, readBody, familyName, what, options)
 }
 async function ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style, options) {
   try {
-    return `data:font/woff2;base64,${readFileSync11(cachePath).toString("base64")}`;
+    return `data:font/woff2;base64,${readFileSync12(cachePath).toString("base64")}`;
   } catch {
   }
   const woff2What = `Google Fonts woff2 (${weight}/${style})`;
@@ -94221,7 +94548,7 @@ async function ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style
       return null;
     }
   }
-  return `data:font/woff2;base64,${readFileSync11(cachePath).toString("base64")}`;
+  return `data:font/woff2;base64,${readFileSync12(cachePath).toString("base64")}`;
 }
 var googleFontCssCache = /* @__PURE__ */ new Map();
 function raceAgainstAbort(promise, signal) {
@@ -94502,12 +94829,12 @@ import {
   copyFileSync as copyFileSync4,
   existsSync as existsSync25,
   mkdirSync as mkdirSync15,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   renameSync as renameSync6,
   rmSync as rmSync12,
   statSync as statSync10
 } from "fs";
-import { dirname as dirname14, isAbsolute as isAbsolute4, join as join33, resolve as resolve11 } from "path";
+import { dirname as dirname15, isAbsolute as isAbsolute4, join as join34, resolve as resolve11 } from "path";
 var PREPARED_GIF_SUBDIR = "_animated_gif";
 var CACHE_SCHEMA = "hfgif-v1";
 function splitUrlSuffix(src) {
@@ -94660,11 +94987,11 @@ async function runAnimatedGifTranscode(request) {
   throw result.error ?? new Error(`Animated GIF transcode failed (${result.exitCode}): ${result.stderr.slice(-500)}`);
 }
 async function ensurePreparedWebm(input) {
-  if (!existsSync25(dirname14(input.cachePath))) {
-    mkdirSync15(dirname14(input.cachePath), { recursive: true });
+  if (!existsSync25(dirname15(input.cachePath))) {
+    mkdirSync15(dirname15(input.cachePath), { recursive: true });
   }
-  if (!existsSync25(dirname14(input.outputPath))) {
-    mkdirSync15(dirname14(input.outputPath), { recursive: true });
+  if (!existsSync25(dirname15(input.outputPath))) {
+    mkdirSync15(dirname15(input.outputPath), { recursive: true });
   }
   if (!isUsableFile(input.cachePath)) {
     const tmpPath = `${input.cachePath}.tmp-${process.pid}-${Date.now()}`;
@@ -94747,7 +95074,7 @@ function replaceImageWithVideo(input) {
   return video;
 }
 async function prepareAnimatedGifInputs(html, options) {
-  const outputDir = options.outputDir ?? join33(options.downloadDir, PREPARED_GIF_SUBDIR);
+  const outputDir = options.outputDir ?? join34(options.downloadDir, PREPARED_GIF_SUBDIR);
   const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_GIF_SUBDIR);
   const cacheDir = options.cacheDir ?? outputDir;
   const { document: document2 } = parseHTML(html);
@@ -94761,7 +95088,7 @@ async function prepareAnimatedGifInputs(html, options) {
     if (!hasGifExtension(src)) continue;
     const sourcePath = resolveGifSourcePath(src, options);
     if (!sourcePath) continue;
-    const bytes = readFileSync12(sourcePath);
+    const bytes = readFileSync13(sourcePath);
     const metadata = parseAnimatedGifMetadata(bytes);
     if (!metadata?.animated) continue;
     const loop = resolveLoop(metadata, readLoopOverride(img));
@@ -94769,8 +95096,8 @@ async function prepareAnimatedGifInputs(html, options) {
     const { loopIterations, padSeconds } = resolvePreparedPlayback(metadata, loop, windowSeconds);
     const hash2 = computePreparedGifHash(bytes, loopIterations, padSeconds);
     const filename = `${CACHE_SCHEMA}-${hash2.slice(0, 24)}.webm`;
-    const cachePath = join33(cacheDir, filename);
-    const outputPath = join33(outputDir, filename);
+    const cachePath = join34(cacheDir, filename);
+    const outputPath = join34(outputDir, filename);
     const outputSrc = `${outputSrcPrefix}/${filename}`;
     await ensurePreparedWebm({
       sourcePath,
@@ -95301,7 +95628,7 @@ function assertSubCompositionsUsable(html, projectDir, visited = /* @__PURE__ */
       problems.push({ srcPath, detail: "the file does not exist" });
       continue;
     }
-    const fileHtml = readFileSync13(filePath, "utf-8");
+    const fileHtml = readFileSync14(filePath, "utf-8");
     const validity = checkSubCompositionUsability(fileHtml, parseSubCompHtmlForValidity);
     if (!validity.ok) {
       problems.push({
@@ -95440,7 +95767,7 @@ async function resolveMediaDuration2(src, mediaStart, playbackRate, baseDir, dow
       return { duration: null, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join34(baseDir, filePath);
+    filePath = join35(baseDir, filePath);
   }
   if (!existsSync27(filePath)) {
     return { duration: null, resolvedPath: filePath };
@@ -95578,7 +95905,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     if (!existsSync27(filePath)) {
       continue;
     }
-    const rawSubHtml = readFileSync13(filePath, "utf-8");
+    const rawSubHtml = readFileSync14(filePath, "utf-8");
     const nestedVisited = new Set(visited);
     nestedVisited.add(filePath);
     workItems.push({ srcPath, filePath, rawSubHtml, nestedVisited });
@@ -95587,7 +95914,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
         item.rawSubHtml,
-        dirname15(item.filePath),
+        dirname16(item.filePath),
         downloadDir
       );
       const nested = await parseSubCompositions(
@@ -95762,7 +96089,7 @@ function inlineSubCompositions2(html, subCompositions, projectDir, variableOverr
         if (!compHtml) {
           const filePath = resolve12(projectDir, srcPath);
           if (existsSync27(filePath)) {
-            compHtml = readFileSync13(filePath, "utf-8");
+            compHtml = readFileSync14(filePath, "utf-8");
           }
         }
         return compHtml;
@@ -95819,17 +96146,33 @@ function inlineSubCompositions2(html, subCompositions, projectDir, variableOverr
     styleEl.textContent = result.styles.join("\n\n");
     head.appendChild(styleEl);
   }
+  const isHoisted = (item) => Boolean(item.integrity?.trim()) || isNonRelativeUrl(item.src);
   if (body) {
     for (const item of result.scriptItems) {
-      if (item.kind === "external") ensureExternalScriptTag(document2, item.src, item);
+      if (item.kind === "external" && isHoisted(item)) {
+        ensureExternalScriptTag(document2, item.src, item);
+      }
     }
   }
   const variablesByCompScript = buildVariablesByCompScript(result.variablesByComp);
-  const inlineScripts = variablesByCompScript ? [variablesByCompScript, ...result.scripts] : result.scripts;
-  if (inlineScripts.length && body) {
-    const scriptEl = document2.createElement("script");
-    scriptEl.textContent = inlineScripts.join("\n;\n");
-    body.appendChild(scriptEl);
+  if (body) {
+    let pending = variablesByCompScript ? [variablesByCompScript] : [];
+    const flushInline = () => {
+      if (!pending.length) return;
+      const scriptEl = document2.createElement("script");
+      scriptEl.textContent = pending.join("\n;\n");
+      body.appendChild(scriptEl);
+      pending = [];
+    };
+    for (const item of result.scriptItems) {
+      if (item.kind === "inline") {
+        pending.push(item.content);
+      } else if (!isHoisted(item)) {
+        flushInline();
+        ensureExternalScriptTag(document2, item.src, item);
+      }
+    }
+    flushInline();
   }
   emitRootCompositionVariableStyles(
     document2,
@@ -96042,7 +96385,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join34(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join35(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote media download failed",
     "Localized remote media source(s)"
   );
@@ -96057,7 +96400,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join34(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join35(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote image download failed",
     "Localized remote image source(s)"
   );
@@ -96073,7 +96416,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join34(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join35(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
@@ -96208,7 +96551,7 @@ async function localizeRemoteFontFaces(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     processed,
-    join34(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join35(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
     (h, url, relPath) => h.replaceAll(`url(${url})`, `url("${relPath}")`)
@@ -96332,7 +96675,7 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
 }
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
   const entryHtml = rebaseDirectEntryAssetPaths(
-    readFileSync13(htmlPath, "utf-8"),
+    readFileSync14(htmlPath, "utf-8"),
     projectDir,
     htmlPath
   );
@@ -96823,13 +97166,13 @@ async function runCompileStage(input) {
     abortSignal
   } = input;
   const compileStart = Date.now();
-  const compiled = await compileForRender(projectDir, htmlPath, join35(workDir, "downloads"), {
+  const compiled = await compileForRender(projectDir, htmlPath, join36(workDir, "downloads"), {
     log,
     failClosedFontFetch: failClosedFontFetch === true,
     allowSystemFontCapture,
     abortSignal,
     variables: input.variables,
-    animatedGifCacheDir: cfg.extractCacheDir ? join35(cfg.extractCacheDir, "animated-gif") : void 0,
+    animatedGifCacheDir: cfg.extractCacheDir ? join36(cfg.extractCacheDir, "animated-gif") : void 0,
     ffmpegProcessTimeout: cfg.ffmpegProcessTimeout
   });
   assertNotAborted();
@@ -96891,7 +97234,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join35(workDir, "compiled"),
+    compiledDir: join36(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -96940,7 +97283,7 @@ init_esm10();
 init_src();
 init_dist2();
 init_dist();
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 
 // ../producer/src/services/render/stages/probeFailures.ts
 var NETWORK_FAILURE_PATTERN = /404|ERR_NAME_NOT_RESOLVED|ERR_CONNECTION_REFUSED|net::ERR_/i;
@@ -97073,7 +97416,7 @@ async function runProbeStage(input) {
     });
     fileServer = await createFileServer2({
       projectDir,
-      compiledDir: join36(workDir, "compiled"),
+      compiledDir: join37(workDir, "compiled"),
       port: 0,
       preHeadScripts: [VIRTUAL_TIME_SHIM],
       fps: job.config.fps
@@ -97099,7 +97442,7 @@ async function runProbeStage(input) {
         log.info("Creating capture session...", { attempt, maxAttempts: PROBE_MAX_ATTEMPTS });
         probeSession = await createCaptureSession(
           fileServer.url,
-          join36(workDir, "probe"),
+          join37(workDir, "probe"),
           captureOpts,
           null,
           probeCfg
@@ -97184,7 +97527,7 @@ async function runProbeStage(input) {
         });
         probeSession = await createCaptureSession(
           fileServer.url,
-          join36(workDir, "probe-screenshot"),
+          join37(workDir, "probe-screenshot"),
           captureOpts,
           null,
           { ...probeCfg, forceScreenshot: true }
@@ -97220,7 +97563,7 @@ async function runProbeStage(input) {
           compiled,
           resolutions,
           projectDir,
-          join36(workDir, "downloads")
+          join37(workDir, "downloads")
         );
         assertNotAborted();
         composition.videos = compiled.videos;
@@ -97399,7 +97742,7 @@ async function runProbeStage(input) {
   try {
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join36(workDir, "compiled"),
+      compiledDir: join37(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -97527,7 +97870,7 @@ function validateRenderDuration(input) {
 // ../producer/src/services/render/stages/extractVideosStage.ts
 init_src();
 import { existsSync as existsSync28 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 // ../producer/src/services/render/extractionFailureMetadata.ts
 function stringOrEmpty(value) {
@@ -97820,7 +98163,7 @@ async function runExtractVideosStage(input) {
       // because short boundary counts can differ by one frame.
       {
         fps: job.config.fps,
-        outputDir: join37(compiledDir, "__hyperframes_video_frames"),
+        outputDir: join38(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
         toneMapHdrToSdr: job.config.hdrMode === "force-sdr",
         timelineEnd: composition.duration,
@@ -97886,7 +98229,7 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
 
 // ../producer/src/services/render/stages/audioStage.ts
 init_src();
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 async function runAudioStage(input) {
   const {
     projectDir,
@@ -97901,7 +98244,7 @@ async function runAudioStage(input) {
     log
   } = input;
   const stage3Start = Date.now();
-  const audioOutputPath = join38(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join39(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -97911,7 +98254,7 @@ async function runAudioStage(input) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join38(workDir, "audio-work"),
+        join39(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -97983,7 +98326,7 @@ async function runAudioStage(input) {
 // ../producer/src/services/render/stages/captureStage.ts
 init_src();
 import { existsSync as existsSync29, readdirSync as readdirSync10, statfsSync as statfsSync2 } from "fs";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 function shouldAllowAdaptiveCaptureRetry(workerCount, _explicitlyConfigured) {
   return workerCount > 1;
 }
@@ -98038,13 +98381,13 @@ function measureCaptureFrameBytes(workDir, framesDir) {
   if (!existsSync29(workDir)) return total;
   for (const attempt of readdirSync10(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join39(workDir, attempt));
+      total += sampleDirectoryBytes(join40(workDir, attempt));
       continue;
     }
     if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join39(workDir, attempt);
+    const attemptDir = join40(workDir, attempt);
     for (const name of readdirSync10(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join39(attemptDir, name));
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join40(attemptDir, name));
     }
   }
   return total;
@@ -98125,19 +98468,20 @@ async function runCaptureStage(input) {
       frameRangeStart: frameRange?.startFrame,
       dedupPerfs,
       onProgress: (progress) => {
+        if (progress.latestWorkerPhase) {
+          if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
+          return;
+        }
         job.framesRendered = progress.capturedFrames;
         checkDiskProjection(progress.capturedFrames);
         const frameProgress = progress.capturedFrames / progress.totalFrames;
-        const progressPct = 25 + frameProgress * 45;
-        if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
-          updateJobStatus(
-            job,
-            "rendering",
-            `Capturing frame ${progress.capturedFrames}/${progress.totalFrames} (${progress.activeWorkers} workers)`,
-            Math.round(progressPct),
-            onProgress
-          );
-        }
+        reportFrameProgress(
+          job,
+          `Capturing frame ${progress.capturedFrames}/${progress.totalFrames} (${progress.activeWorkers} workers)`,
+          Math.round(25 + frameProgress * 45),
+          onProgress,
+          progress.capturedFrames === progress.totalFrames
+        );
       },
       cfg: captureCfg,
       log
@@ -98267,12 +98611,12 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
   const reportFrame = (fileIndex) => {
     job.framesRendered = fileIndex + 1;
     checkDiskProjection(fileIndex + 1);
-    updateJobStatus(
+    reportFrameProgress(
       job,
-      "rendering",
       `Capturing frame ${fileIndex + 1}/${rangeFrames}`,
       Math.round(25 + (fileIndex + 1) / rangeFrames * 45),
-      onProgress
+      onProgress,
+      fileIndex + 1 === rangeFrames
     );
   };
   if (session.workerEncodeEnabled) {
@@ -98320,7 +98664,7 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 init_src();
 init_dist2();
 import { existsSync as existsSync31, mkdirSync as mkdirSync17 } from "fs";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 
 // ../producer/src/services/hdrImageTransferCache.ts
 init_src();
@@ -98384,7 +98728,7 @@ function createHdrImageTransferCache(options = {}) {
 
 // ../producer/src/services/render/stages/captureHdrSequentialLoop.ts
 init_src();
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 async function runSequentialLayeredFrameLoop(input) {
   const {
     job,
@@ -98505,7 +98849,7 @@ async function runSequentialLayeredFrameLoop(input) {
       );
       if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
         writeFileExclusiveSync(
-          join40(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          join41(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
       }
@@ -98525,28 +98869,25 @@ async function runSequentialLayeredFrameLoop(input) {
       log
     });
     job.framesRendered = i + 1;
-    if ((i + 1) % 10 === 0 || i + 1 === totalFrames) {
-      const frameProgress = (i + 1) / totalFrames;
-      updateJobStatus(
-        job,
-        "rendering",
-        `Layered composite frame ${i + 1}/${job.totalFrames}`,
-        Math.round(25 + frameProgress * 55),
-        onProgress
-      );
-    }
+    reportFrameProgress(
+      job,
+      `Layered composite frame ${i + 1}/${job.totalFrames}`,
+      Math.round(25 + (i + 1) / totalFrames * 55),
+      onProgress,
+      i + 1 === totalFrames
+    );
   }
 }
 
 // ../producer/src/services/render/stages/captureHdrHybridLoop.ts
 init_src();
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 
 // ../producer/src/services/shaderTransitionWorkerPool.ts
 import { Worker as Worker2 } from "worker_threads";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL2 } from "url";
-import { dirname as dirname16, join as join41 } from "path";
-import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL2 } from "url";
+import { dirname as dirname17, join as join42 } from "path";
+import { createRequire } from "module";
 import { existsSync as existsSync30 } from "fs";
 import { cpus as cpus3 } from "os";
 function resolveWorkerEntry(explicit) {
@@ -98558,10 +98899,10 @@ function resolveWorkerEntry(explicit) {
     const isTs = override.endsWith(".ts");
     return { path: override, isTs };
   }
-  const moduleDir = dirname16(fileURLToPath4(import.meta.url));
-  const jsPath = join41(moduleDir, "shaderTransitionWorker.js");
+  const moduleDir = dirname17(fileURLToPath5(import.meta.url));
+  const jsPath = join42(moduleDir, "shaderTransitionWorker.js");
   if (existsSync30(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join41(moduleDir, "shaderTransitionWorker.ts");
+  const tsPath = join42(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -98572,7 +98913,7 @@ function buildExecArgv(entryIsTs) {
   );
   if (hasLoader) return inherited;
   try {
-    const require2 = createRequire2(import.meta.url);
+    const require2 = createRequire(import.meta.url);
     const tsxEsm = require2.resolve("tsx/esm");
     inherited.push("--import", pathToFileURL2(tsxEsm).href);
   } catch {
@@ -98826,16 +99167,13 @@ async function runHybridLayeredFrameLoop(input) {
       reorderBuffer.advanceTo(frameIdx + 1);
       framesWritten += 1;
       job.framesRendered = framesWritten;
-      if (framesWritten % 10 === 0 || framesWritten === totalFrames) {
-        const frameProgress = framesWritten / totalFrames;
-        updateJobStatus(
-          job,
-          "rendering",
-          `Layered composite frame ${framesWritten}/${job.totalFrames}`,
-          Math.round(25 + frameProgress * 55),
-          onProgress
-        );
-      }
+      reportFrameProgress(
+        job,
+        `Layered composite frame ${framesWritten}/${job.totalFrames}`,
+        Math.round(25 + framesWritten / totalFrames * 55),
+        onProgress,
+        framesWritten === totalFrames
+      );
     };
     const poolRef = shaderPool;
     const workerTaskOf = async (w) => {
@@ -98931,7 +99269,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join42(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join43(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -99117,7 +99455,7 @@ async function runCaptureHdrStage(input) {
         if (hdrVideoFrameSources.has(v.id)) hdrVideoEndTimes.set(v.id, v.end);
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-      const debugDumpDir = debugDumpEnabled ? join43(framesDir, "debug-composite") : null;
+      const debugDumpDir = debugDumpEnabled ? join44(framesDir, "debug-composite") : null;
       if (debugDumpDir && !existsSync31(debugDumpDir)) {
         mkdirSync17(debugDumpDir, { recursive: true });
       }
@@ -99269,10 +99607,10 @@ async function runCaptureHdrStage(input) {
 // ../producer/src/services/render/stages/encodeStage.ts
 init_src();
 import { copyFileSync as copyFileSync5, existsSync as existsSync32, mkdirSync as mkdirSync18, readdirSync as readdirSync11, rmSync as rmSync13, statSync as statSync11 } from "fs";
-import { dirname as dirname17, join as join45 } from "path";
+import { dirname as dirname18, join as join46 } from "path";
 
 // ../producer/src/services/render/stages/gifEncodeArgs.ts
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 function fpsToFfmpegArg2(fps) {
   return fps.den === 1 ? String(fps.num) : `${fps.num}/${fps.den}`;
 }
@@ -99284,7 +99622,7 @@ function buildGifPalettegenArgs(input) {
     "-framerate",
     fpsArg,
     "-i",
-    join44(input.framesDir, input.framePattern),
+    join45(input.framesDir, input.framePattern),
     "-vf",
     `fps=${fpsArg},palettegen=stats_mode=diff${transparency}`,
     input.palettePath
@@ -99298,7 +99636,7 @@ function buildGifPaletteuseArgs(input) {
     "-framerate",
     fpsArg,
     "-i",
-    join44(input.framesDir, input.framePattern),
+    join45(input.framesDir, input.framePattern),
     "-i",
     input.palettePath,
     "-lavfi",
@@ -99418,11 +99756,11 @@ async function runEncodeStage(input) {
       );
     }
     captured.forEach((name, i) => {
-      const dst = join45(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync5(join45(framesDir, name), dst);
+      const dst = join46(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync5(join46(framesDir, name), dst);
     });
     if (hasAudio && audioOutputPath && existsSync32(audioOutputPath)) {
-      copyFileSync5(audioOutputPath, join45(outputPath, MIXED_AUDIO_FILENAME));
+      copyFileSync5(audioOutputPath, join46(outputPath, MIXED_AUDIO_FILENAME));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME}`
       );
@@ -99441,7 +99779,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join45(dirname17(videoOnlyPath), "gif-palette.png"),
+      palettePath: join46(dirname18(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -99508,7 +99846,7 @@ init_src();
 init_dist2();
 import { spawn as spawn5 } from "child_process";
 import { mkdtempSync as mkdtempSync10, renameSync as renameSync7, rmSync as rmSync14 } from "fs";
-import { dirname as dirname18, join as join46 } from "path";
+import { dirname as dirname19, join as join47 } from "path";
 var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
 var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
 var AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB = 0.5;
@@ -99709,8 +100047,8 @@ async function padOrTrimAudioToVideoFrameCount(input) {
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
-    scratchDir = mkdtempSync10(join46(dirname18(input.audioPath), ".true-peak-"));
-    const correctedPath = join46(scratchDir, "audio.m4a");
+    scratchDir = mkdtempSync10(join47(dirname19(input.audioPath), ".true-peak-"));
+    const correctedPath = join47(scratchDir, "audio.m4a");
     const correctionTargetDbfs = AAC_DELIVERY_TRUE_PEAK_DBFS - AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB;
     const measurements = [];
     let attenuationDb = 0;
@@ -100013,7 +100351,7 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries2) {
-      const full2 = join47(current2, name);
+      const full2 = join48(current2, name);
       try {
         const st = statSync12(full2);
         if (st.isDirectory()) {
@@ -100162,7 +100500,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join47(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join48(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     const missing = !existsSync33(framePath) || statSync12(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
@@ -100185,7 +100523,7 @@ function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, ran
       workerId,
       startFrame: rangeStart + range.startFrame,
       endFrame: rangeStart + range.endFrame,
-      outputDir: join47(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
+      outputDir: join48(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
       outputFrameOffset: rangeStart
     }));
     batches.push(batch);
@@ -100213,8 +100551,8 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform3 = process.platform, systemTempDir = tmpdir7()) {
-  if (platform3 === "win32") return join47(systemTempDir, "hf-render-");
-  return join47(dirname19(outputPath), `work-${jobId}-`);
+  if (platform3 === "win32") return join48(systemTempDir, "hf-render-");
+  return join48(dirname20(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -100246,7 +100584,7 @@ The composition is too large for the available memory. To reduce memory pressure
 function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join47(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join48(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     if (existsSync33(framePath)) captured++;
   }
   return captured;
@@ -100272,7 +100610,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join47(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join48(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -100886,15 +101224,15 @@ function deVerifyFallbackTelemetry(err) {
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
-  const moduleDir = dirname19(fileURLToPath5(import.meta.url));
+  const moduleDir = dirname20(fileURLToPath6(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve13(process.env.PRODUCER_RENDERS_DIR, "..") : resolve13(moduleDir, "../..");
-  const debugDir = join47(producerRoot, ".debug");
-  const outputDir = dirname19(outputPath);
+  const debugDir = join48(producerRoot, ".debug");
+  const outputDir = dirname20(outputPath);
   if (!existsSync33(outputDir)) mkdirSync19(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join47(debugDir, job.id) : mkdtempSync11(resolveRenderWorkDirPrefix(outputPath, job.id));
+  const workDir = job.config.debug ? join48(debugDir, job.id) : mkdtempSync11(resolveRenderWorkDirPrefix(outputPath, job.id));
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join47(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join48(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -100952,7 +101290,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join47(workDir, "perf-summary.json");
+  const perfOutputPath = join48(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -101051,22 +101389,22 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join47(projectDir, entryFile);
+    let htmlPath = join48(projectDir, entryFile);
     if (!existsSync33(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync14(htmlPath, "utf-8");
+    const rawEntry = readFileSync15(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join47(workDir, "standalone-entry.html");
-      const projectIndexPath = join47(projectDir, "index.html");
+      const wrapperPath = join48(workDir, "standalone-entry.html");
+      const projectIndexPath = join48(projectDir, "index.html");
       if (!existsSync33(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
       }
       const standaloneHtml = extractStandaloneEntryFromIndex(
-        readFileSync14(projectIndexPath, "utf-8"),
+        readFileSync15(projectIndexPath, "utf-8"),
         entryFile,
         rawEntry
       );
@@ -101215,7 +101553,7 @@ async function executeRenderPipeline(input) {
       beginFrameStalled: probeResult.beginFrameStalled
     });
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress);
-    const compiledDir = join47(workDir, "compiled");
+    const compiledDir = join48(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -101341,7 +101679,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer2({
           projectDir,
-          compiledDir: join47(workDir, "compiled"),
+          compiledDir: join48(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -101359,8 +101697,9 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join47(workDir, "captured-frames");
+    const framesDir = join48(workDir, "captured-frames");
     if (!existsSync33(framesDir)) mkdirSync19(framesDir, { recursive: true });
+    updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress);
     const resolvedBrowserGpuMode = await resolveBrowserGpuMode(cfg.browserGpuMode, {
       chromePath: resolveHeadlessShellPath(cfg),
       browserTimeout: cfg.browserTimeout
@@ -101553,6 +101892,7 @@ async function executeRenderPipeline(input) {
       }
     });
     if (job.config.workers === void 0 && totalFrames >= 60 && !htmlInCanvasDetected && !cfg.lowMemoryMode && !deInversionEligible && !deParallelRouterEligible) {
+      updateJobStatus(job, "rendering", "Measuring capture speed", 25, onProgress);
       const outcome = await observeRenderStage(
         observability,
         "capture_calibration",
@@ -101768,7 +102108,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join47(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join48(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -102010,7 +102350,7 @@ async function executeRenderPipeline(input) {
           outputHeight: captureCompositionHeight ?? height,
           motionBlur: job.config.motionBlur ? JSON.stringify(job.config.motionBlur) : ""
         });
-        const segmentDir = segmentDirFor(join47(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join48(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -102557,7 +102897,7 @@ async function executeRenderPipeline(input) {
     }
     if (job.config.debug) {
       if (!isPngSequence && !isHls && existsSync33(stagedOutputPath)) {
-        const debugOutput = join47(workDir, `output${videoExt}`);
+        const debugOutput = join48(workDir, `output${videoExt}`);
         copyFileSync6(stagedOutputPath, debugOutput);
       }
     }
@@ -102904,7 +103244,7 @@ import {
   rmSync as rmSync16,
   createReadStream as createReadStream5
 } from "fs";
-import { resolve as resolve15, dirname as dirname21, join as join50 } from "path";
+import { resolve as resolve15, dirname as dirname22, join as join51 } from "path";
 import { tmpdir as tmpdir8 } from "os";
 import { parseArgs } from "util";
 import crypto from "crypto";
@@ -102916,14 +103256,14 @@ import { serve as serve3 } from "@hono/node-server";
 init_dist3();
 import {
   existsSync as existsSync34,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   statSync as statSync13,
   openSync as openSync8,
   fstatSync as fstatSync5,
   closeSync as closeSync9,
   constants as constants5
 } from "fs";
-import { resolve as resolve14, join as join48, relative as relative5, isAbsolute as isAbsolute5, sep as sep4 } from "path";
+import { resolve as resolve14, join as join49, relative as relative5, isAbsolute as isAbsolute5, sep as sep4 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -102961,7 +103301,7 @@ function readEntryHtml(filePath) {
   }
   try {
     if (!fstatSync5(fd).isFile()) return null;
-    return readFileSync15(fd, "utf-8");
+    return readFileSync16(fd, "utf-8");
   } finally {
     closeSync9(fd);
   }
@@ -102990,7 +103330,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join48(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join49(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -103032,8 +103372,8 @@ async function runHyperframeLint(prepared) {
 
 // ../producer/src/services/healthWorker.ts
 import { Worker as Worker3 } from "worker_threads";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname20, join as join49 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import { dirname as dirname21, join as join50 } from "path";
 import { existsSync as existsSync35 } from "fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -103108,8 +103448,8 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname20(fileURLToPath6(import.meta.url));
-  const candidates = [join49(here, "healthWorkerThread.js"), join49(here, "healthWorkerThread.ts")];
+  const here = dirname21(fileURLToPath7(import.meta.url));
+  const candidates = [join50(here, "healthWorkerThread.js"), join50(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync35(candidate)) return candidate;
   }
@@ -103246,7 +103586,7 @@ function buildRenderJobConfig(input, outputPath, log) {
 function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
-  const outputDir = dirname21(absoluteOutputPath);
+  const outputDir = dirname22(absoluteOutputPath);
   if (!existsSync36(outputDir)) mkdirSync20(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
@@ -103314,8 +103654,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir8();
-  const tempProjectDir = mkdtempSync12(join50(tempRoot, "producer-project-"));
-  writeFileSync12(join50(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync12(join51(tempRoot, "producer-project-"));
+  writeFileSync12(join51(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -103766,11 +104106,11 @@ init_src();
 init_dist2();
 init_src();
 import { cpSync as cpSync2, existsSync as existsSync39, mkdirSync as mkdirSync22, renameSync as renameSync8, rmSync as rmSync17, writeFileSync as writeFileSync14 } from "fs";
-import { join as join54, relative as relative8, sep as sep5 } from "path";
+import { join as join55, relative as relative8, sep as sep5 } from "path";
 
 // ../producer/src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync21, readFileSync as readFileSync16, readdirSync as readdirSync13, writeFileSync as writeFileSync13 } from "fs";
-import { join as join51, relative as relative6, resolve as resolve16 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync21, readFileSync as readFileSync17, readdirSync as readdirSync13, writeFileSync as writeFileSync13 } from "fs";
+import { join as join52, relative as relative6, resolve as resolve16 } from "path";
 
 // ../producer/src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
@@ -103812,9 +104152,9 @@ var FIELD_DELIMITER = Buffer.from([0]);
 // ../producer/src/services/distributed/shared.ts
 init_src();
 import { execFile as execFileCallback } from "child_process";
-import { dirname as dirname22, join as join52 } from "path";
-import { existsSync as existsSync38, readFileSync as readFileSync17 } from "fs";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import { dirname as dirname23, join as join53 } from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync18 } from "fs";
+import { fileURLToPath as fileURLToPath8 } from "url";
 import { promisify as promisify5 } from "util";
 var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME;
 var execFile4 = promisify5(execFileCallback);
@@ -103822,7 +104162,7 @@ var execFile4 = promisify5(execFileCallback);
 // ../producer/src/services/distributed/planSize.ts
 import { createHash as createHash12 } from "crypto";
 import { lstatSync as lstatSync5, readdirSync as readdirSync14 } from "fs";
-import { extname as extname7, join as join53, relative as relative7 } from "path";
+import { extname as extname7, join as join54, relative as relative7 } from "path";
 var PLAN_ROOT_CATEGORY = {
   compiled: "compiled",
   [PLAN_AUDIO_RELATIVE_PATH]: "audio",
@@ -103834,9 +104174,9 @@ var PLAN_ROOT_CATEGORY = {
 var PLAN_DIR_SIZE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join54("meta", "composition.json"),
-  join54("meta", "encoder.json"),
-  join54("meta", "chunks.json")
+  join55("meta", "composition.json"),
+  join55("meta", "encoder.json"),
+  join55("meta", "chunks.json")
 ];
 
 // ../producer/src/services/distributed/planV2.ts
@@ -103849,7 +104189,7 @@ import {
   mkdirSync as mkdirSync24,
   mkdtempSync as mkdtempSync14,
   openSync as openSync9,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   readSync as readSync3,
   readdirSync as readdirSync15,
   renameSync as renameSync10,
@@ -103859,7 +104199,7 @@ import {
 } from "fs";
 import { createHash as createHash13 } from "crypto";
 import { tmpdir as tmpdir9 } from "os";
-import { dirname as dirname24, isAbsolute as isAbsolute6, join as join57, relative as relative9, resolve as resolve17, sep as sep6 } from "path";
+import { dirname as dirname25, isAbsolute as isAbsolute6, join as join58, relative as relative9, resolve as resolve17, sep as sep6 } from "path";
 
 // ../producer/src/services/distributed/planV2Publisher.ts
 import {
@@ -103873,15 +104213,15 @@ import {
   statSync as statSync15,
   writeFileSync as writeFileSync15
 } from "fs";
-import { dirname as dirname23, join as join56 } from "path";
+import { dirname as dirname24, join as join57 } from "path";
 
 // ../producer/src/services/distributed/planV2Layout.ts
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 
 // ../producer/src/services/distributed/planV2Execution.ts
 import { mkdtempSync as mkdtempSync16, rmSync as rmSync22 } from "fs";
 import { tmpdir as tmpdir10 } from "os";
-import { join as join60 } from "path";
+import { join as join61 } from "path";
 
 // ../producer/src/services/distributed/assemble.ts
 init_src();
@@ -103891,25 +104231,25 @@ import {
   existsSync as existsSync42,
   mkdirSync as mkdirSync25,
   mkdtempSync as mkdtempSync15,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   readdirSync as readdirSync16,
   rmSync as rmSync20,
   statSync as statSync17,
   writeFileSync as writeFileSync17
 } from "fs";
-import { dirname as dirname25, join as join58 } from "path";
+import { dirname as dirname26, join as join59 } from "path";
 
 // ../producer/src/services/distributed/renderChunk.ts
 init_src();
 import { randomBytes } from "crypto";
-import { existsSync as existsSync43, mkdirSync as mkdirSync26, readFileSync as readFileSync20, readdirSync as readdirSync17, rmSync as rmSync21, writeFileSync as writeFileSync18 } from "fs";
-import { extname as extname8, join as join59 } from "path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync26, readFileSync as readFileSync21, readdirSync as readdirSync17, rmSync as rmSync21, writeFileSync as writeFileSync18 } from "fs";
+import { extname as extname8, join as join60 } from "path";
 init_src();
 
 // ../producer/src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync18, readFileSync as readFileSync21 } from "fs";
+import { readdirSync as readdirSync18, readFileSync as readFileSync22 } from "fs";
 import { createHash as createHash14 } from "crypto";
-import { join as join61, relative as relative10 } from "path";
+import { join as join62, relative as relative10 } from "path";
 
 // src/fontLocalize.ts
 function safeVersion(version2) {
@@ -103950,8 +104290,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.72" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.72" : "0.0.0-dev";
+var VERSION = true ? "0.8.74" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.74" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {