@hyperframes/producer 0.8.188 → 0.8.190-hdr.1

package/dist/distributed.js

@@ -1097,6 +1097,14 @@ function materializeExtractedFramesForCompiledDir(extracted, compiledDir, option
   }
 }
 
+// src/services/render/frameCacheBudget.ts
+function frameCacheOptions(cfg, workers) {
+  return {
+    frameDataUriCacheLimit: cfg.frameDataUriCacheLimit,
+    frameDataUriCacheBytesLimitMb: Math.floor(cfg.frameDataUriCacheBytesLimitMb / (workers || 1))
+  };
+}
+
 // src/utils/errorMessage.ts
 function normalizeErrorMessage(error) {
   if (error instanceof Error) return error.message;
@@ -6847,12 +6855,13 @@ var RenderChunkValidationError = class extends Error {
     this.code = code;
   }
 };
-function createChunkVideoFrameInjectorFactory(frameLookup) {
-  if (!(frameLookup instanceof Promise)) return () => createVideoFrameInjector2(frameLookup);
+function createChunkVideoFrameInjectorFactory(frameLookup, options) {
+  if (!(frameLookup instanceof Promise))
+    return () => createVideoFrameInjector2(frameLookup, options);
   return () => {
     let hook;
     return async (page, time, heldVideoTime) => {
-      hook ??= createVideoFrameInjector2(await frameLookup);
+      hook ??= createVideoFrameInjector2(await frameLookup, options);
       await hook?.(page, time, heldVideoTime);
     };
   };
@@ -9899,7 +9908,8 @@ import {
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME4,
   muxVideoWithAudio as muxVideoWithAudio2,
   resolveConfig as resolveConfig4,
-  runFfmpeg as runFfmpeg7
+  runFfmpeg as runFfmpeg7,
+  appendSoftwareEncoderThreadsArg
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
 function cfrRateControlArgs(locked) {
@@ -10013,10 +10023,9 @@ function readAssemblePlan(planDir, chunkPaths) {
 function videoInputArgs(ctx, videoSources) {
   return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg);
 }
-async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join25(ctx.workDir, `cfr.${ctx.format}`);
-  const cfrArgs = [
-    ...videoInputArgs(ctx, chunkPaths),
+function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
+  const args = [
+    ...inputArgs,
     "-c:v",
     "libx264",
     ...cfrRateControlArgs(encoder),
@@ -10025,8 +10034,14 @@ async function reencodeCfr(ctx, chunkPaths, encoder) {
     "-fps_mode",
     "cfr",
     "-r",
-    ctx.fpsArg
+    fpsArg
   ];
+  appendSoftwareEncoderThreadsArg(args, "libx264");
+  return args;
+}
+async function reencodeCfr(ctx, chunkPaths, encoder) {
+  const cfrOutputPath = join25(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
   await ctx.timed(
@@ -10277,6 +10292,22 @@ async function createVerifiedDistributedCaptureSession(serverUrl, framesDir, cap
 function isCaptureMode(value) {
   return value === "beginframe" || value === "screenshot" || value === "drawelement";
 }
+var MixedCaptureModesError = class extends Error {
+  constructor(modes) {
+    super(`[renderChunk] capture workers reported inconsistent modes: ${modes.join(",")}`);
+    this.modes = modes;
+    this.name = "MixedCaptureModesError";
+  }
+};
+function observedChunkCaptureMode(perfs) {
+  const modes = [...new Set(perfs.map((perf) => perf.captureMode))];
+  if (modes.length > 1) throw new MixedCaptureModesError(modes);
+  const [mode] = modes;
+  if (!mode || !isCaptureMode(mode)) {
+    throw new Error(`[renderChunk] capture workers reported an invalid mode: ${mode ?? "<none>"}`);
+  }
+  return mode;
+}
 function shouldRetryChunkCaptureWithScreenshot(error) {
   const failure = classifyCaptureFailure4(error);
   if (failure.kind === "cancelled" || failure.kind === "memory_exhaustion") return false;
@@ -10574,7 +10605,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       ) : null;
       videoFrameLookup?.catch(() => {
       });
-      const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(videoFrameLookup);
+      const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(
+        videoFrameLookup,
+        frameCacheOptions(cfg, chunkWorkerCount)
+      );
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
         forceScreenshot: forceScreenshotForChunk,
@@ -10628,17 +10662,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             },
             frameRange: range
           });
-          const observedModes = new Set(capturePerfs.map((perf) => perf.captureMode));
-          if (observedModes.size !== 1 || ![...observedModes].every(isCaptureMode)) {
-            throw new Error(
-              `[renderChunk] capture workers reported invalid or inconsistent modes: ${[...observedModes].join(",") || "<none>"}`
-            );
-          }
-          const [observedMode] = observedModes;
-          if (!observedMode || !isCaptureMode(observedMode)) {
-            throw new Error("[renderChunk] capture completed without an observed mode");
-          }
-          return observedMode;
+          return observedChunkCaptureMode(capturePerfs);
         },
         resetForScreenshotRetry: () => {
           rmSync13(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "eee27ae31219b3ee97526ca8d8716b921e7f5bce461e1d62f1ff2a49eb26ea67",
+  "sha256": "54a6d80fb24c9d14b82e50000abc5ff73819d53fe7951b53299a20e941371b5b",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"