hyperframes 0.8.175 → 0.8.176

package/dist/{chunk-KZQGUXG5.js → chunk-LEILKM2N.js}

@@ -22,7 +22,7 @@ import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-UWUKJDTA.js";
+} from "./chunk-PL4WM5XE.js";
 import {
   BROWSER_GPU_NOT_SOFTWARE,
   CaptureFailure,
@@ -151,7 +151,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-RERXOG54.js";
+} from "./chunk-YWSXFFO3.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -13151,477 +13151,113 @@ async function executeRenderPipeline(input) {
 import {
   copyFileSync as copyFileSync4,
   cpSync as cpSync2,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   linkSync,
   mkdirSync as mkdirSync10,
   renameSync as renameSync4,
   rmSync as rmSync9,
   writeFileSync as writeFileSync7
 } from "fs";
-import { extname as extname5, isAbsolute as isAbsolute2, join as join29, relative as relative5, sep as sep2 } from "path";
+import { extname as extname6, isAbsolute as isAbsolute2, join as join31, relative as relative5, sep as sep2 } from "path";
 
-// ../producer/src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync8, readdirSync as readdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join26, relative as relative3, resolve as resolve7 } from "path";
+// ../producer/src/services/distributed/planFrameCost.ts
+import { join as join28 } from "path";
 
-// ../producer/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;
+// ../producer/src/services/distributed/chunkFrames.ts
+import { existsSync as existsSync17, readdirSync as readdirSync6 } from "fs";
+import { extname as extname4, join as join27 } from "path";
+
+// ../producer/src/services/distributed/shared.ts
+import { execFile as execFileCallback } from "child_process";
+import { dirname as dirname10, join as join26 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync8 } from "fs";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import { promisify as promisify2 } from "util";
+var PLAN_VIDEOS_META_RELATIVE_PATH = "meta/videos.json";
+var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME;
+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 = join26(planDir, name);
+    if (existsSync16(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;
-  }
-  const descriptor = planJson.protocol;
-  if (!isRecord(descriptor)) {
-    throw new PlanProtocolUnsupportedError("plan.json protocol descriptor must be an object");
-  }
-  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");
+function readRecord(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    metadataError(field, "must be an object");
   }
-  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 readNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    metadataError(field, "must be a non-empty string");
   }
-  return PLAN_PROTOCOL_V1;
+  return value;
 }
-
-// ../producer/src/services/render/stages/planHash.ts
-import { createHash as createHash5 } from "crypto";
-import { closeSync as closeSync5, createReadStream as createReadStream3, openSync as openSync4, readSync as readSync3 } from "fs";
-var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
-var FIELD_DELIMITER = Buffer.from([0]);
-function computePlanHash(input) {
-  const hash = createHash5("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 readString(value, field) {
+  if (typeof value !== "string") {
+    metadataError(field, "must be a string");
   }
-  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);
-  }
-  if (typeof value === "string") return JSON.stringify(value);
-  if (Array.isArray(value)) {
-    return `[${value.map(canonicalJsonStringify).join(",")}]`;
-  }
-  if (typeof value === "object") {
-    const obj = value;
-    const keys = Object.keys(obj).sort();
-    const parts = keys.map((k) => `${JSON.stringify(k)}:${canonicalJsonStringify(obj[k])}`);
-    return `{${parts.join(",")}}`;
+function readFiniteNumber(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    metadataError(field, "must be a finite number");
   }
-  throw new TypeError(`canonicalJsonStringify: unsupported value type ${typeof value}`);
-}
-function sha256Hex(bytes) {
-  const h = createHash5("sha256");
-  h.update(bytes);
-  return h.digest("hex");
+  return value;
 }
-function sha256File(path) {
-  const hash = createHash5("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 readBoolean(value, field) {
+  if (typeof value !== "boolean") {
+    metadataError(field, "must be boolean");
   }
-  return hash.digest("hex");
+  return value;
 }
-async function sha256FileAsync(path) {
-  const hash = createHash5("sha256");
-  for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
-    hash.update(chunk);
+function readPositiveInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    metadataError(field, "must be a positive integer");
   }
-  return hash.digest("hex");
+  return value;
 }
-
-// ../producer/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 readNonNegativeInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    metadataError(field, "must be a non-negative integer");
   }
-  return sha256;
+  return value;
 }
