@hyperframes/producer 0.8.231 → 0.9.1

package/dist/distributed.d.ts

@@ -2,8 +2,9 @@
  * `@hyperframes/producer/distributed` — the distributed render primitives.
  *
  * The distributed activities are pure functions over local file paths;
- * networking + orchestration live in adapters. New integrations should use
- * Plan v2; the v1 functions remain available for compatibility.
+ * networking + orchestration live in adapters. Plan v2 is the only public
+ * transport; chunk and assemble primitives consume its materialized execution
+ * directory.
  *
  * Adopters (AWS Lambda, Cloud Run Jobs, Temporal, K8s Jobs, plain SSH):
  *
@@ -29,8 +30,8 @@
  * No networking, no AWS SDK, no Temporal SDK — those live in adapter
  * packages. This module is library code only.
  */
-export { buildChunkSlices, measurePlanDirBytes, plan, rejectUnsupportedDistributedFormat, resolveChunkPlan, buildPlanAudio, plansSeparateAudio, type DistributedRenderConfig, type PlanResult, type RemoteProjectFile, DEFAULT_CHUNK_SIZE, DEFAULT_MAX_PARALLEL_CHUNKS, MIN_CHUNK_SIZE, PLAN_DIR_SIZE_LIMIT_BYTES, PLAN_PROJECT_DIR_SKIP_SEGMENTS, CHUNK_EXCEEDS_WORKER_TIMEOUT, ChunkExceedsWorkerTimeoutError, FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED, FormatNotSupportedInDistributedError, PLAN_TOO_LARGE, PlanTooLargeError, } from "./services/distributed/plan.js";
-export { createPlanV2FromExecutionPlan, createPlanV2FromV1, getPlanV2ExecutionPlanHash, isPlanV2DeferredSourceArtifact, listPlanV2ArtifactsForTarget, materializePlanV2Target, planV2, planV2WithPublisher, publishPlanV2FromExecutionPlan, publishPlanV2FromV1, readPlanV2Manifest, validatePlanV2MaterializedTarget, PLAN_V2_INTEGRITY_UNRECOVERABLE, PLAN_V2_MATERIALIZATION_MARKER, PlanV2IntegrityError, type PlanV2Artifact, type PlanV2Limitations, type PlanV2Manifest, type PlanV2MaterializeOptions, type PlanV2MaterializationResult, type PlanV2MaterializationTarget, type PlanV2RemoteSources, type PlanV2Result, type PlanV2WithPublisherOptions, } from "./services/distributed/planV2.js";
+export { buildChunkSlices, measurePlanDirBytes, rejectUnsupportedDistributedFormat, resolveChunkPlan, buildPlanAudio, plansSeparateAudio, type DistributedRenderConfig, type RemoteProjectFile, DEFAULT_CHUNK_SIZE, DEFAULT_MAX_PARALLEL_CHUNKS, MIN_CHUNK_SIZE, PLAN_DIR_SIZE_LIMIT_BYTES, PLAN_PROJECT_DIR_SKIP_SEGMENTS, CHUNK_EXCEEDS_WORKER_TIMEOUT, ChunkExceedsWorkerTimeoutError, FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED, FormatNotSupportedInDistributedError, } from "./services/distributed/plan.js";
+export { createPlanV2FromExecutionPlan, getPlanV2ExecutionPlanHash, isPlanV2DeferredSourceArtifact, listPlanV2ArtifactsForTarget, materializePlanV2Target, planV2, planV2WithPublisher, publishPlanV2FromExecutionPlan, readPlanV2Manifest, validatePlanV2MaterializedTarget, PLAN_V2_INTEGRITY_UNRECOVERABLE, PLAN_V2_MATERIALIZATION_MARKER, PlanV2IntegrityError, type PlanV2Artifact, type PlanV2Limitations, type PlanV2Manifest, type PlanV2MaterializeOptions, type PlanV2MaterializationResult, type PlanV2MaterializationTarget, type PlanV2RemoteSources, type PlanV2Result, type PlanV2WithPublisherOptions, } from "./services/distributed/planV2.js";
 export { LocalPlanV2ArtifactPublisher, type LocalPlanV2ArtifactPublisherOptions, type PlanV2ArtifactPublisher, type PlanV2PublishBlob, } from "./services/distributed/planV2Publisher.js";
 export { assembleV2, renderChunkV2 } from "./services/distributed/planV2Execution.js";
 export { applyRuntimeEnvSnapshot, readWebGlVendorInfoFromCanvas, renderChunk, type ChunkFrameRange, type ChunkRenderer, type ChunkResult, type EffectiveChunkResult, type RenderChunkOptions, CHUNK_FRAME_RANGE_INVALID, FFMPEG_VERSION_MISMATCH, INVALID_VIDEO_METADATA, PLAN_HASH_MISMATCH, RenderChunkValidationError, } from "./services/distributed/renderChunk.js";
