hyperframes 0.6.115 → 0.6.116

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.6.115" : "0.0.0-dev";
+    VERSION = true ? "0.6.116" : "0.0.0-dev";
   }
 });
 
@@ -32382,6 +32382,25 @@ var init_systemMemory = __esm({
   }
 });
 
+// ../engine/src/services/vp9Options.ts
+function normalizeVp9CpuUsed(value) {
+  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_VP9_CPU_USED;
+  const integer = Math.trunc(value);
+  return Math.max(MIN_VP9_CPU_USED, Math.min(MAX_VP9_CPU_USED, integer));
+}
+function appendVp9CpuUsedArg(args, value) {
+  args.push("-cpu-used", String(normalizeVp9CpuUsed(value)));
+}
+var DEFAULT_VP9_CPU_USED, MIN_VP9_CPU_USED, MAX_VP9_CPU_USED;
+var init_vp9Options = __esm({
+  "../engine/src/services/vp9Options.ts"() {
+    "use strict";
+    DEFAULT_VP9_CPU_USED = 4;
+    MIN_VP9_CPU_USED = -8;
+    MAX_VP9_CPU_USED = 8;
+  }
+});
+
 // ../engine/src/config.ts
 function memoryAdaptiveCacheLimit() {
   const total = getSystemTotalMb();
@@ -32408,6 +32427,11 @@ function resolveConfig(overrides) {
     if (raw === void 0) return fallback;
     return raw === "true";
   };
+  const envVp9CpuUsed = () => {
+    const raw = env("PRODUCER_VP9_CPU_USED");
+    if (raw === void 0 || raw === "") return DEFAULT_CONFIG2.vp9CpuUsed;
+    return normalizeVp9CpuUsed(Number(raw));
+  };
   const envBrowserGpuMode = () => {
     const raw = env("PRODUCER_BROWSER_GPU_MODE");
     if (raw === "hardware" || raw === "software" || raw === "auto") return raw;
@@ -32448,6 +32472,7 @@ function resolveConfig(overrides) {
       "HF_PAGE_SIDE_COMPOSITING",
       DEFAULT_CONFIG2.enablePageSideCompositing
     ),
+    vp9CpuUsed: envVp9CpuUsed(),
     enableChunkedEncode: envBool(
       "PRODUCER_ENABLE_CHUNKED_ENCODE",
       DEFAULT_CONFIG2.enableChunkedEncode
@@ -32505,17 +32530,22 @@ function resolveConfig(overrides) {
     extractCacheDir: env("HYPERFRAMES_EXTRACT_CACHE_DIR")
   };
   const cleanEnv = Object.fromEntries(Object.entries(fromEnv).filter(([, v2]) => v2 !== void 0));
-  return {
+  const merged = {
     ...DEFAULT_CONFIG2,
     ...cleanEnv,
     ...overrides
   };
+  return {
+    ...merged,
+    vp9CpuUsed: normalizeVp9CpuUsed(merged.vp9CpuUsed)
+  };
 }
 var DEFAULT_CONFIG2;
 var init_config2 = __esm({
   "../engine/src/config.ts"() {
     "use strict";
     init_systemMemory();
+    init_vp9Options();
     DEFAULT_CONFIG2 = {
       fps: 30,
       quality: "standard",
@@ -32536,6 +32566,7 @@ var init_config2 = __esm({
       // DEFAULT_CONFIG (used directly by tests and worker-sizing fallbacks).
       lowMemoryMode: false,
       enablePageSideCompositing: true,
+      vp9CpuUsed: DEFAULT_VP9_CPU_USED,
       enableChunkedEncode: false,
       chunkSizeFrames: 360,
       enableStreamingEncode: true,
@@ -34837,15 +34868,322 @@ var init_runFfmpeg = __esm({
   }
 });
 
-// ../engine/src/services/chunkEncoder.ts
+// ../engine/src/utils/ffprobe.ts
 import { spawn as spawn3 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { extname } from "path";
+function runFfprobe(args) {
+  return new Promise((resolve58, reject) => {
+    const command2 = getFfprobeBinary();
+    const proc = spawn3(command2, args);
+    let stdout2 = "";
+    let stderr = "";
+    proc.stdout.on("data", (data2) => {
+      stdout2 += data2.toString();
+    });
+    proc.stderr.on("data", (data2) => {
+      stderr += data2.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`[FFmpeg] ffprobe exited with code ${code}: ${stderr}`));
+      } else {
+        resolve58(stdout2);
+      }
+    });
+    proc.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        const configured = process.env[FFPROBE_PATH_ENV]?.trim();
+        reject(
+          new Error(
+            configured ? `[FFmpeg] ffprobe not found at ${FFPROBE_PATH_ENV}="${configured}". Please install FFmpeg.` : "[FFmpeg] ffprobe not found. Please install FFmpeg."
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+function parseProbeJson(stdout2) {
+  try {
+    return JSON.parse(stdout2);
+  } catch (e3) {
+    throw new Error(
+      `[FFmpeg] Failed to parse ffprobe output: ${e3 instanceof Error ? e3.message : e3}`
+    );
+  }
+}
+function crc32(buf) {
+  let crc = 4294967295;
+  for (let i2 = 0; i2 < buf.length; i2++) {
+    crc ^= buf[i2] ?? 0;
+    for (let bit = 0; bit < 8; bit++) {
+      const mask = -(crc & 1);
+      crc = crc >>> 1 ^ 3988292384 & mask;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function extractPngMetadataFromBuffer(buf) {
+  if (buf.length < 8 || buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71 || buf[4] !== 13 || buf[5] !== 10 || buf[6] !== 26 || buf[7] !== 10) {
+    return null;
+  }
+  let width = 0;
+  let height = 0;
+  let seenIdat = false;
+  let pos = 8;
+  while (pos + 12 <= buf.length) {
+    const chunkLen = buf.readUInt32BE(pos);
+    const chunkType = buf.toString("ascii", pos + 4, pos + 8);
+    if (pos + 12 + chunkLen > buf.length) return null;
+    const chunkData = buf.subarray(pos + 8, pos + 8 + chunkLen);
+    const chunkCrc = buf.readUInt32BE(pos + 8 + chunkLen);
+    const chunkBytes = Buffer.concat([Buffer.from(chunkType, "ascii"), chunkData]);
+    if (crc32(chunkBytes) !== chunkCrc) return null;
+    if (chunkType === "IHDR" && chunkLen >= 8) {
+      width = buf.readUInt32BE(pos + 8);
+      height = buf.readUInt32BE(pos + 12);
+    }
+    if (chunkType === "IDAT") {
+      seenIdat = true;
+    }
+    if (chunkType === "cICP" && chunkLen === 4 && !seenIdat) {
+      const primariesCode = chunkData[0] ?? 0;
+      const transferCode = chunkData[1] ?? 0;
+      const matrixCode = chunkData[2] ?? 0;
+      return {
+        width,
+        height,
+        colorSpace: {
+          colorPrimaries: primariesCode === 9 ? "bt2020" : primariesCode === 1 ? "bt709" : `unknown-${primariesCode}`,
+          colorTransfer: transferCode === 16 ? "smpte2084" : transferCode === 18 ? "arib-std-b67" : transferCode === 1 ? "bt709" : `unknown-${transferCode}`,
+          colorSpace: matrixCode === 9 ? "bt2020nc" : matrixCode === 0 ? "gbr" : `unknown-${matrixCode}`
+        }
+      };
+    }
+    if (chunkType === "IEND") break;
+    pos += 12 + chunkLen;
+  }
+  return width > 0 && height > 0 ? { width, height, colorSpace: null } : null;
+}
+function extractStillImageMetadata(filePath) {
+  if (extname(filePath).toLowerCase() !== ".png") return null;
+  try {
+    return extractPngMetadataFromBuffer(readFileSync3(filePath));
+  } catch {
+    return null;
+  }
+}
+function readTagCI(tags, name) {
+  if (!tags) return "";
+  const target = name.toLowerCase();
+  for (const [key2, value] of Object.entries(tags)) {
+    if (key2.toLowerCase() === target && typeof value === "string") return value;
+  }
+  return "";
+}
+function parseFrameRate(frameRateStr) {
+  if (!frameRateStr) return 0;
+  const parts = frameRateStr.split("/");
+  if (parts.length === 2) {
+    const num = parseFloat(parts[0] ?? "");
+    const den = parseFloat(parts[1] ?? "");
+    if (den !== 0) return Math.round(num / den * 100) / 100;
+  }
+  return parseFloat(frameRateStr) || 0;
+}
+async function extractMediaMetadata(filePath) {
+  const cached2 = videoMetadataCache.get(filePath);
+  if (cached2) return cached2;
+  const probePromise = (async () => {
+    const stillImageMeta = extractStillImageMetadata(filePath);
+    let output = null;
+    try {
+      const stdout2 = await runFfprobe([
+        "-v",
+        "quiet",
+        "-print_format",
+        "json",
+        "-show_format",
+        "-show_streams",
+        filePath
+      ]);
+      output = parseProbeJson(stdout2);
+    } catch (error) {
+      if (!stillImageMeta) throw error;
+    }
+    const videoStream = output?.streams.find((s2) => s2.codec_type === "video");
+    if (!videoStream) {
+      if (stillImageMeta) {
+        return {
+          durationSeconds: 0,
+          videoStreamDurationSeconds: 0,
+          width: stillImageMeta.width,
+          height: stillImageMeta.height,
+          fps: 0,
+          videoCodec: "png",
+          hasAudio: false,
+          isVFR: false,
+          hasAlpha: false,
+          colorSpace: stillImageMeta.colorSpace
+        };
+      }
+      throw new Error("[FFmpeg] No video stream found");
+    }
+    const rFps = parseFrameRate(videoStream.r_frame_rate);
+    const avgFps = parseFrameRate(videoStream.avg_frame_rate);
+    const fps = avgFps || rFps;
+    const isVFR = rFps > 0 && avgFps > 0 && Math.abs(rFps - avgFps) / Math.max(rFps, avgFps) > 0.1;
+    const colorTransfer = videoStream.color_transfer || "";
+    const colorPrimaries = videoStream.color_primaries || "";
+    const colorSpaceVal = videoStream.color_space || "";
+    const ffprobeColorSpace = colorTransfer || colorPrimaries || colorSpaceVal ? { colorTransfer, colorPrimaries, colorSpace: colorSpaceVal } : null;
+    const colorSpace = ffprobeColorSpace ?? stillImageMeta?.colorSpace ?? null;
+    const pixelFormat = videoStream.pix_fmt || "";
+    const alphaMode = readTagCI(videoStream.tags, "alpha_mode");
+    const hasAlpha = /(^|[^a-z])yuva|rgba|argb|bgra|gbrap|gray[a-z0-9]*a/i.test(pixelFormat) || alphaMode === "1";
+    const containerDuration = output?.format.duration ? parseFloat(output.format.duration) : 0;
+    const streamDuration = videoStream.duration ? parseFloat(videoStream.duration) : 0;
+    return {
+      durationSeconds: containerDuration,
+      videoStreamDurationSeconds: streamDuration > 0 ? streamDuration : containerDuration,
+      width: videoStream.width || stillImageMeta?.width || 0,
+      height: videoStream.height || stillImageMeta?.height || 0,
+      fps,
+      videoCodec: videoStream.codec_name || "unknown",
+      hasAudio: output?.streams.some((s2) => s2.codec_type === "audio") ?? false,
+      isVFR,
+      hasAlpha,
+      colorSpace
+    };
+  })();
+  videoMetadataCache.set(filePath, probePromise);
+  probePromise.catch(() => {
+    if (videoMetadataCache.get(filePath) === probePromise) {
+      videoMetadataCache.delete(filePath);
+    }
+  });
+  return probePromise;
+}
+async function extractAudioMetadata(filePath) {
+  const cached2 = audioMetadataCache.get(filePath);
+  if (cached2) return cached2;
+  const probePromise = (async () => {
+    const stdout2 = await runFfprobe([
+      "-v",
+      "quiet",
+      "-print_format",
+      "json",
+      "-show_format",
+      "-show_streams",
+      filePath
+    ]);
+    const output = parseProbeJson(stdout2);
+    const audioStream = output.streams.find((s2) => s2.codec_type === "audio");
+    if (!audioStream) throw new Error("[FFmpeg] No audio stream found");
+    const durationSeconds = output.format.duration ? parseFloat(output.format.duration) : 0;
+    return {
+      durationSeconds,
+      sampleRate: audioStream.sample_rate ? parseInt(audioStream.sample_rate) : 44100,
+      channels: audioStream.channels || 2,
+      audioCodec: audioStream.codec_name || "unknown",
+      bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0
+    };
+  })();
+  audioMetadataCache.set(filePath, probePromise);
+  probePromise.catch(() => {
+    if (audioMetadataCache.get(filePath) === probePromise) {
+      audioMetadataCache.delete(filePath);
+    }
+  });
+  return probePromise;
+}
+async function analyzeKeyframeIntervals(filePath) {
+  const cached2 = keyframeCache.get(filePath);
+  if (cached2) return cached2;
+  const promise = analyzeKeyframeIntervalsUncached(filePath);
+  keyframeCache.set(filePath, promise);
+  promise.catch(() => {
+    if (keyframeCache.get(filePath) === promise) {
+      keyframeCache.delete(filePath);
+    }
+  });
+  return promise;
+}
+async function analyzeKeyframeIntervalsUncached(filePath) {
+  const stdout2 = await runFfprobe([
+    "-v",
+    "quiet",
+    "-select_streams",
+    "v:0",
+    "-skip_frame",
+    "nokey",
+    "-show_entries",
+    "frame=pts_time",
+    "-of",
+    "csv=p=0",
+    filePath
+  ]);
+  const timestamps = stdout2.split("\n").map((line) => parseFloat(line.trim())).filter((t2) => Number.isFinite(t2));
+  if (timestamps.length < 2) {
+    return {
+      avgIntervalSeconds: 0,
+      maxIntervalSeconds: 0,
+      keyframeCount: timestamps.length,
+      isProblematic: false
+    };
+  }
+  let maxInterval = 0;
+  let totalInterval = 0;
+  for (let i2 = 1; i2 < timestamps.length; i2++) {
+    const interval = (timestamps[i2] ?? 0) - (timestamps[i2 - 1] ?? 0);
+    totalInterval += interval;
+    if (interval > maxInterval) maxInterval = interval;
+  }
+  const avgInterval = totalInterval / (timestamps.length - 1);
+  return {
+    avgIntervalSeconds: Math.round(avgInterval * 100) / 100,
+    maxIntervalSeconds: Math.round(maxInterval * 100) / 100,
+    keyframeCount: timestamps.length,
+    isProblematic: maxInterval > 2
+  };
+}
+var videoMetadataCache, audioMetadataCache, extractVideoMetadata, keyframeCache;
+var init_ffprobe = __esm({
+  "../engine/src/utils/ffprobe.ts"() {
+    "use strict";
+    init_ffmpegBinaries();
+    videoMetadataCache = /* @__PURE__ */ new Map();
+    audioMetadataCache = /* @__PURE__ */ new Map();
+    extractVideoMetadata = extractMediaMetadata;
+    keyframeCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../engine/src/services/chunkEncoder.ts
+import { spawn as spawn4 } from "child_process";
 import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6, dirname as dirname4 } from "path";
+import { join as join6, dirname as dirname4, extname as extname2 } from "path";
 function appendEncodeTimeoutMessage(error, timedOut, timeoutMs) {
   if (!timedOut) return error;
   return `${error}
 FFmpeg killed after exceeding ffmpegEncodeTimeout (${timeoutMs} ms)`;
 }
+function isAacSidecar(audioPath) {
+  return extname2(audioPath).toLowerCase() === ".aac";
+}
+async function shouldCopyAacSidecar(audioPath, options) {
+  if (options?.audioCodec === "aac" || isAacSidecar(audioPath)) return true;
+  const audioExtension = extname2(audioPath).toLowerCase();
+  if (KNOWN_NON_AAC_AUDIO_EXTENSIONS.has(audioExtension)) return false;
+  try {
+    const metadata = await extractAudioMetadata(audioPath);
+    return metadata.audioCodec === "aac";
+  } catch {
+    return false;
+  }
+}
 function getEncoderPreset(quality, format = "mp4", hdr) {
   const base2 = ENCODER_PRESETS[quality];
   if (format === "webm") {
@@ -34883,6 +35221,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
     quality = 23,
     bitrate,
     pixelFormat = "yuv420p",
+    vp9CpuUsed,
     useGpu = false
   } = options;
   if (options.hdr && codec === "h264") {
@@ -34985,6 +35324,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
     args.push("-c:v", "libvpx-vp9", "-b:v", bitrate || "0", "-crf", String(quality));
     args.push("-deadline", preset === "ultrafast" ? "realtime" : "good");
     args.push("-row-mt", "1");
+    appendVp9CpuUsedArg(args, vp9CpuUsed);
     const lockGopVp9 = options.lockGopForChunkConcat === true;
     if (lockGopVp9) {
       if (typeof options.gopSize !== "number" || !Number.isFinite(options.gopSize) || options.gopSize <= 0) {
@@ -34993,16 +35333,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
         );
       }
       const gop = Math.floor(options.gopSize);
-      args.push(
-        "-g",
-        String(gop),
-        "-keyint_min",
-        String(gop),
-        "-auto-alt-ref",
-        "0",
-        "-cpu-used",
-        "2"
-      );
+      args.push("-g", String(gop), "-keyint_min", String(gop), "-auto-alt-ref", "0");
     }
     if (pixelFormat === "yuva420p") {
       if (!lockGopVp9) {
@@ -35081,7 +35412,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
   const inputArgs = ["-framerate", fpsToFfmpegArg(options.fps), "-i", inputPath];
   const args = buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder);
   return new Promise((resolve58) => {
-    const ffmpeg = spawn3(getFfmpegBinary(), args);
+    const ffmpeg = spawn4(getFfmpegBinary(), args);
     trackChildProcess(ffmpeg);
     let stderr = "";
     const onAbort = () => {
@@ -35198,7 +35529,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     if (options.useGpu) gpuEncoder = await getCachedGpuEncoder();
     const args = buildEncoderArgs(options, inputArgs, chunkPath, gpuEncoder);
     const chunkResult = await new Promise((resolve58) => {
-      const ffmpeg = spawn3(getFfmpegBinary(), args);
+      const ffmpeg = spawn4(getFfmpegBinary(), args);
       trackChildProcess(ffmpeg);
       let stderr = "";
       const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG2.ffmpegEncodeTimeout;
@@ -35264,7 +35595,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
     outputPath
   ];
   const concatResult = await new Promise((resolve58) => {
-    const ffmpeg = spawn3(getFfmpegBinary(), concatArgs);
+    const ffmpeg = spawn4(getFfmpegBinary(), concatArgs);
     trackChildProcess(ffmpeg);
     let stderr = "";
     const encodeTimeout = config?.ffmpegEncodeTimeout ?? DEFAULT_CONFIG2.ffmpegEncodeTimeout;
@@ -35326,13 +35657,22 @@ async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, confi
   if (!existsSync6(outputDir)) mkdirSync3(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const isMov = outputPath.endsWith(".mov");
+  const shouldCopyAudio = isWebm ? false : await shouldCopyAacSidecar(audioPath, config);
   const args = ["-i", videoPath, "-i", audioPath, "-c:v", "copy"];
   if (isWebm) {
     args.push("-c:a", "libopus", "-b:a", "128k");
   } else if (isMov) {
-    args.push("-c:a", "aac", "-b:a", "192k");
+    if (shouldCopyAudio) {
+      args.push("-c:a", "copy");
+    } else {
+      args.push("-c:a", "aac", "-b:a", "192k");
+    }
   } else {
-    args.push("-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart");
+    if (shouldCopyAudio) {
+      args.push("-c:a", "copy", "-movflags", "+faststart");
+    } else {
+      args.push("-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart");
+    }
   }
   args.push("-avoid_negative_ts", "make_zero");
   if (fps !== void 0) {
@@ -35383,7 +35723,7 @@ async function applyFaststart(inputPath, outputPath, signal, config, fps) {
     error: !result.success ? formatFfmpegError(result.exitCode, result.stderr) : void 0
   };
 }
-var ENCODER_PRESETS;
+var ENCODER_PRESETS, KNOWN_NON_AAC_AUDIO_EXTENSIONS;
 var init_chunkEncoder = __esm({
   "../engine/src/services/chunkEncoder.ts"() {
     "use strict";
@@ -35393,18 +35733,29 @@ var init_chunkEncoder = __esm({
     init_hdr();
     init_runFfmpeg();
     init_ffmpegBinaries();
+    init_ffprobe();
     init_src();
+    init_vp9Options();
     init_gpuEncoder();
     ENCODER_PRESETS = {
       draft: { preset: "ultrafast", quality: 28, codec: "h264" },
       standard: { preset: "medium", quality: 18, codec: "h264" },
       high: { preset: "slow", quality: 15, codec: "h264" }
     };
+    KNOWN_NON_AAC_AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".flac",
+      ".mp3",
+      ".oga",
+      ".ogg",
+      ".opus",
+      ".wav",
+      ".webm"
+    ]);
   }
 });
 
 // ../engine/src/services/streamingEncoder.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { once } from "events";
 import { existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSync2 } from "fs";
 import { dirname as dirname5 } from "path";
@@ -35453,6 +35804,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
     quality = 23,
     bitrate,
     pixelFormat = "yuv420p",
+    vp9CpuUsed,
     useGpu = false,
     imageFormat = "jpeg"
   } = options;
@@ -35559,6 +35911,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
     args.push("-c:v", "libvpx-vp9", "-b:v", bitrate || "0", "-crf", String(quality));
     args.push("-deadline", preset === "ultrafast" ? "realtime" : "good");
     args.push("-row-mt", "1");
+    appendVp9CpuUsedArg(args, vp9CpuUsed);
     if (pixelFormat === "yuva420p") {
       args.push("-auto-alt-ref", "0");
       args.push("-metadata:s:v:0", "alpha_mode=1");
@@ -35619,7 +35972,7 @@ async function spawnStreamingEncoder(outputPath, options, signal, config) {
   }
   const args = buildStreamingArgs(options, outputPath, gpuEncoder);
   const startTime = Date.now();
-  const ffmpeg = spawn4(getFfmpegBinary(), args, {
+  const ffmpeg = spawn5(getFfmpegBinary(), args, {
     stdio: ["pipe", "pipe", "pipe"]
   });
   trackChildProcess(ffmpeg);
@@ -35758,306 +36111,14 @@ var init_streamingEncoder = __esm({
     init_hdr();
     init_config2();
     init_src();
-  }
-});
-
-// ../engine/src/utils/ffprobe.ts
-import { spawn as spawn5 } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
-import { extname } from "path";
-function runFfprobe(args) {
-  return new Promise((resolve58, reject) => {
-    const command2 = getFfprobeBinary();
-    const proc = spawn5(command2, args);
-    let stdout2 = "";
-    let stderr = "";
-    proc.stdout.on("data", (data2) => {
-      stdout2 += data2.toString();
-    });
-    proc.stderr.on("data", (data2) => {
-      stderr += data2.toString();
-    });
-    proc.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error(`[FFmpeg] ffprobe exited with code ${code}: ${stderr}`));
-      } else {
-        resolve58(stdout2);
-      }
-    });
-    proc.on("error", (err) => {
-      if (err.code === "ENOENT") {
-        const configured = process.env[FFPROBE_PATH_ENV]?.trim();
-        reject(
-          new Error(
-            configured ? `[FFmpeg] ffprobe not found at ${FFPROBE_PATH_ENV}="${configured}". Please install FFmpeg.` : "[FFmpeg] ffprobe not found. Please install FFmpeg."
-          )
-        );
-      } else {
-        reject(err);
-      }
-    });
-  });
-}
-function parseProbeJson(stdout2) {
-  try {
-    return JSON.parse(stdout2);
-  } catch (e3) {
-    throw new Error(
-      `[FFmpeg] Failed to parse ffprobe output: ${e3 instanceof Error ? e3.message : e3}`
-    );
-  }
-}
-function crc32(buf) {
-  let crc = 4294967295;
-  for (let i2 = 0; i2 < buf.length; i2++) {
-    crc ^= buf[i2] ?? 0;
-    for (let bit = 0; bit < 8; bit++) {
-      const mask = -(crc & 1);
-      crc = crc >>> 1 ^ 3988292384 & mask;
-    }
-  }
-  return (crc ^ 4294967295) >>> 0;
-}
-function extractPngMetadataFromBuffer(buf) {
-  if (buf.length < 8 || buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71 || buf[4] !== 13 || buf[5] !== 10 || buf[6] !== 26 || buf[7] !== 10) {
-    return null;
-  }
-  let width = 0;
-  let height = 0;
-  let seenIdat = false;
-  let pos = 8;
-  while (pos + 12 <= buf.length) {
-    const chunkLen = buf.readUInt32BE(pos);
-    const chunkType = buf.toString("ascii", pos + 4, pos + 8);
-    if (pos + 12 + chunkLen > buf.length) return null;
-    const chunkData = buf.subarray(pos + 8, pos + 8 + chunkLen);
-    const chunkCrc = buf.readUInt32BE(pos + 8 + chunkLen);
-    const chunkBytes = Buffer.concat([Buffer.from(chunkType, "ascii"), chunkData]);
-    if (crc32(chunkBytes) !== chunkCrc) return null;
-    if (chunkType === "IHDR" && chunkLen >= 8) {
-      width = buf.readUInt32BE(pos + 8);
-      height = buf.readUInt32BE(pos + 12);
-    }
-    if (chunkType === "IDAT") {
-      seenIdat = true;
-    }
-    if (chunkType === "cICP" && chunkLen === 4 && !seenIdat) {
-      const primariesCode = chunkData[0] ?? 0;
-      const transferCode = chunkData[1] ?? 0;
-      const matrixCode = chunkData[2] ?? 0;
-      return {
-        width,
-        height,
-        colorSpace: {
-          colorPrimaries: primariesCode === 9 ? "bt2020" : primariesCode === 1 ? "bt709" : `unknown-${primariesCode}`,
-          colorTransfer: transferCode === 16 ? "smpte2084" : transferCode === 18 ? "arib-std-b67" : transferCode === 1 ? "bt709" : `unknown-${transferCode}`,
-          colorSpace: matrixCode === 9 ? "bt2020nc" : matrixCode === 0 ? "gbr" : `unknown-${matrixCode}`
-        }
-      };
-    }
-    if (chunkType === "IEND") break;
-    pos += 12 + chunkLen;
-  }
-  return width > 0 && height > 0 ? { width, height, colorSpace: null } : null;
-}
-function extractStillImageMetadata(filePath) {
-  if (extname(filePath).toLowerCase() !== ".png") return null;
-  try {
-    return extractPngMetadataFromBuffer(readFileSync3(filePath));
-  } catch {
-    return null;
-  }
-}
-function readTagCI(tags, name) {
-  if (!tags) return "";
-  const target = name.toLowerCase();
-  for (const [key2, value] of Object.entries(tags)) {
-    if (key2.toLowerCase() === target && typeof value === "string") return value;
-  }
-  return "";
-}
-function parseFrameRate(frameRateStr) {
-  if (!frameRateStr) return 0;
-  const parts = frameRateStr.split("/");
-  if (parts.length === 2) {
-    const num = parseFloat(parts[0] ?? "");
-    const den = parseFloat(parts[1] ?? "");
-    if (den !== 0) return Math.round(num / den * 100) / 100;
-  }
-  return parseFloat(frameRateStr) || 0;
-}
-async function extractMediaMetadata(filePath) {
-  const cached2 = videoMetadataCache.get(filePath);
-  if (cached2) return cached2;
-  const probePromise = (async () => {
-    const stillImageMeta = extractStillImageMetadata(filePath);
-    let output = null;
-    try {
-      const stdout2 = await runFfprobe([
-        "-v",
-        "quiet",
-        "-print_format",
-        "json",
-        "-show_format",
-        "-show_streams",
-        filePath
-      ]);
-      output = parseProbeJson(stdout2);
-    } catch (error) {
-      if (!stillImageMeta) throw error;
-    }
-    const videoStream = output?.streams.find((s2) => s2.codec_type === "video");
-    if (!videoStream) {
-      if (stillImageMeta) {
-        return {
-          durationSeconds: 0,
-          videoStreamDurationSeconds: 0,
-          width: stillImageMeta.width,
-          height: stillImageMeta.height,
-          fps: 0,
-          videoCodec: "png",
-          hasAudio: false,
-          isVFR: false,
-          hasAlpha: false,
-          colorSpace: stillImageMeta.colorSpace
-        };
-      }
-      throw new Error("[FFmpeg] No video stream found");
-    }
-    const rFps = parseFrameRate(videoStream.r_frame_rate);
-    const avgFps = parseFrameRate(videoStream.avg_frame_rate);
-    const fps = avgFps || rFps;
-    const isVFR = rFps > 0 && avgFps > 0 && Math.abs(rFps - avgFps) / Math.max(rFps, avgFps) > 0.1;
-    const colorTransfer = videoStream.color_transfer || "";
-    const colorPrimaries = videoStream.color_primaries || "";
-    const colorSpaceVal = videoStream.color_space || "";
-    const ffprobeColorSpace = colorTransfer || colorPrimaries || colorSpaceVal ? { colorTransfer, colorPrimaries, colorSpace: colorSpaceVal } : null;
-    const colorSpace = ffprobeColorSpace ?? stillImageMeta?.colorSpace ?? null;
-    const pixelFormat = videoStream.pix_fmt || "";
-    const alphaMode = readTagCI(videoStream.tags, "alpha_mode");
-    const hasAlpha = /(^|[^a-z])yuva|rgba|argb|bgra|gbrap|gray[a-z0-9]*a/i.test(pixelFormat) || alphaMode === "1";
-    const containerDuration = output?.format.duration ? parseFloat(output.format.duration) : 0;
-    const streamDuration = videoStream.duration ? parseFloat(videoStream.duration) : 0;
-    return {
-      durationSeconds: containerDuration,
-      videoStreamDurationSeconds: streamDuration > 0 ? streamDuration : containerDuration,
-      width: videoStream.width || stillImageMeta?.width || 0,
-      height: videoStream.height || stillImageMeta?.height || 0,
-      fps,
-      videoCodec: videoStream.codec_name || "unknown",
-      hasAudio: output?.streams.some((s2) => s2.codec_type === "audio") ?? false,
-      isVFR,
-      hasAlpha,
-      colorSpace
-    };
-  })();
-  videoMetadataCache.set(filePath, probePromise);
-  probePromise.catch(() => {
-    if (videoMetadataCache.get(filePath) === probePromise) {
-      videoMetadataCache.delete(filePath);
-    }
-  });
-  return probePromise;
-}
-async function extractAudioMetadata(filePath) {
-  const cached2 = audioMetadataCache.get(filePath);
-  if (cached2) return cached2;
-  const probePromise = (async () => {
-    const stdout2 = await runFfprobe([
-      "-v",
-      "quiet",
-      "-print_format",
-      "json",
-      "-show_format",
-      "-show_streams",
-      filePath
-    ]);
-    const output = parseProbeJson(stdout2);
-    const audioStream = output.streams.find((s2) => s2.codec_type === "audio");
-    if (!audioStream) throw new Error("[FFmpeg] No audio stream found");
-    const durationSeconds = output.format.duration ? parseFloat(output.format.duration) : 0;
-    return {
-      durationSeconds,
-      sampleRate: audioStream.sample_rate ? parseInt(audioStream.sample_rate) : 44100,
-      channels: audioStream.channels || 2,
-      audioCodec: audioStream.codec_name || "unknown",
-      bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0
-    };
-  })();
-  audioMetadataCache.set(filePath, probePromise);
-  probePromise.catch(() => {
-    if (audioMetadataCache.get(filePath) === probePromise) {
-      audioMetadataCache.delete(filePath);
-    }
-  });
-  return probePromise;
-}
-async function analyzeKeyframeIntervals(filePath) {
-  const cached2 = keyframeCache.get(filePath);
-  if (cached2) return cached2;
-  const promise = analyzeKeyframeIntervalsUncached(filePath);
-  keyframeCache.set(filePath, promise);
-  promise.catch(() => {
-    if (keyframeCache.get(filePath) === promise) {
-      keyframeCache.delete(filePath);
-    }
-  });
-  return promise;
-}
-async function analyzeKeyframeIntervalsUncached(filePath) {
-  const stdout2 = await runFfprobe([
-    "-v",
-    "quiet",
-    "-select_streams",
-    "v:0",
-    "-skip_frame",
-    "nokey",
-    "-show_entries",
-    "frame=pts_time",
-    "-of",
-    "csv=p=0",
-    filePath
-  ]);
-  const timestamps = stdout2.split("\n").map((line) => parseFloat(line.trim())).filter((t2) => Number.isFinite(t2));
-  if (timestamps.length < 2) {
-    return {
-      avgIntervalSeconds: 0,
-      maxIntervalSeconds: 0,
-      keyframeCount: timestamps.length,
-      isProblematic: false
-    };
-  }
-  let maxInterval = 0;
-  let totalInterval = 0;
-  for (let i2 = 1; i2 < timestamps.length; i2++) {
-    const interval = (timestamps[i2] ?? 0) - (timestamps[i2 - 1] ?? 0);
-    totalInterval += interval;
-    if (interval > maxInterval) maxInterval = interval;
-  }
-  const avgInterval = totalInterval / (timestamps.length - 1);
-  return {
-    avgIntervalSeconds: Math.round(avgInterval * 100) / 100,
-    maxIntervalSeconds: Math.round(maxInterval * 100) / 100,
-    keyframeCount: timestamps.length,
-    isProblematic: maxInterval > 2
-  };
-}
-var videoMetadataCache, audioMetadataCache, extractVideoMetadata, keyframeCache;
-var init_ffprobe = __esm({
-  "../engine/src/utils/ffprobe.ts"() {
-    "use strict";
-    init_ffmpegBinaries();
-    videoMetadataCache = /* @__PURE__ */ new Map();
-    audioMetadataCache = /* @__PURE__ */ new Map();
-    extractVideoMetadata = extractMediaMetadata;
-    keyframeCache = /* @__PURE__ */ new Map();
+    init_vp9Options();
   }
 });
 
 // ../engine/src/utils/urlDownloader.ts
 import { createWriteStream, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
 import { createHash } from "crypto";
-import { join as join7, extname as extname2 } from "path";
+import { join as join7, extname as extname3 } from "path";
 import { Readable } from "stream";
 import { finished } from "stream/promises";
 function isBlockedHost(hostname) {
@@ -36092,7 +36153,7 @@ function assertPublicHttpsUrl(url) {
 function getFilenameFromUrl(url) {
   const hash2 = createHash("md5").update(url).digest("hex").slice(0, 12);
   const urlObj = new URL(url);
-  const ext = extname2(urlObj.pathname) || ".mp4";
+  const ext = extname3(urlObj.pathname) || ".mp4";
   return `download_${hash2}${ext}`;
 }
 async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
@@ -40023,7 +40084,7 @@ var init_parallelCoordinator = __esm({
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
 import { readFileSync as readFileSync6, existsSync as existsSync14, statSync as statSync4 } from "fs";
-import { join as join13, extname as extname3 } from "path";
+import { join as join13, extname as extname4 } from "path";
 function createFileServer(options) {
   const { projectDir, compiledDir, port = 0, stripEmbeddedRuntime = true } = options;
   const headScripts = options.headScripts ?? [];
@@ -40041,7 +40102,7 @@ function createFileServer(options) {
     if (!existsSync14(filePath) || !statSync4(filePath).isFile()) {
       return c3.text("Not found", 404);
     }
-    const ext = extname3(filePath).toLowerCase();
+    const ext = extname4(filePath).toLowerCase();
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     if (ext === ".html") {
       const rawHtml = readFileSync6(filePath, "utf-8");
@@ -41569,6 +41630,7 @@ __export(src_exports2, {
   BROWSER_GPU_NOT_SOFTWARE: () => BROWSER_GPU_NOT_SOFTWARE,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG2,
   DEFAULT_HDR10_MASTERING: () => DEFAULT_HDR10_MASTERING,
+  DEFAULT_VP9_CPU_USED: () => DEFAULT_VP9_CPU_USED,
   DOM_LAYER_MASK_STYLE_ID: () => DOM_LAYER_MASK_STYLE_ID,
   ENABLE_BROWSER_POOL: () => ENABLE_BROWSER_POOL,
   ENCODER_PRESETS: () => ENCODER_PRESETS,
@@ -41576,7 +41638,9 @@ __export(src_exports2, {
   FFPROBE_PATH_ENV: () => FFPROBE_PATH_ENV,
   FrameLookupTable: () => FrameLookupTable,
   LOW_MEMORY_TOTAL_MB_THRESHOLD: () => LOW_MEMORY_TOTAL_MB_THRESHOLD,
+  MAX_VP9_CPU_USED: () => MAX_VP9_CPU_USED,
   MEDIA_VISUAL_STYLE_PROPERTIES: () => MEDIA_VISUAL_STYLE_PROPERTIES,
+  MIN_VP9_CPU_USED: () => MIN_VP9_CPU_USED,
   SwiftShaderAssertionError: () => SwiftShaderAssertionError,
   TRANSITIONS: () => TRANSITIONS,
   VIDEO_FRAME_FORMATS: () => VIDEO_FRAME_FORMATS,
@@ -41654,6 +41718,7 @@ __export(src_exports2, {
   mergeWorkerFrames: () => mergeWorkerFrames,
   muxVideoWithAudio: () => muxVideoWithAudio,
   normalizeObjectFit: () => normalizeObjectFit,
+  normalizeVp9CpuUsed: () => normalizeVp9CpuUsed,
   pageScreenshotCapture: () => pageScreenshotCapture,
   parseAudioElements: () => parseAudioElements,
   parseImageElements: () => parseImageElements,
@@ -41686,6 +41751,7 @@ var init_src2 = __esm({
   "../engine/src/index.ts"() {
     "use strict";
     init_config2();
+    init_vp9Options();
     init_systemMemory();
     init_browserManager();
     init_frameCapture();
@@ -45223,9 +45289,9 @@ __export(normalize_exports, {
   stripBeforeOnset: () => stripBeforeOnset
 });
 import { readFileSync as readFileSync12, readdirSync as readdirSync7, writeFileSync as writeFileSync8 } from "fs";
-import { extname as extname4, join as join18 } from "path";
+import { extname as extname5, join as join18 } from "path";
 function detectFormat(filePath) {
-  const ext = extname4(filePath).toLowerCase();
+  const ext = extname5(filePath).toLowerCase();
   if (ext === ".srt") return "srt";
   if (ext === ".vtt") return "vtt";
   if (ext === ".json") return detectJsonFormat(JSON.parse(readFileSync12(filePath, "utf-8")));
@@ -45377,7 +45443,7 @@ function round3(n2) {
   return Math.round(n2 * 1e3) / 1e3;
 }
 function loadTranscript(filePath) {
-  const ext = extname4(filePath).toLowerCase();
+  const ext = extname5(filePath).toLowerCase();
   const content = readFileSync12(filePath, "utf-8");
   if (ext === ".srt") {
     const words2 = parseSrt(content).map((w3, i2) => ({ ...w3, id: w3.id ?? `w${i2}` }));
@@ -45502,7 +45568,7 @@ __export(transcribe_exports, {
 });
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync21, readFileSync as readFileSync14, mkdirSync as mkdirSync12, unlinkSync as unlinkSync2 } from "fs";
-import { join as join20, extname as extname5 } from "path";
+import { join as join20, extname as extname6 } from "path";
 import { tmpdir } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
 function detectLanguage(whisperPath, modelPath2, wavPath) {
@@ -45576,10 +45642,10 @@ function detectSpeechOnset(wavPath) {
   return null;
 }
 function isAudioFile(filePath) {
-  return AUDIO_EXTENSIONS.has(extname5(filePath).toLowerCase());
+  return AUDIO_EXTENSIONS.has(extname6(filePath).toLowerCase());
 }
 function isVideoFile(filePath) {
-  return VIDEO_EXTENSIONS.has(extname5(filePath).toLowerCase());
+  return VIDEO_EXTENSIONS.has(extname6(filePath).toLowerCase());
 }
 function tempWavPath() {
   return join20(tmpdir(), `hyperframes-audio-${process.pid}-${randomUUID2()}.wav`);
@@ -45616,7 +45682,7 @@ function isWav16kMono(filePath) {
   }
 }
 function prepareAudio(audioPath) {
-  if (extname5(audioPath).toLowerCase() === ".wav" && isWav16kMono(audioPath)) {
+  if (extname6(audioPath).toLowerCase() === ".wav" && isWav16kMono(audioPath)) {
     return audioPath;
   }
   const ffmpegPath = findFFmpeg();
@@ -45640,7 +45706,7 @@ async function transcribe(inputPath, outputDir, options) {
     onProgress: options?.onProgress
   });
   let wavPath;
-  const ext = extname5(inputPath).toLowerCase();
+  const ext = extname6(inputPath).toLowerCase();
   if (isAudioFile(inputPath)) {
     options?.onProgress?.("Preparing audio...");
     wavPath = prepareAudio(inputPath);
@@ -45867,7 +45933,7 @@ var init_lint = __esm({
 
 // src/utils/lintProject.ts
 import { existsSync as existsSync22, readFileSync as readFileSync15, readdirSync as readdirSync8 } from "fs";
-import { dirname as dirname9, extname as extname6, isAbsolute as isAbsolute6, join as join21, posix as posix3, relative as relative4, resolve as resolve12 } from "path";
+import { dirname as dirname9, extname as extname7, isAbsolute as isAbsolute6, join as join21, posix as posix3, relative as relative4, resolve as resolve12 } from "path";
 function readHtmlAttr(tag, name) {
   const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const match = tag.match(new RegExp(`\\b${escaped}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, "i"));
@@ -46040,7 +46106,7 @@ function lintProjectAudioFiles(projectDir, htmlSources) {
   let audioFiles;
   try {
     audioFiles = readdirSync8(projectDir).filter(
-      (f3) => AUDIO_EXTENSIONS2.has(extname6(f3).toLowerCase())
+      (f3) => AUDIO_EXTENSIONS2.has(extname7(f3).toLowerCase())
     );
   } catch {
     return findings;
@@ -86064,13 +86130,13 @@ var init_subComposition = __esm({
 // ../core/src/studio-api/helpers/projectSignature.ts
 import { createHash as createHash4 } from "crypto";
 import { lstatSync, readFileSync as readFileSync21, readdirSync as readdirSync12 } from "fs";
-import { extname as extname7, isAbsolute as isAbsolute7, relative as relative6, resolve as resolve18 } from "path";
+import { extname as extname8, isAbsolute as isAbsolute7, relative as relative6, resolve as resolve18 } from "path";
 function isPathWithin(parentDir, childPath) {
   const childRelativePath = relative6(parentDir, childPath);
   return childRelativePath === "" || !childRelativePath.startsWith("..") && !isAbsolute7(childRelativePath);
 }
 function isTextContentEligible(file, size) {
-  return SIGNATURE_TEXT_EXTENSIONS.has(extname7(file).toLowerCase()) && size <= MAX_SIGNATURE_TEXT_BYTES;
+  return SIGNATURE_TEXT_EXTENSIONS.has(extname8(file).toLowerCase()) && size <= MAX_SIGNATURE_TEXT_BYTES;
 }
 function collectProjectSignatureFiles(projectDir, dir, files) {
   let entries2;
@@ -92412,6 +92478,8 @@ function buildAnimatedGifTranscodeArgs(input2) {
     "0",
     "-deadline",
     "good",
+    "-cpu-used",
+    String(DEFAULT_VP9_CPU_USED),
     "-crf",
     "18",
     "-b:v",
@@ -92704,7 +92772,7 @@ var init_hf_early_stub_inline = __esm({
 import { Hono as Hono3 } from "hono";
 import { serve as serve2 } from "@hono/node-server";
 import { readFileSync as readFileSync31, existsSync as existsSync38, realpathSync as realpathSync3, statSync as statSync12 } from "fs";
-import { join as join38, extname as extname8, resolve as resolve22, sep as sep4 } from "path";
+import { join as join38, extname as extname9, resolve as resolve22, sep as sep4 } from "path";
 function isPathInside2(child, parent, options = {}) {
   const { resolveSymlinks = false, pathModule } = options;
   const resolveFn = pathModule?.resolve ?? resolve22;
@@ -92904,7 +92972,7 @@ function createFileServer2(options) {
       }
       return c3.text("Not found", 404);
     }
-    const ext = extname8(filePath).toLowerCase();
+    const ext = extname9(filePath).toLowerCase();
     const contentType = MIME_TYPES3[ext] || "application/octet-stream";
     if (ext === ".html") {
       const rawHtml = readFileSync31(filePath, "utf-8");
@@ -98465,6 +98533,7 @@ async function runEncodeStage(input2) {
     quality: effectiveQuality,
     bitrate: effectiveBitrate,
     pixelFormat: preset.pixelFormat,
+    vp9CpuUsed: engineCfg.vp9CpuUsed,
     useGpu: job.config.useGpu,
     hdr: preset.hdr,
     // Distributed chunk renders pass these so the encoder writes closed-GOP
@@ -98525,7 +98594,7 @@ async function runAssembleStage(input2) {
       audioOutputPath,
       outputPath,
       abortSignal,
-      void 0,
+      { audioCodec: "aac" },
       job.config.fps
     );
     assertNotAborted();
@@ -99390,6 +99459,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
               quality: effectiveQuality,
               bitrate: effectiveBitrate,
               pixelFormat: preset.pixelFormat,
+              vp9CpuUsed: cfg.vp9CpuUsed,
               useGpu: job.config.useGpu,
               imageFormat: captureOptions.format || "jpeg",
               hdr: preset.hdr
@@ -100848,6 +100918,7 @@ async function readFontSnapshotSha() {
 function buildLockedRenderConfig(input2) {
   const { config, forceScreenshot, deviceScaleFactor, ffmpegVersion } = input2;
   const { encoder, pixelFormat, preset } = resolveEncoderTriple(config);
+  const locksVp9CpuUsed = encoder === "libvpx-vp9-software" ? { vp9CpuUsed: normalizeVp9CpuUsed(input2.engineConfig.vp9CpuUsed) } : {};
   return {
     captureMode: forceScreenshot ? "screenshot" : "beginframe",
     forceScreenshot,
@@ -100864,6 +100935,7 @@ function buildLockedRenderConfig(input2) {
     preset,
     crf: config.crf,
     bitrate: config.bitrate,
+    ...locksVp9CpuUsed,
     // GOP === chunkSize so every chunk's first frame is an IDR keyframe and
     // ffmpeg concat-copy round-trips losslessly.
     gopSize: input2.effectiveChunkSize,
@@ -101091,6 +101163,7 @@ async function plan(projectDir, config, planDir) {
     forceScreenshot,
     deviceScaleFactor,
     ffmpegVersion,
+    engineConfig: cfg,
     effectiveChunkSize,
     chunkCount,
     runtimeEnv
@@ -101213,7 +101286,7 @@ var init_plan = __esm({
 // ../producer/src/services/distributed/renderChunk.ts
 import { randomBytes as randomBytes2 } from "crypto";
 import { existsSync as existsSync51, mkdirSync as mkdirSync30, readFileSync as readFileSync38, readdirSync as readdirSync20, rmSync as rmSync14, writeFileSync as writeFileSync23 } from "fs";
-import { extname as extname9, join as join61 } from "path";
+import { extname as extname10, join as join61 } from "path";
 function rebuildExtractedFramesFromPlanDir(planDir, videos) {
   const result = [];
   for (const v2 of videos) {
@@ -101223,7 +101296,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos) {
         `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v2.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
       );
     }
-    const ext = (extname9(v2.framePattern) || ".jpg").toLowerCase();
+    const ext = (extname10(v2.framePattern) || ".jpg").toLowerCase();
     const frames = readdirSync20(outputDir).filter((name) => name.toLowerCase().endsWith(ext)).sort();
     const framePaths = /* @__PURE__ */ new Map();
     for (let i2 = 0; i2 < frames.length; i2++) {
@@ -101264,6 +101337,10 @@ function resolvePresetForLockedEncoder(basePreset, lockedEncoder) {
   }
   return basePreset;
 }
+function resolveLockedVp9CpuUsed(lockedEncoder) {
+  if (lockedEncoder.encoder !== "libvpx-vp9-software") return void 0;
+  return lockedEncoder.vp9CpuUsed ?? LEGACY_DISTRIBUTED_VP9_CPU_USED;
+}
 async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   const start = Date.now();
   const log2 = defaultLogger;
@@ -101473,6 +101550,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         preset,
         effectiveQuality,
         effectiveBitrate,
+        engineConfig: {
+          ffmpegEncodeTimeout: cfg.ffmpegEncodeTimeout,
+          vp9CpuUsed: resolveLockedVp9CpuUsed(encoder) ?? cfg.vp9CpuUsed
+        },
         // Distributed chunks emit a single ffmpeg call per chunk; the
         // in-process per-chunk-within-chunk path would re-split our
         // already-chunked work.
@@ -101547,7 +101628,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     envRestore.restore();
   }
 }
-var FFMPEG_VERSION_MISMATCH, PLAN_HASH_MISMATCH, MISSING_PLAN_ARTIFACT, CHUNK_INDEX_OUT_OF_RANGE, MISSING_RUNTIME_ENV_SNAPSHOT, RenderChunkValidationError;
+var FFMPEG_VERSION_MISMATCH, PLAN_HASH_MISMATCH, MISSING_PLAN_ARTIFACT, CHUNK_INDEX_OUT_OF_RANGE, MISSING_RUNTIME_ENV_SNAPSHOT, LEGACY_DISTRIBUTED_VP9_CPU_USED, RenderChunkValidationError;
 var init_renderChunk = __esm({
   "../producer/src/services/distributed/renderChunk.ts"() {
     "use strict";
@@ -101567,6 +101648,7 @@ var init_renderChunk = __esm({
     MISSING_PLAN_ARTIFACT = "MISSING_PLAN_ARTIFACT";
     CHUNK_INDEX_OUT_OF_RANGE = "CHUNK_INDEX_OUT_OF_RANGE";
     MISSING_RUNTIME_ENV_SNAPSHOT = "MISSING_RUNTIME_ENV_SNAPSHOT";
+    LEGACY_DISTRIBUTED_VP9_CPU_USED = 2;
     RenderChunkValidationError = class extends Error {
       code;
       constructor(code, message) {
@@ -101580,41 +101662,89 @@ var init_renderChunk = __esm({
 
 // ../producer/src/services/render/audioPadTrim.ts
 import { spawn as spawn11 } from "child_process";
-function buildPadTrimAudioArgs(audioPath, outputPath, sourceDurationSeconds, targetDurationSeconds) {
+import { rmSync as rmSync15 } from "fs";
+import { pathToFileURL as pathToFileURL2 } from "url";
+function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, targetDurationSeconds, audioInfo = {}) {
   const delta = targetDurationSeconds - sourceDurationSeconds;
   const targetSec = formatSeconds(targetDurationSeconds);
   if (Math.abs(delta) < AUDIO_DURATION_TOLERANCE_SECONDS) {
     return {
       operation: "copy",
-      args: ["-i", audioPath, "-c:a", "copy", "-y", outputPath]
+      steps: [{ kind: "copy", args: ["-i", audioPath, "-c:a", "copy", "-y", outputPath] }],
+      cleanupPaths: []
     };
   }
   if (delta > 0) {
     const padDur = formatSeconds(delta);
+    const silencePath = `${outputPath}.pad-silence.aac`;
     return {
       operation: "pad",
-      args: [
-        "-i",
-        audioPath,
-        "-af",
-        `apad=pad_dur=${padDur}`,
-        "-c:a",
-        "aac",
-        "-b:a",
-        "192k",
-        "-y",
-        outputPath
-      ]
+      steps: [
+        {
+          kind: "pad-silence",
+          args: [
+            "-f",
+            "lavfi",
+            "-i",
+            `anullsrc=channel_layout=${channelLayoutForChannels(audioInfo.channels)}:sample_rate=${sampleRateForFilter(audioInfo.sampleRate)}`,
+            "-t",
+            padDur,
+            "-c:a",
+            "aac",
+            "-b:a",
+            "192k",
+            "-y",
+            silencePath
+          ]
+        },
+        {
+          kind: "pad-concat",
+          args: [
+            "-f",
+            "concat",
+            "-safe",
+            "0",
+            "-protocol_whitelist",
+            "file,pipe,crypto,data",
+            "-i",
+            "pipe:0",
+            "-c:a",
+            "copy",
+            "-y",
+            outputPath
+          ],
+          stdin: `${concatFileLine(audioPath)}
+${concatFileLine(silencePath)}
+`
+        }
+      ],
+      cleanupPaths: [silencePath]
     };
   }
   return {
     operation: "trim",
-    args: ["-i", audioPath, "-t", targetSec, "-c:a", "copy", "-y", outputPath]
+    steps: [
+      { kind: "trim", args: ["-i", audioPath, "-t", targetSec, "-c:a", "copy", "-y", outputPath] }
+    ],
+    cleanupPaths: []
   };
 }
 function formatSeconds(sec) {
   return sec.toFixed(6);
 }
+function sampleRateForFilter(sampleRate) {
+  return sampleRate !== void 0 && Number.isFinite(sampleRate) && sampleRate > 0 ? Math.round(sampleRate) : 48e3;
+}
+function channelLayoutForChannels(channels) {
+  if (channels === 1) return "mono";
+  if (channels === 6) return "5.1";
+  if (channels === 8) return "7.1";
+  return "stereo";
+}
+function concatFileLine(path2) {
+  const normalized = pathToFileURL2(path2).href;
+  return `file '${normalized.replace(/'/g, "'\\''")}'`;
+}
 async function padOrTrimAudioToVideoFrameCount(input2) {
   const probeVideo2 = input2.probeVideoFrameInfo ?? defaultProbeVideoFrameInfo;
   const probeAudio = input2.probeAudioInfo ?? defaultProbeAudioInfo;
@@ -101650,29 +101780,45 @@ async function padOrTrimAudioToVideoFrameCount(input2) {
     );
   }
   const targetDurationSeconds = videoInfo.frameCount * videoInfo.fpsDen / videoInfo.fpsNum;
-  const { args, operation } = buildPadTrimAudioArgs(
+  const plan2 = buildPadTrimAudioPlan(
     input2.audioPath,
     input2.outputPath,
     audioInfo.durationSeconds,
-    targetDurationSeconds
+    targetDurationSeconds,
+    audioInfo
   );
-  const ffmpegResult = await runner(args);
-  if (!ffmpegResult.success) {
+  try {
+    for (const step of plan2.steps) {
+      const ffmpegResult = await runner(step.args, { stdin: step.stdin });
+      if (!ffmpegResult.success) {
+        return {
+          success: false,
+          outputPath: input2.outputPath,
+          targetDurationSeconds,
+          sourceDurationSeconds: audioInfo.durationSeconds,
+          operation: plan2.operation,
+          error: ffmpegResult.error
+        };
+      }
+    }
+  } catch (err) {
     return {
       success: false,
       outputPath: input2.outputPath,
       targetDurationSeconds,
       sourceDurationSeconds: audioInfo.durationSeconds,
-      operation,
-      error: ffmpegResult.error
+      operation: plan2.operation,
+      error: `audioPadTrim: failed to materialize ${plan2.operation}: ${err instanceof Error ? err.message : String(err)}`
     };
+  } finally {
+    for (const path2 of plan2.cleanupPaths) rmSync15(path2, { force: true });
   }
   return {
     success: true,
     outputPath: input2.outputPath,
     targetDurationSeconds,
     sourceDurationSeconds: audioInfo.durationSeconds,
-    operation
+    operation: plan2.operation
   };
 }
 function failResult(outputPath, target, source, error) {
@@ -101733,9 +101879,15 @@ function parseFrameRate2(rate) {
 }
 async function defaultProbeAudioInfo(audioPath) {
   const metadata = await extractAudioMetadata(audioPath);
-  return { durationSeconds: metadata.durationSeconds };
+  return {
+    durationSeconds: metadata.durationSeconds,
+    sampleRate: metadata.sampleRate,
+    channels: metadata.channels,
+    audioCodec: metadata.audioCodec
+  };
 }
-async function defaultRunFfmpeg(args) {
+async function defaultRunFfmpeg(args, options) {
+  if (options?.stdin !== void 0) return runFfmpegWithStdin(args, options.stdin);
   const result = await runFfmpeg(args);
   if (result.success) return { success: true };
   return {
@@ -101743,6 +101895,32 @@ async function defaultRunFfmpeg(args) {
     error: `[audioPadTrim] ${formatFfmpegError(result.exitCode, result.stderr)}`
   };
 }
+async function runFfmpegWithStdin(args, stdin) {
+  return new Promise((resolve58) => {
+    const proc = spawn11(getFfmpegBinary(), args);
+    let stderr = "";
+    proc.stderr.on("data", (data2) => {
+      stderr += data2.toString();
+    });
+    proc.on("error", (err) => {
+      resolve58({
+        success: false,
+        error: `[audioPadTrim] ${err instanceof Error ? err.message : String(err)}`
+      });
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve58({ success: true });
+        return;
+      }
+      resolve58({
+        success: false,
+        error: `[audioPadTrim] ${formatFfmpegError(code, stderr)}`
+      });
+    });
+    proc.stdin.end(stdin);
+  });
+}
 function runFfprobeJson(args) {
   return new Promise((resolve58, reject) => {
     const proc = spawn11(getFfprobeBinary(), args);
@@ -101790,7 +101968,7 @@ import {
   mkdirSync as mkdirSync31,
   readFileSync as readFileSync39,
   readdirSync as readdirSync21,
-  rmSync as rmSync15,
+  rmSync as rmSync16,
   statSync as statSync18,
   writeFileSync as writeFileSync24
 } from "fs";
@@ -101827,7 +102005,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
     mkdirSync31(dirname21(outputPath), { recursive: true });
   }
   const workDir = `${outputPath}.assemble-work`;
-  if (existsSync52(workDir)) rmSync15(workDir, { recursive: true, force: true });
+  if (existsSync52(workDir)) rmSync16(workDir, { recursive: true, force: true });
   mkdirSync31(workDir, { recursive: true });
   try {
     const concatOutputPath = join62(workDir, `concat.${plan2.dimensions.format}`);
@@ -101943,7 +102121,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
         audioForMux,
         muxOutputPath,
         abortSignal,
-        void 0,
+        { audioCodec: "aac" },
         { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen }
       );
       if (!muxResult.success) {
@@ -101965,7 +102143,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
     }
   } finally {
     try {
-      rmSync15(workDir, { recursive: true, force: true });
+      rmSync16(workDir, { recursive: true, force: true });
     } catch (err) {
       log2.warn("[assemble] failed to remove work dir", {
         workDir,
@@ -101982,7 +102160,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync52(outputPath)) rmSync15(outputPath, { recursive: true, force: true });
+  if (existsSync52(outputPath)) rmSync16(outputPath, { recursive: true, force: true });
   mkdirSync31(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -105915,6 +106093,7 @@ function buildDockerRunArgs(input2) {
     ...options.gifLoop != null ? ["--gif-loop", String(options.gifLoop)] : [],
     ...options.workers != null ? ["--workers", String(options.workers)] : [],
     ...options.crf != null ? ["--crf", String(options.crf)] : [],
+    ...options.vp9CpuUsed != null ? ["--vp9-cpu-used", String(options.vp9CpuUsed)] : [],
     ...options.videoBitrate ? ["--video-bitrate", options.videoBitrate] : [],
     ...options.videoFrameFormat && options.videoFrameFormat !== "auto" ? ["--video-frame-format", options.videoFrameFormat] : [],
     ...options.quiet ? ["--quiet"] : [],
@@ -106503,7 +106682,7 @@ __export(render_exports, {
   renderLocal: () => renderLocal,
   resolveBrowserGpuForCli: () => resolveBrowserGpuForCli
 });
-import { mkdirSync as mkdirSync35, readdirSync as readdirSync25, readFileSync as readFileSync48, statSync as statSync21, writeFileSync as writeFileSync28, rmSync as rmSync16 } from "fs";
+import { mkdirSync as mkdirSync35, readdirSync as readdirSync25, readFileSync as readFileSync48, statSync as statSync21, writeFileSync as writeFileSync28, rmSync as rmSync17 } from "fs";
 import { cpus as cpus4, freemem as freemem5, tmpdir as tmpdir5 } from "os";
 import { resolve as resolve42, dirname as dirname27, join as join70, basename as basename13 } from "path";
 import { execFileSync as execFileSync8, spawn as spawn14 } from "child_process";
@@ -106595,7 +106774,7 @@ function ensureDockerImage(version2, platform10, quiet) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to build Docker image: ${message}`);
   } finally {
-    rmSync16(tmpDir, { recursive: true, force: true });
+    rmSync17(tmpDir, { recursive: true, force: true });
   }
   if (!quiet) console.log(c.dim(`  Docker image: ${tag} (built)`));
   return tag;
@@ -106657,6 +106836,7 @@ async function renderDocker(projectDir, outputPath, options) {
       browserGpu: options.browserGpuMode === "hardware",
       hdrMode: options.hdrMode,
       crf: options.crf,
+      vp9CpuUsed: options.vp9CpuUsed,
       videoBitrate: options.videoBitrate,
       videoFrameFormat: options.videoFrameFormat,
       quiet: options.quiet,
@@ -106745,7 +106925,8 @@ async function renderLocal(projectDir, outputPath, options) {
       browserGpuMode: options.browserGpuMode ?? "software",
       ...options.pageNavigationTimeoutMs != null ? { pageNavigationTimeout: options.pageNavigationTimeoutMs } : {},
       ...options.protocolTimeout != null && { protocolTimeout: options.protocolTimeout },
-      ...options.playerReadyTimeout != null && { playerReadyTimeout: options.playerReadyTimeout }
+      ...options.playerReadyTimeout != null && { playerReadyTimeout: options.playerReadyTimeout },
+      ...options.vp9CpuUsed != null ? { vp9CpuUsed: options.vp9CpuUsed } : {}
     }),
     hdrMode: options.hdrMode,
     crf: options.crf,
@@ -107116,6 +107297,10 @@ var init_render2 = __esm({
           type: "string",
           description: "Target video bitrate such as 10M. Mutually exclusive with --crf."
         },
+        "vp9-cpu-used": {
+          type: "string",
+          description: "libvpx-vp9 -cpu-used value for WebM encodes (-8 to 8). Higher is faster with a larger quality/size tradeoff. Env: PRODUCER_VP9_CPU_USED."
+        },
         gpu: { type: "boolean", description: "Use GPU encoding", default: false },
         "browser-gpu": {
           type: "boolean",
@@ -107380,6 +107565,19 @@ var init_render2 = __esm({
           }
           crf = parsed;
         }
+        let vp9CpuUsed;
+        if (args["vp9-cpu-used"] != null) {
+          const raw = args["vp9-cpu-used"];
+          const parsed = Number(raw);
+          if (!Number.isInteger(parsed) || parsed < MIN_VP9_CPU_USED || parsed > MAX_VP9_CPU_USED) {
+            errorBox(
+              "Invalid vp9-cpu-used",
+              `Got "${raw}". Must be an integer between ${MIN_VP9_CPU_USED} and ${MAX_VP9_CPU_USED}.`
+            );
+            process.exit(1);
+          }
+          vp9CpuUsed = parsed;
+        }
         if (args["video-bitrate"] != null && !videoBitrate) {
           errorBox(
             "Invalid video-bitrate",
@@ -107502,6 +107700,7 @@ var init_render2 = __esm({
             browserGpuMode,
             hdrMode,
             crf,
+            vp9CpuUsed,
             videoBitrate,
             quiet: batchQuiet,
             browserPath,
@@ -107549,6 +107748,7 @@ var init_render2 = __esm({
             browserGpuMode,
             hdrMode: args.sdr ? "force-sdr" : args.hdr ? "force-hdr" : "auto",
             crf,
+            vp9CpuUsed,
             videoBitrate,
             videoFrameFormat,
             quiet,
@@ -107572,6 +107772,7 @@ var init_render2 = __esm({
             browserGpuMode,
             hdrMode: args.sdr ? "force-sdr" : args.hdr ? "force-hdr" : "auto",
             crf,
+            vp9CpuUsed,
             videoBitrate,
             videoFrameFormat,
             quiet,
@@ -109991,9 +110192,9 @@ __export(pipeline_exports, {
   waitForExit: () => waitForExit
 });
 import { spawn as spawn15 } from "child_process";
-import { extname as extname10 } from "path";
+import { extname as extname11 } from "path";
 function inferOutputFormat(outputPath) {
-  const ext = extname10(outputPath).toLowerCase();
+  const ext = extname11(outputPath).toLowerCase();
   if (ext === ".webm") return "webm";
   if (ext === ".mov") return "mov";
   if (ext === ".png") return "png";
@@ -110002,7 +110203,7 @@ function inferOutputFormat(outputPath) {
   );
 }
 function inferInputKind(inputPath) {
-  const ext = extname10(inputPath).toLowerCase();
+  const ext = extname11(inputPath).toLowerCase();
   if (VIDEO_EXTENSIONS2.has(ext)) return "video";
   if (IMAGE_EXTENSIONS.has(ext)) return "image";
   throw new Error(
@@ -110047,6 +110248,8 @@ function buildEncoderArgs2(format, width, height, fps, outputPath, quality = DEF
       "good",
       "-row-mt",
       "1",
+      "-cpu-used",
+      String(DEFAULT_VP9_CPU_USED),
       "-auto-alt-ref",
       "0",
       "-pix_fmt",
@@ -110102,7 +110305,7 @@ function resolveRenderTargets(inputPath, outputPath, backgroundOutputPath) {
   const inputKind = inferInputKind(inputPath);
   if (inputKind === "image" && format !== "png") {
     throw new Error(
-      `Image input requires a .png output (got ${extname10(outputPath)}). Use a video input for .webm/.mov.`
+      `Image input requires a .png output (got ${extname11(outputPath)}). Use a video input for .webm/.mov.`
     );
   }
   if (inputKind === "video" && format === "png") {
@@ -110285,6 +110488,7 @@ var init_pipeline = __esm({
     "use strict";
     init_ffmpeg();
     init_inference();
+    init_src2();
     QUALITY_CRF = {
       fast: 30,
       balanced: 18,
@@ -110521,7 +110725,7 @@ __export(transcribe_exports2, {
   examples: () => examples18
 });
 import { existsSync as existsSync72, writeFileSync as writeFileSync30 } from "fs";
-import { resolve as resolve48, join as join78, extname as extname11, dirname as dirname32 } from "path";
+import { resolve as resolve48, join as join78, extname as extname12, dirname as dirname32 } from "path";
 async function importTranscript(inputPath, dir, json) {
   const { loadTranscript: loadTranscript2, patchCaptionHtml: patchCaptionHtml2 } = await Promise.resolve().then(() => (init_normalize(), normalize_exports));
   const { words, format } = loadTranscript2(inputPath);
@@ -110657,7 +110861,7 @@ var init_transcribe2 = __esm({
           process.exit(1);
         }
         const dir = resolve48(args.dir ?? dirname32(inputPath));
-        const ext = extname11(inputPath).toLowerCase();
+        const ext = extname12(inputPath).toLowerCase();
         const isImport = ext === ".json" || ext === ".srt" || ext === ".vtt";
         if (isImport) {
           return importTranscript(inputPath, dir, args.json);
@@ -110946,7 +111150,7 @@ __export(tts_exports, {
   examples: () => examples19
 });
 import { existsSync as existsSync75, readFileSync as readFileSync56 } from "fs";
-import { resolve as resolve49, extname as extname12 } from "path";
+import { resolve as resolve49, extname as extname13 } from "path";
 function listVoices(json) {
   const rows = BUNDLED_VOICES.map((v2) => ({ ...v2, defaultLang: inferLangFromVoiceId(v2.id) }));
   if (json) {
@@ -111055,7 +111259,7 @@ var init_tts = __esm({
         }
         let text;
         const maybeFile = resolve49(args.input);
-        if (existsSync75(maybeFile) && extname12(maybeFile).toLowerCase() === ".txt") {
+        if (existsSync75(maybeFile) && extname13(maybeFile).toLowerCase() === ".txt") {
           text = readFileSync56(maybeFile, "utf-8").trim();
           if (!text) {
             console.error(c.error("File is empty."));
@@ -112056,7 +112260,7 @@ __export(contactSheet_exports, {
 });
 import sharp from "sharp";
 import { readdirSync as readdirSync29, readFileSync as readFileSync59, writeFileSync as writeFileSync32, unlinkSync as unlinkSync8, existsSync as existsSync78 } from "fs";
-import { join as join83, extname as extname13, basename as basename16, dirname as dirname36 } from "path";
+import { join as join83, extname as extname14, basename as basename16, dirname as dirname36 } from "path";
 async function createContactSheet(imagePaths, outputPath, opts = {}) {
   const {
     cols = 3,
@@ -112089,7 +112293,7 @@ async function createContactSheet(imagePaths, outputPath, opts = {}) {
     overlays.push({ input: resized, left: x3, top: y + labelH });
     let labelText = `${i2 + 1}`;
     if (labelMode === "filename") {
-      labelText = `${i2 + 1}. ${basename16(files[i2]).replace(extname13(files[i2]), "")}`;
+      labelText = `${i2 + 1}. ${basename16(files[i2]).replace(extname14(files[i2]), "")}`;
     } else if (labelMode === "custom" && labels?.[i2]) {
       labelText = `${i2 + 1}. ${labels[i2]}`;
     }
@@ -112171,7 +112375,7 @@ async function createSnapshotContactSheet(snapshotsDir, outputPath) {
 async function createAssetContactSheet(assetsDir, outputPath) {
   if (!existsSync78(assetsDir)) return [];
   const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
-  const assetFiles = readdirSync29(assetsDir).filter((f3) => imageExts.has(extname13(f3).toLowerCase()) && !f3.includes("contact-sheet")).sort();
+  const assetFiles = readdirSync29(assetsDir).filter((f3) => imageExts.has(extname14(f3).toLowerCase()) && !f3.includes("contact-sheet")).sort();
   if (assetFiles.length === 0) return [];
   const paths = assetFiles.map((f3) => join83(assetsDir, f3));
   return createContactSheetPages(paths, outputPath, {
@@ -151984,7 +152188,7 @@ __export(snapshot_exports, {
   examples: () => examples25
 });
 import { spawn as spawn16 } from "child_process";
-import { existsSync as existsSync79, mkdtempSync as mkdtempSync5, readFileSync as readFileSync60, mkdirSync as mkdirSync40, rmSync as rmSync17, writeFileSync as writeFileSync33 } from "fs";
+import { existsSync as existsSync79, mkdtempSync as mkdtempSync5, readFileSync as readFileSync60, mkdirSync as mkdirSync40, rmSync as rmSync18, writeFileSync as writeFileSync33 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { resolve as resolve51, join as join84, relative as relative14, isAbsolute as isAbsolute12 } from "path";
 async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDecoder = false) {
@@ -152035,7 +152239,7 @@ async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDeco
     return readFileSync60(outPath);
   } finally {
     try {
-      rmSync17(tmp, { recursive: true, force: true });
+      rmSync18(tmp, { recursive: true, force: true });
     } catch {
     }
   }
@@ -152136,7 +152340,7 @@ async function captureSnapshots(projectDir, opts) {
         const { readdirSync: readdirSync35 } = await import("fs");
         for (const file of readdirSync35(snapshotDir)) {
           if (/\.(png|jpg|jpeg)$/i.test(file)) {
-            rmSync17(join84(snapshotDir, file), { force: true });
+            rmSync18(join84(snapshotDir, file), { force: true });
           }
         }
       } catch {
@@ -152428,7 +152632,7 @@ ${c.error("\u2717")} Snapshot failed: ${msg}`);
 
 // src/capture/assetDownloader.ts
 import { writeFileSync as writeFileSync34, mkdirSync as mkdirSync41 } from "fs";
-import { join as join85, extname as extname14 } from "path";
+import { join as join85, extname as extname15 } from "path";
 import { createHash as createHash12 } from "crypto";
 function svgContentHashSlug(svgSource, isLogo) {
   const hash2 = createHash12("sha1").update(svgSource).digest("hex").slice(0, 8);
@@ -152463,7 +152667,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
   for (const icon of faviconLinks || []) {
     if (!icon.href) continue;
     try {
-      const ext = extname14(new URL(icon.href).pathname) || ".ico";
+      const ext = extname15(new URL(icon.href).pathname) || ".ico";
       const name = `favicon${ext}`;
       const localPath = `assets/${name}`;
       const buffer = await fetchBuffer(icon.href);
@@ -152507,7 +152711,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
     const results = await Promise.allSettled(
       batch.map(async ({ url, isPoster, catalog }) => {
         const parsedUrl = new URL(url);
-        const pathExt = extname14(parsedUrl.pathname);
+        const pathExt = extname15(parsedUrl.pathname);
         const ext = pathExt && pathExt.length <= 5 ? pathExt : ".jpg";
         const buffer = await fetchBuffer(url);
         if (!buffer) return null;
@@ -152542,7 +152746,7 @@ async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks)
   }
   if (tokens.ogImage && !downloadedUrls.has(normalizeUrl(tokens.ogImage))) {
     try {
-      const ext = extname14(new URL(tokens.ogImage).pathname) || ".jpg";
+      const ext = extname15(new URL(tokens.ogImage).pathname) || ".jpg";
       const localPath = `assets/og-image${ext}`;
       const buffer = await fetchBuffer(tokens.ogImage);
       if (buffer && buffer.length > 5e3) {
@@ -154276,7 +154480,7 @@ var init_animationCataloger = __esm({
 
 // src/capture/mediaCapture.ts
 import { mkdirSync as mkdirSync43, writeFileSync as writeFileSync36, readdirSync as readdirSync31, readFileSync as readFileSync63, statSync as statSync25 } from "fs";
-import { join as join88, extname as extname15 } from "path";
+import { join as join88, extname as extname16 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
   const savedHashes = /* @__PURE__ */ new Set();
@@ -154415,7 +154619,7 @@ async function downloadVideoBody(srcUrl, filename, videosDir) {
   if (isPrivateUrl(srcUrl)) return null;
   let ext = "";
   try {
-    ext = extname15(new URL(srcUrl).pathname).toLowerCase();
+    ext = extname16(new URL(srcUrl).pathname).toLowerCase();
   } catch {
     return null;
   }
@@ -156359,7 +156563,7 @@ __export(state_exports, {
   stateFilePath: () => stateFilePath,
   writeStackOutputs: () => writeStackOutputs
 });
-import { existsSync as existsSync86, mkdirSync as mkdirSync46, readdirSync as readdirSync34, readFileSync as readFileSync66, rmSync as rmSync18, writeFileSync as writeFileSync41 } from "fs";
+import { existsSync as existsSync86, mkdirSync as mkdirSync46, readdirSync as readdirSync34, readFileSync as readFileSync66, rmSync as rmSync19, writeFileSync as writeFileSync41 } from "fs";
 import { dirname as dirname37, join as join94 } from "path";
 function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
   return join94(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
@@ -156381,7 +156585,7 @@ function readStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
 }
 function deleteStackOutputs(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
   const path2 = stateFilePath(stackName, cwd);
-  if (existsSync86(path2)) rmSync18(path2);
+  if (existsSync86(path2)) rmSync19(path2);
 }
 function listStackNames(cwd = process.cwd()) {
   const dir = join94(cwd, STATE_DIR_NAME);