@hyperframes/producer 0.8.207 → 0.8.208

package/dist/distributed.js

@@ -5446,10 +5446,11 @@ var VideoExtractionStageError = class extends Error {
       kind: failure.kind,
       affectedElementCount: failure.count
     }))
-  )) {
+  ), ffmpegReason) {
     const total = failures.reduce((sum2, failure) => sum2 + failure.count, 0);
     const breakdown = failures.map((failure) => `${failure.kind}=${failure.count}`).join(",");
-    super(`Video extraction failed for ${total} source(s) [${code}; ${breakdown}]`);
+    const reason = ffmpegReason ? `: ffmpeg said: ${ffmpegReason}` : "";
+    super(`Video extraction failed for ${total} source(s) [${code}; ${breakdown}]${reason}`);
     this.code = code;
     this.retryable = retryable;
     this.failures = failures;
@@ -5496,7 +5497,8 @@ function buildVideoExtractionStageError(result) {
     retryable ? "VIDEO_EXTRACTION_FAILED" : "VIDEO_SOURCE_UNRENDERABLE",
     retryable,
     failures,
-    extractionFailureMetadataFromResult(result)
+    extractionFailureMetadataFromResult(result),
+    result.errors.find((failure) => failure.ffmpegReason)?.ffmpegReason
   );
 }
 function buildHdrProbeStageError(failures) {
@@ -6501,6 +6503,7 @@ async function runCaptureStage(input) {
       dedupPerfs,
       pageErrorLines: workerPageErrors,
       openAttempt: input.openAttempt,
+      verifyFirstSession: input.verifyFirstSession,
       onProgress: (progress) => {
         if (progress.latestWorkerPhase) {
           if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
@@ -7371,7 +7374,8 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
               });
             } : void 0,
             void 0,
-            options.cfg
+            options.cfg,
+            { verifyFirstSession: options.verifyFirstSession }
           );
           pushWorkerDedupPerfs(workerResults, options.dedupPerfs);
           if (options.pageErrorLines) pushWorkerPageErrors(workerResults, options.pageErrorLines);
@@ -11432,16 +11436,18 @@ function observedChunkCaptureMode(perfs) {
   }
   return mode;
 }
