@hyperframes/producer 0.8.174 → 0.8.176

package/dist/index.js

@@ -6923,7 +6923,7 @@ async function embedLocalFontFaces(html, projectDir) {
               embeddedPaths.add(localPath);
               continue;
             }
-            dataUri = await toDataUri(font.buffer, ext);
+            dataUri = await toDataUri(font.buffer, ext, { compressToWoff2: false });
             dataUriByAbsolutePath.set(absPath, dataUri);
             defaultLogger.info(
               `[Compiler] Embedded local font file: ${localPath} (${(font.buffer.length / 1024).toFixed(0)} KB \u2192 data URI)`
@@ -13577,688 +13577,914 @@ import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframe
 import {
   copyFileSync as copyFileSync5,
   cpSync as cpSync2,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   linkSync,
   mkdirSync as mkdirSync11,
   renameSync as renameSync5,
   rmSync as rmSync10,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { extname as extname5, isAbsolute as isAbsolute3, join as join30, relative as relative5, sep as sep2 } from "node:path";
-import { fpsToNumber as fpsToNumber10 } from "@hyperframes/core";
+import { extname as extname6, isAbsolute as isAbsolute3, join as join32, 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,
   resolveConfig as resolveConfig3
 } from "@hyperframes/engine";
 
-// src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync9, readdirSync as readdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join27, relative as relative3, resolve as resolve8 } from "node:path";
+// src/services/distributed/planFrameCost.ts
+import { join as join29 } 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 existsSync18, readdirSync as readdirSync6 } from "node:fs";
+import { extname as extname4, join as join28 } 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 dirname11, join as join27 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
+import { fileURLToPath as fileURLToPath5 } 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 = join27(planDir, name);
+    if (existsSync17(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 createHash6 } from "node:crypto";
-import { closeSync as closeSync5, createReadStream as createReadStream3, openSync as openSync4, readSync as readSync3 } from "node:fs";
-var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
-var FIELD_DELIMITER = Buffer.from([0]);
-function computePlanHash(input) {
-  const hash = createHash6("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}`);
-}
-function sha256Hex(bytes) {
-  const h = createHash6("sha256");
-  h.update(bytes);
-  return h.digest("hex");
+  return {
+    sourcePath,
+    startTime: readFiniteNumber(range.startTime, `${field}.startTime`),
+    durationSeconds,
+    format: range.format
+  };
 }
-function sha256File(path) {
-  const hash = createHash6("sha256");
-  const buffer = Buffer.allocUnsafe(1024 * 1024);
-  const fd = openSync4(path, "r");
-  try {
-    let bytesRead = 0;
-    do {
-      bytesRead = readSync3(fd, buffer, 0, buffer.byteLength, null);
-      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
-    } while (bytesRead > 0);
-  } finally {
-    closeSync5(fd);
+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 hash.digest("hex");
+  return lane;
 }
-async function sha256FileAsync(path) {
-  const hash = createHash6("sha256");
-  for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
-    hash.update(chunk);
+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
+  };
 }
-
-// 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);
+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 sha256;
-}
-async function prehashPlanFiles(dir, digests) {
-  if (!existsSync17(dir)) return;
-  for (const { absolutePath } of listPlanFiles(dir)) {
-    if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
+  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);
   }
-}
-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);
+  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)}`
+      );
     }
-    return out;
   }
-  return value;
-}
-function listPlanFiles(planDir) {
-  const results = [];
-  const rootResolved = resolve8(planDir);
-  function walk(dir) {
-    const entries = readdirSync6(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join27(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full);
-      } else if (entry.isFile()) {
-        results.push({
-          planRelativePath: relative3(rootResolved, full).split(/[\\/]+/).join("/"),
-          absolutePath: full
-        });
-      }
+  for (const video of videos) {
+    if (!extractedIds.has(video.id)) {
+      metadataError(
+        "meta/videos.json.extracted",
+        `is missing declared video ${JSON.stringify(video.id)}`
+      );
     }
   }
-  walk(rootResolved);
-  results.sort((a, b) => a.planRelativePath < b.planRelativePath ? -1 : 1);
-  return results;
+  return { videos, extracted };
 }
-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 = readFileSync9(file.absolutePath);
-      continue;
+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"
+      );
     }
-    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).`
-    );
-  }
-  return { compositionHtml, assets };
+    return { ...video, end: input.compositionEnd };
+  });
+  return parsePlanVideosJson({ videos, extracted: input.extracted });
 }