@@ -41,7 +42,7 @@ export { InvalidConfigError, type SerializableDistributedRenderConfig, validateD
 export { hashProjectDir, listSiteFiles } from "./services/distributed/projectHash.js";
 export { AUDIO_SIDECAR_MIN_BYTES, buildAudioSidecar, wantsAudioSidecar, type AudioSidecarOutcome, } from "./services/distributed/audioSidecar.js";
 export { buildProbeFacts, wantsProbeFacts, type ProbeFactsOutcome, } from "./services/distributed/probeFacts.js";
-export { CURRENT_PLAN_PROTOCOL, DISTRIBUTED_RENDER_CAPABILITIES, getDistributedRenderCapabilities, PLAN_ARTIFACT_LAYOUT, PLAN_HASH_SCHEMA, PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2, PLAN_PROTOCOL_UNSUPPORTED, PLAN_SCHEMA_VERSION, PLAN_V2_ARTIFACT_LAYOUT, PLAN_V2_HASH_SCHEMA, PLAN_V2_SCHEMA_VERSION, PlanProtocolUnsupportedError, readPlanProtocol, readPlanProtocolV1, type DistributedRenderCapabilities, type PlanProtocolConsumerCapabilities, type PlanProtocolDescriptor, type PlanProtocolV1Descriptor, type PlanProtocolV2Descriptor, type SupportedPlanProtocolDescriptor, } from "./services/distributed/planProtocol.js";
+export { PLAN_PROTOCOL_V2, PLAN_PROTOCOL_UNSUPPORTED, PLAN_V2_ARTIFACT_LAYOUT, PLAN_V2_HASH_SCHEMA, PLAN_V2_SCHEMA_VERSION, PlanProtocolUnsupportedError, type PlanProtocolDescriptor, type PlanProtocolV2Descriptor, } from "./services/distributed/planProtocol.js";
 export { PlanVideosMetadataError, type DistributedFormat } from "./services/distributed/shared.js";
 export { isPlanAudioArtifactPath, PLAN_AUDIO_LEGACY_RELATIVE_PATH, PLAN_AUDIO_RELATIVE_PATH, resolvePlanAudioPath, } from "./services/distributed/shared.js";
 export type { ChunkSliceJson, CompositionMetadataJson, LockedRenderConfig, } from "./services/render/stages/freezePlan.js";

package/dist/distributed.js

@@ -6085,14 +6085,14 @@ async function padOrTrimAudioToVideoFrameCount(input) {
     );
   }
   const targetDurationSeconds = videoInfo.frameCount * videoInfo.fpsDen / videoInfo.fpsNum;
