hyperframes 0.8.28 → 0.8.30

package/dist/fontLocalizeCli.js

@@ -17022,7 +17022,7 @@ var require_util = __commonJS({
       return path;
     }
     exports.normalize = normalize;
-    function join57(aRoot, aPath) {
+    function join58(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -17054,7 +17054,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join57;
+    exports.join = join58;
     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 = join57(urlGenerate(parsed), sourceURL);
+        sourceURL = join58(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -50766,17 +50766,87 @@ function setAttr(tag, attr, value) {
 }
 function maskInertRegions(html) {
   const stash = [];
-  const masked = html.replace(INERT_REGION_RE, (region) => {
+  const parts = [];
+  const opening = /<!--|<script\b|<style\b/gi;
+  const closings = /* @__PURE__ */ new Map([
+    ["<!--", /--!?>/g],
+    ["<script", /<\/script\s*>/gi],
+    ["<style", /<\/style\s*>/gi]
+  ]);
+  let cursor = 0;
+  let match;
+  while ((match = opening.exec(html)) !== null) {
+    const kind = match[0].toLowerCase();
+    const closing = closings.get(kind);
+    if (!closing)
+      continue;
+    closing.lastIndex = opening.lastIndex;
+    const end = closing.exec(html) ? closing.lastIndex : -1;
+    if (end < 0) {
+      closings.delete(kind);
+      continue;
+    }
     const token = `\0HFMASK${stash.length}\0`;
-    stash.push(region);
-    return token;
-  });
+    parts.push(html.slice(cursor, match.index), token);
+    stash.push(html.slice(match.index, end));
+    cursor = end;
+    opening.lastIndex = cursor;
+  }
+  parts.push(html.slice(cursor));
+  const masked = parts.join("");
   const restore = (s) => (
     // oxlint-disable-next-line no-control-regex -- NUL cannot appear in HTML, which is what makes it a safe mask delimiter
     s.replace(/\u0000HFMASK(\d+)\u0000/g, (_, i) => stash[Number(i)] ?? "")
   );
   return { masked, restore };
 }
+function* iterateOpeningTags(html, prefix) {
+  let match;
+  while ((match = prefix.exec(html)) !== null) {
+    const closing = html.indexOf(">", prefix.lastIndex);
+    if (closing < 0)
+      break;
+    const end = closing + 1;
+    yield { tag: html.slice(match.index, end), index: match.index, end };
+    prefix.lastIndex = end;
+  }
+}
+function replaceOpeningTags(html, prefix, replace3) {
+  const parts = [];
+  let cursor = 0;
+  for (const { tag, index, end } of iterateOpeningTags(html, prefix)) {
+    parts.push(html.slice(cursor, index), replace3(tag));
+    cursor = end;
+  }
+  parts.push(html.slice(cursor));
+  return parts.join("");
+}
+function replaceIdTags(html, id, replace3) {
+  const idPattern = new RegExp(`id=["']${escapeRegex2(id)}["']`, "gi");
+  const lastClosing = html.lastIndexOf(">");
+  const parts = [];
+  let cursor = 0;
+  let candidate = idPattern.exec(html);
+  for (const { index, end } of iterateOpeningTags(html, /</g)) {
+    if (index < cursor)
+      continue;
+    let targetEnd = -1;
+    while (candidate && candidate.index < end) {
+      const candidateEnd = candidate.index + candidate[0].length;
+      if (candidate.index > index && candidateEnd <= lastClosing)
+        targetEnd = candidateEnd;
+      idPattern.lastIndex = candidate.index + 1;
+      candidate = idPattern.exec(html);
+    }
+    if (targetEnd < 0)
+      continue;
+    const closing = html.indexOf(">", targetEnd) + 1;
+    parts.push(html.slice(cursor, index), replace3(html.slice(index, closing)));
+    cursor = closing;
+  }
+  parts.push(html.slice(cursor));
+  return parts.join("");
+}
 function compileTag(tag, isVideo, generateId) {
   let result = tag;
   let unresolved = null;
@@ -50824,23 +50894,23 @@ function compileTimingAttrs(html) {
   let nextAudioId = 0;
   const { masked, restore } = maskInertRegions(html);
   html = masked;
-  html = html.replace(/<video[^>]*>/gi, (match) => {
+  html = replaceOpeningTags(html, /<video/gi, (match) => {
     const { tag, unresolved: u } = compileTag(match, true, () => nextVideoId++);
     if (u)
       unresolved.push(u);
     return tag;
   });
-  html = html.replace(/<audio[^>]*>/gi, (match) => {
+  html = replaceOpeningTags(html, /<audio/gi, (match) => {
     const { tag, unresolved: u } = compileTag(match, false, () => nextAudioId++);
     if (u)
       unresolved.push(u);
     return tag;
   });
-  html.replace(/<(?:div|section)[^>]*>/gi, (match) => {
+  for (const { tag: match } of iterateOpeningTags(html, /<(?:div|section)/gi)) {
     if (!hasAttr(match, "data-start"))
-      return match;
+      continue;
     if (hasAttr(match, "data-end") || hasAttr(match, "data-duration"))
-      return match;
+      continue;
     const id = getAttr(match, "id");
     const compositionSrc = getAttr(match, "data-composition-src");
     if (id) {
@@ -50854,14 +50924,12 @@ function compileTimingAttrs(html) {
         compositionSrc: compositionSrc ?? void 0
       });
     }
-    return match;
-  });
+  }
   return { html: restore(html), unresolved };
 }
 function injectDurations(html, resolutions) {
   for (const { id, duration } of resolutions) {
-    const idPattern = new RegExp(`(<[^>]*id=["']${escapeRegex2(id)}["'][^>]*>)`, "gi");
-    html = html.replace(idPattern, (tag) => {
+    html = replaceIdTags(html, id, (tag) => {
       let result = tag;
       if (parseStrictFiniteTimingNumber(getAttr(result, "data-duration")) == null) {
         result = setAttr(result, "data-duration", String(duration));
@@ -50883,10 +50951,7 @@ function escapeRegex2(str) {
 function extractResolvedMedia(html) {
   const resolved = [];
   html = maskInertRegions(html).masked;
-  const mediaRegex = /<(?:video|audio)[^>]*>/gi;
-  let match;
-  while ((match = mediaRegex.exec(html)) !== null) {
-    const tag = match[0];
+  for (const { tag } of iterateOpeningTags(html, /<(?:video|audio)/gi)) {
     const id = getAttr(tag, "id");
     const durationStr = getAttr(tag, "data-duration");
     if (!id || durationStr === null)
@@ -50912,8 +50977,7 @@ function extractResolvedMedia(html) {
 }
 function clampDurations(html, clamps) {
   for (const { id, duration } of clamps) {
-    const idPattern = new RegExp(`(<[^>]*id=["']${escapeRegex2(id)}["'][^>]*>)`, "gi");
-    html = html.replace(idPattern, (tag) => {
+    html = replaceIdTags(html, id, (tag) => {
       tag = tag.replace(/data-duration=["'][^"']*["']/, `data-duration="${duration}"`);
       const start = parseNumeric(getAttr(tag, "data-start"));
       if (start != null) {
@@ -50924,14 +50988,13 @@ function clampDurations(html, clamps) {
   }
   return html;
 }
-var MEDIA_DURATION_CLAMP_EPSILON_SECONDS, INERT_REGION_RE;
+var MEDIA_DURATION_CLAMP_EPSILON_SECONDS;
 var init_timingCompiler = __esm({
   "../core/dist/compiler/timingCompiler.js"() {
     "use strict";
     init_compositionContract();
     init_playbackRate();
     MEDIA_DURATION_CLAMP_EPSILON_SECONDS = 0.05;
-    INERT_REGION_RE = /<!--[\s\S]*?-->|<script\b[\s\S]*?<\/script\s*>|<style\b[\s\S]*?<\/style\s*>/gi;
   }
 });
 
@@ -61171,7 +61234,15 @@ var init_renderProvenance = __esm({
 });
 
 // ../engine/src/services/chunkEncoder.ts
-import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import {
+  copyFileSync,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  readdirSync as readdirSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
 import { join as join7, dirname as dirname4, extname } from "path";
 function appendEncodeTimeoutMessage(error, timedOut, timeoutMs) {
   if (!timedOut) return error;
@@ -61483,8 +61554,8 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
   }
   const chunkSize = Math.max(30, Math.floor(chunkSizeFrames));
   const chunkCount = Math.ceil(files.length / chunkSize);
-  const chunkDir = join7(dirname4(outputPath), "chunk-encode");
-  if (!existsSync6(chunkDir)) mkdirSync2(chunkDir, { recursive: true });
+  mkdirSync2(dirname4(outputPath), { recursive: true });
+  const chunkDir = mkdtempSync(join7(dirname4(outputPath), "chunk-encode-"));
   const chunkPaths = [];
   for (let i = 0; i < chunkCount; i++) {
     if (signal?.aborted) {
@@ -62144,7 +62215,7 @@ import {
   existsSync as existsSync8,
   fsyncSync,
   linkSync,
-  mkdtempSync,
+  mkdtempSync as mkdtempSync2,
   mkdirSync as mkdirSync4,
   lstatSync as lstatSync2,
   openSync,
@@ -62793,7 +62864,7 @@ function emitDownloadTelemetry(options, event) {
   }
 }
 async function runDownloadAttempt(url, localPath, timeoutMs, attempt, options, signal) {
-  const attemptDir = mkdtempSync(join8(dirname6(localPath), ".hf-download-"));
+  const attemptDir = mkdtempSync2(join8(dirname6(localPath), ".hf-download-"));
   const partialPath = join8(attemptDir, "payload");
   const controller = new AbortController();
   let timedOut = false;
@@ -77068,8 +77139,8 @@ var init_wavChunks = __esm({
 });
 
 // ../engine/src/services/audioVolumeEnvelope.ts
-import { readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
-import { randomBytes } from "crypto";
+import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname7, join as join12 } from "path";
 function readFmtChunk(buffer, body) {
   const format = buffer.readUInt16LE(body);
   const bits = buffer.readUInt16LE(body + 14);
@@ -77135,17 +77206,26 @@ function scaleSamples(buffer, layout2, gainAt) {
 function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
   const gainAt = createEnvelopeWalker(keyframes, trackStart, baseVolume);
   if (!gainAt) return false;
+  let stagingDir;
   try {
     const buffer = readFileSync3(wavPath);
     const layout2 = parseWavLayout(buffer);
     if (!layout2) return false;
     scaleSamples(buffer, layout2, gainAt);
-    const tempPath = `${wavPath}.${randomBytes(6).toString("hex")}.tmp`;
-    writeFileSync4(tempPath, buffer);
+    stagingDir = mkdtempSync3(join12(dirname7(wavPath), ".hf-volume-"));
+    const tempPath = join12(stagingDir, "audio.wav");
+    writeFileSync4(tempPath, buffer, { flag: "wx" });
     renameSync2(tempPath, wavPath);
     return true;
   } catch {
     return false;
+  } finally {
+    if (stagingDir) {
+      try {
+        rmSync4(stagingDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
   }
 }
 var PCM_FORMAT, FLOAT_FORMAT;
@@ -77234,9 +77314,9 @@ var init_audio_fx_runtime_inline = __esm({
 });
 
 // ../engine/src/services/audioFxRender.ts
-import { existsSync as existsSync11, mkdtempSync as mkdtempSync2, readFileSync as readFileSync4, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, mkdtempSync as mkdtempSync4, readFileSync as readFileSync4, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { pathToFileURL } from "url";
 function readWavChunks(buf) {
   const head = { format: 1, channels: 1, sampleRate: 48e3, bits: 16 };
@@ -77349,7 +77429,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 = mkdtempSync2(join12(tmpdir2(), "hf-fx-host-"));
+  const hostDir = mkdtempSync4(join13(tmpdir2(), "hf-fx-host-"));
   let lease = null;
   try {
     if (options.signal?.aborted) {
@@ -77358,7 +77438,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 = join12(hostDir, "audio-fx.html");
+      const hostPage = join13(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() });
@@ -77386,7 +77466,7 @@ async function applyAudioFxChain(inputWav, chain, outputWav, options) {
       `Audio FX failed for track ${options.trackId}: ${err.message}`
     );
   } finally {
-    rmSync4(hostDir, { recursive: true, force: true });
+    rmSync5(hostDir, { recursive: true, force: true });
     await lease?.release().catch(() => void 0);
   }
 }
@@ -77494,8 +77574,8 @@ var init_audioFxRender = __esm({
 });
 
 // ../engine/src/services/audioMixer.ts
-import { closeSync as closeSync2, existsSync as existsSync12, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, openSync as openSync2, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13, dirname as dirname7 } from "path";
+import { closeSync as closeSync2, existsSync as existsSync12, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync5, openSync as openSync2, rmSync as rmSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14, dirname as dirname8 } from "path";
 function memberGroupKey(el) {
   return el.getAttribute(AUDIO_GROUP_RENDER_ID_ATTR) ?? el.getAttribute(HF_AUDIO_GROUP_ATTR);
 }
@@ -77798,7 +77878,7 @@ function parseAudioElements(html) {
 }
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname7(outputPath);
+  const outputDir = dirname8(outputPath);
   if (!existsSync12(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const playbackRate = normalizePlaybackRate(options?.playbackRate ?? 1);
   const args = [];
@@ -77842,7 +77922,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 = dirname7(outputPath);
+  const outputDir = dirname8(outputPath);
   if (!existsSync12(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const normalizedPlaybackRate = normalizePlaybackRate(playbackRate);
   const outputArgs = await preparedAudioOutputArgs(srcPath, normalizedPlaybackRate);
@@ -77889,7 +77969,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 = dirname7(outputPath);
+  const outputDir = dirname8(outputPath);
   if (!existsSync12(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const args = [
     "-f",
@@ -77943,7 +78023,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
       failures: result2.failure ? [result2.failure] : void 0
     };
   }
-  const outputDir = dirname7(outputPath);
+  const outputDir = dirname8(outputPath);
   if (!existsSync12(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildFilterComplex = (ignoreAutomation) => {
     const filterParts = [];
@@ -77964,8 +78044,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 = mkdtempSync3(join13(outputDir, ".filter-complex-"));
-    const scriptPath = join13(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync5(join14(outputDir, ".filter-complex-"));
+    const scriptPath = join14(scriptDir, "graph.txt");
     const fd = openSync2(scriptPath, "wx", 384);
     try {
       writeFileSync6(fd, buildFilterComplex(ignoreAutomation));
@@ -77996,7 +78076,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
       currentArgs[currentArgs.indexOf("-filter_complex_script")] = "-/filter_complex";
       return await runFfmpeg(currentArgs, { signal, timeout: ffmpegProcessTimeout });
     } finally {
-      rmSync5(scriptDir, { recursive: true, force: true });
+      rmSync6(scriptDir, { recursive: true, force: true });
     }
   };
   let result = await runMix(false);
@@ -78051,7 +78131,7 @@ function groupNormalizeOptionUnsupported(stderr) {
 }
 async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname7(outputPath);
+  const outputDir = dirname8(outputPath);
   if (!existsSync12(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildInputFilters = (ignoreKeyframes) => memberTracks.map((track, i) => {
     const delayMs = Math.round(track.start * 1e3);
@@ -78071,8 +78151,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 = mkdtempSync3(join13(outputDir, ".group-filter-complex-"));
-    const scriptPath = join13(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync5(join14(outputDir, ".group-filter-complex-"));
+    const scriptPath = join14(scriptDir, "graph.txt");
     const fd = openSync2(scriptPath, "wx", 384);
     try {
       writeFileSync6(fd, filterComplex);
@@ -78112,7 +78192,7 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
       currentArgs[currentArgs.indexOf("-filter_complex_script")] = "-/filter_complex";
       return await runFfmpeg(currentArgs, { signal, timeout: ffmpegProcessTimeout });
     } finally {
-      rmSync5(scriptDir, { recursive: true, force: true });
+      rmSync6(scriptDir, { recursive: true, force: true });
     }
   };
   let useNormalize = true;
@@ -78222,7 +78302,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join13(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join14(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -78249,7 +78329,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join13(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join14(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -78293,7 +78373,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           const fxResult = await applyAudioFxChain(
             audioSrcPath,
             chain,
-            join13(workDir, `${element.id}-fx.wav`),
+            join14(workDir, `${element.id}-fx.wav`),
             {
               trackId: element.id,
               signal: effectiveSignal,
@@ -78355,14 +78435,14 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   ).catch((err) => {
     internalController.abort();
     try {
-      rmSync5(workDir, { recursive: true, force: true });
+      rmSync6(workDir, { recursive: true, force: true });
     } catch {
     }
     throw err;
   });
   const bail = () => {
     try {
-      rmSync5(workDir, { recursive: true, force: true });
+      rmSync6(workDir, { recursive: true, force: true });
     } catch {
     }
     return {
@@ -78384,7 +78464,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
     const meta = groupMeta.get(groupId);
     if (!meta) continue;
     const pathId = safePathSegment(groupId, groupIndex);
-    const groupWavPath = join13(workDir, `group-${pathId}.wav`);
+    const groupWavPath = join14(workDir, `group-${pathId}.wav`);
     try {
       const subMix = await mixGroupMembers(
         memberTracks,
@@ -78420,7 +78500,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         const fxResult = await applyAudioFxChain(
           groupSrcPath,
           chain,
-          join13(workDir, `group-${pathId}-fx.wav`),
+          join14(workDir, `group-${pathId}-fx.wav`),
           {
             trackId: groupId,
             signal: effectiveSignal,
@@ -78469,7 +78549,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   if (failures.length > 0) return bail();
   const mixResult = await mixAudioTracks(tracks, outputPath, totalDuration, signal, config);
   try {
-    rmSync5(workDir, { recursive: true, force: true });
+    rmSync6(workDir, { recursive: true, force: true });
   } catch {
   }
   const degradedNote = groupsDegradedAutomation.length > 0 ? `Volume automation exceeded this ffmpeg build's expression limits in group(s) ${groupsDegradedAutomation.join(", ")}; rendered at base volume` : void 0;
@@ -78518,14 +78598,14 @@ var init_audioMixer = __esm({
 import { execFile as execFile2 } from "child_process";
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { promisify as promisify2 } from "util";
 async function psnrDb(a, b) {
   const execFileP = promisify2(execFile2);
-  const dir = await mkdtemp(join14(tmpdir3(), "hf-de-verify-"));
+  const dir = await mkdtemp(join15(tmpdir3(), "hf-de-verify-"));
   try {
-    const pa = join14(dir, "a.jpg");
-    const pb = join14(dir, "b.jpg");
+    const pa = join15(dir, "a.jpg");
+    const pb = join15(dir, "b.jpg");
     await Promise.all([writeFile(pa, a), writeFile(pb, b)]);
     const { stderr } = await execFileP(
       getFfmpegBinary(),
@@ -78636,7 +78716,7 @@ var init_readWebGlVendorInfoFromCanvas = __esm({
 import { cpus, freemem } from "os";
 import { existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile, rename } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { getHeapStatistics } from "v8";
 function defaultSafeMaxWorkers() {
   return Math.max(6, Math.min(16, Math.floor(cpus().length / 8)));
@@ -78765,7 +78845,7 @@ function distributeFrames(totalFrames, workerCount, workDir, rangeStart = 0) {
       workerId: i,
       startFrame,
       endFrame,
-      outputDir: join15(workDir, `worker-${i}`),
+      outputDir: join16(workDir, `worker-${i}`),
       outputFrameOffset: rangeStart
     });
   }
@@ -78779,7 +78859,7 @@ function distributeFramesInterleaved(totalFrames, workerCount, workDir, rangeSta
       startFrame: rangeStart + i,
       endFrame: rangeStart + totalFrames,
       frameStride: workerCount,
-      outputDir: join15(workDir, `worker-${i}`),
+      outputDir: join16(workDir, `worker-${i}`),
       outputFrameOffset: rangeStart
     });
   }
@@ -78937,7 +79017,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 = join15(task.outputDir, `frame_${String(idx - offset2).padStart(6, "0")}.${ext}`);
+    const framePath = join16(task.outputDir, `frame_${String(idx - offset2).padStart(6, "0")}.${ext}`);
     const db = await psnrForDiskSample(framePath, truth, task.workerId, idx);
     if (db === null) continue;
     assertDiskSampleAboveFloor(db, verifyMinDb, idx, task.workerId);
@@ -79103,8 +79183,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 = join15(task.outputDir, file);
-      const targetPath = join15(outputDir, file);
+      const sourcePath = join16(task.outputDir, file);
+      const targetPath = join16(outputDir, file);
       try {
         await rename(sourcePath, targetPath);
       } catch {
@@ -79149,8 +79229,25 @@ var init_parallelCoordinator = __esm({
 // ../engine/src/services/fileServer.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync5, existsSync as existsSync14, statSync as statSync6 } from "fs";
-import { join as join16, extname as extname3 } from "path";
+import { readFileSync as readFileSync5, openSync as openSync3, fstatSync, closeSync as closeSync3, statSync as statSync6, constants as constants2 } from "fs";
+import { join as join17, extname as extname3 } from "path";
+function readRegularFile(filePath) {
+  let fd;
+  try {
+    fd = openSync3(filePath, constants2.O_RDONLY | constants2.O_NONBLOCK);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
+      return null;
+    if (!statSync6(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    throw error;
+  }
+  try {
+    if (!fstatSync(fd).isFile()) return null;
+    return readFileSync5(fd);
+  } finally {
+    closeSync3(fd);
+  }
+}
 function createFileServer(options) {
   const { projectDir, compiledDir, port = 0, stripEmbeddedRuntime = true } = options;
   const headScripts = options.headScripts ?? [];
@@ -79160,22 +79257,16 @@ function createFileServer(options) {
     let requestPath = c.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join16(compiledDir, relativePath) : null;
-    const hasCompiledFile = Boolean(
-      compiledPath && existsSync14(compiledPath) && statSync6(compiledPath).isFile()
-    );
-    const filePath = hasCompiledFile ? compiledPath : join16(projectDir, relativePath);
-    if (!existsSync14(filePath) || !statSync6(filePath).isFile()) {
-      return c.text("Not found", 404);
-    }
-    const ext = extname3(filePath).toLowerCase();
+    const compiledPath = compiledDir ? join17(compiledDir, relativePath) : null;
+    const content = (compiledPath ? readRegularFile(compiledPath) : null) ?? readRegularFile(join17(projectDir, relativePath));
+    if (content === null) return c.text("Not found", 404);
+    const ext = extname3(relativePath).toLowerCase();
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     if (ext === ".html") {
-      const rawHtml = readFileSync5(filePath, "utf-8");
+      const rawHtml = content.toString("utf-8");
       const html = relativePath === "index.html" ? injectScriptsIntoHtml(rawHtml, headScripts, bodyScripts, stripEmbeddedRuntime) : rawHtml;
       return c.text(html, 200, { "Content-Type": contentType });
     }
-    const content = readFileSync5(filePath);
     return new Response(content, {
       status: 200,
       headers: { "Content-Type": contentType }
@@ -79730,15 +79821,13 @@ function normalizeObjectFit(value) {
 }
 function parseTransformMatrix(css) {
   if (!css || css === "none") return null;
-  const match2d = css.match(
-    /^matrix\(\s*([^,]+),\s*([^,]+),\s*([^,]+),\s*([^,]+),\s*([^,]+),\s*([^,)]+)\s*\)$/
-  );
+  const match2d = css.match(/^matrix\(([^,]+),([^,]+),([^,]+),([^,]+),([^,]+),([^,)]+)\)$/);
   if (match2d) {
     const values = match2d.slice(1, 7).map(Number);
     if (!values.every(Number.isFinite)) return null;
     return values;
   }
-  const match3d = css.match(/^matrix3d\(\s*([^)]+)\)$/);
+  const match3d = css.match(/^matrix3d\(([^)]+)\)$/);
   if (match3d) {
     const raw = match3d[1];
     if (!raw) return null;
@@ -80621,8 +80710,8 @@ var init_shaderTransitions = __esm({
 });
 
 // ../engine/src/services/hdrCapture.ts
-import { existsSync as existsSync15, readdirSync as readdirSync7 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync7 } from "fs";
+import { join as join18 } from "path";
 import { homedir as homedir2 } from "os";
 function linearToPQ(L) {
   const Lp = Math.max(0, L * SDR_NITS / PQ_MAX_NITS);
@@ -80738,12 +80827,12 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   return output;
 }
 function resolveHeadedChromePath() {
-  const baseDir = join17(homedir2(), ".cache", "puppeteer", "chrome");
-  if (!existsSync15(baseDir)) return void 0;
+  const baseDir = join18(homedir2(), ".cache", "puppeteer", "chrome");
+  if (!existsSync14(baseDir)) return void 0;
   const versions = readdirSync7(baseDir).sort().reverse();
   for (const version2 of versions) {
     const candidates = [
-      join17(
+      join18(
         baseDir,
         version2,
         "chrome-mac-arm64",
@@ -80752,7 +80841,7 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join17(
+      join18(
         baseDir,
         version2,
         "chrome-mac-x64",
@@ -80761,11 +80850,11 @@ function resolveHeadedChromePath() {
         "MacOS",
         "Google Chrome for Testing"
       ),
-      join17(baseDir, version2, "chrome-linux64", "chrome"),
-      join17(baseDir, version2, "chrome-win64", "chrome.exe")
+      join18(baseDir, version2, "chrome-linux64", "chrome"),
+      join18(baseDir, version2, "chrome-win64", "chrome.exe")
     ];
     for (const binary of candidates) {
-      if (existsSync15(binary)) return binary;
+      if (existsSync14(binary)) return binary;
     }
   }
   return void 0;
@@ -84240,16 +84329,16 @@ __export(fontCompression_exports, {
 });
 import { createHash as createHash6 } from "crypto";
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync10,
-  mkdtempSync as mkdtempSync5,
+  mkdtempSync as mkdtempSync7,
   readFileSync as readFileSync7,
   renameSync as renameSync4,
-  rmSync as rmSync8,
+  rmSync as rmSync9,
   writeFileSync as writeFileSync8
 } from "fs";
 import { homedir as homedir4, tmpdir as tmpdir4 } from "os";
-import { dirname as dirname11, join as join24 } from "path";
+import { dirname as dirname12, join as join25 } from "path";
 async function compressToWoff2(input) {
   return Buffer.from(await compress(input));
 }
@@ -84257,16 +84346,16 @@ 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 ? join24(tmpdir4(), "hyperframes", "fonts") : join24(homedir4(), ".cache", "hyperframes", "fonts"));
-  return join24(root, "local-compression-v1");
+  const root = process.env.HYPERFRAMES_FONT_CACHE_DIR ?? (process.env.AWS_LAMBDA_FUNCTION_NAME ? join25(tmpdir4(), "hyperframes", "fonts") : join25(homedir4(), ".cache", "hyperframes", "fonts"));
+  return join25(root, "local-compression-v1");
 }
 function cachedCompressionPath(input, originalFormat, cacheDir) {
   const digest = createHash6("sha256").update("hyperframes-local-font-compression-v1\0").update(originalFormat).update("\0").update(input).digest("hex");
-  return join24(cacheDir, `${digest}.woff2`);
+  return join25(cacheDir, `${digest}.woff2`);
 }
 function readCachedCompression(path) {
   try {
-    if (!existsSync21(path)) return null;
+    if (!existsSync20(path)) return null;
     const cached2 = readFileSync7(path);
     return cached2.length > 0 ? cached2 : null;
   } catch {
@@ -84276,15 +84365,15 @@ function readCachedCompression(path) {
 function cacheCompression(path, compressed) {
   let tempDir;
   try {
-    mkdirSync10(dirname11(path), { recursive: true });
-    tempDir = mkdtempSync5(join24(dirname11(path), ".compression-"));
-    const tmpPath = join24(tempDir, "font.woff2");
+    mkdirSync10(dirname12(path), { recursive: true });
+    tempDir = mkdtempSync7(join25(dirname12(path), ".compression-"));
+    const tmpPath = join25(tempDir, "font.woff2");
     writeFileSync8(tmpPath, compressed, { flag: "wx", mode: 420 });
     renameSync4(tmpPath, path);
   } catch {
   } finally {
     try {
-      if (tempDir) rmSync8(tempDir, { recursive: true, force: true });
+      if (tempDir) rmSync9(tempDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -84332,19 +84421,19 @@ init_esm10();
 init_dist2();
 init_src();
 import {
-  existsSync as existsSync30,
+  existsSync as existsSync29,
   mkdirSync as mkdirSync17,
-  mkdtempSync as mkdtempSync9,
+  mkdtempSync as mkdtempSync11,
   readFileSync as readFileSync12,
   readdirSync as readdirSync11,
-  rmSync as rmSync13,
+  rmSync as rmSync14,
   statSync as statSync10,
   writeFileSync as writeFileSync10,
   copyFileSync as copyFileSync6,
   appendFileSync
 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join42, dirname as dirname17, resolve as resolve13 } from "path";
+import { join as join43, dirname as dirname18, resolve as resolve13 } from "path";
 import { totalmem as totalmem3 } from "os";
 import { randomUUID as randomUUID3 } from "crypto";
 import { fileURLToPath as fileURLToPath5 } from "url";
@@ -84354,17 +84443,27 @@ init_compiler();
 init_dist2();
 import { Hono as Hono2 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
-import { existsSync as existsSync17, realpathSync as realpathSync2, statSync as statSync7, createReadStream as createReadStream3 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
+import {
+  existsSync as existsSync16,
+  realpathSync as realpathSync2,
+  statSync as statSync7,
+  createReadStream as createReadStream3,
+  openSync as openSync4,
+  fstatSync as fstatSync2,
+  closeSync as closeSync4,
+  constants as constants3,
+  readFile as readFile2
+} from "fs";
+import { promisify as promisify3 } from "util";
 import { Readable as Readable2 } from "stream";
-import { join as join18, extname as extname4, resolve as resolve7, sep as sep3 } from "path";
+import { join as join19, 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 readFileSync6 } from "fs";
-import { dirname as dirname8, resolve as resolve6 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname9, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var PRODUCER_DIR = dirname8(fileURLToPath2(import.meta.url));
+var PRODUCER_DIR = dirname9(fileURLToPath2(import.meta.url));
 var SIBLING_MANIFEST_PATH = resolve6(PRODUCER_DIR, "hyperframe.manifest.json");
 var MODULE_RELATIVE_MANIFEST_PATH = resolve6(
   PRODUCER_DIR,
@@ -84382,7 +84481,7 @@ function resolveHyperframeManifestPath() {
   if (envOverride) {
     return envOverride;
   }
-  const found = MANIFEST_CANDIDATES.find((candidate) => existsSync16(candidate));
+  const found = MANIFEST_CANDIDATES.find((candidate) => existsSync15(candidate));
   return found ?? MODULE_RELATIVE_MANIFEST_PATH;
 }
 function triedManifestPaths() {
@@ -84393,7 +84492,7 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync16(manifestPath)) {
+  if (!existsSync15(manifestPath)) {
     const tried = triedManifestPaths().join(", ");
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest. Tried: ${tried}. Searched from cwd=${process.cwd()}. Build core runtime artifacts before rendering.`
@@ -84407,8 +84506,8 @@ function resolveVerifiedHyperframeRuntime() {
       `[HyperframeRuntimeLoader] Invalid manifest at ${manifestPath}; missing iife artifact or sha256.`
     );
   }
-  const runtimePath = resolve6(dirname8(manifestPath), runtimeFileName);
-  if (!existsSync16(runtimePath)) {
+  const runtimePath = resolve6(dirname9(manifestPath), runtimeFileName);
+  if (!existsSync15(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
   const runtimeSource = readFileSync6(runtimePath, "utf8");
@@ -84473,14 +84572,15 @@ function createConsoleLogger(level = "info") {
 var defaultLogger = createConsoleLogger("info");
 
 // ../producer/src/services/fileServer.ts
+var readFileAsync = promisify3(readFile2);
 function isPathInside2(child, parent, options = {}) {
   const { resolveSymlinks = false, pathModule } = options;
   const resolveFn = pathModule?.resolve ?? resolve7;
   const separator = pathModule?.sep ?? sep3;
   const resolvedChild = resolveFn(child);
   const resolvedParent = resolveFn(parent);
-  const normalizedChild = resolveSymlinks && existsSync17(resolvedChild) ? realpathSync2.native(resolvedChild) : resolvedChild;
-  const normalizedParent = resolveSymlinks && existsSync17(resolvedParent) ? realpathSync2.native(resolvedParent) : resolvedParent;
+  const normalizedChild = resolveSymlinks && existsSync16(resolvedChild) ? realpathSync2.native(resolvedChild) : resolvedChild;
+  const normalizedParent = resolveSymlinks && existsSync16(resolvedParent) ? realpathSync2.native(resolvedParent) : resolvedParent;
   if (normalizedChild === normalizedParent) return true;
   const parentWithSep = normalizedParent.endsWith(separator) ? normalizedParent : normalizedParent + separator;
   return normalizedChild.startsWith(parentWithSep);
@@ -84930,6 +85030,26 @@ function closeFileServerSafely(fileServer, label, log = defaultLogger) {
     });
   }
 }
+function openRegularFile(filePath) {
+  let fd;
+  try {
+    fd = openSync4(filePath, constants3.O_RDONLY | constants3.O_NONBLOCK);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
+      return null;
+    if (!statSync7(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    throw error;
+  }
+  let accepted = false;
+  try {
+    const stat = fstatSync2(fd);
+    if (!stat.isFile()) return null;
+    accepted = true;
+    return { fd, stat, filePath };
+  } finally {
+    if (!accepted) closeSync4(fd);
+  }
+}
 function createFileServer2(options) {
   const { projectDir, compiledDir, port = 0, stripEmbeddedRuntime = true } = options;
   const preHeadScripts = [
@@ -84950,76 +85070,73 @@ function createFileServer2(options) {
         return seg;
       }
     }).join("/");
-    let filePath = null;
-    if (compiledDir) {
-      const candidate = join18(compiledDir, relativePath);
-      if (existsSync17(candidate) && isPathInside2(candidate, compiledDir) && statSync7(candidate).isFile()) {
-        filePath = candidate;
-      }
-    }
-    if (!filePath) {
-      const candidate = join18(projectDir, relativePath);
-      if (existsSync17(candidate) && isPathInside2(candidate, projectDir) && statSync7(candidate).isFile()) {
-        filePath = candidate;
-      }
+    let file = null;
+    for (const root of compiledDir ? [compiledDir, projectDir] : [projectDir]) {
+      const candidate = join19(root, relativePath);
+      if (isPathInside2(candidate, root)) file = openRegularFile(candidate);
+      if (file) break;
     }
-    if (!filePath) {
+    if (!file) {
       if (!/favicon\.ico$/i.test(requestPath)) {
         console.warn(`[FileServer] 404 Not Found: ${requestPath}`);
       }
       return c.text("Not found", 404);
     }
-    const ext = extname4(filePath).toLowerCase();
-    const contentType = MIME_TYPES2[ext] || "application/octet-stream";
-    if (ext === ".html") {
-      const rawHtml = await readFile2(filePath, "utf-8");
-      const isIndex = relativePath === "index.html";
-      let html = rawHtml;
-      if (preHeadScripts.length > 0) {
-        html = injectScriptsAtHeadStart(html, preHeadScripts);
+    const { fd, stat, filePath } = file;
+    let streamOwnsFd = false;
+    try {
+      const ext = extname4(filePath).toLowerCase();
+      const contentType = MIME_TYPES2[ext] || "application/octet-stream";
+      if (ext === ".html") {
+        const rawHtml = await readFileAsync(fd, "utf-8");
+        const isIndex = relativePath === "index.html";
+        let html = rawHtml;
+        if (preHeadScripts.length > 0) {
+          html = injectScriptsAtHeadStart(html, preHeadScripts);
+        }
+        html = isIndex ? injectScriptsIntoHtml(html, headScripts, bodyScripts, stripEmbeddedRuntime) : html;
+        return c.text(html, 200, { "Content-Type": contentType });
+      }
+      const totalSize = stat.size;
+      const rangeHeader = c.req.header("range");
+      const rangeRequest = parseRangeHeader(rangeHeader, totalSize);
+      if (rangeRequest.kind === "unsatisfiable") {
+        return new Response(null, {
+          status: 416,
+          headers: {
+            "Content-Type": contentType,
+            "Content-Range": `bytes */${totalSize}`,
+            "Accept-Ranges": "bytes"
+          }
+        });
       }
-      html = isIndex ? injectScriptsIntoHtml(html, headScripts, bodyScripts, stripEmbeddedRuntime) : html;
-      return c.text(html, 200, { "Content-Type": contentType });
-    }
-    const stat = statSync7(filePath);
-    const totalSize = stat.size;
-    const rangeHeader = c.req.header("range");
-    const rangeRequest = parseRangeHeader(rangeHeader, totalSize);
-    if (rangeRequest.kind === "unsatisfiable") {
-      return new Response(null, {
-        status: 416,
-        headers: {
-          "Content-Type": contentType,
-          "Content-Range": `bytes */${totalSize}`,
-          "Accept-Ranges": "bytes"
-        }
-      });
-    }
-    if (rangeRequest.kind === "satisfiable") {
-      const { start, end } = rangeRequest;
-      const length = end - start + 1;
-      const stream2 = createReadStream3(filePath, { start, end });
-      const webStream2 = Readable2.toWeb(stream2);
-      return new Response(webStream2, {
-        status: 206,
+      const range = rangeRequest.kind === "satisfiable" ? rangeRequest : null;
+      const responseOptions = {
+        status: range ? 206 : 200,
         headers: {
           "Content-Type": contentType,
-          "Content-Length": String(length),
-          "Content-Range": `bytes ${start}-${end}/${totalSize}`,
-          "Accept-Ranges": "bytes"
+          "Content-Length": String(range ? range.end - range.start + 1 : totalSize),
+          "Accept-Ranges": "bytes",
+          ...range ? { "Content-Range": `bytes ${range.start}-${range.end}/${totalSize}` } : {}
         }
+      };
+      if (c.req.method === "HEAD") return new Response(null, responseOptions);
+      const stream = createReadStream3(filePath, {
+        fd,
+        autoClose: true,
+        ...range ? { start: range.start, end: range.end } : {}
       });
-    }
-    const stream = createReadStream3(filePath);
-    const webStream = Readable2.toWeb(stream);
-    return new Response(webStream, {
-      status: 200,
-      headers: {
-        "Content-Type": contentType,
-        "Content-Length": String(totalSize),
-        "Accept-Ranges": "bytes"
+      streamOwnsFd = true;
+      try {
+        const webStream = Readable2.toWeb(stream);
+        return new Response(webStream, responseOptions);
+      } catch (error) {
+        stream.destroy();
+        throw error;
       }
-    });
+    } finally {
+      if (!streamOwnsFd) closeSync4(fd);
+    }
   });
   return new Promise((resolve18) => {
     const connections = /* @__PURE__ */ new Set();
@@ -85057,18 +85174,18 @@ init_dist2();
 import {
   copyFileSync as copyFileSync3,
   cpSync,
-  existsSync as existsSync18,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync9,
-  rmSync as rmSync6,
+  rmSync as rmSync7,
   symlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute2, join as join20, relative, resolve as resolve8 } from "path";
+import { basename as basename4, dirname as dirname10, isAbsolute as isAbsolute2, join as join21, relative, resolve as resolve8 } from "path";
 
 // ../producer/src/utils/paths.ts
 import {
   basename as basename3,
-  join as join19,
+  join as join20,
   resolve as nodeResolve,
   relative as nodeRelative,
   isAbsolute as nodeIsAbsolute
@@ -85106,7 +85223,7 @@ function formatExportFrameName(index, ext) {
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
   const absoluteProjectDir = nodeResolve(projectDir);
   const projectName = basename3(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join19(rendersDir, `${projectName}.mp4`);
+  const resolvedOutputPath = outputPath ?? join20(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = nodeResolve(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
@@ -85143,21 +85260,21 @@ function resolveDeviceScaleFactor(input) {
   return target.width / input.compositionWidth;
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join20(workDir, "compiled");
+  const compileDir = join21(workDir, "compiled");
   mkdirSync9(compileDir, { recursive: true });
-  writeFileSync7(join20(compileDir, "index.html"), compiled.html, "utf-8");
+  writeFileSync7(join21(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join20(compileDir, srcPath);
-    mkdirSync9(dirname9(outPath), { recursive: true });
+    const outPath = join21(compileDir, srcPath);
+    mkdirSync9(dirname10(outPath), { recursive: true });
     writeFileSync7(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve8(join20(compileDir, relativePath));
+    const outPath = resolve8(join21(compileDir, relativePath));
     if (!isPathInside3(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
     }
-    mkdirSync9(dirname9(outPath), { recursive: true });
+    mkdirSync9(dirname10(outPath), { recursive: true });
     copyFileSync3(absolutePath, outPath);
   }
   if (includeSummary) {
@@ -85183,7 +85300,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       renderModeHints: compiled.renderModeHints,
       hasShaderTransitions: compiled.hasShaderTransitions
     };
-    writeFileSync7(join20(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync7(join21(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(alreadyForced, compiled, log = defaultLogger) {
@@ -85210,18 +85327,18 @@ function updateJobStatus(job, status, stage, progress, onProgress) {
 }
 var materializePathModule = {
   resolve: resolve8,
-  join: join20,
-  dirname: dirname9,
+  join: join21,
+  dirname: dirname10,
   basename: basename4,
   relative,
   isAbsolute: isAbsolute2
 };
 var materializeFileSystem = {
-  existsSync: existsSync18,
+  existsSync: existsSync17,
   mkdirSync: mkdirSync9,
   symlinkSync,
   cpSync,
-  rmSync: rmSync6
+  rmSync: rmSync7
 };
 function createMemorySampler(intervalMs = 250) {
   let peakRss = 0;
@@ -85487,26 +85604,26 @@ var RenderExecutionContext = class {
 
 // ../producer/src/services/render/artifactTransaction.ts
 import {
-  closeSync as closeSync3,
-  existsSync as existsSync19,
-  fstatSync,
-  mkdtempSync as mkdtempSync4,
-  openSync as openSync3,
+  closeSync as closeSync5,
+  existsSync as existsSync18,
+  fstatSync as fstatSync3,
+  mkdtempSync as mkdtempSync6,
+  openSync as openSync5,
   readSync,
   readdirSync as readdirSync8,
   renameSync as renameSync3,
-  rmSync as rmSync7
+  rmSync as rmSync8
 } from "fs";
-import { basename as basename5, dirname as dirname10, extname as extname5, join as join21, resolve as resolve9 } from "path";
+import { basename as basename5, dirname as dirname11, extname as extname5, join as join22, resolve as resolve9 } from "path";
 
 // ../producer/src/utils/ffprobe.ts
 init_src();
 
 // ../producer/src/services/render/artifactTransaction.ts
 var defaultFileSystem = {
-  existsSync: existsSync19,
+  existsSync: existsSync18,
   renameSync: renameSync3,
-  rmSync: rmSync7
+  rmSync: rmSync8
 };
 async function defaultArtifactDurationProbe(path) {
   const meta = await extractMediaMetadata(path);
@@ -85516,28 +85633,28 @@ async function defaultArtifactDurationProbe(path) {
   };
 }
 function createSiblingTransactionDirectory(destination) {
-  const parent = dirname10(destination);
+  const parent = dirname11(destination);
   const extension = extname5(destination);
   const stem = extension ? basename5(destination, extension) : basename5(destination);
-  return mkdtempSync4(join21(parent, `.${stem}.hf-transaction-`));
+  return mkdtempSync6(join22(parent, `.${stem}.hf-transaction-`));
 }
 function assertReadableNonEmptyFile(path) {
-  const fd = openSync3(path, "r");
+  const fd = openSync5(path, "r");
   try {
-    const stat = fstatSync(fd);
+    const stat = fstatSync3(fd);
     if (!stat.isFile() || stat.size <= 0) {
       throw new Error(`Render artifact is not a non-empty file: ${path}`);
     }
     readSync(fd, Buffer.allocUnsafe(1), 0, 1, 0);
   } finally {
-    closeSync3(fd);
+    closeSync5(fd);
   }
 }
 function collectDirectoryFiles(root) {
   const files = [];
   const visit = (directory) => {
     for (const entry of readdirSync8(directory, { withFileTypes: true })) {
-      const path = join21(directory, entry.name);
+      const path = join22(directory, entry.name);
       if (entry.isDirectory()) visit(path);
       else if (entry.isFile()) files.push(path);
     }
@@ -85580,8 +85697,8 @@ var ArtifactTransaction = class {
     this.fileSystem = fileSystem;
     this.destinationPath = resolve9(destinationPath);
     this.transactionDirectory = createSiblingTransactionDirectory(this.destinationPath);
-    this.stagingPath = join21(this.transactionDirectory, basename5(this.destinationPath));
-    this.backupPath = join21(this.transactionDirectory, "backup");
+    this.stagingPath = join22(this.transactionDirectory, basename5(this.destinationPath));
+    this.backupPath = join22(this.transactionDirectory, "backup");
     this.durationProbe = durationProbe;
   }
   kind;
@@ -86146,7 +86263,7 @@ function resolveVideoCaptureBeyondViewport(videoCount) {
 // ../producer/src/services/render/captureCost.ts
 init_dist2();
 init_src();
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var CAPTURE_CALIBRATION_TARGET_MS = 600;
 var MAX_MEASURED_CAPTURE_COST_MULTIPLIER = 8;
 var CAPTURE_CALIBRATION_PROTOCOL_TIMEOUT_MS = 3e4;
@@ -86382,7 +86499,7 @@ async function runCaptureCalibration(input) {
   });
   let calibration;
   try {
-    calibration = await runOneCalibration(join22(workDir, "capture-calibration"), calibrationCfg);
+    calibration = await runOneCalibration(join23(workDir, "capture-calibration"), calibrationCfg);
   } catch (error) {
     const shouldFallback = !forceScreenshot && shouldFallbackToScreenshotAfterCalibrationError(error);
     if (!shouldFallback) {
@@ -86415,7 +86532,7 @@ async function runCaptureCalibration(input) {
       const screenshotCfg = createCaptureCalibrationConfig({ ...cfg, forceScreenshot: true });
       try {
         calibration = await runOneCalibration(
-          join22(workDir, "capture-calibration-screenshot"),
+          join23(workDir, "capture-calibration-screenshot"),
           screenshotCfg
         );
       } catch (fallbackError) {
@@ -86838,7 +86955,7 @@ function countAuthoredTimedClips(html) {
 
 // ../producer/src/services/render/stages/compileStage.ts
 init_dist2();
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 
 // ../producer/src/services/htmlCompiler.ts
 init_esm10();
@@ -86847,8 +86964,8 @@ init_audioGain();
 init_compiler();
 init_subCompositionValidity();
 init_assetResolution();
-import { createReadStream as createReadStream4, existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join27, dirname as dirname13, resolve as resolve12, basename as basename6, relative as relative2 } from "path";
+import { createReadStream as createReadStream4, existsSync as existsSync24, mkdirSync as mkdirSync13, readFileSync as readFileSync10 } from "fs";
+import { join as join28, dirname as dirname14, resolve as resolve12, basename as basename6, relative as relative2 } from "path";
 
 // ../producer/src/services/renderMediaCollector.ts
 init_esm10();
@@ -86934,18 +87051,18 @@ init_src();
 
 // ../producer/src/services/deterministicFonts.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir5, tmpdir as tmpdir5 } from "os";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 
 // ../core/dist/fonts/aliases.js
 init_dist();
 
 // ../core/dist/fonts/systemFontLocator.js
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync20, lstatSync as lstatSync4, readdirSync as readdirSync9, realpathSync as realpathSync3 } from "fs";
+import { existsSync as existsSync19, lstatSync as lstatSync4, readdirSync as readdirSync9, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir3, platform as platform2 } from "os";
-import { join as join23, resolve as resolve10 } from "path";
+import { join as join24, 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;
@@ -86977,7 +87094,7 @@ var allowedDirsCache = null;
 function getAllowedFontDirs() {
   if (allowedDirsCache)
     return allowedDirsCache;
-  allowedDirsCache = fontDirectories().filter((d) => existsSync20(d)).map((d) => {
+  allowedDirsCache = fontDirectories().filter((d) => existsSync19(d)).map((d) => {
     try {
       return realpathSync3(d);
     } catch {
@@ -87042,7 +87159,7 @@ function fontDirectories() {
   const home = homedir3();
   if (platform2() === "darwin") {
     return [
-      join23(home, "Library", "Fonts"),
+      join24(home, "Library", "Fonts"),
       "/Library/Fonts",
       "/System/Library/Fonts",
       "/System/Library/Fonts/Supplemental"
@@ -87050,24 +87167,24 @@ function fontDirectories() {
   }
   if (platform2() === "win32") {
     return [
-      join23(process.env.WINDIR || "C:\\Windows", "Fonts"),
-      join23(process.env.LOCALAPPDATA || join23(homedir3(), "AppData", "Local"), "Microsoft", "Windows", "Fonts")
+      join24(process.env.WINDIR || "C:\\Windows", "Fonts"),
+      join24(process.env.LOCALAPPDATA || join24(homedir3(), "AppData", "Local"), "Microsoft", "Windows", "Fonts")
     ];
   }
   return [
-    join23(home, ".fonts"),
-    join23(home, ".local", "share", "fonts"),
+    join24(home, ".fonts"),
+    join24(home, ".local", "share", "fonts"),
     "/usr/local/share/fonts",
     "/usr/share/fonts"
   ];
 }
 function collectFontFileEntries(dir, depth = 0) {
-  if (!existsSync20(dir) || depth > 2)
+  if (!existsSync19(dir) || depth > 2)
     return [];
   const entries2 = [];
   try {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const fullPath = join23(dir, entry.name);
+      const fullPath = join24(dir, entry.name);
       if (entry.isDirectory()) {
         entries2.push(...collectFontFileEntries(fullPath, depth + 1));
         continue;
@@ -87517,13 +87634,23 @@ function fontDataUri(packageName, weight, style = "normal") {
 }
 function extractExistingFontFaces(html) {
   const families = /* @__PURE__ */ new Set();
-  const fontFaceRegex = /@font-face\s*\{[\s\S]*?font-family\s*:\s*([^;]+);[\s\S]*?\}/gi;
-  for (const match of html.matchAll(fontFaceRegex)) {
-    const raw = match[1] || "";
-    const normalized = normalizeFamilyName(raw);
-    if (normalized) {
-      families.add(normalized);
-    }
+  const opening = /@font-face\s*\{/gi;
+  const family = /font-family\s*:/gi;
+  while (opening.exec(html)) {
+    family.lastIndex = opening.lastIndex;
+    let declaration = family.exec(html);
+    while (declaration && html[family.lastIndex] === ";") {
+      declaration = family.exec(html);
+    }
+    if (!declaration) break;
+    const valueStart = family.lastIndex;
+    const semicolon = html.indexOf(";", valueStart);
+    if (semicolon < 0) break;
+    const end = html.indexOf("}", semicolon + 1);
+    if (end < 0) break;
+    const normalized = normalizeFamilyName(html.slice(valueStart, semicolon));
+    if (normalized) families.add(normalized);
+    opening.lastIndex = end + 1;
   }
   return families;
 }
@@ -87730,10 +87857,10 @@ function resolveFontCacheRoot() {
     return process.env.HYPERFRAMES_FONT_CACHE_DIR;
   }
   if (process.env.AWS_LAMBDA_FUNCTION_NAME) {
-    lambdaFontCacheRoot ??= mkdtempSync6(join25(tmpdir5(), "hyperframes-fonts-"));
+    lambdaFontCacheRoot ??= mkdtempSync8(join26(tmpdir5(), "hyperframes-fonts-"));
     return lambdaFontCacheRoot;
   }
-  return join25(homedir5(), ".cache", "hyperframes", "fonts");
+  return join26(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) {
@@ -87741,14 +87868,14 @@ function fontSlug(familyName) {
 }
 var ephemeralFontCacheRoot;
 function fontCacheDir(slug) {
-  const dir = join25(resolveFontCacheRoot(), slug);
-  if (!existsSync22(dir)) {
+  const dir = join26(resolveFontCacheRoot(), slug);
+  if (!existsSync21(dir)) {
     try {
       mkdirSync11(dir, { recursive: true });
     } catch {
       const firstFallback = ephemeralFontCacheRoot === void 0;
-      ephemeralFontCacheRoot ??= mkdtempSync6(join25(tmpdir5(), "hyperframes-fonts-"));
-      const fallback = join25(ephemeralFontCacheRoot, slug);
+      ephemeralFontCacheRoot ??= mkdtempSync8(join26(tmpdir5(), "hyperframes-fonts-"));
+      const fallback = join26(ephemeralFontCacheRoot, slug);
       mkdirSync11(fallback, { recursive: true });
       if (firstFallback) {
         defaultLogger.warn(
@@ -87764,7 +87891,7 @@ function subsetToken(woff2Url) {
   return createHash7("sha1").update(woff2Url).digest("hex").slice(0, 12);
 }
 function cachedWoff2Path(slug, weight, style, subset) {
-  return join25(fontCacheDir(slug), `${weight}-${style}-${subset}.woff2`);
+  return join26(fontCacheDir(slug), `${weight}-${style}-${subset}.woff2`);
 }
 var FONT_FETCH_FAILED = "FONT_FETCH_FAILED";
 var FONT_FETCH_UNAVAILABLE = "FONT_FETCH_UNAVAILABLE";
@@ -88165,14 +88292,14 @@ init_src();
 import { createHash as createHash8 } from "crypto";
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync23,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync9,
   renameSync as renameSync5,
-  rmSync as rmSync9,
+  rmSync as rmSync10,
   statSync as statSync8
 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute3, join as join26, resolve as resolve11 } from "path";
+import { dirname as dirname13, isAbsolute as isAbsolute3, join as join27, resolve as resolve11 } from "path";
 var PREPARED_GIF_SUBDIR = "_animated_gif";
 var CACHE_SCHEMA = "hfgif-v1";
 function splitUrlSuffix(src) {
@@ -88207,14 +88334,14 @@ function resolveGifSourcePath(src, options) {
   const { basePath } = splitUrlSuffix(trimmed);
   const normalizedBase = normalizeRelPath(basePath);
   const mapped = options.sourceAssets?.get(trimmed) ?? options.sourceAssets?.get(basePath) ?? options.sourceAssets?.get(normalizedBase);
-  if (mapped && existsSync23(mapped)) return mapped;
+  if (mapped && existsSync22(mapped)) return mapped;
   if (isHttpUrl(trimmed)) return null;
   const projectRelative = basePath.startsWith("/") ? basePath.slice(1) : basePath;
   const candidates = [
     isAbsolute3(basePath) ? basePath : resolve11(options.projectDir, projectRelative),
     resolve11(options.downloadDir, normalizedBase)
   ];
-  return candidates.find((candidate) => existsSync23(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync22(candidate)) ?? null;
 }
 function isUsableFile(path) {
   try {
@@ -88325,11 +88452,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 (!existsSync23(dirname12(input.cachePath))) {
-    mkdirSync12(dirname12(input.cachePath), { recursive: true });
+  if (!existsSync22(dirname13(input.cachePath))) {
+    mkdirSync12(dirname13(input.cachePath), { recursive: true });
   }
-  if (!existsSync23(dirname12(input.outputPath))) {
-    mkdirSync12(dirname12(input.outputPath), { recursive: true });
+  if (!existsSync22(dirname13(input.outputPath))) {
+    mkdirSync12(dirname13(input.outputPath), { recursive: true });
   }
   if (!isUsableFile(input.cachePath)) {
     const tmpPath = `${input.cachePath}.tmp-${process.pid}-${Date.now()}`;
@@ -88353,10 +88480,10 @@ async function ensurePreparedWebm(input) {
       if (!isUsableFile(input.cachePath)) {
         renameSync5(tmpPath, input.cachePath);
       } else {
-        rmSync9(tmpPath, { force: true });
+        rmSync10(tmpPath, { force: true });
       }
     } catch (error) {
-      rmSync9(tmpPath, { force: true });
+      rmSync10(tmpPath, { force: true });
       throw error;
     }
   }
@@ -88412,7 +88539,7 @@ function replaceImageWithVideo(input) {
   return video;
 }
 async function prepareAnimatedGifInputs(html, options) {
-  const outputDir = options.outputDir ?? join26(options.downloadDir, PREPARED_GIF_SUBDIR);
+  const outputDir = options.outputDir ?? join27(options.downloadDir, PREPARED_GIF_SUBDIR);
   const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_GIF_SUBDIR);
   const cacheDir = options.cacheDir ?? outputDir;
   const { document: document2 } = parseHTML(html);
@@ -88434,8 +88561,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 = join26(cacheDir, filename);
-    const outputPath = join26(outputDir, filename);
+    const cachePath = join27(cacheDir, filename);
+    const outputPath = join27(outputDir, filename);
     const outputSrc = `${outputSrcPrefix}/${filename}`;
     await ensurePreparedWebm({
       sourcePath,
@@ -88766,7 +88893,7 @@ function getPositionEditsRenderScript() {
 
 // ../producer/src/services/assetMediaType.ts
 init_src();
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 
 // ../producer/src/utils/semaphore.ts
 var Semaphore = class {
@@ -88881,7 +89008,7 @@ async function preflightCompositionAssetMediaTypes(input) {
       input.projectDir,
       input.compiledDir
     );
-    if (!existsSync24(resolvedPath)) continue;
+    if (!existsSync23(resolvedPath)) continue;
     byPath.set(resolvedPath, [...byPath.get(resolvedPath) ?? [], reference]);
   }
   const mismatches = [];
@@ -88962,7 +89089,7 @@ function assertSubCompositionsUsable(html, projectDir, visited = /* @__PURE__ */
     if (isUnresolvedAssetPlaceholder(srcPath)) continue;
     const filePath = resolve12(projectDir, srcPath);
     if (visited.has(filePath)) continue;
-    if (!existsSync25(filePath)) {
+    if (!existsSync24(filePath)) {
       problems.push({ srcPath, detail: "the file does not exist" });
       continue;
     }
@@ -89096,7 +89223,7 @@ function detectShaderTransitionUsage(html) {
 async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, downloadDir, tagName19, elementIdentity, log) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync25(downloadDir)) mkdirSync13(downloadDir, { recursive: true });
+    if (!existsSync24(downloadDir)) mkdirSync13(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir, void 0, void 0, void 0, {
         onTelemetry: logRemoteDownloadTelemetry
@@ -89105,9 +89232,9 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
       return { duration: null, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join27(baseDir, filePath);
+    filePath = join28(baseDir, filePath);
   }
-  if (!existsSync25(filePath)) {
+  if (!existsSync24(filePath)) {
     return { duration: null, resolvedPath: filePath };
   }
   const withSrcContext = (error) => {
@@ -89240,7 +89367,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync25(filePath)) {
+    if (!existsSync24(filePath)) {
       continue;
     }
     const rawSubHtml = readFileSync10(filePath, "utf-8");
@@ -89252,7 +89379,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
         item.rawSubHtml,
-        dirname13(item.filePath),
+        dirname14(item.filePath),
         downloadDir
       );
       const nested = await parseSubCompositions(
@@ -89432,7 +89559,7 @@ function inlineSubCompositions2(html, subCompositions, projectDir, variableOverr
         let compHtml = subCompositions.get(srcPath) || null;
         if (!compHtml) {
           const filePath = resolve12(projectDir, srcPath);
-          if (existsSync25(filePath)) {
+          if (existsSync24(filePath)) {
             compHtml = readFileSync10(filePath, "utf-8");
           }
         }
@@ -89441,7 +89568,7 @@ function inlineSubCompositions2(html, subCompositions, projectDir, variableOverr
       parseHtml: (htmlStr) => parseHTML(htmlStr).document,
       // Mirrors the preview bundler: a sub-composition's SIBLING assets resolve
       // against its own directory, project-root refs stay as authored.
-      assetExists: (path) => existsSync25(resolve12(projectDir, path)),
+      assetExists: (path) => existsSync24(resolve12(projectDir, path)),
       scriptErrorLabel: "[Compiler] Composition script failed",
       // Preserve the authored root wrapper as a child of the host, matching
       // the preview bundler's shape (htmlBundler.ts's prepareFlattenedInnerRoot,
@@ -89604,7 +89731,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside3(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync25(absPath)) return null;
+    if (!existsSync24(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -89654,7 +89781,7 @@ var REMOTE_SOURCE_TAG_RE = /<source\b[^>]*?\bsrc\s*=\s*["'](https?:\/\/[^"']+)["
 var REMOTE_IMG_TAG_RE = /<img\b[^>]*?(?<![\w-])src\s*=\s*["'](https?:\/\/[^"']+)["'][^>]*>/gi;
 async function downloadAndRewriteUrls(urlSet, html, remoteDir, warnLabel, logLabel, extraRewrite) {
   if (urlSet.size === 0) return { html, remoteMediaAssets: /* @__PURE__ */ new Map() };
-  if (!existsSync25(remoteDir)) mkdirSync13(remoteDir, { recursive: true });
+  if (!existsSync24(remoteDir)) mkdirSync13(remoteDir, { recursive: true });
   const urlToLocal = /* @__PURE__ */ new Map();
   await Promise.all(
     [...urlSet].map(async (url) => {
@@ -89701,7 +89828,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join27(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join28(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote media download failed",
     "Localized remote media source(s)"
   );
@@ -89716,7 +89843,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join27(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join28(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote image download failed",
     "Localized remote image source(s)"
   );
@@ -89732,7 +89859,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join27(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join28(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
@@ -89867,7 +89994,7 @@ async function localizeRemoteFontFaces(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     processed,
-    join27(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join28(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
     (h, url, relPath) => h.replaceAll(`url(${url})`, `url("${relPath}")`)
@@ -89956,7 +90083,7 @@ function rewriteUnresolvableGsapToCdn(html, projectDir) {
     (full, prefix, src, file, suffix) => {
       if (/^https?:\/\//i.test(src)) return full;
       const absPath = resolve12(projectDir, src);
-      if (existsSync25(absPath)) return full;
+      if (existsSync24(absPath)) return full;
       defaultLogger.info(
         `[Compiler] Rewriting missing gsap script to CDN: ${src} \u2192 ${GSAP_CDN_BASE}${file}`
       );
@@ -89969,7 +90096,7 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
   const entryPath = relative2(projectDir, htmlPath).replace(/\\/g, "/");
   if (!entryPath.includes("/")) return html;
   const { document: document2 } = parseHTML(html);
-  const assetExists = (path) => existsSync25(resolve12(projectDir, path));
+  const assetExists = (path) => existsSync24(resolve12(projectDir, path));
   rewriteAssetPaths(
     document2.querySelectorAll("[src], [href]"),
     entryPath,
@@ -90481,13 +90608,13 @@ async function runCompileStage(input) {
     abortSignal
   } = input;
   const compileStart = Date.now();
-  const compiled = await compileForRender(projectDir, htmlPath, join28(workDir, "downloads"), {
+  const compiled = await compileForRender(projectDir, htmlPath, join29(workDir, "downloads"), {
     log,
     failClosedFontFetch: failClosedFontFetch === true,
     allowSystemFontCapture,
     abortSignal,
     variables: input.variables,
-    animatedGifCacheDir: cfg.extractCacheDir ? join28(cfg.extractCacheDir, "animated-gif") : void 0,
+    animatedGifCacheDir: cfg.extractCacheDir ? join29(cfg.extractCacheDir, "animated-gif") : void 0,
     ffmpegProcessTimeout: cfg.ffmpegProcessTimeout
   });
   assertNotAborted();
@@ -90549,7 +90676,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join28(workDir, "compiled"),
+    compiledDir: join29(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -90597,7 +90724,7 @@ async function runCompileStage(input) {
 init_esm10();
 init_src();
 init_dist2();
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // ../producer/src/services/render/stages/probeFailures.ts
 var NETWORK_FAILURE_PATTERN = /404|ERR_NAME_NOT_RESOLVED|ERR_CONNECTION_REFUSED|net::ERR_/i;
@@ -90703,7 +90830,7 @@ async function runProbeStage(input) {
     });
     fileServer = await createFileServer2({
       projectDir,
-      compiledDir: join29(workDir, "compiled"),
+      compiledDir: join30(workDir, "compiled"),
       port: 0,
       preHeadScripts: [VIRTUAL_TIME_SHIM],
       fps: job.config.fps
@@ -90725,7 +90852,7 @@ async function runProbeStage(input) {
         log.info("Creating capture session...", { attempt, maxAttempts: PROBE_MAX_ATTEMPTS });
         probeSession = await createCaptureSession(
           fileServer.url,
-          join29(workDir, "probe"),
+          join30(workDir, "probe"),
           captureOpts,
           null,
           probeCfg
@@ -90810,7 +90937,7 @@ async function runProbeStage(input) {
         });
         probeSession = await createCaptureSession(
           fileServer.url,
-          join29(workDir, "probe-screenshot"),
+          join30(workDir, "probe-screenshot"),
           captureOpts,
           null,
           { ...probeCfg, forceScreenshot: true }
@@ -90846,7 +90973,7 @@ async function runProbeStage(input) {
           compiled,
           resolutions,
           projectDir,
-          join29(workDir, "downloads")
+          join30(workDir, "downloads")
         );
         assertNotAborted();
         composition.videos = compiled.videos;
@@ -91025,7 +91152,7 @@ async function runProbeStage(input) {
   try {
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join29(workDir, "compiled"),
+      compiledDir: join30(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -91152,8 +91279,8 @@ function validateRenderDuration(input) {
 
 // ../producer/src/services/render/stages/extractVideosStage.ts
 init_src();
-import { existsSync as existsSync26 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { join as join31 } from "path";
 
 // ../producer/src/services/render/extractionFailureMetadata.ts
 function stringOrEmpty(value) {
@@ -91382,7 +91509,7 @@ async function runExtractVideosStage(input) {
     const probeFailures = await Promise.all(
       composition.videos.map(async (v) => {
         const videoPath = resolveProjectRelativeSrc(v.src, projectDir, compiledDir);
-        if (!existsSync26(videoPath)) return null;
+        if (!existsSync25(videoPath)) return null;
         try {
           const attempted = extractionPolicy.maxTransientRetries === 0 ? { result: await extractMediaMetadata(videoPath), retries: 0 } : await runVideoExtractionWithRetry(() => extractMediaMetadata(videoPath), {
             signal: abortSignal,
@@ -91420,7 +91547,7 @@ async function runExtractVideosStage(input) {
     const probed = await Promise.all(
       composition.images.map(async (img) => {
         const imgPath = resolveProjectRelativeSrc(img.src, projectDir, compiledDir);
-        if (!existsSync26(imgPath)) return null;
+        if (!existsSync25(imgPath)) return null;
         const colorSpace = await probeColorSpaceSafely(imgPath, log);
         if (isHdrColorSpace(colorSpace)) {
           nativeHdrImageIds.add(img.id);
@@ -91449,7 +91576,7 @@ async function runExtractVideosStage(input) {
       // because short boundary counts can differ by one frame.
       {
         fps: job.config.fps,
-        outputDir: join30(compiledDir, "__hyperframes_video_frames"),
+        outputDir: join31(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
         timelineEnd: composition.duration,
         maxTransientRetries: extractionPolicy.maxTransientRetries,
@@ -91514,7 +91641,7 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
 
 // ../producer/src/services/render/stages/audioStage.ts
 init_src();
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 async function runAudioStage(input) {
   const {
     projectDir,
@@ -91529,7 +91656,7 @@ async function runAudioStage(input) {
     log
   } = input;
   const stage3Start = Date.now();
-  const audioOutputPath = join31(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join32(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -91539,7 +91666,7 @@ async function runAudioStage(input) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join31(workDir, "audio-work"),
+        join32(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -91807,15 +91934,15 @@ async function runCaptureStage(input) {
 init_src();
 import { mkdtemp as mkdtemp2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 
 // ../producer/src/services/render/stages/captureHdrFrameShared.ts
 init_src();
 
 // ../producer/src/services/hdrCompositor.ts
 init_src();
-import { readSync as readSync2, closeSync as closeSync4 } from "fs";
-import { join as join32 } from "path";
+import { readSync as readSync2, closeSync as closeSync6 } from "fs";
+import { join as join33 } from "path";
 function countNonZeroAlpha(rgba) {
   let n = 0;
   for (let p = 3; p < rgba.length; p += 4) {
@@ -91854,7 +91981,7 @@ function cropRgb48le(src, srcW, srcH, cropX, cropY, cropW, cropH) {
 }
 function closeHdrVideoFrameSource(source, log) {
   try {
-    closeSync4(source.fd);
+    closeSync6(source.fd);
   } catch (err) {
     log?.warn("Failed to close HDR raw frame file", {
       rawPath: source.rawPath,
@@ -92221,7 +92348,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 = join32(debugDumpDir, dumpName);
+          const dumpPath = join33(debugDumpDir, dumpName);
           writeFileExclusiveSync(dumpPath, domPng);
           log.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
@@ -92259,18 +92386,18 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
 init_src();
 init_dist2();
 import {
-  closeSync as closeSync5,
-  constants as constants2,
-  fstatSync as fstatSync2,
+  closeSync as closeSync7,
+  constants as constants4,
+  fstatSync as fstatSync4,
   mkdirSync as mkdirSync14,
-  mkdtempSync as mkdtempSync7,
-  openSync as openSync4,
+  mkdtempSync as mkdtempSync9,
+  openSync as openSync6,
   readFileSync as readFileSync11,
-  rmSync as rmSync10,
+  rmSync as rmSync11,
   statfsSync as statfsSync2
 } from "fs";
-import { join as join33 } from "path";
-var NO_FOLLOW_FLAG = constants2.O_NOFOLLOW ?? 0;
+import { join as join34 } 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);
   return safe || "video";
@@ -92420,7 +92547,7 @@ function resolveHdrExtractionWindow(video, compositionDuration, metadata) {
 function cleanupHdrFrameDirectory(frameDir, rawPath, log) {
   if (process.env.KEEP_TEMP === "1") return;
   try {
-    rmSync10(frameDir, { recursive: true, force: true });
+    rmSync11(frameDir, { recursive: true, force: true });
   } catch (err) {
     log?.warn("Failed to clean up HDR raw frame directory", {
       frameDir,
@@ -92513,10 +92640,10 @@ async function extractHdrVideoFrames(args) {
       const window3 = extractionWindows.get(videoId);
       if (!video || !window3) continue;
       mkdirSync14(framesDir, { recursive: true });
-      const frameDir = mkdtempSync7(join33(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
+      const frameDir = mkdtempSync9(join34(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
       createdFrameDirs.add(frameDir);
       const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
-      const rawPath = join33(frameDir, "frames.rgb48le");
+      const rawPath = join34(frameDir, "frames.rgb48le");
       const extractionStart = String(window3.extractionMediaStart ?? window3.mediaStart);
       const ffmpegArgs = [];
       if (window3.finalFrameOnly) {
@@ -92558,10 +92685,10 @@ async function extractHdrVideoFrames(args) {
         });
       }
       const frameSize = dims.width * dims.height * 6;
-      const fd = openSync4(rawPath, constants2.O_RDONLY | NO_FOLLOW_FLAG);
+      const fd = openSync6(rawPath, constants4.O_RDONLY | NO_FOLLOW_FLAG);
       let handedOff = false;
       try {
-        const frameCount = Math.floor(fstatSync2(fd).size / frameSize);
+        const frameCount = Math.floor(fstatSync4(fd).size / frameSize);
         if (frameCount < 1) {
           hdrDiagnostics.videoExtractionFailures += 1;
           throw new Error(
@@ -92581,7 +92708,7 @@ async function extractHdrVideoFrames(args) {
         });
         handedOff = true;
       } finally {
-        if (!handedOff) closeSync5(fd);
+        if (!handedOff) closeSync7(fd);
       }
     }
     return { sources: out, estimatedBytes, releaseReservation };
@@ -92981,11 +93108,11 @@ function createDrainFrameGuard(args) {
         return buf;
       }
       if (db < verifyMinDb) {
-        const dumpDir = await mkdtemp2(join34(tmpdir6(), "hf-de-verify-fail-")).catch(() => null);
+        const dumpDir = await mkdtemp2(join35(tmpdir6(), "hf-de-verify-fail-")).catch(() => null);
         if (dumpDir) {
           await Promise.all([
-            writeFile2(join34(dumpDir, `frame-${idx}-de.jpg`), buf),
-            writeFile2(join34(dumpDir, `frame-${idx}-truth.jpg`), truth)
+            writeFile2(join35(dumpDir, `frame-${idx}-de.jpg`), buf),
+            writeFile2(join35(dumpDir, `frame-${idx}-truth.jpg`), truth)
           ]).catch(() => {
           });
         }
@@ -93379,8 +93506,8 @@ async function runCaptureStreamingStage(input) {
 // ../producer/src/services/render/stages/captureHdrStage.ts
 init_src();
 init_dist2();
-import { existsSync as existsSync28, mkdirSync as mkdirSync15 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync15 } from "fs";
+import { join as join39 } from "path";
 
 // ../producer/src/services/hdrImageTransferCache.ts
 init_src();
@@ -93444,7 +93571,7 @@ function createHdrImageTransferCache(options = {}) {
 
 // ../producer/src/services/render/stages/captureHdrSequentialLoop.ts
 init_src();
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 async function runSequentialLayeredFrameLoop(input) {
   const {
     job,
@@ -93565,7 +93692,7 @@ async function runSequentialLayeredFrameLoop(input) {
       );
       if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
         writeFileExclusiveSync(
-          join35(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          join36(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
       }
@@ -93600,14 +93727,14 @@ async function runSequentialLayeredFrameLoop(input) {
 
 // ../producer/src/services/render/stages/captureHdrHybridLoop.ts
 init_src();
-import { join as join37 } from "path";
+import { join as join38 } 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 dirname14, join as join36 } from "path";
+import { dirname as dirname15, join as join37 } from "path";
 import { createRequire as createRequire2 } from "module";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { cpus as cpus3 } from "os";
 function resolveWorkerEntry(explicit) {
   if (explicit && explicit.length > 0) {
@@ -93618,10 +93745,10 @@ function resolveWorkerEntry(explicit) {
     const isTs = override.endsWith(".ts");
     return { path: override, isTs };
   }
-  const moduleDir = dirname14(fileURLToPath4(import.meta.url));
-  const jsPath = join36(moduleDir, "shaderTransitionWorker.js");
-  if (existsSync27(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join36(moduleDir, "shaderTransitionWorker.ts");
+  const moduleDir = dirname15(fileURLToPath4(import.meta.url));
+  const jsPath = join37(moduleDir, "shaderTransitionWorker.js");
+  if (existsSync26(jsPath)) return { path: jsPath, isTs: false };
+  const tsPath = join37(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -93991,7 +94118,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join37(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join38(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -94177,8 +94304,8 @@ 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 ? join38(framesDir, "debug-composite") : null;
-      if (debugDumpDir && !existsSync28(debugDumpDir)) {
+      const debugDumpDir = debugDumpEnabled ? join39(framesDir, "debug-composite") : null;
+      if (debugDumpDir && !existsSync27(debugDumpDir)) {
         mkdirSync15(debugDumpDir, { recursive: true });
       }
       const compositeTransfer = resolveCompositeTransfer(hasHdrContent, effectiveHdr);
@@ -94328,11 +94455,11 @@ async function runCaptureHdrStage(input) {
 
 // ../producer/src/services/render/stages/encodeStage.ts
 init_src();
-import { copyFileSync as copyFileSync5, existsSync as existsSync29, mkdirSync as mkdirSync16, readdirSync as readdirSync10, rmSync as rmSync11, statSync as statSync9 } from "fs";
-import { dirname as dirname15, join as join40 } from "path";
+import { copyFileSync as copyFileSync5, existsSync as existsSync28, mkdirSync as mkdirSync16, readdirSync as readdirSync10, rmSync as rmSync12, statSync as statSync9 } from "fs";
+import { dirname as dirname16, join as join41 } from "path";
 
 // ../producer/src/services/render/stages/gifEncodeArgs.ts
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 function fpsToFfmpegArg2(fps) {
   return fps.den === 1 ? String(fps.num) : `${fps.num}/${fps.den}`;
 }
@@ -94344,7 +94471,7 @@ function buildGifPalettegenArgs(input) {
     "-framerate",
     fpsArg,
     "-i",
-    join39(input.framesDir, input.framePattern),
+    join40(input.framesDir, input.framePattern),
     "-vf",
     `fps=${fpsArg},palettegen=stats_mode=diff${transparency}`,
     input.palettePath
@@ -94358,7 +94485,7 @@ function buildGifPaletteuseArgs(input) {
     "-framerate",
     fpsArg,
     "-i",
-    join39(input.framesDir, input.framePattern),
+    join40(input.framesDir, input.framePattern),
     "-i",
     input.palettePath,
     "-lavfi",
@@ -94431,7 +94558,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
         failureReason: gifResult.failureReason
       };
     }
-    const fileSize = existsSync29(outputPath) ? statSync9(outputPath).size : 0;
+    const fileSize = existsSync28(outputPath) ? statSync9(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -94440,7 +94567,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       fileSize
     };
   } finally {
-    rmSync11(input.palettePath, { force: true });
+    rmSync12(input.palettePath, { force: true });
   }
 }
 async function runEncodeStage(input) {
@@ -94469,7 +94596,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     updateJobStatus(job, "encoding", "Writing PNG sequence", 75, onProgress);
-    if (!existsSync29(outputPath)) mkdirSync16(outputPath, { recursive: true });
+    if (!existsSync28(outputPath)) mkdirSync16(outputPath, { recursive: true });
     const captured = readdirSync10(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -94477,11 +94604,11 @@ async function runEncodeStage(input) {
       );
     }
     captured.forEach((name, i) => {
-      const dst = join40(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync5(join40(framesDir, name), dst);
+      const dst = join41(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync5(join41(framesDir, name), dst);
     });
-    if (hasAudio && audioOutputPath && existsSync29(audioOutputPath)) {
-      copyFileSync5(audioOutputPath, join40(outputPath, MIXED_AUDIO_FILENAME));
+    if (hasAudio && audioOutputPath && existsSync28(audioOutputPath)) {
+      copyFileSync5(audioOutputPath, join41(outputPath, MIXED_AUDIO_FILENAME));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME}`
       );
@@ -94500,7 +94627,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join40(dirname15(videoOnlyPath), "gif-palette.png"),
+      palettePath: join41(dirname16(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -94566,8 +94693,8 @@ import { extname as extname6 } from "path";
 init_src();
 init_dist2();
 import { spawn as spawn5 } from "child_process";
-import { mkdtempSync as mkdtempSync8, renameSync as renameSync6, rmSync as rmSync12 } from "fs";
-import { dirname as dirname16, join as join41 } from "path";
+import { mkdtempSync as mkdtempSync10, renameSync as renameSync6, rmSync as rmSync13 } from "fs";
+import { dirname as dirname17, join as join42 } from "path";
 var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
 var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
 var MAX_TRUE_PEAK_CORRECTION_PASSES = 3;
@@ -94734,7 +94861,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       error: `audioPadTrim: failed to materialize ${plan2.operation}: ${err instanceof Error ? err.message : String(err)}`
     };
   } finally {
-    for (const path of plan2.cleanupPaths) rmSync12(path, { force: true });
+    for (const path of plan2.cleanupPaths) rmSync13(path, { force: true });
   }
   if (probeTruePeak) {
     const correction = await enforceAacTruePeak({
@@ -94767,8 +94894,8 @@ async function padOrTrimAudioToVideoFrameCount(input) {
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
-    scratchDir = mkdtempSync8(join41(dirname16(input.audioPath), ".true-peak-"));
-    const correctedPath = join41(scratchDir, "audio.m4a");
+    scratchDir = mkdtempSync10(join42(dirname17(input.audioPath), ".true-peak-"));
+    const correctedPath = join42(scratchDir, "audio.m4a");
     let attenuationDb = 0;
     let measuredPath = input.audioPath;
     for (let pass = 0; pass <= MAX_TRUE_PEAK_CORRECTION_PASSES; pass += 1) {
@@ -94815,7 +94942,7 @@ async function enforceAacTruePeak(input) {
       )}`
     };
   } finally {
-    if (scratchDir) rmSync12(scratchDir, { recursive: true, force: true });
+    if (scratchDir) rmSync13(scratchDir, { recursive: true, force: true });
   }
 }
 function failResult(outputPath, target, source, error) {
@@ -95021,7 +95148,7 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries2) {
-      const full = join42(current2, name);
+      const full = join43(current2, name);
       try {
         const st = statSync10(full);
         if (st.isDirectory()) {
@@ -95170,8 +95297,8 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join42(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync30(framePath) || statSync10(framePath).size <= 8;
+    const framePath = join43(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const missing = !existsSync29(framePath) || statSync10(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -95193,7 +95320,7 @@ function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, ran
       workerId,
       startFrame: rangeStart + range.startFrame,
       endFrame: rangeStart + range.endFrame,
-      outputDir: join42(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
+      outputDir: join43(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
       outputFrameOffset: rangeStart
     }));
     batches.push(batch);
@@ -95216,8 +95343,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 join42(systemTempDir, "hf-render-");
-  return join42(dirname17(outputPath), `work-${jobId}-`);
+  if (platform3 === "win32") return join43(systemTempDir, "hf-render-");
+  return join43(dirname18(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function captureAttemptMadeProgress(attemptTargetFrameCount, remainingFrameCount) {
@@ -95246,8 +95373,8 @@ 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 = join42(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    if (existsSync30(framePath)) captured++;
+    const framePath = join43(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    if (existsSync29(framePath)) captured++;
   }
   return captured;
 }
@@ -95271,7 +95398,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join42(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join43(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -95608,15 +95735,15 @@ function deVerifyFallbackTelemetry(err) {
   };
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal) {
-  const moduleDir = dirname17(fileURLToPath5(import.meta.url));
+  const moduleDir = dirname18(fileURLToPath5(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve13(process.env.PRODUCER_RENDERS_DIR, "..") : resolve13(moduleDir, "../..");
-  const debugDir = join42(producerRoot, ".debug");
-  const outputDir = dirname17(outputPath);
-  if (!existsSync30(outputDir)) mkdirSync17(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join42(debugDir, job.id) : mkdtempSync9(resolveRenderWorkDirPrefix(outputPath, job.id));
+  const debugDir = join43(producerRoot, ".debug");
+  const outputDir = dirname18(outputPath);
+  if (!existsSync29(outputDir)) mkdirSync17(outputDir, { recursive: true });
+  const workDir = job.config.debug ? join43(debugDir, job.id) : mkdtempSync11(resolveRenderWorkDirPrefix(outputPath, job.id));
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join42(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join43(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -95630,7 +95757,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
       log.info("KEEP_TEMP=1 \u2014 leaving workDir on disk for inspection", { workDir });
       return;
     }
-    rmSync13(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    rmSync14(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   });
   try {
     await executeRenderPipeline({
@@ -95664,7 +95791,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join42(workDir, "perf-summary.json");
+  const perfOutputPath = join43(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -95727,7 +95854,7 @@ async function executeRenderPipeline(input) {
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
     assertConfiguredFfmpegBinariesExist();
-    if (!existsSync30(workDir)) mkdirSync17(workDir, { recursive: true });
+    if (!existsSync29(workDir)) mkdirSync17(workDir, { recursive: true });
     if (job.config.debug) {
       log.info("[Render] Debug artifacts enabled", { workDir, logPath });
     }
@@ -95756,16 +95883,16 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join42(projectDir, entryFile);
-    if (!existsSync30(htmlPath)) {
+    let htmlPath = join43(projectDir, entryFile);
+    if (!existsSync29(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync12(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join42(workDir, "standalone-entry.html");
-      const projectIndexPath = join42(projectDir, "index.html");
-      if (!existsSync30(projectIndexPath)) {
+      const wrapperPath = join43(workDir, "standalone-entry.html");
+      const projectIndexPath = join43(projectDir, "index.html");
+      if (!existsSync29(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
@@ -95919,7 +96046,7 @@ async function executeRenderPipeline(input) {
       beginFrameStalled: probeResult.beginFrameStalled
     });
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress);
-    const compiledDir = join42(workDir, "compiled");
+    const compiledDir = join43(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -96039,7 +96166,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer2({
           projectDir,
-          compiledDir: join42(workDir, "compiled"),
+          compiledDir: join43(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -96057,8 +96184,8 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join42(workDir, "captured-frames");
-    if (!existsSync30(framesDir)) mkdirSync17(framesDir, { recursive: true });
+    const framesDir = join43(workDir, "captured-frames");
+    if (!existsSync29(framesDir)) mkdirSync17(framesDir, { recursive: true });
     const resolvedBrowserGpuMode = await resolveBrowserGpuMode(cfg.browserGpuMode, {
       chromePath: resolveHeadlessShellPath(cfg),
       browserTimeout: cfg.browserTimeout
@@ -96382,7 +96509,7 @@ async function executeRenderPipeline(input) {
       gif: ".gif"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join42(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join43(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -96790,7 +96917,7 @@ async function executeRenderPipeline(input) {
             "capture_disk",
             "drawElement self-verify failed; retrying with forceScreenshot"
           );
-          rmSync13(framesDir, { recursive: true, force: true });
+          rmSync14(framesDir, { recursive: true, force: true });
           mkdirSync17(framesDir, { recursive: true });
           resetCaptureAttemptProgress(job);
           dedupPerfs.length = 0;
@@ -96909,7 +97036,7 @@ async function executeRenderPipeline(input) {
       } : void 0
     );
     const totalElapsed = Date.now() - pipelineStart;
-    const tmpPeakBytes = existsSync30(workDir) ? sampleDirectoryBytes(workDir) : 0;
+    const tmpPeakBytes = existsSync29(workDir) ? sampleDirectoryBytes(workDir) : 0;
     recordTransientRetryObservability();
     observability.checkpoint("pipeline", "artifact validated", { totalElapsedMs: totalElapsed });
     const observabilitySummary = observability.summary({
@@ -96974,8 +97101,8 @@ async function executeRenderPipeline(input) {
       }
     }
     if (job.config.debug) {
-      if (!isPngSequence && existsSync30(stagedOutputPath)) {
-        const debugOutput = join42(workDir, `output${videoExt}`);
+      if (!isPngSequence && existsSync29(stagedOutputPath)) {
+        const debugOutput = join43(workDir, `output${videoExt}`);
         copyFileSync6(stagedOutputPath, debugOutput);
       }
     }
@@ -97310,15 +97437,15 @@ init_src();
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync33,
+  existsSync as existsSync32,
   mkdirSync as mkdirSync18,
   statSync as statSync12,
-  mkdtempSync as mkdtempSync10,
+  mkdtempSync as mkdtempSync12,
   writeFileSync as writeFileSync11,
-  rmSync as rmSync14,
+  rmSync as rmSync15,
   createReadStream as createReadStream5
 } from "fs";
-import { resolve as resolve15, dirname as dirname19, join as join45 } from "path";
+import { resolve as resolve15, dirname as dirname20, join as join46 } from "path";
 import { tmpdir as tmpdir8 } from "os";
 import { parseArgs } from "util";
 import crypto from "crypto";
@@ -97328,8 +97455,8 @@ import { serve as serve3 } from "@hono/node-server";
 
 // ../producer/src/services/hyperframeLint.ts
 init_dist3();
-import { existsSync as existsSync31, readFileSync as readFileSync13, statSync as statSync11 } from "fs";
-import { resolve as resolve14, join as join43 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync13, statSync as statSync11 } from "fs";
+import { resolve as resolve14, join as join44 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -97357,7 +97484,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve14(projectDir);
-  if (!existsSync31(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
+  if (!existsSync30(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -97368,7 +97495,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync31(absoluteEntryPath) && statSync11(absoluteEntryPath).isFile()) {
+    if (existsSync30(absoluteEntryPath) && statSync11(absoluteEntryPath).isFile()) {
       return {
         entryFile,
         html: readFileSync13(absoluteEntryPath, "utf-8"),
@@ -97377,7 +97504,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join43(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join44(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -97420,8 +97547,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 dirname18, join as join44 } from "path";
-import { existsSync as existsSync32 } from "fs";
+import { dirname as dirname19, join as join45 } from "path";
+import { existsSync as existsSync31 } from "fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -97495,10 +97622,10 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname18(fileURLToPath6(import.meta.url));
-  const candidates = [join44(here, "healthWorkerThread.js"), join44(here, "healthWorkerThread.ts")];
+  const here = dirname19(fileURLToPath6(import.meta.url));
+  const candidates = [join45(here, "healthWorkerThread.js"), join45(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync32(candidate)) return candidate;
+    if (existsSync31(candidate)) return candidate;
   }
   return void 0;
 }
@@ -97633,8 +97760,8 @@ 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 = dirname19(absoluteOutputPath);
-  if (!existsSync33(outputDir)) mkdirSync18(outputDir, { recursive: true });
+  const outputDir = dirname20(absoluteOutputPath);
+  if (!existsSync32(outputDir)) mkdirSync18(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -97672,11 +97799,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString2(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve15(candidate);
-  if (!existsSync33(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
+  if (!existsSync32(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync33(resolve15(absProjectDir, entry))) {
+  if (!existsSync32(resolve15(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -97701,8 +97828,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir8();
-  const tempProjectDir = mkdtempSync10(join45(tempRoot, "producer-project-"));
-  writeFileSync11(join45(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync12(join46(tempRoot, "producer-project-"));
+  writeFileSync11(join46(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -97759,7 +97886,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync14(dir, { recursive: true, force: true });
+    rmSync15(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -97768,7 +97895,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync33(path) ? statSync12(path).size : 0;
+  return existsSync32(path) ? statSync12(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -98064,7 +98191,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync33(artifact.path)) {
+    if (!existsSync32(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -98152,12 +98279,12 @@ init_src();
 // ../producer/src/services/distributed/plan.ts
 init_dist2();
 init_src();
-import { cpSync as cpSync2, existsSync as existsSync36, mkdirSync as mkdirSync20, renameSync as renameSync7, rmSync as rmSync15, writeFileSync as writeFileSync13 } from "fs";
-import { join as join49, relative as relative5, sep as sep4 } from "path";
+import { cpSync as cpSync2, existsSync as existsSync35, mkdirSync as mkdirSync20, renameSync as renameSync7, rmSync as rmSync16, writeFileSync as writeFileSync13 } from "fs";
+import { join as join50, relative as relative5, sep as sep4 } from "path";
 
 // ../producer/src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync19, readFileSync as readFileSync14, readdirSync as readdirSync12, writeFileSync as writeFileSync12 } from "fs";
-import { join as join46, relative as relative3, resolve as resolve16 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync19, readFileSync as readFileSync14, readdirSync as readdirSync12, writeFileSync as writeFileSync12 } from "fs";
+import { join as join47, relative as relative3, resolve as resolve16 } from "path";
 
 // ../producer/src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
@@ -98199,17 +98326,17 @@ var FIELD_DELIMITER = Buffer.from([0]);
 // ../producer/src/services/distributed/shared.ts
 init_src();
 import { execFile as execFileCallback } from "child_process";
-import { dirname as dirname20, join as join47 } from "path";
-import { existsSync as existsSync35, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname21, join as join48 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync15 } from "fs";
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { promisify as promisify3 } from "util";
+import { promisify as promisify4 } from "util";
 var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME;
-var execFile3 = promisify3(execFileCallback);
+var execFile3 = promisify4(execFileCallback);
 
 // ../producer/src/services/distributed/planSize.ts
 import { createHash as createHash10 } from "crypto";
 import { lstatSync as lstatSync5, readdirSync as readdirSync13 } from "fs";
-import { extname as extname7, join as join48, relative as relative4 } from "path";
+import { extname as extname7, join as join49, relative as relative4 } from "path";
 var PLAN_ROOT_CATEGORY = {
   compiled: "compiled",
   [PLAN_AUDIO_RELATIVE_PATH]: "audio",
@@ -98221,81 +98348,81 @@ var PLAN_ROOT_CATEGORY = {
 var PLAN_DIR_SIZE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join49("meta", "composition.json"),
-  join49("meta", "encoder.json"),
-  join49("meta", "chunks.json")
+  join50("meta", "composition.json"),
+  join50("meta", "encoder.json"),
+  join50("meta", "chunks.json")
 ];
 
 // ../producer/src/services/distributed/planV2.ts
 init_src();
 import {
-  closeSync as closeSync6,
+  closeSync as closeSync8,
   copyFileSync as copyFileSync8,
-  existsSync as existsSync38,
+  existsSync as existsSync37,
   lstatSync as lstatSync6,
   mkdirSync as mkdirSync22,
-  mkdtempSync as mkdtempSync12,
-  openSync as openSync5,
+  mkdtempSync as mkdtempSync14,
+  openSync as openSync7,
   readFileSync as readFileSync16,
   readSync as readSync3,
   readdirSync as readdirSync14,
   renameSync as renameSync9,
-  rmSync as rmSync17,
+  rmSync as rmSync18,
   statSync as statSync14,
   writeFileSync as writeFileSync15
 } from "fs";
 import { createHash as createHash11 } from "crypto";
 import { tmpdir as tmpdir9 } from "os";
-import { dirname as dirname22, isAbsolute as isAbsolute4, join as join52, relative as relative6, resolve as resolve17, sep as sep5 } from "path";
+import { dirname as dirname23, isAbsolute as isAbsolute4, join as join53, relative as relative6, resolve as resolve17, sep as sep5 } from "path";
 
 // ../producer/src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync7,
-  existsSync as existsSync37,
+  existsSync as existsSync36,
   linkSync as linkSync3,
   mkdirSync as mkdirSync21,
-  mkdtempSync as mkdtempSync11,
+  mkdtempSync as mkdtempSync13,
   renameSync as renameSync8,
-  rmSync as rmSync16,
+  rmSync as rmSync17,
   statSync as statSync13,
   writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname21, join as join51 } from "path";
+import { dirname as dirname22, join as join52 } from "path";
 
 // ../producer/src/services/distributed/planV2Layout.ts
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 
 // ../producer/src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync13, rmSync as rmSync20 } from "fs";
+import { mkdtempSync as mkdtempSync15, rmSync as rmSync21 } from "fs";
 import { tmpdir as tmpdir10 } from "os";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 
 // ../producer/src/services/distributed/assemble.ts
 init_src();
 init_dist2();
 import {
   cpSync as cpSync3,
-  existsSync as existsSync39,
+  existsSync as existsSync38,
   mkdirSync as mkdirSync23,
   readFileSync as readFileSync17,
   readdirSync as readdirSync15,
-  rmSync as rmSync18,
+  rmSync as rmSync19,
   statSync as statSync15,
   writeFileSync as writeFileSync16
 } from "fs";
-import { dirname as dirname23, join as join53 } from "path";
+import { dirname as dirname24, join as join54 } from "path";
 
 // ../producer/src/services/distributed/renderChunk.ts
 init_src();
-import { randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync40, mkdirSync as mkdirSync24, readFileSync as readFileSync18, readdirSync as readdirSync16, rmSync as rmSync19, writeFileSync as writeFileSync17 } from "fs";
-import { extname as extname8, join as join54 } from "path";
+import { randomBytes } from "crypto";
+import { existsSync as existsSync39, mkdirSync as mkdirSync24, readFileSync as readFileSync18, readdirSync as readdirSync16, rmSync as rmSync20, writeFileSync as writeFileSync17 } from "fs";
+import { extname as extname8, join as join55 } from "path";
 init_src();
 
 // ../producer/src/services/distributed/projectHash.ts
 import { readdirSync as readdirSync17, readFileSync as readFileSync19 } from "fs";
 import { createHash as createHash12 } from "crypto";
-import { join as join56, relative as relative7 } from "path";
+import { join as join57, relative as relative7 } from "path";
 
 // src/fontLocalize.ts
 function safeVersion(version2) {
@@ -98336,8 +98463,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.28" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.28" : "0.0.0-dev";
+var VERSION = true ? "0.8.30" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.30" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {