@hyperframes/producer 0.8.188 → 0.8.190-hdr.1

package/dist/index.js

@@ -1188,6 +1188,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/services/render/cleanup.ts
 import { freemem } from "node:os";
 
@@ -12515,10 +12523,7 @@ async function executeRenderPipeline(input) {
         });
       }
     });
-    const createRenderVideoFrameInjector = () => createVideoFrameInjector(frameLookup, {
-      frameDataUriCacheLimit: cfg.frameDataUriCacheLimit,
-      frameDataUriCacheBytesLimitMb: cfg.frameDataUriCacheBytesLimitMb
-    });
+    const createRenderVideoFrameInjector = () => createVideoFrameInjector(frameLookup, frameCacheOptions(cfg, workerCount));
     let captureCalibration;
     const htmlInCanvasDetected = compiled.renderModeHints.reasons.some(
       (r) => r.code === "htmlInCanvas"
@@ -14172,12 +14177,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);
     };
   };
@@ -18591,7 +18597,8 @@ import {
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME4,
   muxVideoWithAudio as muxVideoWithAudio2,
   resolveConfig as resolveConfig6,
-  runFfmpeg as runFfmpeg7
+  runFfmpeg as runFfmpeg7,
+  appendSoftwareEncoderThreadsArg
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
 function cfrRateControlArgs(locked) {
@@ -18705,10 +18712,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 = join40(ctx.workDir, `cfr.${ctx.format}`);
-  const cfrArgs = [
-    ...videoInputArgs(ctx, chunkPaths),
+function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
+  const args = [
+    ...inputArgs,
     "-c:v",
     "libx264",
     ...cfrRateControlArgs(encoder),
@@ -18717,8 +18723,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 = join40(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
   await ctx.timed(
@@ -18969,6 +18981,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;
@@ -19266,7 +19294,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,
@@ -19320,17 +19351,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: () => {
           rmSync17(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });

package/dist/public-server.js

@@ -1208,6 +1208,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/services/render/cleanup.ts
 import { freemem } from "node:os";
 
@@ -12498,10 +12506,7 @@ async function executeRenderPipeline(input) {
         });
       }
     });
-    const createRenderVideoFrameInjector = () => createVideoFrameInjector(frameLookup, {
-      frameDataUriCacheLimit: cfg.frameDataUriCacheLimit,
-      frameDataUriCacheBytesLimitMb: cfg.frameDataUriCacheBytesLimitMb
-    });
+    const createRenderVideoFrameInjector = () => createVideoFrameInjector(frameLookup, frameCacheOptions(cfg, workerCount));
     let captureCalibration;
     const htmlInCanvasDetected = compiled.renderModeHints.reasons.some(
       (r) => r.code === "htmlInCanvas"

package/dist/services/distributed/assemble.d.ts

@@ -68,6 +68,7 @@ export declare function assemble(planDir: string, chunkOutputs: AssembleChunkPat
      */
     cfr?: boolean;
 }): Promise<AssembleResult>;
+export declare function cfrEncodeArgs(inputArgs: string[], encoder: CfrRateControlSource, fpsArg: string): string[];
 /** Mp4 chunks carrying audio, or with it as a separate file, stitch under one index like S3's. */
 export declare function chunksAreStitchedMp4(planDir: string, cfr: boolean): boolean;
 export declare function stitchesSeparateAudio(planDir: string): boolean;

package/dist/services/distributed/chunkFrames.d.ts

@@ -1,4 +1,4 @@
-import { type BeforeCaptureHook, BROWSER_GPU_NOT_SOFTWARE, type CaptureOptions, type EngineConfig, type ExtractedFrames, type FrameLookupTable, type ShownBox } from "@hyperframes/engine";
+import { type BeforeCaptureHook, BROWSER_GPU_NOT_SOFTWARE, type CaptureOptions, createVideoFrameInjector, type EngineConfig, type ExtractedFrames, type FrameLookupTable, type ShownBox } from "@hyperframes/engine";
 import type { LockedRenderConfig } from "../render/stages/freezePlan.js";
 import type { PlanV2RemoteSources } from "./planV2.js";
 import { type DistributedFormat, INVALID_VIDEO_METADATA, type PlanVideosJson } from "./shared.js";
@@ -17,7 +17,7 @@ export declare class RenderChunkValidationError extends Error {
     constructor(code: RenderChunkValidationCode, message: string);
 }
 /** One injector per browser session: a hook reused on a fresh page can skip its first injection. */
-export declare function createChunkVideoFrameInjectorFactory(frameLookup: FrameLookupTable | Promise<FrameLookupTable> | null): () => BeforeCaptureHook | null;
+export declare function createChunkVideoFrameInjectorFactory(frameLookup: FrameLookupTable | Promise<FrameLookupTable> | null, options?: Parameters<typeof createVideoFrameInjector>[1]): () => BeforeCaptureHook | null;
 /**
  * Rebuilds `ExtractedFrames[]` from `<planDir>/video-frames/<videoId>/`. `framePaths` keys are 0-based
  * frame indexes (what `getFrameAtTime` reads); any other key drops every video's first-paint frame.

package/dist/services/distributed/renderChunk.d.ts

@@ -33,7 +33,7 @@
  * Every determinism toggle above is opt-in — only this primitive enables them.
  * In-process renders (`executeRenderJob`) leave them off.
  */
-import { assertSwiftShader, type CaptureOptions, type CaptureMode, type CaptureSession, closeCaptureSession, createCaptureSession, type EngineConfig, initializeSession, probeBeginFrameLiveness, readWebGlVendorInfoFromCanvas } from "@hyperframes/engine";
+import { assertSwiftShader, type CaptureOptions, type CaptureMode, type CapturePerfSummary, type CaptureSession, closeCaptureSession, createCaptureSession, type EngineConfig, initializeSession, probeBeginFrameLiveness, readWebGlVendorInfoFromCanvas } from "@hyperframes/engine";
 import { type ChunkSliceJson, type LockedRenderConfig } from "../render/stages/freezePlan.js";
 import { type PlanVideosJson } from "./shared.js";
 export { CHUNK_FRAME_RANGE_INVALID, CHUNK_INDEX_OUT_OF_RANGE, createChunkVideoFrameInjectorFactory, extractDeferredVideoFramesForChunk, FFMPEG_VERSION_MISMATCH, INVALID_VIDEO_METADATA, MISSING_PLAN_ARTIFACT, MISSING_RUNTIME_ENV_SNAPSHOT, PLAN_HASH_MISMATCH, rebuildExtractedFramesFromPlanDir, RenderChunkValidationError, } from "./chunkFrames.js";
@@ -136,6 +136,12 @@ export declare const distributedCaptureSessionDependencies: DistributedCaptureSe
  * assertion, including fresh screenshot browsers created after a fallback.
  */
 export declare function createVerifiedDistributedCaptureSession(serverUrl: string, framesDir: string, captureOptions: CaptureOptions, cfg: EngineConfig, dependencies?: DistributedCaptureSessionDependencies): Promise<CaptureSession>;
+/** Workers of one chunk launched in different modes: one worker's BeginFrame check failed and it fell back alone. */
+export declare class MixedCaptureModesError extends Error {
+    readonly modes: readonly string[];
+    constructor(modes: readonly string[]);
+}
+export declare function observedChunkCaptureMode(perfs: readonly Pick<CapturePerfSummary, "captureMode">[]): CaptureMode;
 /**
  * Only BeginFrame-specific failures are safe to retry in screenshot mode.
  * Cancellation, memory exhaustion, and unrelated authoring/IO failures must

package/dist/services/render/frameCacheBudget.d.ts

@@ -0,0 +1,3 @@
+import type { EngineConfig } from "@hyperframes/engine";
+/** Cache options for one of `workers` injectors that share the configured budget on the one Node heap. */
+export declare function frameCacheOptions(cfg: Pick<EngineConfig, "frameDataUriCacheLimit" | "frameDataUriCacheBytesLimitMb">, workers: number | undefined): Pick<EngineConfig, "frameDataUriCacheLimit" | "frameDataUriCacheBytesLimitMb">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/producer",
-  "version": "0.8.188",
+  "version": "0.8.190-hdr.1",
   "description": "HTML-to-video rendering engine using Chrome's BeginFrame API",
   "repository": {
     "type": "git",
@@ -35,11 +35,11 @@
     "postcss": "^8.4.0",
     "puppeteer": "^25.2.1",
     "puppeteer-core": "^25.2.1",
-    "@hyperframes/engine": "0.8.188",
-    "@hyperframes/parsers": "0.8.188",
-    "@hyperframes/lint": "0.8.188",
-    "@hyperframes/core": "0.8.188",
-    "@hyperframes/studio-server": "0.8.188"
+    "@hyperframes/core": "0.8.190-hdr.1",
+    "@hyperframes/parsers": "0.8.190-hdr.1",
+    "@hyperframes/lint": "0.8.190-hdr.1",
+    "@hyperframes/studio-server": "0.8.190-hdr.1",
+    "@hyperframes/engine": "0.8.190-hdr.1"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",
@@ -48,7 +48,7 @@
     "tsx": "^4.21.0",
     "typescript": "^5.7.2",
     "vitest": "^4.1.11",
-    "@hyperframes/aws-lambda": "0.8.188"
+    "@hyperframes/aws-lambda": "0.8.190-hdr.1"
   },
   "engines": {
     "node": ">=22"