hyperframes 0.8.191 → 0.8.193

package/dist/{chunk-NMDUSCCE.js → chunk-L4JB7LI4.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-GM3WIOO6.js";
+} from "./chunk-7HTH5PFK.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -63,7 +63,7 @@ import {
   sourceTimeAt,
   timeAtSourceTime,
   volumeSegmentSampleCount
-} from "./chunk-LM265QNK.js";
+} from "./chunk-USWPZXEA.js";
 import {
   clampAudioGain,
   clipGain,
@@ -83,7 +83,7 @@ import {
 } from "./chunk-4UMPIPCQ.js";
 import {
   resolveReferencedStart
-} from "./chunk-3NRB7YXW.js";
+} from "./chunk-2VXY3PEF.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
@@ -1477,6 +1477,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 +1533,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) {
@@ -4778,8 +4782,11 @@ async function sampleProcessRss(pids, exec = defaultExec(), platform = process.p
     if (platform === "win32") {
       const results = [];
       for (const pid of unique) {
-        const { stdout: stdout2 } = await exec("tasklist", ["/FO", "CSV", "/NH", "/FI", `PID eq ${pid}`]);
-        results.push(...parseTasklistCsv(pid, stdout2));
+        try {
+          const { stdout: stdout2 } = await exec("tasklist", ["/FO", "CSV", "/NH", "/FI", `PID eq ${pid}`]);
+          results.push(...parseTasklistCsv(pid, stdout2));
+        } catch {
+        }
       }
       return results;
     }
@@ -4795,6 +4802,7 @@ var CaptureFailure = class extends Error {
   kind;
   cause;
   workerDiagnostics;
+  pageErrorLines;
   constructor(input) {
     super(input.message);
     this.name = "CaptureFailure";
@@ -4805,6 +4813,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;
   }
 };
@@ -4890,32 +4899,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) {
@@ -5200,12 +5214,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) {
@@ -8544,6 +8560,7 @@ var videoMetadataCache = /* @__PURE__ */ new Map();
 var finalVideoFrameTimestampCache = /* @__PURE__ */ new Map();
 var finalVideoFrameTimestampSignalCaches = /* @__PURE__ */ new WeakMap();
 var audioMetadataCache = /* @__PURE__ */ new Map();
+var audioMetadataSignalCaches = /* @__PURE__ */ new WeakMap();
 var mediaProbeOutputCache = /* @__PURE__ */ new Map();
 var mediaProbeOutputSignalCaches = /* @__PURE__ */ new WeakMap();
 var MEDIA_PROBE_OUTPUT_CACHE_MAX_ENTRIES = 128;
@@ -8599,7 +8616,20 @@ function isPngImageProbe(output) {
     (stream) => stream.codec_type === "video" && stream.codec_name?.toLowerCase() === "png"
   );
 }
+var contentAddressedUrls = /* @__PURE__ */ new Map();
+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));
+    return sha256 ? `sha256:${sha256}` : null;
+  }
   try {
     const stat = statSync2(filePath, { bigint: true });
     return [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
@@ -8623,6 +8653,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((resolve) => {
+    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", () => resolve(void 0));
+    proc.on("close", () => resolve(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) {
@@ -8638,11 +8737,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) {
@@ -8898,6 +8993,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,
@@ -8913,6 +9045,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)}`
@@ -8951,44 +9086,51 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
 var extractVideoMetadata = extractMediaMetadata;
 async function extractAudioMetadata(filePath, options) {
   const identity = mediaFileIdentity(filePath);
-  const cached = options?.signal ? void 0 : readMetadataCache(audioMetadataCache, filePath, identity);
+  const signal = options?.signal;
+  if (signal && identity === null) return probeAudioMetadata(filePath, signal);
+  let cache = audioMetadataCache;
+  if (signal) {
+    cache = audioMetadataSignalCaches.get(signal) ?? /* @__PURE__ */ new Map();
+    audioMetadataSignalCaches.set(signal, cache);
+  }
+  const cached = readMetadataCache(cache, filePath, identity);
   if (cached) return cached;
-  const probePromise = (async () => {
-    const output = await probeMediaOutput(filePath, options?.signal);
-    const audioStream = output.streams.find((s) => s.codec_type === "audio");
-    if (!audioStream) throw new Error("[FFmpeg] No audio stream found");
-    let durationSeconds = output.format.duration ? parseFloat(output.format.duration) : 0;
-    const streamDuration = audioStream.duration ? parseFloat(audioStream.duration) : void 0;
-    const sampleRate = audioStream.sample_rate ? parseInt(audioStream.sample_rate) : 44100;
-    const audioCodec = audioStream.codec_name || "unknown";
-    if (sampleRate > 0) {
-      const decoded = await probeDecodedAudioDuration(
-        filePath,
-        sampleRate,
-        audioStartSeconds(audioStream, output.format),
-        durationSeconds,
-        options?.signal
-      );
-      if (decoded !== null) {
-        durationSeconds = reconcileAudioDuration(durationSeconds, decoded, output.format);
-      }
-    }
-    return {
-      durationSeconds,
-      streamDurationSeconds: streamDuration && streamDuration > 0 ? streamDuration : void 0,
-      sampleRate,
-      channels: audioStream.channels || 2,
-      audioCodec,
-      bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0,
-      latestStreamLeadSeconds: latestStreamLeadSeconds(output),
-      audioStreamLeadSeconds: streamLeadSeconds(output, audioStream),
-      audioStreamCount: output.streams.filter((s) => s.codec_type === "audio").length
-    };
-  })();
-  if (options?.signal) return probePromise;
-  writeMetadataCache(audioMetadataCache, filePath, identity, probePromise);
+  const probePromise = probeAudioMetadata(filePath, signal);
+  writeMetadataCache(cache, filePath, identity, probePromise);
   return probePromise;
 }
+async function probeAudioMetadata(filePath, signal) {
+  const output = await probeMediaOutput(filePath, signal);
+  const audioStream = output.streams.find((s) => s.codec_type === "audio");
+  if (!audioStream) throw new Error("[FFmpeg] No audio stream found");
+  let durationSeconds = output.format.duration ? parseFloat(output.format.duration) : 0;
+  const streamDuration = audioStream.duration ? parseFloat(audioStream.duration) : void 0;
+  const sampleRate = audioStream.sample_rate ? parseInt(audioStream.sample_rate) : 44100;
+  const audioCodec = audioStream.codec_name || "unknown";
+  if (sampleRate > 0) {
+    const decoded = await probeDecodedAudioDuration(
+      filePath,
+      sampleRate,
+      audioStartSeconds(audioStream, output.format),
+      durationSeconds,
+      signal
+    );
+    if (decoded !== null) {
+      durationSeconds = reconcileAudioDuration(durationSeconds, decoded, output.format);
+    }
+  }
+  return {
+    durationSeconds,
+    streamDurationSeconds: streamDuration && streamDuration > 0 ? streamDuration : void 0,
+    sampleRate,
+    channels: audioStream.channels || 2,
+    audioCodec,
+    bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0,
+    latestStreamLeadSeconds: latestStreamLeadSeconds(output),
+    audioStreamLeadSeconds: streamLeadSeconds(output, audioStream),
+    audioStreamCount: output.streams.filter((s) => s.codec_type === "audio").length
+  };
+}
 function audioVideoStreamStarts(output) {
   return (output?.streams ?? []).filter(
     (s) => (s.codec_type === "audio" || s.codec_type === "video") && s.disposition?.attached_pic !== 1
@@ -9124,8 +9266,10 @@ async function analyzeKeyframeIntervalsUncached(filePath, videoStreamStartSecond
 
 // ../engine/src/services/softwareEncoderThreads.ts
 import { availableParallelism } from "os";
-function appendSoftwareEncoderThreadsArg(args, parallelism = availableParallelism()) {
-  args.push("-threads", String(Math.max(1, Math.floor(parallelism))));
+var X265_MAX_THREADS = 16;
+function appendSoftwareEncoderThreadsArg(args, encoder, parallelism = availableParallelism()) {
+  const cap = encoder === "libx265" ? X265_MAX_THREADS : Infinity;
+  args.push("-threads", String(Math.min(cap, Math.max(1, Math.floor(parallelism)))));
 }
 
 // ../engine/src/utils/renderProvenance.ts
@@ -9352,7 +9496,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
-      appendSoftwareEncoderThreadsArg(args);
+      appendSoftwareEncoderThreadsArg(args, encoderName);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const gop = resolveLockedGopSize(options);
@@ -10057,7 +10201,7 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
     } else {
       const encoderName = codec === "h264" ? "libx264" : "libx265";
       args.push("-c:v", encoderName, "-preset", preset);
-      appendSoftwareEncoderThreadsArg(args);
+      appendSoftwareEncoderThreadsArg(args, encoderName);
       if (bitrate) args.push("-b:v", bitrate);
       else args.push("-crf", String(quality));
       const lockedGop = resolveLockedGopSize(options);
@@ -11481,7 +11625,7 @@ function getSingleMeaningfulChild(container) {
 }
 function unwrapTemplate(html) {
   const lowered = html.toLowerCase();
-  if (!lowered.includes("<template") || !lowered.includes("</template>")) {
+  if (!lowered.includes("<template") || !/<\/template[ \t\n\r\f]*>/.test(lowered)) {
     return html;
   }
   const { body } = parseHTMLContent(html);
@@ -11506,12 +11650,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((resolve) => setTimeout(resolve, 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";
@@ -11575,7 +11759,7 @@ function isTargetExistsRenameError(err) {
   return code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM";
 }
 function adoptPublishedWinner(entry, partialDir) {
-  if (!existsSync8(join9(entry.dir, COMPLETE_SENTINEL))) return null;
+  if (!existsSync8(join9(entry.dir, COMPLETE_SENTINEL)) || !hasFrameFiles(entry.dir)) return null;
   removeDir(partialDir);
   return { dir: entry.dir, published: true };
 }
@@ -11586,7 +11770,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 };
@@ -11599,7 +11783,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 };
@@ -11784,6 +11968,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;
@@ -12158,6 +12360,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) {
@@ -12171,7 +12375,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;
@@ -12182,7 +12386,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,
@@ -12333,6 +12537,7 @@ async function extractVideoFramesRangeUnredacted(videoPath, videoId, startTime,
     videoPath,
     startTime,
     fps,
+    gate: options.tailProbe ? inTailProbeSlot : inExtractionSlot,
     segments: splitFrameRanges(
       options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }],
       segmentFrames
@@ -12433,9 +12638,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;
@@ -13114,23 +13316,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 {
@@ -13148,6 +13334,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 {
@@ -14026,16 +14251,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
@@ -14154,6 +14370,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;
@@ -14189,12 +14406,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((resolve) => {
+      execFile3(binary, ["-hide_banner", "-h", "bsf=setts"], (error, stdout) => {
+        resolve(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) => ({
@@ -14360,7 +14600,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
@@ -14490,7 +14730,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;
@@ -15269,6 +15509,7 @@ function legacyFilterScriptOptionIsUnsupported(stderr) {
   return /filter_complex_script/i.test(stderr) && /(?:unrecognized option|option (?:was )?not found)/i.test(stderr);
 }
 var inPrepareSlot = createConcurrencyLimit(Math.max(2, Math.floor(cpus2().length / 2)));
+var inRemotePrepareSlot = createConcurrencyLimit(16);
 var MAX_VOLUME_SEGMENTS = 32;
 var VOLUME_SIMPLIFY_EPSILON = 5e-3;
 var STEREO_CHANNEL_FILTER = "pan=stereo|FL=FL+FC|FR=FR+FC";
@@ -15485,8 +15726,11 @@ function parseAudioElements(html) {
   const startCache = /* @__PURE__ */ new Map();
   const visiting = /* @__PURE__ */ new Set();
   const resolveStart = (el) => el.getAttribute("data-start") ? resolveReferencedStart(document2, el, startCache, visiting) : 0;
-  const parseEnd = (raw) => {
-    return parseStrictFiniteTimingNumber(raw) ?? 0;
+  const resolveEnd = (el) => {
+    const end = parseStrictFiniteTimingNumber(el.getAttribute("data-end"));
+    if (end != null) return end;
+    const duration = parseStrictFiniteTimingNumber(el.getAttribute("data-duration"));
+    return duration != null && duration > 0 ? resolveStart(el) + duration : 0;
   };
   const isHidden = isSelfOrAncestorHidden;
   const groupsById = new Map(
@@ -15505,9 +15749,10 @@ function parseAudioElements(html) {
       id,
       src,
       start: resolveStart(el),
-      end: parseEnd(el.getAttribute("data-end")),
+      end: resolveEnd(el),
       mediaStart: readMediaStart(el),
       playbackRate: readElementRateSpec(el),
+      loop: el.getAttribute("loop") !== null,
       layer: layerAttr ? parseInt(layerAttr) : 0,
       volume: volumeAttr ? parseFloat(volumeAttr) : 1,
       ...fades.fadeIn > 0 ? { fadeIn: fades.fadeIn } : {},
@@ -15543,7 +15788,7 @@ function parseAudioElements(html) {
 }
 var FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE = ["-xerror"];
 var SIDECAR_WARM_UP_SECONDS = 1;
-async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config, audioSidecarUrl) {
+async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config, audioSidecarUrl, options) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
   if (!existsSync11(outputDir)) mkdirSync7(outputDir, { recursive: true });
@@ -15553,7 +15798,62 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
   const metadata = readsUrl ? await extractAudioMetadata(srcPath, { signal }).catch((error) => {
     if (signal?.aborted) throw error;
     return extractAudioMetadata(srcPath, { signal });
-  }) : await extractAudioMetadata(srcPath).catch(() => null);
+  }) : await extractAudioMetadata(srcPath).catch((error) => {
+    if (options?.loop) throw error;
+    return null;
+  });
+  const loopDuration = (metadata?.durationSeconds ?? 0) - mediaStart;
+  if (options?.loop && loopDuration > 0 && sourceDuration > loopDuration) {
+    const cycleDir = mkdtempSync7(join14(outputDir, ".audio-loop-"));
+    const cyclePath = join14(cycleDir, "cycle.wav");
+    try {
+      const cycle = await extractAudioSegment(
+        srcPath,
+        cyclePath,
+        stage,
+        mediaStart,
+        loopDuration,
+        1,
+        signal,
+        config,
+        audioSidecarUrl,
+        { padToDuration: true }
+      );
+      if (!cycle.success) return { ...cycle, outputPath };
+      const outputArgs2 = preparedAudioOutputArgs(metadata, normalizedPlaybackRate, duration, null);
+      const result2 = await runFfmpeg(
+        [
+          "-stream_loop",
+          "-1",
+          "-t",
+          String(sourceDuration),
+          "-i",
+          cyclePath,
+          "-vn",
+          "-acodec",
+          "pcm_s16le",
+          "-ar",
+          "48000",
+          ...outputArgs2,
+          "-t",
+          String(duration),
+          "-y",
+          outputPath
+        ],
+        { signal, timeout: ffmpegProcessTimeout }
+      );
+      const failure2 = result2.success ? void 0 : ffmpegFailure(stage, result2, ffmpegProcessTimeout);
+      return {
+        success: result2.success,
+        outputPath,
+        durationMs: cycle.durationMs + result2.durationMs,
+        error: failure2?.detail,
+        failure: failure2
+      };
+    } finally {
+      rmSync8(cycleDir, { recursive: true, force: true });
+    }
+  }
   const inputSeek = mediaStart >= (metadata?.latestStreamLeadSeconds ?? 0);
   const start = formatFilterNumber(mediaStart);
   const timestampTrim = inputSeek ? null : `atrim=start=${start}:end=${formatFilterNumber(mediaStart + sourceDuration)},asetpts=PTS-${start}/TB,aresample=async=1:first_pts=0`;
@@ -15563,7 +15863,10 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
     metadata,
     normalizedPlaybackRate,
     duration,
-    warmUp > 0 ? `atrim=start=${warmUp},asetpts=PTS-STARTPTS` : timestampTrim
+    [
+      warmUp > 0 ? `atrim=start=${warmUp},asetpts=PTS-STARTPTS` : timestampTrim,
+      ...options?.padToDuration ? ["apad"] : []
+    ].filter(Boolean).join(",") || null
   );
   const readFrom = fromSidecar ? audioSidecarUrl : srcPath;
   const args = [
@@ -15574,7 +15877,7 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
     readFrom
   ];
   args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
-  if (normalizedPlaybackRate !== 1) args.push("-t", String(duration));
+  if (normalizedPlaybackRate !== 1 || options?.padToDuration) args.push("-t", String(duration));
   args.push("-y", outputPath);
   const result = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
   if (signal?.aborted) {
@@ -15606,6 +15909,17 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
     failure
   };
 }
+function isRemoteElement(element, baseDir, compiledDir, config) {
+  if (isHttpUrl(element.src)) return true;
+  if (!config?.urlByAbsentLocalPath?.size) return false;
+  try {
+    return config.urlByAbsentLocalPath.has(
+      resolveProjectRelativeSrc(element.src, baseDir, compiledDir)
+    );
+  } catch {
+    return false;
+  }
+}
 async function generateSilence(outputPath, duration, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
@@ -15914,7 +16228,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 });
@@ -15956,12 +16270,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
@@ -15981,8 +16298,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();
@@ -16000,7 +16326,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   }
   await Promise.all(
     elements.map(
-      (element, index) => inPrepareSlot(async () => {
+      (element, index) => (isRemoteElement(element, baseDir, compiledDir, config) ? inRemotePrepareSlot : inPrepareSlot)(async () => {
         if (effectiveSignal.aborted) {
           failures.push({
             stage: "cancelled",
@@ -16069,6 +16395,9 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
           if (element.end - element.start <= 0) {
+            console.warn(
+              `[audioMixer] ${element.id} has no data-duration or data-end; its length is unknown, so it plays to the end of its source`
+            );
             let metadata;
             try {
               metadata = await extractAudioMetadata(
@@ -16099,7 +16428,8 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
               element.playbackRate,
               effectiveSignal,
               config,
-              audioSidecarUrl
+              audioSidecarUrl,
+              { loop: element.loop }
             );
             if (!extractResult.success) {
               failures.push(
@@ -16125,7 +16455,9 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
               element.end - element.start,
               element.playbackRate,
               effectiveSignal,
-              config
+              config,
+              void 0,
+              { loop: element.loop }
             );
             if (!prepResult.success) {
               failures.push(
@@ -16261,6 +16593,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;
@@ -16371,6 +16704,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(
@@ -16389,6 +16723,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
@@ -16400,18 +16735,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");
@@ -16945,7 +17280,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) : [];
@@ -16958,7 +17294,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 {
@@ -16971,6 +17308,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 {
@@ -16987,6 +17325,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 {
@@ -17078,7 +17419,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;
@@ -17096,7 +17438,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);
       }
@@ -17644,6 +17986,11 @@ export {
   formatFfmpegError,
   describeFfmpegFailure,
   runFfmpeg,
+  declareContentAddressedUrl,
+  declareProbeFactsUrl,
+  PROBE_FACTS_VERSION,
+  buildProbeFactsText,
+  resolvePlayableVideoDuration,
   probeMediaProfile,
   extractMediaMetadata,
   extractFinalVideoFrameTimestamp,
@@ -17682,6 +18029,8 @@ export {
   fetchPublicHttpsText,
   downloadToTemp,
   isHttpUrl,
+  renameWithRetry,
+  renameWithRetryAsync,
   directorySizeBytes,
   gcExtractionCache,
   VIDEO_FRAME_FORMATS,
@@ -17696,8 +18045,8 @@ export {
   parseVideoElements,
   parseImageElements,
   extractVideoFramesRange,
-  resolvePlayableVideoDuration,
   isVideoPastTimelineEnd,
+  rebaseVideoToWindow,
   resolveTimelineExtractionWindow,
   resolveFinalFrameExtractionWindow,
   resolveVideoExtractionWindow,