@hyperframes/producer 0.8.175 → 0.8.176

package/dist/distributed.js

@@ -3,15 +3,18 @@ import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframe
 import {
   copyFileSync as copyFileSync5,
   cpSync as cpSync2,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   linkSync,
   mkdirSync as mkdirSync8,
   renameSync as renameSync3,
   rmSync as rmSync7,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { extname as extname3, isAbsolute as isAbsolute3, join as join18, relative as relative5, sep as sep2 } from "node:path";
-import { fpsToNumber as fpsToNumber10 } from "@hyperframes/core";
+import { extname as extname4, isAbsolute as isAbsolute3, join as join20, relative as relative5, sep as sep2 } from "node:path";
+import {
+  fpsToNumber as fpsToNumber10,
+  HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
+} from "@hyperframes/core";
 import {
   getEncoderPreset as getEncoderPreset4,
   normalizeVp9CpuUsed,
@@ -1340,6 +1343,81 @@ import {
   createCaptureSession as createCaptureSession3,
   initializeSession as initializeSession3
 } from "@hyperframes/engine";
+var CAPTURE_CALIBRATION_TARGET_MS = 600;
+var MAX_MEASURED_CAPTURE_COST_MULTIPLIER = 8;
+var CAPTURE_CALIBRATION_PROTOCOL_TIMEOUT_MS = 3e4;
+function createCaptureCalibrationConfig(cfg) {
+  return {
+    ...cfg,
+    protocolTimeout: Math.min(cfg.protocolTimeout, CAPTURE_CALIBRATION_PROTOCOL_TIMEOUT_MS)
+  };
+}
+function estimateMeasuredCaptureCostMultiplier(samples) {
+  if (samples.length === 0) {
+    return { multiplier: 1, reasons: [] };
+  }
+  const sorted = [...samples].sort((a, b) => a.captureTimeMs - b.captureTimeMs);
+  const p95Index = Math.max(0, Math.ceil(sorted.length * 0.95) - 1);
+  const p95Sample = sorted[p95Index] ?? sorted[sorted.length - 1];
+  if (!p95Sample) {
+    return { multiplier: 1, reasons: [] };
+  }
+  const p95Ms = Math.round(p95Sample.captureTimeMs);
+  const multiplier = Math.min(
+    MAX_MEASURED_CAPTURE_COST_MULTIPLIER,
+    Math.max(1, Math.round(p95Ms / CAPTURE_CALIBRATION_TARGET_MS * 100) / 100)
+  );
+  return {
+    multiplier,
+    reasons: multiplier > 1 ? [`calibration-p95=${p95Ms}ms`] : [],
+    p95Ms
+  };
+}
+function selectCaptureCalibrationFrames(totalFrames) {
+  if (totalFrames <= 0) return [];
+  const lastFrame = totalFrames - 1;
+  const candidates = [
+    0,
+    Math.floor(totalFrames * 0.25),
+    Math.floor(totalFrames * 0.5),
+    Math.floor(totalFrames * 0.75),
+    lastFrame
+  ];
+  return Array.from(
+    new Set(candidates.map((frame) => Math.max(0, Math.min(lastFrame, frame))))
+  ).sort((a, b) => a - b);
+}
+async function measureCaptureCostFromSession(session, totalFrames, fps, log) {
+  const sampledFrames = selectCaptureCalibrationFrames(totalFrames);
+  const samples = [];
+  const totalSamples = sampledFrames.length;
+  const savedStaticFrames = session.staticFrames;
+  session.staticFrames = void 0;
+  try {
+    for (let i = 0; i < sampledFrames.length; i++) {
+      const frameIndex = sampledFrames[i];
+      log?.info(`Calibration: capturing test frame ${i + 1}/${totalSamples}...`);
+      const time = frameIndex / fps;
+      const startedAt = Date.now();
+      const result = await captureFrameToBuffer3(session, frameIndex, time);
+      samples.push({
+        frameIndex,
+        captureTimeMs: result.captureTimeMs || Date.now() - startedAt
+      });
+    }
+  } finally {
+    session.staticFrames = savedStaticFrames;
+    session.lastFrameBuffer = void 0;
+  }
+  const estimate = estimateMeasuredCaptureCostMultiplier(samples);
+  if (estimate.p95Ms !== void 0) {
+    log?.info(`Calibration complete, estimated cost: ${estimate.p95Ms}ms/frame (p95)`);
+  }
+  return {
+    estimate,
+    samples
+  };
+}
 
 // src/services/render/observability.ts
 import { redactTelemetryString } from "@hyperframes/core";
@@ -6360,673 +6438,896 @@ function createRenderJob(config) {
 }
 var DEFAULT_SEGMENTED_MIN_SECONDS = Number.POSITIVE_INFINITY;
 
-// src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync7, readdirSync as readdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join15, relative as relative3, resolve as resolve7 } from "node:path";
+// src/services/distributed/planFrameCost.ts
+import { join as join17 } from "node:path";
+import {
+  closeCaptureSession as closeCaptureSession9,
+  createCaptureSession as createCaptureSession8,
+  createFrameLookupTable as createFrameLookupTable3,
+  initializeSession as initializeSession8
+} from "@hyperframes/engine";
 
-// src/services/distributed/planProtocol.ts
-var PLAN_SCHEMA_VERSION = 1;
-var PLAN_ARTIFACT_LAYOUT = "plan-dir-v1";
-var PLAN_HASH_SCHEMA = "hyperframes-plan-hash-v1";
-var PLAN_V2_SCHEMA_VERSION = 2;
-var PLAN_V2_ARTIFACT_LAYOUT = "content-addressed-plan-v2";
-var PLAN_V2_HASH_SCHEMA = "hyperframes-plan-manifest-hash-v2";
-var PLAN_PROTOCOL_UNSUPPORTED = "PLAN_PROTOCOL_UNSUPPORTED";
-var PLAN_PROTOCOL_V1 = Object.freeze({
-  schemaVersion: PLAN_SCHEMA_VERSION,
-  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,
-  hashSchema: PLAN_V2_HASH_SCHEMA
-});
-var DISTRIBUTED_RENDER_CAPABILITIES = Object.freeze({
-  roles: Object.freeze({
-    planner: Object.freeze({
-      produces: Object.freeze([PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2])
-    }),
-    chunk: Object.freeze({
-      accepts: Object.freeze([PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2]),
-      acceptsLegacyV1WithoutDescriptor: true
-    }),
-    assembler: Object.freeze({
-      accepts: Object.freeze([PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2]),
-      acceptsLegacyV1WithoutDescriptor: true
-    })
-  })
-});
-function getDistributedRenderCapabilities() {
-  return DISTRIBUTED_RENDER_CAPABILITIES;
+// src/services/distributed/chunkFrames.ts
+import { existsSync as existsSync12, readdirSync as readdirSync4 } from "node:fs";
+import { extname as extname2, join as join16 } from "node:path";
+import {
+  compositionRequiresWebGpu as compositionRequiresWebGpu3,
+  createFrameLookupTable as createFrameLookupTable2,
+  createVideoFrameInjector as createVideoFrameInjector2,
+  extractVideoFramesRange
+} from "@hyperframes/engine";
+
+// src/services/distributed/shared.ts
+import { execFile as execFileCallback } from "node:child_process";
+import { dirname as dirname8, join as join15 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { promisify as promisify2 } from "node:util";
+import {
+  getFfmpegBinary,
+  MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME3
+} from "@hyperframes/engine";
+var PLAN_VIDEOS_META_RELATIVE_PATH = "meta/videos.json";
+var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME3;
+var PLAN_AUDIO_LEGACY_RELATIVE_PATH = "audio.aac";
+function isPlanAudioArtifactPath(path) {
+  return path === PLAN_AUDIO_RELATIVE_PATH || path === PLAN_AUDIO_LEGACY_RELATIVE_PATH;
 }
-var PlanProtocolUnsupportedError = class extends Error {
-  // Public adapters inspect this typed code even though OSS producer does not.
+function resolvePlanAudioPath(planDir) {
+  for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
+    const candidate = join15(planDir, name);
+    if (existsSync11(candidate)) return candidate;
+  }
+  return null;
+}
+var INVALID_VIDEO_METADATA = "INVALID_VIDEO_METADATA";
+var PlanVideosMetadataError = class extends Error {
+  // Read by cloud adapters across the package boundary to classify retries.
   // fallow-ignore-next-line unused-class-member
-  code = PLAN_PROTOCOL_UNSUPPORTED;
-  constructor(reason) {
-    super(`[planProtocol] ${reason} (${PLAN_PROTOCOL_UNSUPPORTED})`);
-    this.name = "PlanProtocolUnsupportedError";
+  code = INVALID_VIDEO_METADATA;
+  constructor(message) {
+    super(message);
+    this.name = "PlanVideosMetadataError";
   }
 };
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function protocolMatches(descriptor, expected) {
-  return descriptor.schemaVersion === expected.schemaVersion && descriptor.artifactLayout === expected.artifactLayout && descriptor.hashSchema === expected.hashSchema;
-}
-function capabilitiesAccept(capabilities, protocol) {
-  return capabilities.accepts.some(
-    (accepted) => accepted.schemaVersion === protocol.schemaVersion && accepted.artifactLayout === protocol.artifactLayout && accepted.hashSchema === protocol.hashSchema
-  );
+function metadataError(field, expectation) {
+  throw new PlanVideosMetadataError(`${field} ${expectation}`);
 }
-function readPlanProtocol(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk) {
-  if (!isRecord(planJson)) {
-    throw new PlanProtocolUnsupportedError("plan.json must contain a JSON object");
-  }
-  if (!Object.prototype.hasOwnProperty.call(planJson, "protocol")) {
-    if (!capabilities.acceptsLegacyV1WithoutDescriptor || !capabilitiesAccept(capabilities, PLAN_PROTOCOL_V1)) {
-      throw new PlanProtocolUnsupportedError(
-        "legacy v1 plan without a protocol descriptor is not accepted by this worker"
-      );
-    }
-    return PLAN_PROTOCOL_V1;
+function readRecord(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    metadataError(field, "must be an object");
   }
-  const descriptor = planJson.protocol;
-  if (!isRecord(descriptor)) {
-    throw new PlanProtocolUnsupportedError("plan.json protocol descriptor must be an object");
+  return value;
+}
+function readNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    metadataError(field, "must be a non-empty string");
   }
-  for (const field of ["schemaVersion", "artifactLayout", "hashSchema"]) {
-    if (!Object.prototype.hasOwnProperty.call(descriptor, field)) {
-      throw new PlanProtocolUnsupportedError(`plan.json protocol descriptor is missing ${field}`);
-    }
+  return value;
+}
+function readString(value, field) {
+  if (typeof value !== "string") {
+    metadataError(field, "must be a string");
   }
-  const protocol = protocolMatches(descriptor, PLAN_PROTOCOL_V1) ? PLAN_PROTOCOL_V1 : protocolMatches(descriptor, PLAN_PROTOCOL_V2) ? PLAN_PROTOCOL_V2 : null;
-  if (protocol === null || !capabilitiesAccept(capabilities, protocol)) {
-    throw new PlanProtocolUnsupportedError("unsupported plan.json protocol descriptor");
+  return value;
+}
+function readFiniteNumber(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    metadataError(field, "must be a finite number");
   }
-  return protocol;
+  return value;
 }
-function readPlanProtocolV1(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk) {
-  const protocol = readPlanProtocol(planJson, capabilities);
-  if (protocol !== PLAN_PROTOCOL_V1) {
-    throw new PlanProtocolUnsupportedError(
-      "content-addressed v2 plan must be materialized before v1 layout access"
-    );
+function readBoolean(value, field) {
+  if (typeof value !== "boolean") {
+    metadataError(field, "must be boolean");
   }
-  return PLAN_PROTOCOL_V1;
+  return value;
 }
-
-// src/services/render/stages/planHash.ts
-import { createHash as createHash4 } from "node:crypto";
-import { closeSync as closeSync3, createReadStream as createReadStream3, openSync as openSync3, readSync } from "node:fs";
-var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
-var FIELD_DELIMITER = Buffer.from([0]);
-function computePlanHash(input) {
-  const hash = createHash4("sha256");
-  hash.update(PLAN_HASH_SCHEMA_PREFIX, "utf8");
-  hash.update(input.compositionHtml);
-  hash.update(FIELD_DELIMITER);
-  const sortedAssets = [...input.assets].sort(
-    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
-  );
-  for (const asset of sortedAssets) {
-    hash.update(asset.path, "utf8");
-    hash.update(FIELD_DELIMITER);
-    hash.update(asset.sha256, "utf8");
-    hash.update(FIELD_DELIMITER);
+function readPositiveInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    metadataError(field, "must be a positive integer");
   }
-  hash.update(input.fontSnapshotSha, "utf8");
-  hash.update(FIELD_DELIMITER);
-  hash.update(input.encoderConfigCanonicalJson, "utf8");
-  hash.update(FIELD_DELIMITER);
-  hash.update(input.producerVersion, "utf8");
-  hash.update(FIELD_DELIMITER);
-  hash.update(input.ffmpegVersion, "utf8");
-  hash.update(FIELD_DELIMITER);
-  const d = input.dimensions;
-  hash.update(`${d.fpsNum}/${d.fpsDen}x${d.width}x${d.height}x${d.format}`, "utf8");
-  return hash.digest("hex");
+  return value;
 }
-function canonicalJsonStringify(value) {
-  if (value === null) return "null";
-  if (typeof value === "boolean") return value ? "true" : "false";
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new TypeError(`canonicalJsonStringify: non-finite number ${value}`);
-    }
-    return JSON.stringify(value);
+function readNonNegativeInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    metadataError(field, "must be a non-negative integer");
   }
-  if (typeof value === "string") return JSON.stringify(value);
-  if (Array.isArray(value)) {
-    return `[${value.map(canonicalJsonStringify).join(",")}]`;
+  return value;
+}
+function readDeferredFrameRange(value, field) {
+  const range = readRecord(value, field);
+  const sourcePath = readNonEmptyString(range.sourcePath, `${field}.sourcePath`);
+  if (sourcePath.startsWith("/") || sourcePath.split(/[\\/]/).some((part) => part === "..")) {
+    metadataError(`${field}.sourcePath`, "must stay inside the plan directory");
   }
-  if (typeof value === "object") {
-    const obj = value;
-    const keys = Object.keys(obj).sort();
-    const parts = keys.map((k) => `${JSON.stringify(k)}:${canonicalJsonStringify(obj[k])}`);
-    return `{${parts.join(",")}}`;
+  const durationSeconds = readFiniteNumber(range.durationSeconds, `${field}.durationSeconds`);
+  if (durationSeconds <= 0) metadataError(`${field}.durationSeconds`, "must be positive");
+  if (range.format !== "jpg" && range.format !== "png") {
+    metadataError(`${field}.format`, 'must be "jpg" or "png"');
   }
-  throw new TypeError(`canonicalJsonStringify: unsupported value type ${typeof value}`);
+  return {
+    sourcePath,
+    startTime: readFiniteNumber(range.startTime, `${field}.startTime`),
+    durationSeconds,
+    format: range.format
+  };
 }
-function sha256Hex(bytes) {
-  const h = createHash4("sha256");
-  h.update(bytes);
-  return h.digest("hex");
+function readRateSpec(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number") return readFiniteNumber(value, field);
+  const lane = readRecord(value, field);
+  if (!Array.isArray(lane.points)) {
+    metadataError(`${field}.points`, "must be an array");
+  }
+  return lane;
 }
-function sha256File(path) {
-  const hash = createHash4("sha256");
-  const buffer = Buffer.allocUnsafe(1024 * 1024);
-  const fd = openSync3(path, "r");
-  try {
-    let bytesRead = 0;
-    do {
-      bytesRead = readSync(fd, buffer, 0, buffer.byteLength, null);
-      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
-    } while (bytesRead > 0);
-  } finally {
-    closeSync3(fd);
+function readVideoMetadata(value, field) {
+  const record = readRecord(value, field);
+  let colorSpace = null;
+  if (record.colorSpace !== null) {
+    const color = readRecord(record.colorSpace, `${field}.colorSpace`);
+    colorSpace = {
+      colorTransfer: readString(color.colorTransfer, `${field}.colorSpace.colorTransfer`),
+      colorPrimaries: readString(color.colorPrimaries, `${field}.colorSpace.colorPrimaries`),
+      colorSpace: readString(color.colorSpace, `${field}.colorSpace.colorSpace`)
+    };
   }
-  return hash.digest("hex");
+  return {
+    durationSeconds: readFiniteNumber(record.durationSeconds, `${field}.durationSeconds`),
+    videoStreamDurationSeconds: readFiniteNumber(
+      record.videoStreamDurationSeconds,
+      `${field}.videoStreamDurationSeconds`
+    ),
+    // Plans written before stream-start metadata existed implicitly used the
+    // overwhelmingly common start-at-zero domain. Preserve that compatibility
+    // while carrying non-zero edit-list/transport timestamps in new plans.
+    videoStreamStartSeconds: record.videoStreamStartSeconds === void 0 ? 0 : readFiniteNumber(record.videoStreamStartSeconds, `${field}.videoStreamStartSeconds`),
+    videoStreamLeadSeconds: record.videoStreamLeadSeconds === void 0 ? 0 : readFiniteNumber(record.videoStreamLeadSeconds, `${field}.videoStreamLeadSeconds`),
+    width: readPositiveInteger(record.width, `${field}.width`),
+    height: readPositiveInteger(record.height, `${field}.height`),
+    fps: readFiniteNumber(record.fps, `${field}.fps`),
+    videoCodec: readNonEmptyString(record.videoCodec, `${field}.videoCodec`),
+    hasAudio: readBoolean(record.hasAudio, `${field}.hasAudio`),
+    isVFR: readBoolean(record.isVFR, `${field}.isVFR`),
+    hasAlpha: readBoolean(record.hasAlpha, `${field}.hasAlpha`),
+    colorSpace
+  };
 }
-async function sha256FileAsync(path) {
-  const hash = createHash4("sha256");
-  for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
-    hash.update(chunk);
+function parsePlanVideosJson(value) {
+  const record = readRecord(value, "meta/videos.json");
+  if (!Array.isArray(record.videos) || !Array.isArray(record.extracted)) {
+    metadataError("meta/videos.json", "must contain videos and extracted arrays");
   }
-  return hash.digest("hex");
-}
-
-// src/services/render/stages/freezePlan.ts
-var COMPILED_INDEX_RELATIVE_PATH = "compiled/index.html";
-var HASH_EXCLUDED_PLAN_FILES = /* @__PURE__ */ new Set([
-  "plan.json",
-  "meta/encoder.json",
-  COMPILED_INDEX_RELATIVE_PATH
-]);
-function planFileSha256(absolutePath, digests) {
-  let sha256 = digests?.get(absolutePath);
-  if (sha256 === void 0) {
-    sha256 = sha256File(absolutePath);
-    digests?.set(absolutePath, sha256);
+  const videos = record.videos.map((value2, index) => {
+    const field = `meta/videos.json.videos[${index}]`;
+    const video = readRecord(value2, field);
+    return {
+      id: readNonEmptyString(video.id, `${field}.id`),
+      src: readNonEmptyString(video.src, `${field}.src`),
+      start: readFiniteNumber(video.start, `${field}.start`),
+      end: readFiniteNumber(video.end, `${field}.end`),
+      mediaStart: readFiniteNumber(video.mediaStart, `${field}.mediaStart`),
+      playbackRate: readRateSpec(video.playbackRate, `${field}.playbackRate`),
+      loop: readBoolean(video.loop, `${field}.loop`),
+      hasAudio: readBoolean(video.hasAudio, `${field}.hasAudio`)
+    };
+  });
+  const extracted = record.extracted.map((value2, index) => {
+    const field = `meta/videos.json.extracted[${index}]`;
+    const entry = readRecord(value2, field);
+    return {
+      videoId: readNonEmptyString(entry.videoId, `${field}.videoId`),
+      srcPath: readNonEmptyString(entry.srcPath, `${field}.srcPath`),
+      framePattern: readNonEmptyString(entry.framePattern, `${field}.framePattern`),
+      fps: readFiniteNumber(entry.fps, `${field}.fps`),
+      totalFrames: readNonNegativeInteger(entry.totalFrames, `${field}.totalFrames`),
+      metadata: readVideoMetadata(entry.metadata, `${field}.metadata`),
+      ...entry.deferredRange === void 0 ? {} : { deferredRange: readDeferredFrameRange(entry.deferredRange, `${field}.deferredRange`) }
+    };
+  });
+  const videoIds = /* @__PURE__ */ new Set();
+  for (const video of videos) {
+    if (videoIds.has(video.id)) {
+      metadataError("meta/videos.json.videos", `contains duplicate id ${JSON.stringify(video.id)}`);
+    }
+    videoIds.add(video.id);
   }
-  return sha256;
-}
-async function prehashPlanFiles(dir, digests) {
-  if (!existsSync11(dir)) return;
-  for (const { absolutePath } of listPlanFiles(dir)) {
-    if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
+  const extractedIds = /* @__PURE__ */ new Set();
+  for (const entry of extracted) {
+    if (extractedIds.has(entry.videoId)) {
+      metadataError(
+        "meta/videos.json.extracted",
+        `contains duplicate videoId ${JSON.stringify(entry.videoId)}`
+      );
+    }
+    extractedIds.add(entry.videoId);
+    if (!videoIds.has(entry.videoId)) {
+      metadataError(
+        "meta/videos.json.extracted",
+        `references undeclared video ${JSON.stringify(entry.videoId)}`
+      );
+    }
+  }
+  for (const video of videos) {
+    if (!extractedIds.has(video.id)) {
+      metadataError(
+        "meta/videos.json.extracted",
+        `is missing declared video ${JSON.stringify(video.id)}`
+      );
+    }
   }
+  return { videos, extracted };
 }
-function stripUndefined(value) {
-  if (Array.isArray(value)) return value.map(stripUndefined);
-  if (value !== null && typeof value === "object") {
-    const obj = value;
-    const out = {};
-    for (const key of Object.keys(obj)) {
-      const v = obj[key];
-      if (v === void 0) continue;
-      out[key] = stripUndefined(v);
+function buildPlanVideosJson(input) {
+  const videos = input.videos.map((video, index) => {
+    if (Number.isFinite(video.end)) return { ...video };
+    if (!Number.isFinite(input.compositionEnd) || input.compositionEnd <= 0 || input.compositionEnd <= video.start) {
+      metadataError(
+        `meta/videos.json.videos[${index}].end`,
+        "cannot be resolved without a finite composition end after its start"
+      );
     }
-    return out;
+    return { ...video, end: input.compositionEnd };
+  });
+  return parsePlanVideosJson({ videos, extracted: input.extracted });
+}
+var execFile = promisify2(execFileCallback);
+var cachedFfmpegVersions = /* @__PURE__ */ new Map();
+async function readFfmpegVersion() {
+  const binary = getFfmpegBinary();
+  const cached = cachedFfmpegVersions.get(binary);
+  if (cached !== void 0) return cached;
+  let stdout;
+  try {
+    ({ stdout } = await execFile(binary, ["-version"], {
+      maxBuffer: 1024 * 1024,
+      // See runFfmpeg.ts: keeps a console window off the user's desktop on Windows.
+      windowsHide: true
+    }));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    throw Object.assign(
+      new Error(`ffmpeg not found at "${binary}": install FFmpeg or set HYPERFRAMES_FFMPEG_PATH.`, {
+        cause: error
+      }),
+      { code: "ENOENT" }
+    );
   }
-  return value;
+  const firstLine = stdout.split(/\r?\n/)[0]?.trim() ?? "";
+  if (!firstLine) {
+    throw new Error("ffmpeg -version returned empty output");
+  }
+  cachedFfmpegVersions.set(binary, firstLine);
+  return firstLine;
 }
-function listPlanFiles(planDir) {
-  const results = [];
-  const rootResolved = resolve7(planDir);
-  function walk(dir) {
-    const entries = readdirSync4(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join15(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full);
-      } else if (entry.isFile()) {
-        results.push({
-          planRelativePath: relative3(rootResolved, full).split(/[\\/]+/).join("/"),
-          absolutePath: full
-        });
+function buildSyntheticRenderJob(input) {
+  const renderConfig = {
+    fps: input.fps,
+    quality: input.quality,
+    format: input.format,
+    crf: input.crf,
+    videoBitrate: input.bitrate,
+    videoFrameFormat: input.videoFrameFormat,
+    outputResolution: input.outputResolution,
+    outputResolutionAspectAgnostic: input.outputResolutionAspectAgnostic,
+    // Distributed mode hard-pins to software GPU. The plan-time validator
+    // refuses to fan out otherwise.
+    useGpu: false,
+    debug: false,
+    entryFile: input.entryFile,
+    logger: input.logger ?? defaultLogger,
+    hdrMode: input.hdrMode,
+    strictness: input.strictness,
+    producerConfig: input.producerConfig,
+    variables: input.variables
+  };
+  return createRenderJob(renderConfig);
+}
+var cachedProducerVersion = null;
+function readProducerVersion() {
+  if (cachedProducerVersion !== null) return cachedProducerVersion;
+  const startDir = dirname8(fileURLToPath3(import.meta.url));
+  let current = startDir;
+  for (let i = 0; i < 10; i++) {
+    const candidate = join15(current, "package.json");
+    if (existsSync11(candidate)) {
+      try {
+        const pkg = JSON.parse(readFileSync7(candidate, "utf-8"));
+        if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
+          cachedProducerVersion = pkg.version;
+          return pkg.version;
+        }
+      } catch {
       }
     }
+    const parent = dirname8(current);
+    if (parent === current) break;
+    current = parent;
   }
-  walk(rootResolved);
-  results.sort((a, b) => a.planRelativePath < b.planRelativePath ? -1 : 1);
-  return results;
+  cachedProducerVersion = "0.0.0-unknown";
+  return cachedProducerVersion;
 }
-function collectPlanAssetShas(planDir, digests) {
-  const files = listPlanFiles(planDir);
-  let compositionHtml = null;
-  const assets = [];
-  for (const file of files) {
-    if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
-      compositionHtml = readFileSync7(file.absolutePath);
-      continue;
+
+// src/services/distributed/chunkFrames.ts
+var FFMPEG_VERSION_MISMATCH = "FFMPEG_VERSION_MISMATCH";
+var PLAN_HASH_MISMATCH = "PLAN_HASH_MISMATCH";
+var MISSING_PLAN_ARTIFACT = "MISSING_PLAN_ARTIFACT";
+var CHUNK_INDEX_OUT_OF_RANGE = "CHUNK_INDEX_OUT_OF_RANGE";
+var MISSING_RUNTIME_ENV_SNAPSHOT = "MISSING_RUNTIME_ENV_SNAPSHOT";
+var RenderChunkValidationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RenderChunkValidationError";
+    this.code = code;
+  }
+};
+function createChunkVideoFrameInjectorFactory(frameLookup) {
+  return () => createVideoFrameInjector2(frameLookup);
+}
+function frameNumberFromFileName(name) {
+  const match = /(\d+)(?=\.[^.]+$)/.exec(name);
+  if (!match) return null;
+  const frameNumber = Number(match[1]);
+  return Number.isSafeInteger(frameNumber) ? frameNumber : null;
+}
+function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
+  const result = [];
+  for (const v of videos) {
+    const outputDir = join16(planDir, "video-frames", v.videoId);
+    if (!existsSync12(outputDir)) {
+      throw new Error(
+        `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
+      );
     }
-    if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
-    assets.push({
-      path: file.planRelativePath,
-      sha256: planFileSha256(file.absolutePath, digests)
+    const ext = (extname2(v.framePattern) || ".jpg").toLowerCase();
+    const frames = readdirSync4(outputDir).filter((name) => name.toLowerCase().endsWith(ext)).sort((left, right) => {
+      const leftNumber = frameNumberFromFileName(left);
+      const rightNumber = frameNumberFromFileName(right);
+      if (leftNumber === null || rightNumber === null) return left.localeCompare(right);
+      return leftNumber - rightNumber || left.localeCompare(right);
+    });
+    const framePaths = /* @__PURE__ */ new Map();
+    for (let i = 0; i < frames.length; i++) {
+      const frameName = frames[i];
+      if (!frameName) continue;
+      const frameNumber = indexMode === "sparse-v2" ? frameNumberFromFileName(frameName) : null;
+      const frameIndex = frameNumber === null ? i : frameNumber - 1;
+      framePaths.set(frameIndex, join16(outputDir, frameName));
+    }
+    result.push({
+      videoId: v.videoId,
+      srcPath: v.srcPath,
+      outputDir,
+      framePattern: v.framePattern,
+      fps: v.fps,
+      totalFrames: v.totalFrames,
+      metadata: v.metadata,
+      framePaths,
+      // The planDir is shared read-only across workers; cleanup must not delete its frames.
+      ownedByLookup: false
     });
   }
-  if (compositionHtml === null) {
-    throw new Error(
-      `[freezePlan] compiled HTML missing at ${COMPILED_INDEX_RELATIVE_PATH} (upstream compile stage did not materialize the expected file).`
-    );
-  }
-  return { compositionHtml, assets };
+  return result;
 }
-function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join15(planDir, "plan.json");
-  const encoderJsonPath = join15(planDir, "meta", "encoder.json");
-  if (!existsSync11(planJsonPath)) {
-    throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
-  }
-  if (!existsSync11(encoderJsonPath)) {
-    throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
+function contiguousRuns(sortedIndexes) {
+  const runs2 = [];
+  for (const index of sortedIndexes) {
+    const last = runs2[runs2.length - 1];
+    if (last && last.firstFrame + last.frames === index) last.frames++;
+    else runs2.push({ firstFrame: index, frames: 1 });
   }
-  const planJson = JSON.parse(readFileSync7(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync7(encoderJsonPath, "utf-8");
-  const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
-  return computePlanHash({
-    compositionHtml,
-    assets,
-    fontSnapshotSha: planJson.fontSnapshotSha,
-    encoderConfigCanonicalJson,
-    producerVersion: planJson.producerVersion,
-    ffmpegVersion: planJson.ffmpegVersion,
-    dimensions: planJson.dimensions
-  });
+  return runs2;
 }
-async function freezePlan(input) {
-  const {
-    planDir,
-    composition,
-    encoder,
-    chunks,
-    dimensions,
-    producerVersion,
-    fontSnapshotSha,
-    durationSeconds,
-    totalFrames,
-    hasAudio,
-    digests
-  } = input;
-  if (!existsSync11(planDir)) {
-    throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
-  }
-  const metaDir = join15(planDir, "meta");
-  if (!existsSync11(metaDir)) mkdirSync7(metaDir, { recursive: true });
-  writeFileSync4(
-    join15(metaDir, "composition.json"),
-    `${JSON.stringify(composition, null, 2)}
-`,
-    "utf-8"
-  );
-  const encoderForCanonical = stripUndefined(encoder);
-  const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync4(join15(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync4(join15(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
-`, "utf-8");
-  const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
-  const planHash = computePlanHash({
-    compositionHtml,
-    assets,
-    fontSnapshotSha,
-    encoderConfigCanonicalJson,
-    producerVersion,
-    ffmpegVersion: encoder.ffmpegVersion,
-    dimensions
-  });
-  const planJson = {
-    protocol: PLAN_PROTOCOL_V1,
-    planHash,
-    producerVersion,
-    ffmpegVersion: encoder.ffmpegVersion,
-    fontSnapshotSha,
-    dimensions,
-    chunkCount: chunks.length,
-    totalFrames,
-    duration: durationSeconds,
-    hasAudio
+function buildChunkCaptureOptions(input) {
+  const { dimensions, encoder } = input;
+  const videoCaptureBeyondViewport = resolveVideoCaptureBeyondViewport(input.videoCount);
+  return {
+    width: dimensions.width,
+    height: dimensions.height,
+    fps: { num: dimensions.fpsNum, den: dimensions.fpsDen },
+    format: dimensions.format === "mp4" ? "jpeg" : "png",
+    quality: dimensions.format === "mp4" ? resolveCaptureJpegQuality(encoder.quality) : void 0,
+    deviceScaleFactor: encoder.deviceScaleFactor,
+    // The controller's snapshot, so the first capture sees the in-process renderer's `__hfVariables`.
+    variables: encoder.variables,
+    subTimelineWaitMemo: {},
+    ...videoCaptureBeyondViewport !== void 0 ? { captureBeyondViewport: videoCaptureBeyondViewport } : {},
+    // A fixed warmup count keeps `beginFrameTimeTicks` host-independent.
+    lockWarmupTicks: true,
+    requiresWebGpu: compositionRequiresWebGpu3(input.html)
   };
-  const planJsonPath = join15(planDir, "plan.json");
-  writeFileSync4(planJsonPath, `${JSON.stringify(planJson, null, 2)}
-`, "utf-8");
-  return { planJsonPath, planHash };
 }
-
-// src/services/render/runtimeEnvSnapshot.ts
-var RUNTIME_ENV_PREFIXES = [
-  "PRODUCER_RUNTIME_",
-  "PRODUCER_RENDER_"
-];
-function snapshotRuntimeEnv(env = process.env) {
-  const snapshot = {};
-  for (const key of Object.keys(env)) {
-    const matches = RUNTIME_ENV_PREFIXES.some((prefix) => key.startsWith(prefix));
-    if (!matches) continue;
-    const value = env[key];
-    if (typeof value !== "string") continue;
-    snapshot[key] = value;
-  }
-  return snapshot;
-}
-function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
-  const previous = {};
-  for (const [key, value] of Object.entries(snapshot)) {
-    if (typeof value !== "string") continue;
-    const matches = RUNTIME_ENV_PREFIXES.some((prefix) => key.startsWith(prefix));
-    if (!matches) continue;
-    previous[key] = env[key];
-    env[key] = value;
+async function extractDeferredVideoFramesForChunk(input) {
+  const deferred = input.planVideos.extracted.filter((video) => video.deferredRange);
+  if (deferred.length === 0) return [];
+  const table = createFrameLookupTable2(
+    input.planVideos.videos,
+    deferred.map((video) => ({
+      ...video,
+      outputDir: input.outputRoot,
+      framePaths: new Map(Array.from({ length: video.totalFrames }, (_, i) => [i, String(i)]))
+    })),
+    resolveRenderFpsConfig(input.fps).value
+  );
+  const shown = /* @__PURE__ */ new Map();
+  for (const frame of input.frames) {
+    const globalTime = frame * input.fps.den / input.fps.num;
+    for (const [videoId, payload] of table.getActiveFramePayloads(globalTime)) {
+      const indexes = shown.get(videoId) ?? /* @__PURE__ */ new Set();
+      indexes.add(payload.frameIndex);
+      shown.set(videoId, indexes);
+    }
   }
-  return {
-    restore: () => {
-      for (const [key, value] of Object.entries(previous)) {
-        if (value === void 0) delete env[key];
-        else env[key] = value;
+  return Promise.all(
+    deferred.map(async (video) => {
+      const outputDir = join16(input.outputRoot, video.videoId);
+      const indexes = [...shown.get(video.videoId) ?? []].sort((a, b) => a - b);
+      if (indexes.length === 0) {
+        return { ...video, outputDir, framePaths: /* @__PURE__ */ new Map(), ownedByLookup: false };
+      }
+      const range = video.deferredRange;
+      const sourcePath = join16(input.planDir, ...range.sourcePath.split("/"));
+      if (!existsSync12(sourcePath)) {
+        throw new RenderChunkValidationError(
+          MISSING_PLAN_ARTIFACT,
+          `[renderChunk] planDir is missing the source for video ${JSON.stringify(video.videoId)}: ${range.sourcePath}`
+        );
       }
-    }
-  };
+      const extracted = await extractVideoFramesRange(
+        sourcePath,
+        video.videoId,
+        range.startTime,
+        range.durationSeconds,
+        {
+          fps: input.fps,
+          outputDir: input.outputRoot,
+          format: range.format,
+          frameRanges: contiguousRuns(indexes)
+        },
+        void 0,
+        input.cfg
+      );
+      const missing = indexes.find((index) => !extracted.framePaths.has(index));
+      if (missing !== void 0) {
+        throw new RenderChunkValidationError(
+          INVALID_VIDEO_METADATA,
+          `[renderChunk] video ${JSON.stringify(video.videoId)} has no frame ${missing}; the plan expected ${video.totalFrames} frames from ${range.sourcePath}.`
+        );
+      }
+      return { ...video, outputDir, framePaths: extracted.framePaths, ownedByLookup: false };
+    })
+  );
 }
 
-// src/services/distributed/shared.ts
-import { execFile as execFileCallback } from "node:child_process";
-import { dirname as dirname8, join as join16 } from "node:path";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { promisify as promisify2 } from "node:util";
-import {
-  getFfmpegBinary,
-  MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME3
-} from "@hyperframes/engine";
-var PLAN_VIDEOS_META_RELATIVE_PATH = "meta/videos.json";
-var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME3;
-var PLAN_AUDIO_LEGACY_RELATIVE_PATH = "audio.aac";
-function isPlanAudioArtifactPath(path) {
-  return path === PLAN_AUDIO_RELATIVE_PATH || path === PLAN_AUDIO_LEGACY_RELATIVE_PATH;
-}
-function resolvePlanAudioPath(planDir) {
-  for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
-    const candidate = join16(planDir, name);
-    if (existsSync12(candidate)) return candidate;
+// src/services/distributed/planFrameCost.ts
+async function measurePlanSecondsPerFrame(input) {
+  const { planDir, workDir, planVideos, fps, log } = input;
+  const fpsRatio = { num: fps, den: 1 };
+  const sampled = selectCaptureCalibrationFrames(input.totalFrames);
+  const extracted = [
+    ...rebuildExtractedFramesFromPlanDir(
+      planDir,
+      planVideos.extracted.filter((video) => !video.deferredRange)
+    ),
+    ...await extractDeferredVideoFramesForChunk({
+      planDir,
+      planVideos,
+      frames: sampled,
+      fps: fpsRatio,
+      outputRoot: join17(workDir, "frame-cost-video-frames"),
+      cfg: input.cfg
+    })
+  ];
+  const lookup = extracted.length > 0 ? createFrameLookupTable3(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
+  const compiledDir = join17(planDir, "compiled");
+  const fileServer = await createFileServer({
+    projectDir: compiledDir,
+    compiledDir,
+    port: 0,
+    preHeadScripts: [buildVirtualTimeShim({ seedRandomFromFrame: true })],
+    fps: fpsRatio
+  });
+  let session = null;
+  try {
+    session = await createCaptureSession8(
+      fileServer.url,
+      join17(workDir, "frame-cost"),
+      buildChunkCaptureOptions({
+        dimensions: { ...input, fpsNum: fps, fpsDen: 1 },
+        encoder: input,
+        videoCount: planVideos.videos.length,
+        html: input.html
+      }),
+      createChunkVideoFrameInjectorFactory(lookup)(),
+      createCaptureCalibrationConfig(input.cfg)
+    );
+    await initializeSession8(session);
+    const { estimate } = await measureCaptureCostFromSession(session, input.totalFrames, fps, log);
+    return (estimate.p95Ms ?? 0) / 1e3;
+  } finally {
+    if (session) await closeCaptureSession9(session).catch(() => {
+    });
+    closeFileServerSafely(fileServer, "plan frame cost", log);
   }
-  return null;
 }
-var INVALID_VIDEO_METADATA = "INVALID_VIDEO_METADATA";
-var PlanVideosMetadataError = class extends Error {
-  // Read by cloud adapters across the package boundary to classify retries.
+
+// src/services/render/stages/freezePlan.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync8, readdirSync as readdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join18, relative as relative3, resolve as resolve7 } from "node:path";
+
+// src/services/distributed/planProtocol.ts
+var PLAN_SCHEMA_VERSION = 1;
+var PLAN_ARTIFACT_LAYOUT = "plan-dir-v1";
+var PLAN_HASH_SCHEMA = "hyperframes-plan-hash-v1";
+var PLAN_V2_SCHEMA_VERSION = 2;
+var PLAN_V2_ARTIFACT_LAYOUT = "content-addressed-plan-v2";
+var PLAN_V2_HASH_SCHEMA = "hyperframes-plan-manifest-hash-v2";
+var PLAN_PROTOCOL_UNSUPPORTED = "PLAN_PROTOCOL_UNSUPPORTED";
+var PLAN_PROTOCOL_V1 = Object.freeze({
+  schemaVersion: PLAN_SCHEMA_VERSION,
+  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,
+  hashSchema: PLAN_V2_HASH_SCHEMA
+});
+var DISTRIBUTED_RENDER_CAPABILITIES = Object.freeze({
+  roles: Object.freeze({
+    planner: Object.freeze({
+      produces: Object.freeze([PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2])
+    }),
+    chunk: Object.freeze({
+      accepts: Object.freeze([PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2]),
+      acceptsLegacyV1WithoutDescriptor: true
+    }),
+    assembler: Object.freeze({
+      accepts: Object.freeze([PLAN_PROTOCOL_V1, PLAN_PROTOCOL_V2]),
+      acceptsLegacyV1WithoutDescriptor: 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
-  code = INVALID_VIDEO_METADATA;
-  constructor(message) {
-    super(message);
-    this.name = "PlanVideosMetadataError";
+  code = PLAN_PROTOCOL_UNSUPPORTED;
+  constructor(reason) {
+    super(`[planProtocol] ${reason} (${PLAN_PROTOCOL_UNSUPPORTED})`);
+    this.name = "PlanProtocolUnsupportedError";
   }
 };
-function metadataError(field, expectation) {
-  throw new PlanVideosMetadataError(`${field} ${expectation}`);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function readRecord(value, field) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    metadataError(field, "must be an object");
-  }
-  return value;
+function protocolMatches(descriptor, expected) {
+  return descriptor.schemaVersion === expected.schemaVersion && descriptor.artifactLayout === expected.artifactLayout && descriptor.hashSchema === expected.hashSchema;
 }
-function readNonEmptyString(value, field) {
-  if (typeof value !== "string" || value.length === 0) {
-    metadataError(field, "must be a non-empty string");
-  }
-  return value;
+function capabilitiesAccept(capabilities, protocol) {
+  return capabilities.accepts.some(
+    (accepted) => accepted.schemaVersion === protocol.schemaVersion && accepted.artifactLayout === protocol.artifactLayout && accepted.hashSchema === protocol.hashSchema
+  );
 }
-function readString(value, field) {
-  if (typeof value !== "string") {
-    metadataError(field, "must be a string");
+function readPlanProtocol(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk) {
+  if (!isRecord(planJson)) {
+    throw new PlanProtocolUnsupportedError("plan.json must contain a JSON object");
   }
-  return value;
-}
-function readFiniteNumber(value, field) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    metadataError(field, "must be a finite number");
+  if (!Object.prototype.hasOwnProperty.call(planJson, "protocol")) {
+    if (!capabilities.acceptsLegacyV1WithoutDescriptor || !capabilitiesAccept(capabilities, PLAN_PROTOCOL_V1)) {
+      throw new PlanProtocolUnsupportedError(
+        "legacy v1 plan without a protocol descriptor is not accepted by this worker"
+      );
+    }
+    return PLAN_PROTOCOL_V1;
   }
-  return value;
-}
-function readBoolean(value, field) {
-  if (typeof value !== "boolean") {
-    metadataError(field, "must be boolean");
+  const descriptor = planJson.protocol;
+  if (!isRecord(descriptor)) {
+    throw new PlanProtocolUnsupportedError("plan.json protocol descriptor must be an object");
   }
-  return value;
+  for (const field of ["schemaVersion", "artifactLayout", "hashSchema"]) {
+    if (!Object.prototype.hasOwnProperty.call(descriptor, field)) {
+      throw new PlanProtocolUnsupportedError(`plan.json protocol descriptor is missing ${field}`);
+    }
+  }
+  const protocol = protocolMatches(descriptor, PLAN_PROTOCOL_V1) ? PLAN_PROTOCOL_V1 : protocolMatches(descriptor, PLAN_PROTOCOL_V2) ? PLAN_PROTOCOL_V2 : null;
+  if (protocol === null || !capabilitiesAccept(capabilities, protocol)) {
+    throw new PlanProtocolUnsupportedError("unsupported plan.json protocol descriptor");
+  }
+  return protocol;
 }
-function readPositiveInteger(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    metadataError(field, "must be a positive integer");
+function readPlanProtocolV1(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk) {
+  const protocol = readPlanProtocol(planJson, capabilities);
+  if (protocol !== PLAN_PROTOCOL_V1) {
+    throw new PlanProtocolUnsupportedError(
+      "content-addressed v2 plan must be materialized before v1 layout access"
+    );
   }
-  return value;
+  return PLAN_PROTOCOL_V1;
 }
-function readNonNegativeInteger(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-    metadataError(field, "must be a non-negative integer");
+
+// src/services/render/stages/planHash.ts
+import { createHash as createHash4 } from "node:crypto";
+import { closeSync as closeSync3, createReadStream as createReadStream3, openSync as openSync3, readSync } from "node:fs";
+var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
+var FIELD_DELIMITER = Buffer.from([0]);
+function computePlanHash(input) {
+  const hash = createHash4("sha256");
+  hash.update(PLAN_HASH_SCHEMA_PREFIX, "utf8");
+  hash.update(input.compositionHtml);
+  hash.update(FIELD_DELIMITER);
+  const sortedAssets = [...input.assets].sort(
+    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+  );
+  for (const asset of sortedAssets) {
+    hash.update(asset.path, "utf8");
+    hash.update(FIELD_DELIMITER);
+    hash.update(asset.sha256, "utf8");
+    hash.update(FIELD_DELIMITER);
   }
-  return value;
+  hash.update(input.fontSnapshotSha, "utf8");
+  hash.update(FIELD_DELIMITER);
+  hash.update(input.encoderConfigCanonicalJson, "utf8");
+  hash.update(FIELD_DELIMITER);
+  hash.update(input.producerVersion, "utf8");
+  hash.update(FIELD_DELIMITER);
+  hash.update(input.ffmpegVersion, "utf8");
+  hash.update(FIELD_DELIMITER);
+  const d = input.dimensions;
+  hash.update(`${d.fpsNum}/${d.fpsDen}x${d.width}x${d.height}x${d.format}`, "utf8");
+  return hash.digest("hex");
 }
-function readDeferredFrameRange(value, field) {
-  const range = readRecord(value, field);
-  const sourcePath = readNonEmptyString(range.sourcePath, `${field}.sourcePath`);
-  if (sourcePath.startsWith("/") || sourcePath.split(/[\\/]/).some((part) => part === "..")) {
-    metadataError(`${field}.sourcePath`, "must stay inside the plan directory");
+function canonicalJsonStringify(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`canonicalJsonStringify: non-finite number ${value}`);
+    }
+    return JSON.stringify(value);
   }
-  const durationSeconds = readFiniteNumber(range.durationSeconds, `${field}.durationSeconds`);
-  if (durationSeconds <= 0) metadataError(`${field}.durationSeconds`, "must be positive");
-  if (range.format !== "jpg" && range.format !== "png") {
-    metadataError(`${field}.format`, 'must be "jpg" or "png"');
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJsonStringify).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = keys.map((k) => `${JSON.stringify(k)}:${canonicalJsonStringify(obj[k])}`);
+    return `{${parts.join(",")}}`;
+  }
+  throw new TypeError(`canonicalJsonStringify: unsupported value type ${typeof value}`);
+}
+function sha256Hex(bytes) {
+  const h = createHash4("sha256");
+  h.update(bytes);
+  return h.digest("hex");
+}
+function sha256File(path) {
+  const hash = createHash4("sha256");
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  const fd = openSync3(path, "r");
+  try {
+    let bytesRead = 0;
+    do {
+      bytesRead = readSync(fd, buffer, 0, buffer.byteLength, null);
+      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
+    } while (bytesRead > 0);
+  } finally {
+    closeSync3(fd);
   }
-  return {
-    sourcePath,
-    startTime: readFiniteNumber(range.startTime, `${field}.startTime`),
-    durationSeconds,
-    format: range.format
-  };
+  return hash.digest("hex");
 }
-function readRateSpec(value, field) {
-  if (value === void 0) return void 0;
-  if (typeof value === "number") return readFiniteNumber(value, field);
-  const lane = readRecord(value, field);
-  if (!Array.isArray(lane.points)) {
-    metadataError(`${field}.points`, "must be an array");
+async function sha256FileAsync(path) {
+  const hash = createHash4("sha256");
+  for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
+    hash.update(chunk);
   }
-  return lane;
+  return hash.digest("hex");
 }
-function readVideoMetadata(value, field) {
-  const record = readRecord(value, field);
-  let colorSpace = null;
-  if (record.colorSpace !== null) {
-    const color = readRecord(record.colorSpace, `${field}.colorSpace`);
-    colorSpace = {
-      colorTransfer: readString(color.colorTransfer, `${field}.colorSpace.colorTransfer`),
-      colorPrimaries: readString(color.colorPrimaries, `${field}.colorSpace.colorPrimaries`),
-      colorSpace: readString(color.colorSpace, `${field}.colorSpace.colorSpace`)
-    };
+
+// src/services/render/stages/freezePlan.ts
+var COMPILED_INDEX_RELATIVE_PATH = "compiled/index.html";
+var HASH_EXCLUDED_PLAN_FILES = /* @__PURE__ */ new Set([
+  "plan.json",
+  "meta/encoder.json",
+  COMPILED_INDEX_RELATIVE_PATH
+]);
+function planFileSha256(absolutePath, digests) {
+  let sha256 = digests?.get(absolutePath);
+  if (sha256 === void 0) {
+    sha256 = sha256File(absolutePath);
+    digests?.set(absolutePath, sha256);
   }
-  return {
-    durationSeconds: readFiniteNumber(record.durationSeconds, `${field}.durationSeconds`),
-    videoStreamDurationSeconds: readFiniteNumber(
-      record.videoStreamDurationSeconds,
-      `${field}.videoStreamDurationSeconds`
-    ),
-    // Plans written before stream-start metadata existed implicitly used the
-    // overwhelmingly common start-at-zero domain. Preserve that compatibility
-    // while carrying non-zero edit-list/transport timestamps in new plans.
-    videoStreamStartSeconds: record.videoStreamStartSeconds === void 0 ? 0 : readFiniteNumber(record.videoStreamStartSeconds, `${field}.videoStreamStartSeconds`),
-    videoStreamLeadSeconds: record.videoStreamLeadSeconds === void 0 ? 0 : readFiniteNumber(record.videoStreamLeadSeconds, `${field}.videoStreamLeadSeconds`),
-    width: readPositiveInteger(record.width, `${field}.width`),
-    height: readPositiveInteger(record.height, `${field}.height`),
-    fps: readFiniteNumber(record.fps, `${field}.fps`),
-    videoCodec: readNonEmptyString(record.videoCodec, `${field}.videoCodec`),
-    hasAudio: readBoolean(record.hasAudio, `${field}.hasAudio`),
-    isVFR: readBoolean(record.isVFR, `${field}.isVFR`),
-    hasAlpha: readBoolean(record.hasAlpha, `${field}.hasAlpha`),
-    colorSpace
-  };
+  return sha256;
 }
-function parsePlanVideosJson(value) {
-  const record = readRecord(value, "meta/videos.json");
-  if (!Array.isArray(record.videos) || !Array.isArray(record.extracted)) {
-    metadataError("meta/videos.json", "must contain videos and extracted arrays");
-  }
-  const videos = record.videos.map((value2, index) => {
-    const field = `meta/videos.json.videos[${index}]`;
-    const video = readRecord(value2, field);
-    return {
-      id: readNonEmptyString(video.id, `${field}.id`),
-      src: readNonEmptyString(video.src, `${field}.src`),
-      start: readFiniteNumber(video.start, `${field}.start`),
-      end: readFiniteNumber(video.end, `${field}.end`),
-      mediaStart: readFiniteNumber(video.mediaStart, `${field}.mediaStart`),
-      playbackRate: readRateSpec(video.playbackRate, `${field}.playbackRate`),
-      loop: readBoolean(video.loop, `${field}.loop`),
-      hasAudio: readBoolean(video.hasAudio, `${field}.hasAudio`)
-    };
-  });
-  const extracted = record.extracted.map((value2, index) => {
-    const field = `meta/videos.json.extracted[${index}]`;
-    const entry = readRecord(value2, field);
-    return {
-      videoId: readNonEmptyString(entry.videoId, `${field}.videoId`),
-      srcPath: readNonEmptyString(entry.srcPath, `${field}.srcPath`),
-      framePattern: readNonEmptyString(entry.framePattern, `${field}.framePattern`),
-      fps: readFiniteNumber(entry.fps, `${field}.fps`),
-      totalFrames: readNonNegativeInteger(entry.totalFrames, `${field}.totalFrames`),
-      metadata: readVideoMetadata(entry.metadata, `${field}.metadata`),
-      ...entry.deferredRange === void 0 ? {} : { deferredRange: readDeferredFrameRange(entry.deferredRange, `${field}.deferredRange`) }
-    };
-  });
-  const videoIds = /* @__PURE__ */ new Set();
-  for (const video of videos) {
-    if (videoIds.has(video.id)) {
-      metadataError("meta/videos.json.videos", `contains duplicate id ${JSON.stringify(video.id)}`);
-    }
-    videoIds.add(video.id);
+async function prehashPlanFiles(dir, digests) {
+  if (!existsSync13(dir)) return;
+  for (const { absolutePath } of listPlanFiles(dir)) {
+    if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
   }
-  const extractedIds = /* @__PURE__ */ new Set();
-  for (const entry of extracted) {
-    if (extractedIds.has(entry.videoId)) {
-      metadataError(
-        "meta/videos.json.extracted",
-        `contains duplicate videoId ${JSON.stringify(entry.videoId)}`
-      );
-    }
-    extractedIds.add(entry.videoId);
-    if (!videoIds.has(entry.videoId)) {
-      metadataError(
-        "meta/videos.json.extracted",
-        `references undeclared video ${JSON.stringify(entry.videoId)}`
-      );
+}
+function stripUndefined(value) {
+  if (Array.isArray(value)) return value.map(stripUndefined);
+  if (value !== null && typeof value === "object") {
+    const obj = value;
+    const out = {};
+    for (const key of Object.keys(obj)) {
+      const v = obj[key];
+      if (v === void 0) continue;
+      out[key] = stripUndefined(v);
     }
+    return out;
   }
-  for (const video of videos) {
-    if (!extractedIds.has(video.id)) {
-      metadataError(
-        "meta/videos.json.extracted",
-        `is missing declared video ${JSON.stringify(video.id)}`
-      );
+  return value;
+}
+function listPlanFiles(planDir) {
+  const results = [];
+  const rootResolved = resolve7(planDir);
+  function walk(dir) {
+    const entries = readdirSync5(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join18(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        results.push({
+          planRelativePath: relative3(rootResolved, full).split(/[\\/]+/).join("/"),
+          absolutePath: full
+        });
+      }
     }
   }
-  return { videos, extracted };
+  walk(rootResolved);
+  results.sort((a, b) => a.planRelativePath < b.planRelativePath ? -1 : 1);
+  return results;
 }
-function buildPlanVideosJson(input) {
-  const videos = input.videos.map((video, index) => {
-    if (Number.isFinite(video.end)) return { ...video };
-    if (!Number.isFinite(input.compositionEnd) || input.compositionEnd <= 0 || input.compositionEnd <= video.start) {
-      metadataError(
-        `meta/videos.json.videos[${index}].end`,
-        "cannot be resolved without a finite composition end after its start"
-      );
+function collectPlanAssetShas(planDir, digests) {
+  const files = listPlanFiles(planDir);
+  let compositionHtml = null;
+  const assets = [];
+  for (const file of files) {
+    if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
+      compositionHtml = readFileSync8(file.absolutePath);
+      continue;
     }
-    return { ...video, end: input.compositionEnd };
-  });
-  return parsePlanVideosJson({ videos, extracted: input.extracted });
-}
-var execFile = promisify2(execFileCallback);
-var cachedFfmpegVersions = /* @__PURE__ */ new Map();
-async function readFfmpegVersion() {
-  const binary = getFfmpegBinary();
-  const cached = cachedFfmpegVersions.get(binary);
-  if (cached !== void 0) return cached;
-  let stdout;
-  try {
-    ({ stdout } = await execFile(binary, ["-version"], {
-      maxBuffer: 1024 * 1024,
-      // See runFfmpeg.ts: keeps a console window off the user's desktop on Windows.
-      windowsHide: true
-    }));
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-    throw Object.assign(
-      new Error(`ffmpeg not found at "${binary}": install FFmpeg or set HYPERFRAMES_FFMPEG_PATH.`, {
-        cause: error
-      }),
-      { code: "ENOENT" }
+    if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
+    assets.push({
+      path: file.planRelativePath,
+      sha256: planFileSha256(file.absolutePath, digests)
+    });
+  }
+  if (compositionHtml === null) {
+    throw new Error(
+      `[freezePlan] compiled HTML missing at ${COMPILED_INDEX_RELATIVE_PATH} (upstream compile stage did not materialize the expected file).`
     );
   }
-  const firstLine = stdout.split(/\r?\n/)[0]?.trim() ?? "";
-  if (!firstLine) {
-    throw new Error("ffmpeg -version returned empty output");
+  return { compositionHtml, assets };
+}
+function recomputePlanHashFromPlanDir(planDir, digests) {
+  const planJsonPath = join18(planDir, "plan.json");
+  const encoderJsonPath = join18(planDir, "meta", "encoder.json");
+  if (!existsSync13(planJsonPath)) {
+    throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
-  cachedFfmpegVersions.set(binary, firstLine);
-  return firstLine;
+  if (!existsSync13(encoderJsonPath)) {
+    throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
+  }
+  const planJson = JSON.parse(readFileSync8(planJsonPath, "utf-8"));
+  const encoderConfigCanonicalJson = readFileSync8(encoderJsonPath, "utf-8");
+  const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
+  return computePlanHash({
+    compositionHtml,
+    assets,
+    fontSnapshotSha: planJson.fontSnapshotSha,
+    encoderConfigCanonicalJson,
+    producerVersion: planJson.producerVersion,
+    ffmpegVersion: planJson.ffmpegVersion,
+    dimensions: planJson.dimensions
+  });
 }
-function buildSyntheticRenderJob(input) {
-  const renderConfig = {
-    fps: input.fps,
-    quality: input.quality,
-    format: input.format,
-    crf: input.crf,
-    videoBitrate: input.bitrate,
-    videoFrameFormat: input.videoFrameFormat,
-    outputResolution: input.outputResolution,
-    outputResolutionAspectAgnostic: input.outputResolutionAspectAgnostic,
-    // Distributed mode hard-pins to software GPU. The plan-time validator
-    // refuses to fan out otherwise.
-    useGpu: false,
-    debug: false,
-    entryFile: input.entryFile,
-    logger: input.logger ?? defaultLogger,
-    hdrMode: input.hdrMode,
-    strictness: input.strictness,
-    producerConfig: input.producerConfig,
-    variables: input.variables
+async function freezePlan(input) {
+  const {
+    planDir,
+    composition,
+    encoder,
+    chunks,
+    dimensions,
+    producerVersion,
+    fontSnapshotSha,
+    durationSeconds,
+    totalFrames,
+    hasAudio,
+    digests
+  } = input;
+  if (!existsSync13(planDir)) {
+    throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
+  }
+  const metaDir = join18(planDir, "meta");
+  if (!existsSync13(metaDir)) mkdirSync7(metaDir, { recursive: true });
+  writeFileSync4(
+    join18(metaDir, "composition.json"),
+    `${JSON.stringify(composition, null, 2)}
+`,
+    "utf-8"
+  );
+  const encoderForCanonical = stripUndefined(encoder);
+  const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
+  writeFileSync4(join18(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync4(join18(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+`, "utf-8");
+  const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
+  const planHash = computePlanHash({
+    compositionHtml,
+    assets,
+    fontSnapshotSha,
+    encoderConfigCanonicalJson,
+    producerVersion,
+    ffmpegVersion: encoder.ffmpegVersion,
+    dimensions
+  });
+  const planJson = {
+    protocol: PLAN_PROTOCOL_V1,
+    planHash,
+    producerVersion,
+    ffmpegVersion: encoder.ffmpegVersion,
+    fontSnapshotSha,
+    dimensions,
+    chunkCount: chunks.length,
+    totalFrames,
+    duration: durationSeconds,
+    hasAudio
   };
-  return createRenderJob(renderConfig);
+  const planJsonPath = join18(planDir, "plan.json");
+  writeFileSync4(planJsonPath, `${JSON.stringify(planJson, null, 2)}
+`, "utf-8");
+  return { planJsonPath, planHash };
 }
-var cachedProducerVersion = null;
-function readProducerVersion() {
-  if (cachedProducerVersion !== null) return cachedProducerVersion;
-  const startDir = dirname8(fileURLToPath3(import.meta.url));
-  let current = startDir;
-  for (let i = 0; i < 10; i++) {
-    const candidate = join16(current, "package.json");
-    if (existsSync12(candidate)) {
-      try {
-        const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
-        if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
-          cachedProducerVersion = pkg.version;
-          return pkg.version;
-        }
-      } catch {
+
+// src/services/render/runtimeEnvSnapshot.ts
+var RUNTIME_ENV_PREFIXES = [
+  "PRODUCER_RUNTIME_",
+  "PRODUCER_RENDER_"
+];
+function snapshotRuntimeEnv(env = process.env) {
+  const snapshot = {};
+  for (const key of Object.keys(env)) {
+    const matches = RUNTIME_ENV_PREFIXES.some((prefix) => key.startsWith(prefix));
+    if (!matches) continue;
+    const value = env[key];
+    if (typeof value !== "string") continue;
+    snapshot[key] = value;
+  }
+  return snapshot;
+}
+function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
+  const previous = {};
+  for (const [key, value] of Object.entries(snapshot)) {
+    if (typeof value !== "string") continue;
+    const matches = RUNTIME_ENV_PREFIXES.some((prefix) => key.startsWith(prefix));
+    if (!matches) continue;
+    previous[key] = env[key];
+    env[key] = value;
+  }
+  return {
+    restore: () => {
+      for (const [key, value] of Object.entries(previous)) {
+        if (value === void 0) delete env[key];
+        else env[key] = value;
       }
     }
-    const parent = dirname8(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  cachedProducerVersion = "0.0.0-unknown";
-  return cachedProducerVersion;
+  };
 }
 
 // src/services/distributed/planSize.ts
 import { createHash as createHash5 } from "node:crypto";
-import { lstatSync, readdirSync as readdirSync5 } from "node:fs";
-import { extname as extname2, join as join17, relative as relative4 } from "node:path";
+import { lstatSync, readdirSync as readdirSync6 } from "node:fs";
+import { extname as extname3, join as join19, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -7086,7 +7387,7 @@ function emptyBreakdown() {
 function addCategoryBytes(result, category, filePath, sizeBytes) {
   if (category === "compiled") {
     result.compiledBytes += sizeBytes;
-    if (SOURCE_MEDIA_EXTENSIONS.has(extname2(filePath).toLowerCase())) {
+    if (SOURCE_MEDIA_EXTENSIONS.has(extname3(filePath).toLowerCase())) {
       result.sourceMediaBytes += sizeBytes;
     }
     return;
@@ -7133,12 +7434,12 @@ function recordFile(result, components, rootDir, rootKind, filePath) {
 function walkRegularFiles(dir, visit) {
   let entries;
   try {
-    entries = readdirSync5(dir, { withFileTypes: true });
+    entries = readdirSync6(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const full = join17(dir, entry.name);
+    const full = join19(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -7200,8 +7501,17 @@ var MAX_PARALLEL_CHUNKS_CEILING = 256;
 var ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME = 0.11;
 var ESTIMATED_CHUNK_OVERHEAD_SECONDS = 60;
 var WORKER_TIMEOUT_MARGIN = 0.75;
-function estimateChunkSeconds(frames, megapixels) {
-  return ESTIMATED_CHUNK_OVERHEAD_SECONDS + frames * ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels;
+function estimateFrameSeconds(megapixels, measuredSecondsPerFrame = 0) {
+  return Math.max(ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels, measuredSecondsPerFrame);
+}
+function estimateChunkSeconds(frames, megapixels, measuredSecondsPerFrame) {
+  return ESTIMATED_CHUNK_OVERHEAD_SECONDS + frames * estimateFrameSeconds(megapixels, measuredSecondsPerFrame);
+}
+function planNeedsFrameCostMeasurement(html) {
+  return new RegExp(`\\b${HF_COLOR_GRADING_ATTR2}=`, "i").test(html);
+}
+function chunkSizingUsesFrameCost(config) {
+  return config.maxParallelChunks === void 0 && config.chunkSize === void 0 && config.targetChunkFrames === void 0 && (config.workerTimeoutSeconds !== void 0 || config.workerConcurrency !== void 0);
 }
 var CHUNK_EXCEEDS_WORKER_TIMEOUT = "CHUNK_EXCEEDS_WORKER_TIMEOUT";
 var ChunkExceedsWorkerTimeoutError = class extends Error {
@@ -7214,18 +7524,15 @@ var ChunkExceedsWorkerTimeoutError = class extends Error {
     this.name = "ChunkExceedsWorkerTimeoutError";
   }
 };
-function resolveMaxParallelChunks(config, totalFrames, megapixels, log = defaultLogger) {
+function resolveMaxParallelChunks(config, totalFrames, megapixels, log = defaultLogger, measuredSecondsPerFrame) {
   if (config.maxParallelChunks !== void 0) return config.maxParallelChunks;
   const { workerTimeoutSeconds, workerConcurrency } = config;
   const wave = Math.min(
     workerConcurrency ?? DEFAULT_MAX_PARALLEL_CHUNKS,
     MAX_PARALLEL_CHUNKS_CEILING
   );
-  const pinsChunking = config.chunkSize !== void 0 || config.targetChunkFrames !== void 0;
-  if (pinsChunking || workerTimeoutSeconds === void 0 && workerConcurrency === void 0) {
-    return wave;
-  }
-  const secondsPerFrame = ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels;
+  if (!chunkSizingUsesFrameCost(config)) return wave;
+  const secondsPerFrame = estimateFrameSeconds(megapixels, measuredSecondsPerFrame);
   const minFramesPerChunk = Math.ceil(ESTIMATED_CHUNK_OVERHEAD_SECONDS / secondsPerFrame);
   const wide = Math.max(1, Math.min(wave, Math.floor(totalFrames / minFramesPerChunk)));
   if (workerTimeoutSeconds === void 0) return wide;
@@ -7236,7 +7543,7 @@ function resolveMaxParallelChunks(config, totalFrames, megapixels, log = default
   if (needed > MAX_PARALLEL_CHUNKS_CEILING) {
     const framesAtCeiling = Math.ceil(totalFrames / MAX_PARALLEL_CHUNKS_CEILING);
     throw new ChunkExceedsWorkerTimeoutError(
-      Math.ceil(estimateChunkSeconds(framesAtCeiling, megapixels)),
+      Math.ceil(estimateChunkSeconds(framesAtCeiling, megapixels, measuredSecondsPerFrame)),
       workerTimeoutSeconds
     );
   }
@@ -7346,13 +7653,13 @@ function assertPositiveInteger(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join18("meta", "composition.json"),
-  join18("meta", "encoder.json"),
-  join18("meta", "chunks.json")
+  join20("meta", "composition.json"),
+  join20("meta", "encoder.json"),
+  join20("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync7(join18(planDir, relativePath), { force: true });
+    rmSync7(join20(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -7483,19 +7790,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join18(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join20(input.planDir, "video-frames", stagedRel);
     let result = null;
     for (const root of stagedRel === null ? [input.workCompiledDir, input.projectDir] : []) {
       const rel = pathInside(root, srcPath);
-      if (rel !== null && existsSync13(join18(input.planDir, "compiled", rel))) {
+      if (rel !== null && existsSync14(join20(input.planDir, "compiled", rel))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
     }
     if (result === null) {
-      result = `video-sources/${shipped.size}${extname3(current)}`;
-      const destination = join18(input.planDir, ...result.split("/"));
-      mkdirSync8(join18(input.planDir, "video-sources"), { recursive: true });
+      result = `video-sources/${shipped.size}${extname4(current)}`;
+      const destination = join20(input.planDir, ...result.split("/"));
+      mkdirSync8(join20(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -7513,7 +7820,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync13(planDir)) mkdirSync8(planDir, { recursive: true });
+  if (!existsSync14(planDir)) mkdirSync8(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -7542,14 +7849,14 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join18(projectDir, entryFile);
-  if (!existsSync13(htmlPath)) {
+  const htmlPath = join20(projectDir, entryFile);
+  if (!existsSync14(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join18(planDir, ".plan-work");
+  const workDir = join20(planDir, ".plan-work");
   rmSync7(workDir, { recursive: true, force: true });
   mkdirSync8(workDir, { recursive: true });
-  const compiledDir = join18(workDir, "compiled");
+  const compiledDir = join20(workDir, "compiled");
   mkdirSync8(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
@@ -7563,7 +7870,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join18(planDir, "compiled");
+  const finalCompiledDir = join20(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   stageStarted = Date.now();
   const compileResult = await runCompileStage({
@@ -7626,27 +7933,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession10 } = await import("@hyperframes/engine");
-      await closeCaptureSession10(probeResult.probeSession);
+      const { closeCaptureSession: closeCaptureSession11 } = await import("@hyperframes/engine");
+      await closeCaptureSession11(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
   }
-  const maxParallel = resolveMaxParallelChunks(
-    config,
-    totalFrames,
-    compileResult.outputWidth * compileResult.outputHeight / 1e6,
-    log
-  );
-  const { chunkCount, effectiveChunkSize } = resolveChunkPlan(
-    totalFrames,
-    config.chunkSize,
-    maxParallel,
-    config.targetChunkFrames
-  );
-  const chunks = buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize);
+  const megapixels = compileResult.outputWidth * compileResult.outputHeight / 1e6;
+  let maxParallel = resolveMaxParallelChunks(config, totalFrames, megapixels, log);
+  const measureFrameCost = chunkSizingUsesFrameCost(config) && planNeedsFrameCostMeasurement(compiled.html);
   assertPlanSizeWithinLimit({
     rootDir: compiledDir,
     rootKind: "compiled",
@@ -7671,17 +7968,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (extractResult.extractionResult) {
     assertVideoExtractionSucceeded(extractResult.extractionResult);
   }
-  const stagedVideoFrames = join18(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join18(planDir, "video-frames");
-  if (existsSync13(videoFramesDst)) rmSync7(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join18(planDir, "video-sources");
+  const stagedVideoFrames = join20(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join20(planDir, "video-frames");
+  if (existsSync14(videoFramesDst)) rmSync7(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join20(planDir, "video-sources");
   rmSync7(videoSourcesDir, { recursive: true, force: true });
-  if (existsSync13(stagedVideoFrames)) {
+  if (existsSync14(stagedVideoFrames)) {
     renameSync3(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync8(videoFramesDst, { recursive: true });
   }
-  if (existsSync13(finalCompiledDir)) rmSync7(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync14(finalCompiledDir)) rmSync7(finalCompiledDir, { recursive: true, force: true });
   renameSync3(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -7707,9 +8004,9 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       ...ext.deferredRange ? { deferredRange: { ...ext.deferredRange, sourcePath: shipVideoSource(ext.srcPath) } } : {}
     }))
   });
-  mkdirSync8(join18(planDir, "meta"), { recursive: true });
+  mkdirSync8(join20(planDir, "meta"), { recursive: true });
   writeFileSync5(
-    join18(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+    join20(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -7717,7 +8014,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   const chunksCarryAudio2 = carriesChunkAudio(config, options);
   const audioSeconds = chunksCarryAudio2 ? totalFrames / config.fps : probeResult.duration;
   stageStarted = Date.now();
-  const [audioOutcome, overlapOutcome] = await Promise.allSettled([
+  const [audioOutcome, overlapOutcome, frameCostOutcome] = await Promise.allSettled([
     runAudioStage({
       projectDir,
       workDir,
@@ -7740,19 +8037,53 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
         await options.whileAudioMixes();
         logPlanStage(log, "prepublish", prepublishStarted);
       }
-    })()
+    })(),
+    measureFrameCost ? measurePlanSecondsPerFrame({
+      planDir,
+      workDir,
+      html: compiled.html,
+      planVideos: planVideosJson,
+      totalFrames,
+      fps: config.fps,
+      width,
+      height,
+      format: config.format,
+      quality: config.quality ?? "standard",
+      deviceScaleFactor,
+      variables: config.variables,
+      cfg: { ...cfg, forceScreenshot, forceScreenshotExplicitlyOptedOut: !forceScreenshot },
+      log
+    }).finally(() => logPlanStage(log, "frame-cost", stageStarted)) : void 0
   ]);
   if (audioOutcome.status === "rejected") throw audioOutcome.reason;
   if (overlapOutcome.status === "rejected") throw overlapOutcome.reason;
+  if (frameCostOutcome.status === "rejected") throw frameCostOutcome.reason;
+  if (frameCostOutcome.value !== void 0) {
+    log.info("[plan] measured frame cost", { secondsPerFrame: frameCostOutcome.value });
+    maxParallel = resolveMaxParallelChunks(
+      config,
+      totalFrames,
+      megapixels,
+      log,
+      frameCostOutcome.value
+    );
+  }
+  const { chunkCount, effectiveChunkSize } = resolveChunkPlan(
+    totalFrames,
+    config.chunkSize,
+    maxParallel,
+    config.targetChunkFrames
+  );
+  const chunks = buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize);
   const audioResult = audioOutcome.value;
   if (audioResult.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
-  const planAudioPath = join18(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult.hasAudio && existsSync13(audioResult.audioOutputPath)) {
+  const planAudioPath = join20(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  if (audioResult.hasAudio && existsSync14(audioResult.audioOutputPath)) {
     renameSync3(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio2 && existsSync13(planAudioPath)) {
+  if (chunksCarryAudio2 && existsSync14(planAudioPath)) {
     stageStarted = Date.now();
     const peak = await constrainAacTruePeak({
       audioPath: planAudioPath,
@@ -7866,26 +8197,26 @@ async function plan(projectDir, config, planDir, options = {}) {
 // src/services/distributed/planV2.ts
 import {
   copyFileSync as copyFileSync7,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync4,
   readFileSync as readFileSync9,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   renameSync as renameSync5,
   rmSync as rmSync9,
   statSync as statSync6,
   writeFileSync as writeFileSync7
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname as dirname10, isAbsolute as isAbsolute4, join as join21, relative as relative6, resolve as resolve8, sep as sep3 } from "node:path";
+import { dirname as dirname10, isAbsolute as isAbsolute4, join as join23, relative as relative6, resolve as resolve8, sep as sep3 } from "node:path";
 import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
-import { createFrameLookupTable as createFrameLookupTable2 } from "@hyperframes/engine";
+import { createFrameLookupTable as createFrameLookupTable4 } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   linkSync as linkSync2,
   mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync3,
@@ -7894,7 +8225,7 @@ import {
   statSync as statSync5,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname9, join as join20 } from "node:path";
+import { dirname as dirname9, join as join22 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -7909,7 +8240,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join19 } from "node:path";
+import { join as join21 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -7919,7 +8250,7 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join19(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join21(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
@@ -7954,13 +8285,13 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync14(destinationDir)) {
+    if (existsSync15(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
     mkdirSync9(dirname9(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync3(join20(dirname9(destinationDir), ".plan-v2-publish-"));
+    this.temporaryDir = mkdtempSync3(join22(dirname9(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -7971,10 +8302,10 @@ var LocalPlanV2ArtifactPublisher = class {
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync14(destinationPath)) return;
+    if (existsSync15(destinationPath)) return;
     mkdirSync9(dirname9(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync3(join20(dirname9(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join20(stagingDir, "blob");
+    const stagingDir = mkdtempSync3(join22(dirname9(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join22(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -7989,13 +8320,13 @@ var LocalPlanV2ArtifactPublisher = class {
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync14(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync15(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
       }
     }
-    writeFileSync6(join20(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync6(join22(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameSync4(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
@@ -8039,8 +8370,8 @@ function listFiles(root) {
   const files = [];
   const rootResolved = resolve8(root);
   function walk(dir) {
-    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
-      const absolutePath = join21(dir, entry.name);
+    for (const entry of readdirSync7(dir, { withFileTypes: true })) {
+      const absolutePath = join23(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -8067,13 +8398,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join21(executionPlanDir, "video-frames");
-  if (!existsSync15(videoRoot)) return;
-  for (const videoEntry of readdirSync6(videoRoot, { withFileTypes: true })) {
+  const videoRoot = join23(executionPlanDir, "video-frames");
+  if (!existsSync16(videoRoot)) return;
+  for (const videoEntry of readdirSync7(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join21(videoRoot, videoEntry.name);
-    if (readdirSync6(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join21(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+    const videoDir = join23(videoRoot, videoEntry.name);
+    if (readdirSync7(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
+      const sentinelPath = join23(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -8114,15 +8445,15 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join21(outputDir, String(index)));
+        framePaths2.set(index, join23(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
-    const frameNames = readdirSync6(outputDir).sort();
+    const frameNames = readdirSync7(outputDir).sort();
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join21(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join23(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -8141,7 +8472,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join21(outputDir, frameName));
+      framePaths.set(frameIndex, join23(outputDir, frameName));
     }
     return {
       ...video,
@@ -8162,8 +8493,8 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join21(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync15(videosPath)) return;
+  const videosPath = join23(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync16(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
     mkdirSync10(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
@@ -8191,13 +8522,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join21(executionPlanDir, "video-frames");
-  const hasExtractedFrames = existsSync15(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join21(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync15(videosPath)) {
+  const videoRoot = join23(executionPlanDir, "video-frames");
+  const hasExtractedFrames = existsSync16(videoRoot) && listFiles(videoRoot).length > 0;
+  const videosPath = join23(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync16(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join21(executionPlanDir, "meta", "chunks.json");
+  const chunksPath = join23(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -8205,7 +8536,7 @@ function buildVideoChunkDependencies(executionPlanDir, dimensions) {
   const extracted = listVideoFramePaths(executionPlanDir, parsedVideos);
   const fpsNum = readPositiveInteger2(dimensions.fpsNum, "dimensions.fpsNum");
   const fpsDen = readPositiveInteger2(dimensions.fpsDen, "dimensions.fpsDen");
-  const table = createFrameLookupTable2(
+  const table = createFrameLookupTable4(
     parsedVideos.videos,
     extracted,
     resolveRenderFpsConfig({ num: fpsNum, den: fpsDen }).value
@@ -8251,10 +8582,10 @@ function computeManifestHash(manifest) {
   return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
 function writeBlob(sourcePath, destinationPath) {
-  if (existsSync15(destinationPath)) return;
+  if (existsSync16(destinationPath)) return;
   mkdirSync10(dirname10(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync4(join21(dirname10(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join21(temporaryDir, "blob");
+  const temporaryDir = mkdtempSync4(join23(dirname10(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join23(temporaryDir, "blob");
   try {
     copyFileSync7(sourcePath, temporaryPath);
     renameSync5(temporaryPath, destinationPath);
@@ -8287,8 +8618,8 @@ async function putBlobs(publisher, blobs) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join21(executionPlanDir, "plan.json");
-  if (!existsSync15(executionPlanPath)) {
+  const executionPlanPath = join23(executionPlanDir, "plan.json");
+  if (!existsSync16(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
   const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
@@ -8315,7 +8646,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  const encoder = readJsonFile(join21(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const encoder = readJsonFile(join23(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
   const chunksCarryAudio2 = isRecord3(encoder) && encoder.chunksCarryAudio === true;
   for (const file of listFiles(executionPlanDir)) {
     if (isExtractionCacheCompleteSentinelPath(file.path)) continue;
@@ -8357,18 +8688,18 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   };
 }
 function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync15(planV2Dir)) {
+  if (existsSync16(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publication = buildPlanV2Publication(executionPlanDir);
   mkdirSync10(dirname10(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync4(join21(dirname10(planV2Dir), ".plan-v2-build-"));
+  const tempDir = mkdtempSync4(join23(dirname10(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
     writeFileSync7(
-      join21(tempDir, "plan.json"),
+      join23(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
@@ -8409,7 +8740,7 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
   return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync4(join21(options.stagingParentDir ?? tmpdir(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync4(join23(options.stagingParentDir ?? tmpdir(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -8419,7 +8750,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
       // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
       whileAudioMixes: () => putBlobs(
         publisher,
-        listFiles(join21(stagingRoot, "compiled")).map(
+        listFiles(join23(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -8437,7 +8768,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync15(planV2Dir)) {
+  if (existsSync16(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
@@ -8449,7 +8780,7 @@ async function planV2(projectDir, config, planV2Dir) {
 function resultFromManifest(planV2Dir, manifest) {
   return {
     planDir: planV2Dir,
-    manifestPath: join21(planV2Dir, "plan.json"),
+    manifestPath: join23(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -8585,8 +8916,8 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join21(planV2Dir, "plan.json");
-  if (!existsSync15(manifestPath)) {
+  const manifestPath = join23(planV2Dir, "plan.json");
+  if (!existsSync16(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
   const value = readJsonFile(manifestPath, "v2 manifest");
@@ -8605,7 +8936,7 @@ function listPlanV2ArtifactsForTarget(manifest, target) {
 }
 function verifyBlob(planV2Dir, artifact) {
   const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync15(sourcePath)) {
+  if (!existsSync16(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
   const stats = statSync6(sourcePath);
@@ -8618,7 +8949,7 @@ function verifyBlob(planV2Dir, artifact) {
   return sourcePath;
 }
 function materializePlanV2Target(planV2Dir, target, destinationDir) {
-  if (existsSync15(destinationDir)) {
+  if (existsSync16(destinationDir)) {
     throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
   }
   const manifest = readPlanV2Manifest(planV2Dir);
@@ -8629,16 +8960,16 @@ function materializePlanV2Target(planV2Dir, target, destinationDir) {
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
   mkdirSync10(dirname10(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync4(join21(dirname10(destinationDir), ".plan-v2-materialize-"));
+  const tempDir = mkdtempSync4(join23(dirname10(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join21(tempDir, ...artifact.path.split("/"));
+      const destinationPath = join23(tempDir, ...artifact.path.split("/"));
       mkdirSync10(dirname10(destinationPath), { recursive: true });
       copyFileSync7(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
     writeFileSync7(
-      join21(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      join23(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({ manifest, target }),
       "utf-8"
     );
@@ -8657,12 +8988,12 @@ function materializePlanV2Target(planV2Dir, target, destinationDir) {
     // Join the artifact's OWN name, not the current constant: a plan written
     // before the container change carries the legacy name, and materializing it
     // under the new one would point at a file that was never written.
-    audioPath: target.role === "assembler" ? audioArtifact ? join21(destinationDir, audioArtifact.path) : null : null
+    audioPath: target.role === "assembler" ? audioArtifact ? join23(destinationDir, audioArtifact.path) : null : null
   };
 }
 function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
-  const markerPath = join21(planDir, PLAN_V2_MATERIALIZATION_MARKER);
-  if (!existsSync15(markerPath)) return null;
+  const markerPath = join23(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  if (!existsSync16(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
     throw new PlanV2IntegrityError("malformed materialization marker");
@@ -8676,8 +9007,8 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   const manifest = parsePlanV2Manifest(marker.manifest);
   const required = listPlanV2ArtifactsForTarget(manifest, expectedTarget);
   for (const artifact of required) {
-    const path = join21(planDir, ...artifact.path.split("/"));
-    if (!existsSync15(path) || statSync6(path).size !== artifact.sizeBytes) {
+    const path = join23(planDir, ...artifact.path.split("/"));
+    if (!existsSync16(path) || statSync6(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -8692,22 +9023,22 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
 // src/services/distributed/planV2Execution.ts
 import { mkdtempSync as mkdtempSync7, rmSync as rmSync13 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync10,
-  readdirSync as readdirSync7,
+  readdirSync as readdirSync8,
   renameSync as renameSync7,
   rmSync as rmSync11,
   statSync as statSync7,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname12, join as join23 } from "node:path";
+import { dirname as dirname12, join as join25 } from "node:path";
 import {
   appendRenderProvenanceArgs,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -8729,7 +9060,7 @@ import {
   rmSync as rmSync10
 } from "node:fs";
 import { open } from "node:fs/promises";
-import { dirname as dirname11, join as join22 } from "node:path";
+import { dirname as dirname11, join as join24 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -9051,13 +9382,13 @@ async function writeStitchedMp4(chunkPaths, outputPath) {
   const header = buildStitchedHeader(layouts);
   mkdirSync11(dirname11(outputPath), { recursive: true });
   const workDir = mkdtempSync5(`${outputPath}.stitch-`);
-  const out = createWriteStream(join22(workDir, "out.mp4"));
+  const out = createWriteStream(join24(workDir, "out.mp4"));
   try {
     out.write(header);
     for (const [i, path] of chunkPaths.entries()) await copyPayload(path, layouts[i], i, out);
     out.end();
     await finished(out);
-    renameSync6(join22(workDir, "out.mp4"), outputPath);
+    renameSync6(join24(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
     rmSync10(workDir, { recursive: true, force: true });
@@ -9091,7 +9422,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync16(dirname12(outputPath))) {
+  if (!existsSync17(dirname12(outputPath))) {
     mkdirSync12(dirname12(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync6(`${outputPath}.assemble-work-`);
@@ -9114,8 +9445,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join23(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync16(audioPath) ? audioPath : null;
+    const finalPath = join25(workDir, `output.${format}`);
+    const audio = audioPath !== null && existsSync17(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameSync7(finalPath, outputPath);
     log.info("[assemble] stage timings", {
@@ -9133,7 +9464,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync16(outputPath) ? statSync7(outputPath).size : 0;
+  const fileSize = existsSync17(outputPath) ? statSync7(outputPath).size : 0;
   return {
     outputPath,
     durationMs: Date.now() - start,
@@ -9142,15 +9473,15 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join23(planDir, "plan.json");
-  const chunksJsonPath = join23(planDir, "meta", "chunks.json");
-  if (!existsSync16(planJsonPath)) {
+  const planJsonPath = join25(planDir, "plan.json");
+  const chunksJsonPath = join25(planDir, "meta", "chunks.json");
+  if (!existsSync17(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
   const plan2 = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync16(chunksJsonPath)) {
+  if (!existsSync17(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
   const chunks = JSON.parse(readFileSync10(chunksJsonPath, "utf-8"));
@@ -9160,7 +9491,7 @@ function readAssemblePlan(planDir, chunkPaths) {
     );
   }
   for (const path of chunkPaths) {
-    if (!existsSync16(path)) {
+    if (!existsSync17(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -9170,7 +9501,7 @@ 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 = join23(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join25(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = [
     ...videoInputArgs(ctx, chunkPaths),
     "-c:v",
@@ -9208,7 +9539,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join23(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join25(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -9248,7 +9579,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join23(workDir, "concat-list.txt");
+  const listPath = join25(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync8(listPath, `${body}
 `, "utf-8");
@@ -9281,8 +9612,8 @@ function chunksAreStitchedMp4(planDir, cfr) {
   return true;
 }
 function chunksCarryAudio(planDir) {
-  const encoderJsonPath = join23(planDir, "meta", "encoder.json");
-  if (!existsSync16(encoderJsonPath)) return false;
+  const encoderJsonPath = join25(planDir, "meta", "encoder.json");
+  if (!existsSync17(encoderJsonPath)) return false;
   return JSON.parse(readFileSync10(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
 }
 function readCfrEncoder(planDir, format) {
@@ -9291,8 +9622,8 @@ function readCfrEncoder(planDir, format) {
       `[assemble] cfr=true is only supported for format="mp4" (got "${format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
     );
   }
-  const encoderJsonPath = join23(planDir, "meta", "encoder.json");
-  if (!existsSync16(encoderJsonPath)) {
+  const encoderJsonPath = join25(planDir, "meta", "encoder.json");
+  if (!existsSync17(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
   const encoderJson = JSON.parse(readFileSync10(encoderJsonPath, "utf-8"));
@@ -9304,7 +9635,7 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync16(outputPath)) rmSync11(outputPath, { recursive: true, force: true });
+  if (existsSync17(outputPath)) rmSync11(outputPath, { recursive: true, force: true });
   mkdirSync12(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -9313,13 +9644,13 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
         `[assemble] png-sequence chunk must be a directory: ${chunkDir} (got a file)`
       );
     }
-    const frames = readdirSync7(chunkDir).filter((name) => name.endsWith(".png")).sort();
+    const frames = readdirSync8(chunkDir).filter((name) => name.endsWith(".png")).sort();
     if (frames.length === 0) {
       throw new Error(`[assemble] png-sequence chunk has no frames: ${chunkDir}`);
     }
     for (const frame of frames) {
-      const dst = join23(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join23(chunkDir, frame), dst);
+      const dst = join25(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join25(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -9328,14 +9659,14 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       `[assemble] png-sequence frame count mismatch: merged ${globalIdx} frames vs plan.totalFrames=${totalFrames}. Using on-disk count.`
     );
   }
-  if (audioPath !== null && existsSync16(audioPath)) {
-    const sidecar = join23(outputPath, MIXED_AUDIO_FILENAME4);
+  if (audioPath !== null && existsSync17(audioPath)) {
+    const sidecar = join25(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
-  for (const name of readdirSync7(outputPath)) {
+  for (const name of readdirSync8(outputPath)) {
     try {
-      fileSize += statSync7(join23(outputPath, name)).size;
+      fileSize += statSync7(join25(outputPath, name)).size;
     } catch {
     }
   }
@@ -9349,22 +9680,19 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync17, mkdirSync as mkdirSync13, readFileSync as readFileSync11, readdirSync as readdirSync8, rmSync as rmSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { extname as extname4, join as join24 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, readFileSync as readFileSync11, readdirSync as readdirSync9, rmSync as rmSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join26 } from "node:path";
 import {
   assertSwiftShader,
-  BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE3,
+  BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE4,
   calculateOptimalWorkers as calculateOptimalWorkers2,
   classifyCaptureFailure as classifyCaptureFailure4,
-  compositionRequiresWebGpu as compositionRequiresWebGpu3,
-  closeCaptureSession as closeCaptureSession9,
-  createCaptureSession as createCaptureSession8,
-  createFrameLookupTable as createFrameLookupTable3,
-  createVideoFrameInjector as createVideoFrameInjector2,
+  closeCaptureSession as closeCaptureSession10,
+  createCaptureSession as createCaptureSession9,
+  createFrameLookupTable as createFrameLookupTable5,
   deriveBeginFrameProbeTimeTicks as deriveBeginFrameProbeTimeTicks2,
-  extractVideoFramesRange,
   getEncoderPreset as getEncoderPreset6,
-  initializeSession as initializeSession8,
+  initializeSession as initializeSession9,
   probeBeginFrameLiveness as probeBeginFrameLiveness2,
   readWebGlVendorInfoFromCanvas,
   resolveConfig as resolveConfig5
@@ -9468,20 +9796,7 @@ async function muxChunkWithAudio(input) {
 
 // src/services/distributed/renderChunk.ts
 import { readWebGlVendorInfoFromCanvas as readWebGlVendorInfoFromCanvas2 } from "@hyperframes/engine";
-var FFMPEG_VERSION_MISMATCH = "FFMPEG_VERSION_MISMATCH";
-var PLAN_HASH_MISMATCH = "PLAN_HASH_MISMATCH";
-var MISSING_PLAN_ARTIFACT = "MISSING_PLAN_ARTIFACT";
-var CHUNK_INDEX_OUT_OF_RANGE = "CHUNK_INDEX_OUT_OF_RANGE";
-var MISSING_RUNTIME_ENV_SNAPSHOT = "MISSING_RUNTIME_ENV_SNAPSHOT";
 var LEGACY_DISTRIBUTED_VP9_CPU_USED = 2;
-var RenderChunkValidationError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "RenderChunkValidationError";
-    this.code = code;
-  }
-};
 function validatePlanVideosForChunk(value) {
   try {
     return parsePlanVideosJson(value);
@@ -9493,10 +9808,10 @@ function validatePlanVideosForChunk(value) {
   }
 }
 var distributedCaptureSessionDependencies = {
-  createCaptureSession: createCaptureSession8,
+  createCaptureSession: createCaptureSession9,
   assertSwiftShader,
-  initializeSession: initializeSession8,
-  closeCaptureSession: closeCaptureSession9,
+  initializeSession: initializeSession9,
+  closeCaptureSession: closeCaptureSession10,
   readWebGlVendorInfo: readWebGlVendorInfoFromCanvas
 };
 async function createVerifiedDistributedCaptureSession(serverUrl, framesDir, captureOptions, cfg, dependencies = distributedCaptureSessionDependencies) {
@@ -9517,9 +9832,6 @@ async function createVerifiedDistributedCaptureSession(serverUrl, framesDir, cap
     throw error;
   }
 }
-function createChunkVideoFrameInjectorFactory(frameLookup) {
-  return () => createVideoFrameInjector2(frameLookup);
-}
 function isCaptureMode(value) {
   return value === "beginframe" || value === "screenshot" || value === "drawelement";
 }
@@ -9547,130 +9859,11 @@ async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBe
   );
   return !await probe(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
 }
-function frameNumberFromFileName(name) {
-  const match = /(\d+)(?=\.[^.]+$)/.exec(name);
-  if (!match) return null;
-  const frameNumber = Number(match[1]);
-  return Number.isSafeInteger(frameNumber) ? frameNumber : null;
-}
-function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
-  const result = [];
-  for (const v of videos) {
-    const outputDir = join24(planDir, "video-frames", v.videoId);
-    if (!existsSync17(outputDir)) {
-      throw new Error(
-        `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
-      );
-    }
-    const ext = (extname4(v.framePattern) || ".jpg").toLowerCase();
-    const frames = readdirSync8(outputDir).filter((name) => name.toLowerCase().endsWith(ext)).sort((left, right) => {
-      const leftNumber = frameNumberFromFileName(left);
-      const rightNumber = frameNumberFromFileName(right);
-      if (leftNumber === null || rightNumber === null) return left.localeCompare(right);
-      return leftNumber - rightNumber || left.localeCompare(right);
-    });
-    const framePaths = /* @__PURE__ */ new Map();
-    for (let i = 0; i < frames.length; i++) {
-      const frameName = frames[i];
-      if (!frameName) continue;
-      const frameNumber = indexMode === "sparse-v2" ? frameNumberFromFileName(frameName) : null;
-      const frameIndex = frameNumber === null ? i : frameNumber - 1;
-      framePaths.set(frameIndex, join24(outputDir, frameName));
-    }
-    result.push({
-      videoId: v.videoId,
-      srcPath: v.srcPath,
-      outputDir,
-      framePattern: v.framePattern,
-      fps: v.fps,
-      totalFrames: v.totalFrames,
-      metadata: v.metadata,
-      framePaths,
-      // The chunk worker doesn't own the planDir's video-frames/ directory
-      // (the controller does — adapters that fan out chunks across machines
-      // share the planDir as read-only). Mark ownership as false so the
-      // injector's eventual cleanup doesn't rm bytes another worker may
-      // still be reading.
-      ownedByLookup: false
-    });
-  }
-  return result;
-}
-function contiguousRuns(sortedIndexes) {
-  const runs2 = [];
-  for (const index of sortedIndexes) {
-    const last = runs2[runs2.length - 1];
-    if (last && last.firstFrame + last.frames === index) last.frames++;
-    else runs2.push({ firstFrame: index, frames: 1 });
-  }
-  return runs2;
-}
-async function extractDeferredVideoFramesForChunk(input) {
-  const deferred = input.planVideos.extracted.filter((video) => video.deferredRange);
-  if (deferred.length === 0) return [];
-  const table = createFrameLookupTable3(
-    input.planVideos.videos,
-    deferred.map((video) => ({
-      ...video,
-      outputDir: input.outputRoot,
-      framePaths: new Map(Array.from({ length: video.totalFrames }, (_, i) => [i, String(i)]))
-    })),
-    resolveRenderFpsConfig(input.fps).value
-  );
-  const shown = /* @__PURE__ */ new Map();
-  for (let frame = input.slice.startFrame; frame < input.slice.endFrame; frame++) {
-    const globalTime = frame * input.fps.den / input.fps.num;
-    for (const [videoId, payload] of table.getActiveFramePayloads(globalTime)) {
-      const indexes = shown.get(videoId) ?? /* @__PURE__ */ new Set();
-      indexes.add(payload.frameIndex);
-      shown.set(videoId, indexes);
-    }
-  }
-  return Promise.all(
-    deferred.map(async (video) => {
-      const outputDir = join24(input.outputRoot, video.videoId);
-      const indexes = [...shown.get(video.videoId) ?? []].sort((a, b) => a - b);
-      if (indexes.length === 0) {
-        return { ...video, outputDir, framePaths: /* @__PURE__ */ new Map(), ownedByLookup: false };
-      }
-      const range = video.deferredRange;
-      const sourcePath = join24(input.planDir, ...range.sourcePath.split("/"));
-      if (!existsSync17(sourcePath)) {
-        throw new RenderChunkValidationError(
-          MISSING_PLAN_ARTIFACT,
-          `[renderChunk] planDir is missing the source for video ${JSON.stringify(video.videoId)}: ${range.sourcePath}`
-        );
-      }
-      const extracted = await extractVideoFramesRange(
-        sourcePath,
-        video.videoId,
-        range.startTime,
-        range.durationSeconds,
-        {
-          fps: input.fps,
-          outputDir: input.outputRoot,
-          format: range.format,
-          frameRanges: contiguousRuns(indexes)
-        },
-        void 0,
-        input.cfg
-      );
-      const missing = indexes.find((index) => !extracted.framePaths.has(index));
-      if (missing !== void 0) {
-        throw new RenderChunkValidationError(
-          INVALID_VIDEO_METADATA,
-          `[renderChunk] video ${JSON.stringify(video.videoId)} has no frame ${missing}; the plan expected ${video.totalFrames} frames from ${range.sourcePath}.`
-        );
-      }
-      return { ...video, outputDir, framePaths: extracted.framePaths, ownedByLookup: false };
-    })
-  );
-}
 function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync11(outputPath));
-  const entries = readdirSync8(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
+  const entries = readdirSync9(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync11(join24(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync11(join26(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -9687,10 +9880,10 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join24(planDir, "plan.json");
-  const encoderJsonPath = join24(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join24(planDir, "meta", "chunks.json");
-  if (!existsSync17(planJsonPath)) {
+  const planJsonPath = join26(planDir, "plan.json");
+  const encoderJsonPath = join26(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join26(planDir, "meta", "chunks.json");
+  if (!existsSync18(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
@@ -9704,7 +9897,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     chunkIndex
   });
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync17(required)) {
+    if (!existsSync18(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
@@ -9713,9 +9906,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   }
   const encoder = JSON.parse(readFileSync11(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync11(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join24(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join26(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync17(videosJsonPath)) {
+  if (existsSync18(videosJsonPath)) {
     try {
       planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync11(videosJsonPath, "utf-8")));
     } catch (err) {
@@ -9743,8 +9936,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       `[renderChunk] chunk ${chunkIndex} has non-positive frame count: ${framesInChunk}`
     );
   }
-  const compiledDir = join24(planDir, "compiled");
-  if (!existsSync17(compiledDir)) {
+  const compiledDir = join26(planDir, "compiled");
+  if (!existsSync18(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -9759,7 +9952,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   }
   if (encoder.browserGpuMode !== "software") {
     throw new RenderChunkValidationError(
-      BROWSER_GPU_NOT_SOFTWARE3,
+      BROWSER_GPU_NOT_SOFTWARE4,
       `[renderChunk] planDir requires browserGpuMode=software, got ${JSON.stringify(encoder.browserGpuMode)}.`
     );
   }
@@ -9801,10 +9994,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
     mkdirSync13(workDir, { recursive: true });
-    const framesDir = join24(workDir, "captured-frames");
+    const framesDir = join26(workDir, "captured-frames");
     mkdirSync13(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
-    const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable3(
+    const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable5(
       planVideos.videos,
       [
         ...rebuildExtractedFramesFromPlanDir(
@@ -9815,7 +10008,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         ...await extractDeferredVideoFramesForChunk({
           planDir,
           planVideos,
-          slice,
+          frames: Array.from(
+            { length: slice.endFrame - slice.startFrame },
+            (_, i) => slice.startFrame + i
+          ),
           fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
           outputRoot: videoFramesDir,
           cfg
@@ -9824,9 +10020,6 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       resolveRenderFpsConfig(job.config.fps).value
     ) : null;
     const createChunkVideoFrameInjector = createChunkVideoFrameInjectorFactory(videoFrameLookup);
-    const videoCaptureBeyondViewport = resolveVideoCaptureBeyondViewport(
-      planVideos?.videos.length ?? 0
-    );
     const fileServer = await createFileServer({
       projectDir: compiledDir,
       compiledDir,
@@ -9836,28 +10029,12 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       // chunk runtime seek quantization stays on the same fps grid as capture.
       fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen }
     });
-    const captureOptions = {
-      width: plan2.dimensions.width,
-      height: plan2.dimensions.height,
-      fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
-      format: plan2.dimensions.format === "mp4" ? "jpeg" : "png",
-      quality: plan2.dimensions.format === "mp4" ? resolveCaptureJpegQuality(job.config.quality) : void 0,
-      deviceScaleFactor: encoder.deviceScaleFactor,
-      // Re-inject the controller's snapshotted variables so the chunk's
-      // first capture sees the same `window.__hfVariables` the in-process
-      // renderer would have seen. Optional — compositions that don't
-      // declare `data-composition-variables` leave this undefined and the
-      // engine skips the `evaluateOnNewDocument` injection.
-      variables: encoder.variables,
-      subTimelineWaitMemo: {},
-      ...videoCaptureBeyondViewport !== void 0 ? { captureBeyondViewport: videoCaptureBeyondViewport } : {},
-      // lock the BeginFrame warmup loop to a fixed iteration count so
-      // `beginFrameTimeTicks` is host-independent. Only chunks ever set this.
-      lockWarmupTicks: true,
-      requiresWebGpu: compositionRequiresWebGpu3(
-        readFileSync11(join24(compiledDir, "index.html"), "utf-8")
-      )
-    };
+    const captureOptions = buildChunkCaptureOptions({
+      dimensions: plan2.dimensions,
+      encoder,
+      videoCount: planVideos?.videos.length ?? 0,
+      html: readFileSync11(join26(compiledDir, "index.html"), "utf-8")
+    });
     const chunkWorkerCount = calculateOptimalWorkers2(framesInChunk, void 0, cfg);
     let session = null;
     let outputKind;
@@ -9888,7 +10065,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
             { chunkIndex }
           );
           if (chunkWorkerCount > 1) {
-            await closeCaptureSession9(session);
+            await closeCaptureSession10(session);
             session = null;
           }
         } else if (beginFrameStalled) {
@@ -9897,7 +10074,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
             "[renderChunk] BeginFrame liveness probe failed; using screenshot capture for the entire chunk",
             { chunkIndex }
           );
-          await closeCaptureSession9(session).catch(() => {
+          await closeCaptureSession10(session).catch(() => {
           });
           session = null;
           if (chunkWorkerCount === 1) {
@@ -9916,7 +10093,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
             sessionBootMs += Date.now() - screenshotBootStarted;
           }
         } else if (chunkWorkerCount > 1) {
-          await closeCaptureSession9(session);
+          await closeCaptureSession10(session);
           session = null;
         }
       }
@@ -10018,10 +10195,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
       const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
       if (isPngSequence) {
-        if (!existsSync17(outputChunkPath)) mkdirSync13(outputChunkPath, { recursive: true });
+        if (!existsSync18(outputChunkPath)) mkdirSync13(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join24(outputChunkPath, "..");
-        if (!existsSync17(outDir)) mkdirSync13(outDir, { recursive: true });
+        const outDir = join26(outputChunkPath, "..");
+        if (!existsSync18(outDir)) mkdirSync13(outDir, { recursive: true });
       }
       const encodeStarted = Date.now();
       await runEncodeStage({
@@ -10079,7 +10256,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     } finally {
       if (session) {
         try {
-          await closeCaptureSession9(session);
+          await closeCaptureSession10(session);
         } catch (err) {
           log.warn("[renderChunk] error closing capture session in finally", {
             error: err instanceof Error ? err.message : String(err)
@@ -10144,8 +10321,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
-  const workRoot = mkdtempSync7(join25(tmpdir2(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join25(workRoot, "plan");
+  const workRoot = mkdtempSync7(join27(tmpdir2(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join27(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath);
@@ -10154,8 +10331,8 @@ async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync7(join25(tmpdir2(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join25(workRoot, "plan");
+  const workRoot = mkdtempSync7(join27(tmpdir2(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join27(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -10417,18 +10594,18 @@ function validateIntDimension(field, value) {
 }
 
 // src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync12 } from "node:fs";
+import { readdirSync as readdirSync10, readFileSync as readFileSync12 } from "node:fs";
 import { createHash as createHash6 } from "node:crypto";
-import { join as join26, relative as relative7 } from "node:path";
+import { join as join28, relative as relative7 } from "node:path";
 function hashProjectDir(projectDir) {
   const hash = createHash6("sha256");
   const files = [];
   function walk(dir, isRoot) {
-    for (const entry of readdirSync9(dir, { withFileTypes: true }).sort(
+    for (const entry of readdirSync10(dir, { withFileTypes: true }).sort(
       (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
     )) {
       if (isRoot && PLAN_PROJECT_DIR_SKIP_SEGMENTS.has(entry.name)) continue;
-      const full = join26(dir, entry.name);
+      const full = join28(dir, entry.name);
       if (entry.isDirectory()) walk(full, false);
       else if (entry.isFile()) files.push(full);
     }