@hyperframes/producer 0.8.178 → 0.8.180

package/dist/public-server.js

@@ -13845,12 +13845,24 @@ var DISTRIBUTED_RENDER_CAPABILITIES = Object.freeze({
       accepts: Object.freeze([PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2]),
       acceptsLegacyV1WithoutDescriptor: true
     })
-  })
+  }),
+  chunkFrameRange: true
 });
 
 // src/services/render/stages/planHash.ts
 var FIELD_DELIMITER = Buffer.from([0]);
 
+// src/services/distributed/chunkAudio.ts
+import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure2, runFfmpeg as runFfmpeg5 } from "@hyperframes/engine";
+
+// src/services/distributed/mp4Stitch.ts
+var SCAN_BYTES = 64 * 1024;
+
+// src/services/distributed/chunkAudio.ts
+var SLICE_DIR = "audio-chunks";
+var SLICE_FRAME = `${SLICE_DIR}/frame.m4a`;
+var SLICE_LAYOUT = `${SLICE_DIR}/layout.json`;
+
 // src/services/distributed/planSize.ts
 var PLAN_ROOT_CATEGORY = {
   compiled: "compiled",

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

@@ -31,6 +31,7 @@ export interface AssembleResult {
     framesEncoded: number;
     fileSize: number;
 }
+export type AssembleChunkPaths = readonly (string | readonly string[])[];
 type CfrRateControlSource = Partial<Pick<LockedRenderConfig, "quality" | "crf" | "bitrate">>;
 export declare function cfrRateControlArgs(locked: CfrRateControlSource): string[];
 /**
@@ -39,7 +40,8 @@ export declare function cfrRateControlArgs(locked: CfrRateControlSource): string
  * @param planDir — absolute path to the planDir produced by `plan()`.
  * @param chunkPaths — ordered chunk outputs, length === `chunks.json` length.
  *   For mp4/mov each entry is a path to an encoded chunk file; for
- *   png-sequence each entry is a path to a directory of frames.
+ *   png-sequence each entry is a path to a directory of frames. An entry
+ *   may instead be the ordered parts of that chunk (see {@link AssembleChunkPaths}).
  * @param audioPath — `<planDir>/<MIXED_AUDIO_FILENAME>` for mux'd formats. Pass `null`
  *   when the composition has no audio (or `assemble` is being called for a
  *   format whose audio is muxed elsewhere). `assemble` always normalizes
@@ -48,7 +50,7 @@ export declare function cfrRateControlArgs(locked: CfrRateControlSource): string
  * @param outputPath — final on-disk output (file for mp4/mov; directory
  *   for png-sequence — created if missing).
  */
-export declare function assemble(planDir: string, chunkPaths: readonly string[], audioPath: string | null, outputPath: string, options?: {
+export declare function assemble(planDir: string, chunkOutputs: AssembleChunkPaths, audioPath: string | null, outputPath: string, options?: {
     logger?: ProducerLogger;
     abortSignal?: AbortSignal;
     /**

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

@@ -15,6 +15,25 @@ interface AudioCut {
     packetCount: number;
 }
 export declare function audioCutForChunk(grid: AacPacketGrid, chunks: readonly ChunkSliceJson[], index: number, fps: Fps): AudioCut | null;
+/** Chunk `index` split around `range`, so `audioCutForChunk` treats `range` as a chunk. */
+export declare function chunksWithSubRange(chunks: readonly ChunkSliceJson[], index: number, range: {
+    startFrame: number;
+    endFrame: number;
+}): {
+    chunks: ChunkSliceJson[];
+    index: number;
+};
+export declare function chunkAudioSlicePath(index: number): string;
+/** Which chunks need a sliced-audio file: `"all"`, one index, or `null` if it is not one. */
+export declare function chunkAudioSliceTarget(path: string): "all" | number | null;
+export declare function writeChunkAudioSlices(input: {
+    audioPath: string;
+    planDir: string;
+    chunks: readonly ChunkSliceJson[];
+    fps: Fps;
+}): Promise<void>;
+/** The plan audio for a chunk: the whole file, or one rebuilt at `scratchPath` from its slice. */
+export declare function chunkAudioSource(planDir: string, chunkIndex: number, scratchPath: string): string | null;
 interface MuxInput {
     videoPath: string;
     audioPath: string | null;

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

@@ -7,9 +7,10 @@ export declare const FFMPEG_VERSION_MISMATCH = "FFMPEG_VERSION_MISMATCH";
 export declare const PLAN_HASH_MISMATCH = "PLAN_HASH_MISMATCH";
 export declare const MISSING_PLAN_ARTIFACT = "MISSING_PLAN_ARTIFACT";
 export declare const CHUNK_INDEX_OUT_OF_RANGE = "CHUNK_INDEX_OUT_OF_RANGE";
+export declare const CHUNK_FRAME_RANGE_INVALID = "CHUNK_FRAME_RANGE_INVALID";
 export declare const MISSING_RUNTIME_ENV_SNAPSHOT = "MISSING_RUNTIME_ENV_SNAPSHOT";
 export { INVALID_VIDEO_METADATA };
-export type RenderChunkValidationCode = typeof FFMPEG_VERSION_MISMATCH | typeof PLAN_HASH_MISMATCH | typeof MISSING_PLAN_ARTIFACT | typeof CHUNK_INDEX_OUT_OF_RANGE | typeof MISSING_RUNTIME_ENV_SNAPSHOT | typeof INVALID_VIDEO_METADATA | typeof BROWSER_GPU_NOT_SOFTWARE;
+export type RenderChunkValidationCode = typeof FFMPEG_VERSION_MISMATCH | typeof PLAN_HASH_MISMATCH | typeof MISSING_PLAN_ARTIFACT | typeof CHUNK_INDEX_OUT_OF_RANGE | typeof CHUNK_FRAME_RANGE_INVALID | typeof MISSING_RUNTIME_ENV_SNAPSHOT | typeof INVALID_VIDEO_METADATA | typeof BROWSER_GPU_NOT_SOFTWARE;
 /** A malformed planDir or a worker that does not match the plan's fingerprint; adapters key retries off `code`. */
 export declare class RenderChunkValidationError extends Error {
     readonly code: RenderChunkValidationCode;

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

@@ -32,6 +32,7 @@ export interface TrackTable {
 /** Each track's sample tables, expanded to one entry per sample (and per chunk). */
 export declare function readTracks(moov: Buffer): TrackTable[];
 export declare function buildStitchedHeader(layouts: readonly Mp4Layout[]): Buffer;
+export declare function fileRange(path: string): ReadRange;
 /** Local join: the stitched header, then each chunk's mdat payload in order. Like the ffmpeg
  * join, it writes in a work folder beside `outputPath` and renames only a finished file there. */
 export declare function writeStitchedMp4(chunkPaths: readonly string[], outputPath: string): Promise<void>;

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

@@ -209,6 +209,8 @@ export interface BuildLocalExecutionPlanOptions {
     readonly whileAudioMixes?: () => Promise<void>;
     /** mp4 chunks carry their plan-audio slice unless cfr re-encodes. */
     readonly chunksCarryAudio?: boolean;
+    /** With `chunksCarryAudio`, also write each chunk's audio packets to their own file. Plan v2 only. */
+    readonly sliceChunkAudio?: boolean;
 }
 export interface RemoteProjectFile {
     readonly url: string;

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

@@ -53,6 +53,7 @@ export interface DistributedRenderCapabilities {
         chunk: Readonly<PlanProtocolConsumerCapabilities>;
         assembler: Readonly<PlanProtocolConsumerCapabilities>;
     }>;
+    readonly chunkFrameRange?: boolean;
 }
 /** Serializable capability payload for fleet rollout and worker handshakes. */
 export declare const DISTRIBUTED_RENDER_CAPABILITIES: Readonly<DistributedRenderCapabilities>;

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

@@ -1,12 +1,12 @@
-import { assemble, type AssembleResult } from "./assemble.js";
-import { type EffectiveChunkResult } from "./renderChunk.js";
+import { assemble, type AssembleChunkPaths, type AssembleResult } from "./assemble.js";
+import { type EffectiveChunkResult, type RenderChunkOptions } from "./renderChunk.js";
 /**
  * Direct v2 chunk-role entry point. Storage adapters may instead download the
  * selected blobs themselves and call `materializePlanV2Target` + `renderChunk`.
  */
-export declare function renderChunkV2(planV2Dir: string, chunkIndex: number, outputChunkPath: string): Promise<EffectiveChunkResult>;
+export declare function renderChunkV2(planV2Dir: string, chunkIndex: number, outputChunkPath: string, options?: RenderChunkOptions): Promise<EffectiveChunkResult>;
 /**
  * Direct v2 assembler-role entry point. Audio is resolved exclusively from
  * the assembler dependency set and never materialized by chunk workers.
  */
-export declare function assembleV2(planV2Dir: string, chunkPaths: readonly string[], outputPath: string, options?: Parameters<typeof assemble>[4]): Promise<AssembleResult>;
+export declare function assembleV2(planV2Dir: string, chunkPaths: AssembleChunkPaths, outputPath: string, options?: Parameters<typeof assemble>[4]): Promise<AssembleResult>;

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

@@ -34,9 +34,9 @@
  * 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 { type LockedRenderConfig } from "../render/stages/freezePlan.js";
+import { type ChunkSliceJson, type LockedRenderConfig } from "../render/stages/freezePlan.js";
 import { type PlanVideosJson } from "./shared.js";
-export { 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";
+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";
 /** Validate the shared video contract before any v1 chunk can inject frames. */
 export declare function validatePlanVideosForChunk(value: unknown): PlanVideosJson;
 /**
@@ -51,6 +51,7 @@ export interface ChunkResult {
     /** `"file"` for mp4/mov; `"frame-dir"` for png-sequence. */
     outputKind: "file" | "frame-dir";
     framesEncoded: number;
+    frameRange?: ChunkFrameRange;
     sha256: string;
     durationMs: number;
     /**
@@ -92,7 +93,26 @@ export interface ChunkResult {
 /** Result returned by the built-in renderer, which always observes its mode. */
 export interface EffectiveChunkResult extends ChunkResult {
     captureMode: CaptureMode;
+    frameRange: ChunkFrameRange;
 }
+/** Absolute composition frame indices, end exclusive, like a chunk's slice. */
+export interface ChunkFrameRange {
+    startFrame: number;
+    endFrame: number;
+}
+export interface RenderChunkOptions {
+    /**
+     * Render only these frames of the chunk, e.g. to retry a slow chunk as
+     * parts rendered in parallel. Must be a non-empty range inside the chunk's
+     * slice. Each part is a self-contained output (its own IDR keyframe, frame
+     * names from zero, the audio packets it owns); pass the parts of a chunk,
+     * in order, as one `chunkPaths` entry to `assemble`. Omitted renders the
+     * whole slice.
+     */
+    frameRange?: ChunkFrameRange;
+}
+/** The frames a chunk renders: its slice, or a validated sub-range of it. */
+export declare function resolveChunkFrameRange(slice: ChunkSliceJson, chunkIndex: number, frameRange: ChunkFrameRange | undefined): ChunkFrameRange;
 /** Compatibility-safe adapter seam for built-in or injected chunk renderers. */
 export type ChunkRenderer = (planDir: string, chunkIndex: number, outputChunkPath: string) => Promise<ChunkResult>;
 interface DistributedCaptureSessionDependencies {
@@ -159,4 +179,4 @@ export declare function resolveLockedVp9CpuUsed(lockedEncoder: Pick<LockedRender
  * outputs — the caller picks the right shape based on `meta/encoder.json`.
  * `renderChunk` enforces the same choice via `outputKind` on the result.
  */
-export declare function renderChunk(planDir: string, chunkIndex: number, outputChunkPath: string): Promise<EffectiveChunkResult>;
+export declare function renderChunk(planDir: string, chunkIndex: number, outputChunkPath: string, options?: RenderChunkOptions): Promise<EffectiveChunkResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/producer",
-  "version": "0.8.178",
+  "version": "0.8.180",
   "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/core": "0.8.178",
-    "@hyperframes/engine": "0.8.178",
-    "@hyperframes/lint": "0.8.178",
-    "@hyperframes/parsers": "0.8.178",
-    "@hyperframes/studio-server": "0.8.178"
+    "@hyperframes/engine": "0.8.180",
+    "@hyperframes/lint": "0.8.180",
+    "@hyperframes/parsers": "0.8.180",
+    "@hyperframes/core": "0.8.180",
+    "@hyperframes/studio-server": "0.8.180"
   },
   "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.178"
+    "@hyperframes/aws-lambda": "0.8.180"
   },
   "engines": {
     "node": ">=22"