hyperframes 0.7.43 → 0.7.44

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.7.43" : "0.0.0-dev";
+    VERSION = true ? "0.7.44" : "0.0.0-dev";
   }
 });
 
@@ -62953,6 +62953,7 @@ async function createCaptureSession(serverUrl, outputDir, options, onBeforeCaptu
     onBeforeCapture,
     isInitialized: false,
     browserConsoleBuffer: [],
+    scriptLoadFailures: [],
     capturePerf: {
       frames: 0,
       seekMs: 0,
@@ -62993,15 +62994,6 @@ function formatConsoleDiagnostic(type, text2, locationUrl) {
   const prefix = isResourceLoadError ? "[non-blocking]" : type === "error" ? "[Browser:ERROR]" : type === "warn" ? "[Browser:WARN]" : "[Browser]";
   return { text: `${prefix} ${text2}`, suppressHostLog: false };
 }
-async function pollPageExpression(page, expression, timeoutMs, intervalMs = 100) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const ready = Boolean(await page.evaluate(expression));
-    if (ready) return true;
-    await new Promise((resolve62) => setTimeout(resolve62, intervalMs));
-  }
-  return Boolean(await page.evaluate(expression));
-}
 function buildZeroDurationDiagnostic(diag) {
   const hints = [];
   if (!diag.hasPlayer) {
@@ -63058,7 +63050,7 @@ async function pollHfReady(page, timeoutMs, intervalMs = 100) {
   State: __hf=${diag.hasHf}, seek=${diag.hasSeek}, player=${diag.hasPlayer}, renderReady=${diag.renderReady}, duration=${diag.duration}`
   );
 }
-async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150) {
+async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2e3) {
   const expression = `(function() {
     var hosts = document.querySelectorAll("[data-composition-id]");
     if (hosts.length === 0) return true;
@@ -63071,30 +63063,52 @@ async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150) {
     }
     return true;
   })()`;
-  const ready = await pollPageExpression(page, expression, timeoutMs, intervalMs);
+  const start = Date.now();
+  const deadline = start + timeoutMs;
+  let ready = false;
+  let scriptFailureBail = false;
+  for (; ; ) {
+    ready = Boolean(await page.evaluate(expression));
+    if (ready) break;
+    const now = Date.now();
+    if (now >= deadline) break;
+    const failures = getScriptLoadFailures?.() ?? [];
+    if (failures.length > 0 && now - start >= scriptFailureGraceMs) {
+      scriptFailureBail = true;
+      console.warn(
+        `[FrameCapture] Sub-composition timeline wait cut short after ${now - start}ms: script resource(s) failed to load (${failures.join(", ")}) \u2014 the timeline registration they carry can never arrive. Fix the script reference; the render proceeds without those animations.`
+      );
+      break;
+    }
+    await new Promise((resolve62) => setTimeout(resolve62, intervalMs));
+  }
   if (ready) {
     await page.evaluate(`(function() {
       if (typeof window.__hfForceTimelineRebind === "function") {
         window.__hfForceTimelineRebind();
       }
     })()`);
+    return "ready";
   }
-  if (!ready) {
-    const missing = await page.evaluate(`(function() {
-      var hosts = document.querySelectorAll("[data-composition-id]");
-      var timelines = window.__timelines || {};
-      var m = [];
-      for (var i = 0; i < hosts.length; i++) {
-        if (hosts[i].hasAttribute("data-no-timeline")) continue;
-        var id = hosts[i].getAttribute("data-composition-id");
-        if (id && !timelines[id]) m.push(id);
-      }
-      return m.join(", ");
-    })()`);
+  const missing = await page.evaluate(`(function() {
+    var hosts = document.querySelectorAll("[data-composition-id]");
+    var timelines = window.__timelines || {};
+    var m = [];
+    for (var i = 0; i < hosts.length; i++) {
+      if (hosts[i].hasAttribute("data-no-timeline")) continue;
+      var id = hosts[i].getAttribute("data-composition-id");
+      if (id && !timelines[id]) m.push(id);
+    }
+    return m.join(", ");
+  })()`);
+  if (scriptFailureBail) {
+    console.warn(`[FrameCapture] Composition(s) still waiting on the failed script: ${missing}.`);
+  } else {
     console.warn(
       `[FrameCapture] Sub-composition timelines not registered after ${timeoutMs}ms: ${missing}. Compositions that load data asynchronously (e.g. fetch) must register window.__timelines[id] after setup completes. Compositions intentionally driven without GSAP timelines (CSS animations / rAF) can mark the host with data-no-timeline to skip this wait.`
     );
   }
+  return scriptFailureBail ? "script_failure" : "timeout";
 }
 async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
   const check = async () => {
@@ -63193,6 +63207,11 @@ async function waitForOptionalTailwindReady(page, timeoutMs) {
     );
   }
 }
+function recordScriptLoadFailure(session, url) {
+  if (!session.scriptLoadFailures.includes(url)) {
+    session.scriptLoadFailures.push(url);
+  }
+}
 async function initializeSession(session) {
   const { page, serverUrl } = session;
   page.on("console", (msg) => {
@@ -63213,6 +63232,9 @@ async function initializeSession(session) {
     appendBrowserDiagnostic(session, text2);
   });
   page.on("requestfailed", (request) => {
+    if (request.resourceType() === "script") {
+      recordScriptLoadFailure(session, request.url());
+    }
     appendBrowserDiagnostic(
       session,
       formatRequestFailureDiagnostic({
@@ -63227,6 +63249,9 @@ async function initializeSession(session) {
     const status = response.status();
     if (status < 400) return;
     const request = response.request();
+    if (request.resourceType() === "script") {
+      recordScriptLoadFailure(session, response.url());
+    }
     appendBrowserDiagnostic(
       session,
       formatHttpErrorDiagnostic({
@@ -63278,8 +63303,13 @@ async function initializeSession(session) {
     const pageReadyTimeout2 = session.config?.playerReadyTimeout ?? DEFAULT_CONFIG2.playerReadyTimeout;
     await pollHfReady(page, pageReadyTimeout2);
     logInitPhase("pollHfReady complete");
-    await pollSubCompositionTimelines(page, pageReadyTimeout2);
-    logInitPhase("pollSubCompositionTimelines complete");
+    session.subTimelineWaitOutcome = await pollSubCompositionTimelines(
+      page,
+      pageReadyTimeout2,
+      void 0,
+      () => session.scriptLoadFailures
+    );
+    logInitPhase(`pollSubCompositionTimelines complete (${session.subTimelineWaitOutcome})`);
     await applyVideoMetadataHints(page, session.options.videoMetadataHints);
     logInitPhase("applyVideoMetadataHints complete");
     const skipVideoIds = session.options.skipReadinessVideoIds ?? [];
@@ -63371,8 +63401,13 @@ async function initializeSession(session) {
     warmupState.running = false;
     throw err;
   }
-  await pollSubCompositionTimelines(page, pageReadyTimeout);
-  logInitPhase("pollSubCompositionTimelines complete");
+  session.subTimelineWaitOutcome = await pollSubCompositionTimelines(
+    page,
+    pageReadyTimeout,
+    void 0,
+    () => session.scriptLoadFailures
+  );
+  logInitPhase(`pollSubCompositionTimelines complete (${session.subTimelineWaitOutcome})`);
   await applyVideoMetadataHints(page, session.options.videoMetadataHints);
   logInitPhase("applyVideoMetadataHints complete");
   const bfSkipVideoIds = session.options.skipReadinessVideoIds ?? [];
@@ -63899,9 +63934,20 @@ async function captureFrameToBufferPipelined(session, frameIndex, time) {
   const { page, options } = session;
   const startTime = Date.now();
   if (session.staticFrames?.has(frameIndex) && session.lastEncodeResult) {
-    session.staticDedupCount = (session.staticDedupCount ?? 0) + 1;
-    session.capturePerf.frames += 1;
-    return { encodeResult: session.lastEncodeResult, captureTimeMs: Date.now() - startTime };
+    const lastIdx = session.lastEncodeResultFrame ?? frameIndex - 1;
+    let gapStatic = true;
+    for (let j3 = lastIdx + 1; j3 <= frameIndex; j3++) {
+      if (!session.staticFrames.has(j3)) {
+        gapStatic = false;
+        break;
+      }
+    }
+    if (gapStatic) {
+      session.staticDedupCount = (session.staticDedupCount ?? 0) + 1;
+      session.capturePerf.frames += 1;
+      session.lastEncodeResultFrame = frameIndex;
+      return { encodeResult: session.lastEncodeResult, captureTimeMs: Date.now() - startTime };
+    }
   }
   try {
     const { quantizedTime, seekMs, beforeCaptureMs } = await prepareFrameForCapture(
@@ -63921,7 +63967,10 @@ async function captureFrameToBufferPipelined(session, frameIndex, time) {
         session.capturePerf.frameMs.push(boundaryMs);
       }
       const boundaryResult = Promise.resolve(buffer);
-      if (session.staticFrames) session.lastEncodeResult = boundaryResult;
+      if (session.staticFrames) {
+        session.lastEncodeResult = boundaryResult;
+        session.lastEncodeResultFrame = frameIndex;
+      }
       return { encodeResult: boundaryResult, captureTimeMs: Date.now() - startTime };
     }
     const { encodeResult } = await produceDrawElementFrame(
@@ -63938,7 +63987,10 @@ async function captureFrameToBufferPipelined(session, frameIndex, time) {
     session.capturePerf.screenshotMs += captureTimeMs - seekMs - beforeCaptureMs;
     session.capturePerf.totalMs += captureTimeMs;
     session.capturePerf.frameMs.push(captureTimeMs);
-    if (session.staticFrames) session.lastEncodeResult = encodeResult;
+    if (session.staticFrames) {
+      session.lastEncodeResult = encodeResult;
+      session.lastEncodeResultFrame = frameIndex;
+    }
     return { encodeResult, captureTimeMs };
   } catch (captureError) {
     if (isNoCachedPaintRecordError(captureError)) {
@@ -64164,6 +64216,7 @@ function getCapturePerfSummary(session) {
     avgBeforeCaptureMs: Math.round(session.capturePerf.beforeCaptureMs / frames),
     avgScreenshotMs: Math.round(session.capturePerf.screenshotMs / frames),
     p50TotalMs: medianOf(session.capturePerf.frameMs),
+    subTimelineWaitOutcome: session.subTimelineWaitOutcome,
     staticDedupReused: session.staticDedupCount ?? 0,
     staticDedupEnabled: session.staticDedupEnabled ?? false,
     // armed ⟺ a non-empty static set survived verification; predicted === its size.
@@ -65634,40 +65687,57 @@ import { existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSyn
 import { dirname as dirname5 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
+  let aborted = null;
   const pending = /* @__PURE__ */ new Map();
-  const enqueueAt = (frame, resolve62) => {
+  const enqueueAt = (frame, resolve62, reject) => {
     const list = pending.get(frame);
     if (list === void 0) {
-      pending.set(frame, [resolve62]);
+      pending.set(frame, [{ resolve: resolve62, reject }]);
     } else {
-      list.push(resolve62);
+      list.push({ resolve: resolve62, reject });
     }
   };
   const flushAt = (frame) => {
     const list = pending.get(frame);
     if (list === void 0) return;
     pending.delete(frame);
-    for (const resolve62 of list) resolve62();
+    for (const waiter of list) waiter.resolve();
   };
-  const waitForFrame = (frame) => new Promise((resolve62) => {
+  const waitForFrame = (frame) => new Promise((resolve62, reject) => {
+    if (aborted) {
+      reject(aborted);
+      return;
+    }
     if (frame === cursor) {
       resolve62();
       return;
     }
-    enqueueAt(frame, resolve62);
+    enqueueAt(frame, resolve62, reject);
   });
   const advanceTo = (frame) => {
     cursor = frame;
     flushAt(frame);
   };
-  const waitForAllDone = () => new Promise((resolve62) => {
+  const waitForAllDone = () => new Promise((resolve62, reject) => {
+    if (aborted) {
+      reject(aborted);
+      return;
+    }
     if (cursor >= endFrame) {
       resolve62();
       return;
     }
-    enqueueAt(endFrame, resolve62);
+    enqueueAt(endFrame, resolve62, reject);
   });
-  return { waitForFrame, advanceTo, waitForAllDone };
+  const abort = (err) => {
+    if (aborted) return;
+    aborted = err;
+    for (const [frame, list] of pending) {
+      pending.delete(frame);
+      for (const waiter of list) waiter.reject(err);
+    }
+  };
+  return { waitForFrame, advanceTo, waitForAllDone, abort };
 }
 function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
   const {
@@ -76185,19 +76255,79 @@ function distributeFrames(totalFrames, workerCount, workDir, rangeStart = 0) {
   }
   return tasks;
 }
+function distributeFramesInterleaved(totalFrames, workerCount, workDir, rangeStart = 0) {
+  const tasks = [];
+  for (let i2 = 0; i2 < workerCount && i2 < totalFrames; i2++) {
+    tasks.push({
+      workerId: i2,
+      startFrame: rangeStart + i2,
+      endFrame: rangeStart + totalFrames,
+      frameStride: workerCount,
+      outputDir: join15(workDir, `worker-${i2}`),
+      outputFrameOffset: rangeStart
+    });
+  }
+  return tasks;
+}
 function shouldVerifyWorkerGpu(workerId, config) {
   return config?.browserGpuMode === "software" && workerId === 0;
 }
 async function captureFrameRange(session, task, captureOptions, signal, onFrameCaptured, onFrameBuffer) {
   let framesCaptured = 0;
   const outputOffset = task.outputFrameOffset ?? 0;
-  for (let i2 = task.startFrame; i2 < task.endFrame; i2++) {
+  const stride = task.frameStride ?? 1;
+  if (onFrameBuffer && session.workerEncodeEnabled) {
+    const dbg = process.env.HF_DE_PAR_DEBUG === "1";
+    const dbgT0 = Date.now();
+    const dbgWin = 40 * stride;
+    let prev = null;
+    for (let i2 = task.startFrame; i2 < task.endFrame; i2 += stride) {
+      if (signal?.aborted) throw new Error("Parallel worker cancelled");
+      const time = i2 * captureOptions.fps.den / captureOptions.fps.num;
+      if (dbg && i2 < task.startFrame + dbgWin) {
+        console.log(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms produce ${i2} start`);
+      }
+      const { encodeResult } = await captureFrameToBufferPipelined(session, i2 - outputOffset, time);
+      encodeResult.catch(() => {
+      });
+      if (dbg && i2 < task.startFrame + dbgWin) {
+        console.log(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms produce ${i2} kicked`);
+      }
+      if (prev) {
+        if (dbg && prev.idx < task.startFrame + dbgWin) {
+          console.log(
+            `[par:w${task.workerId}] +${Date.now() - dbgT0}ms drain ${prev.idx} await-encode`
+          );
+        }
+        const buf = await prev.encodeResult;
+        if (dbg && prev.idx < task.startFrame + dbgWin) {
+          console.log(
+            `[par:w${task.workerId}] +${Date.now() - dbgT0}ms drain ${prev.idx} encoded ${buf.length}B`
+          );
+        }
+        await onFrameBuffer(prev.idx, buf, session);
+        if (dbg && prev.idx < task.startFrame + dbgWin) {
+          console.log(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms drain ${prev.idx} written`);
+        }
+        framesCaptured++;
+        if (onFrameCaptured) onFrameCaptured(task.workerId, prev.idx);
+      }
+      prev = { idx: i2, encodeResult };
+    }
+    if (prev) {
+      await onFrameBuffer(prev.idx, await prev.encodeResult, session);
+      framesCaptured++;
+      if (onFrameCaptured) onFrameCaptured(task.workerId, prev.idx);
+    }
+    return framesCaptured;
+  }
+  for (let i2 = task.startFrame; i2 < task.endFrame; i2 += stride) {
     if (signal?.aborted) throw new Error("Parallel worker cancelled");
     const time = i2 * captureOptions.fps.den / captureOptions.fps.num;
     const fileFrameIdx = i2 - outputOffset;
     if (onFrameBuffer) {
       const { buffer } = await captureFrameToBuffer(session, fileFrameIdx, time);
-      await onFrameBuffer(i2, buffer);
+      await onFrameBuffer(i2, buffer, session);
     } else {
       await captureFrame(session, fileFrameIdx, time);
     }
@@ -76228,10 +76358,18 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
       createBeforeCaptureHook(),
       workerConfig
     );
