hyperframes 0.8.192 → 0.8.194

package/dist/{chunk-QX4TB4NH.js → chunk-52YJKWV3.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-MGBUWPXX.js";
+} from "./chunk-JVTWX5G3.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -63,7 +63,7 @@ import {
   sourceTimeAt,
   timeAtSourceTime,
   volumeSegmentSampleCount
-} from "./chunk-B2XLXD7V.js";
+} from "./chunk-2D5WP2NI.js";
 import {
   clampAudioGain,
   clipGain,
@@ -73,6 +73,9 @@ import {
   redactTelemetryString,
   redactUrlQueryStrings
 } from "./chunk-634HSJ3J.js";
+import {
+  withHyperframesBrowserMarker
+} from "./chunk-K4MJX7SR.js";
 import {
   browserPathFromEnv,
   chromeMajorCeiling,
@@ -83,7 +86,7 @@ import {
 } from "./chunk-4UMPIPCQ.js";
 import {
   resolveReferencedStart
-} from "./chunk-2VXY3PEF.js";
+} from "./chunk-K2VXPQKC.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
@@ -765,7 +768,7 @@ var BrowserLeasePool = class _BrowserLeasePool {
     for (const entry of entries) this.requestClose(entry, false);
     const settle = Promise.all(entries.map((entry) => entry.closePromise));
     const bound = new Promise(
-      (resolve) => setTimeout(resolve, _BrowserLeasePool.DRAIN_FORCE_CLOSE_MS).unref()
+      (resolve2) => setTimeout(resolve2, _BrowserLeasePool.DRAIN_FORCE_CLOSE_MS).unref()
     );
     this.drainPromise = Promise.race([settle, bound]).then(() => {
       for (const entry of entries) if (this.entries.has(entry)) this.requestClose(entry, true);
@@ -864,11 +867,11 @@ var BrowserLeasePool = class _BrowserLeasePool {
         await Promise.race([
           this.options.close(result.browser).catch(() => {
           }),
-          new Promise((resolve) => {
+          new Promise((resolve2) => {
             entry.forceClose = () => {
               entry.forceClose = void 0;
               this.options.forceClose(result.browser);
-              resolve();
+              resolve2();
             };
           })
         ]);
@@ -918,7 +921,7 @@ async function probeHardwareWebGlInfo(ppt, options) {
     const launchOptions = {
       ...sigintLaunchOptions(),
       headless: true,
-      args: options.args,
+      args: withHyperframesBrowserMarker(options.args),
       defaultViewport: { width: 64, height: 64 },
       executablePath: options.executablePath,
       env: options.env,
@@ -1366,7 +1369,7 @@ async function launchBrowser(fingerprint) {
     browser = await ppt.launch({
       ...sigintLaunchOptions(),
       headless: true,
-      args: [...fingerprint.args],
+      args: withHyperframesBrowserMarker(fingerprint.args),
       defaultViewport: null,
       executablePath: fingerprint.executablePath,
       env,
@@ -1396,7 +1399,7 @@ async function launchBrowser(fingerprint) {
         browser = await ppt.launch({
           ...sigintLaunchOptions(),
           headless: true,
-          args: stripBeginFrameFlags([...fingerprint.args]),
+          args: withHyperframesBrowserMarker(stripBeginFrameFlags([...fingerprint.args])),
           defaultViewport: null,
           executablePath: fingerprint.executablePath,
           env,
@@ -1477,6 +1480,7 @@ function getLowMemoryFlags() {
 }
 var CANVAS_DRAW_ELEMENT_FEATURE_FLAG = "--enable-features=CanvasDrawElement";
 var WEBGPU_FLAG = "--enable-unsafe-webgpu";
+var DISABLE_DXC_FLAG = "--disable-dawn-features=use_dxc";
 function usesSoftwareWebGpu(requiresWebGpu, config) {
   return !!requiresWebGpu && !!config?.allowSoftwareWebGpu && !(config.disableGpu ?? DEFAULT_CONFIG.disableGpu) && (config.browserGpuMode ?? DEFAULT_CONFIG.browserGpuMode) === "software";
 }
@@ -1532,6 +1536,9 @@ function buildChromeArgs(options, config) {
   ];
   if (browserGpuMode !== "software" || options.requiresWebGpu) {
     chromeArgs.push(WEBGPU_FLAG);
+    if (platform === "win32") {
+      chromeArgs.push(DISABLE_DXC_FLAG);
+    }
   }
   if (softwareWebGpu) chromeArgs.push("--use-vulkan=swiftshader");
   if (browserGpuMode === "software" && !softwareWebGpu) {
@@ -1580,7 +1587,7 @@ async function assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu
       try {
         const adapter = await Promise.race([
           navigator.gpu.requestAdapter(),
-          new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+          new Promise((resolve2) => setTimeout(() => resolve2(null), timeoutMs))
         ]);
         return !!adapter && (acceptFallback || !adapter.info.isFallbackAdapter);
       } catch {
@@ -2583,8 +2590,8 @@ async function describePageMotionBlur(page) {
 }
 async function describePageMotionBlurAtEnd(page, timeoutMs = 1500) {
   let timer;
-  const stuck = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(null), timeoutMs);
+  const stuck = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(null), timeoutMs);
   });
   try {
     const r = await Promise.race([readPageMotionBlur(page), stuck]);
@@ -2703,8 +2710,8 @@ async function probeBeginFrameLiveness(page, timeoutMs, frameTimeTicks, interval
   try {
     return await Promise.race([
       client.send("HeadlessExperimental.beginFrame", params).then(() => true).catch(() => false),
-      new Promise((resolve) => {
-        timer = setTimeout(() => resolve(false), timeoutMs);
+      new Promise((resolve2) => {
+        timer = setTimeout(() => resolve2(false), timeoutMs);
       })
     ]);
   } finally {
@@ -3503,7 +3510,7 @@ async function produceDrawElementFrame(page, width, height, quality = 80, syncTo
     );
   }
   const frameId = ++state.nextId;
-  const encodeResult = new Promise((resolve, reject) => {
+  const encodeResult = new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
       if (state.pending.delete(frameId)) {
         reject(new Error(`drawElement worker encode timed out (frame ${frameId})`));
@@ -3512,7 +3519,7 @@ async function produceDrawElementFrame(page, width, height, quality = 80, syncTo
     state.pending.set(frameId, {
       resolve: (b) => {
         clearTimeout(timer);
-        resolve(b);
+        resolve2(b);
       },
       reject: (e) => {
         clearTimeout(timer);
@@ -3668,7 +3675,7 @@ async function produceDrawElementFrameBatch(page, times, width, height, quality
   for (let i = 0; i < times.length; i++) {
     const frameId = ++state.nextId;
     fids.push(frameId);
-    const p = new Promise((resolve, reject) => {
+    const p = new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         if (state.pending.delete(frameId)) {
           reject(new Error(`drawElement worker encode timed out (frame ${frameId})`));
@@ -3677,7 +3684,7 @@ async function produceDrawElementFrameBatch(page, times, width, height, quality
       state.pending.set(frameId, {
         resolve: (b) => {
           clearTimeout(timer);
-          resolve(b);
+          resolve2(b);
         },
         reject: (e) => {
           clearTimeout(timer);
@@ -3952,9 +3959,9 @@ async function initThreeDProjectionInPage() {
   const toDataUrl = async (url) => {
     const resp = await fetch(url);
     const blob = await resp.blob();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const r = new FileReader();
-      r.onload = () => resolve(String(r.result));
+      r.onload = () => resolve2(String(r.result));
       r.onerror = () => reject(new Error(`FileReader failed for ${url}`));
       r.readAsDataURL(blob);
     });
@@ -4798,6 +4805,7 @@ var CaptureFailure = class extends Error {
   kind;
   cause;
   workerDiagnostics;
+  pageErrorLines;
   constructor(input) {
     super(input.message);
     this.name = "CaptureFailure";
@@ -4808,6 +4816,7 @@ var CaptureFailure = class extends Error {
         (diagnostic) => Object.freeze({ ...diagnostic, lines: Object.freeze([...diagnostic.lines]) })
       )
     );
+    this.pageErrorLines = Object.freeze([...input.pageErrorLines ?? []]);
     if (input.cause instanceof Error && input.cause.stack) this.stack = input.cause.stack;
   }
 };
@@ -4893,32 +4902,37 @@ function ioError(error, message) {
     )
   ) || BROKEN_PIPE_MESSAGE.test(message) || hasIoOperationFailure(message);
 }
+var ORDERED_KIND_RULES = [
+  [
+    "memory_exhaustion",
+    (message) => BUN_MEMORY_EXHAUSTION_EXACT_MESSAGE.test(message.trim()) || BUN_MEMORY_EXHAUSTION_WRAPPED_WORKER_MESSAGE.test(message) || matchesAny(message, MEMORY_EXHAUSTION_ERROR_PATTERNS)
+  ],
+  ["verification", (message) => matchesAny(message, VERIFICATION_ERROR_PATTERNS)],
+  ["protocol_timeout", (message) => matchesAny(message, PROTOCOL_TIMEOUT_PATTERNS)],
+  ["transient_browser", (message) => matchesAny(message, TRANSIENT_BROWSER_ERROR_PATTERNS)],
+  ["authoring", (message) => matchesAny(message, AUTHORING_ERROR_PATTERNS)]
+];
+function classifyKind(error, message, signal) {
+  if (signal?.aborted || /(?:render|capture)?_?cancelled|AbortError/i.test(message)) {
+    return "cancelled";
+  }
+  const rule = ORDERED_KIND_RULES.find(([, matches]) => matches(message));
+  if (rule) return rule[0];
+  return ioError(error, message) ? "io" : "authoring";
+}
 function classifyCaptureFailure(error, options = {}) {
-  if (error instanceof CaptureFailure && !options.workerDiagnostics && !options.signal?.aborted) {
-    return error;
+  const prior = error instanceof CaptureFailure ? error : void 0;
+  if (prior && !(options.workerDiagnostics || options.pageErrorLines || options.signal?.aborted)) {
+    return prior;
   }
   const message = messageOf(error);
-  let kind;
-  if (options.signal?.aborted || /(?:render|capture)?_?cancelled|AbortError/i.test(message)) {
-    kind = "cancelled";
-  } else if (BUN_MEMORY_EXHAUSTION_EXACT_MESSAGE.test(message.trim()) || BUN_MEMORY_EXHAUSTION_WRAPPED_WORKER_MESSAGE.test(message) || matchesAny(message, MEMORY_EXHAUSTION_ERROR_PATTERNS)) {
-    kind = "memory_exhaustion";
-  } else if (matchesAny(message, VERIFICATION_ERROR_PATTERNS)) {
-    kind = "verification";
-  } else if (matchesAny(message, PROTOCOL_TIMEOUT_PATTERNS)) {
-    kind = "protocol_timeout";
-  } else if (matchesAny(message, TRANSIENT_BROWSER_ERROR_PATTERNS)) {
-    kind = "transient_browser";
-  } else if (matchesAny(message, AUTHORING_ERROR_PATTERNS)) {
-    kind = "authoring";
-  } else {
-    kind = ioError(error, message) ? "io" : "authoring";
-  }
+  const kind = classifyKind(error, message, options.signal);
   return new CaptureFailure({
     kind,
     message,
     cause: error,
-    workerDiagnostics: options.workerDiagnostics ?? (error instanceof CaptureFailure ? error.workerDiagnostics : void 0)
+    workerDiagnostics: options.workerDiagnostics ?? prior?.workerDiagnostics,
+    pageErrorLines: options.pageErrorLines ?? prior?.pageErrorLines
   });
 }
 function isTransientBrowserError(error) {
@@ -5139,7 +5153,7 @@ function formatHttpErrorDiagnostic(input) {
   return `[Browser:HTTP${input.status}] ${input.method} ${sanitizeDiagnosticUrl(input.url)} resource=${input.resourceType}${statusText}`;
 }
 var LOCKED_WARMUP_TICKS = 60;
-var realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var realSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 function warmupFrameTimeTicks(state, intervalMs) {
   return state.ticks * intervalMs;
 }
@@ -5203,12 +5217,14 @@ async function driveWarmupTicks(options, state) {
     } else {
       if (!state.running) return;
     }
+    let ticked = false;
     try {
       await options.tick(state.ticks * options.intervalMs, options.intervalMs);
       state.ticks += 1;
+      ticked = true;
     } catch {
     }
-    await sleep(options.intervalMs);
+    if (!(options.lockWarmupTicks && !state.running && ticked)) await sleep(options.intervalMs);
   }
 }
 function resolveCaptureSessionOptions(options, browserVersion, platform = process.platform) {
@@ -5225,10 +5241,10 @@ async function waitForCloseWithTimeout(promise) {
       () => void 0,
       () => void 0
     ),
-    new Promise((resolve) => {
+    new Promise((resolve2) => {
       timer = setTimeout(() => {
         timedOut = true;
-        resolve();
+        resolve2();
       }, CAPTURE_SESSION_CLOSE_TIMEOUT_MS);
     })
   ]);
@@ -5717,7 +5733,7 @@ async function pollHfReady(page, timeoutMs, intervalMs = 100) {
         }
       }
     }
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
   }
   const diag = await evaluateHfDiagnostic(page);
   if (diag.hasSeek && diag.duration === 0) {
@@ -5847,7 +5863,7 @@ async function pollSubCompositionTimelines(page, timeoutMs, {
       );
       break;
     }
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
   }
   const pendingIds = ready && knownUnregisteredIds.length === 0 ? [] : await listUnregisteredTimelineIds(page);
   if (ready && pendingIds.length > 0 && (getScriptLoadFailures?.() ?? []).length > 0) {
@@ -5891,7 +5907,7 @@ async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await check()) return true;
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
   }
   return check();
 }
@@ -5914,7 +5930,7 @@ async function pollImagesReady(page, timeoutMs, intervalMs = 100) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await check()) return true;
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
   }
   return check();
 }
@@ -6095,7 +6111,7 @@ async function waitForOptionalTailwindReady(page, timeoutMs) {
     page.evaluate(
       `Promise.resolve(window.__tailwindReady).then(() => true, () => false)`
     ),
-    new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs))
+    new Promise((resolve2) => setTimeout(() => resolve2(false), timeoutMs))
   ]);
   if (!ready) {
     throw new Error(
@@ -7838,7 +7854,7 @@ import {
   writeFileSync as writeFileSync2,
   writeSync
 } from "fs";
-import { join as join6, dirname as dirname2, extname } from "path";
+import { join as join6, dirname as dirname2, extname, resolve } from "path";
 
 // ../engine/src/utils/gpuEncoder.ts
 import { spawn } from "child_process";
@@ -7854,8 +7870,8 @@ var ManagedChildProcess = class {
     this.options = options;
     this.now = options.now ?? Date.now;
     this.startedAtMs = this.now();
-    this.outcomePromise = new Promise((resolve) => {
-      this.resolveOutcome = resolve;
+    this.outcomePromise = new Promise((resolve2) => {
+      this.resolveOutcome = resolve2;
     });
     child.stderr?.on("data", this.onStderr);
     child.once("spawn", this.onSpawn);
@@ -8608,6 +8624,10 @@ var withoutQuery = (url) => url.split(/[?#]/, 1)[0] ?? url;
 function declareContentAddressedUrl(url, sha256) {
   contentAddressedUrls.set(withoutQuery(url), sha256);
 }
+var probeFactsUrls = /* @__PURE__ */ new Map();
+function declareProbeFactsUrl(url, factsUrl) {
+  probeFactsUrls.set(withoutQuery(url), factsUrl);
+}
 function mediaFileIdentity(filePath) {
   if (/^https?:\/\//i.test(filePath)) {
     const sha256 = contentAddressedUrls.get(withoutQuery(filePath));
@@ -8636,6 +8656,75 @@ function writeMetadataCache(cache, key, identity, promise) {
     }
   );
 }
+var PROBE_FACTS_VERSION = "v2";
+var PROBE_JSON_ARGS = ["-print_format", "json", "-show_format", "-show_streams"];
+var storedFacts = /* @__PURE__ */ new Map();
+function readStoredFacts(filePath) {
+  if (!/^https?:\/\//i.test(filePath)) return void 0;
+  const factsUrl = probeFactsUrls.get(withoutQuery(filePath));
+  if (!factsUrl) return void 0;
+  let facts = storedFacts.get(factsUrl);
+  if (!facts) {
+    facts = (async () => {
+      try {
+        const response = await fetch(factsUrl, { signal: AbortSignal.timeout(1e4) });
+        if (!response.ok) return null;
+        const parsed = JSON.parse(await response.text());
+        return Array.isArray(parsed.ffprobe?.streams) ? parsed : null;
+      } catch {
+        return null;
+      }
+    })();
+    storedFacts.set(factsUrl, facts);
+  }
+  return facts;
+}
+function readProbeJson(filePath, signal) {
+  const pending = readStoredFacts(filePath);
+  if (!pending) return runFfprobe(filePath, PROBE_JSON_ARGS, signal);
+  return pending.then(
+    (stored) => stored ? JSON.stringify(stored.ffprobe) : runFfprobe(filePath, PROBE_JSON_ARGS, signal)
+  );
+}
+var runtimeFfprobeMajor;
+function ffprobeMajor() {
+  runtimeFfprobeMajor ??= new Promise((resolve2) => {
+    let out = "";
+    const binary = getFfprobeBinary();
+    const proc = spawn3(binary, ["-version"], { stdio: ["ignore", "pipe", "ignore"] });
+    proc.stdout.on("data", (chunk) => out += String(chunk));
+    proc.on("error", () => resolve2(void 0));
+    proc.on("close", () => resolve2(Number(/version n?(\d+)/.exec(out)?.[1]) || void 0));
+  });
+  return runtimeFfprobeMajor;
+}
+async function buildProbeFactsText(filePath, signal) {
+  const facts = {
+    ffprobe: parseProbeJson(await runFfprobe(filePath, PROBE_JSON_ARGS, signal)),
+    ffprobeMajor: await ffprobeMajor()
+  };
+  try {
+    const metadata = await extractMediaMetadata(filePath);
+    const window2 = resolveStreamWindow(filePath, {
+      videoStreamStartSeconds: metadata.videoStreamStartSeconds,
+      videoStreamDurationSeconds: resolvePlayableVideoDuration(metadata) - (metadata.videoStreamLeadSeconds ?? 0)
+    });
+    if (window2.videoStreamDurationSeconds > 0) {
+      facts.finalFrame = {
+        streamStart: window2.videoStreamStartSeconds,
+        streamDuration: window2.videoStreamDurationSeconds,
+        seconds: await extractFinalVideoFrameTimestamp(filePath, window2, signal),
+        lastPacketSeconds: await extractFinalPacketDuration(filePath, window2, signal)
+      };
+    }
+  } catch {
+    if (signal?.aborted) throw signal.reason;
+  }
+  return JSON.stringify(facts);
+}
+function resolvePlayableVideoDuration(metadata) {
+  return Number.isFinite(metadata.videoStreamDurationSeconds) && metadata.videoStreamDurationSeconds > 0 ? (metadata.videoStreamLeadSeconds ?? 0) + metadata.videoStreamDurationSeconds : metadata.durationSeconds;
+}
 async function probeMediaOutput(filePath, signal) {
   let cache = mediaProbeOutputCache;
   if (signal) {
@@ -8651,11 +8740,7 @@ async function probeMediaOutput(filePath, signal) {
     }
     return cached.promise;
   }
-  const promise = runFfprobe(
-    filePath,
-    ["-print_format", "json", "-show_format", "-show_streams"],
-    signal
-  ).then(parseProbeJson);
+  const promise = readProbeJson(filePath, signal).then(parseProbeJson);
   if (identity !== null) {
     cache.set(filePath, { identity, promise });
     if (!signal && cache.size > MEDIA_PROBE_OUTPUT_CACHE_MAX_ENTRIES) {
@@ -8911,6 +8996,43 @@ function resolveStreamWindow(filePath, metadata) {
   const cacheKey = `${filePath}\0${String(videoStreamStartSeconds)}\0${String(videoStreamDurationSeconds)}`;
   return { videoStreamStartSeconds, videoStreamDurationSeconds, cacheKey };
 }
+function readStoredFinalFrame(filePath, metadata) {
+  const { videoStreamStartSeconds, videoStreamDurationSeconds } = resolveStreamWindow(
+    filePath,
+    metadata
+  );
+  return readStoredFacts(filePath)?.then(async (facts) => {
+    const stored = facts?.finalFrame;
+    if (facts?.ffprobeMajor !== void 0 && facts.ffprobeMajor !== await ffprobeMajor())
+      return void 0;
+    return stored && stored.streamStart === videoStreamStartSeconds && stored.streamDuration === videoStreamDurationSeconds ? stored : void 0;
+  });
+}
+async function extractFinalPacketDuration(filePath, window2, signal) {
+  const streamEnd = window2.videoStreamStartSeconds + window2.videoStreamDurationSeconds;
+  const intervalStart = Math.max(window2.videoStreamStartSeconds, streamEnd - 1);
+  const stdout = await runFfprobe(
+    filePath,
+    [
+      "-select_streams",
+      "v:0",
+      "-read_intervals",
+      `${intervalStart}%${streamEnd}`,
+      "-show_entries",
+      "packet=pts_time,duration_time",
+      "-of",
+      "csv=p=0"
+    ],
+    signal,
+    { retainTail: true, maxChars: 64 * 1024 }
+  );
+  const packets = stdout.split("\n").map((line) => line.trim().split(",").map(Number)).filter(([pts, duration]) => Number.isFinite(pts) && Number.isFinite(duration));
+  const last = packets.reduce(
+    (best, packet) => !best || packet[0] > best[0] ? packet : best,
+    void 0
+  );
+  return last?.[1];
+}
 async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
   const {
     videoStreamStartSeconds,
@@ -8926,6 +9048,9 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
   const cached = readMetadataCache(probeCache, cacheKey, identity);
   if (cached) return cached;
   const probePromise = (async () => {
+    const pendingStored = readStoredFinalFrame(filePath, metadata);
+    const stored = pendingStored && await pendingStored;
+    if (stored) return stored.seconds;
     if (!(videoDurationSeconds > 0) || !Number.isFinite(videoDurationSeconds)) {
       throw new Error(
         `[FFmpeg] Cannot locate final video frame for invalid duration ${String(videoDurationSeconds)}`
@@ -9570,7 +9695,7 @@ var concatListSeq = 0;
 function writeConcatList(dir, inputPaths) {
   concatListSeq += 1;
   const listPath = join6(dir, `concat-list-${process.pid}-${concatListSeq}.txt`);
-  const body = inputPaths.map((p) => `file '${p.replace(/'/g, "'\\''")}'`).join("\n");
+  const body = inputPaths.map((p) => `file '${resolve(p).replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync2(listPath, body, "utf-8");
   return listPath;
 }
@@ -9931,12 +10056,12 @@ function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
   let aborted = null;
   const pending = /* @__PURE__ */ new Map();
-  const enqueueAt = (frame, resolve, reject) => {
+  const enqueueAt = (frame, resolve2, reject) => {
     const list = pending.get(frame);
     if (list === void 0) {
-      pending.set(frame, [{ resolve, reject }]);
+      pending.set(frame, [{ resolve: resolve2, reject }]);
     } else {
-      list.push({ resolve, reject });
+      list.push({ resolve: resolve2, reject });
     }
   };
   const flushAt = (frame) => {
@@ -9945,31 +10070,31 @@ function createFrameReorderBuffer(startFrame, endFrame) {
     pending.delete(frame);
     for (const waiter of list) waiter.resolve();
   };
-  const waitForFrame = (frame) => new Promise((resolve, reject) => {
+  const waitForFrame = (frame) => new Promise((resolve2, reject) => {
     if (aborted) {
       reject(aborted);
       return;
     }
     if (frame === cursor) {
-      resolve();
+      resolve2();
       return;
     }
-    enqueueAt(frame, resolve, reject);
+    enqueueAt(frame, resolve2, reject);
   });
   const advanceTo = (frame) => {
     cursor = frame;
     flushAt(frame);
   };
-  const waitForAllDone = () => new Promise((resolve, reject) => {
+  const waitForAllDone = () => new Promise((resolve2, reject) => {
     if (aborted) {
       reject(aborted);
       return;
     }
     if (cursor >= endFrame) {
-      resolve();
+      resolve2();
       return;
     }
-    enqueueAt(endFrame, resolve, reject);
+    enqueueAt(endFrame, resolve2, reject);
   });
   const abort = (err) => {
     if (aborted) return;
@@ -10264,8 +10389,8 @@ async function spawnStreamingEncoder(outputPath, options, signal, config) {
       }
       const stdin = ffmpeg.stdin;
       if (stdin && !stdin.destroyed) {
-        await new Promise((resolve) => {
-          stdin.end(() => resolve());
+        await new Promise((resolve2) => {
+          stdin.end(() => resolve2());
         });
       }
       const outcome = await exitPromise;
@@ -10403,14 +10528,14 @@ import { cpus } from "os";
 function createConcurrencyLimit(limit) {
   let active = 0;
   const waiting = [];
-  const waitForSlot = (signal) => new Promise((resolve) => {
+  const waitForSlot = (signal) => new Promise((resolve2) => {
     const granted = () => {
       signal?.removeEventListener("abort", aborted);
-      resolve(true);
+      resolve2(true);
     };
     const aborted = () => {
       waiting.splice(waiting.indexOf(granted), 1);
-      resolve(false);
+      resolve2(false);
     };
     waiting.push(granted);
     signal?.addEventListener("abort", aborted, { once: true });
@@ -10713,10 +10838,10 @@ async function waitForCacheLock(signal) {
   if (signal?.aborted) {
     throw new UrlDownloadError("cancelled", false, "Download cancelled");
   }
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const timeout = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve();
+      resolve2();
     }, CACHE_LOCK_POLL_MS);
     const onAbort = () => {
       clearTimeout(timeout);
@@ -11528,12 +11653,52 @@ import {
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync5,
-  renameSync,
   rmSync as rmSync3,
   statSync as statSync6,
   utimesSync,
   writeFileSync as writeFileSync3
 } from "fs";
+
+// ../engine/src/utils/renameWithRetry.ts
+import { renameSync } from "fs";
+import { rename } from "fs/promises";
+var RETRYABLE = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+var BACKOFF_MS = [10, 20, 40, 80, 160, 320, 640];
+function isRetryable(error, platform) {
+  if (platform !== "win32") return false;
+  return RETRYABLE.has(error?.code ?? "");
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function renameWithRetry(from, to, options = {}) {
+  const doRename = options.rename ?? renameSync;
+  const platform = options.platform ?? process.platform;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      doRename(from, to);
+      return;
+    } catch (error) {
+      if (attempt >= BACKOFF_MS.length || !isRetryable(error, platform)) throw error;
+      sleepSync(BACKOFF_MS[attempt]);
+    }
+  }
+}
+async function renameWithRetryAsync(from, to, options = {}) {
+  const doRename = options.rename ?? rename;
+  const platform = options.platform ?? process.platform;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await doRename(from, to);
+      return;
+    } catch (error) {
+      if (attempt >= BACKOFF_MS.length || !isRetryable(error, platform)) throw error;
+      await new Promise((resolve2) => setTimeout(resolve2, BACKOFF_MS[attempt]));
+    }
+  }
+}
+
+// ../engine/src/services/extractionCache.ts
 import { join as join9 } from "path";
 var COMPLETE_SENTINEL = ".hf-complete";
 var GC_MARKER = ".hf-last-gc";
@@ -11608,7 +11773,7 @@ function publishCacheEntry(entry, partialDir) {
     return { dir: partialDir, published: false };
   }
   try {
-    renameSync(partialDir, entry.dir);
+    renameWithRetry(partialDir, entry.dir);
     return { dir: entry.dir, published: true };
   } catch (err) {
     if (!isTargetExistsRenameError(err)) return { dir: partialDir, published: false };
@@ -11621,7 +11786,7 @@ function publishCacheEntry(entry, partialDir) {
     return { dir: partialDir, published: false };
   }
   try {
-    renameSync(partialDir, entry.dir);
+    renameWithRetry(partialDir, entry.dir);
     return { dir: entry.dir, published: true };
   } catch {
     return adoptPublishedWinner(entry, partialDir) ?? { dir: partialDir, published: false };
@@ -11806,6 +11971,24 @@ function extractionFrameCountForDuration(durationSeconds, fps, isVFR) {
   const frames = Number(frameCount);
   return Math.max(1, Number.isSafeInteger(frames) ? frames : Number.MAX_SAFE_INTEGER);
 }
+function exactSourceRate(probed) {
+  const nominal = Math.round(probed * 1.001);
+  return [nominal, nominal * 1e3 / 1001].find((rate) => Math.abs(rate - probed) <= 5e-3 + 1e-9) ?? null;
+}
+function tailFramesFromFinalFrame(input) {
+  const sourceRate = exactSourceRate(input.sourceFps);
+  if (!sourceRate || !(input.outputFps > 0)) return null;
+  const lead = input.streamLeadSeconds;
+  if (lead !== 0 && !(Math.abs((input.lastPacketSeconds ?? NaN) - 1 / sourceRate) <= 1e-4)) {
+    return null;
+  }
+  const seek = input.startTime + input.firstFrame / input.outputFps;
+  const slots = (lead + input.finalFrameSeconds + 1 / sourceRate - seek) * input.outputFps;
+  const distanceToSlot = Math.abs(slots - Math.round(slots));
+  if (distanceToSlot >= 5e-5 && distanceToSlot < 5e-4) return null;
+  const count = Math.min(input.tailFrames, Math.ceil(slots - 5e-5));
+  return count > 0 ? count : null;
+}
 var DOWNLOAD_SUBDIR = "_downloads";
 var EXTRACT_CACHE_MIN_AGE_MS = 60 * 60 * 1e3;
 var GC_STALENESS_MS = 24 * 60 * 60 * 1e3;
@@ -12180,6 +12363,8 @@ function undoTickRoundingOnTheSourceFrameGrid(seek, lead) {
 }
 var EXTRACTION_SLOTS = Math.max(1, Math.floor(cpus().length / 2));
 var inExtractionSlot = createConcurrencyLimit(EXTRACTION_SLOTS);
+var TAIL_PROBE_SLOTS = Math.max(1, Number(process.env.HF_TAIL_PROBE_SLOTS) || 16);
+var inTailProbeSlot = createConcurrencyLimit(TAIL_PROBE_SLOTS);
 function splitFrameRanges(ranges, segmentFrames) {
   const segments = [];
   for (const range of ranges) {
@@ -12193,7 +12378,7 @@ function splitFrameRanges(ranges, segmentFrames) {
   return segments;
 }
 async function runSegmentedExtraction(job) {
-  const { decodeArgs, filterAndEncodeArgs, videoPath, startTime, fps, segments } = job;
+  const { decodeArgs, filterAndEncodeArgs, videoPath, startTime, fps, segments, gate } = job;
   const segmentCount = segments.length;
   const failed = new AbortController();
   const signal = job.runOptions.signal ? AbortSignal.any([job.runOptions.signal, failed.signal]) : failed.signal;
@@ -12204,7 +12389,7 @@ async function runSegmentedExtraction(job) {
       const index = next++;
       const { firstFrame, frames } = segments[index];
       const seek = startTime + firstFrame / fps;
-      const result = await inExtractionSlot(
+      const result = await gate(
         () => runFfmpeg(
           [
             ...decodeArgs,
@@ -12355,6 +12540,7 @@ async function extractVideoFramesRangeUnredacted(videoPath, videoId, startTime,
     videoPath,
     startTime,
     fps,
+    gate: options.tailProbe ? inTailProbeSlot : inExtractionSlot,
     segments: splitFrameRanges(
       options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }],
       segmentFrames
@@ -12455,9 +12641,6 @@ function resolveSegmentDuration(requested, mediaStart, sourceDuration) {
   const sourceRemaining = sourceDuration - mediaStart;
   return sourceRemaining > 0 ? sourceRemaining : sourceDuration;
 }
-function resolvePlayableVideoDuration(metadata) {
-  return Number.isFinite(metadata.videoStreamDurationSeconds) && metadata.videoStreamDurationSeconds > 0 ? (metadata.videoStreamLeadSeconds ?? 0) + metadata.videoStreamDurationSeconds : metadata.durationSeconds;
-}
 function canHoldFinalFramePastEof(video) {
   const timelineDuration = video.end - video.start;
   return !video.loop && Number.isFinite(timelineDuration) && timelineDuration > 0;
@@ -13136,23 +13319,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     );
     const tailFrames = Math.min(expectedFrames, Math.ceil(fps));
     if (expectedFrames <= tailFrames) return null;
-    const probeDir = join10(options.outputDir, `${work.video.id}.tail-probe`);
-    try {
-      const tail = await extractVideoFramesRange(
-        work.videoPath,
-        work.video.id,
-        work.extractionMediaStart,
-        work.videoDuration,
-        {
-          ...scopedExtractionOptions(work),
-          frameRanges: [{ firstFrame: expectedFrames - tailFrames, frames: tailFrames }]
-        },
-        signal,
-        config,
-        probeDir
-      );
-      const totalFrames = expectedFrames - tailFrames + tail.totalFrames;
-      if (totalFrames <= expectedFrames * 0.6) return null;
+    const deferred = (totalFrames) => {
       const outputDir = join10(options.outputDir, work.video.id);
       mkdirSync6(outputDir, { recursive: true });
       return {
@@ -13170,6 +13337,45 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
           format: work.format
         }
       };
+    };
+    if (work.extractionMediaStart + work.videoDuration + 1 <= resolvePlayableVideoDuration(work.metadata)) {
+      return deferred(expectedFrames);
+    }
+    const firstTailFrame = expectedFrames - tailFrames;
+    const storedFinalFrame = await readStoredFinalFrame(work.videoPath, work.metadata);
+    const storedTailFrames = storedFinalFrame === void 0 ? null : tailFramesFromFinalFrame({
+      startTime: work.extractionMediaStart,
+      firstFrame: firstTailFrame,
+      tailFrames,
+      outputFps: fps,
+      sourceFps: work.metadata.fps,
+      finalFrameSeconds: storedFinalFrame.seconds,
+      lastPacketSeconds: storedFinalFrame.lastPacketSeconds,
+      streamLeadSeconds: work.metadata.videoStreamLeadSeconds ?? 0
+    });
+    if (storedTailFrames !== null) {
+      const totalFrames = firstTailFrame + storedTailFrames;
+      return totalFrames <= expectedFrames * 0.6 ? null : deferred(totalFrames);
+    }
+    const probeDir = join10(options.outputDir, `${work.video.id}.tail-probe`);
+    try {
+      const tail = await extractVideoFramesRange(
+        work.videoPath,
+        work.video.id,
+        work.extractionMediaStart,
+        work.videoDuration,
+        {
+          ...scopedExtractionOptions(work),
+          frameRanges: [{ firstFrame: firstTailFrame, frames: tailFrames }],
+          tailProbe: isHttpUrl(work.videoPath)
+        },
+        signal,
+        config,
+        probeDir
+      );
+      const totalFrames = firstTailFrame + tail.totalFrames;
+      if (totalFrames <= expectedFrames * 0.6) return null;
+      return deferred(totalFrames);
     } catch {
       return null;
     } finally {
@@ -14048,16 +14254,7 @@ async function queryElementStacking(page, nativeHdrIds) {
 }
 
 // ../engine/src/services/audioMixer.ts
-import {
-  closeSync as closeSync4,
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync7,
-  mkdtempSync as mkdtempSync7,
-  openSync as openSync4,
-  renameSync as renameSync3,
-  rmSync as rmSync8,
-  writeFileSync as writeFileSync7
-} from "fs";
+import { closeSync as closeSync4, existsSync as existsSync11, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync7, openSync as openSync4, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "fs";
 import { join as join14, dirname as dirname7, isAbsolute, relative } from "path";
 
 // ../engine/src/utils/notMediaPayload.ts
@@ -14176,6 +14373,7 @@ function clampFadesToDuration(fades, duration) {
 import { cpus as cpus2 } from "os";
 
 // ../engine/src/services/aacEncode.ts
+import { execFile as execFile3 } from "child_process";
 import { mkdtempSync as mkdtempSync4, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname5, join as join11 } from "path";
 var SAMPLE_RATE = 48e3;
@@ -14211,12 +14409,35 @@ function planSegments(totalDuration, count) {
     return { trim, keepFrom: cut - firstFrame, keepTo: next - firstFrame };
   });
 }
+var settsDurationSupport = /* @__PURE__ */ new Map();
+function supportsSettsDuration(binary = getFfmpegBinary()) {
+  let supported = settsDurationSupport.get(binary);
+  if (!supported) {
+    supported = new Promise((resolve2) => {
+      execFile3(binary, ["-hide_banner", "-h", "bsf=setts"], (error, stdout) => {
+        resolve2(error !== null || stdout.includes("duration"));
+      });
+    });
+    settsDurationSupport.set(binary, supported);
+  }
+  return supported;
+}
+function encodeInOnePass(input, outputPath, { signal, timeout, filter }) {
+  const filters = [filter, `aresample=${SAMPLE_RATE}`].filter(Boolean).join(",");
+  return runFfmpeg(["-i", input, "-af", filters, ...AAC_ARGS, "-y", outputPath], {
+    signal,
+    timeout
+  });
+}
 async function encodeAac(input, outputPath, totalDuration, {
   signal,
   timeout,
   filter,
   segments: count = aacSegmentCount(totalDuration)
 }) {
+  if (!await supportsSettsDuration()) {
+    return encodeInOnePass(input, outputPath, { signal, timeout, filter });
+  }
   const dir = mkdtempSync4(join11(dirname5(outputPath), ".aac-segments-"));
   try {
     const segments = planSegments(totalDuration, count).map((segment, k) => ({
@@ -14382,7 +14603,7 @@ function audioFailureDiagnostics(values) {
 }
 
 // ../engine/src/services/audioVolumeEnvelope.ts
-import { mkdtempSync as mkdtempSync5, readFileSync as readFileSync6, renameSync as renameSync2, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
+import { mkdtempSync as mkdtempSync5, readFileSync as readFileSync6, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname6, join as join12 } from "path";
 
 // ../core/dist/runtime/mediaVolumeEnvelope.js
@@ -14512,7 +14733,7 @@ function applyVolumeEnvelopeToWav(wavPath, keyframes, trackStart, baseVolume) {
     stagingDir = mkdtempSync5(join12(dirname6(wavPath), ".hf-volume-"));
     const tempPath = join12(stagingDir, "audio.wav");
     writeFileSync5(tempPath, buffer, { flag: "wx" });
-    renameSync2(tempPath, wavPath);
+    renameWithRetry(tempPath, wavPath);
     return true;
   } catch {
     return false;
@@ -15502,6 +15723,9 @@ function volumeLaneKeyframes(automation, trackStart, duration, gain, gainAhead =
 function parseMasterFxChain(html) {
   return readMasterFxChain(parseHTML(unwrapTemplate(html)).document);
 }
+function videoAudioId(videoId) {
+  return `${videoId}-audio`;
+}
 function parseAudioElements(html) {
   const elements = [];
   const { document: document2 } = parseHTML(unwrapTemplate(html));
@@ -15564,7 +15788,7 @@ function parseAudioElements(html) {
     const src = resolveMediaElementSrc(el);
     if (!id || !src || isHidden(el) || memberGroupHidden(el)) continue;
     if (isKnownInactiveTimelineWindow(el, resolveStart(el))) continue;
-    elements.push(build(el, `${id}-audio`, src, "video", true));
+    elements.push(build(el, videoAudioId(id), src, "video", true));
   }
   return elements;
 }
@@ -16010,7 +16234,7 @@ async function mixGroupMembers(memberTracks, outputPath, totalDuration, signal,
   try {
     const summed = await sumInSlices(memberTracks, scratchDir, totalDuration, signal, config);
     if (!summed.success) return summed;
-    renameSync3(summed.track.srcPath, outputPath);
+    renameWithRetry(summed.track.srcPath, outputPath);
     return { success: true, degradedAutomation: summed.degradedAutomation };
   } finally {
     rmSync8(scratchDir, { recursive: true, force: true });
@@ -16052,12 +16276,15 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config)
 }
 async function mixThroughFloatSum(tracks, masterChain, outputPath, workDir, totalDuration, signal, config) {
   const sumPath = join14(workDir, "master-sum.wav");
+  const mixStart = Date.now();
   const sum = await mixAudioTracks(tracks, sumPath, totalDuration, signal, config);
   if (!sum.success) return { ...sum, outputPath };
+  const masterStart = Date.now();
   const encoderInput = masterChain ? (await applyAudioFxChain(sumPath, masterChain, join14(workDir, "master-fx.wav"), {
     trackId: "master",
     signal
   })).path : sumPath;
+  const encodeStart = Date.now();
   const encoded = await encodeAac(encoderInput, outputPath, totalDuration, {
     signal,
     timeout: config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout
@@ -16077,8 +16304,17 @@ async function mixThroughFloatSum(tracks, masterChain, outputPath, workDir, tota
       failures: [failure]
     };
   }
-  if (config?.keepEncoderInputAt) renameSync3(encoderInput, config.keepEncoderInputAt);
-  return { ...sum, outputPath, durationMs: sum.durationMs + encoded.durationMs };
+  if (config?.keepEncoderInputAt) renameWithRetry(encoderInput, config.keepEncoderInputAt);
+  return {
+    ...sum,
+    outputPath,
+    durationMs: sum.durationMs + encoded.durationMs,
+    phaseMs: {
+      mix: masterStart - mixStart,
+      master: encodeStart - masterStart,
+      encode: Date.now() - encodeStart
+    }
+  };
 }
 async function processCompositionAudio(elements, baseDir, workDir, outputPath, totalDuration, signal, config, compiledDir) {
   const startMs = Date.now();
@@ -16363,6 +16599,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       failures
     };
   };
+  const prepareMs = Date.now() - startMs;
   if (failures.length > 0) return bail();
   let masterChain;
   const masterFxJson = config?.masterFxChain;
@@ -16473,6 +16710,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
     }
   }
   if (failures.length > 0) return bail();
+  const groupsMs = Date.now() - startMs - prepareMs;
   let mixResult;
   try {
     mixResult = tracks.length > 0 ? await mixThroughFloatSum(
@@ -16491,6 +16729,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   return {
     ...mixResult,
     durationMs: Date.now() - startMs,
+    phaseMs: { prepare: prepareMs, groups: groupsMs, ...mixResult.phaseMs },
     // Both, when both degraded. `mixResult.error ?? degradedNote` reported only
     // the outer mix and dropped the one that names which GROUPS lost their
     // members' automation — two different losses, and the operator needs to
@@ -16502,18 +16741,18 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus as cpus3, freemem } from "os";
 import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
-import { copyFile, readFile as readFile2, rename } from "fs/promises";
+import { copyFile, readFile as readFile2 } from "fs/promises";
 import { join as join16 } from "path";
 import { getHeapStatistics } from "v8";
 
 // ../engine/src/utils/psnr.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join15 } from "path";
 import { promisify as promisify3 } from "util";
 async function psnrDb(a, b) {
-  const execFileP = promisify3(execFile3);
+  const execFileP = promisify3(execFile4);
   const dir = await mkdtemp(join15(tmpdir4(), "hf-de-verify-"));
   try {
     const pa = join15(dir, "a.jpg");
@@ -16766,7 +17005,7 @@ function shouldVerifyWorkerGpu(workerId, config) {
 }
 function withParallelWorkerDeadline(promise, diagnostic, timeoutMs, signal) {
   if (signal?.aborted) return Promise.reject(new Error("Parallel worker cancelled"));
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let timer;
     const cleanup = () => {
       if (timer) clearTimeout(timer);
@@ -16791,7 +17030,7 @@ function withParallelWorkerDeadline(promise, diagnostic, timeoutMs, signal) {
     promise.then(
       (value) => {
         cleanup();
-        resolve(value);
+        resolve2(value);
       },
       (error) => {
         cleanup();
@@ -17047,7 +17286,8 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
       endFrame: task.endFrame,
       frameStride: task.frameStride,
       durationMs: Date.now() - startTime,
-      perf
+      perf,
+      pageErrorLines: pageErrorLinesOf(activeSession)
     };
   } catch (error) {
     const diagnostics = session ? selectWorkerDiagnostics(session.browserConsoleBuffer) : [];
@@ -17060,7 +17300,8 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
     };
     const failure = classifyCaptureFailure(error, {
       signal,
-      workerDiagnostics: [workerDiagnostic]
+      workerDiagnostics: [workerDiagnostic],
+      pageErrorLines: session ? pageErrorLinesOf(session) : void 0
     });
     onFailure?.(failure);
     return {
@@ -17073,6 +17314,7 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
       perf,
       error: failure.message,
       diagnostics: diagnostics.length > 0 ? diagnostics : void 0,
+      pageErrorLines: session ? pageErrorLinesOf(session) : void 0,
       failure
     };
   } finally {
@@ -17089,6 +17331,9 @@ function isPoolFatalWorkerFailure(failure, streaming) {
   if (streaming) return failure.kind !== "cancelled";
   return isFatalCaptureFailure(failure);
 }
+function pageErrorLinesOf(session) {
+  return session.browserConsoleBuffer.filter((line) => line.includes("PAGEERROR"));
+}
 function createPoolFailureHandler(args) {
   let firstFatalFailure;
   return {
@@ -17180,7 +17425,8 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
       kind: representative?.kind ?? "io",
       message: `[Parallel] Capture failed: ${errorMessages}`,
       cause: representative,
-      workerDiagnostics
+      workerDiagnostics,
+      pageErrorLines: [...new Set(results.flatMap((result) => result.pageErrorLines ?? []))]
     });
   }
   return results;
@@ -17198,7 +17444,7 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
       const sourcePath = join16(task.outputDir, file);
       const targetPath = join16(outputDir, file);
       try {
-        await rename(sourcePath, targetPath);
+        await renameWithRetryAsync(sourcePath, targetPath);
       } catch {
         await copyFile(sourcePath, targetPath);
       }
@@ -17300,11 +17546,11 @@ function createFileServer(options) {
       headers: { "Content-Type": contentType }
     });
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const server = serve({ fetch: app.fetch, port }, (info) => {
       const actualPort = info.port;
       const url = `http://localhost:${actualPort}`;
-      resolve({
+      resolve2({
         url,
         port: actualPort,
         close: () => server.close()
@@ -17607,7 +17853,7 @@ async function launchHdrBrowser(width, height) {
     ...sigintLaunchOptions(),
     headless: false,
     executablePath: chromePath,
-    args: buildHdrChromeArgs(width, height)
+    args: withHyperframesBrowserMarker(buildHdrChromeArgs(width, height))
   });
   const page = await browser.newPage();
   await page.setViewport({ width, height });
@@ -17747,6 +17993,10 @@ export {
   describeFfmpegFailure,
   runFfmpeg,
   declareContentAddressedUrl,
+  declareProbeFactsUrl,
+  PROBE_FACTS_VERSION,
+  buildProbeFactsText,
+  resolvePlayableVideoDuration,
   probeMediaProfile,
   extractMediaMetadata,
   extractFinalVideoFrameTimestamp,
@@ -17785,6 +18035,8 @@ export {
   fetchPublicHttpsText,
   downloadToTemp,
   isHttpUrl,
+  renameWithRetry,
+  renameWithRetryAsync,
   directorySizeBytes,
   gcExtractionCache,
   VIDEO_FRAME_FORMATS,
@@ -17799,7 +18051,6 @@ export {
   parseVideoElements,
   parseImageElements,
   extractVideoFramesRange,
-  resolvePlayableVideoDuration,
   isVideoPastTimelineEnd,
   rebaseVideoToWindow,
   resolveTimelineExtractionWindow,
@@ -17828,6 +18079,7 @@ export {
   audioFailureDiagnostics,
   MIXED_AUDIO_FILENAME,
   parseMasterFxChain,
+  videoAudioId,
   parseAudioElements,
   processCompositionAudio,
   psnrDb,