+var PROBE_SELECTED_SCREENSHOT = "[renderChunk] probe selected screenshot capture";
 function shouldRetryChunkCaptureWithScreenshot(error) {
   const failure = classifyCaptureFailure4(error);
   if (failure.kind === "cancelled" || failure.kind === "memory_exhaustion") return false;
-  return /HeadlessExperimental\.beginFrame/i.test(failure.message) || /beginFrame probe timeout/i.test(failure.message) || /Another frame is pending|Frame still pending/i.test(failure.message);
+  return /HeadlessExperimental\.beginFrame/i.test(failure.message) || /beginFrame probe timeout/i.test(failure.message) || failure.message.includes(PROBE_SELECTED_SCREENSHOT) || /Another frame is pending|Frame still pending/i.test(failure.message);
 }
 async function runCaptureWithScreenshotFallback(input) {
   try {
     return await input.run(input.forceScreenshot);
   } catch (error) {
-    if (input.forceScreenshot || !shouldRetryChunkCaptureWithScreenshot(error)) throw error;
+    if (input.forceScreenshot || await input.canRetry?.() === false) throw error;
+    if (!shouldRetryChunkCaptureWithScreenshot(error)) throw error;
     input.onFallback?.(error);
     await input.resetForScreenshotRetry();
     return await input.run(true);
@@ -11650,7 +11656,24 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     let extraction;
     const overlap = { current: null };
     try {
-      if (chunkWorkerCount === 1 || !forceScreenshotForChunk) {
+      const verifyInWorker = chunkWorkerCount > 1 && !forceScreenshotForChunk;
+      let boxesMeasured;
+      let boxesFailed;
+      const boxesReady = new Promise((resolve10, reject) => {
+        boxesMeasured = resolve10;
+        boxesFailed = reject;
+      });
+      boxesReady.catch(() => {
+      });
+      const measureBoxes = async (page) => {
+        shownBoxes = await measureVideoShownBoxes(
+          page,
+          [...shownFrames.keys()],
+          chunkFrameNumbers.map((frame) => frame * chunkFps.den / chunkFps.num)
+        );
+        boxesMeasured();
+      };
+      if (chunkWorkerCount === 1) {
         const bootStarted = Date.now();
         session = await createVerifiedDistributedCaptureSession(
           fileServer.url,
@@ -11659,11 +11682,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           cfg
         );
         sessionBootMs = Date.now() - bootStarted;
-        shownBoxes = await measureVideoShownBoxes(
-          session.page,
-          [...shownFrames.keys()],
-          chunkFrameNumbers.map((frame) => frame * chunkFps.den / chunkFps.num)
-        );
+        await measureBoxes(session.page);
         const browserSelectedScreenshot = session.launchCaptureMode === "screenshot";
         const beginFrameStalled = !browserSelectedScreenshot && await beginFrameSessionNeedsScreenshotFallback(session);
         if (browserSelectedScreenshot) {
@@ -11672,10 +11691,6 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             "[renderChunk] Browser capability probe selected screenshot capture for the entire chunk",
             { chunkIndex }
           );
-          if (chunkWorkerCount > 1) {
-            await closeCaptureSession10(session);
-            session = null;
-          }
         } else if (beginFrameStalled) {
           forceScreenshotForChunk = true;
           log.warn(
@@ -11685,41 +11700,66 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           await closeCaptureSession10(session).catch(() => {
           });
           session = null;
-          if (chunkWorkerCount === 1) {
-            const screenshotBootStarted = Date.now();
-            const screenshotCfg = {
-              ...cfg,
-              forceScreenshot: true,
-              forceScreenshotExplicitlyOptedOut: false
-            };
-            session = await createVerifiedDistributedCaptureSession(
-              fileServer.url,
-              framesDir,
-              captureOptions,
-              screenshotCfg
+          const screenshotBootStarted = Date.now();
+          const screenshotCfg = {
+            ...cfg,
+            forceScreenshot: true,
+            forceScreenshotExplicitlyOptedOut: false
+          };
+          session = await createVerifiedDistributedCaptureSession(
+            fileServer.url,
+            framesDir,
+            captureOptions,
+            screenshotCfg
+          );
+          sessionBootMs += Date.now() - screenshotBootStarted;
+        }
+      } else if (!verifyInWorker) {
+        boxesMeasured();
+      }
+      let verification;
+      const verifyFirstWorker = (first) => verification ??= (async () => {
+        sessionBootMs = Date.now() - verifyStarted;
+        try {
+          await measureBoxes(first.page);
+          const selectedScreenshot = first.launchCaptureMode === "screenshot";
+          if (selectedScreenshot || await beginFrameSessionNeedsScreenshotFallback(first)) {
+            forceScreenshotForChunk = true;
+            log.warn(
+              selectedScreenshot ? "[renderChunk] Browser capability probe selected screenshot capture for the entire chunk" : "[renderChunk] BeginFrame liveness probe failed; using screenshot capture for the entire chunk",
+              { chunkIndex }
             );
-            sessionBootMs += Date.now() - screenshotBootStarted;
+            throw new Error(PROBE_SELECTED_SCREENSHOT);
           }
-        } else if (chunkWorkerCount > 1) {
-          await closeCaptureSession10(session);
-          session = null;
+        } catch (error) {
+          if (!forceScreenshotForChunk) {
+            verifyFailure = error;
+            boxesFailed(error);
+          }
+          throw error;
         }
-      }
-      const extractStarted = Date.now();
-      const deferredVideoFrames = planVideos ? extractDeferredVideoFramesForChunk({
-        planDir,
-        planVideos,
-        frames: chunkFrameNumbers,
-        fps: chunkFps,
-        outputRoot: videoFramesDir,
-        cfg,
-        remoteSources,
-        shownBoxes
-      }).then((frames) => {
-        videoExtractMs = Date.now() - extractStarted;
-        return frames;
-      }) : Promise.resolve([]);
+      })();
+      let verifyStarted = 0;
+      let verifyFailure;
+      const deferredVideoFrames = planVideos ? boxesReady.then(() => {
+        const extractStarted = Date.now();
+        return extractDeferredVideoFramesForChunk({
+          planDir,
+          planVideos,
+          frames: chunkFrameNumbers,
+          fps: chunkFps,
+          outputRoot: videoFramesDir,
+          cfg,
+          remoteSources,
+          shownBoxes
+        }).then((frames) => {
+          videoExtractMs = Date.now() - extractStarted;
+          return frames;
+        });
+      }) : boxesReady.then(() => []);
       extraction = deferredVideoFrames;
+      deferredVideoFrames.catch(() => {
+      });
       const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? deferredVideoFrames.then(
         (deferred) => createFrameLookupTable5(
           planVideos.videos,
@@ -11798,6 +11838,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
         forceScreenshot: forceScreenshotForChunk,
+        canRetry: () => verifyFailure === void 0,
         // fallow-ignore-next-line complexity
         run: async (forceScreenshot) => {
           const captureCfg = cfg.forceScreenshot === forceScreenshot ? cfg : {
@@ -11827,6 +11868,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           }
           const captureSession = session;
           session = null;
+          verifyStarted = Date.now();
           overlap.current = canEncodeWhileCapturing(encodeInput, chunkWorkerCount, cpus().length) ? encodeWhileCapturing(encodeInput, framesInChunk) : null;
           await observeRenderStage(
             new RenderObservabilityRecorder({ pipelineStartMs: start, log }),
@@ -11854,7 +11896,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
               frameRange: range,
               onFrameLanded: (frame) => overlap.current?.onFrameLanded(frame),
               interleaveFrames: interleavesCapture(overlap.current !== null, options),
-              openAttempt
+              openAttempt,
+              verifyFirstSession: forceScreenshot || !verifyInWorker ? void 0 : verifyFirstWorker
             }),
             { stall: frameStallRule(job) }
           ).catch(async (captureError) => {
@@ -11866,6 +11909,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         },
         resetForScreenshotRetry: () => {
           rmSync11(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          boxesMeasured();
           mkdirSync14(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
@@ -11881,6 +11925,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           );
         }
       }).catch(async (captureError) => {
+        if (verifyFailure !== void 0) throw verifyFailure;
+        boxesFailed(captureError);
         await deferredVideoFrames;
         throw captureError;
       });

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "98ef5d9ded07a8647d7220aa648089eaf8ad2c3ddee0e2e6d563f80ba60a7a58",
+  "sha256": "e7380e2810c1db76b94231462d6756bbd8fd7047ab2014b7428a26dc7105b099",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"