@hyperframes/producer 0.9.19 → 0.9.21

package/dist/renderRequest.d.ts

@@ -12,6 +12,7 @@ export interface DistributedRenderOptions {
     chunkSize?: number;
     maxParallelChunks?: number;
     targetChunkFrames?: number;
+    minParallelChunks?: number;
     runtimeCap?: DistributedRenderConfig["runtimeCap"];
     rejectOnSystemFonts?: boolean;
     failClosedFontFetch?: boolean;

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

@@ -104,17 +104,19 @@ export interface DistributedRenderConfig extends Pick<RenderRequestOptions, "pag
      * chunks whose per-chunk frame count stays at or below this bound, still
      * capped by `maxParallelChunks`:
      *
-     *     chunkCount = clamp(ceil(totalFrames / targetChunkFrames), 1, maxParallelChunks)
+     *     chunkCount = clamp(ceil(totalFrames / targetChunkFrames), minParallelChunks, maxParallelChunks)
      *
      * This bounds per-chunk render *time* (which scales with frames-per-chunk) so
      * a single chunk can't exceed a downstream per-chunk timeout on a long video,
-     * while short videos still collapse to few chunks. It is a ceiling, not a
+     * while short videos drop to `minParallelChunks` (default 1). It is a ceiling, not a
      * fixed size: a video short enough to fit in fewer chunks gets fewer. Ignored
      * when `chunkSize` is set (an explicit fixed size already pins per-chunk
      * frames). Mutually exclusive with `chunkSize` in intent; if both are passed,
      * `chunkSize` wins and `targetChunkFrames` is a no-op.
      */
     targetChunkFrames?: number;
+    /** Fewest chunks a `targetChunkFrames`-sized plan uses, so a short video keeps this fan-out. */
+    minParallelChunks?: number;
     /** Runtime hint; consumed by future per-runtime budget checks. The current implementation records the value but does not enforce. */
     runtimeCap?: "lambda" | "temporal" | "cloud-run-job" | "k8s-job" | "none";
     /**
@@ -397,12 +399,12 @@ export declare function measurePlanDirBytes(planDir: string): number;
  * on tiny renders). Explicit numbers, including `240`, take precedence.
  *
  * Optional `targetChunkFrames` caps per-chunk frames in the auto-sized path:
- * the auto-sizer then targets `clamp(ceil(totalFrames / targetChunkFrames), 1,
- * maxParallelChunks)` chunks, so short videos collapse to fewer chunks and long
+ * the auto-sizer then targets `clamp(ceil(totalFrames / targetChunkFrames), minParallelChunks,
+ * maxParallelChunks)` chunks, so short videos drop to `minParallelChunks` and long
  * videos add chunks (up to the cap) to keep each one under the bound. It is a
  * no-op when omitted, and ignored when `configChunkSize` is set.
  */
-export declare function resolveChunkPlan(totalFrames: number, configChunkSize: number | undefined, maxParallelChunks: number, targetChunkFrames?: number): {
+export declare function resolveChunkPlan(totalFrames: number, configChunkSize: number | undefined, maxParallelChunks: number, targetChunkFrames?: number, minParallelChunks?: number): {
     chunkCount: number;
     effectiveChunkSize: number;
 };

package/dist/services/fileServer.d.ts

@@ -95,9 +95,9 @@ export interface VirtualTimeShimOptions {
 /**
  * Build the page-side virtual-time shim script.
  *
- * The shim freezes `Date.now`, `performance.now`, and the rAF/setTimeout
- * pipeline so a render seek can deterministically advance the page's
- * notion of "now". The renderer issues `__HF_VIRTUAL_TIME__.seekToTime(ms)`
+ * The shim freezes `Date.now`, `performance.now`, rAF, and the timers set
+ * after the first seek, so a render seek can deterministically advance the
+ * page's notion of "now". The renderer issues `__HF_VIRTUAL_TIME__.seekToTime(ms)`
  * before every frame capture; everything timing-related on the page sees
  * exactly `ms` until the next seek.
  *

package/dist/services/render/stages/captureStreamingStage.d.ts

@@ -44,16 +44,26 @@ import type { ProducerLogger } from "../../../logger.js";
 import type { ProgressCallback, RenderJob } from "../../renderOrchestrator.js";
 import type { SdrStreamingCapturePlan } from "../capturePlan.js";
 export declare function resolveCaptureStallTimeoutMs(): number;
-type StalledSession = {
+export type StalledSession = {
     captureMode: CaptureSession["captureMode"];
     captureStep?: string;
 };
+export declare const OPENING_CAPTURE_SESSION: StalledSession;
 export declare function raceAgainstStall<T>(promise: Promise<T>, deadlineMs: number, input: {
     session: StalledSession;
     frameIndex: number;
     totalFrames: number;
     stallTimeoutMs: number;
 }, signal?: AbortSignal): Promise<T>;
+/**
+ * The setup budget for opening a session, initializing it, and the deferred drawElement init.
+ * It bounds each step, not setup as a whole: the clock drops a step longer than its suspend gap.
+ */
+export declare function createSessionInitBudget(input: {
+    frameIndex: number;
+    totalFrames: number;
+    abortSignal: AbortSignal | undefined;
+}): <T>(work: Promise<T>, stalled: StalledSession) => Promise<T>;
 /**
  * Pre-built ffmpeg streaming-encoder options, exactly matching the
  * second argument to `spawnStreamingEncoder`. The sequencer constructs
@@ -135,4 +145,3 @@ export declare function verifyDrawElementSample(session: CaptureSession, idx: nu
     verifyMinDb: number;
 }): Promise<void>;
 export declare function runCaptureStreamingStage(input: CaptureStreamingStageInput): Promise<CaptureStreamingStageResult>;
-export {};

package/dist/services/renderOrchestrator.d.ts

@@ -1,5 +1,5 @@
 import { type CanvasResolution, type Fps, type FpsInput, type HfVfxCapture } from "@hyperframes/core";
-import { type EngineConfig, type ExtractionPhaseBreakdown, type VideoFrameFormat, type CaptureOptions, type CaptureVideoMetadataHint, type CaptureSession, type BeforeCaptureHook, type ProresProfile, type ParallelProgress, type WorkerTask, type CapturePerfSummary, type CaptureWarning, type SubTimelineWaitOutcome, type WorkerSizing, type StaticVerificationOutcome, explainDrawElementDisabled, type CaptureFailureKind, displaySize, type MotionBlurOptions } from "@hyperframes/engine";
+import { type EngineConfig, type ExtractionPhaseBreakdown, type VideoFrameFormat, type CaptureOptions, type CaptureVideoMetadataHint, type CaptureSession, type BeforeCaptureHook, type ProresProfile, type ParallelProgress, type WorkerTask, type CapturePerfSummary, type CaptureWarning, type SubTimelineWaitOutcome, type WorkerSizing, type StaticVerificationOutcome, explainDrawElementDisabled, type CaptureFailureKind, displaySize, type MotionBlurOptions, type PageMotionBlurSummary } from "@hyperframes/engine";
 import { type ReferenceBackgroundResult } from "@hyperframes/engine";
 import { type ProducerLogger } from "../logger.js";
 import { type RenderOutputFormat } from "./render/renderFormat.js";
@@ -286,6 +286,7 @@ export interface RenderPerfSummary {
         noDamageFrames: number;
         hasDamageFrames: number;
     };
+    motionBlur?: PageMotionBlurSummary;
     /**
      * drawElement fast-capture outcome for this render (default-on release
      * visibility). Undefined when no capture session ran.
@@ -335,7 +336,7 @@ export interface RenderPerfSummary {
         parallelRouter?: string;
         /** Worker count the auto-resolution chose BEFORE the router pinned it to 3 — the single-worker-inversion counterfactual. Only set when the router fired. */
         preRouterWorkers?: number;
-        /** Engine init-time gate: swiftshader | css_effect:* | at_risk_timeline | 3d_init_failed | supersampling | render_mode_hint. */
+        /** Engine init-time gate: swiftshader | webgl_unavailable | beginframe_no_self_verify | css_effect:* | at_risk_timeline | 3d_init_failed | supersampling | render_mode_hint. */
         gateReason?: string;
         /** Low-cardinality GPU bucket from DE session init (`<backend>/<vendor>`, e.g. `d3d11/nvidia`); |-joined across parallel sessions (bounded: one bucket per distinct backend on the host). */
         gpuRenderer?: string;

package/dist/utils/paths.d.ts

@@ -51,4 +51,6 @@ export declare function toExternalAssetKey(absPath: string): string;
 export declare function formatCaptureFrameName(index: number, ext: string): string;
 export declare function formatExportFrameName(index: number, ext: string): string;
 export declare function resolveRenderPaths(projectDir: string, outputPath: string | null | undefined, rendersDir?: string): RenderPaths;
+/** The project file a data-composition-src names, as the preview reads it; null when it leaves the project. */
+export declare function resolveCompositionSrc(projectDir: string, src: string): string | null;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/producer",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "HTML-to-video rendering engine using Chrome's BeginFrame API",
   "repository": {
     "type": "git",
@@ -35,11 +35,11 @@
     "postcss": "^8.4.0",
     "puppeteer": "~25.11.0",
     "puppeteer-core": "^25.11.0",
-    "@hyperframes/core": "0.9.19",
-    "@hyperframes/engine": "0.9.19",
-    "@hyperframes/parsers": "0.9.19",
-    "@hyperframes/lint": "0.9.19",
-    "@hyperframes/studio-server": "0.9.19"
+    "@hyperframes/engine": "0.9.21",
+    "@hyperframes/parsers": "0.9.21",
+    "@hyperframes/studio-server": "0.9.21",
+    "@hyperframes/lint": "0.9.21",
+    "@hyperframes/core": "0.9.21"
   },
   "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.9.19"
+    "@hyperframes/aws-lambda": "0.9.21"
   },
   "engines": {
     "node": ">=22"