@hyperframes/producer 0.8.183 → 0.8.185

package/dist/distributed.js

@@ -5233,6 +5233,7 @@ async function runCaptureStage(input) {
           if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
           return;
         }
+        if (progress.landedFrame) input.onFrameLanded?.(progress.landedFrame);
         job.framesRendered = progress.capturedFrames;
         checkDiskProjection(progress.capturedFrames);
         const frameProgress = progress.capturedFrames / progress.totalFrames;
@@ -5473,7 +5474,8 @@ import {
   formatFfmpegError,
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME2,
   resolveConfig,
-  runFfmpeg as runFfmpeg3
+  runFfmpeg as runFfmpeg3,
+  spawnStreamingEncoder as spawnStreamingEncoder4
 } from "@hyperframes/engine";
 import {
   clearGifFramesBeforeNext,
@@ -5610,6 +5612,30 @@ function startEncodeProgress(job, stage, onProgress) {
   });
   return (frames = total) => reportEncodeProgress(job, frames, total, onProgress, 75);
 }
+function resolveEngineConfig(input) {
+  return input.engineConfig ?? input.job.config.producerConfig ?? resolveConfig();
+}
+function videoEncoderOptions(input, engineCfg) {
+  const { job, preset } = input;
+  return {
+    fps: job.config.fps,
+    width: input.width,
+    height: input.height,
+    codec: preset.codec,
+    preset: preset.preset,
+    quality: input.effectiveQuality,
+    bitrate: input.effectiveBitrate,
+    pixelFormat: preset.pixelFormat,
+    vp9CpuUsed: engineCfg.vp9CpuUsed,
+    useGpu: job.config.useGpu,
+    hdr: preset.hdr,
+    // Distributed chunk renders pass these so the encoder writes closed-GOP
+    // keyframes that survive `-f concat -c copy` at assemble time. In-process
+    // renders leave both undefined → preserves the existing open-GOP output.
+    lockGopForChunkConcat: input.lockGopForChunkConcat === true,
+    gopSize: input.gopSize
+  };
+}
 async function runEncodeStage(input) {
   const {
     job,
@@ -5617,16 +5643,11 @@ async function runEncodeStage(input) {
     outputPath,
     framesDir,
     videoOnlyPath,
-    width,
-    height,
     needsAlpha,
     hasAudio,
     audioOutputPath,
     isPngSequence,
     isGif,
-    preset,
-    effectiveQuality,
-    effectiveBitrate,
     enableChunkedEncode,
     chunkedEncodeSize,
     abortSignal,
@@ -5656,7 +5677,7 @@ async function runEncodeStage(input) {
     encoded();
     return { encodeMs: Date.now() - stage5Start };
   }
-  const engineCfg = input.engineConfig ?? job.config.producerConfig ?? resolveConfig();
+  const engineCfg = resolveEngineConfig(input);
   if (isGif) {
     const encoded = startEncodeProgress(job, "Encoding GIF", onProgress);
     if (hasAudio) {
@@ -5686,24 +5707,7 @@ async function runEncodeStage(input) {
   const videoEngineCfg = scaledEncodeTimeout > engineCfg.ffmpegEncodeTimeout ? { ...engineCfg, ffmpegEncodeTimeout: scaledEncodeTimeout } : engineCfg;
   const frameExt = frameFileExtension2(input.captureImageFormat);
   const framePattern = `frame_%06d.${frameExt}`;
-  const encoderOpts = {
-    fps: job.config.fps,
-    width,
-    height,
-    codec: preset.codec,
-    preset: preset.preset,
-    quality: effectiveQuality,
-    bitrate: effectiveBitrate,
-    pixelFormat: preset.pixelFormat,
-    vp9CpuUsed: engineCfg.vp9CpuUsed,
-    useGpu: job.config.useGpu,
-    hdr: preset.hdr,
-    // Distributed chunk renders pass these so the encoder writes closed-GOP
-    // keyframes that survive `-f concat -c copy` at assemble time. In-process
-    // renders leave both undefined → preserves the existing open-GOP output.
-    lockGopForChunkConcat: input.lockGopForChunkConcat === true,
-    gopSize: input.gopSize
-  };
+  const encoderOpts = videoEncoderOptions(input, engineCfg);
   const encodeResult = enableChunkedEncode ? await encodeFramesChunkedConcat(
     framesDir,
     framePattern,
@@ -5986,7 +5990,6 @@ async function enforceAacTruePeak(input) {
   try {
     scratchDir = mkdtempSync2(join13(dirname6(input.audioPath), ".true-peak-"));
     const correctedPath = join13(scratchDir, "audio.m4a");
-    const correctionTargetDbfs = AAC_DELIVERY_TRUE_PEAK_DBFS - AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB;
     const measurements = [];
     let attenuationDb = 0;
     let measuredPath = input.audioPath;
@@ -6004,7 +6007,8 @@ async function enforceAacTruePeak(input) {
         return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
-      attenuationDb += correctionTargetDbfs - truePeakDbfs;
+      const headroomDb = AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB * 2 ** pass;
+      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - headroomDb - truePeakDbfs;
       const result = await input.encode(
         input.audioPath,
         correctedPath,
@@ -6847,7 +6851,14 @@ var RenderChunkValidationError = class extends Error {
   }
 };
 function createChunkVideoFrameInjectorFactory(frameLookup) {
-  return () => createVideoFrameInjector2(frameLookup);
+  if (!(frameLookup instanceof Promise)) return () => createVideoFrameInjector2(frameLookup);
+  return () => {
+    let hook;
+    return async (page, time, heldVideoTime) => {
+      hook ??= createVideoFrameInjector2(await frameLookup);
+      await hook?.(page, time, heldVideoTime);
+    };
+  };
 }
 function frameNumberFromFileName(name) {
   const match = /(\d+)(?=\.[^.]+$)/.exec(name);
@@ -10245,6 +10256,12 @@ function validatePlanVideosForChunk(value) {
     );
   }
 }
+var MIN_FRAMES_PER_CHUNK_BROWSER = 20;
+function resolveChunkCaptureWorkers(framesInChunk, machineSized, maxCaptureWorkers) {
+  if (maxCaptureWorkers === void 0) return machineSized;
+  const byFrames = Math.floor(framesInChunk / MIN_FRAMES_PER_CHUNK_BROWSER);
+  return Math.max(machineSized, Math.floor(Math.min(maxCaptureWorkers, byFrames)));
+}
 function resolveChunkFrameRange(slice, chunkIndex, frameRange) {
   if (frameRange === void 0) return { startFrame: slice.startFrame, endFrame: slice.endFrame };
   const { startFrame, endFrame } = frameRange;
@@ -10481,7 +10498,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         deferredVideos.filter((video) => remoteVideoIds.has(video.videoId))
       )
     });
-    const chunkWorkerCount = calculateOptimalWorkers2(framesInChunk, void 0, cfg);
+    const chunkWorkerCount = resolveChunkCaptureWorkers(
+      framesInChunk,
+      calculateOptimalWorkers2(framesInChunk, void 0, cfg),
+      options?.maxCaptureWorkers
+    );
     let session = null;
     let outputKind;
     let framesEncoded = 0;
@@ -10493,6 +10514,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     const captureAttempts = [];
     let forceScreenshotForChunk = encoder.forceScreenshot;
     let shownBoxes;
+    let extraction;
     try {
       if (chunkWorkerCount === 1 || !forceScreenshotForChunk) {
         const bootStarted = Date.now();
@@ -10549,7 +10571,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           session = null;
         }
       }
-      const deferredVideoFrames = planVideos ? await extractDeferredVideoFramesForChunk({
+      const deferredVideoFrames = planVideos ? extractDeferredVideoFramesForChunk({
         planDir,
         planVideos,
         frames: chunkFrameNumbers,
@@ -10558,19 +10580,24 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         cfg,
         remoteSources,
         shownBoxes
-      }) : [];
-      const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable5(
-        planVideos.videos,
-        [
-          ...rebuildExtractedFramesFromPlanDir(
-            planDir,
-            planVideos.extracted.filter((video) => !video.deferredRange),
-            v2Manifest === null ? "dense-v1" : "sparse-v2"
-          ),
-          ...deferredVideoFrames
-        ],
-        resolveRenderFpsConfig(job.config.fps).value
+      }) : Promise.resolve([]);
+      extraction = deferredVideoFrames;
+      const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? deferredVideoFrames.then(
+        (deferred) => createFrameLookupTable5(
+          planVideos.videos,
+          [
+            ...rebuildExtractedFramesFromPlanDir(
+              planDir,
+              planVideos.extracted.filter((video) => !video.deferredRange),
+              v2Manifest === null ? "dense-v1" : "sparse-v2"
+            ),
+            ...deferred
+          ],
+          resolveRenderFpsConfig(job.config.fps).value
+        )
       ) : null;
+      videoFrameLookup?.catch(() => {
+      });
       const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(videoFrameLookup);
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
@@ -10653,7 +10680,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             }
           );
         }
+      }).catch(async (captureError) => {
+        await deferredVideoFrames;
+        throw captureError;
       });
+      await deferredVideoFrames;
       captureStageMs = Date.now() - captureStarted;
       applyRenderWarningPolicy(
         job,
@@ -10732,6 +10763,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
+      await extraction?.catch(() => {
+      });
       if (session) {
         try {
           await closeCaptureSession10(session);

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "ba14a236a2e876f93d6683f19606311590ca5ee22b8f08cbe0e1205eabf24464",
+  "sha256": "6b080917689b34014c8f3884d89beea5dcd39986c93335d117c29fa055e0ecd8",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"