-async function prehashPlanFiles(dir, digests) {
-  if (!existsSync16(dir)) return;
-  for (const { absolutePath } of listPlanFiles(dir)) {
-    if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
+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 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;
+  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"');
   }
-  return value;
-}
-function listPlanFiles(planDir) {
-  const results = [];
-  const rootResolved = resolve7(planDir);
-  function walk(dir) {
-    const entries = readdirSync6(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join26(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full);
-      } else if (entry.isFile()) {
-        results.push({
-          planRelativePath: relative3(rootResolved, full).split(/[\\/]+/).join("/"),
-          absolutePath: full
-        });
-      }
-    }
-  }
-  walk(rootResolved);
-  results.sort((a, b) => a.planRelativePath < b.planRelativePath ? -1 : 1);
-  return results;
-}
-function collectPlanAssetShas(planDir, digests) {
-  const files = listPlanFiles(planDir);
-  let compositionHtml = null;
-  const assets = [];
-  for (const file of files) {
-    if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
-      compositionHtml = readFileSync8(file.absolutePath);
-      continue;
-    }
-    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 };
-}
-function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join26(planDir, "plan.json");
-  const encoderJsonPath = join26(planDir, "meta", "encoder.json");
-  if (!existsSync16(planJsonPath)) {
-    throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
-  }
-  if (!existsSync16(encoderJsonPath)) {
-    throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
-  }
-  const planJson = JSON.parse(readFileSync8(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync8(encoderJsonPath, "utf-8");
-  const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
-  return computePlanHash({
-    compositionHtml,
-    assets,
-    fontSnapshotSha: planJson.fontSnapshotSha,
-    encoderConfigCanonicalJson,
-    producerVersion: planJson.producerVersion,
-    ffmpegVersion: planJson.ffmpegVersion,
-    dimensions: planJson.dimensions
-  });
-}
-async function freezePlan(input) {
-  const {
-    planDir,
-    composition,
-    encoder,
-    chunks,
-    dimensions,
-    producerVersion,
-    fontSnapshotSha,
-    durationSeconds,
-    totalFrames,
-    hasAudio,
-    digests
-  } = input;
-  if (!existsSync16(planDir)) {
-    throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
-  }
-  const metaDir = join26(planDir, "meta");
-  if (!existsSync16(metaDir)) mkdirSync9(metaDir, { recursive: true });
-  writeFileSync6(
-    join26(metaDir, "composition.json"),
-    `${JSON.stringify(composition, null, 2)}
-`,
-    "utf-8"
-  );
-  const encoderForCanonical = stripUndefined(encoder);
-  const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync6(join26(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync6(join26(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
-  };
-  const planJsonPath = join26(planDir, "plan.json");
-  writeFileSync6(planJsonPath, `${JSON.stringify(planJson, null, 2)}
-`, "utf-8");
-  return { planJsonPath, planHash };
-}
-
-// ../producer/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;
-      }
-    }
-  };
-}
-
-// ../producer/src/services/distributed/shared.ts
-import { execFile as execFileCallback } from "child_process";
-import { dirname as dirname10, join as join27 } from "path";
-import { existsSync as existsSync17, readFileSync as readFileSync9 } from "fs";
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { promisify as promisify2 } from "util";
-var PLAN_VIDEOS_META_RELATIVE_PATH = "meta/videos.json";
-var PLAN_AUDIO_RELATIVE_PATH = MIXED_AUDIO_FILENAME;
-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 = 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 = INVALID_VIDEO_METADATA;
-  constructor(message) {
-    super(message);
-    this.name = "PlanVideosMetadataError";
-  }
-};
-function metadataError(field, expectation) {
-  throw new PlanVideosMetadataError(`${field} ${expectation}`);
-}
-function readRecord(value, field) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    metadataError(field, "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");
-  }
-  return value;
-}
-function readString(value, field) {
-  if (typeof value !== "string") {
-    metadataError(field, "must be a string");
-  }
-  return value;
-}
-function readFiniteNumber(value, field) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    metadataError(field, "must be a finite number");
-  }
-  return value;
-}
-function readBoolean(value, field) {
-  if (typeof value !== "boolean") {
-    metadataError(field, "must be boolean");
-  }
-  return value;
-}
-function readPositiveInteger(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    metadataError(field, "must be a positive integer");
-  }
-  return value;
-}
-function readNonNegativeInteger(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-    metadataError(field, "must be a non-negative integer");
-  }
-  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");
-  }
-  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"');
-  }
-  return {
-    sourcePath,
-    startTime: readFiniteNumber(range.startTime, `${field}.startTime`),
-    durationSeconds,
-    format: range.format
-  };
+  return {
+    sourcePath,
+    startTime: readFiniteNumber(range.startTime, `${field}.startTime`),
+    durationSeconds,
+    format: range.format
+  };
 }
 function readRateSpec(value, field) {
   if (value === void 0) return void 0;
@@ -13792,37 +13428,612 @@ function buildSyntheticRenderJob(input) {
     producerConfig: input.producerConfig,
     variables: input.variables
   };
-  return createRenderJob(renderConfig);
+  return createRenderJob(renderConfig);
+}
+var cachedProducerVersion = null;
+function readProducerVersion() {
+  if (cachedProducerVersion !== null) return cachedProducerVersion;
+  const startDir = dirname10(fileURLToPath5(import.meta.url));
+  let current = startDir;
+  for (let i = 0; i < 10; i++) {
+    const candidate = join26(current, "package.json");
+    if (existsSync16(candidate)) {
+      try {
+        const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
+        if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
+          cachedProducerVersion = pkg.version;
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname10(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  cachedProducerVersion = "0.0.0-unknown";
+  return cachedProducerVersion;
+}
+
+// ../producer/src/services/distributed/chunkFrames.ts
+var FFMPEG_VERSION_MISMATCH = "FFMPEG_VERSION_MISMATCH";
+var PLAN_HASH_MISMATCH = "PLAN_HASH_MISMATCH";
+var MISSING_PLAN_ARTIFACT = "MISSING_PLAN_ARTIFACT";
+var CHUNK_INDEX_OUT_OF_RANGE = "CHUNK_INDEX_OUT_OF_RANGE";
+var MISSING_RUNTIME_ENV_SNAPSHOT = "MISSING_RUNTIME_ENV_SNAPSHOT";
+var RenderChunkValidationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RenderChunkValidationError";
+    this.code = code;
+  }
+};
+function createChunkVideoFrameInjectorFactory(frameLookup) {
+  return () => createVideoFrameInjector(frameLookup);
+}
+function frameNumberFromFileName(name) {
+  const match = /(\d+)(?=\.[^.]+$)/.exec(name);
+  if (!match) return null;
+  const frameNumber = Number(match[1]);
+  return Number.isSafeInteger(frameNumber) ? frameNumber : null;
+}
+function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
+  const result = [];
+  for (const v of videos) {
+    const outputDir = join27(planDir, "video-frames", v.videoId);
+    if (!existsSync17(outputDir)) {
+      throw new Error(
+        `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
+      );
+    }
+    const ext = (extname4(v.framePattern) || ".jpg").toLowerCase();
+    const frames = 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, join27(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 {
+    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: compositionRequiresWebGpu(input.html)
+  };
+}
+async function extractDeferredVideoFramesForChunk(input) {
+  const deferred = input.planVideos.extracted.filter((video) => video.deferredRange);
+  if (deferred.length === 0) return [];
+  const table = createFrameLookupTable(
+    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 = join27(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 = join27(input.planDir, ...range.sourcePath.split("/"));
+      if (!existsSync17(sourcePath)) {
+        throw new RenderChunkValidationError(
+          MISSING_PLAN_ARTIFACT,
+          `[renderChunk] planDir is missing the source for video ${JSON.stringify(video.videoId)}: ${range.sourcePath}`
+        );
+      }
+      const extracted = await extractVideoFramesRange(
+        sourcePath,
+        video.videoId,
+        range.startTime,
+        range.durationSeconds,
+        {
+          fps: input.fps,
+          outputDir: input.outputRoot,
+          format: range.format,
+          frameRanges: contiguousRuns(indexes)
+        },
+        void 0,
+        input.cfg
+      );
+      const missing = indexes.find((index) => !extracted.framePaths.has(index));
+      if (missing !== void 0) {
+        throw new RenderChunkValidationError(
+          INVALID_VIDEO_METADATA,
+          `[renderChunk] video ${JSON.stringify(video.videoId)} has no frame ${missing}; the plan expected ${video.totalFrames} frames from ${range.sourcePath}.`
+        );
+      }
+      return { ...video, outputDir, framePaths: extracted.framePaths, ownedByLookup: false };
+    })
+  );
+}
+
+// ../producer/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: join28(workDir, "frame-cost-video-frames"),
+      cfg: input.cfg
+    })
+  ];
+  const lookup = extracted.length > 0 ? createFrameLookupTable(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
+  const compiledDir = join28(planDir, "compiled");
+  const fileServer = await createFileServer({
+    projectDir: compiledDir,
+    compiledDir,
+    port: 0,
+    preHeadScripts: [buildVirtualTimeShim({ seedRandomFromFrame: true })],
+    fps: fpsRatio
+  });
+  let session = null;
+  try {
+    session = await createCaptureSession(
+      fileServer.url,
+      join28(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 initializeSession(session);
+    const { estimate } = await measureCaptureCostFromSession(session, input.totalFrames, fps, log);
+    return (estimate.p95Ms ?? 0) / 1e3;
+  } finally {
+    if (session) await closeCaptureSession(session).catch(() => {
+    });
+    closeFileServerSafely(fileServer, "plan frame cost", log);
+  }
+}
+
+// ../producer/src/services/render/stages/freezePlan.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync9, readdirSync as readdirSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join29, relative as relative3, resolve as resolve7 } from "path";
+
+// ../producer/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 = PLAN_PROTOCOL_UNSUPPORTED;
+  constructor(reason) {
+    super(`[planProtocol] ${reason} (${PLAN_PROTOCOL_UNSUPPORTED})`);
+    this.name = "PlanProtocolUnsupportedError";
+  }
+};
+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 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;
+  }
+  const descriptor = planJson.protocol;
+  if (!isRecord(descriptor)) {
+    throw new PlanProtocolUnsupportedError("plan.json protocol descriptor must be an object");
+  }
+  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 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 PLAN_PROTOCOL_V1;
+}
+
+// ../producer/src/services/render/stages/planHash.ts
+import { createHash as createHash5 } from "crypto";
+import { closeSync as closeSync5, createReadStream as createReadStream3, openSync as openSync4, readSync as readSync3 } from "fs";
+var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
+var FIELD_DELIMITER = Buffer.from([0]);
+function computePlanHash(input) {
+  const hash = createHash5("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);
+  }
+  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 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);
+  }
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJsonStringify).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = keys.map((k) => `${JSON.stringify(k)}:${canonicalJsonStringify(obj[k])}`);
+    return `{${parts.join(",")}}`;
+  }
+  throw new TypeError(`canonicalJsonStringify: unsupported value type ${typeof value}`);
+}
+function sha256Hex(bytes) {
+  const h = createHash5("sha256");
+  h.update(bytes);
+  return h.digest("hex");
+}
+function sha256File(path) {
+  const hash = createHash5("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 hash.digest("hex");
+}
+async function sha256FileAsync(path) {
+  const hash = createHash5("sha256");
+  for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+
+// ../producer/src/services/render/stages/freezePlan.ts
+var COMPILED_INDEX_RELATIVE_PATH = "compiled/index.html";
+var HASH_EXCLUDED_PLAN_FILES = /* @__PURE__ */ new Set([
+  "plan.json",
+  "meta/encoder.json",
+  COMPILED_INDEX_RELATIVE_PATH
+]);
+function planFileSha256(absolutePath, digests) {
+  let sha256 = digests?.get(absolutePath);
+  if (sha256 === void 0) {
+    sha256 = sha256File(absolutePath);
+    digests?.set(absolutePath, sha256);
+  }
+  return sha256;
+}
+async function prehashPlanFiles(dir, digests) {
+  if (!existsSync18(dir)) return;
+  for (const { absolutePath } of listPlanFiles(dir)) {
+    if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
+  }
+}
+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;
+  }
+  return value;
+}
+function listPlanFiles(planDir) {
+  const results = [];
+  const rootResolved = resolve7(planDir);
+  function walk(dir) {
+    const entries = readdirSync7(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join29(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        results.push({
+          planRelativePath: relative3(rootResolved, full).split(/[\\/]+/).join("/"),
+          absolutePath: full
+        });
+      }
+    }
+  }
+  walk(rootResolved);
+  results.sort((a, b) => a.planRelativePath < b.planRelativePath ? -1 : 1);
+  return results;
+}
+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;
+    }
+    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 };
+}
+function recomputePlanHashFromPlanDir(planDir, digests) {
+  const planJsonPath = join29(planDir, "plan.json");
+  const encoderJsonPath = join29(planDir, "meta", "encoder.json");
+  if (!existsSync18(planJsonPath)) {
+    throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
+  }
+  if (!existsSync18(encoderJsonPath)) {
+    throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
+  }
+  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
+  });
+}
+async function freezePlan(input) {
+  const {
+    planDir,
+    composition,
+    encoder,
+    chunks,
+    dimensions,
+    producerVersion,
+    fontSnapshotSha,
+    durationSeconds,
+    totalFrames,
+    hasAudio,
+    digests
+  } = input;
+  if (!existsSync18(planDir)) {
+    throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
+  }
+  const metaDir = join29(planDir, "meta");
+  if (!existsSync18(metaDir)) mkdirSync9(metaDir, { recursive: true });
+  writeFileSync6(
+    join29(metaDir, "composition.json"),
+    `${JSON.stringify(composition, null, 2)}
+`,
+    "utf-8"
+  );
+  const encoderForCanonical = stripUndefined(encoder);
+  const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
+  writeFileSync6(join29(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync6(join29(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
+  };
+  const planJsonPath = join29(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 = dirname10(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 {
+
+// ../producer/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 = dirname10(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  cachedProducerVersion = "0.0.0-unknown";
-  return cachedProducerVersion;
+  };
 }
 
 // ../producer/src/services/distributed/planSize.ts
 import { createHash as createHash6 } from "crypto";
-import { lstatSync as lstatSync2, readdirSync as readdirSync7 } from "fs";
-import { extname as extname4, join as join28, relative as relative4 } from "path";
+import { lstatSync as lstatSync2, readdirSync as readdirSync8 } from "fs";
+import { extname as extname5, join as join30, relative as relative4 } from "path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -13882,7 +14093,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;
@@ -13929,12 +14140,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 = join28(dir, entry.name);
+    const full = join30(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -13995,8 +14206,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_ATTR}=`, "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 {
@@ -14009,18 +14229,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;
@@ -14031,7 +14248,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
     );
   }
@@ -14138,13 +14355,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join29("meta", "composition.json"),
-  join29("meta", "encoder.json"),
-  join29("meta", "chunks.json")
+  join31("meta", "composition.json"),
+  join31("meta", "encoder.json"),
+  join31("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync9(join29(planDir, relativePath), { force: true });
+    rmSync9(join31(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -14275,19 +14492,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join29(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join31(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 && existsSync18(join29(input.planDir, "compiled", rel))) {
+      if (rel !== null && existsSync19(join31(input.planDir, "compiled", rel))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
     }
     if (result === null) {
-      result = `video-sources/${shipped.size}${extname5(current)}`;
-      const destination = join29(input.planDir, ...result.split("/"));
-      mkdirSync10(join29(input.planDir, "video-sources"), { recursive: true });
+      result = `video-sources/${shipped.size}${extname6(current)}`;
+      const destination = join31(input.planDir, ...result.split("/"));
+      mkdirSync10(join31(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -14305,7 +14522,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync18(planDir)) mkdirSync10(planDir, { recursive: true });
+  if (!existsSync19(planDir)) mkdirSync10(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -14334,14 +14551,14 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join29(projectDir, entryFile);
-  if (!existsSync18(htmlPath)) {
+  const htmlPath = join31(projectDir, entryFile);
+  if (!existsSync19(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join29(planDir, ".plan-work");
+  const workDir = join31(planDir, ".plan-work");
   rmSync9(workDir, { recursive: true, force: true });
   mkdirSync10(workDir, { recursive: true });
-  const compiledDir = join29(workDir, "compiled");
+  const compiledDir = join31(workDir, "compiled");
   mkdirSync10(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
@@ -14355,7 +14572,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join29(planDir, "compiled");
+  const finalCompiledDir = join31(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   stageStarted = Date.now();
   const compileResult = await runCompileStage({
@@ -14418,7 +14635,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-4COYCAFY.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-JGPFLYBL.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -14426,19 +14643,9 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       });
     }
   }
-  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",
@@ -14463,17 +14670,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (extractResult.extractionResult) {
     assertVideoExtractionSucceeded(extractResult.extractionResult);
   }
-  const stagedVideoFrames = join29(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join29(planDir, "video-frames");
-  if (existsSync18(videoFramesDst)) rmSync9(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join29(planDir, "video-sources");
+  const stagedVideoFrames = join31(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join31(planDir, "video-frames");
+  if (existsSync19(videoFramesDst)) rmSync9(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join31(planDir, "video-sources");
   rmSync9(videoSourcesDir, { recursive: true, force: true });
-  if (existsSync18(stagedVideoFrames)) {
+  if (existsSync19(stagedVideoFrames)) {
     renameSync4(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync10(videoFramesDst, { recursive: true });
   }
-  if (existsSync18(finalCompiledDir)) rmSync9(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync19(finalCompiledDir)) rmSync9(finalCompiledDir, { recursive: true, force: true });
   renameSync4(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -14499,9 +14706,9 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       ...ext.deferredRange ? { deferredRange: { ...ext.deferredRange, sourcePath: shipVideoSource(ext.srcPath) } } : {}
     }))
   });
-  mkdirSync10(join29(planDir, "meta"), { recursive: true });
+  mkdirSync10(join31(planDir, "meta"), { recursive: true });
   writeFileSync7(
-    join29(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+    join31(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -14509,7 +14716,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,
@@ -14532,19 +14739,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 = join29(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult.hasAudio && existsSync18(audioResult.audioOutputPath)) {
+  const planAudioPath = join31(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  if (audioResult.hasAudio && existsSync19(audioResult.audioOutputPath)) {
     renameSync4(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio2 && existsSync18(planAudioPath)) {
+  if (chunksCarryAudio2 && existsSync19(planAudioPath)) {
     stageStarted = Date.now();
     const peak = await constrainAacTruePeak({
       audioPath: planAudioPath,
@@ -15129,7 +15370,7 @@ function renderRequestFromDistributedConfig(input) {
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync11,
   statSync as statSync7,
   mkdtempSync as mkdtempSync4,
@@ -15137,7 +15378,7 @@ import {
   rmSync as rmSync10,
   createReadStream as createReadStream4
 } from "fs";
-import { resolve as resolve9, dirname as dirname12, join as join32 } from "path";
+import { resolve as resolve9, dirname as dirname12, join as join34 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { parseArgs } from "util";
 import crypto from "crypto";
@@ -15147,7 +15388,7 @@ import { serve as serve2 } from "@hono/node-server";
 
 // ../producer/src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   readFileSync as readFileSync10,
   statSync as statSync6,
   openSync as openSync5,
@@ -15155,7 +15396,7 @@ import {
   closeSync as closeSync6,
   constants as constants3
 } from "fs";
-import { resolve as resolve8, join as join30, relative as relative6, isAbsolute as isAbsolute3, sep as sep3 } from "path";
+import { resolve as resolve8, join as join32, relative as relative6, isAbsolute as isAbsolute3, sep as sep3 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -15200,7 +15441,7 @@ function readEntryHtml(filePath) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve8(projectDir);
-  if (!existsSync19(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
+  if (!existsSync20(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -15222,7 +15463,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join30(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join32(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -15268,8 +15509,8 @@ async function runHyperframeLint(prepared) {
 // ../producer/src/services/healthWorker.ts
 import { Worker as Worker2 } from "worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname11, join as join31 } from "path";
-import { existsSync as existsSync20 } from "fs";
+import { dirname as dirname11, join as join33 } from "path";
+import { existsSync as existsSync21 } from "fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -15344,9 +15585,9 @@ function defaultLogger2() {
 }
 function resolveWorkerEntry2() {
   const here = dirname11(fileURLToPath6(import.meta.url));
-  const candidates = [join31(here, "healthWorkerThread.js"), join31(here, "healthWorkerThread.ts")];
+  const candidates = [join33(here, "healthWorkerThread.js"), join33(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync20(candidate)) return candidate;
+    if (existsSync21(candidate)) return candidate;
   }
   return void 0;
 }
@@ -15485,7 +15726,7 @@ function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
   const outputDir = dirname12(absoluteOutputPath);
-  if (!existsSync21(outputDir)) mkdirSync11(outputDir, { recursive: true });
+  if (!existsSync22(outputDir)) mkdirSync11(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -15525,11 +15766,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve9(candidate);
-  if (!existsSync21(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
+  if (!existsSync22(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync21(resolve9(absProjectDir, entry))) {
+  if (!existsSync22(resolve9(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -15554,8 +15795,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync4(join32(tempRoot, "producer-project-"));
-  writeFileSync8(join32(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync4(join34(tempRoot, "producer-project-"));
+  writeFileSync8(join34(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -15621,7 +15862,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync21(path) ? statSync7(path).size : 0;
+  return existsSync22(path) ? statSync7(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -15917,7 +16158,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync21(artifact.path)) {
+    if (!existsSync22(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
@@ -15964,7 +16205,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-4COYCAFY.js");
+    const { drainBrowserPool } = await import("./src-JGPFLYBL.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -16002,24 +16243,24 @@ if (isPublicServerEntry) {
 // ../producer/src/services/distributed/planV2.ts
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync11,
-  readdirSync as readdirSync8,
+  readdirSync as readdirSync9,
   renameSync as renameSync6,
   rmSync as rmSync12,
   statSync as statSync9,
   writeFileSync as writeFileSync10
 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname14, isAbsolute as isAbsolute4, join as join35, relative as relative7, resolve as resolve10, sep as sep4 } from "path";
+import { dirname as dirname14, isAbsolute as isAbsolute4, join as join37, relative as relative7, resolve as resolve10, sep as sep4 } from "path";
 
 // ../producer/src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync5,
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   linkSync as linkSync2,
   mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync5,
@@ -16028,7 +16269,7 @@ import {
   statSync as statSync8,
   writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname13, join as join34 } from "path";
+import { dirname as dirname13, join as join36 } from "path";
 
 // ../producer/src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -16043,7 +16284,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // ../producer/src/services/distributed/planV2Layout.ts
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -16053,7 +16294,7 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join33(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join35(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // ../producer/src/services/distributed/planV2Publisher.ts
@@ -16088,13 +16329,13 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync22(destinationDir)) {
+    if (existsSync23(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
     mkdirSync12(dirname13(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync5(join34(dirname13(destinationDir), ".plan-v2-publish-"));
+    this.temporaryDir = mkdtempSync5(join36(dirname13(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -16105,10 +16346,10 @@ var LocalPlanV2ArtifactPublisher = class {
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync22(destinationPath)) return;
+    if (existsSync23(destinationPath)) return;
     mkdirSync12(dirname13(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync5(join34(dirname13(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join34(stagingDir, "blob");
+    const stagingDir = mkdtempSync5(join36(dirname13(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join36(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -16123,13 +16364,13 @@ var LocalPlanV2ArtifactPublisher = class {
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync22(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync23(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
       }
     }
-    writeFileSync9(join34(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync9(join36(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameSync5(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
@@ -16173,8 +16414,8 @@ function listFiles(root) {
   const files = [];
   const rootResolved = resolve10(root);
   function walk(dir) {
-    for (const entry of readdirSync8(dir, { withFileTypes: true })) {
-      const absolutePath = join35(dir, entry.name);
+    for (const entry of readdirSync9(dir, { withFileTypes: true })) {
+      const absolutePath = join37(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -16201,13 +16442,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join35(executionPlanDir, "video-frames");
-  if (!existsSync23(videoRoot)) return;
-  for (const videoEntry of readdirSync8(videoRoot, { withFileTypes: true })) {
+  const videoRoot = join37(executionPlanDir, "video-frames");
+  if (!existsSync24(videoRoot)) return;
+  for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join35(videoRoot, videoEntry.name);
-    if (readdirSync8(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join35(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+    const videoDir = join37(videoRoot, videoEntry.name);
+    if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
+      const sentinelPath = join37(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -16248,15 +16489,15 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join35(outputDir, String(index)));
+        framePaths2.set(index, join37(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(join35(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join37(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -16275,7 +16516,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join35(outputDir, frameName));
+      framePaths.set(frameIndex, join37(outputDir, frameName));
     }
     return {
       ...video,
@@ -16296,8 +16537,8 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join35(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync23(videosPath)) return;
+  const videosPath = join37(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync24(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
     mkdirSync13(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
@@ -16325,13 +16566,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join35(executionPlanDir, "video-frames");
-  const hasExtractedFrames = existsSync23(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join35(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync23(videosPath)) {
+  const videoRoot = join37(executionPlanDir, "video-frames");
+  const hasExtractedFrames = existsSync24(videoRoot) && listFiles(videoRoot).length > 0;
+  const videosPath = join37(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync24(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join35(executionPlanDir, "meta", "chunks.json");
+  const chunksPath = join37(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -16385,10 +16626,10 @@ function computeManifestHash(manifest) {
   return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
 function writeBlob(sourcePath, destinationPath) {
-  if (existsSync23(destinationPath)) return;
+  if (existsSync24(destinationPath)) return;
   mkdirSync13(dirname14(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync6(join35(dirname14(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join35(temporaryDir, "blob");
+  const temporaryDir = mkdtempSync6(join37(dirname14(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join37(temporaryDir, "blob");
   try {
     copyFileSync6(sourcePath, temporaryPath);
     renameSync6(temporaryPath, destinationPath);
@@ -16421,8 +16662,8 @@ async function putBlobs(publisher, blobs) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join35(executionPlanDir, "plan.json");
-  if (!existsSync23(executionPlanPath)) {
+  const executionPlanPath = join37(executionPlanDir, "plan.json");
+  if (!existsSync24(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
   const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
@@ -16449,7 +16690,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  const encoder = readJsonFile(join35(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const encoder = readJsonFile(join37(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;
@@ -16491,18 +16732,18 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   };
 }
 function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync23(planV2Dir)) {
+  if (existsSync24(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publication = buildPlanV2Publication(executionPlanDir);
   mkdirSync13(dirname14(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync6(join35(dirname14(planV2Dir), ".plan-v2-build-"));
+  const tempDir = mkdtempSync6(join37(dirname14(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
     writeFileSync10(
-      join35(tempDir, "plan.json"),
+      join37(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
@@ -16543,7 +16784,7 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
   return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync6(join35(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync6(join37(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -16553,7 +16794,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(join35(stagingRoot, "compiled")).map(
+        listFiles(join37(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -16571,7 +16812,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync23(planV2Dir)) {
+  if (existsSync24(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
@@ -16583,7 +16824,7 @@ async function planV2(projectDir, config, planV2Dir) {
 function resultFromManifest(planV2Dir, manifest) {
   return {
     planDir: planV2Dir,
-    manifestPath: join35(planV2Dir, "plan.json"),
+    manifestPath: join37(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -16719,8 +16960,8 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join35(planV2Dir, "plan.json");
-  if (!existsSync23(manifestPath)) {
+  const manifestPath = join37(planV2Dir, "plan.json");
+  if (!existsSync24(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
   const value = readJsonFile(manifestPath, "v2 manifest");
@@ -16739,7 +16980,7 @@ function listPlanV2ArtifactsForTarget(manifest, target) {
 }
 function verifyBlob(planV2Dir, artifact) {
   const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync23(sourcePath)) {
+  if (!existsSync24(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
   const stats = statSync9(sourcePath);
@@ -16752,7 +16993,7 @@ function verifyBlob(planV2Dir, artifact) {
   return sourcePath;
 }
 function materializePlanV2Target(planV2Dir, target, destinationDir) {
-  if (existsSync23(destinationDir)) {
+  if (existsSync24(destinationDir)) {
     throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
   }
   const manifest = readPlanV2Manifest(planV2Dir);
@@ -16763,16 +17004,16 @@ function materializePlanV2Target(planV2Dir, target, destinationDir) {
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
   mkdirSync13(dirname14(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync6(join35(dirname14(destinationDir), ".plan-v2-materialize-"));
+  const tempDir = mkdtempSync6(join37(dirname14(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join35(tempDir, ...artifact.path.split("/"));
+      const destinationPath = join37(tempDir, ...artifact.path.split("/"));
       mkdirSync13(dirname14(destinationPath), { recursive: true });
       copyFileSync6(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
     writeFileSync10(
-      join35(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      join37(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({ manifest, target }),
       "utf-8"
     );
@@ -16791,12 +17032,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 ? join35(destinationDir, audioArtifact.path) : null : null
+    audioPath: target.role === "assembler" ? audioArtifact ? join37(destinationDir, audioArtifact.path) : null : null
   };
 }
 function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
-  const markerPath = join35(planDir, PLAN_V2_MATERIALIZATION_MARKER);
-  if (!existsSync23(markerPath)) return null;
+  const markerPath = join37(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  if (!existsSync24(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
     throw new PlanV2IntegrityError("malformed materialization marker");
@@ -16810,8 +17051,8 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   const manifest = parsePlanV2Manifest(marker.manifest);
   const required = listPlanV2ArtifactsForTarget(manifest, expectedTarget);
   for (const artifact of required) {
-    const path = join35(planDir, ...artifact.path.split("/"));
-    if (!existsSync23(path) || statSync9(path).size !== artifact.sizeBytes) {
+    const path = join37(planDir, ...artifact.path.split("/"));
+    if (!existsSync24(path) || statSync9(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -16826,22 +17067,22 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
 // ../producer/src/services/distributed/planV2Execution.ts
 import { mkdtempSync as mkdtempSync9, rmSync as rmSync16 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join39 } from "path";
+import { join as join41 } from "path";
 
 // ../producer/src/services/distributed/assemble.ts
 import {
   cpSync as cpSync3,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync8,
   readFileSync as readFileSync12,
-  readdirSync as readdirSync9,
+  readdirSync as readdirSync10,
   renameSync as renameSync8,
   rmSync as rmSync14,
   statSync as statSync10,
   writeFileSync as writeFileSync11
 } from "fs";
-import { dirname as dirname16, join as join37 } from "path";
+import { dirname as dirname16, join as join39 } from "path";
 
 // ../producer/src/services/distributed/mp4Stitch.ts
 import {
@@ -16853,7 +17094,7 @@ import {
   rmSync as rmSync13
 } from "fs";
 import { open } from "fs/promises";
-import { dirname as dirname15, join as join36 } from "path";
+import { dirname as dirname15, join as join38 } from "path";
 import { finished, pipeline } from "stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -17175,13 +17416,13 @@ async function writeStitchedMp4(chunkPaths, outputPath) {
   const header = buildStitchedHeader(layouts);
   mkdirSync14(dirname15(outputPath), { recursive: true });
   const workDir = mkdtempSync7(`${outputPath}.stitch-`);
-  const out = createWriteStream(join36(workDir, "out.mp4"));
+  const out = createWriteStream(join38(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);
-    renameSync7(join36(workDir, "out.mp4"), outputPath);
+    renameSync7(join38(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
     rmSync13(workDir, { recursive: true, force: true });
@@ -17215,7 +17456,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync24(dirname16(outputPath))) {
+  if (!existsSync25(dirname16(outputPath))) {
     mkdirSync15(dirname16(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync8(`${outputPath}.assemble-work-`);
@@ -17238,8 +17479,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join37(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync24(audioPath) ? audioPath : null;
+    const finalPath = join39(workDir, `output.${format}`);
+    const audio = audioPath !== null && existsSync25(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameSync8(finalPath, outputPath);
     log.info("[assemble] stage timings", {
@@ -17257,7 +17498,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync24(outputPath) ? statSync10(outputPath).size : 0;
+  const fileSize = existsSync25(outputPath) ? statSync10(outputPath).size : 0;
   return {
     outputPath,
     durationMs: Date.now() - start,
@@ -17266,15 +17507,15 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join37(planDir, "plan.json");
-  const chunksJsonPath = join37(planDir, "meta", "chunks.json");
-  if (!existsSync24(planJsonPath)) {
+  const planJsonPath = join39(planDir, "plan.json");
+  const chunksJsonPath = join39(planDir, "meta", "chunks.json");
+  if (!existsSync25(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
   const plan2 = JSON.parse(readFileSync12(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync24(chunksJsonPath)) {
+  if (!existsSync25(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
   const chunks = JSON.parse(readFileSync12(chunksJsonPath, "utf-8"));
@@ -17284,7 +17525,7 @@ function readAssemblePlan(planDir, chunkPaths) {
     );
   }
   for (const path of chunkPaths) {
-    if (!existsSync24(path)) {
+    if (!existsSync25(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -17294,7 +17535,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 = join37(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join39(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = [
     ...videoInputArgs(ctx, chunkPaths),
     "-c:v",
@@ -17332,7 +17573,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join37(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join39(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -17372,7 +17613,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join37(workDir, "concat-list.txt");
+  const listPath = join39(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync11(listPath, `${body}
 `, "utf-8");
@@ -17405,8 +17646,8 @@ function chunksAreStitchedMp4(planDir, cfr) {
   return true;
 }
 function chunksCarryAudio(planDir) {
-  const encoderJsonPath = join37(planDir, "meta", "encoder.json");
-  if (!existsSync24(encoderJsonPath)) return false;
+  const encoderJsonPath = join39(planDir, "meta", "encoder.json");
+  if (!existsSync25(encoderJsonPath)) return false;
   return JSON.parse(readFileSync12(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
 }
 function readCfrEncoder(planDir, format) {
@@ -17415,8 +17656,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 = join37(planDir, "meta", "encoder.json");
-  if (!existsSync24(encoderJsonPath)) {
+  const encoderJsonPath = join39(planDir, "meta", "encoder.json");
+  if (!existsSync25(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
   const encoderJson = JSON.parse(readFileSync12(encoderJsonPath, "utf-8"));
@@ -17428,7 +17669,7 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync24(outputPath)) rmSync14(outputPath, { recursive: true, force: true });
+  if (existsSync25(outputPath)) rmSync14(outputPath, { recursive: true, force: true });
   mkdirSync15(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -17437,13 +17678,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 = join37(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join37(chunkDir, frame), dst);
+      const dst = join39(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join39(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -17452,14 +17693,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 && existsSync24(audioPath)) {
-    const sidecar = join37(outputPath, MIXED_AUDIO_FILENAME);
+  if (audioPath !== null && existsSync25(audioPath)) {
+    const sidecar = join39(outputPath, MIXED_AUDIO_FILENAME);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
-  for (const name of readdirSync9(outputPath)) {
+  for (const name of readdirSync10(outputPath)) {
     try {
-      fileSize += statSync10(join37(outputPath, name)).size;
+      fileSize += statSync10(join39(outputPath, name)).size;
     } catch {
     }
   }
@@ -17473,8 +17714,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // ../producer/src/services/distributed/renderChunk.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync25, mkdirSync as mkdirSync16, readFileSync as readFileSync13, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync12 } from "fs";
-import { extname as extname6, join as join38 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync13, readdirSync as readdirSync11, rmSync as rmSync15, writeFileSync as writeFileSync12 } from "fs";
+import { join as join40 } from "path";
 
 // ../producer/src/services/distributed/chunkAudio.ts
 function audioCutForChunk(grid, chunks, index, fps) {
@@ -17572,20 +17813,7 @@ async function muxChunkWithAudio(input) {
 }
 
 // ../producer/src/services/distributed/renderChunk.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 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);
@@ -17621,9 +17849,6 @@ async function createVerifiedDistributedCaptureSession(serverUrl, framesDir, cap
     throw error;
   }
 }
-function createChunkVideoFrameInjectorFactory(frameLookup) {
-  return () => createVideoFrameInjector(frameLookup);
-}
 function isCaptureMode(value) {
   return value === "beginframe" || value === "screenshot" || value === "drawelement";
 }
@@ -17651,130 +17876,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 = join38(planDir, "video-frames", v.videoId);
-    if (!existsSync25(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, join38(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 = createFrameLookupTable(
-    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 = join38(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 = join38(input.planDir, ...range.sourcePath.split("/"));
-      if (!existsSync25(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(readFileSync13(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(readFileSync13(join38(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync13(join40(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -17791,10 +17897,10 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join38(planDir, "plan.json");
-  const encoderJsonPath = join38(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join38(planDir, "meta", "chunks.json");
-  if (!existsSync25(planJsonPath)) {
+  const planJsonPath = join40(planDir, "plan.json");
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join40(planDir, "meta", "chunks.json");
+  if (!existsSync26(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
@@ -17808,7 +17914,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     chunkIndex
   });
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync25(required)) {
+    if (!existsSync26(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
@@ -17817,9 +17923,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   }
   const encoder = JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join38(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync25(videosJsonPath)) {
+  if (existsSync26(videosJsonPath)) {
     try {
       planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync13(videosJsonPath, "utf-8")));
     } catch (err) {
@@ -17847,8 +17953,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       `[renderChunk] chunk ${chunkIndex} has non-positive frame count: ${framesInChunk}`
     );
   }
-  const compiledDir = join38(planDir, "compiled");
-  if (!existsSync25(compiledDir)) {
+  const compiledDir = join40(planDir, "compiled");
+  if (!existsSync26(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -17905,7 +18011,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
     mkdirSync16(workDir, { recursive: true });
-    const framesDir = join38(workDir, "captured-frames");
+    const framesDir = join40(workDir, "captured-frames");
     mkdirSync16(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable(
@@ -17919,7 +18025,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
@@ -17928,9 +18037,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,
@@ -17940,28 +18046,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: compositionRequiresWebGpu(
-        readFileSync13(join38(compiledDir, "index.html"), "utf-8")
-      )
-    };
+    const captureOptions = buildChunkCaptureOptions({
+      dimensions: plan2.dimensions,
+      encoder,
+      videoCount: planVideos?.videos.length ?? 0,
+      html: readFileSync13(join40(compiledDir, "index.html"), "utf-8")
+    });
     const chunkWorkerCount = calculateOptimalWorkers(framesInChunk, void 0, cfg);
     let session = null;
     let outputKind;
@@ -18122,10 +18212,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 (!existsSync25(outputChunkPath)) mkdirSync16(outputChunkPath, { recursive: true });
+        if (!existsSync26(outputChunkPath)) mkdirSync16(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join38(outputChunkPath, "..");
-        if (!existsSync25(outDir)) mkdirSync16(outDir, { recursive: true });
+        const outDir = join40(outputChunkPath, "..");
+        if (!existsSync26(outDir)) mkdirSync16(outDir, { recursive: true });
       }
       const encodeStarted = Date.now();
       await runEncodeStage({
@@ -18248,8 +18338,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
 
 // ../producer/src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
-  const workRoot = mkdtempSync9(join39(tmpdir5(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join39(workRoot, "plan");
+  const workRoot = mkdtempSync9(join41(tmpdir5(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join41(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath);
@@ -18258,8 +18348,8 @@ async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync9(join39(tmpdir5(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join39(workRoot, "plan");
+  const workRoot = mkdtempSync9(join41(tmpdir5(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join41(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -18279,9 +18369,9 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
 }
 
 // ../producer/src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync14 } from "fs";
+import { readdirSync as readdirSync12, readFileSync as readFileSync14 } from "fs";
 import { createHash as createHash7 } from "crypto";
-import { join as join40, relative as relative8 } from "path";
+import { join as join42, relative as relative8 } from "path";
 
 export {
   createConsoleLogger,