hyperframes 0.8.192 → 0.8.193

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

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-MGBUWPXX.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-B2XLXD7V.js";
+} from "./chunk-USWPZXEA.js";
 import {
   clampAudioGain,
   clipGain,
@@ -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) {
@@ -4798,6 +4802,7 @@ var CaptureFailure = class extends Error {
   kind;
   cause;
   workerDiagnostics;
+  pageErrorLines;
   constructor(input) {
     super(input.message);
     this.name = "CaptureFailure";
@@ -4808,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;
   }
 };
@@ -4893,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) {
@@ -5203,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) {
@@ -8608,6 +8621,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 +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) {
@@ -8651,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) {
@@ -8911,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,
@@ -8926,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)}`
@@ -11528,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";
@@ -11608,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 };
@@ -11621,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 };
@@ -11806,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;
@@ -12180,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) {
@@ -12193,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;
@@ -12204,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,
@@ -12355,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
@@ -12455,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;
@@ -13136,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 {
@@ -13170,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 {
@@ -14048,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
@@ -14176,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;
@@ -14211,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) => ({
@@ -14382,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
@@ -14512,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;
@@ -16010,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 });
@@ -16052,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
@@ -16077,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();
@@ -16363,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;
@@ -16473,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(
@@ -16491,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
@@ -16502,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");
@@ -17047,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) : [];
@@ -17060,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 {
@@ -17073,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 {
@@ -17089,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 {
@@ -17180,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;
@@ -17198,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);
       }
@@ -17747,6 +17987,10 @@ export {
   describeFfmpegFailure,
   runFfmpeg,
   declareContentAddressedUrl,
+  declareProbeFactsUrl,
+  PROBE_FACTS_VERSION,
+  buildProbeFactsText,
+  resolvePlayableVideoDuration,
   probeMediaProfile,
   extractMediaMetadata,
   extractFinalVideoFrameTimestamp,
@@ -17785,6 +18029,8 @@ export {
   fetchPublicHttpsText,
   downloadToTemp,
   isHttpUrl,
+  renameWithRetry,
+  renameWithRetryAsync,
   directorySizeBytes,
   gcExtractionCache,
   VIDEO_FRAME_FORMATS,
@@ -17799,7 +18045,6 @@ export {
   parseVideoElements,
   parseImageElements,
   extractVideoFramesRange,
-  resolvePlayableVideoDuration,
   isVideoPastTimelineEnd,
   rebaseVideoToWindow,
   resolveTimelineExtractionWindow,