-function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join27(planDir, "plan.json");
-  const encoderJsonPath = join27(planDir, "meta", "encoder.json");
-  if (!existsSync17(planJsonPath)) {
-    throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
+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 (!existsSync17(encoderJsonPath)) {
-    throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
+  const firstLine = stdout.split(/\r?\n/)[0]?.trim() ?? "";
+  if (!firstLine) {
+    throw new Error("ffmpeg -version returned empty output");
   }
-  const planJson = JSON.parse(readFileSync9(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync9(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
-  });
+  cachedFfmpegVersions.set(binary, firstLine);
+  return firstLine;
 }
-async function freezePlan(input) {
-  const {
-    planDir,
-    composition,
-    encoder,
-    chunks,
-    dimensions,
-    producerVersion,
-    fontSnapshotSha,
-    durationSeconds,
-    totalFrames,
-    hasAudio,
-    digests
-  } = input;
-  if (!existsSync17(planDir)) {
-    throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
-  }
-  const metaDir = join27(planDir, "meta");
-  if (!existsSync17(metaDir)) mkdirSync10(metaDir, { recursive: true });
-  writeFileSync6(
-    join27(metaDir, "composition.json"),
-    `${JSON.stringify(composition, null, 2)}
-`,
-    "utf-8"
-  );
-  const encoderForCanonical = stripUndefined(encoder);
-  const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync6(join27(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync6(join27(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 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
   };
-  const planJsonPath = join27(planDir, "plan.json");
-  writeFileSync6(planJsonPath, `${JSON.stringify(planJson, null, 2)}
-`, "utf-8");
-  return { planJsonPath, planHash };
+  return createRenderJob(renderConfig);
+}
+var cachedProducerVersion = null;
+function readProducerVersion() {
+  if (cachedProducerVersion !== null) return cachedProducerVersion;
+  const startDir = dirname11(fileURLToPath5(import.meta.url));
+  let current = startDir;
+  for (let i = 0; i < 10; i++) {
+    const candidate = join27(current, "package.json");
+    if (existsSync17(candidate)) {
+      try {
+        const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
+        if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
+          cachedProducerVersion = pkg.version;
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname11(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  cachedProducerVersion = "0.0.0-unknown";
+  return cachedProducerVersion;
 }
 
-// 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;
+// 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;
   }
-  return snapshot;
+};
+function createChunkVideoFrameInjectorFactory(frameLookup) {
+  return () => createVideoFrameInjector2(frameLookup);
 }
-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;
+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 = join28(planDir, "video-frames", v.videoId);
+    if (!existsSync18(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 = readdirSync6(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, join28(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
+    });
   }
+  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;
+}
+function buildChunkCaptureOptions(input) {
+  const { dimensions, encoder } = input;
+  const videoCaptureBeyondViewport = resolveVideoCaptureBeyondViewport(input.videoCount);
   return {
-    restore: () => {
-      for (const [key, value] of Object.entries(previous)) {
-        if (value === void 0) delete env[key];
-        else env[key] = value;
+    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)
+  };
+}
+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 Promise.all(
+    deferred.map(async (video) => {
+      const outputDir = join28(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 = join28(input.planDir, ...range.sourcePath.split("/"));
+      if (!existsSync18(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 dirname11, join as join28 } from "node:path";
-import { existsSync as existsSync18, readFileSync as readFileSync10 } from "node:fs";
-import { fileURLToPath as fileURLToPath5 } 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 = join28(planDir, name);
-    if (existsSync18(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: join29(workDir, "frame-cost-video-frames"),
+      cfg: input.cfg
+    })
+  ];
+  const lookup = extracted.length > 0 ? createFrameLookupTable3(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
+  const compiledDir = join29(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,
+      join29(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 existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join30, relative as relative3, resolve as resolve8 } 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 createHash6 } from "node:crypto";
+import { closeSync as closeSync5, createReadStream as createReadStream3, openSync as openSync4, readSync as readSync3 } from "node:fs";
+var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
+var FIELD_DELIMITER = Buffer.from([0]);
+function computePlanHash(input) {
+  const hash = createHash6("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(",")}]`;
   }
-  return {
-    sourcePath,
-    startTime: readFiniteNumber(range.startTime, `${field}.startTime`),
-    durationSeconds,
-    format: range.format
-  };
+  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 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");
+function sha256Hex(bytes) {
+  const h = createHash6("sha256");
+  h.update(bytes);
+  return h.digest("hex");
+}
+function sha256File(path) {
+  const hash = createHash6("sha256");
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  const fd = openSync4(path, "r");
+  try {
+    let bytesRead = 0;
+    do {
+      bytesRead = readSync3(fd, buffer, 0, buffer.byteLength, null);
+      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
+    } while (bytesRead > 0);
+  } finally {
+    closeSync5(fd);
   }
-  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`)
-    };
+async function sha256FileAsync(path) {
+  const hash = createHash6("sha256");
+  for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
+    hash.update(chunk);
   }
-  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 hash.digest("hex");
 }
-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");
+
+// 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 (!existsSync19(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 = resolve8(planDir);
+  function walk(dir) {
+    const entries = readdirSync7(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join30(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 = readFileSync10(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 = join30(planDir, "plan.json");
+  const encoderJsonPath = join30(planDir, "meta", "encoder.json");
+  if (!existsSync19(planJsonPath)) {
+    throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
-  cachedFfmpegVersions.set(binary, firstLine);
-  return firstLine;
+  if (!existsSync19(encoderJsonPath)) {
+    throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
+  }
+  const planJson = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
+  const encoderConfigCanonicalJson = readFileSync10(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 (!existsSync19(planDir)) {
+    throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
+  }
+  const metaDir = join30(planDir, "meta");
+  if (!existsSync19(metaDir)) mkdirSync10(metaDir, { recursive: true });
+  writeFileSync6(
+    join30(metaDir, "composition.json"),
+    `${JSON.stringify(composition, null, 2)}
+`,
+    "utf-8"
+  );
+  const encoderForCanonical = stripUndefined(encoder);
+  const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
+  writeFileSync6(join30(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync6(join30(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 = join30(planDir, "plan.json");
+  writeFileSync6(planJsonPath, `${JSON.stringify(planJson, null, 2)}
+`, "utf-8");
+  return { planJsonPath, planHash };
 }
-var cachedProducerVersion = null;
-function readProducerVersion() {
-  if (cachedProducerVersion !== null) return cachedProducerVersion;
-  const startDir = dirname11(fileURLToPath5(import.meta.url));
-  let current = startDir;
-  for (let i = 0; i < 10; i++) {
-    const candidate = join28(current, "package.json");
-    if (existsSync18(candidate)) {
-      try {
-        const pkg = JSON.parse(readFileSync10(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 = dirname11(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  cachedProducerVersion = "0.0.0-unknown";
-  return cachedProducerVersion;
+  };
 }
 
 // src/services/distributed/planSize.ts
 import { createHash as createHash7 } from "node:crypto";
-import { lstatSync as lstatSync2, readdirSync as readdirSync7 } from "node:fs";
-import { extname as extname4, join as join29, relative as relative4 } from "node:path";
+import { lstatSync as lstatSync2, readdirSync as readdirSync8 } from "node:fs";
+import { extname as extname5, join as join31, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -14318,7 +14544,7 @@ function emptyBreakdown() {
 function addCategoryBytes(result, category, filePath, sizeBytes) {
   if (category === "compiled") {
     result.compiledBytes += sizeBytes;
-    if (SOURCE_MEDIA_EXTENSIONS.has(extname4(filePath).toLowerCase())) {
+    if (SOURCE_MEDIA_EXTENSIONS.has(extname5(filePath).toLowerCase())) {
       result.sourceMediaBytes += sizeBytes;
     }
     return;
@@ -14365,12 +14591,12 @@ function recordFile(result, components, rootDir, rootKind, filePath) {
 function walkRegularFiles(dir, visit) {
   let entries;
   try {
-    entries = readdirSync7(dir, { withFileTypes: true });
+    entries = readdirSync8(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const full = join29(dir, entry.name);
+    const full = join31(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -14431,8 +14657,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 {
@@ -14445,18 +14680,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;
@@ -14467,7 +14699,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
     );
   }
@@ -14574,13 +14806,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join30("meta", "composition.json"),
-  join30("meta", "encoder.json"),
-  join30("meta", "chunks.json")
+  join32("meta", "composition.json"),
+  join32("meta", "encoder.json"),
+  join32("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync10(join30(planDir, relativePath), { force: true });
+    rmSync10(join32(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -14711,19 +14943,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join30(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join32(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 && existsSync19(join30(input.planDir, "compiled", rel))) {
+      if (rel !== null && existsSync20(join32(input.planDir, "compiled", rel))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
     }
     if (result === null) {
-      result = `video-sources/${shipped.size}${extname5(current)}`;
-      const destination = join30(input.planDir, ...result.split("/"));
-      mkdirSync11(join30(input.planDir, "video-sources"), { recursive: true });
+      result = `video-sources/${shipped.size}${extname6(current)}`;
+      const destination = join32(input.planDir, ...result.split("/"));
+      mkdirSync11(join32(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -14741,7 +14973,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync19(planDir)) mkdirSync11(planDir, { recursive: true });
+  if (!existsSync20(planDir)) mkdirSync11(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -14770,14 +15002,14 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join30(projectDir, entryFile);
-  if (!existsSync19(htmlPath)) {
+  const htmlPath = join32(projectDir, entryFile);
+  if (!existsSync20(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join30(planDir, ".plan-work");
+  const workDir = join32(planDir, ".plan-work");
   rmSync10(workDir, { recursive: true, force: true });
   mkdirSync11(workDir, { recursive: true });
-  const compiledDir = join30(workDir, "compiled");
+  const compiledDir = join32(workDir, "compiled");
   mkdirSync11(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
@@ -14791,7 +15023,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join30(planDir, "compiled");
+  const finalCompiledDir = join32(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   stageStarted = Date.now();
   const compileResult = await runCompileStage({
@@ -14854,27 +15086,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession11 } = await import("@hyperframes/engine");
-      await closeCaptureSession11(probeResult.probeSession);
+      const { closeCaptureSession: closeCaptureSession12 } = await import("@hyperframes/engine");
+      await closeCaptureSession12(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",
@@ -14899,17 +15121,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (extractResult.extractionResult) {
     assertVideoExtractionSucceeded(extractResult.extractionResult);
   }
-  const stagedVideoFrames = join30(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join30(planDir, "video-frames");
-  if (existsSync19(videoFramesDst)) rmSync10(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join30(planDir, "video-sources");
+  const stagedVideoFrames = join32(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join32(planDir, "video-frames");
+  if (existsSync20(videoFramesDst)) rmSync10(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join32(planDir, "video-sources");
   rmSync10(videoSourcesDir, { recursive: true, force: true });
-  if (existsSync19(stagedVideoFrames)) {
+  if (existsSync20(stagedVideoFrames)) {
     renameSync5(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync11(videoFramesDst, { recursive: true });
   }
-  if (existsSync19(finalCompiledDir)) rmSync10(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync20(finalCompiledDir)) rmSync10(finalCompiledDir, { recursive: true, force: true });
   renameSync5(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -14935,9 +15157,9 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       ...ext.deferredRange ? { deferredRange: { ...ext.deferredRange, sourcePath: shipVideoSource(ext.srcPath) } } : {}
     }))
   });
-  mkdirSync11(join30(planDir, "meta"), { recursive: true });
+  mkdirSync11(join32(planDir, "meta"), { recursive: true });
   writeFileSync7(
-    join30(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+    join32(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -14945,7 +15167,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,
@@ -14968,19 +15190,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 = join30(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult.hasAudio && existsSync19(audioResult.audioOutputPath)) {
+  const planAudioPath = join32(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  if (audioResult.hasAudio && existsSync20(audioResult.audioOutputPath)) {
     renameSync5(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio2 && existsSync19(planAudioPath)) {
+  if (chunksCarryAudio2 && existsSync20(planAudioPath)) {
     stageStarted = Date.now();
     const peak = await constrainAacTruePeak({
       audioPath: planAudioPath,
@@ -15565,9 +15821,9 @@ function renderRequestFromDistributedConfig(input) {
 
 // src/services/frameCapture.ts
 import {
-  createCaptureSession as createCaptureSession8,
-  initializeSession as initializeSession8,
-  closeCaptureSession as closeCaptureSession9,
+  createCaptureSession as createCaptureSession9,
+  initializeSession as initializeSession9,
+  closeCaptureSession as closeCaptureSession10,
   captureFrame as captureFrame2,
   captureFrameToBuffer as captureFrameToBuffer4,
   getCompositionDuration as getCompositionDuration2,
@@ -15587,7 +15843,7 @@ import {
 
 // src/server.ts
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync12,
   statSync as statSync8,
   mkdtempSync as mkdtempSync4,
@@ -15595,7 +15851,7 @@ import {
   rmSync as rmSync11,
   createReadStream as createReadStream4
 } from "node:fs";
-import { resolve as resolve10, dirname as dirname13, join as join33 } from "node:path";
+import { resolve as resolve10, dirname as dirname13, join as join35 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -15605,7 +15861,7 @@ import { serve as serve2 } from "@hono/node-server";
 
 // src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   readFileSync as readFileSync11,
   statSync as statSync7,
   openSync as openSync5,
@@ -15613,7 +15869,7 @@ import {
   closeSync as closeSync6,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve9, join as join31, relative as relative6, isAbsolute as isAbsolute4, sep as sep3 } from "node:path";
+import { resolve as resolve9, join as join33, relative as relative6, isAbsolute as isAbsolute4, sep as sep3 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -15659,7 +15915,7 @@ function readEntryHtml(filePath) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve9(projectDir);
-  if (!existsSync20(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
+  if (!existsSync21(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -15681,7 +15937,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join31(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join33(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -15727,8 +15983,8 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { dirname as dirname12, join as join32 } from "node:path";
-import { existsSync as existsSync21 } from "node:fs";
+import { dirname as dirname12, join as join34 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -15803,9 +16059,9 @@ function defaultLogger2() {
 }
 function resolveWorkerEntry2() {
   const here = dirname12(fileURLToPath6(import.meta.url));
-  const candidates = [join32(here, "healthWorkerThread.js"), join32(here, "healthWorkerThread.ts")];
+  const candidates = [join34(here, "healthWorkerThread.js"), join34(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync21(candidate)) return candidate;
+    if (existsSync22(candidate)) return candidate;
   }
   return void 0;
 }
@@ -15950,7 +16206,7 @@ function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
   const outputDir = dirname13(absoluteOutputPath);
-  if (!existsSync22(outputDir)) mkdirSync12(outputDir, { recursive: true });
+  if (!existsSync23(outputDir)) mkdirSync12(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -15990,11 +16246,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve10(candidate);
-  if (!existsSync22(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
+  if (!existsSync23(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync22(resolve10(absProjectDir, entry))) {
+  if (!existsSync23(resolve10(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -16019,8 +16275,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync4(join33(tempRoot, "producer-project-"));
-  writeFileSync8(join33(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync4(join35(tempRoot, "producer-project-"));
+  writeFileSync8(join35(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -16086,7 +16342,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync22(path) ? statSync8(path).size : 0;
+  return existsSync23(path) ? statSync8(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -16382,7 +16638,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync22(artifact.path)) {
+    if (!existsSync23(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -16479,26 +16735,26 @@ import { quantizeTimeToFrame, MEDIA_VISUAL_STYLE_PROPERTIES } from "@hyperframes
 // src/services/distributed/planV2.ts
 import {
   copyFileSync as copyFileSync7,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync14,
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync12,
-  readdirSync as readdirSync8,
+  readdirSync as readdirSync9,
   renameSync as renameSync7,
   rmSync as rmSync13,
   statSync as statSync10,
   writeFileSync as writeFileSync10
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname15, isAbsolute as isAbsolute5, join as join36, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
+import { dirname as dirname15, isAbsolute as isAbsolute5, join as join38, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
 import { DISTRIBUTED_FPS as DISTRIBUTED_FPS2, isDistributedFps as isDistributedFps3 } 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 existsSync23,
+  existsSync as existsSync24,
   linkSync as linkSync2,
   mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync5,
@@ -16507,7 +16763,7 @@ import {
   statSync as statSync9,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { dirname as dirname14, join as join35 } from "node:path";
+import { dirname as dirname14, join as join37 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -16522,7 +16778,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join34 } from "node:path";
+import { join as join36 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -16532,7 +16788,7 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join34(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join36(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
@@ -16567,13 +16823,13 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync23(destinationDir)) {
+    if (existsSync24(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
     mkdirSync13(dirname14(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync5(join35(dirname14(destinationDir), ".plan-v2-publish-"));
+    this.temporaryDir = mkdtempSync5(join37(dirname14(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -16584,10 +16840,10 @@ var LocalPlanV2ArtifactPublisher = class {
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync23(destinationPath)) return;
+    if (existsSync24(destinationPath)) return;
     mkdirSync13(dirname14(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync5(join35(dirname14(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join35(stagingDir, "blob");
+    const stagingDir = mkdtempSync5(join37(dirname14(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join37(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -16602,13 +16858,13 @@ var LocalPlanV2ArtifactPublisher = class {
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync23(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync24(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
       }
     }
-    writeFileSync9(join35(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync9(join37(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameSync6(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
@@ -16652,8 +16908,8 @@ function listFiles(root) {
   const files = [];
   const rootResolved = resolve11(root);
   function walk(dir) {
-    for (const entry of readdirSync8(dir, { withFileTypes: true })) {
-      const absolutePath = join36(dir, entry.name);
+    for (const entry of readdirSync9(dir, { withFileTypes: true })) {
+      const absolutePath = join38(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -16680,13 +16936,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join36(executionPlanDir, "video-frames");
-  if (!existsSync24(videoRoot)) return;
-  for (const videoEntry of readdirSync8(videoRoot, { withFileTypes: true })) {
+  const videoRoot = join38(executionPlanDir, "video-frames");
+  if (!existsSync25(videoRoot)) return;
+  for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join36(videoRoot, videoEntry.name);
-    if (readdirSync8(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join36(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+    const videoDir = join38(videoRoot, videoEntry.name);
+    if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
+      const sentinelPath = join38(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -16727,15 +16983,15 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join36(outputDir, String(index)));
+        framePaths2.set(index, join38(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
-    const frameNames = readdirSync8(outputDir).sort();
+    const frameNames = readdirSync9(outputDir).sort();
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join36(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join38(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -16754,7 +17010,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join36(outputDir, frameName));
+      framePaths.set(frameIndex, join38(outputDir, frameName));
     }
     return {
       ...video,
@@ -16775,8 +17031,8 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join36(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync24(videosPath)) return;
+  const videosPath = join38(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync25(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
     mkdirSync14(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
@@ -16804,13 +17060,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join36(executionPlanDir, "video-frames");
-  const hasExtractedFrames = existsSync24(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join36(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync24(videosPath)) {
+  const videoRoot = join38(executionPlanDir, "video-frames");
+  const hasExtractedFrames = existsSync25(videoRoot) && listFiles(videoRoot).length > 0;
+  const videosPath = join38(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync25(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join36(executionPlanDir, "meta", "chunks.json");
+  const chunksPath = join38(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -16818,7 +17074,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
@@ -16864,10 +17120,10 @@ function computeManifestHash(manifest) {
   return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
 function writeBlob(sourcePath, destinationPath) {
-  if (existsSync24(destinationPath)) return;
+  if (existsSync25(destinationPath)) return;
   mkdirSync14(dirname15(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync6(join36(dirname15(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join36(temporaryDir, "blob");
+  const temporaryDir = mkdtempSync6(join38(dirname15(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join38(temporaryDir, "blob");
   try {
     copyFileSync7(sourcePath, temporaryPath);
     renameSync7(temporaryPath, destinationPath);
@@ -16900,8 +17156,8 @@ async function putBlobs(publisher, blobs) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join36(executionPlanDir, "plan.json");
-  if (!existsSync24(executionPlanPath)) {
+  const executionPlanPath = join38(executionPlanDir, "plan.json");
+  if (!existsSync25(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
   const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
@@ -16928,7 +17184,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  const encoder = readJsonFile(join36(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const encoder = readJsonFile(join38(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;
@@ -16970,18 +17226,18 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   };
 }
 function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync24(planV2Dir)) {
+  if (existsSync25(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publication = buildPlanV2Publication(executionPlanDir);
   mkdirSync14(dirname15(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync6(join36(dirname15(planV2Dir), ".plan-v2-build-"));
+  const tempDir = mkdtempSync6(join38(dirname15(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
     writeFileSync10(
-      join36(tempDir, "plan.json"),
+      join38(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
@@ -17022,7 +17278,7 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
   return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync6(join36(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync6(join38(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -17032,7 +17288,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(join36(stagingRoot, "compiled")).map(
+        listFiles(join38(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -17050,7 +17306,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync24(planV2Dir)) {
+  if (existsSync25(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
@@ -17062,7 +17318,7 @@ async function planV2(projectDir, config, planV2Dir) {
 function resultFromManifest(planV2Dir, manifest) {
   return {
     planDir: planV2Dir,
-    manifestPath: join36(planV2Dir, "plan.json"),
+    manifestPath: join38(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -17198,8 +17454,8 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join36(planV2Dir, "plan.json");
-  if (!existsSync24(manifestPath)) {
+  const manifestPath = join38(planV2Dir, "plan.json");
+  if (!existsSync25(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
   const value = readJsonFile(manifestPath, "v2 manifest");
@@ -17218,7 +17474,7 @@ function listPlanV2ArtifactsForTarget(manifest, target) {
 }
 function verifyBlob(planV2Dir, artifact) {
   const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync24(sourcePath)) {
+  if (!existsSync25(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
   const stats = statSync10(sourcePath);
@@ -17231,7 +17487,7 @@ function verifyBlob(planV2Dir, artifact) {
   return sourcePath;
 }
 function materializePlanV2Target(planV2Dir, target, destinationDir) {
-  if (existsSync24(destinationDir)) {
+  if (existsSync25(destinationDir)) {
     throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
   }
   const manifest = readPlanV2Manifest(planV2Dir);
@@ -17242,16 +17498,16 @@ function materializePlanV2Target(planV2Dir, target, destinationDir) {
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
   mkdirSync14(dirname15(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync6(join36(dirname15(destinationDir), ".plan-v2-materialize-"));
+  const tempDir = mkdtempSync6(join38(dirname15(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join36(tempDir, ...artifact.path.split("/"));
+      const destinationPath = join38(tempDir, ...artifact.path.split("/"));
       mkdirSync14(dirname15(destinationPath), { recursive: true });
       copyFileSync7(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
     writeFileSync10(
-      join36(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      join38(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({ manifest, target }),
       "utf-8"
     );
@@ -17270,12 +17526,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 ? join36(destinationDir, audioArtifact.path) : null : null
+    audioPath: target.role === "assembler" ? audioArtifact ? join38(destinationDir, audioArtifact.path) : null : null
   };
 }
 function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
-  const markerPath = join36(planDir, PLAN_V2_MATERIALIZATION_MARKER);
-  if (!existsSync24(markerPath)) return null;
+  const markerPath = join38(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  if (!existsSync25(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
     throw new PlanV2IntegrityError("malformed materialization marker");
@@ -17289,8 +17545,8 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   const manifest = parsePlanV2Manifest(marker.manifest);
   const required = listPlanV2ArtifactsForTarget(manifest, expectedTarget);
   for (const artifact of required) {
-    const path = join36(planDir, ...artifact.path.split("/"));
-    if (!existsSync24(path) || statSync10(path).size !== artifact.sizeBytes) {
+    const path = join38(planDir, ...artifact.path.split("/"));
+    if (!existsSync25(path) || statSync10(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -17305,22 +17561,22 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
 // src/services/distributed/planV2Execution.ts
 import { mkdtempSync as mkdtempSync9, rmSync as rmSync17 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join40 } from "node:path";
+import { join as join42 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   mkdirSync as mkdirSync16,
   mkdtempSync as mkdtempSync8,
   readFileSync as readFileSync13,
-  readdirSync as readdirSync9,
+  readdirSync as readdirSync10,
   renameSync as renameSync9,
   rmSync as rmSync15,
   statSync as statSync11,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname17, join as join38 } from "node:path";
+import { dirname as dirname17, join as join40 } from "node:path";
 import {
   appendRenderProvenanceArgs,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -17342,7 +17598,7 @@ import {
   rmSync as rmSync14
 } from "node:fs";
 import { open } from "node:fs/promises";
-import { dirname as dirname16, join as join37 } from "node:path";
+import { dirname as dirname16, join as join39 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -17664,13 +17920,13 @@ async function writeStitchedMp4(chunkPaths, outputPath) {
   const header = buildStitchedHeader(layouts);
   mkdirSync15(dirname16(outputPath), { recursive: true });
   const workDir = mkdtempSync7(`${outputPath}.stitch-`);
-  const out = createWriteStream(join37(workDir, "out.mp4"));
+  const out = createWriteStream(join39(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);
-    renameSync8(join37(workDir, "out.mp4"), outputPath);
+    renameSync8(join39(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
     rmSync14(workDir, { recursive: true, force: true });
@@ -17704,7 +17960,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync25(dirname17(outputPath))) {
+  if (!existsSync26(dirname17(outputPath))) {
     mkdirSync16(dirname17(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync8(`${outputPath}.assemble-work-`);
@@ -17727,8 +17983,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join38(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync25(audioPath) ? audioPath : null;
+    const finalPath = join40(workDir, `output.${format}`);
+    const audio = audioPath !== null && existsSync26(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameSync9(finalPath, outputPath);
     log.info("[assemble] stage timings", {
@@ -17746,7 +18002,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync25(outputPath) ? statSync11(outputPath).size : 0;
+  const fileSize = existsSync26(outputPath) ? statSync11(outputPath).size : 0;
   return {
     outputPath,
     durationMs: Date.now() - start,
@@ -17755,15 +18011,15 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join38(planDir, "plan.json");
-  const chunksJsonPath = join38(planDir, "meta", "chunks.json");
-  if (!existsSync25(planJsonPath)) {
+  const planJsonPath = join40(planDir, "plan.json");
+  const chunksJsonPath = join40(planDir, "meta", "chunks.json");
+  if (!existsSync26(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
   const plan2 = JSON.parse(readFileSync13(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync25(chunksJsonPath)) {
+  if (!existsSync26(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
   const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
@@ -17773,7 +18029,7 @@ function readAssemblePlan(planDir, chunkPaths) {
     );
   }
   for (const path of chunkPaths) {
-    if (!existsSync25(path)) {
+    if (!existsSync26(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -17783,7 +18039,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 = join38(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join40(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = [
     ...videoInputArgs(ctx, chunkPaths),
     "-c:v",
@@ -17821,7 +18077,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join38(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join40(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -17861,7 +18117,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join38(workDir, "concat-list.txt");
+  const listPath = join40(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync11(listPath, `${body}
 `, "utf-8");
@@ -17894,8 +18150,8 @@ function chunksAreStitchedMp4(planDir, cfr) {
   return true;
 }
 function chunksCarryAudio(planDir) {
-  const encoderJsonPath = join38(planDir, "meta", "encoder.json");
-  if (!existsSync25(encoderJsonPath)) return false;
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  if (!existsSync26(encoderJsonPath)) return false;
   return JSON.parse(readFileSync13(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
 }
 function readCfrEncoder(planDir, format) {
@@ -17904,8 +18160,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 = join38(planDir, "meta", "encoder.json");
-  if (!existsSync25(encoderJsonPath)) {
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  if (!existsSync26(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
   const encoderJson = JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
@@ -17917,7 +18173,7 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync25(outputPath)) rmSync15(outputPath, { recursive: true, force: true });
+  if (existsSync26(outputPath)) rmSync15(outputPath, { recursive: true, force: true });
   mkdirSync16(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -17926,13 +18182,13 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
         `[assemble] png-sequence chunk must be a directory: ${chunkDir} (got a file)`
       );
     }
-    const frames = readdirSync9(chunkDir).filter((name) => name.endsWith(".png")).sort();
+    const frames = readdirSync10(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 = join38(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join38(chunkDir, frame), dst);
+      const dst = join40(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join40(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -17941,14 +18197,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 && existsSync25(audioPath)) {
-    const sidecar = join38(outputPath, MIXED_AUDIO_FILENAME4);
+  if (audioPath !== null && existsSync26(audioPath)) {
+    const sidecar = join40(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
-  for (const name of readdirSync9(outputPath)) {
+  for (const name of readdirSync10(outputPath)) {
     try {
-      fileSize += statSync11(join38(outputPath, name)).size;
+      fileSize += statSync11(join40(outputPath, name)).size;
     } catch {
     }
   }
@@ -17962,22 +18218,19 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync14, readdirSync as readdirSync10, rmSync as rmSync16, writeFileSync as writeFileSync12 } from "node:fs";
-import { extname as extname6, join as join39 } from "node:path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync14, readdirSync as readdirSync11, rmSync as rmSync16, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join41 } 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 closeCaptureSession10,
-  createCaptureSession as createCaptureSession9,
-  createFrameLookupTable as createFrameLookupTable3,
-  createVideoFrameInjector as createVideoFrameInjector2,
+  closeCaptureSession as closeCaptureSession11,
+  createCaptureSession as createCaptureSession10,
+  createFrameLookupTable as createFrameLookupTable5,
   deriveBeginFrameProbeTimeTicks as deriveBeginFrameProbeTimeTicks2,
-  extractVideoFramesRange,
   getEncoderPreset as getEncoderPreset6,
-  initializeSession as initializeSession9,
+  initializeSession as initializeSession10,
   probeBeginFrameLiveness as probeBeginFrameLiveness2,
   readWebGlVendorInfoFromCanvas,
   resolveConfig as resolveConfig7
@@ -18081,20 +18334,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);
@@ -18106,10 +18346,10 @@ function validatePlanVideosForChunk(value) {
   }
 }
 var distributedCaptureSessionDependencies = {
-  createCaptureSession: createCaptureSession9,
+  createCaptureSession: createCaptureSession10,
   assertSwiftShader,
-  initializeSession: initializeSession9,
-  closeCaptureSession: closeCaptureSession10,
+  initializeSession: initializeSession10,
+  closeCaptureSession: closeCaptureSession11,
   readWebGlVendorInfo: readWebGlVendorInfoFromCanvas
 };
 async function createVerifiedDistributedCaptureSession(serverUrl, framesDir, captureOptions, cfg, dependencies = distributedCaptureSessionDependencies) {
@@ -18130,9 +18370,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";
 }
@@ -18160,130 +18397,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 = join39(planDir, "video-frames", v.videoId);
-    if (!existsSync26(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 = (extname6(v.framePattern) || ".jpg").toLowerCase();
-    const frames = readdirSync10(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, join39(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 = join39(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 = join39(input.planDir, ...range.sourcePath.split("/"));
-      if (!existsSync26(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(readFileSync14(outputPath));
-  const entries = readdirSync10(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
+  const entries = readdirSync11(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync14(join39(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync14(join41(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -18300,10 +18418,10 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join39(planDir, "plan.json");
-  const encoderJsonPath = join39(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join39(planDir, "meta", "chunks.json");
-  if (!existsSync26(planJsonPath)) {
+  const planJsonPath = join41(planDir, "plan.json");
+  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join41(planDir, "meta", "chunks.json");
+  if (!existsSync27(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
@@ -18317,7 +18435,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     chunkIndex
   });
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync26(required)) {
+    if (!existsSync27(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
@@ -18326,9 +18444,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   }
   const encoder = JSON.parse(readFileSync14(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync14(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join39(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join41(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync26(videosJsonPath)) {
+  if (existsSync27(videosJsonPath)) {
     try {
       planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync14(videosJsonPath, "utf-8")));
     } catch (err) {
@@ -18356,8 +18474,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       `[renderChunk] chunk ${chunkIndex} has non-positive frame count: ${framesInChunk}`
     );
   }
-  const compiledDir = join39(planDir, "compiled");
-  if (!existsSync26(compiledDir)) {
+  const compiledDir = join41(planDir, "compiled");
+  if (!existsSync27(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -18372,7 +18490,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)}.`
     );
   }
@@ -18414,10 +18532,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
     mkdirSync17(workDir, { recursive: true });
-    const framesDir = join39(workDir, "captured-frames");
+    const framesDir = join41(workDir, "captured-frames");
     mkdirSync17(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(
@@ -18428,7 +18546,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
@@ -18437,9 +18558,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,
@@ -18449,28 +18567,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(
-        readFileSync14(join39(compiledDir, "index.html"), "utf-8")
-      )
-    };
+    const captureOptions = buildChunkCaptureOptions({
+      dimensions: plan2.dimensions,
+      encoder,
+      videoCount: planVideos?.videos.length ?? 0,
+      html: readFileSync14(join41(compiledDir, "index.html"), "utf-8")
+    });
     const chunkWorkerCount = calculateOptimalWorkers2(framesInChunk, void 0, cfg);
     let session = null;
     let outputKind;
@@ -18501,7 +18603,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
             { chunkIndex }
           );
           if (chunkWorkerCount > 1) {
-            await closeCaptureSession10(session);
+            await closeCaptureSession11(session);
             session = null;
           }
         } else if (beginFrameStalled) {
@@ -18510,7 +18612,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
             "[renderChunk] BeginFrame liveness probe failed; using screenshot capture for the entire chunk",
             { chunkIndex }
           );
-          await closeCaptureSession10(session).catch(() => {
+          await closeCaptureSession11(session).catch(() => {
           });
           session = null;
           if (chunkWorkerCount === 1) {
@@ -18529,7 +18631,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
             sessionBootMs += Date.now() - screenshotBootStarted;
           }
         } else if (chunkWorkerCount > 1) {
-          await closeCaptureSession10(session);
+          await closeCaptureSession11(session);
           session = null;
         }
       }
@@ -18631,10 +18733,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 (!existsSync26(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
+        if (!existsSync27(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join39(outputChunkPath, "..");
-        if (!existsSync26(outDir)) mkdirSync17(outDir, { recursive: true });
+        const outDir = join41(outputChunkPath, "..");
+        if (!existsSync27(outDir)) mkdirSync17(outDir, { recursive: true });
       }
       const encodeStarted = Date.now();
       await runEncodeStage({
@@ -18692,7 +18794,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     } finally {
       if (session) {
         try {
-          await closeCaptureSession10(session);
+          await closeCaptureSession11(session);
         } catch (err) {
           log.warn("[renderChunk] error closing capture session in finally", {
             error: err instanceof Error ? err.message : String(err)
@@ -18757,8 +18859,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
-  const workRoot = mkdtempSync9(join40(tmpdir5(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join40(workRoot, "plan");
+  const workRoot = mkdtempSync9(join42(tmpdir5(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join42(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath);
@@ -18767,8 +18869,8 @@ async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync9(join40(tmpdir5(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join40(workRoot, "plan");
+  const workRoot = mkdtempSync9(join42(tmpdir5(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join42(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -18816,9 +18918,9 @@ export {
   assembleV2,
   captureFrame2 as captureFrame,
   captureFrameToBuffer4 as captureFrameToBuffer,
-  closeCaptureSession9 as closeCaptureSession,
+  closeCaptureSession10 as closeCaptureSession,
   collectRenderMedia,
-  createCaptureSession8 as createCaptureSession,
+  createCaptureSession9 as createCaptureSession,
   createConsoleLogger,
   createFileServer,
   createOwnedRenderDir,
@@ -18836,7 +18938,7 @@ export {
   getCompositionDuration2 as getCompositionDuration,
   getDistributedRenderCapabilities,
   getPlanV2ExecutionPlanHash,
-  initializeSession8 as initializeSession,
+  initializeSession9 as initializeSession,
   injectDeterministicFontFaces2 as injectDeterministicFontFaces,
   isTransientBrowserError3 as isTransientBrowserError,
   listAbandonedRenderDirs,