hyperframes 0.8.169 → 0.8.171

package/dist/{chunk-7FHFPHEM.js → chunk-VKFYI7AQ.js}

@@ -31,7 +31,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-O3J7BHBU.js";
+} from "./chunk-QZUVPWC4.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -60,7 +60,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-BIV5HVTQ.js";
+} from "./chunk-6M3IPJS6.js";
 import {
   clampAudioGain,
   isAudibleVideoElement
@@ -5873,6 +5873,26 @@ async function decodeAllImages(page) {
     );
   });
 }
+function releasableVideoIds(options) {
+  const hinted = new Set((options.videoMetadataHints ?? []).map((hint) => hint.id));
+  return (options.skipReadinessVideoIds ?? []).filter((id) => hinted.has(id));
+}
+async function releaseInjectedVideoMedia(page, videoIds) {
+  if (videoIds.length === 0) return;
+  await page.evaluate(
+    (ids) => {
+      for (const id of ids) {
+        const video = window.__hfMediaEl?.(id) ?? document.getElementById(id);
+        if (!(video instanceof HTMLVideoElement)) continue;
+        video.pause();
+        for (const source of video.querySelectorAll("source")) source.remove();
+        video.removeAttribute("src");
+        video.load();
+      }
+    },
+    [...videoIds]
+  );
+}
 async function applyVideoMetadataHints(page, hints) {
   if (!hints || hints.length === 0) return;
   await page.evaluate(
@@ -6087,6 +6107,7 @@ async function initializeSession(session) {
     assertVfxIntact(session);
     recordSubTimelineWarning(session, pageReadyTimeout);
     await applyVideoMetadataHints(page, session.options.videoMetadataHints);
+    await releaseInjectedVideoMedia(page, releasableVideoIds(session.options));
     logInitPhase("applyVideoMetadataHints complete");
     const skipVideoIds = session.options.skipReadinessVideoIds ?? [];
     const [videosReady] = await Promise.all([
@@ -6193,6 +6214,7 @@ async function initializeSession(session) {
     assertVfxIntact(session);
     recordSubTimelineWarning(session, pageReadyTimeout);
     await applyVideoMetadataHints(page, session.options.videoMetadataHints);
+    await releaseInjectedVideoMedia(page, releasableVideoIds(session.options));
     logInitPhase("applyVideoMetadataHints complete");
     const bfSkipVideoIds = session.options.skipReadinessVideoIds ?? [];
     const [bfVideosReady] = await Promise.all([
@@ -6637,6 +6659,7 @@ async function createStaticVerificationPage(session) {
       knownUnregisteredIds: session.subTimelineWaitMemo.unregisteredIds
     });
     await applyVideoMetadataHints(page, session.options.videoMetadataHints);
+    await releaseInjectedVideoMedia(page, releasableVideoIds(session.options));
     const skipVideoIds = session.options.skipReadinessVideoIds ?? [];
     await Promise.all([
       pollVideosReady(page, skipVideoIds, pageReadyTimeout),
@@ -13659,8 +13682,8 @@ async function queryElementStacking(page, nativeHdrIds) {
 }
 
 // ../engine/src/services/audioMixer.ts
-import { closeSync as closeSync4, existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync6, openSync as openSync4, rmSync as rmSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13, dirname as dirname6, isAbsolute, relative } from "path";
+import { closeSync as closeSync4, existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync7, openSync as openSync4, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join14, dirname as dirname7, isAbsolute, relative } from "path";
 
 // ../engine/src/utils/notMediaPayload.ts
 import { createHash as createHash3 } from "crypto";
@@ -13774,6 +13797,99 @@ function clampFadesToDuration(fades, duration) {
   return { fadeIn: fadeIn * scale, fadeOut: fadeOut * scale };
 }
 
+// ../engine/src/services/aacEncode.ts
+import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5, join as join11 } from "path";
+var SAMPLE_RATE = 48e3;
+var FRAME_SAMPLES = 1024;
+var MIN_SEGMENT_SECONDS = 60;
+var MAX_SEGMENTS = 8;
+var PRE_ROLL_FRAMES = 469;
+var POST_ROLL_FRAMES = 8;
+var AAC_ARGS = ["-acodec", "aac", "-b:a", "192k"];
+function aacSegmentCount(totalDuration) {
+  return Math.max(1, Math.min(MAX_SEGMENTS, Math.floor(totalDuration / MIN_SEGMENT_SECONDS)));
+}
+function splitAdtsFrames(bytes) {
+  const frames = [];
+  for (let at = 0; at < bytes.length; ) {
+    const length = (bytes[at + 3] & 3) << 11 | bytes[at + 4] << 3 | bytes[at + 5] >> 5;
+    if (bytes[at] !== 255 || (bytes[at + 1] & 240) !== 240 || length < 7) {
+      throw new Error(`Not an ADTS frame at byte ${at}`);
+    }
+    frames.push(bytes.subarray(at, at + length));
+    at += length;
+  }
+  return frames;
+}
+function planSegments(totalDuration, count) {
+  const packets = Math.ceil(Math.round(totalDuration * SAMPLE_RATE) / FRAME_SAMPLES) + 1;
+  const cuts = Array.from({ length: count + 1 }, (_, k) => Math.round(k * packets / count));
+  return cuts.slice(0, -1).map((cut, k) => {
+    const next = cuts[k + 1];
+    const firstFrame = Math.max(0, cut - PRE_ROLL_FRAMES);
+    const end = k === count - 1 ? "" : `:end_sample=${(next + POST_ROLL_FRAMES) * FRAME_SAMPLES}`;
+    const trim = `atrim=start_sample=${firstFrame * FRAME_SAMPLES}${end}`;
+    return { trim, keepFrom: cut - firstFrame, keepTo: next - firstFrame };
+  });
+}
+async function encodeAac(input, outputPath, totalDuration, { signal, timeout }) {
+  const count = aacSegmentCount(totalDuration);
+  if (count === 1) {
+    const args = ["-i", input, "-t", String(totalDuration), ...AAC_ARGS, "-y", outputPath];
+    return runFfmpeg(args, { signal, timeout });
+  }
+  const dir = mkdtempSync4(join11(dirname5(outputPath), ".aac-segments-"));
+  try {
+    const segments = planSegments(totalDuration, count).map((segment, k) => ({
+      ...segment,
+      path: join11(dir, `${k}.aac`)
+    }));
+    const results = await Promise.all(
+      segments.map(
+        ({ trim, path }) => runFfmpeg(["-i", input, "-af", trim, ...AAC_ARGS, "-f", "adts", "-y", path], {
+          signal,
+          timeout
+        })
+      )
+    );
+    const failed = results.find((result) => !result.success);
+    if (failed) return failed;
+    const joined = join11(dir, "joined.aac");
+    const frames = segments.flatMap(({ path, keepFrom, keepTo }) => {
+      const segmentFrames = splitAdtsFrames(readFileSync5(path));
+      if (segmentFrames.length < keepTo) {
+        throw new Error(`AAC segment ${path} has ${segmentFrames.length} frames, needs ${keepTo}`);
+      }
+      return segmentFrames.slice(keepFrom, keepTo);
+    });
+    writeFileSync4(joined, Buffer.concat(frames));
+    const offset = String(-FRAME_SAMPLES / SAMPLE_RATE);
+    const end = `setts=duration='if(gte((PTS+DURATION)*TB,${totalDuration}),round(${totalDuration}/TB-PTS),DURATION)'`;
+    const muxed = await runFfmpeg(
+      [
+        "-itsoffset",
+        offset,
+        "-f",
+        "aac",
+        "-i",
+        joined,
+        "-c",
+        "copy",
+        "-bsf:a",
+        end,
+        "-y",
+        outputPath
+      ],
+      { signal, timeout }
+    );
+    const slowest = Math.max(...results.map((result) => result.durationMs));
+    return { ...muxed, durationMs: slowest + muxed.durationMs };
+  } finally {
+    rmSync5(dir, { recursive: true, force: true });
+  }
+}
+
 // ../engine/src/services/audioFailureDiagnostic.ts
 var STAGES = /* @__PURE__ */ new Set([
   "source",
@@ -13873,8 +13989,8 @@ function audioFailureDiagnostics(values) {
 }
 
 // ../engine/src/services/audioVolumeEnvelope.ts
-import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, join as join11 } from "path";
+import { mkdtempSync as mkdtempSync5, readFileSync as readFileSync6, renameSync as renameSync2, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname6, join as join12 } from "path";
 
 // ../core/dist/runtime/mediaVolumeEnvelope.js
 function normaliseEnvelope(keyframes, trackStart, baseVolume) {
@@ -13996,13 +14112,13 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
   if (!gainAt) return false;
   let stagingDir;
   try {
-    const buffer = readFileSync5(wavPath);
+    const buffer = readFileSync6(wavPath);
     const layout = parseWavLayout(buffer);
     if (!layout) return false;
     scaleSamples(buffer, layout, gainAt);
-    stagingDir = mkdtempSync4(join11(dirname5(wavPath), ".hf-volume-"));
-    const tempPath = join11(stagingDir, "audio.wav");
-    writeFileSync4(tempPath, buffer, { flag: "wx" });
+    stagingDir = mkdtempSync5(join12(dirname6(wavPath), ".hf-volume-"));
+    const tempPath = join12(stagingDir, "audio.wav");
+    writeFileSync5(tempPath, buffer, { flag: "wx" });
     renameSync2(tempPath, wavPath);
     return true;
   } catch {
@@ -14010,7 +14126,7 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
   } finally {
     if (stagingDir) {
       try {
-        rmSync5(stagingDir, { recursive: true, force: true });
+        rmSync6(stagingDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -14231,17 +14347,17 @@ function chainTailSeconds(chain, automation) {
 import {
   closeSync as closeSync3,
   existsSync as existsSync9,
-  mkdtempSync as mkdtempSync5,
+  mkdtempSync as mkdtempSync6,
   openSync as openSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readSync,
-  rmSync as rmSync6,
+  rmSync as rmSync7,
   statSync as statSync7,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync6,
   writeSync as writeSync2
 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { pathToFileURL } from "url";
 
 // ../core/dist/generated/audio-fx-runtime-inline.js
@@ -14336,7 +14452,7 @@ function readWavHeader(path) {
   }
 }
 function readWav(path) {
-  const buf = readFileSync6(path);
+  const buf = readFileSync7(path);
   if (buf.length < 44 || buf.toString("ascii", 0, 4) !== "RIFF") {
     throw new AudioFxRenderError(`Not a WAV file: ${path}`);
   }
@@ -14399,7 +14515,7 @@ function encodeSamples(samples, float) {
 function writeWav(path, samples, sampleRate, channels = 1, float = false) {
   const body = encodeSamples(samples, float);
   const buf = Buffer.concat([wavHeader(body.length, sampleRate, channels, float), body]);
-  writeFileSync5(path, buf);
+  writeFileSync6(path, buf);
 }
 function deinterleave(samples, channels) {
   if (channels <= 1) return [samples];
@@ -14525,7 +14641,7 @@ async function renderInSegments(openPage, inputWav, header, chain, outputWav, op
       );
       if (gainAt) applyEnvelopeToPlanes(kept, sampleRate, gainAt, seg.keepFrom);
       const bytes = encodeSamples(interleave(kept), float);
-      writeFileSync5(outFd, bytes);
+      writeFileSync6(outFd, bytes);
       written += bytes.length;
     }
     writeSync2(outFd, wavHeader(written, sampleRate, channels, float), 0, 44, 0);
@@ -14588,7 +14704,7 @@ async function applyAudioFxChain(inputWav, chain, outputWav, options) {
   });
 }
 async function withFxBrowser(options, body) {
-  const hostDir = mkdtempSync5(join12(tmpdir3(), "hf-fx-host-"));
+  const hostDir = mkdtempSync6(join13(tmpdir3(), "hf-fx-host-"));
   let lease = null;
   try {
     if (options.signal?.aborted) {
@@ -14603,15 +14719,15 @@ async function withFxBrowser(options, body) {
       `Audio FX failed for track ${options.trackId}: ${err.message}`
     );
   } finally {
-    rmSync6(hostDir, { recursive: true, force: true });
+    rmSync7(hostDir, { recursive: true, force: true });
     await lease?.release().catch(() => void 0);
   }
 }
 async function openFxPage(browser, hostDir) {
   const page = await browser.newPage();
   try {
-    const hostPage = join12(hostDir, "audio-fx.html");
-    writeFileSync5(hostPage, "<!doctype html><meta charset=utf-8><title>audio fx</title>");
+    const hostPage = join13(hostDir, "audio-fx.html");
+    writeFileSync6(hostPage, "<!doctype html><meta charset=utf-8><title>audio fx</title>");
     await page.goto(pathToFileURL(hostPage).href, {
       waitUntil: "domcontentloaded"
     });
@@ -15049,7 +15165,7 @@ function parseAudioElements(html) {
 }
 async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname6(outputPath);
+  const outputDir = dirname7(outputPath);
   if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
   const sourceDuration = sourceTimeAt(normalizedPlaybackRate, duration);
@@ -15095,7 +15211,7 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
 }
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname6(outputPath);
+  const outputDir = dirname7(outputPath);
   if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const args = [
     "-f",
@@ -15149,7 +15265,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
       failures: result2.failure ? [result2.failure] : void 0
     };
   }
-  const outputDir = dirname6(outputPath);
+  const outputDir = dirname7(outputPath);
   if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildFilterComplex = (ignoreAutomation, useNormalize2) => {
     const filterParts = [];
@@ -15166,11 +15282,11 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
   const runMix = async (ignoreAutomation, useNormalize2) => {
     const inputs = [];
     tracks.forEach((track) => inputs.push("-i", track.srcPath));
-    const scriptDir = mkdtempSync6(join13(outputDir, ".filter-complex-"));
-    const scriptPath = join13(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync7(join14(outputDir, ".filter-complex-"));
+    const scriptPath = join14(scriptDir, "graph.txt");
     const fd = openSync4(scriptPath, "wx", 384);
     try {
-      writeFileSync6(fd, buildFilterComplex(ignoreAutomation, useNormalize2));
+      writeFileSync7(fd, buildFilterComplex(ignoreAutomation, useNormalize2));
     } finally {
       closeSync4(fd);
     }
@@ -15180,7 +15296,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
       scriptPath,
       "-map",
       "[out]",
-      ...floatWav ? ["-acodec", "pcm_f32le", "-ar", "48000"] : ["-acodec", "aac", "-b:a", "192k"],
+      ...floatWav ? ["-acodec", "pcm_f32le", "-ar", "48000"] : AAC_ARGS,
       "-t",
       String(totalDuration),
       "-y",
@@ -15195,7 +15311,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 {
-      rmSync7(scriptDir, { recursive: true, force: true });
+      rmSync8(scriptDir, { recursive: true, force: true });
     }
   };
   let useNormalize = true;
@@ -15255,7 +15371,7 @@ function groupNormalizeOptionUnsupported(stderr) {
 }
 async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname6(outputPath);
+  const outputDir = dirname7(outputPath);
   if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const buildInputFilters = (ignoreKeyframes) => memberTracks.map((track, i) => {
     const volumeFilter = buildVolumeExpression(track, ignoreKeyframes);
@@ -15273,11 +15389,11 @@ 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 = mkdtempSync6(join13(outputDir, ".group-filter-complex-"));
-    const scriptPath = join13(scriptDir, "graph.txt");
+    const scriptDir = mkdtempSync7(join14(outputDir, ".group-filter-complex-"));
+    const scriptPath = join14(scriptDir, "graph.txt");
     const fd = openSync4(scriptPath, "wx", 384);
     try {
-      writeFileSync6(fd, filterComplex);
+      writeFileSync7(fd, filterComplex);
     } finally {
       closeSync4(fd);
     }
@@ -15314,7 +15430,7 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
       currentArgs[currentArgs.indexOf("-filter_complex_script")] = "-/filter_complex";
       return await runFfmpeg(currentArgs, { signal, timeout: ffmpegProcessTimeout });
     } finally {
-      rmSync7(scriptDir, { recursive: true, force: true });
+      rmSync8(scriptDir, { recursive: true, force: true });
     }
   };
   let useNormalize = true;
@@ -15338,29 +15454,18 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
   }
   return { success: true, degradedAutomation };
 }
-async function mixThroughMasterBus(tracks, masterChain, outputPath, workDir, totalDuration, signal, config) {
-  const sumPath = join13(workDir, "master-sum.wav");
+async function mixThroughFloatSum(tracks, masterChain, outputPath, workDir, totalDuration, signal, config) {
+  const sumPath = join14(workDir, "master-sum.wav");
   const sum = await mixAudioTracks(tracks, sumPath, totalDuration, signal, config, true);
   if (!sum.success) return { ...sum, outputPath };
-  const fx = await applyAudioFxChain(sumPath, masterChain, join13(workDir, "master-fx.wav"), {
+  const encoderInput = masterChain ? (await applyAudioFxChain(sumPath, masterChain, join14(workDir, "master-fx.wav"), {
     trackId: "master",
     signal
+  })).path : sumPath;
+  const encoded = await encodeAac(encoderInput, outputPath, totalDuration, {
+    signal,
+    timeout: config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout
   });
-  const encoded = await runFfmpeg(
-    [
-      "-i",
-      fx.path,
-      "-t",
-      String(totalDuration),
-      "-acodec",
-      "aac",
-      "-b:a",
-      "192k",
-      "-y",
-      outputPath
-    ],
-    { signal, timeout: config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout }
-  );
   if (!encoded.success) {
     const failure = ffmpegFailure("mix", encoded);
     return {
@@ -15465,7 +15570,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 extractAudioSegment(
             srcPath,
             extractedPath,
@@ -15491,7 +15596,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 extractAudioSegment(
             srcPath,
             trimmedPath,
@@ -15536,7 +15641,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,
@@ -15587,7 +15692,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   ).catch((err) => {
     internalController.abort();
     try {
-      rmSync7(workDir, { recursive: true, force: true });
+      rmSync8(workDir, { recursive: true, force: true });
     } catch {
     }
     throw err;
@@ -15612,7 +15717,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   });
   const removeWorkDir = () => {
     try {
-      rmSync7(workDir, { recursive: true, force: true });
+      rmSync8(workDir, { recursive: true, force: true });
     } catch {
     }
   };
@@ -15656,7 +15761,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,
@@ -15689,7 +15794,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,
@@ -15741,7 +15846,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   if (failures.length > 0) return bail();
   let mixResult;
   try {
-    mixResult = masterChain && tracks.length > 0 ? await mixThroughMasterBus(
+    mixResult = (masterChain || aacSegmentCount(totalDuration) > 1) && tracks.length > 0 ? await mixThroughFloatSum(
       tracks,
       masterChain,
       outputPath,
@@ -15769,21 +15874,21 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 import { cpus as cpus2, freemem } from "os";
 import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { getHeapStatistics } from "v8";
 
 // ../engine/src/utils/psnr.ts
 import { execFile as execFile3 } from "child_process";
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { promisify as promisify3 } from "util";
 async function psnrDb(a, b) {
   const execFileP = promisify3(execFile3);
-  const dir = await mkdtemp(join14(tmpdir4(), "hf-de-verify-"));
+  const dir = await mkdtemp(join15(tmpdir4(), "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(),
@@ -16007,7 +16112,7 @@ function distributeFrames(totalFrames, workerCount, workDir, rangeStart = 0) {
       workerId: i,
       startFrame,
       endFrame,
-      outputDir: join15(workDir, `worker-${i}`),
+      outputDir: join16(workDir, `worker-${i}`),
       outputFrameOffset: rangeStart
     });
   }
@@ -16021,7 +16126,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
     });
   }
@@ -16221,7 +16326,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 - offset).padStart(6, "0")}.${ext}`);
+    const framePath = join16(task.outputDir, `frame_${String(idx - offset).padStart(6, "0")}.${ext}`);
     const db = await psnrForDiskSample(framePath, truth, task.workerId, idx);
     if (db === null) continue;
     assertDiskSampleAboveFloor(db, verifyMinDb, idx, task.workerId);
@@ -16458,8 +16563,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 {
@@ -16483,8 +16588,8 @@ function getSystemResources() {
 // ../engine/src/services/fileServer.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync7, openSync as openSync5, fstatSync, closeSync as closeSync5, statSync as statSync8, constants } from "fs";
-import { join as join16, extname as extname3 } from "path";
+import { readFileSync as readFileSync8, openSync as openSync5, fstatSync, closeSync as closeSync5, statSync as statSync8, constants } from "fs";
+import { join as join17, extname as extname3 } from "path";
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
@@ -16525,16 +16630,16 @@ function readRegularFile(filePath) {
   }
   try {
     if (!fstatSync(fd).isFile()) return null;
-    return readFileSync7(fd);
+    return readFileSync8(fd);
   } finally {
     closeSync5(fd);
   }
 }
 function resolveContainedPaths(projectDir, compiledDir, relativePath) {
-  const projectPath = join16(projectDir, relativePath);
+  const projectPath = join17(projectDir, relativePath);
   if (!isWithinProjectRoot(projectDir, projectPath)) return null;
   if (!compiledDir) return { projectPath, compiledPath: null };
-  const compiledPath = join16(compiledDir, relativePath);
+  const compiledPath = join17(compiledDir, relativePath);
   if (!isWithinProjectRoot(compiledDir, compiledPath)) return null;
   return { projectPath, compiledPath };
 }

package/dist/{chunk-QABAVWEX.js → chunk-W47D3KOB.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   artifactDirectory,
   finishSnapshotRun
-} from "./chunk-JGYHWVXQ.js";
+} from "./chunk-GMJ3ILLW.js";
 
 // src/utils/checkSnapshotDirectory.ts
 import { resolve } from "path";

package/dist/{chunk-YLAREDAU.js → chunk-X3U6KEID.js}

@@ -10,7 +10,7 @@ import {
   isDevice,
   isQuality,
   render
-} from "./chunk-SJPNVLYS.js";
+} from "./chunk-ERJHLFPD.js";
 
 // src/api/removeBackground.ts
 import { resolve } from "path";

package/dist/{chunk-5FWVFCQM.js → chunk-XGFYN53T.js}

@@ -8,14 +8,14 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemFile,
   validRegistryItem
-} from "./chunk-EELTMBCC.js";
+} from "./chunk-RTW6WSC7.js";
 import {
   publishRegistryFile,
   registryTargetPath
 } from "./chunk-GMECXFAN.js";
 import {
   validateVariables
-} from "./chunk-O3J7BHBU.js";
+} from "./chunk-QZUVPWC4.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-M4N6IHCQ.js → chunk-XRQBHOBT.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   SYSTEM_FONT_SIZE_LIMIT,
   locateSystemFontVariants
-} from "./chunk-TJSTGSAW.js";
+} from "./chunk-7FMUTGOH.js";
 import {
   EMBEDDED_FONT_DATA
 } from "./chunk-FI4I7CME.js";
@@ -3227,6 +3227,8 @@ function googleStylesheetFamilies(urlText) {
   return parsed.searchParams.getAll("family").flatMap((family) => family.split("|")).map((family) => family.split(":")[0]?.trim().toLowerCase() ?? "").filter(Boolean);
 }
 function importUrls(css) {
+  if (!/@import/i.test(css))
+    return [];
   let root;
   try {
     root = postcss.parse(css);
@@ -3483,6 +3485,8 @@ function normalizeSystemFontPrimaryFamilies(html, deterministicPrimary = "Inter"
   return changed ? document2.toString() : html;
 }
 function collectCssCustomProperties(css, customProperties) {
+  if (!css.includes("--"))
+    return;
   const root = parseCssRoot(css);
   if (!root)
     return;
@@ -3509,6 +3513,8 @@ function* iterateCssRootFontFamilyDeclarations(root) {
   yield* declarations;
 }
 function* iterateCssFontFamilyDeclarations(css) {
+  if (!/font-family/i.test(css))
+    return;
   const root = parseCssRoot(css);
   if (!root)
     return;