-  const plan2 = buildPadTrimAudioPlan(
+  const plan = buildPadTrimAudioPlan(
     input.audioPath,
     input.outputPath,
     audioInfo.durationSeconds,
     targetDurationSeconds
   );
   try {
-    for (const step of plan2.steps) {
+    for (const step of plan.steps) {
       const ffmpegResult = step.kind === "copy" ? await runner(step.args) : await encode(input.audioPath, input.outputPath, targetDurationSeconds, step.filter);
       if (!ffmpegResult.success) {
         return {
@@ -6100,7 +6100,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
           outputPath: input.outputPath,
           targetDurationSeconds,
           sourceDurationSeconds: audioInfo.durationSeconds,
-          operation: plan2.operation,
+          operation: plan.operation,
           error: ffmpegResult.error,
           failureReason: ffmpegResult.failureReason
         };
@@ -6112,11 +6112,11 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       outputPath: input.outputPath,
       targetDurationSeconds,
       sourceDurationSeconds: audioInfo.durationSeconds,
-      operation: plan2.operation,
-      error: `audioPadTrim: failed to materialize ${plan2.operation}: ${err instanceof Error ? err.message : String(err)}`
+      operation: plan.operation,
+      error: `audioPadTrim: failed to materialize ${plan.operation}: ${err instanceof Error ? err.message : String(err)}`
     };
   } finally {
-    for (const path of plan2.cleanupPaths) removeScratch(path);
+    for (const path of plan.cleanupPaths) removeScratch(path);
   }
   let loweredDb = 0;
   if (probeTruePeak) {
@@ -6133,7 +6133,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
         outputPath: input.outputPath,
         targetDurationSeconds,
         sourceDurationSeconds: audioInfo.durationSeconds,
-        operation: plan2.operation,
+        operation: plan.operation,
         error: correction.error,
         failureReason: correction.failureReason
       };
@@ -6145,7 +6145,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
     outputPath: input.outputPath,
     targetDurationSeconds,
     sourceDurationSeconds: audioInfo.durationSeconds,
-    operation: plan2.operation,
+    operation: plan.operation,
     ...loweredDb > 0 ? { audioLoweredDb: loweredDb } : {}
   };
 }
@@ -6634,7 +6634,7 @@ async function runCaptureStage(input) {
     job,
     totalFrames,
     cfg,
-    plan: plan2,
+    plan,
     log,
     captureAttempts,
     buildCaptureOptions,
@@ -6645,8 +6645,8 @@ async function runCaptureStage(input) {
     dedupPerfs
   } = input;
   let { probeSession } = input;
-  let { workerCount } = plan2;
-  const { forceScreenshot } = plan2;
+  let { workerCount } = plan;
+  const { forceScreenshot } = plan;
   let lastBrowserConsole = [];
   const workerPageErrors = [];
   let captureBeyondViewport = probeSession?.options.captureBeyondViewport;
@@ -8358,7 +8358,6 @@ var PLAN_PROTOCOL_V1 = Object.freeze({
   artifactLayout: PLAN_ARTIFACT_LAYOUT,
   hashSchema: PLAN_HASH_SCHEMA
 });
-var CURRENT_PLAN_PROTOCOL = PLAN_PROTOCOL_V1;
 var PLAN_PROTOCOL_V2 = Object.freeze({
   schemaVersion: PLAN_V2_SCHEMA_VERSION,
   artifactLayout: PLAN_V2_ARTIFACT_LAYOUT,
@@ -8380,9 +8379,6 @@ var DISTRIBUTED_RENDER_CAPABILITIES = Object.freeze({
   }),
   chunkFrameRange: true
 });
-function getDistributedRenderCapabilities() {
-  return DISTRIBUTED_RENDER_CAPABILITIES;
-}
 var PlanProtocolUnsupportedError = class extends Error {
   // Public adapters inspect this typed code even though OSS producer does not.
   // fallow-ignore-next-line unused-class-member
@@ -8956,10 +8952,10 @@ function buildStbl(stsd, track) {
   );
 }
 var codecOf = (track) => track.stsd.toString("latin1", 20, 24);
-var sameTrack = (track, plan2) => track.handler === plan2.handler && track.timescale === plan2.timescale && codecOf(track) === codecOf(plan2);
-function planTracksOf(tracks, plan2, index) {
+var sameTrack = (track, plan) => track.handler === plan.handler && track.timescale === plan.timescale && codecOf(track) === codecOf(plan);
+function planTracksOf(tracks, plan, index) {
   let next = 0;
-  const matched = plan2.map((planTrack) => {
+  const matched = plan.map((planTrack) => {
     const track = tracks[next];
     if (track && sameTrack(track, planTrack)) return tracks[next++];
     if (planTrack.handler === "soun") return null;
@@ -8980,22 +8976,22 @@ function sourceTracks(layouts, audio) {
   if (audio && (audioTracks.length !== 1 || audioTracks[0].handler !== "soun")) {
     throw new Error("[mp4Stitch] the separate audio file must hold one audio track");
   }
-  const plan2 = [...chunkPlan, ...audioTracks];
+  const plan = [...chunkPlan, ...audioTracks];
   const chunks = layouts.map((layout, i) => {
     const tracks = readTracks(layout.moov);
     if (audio && tracks.some((track) => track.handler === "soun")) {
       throw new Error(`[mp4Stitch] chunk ${i} carries its own audio`);
     }
-    return planTracksOf(tracks, plan2, i);
+    return planTracksOf(tracks, plan, i);
   });
   return {
-    plan: plan2,
+    plan,
     chunkTrackCount: chunkPlan.length,
     sources: audio ? [[...chunkPlan.map(() => null), audioTracks[0]], ...chunks] : chunks
   };
 }
 function buildStitchedHeader(layouts, audio) {
-  const { plan: plan2, chunkTrackCount, sources } = sourceTracks(layouts, audio);
+  const { plan, chunkTrackCount, sources } = sourceTracks(layouts, audio);
   const sourceLayouts = audio ? [audio, ...layouts] : layouts;
   const payloadBases = [];
   let payloadBytes = 0;
@@ -9007,10 +9003,10 @@ function buildStitchedHeader(layouts, audio) {
   const root = boxAt(template, 0, 0, template.length);
   const mvhd = child2(template, root, "mvhd");
   const movieTimescale = timescaleOf(template, mvhd);
-  const chunkTrackIds = plan2.slice(0, chunkTrackCount).map((track) => idOf(template, child2(template, track.trak, "tkhd")));
+  const chunkTrackIds = plan.slice(0, chunkTrackCount).map((track) => idOf(template, child2(template, track.trak, "tkhd")));
   const audioTrackId = Math.max(...chunkTrackIds) + 1;
   const buildMoov = (dataStart2) => {
-    const traks = plan2.map((track, t) => {
+    const traks = plan.map((track, t) => {
       const parts = sources.flatMap((tracks, chunk) => {
         const part = tracks[t];
         return part ? [{ ...part, chunk }] : [];
@@ -10297,22 +10293,6 @@ async function buildPlanAudio(projectDir, config, workRoot, outputPath, options
     rmSync7(c.workDir, { recursive: true, force: true });
   }
 }
-async function plan(projectDir, config, planDir, options = {}) {
-  const executionPlan = await buildLocalExecutionPlan(projectDir, config, planDir, options);
-  return {
-    planDir: executionPlan.executionPlanDir,
-    planProtocol: PLAN_PROTOCOL_V1,
-    planHash: executionPlan.executionPlanHash,
-    chunkCount: executionPlan.chunkCount,
-    totalFrames: executionPlan.totalFrames,
-    fps: executionPlan.fps,
-    width: executionPlan.width,
-    height: executionPlan.height,
-    format: executionPlan.format,
-    ffmpegVersion: executionPlan.ffmpegVersion,
-    producerVersion: executionPlan.producerVersion
-  };
-}
 
 // src/services/distributed/planV2.ts
 import {
@@ -10857,9 +10837,6 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
     throw error;
   }
 }
-function createPlanV2FromV1(executionPlanDir, planV2Dir) {
-  return createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir);
-}
 async function publishPlanV2FromExecutionPlan(executionPlanDir, publisher) {
   return publishExecutionPlan(executionPlanDir, publisher, {});
 }
@@ -10889,9 +10866,6 @@ async function publishExecutionPlan(executionPlanDir, publisher, { digests, log
     throw error;
   }
 }
-async function publishPlanV2FromV1(executionPlanDir, publisher) {
-  return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
-}
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
   const stagingRoot = mkdtempSync4(join26(options.stagingParentDir ?? tmpdir(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
@@ -10951,8 +10925,8 @@ function resultFromManifest(planV2Dir, manifest) {
     limitations: manifest.limitations
   };
 }
-function getPlanV2ExecutionPlanHash(plan2) {
-  return plan2.sourcePlanV1Hash;
+function getPlanV2ExecutionPlanHash(plan) {
+  return plan.sourcePlanV1Hash;
 }
 function readString2(value, field) {
   if (typeof value !== "string" || value.length === 0) {
@@ -11242,10 +11216,10 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   const start = Date.now();
   const log = options?.logger ?? defaultLogger;
   const cfr = options?.cfr === true;
-  const plan2 = readAssemblePlan(planDir, chunkOutputs);
+  const plan = readAssemblePlan(planDir, chunkOutputs);
   const chunkPaths = chunkOutputs.flat();
-  if (plan2.dimensions.format === "png-sequence") {
-    return mergePngFrameDirs(chunkPaths, outputPath, plan2.totalFrames, audioPath, start);
+  if (plan.dimensions.format === "png-sequence") {
+    return mergePngFrameDirs(chunkPaths, outputPath, plan.totalFrames, audioPath, start);
   }
   if (chunksAreStitchedMp4(planDir, cfr)) {
     const separateAudio = stitchesSeparateAudio(planDir) && audioPath !== null;
@@ -11253,17 +11227,17 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     return {
       outputPath,
       durationMs: Date.now() - start,
-      framesEncoded: plan2.totalFrames,
+      framesEncoded: plan.totalFrames,
       fileSize: statSync8(outputPath).size
     };
   }
-  const format = plan2.dimensions.format;
+  const format = plan.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
   if (!existsSync19(dirname14(outputPath))) {
     mkdirSync13(dirname14(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync5(`${outputPath}.assemble-work-`);
-  const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
+  const fps = { num: plan.dimensions.fpsNum, den: plan.dimensions.fpsDen };
   const stageMs = {};
   const ctx = {
     workDir,
@@ -11305,7 +11279,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   return {
     outputPath,
     durationMs: Date.now() - start,
-    framesEncoded: plan2.totalFrames,
+    framesEncoded: plan.totalFrames,
     fileSize
   };
 }
@@ -11315,8 +11289,8 @@ function readAssemblePlan(planDir, chunkPaths) {
   if (!existsSync19(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
-  const plan2 = JSON.parse(readFileSync9(planJsonPath, "utf-8"));
-  readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
+  const plan = JSON.parse(readFileSync9(planJsonPath, "utf-8"));
+  readPlanProtocolV1(plan, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
   if (!existsSync19(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
@@ -11337,7 +11311,7 @@ function readAssemblePlan(planDir, chunkPaths) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
-  return plan2;
+  return plan;
 }
 function videoInputArgs(ctx, videoSources) {
   return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg);
@@ -11467,8 +11441,8 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync9(join27(planDir, "plan.json"), "utf-8"));
-  return plan2.dimensions.format;
+  const plan = JSON.parse(readFileSync9(join27(planDir, "plan.json"), "utf-8"));
+  return plan.dimensions.format;
 }
 function lockedAudio(planDir) {
   const encoderJsonPath = join27(planDir, "meta", "encoder.json");
@@ -11691,8 +11665,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
     );
   }
-  const plan2 = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
-  readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk);
+  const plan = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
+  readPlanProtocolV1(plan, DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk);
   const planHashStarted = Date.now();
   const v2Materialization = readValidatedPlanV2Materialization(planDir, {
     role: "chunk",
@@ -11750,10 +11724,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     );
   }
   const ffmpegVersion = await readFfmpegVersion();
-  if (ffmpegVersion !== plan2.ffmpegVersion) {
+  if (ffmpegVersion !== plan.ffmpegVersion) {
     throw new RenderChunkValidationError(
       FFMPEG_VERSION_MISMATCH,
-      `[renderChunk] ffmpeg version on this worker does not match planDir. planDir: ${JSON.stringify(plan2.ffmpegVersion)}; worker: ${JSON.stringify(ffmpegVersion)}. Distributed retries require byte-identical ffmpeg builds across workers. Re-plan from a worker matching this version, or run all renders on an image with the planDir's ffmpeg.`
+      `[renderChunk] ffmpeg version on this worker does not match planDir. planDir: ${JSON.stringify(plan.ffmpegVersion)}; worker: ${JSON.stringify(ffmpegVersion)}. Distributed retries require byte-identical ffmpeg builds across workers. Re-plan from a worker matching this version, or run all renders on an image with the planDir's ffmpeg.`
     );
   }
   if (encoder.browserGpuMode !== "software") {
@@ -11762,12 +11736,12 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       `[renderChunk] planDir requires browserGpuMode=software, got ${JSON.stringify(encoder.browserGpuMode)}.`
     );
   }
-  const recomputedPlanHash = v2Manifest === null ? recomputePlanHashFromPlanDir(planDir) : plan2.planHash;
+  const recomputedPlanHash = v2Manifest === null ? recomputePlanHashFromPlanDir(planDir) : plan.planHash;
   const planHashMs = Date.now() - planHashStarted;
-  if (recomputedPlanHash !== plan2.planHash) {
+  if (recomputedPlanHash !== plan.planHash) {
     throw new RenderChunkValidationError(
       PLAN_HASH_MISMATCH,
-      `[renderChunk] planDir content fingerprint does not match plan.json.planHash. plan.json: ${plan2.planHash}; recomputed: ${recomputedPlanHash}. Likely a corrupted artifact (partial S3 download, manual tampering) or a planDir produced by an incompatible producer version. Re-plan and re-fan-out.`
+      `[renderChunk] planDir content fingerprint does not match plan.json.planHash. plan.json: ${plan.planHash}; recomputed: ${recomputedPlanHash}. Likely a corrupted artifact (partial S3 download, manual tampering) or a planDir produced by an incompatible producer version. Re-plan and re-fan-out.`
     );
   }
   if (!encoder.runtimeEnv || typeof encoder.runtimeEnv !== "object") {
@@ -11779,16 +11753,16 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const envRestore = applyRuntimeEnvSnapshot(encoder.runtimeEnv);
   try {
     const job = buildSyntheticRenderJob({
-      fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
+      fps: { num: plan.dimensions.fpsNum, den: plan.dimensions.fpsDen },
       quality: encoder.quality,
-      format: plan2.dimensions.format,
+      format: plan.dimensions.format,
       crf: encoder.crf,
       bitrate: encoder.bitrate,
       hdrMode: "force-sdr",
       entryFile: "index.html"
     });
     job.totalFrames = framesInChunk;
-    job.duration = framesInChunk * plan2.dimensions.fpsDen / plan2.dimensions.fpsNum;
+    job.duration = framesInChunk * plan.dimensions.fpsDen / plan.dimensions.fpsNum;
     const cfg = {
       ...resolveConfig5(),
       browserGpuMode: "software",
@@ -11804,7 +11778,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     mkdirSync14(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
-    const chunkFps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
+    const chunkFps = { num: plan.dimensions.fpsNum, den: plan.dimensions.fpsDen };
     const deferredVideos = planVideos?.extracted.filter((video) => video.deferredRange) ?? [];
     const shownFrames = planVideos ? shownDeferredFrameIndexes(planVideos, chunkFrameNumbers, chunkFps) : /* @__PURE__ */ new Map();
     const remoteVideoIds = new Set(
@@ -11819,10 +11793,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       preHeadScripts: [buildVirtualTimeShim({ seedRandomFromFrame: true })],
       // These dimensions are frozen by the controller from the render job, so
       // chunk runtime seek quantization stays on the same fps grid as capture.
-      fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen }
+      fps: { num: plan.dimensions.fpsNum, den: plan.dimensions.fpsDen }
     });
     const captureOptions = buildChunkCaptureOptions({
-      dimensions: plan2.dimensions,
+      dimensions: plan.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
       html: readFileSync10(join28(compiledDir, "index.html"), "utf-8"),
@@ -11979,9 +11953,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         videoFrameLookup,
         frameCacheOptions(cfg, chunkWorkerCount)
       );
-      const isPngSequence = plan2.dimensions.format === "png-sequence";
+      const isPngSequence = plan.dimensions.format === "png-sequence";
       outputKind = isPngSequence ? "frame-dir" : "file";
-      const presetFormat = isPngSequence ? "mp4" : plan2.dimensions.format;
+      const presetFormat = isPngSequence ? "mp4" : plan.dimensions.format;
       const basePreset = getEncoderPreset6(
         job.config.quality,
         presetFormat,
@@ -12004,9 +11978,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         outputPath: videoOnlyPath,
         framesDir,
         videoOnlyPath,
-        width: Math.round(plan2.dimensions.width * encoder.deviceScaleFactor),
-        height: Math.round(plan2.dimensions.height * encoder.deviceScaleFactor),
-        needsAlpha: plan2.dimensions.format !== "mp4",
+        width: Math.round(plan.dimensions.width * encoder.deviceScaleFactor),
+        height: Math.round(plan.dimensions.height * encoder.deviceScaleFactor),
+        needsAlpha: plan.dimensions.format !== "mp4",
         captureImageFormat: captureOptions.format ?? "jpeg",
         // The encoder writes video only; audio joins at assemble time or in the
         // chunk that carries audio. Suppressing `hasAudio` skips the png-sequence audio
@@ -12065,7 +12039,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
             useLayeredComposite: false,
             usePageSideCompositing: false,
             hasHdrContent: false,
-            needsAlpha: plan2.dimensions.format !== "mp4"
+            needsAlpha: plan.dimensions.format !== "mp4"
           });
           if (capturePlan.kind !== "sdr_disk") {
             throw new Error(`Distributed chunk requires sdr_disk plan; got ${capturePlan.kind}`);
@@ -12155,7 +12129,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           outputPath: outputChunkPath,
           chunks: audioChunks.chunks,
           chunkIndex: audioChunks.index,
-          fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
+          fps: { num: plan.dimensions.fpsNum, den: plan.dimensions.fpsDen },
           timeoutMs: cfg.ffmpegProcessTimeout
         });
         rmSync11(videoOnlyPath, { force: true });
@@ -12185,7 +12159,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     const durationMs = Date.now() - start;
     const perfPath = `${outputChunkPath}.perf.json`;
     const perfPayload = {
-      planHash: plan2.planHash,
+      planHash: plan.planHash,
       chunkIndex,
       startFrame: range.startFrame,
       endFrame: range.endFrame,
@@ -12203,7 +12177,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       videoShownBoxes: Object.fromEntries(shownBoxes ?? []),
       sha256,
       outputKind,
-      producerVersion: plan2.producerVersion,
+      producerVersion: plan.producerVersion,
       ffmpegVersion
     };
     writeFileSync11(perfPath, `${JSON.stringify(perfPayload, null, 2)}
@@ -12643,12 +12617,10 @@ export {
   AUDIO_SIDECAR_MIN_BYTES,
   CHUNK_EXCEEDS_WORKER_TIMEOUT,
   CHUNK_FRAME_RANGE_INVALID,
-  CURRENT_PLAN_PROTOCOL,
   ChunkExceedsWorkerTimeoutError,
   DEFAULT_CHUNK_SIZE,
   DEFAULT_MAX_PARALLEL_CHUNKS,
   DISTRIBUTED_DURATION_OUT_OF_RANGE,
-  DISTRIBUTED_RENDER_CAPABILITIES,
   FFMPEG_VERSION_MISMATCH,
   FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED,
   FormatNotSupportedInDistributedError,
@@ -12657,25 +12629,19 @@ export {
   LocalPlanV2ArtifactPublisher,
   MAX_DISTRIBUTED_DURATION_SECONDS,
   MIN_CHUNK_SIZE,
-  PLAN_ARTIFACT_LAYOUT,
   PLAN_AUDIO_LEGACY_RELATIVE_PATH,
   PLAN_AUDIO_RELATIVE_PATH,
   PLAN_DIR_SIZE_LIMIT_BYTES,
   PLAN_HASH_MISMATCH,
-  PLAN_HASH_SCHEMA,
   PLAN_PROJECT_DIR_SKIP_SEGMENTS,
   PLAN_PROTOCOL_UNSUPPORTED,
-  PLAN_PROTOCOL_V1,
   PLAN_PROTOCOL_V2,
-  PLAN_SCHEMA_VERSION,
-  PLAN_TOO_LARGE,
   PLAN_V2_ARTIFACT_LAYOUT,
   PLAN_V2_HASH_SCHEMA,
   PLAN_V2_INTEGRITY_UNRECOVERABLE,
   PLAN_V2_MATERIALIZATION_MARKER,
   PLAN_V2_SCHEMA_VERSION,
   PlanProtocolUnsupportedError,
-  PlanTooLargeError,
   PlanV2IntegrityError,
   PlanValidationError,
   PlanVideosMetadataError,
@@ -12690,8 +12656,6 @@ export {
   buildStitchedHeader,
   chunksAreStitchedMp4,
   createPlanV2FromExecutionPlan,
-  createPlanV2FromV1,
-  getDistributedRenderCapabilities,
   getPlanV2ExecutionPlanHash,
   hashProjectDir,
   isPlanAudioArtifactPath,
@@ -12701,15 +12665,11 @@ export {
   materializePlanV2Target,
   measurePlanDirBytes,
   muxChunkWithAudio,
-  plan,
   planV2,
   planV2WithPublisher,
   plansSeparateAudio,
   publishPlanV2FromExecutionPlan,
-  publishPlanV2FromV1,
   readMp4Layout,
-  readPlanProtocol,
-  readPlanProtocolV1,
   readPlanV2Manifest,
   readWebGlVendorInfoFromCanvas2 as readWebGlVendorInfoFromCanvas,
   rejectUnsupportedDistributedFormat,

package/dist/hyperframe.manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "0.1.0",
   "buildId": "dev",
-  "sha256": "26a38a1b27437168d361cad2fffff9ae50f5a86ce880bb7f3fb473b97304fec5",
+  "sha256": "6018b9f4174f36358ea66bf885e50e05ed18042628340e4e488bbaf5584e8a8a",
   "artifacts": {
     "iife": "hyperframe.runtime.iife.js",
     "esm": "hyperframe.runtime.mjs"