+    if (process.env.HF_DE_PAR_DEBUG === "1") {
+      console.log(`[par:w${task.workerId}] session created`);
+    }
     if (shouldVerifyWorkerGpu(task.workerId, workerConfig)) {
       await assertSwiftShader(session.page, readWebGlVendorInfoFromCanvas);
     }
     await initializeSession(session);
+    if (process.env.HF_DE_PAR_DEBUG === "1") {
+      console.log(
+        `[par:w${task.workerId}] init done (mode=${session.captureMode} workerEncode=${session.workerEncodeEnabled === true})`
+      );
+    }
     framesCaptured = await captureFrameRange(
       session,
       task,
@@ -76268,7 +76406,10 @@ async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCa
   }
 }
 async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions, createBeforeCaptureHook, signal, onProgress, onFrameBuffer, config) {
-  const totalFrames = tasks.reduce((sum, t2) => sum + (t2.endFrame - t2.startFrame), 0);
+  const totalFrames = tasks.reduce(
+    (sum, t2) => sum + Math.ceil((t2.endFrame - t2.startFrame) / (t2.frameStride ?? 1)),
+    0
+  );
   const workerProgress = /* @__PURE__ */ new Map();
   for (const task of tasks) workerProgress.set(task.workerId, 0);
   const onFrameCaptured = (workerId, _frameIndex) => {
@@ -77960,6 +78101,7 @@ __export(src_exports, {
   detectTransfer: () => detectTransfer,
   discardWarmupCapture: () => discardWarmupCapture,
   distributeFrames: () => distributeFrames,
+  distributeFramesInterleaved: () => distributeFramesInterleaved,
   downloadToTemp: () => downloadToTemp,
   drainBrowserPool: () => drainBrowserPool,
   encodeFramesChunkedConcat: () => encodeFramesChunkedConcat,
@@ -78634,6 +78776,7 @@ __export(events_exports, {
 });
 function renderObservabilityEventProperties(props) {
   return {
+    sub_timeline_wait: props.subTimelineWait,
     observability_render_job_id: props.observabilityRenderJobId,
     observability_composition_hash: props.observabilityCompositionHash,
     observability_event_count: props.observabilityEventCount,
@@ -83465,6 +83608,7 @@ var init_skills = __esm({
 var transcribe_exports = {};
 __export(transcribe_exports, {
   detectSpeechOnset: () => detectSpeechOnset,
+  dtwPresetForModel: () => dtwPresetForModel,
   transcribe: () => transcribe
 });
 import { execFileSync as execFileSync5 } from "child_process";
@@ -83598,6 +83742,9 @@ function prepareAudio(audioPath) {
   );
   return wavPath;
 }
+function dtwPresetForModel(model) {
+  return model.replace(/-/g, ".");
+}
 async function transcribe(inputPath, outputDir, options) {
   const model = options?.model ?? DEFAULT_MODEL;
   options?.onProgress?.("Checking whisper...");
@@ -83649,7 +83796,7 @@ async function transcribe(inputPath, outputDir, options) {
     "--output-file",
     outputBase,
     "--dtw",
-    effectiveModel,
+    dtwPresetForModel(effectiveModel),
     "--suppress-nst"
   ];
   if (detectedLanguage) {
@@ -84619,9 +84766,12 @@ function renderObservabilityTelemetryPayload(observability) {
   };
 }
 function renderJobObservabilityTelemetryPayload(job) {
-  return renderObservabilityTelemetryPayload(
-    job?.errorDetails?.observability ?? job?.perfSummary?.observability
-  );
+  return {
+    ...renderObservabilityTelemetryPayload(
+      job?.errorDetails?.observability ?? job?.perfSummary?.observability
+    ),
+    subTimelineWait: job?.errorDetails?.subTimelineWait ?? job?.perfSummary?.subTimelineWait
+  };
 }
 var init_renderObservability = __esm({
   "src/telemetry/renderObservability.ts"() {
@@ -99988,7 +100138,8 @@ function buildRenderErrorDetails(input2) {
     browserConsoleTail: input2.lastBrowserConsole.length > 0 ? input2.lastBrowserConsole.slice(-30) : void 0,
     perfStages: Object.keys(input2.perfStages).length > 0 ? { ...input2.perfStages } : void 0,
     hdrDiagnostics: input2.hdrDiagnostics.videoExtractionFailures > 0 || input2.hdrDiagnostics.imageDecodeFailures > 0 ? { ...input2.hdrDiagnostics } : void 0,
-    observability: input2.observability
+    observability: input2.observability,
+    subTimelineWait: input2.subTimelineWait
   };
 }
 var init_cleanup = __esm({
@@ -100168,6 +100319,13 @@ var init_hdrPerf = __esm({
 });
 
 // ../producer/src/services/render/perfSummary.ts
+function worstSubTimelineWaitOutcome(perfs) {
+  const outcomes = perfs.map((p2) => p2.subTimelineWaitOutcome).filter((o) => !!o);
+  if (outcomes.length === 0) return void 0;
+  if (outcomes.includes("script_failure")) return "script_failure";
+  if (outcomes.includes("timeout")) return "timeout";
+  return "ready";
+}
 function pushWorkerDedupPerfs(results, sink) {
   for (const r2 of results) {
     if (r2.perf) sink.push(r2.perf);
@@ -100249,6 +100407,7 @@ function buildRenderPerfSummary(input2) {
     captureAvgMs: input2.totalFrames > 0 ? Math.round(
       (input2.perfStages.captureFrameMs ?? input2.perfStages.captureMs ?? 0) / input2.totalFrames
     ) : void 0,
+    subTimelineWait: worstSubTimelineWaitOutcome(input2.dedupPerfs),
     captureP50Ms: (() => {
       const withSamples = input2.dedupPerfs.filter((p2) => (p2.p50TotalMs ?? 0) > 0);
       if (withSamples.length === 0) return void 0;
@@ -108231,9 +108390,8 @@ async function psnrDb(a, b2) {
     });
   }
 }
-async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEncoder, reorderBuffer, assertNotAborted, onProgress, log2, stats) {
-  let prev = null;
-  const frameTime = (i2) => i2 * job.config.fps.den / job.config.fps.num;
+function createDrainFrameGuard(args) {
+  const { log: log2, stats, frameTime } = args;
   const verifyMinDbRaw = Number(process.env.HF_DE_VERIFY_MIN_DB ?? "32");
   const verifyMinDb = Number.isFinite(verifyMinDbRaw) && verifyMinDbRaw >= 10 && verifyMinDbRaw <= 60 ? verifyMinDbRaw : 32;
   if (process.env.HF_DE_VERIFY_MIN_DB !== void 0 && verifyMinDb !== verifyMinDbRaw) {
@@ -108250,7 +108408,7 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
     return Math.max(absFloor, median * 0.12);
   };
   let acceptedSmall = null;
-  const guardFrame = async (idx, buf) => {
+  return async (session, idx, buf) => {
     if (process.env.HF_FORCE_DRAWELEMENT !== "1") {
       const floor = blankFloor();
       if (floor > 0 && buf.length < floor && acceptedSmall?.equals(buf)) {
@@ -108325,6 +108483,12 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
     }
     return buf;
   };
+}
+async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEncoder, reorderBuffer, assertNotAborted, onProgress, log2, stats) {
+  let prev = null;
+  const frameTime = (i2) => i2 * job.config.fps.den / job.config.fps.num;
+  const guard = createDrainFrameGuard({ log: log2, stats, frameTime });
+  const guardFrame = (idx, buf) => guard(session, idx, buf);
   const drainPrev = async () => {
     if (!prev) return;
     assertNotAborted();
@@ -108451,37 +108615,81 @@ async function runCaptureStreamingStage(input2) {
   try {
     const reorderBuffer = createFrameReorderBuffer(0, totalFrames);
     if (workerCount > 1) {
-      const tasks = distributeFrames(totalFrames, workerCount, workDir);
-      const onFrameBuffer = async (frameIndex, buffer) => {
-        await reorderBuffer.waitForFrame(frameIndex);
-        ensureFrameWritten(await currentEncoder.writeFrame(buffer), frameIndex, currentEncoder);
-        reorderBuffer.advanceTo(frameIndex + 1);
+      const deParallelStream = process.env.HF_DE_PARALLEL_STREAM === "true";
+      const tasks = deParallelStream ? distributeFramesInterleaved(totalFrames, workerCount, workDir) : distributeFrames(totalFrames, workerCount, workDir);
+      const parallelStats = {
+        verifyChecked: 0,
+        blankSuspects: 0,
+        blankDeterministicAccepts: 0,
+        blankRecaptures: 0
       };
-      const workerResults = await executeParallelCapture(
-        fileServer.url,
-        workDir,
-        tasks,
-        buildCaptureOptions(),
-        createRenderVideoFrameInjector,
-        abortSignal,
-        (progress) => {
-          job.framesRendered = progress.capturedFrames;
-          const frameProgress = progress.capturedFrames / progress.totalFrames;
-          const progressPct = 25 + frameProgress * 55;
-          if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
-            updateJobStatus(
-              job,
-              "rendering",
-              `Streaming frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
-              Math.round(progressPct),
-              onProgress
-            );
+      const parallelGuard = createDrainFrameGuard({
+        log: log2,
+        stats: parallelStats,
+        frameTime: (i2) => i2 * job.config.fps.den / job.config.fps.num
+      });
+      let parallelGuardRan = false;
+      let parallelDrainError = null;
+      const onFrameBuffer = async (frameIndex, buffer, workerSession) => {
+        try {
+          if (deParallelStream && workerSession.captureMode === "drawelement") {
+            parallelGuardRan = true;
+            buffer = await parallelGuard(workerSession, frameIndex, buffer);
           }
-        },
-        onFrameBuffer,
-        captureCfg
-      );
+          await reorderBuffer.waitForFrame(frameIndex);
+          ensureFrameWritten(await currentEncoder.writeFrame(buffer), frameIndex, currentEncoder);
+          reorderBuffer.advanceTo(frameIndex + 1);
+        } catch (err) {
+          const e3 = err instanceof Error ? err : new Error(String(err));
+          if (!parallelDrainError) {
+            parallelDrainError = e3;
+            reorderBuffer.abort(e3);
+          }
+          throw e3;
+        }
+      };
+      let workerResults;
+      try {
+        workerResults = await executeParallelCapture(
+          fileServer.url,
+          workDir,
+          tasks,
+          buildCaptureOptions(),
+          createRenderVideoFrameInjector,
+          abortSignal,
+          (progress) => {
+            job.framesRendered = progress.capturedFrames;
+            const frameProgress = progress.capturedFrames / progress.totalFrames;
+            const progressPct = 25 + frameProgress * 55;
+            if (progress.capturedFrames % 30 === 0 || progress.capturedFrames === progress.totalFrames) {
+              updateJobStatus(
+                job,
+                "rendering",
+                `Streaming frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
+                Math.round(progressPct),
+                onProgress
+              );
+            }
+          },
+          onFrameBuffer,
+          // Interleaved DE workers each need their own browser PROCESS:
+          // pages co-tenant in one browser share one compositor, whose
+          // internal frame scheduling deprioritizes non-active pages — their
+          // canvas `paint` events starve and the drawElement paint-wait slows
+          // ~3x (measured: 86s vs 30s on a 3,245-frame rAF comp). This is
+          // Chromium's internal frame-production scheduling on ALL platforms,
+          // NOT the Linux-only HeadlessExperimental.beginFrame capture mode.
+          deParallelStream ? { ...captureCfg, enableBrowserPool: false } : captureCfg
+        );
+      } catch (err) {
+        if (parallelDrainError) throw parallelDrainError;
+        throw err;
+      }
+      if (parallelDrainError) throw parallelDrainError;
       pushWorkerDedupPerfs(workerResults, dedupPerfs);
+      if (parallelGuardRan) {
+        deDrainStats = parallelStats;
+      }
       if (probeSession) {
         captureBeyondViewport = probeSession.options.captureBeyondViewport;
         lastBrowserConsole = probeSession.browserConsoleBuffer;
@@ -110435,6 +110643,7 @@ function shouldUseStreamingEncode(cfg, outputFormat, workerCount, durationSecond
   if (outputFormat === "gif") return false;
   if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) return false;
   if (durationSeconds > cfg.streamingEncodeMaxDurationSeconds) return false;
+  if (process.env.HF_DE_PARALLEL_STREAM === "true") return true;
   return workerCount === 1;
 }
 function shouldPreferSingleWorkerDrawElement(args) {
@@ -110529,6 +110738,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     captureObservability.captureMode = captureObservability.forceScreenshot ? "screenshot" : "beginframe";
   };
   const captureAttempts = [];
+  const dedupPerfs = [];
   const recordTransientRetryObservability = () => {
     const count = captureAttempts.filter((a) => a.reason === "transient-retry").length;
     if (count > 0) updateCaptureObservability({ transientRetries: count });
@@ -110883,7 +111093,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       layeredOrEffectRoute: hasHdrContent || compiled.hasShaderTransitions,
       supersampling: deviceScaleFactor > 1,
       probeDeGated: probeSession !== null && probeSession.captureMode !== "drawelement" && !probeSession.deInitDeferred,
-      experimentalParallelDeOptIn: process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true"
+      experimentalParallelDeOptIn: process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true" || // Verified parallel DE streaming (opt-in) wants its parallelism kept.
+      process.env.HF_DE_PARALLEL_STREAM === "true"
     });
     if (job.config.workers === void 0 && totalFrames >= 60 && !htmlInCanvasDetected && !cfg.lowMemoryMode && !deInversionEligible) {
       const outcome = await observeRenderStage(
@@ -110960,7 +111171,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       durationSeconds: job.duration,
       maxDurationSeconds: cfg.streamingEncodeMaxDurationSeconds
     });
-    if (cfg.useDrawElement && process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE !== "true" && (!useStreamingEncode || workerCount > 1)) {
+    const deParallelStreamVerified = process.env.HF_DE_PARALLEL_STREAM === "true" && useStreamingEncode && workerCount > 1;
+    if (cfg.useDrawElement && process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE !== "true" && (!useStreamingEncode || workerCount > 1) && !deParallelStreamVerified) {
       cfg.useDrawElement = false;
       deClampReason = workerCount > 1 ? "parallel" : "disk_path";
       log2.info(
@@ -110971,7 +111183,6 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         probeSession = null;
       }
     }
-    const dedupPerfs = [];
     const FORMAT_EXT3 = {
       mp4: ".mp4",
       webm: ".webm",
@@ -111437,7 +111648,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       lastBrowserConsole,
       perfStages,
       hdrDiagnostics,
-      observability: observabilitySummary
+      observability: observabilitySummary,
+      subTimelineWait: worstSubTimelineWaitOutcome(dedupPerfs)
     });
     log2.info("[Render] Failure summary", {
       failedStage: job.currentStage,
@@ -114313,7 +114525,9 @@ async function findFromHyperframesCache() {
     );
     installed = [];
   }
-  const match = installed.find((b2) => b2.browser === Browser.CHROMEHEADLESSSHELL);
+  const match = installed.find(
+    (b2) => b2.browser === Browser.CHROMEHEADLESSSHELL && b2.buildId === CHROME_VERSION
+  );
   if (match && existsSync53(match.executablePath)) {
     return { result: { executablePath: match.executablePath, source: "cache" } };
   }
@@ -120525,6 +120739,7 @@ function trackRenderMetrics(job, elapsedMs, options, docker) {
     speedRatio,
     captureAvgMs: perf?.captureAvgMs,
     captureP50Ms: perf?.captureP50Ms,
+    subTimelineWait: perf?.subTimelineWait,
     videoCount: perf?.videoCount,
     capturePeakMs: perf?.capturePeakMs,
     tmpPeakBytes: perf?.tmpPeakBytes,