hyperframes 0.8.8 → 0.8.9

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.8.8" : "0.0.0-dev";
+    VERSION = true ? "0.8.9" : "0.0.0-dev";
   }
 });
 
@@ -58829,17 +58829,17 @@ function isSafePath(base2, resolved2) {
   }
   const target = resolve4(resolved2);
   const trailing = [];
-  let probe = target;
+  let probe2 = target;
   for (; ; ) {
     let ancestorReal;
     try {
-      ancestorReal = realpathSync(probe);
+      ancestorReal = realpathSync(probe2);
     } catch {
-      const parent = dirname3(probe);
-      if (parent === probe)
+      const parent = dirname3(probe2);
+      if (parent === probe2)
         return false;
-      trailing.push(basename(probe));
-      probe = parent;
+      trailing.push(basename(probe2));
+      probe2 = parent;
       continue;
     }
     const targetReal = trailing.length ? join2(ancestorReal, ...[...trailing].reverse()) : ancestorReal;
@@ -63261,9 +63261,9 @@ function createRuntimeStartTimeResolver(params) {
     return typeof HTMLMediaElement !== "undefined" && el instanceof HTMLMediaElement;
   };
   const resolveDurationForElement = (element) => {
-    const cached2 = durationCache.get(element);
-    if (cached2 !== void 0)
-      return cached2;
+    const cached3 = durationCache.get(element);
+    if (cached3 !== void 0)
+      return cached3;
     let resolved2 = null;
     const durationAttr = parseDurationAttr(element) ?? (includeAuthoredTimingAttrs ? parseAuthoredDurationAttr(element) : null);
     if (durationAttr != null && durationAttr > 0) {
@@ -63321,9 +63321,9 @@ function createRuntimeStartTimeResolver(params) {
     return resolveStartForElementInternal(compositionRoot2, fallback);
   };
   const resolveStartForElementInternal = (element, fallback) => {
-    const cached2 = startCache.get(element);
-    if (cached2 !== void 0) {
-      return cached2 == null ? fallback : cached2;
+    const cached3 = startCache.get(element);
+    if (cached3 !== void 0) {
+      return cached3 == null ? fallback : cached3;
     }
     if (visiting.has(element)) {
       return fallback;
@@ -65570,16 +65570,16 @@ async function launchBrowser(fingerprint) {
       `[BrowserManager] Browser launched (${browserVersion}, ${captureMode}, gl=${gpuFlags.join(" ") || "default"}, headlessShell=${!!fingerprint.executablePath}, platform=${process.platform})`
     );
     if (captureMode === "beginframe") {
-      const probe = await probeBeginFrameSupport(browser).catch((error) => ({
+      const probe2 = await probeBeginFrameSupport(browser).catch((error) => ({
         supported: true,
         detail: `probe harness error ignored: ${error instanceof Error ? error.message : String(error)}`,
         durationMs: 0
       }));
-      if (!probe.supported) {
+      if (!probe2.supported) {
         await closeBrowserAfterFailedProbe(browser);
         browser = void 0;
         console.warn(
-          `[BrowserManager] HeadlessExperimental.beginFrame probe failed after ${probe.durationMs}ms: ${probe.detail}; falling back to screenshot mode.`
+          `[BrowserManager] HeadlessExperimental.beginFrame probe failed after ${probe2.durationMs}ms: ${probe2.detail}; falling back to screenshot mode.`
         );
         captureMode = "screenshot";
         browser = await ppt.launch({
@@ -65935,9 +65935,9 @@ async function beginFrameCapture(page, options, frameTimeTicks, interval) {
     buffer = Buffer.from(result.screenshotData, "base64");
     lastFrameCache.set(page, buffer);
   } else {
-    const cached2 = lastFrameCache.get(page);
-    if (cached2) {
-      buffer = cached2;
+    const cached3 = lastFrameCache.get(page);
+    if (cached3) {
+      buffer = cached3;
     } else {
       const fallback = await sendBeginFrame(client, {
         frameTimeTicks: frameTimeTicks + 1e-3,
@@ -67726,6 +67726,169 @@ var init_threeDProjection = __esm({
   }
 });
 
+// ../parsers/dist/ffBinaries.js
+import { execFileSync } from "child_process";
+import { accessSync, constants, existsSync as existsSync4 } from "fs";
+import { delimiter, join as join6, resolve as resolve5 } from "path";
+function candidateFileName(candidate) {
+  return candidate.split(/[\\/]/).at(-1)?.toLowerCase() ?? candidate.toLowerCase();
+}
+function chooseBestPathCandidate(name, candidates) {
+  const normalized2 = candidates.map((candidate) => candidate.trim()).filter(Boolean);
+  return normalized2.find((candidate) => candidateFileName(candidate) === `${name}.exe`) ?? normalized2.find((candidate) => candidateFileName(candidate) === name) ?? normalized2.find((candidate) => !candidateFileName(candidate).match(/\.(cmd|bat)$/i)) ?? normalized2[0];
+}
+function isExecutablePathCandidate(candidate) {
+  if (process.platform === "win32") return existsSync4(candidate);
+  try {
+    accessSync(candidate, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function scanPath(name) {
+  const pathValue = process.env.PATH;
+  const searchDirs = [
+    ...process.platform === "win32" ? [process.cwd()] : [],
+    ...pathValue ? pathValue.split(delimiter) : []
+  ].filter(Boolean);
+  if (searchDirs.length === 0) return void 0;
+  const extensions = process.platform === "win32" ? [
+    ".exe",
+    ...new Set(
+      (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean)
+    ),
+    ""
+  ] : [""];
+  const candidates = [];
+  for (const dir of new Set(searchDirs)) {
+    for (const ext of extensions) {
+      const candidate = join6(dir, `${name}${ext}`);
+      if (isExecutablePathCandidate(candidate)) candidates.push(candidate);
+    }
+  }
+  return chooseBestPathCandidate(name, candidates);
+}
+function findInCommonDirs(name) {
+  for (const dir of COMMON_BIN_DIRS) {
+    const candidate = `${dir}/${name}`;
+    if (existsSync4(candidate)) return candidate;
+  }
+  return void 0;
+}
+function findInProjectLocalBin(name) {
+  const extension2 = process.platform === "win32" ? ".exe" : "";
+  const candidate = resolve5(".hyperframes", "bin", `${name}${extension2}`);
+  return existsSync4(candidate) ? candidate : void 0;
+}
+function lookupOnSystem(name) {
+  if (pathLookupCache.has(name)) return pathLookupCache.get(name);
+  let found;
+  if (process.platform === "win32") {
+    found = scanPath(name);
+  } else {
+    try {
+      const output = execFileSync("which", [name], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      });
+      const candidate = chooseBestPathCandidate(name, output.split(/\r?\n/));
+      found = candidate && isExecutablePathCandidate(candidate) ? candidate : scanPath(name);
+    } catch {
+      found = scanPath(name);
+    }
+  }
+  found ??= findInProjectLocalBin(name);
+  found ??= findInCommonDirs(name);
+  const resolved2 = found ? resolve5(found) : void 0;
+  pathLookupCache.set(name, resolved2);
+  return resolved2;
+}
+function findFfBinary(name, options = {}) {
+  const configured = process.env[ENV_BY_NAME[name]]?.trim();
+  if (configured) {
+    if (options.configuredMustExist && !existsSync4(configured)) return void 0;
+    return resolve5(configured);
+  }
+  return lookupOnSystem(name);
+}
+var FFMPEG_PATH_ENV, FFPROBE_PATH_ENV, ENV_BY_NAME, pathLookupCache, COMMON_BIN_DIRS;
+var init_ffBinaries = __esm({
+  "../parsers/dist/ffBinaries.js"() {
+    "use strict";
+    FFMPEG_PATH_ENV = "HYPERFRAMES_FFMPEG_PATH";
+    FFPROBE_PATH_ENV = "HYPERFRAMES_FFPROBE_PATH";
+    ENV_BY_NAME = {
+      ffmpeg: FFMPEG_PATH_ENV,
+      ffprobe: FFPROBE_PATH_ENV
+    };
+    pathLookupCache = /* @__PURE__ */ new Map();
+    COMMON_BIN_DIRS = process.platform === "win32" ? [] : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/snap/bin"];
+  }
+});
+
+// ../engine/src/utils/ffmpegBinaries.ts
+import { existsSync as existsSync5 } from "fs";
+function getFfmpegBinary() {
+  return findFfBinary("ffmpeg") ?? "ffmpeg";
+}
+function getFfprobeBinary() {
+  return findFfBinary("ffprobe") ?? "ffprobe";
+}
+function assertConfiguredFfmpegBinariesExist() {
+  const ffmpegPath = process.env[FFMPEG_PATH_ENV]?.trim();
+  if (ffmpegPath && !existsSync5(ffmpegPath)) {
+    throw new Error(
+      `[FFmpeg] FFmpeg binary not found at ${FFMPEG_PATH_ENV}="${ffmpegPath}". Install FFmpeg or unset the override.${pathEncodingHint(ffmpegPath)}`
+    );
+  }
+  const ffprobePath = process.env[FFPROBE_PATH_ENV]?.trim();
+  if (ffprobePath && !existsSync5(ffprobePath)) {
+    throw new Error(
+      `[FFmpeg] FFprobe binary not found at ${FFPROBE_PATH_ENV}="${ffprobePath}". Install FFmpeg or unset the override.${pathEncodingHint(ffprobePath)}`
+    );
+  }
+}
+function pathEncodingHint(configuredPath) {
+  if (!configuredPath.includes("\uFFFD")) return "";
+  return " The path contains a Unicode replacement character, which usually means it was mangled while being copied or decoded.";
+}
+var init_ffmpegBinaries = __esm({
+  "../engine/src/utils/ffmpegBinaries.ts"() {
+    "use strict";
+    init_ffBinaries();
+  }
+});
+
+// ../engine/src/utils/psnrFilterAvailability.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+function isPsnrFilterAvailable() {
+  if (cached === null) cached = probe();
+  return cached;
+}
+async function probe() {
+  const execFileP = promisify(execFile);
+  try {
+    const { stdout: stdout2 } = await execFileP(getFfmpegBinary(), ["-hide_banner", "-filters"], {
+      maxBuffer: 4 * 1024 * 1024,
+      timeout: 5e3
+    });
+    return /(^|\s)psnr(\s|$)/m.test(stdout2);
+  } catch {
+    return false;
+  }
+}
+var cached;
+var init_psnrFilterAvailability = __esm({
+  "../engine/src/utils/psnrFilterAvailability.ts"() {
+    "use strict";
+    init_ffmpegBinaries();
+    cached = null;
+  }
+});
+
 // ../engine/src/services/captureWarning.ts
 function cloneCaptureWarning(warning) {
   return {
@@ -67897,8 +68060,8 @@ var init_captureFailure = __esm({
 });
 
 // ../engine/src/services/frameCapture.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
 function isDrawElementVerificationError(err) {
   let e3 = err;
   for (let depth = 0; depth < 5 && typeof e3 === "object" && e3 !== null; depth++) {
@@ -68219,6 +68382,15 @@ async function initDrawElementOrTransparentBackground(session, page, logInitPhas
       await routeToFallback();
       return;
     }
+    if (!forceDE && !await isPsnrFilterAvailable()) {
+      session.deGateReason = "ffmpeg_no_psnr_filter";
+      session.deFallbackTrigger = "ffmpeg_no_psnr_filter";
+      console.warn(
+        `[engine] fast capture: falling back to ${session.launchCaptureMode} capture \u2014 host ffmpeg is missing or was built without the \`psnr\` filter (libpostproc), so drawElement self-verification cannot run. Install an ffmpeg build that includes libpostproc (or set HYPERFRAMES_FFMPEG_PATH to one) to re-enable fast capture.`
+      );
+      await routeToFallback();
+      return;
+    }
     const mode = resolveDrawElementCaptureMode(session.isSwiftShader, transparent);
     if (mode === "screenshot") {
       session.deGateReason = "swiftshader";
@@ -68329,7 +68501,7 @@ async function completeDeferredDrawElementInit(session) {
   session.deInitDeferred = false;
 }
 async function createCaptureSession(serverUrl, outputDir, options, onBeforeCapture = null, config) {
-  if (!existsSync4(outputDir)) mkdirSync2(outputDir, { recursive: true });
+  if (!existsSync6(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const headlessShell = resolveHeadlessShellPath(config);
   const isLinux = process.platform === "linux";
   const forceScreenshot = config?.forceScreenshot ?? DEFAULT_CONFIG2.forceScreenshot;
@@ -69092,9 +69264,9 @@ async function initializeSession(session) {
 }
 async function captureFrameErrorDiagnostics(session, frameIndex, time, error) {
   try {
-    const diagnosticsDir = join6(session.outputDir, "diagnostics");
-    if (!existsSync4(diagnosticsDir)) mkdirSync2(diagnosticsDir, { recursive: true });
-    const base2 = join6(diagnosticsDir, `frame-error-${frameIndex}`);
+    const diagnosticsDir = join7(session.outputDir, "diagnostics");
+    if (!existsSync6(diagnosticsDir)) mkdirSync2(diagnosticsDir, { recursive: true });
+    const base2 = join7(diagnosticsDir, `frame-error-${frameIndex}`);
     await session.page.screenshot({ path: `${base2}.png`, type: "png", fullPage: true });
     const html = await session.page.content();
     writeFileSync2(`${base2}.html`, html, "utf-8");
@@ -69593,7 +69765,7 @@ async function captureFrame(session, frameIndex, time) {
 }
 function writeCapturedFrame(session, fileIndex, buffer) {
   const ext = session.options.format === "png" ? "png" : "jpg";
-  const framePath = join6(session.outputDir, `frame_${String(fileIndex).padStart(6, "0")}.${ext}`);
+  const framePath = join7(session.outputDir, `frame_${String(fileIndex).padStart(6, "0")}.${ext}`);
   writeFileSync2(framePath, buffer);
   return framePath;
 }
@@ -69800,7 +69972,7 @@ async function closeCaptureSession(session) {
   session.isInitialized = false;
 }
 function prepareCaptureSessionForReuse(session, outputDir, onBeforeCapture) {
-  if (!existsSync4(outputDir)) {
+  if (!existsSync6(outputDir)) {
     mkdirSync2(outputDir, { recursive: true });
   }
   session.outputDir = outputDir;
@@ -69935,6 +70107,7 @@ var init_frameCapture = __esm({
     init_screenshotService();
     init_drawElementService();
     init_threeDProjection();
+    init_psnrFilterAvailability();
     init_config2();
     init_captureWarning();
     init_mediaRenderIdBridge();
@@ -69993,141 +70166,6 @@ var init_frameCapture = __esm({
   }
 });
 
-// ../parsers/dist/ffBinaries.js
-import { execFileSync } from "child_process";
-import { accessSync, constants, existsSync as existsSync5 } from "fs";
-import { delimiter, join as join7, resolve as resolve5 } from "path";
-function candidateFileName(candidate) {
-  return candidate.split(/[\\/]/).at(-1)?.toLowerCase() ?? candidate.toLowerCase();
-}
-function chooseBestPathCandidate(name, candidates) {
-  const normalized2 = candidates.map((candidate) => candidate.trim()).filter(Boolean);
-  return normalized2.find((candidate) => candidateFileName(candidate) === `${name}.exe`) ?? normalized2.find((candidate) => candidateFileName(candidate) === name) ?? normalized2.find((candidate) => !candidateFileName(candidate).match(/\.(cmd|bat)$/i)) ?? normalized2[0];
-}
-function isExecutablePathCandidate(candidate) {
-  if (process.platform === "win32") return existsSync5(candidate);
-  try {
-    accessSync(candidate, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function scanPath(name) {
-  const pathValue = process.env.PATH;
-  const searchDirs = [
-    ...process.platform === "win32" ? [process.cwd()] : [],
-    ...pathValue ? pathValue.split(delimiter) : []
-  ].filter(Boolean);
-  if (searchDirs.length === 0) return void 0;
-  const extensions = process.platform === "win32" ? [
-    ".exe",
-    ...new Set(
-      (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean)
-    ),
-    ""
-  ] : [""];
-  const candidates = [];
-  for (const dir of new Set(searchDirs)) {
-    for (const ext of extensions) {
-      const candidate = join7(dir, `${name}${ext}`);
-      if (isExecutablePathCandidate(candidate)) candidates.push(candidate);
-    }
-  }
-  return chooseBestPathCandidate(name, candidates);
-}
-function findInCommonDirs(name) {
-  for (const dir of COMMON_BIN_DIRS) {
-    const candidate = `${dir}/${name}`;
-    if (existsSync5(candidate)) return candidate;
-  }
-  return void 0;
-}
-function findInProjectLocalBin(name) {
-  const extension2 = process.platform === "win32" ? ".exe" : "";
-  const candidate = resolve5(".hyperframes", "bin", `${name}${extension2}`);
-  return existsSync5(candidate) ? candidate : void 0;
-}
-function lookupOnSystem(name) {
-  if (pathLookupCache.has(name)) return pathLookupCache.get(name);
-  let found;
-  if (process.platform === "win32") {
-    found = scanPath(name);
-  } else {
-    try {
-      const output = execFileSync("which", [name], {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: 5e3
-      });
-      const candidate = chooseBestPathCandidate(name, output.split(/\r?\n/));
-      found = candidate && isExecutablePathCandidate(candidate) ? candidate : scanPath(name);
-    } catch {
-      found = scanPath(name);
-    }
-  }
-  found ??= findInProjectLocalBin(name);
-  found ??= findInCommonDirs(name);
-  const resolved2 = found ? resolve5(found) : void 0;
-  pathLookupCache.set(name, resolved2);
-  return resolved2;
-}
-function findFfBinary(name, options = {}) {
-  const configured = process.env[ENV_BY_NAME[name]]?.trim();
-  if (configured) {
-    if (options.configuredMustExist && !existsSync5(configured)) return void 0;
-    return resolve5(configured);
-  }
-  return lookupOnSystem(name);
-}
-var FFMPEG_PATH_ENV, FFPROBE_PATH_ENV, ENV_BY_NAME, pathLookupCache, COMMON_BIN_DIRS;
-var init_ffBinaries = __esm({
-  "../parsers/dist/ffBinaries.js"() {
-    "use strict";
-    FFMPEG_PATH_ENV = "HYPERFRAMES_FFMPEG_PATH";
-    FFPROBE_PATH_ENV = "HYPERFRAMES_FFPROBE_PATH";
-    ENV_BY_NAME = {
-      ffmpeg: FFMPEG_PATH_ENV,
-      ffprobe: FFPROBE_PATH_ENV
-    };
-    pathLookupCache = /* @__PURE__ */ new Map();
-    COMMON_BIN_DIRS = process.platform === "win32" ? [] : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/snap/bin"];
-  }
-});
-
-// ../engine/src/utils/ffmpegBinaries.ts
-import { existsSync as existsSync6 } from "fs";
-function getFfmpegBinary() {
-  return findFfBinary("ffmpeg") ?? "ffmpeg";
-}
-function getFfprobeBinary() {
-  return findFfBinary("ffprobe") ?? "ffprobe";
-}
-function assertConfiguredFfmpegBinariesExist() {
-  const ffmpegPath = process.env[FFMPEG_PATH_ENV]?.trim();
-  if (ffmpegPath && !existsSync6(ffmpegPath)) {
-    throw new Error(
-      `[FFmpeg] FFmpeg binary not found at ${FFMPEG_PATH_ENV}="${ffmpegPath}". Install FFmpeg or unset the override.${pathEncodingHint(ffmpegPath)}`
-    );
-  }
-  const ffprobePath = process.env[FFPROBE_PATH_ENV]?.trim();
-  if (ffprobePath && !existsSync6(ffprobePath)) {
-    throw new Error(
-      `[FFmpeg] FFprobe binary not found at ${FFPROBE_PATH_ENV}="${ffprobePath}". Install FFmpeg or unset the override.${pathEncodingHint(ffprobePath)}`
-    );
-  }
-}
-function pathEncodingHint(configuredPath) {
-  if (!configuredPath.includes("\uFFFD")) return "";
-  return " The path contains a Unicode replacement character, which usually means it was mangled while being copied or decoded.";
-}
-var init_ffmpegBinaries = __esm({
-  "../engine/src/utils/ffmpegBinaries.ts"() {
-    "use strict";
-    init_ffBinaries();
-  }
-});
-
 // ../engine/src/utils/managedChildProcess.ts
 var DEFAULT_TERMINATION_GRACE_MS, DEFAULT_STDERR_MAX_BYTES, ManagedChildProcess;
 var init_managedChildProcess = __esm({
@@ -70754,13 +70792,13 @@ async function probeMediaOutput(filePath, signal) {
     mediaProbeOutputSignalCaches.set(signal, cache2);
   }
   const identity = mediaFileIdentity(filePath);
-  const cached2 = cache2.get(filePath);
-  if (identity !== null && cached2?.identity === identity) {
+  const cached3 = cache2.get(filePath);
+  if (identity !== null && cached3?.identity === identity) {
     if (!signal) {
       cache2.delete(filePath);
-      cache2.set(filePath, cached2);
+      cache2.set(filePath, cached3);
     }
-    return cached2.promise;
+    return cached3.promise;
   }
   const promise = runFfprobe(
     filePath,
@@ -70943,8 +70981,8 @@ function parseFrameRate(frameRateStr) {
   return rounded > 0 ? rounded : 0.01;
 }
 async function extractMediaMetadata(filePath) {
-  const cached2 = videoMetadataCache.get(filePath);
-  if (cached2) return cached2;
+  const cached3 = videoMetadataCache.get(filePath);
+  if (cached3) return cached3;
   const probePromise = (async () => {
     let stillImageMetaMemo;
     const stillImage = () => {
@@ -71030,8 +71068,8 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
     probeCache = finalVideoFrameTimestampSignalCaches.get(signal) ?? /* @__PURE__ */ new Map();
     finalVideoFrameTimestampSignalCaches.set(signal, probeCache);
   }
-  const cached2 = probeCache.get(cacheKey);
-  if (cached2) return cached2;
+  const cached3 = probeCache.get(cacheKey);
+  if (cached3) return cached3;
   const probePromise = (async () => {
     if (!(videoDurationSeconds > 0) || !Number.isFinite(videoDurationSeconds)) {
       throw new Error(
@@ -71041,7 +71079,7 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
     const streamEnd = videoStreamStartSeconds + videoDurationSeconds;
     const intervalStart = Math.max(videoStreamStartSeconds, streamEnd - 1);
     const parseFinalTimestamp = (stdout2) => stdout2.split("\n").map((line2) => line2.trim().split(",")[0]?.trim() ?? "").filter((value) => value.length > 0).map((value) => Number(value)).filter((timestamp2) => Number.isFinite(timestamp2)).at(-1);
-    const probe = async (readInterval) => {
+    const probe2 = async (readInterval) => {
       const args = [
         "-select_streams",
         "v:0",
@@ -71057,7 +71095,7 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
       });
       return parseFinalTimestamp(stdout2);
     };
-    const timestamp = await probe(`${intervalStart}%${streamEnd}`) ?? await probe(
+    const timestamp = await probe2(`${intervalStart}%${streamEnd}`) ?? await probe2(
       /* full scan */
     );
     if (timestamp === void 0) {
@@ -71074,8 +71112,8 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
   return probePromise;
 }
 async function extractAudioMetadata(filePath, options) {
-  const cached2 = options?.signal ? void 0 : audioMetadataCache.get(filePath);
-  if (cached2) return cached2;
+  const cached3 = options?.signal ? void 0 : audioMetadataCache.get(filePath);
+  if (cached3) return cached3;
   const probePromise = (async () => {
     const output = await probeMediaOutput(filePath, options?.signal);
     const audioStream = output.streams.find((s2) => s2.codec_type === "audio");
@@ -71128,8 +71166,8 @@ async function extractAudioMetadata(filePath, options) {
   return probePromise;
 }
 async function analyzeKeyframeIntervals(filePath) {
-  const cached2 = keyframeCache.get(filePath);
-  if (cached2) return cached2;
+  const cached3 = keyframeCache.get(filePath);
+  if (cached3) return cached3;
   const promise = analyzeKeyframeIntervalsUncached(filePath);
   keyframeCache.set(filePath, promise);
   promise.catch(() => {
@@ -72148,8 +72186,8 @@ function findReferenceTargetEl(doc, refId) {
   return doc.getElementById(refId) ?? doc.querySelector(`[data-composition-id="${refId}"]`);
 }
 function resolveReferencedStart(doc, el, startCache, visiting) {
-  const cached2 = startCache.get(el);
-  if (cached2 !== void 0) return cached2;
+  const cached3 = startCache.get(el);
+  if (cached3 !== void 0) return cached3;
   if (visiting.has(el)) return 0;
   visiting.add(el);
   try {
@@ -79632,7 +79670,7 @@ import postcss22 from "postcss";
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync22, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "fs";
 import { dirname as dirname7, extname as extname3, join as join22, relative as relative3, resolve as resolve8 } from "path";
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { existsSync as existsSync11 } from "fs";
 import { join as join10 } from "path";
 function parseHtmlStructure(source) {
@@ -80372,8 +80410,8 @@ function synthesizeWindowRaw(timelineVar, anim) {
   return `${timelineVar}.${anim.method}("${anim.targetSelector}", { ${entries2.join(", ")} }, ${pos})`;
 }
 async function cachedExtractGsapWindows(scriptContent) {
-  const cached2 = gsapWindowsCache.get(scriptContent);
-  if (cached2) return cached2;
+  const cached3 = gsapWindowsCache.get(scriptContent);
+  if (cached3) return cached3;
   const windows = await extractGsapWindows(scriptContent);
   gsapWindowsCache.set(scriptContent, windows);
   return windows;
@@ -81493,7 +81531,7 @@ function shouldBlockRender(strictErrors, strictAll, totalErrors, totalWarnings)
 }
 function execFileAsync(file, args) {
   return new Promise((resolvePromise, reject2) => {
-    execFile(file, args, { timeout: PROBE_TIMEOUT_MS }, (error, stdout2) => {
+    execFile2(file, args, { timeout: PROBE_TIMEOUT_MS }, (error, stdout2) => {
       if (error) reject2(error);
       else resolvePromise(stdout2.toString());
     });
@@ -88080,10 +88118,10 @@ function createFrameSourceCache(entryLimit, bytesLimit, frameSrcResolver) {
   async function get(framePath) {
     const servedSrc = frameSrcResolver?.(framePath);
     if (servedSrc) return servedSrc;
-    const cached2 = cache2.get(framePath);
-    if (cached2) {
-      remember(framePath, cached2);
-      return cached2;
+    const cached3 = cache2.get(framePath);
+    if (cached3) {
+      remember(framePath, cached3);
+      return cached3;
     }
     const existing = inFlight2.get(framePath);
     if (existing) {
@@ -89986,13 +90024,13 @@ var init_audioMixer = __esm({
 });
 
 // ../engine/src/utils/psnr.ts
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join15 } from "path";
-import { promisify } from "util";
+import { promisify as promisify2 } from "util";
 async function psnrDb(a, b2) {
-  const execFileP = promisify(execFile2);
+  const execFileP = promisify2(execFile3);
   const dir = await mkdtemp(join15(tmpdir3(), "hf-de-verify-"));
   try {
     const pa = join15(dir, "a.jpg");
@@ -90347,10 +90385,27 @@ function assertDiskSampleAboveFloor(db, verifyMinDb, idx, workerId) {
     `[Parallel] drawElement disk self-verify passed (worker ${workerId}, frame ${idx}, ${db === Infinity ? "inf" : db.toFixed(1)}dB)`
   );
 }
+function isFfmpegInfrastructureFailure(err) {
+  if (!err || typeof err !== "object") return false;
+  const record = err;
+  if (record.code === "ENOENT") return true;
+  const message = typeof record.message === "string" ? record.message : "";
+  const stderr = typeof record.stderr === "string" ? record.stderr : "";
+  const text2 = `${message}
+${stderr}`;
+  return /\bENOENT\b|No such filter|Unknown filter/i.test(text2);
+}
 async function psnrForDiskSample(framePath, truth, workerId, idx) {
   try {
     return await psnrDb(await readFile(framePath), truth);
   } catch (err) {
+    if (isFfmpegInfrastructureFailure(err)) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `[Parallel] drawElement disk self-verify aborted (worker ${workerId}, frame ${idx}): ffmpeg or the \`psnr\` filter is unavailable \u2014 ${detail}. The preflight in initDrawElementOrTransparentBackground normally catches this at bootstrap; if you hit this after a successful preflight, ffmpeg was replaced mid-render or HYPERFRAMES_FFMPEG_PATH now points at a different binary.`,
+        { cause: err }
+      );
+    }
     console.warn(
       `[Parallel] drawElement disk self-verify sample skipped (worker ${workerId}, frame ${idx}): ${err instanceof Error ? err.message : String(err)}`
     );
@@ -92792,12 +92847,12 @@ function bytesToMb(bytes) {
   return Math.trunc(bytes / (1024 * 1024));
 }
 function getSystemMeta() {
-  if (cached) return cached;
+  if (cached2) return cached2;
   const cpuInfo = cpus2();
   const firstCpu = cpuInfo[0] ?? null;
   const agent_runtime = detectAgentRuntime();
   const hints = agent_runtime === null ? detectAgentHints() : { agent_hint: null, term_program: null, agent_env_hints: null };
-  cached = {
+  cached2 = {
     os_release: release3(),
     cpu_count: cpuInfo.length,
     cpu_model: firstCpu?.model?.trim() ?? null,
@@ -92814,7 +92869,7 @@ function getSystemMeta() {
     term_program: hints.term_program,
     agent_env_hints: hints.agent_env_hints
   };
-  return cached;
+  return cached2;
 }
 function detectDocker() {
   try {
@@ -92911,14 +92966,14 @@ function getAvailableMemoryMb() {
   }
   return fallback;
 }
-var cached, CI_PROVIDERS;
+var cached2, CI_PROVIDERS;
 var init_system = __esm({
   "src/telemetry/system.ts"() {
     "use strict";
     init_src();
     init_agent_runtime();
     init_platform();
-    cached = null;
+    cached2 = null;
     CI_PROVIDERS = [
       { name: "github_actions", envVar: "GITHUB_ACTIONS", mode: "truthy" },
       { name: "gitlab_ci", envVar: "GITLAB_CI", mode: "truthy" },
@@ -92968,8 +93023,8 @@ function resolveCanary(name) {
     decisions.clear();
     decisionsTelemetryPosture = posture;
   }
-  const cached2 = decisions.get(name);
-  if (cached2) return cached2;
+  const cached3 = decisions.get(name);
+  if (cached3) return cached3;
   const decision = decideCanary(name);
   decisions.set(name, decision);
   return decision;
@@ -95946,28 +96001,28 @@ async function fetchJson(url) {
 }
 async function fetchRegistryManifest(baseUrl = DEFAULT_REGISTRY_URL, options) {
   const cacheFile = cachePath(baseUrl, "registry");
-  const cached2 = readCacheEntry(cacheFile);
-  if (!options?.skipCache && cached2 && isFresh(cached2)) return cached2.data;
+  const cached3 = readCacheEntry(cacheFile);
+  if (!options?.skipCache && cached3 && isFresh(cached3)) return cached3.data;
   try {
     const manifest = await fetchJson(`${baseUrl}/registry.json`);
     writeCache(cacheFile, manifest);
     return manifest;
   } catch {
-    return cached2?.data;
+    return cached3?.data;
   }
 }
 async function fetchItemManifest(name, type, baseUrl = DEFAULT_REGISTRY_URL) {
   const dir = ITEM_TYPE_DIRS[type];
   const cacheFile = cachePath(baseUrl, `${dir}__${name}`);
-  const cached2 = readCacheEntry(cacheFile);
-  if (cached2 && isFresh(cached2)) return cached2.data;
+  const cached3 = readCacheEntry(cacheFile);
+  if (cached3 && isFresh(cached3)) return cached3.data;
   const url = `${baseUrl}/${dir}/${name}/registry-item.json`;
   try {
     const item = await fetchJson(url);
     writeCache(cacheFile, item);
     return item;
   } catch (err) {
-    if (cached2) return cached2.data;
+    if (cached3) return cached3.data;
     throw err;
   }
 }
@@ -98244,7 +98299,7 @@ var init_updateCheck = __esm({
 });
 
 // src/utils/skillsManifest.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { createHash as createHash6 } from "crypto";
 import {
   existsSync as existsSync29,
@@ -98256,7 +98311,7 @@ import {
 } from "fs";
 import { homedir as homedir6 } from "os";
 import { isAbsolute as isAbsolute6, join as join27, relative as relative6, resolve as resolve13, sep as sep4 } from "path";
-import { promisify as promisify2 } from "util";
+import { promisify as promisify3 } from "util";
 function isCoreSkill(name) {
   return name === ENTRY_SKILL || name.startsWith("hyperframes-") || name === "media-use";
 }
@@ -98549,7 +98604,7 @@ var execFileAsync2, TEXT_EXT, DEFAULT_REPO_SLUG, MANIFEST_FILE, FETCH_TIMEOUT_MS
 var init_skillsManifest = __esm({
   "src/utils/skillsManifest.ts"() {
     "use strict";
-    execFileAsync2 = promisify2(execFile3);
+    execFileAsync2 = promisify3(execFile4);
     TEXT_EXT = /* @__PURE__ */ new Set([
       ".md",
       ".txt",
@@ -99668,29 +99723,29 @@ var init_lintFormat = __esm({
 // src/server/portUtils.ts
 import net from "net";
 import http from "http";
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify3 } from "util";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify4 } from "util";
 import { resolve as resolve14 } from "path";
 async function isPortAvailableOnHost(port, host) {
-  const probe = net.createServer();
-  probe.unref();
+  const probe2 = net.createServer();
+  probe2.unref();
   const bindError = await new Promise((settle) => {
     const handleError = (err) => settle(err);
-    probe.once("error", handleError);
-    probe.listen({ port, host }, () => {
-      probe.removeListener("error", handleError);
+    probe2.once("error", handleError);
+    probe2.listen({ port, host }, () => {
+      probe2.removeListener("error", handleError);
       settle(null);
     });
   });
   if (bindError !== null) {
     return bindError.code !== "EADDRINUSE";
   }
-  await new Promise((done) => probe.close(() => done()));
+  await new Promise((done) => probe2.close(() => done()));
   return true;
 }
-async function testPortOnAllHosts(port, probe = isPortAvailableOnHost) {
+async function testPortOnAllHosts(port, probe2 = isPortAvailableOnHost) {
   for (const host of PORT_PROBE_HOSTS) {
-    const available = await probe(port, host);
+    const available = await probe2(port, host);
     if (!available) return false;
   }
   return true;
@@ -99927,7 +99982,7 @@ var execFileAsync3, MAX_PORT_SCAN, PROBE_TIMEOUT_MS2, PROBE_MAX_BYTES, PORT_PROB
 var init_portUtils = __esm({
   "src/server/portUtils.ts"() {
     "use strict";
-    execFileAsync3 = promisify3(execFile4);
+    execFileAsync3 = promisify4(execFile5);
     MAX_PORT_SCAN = 100;
     PROBE_TIMEOUT_MS2 = 300;
     PROBE_MAX_BYTES = 4096;
@@ -101614,7 +101669,7 @@ var init_chunk_W2SBTCO2 = __esm({
 // ../studio-server/dist/chunk-6H3V3WGJ.js
 import { existsSync as existsSync34, statSync as statSync10 } from "fs";
 import { relative as relative8, resolve as resolve18, sep as sep5 } from "path";
-import { execFile as execFile5 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import { extname as extname7 } from "path";
 function lower(value) {
   return value?.toLowerCase() ?? "";
@@ -101752,10 +101807,10 @@ async function probeAssetCodecCached(filePath, cache2, runner) {
   } catch {
     return null;
   }
-  const cached2 = cache2.get(filePath);
-  if (cached2 && cached2.mtimeMs === stat3.mtimeMs && cached2.size === stat3.size) {
-    rememberProbeResult(cache2, filePath, cached2);
-    return cached2.facts;
+  const cached3 = cache2.get(filePath);
+  if (cached3 && cached3.mtimeMs === stat3.mtimeMs && cached3.size === stat3.size) {
+    rememberProbeResult(cache2, filePath, cached3);
+    return cached3.facts;
   }
   const facts = await probeAssetCodec(filePath, runner);
   rememberProbeResult(cache2, filePath, { mtimeMs: stat3.mtimeMs, size: stat3.size, facts });
@@ -101822,7 +101877,7 @@ var init_chunk_6H3V3WGJ = __esm({
     init_assetResolution();
     init_ffBinaries();
     execFileRunner = (command2, args, options) => new Promise((resolvePromise) => {
-      execFile5(
+      execFile6(
         command2,
         args,
         { timeout: options?.timeout, maxBuffer: options?.maxBuffer },
@@ -106262,9 +106317,9 @@ function locateSystemFont(family) {
   const normalized2 = normalizeName(family);
   if (!normalized2)
     return null;
-  const cached2 = cache.get(normalized2);
-  if (cached2 !== void 0)
-    return cached2;
+  const cached3 = cache.get(normalized2);
+  if (cached3 !== void 0)
+    return cached3;
   let result = null;
   result = locateViaSystemProfiler(normalized2);
   if (!result) {
@@ -109280,8 +109335,8 @@ function createProjectSignature(projectDir) {
   collectProjectSignatureManifestFiles(normalizedProjectDir, files);
   files.sort((a, b2) => a.file.localeCompare(b2.file));
   const fingerprint = createProjectFingerprint(normalizedProjectDir, files);
-  const cached2 = projectSignatureCache.get(normalizedProjectDir);
-  if (cached2?.fingerprint === fingerprint) return cached2.signature;
+  const cached3 = projectSignatureCache.get(normalizedProjectDir);
+  if (cached3?.fingerprint === fingerprint) return cached3.signature;
   const hash2 = createHash9("sha256");
   for (const entry of files) {
     const relativePath = relative10(normalizedProjectDir, entry.file);
@@ -115339,20 +115394,15 @@ import { existsSync as existsSync41, readFileSync as readFileSync27 } from "fs";
 import { dirname as dirname16, resolve as resolve26 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveHyperframeManifestPath() {
-  if (process.env.PRODUCER_HYPERFRAME_MANIFEST_PATH) {
-    return process.env.PRODUCER_HYPERFRAME_MANIFEST_PATH;
+  const envOverride = process.env.PRODUCER_HYPERFRAME_MANIFEST_PATH;
+  if (envOverride) {
+    return envOverride;
   }
-  const candidates = [
-    SIBLING_MANIFEST_PATH,
-    ...CWD_RELATIVE_MANIFEST_PATHS,
-    MODULE_RELATIVE_MANIFEST_PATH
-  ];
-  for (const candidate of candidates) {
-    if (existsSync41(candidate)) {
-      return candidate;
-    }
-  }
-  return MODULE_RELATIVE_MANIFEST_PATH;
+  const found = MANIFEST_CANDIDATES.find((candidate) => existsSync41(candidate));
+  return found ?? MODULE_RELATIVE_MANIFEST_PATH;
+}
+function triedManifestPaths() {
+  return process.env.PRODUCER_HYPERFRAME_MANIFEST_PATH ? [process.env.PRODUCER_HYPERFRAME_MANIFEST_PATH] : MANIFEST_CANDIDATES;
 }
 function getVerifiedHyperframeRuntimeSource() {
   return resolveVerifiedHyperframeRuntime().runtimeSource;
@@ -115360,8 +115410,9 @@ function getVerifiedHyperframeRuntimeSource() {
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath2 = resolveHyperframeManifestPath();
   if (!existsSync41(manifestPath2)) {
+    const tried = triedManifestPaths().join(", ");
     throw new Error(
-      `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath2}. Build core runtime artifacts before rendering.`
+      `[HyperframeRuntimeLoader] Missing manifest. Tried: ${tried}. Searched from cwd=${process.cwd()}. Build core runtime artifacts before rendering.`
     );
   }
   const manifestRaw = readFileSync27(manifestPath2, "utf8");
@@ -115391,7 +115442,7 @@ function resolveVerifiedHyperframeRuntime() {
     runtimeSource
   };
 }
-var PRODUCER_DIR, SIBLING_MANIFEST_PATH, MODULE_RELATIVE_MANIFEST_PATH, CWD_RELATIVE_MANIFEST_PATHS;
+var PRODUCER_DIR, SIBLING_MANIFEST_PATH, MODULE_RELATIVE_MANIFEST_PATH, MANIFEST_CANDIDATES;
 var init_hyperframeRuntimeLoader = __esm({
   "../producer/src/services/hyperframeRuntimeLoader.ts"() {
     "use strict";
@@ -115401,13 +115452,12 @@ var init_hyperframeRuntimeLoader = __esm({
       PRODUCER_DIR,
       "../../../core/dist/hyperframe.manifest.json"
     );
-    CWD_RELATIVE_MANIFEST_PATHS = [
-      // When bundled to a single file (dist/public-server.js), the manifest
-      // is copied as a sibling by build.mjs
-      resolve26(PRODUCER_DIR, "hyperframe.manifest.json"),
+    MANIFEST_CANDIDATES = [
+      SIBLING_MANIFEST_PATH,
       resolve26(process.cwd(), "packages/core/dist/hyperframe.manifest.json"),
       resolve26(process.cwd(), "../core/dist/hyperframe.manifest.json"),
-      resolve26(process.cwd(), "core/dist/hyperframe.manifest.json")
+      resolve26(process.cwd(), "core/dist/hyperframe.manifest.json"),
+      MODULE_RELATIVE_MANIFEST_PATH
     ];
   }
 });
@@ -121119,8 +121169,8 @@ function cachedCompressionPath(input2, originalFormat, cacheDir) {
 function readCachedCompression(path2) {
   try {
     if (!existsSync46(path2)) return null;
-    const cached2 = readFileSync28(path2);
-    return cached2.length > 0 ? cached2 : null;
+    const cached3 = readFileSync28(path2);
+    return cached3.length > 0 ? cached3 : null;
   } catch {
     return null;
   }
@@ -121152,8 +121202,8 @@ async function fontToDataUri(input2, originalFormat, options = {}) {
       originalFormat,
       options.cacheDir ?? defaultCacheDir()
     );
-    const cached2 = readCachedCompression(cachePath2);
-    if (cached2) return `data:font/woff2;base64,${cached2.toString("base64")}`;
+    const cached3 = readCachedCompression(cachePath2);
+    if (cached3) return `data:font/woff2;base64,${cached3.toString("base64")}`;
     const compressed = await (options.compressImpl ?? compressToWoff2)(input2);
     cacheCompression(cachePath2, compressed);
     return `data:font/woff2;base64,${compressed.toString("base64")}`;
@@ -123733,8 +123783,8 @@ async function discoverAudioVolumeAutomationFromTimeline(page, audioIds, composi
       const volumeDescriptor = typeof HTMLMediaElement === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(HTMLMediaElement.prototype, "volume");
       const nativeVolumeGet = volumeDescriptor?.get;
       const nativeVolumeSet = volumeDescriptor?.set;
-      const withUnclampedVolume2 = (el, probe) => {
-        if (!nativeVolumeGet || !nativeVolumeSet) return probe();
+      const withUnclampedVolume2 = (el, probe2) => {
+        if (!nativeVolumeGet || !nativeVolumeSet) return probe2();
         let authored = Number(nativeVolumeGet.call(el));
         Object.defineProperty(el, "volume", {
           configurable: true,
@@ -123745,7 +123795,7 @@ async function discoverAudioVolumeAutomationFromTimeline(page, audioIds, composi
           }
         });
         try {
-          return probe();
+          return probe2();
         } finally {
           delete el.volume;
           nativeVolumeSet.call(el, Math.max(0, Math.min(1, authored)));
@@ -129046,9 +129096,9 @@ function shouldRetryViaPinnedFallback(args) {
   if (args.isVerifyError) return true;
   return args.deWorkerInversion === "inverted" || args.deParallelRouter === "routed";
 }
-async function closeOrphanedProbeForRetry(probe, closer, log2, retryContext) {
+async function closeOrphanedProbeForRetry(probe2, closer, log2, retryContext) {
   try {
-    await closer(probe);
+    await closer(probe2);
   } catch (closeErr) {
     log2.warn(`[Render] probe close before ${retryContext} retry failed; continuing with retry`, {
       error: closeErr instanceof Error ? closeErr.message : String(closeErr)
@@ -132324,7 +132374,7 @@ import { execFile as execFileCallback } from "child_process";
 import { dirname as dirname28, join as join67 } from "path";
 import { existsSync as existsSync61, readFileSync as readFileSync37 } from "fs";
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { promisify as promisify4 } from "util";
+import { promisify as promisify5 } from "util";
 function isPlanAudioArtifactPath(path2) {
   return path2 === PLAN_AUDIO_RELATIVE_PATH || path2 === PLAN_AUDIO_LEGACY_RELATIVE_PATH;
 }
@@ -132482,7 +132532,7 @@ function buildPlanVideosJson(input2) {
 }
 async function readFfmpegVersion() {
   if (cachedFfmpegVersion !== null) return cachedFfmpegVersion;
-  const { stdout: stdout2 } = await execFile6("ffmpeg", ["-version"], {
+  const { stdout: stdout2 } = await execFile7("ffmpeg", ["-version"], {
     maxBuffer: 1024 * 1024,
     // See runFfmpeg.ts: keeps a console window off the user's desktop on Windows.
     windowsHide: true
@@ -132540,7 +132590,7 @@ function readProducerVersion() {
   cachedProducerVersion = "0.0.0-unknown";
   return cachedProducerVersion;
 }
-var PLAN_VIDEOS_META_RELATIVE_PATH, PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH, INVALID_VIDEO_METADATA, PlanVideosMetadataError, execFile6, cachedFfmpegVersion, cachedProducerVersion;
+var PLAN_VIDEOS_META_RELATIVE_PATH, PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH, INVALID_VIDEO_METADATA, PlanVideosMetadataError, execFile7, cachedFfmpegVersion, cachedProducerVersion;
 var init_shared2 = __esm({
   "../producer/src/services/distributed/shared.ts"() {
     "use strict";
@@ -132560,7 +132610,7 @@ var init_shared2 = __esm({
         this.name = "PlanVideosMetadataError";
       }
     };
-    execFile6 = promisify4(execFileCallback);
+    execFile7 = promisify5(execFileCallback);
     cachedFfmpegVersion = null;
     cachedProducerVersion = null;
   }
@@ -134397,14 +134447,14 @@ async function runCaptureWithScreenshotFallback(input2) {
     return await input2.run(true);
   }
 }
-async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBeginFrameLiveness) {
+async function beginFrameSessionNeedsScreenshotFallback(session, probe2 = probeBeginFrameLiveness) {
   if (session.launchCaptureMode !== "beginframe") return false;
   const timeoutMs = Number(process.env.PRODUCER_BEGINFRAME_PROBE_TIMEOUT_MS) > 0 ? Number(process.env.PRODUCER_BEGINFRAME_PROBE_TIMEOUT_MS) : 3e4;
   const probeTick = deriveBeginFrameProbeTimeTicks(
     session.beginFrameTimeTicks,
     session.beginFrameIntervalMs
   );
-  return !await probe(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
+  return !await probe2(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
 }
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
   const result = [];
@@ -135766,15 +135816,15 @@ function checkFFprobe() {
 }
 function chromeSharedLibOutcome(executablePath, found) {
   if (process.platform !== "linux") return found;
-  const probe = probeChromeSharedLibs(executablePath);
-  if (probe.probeUnavailable || probe.ok) return found;
+  const probe2 = probeChromeSharedLibs(executablePath);
+  if (probe2.probeUnavailable || probe2.ok) return found;
   const distro = detectLinuxDistro();
   return {
     name: "Chrome",
     ok: false,
     level: "error",
     title: "Chrome cannot launch (missing system libraries)",
-    detail: `Chrome at ${executablePath} is missing shared libraries on ${distroLabel(distro)}: ${probe.missing.join(", ")}`,
+    detail: `Chrome at ${executablePath} is missing shared libraries on ${distroLabel(distro)}: ${probe2.missing.join(", ")}`,
     hint: chromeDepsInstallCommand(distro.family),
     path: executablePath
   };
@@ -144104,13 +144154,13 @@ var init_producer = __esm({
 
 // src/utils/webmAlphaCheck.ts
 import { execFileSync as execFileSync11 } from "child_process";
-function webmAlphaAdvisory(format, probe) {
+function webmAlphaAdvisory(format, probe2) {
   if (format !== "webm") return void 0;
-  if (!probe.probed) return void 0;
-  if (!probe.alphaMode) {
+  if (!probe2.probed) return void 0;
+  if (!probe2.alphaMode) {
     return "The WebM output has no VP9 alpha sidecar (the ALPHA_MODE stream tag is absent), so transparency was flattened to opaque. Your ffmpeg/libvpx-vp9 build cannot emit the alpha plane on this platform. For guaranteed transparency, re-render with --format mov (ProRes 4444).";
   }
-  if (probe.sampledAlphaFullyOpaque) {
+  if (probe2.sampledAlphaFullyOpaque) {
     return "The WebM declares alpha (ALPHA_MODE=1) but every sampled decoded pixel reads alpha=255. This may be intentional (the composition has no transparent regions in the samples) OR your ffmpeg/libvpx-vp9 build wrote the tag without emitting the alpha side data \u2014 a known Windows-build quirk. To rule it out, re-render with --format mov (ProRes 4444), or with --format png-sequence and encode the frames yourself: ffmpeg -framerate <fps> -i frame_%06d.png -c:v prores_ks -profile:v 4444 -pix_fmt yuva444p10le out.mov";
   }
   return void 0;
@@ -144144,12 +144194,12 @@ function probeWebmAlpha(filePath) {
     const alphaMode = Object.entries(tags).some(
       ([k2, v2]) => k2.toLowerCase() === "alpha_mode" && String(v2) === "1"
     );
-    const probe = { probed: true, alphaMode };
+    const probe2 = { probed: true, alphaMode };
     if (alphaMode) {
       const opaque = sampledAlphaIsFullyOpaque(filePath);
-      if (opaque === true) probe.sampledAlphaFullyOpaque = true;
+      if (opaque === true) probe2.sampledAlphaFullyOpaque = true;
     }
-    return probe;
+    return probe2;
   } catch {
     return { probed: false, alphaMode: false };
   }
@@ -144803,12 +144853,13 @@ async function renderLocal(projectDir, outputPath, options) {
     await producer.executeRenderJob(job, projectDir, outputPath, onProgress);
   } catch (error) {
     maybeConsumeDeParallelRouterTrial(deParallelRouterActive, job, options.quiet);
+    const inContainer = process.env.CONTAINER === "true";
     handleRenderError(
       error,
       options,
       startTime,
       false,
-      "Try --docker for containerized rendering",
+      inContainer ? "" : "Try --docker for containerized rendering",
       job.failedStage,
       job
     );
@@ -150177,10 +150228,10 @@ __export(normalize_audio_exports, {
   resolveLocalAudioPath: () => resolveLocalAudioPath,
   updateAudioVolume: () => updateAudioVolume
 });
-import { execFile as execFile7 } from "child_process";
+import { execFile as execFile8 } from "child_process";
 import { existsSync as existsSync91, readFileSync as readFileSync66, renameSync as renameSync15, writeFileSync as writeFileSync38 } from "fs";
 import { isAbsolute as isAbsolute14, relative as relative23, resolve as resolve58 } from "path";
-import { promisify as promisify5 } from "util";
+import { promisify as promisify6 } from "util";
 function authoredNumber(raw, fallback, attribute2, id, strictlyPositive = false) {
   if (raw === void 0) return fallback;
   const value = Number(raw);
@@ -150536,7 +150587,7 @@ var init_normalize_audio = __esm({
     init_colors();
     init_project();
     init_commandResult();
-    execFileAsync4 = promisify5(execFile7);
+    execFileAsync4 = promisify6(execFile8);
     FFMPEG_TIMEOUT_MS = 12e4;
     DEFAULT_TOLERANCE_LU = 0.5;
     examples14 = [
@@ -152773,7 +152824,7 @@ function timelineDuration(page) {
   });
 }
 async function resolveScopeInBrowser(page, scope, candidates) {
-  const probe = await page.evaluate(
+  const probe2 = await page.evaluate(
     (scopeSel, cands) => {
       let root = null;
       try {
@@ -152799,9 +152850,9 @@ async function resolveScopeInBrowser(page, scope, candidates) {
   const selectors = resolveShotSelectors(
     scope,
     candidates,
-    (_s, target) => probe.descendant[candidates.indexOf(target)] === true
+    (_s, target) => probe2.descendant[candidates.indexOf(target)] === true
   );
-  return { selectors, scopeExists: probe.scopeExists };
+  return { selectors, scopeExists: probe2.scopeExists };
 }
 async function resolveScopedRequests(page, requests, scopeSelector2) {
   const resolved2 = await resolveScopeInBrowser(
@@ -153862,8 +153913,8 @@ function findReferenceTargetEl2(doc, refId) {
   return doc.getElementById(refId) ?? doc.querySelector(`[data-composition-id="${refId}"]`);
 }
 function resolveStart3(doc, el, startCache, visiting) {
-  const cached2 = startCache.get(el);
-  if (cached2 !== void 0) return cached2;
+  const cached3 = startCache.get(el);
+  if (cached3 !== void 0) return cached3;
   if (visiting.has(el)) return 0;
   visiting.add(el);
   try {
@@ -154435,12 +154486,12 @@ async function showInfo(json) {
   const { selectProviders: selectProviders2, listAvailableProviders: listAvailableProviders2, DEFAULT_MODEL: DEFAULT_MODEL5, MODEL_MEMORY_MB: MODEL_MEMORY_MB2, modelPath: modelPath2 } = await Promise.resolve().then(() => (init_manager3(), manager_exports3));
   const providers = listAvailableProviders2();
   const auto = selectProviders2("auto");
-  const cached2 = existsSync96(modelPath2());
+  const cached3 = existsSync96(modelPath2());
   if (json) {
     console.log(
       JSON.stringify({
         defaultModel: DEFAULT_MODEL5,
-        modelCached: cached2,
+        modelCached: cached3,
         modelPath: modelPath2(),
         peakMemoryMb: MODEL_MEMORY_MB2[DEFAULT_MODEL5],
         availableProviders: providers,
@@ -154454,7 +154505,7 @@ async function showInfo(json) {
   console.log(`  ${c.dim("Default model:")}     ${c.accent(DEFAULT_MODEL5)}`);
   console.log(`  ${c.dim("Peak memory:")}       ~${MODEL_MEMORY_MB2[DEFAULT_MODEL5]} MB`);
   console.log(
-    `  ${c.dim("Weights cached:")}    ${cached2 ? c.success("yes") : c.dim("no (will download on first run)")}`
+    `  ${c.dim("Weights cached:")}    ${cached3 ? c.success("yes") : c.dim("no (will download on first run)")}`
   );
   console.log(`  ${c.dim("Cache path:")}        ${modelPath2()}`);
   console.log("");
@@ -154705,11 +154756,11 @@ function transcribeWithParakeet(inputPath, dir, options) {
     );
   }
   const model = options?.model ?? DEFAULT_MODEL3;
-  const cached2 = existsSync97(
+  const cached3 = existsSync97(
     join105(homedir20(), ".cache", "huggingface", "hub", `models--${model.replace(/\//g, "--")}`)
   );
   options?.onProgress?.(
-    cached2 ? "Transcribing with Parakeet..." : "Downloading Parakeet model (first run, ~600MB)..."
+    cached3 ? "Transcribing with Parakeet..." : "Downloading Parakeet model (first run, ~600MB)..."
   );
   const workDir = mkdtempSync15(join105(tmpdir15(), "hyperframes-parakeet-"));
   try {
@@ -155169,9 +155220,9 @@ function hasPythonModules(modules) {
   const python = findPython();
   if (!python) return false;
   const list = JSON.stringify(modules);
-  const probe = `import importlib.util,sys; sys.exit(0 if all(importlib.util.find_spec(m) for m in ${list}) else 1)`;
+  const probe2 = `import importlib.util,sys; sys.exit(0 if all(importlib.util.find_spec(m) for m in ${list}) else 1)`;
   try {
-    execFileSync14(python, ["-c", probe], {
+    execFileSync14(python, ["-c", probe2], {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 1e4
     });
@@ -163588,7 +163639,7 @@ var init_multipart_parser = __esm({
 
 // ../../node_modules/.bun/node-fetch@3.3.2/node_modules/node-fetch/src/body.js
 import Stream, { PassThrough } from "stream";
-import { types as types3, deprecate, promisify as promisify6 } from "util";
+import { types as types3, deprecate, promisify as promisify7 } from "util";
 import { Buffer as Buffer3 } from "buffer";
 async function consumeBody(data2) {
   if (data2[INTERNALS].disturbed) {
@@ -163643,7 +163694,7 @@ var init_body = __esm({
     init_fetch_error();
     init_base2();
     init_is();
-    pipeline3 = promisify6(Stream.pipeline);
+    pipeline3 = promisify7(Stream.pipeline);
     INTERNALS = /* @__PURE__ */ Symbol("Body internals");
     Body = class {
       constructor(body, {
@@ -196932,8 +196983,8 @@ async function captureSnapshots(projectDir, opts) {
       const alphaDecoderCache = /* @__PURE__ */ new Map();
       const shouldUseVp9AlphaDecoder = (filePath) => {
         if (!extractMediaMetadata2) return Promise.resolve(false);
-        const cached2 = alphaDecoderCache.get(filePath);
-        if (cached2) return cached2;
+        const cached3 = alphaDecoderCache.get(filePath);
+        if (cached3) return cached3;
         const pending = extractMediaMetadata2(filePath).then((meta) => meta.hasAlpha && meta.videoCodec === "vp9").catch(() => false);
         alphaDecoderCache.set(filePath, pending);
         return pending;
@@ -197515,9 +197566,9 @@ function statsToAdjust(stats) {
     }
   };
 }
-function summarizeMediaTreatmentAnalysis(probe, frames) {
+function summarizeMediaTreatmentAnalysis(probe2, frames) {
   const result = statsToAdjust(summarizeFrames(frames));
-  const hdr = ["smpte2084", "arib-std-b67"].includes(probe.transfer);
+  const hdr = ["smpte2084", "arib-std-b67"].includes(probe2.transfer);
   const diagnosis = [];
   if (result.measured.shadowClipRisk > 0) {
     diagnosis.push("sampled frames contain deep or clipped shadows");
@@ -197530,16 +197581,16 @@ function summarizeMediaTreatmentAnalysis(probe, frames) {
   const warnings = [];
   if (hdr)
     warnings.push("HDR transfer detected; the realtime treatment path is SDR/Rec.709.");
-  if (probe.colorSpace === "unknown" || probe.transfer === "unknown") {
+  if (probe2.colorSpace === "unknown" || probe2.transfer === "unknown") {
     warnings.push("Source color metadata is incomplete; camera LOG cannot be identified reliably from container metadata alone.");
   }
   return {
     ...result,
     source: {
-      colorSpace: probe.colorSpace,
-      transfer: probe.transfer,
-      primaries: probe.primaries,
-      pixelFormat: probe.pixelFormat,
+      colorSpace: probe2.colorSpace,
+      transfer: probe2.transfer,
+      primaries: probe2.primaries,
+      pixelFormat: probe2.pixelFormat,
       hdr,
       log: "unknown"
     },
@@ -197551,9 +197602,9 @@ function analyzeMediaGrade(mediaPath, options = {}) {
   const ffmpegPath = options.ffmpegPath ?? "ffmpeg";
   const ffprobePath = options.ffprobePath ?? "ffprobe";
   try {
-    const probe = probeMedia2(mediaPath, ffprobePath);
+    const probe2 = probeMedia2(mediaPath, ffprobePath);
     const isImage = IMAGE_EXTENSIONS3.has(extname20(mediaPath).toLowerCase());
-    const fps = !isImage && probe.duration ? Math.max(0.1, Math.min(2, SAMPLE_FRAMES / probe.duration)) : null;
+    const fps = !isImage && probe2.duration ? Math.max(0.1, Math.min(2, SAMPLE_FRAMES / probe2.duration)) : null;
     const filters2 = [
       fps ? `fps=${fps.toFixed(4)}` : null,
       "format=yuv444p",
@@ -197579,7 +197630,7 @@ function analyzeMediaGrade(mediaPath, options = {}) {
       timeout: Number(process.env.HYPERFRAMES_ANALYZE_TIMEOUT_MS) || DEFAULT_TIMEOUT_MS2,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    return summarizeMediaTreatmentAnalysis(probe, parseMediaTreatmentSignalStats(raw));
+    return summarizeMediaTreatmentAnalysis(probe2, parseMediaTreatmentSignalStats(raw));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`grade analysis failed for ${mediaPath}: ${message}`);
@@ -208691,8 +208742,8 @@ function collectStatusRows(s2) {
   if (s2.credential.type === "oauth") rows.push(...oauthRows(s2.credential));
   if (s2.apiError) {
     rows.push([c.error("API check failed:"), s2.apiError]);
-    const cached2 = s2.persistedUser && userDisplayName(s2.persistedUser);
-    if (cached2) rows.push(["Account:", `${cached2} ${c.dim("(cached)")}`]);
+    const cached3 = s2.persistedUser && userDisplayName(s2.persistedUser);
+    if (cached3) rows.push(["Account:", `${cached3} ${c.dim("(cached)")}`]);
     return rows;
   }
   if (s2.user) rows.push(...identityRows(s2.user));