hyperframes 0.8.178 → 0.8.179

package/dist/{chunk-O7PFPCQF.js → chunk-JRIXYXG3.js}

@@ -13167,14 +13167,14 @@ async function executeRenderPipeline(input) {
 import {
   copyFileSync as copyFileSync4,
   cpSync as cpSync2,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   linkSync,
-  mkdirSync as mkdirSync10,
-  renameSync as renameSync4,
-  rmSync as rmSync9,
-  writeFileSync as writeFileSync7
+  mkdirSync as mkdirSync12,
+  renameSync as renameSync5,
+  rmSync as rmSync10,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { extname as extname6, isAbsolute as isAbsolute2, join as join31, relative as relative5, sep as sep2 } from "path";
+import { extname as extname6, isAbsolute as isAbsolute2, join as join33, relative as relative5, sep as sep2 } from "path";
 
 // ../producer/src/services/distributed/planFrameCost.ts
 import { join as join28 } from "path";
@@ -14072,187 +14072,696 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
   };
 }
 
-// ../producer/src/services/distributed/planSize.ts
-import { createHash as createHash6 } from "crypto";
-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",
-  ".aiff",
-  ".avi",
-  ".flac",
-  ".m4a",
-  ".m4v",
-  ".mkv",
-  ".mov",
-  ".mp3",
-  ".mp4",
-  ".mpeg",
-  ".mpg",
-  ".ogg",
-  ".ogv",
-  ".ts",
-  ".wav",
-  ".webm"
-]);
-var PLAN_ROOT_CATEGORY = {
-  compiled: "compiled",
-  [PLAN_AUDIO_RELATIVE_PATH]: "audio",
-  meta: "metadata",
-  "plan.json": "metadata"
-};
-function hashComponent(value) {
-  return createHash6("sha256").update(value).digest("hex").slice(0, 12);
+// ../producer/src/services/distributed/chunkAudio.ts
+import { closeSync as closeSync6, existsSync as existsSync19, ftruncateSync, mkdirSync as mkdirSync11, openSync as openSync5, readFileSync as readFileSync10 } from "fs";
+import { writeFileSync as writeFileSync7, writeSync } from "fs";
+import { join as join31 } from "path";
+
+// ../producer/src/services/distributed/mp4Stitch.ts
+import {
+  createReadStream as createReadStream4,
+  createWriteStream,
+  mkdirSync as mkdirSync10,
+  mkdtempSync as mkdtempSync4,
+  renameSync as renameSync4,
+  rmSync as rmSync9
+} from "fs";
+import { open } from "fs/promises";
+import { dirname as dirname11, join as join30 } from "path";
+import { finished, pipeline } from "stream/promises";
+function boxAt(src, off, at, limit) {
+  let size = src.readUInt32BE(off);
+  let bodyStart = at + 8;
+  if (size === 1) {
+    size = Number(src.readBigUInt64BE(off + 8));
+    bodyStart = at + 16;
+  }
+  if (size < 8 || at + size > limit) throw new Error(`[mp4Stitch] malformed box at ${at}`);
+  return { type: src.toString("latin1", off + 4, off + 8), start: at, bodyStart, end: at + size };
 }
-function classifyFile(segments, rootKind) {
-  const rootName = segments[0] ?? "";
-  const extractedRootName = rootKind === "compiled" ? "__hyperframes_video_frames" : "video-frames";
-  if (rootName === extractedRootName) {
-    const videoKey = segments[1] ?? "unknown";
-    return {
-      category: "video-frames",
-      componentLabel: `video-frames:${hashComponent(videoKey)}`
-    };
+function childBoxes(buf, parent) {
+  const boxes = [];
+  for (let at = parent.bodyStart; at < parent.end; at = boxes.at(-1).end) {
+    boxes.push(boxAt(buf, at, at, parent.end));
   }
-  const category = rootKind === "compiled" ? "compiled" : PLAN_ROOT_CATEGORY[rootName] ?? "other";
-  return { category, componentLabel: category };
+  return boxes;
 }
-function emptyBreakdown() {
-  return {
-    totalBytes: 0,
-    fileCount: 0,
-    compiledBytes: 0,
-    sourceMediaBytes: 0,
-    videoFramesBytes: 0,
-    videoFrameFileCount: 0,
-    audioBytes: 0,
-    metadataBytes: 0,
-    otherBytes: 0,
-    topComponents: []
-  };
+function findChild(buf, parent, type) {
+  return childBoxes(buf, parent).find((box2) => box2.type === type);
 }
-function addCategoryBytes(result, category, filePath, sizeBytes) {
-  if (category === "compiled") {
-    result.compiledBytes += sizeBytes;
-    if (SOURCE_MEDIA_EXTENSIONS.has(extname5(filePath).toLowerCase())) {
-      result.sourceMediaBytes += sizeBytes;
-    }
-    return;
-  }
-  if (category === "video-frames") {
-    result.videoFramesBytes += sizeBytes;
-    result.videoFrameFileCount += 1;
-    return;
-  }
-  if (category === "audio") {
-    result.audioBytes += sizeBytes;
-    return;
-  }
-  if (category === "metadata") {
-    result.metadataBytes += sizeBytes;
-    return;
-  }
-  result.otherBytes += sizeBytes;
+function child(buf, parent, type) {
+  const found = findChild(buf, parent, type);
+  if (!found) throw new Error(`[mp4Stitch] ${parent.type} has no ${type}`);
+  return found;
 }
-function recordFile(result, components, rootDir, rootKind, filePath) {
-  let sizeBytes;
-  try {
-    const stat = lstatSync2(filePath);
-    if (!stat.isFile()) return;
-    sizeBytes = stat.size;
-  } catch {
-    return;
-  }
-  const rel = relative4(rootDir, filePath);
-  const segments = rel.split(/[\\/]+/).filter(Boolean);
-  const classified = classifyFile(segments, rootKind);
-  result.totalBytes += sizeBytes;
-  result.fileCount += 1;
-  addCategoryBytes(result, classified.category, filePath, sizeBytes);
-  const component = components.get(classified.componentLabel) ?? {
-    label: classified.componentLabel,
-    sizeBytes: 0,
-    fileCount: 0
+var SCAN_BYTES = 64 * 1024;
+async function readMp4Layout(read) {
+  const found = /* @__PURE__ */ new Map();
+  let payload;
+  let buf = Buffer.alloc(0);
+  let bufAt = 0;
+  const load = async (start, end) => {
+    if (start >= bufAt && end <= bufAt + buf.length) return;
+    buf = await read(start, Math.max(end, start + SCAN_BYTES));
+    bufAt = start;
   };
-  component.sizeBytes += sizeBytes;
-  component.fileCount += 1;
-  components.set(classified.componentLabel, component);
-}
-function walkRegularFiles(dir, visit) {
-  let entries;
-  try {
-    entries = readdirSync8(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const full = join30(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkRegularFiles(full, visit);
-    } else if (entry.isFile()) {
-      visit(full);
+  for (let at = 0; !(found.has("ftyp") && found.has("moov") && payload); ) {
+    await load(at, at + 16);
+    if (at + 8 > bufAt + buf.length) {
+      throw new Error(`[mp4Stitch] chunk needs ftyp, moov and mdat; found ${[...found.keys()]}`);
+    }
+    const box2 = boxAt(buf, at - bufAt, at, Number.MAX_SAFE_INTEGER);
+    if (box2.type === "mdat") payload ??= box2;
+    if (box2.type === "ftyp" || box2.type === "moov") {
+      await load(at, box2.end);
+      found.set(box2.type, buf.subarray(at - bufAt, box2.end - bufAt));
     }
+    at = box2.end;
   }
+  const [ftyp, moov] = [found.get("ftyp"), found.get("moov")];
+  if (moov.length !== moovSize(moov)) throw new Error("[mp4Stitch] moov is cut off");
+  return { ftyp, moov, payloadStart: payload.bodyStart, payloadEnd: payload.end };
 }
-function measurePlanSizeBreakdown(rootDir, rootKind = "plan") {
-  const result = emptyBreakdown();
-  const components = /* @__PURE__ */ new Map();
-  walkRegularFiles(
-    rootDir,
-    (filePath) => recordFile(result, components, rootDir, rootKind, filePath)
-  );
-  result.topComponents = [...components.values()].sort((a, b) => b.sizeBytes - a.sizeBytes || a.label.localeCompare(b.label)).slice(0, MAX_TOP_COMPONENTS);
-  return result;
-}
-
-// ../producer/src/services/distributed/plan.ts
-function logPlanStage(log, stage, startedAt) {
-  log.info("[plan] stage", { stage, ms: Date.now() - startedAt });
+var moovSize = (moov) => boxAt(moov, 0, 0, Number.MAX_SAFE_INTEGER).end;
+function readTracks(moov) {
+  const root = boxAt(moov, 0, 0, moov.length);
+  return childBoxes(moov, root).filter((box2) => box2.type === "trak").map((trak) => readTrack(moov, trak));
 }
-function applyDistributedAudioWarningPolicy(job, audioError, audioFailures = [], log = defaultLogger) {
-  const failureOwner = audioFailures.length === 0 ? void 0 : audioFailures.some((failure) => failure.owner === "system") ? "system" : "user";
-  const retryable = audioFailures.length === 0 ? void 0 : audioFailures.every((failure) => failure.retryable);
-  applyRenderWarningPolicy(
-    job,
-    [
-      {
-        code: "audio_processing_failed",
-        message: `Audio mix failed; output would be video-only: ${audioError}`,
-        details: {
-          mediaType: "audio",
-          audioFailures: audioFailureDiagnostics(audioFailures),
-          failureReasons: [...new Set(audioFailures.map((failure) => failure.reason))],
-          failureStages: [...new Set(audioFailures.map((failure) => failure.stage))],
-          failureOwner,
-          retryable
-        }
-      }
-    ],
-    log
+function rows(buf, table, columns, countAt = 4) {
+  const count = buf.readUInt32BE(table.bodyStart + countAt);
+  const first = table.bodyStart + countAt + 4;
+  return Array.from(
+    { length: count },
+    (_, row) => Array.from(
+      { length: columns },
+      (_2, col) => buf.readUInt32BE(first + (row * columns + col) * 4)
+    )
   );
 }
-var PLAN_PROJECT_DIR_SKIP_SEGMENTS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".cache",
-  "output",
-  "failures",
-  "dist",
-  ".next",
-  ".turbo"
-]);
-var DEFAULT_MAX_PARALLEL_CHUNKS = 16;
-var MIN_CHUNK_SIZE = 10;
-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 estimateFrameSeconds(megapixels, measuredSecondsPerFrame = 0) {
-  return Math.max(ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels, measuredSecondsPerFrame);
+function readMediaTime(moov, trak) {
+  const edts = findChild(moov, trak, "edts");
+  if (!edts) return 0;
+  const elst = child(moov, edts, "elst");
+  const wide = moov[elst.bodyStart] === 1;
+  const entries = moov.readUInt32BE(elst.bodyStart + 4);
+  for (let i = 0, at = elst.bodyStart + 8; i < entries; i++, at += wide ? 20 : 12) {
+    const offset = at + (wide ? 8 : 4);
+    const mediaTime = wide ? Number(moov.readBigInt64BE(offset)) : moov.readInt32BE(offset);
+    if (mediaTime !== -1) return mediaTime;
+  }
+  return 0;
 }
-function estimateChunkSeconds(frames, megapixels, measuredSecondsPerFrame) {
-  return ESTIMATED_CHUNK_OVERHEAD_SECONDS + frames * estimateFrameSeconds(megapixels, measuredSecondsPerFrame);
+function readSizes(moov, stsz) {
+  const fixedSize = moov.readUInt32BE(stsz.bodyStart + 4);
+  if (!fixedSize) return rows(moov, stsz, 1, 8).map(([size]) => size);
+  return Array(moov.readUInt32BE(stsz.bodyStart + 8)).fill(fixedSize);
+}
+function readSync4(moov, stbl, sampleCount) {
+  const stss = findChild(moov, stbl, "stss");
+  if (!stss) return null;
+  const sync = Array(sampleCount).fill(false);
+  for (const [n] of rows(moov, stss, 1)) sync[n - 1] = true;
+  return sync;
+}
+function readChunkOffsets(moov, stbl) {
+  const stco = findChild(moov, stbl, "stco");
+  if (stco) return rows(moov, stco, 1).map(([offset]) => offset);
+  return rows(moov, child(moov, stbl, "co64"), 2).map(([hi, lo]) => hi * 2 ** 32 + lo);
+}
+function readSamplesPerChunk(moov, stbl, chunkCount) {
+  const stsc = rows(moov, child(moov, stbl, "stsc"), 3);
+  return stsc.flatMap(([firstChunk, perChunk, description], i) => {
+    if (description !== 1) throw new Error("[mp4Stitch] chunk uses more than one sample entry");
+    const nextFirst = stsc[i + 1]?.[0] ?? chunkCount + 1;
+    return Array(nextFirst - firstChunk).fill(perChunk);
+  });
+}
+function readTrack(moov, trak) {
+  const mdia = child(moov, trak, "mdia");
+  const hdlr = child(moov, mdia, "hdlr");
+  const stbl = child(moov, child(moov, mdia, "minf"), "stbl");
+  if (findChild(moov, stbl, "ctts")) throw new Error("[mp4Stitch] chunk has ctts (B-frames)");
+  const stts = rows(moov, child(moov, stbl, "stts"), 2);
+  const durations = stts.flatMap(([n, delta]) => Array(n).fill(delta));
+  const sizes = readSizes(moov, child(moov, stbl, "stsz"));
+  const chunkOffsets = readChunkOffsets(moov, stbl);
+  const samplesPerChunk = readSamplesPerChunk(moov, stbl, chunkOffsets.length);
+  if (durations.length !== sizes.length || sum(samplesPerChunk) !== sizes.length) {
+    throw new Error("[mp4Stitch] sample tables disagree on the sample count");
+  }
+  const stsd = child(moov, stbl, "stsd");
+  return {
+    trak,
+    handler: moov.toString("latin1", hdlr.bodyStart + 8, hdlr.bodyStart + 12),
+    timescale: timescaleOf(moov, child(moov, mdia, "mdhd")),
+    mediaTime: readMediaTime(moov, trak),
+    stsd: moov.subarray(stsd.start, stsd.end),
+    durations,
+    sizes,
+    sync: readSync4(moov, stbl, sizes.length),
+    samplesPerChunk,
+    chunkOffsets
+  };
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function box(type, ...body) {
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(8 + sum(body.map((part) => part.length)));
+  header.write(type, 4, "latin1");
+  return Buffer.concat([header, ...body]);
+}
+function fullBox(type, version, body) {
+  return box(type, Buffer.from([version, 0, 0, 0]), body);
+}
+function u32s(values) {
+  const buf = Buffer.alloc(values.length * 4);
+  values.forEach((value, i) => buf.writeUInt32BE(value, i * 4));
+  return buf;
+}
+function runs(values) {
+  const out = [];
+  for (const value of values) {
+    const last = out.at(-1);
+    if (last && last[1] === value) last[0]++;
+    else out.push([1, value]);
+  }
+  return out;
+}
+function rebuild(buf, parent, replace) {
+  const parts = childBoxes(buf, parent).map(
+    (box2) => replace[box2.type]?.(box2) ?? buf.subarray(box2.start, box2.end)
+  );
+  return box(parent.type, ...parts);
+}
+var DURATION_AT = {
+  mvhd: [16, 24],
+  mdhd: [16, 24],
+  tkhd: [20, 28]
+};
+function withDuration(buf, target, duration) {
+  const copy = Buffer.from(buf.subarray(target.start, target.end));
+  const body = target.bodyStart - target.start;
+  const wide = copy[body] === 1;
+  const at = body + DURATION_AT[target.type][wide ? 1 : 0];
+  if (wide) copy.writeBigUInt64BE(BigInt(duration), at);
+  else if (duration <= 4294967295) copy.writeUInt32BE(duration, at);
+  else throw new Error(`[mp4Stitch] ${target.type} duration ${duration} needs a version 1 box`);
+  return copy;
+}
+function timescaleOf(buf, header) {
+  return buf.readUInt32BE(header.bodyStart + (buf[header.bodyStart] === 1 ? 20 : 12));
+}
+function buildStbl(stsd, track) {
+  const stts = runs(track.durations);
+  const stsc = [];
+  let firstChunk = 1;
+  for (const [count, perChunk] of runs(track.samplesPerChunk)) {
+    stsc.push([firstChunk, perChunk, 1]);
+    firstChunk += count;
+  }
+  const co64 = Buffer.alloc(4 + track.chunkOffsets.length * 8);
+  co64.writeUInt32BE(track.chunkOffsets.length);
+  track.chunkOffsets.forEach((offset, i) => co64.writeBigUInt64BE(BigInt(offset), 4 + i * 8));
+  const syncSamples = track.sync?.flatMap((isSync, i) => isSync ? [i + 1] : []) ?? null;
+  return box(
+    "stbl",
+    stsd,
+    fullBox("stts", 0, u32s([stts.length, ...stts.flat()])),
+    ...syncSamples ? [fullBox("stss", 0, u32s([syncSamples.length, ...syncSamples]))] : [],
+    fullBox("stsc", 0, u32s([stsc.length, ...stsc.flat()])),
+    fullBox("stsz", 0, u32s([0, track.sizes.length, ...track.sizes])),
+    fullBox("co64", 0, co64)
+  );
+}
+var codecOf = (track) => track.stsd.toString("latin1", 20, 24);
+var sameTrack = (track, plan2) => track.handler === plan2.handler && track.timescale === plan2.timescale && codecOf(track) === codecOf(plan2);
+function planTracksOf(tracks, plan2, index) {
+  let next = 0;
+  const matched = plan2.map((planTrack) => {
+    const track = tracks[next];
+    if (track && sameTrack(track, planTrack)) return tracks[next++];
+    if (planTrack.handler === "soun") return null;
+    throw new Error(`[mp4Stitch] chunk ${index} tracks differ from chunk 0`);
+  });
+  if (next !== tracks.length)
+    throw new Error(`[mp4Stitch] chunk ${index} tracks differ from chunk 0`);
+  for (const track of tracks) {
+    if (track.handler === "vide" && track.mediaTime !== 0) {
+      throw new Error(`[mp4Stitch] chunk ${index} video starts at media time ${track.mediaTime}`);
+    }
+  }
+  return matched;
+}
+function buildStitchedHeader(layouts) {
+  const plan2 = readTracks(layouts[0].moov);
+  const chunks = layouts.map((layout, i) => planTracksOf(readTracks(layout.moov), plan2, i));
+  const payloadBases = [];
+  let payloadBytes = 0;
+  for (const layout of layouts) {
+    payloadBases.push(payloadBytes);
+    payloadBytes += layout.payloadEnd - layout.payloadStart;
+  }
+  const template = layouts[0].moov;
+  const root = boxAt(template, 0, 0, template.length);
+  const movieTimescale = timescaleOf(template, child(template, root, "mvhd"));
+  const buildMoov = (dataStart2) => {
+    const traks = plan2.map((track, t) => {
+      const parts = chunks.flatMap((tracks, chunk) => {
+        const part = tracks[t];
+        return part ? [{ ...part, chunk }] : [];
+      });
+      const merged = {
+        durations: parts.flatMap((part) => part.durations),
+        sizes: parts.flatMap((part) => part.sizes),
+        sync: parts.every((part) => !part.sync) ? null : parts.flatMap((part) => part.sync ?? part.sizes.map(() => true)),
+        samplesPerChunk: parts.flatMap((part) => part.samplesPerChunk),
+        chunkOffsets: parts.flatMap(
+          (part) => part.chunkOffsets.map((offset) => {
+            const i = part.chunk;
+            const { payloadStart, payloadEnd } = layouts[i];
+            if (offset < payloadStart || offset >= payloadEnd) {
+              throw new Error(`[mp4Stitch] chunk ${i} has samples outside its mdat`);
+            }
+            return offset - payloadStart + payloadBases[i] + dataStart2;
+          })
+        )
+      };
+      const mediaDuration = sum(merged.durations);
+      const shown = Math.round(
+        (mediaDuration - track.mediaTime) * movieTimescale / track.timescale
+      );
+      const elst = Buffer.alloc(24);
+      elst.writeUInt32BE(1);
+      elst.writeBigUInt64BE(BigInt(shown), 4);
+      elst.writeBigInt64BE(BigInt(track.mediaTime), 12);
+      elst.writeUInt32BE(65536, 20);
+      const edts = track.mediaTime ? box("edts", fullBox("elst", 1, elst)) : Buffer.alloc(0);
+      const trak = rebuild(template, track.trak, {
+        tkhd: (tkhd) => Buffer.concat([withDuration(template, tkhd, shown), edts]),
+        edts: () => Buffer.alloc(0),
+        mdia: (mdia) => rebuild(template, mdia, {
+          mdhd: (mdhd) => withDuration(template, mdhd, mediaDuration),
+          minf: (minf) => rebuild(template, minf, { stbl: () => buildStbl(track.stsd, merged) })
+        })
+      });
+      return { trak, shown };
+    });
+    let next = 0;
+    return rebuild(template, root, {
+      mvhd: (mvhd) => withDuration(template, mvhd, Math.max(...traks.map((t) => t.shown))),
+      trak: () => traks[next++].trak
+    });
+  };
+  const ftyp = layouts[0].ftyp;
+  const dataStart = ftyp.length + buildMoov(0).length + 16;
+  const mdat = Buffer.alloc(16);
+  mdat.writeUInt32BE(1);
+  mdat.write("mdat", 4, "latin1");
+  mdat.writeBigUInt64BE(BigInt(16 + payloadBytes), 8);
+  return Buffer.concat([ftyp, buildMoov(dataStart), mdat]);
+}
+function fileRange(path) {
+  return async (start, end) => {
+    const file = await open(path, "r", 384);
+    try {
+      const buf = Buffer.alloc(end - start);
+      const { bytesRead } = await file.read(buf, 0, buf.length, start);
+      return buf.subarray(0, bytesRead);
+    } finally {
+      await file.close();
+    }
+  };
+}
+async function copyPayload(path, layout, index, out) {
+  const { payloadStart, payloadEnd } = layout;
+  const payload = createReadStream4(path, { start: payloadStart, end: payloadEnd - 1 });
+  await pipeline(payload, out, { end: false });
+  if (payload.bytesRead !== payloadEnd - payloadStart) {
+    throw new Error(
+      `[mp4Stitch] chunk ${index} mdat holds ${payload.bytesRead} of ${payloadEnd - payloadStart} payload bytes`
+    );
+  }
+}
+async function writeStitchedMp4(chunkPaths, outputPath) {
+  const layouts = await Promise.all(chunkPaths.map((path) => readMp4Layout(fileRange(path))));
+  const header = buildStitchedHeader(layouts);
+  mkdirSync10(dirname11(outputPath), { recursive: true });
+  const workDir = mkdtempSync4(`${outputPath}.stitch-`);
+  const out = createWriteStream(join30(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);
+    renameSync4(join30(workDir, "out.mp4"), outputPath);
+  } finally {
+    out.destroy();
+    rmSync9(workDir, { recursive: true, force: true });
+  }
+}
+
+// ../producer/src/services/distributed/chunkAudio.ts
+function audioCutForChunk(grid, chunks, index, fps) {
+  const firstPacketAt = (frame) => Math.min(
+    grid.packetCount,
+    Math.max(
+      0,
+      Math.ceil(
+        (frame * fps.den * grid.sampleRate - grid.firstStart * fps.num) / (grid.packetSamples * fps.num)
+      )
+    )
+  );
+  const first = index === 0 ? 0 : firstPacketAt(chunks[index].startFrame);
+  const end = index === chunks.length - 1 ? grid.packetCount : firstPacketAt(chunks[index + 1].startFrame);
+  if (end <= first) return null;
+  const cutSeconds = (packet) => (grid.firstStart + packet * grid.packetSamples - grid.packetSamples / 2) / grid.sampleRate;
+  const seekSeconds = index === 0 ? null : cutSeconds(first);
+  const durationSeconds = end === grid.packetCount ? null : cutSeconds(end) - (seekSeconds ?? 0);
+  return { seekSeconds, durationSeconds, firstPacket: first, packetCount: end - first };
+}
+async function probeAacPacketGrid(audioPath) {
+  const probe = await runFfprobeJson([
+    "-v",
+    "error",
+    "-select_streams",
+    "a:0",
+    "-show_entries",
+    "stream=sample_rate,time_base,nb_frames:packet=pts,duration",
+    "-read_intervals",
+    "%+#1",
+    "-of",
+    "json",
+    "--",
+    audioPath
+  ]);
+  const stream = probe.streams?.[0] ?? {};
+  const packet = probe.packets?.[0] ?? {};
+  const sampleRate = Number(stream.sample_rate);
+  const [tbNum = NaN, tbDen = NaN] = String(stream.time_base).split("/").map(Number);
+  const toSamples = (ticks) => Number(ticks) * sampleRate * tbNum / tbDen;
+  const grid = {
+    sampleRate,
+    firstStart: toSamples(packet.pts),
+    packetSamples: toSamples(packet.duration),
+    packetCount: Number(stream.nb_frames)
+  };
+  const counts = [grid.sampleRate, grid.packetSamples, grid.packetCount];
+  if (!Number.isFinite(grid.firstStart) || !counts.every((n) => Number.isFinite(n) && n > 0)) {
+    throw new Error(`[chunkAudio] could not read the AAC packet grid: ${JSON.stringify(probe)}`);
+  }
+  return grid;
+}
+var SLICE_DIR = "audio-chunks";
+var SLICE_FRAME = `${SLICE_DIR}/frame.m4a`;
+var SLICE_LAYOUT = `${SLICE_DIR}/layout.json`;
+function chunkAudioSlicePath(index) {
+  return `${SLICE_DIR}/${String(index).padStart(4, "0")}.bin`;
+}
+function chunkAudioSliceTarget(path) {
+  if (path === SLICE_FRAME || path === SLICE_LAYOUT) return "all";
+  const match = /^audio-chunks\/(\d{4,})\.bin$/.exec(path);
+  return match ? Number(match[1]) : null;
+}
+async function writeChunkAudioSlices(input) {
+  const grid = await probeAacPacketGrid(input.audioPath);
+  const { payloadStart, payloadEnd, moov } = await readMp4Layout(fileRange(input.audioPath));
+  const [track] = readTracks(moov);
+  const offsets = [];
+  track.chunkOffsets.forEach((offset, chunk) => {
+    for (let i = 0; i < track.samplesPerChunk[chunk]; i++) {
+      offsets.push(offset);
+      offset += track.sizes[offsets.length - 1];
+    }
+  });
+  const bytes = readFileSync10(input.audioPath);
+  const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
+  mkdirSync11(join31(input.planDir, SLICE_DIR), { recursive: true });
+  input.chunks.forEach((_, index) => {
+    const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
+    if (!cut) return;
+    const last = cut.firstPacket + cut.packetCount - 1;
+    const start = offsets[cut.firstPacket];
+    layout.partStarts[index] = start;
+    const end = offsets[last] + track.sizes[last];
+    writeFileSync7(join31(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
+  });
+  const frame = [bytes.subarray(0, payloadStart), bytes.subarray(payloadEnd)];
+  writeFileSync7(join31(input.planDir, SLICE_FRAME), Buffer.concat(frame));
+  writeFileSync7(join31(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
+}
+function chunkAudioSource(planDir, chunkIndex, scratchPath) {
+  const layoutPath = join31(planDir, SLICE_LAYOUT);
+  if (!existsSync19(layoutPath)) return resolvePlanAudioPath(planDir);
+  const layout = JSON.parse(readFileSync10(layoutPath, "utf-8"));
+  const frame = readFileSync10(join31(planDir, SLICE_FRAME));
+  const fd = openSync5(scratchPath, "w");
+  try {
+    writeSync(fd, frame, 0, layout.payloadStart, 0);
+    writeSync(
+      fd,
+      frame,
+      layout.payloadStart,
+      frame.length - layout.payloadStart,
+      layout.payloadEnd
+    );
+    const start = layout.partStarts[chunkIndex];
+    if (start !== void 0) {
+      const part = readFileSync10(join31(planDir, chunkAudioSlicePath(chunkIndex)));
+      writeSync(fd, part, 0, part.length, start);
+    }
+    ftruncateSync(fd, layout.sizeBytes);
+  } finally {
+    closeSync6(fd);
+  }
+  return scratchPath;
+}
+function chunkMuxArgs(input, cut) {
+  if (!cut) return ["-i", input.videoPath, "-map", "0:v:0"];
+  const seek = cut.seekSeconds === null ? [] : ["-ss", cut.seekSeconds.toFixed(6)];
+  const length = cut.durationSeconds === null ? [] : ["-t", cut.durationSeconds.toFixed(6)];
+  const exact = seek.length ? ["-copypriorss", "0"] : [];
+  return [
+    ...["-i", input.videoPath, ...seek, ...length, "-i", input.audioPath],
+    ...["-map", "0:v:0", "-map", "1:a:0", ...exact]
+  ];
+}
+async function muxChunkWithAudio(input) {
+  const grid = input.audioPath ? await probeAacPacketGrid(input.audioPath) : null;
+  const cut = grid ? audioCutForChunk(grid, input.chunks, input.chunkIndex, input.fps) : null;
+  const args = [...chunkMuxArgs(input, cut), "-c", "copy"];
+  appendRenderProvenanceArgs(args, input.outputPath);
+  args.push("-y", input.outputPath);
+  const result = await runFfmpeg(args, { signal: input.signal, timeout: input.timeoutMs });
+  if (!result.success) {
+    throw new Error(
+      `[chunkAudio] chunk mux failed: ${describeFfmpegFailure(result, input.timeoutMs)}`
+    );
+  }
+  const slice = input.chunks[input.chunkIndex];
+  const expected = { video: slice.endFrame - slice.startFrame };
+  if (cut) expected.audio = cut.packetCount;
+  const probe = await runFfprobeJson([
+    "-v",
+    "error",
+    "-count_packets",
+    "-show_entries",
+    "stream=codec_type,nb_read_packets",
+    "-of",
+    "json",
+    "--",
+    input.outputPath
+  ]);
+  for (const [type, count] of Object.entries(expected)) {
+    const packets = Number(probe.streams?.find((s) => s.codec_type === type)?.nb_read_packets ?? 0);
+    if (packets !== count) {
+      throw new Error(`[chunkAudio] ${type} packets in chunk ${packets}, expected ${count}`);
+    }
+  }
+}
+
+// ../producer/src/services/distributed/planSize.ts
+import { createHash as createHash6 } from "crypto";
+import { lstatSync as lstatSync2, readdirSync as readdirSync8 } from "fs";
+import { extname as extname5, join as join32, relative as relative4 } from "path";
+var MAX_TOP_COMPONENTS = 10;
+var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".aac",
+  ".aiff",
+  ".avi",
+  ".flac",
+  ".m4a",
+  ".m4v",
+  ".mkv",
+  ".mov",
+  ".mp3",
+  ".mp4",
+  ".mpeg",
+  ".mpg",
+  ".ogg",
+  ".ogv",
+  ".ts",
+  ".wav",
+  ".webm"
+]);
+var PLAN_ROOT_CATEGORY = {
+  compiled: "compiled",
+  [PLAN_AUDIO_RELATIVE_PATH]: "audio",
+  meta: "metadata",
+  "plan.json": "metadata"
+};
+function hashComponent(value) {
+  return createHash6("sha256").update(value).digest("hex").slice(0, 12);
+}
+function classifyFile(segments, rootKind) {
+  const rootName = segments[0] ?? "";
+  const extractedRootName = rootKind === "compiled" ? "__hyperframes_video_frames" : "video-frames";
+  if (rootName === extractedRootName) {
+    const videoKey = segments[1] ?? "unknown";
+    return {
+      category: "video-frames",
+      componentLabel: `video-frames:${hashComponent(videoKey)}`
+    };
+  }
+  const category = rootKind === "compiled" ? "compiled" : PLAN_ROOT_CATEGORY[rootName] ?? "other";
+  return { category, componentLabel: category };
+}
+function emptyBreakdown() {
+  return {
+    totalBytes: 0,
+    fileCount: 0,
+    compiledBytes: 0,
+    sourceMediaBytes: 0,
+    videoFramesBytes: 0,
+    videoFrameFileCount: 0,
+    audioBytes: 0,
+    metadataBytes: 0,
+    otherBytes: 0,
+    topComponents: []
+  };
+}
+function addCategoryBytes(result, category, filePath, sizeBytes) {
+  if (category === "compiled") {
+    result.compiledBytes += sizeBytes;
+    if (SOURCE_MEDIA_EXTENSIONS.has(extname5(filePath).toLowerCase())) {
+      result.sourceMediaBytes += sizeBytes;
+    }
+    return;
+  }
+  if (category === "video-frames") {
+    result.videoFramesBytes += sizeBytes;
+    result.videoFrameFileCount += 1;
+    return;
+  }
+  if (category === "audio") {
+    result.audioBytes += sizeBytes;
+    return;
+  }
+  if (category === "metadata") {
+    result.metadataBytes += sizeBytes;
+    return;
+  }
+  result.otherBytes += sizeBytes;
+}
+function recordFile(result, components, rootDir, rootKind, filePath) {
+  let sizeBytes;
+  try {
+    const stat = lstatSync2(filePath);
+    if (!stat.isFile()) return;
+    sizeBytes = stat.size;
+  } catch {
+    return;
+  }
+  const rel = relative4(rootDir, filePath);
+  const segments = rel.split(/[\\/]+/).filter(Boolean);
+  const classified = classifyFile(segments, rootKind);
+  result.totalBytes += sizeBytes;
+  result.fileCount += 1;
+  addCategoryBytes(result, classified.category, filePath, sizeBytes);
+  const component = components.get(classified.componentLabel) ?? {
+    label: classified.componentLabel,
+    sizeBytes: 0,
+    fileCount: 0
+  };
+  component.sizeBytes += sizeBytes;
+  component.fileCount += 1;
+  components.set(classified.componentLabel, component);
+}
+function walkRegularFiles(dir, visit) {
+  let entries;
+  try {
+    entries = readdirSync8(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join32(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkRegularFiles(full, visit);
+    } else if (entry.isFile()) {
+      visit(full);
+    }
+  }
+}
+function measurePlanSizeBreakdown(rootDir, rootKind = "plan") {
+  const result = emptyBreakdown();
+  const components = /* @__PURE__ */ new Map();
+  walkRegularFiles(
+    rootDir,
+    (filePath) => recordFile(result, components, rootDir, rootKind, filePath)
+  );
+  result.topComponents = [...components.values()].sort((a, b) => b.sizeBytes - a.sizeBytes || a.label.localeCompare(b.label)).slice(0, MAX_TOP_COMPONENTS);
+  return result;
+}
+
+// ../producer/src/services/distributed/plan.ts
+function logPlanStage(log, stage, startedAt) {
+  log.info("[plan] stage", { stage, ms: Date.now() - startedAt });
+}
+function applyDistributedAudioWarningPolicy(job, audioError, audioFailures = [], log = defaultLogger) {
+  const failureOwner = audioFailures.length === 0 ? void 0 : audioFailures.some((failure) => failure.owner === "system") ? "system" : "user";
+  const retryable = audioFailures.length === 0 ? void 0 : audioFailures.every((failure) => failure.retryable);
+  applyRenderWarningPolicy(
+    job,
+    [
+      {
+        code: "audio_processing_failed",
+        message: `Audio mix failed; output would be video-only: ${audioError}`,
+        details: {
+          mediaType: "audio",
+          audioFailures: audioFailureDiagnostics(audioFailures),
+          failureReasons: [...new Set(audioFailures.map((failure) => failure.reason))],
+          failureStages: [...new Set(audioFailures.map((failure) => failure.stage))],
+          failureOwner,
+          retryable
+        }
+      }
+    ],
+    log
+  );
+}
+var PLAN_PROJECT_DIR_SKIP_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".cache",
+  "output",
+  "failures",
+  "dist",
+  ".next",
+  ".turbo"
+]);
+var DEFAULT_MAX_PARALLEL_CHUNKS = 16;
+var MIN_CHUNK_SIZE = 10;
+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 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);
@@ -14397,13 +14906,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join31("meta", "composition.json"),
-  join31("meta", "encoder.json"),
-  join31("meta", "chunks.json")
+  join33("meta", "composition.json"),
+  join33("meta", "encoder.json"),
+  join33("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync9(join31(planDir, relativePath), { force: true });
+    rmSync10(join33(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -14534,19 +15043,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join31(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join33(input.planDir, "video-frames", stagedRel);
     let result = null;
     for (const root of stagedRel === null ? [input.workCompiledDir, input.projectDir] : []) {
       const rel = pathInside(root, srcPath);
-      if (rel !== null && (existsSync19(join31(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync20(join33(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
         result = ["compiled", ...rel.split(sep2)].join("/");
         break;
       }
     }
     if (result === null) {
       result = `video-sources/${shipped.size}${extname6(current)}`;
-      const destination = join31(input.planDir, ...result.split("/"));
-      mkdirSync10(join31(input.planDir, "video-sources"), { recursive: true });
+      const destination = join33(input.planDir, ...result.split("/"));
+      mkdirSync12(join33(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -14564,7 +15073,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync19(planDir)) mkdirSync10(planDir, { recursive: true });
+  if (!existsSync20(planDir)) mkdirSync12(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -14593,15 +15102,15 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join31(projectDir, entryFile);
-  if (!existsSync19(htmlPath)) {
+  const htmlPath = join33(projectDir, entryFile);
+  if (!existsSync20(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join31(planDir, ".plan-work");
-  rmSync9(workDir, { recursive: true, force: true });
-  mkdirSync10(workDir, { recursive: true });
-  const compiledDir = join31(workDir, "compiled");
-  mkdirSync10(compiledDir, { recursive: true });
+  const workDir = join33(planDir, ".plan-work");
+  rmSync10(workDir, { recursive: true, force: true });
+  mkdirSync12(workDir, { recursive: true });
+  const compiledDir = join33(workDir, "compiled");
+  mkdirSync12(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
     recursive: true,
@@ -14614,10 +15123,10 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join31(planDir, "compiled");
+  const finalCompiledDir = join33(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
-  const remoteLocalPath = (rel) => join31(projectDir, ...rel.split("/"));
+  const remoteLocalPath = (rel) => join33(projectDir, ...rel.split("/"));
   const urlByAbsentLocalPath = new Map(
     remoteFiles.map(([rel, file]) => [remoteLocalPath(rel), file.url])
   );
@@ -14722,18 +15231,18 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (extractResult.extractionResult) {
     assertVideoExtractionSucceeded(extractResult.extractionResult);
   }
-  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 (existsSync19(stagedVideoFrames)) {
-    renameSync4(stagedVideoFrames, videoFramesDst);
+  const stagedVideoFrames = join33(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join33(planDir, "video-frames");
+  if (existsSync20(videoFramesDst)) rmSync10(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join33(planDir, "video-sources");
+  rmSync10(videoSourcesDir, { recursive: true, force: true });
+  if (existsSync20(stagedVideoFrames)) {
+    renameSync5(stagedVideoFrames, videoFramesDst);
   } else {
-    mkdirSync10(videoFramesDst, { recursive: true });
+    mkdirSync12(videoFramesDst, { recursive: true });
   }
-  if (existsSync19(finalCompiledDir)) rmSync9(finalCompiledDir, { recursive: true, force: true });
-  renameSync4(compiledDir, finalCompiledDir);
+  if (existsSync20(finalCompiledDir)) rmSync10(finalCompiledDir, { recursive: true, force: true });
+  renameSync5(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
     projectDir,
@@ -14762,7 +15271,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync10(join31(planDir, "meta"), { recursive: true });
+  mkdirSync12(join33(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -14771,8 +15280,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       sizeBytes
     }))
   );
-  writeFileSync7(
-    join31(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+  writeFileSync8(
+    join33(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -14846,11 +15355,11 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
-  const planAudioPath = join31(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult.hasAudio && existsSync19(audioResult.audioOutputPath)) {
-    renameSync4(audioResult.audioOutputPath, planAudioPath);
+  const planAudioPath = join33(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  if (audioResult.hasAudio && existsSync20(audioResult.audioOutputPath)) {
+    renameSync5(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio2 && existsSync19(planAudioPath)) {
+  if (chunksCarryAudio2 && existsSync20(planAudioPath)) {
     stageStarted = Date.now();
     const peak = await constrainAacTruePeak({
       audioPath: planAudioPath,
@@ -14860,6 +15369,16 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     });
     if (!peak.success) throw encoderFailureError("[plan] audio true-peak check failed", peak);
     logPlanStage(log, "audio-peak", stageStarted);
+    if (options.sliceChunkAudio) {
+      stageStarted = Date.now();
+      await writeChunkAudioSlices({
+        audioPath: planAudioPath,
+        planDir,
+        chunks,
+        fps: { num: config.fps, den: 1 }
+      });
+      logPlanStage(log, "audio-slices", stageStarted);
+    }
   }
   const ffmpegVersion = await readFfmpegVersion();
   const producerVersion = readProducerVersion();
@@ -14893,7 +15412,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     format: config.format
   };
   try {
-    rmSync9(workDir, { recursive: true, force: true });
+    rmSync10(workDir, { recursive: true, force: true });
   } catch (err) {
     log.warn("[plan] failed to remove temp work dir", {
       workDir,
@@ -15435,15 +15954,15 @@ function renderRequestFromDistributedConfig(input) {
 
 // ../producer/src/server.ts
 import {
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync11,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync13,
   statSync as statSync7,
-  mkdtempSync as mkdtempSync4,
-  writeFileSync as writeFileSync8,
-  rmSync as rmSync10,
-  createReadStream as createReadStream4
+  mkdtempSync as mkdtempSync5,
+  writeFileSync as writeFileSync9,
+  rmSync as rmSync11,
+  createReadStream as createReadStream5
 } from "fs";
-import { resolve as resolve9, dirname as dirname12, join as join34 } from "path";
+import { resolve as resolve9, dirname as dirname13, join as join36 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { parseArgs } from "util";
 import crypto from "crypto";
@@ -15453,15 +15972,15 @@ import { serve as serve2 } from "@hono/node-server";
 
 // ../producer/src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync20,
-  readFileSync as readFileSync10,
+  existsSync as existsSync21,
+  readFileSync as readFileSync11,
   statSync as statSync6,
-  openSync as openSync5,
+  openSync as openSync6,
   fstatSync as fstatSync4,
-  closeSync as closeSync6,
+  closeSync as closeSync7,
   constants as constants3
 } from "fs";
-import { resolve as resolve8, join as join32, relative as relative6, isAbsolute as isAbsolute3, sep as sep3 } from "path";
+import { resolve as resolve8, join as join34, relative as relative6, isAbsolute as isAbsolute3, sep as sep3 } from "path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -15490,7 +16009,7 @@ function pickEntryFile(files, preferredEntryFile) {
 function readEntryHtml(filePath) {
   let fd;
   try {
-    fd = openSync5(filePath, constants3.O_RDONLY | constants3.O_NONBLOCK);
+    fd = openSync6(filePath, constants3.O_RDONLY | constants3.O_NONBLOCK);
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
       return null;
@@ -15499,14 +16018,14 @@ function readEntryHtml(filePath) {
   }
   try {
     if (!fstatSync4(fd).isFile()) return null;
-    return readFileSync10(fd, "utf-8");
+    return readFileSync11(fd, "utf-8");
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve8(projectDir);
-  if (!existsSync20(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
+  if (!existsSync21(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -15528,7 +16047,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join32(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join34(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -15574,8 +16093,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 join33 } from "path";
-import { existsSync as existsSync21 } from "fs";
+import { dirname as dirname12, join as join35 } from "path";
+import { existsSync as existsSync22 } from "fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -15649,10 +16168,10 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname11(fileURLToPath6(import.meta.url));
-  const candidates = [join33(here, "healthWorkerThread.js"), join33(here, "healthWorkerThread.ts")];
+  const here = dirname12(fileURLToPath6(import.meta.url));
+  const candidates = [join35(here, "healthWorkerThread.js"), join35(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync21(candidate)) return candidate;
+    if (existsSync22(candidate)) return candidate;
   }
   return void 0;
 }
@@ -15790,8 +16309,8 @@ function buildRenderJobConfig(input, outputPath, log) {
 function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
-  const outputDir = dirname12(absoluteOutputPath);
-  if (!existsSync22(outputDir)) mkdirSync11(outputDir, { recursive: true });
+  const outputDir = dirname13(absoluteOutputPath);
+  if (!existsSync23(outputDir)) mkdirSync13(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -15831,11 +16350,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve9(candidate);
-  if (!existsSync22(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
+  if (!existsSync23(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync22(resolve9(absProjectDir, entry))) {
+  if (!existsSync23(resolve9(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -15860,8 +16379,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync4(join34(tempRoot, "producer-project-"));
-  writeFileSync8(join34(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync5(join36(tempRoot, "producer-project-"));
+  writeFileSync9(join36(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -15918,7 +16437,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync10(dir, { recursive: true, force: true });
+    rmSync11(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -15927,7 +16446,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync22(path) ? statSync7(path).size : 0;
+  return existsSync23(path) ? statSync7(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -16223,12 +16742,12 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync22(artifact.path)) {
+    if (!existsSync23(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
     const stats = statSync7(artifact.path);
-    return new Response(createReadStream4(artifact.path), {
+    return new Response(createReadStream5(artifact.path), {
       headers: {
         "content-type": "video/mp4",
         "content-length": String(stats.size),
@@ -16308,33 +16827,33 @@ if (isPublicServerEntry) {
 // ../producer/src/services/distributed/planV2.ts
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   lstatSync as lstatSync3,
-  mkdirSync as mkdirSync13,
-  mkdtempSync as mkdtempSync6,
-  readFileSync as readFileSync11,
-  readdirSync as readdirSync9,
-  renameSync as renameSync6,
-  rmSync as rmSync12,
+  mkdirSync as mkdirSync15,
+  mkdtempSync as mkdtempSync7,
+  readFileSync as readFileSync12,
+  readdirSync as readdirSync9,
+  renameSync as renameSync7,
+  rmSync as rmSync13,
   statSync as statSync9,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname14, isAbsolute as isAbsolute4, join as join37, relative as relative7, resolve as resolve10, sep as sep4 } from "path";
+import { dirname as dirname15, isAbsolute as isAbsolute4, join as join39, relative as relative7, resolve as resolve10, sep as sep4 } from "path";
 
 // ../producer/src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync5,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   linkSync as linkSync2,
-  mkdirSync as mkdirSync12,
-  mkdtempSync as mkdtempSync5,
-  renameSync as renameSync5,
-  rmSync as rmSync11,
+  mkdirSync as mkdirSync14,
+  mkdtempSync as mkdtempSync6,
+  renameSync as renameSync6,
+  rmSync as rmSync12,
   statSync as statSync8,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
-import { dirname as dirname13, join as join36 } from "path";
+import { dirname as dirname14, join as join38 } from "path";
 
 // ../producer/src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -16349,7 +16868,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // ../producer/src/services/distributed/planV2Layout.ts
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -16359,7 +16878,7 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join35(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join37(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // ../producer/src/services/distributed/planV2Publisher.ts
@@ -16394,13 +16913,13 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync23(destinationDir)) {
+    if (existsSync24(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
-    mkdirSync12(dirname13(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync5(join36(dirname13(destinationDir), ".plan-v2-publish-"));
+    mkdirSync14(dirname14(destinationDir), { recursive: true });
+    this.temporaryDir = mkdtempSync6(join38(dirname14(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -16411,10 +16930,10 @@ var LocalPlanV2ArtifactPublisher = class {
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync23(destinationPath)) return;
-    mkdirSync12(dirname13(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync5(join36(dirname13(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join36(stagingDir, "blob");
+    if (existsSync24(destinationPath)) return;
+    mkdirSync14(dirname14(destinationPath), { recursive: true });
+    const stagingDir = mkdtempSync6(join38(dirname14(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join38(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -16422,26 +16941,26 @@ var LocalPlanV2ArtifactPublisher = class {
         if (!canFallbackToCopy(error)) throw error;
         copyFileSync5(blob.sourcePath, temporaryPath);
       }
-      renameSync5(temporaryPath, destinationPath);
+      renameSync6(temporaryPath, destinationPath);
     } finally {
-      rmSync11(stagingDir, { recursive: true, force: true });
+      rmSync12(stagingDir, { recursive: true, force: true });
     }
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync23(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync24(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
       }
     }
-    writeFileSync9(join36(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
-    renameSync5(this.temporaryDir, this.destinationDir);
+    writeFileSync10(join38(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    renameSync6(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
     if (!this.#committed) {
-      rmSync11(this.temporaryDir, { recursive: true, force: true });
+      rmSync12(this.temporaryDir, { recursive: true, force: true });
     }
   }
 };
@@ -16460,7 +16979,7 @@ function isNonNegativeIntegerArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "number" && Number.isInteger(item) && item >= 0);
 }
 function readJsonFile(path, label) {
-  const contents = readFileSync11(path, "utf-8");
+  const contents = readFileSync12(path, "utf-8");
   try {
     const parsed = JSON.parse(contents);
     return parsed;
@@ -16480,7 +16999,7 @@ function listFiles(root) {
   const rootResolved = resolve10(root);
   function walk(dir) {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const absolutePath = join37(dir, entry.name);
+      const absolutePath = join39(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -16507,13 +17026,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join37(executionPlanDir, "video-frames");
-  if (!existsSync24(videoRoot)) return;
+  const videoRoot = join39(executionPlanDir, "video-frames");
+  if (!existsSync25(videoRoot)) return;
   for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join37(videoRoot, videoEntry.name);
+    const videoDir = join39(videoRoot, videoEntry.name);
     if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join37(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+      const sentinelPath = join39(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -16530,10 +17049,13 @@ function resolveExtractedVideoOutputDir(planDir, videoId) {
   }
   return outputDir;
 }
-function artifactTargets(path, videoDependencies, chunksCarryAudio2) {
+function artifactTargets(path, videoDependencies, chunkAudio) {
   if (isPlanAudioArtifactPath(path)) {
-    return chunksCarryAudio2 ? { chunks: "all", assembler: false } : { chunks: [], assembler: true };
+    if (chunkAudio === "none") return { chunks: [], assembler: true };
+    return { chunks: chunkAudio === "whole" ? "all" : [], assembler: false };
   }
+  const slice = chunkAudioSliceTarget(path);
+  if (slice !== null) return { chunks: slice === "all" ? "all" : [slice], assembler: false };
   if (path === "plan.json" || path === "meta/chunks.json" || path === "meta/encoder.json") {
     return { chunks: "all", assembler: true };
   }
@@ -16557,7 +17079,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join37(outputDir, String(index)));
+        framePaths2.set(index, join39(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
@@ -16565,7 +17087,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join37(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join39(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -16584,7 +17106,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join37(outputDir, frameName));
+      framePaths.set(frameIndex, join39(outputDir, frameName));
     }
     return {
       ...video,
@@ -16605,11 +17127,11 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join37(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync24(videosPath)) return;
+  const videosPath = join39(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync25(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
-    mkdirSync13(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
+    mkdirSync15(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
   }
 }
 function parseChunkSlices(value) {
@@ -16634,13 +17156,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  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)) {
+  const videoRoot = join39(executionPlanDir, "video-frames");
+  const hasExtractedFrames = existsSync25(videoRoot) && listFiles(videoRoot).length > 0;
+  const videosPath = join39(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync25(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join37(executionPlanDir, "meta", "chunks.json");
+  const chunksPath = join39(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -16680,871 +17202,526 @@ function collectChunkVideoDependencies(input) {
         const path = input.deferredSources.get(videoId) ?? relative7(resolve10(input.executionPlanDir), payload.framePath).split(sep4).join("/");
         assertSafeRelativePath(path);
         const indexes = mutable.get(path) ?? /* @__PURE__ */ new Set();
-        indexes.add(chunk.index);
-        mutable.set(path, indexes);
-      }
-    }
-  }
-  return new Map([...mutable].map(([path, indexes]) => [path, [...indexes].sort((a, b) => a - b)]));
-}
-function manifestPayload(manifest) {
-  return manifest;
-}
-function computeManifestHash(manifest) {
-  return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
-}
-function writeBlob(sourcePath, destinationPath) {
-  if (existsSync24(destinationPath)) return;
-  mkdirSync13(dirname14(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync6(join37(dirname14(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join37(temporaryDir, "blob");
-  try {
-    copyFileSync6(sourcePath, temporaryPath);
-    renameSync6(temporaryPath, destinationPath);
-  } finally {
-    rmSync12(temporaryDir, { recursive: true, force: true });
-  }
-}
-function publishBlobFor(absolutePath, digests) {
-  return {
-    sourcePath: absolutePath,
-    sha256: planFileSha256(absolutePath, digests),
-    sizeBytes: statSync9(absolutePath).size
-  };
-}
-async function putBlobs(publisher, blobs) {
-  await putTasks(blobs.map((blob) => () => publisher.putBlob(blob)));
-}
-async function putTasks(tasks) {
-  const uploadSlots = 32;
-  let next = 0;
-  let failure;
-  const upload = async () => {
-    while (!failure && next < tasks.length) {
-      const task = tasks[next++];
-      try {
-        await task();
-      } catch (reason) {
-        failure ??= { reason };
-      }
-    }
-  };
-  await Promise.all(Array.from({ length: uploadSlots }, upload));
-  if (failure) throw failure.reason;
-}
-function buildPlanV2Publication(executionPlanDir, digests) {
-  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");
-  if (!isRecord3(executionPlanValue)) {
-    throw new PlanV2IntegrityError("execution plan.json must be an object");
-  }
-  const executionPlan = executionPlanValue;
-  readPlanProtocolV1(executionPlan);
-  const executionPlanHash = executionPlan.planHash;
-  if (!isSha256(executionPlanHash)) {
-    throw new PlanV2IntegrityError("execution plan.json.planHash must be a sha256 digest");
-  }
-  const recomputedExecutionPlanHash = recomputePlanHashFromPlanDir(executionPlanDir, digests);
-  if (recomputedExecutionPlanHash !== executionPlanHash) {
-    throw new PlanV2IntegrityError(
-      `execution plan content fingerprint does not match plan.json.planHash: expected ${executionPlanHash}, recomputed ${recomputedExecutionPlanHash}`
-    );
-  }
-  const artifacts = [];
-  const blobs = /* @__PURE__ */ new Map();
-  const dimensions = executionPlan.dimensions;
-  if (!isRecord3(dimensions)) {
-    throw new PlanV2IntegrityError("execution plan.json.dimensions must be an object");
-  }
-  validateExtractionCacheCompleteSentinels(executionPlanDir);
-  const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  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;
-    const targets = artifactTargets(file.path, videoDependencyPlan.dependencies, chunksCarryAudio2);
-    if ((file.path.startsWith("video-frames/") || file.path.startsWith("video-sources/")) && targets.chunks !== "all" && targets.chunks.length === 0 && !targets.assembler) {
-      continue;
-    }
-    const blob = publishBlobFor(file.absolutePath, digests);
-    if (!blobs.has(blob.sha256)) blobs.set(blob.sha256, blob);
-    artifacts.push({
-      path: file.path,
-      sha256: blob.sha256,
-      sizeBytes: blob.sizeBytes,
-      ...targets
-    });
-  }
-  const storedBlobs = /* @__PURE__ */ new Map();
-  for (const remote of readPlanRemoteFiles(executionPlanDir)) {
-    const { sha256, sizeBytes } = remote;
-    if (!blobs.has(sha256)) storedBlobs.set(sha256, { sha256, sizeBytes });
-    artifacts.push({
-      ...remote,
-      ...artifactTargets(remote.path, videoDependencyPlan.dependencies, chunksCarryAudio2)
-    });
-  }
-  const base = {
-    protocol: PLAN_PROTOCOL_V2,
-    // Retain the established manifest key byte-for-byte. It now acts as the
-    // wire alias for the neutral local execution-plan hash.
-    sourcePlanV1Hash: executionPlanHash,
-    chunkCount: readPositiveInteger2(executionPlan.chunkCount, "chunkCount"),
-    totalFrames: readPositiveInteger2(executionPlan.totalFrames, "totalFrames"),
-    fps: readExecutionPlanFps(dimensions),
-    width: readPositiveInteger2(dimensions.width, "dimensions.width"),
-    height: readPositiveInteger2(dimensions.height, "dimensions.height"),
-    format: readDistributedFormat(dimensions.format),
-    ffmpegVersion: readString2(executionPlan.ffmpegVersion, "ffmpegVersion"),
-    producerVersion: readString2(executionPlan.producerVersion, "producerVersion"),
-    limitations: { videoDependencyMode: videoDependencyPlan.mode },
-    artifacts
-  };
-  return {
-    manifest: {
-      ...base,
-      planHash: computeManifestHash(base)
-    },
-    blobs: [...blobs.values()],
-    storedBlobs: [...storedBlobs.values()]
-  };
-}
-function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync24(planV2Dir)) {
-    throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
-  }
-  const publication = buildPlanV2Publication(executionPlanDir);
-  if (publication.storedBlobs.length > 0) {
-    throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
-  }
-  mkdirSync13(dirname14(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync6(join37(dirname14(planV2Dir), ".plan-v2-build-"));
-  try {
-    for (const blob of publication.blobs) {
-      writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
-    }
-    writeFileSync10(
-      join37(tempDir, "plan.json"),
-      canonicalJsonStringify(publication.manifest),
-      "utf-8"
-    );
-    renameSync6(tempDir, planV2Dir);
-    return resultFromManifest(planV2Dir, publication.manifest);
-  } catch (error) {
-    rmSync12(tempDir, { recursive: true, force: true });
-    throw error;
-  }
-}
-function createPlanV2FromV1(executionPlanDir, planV2Dir) {
-  return createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir);
-}
-async function publishPlanV2FromExecutionPlan(executionPlanDir, publisher) {
-  return publishExecutionPlan(executionPlanDir, publisher, {});
-}
-async function publishExecutionPlan(executionPlanDir, publisher, { digests, log = defaultLogger }) {
-  try {
-    let stageStarted = Date.now();
-    const publication = buildPlanV2Publication(executionPlanDir, digests);
-    logPlanStage(log, "publication", stageStarted);
-    if (publication.storedBlobs.length > 0 && !publisher.referenceStoredBlob) {
-      throw new PlanV2IntegrityError("this publisher cannot reference remote files");
-    }
-    stageStarted = Date.now();
-    await putTasks([
-      ...publication.blobs.map((blob) => () => publisher.putBlob(blob)),
-      ...publication.storedBlobs.map((blob) => () => publisher.referenceStoredBlob(blob))
-    ]);
-    logPlanStage(log, "upload", stageStarted);
-    stageStarted = Date.now();
-    await publisher.commitManifest(canonicalJsonStringify(publication.manifest));
-    logPlanStage(log, "manifest", stageStarted);
-    return publication.manifest;
-  } catch (error) {
-    try {
-      await publisher.abort();
-    } catch {
-    }
-    throw error;
-  }
-}
-async function publishPlanV2FromV1(executionPlanDir, publisher) {
-  return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
-}
-async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync6(join37(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
-  const digests = /* @__PURE__ */ new Map();
-  try {
-    await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
-      executionPlanSizeLimitBytes: Number.MAX_SAFE_INTEGER,
-      deferVideoExtraction: true,
-      remoteFiles: options.remoteFiles,
-      digests,
-      // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
-      whileAudioMixes: () => putBlobs(
-        publisher,
-        listFiles(join37(stagingRoot, "compiled")).map(
-          (file) => publishBlobFor(file.absolutePath, digests)
-        )
-      ),
-      chunksCarryAudio: options.chunksCarryAudio
-    });
-    return await publishExecutionPlan(stagingRoot, publisher, { digests, log: config.logger });
-  } catch (error) {
-    try {
-      await publisher.abort();
-    } catch {
-    }
-    throw error;
-  } finally {
-    rmSync12(stagingRoot, { recursive: true, force: true });
-  }
-}
-async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync24(planV2Dir)) {
-    throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
-  }
-  const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
-  const manifest = await planV2WithPublisher(projectDir, config, publisher, {
-    stagingParentDir: dirname14(planV2Dir)
-  });
-  return resultFromManifest(planV2Dir, manifest);
-}
-function resultFromManifest(planV2Dir, manifest) {
-  return {
-    planDir: planV2Dir,
-    manifestPath: join37(planV2Dir, "plan.json"),
-    planProtocol: PLAN_PROTOCOL_V2,
-    planHash: manifest.planHash,
-    sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
-    chunkCount: manifest.chunkCount,
-    totalFrames: manifest.totalFrames,
-    fps: manifest.fps,
-    width: manifest.width,
-    height: manifest.height,
-    format: manifest.format,
-    ffmpegVersion: manifest.ffmpegVersion,
-    producerVersion: manifest.producerVersion,
-    limitations: manifest.limitations
-  };
-}
-function getPlanV2ExecutionPlanHash(plan2) {
-  return plan2.sourcePlanV1Hash;
-}
-function readString2(value, field) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new PlanV2IntegrityError(`${field} must be a non-empty string`);
-  }
-  return value;
-}
-function readPositiveInteger2(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    throw new PlanV2IntegrityError(`${field} must be a positive integer`);
-  }
-  return value;
-}
-function readNonNegativeInteger2(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-    throw new PlanV2IntegrityError(`${field} must be a non-negative integer`);
+        indexes.add(chunk.index);
+        mutable.set(path, indexes);
+      }
+    }
   }
-  return value;
+  return new Map([...mutable].map(([path, indexes]) => [path, [...indexes].sort((a, b) => a - b)]));
 }
-function readSupportedFps(value) {
-  if (!isDistributedFps(value)) {
-    throw new PlanV2IntegrityError(
-      `dimensions.fpsNum must be one of ${DISTRIBUTED_FPS.join(", ")}`
-    );
-  }
-  return value;
+function manifestPayload(manifest) {
+  return manifest;
 }
-function readExecutionPlanFps(dimensions) {
-  const fpsDen = readPositiveInteger2(dimensions.fpsDen, "dimensions.fpsDen");
-  if (fpsDen !== 1) {
-    throw new PlanV2IntegrityError("dimensions.fpsDen must be 1 for plan v2");
-  }
-  return readSupportedFps(dimensions.fpsNum);
+function computeManifestHash(manifest) {
+  return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
-function readDistributedFormat(value) {
-  if (value !== "mp4" && value !== "mov" && value !== "webm" && value !== "png-sequence") {
-    throw new PlanV2IntegrityError("dimensions.format is unsupported");
+function writeBlob(sourcePath, destinationPath) {
+  if (existsSync25(destinationPath)) return;
+  mkdirSync15(dirname15(destinationPath), { recursive: true });
+  const temporaryDir = mkdtempSync7(join39(dirname15(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join39(temporaryDir, "blob");
+  try {
+    copyFileSync6(sourcePath, temporaryPath);
+    renameSync7(temporaryPath, destinationPath);
+  } finally {
+    rmSync13(temporaryDir, { recursive: true, force: true });
   }
-  return value;
 }
-function parseArtifact(value, index) {
-  if (!isRecord3(value)) throw new PlanV2IntegrityError(`artifacts[${index}] must be an object`);
-  const path = readString2(value.path, `artifacts[${index}].path`);
-  assertSafeRelativePath(path);
-  if (!isSha256(value.sha256)) {
-    throw new PlanV2IntegrityError(`artifacts[${index}].sha256 must be a lowercase sha256`);
-  }
-  const sizeBytes = value.sizeBytes;
-  if (typeof sizeBytes !== "number" || !Number.isInteger(sizeBytes) || sizeBytes < 0) {
-    throw new PlanV2IntegrityError(`artifacts[${index}].sizeBytes must be a non-negative integer`);
-  }
-  let chunks;
-  if (value.chunks === "all") {
-    chunks = "all";
-  } else if (isNonNegativeIntegerArray(value.chunks)) {
-    chunks = value.chunks;
-  } else {
-    throw new PlanV2IntegrityError(`artifacts[${index}].chunks is invalid`);
-  }
-  if (typeof value.assembler !== "boolean") {
-    throw new PlanV2IntegrityError(`artifacts[${index}].assembler must be boolean`);
-  }
+function publishBlobFor(absolutePath, digests) {
   return {
-    path,
-    sha256: value.sha256,
-    sizeBytes,
-    chunks,
-    assembler: value.assembler
-  };
-}
-function parsePlanV2Manifest(value) {
-  if (!isRecord3(value)) throw new PlanV2IntegrityError("manifest must be an object");
-  if (!isRecord3(value.protocol) || value.protocol.schemaVersion !== PLAN_PROTOCOL_V2.schemaVersion || value.protocol.artifactLayout !== PLAN_PROTOCOL_V2.artifactLayout || value.protocol.hashSchema !== PLAN_PROTOCOL_V2.hashSchema) {
-    throw new PlanV2IntegrityError("manifest protocol is not the supported v2 descriptor");
-  }
-  if (!isSha256(value.planHash) || !isSha256(value.sourcePlanV1Hash)) {
-    throw new PlanV2IntegrityError("manifest hashes must be lowercase sha256 digests");
-  }
-  if (!Array.isArray(value.artifacts)) throw new PlanV2IntegrityError("artifacts must be an array");
-  const artifacts = value.artifacts.map(parseArtifact);
-  const paths = /* @__PURE__ */ new Set();
-  for (const artifact of artifacts) {
-    if (paths.has(artifact.path))
-      throw new PlanV2IntegrityError(`duplicate artifact path: ${artifact.path}`);
-    paths.add(artifact.path);
-  }
-  if (!paths.has("plan.json"))
-    throw new PlanV2IntegrityError("manifest must include the local execution plan.json artifact");
-  if (!isRecord3(value.limitations) || value.limitations.videoDependencyMode !== "exact-rendered-frames" && value.limitations.videoDependencyMode !== "full-source-pack" && value.limitations.videoDependencyMode !== "source-extract") {
-    throw new PlanV2IntegrityError("unsupported video dependency mode");
-  }
-  const parsed = {
-    protocol: PLAN_PROTOCOL_V2,
-    planHash: value.planHash,
-    sourcePlanV1Hash: value.sourcePlanV1Hash,
-    chunkCount: readPositiveInteger2(value.chunkCount, "chunkCount"),
-    totalFrames: readPositiveInteger2(value.totalFrames, "totalFrames"),
-    fps: readSupportedFps(value.fps),
-    width: readPositiveInteger2(value.width, "width"),
-    height: readPositiveInteger2(value.height, "height"),
-    format: readDistributedFormat(value.format),
-    ffmpegVersion: readString2(value.ffmpegVersion, "ffmpegVersion"),
-    producerVersion: readString2(value.producerVersion, "producerVersion"),
-    limitations: { videoDependencyMode: value.limitations.videoDependencyMode },
-    artifacts
+    sourcePath: absolutePath,
+    sha256: planFileSha256(absolutePath, digests),
+    sizeBytes: statSync9(absolutePath).size
   };
-  const { planHash: _planHash, ...payload } = parsed;
-  const expectedHash = computeManifestHash(payload);
-  if (expectedHash !== parsed.planHash) {
-    throw new PlanV2IntegrityError("manifest integrity hash mismatch");
-  }
-  for (const [index, artifact] of parsed.artifacts.entries()) {
-    if (artifact.chunks !== "all" && artifact.chunks.some((chunkIndex) => chunkIndex >= parsed.chunkCount)) {
-      throw new PlanV2IntegrityError(`artifacts[${index}].chunks contains an out-of-range index`);
-    }
-  }
-  return parsed;
 }
-function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join37(planV2Dir, "plan.json");
-  if (!existsSync24(manifestPath)) {
-    throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
-  }
-  const value = readJsonFile(manifestPath, "v2 manifest");
-  return parsePlanV2Manifest(value);
+async function putBlobs(publisher, blobs) {
+  await putTasks(blobs.map((blob) => () => publisher.putBlob(blob)));
 }
-function listPlanV2ArtifactsForTarget(manifest, target) {
-  if (target.role === "chunk") {
-    if (!Number.isInteger(target.chunkIndex) || target.chunkIndex < 0 || target.chunkIndex >= manifest.chunkCount) {
-      throw new PlanV2IntegrityError(`chunkIndex ${String(target.chunkIndex)} is out of range`);
+async function putTasks(tasks) {
+  const uploadSlots = 32;
+  let next = 0;
+  let failure;
+  const upload = async () => {
+    while (!failure && next < tasks.length) {
+      const task = tasks[next++];
+      try {
+        await task();
+      } catch (reason) {
+        failure ??= { reason };
+      }
     }
-    return manifest.artifacts.filter(
-      (artifact) => artifact.chunks === "all" || artifact.chunks.some((chunkIndex) => chunkIndex === target.chunkIndex)
-    );
-  }
-  return manifest.artifacts.filter((artifact) => artifact.assembler);
+  };
+  await Promise.all(Array.from({ length: uploadSlots }, upload));
+  if (failure) throw failure.reason;
 }
-function verifyBlob(planV2Dir, artifact) {
-  const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync24(sourcePath)) {
-    throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
-  }
-  const stats = statSync9(sourcePath);
-  if (!stats.isFile() || stats.size !== artifact.sizeBytes) {
-    throw new PlanV2IntegrityError(`artifact size mismatch for ${artifact.path}`);
+function buildPlanV2Publication(executionPlanDir, digests) {
+  const executionPlanPath = join39(executionPlanDir, "plan.json");
+  if (!existsSync25(executionPlanPath)) {
+    throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
-  if (sha256File(sourcePath) !== artifact.sha256) {
-    throw new PlanV2IntegrityError(`artifact hash mismatch for ${artifact.path}`);
+  const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
+  if (!isRecord3(executionPlanValue)) {
+    throw new PlanV2IntegrityError("execution plan.json must be an object");
   }
-  return sourcePath;
-}
-function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}) {
-  if (existsSync24(destinationDir)) {
-    throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
+  const executionPlan = executionPlanValue;
+  readPlanProtocolV1(executionPlan);
+  const executionPlanHash = executionPlan.planHash;
+  if (!isSha256(executionPlanHash)) {
+    throw new PlanV2IntegrityError("execution plan.json.planHash must be a sha256 digest");
   }
-  const manifest = readPlanV2Manifest(planV2Dir);
-  const artifacts = listPlanV2ArtifactsForTarget(manifest, target);
-  const remoteSources = options.remoteSources ?? {};
-  assertRemoteSources(remoteSources, artifacts);
-  const audioArtifact = artifacts.find((artifact) => isPlanAudioArtifactPath(artifact.path));
-  const verified = artifacts.filter((artifact) => !Object.hasOwn(remoteSources, artifact.path)).map((artifact) => ({
-    artifact,
-    sourcePath: verifyBlob(planV2Dir, artifact)
-  }));
-  mkdirSync13(dirname14(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync6(join37(dirname14(destinationDir), ".plan-v2-materialize-"));
-  try {
-    for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join37(tempDir, ...artifact.path.split("/"));
-      mkdirSync13(dirname14(destinationPath), { recursive: true });
-      copyFileSync6(sourcePath, destinationPath);
-    }
-    if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
-    writeFileSync10(
-      join37(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
-      canonicalJsonStringify({
-        manifest,
-        target,
-        ...Object.keys(remoteSources).length > 0 ? { remoteSources } : {}
-      }),
-      "utf-8"
+  const recomputedExecutionPlanHash = recomputePlanHashFromPlanDir(executionPlanDir, digests);
+  if (recomputedExecutionPlanHash !== executionPlanHash) {
+    throw new PlanV2IntegrityError(
+      `execution plan content fingerprint does not match plan.json.planHash: expected ${executionPlanHash}, recomputed ${recomputedExecutionPlanHash}`
     );
-    renameSync6(tempDir, destinationDir);
-  } catch (error) {
-    rmSync12(tempDir, { recursive: true, force: true });
-    throw error;
   }
-  return {
-    planDir: destinationDir,
-    target,
-    planHash: manifest.planHash,
-    sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
-    artifactCount: artifacts.length,
-    sizeBytes: artifacts.reduce((sum2, artifact) => sum2 + artifact.sizeBytes, 0),
-    // 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 ? join37(destinationDir, audioArtifact.path) : null : null
-  };
-}
-function assertRemoteSources(remoteSources, artifacts) {
-  if (!isRecord3(remoteSources)) throw new PlanV2IntegrityError("remoteSources must be an object");
-  for (const [path, url] of Object.entries(remoteSources)) {
-    const artifact = artifacts.find((candidate) => candidate.path === path);
-    if (!artifact || !isPlanV2DeferredSourceArtifact(artifact)) {
-      throw new PlanV2IntegrityError(`remote source is not a selected deferred video: ${path}`);
-    }
-    if (typeof url !== "string" || !/^https?:\/\//.test(url)) {
-      throw new PlanV2IntegrityError(`remote source for ${path} must be an http(s) URL`);
+  const artifacts = [];
+  const blobs = /* @__PURE__ */ new Map();
+  const dimensions = executionPlan.dimensions;
+  if (!isRecord3(dimensions)) {
+    throw new PlanV2IntegrityError("execution plan.json.dimensions must be an object");
+  }
+  validateExtractionCacheCompleteSentinels(executionPlanDir);
+  const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
+  const encoder = readJsonFile(join39(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const files = listFiles(executionPlanDir);
+  const chunkAudio = !isRecord3(encoder) || encoder.chunksCarryAudio !== true ? "none" : files.some((file) => chunkAudioSliceTarget(file.path) !== null) ? "sliced" : "whole";
+  for (const file of files) {
+    if (isExtractionCacheCompleteSentinelPath(file.path)) continue;
+    const targets = artifactTargets(file.path, videoDependencyPlan.dependencies, chunkAudio);
+    if ((file.path.startsWith("video-frames/") || file.path.startsWith("video-sources/")) && targets.chunks !== "all" && targets.chunks.length === 0 && !targets.assembler) {
+      continue;
     }
+    const blob = publishBlobFor(file.absolutePath, digests);
+    if (!blobs.has(blob.sha256)) blobs.set(blob.sha256, blob);
+    artifacts.push({
+      path: file.path,
+      sha256: blob.sha256,
+      sizeBytes: blob.sizeBytes,
+      ...targets
+    });
   }
+  const storedBlobs = /* @__PURE__ */ new Map();
+  for (const remote of readPlanRemoteFiles(executionPlanDir)) {
+    const { sha256, sizeBytes } = remote;
+    if (!blobs.has(sha256)) storedBlobs.set(sha256, { sha256, sizeBytes });
+    artifacts.push({
+      ...remote,
+      ...artifactTargets(remote.path, videoDependencyPlan.dependencies, chunkAudio)
+    });
+  }
+  const base = {
+    protocol: PLAN_PROTOCOL_V2,
+    // Retain the established manifest key byte-for-byte. It now acts as the
+    // wire alias for the neutral local execution-plan hash.
+    sourcePlanV1Hash: executionPlanHash,
+    chunkCount: readPositiveInteger2(executionPlan.chunkCount, "chunkCount"),
+    totalFrames: readPositiveInteger2(executionPlan.totalFrames, "totalFrames"),
+    fps: readExecutionPlanFps(dimensions),
+    width: readPositiveInteger2(dimensions.width, "dimensions.width"),
+    height: readPositiveInteger2(dimensions.height, "dimensions.height"),
+    format: readDistributedFormat(dimensions.format),
+    ffmpegVersion: readString2(executionPlan.ffmpegVersion, "ffmpegVersion"),
+    producerVersion: readString2(executionPlan.producerVersion, "producerVersion"),
+    limitations: { videoDependencyMode: videoDependencyPlan.mode },
+    artifacts
+  };
+  return {
+    manifest: {
+      ...base,
+      planHash: computeManifestHash(base)
+    },
+    blobs: [...blobs.values()],
+    storedBlobs: [...storedBlobs.values()]
+  };
 }
-function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
-  return readValidatedPlanV2Materialization(planDir, expectedTarget)?.manifest ?? null;
-}
-function readValidatedPlanV2Materialization(planDir, expectedTarget) {
-  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");
+function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
+  if (existsSync25(planV2Dir)) {
+    throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
-  const target = marker.target;
-  if (target.role !== expectedTarget.role || expectedTarget.role === "chunk" && target.chunkIndex !== expectedTarget.chunkIndex) {
-    throw new PlanV2IntegrityError(
-      "materialization target does not match requested execution role"
-    );
+  const publication = buildPlanV2Publication(executionPlanDir);
+  if (publication.storedBlobs.length > 0) {
+    throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
   }
-  const manifest = parsePlanV2Manifest(marker.manifest);
-  const required = listPlanV2ArtifactsForTarget(manifest, expectedTarget);
-  const remoteSources = marker.remoteSources ?? {};
-  assertRemoteSources(remoteSources, required);
-  for (const artifact of required) {
-    if (Object.hasOwn(remoteSources, artifact.path)) continue;
-    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}`
-      );
-    }
-    if (sha256File(path) !== artifact.sha256) {
-      throw new PlanV2IntegrityError(`materialized artifact hash mismatch: ${artifact.path}`);
+  mkdirSync15(dirname15(planV2Dir), { recursive: true });
+  const tempDir = mkdtempSync7(join39(dirname15(planV2Dir), ".plan-v2-build-"));
+  try {
+    for (const blob of publication.blobs) {
+      writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
+    writeFileSync11(
+      join39(tempDir, "plan.json"),
+      canonicalJsonStringify(publication.manifest),
+      "utf-8"
+    );
+    renameSync7(tempDir, planV2Dir);
+    return resultFromManifest(planV2Dir, publication.manifest);
+  } catch (error) {
+    rmSync13(tempDir, { recursive: true, force: true });
+    throw error;
   }
-  return { manifest, remoteSources };
-}
-
-// ../producer/src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync9, rmSync as rmSync16 } from "fs";
-import { tmpdir as tmpdir5 } from "os";
-import { join as join41 } from "path";
-
-// ../producer/src/services/distributed/assemble.ts
-import {
-  cpSync as cpSync3,
-  existsSync as existsSync25,
-  mkdirSync as mkdirSync15,
-  mkdtempSync as mkdtempSync8,
-  readFileSync as readFileSync12,
-  readdirSync as readdirSync10,
-  renameSync as renameSync8,
-  rmSync as rmSync14,
-  statSync as statSync10,
-  writeFileSync as writeFileSync11
-} from "fs";
-import { dirname as dirname16, join as join39 } from "path";
-
-// ../producer/src/services/distributed/mp4Stitch.ts
-import {
-  createReadStream as createReadStream5,
-  createWriteStream,
-  mkdirSync as mkdirSync14,
-  mkdtempSync as mkdtempSync7,
-  renameSync as renameSync7,
-  rmSync as rmSync13
-} from "fs";
-import { open } from "fs/promises";
-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);
-  let bodyStart = at + 8;
-  if (size === 1) {
-    size = Number(src.readBigUInt64BE(off + 8));
-    bodyStart = at + 16;
-  }
-  if (size < 8 || at + size > limit) throw new Error(`[mp4Stitch] malformed box at ${at}`);
-  return { type: src.toString("latin1", off + 4, off + 8), start: at, bodyStart, end: at + size };
-}
-function childBoxes(buf, parent) {
-  const boxes = [];
-  for (let at = parent.bodyStart; at < parent.end; at = boxes.at(-1).end) {
-    boxes.push(boxAt(buf, at, at, parent.end));
-  }
-  return boxes;
 }
-function findChild(buf, parent, type) {
-  return childBoxes(buf, parent).find((box2) => box2.type === type);
+function createPlanV2FromV1(executionPlanDir, planV2Dir) {
+  return createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir);
 }
-function child(buf, parent, type) {
-  const found = findChild(buf, parent, type);
-  if (!found) throw new Error(`[mp4Stitch] ${parent.type} has no ${type}`);
-  return found;
+async function publishPlanV2FromExecutionPlan(executionPlanDir, publisher) {
+  return publishExecutionPlan(executionPlanDir, publisher, {});
 }
-var SCAN_BYTES = 64 * 1024;
-async function readMp4Layout(read) {
-  const found = /* @__PURE__ */ new Map();
-  let payload;
-  let buf = Buffer.alloc(0);
-  let bufAt = 0;
-  const load = async (start, end) => {
-    if (start >= bufAt && end <= bufAt + buf.length) return;
-    buf = await read(start, Math.max(end, start + SCAN_BYTES));
-    bufAt = start;
-  };
-  for (let at = 0; !(found.has("ftyp") && found.has("moov") && payload); ) {
-    await load(at, at + 16);
-    if (at + 8 > bufAt + buf.length) {
-      throw new Error(`[mp4Stitch] chunk needs ftyp, moov and mdat; found ${[...found.keys()]}`);
+async function publishExecutionPlan(executionPlanDir, publisher, { digests, log = defaultLogger }) {
+  try {
+    let stageStarted = Date.now();
+    const publication = buildPlanV2Publication(executionPlanDir, digests);
+    logPlanStage(log, "publication", stageStarted);
+    if (publication.storedBlobs.length > 0 && !publisher.referenceStoredBlob) {
+      throw new PlanV2IntegrityError("this publisher cannot reference remote files");
     }
-    const box2 = boxAt(buf, at - bufAt, at, Number.MAX_SAFE_INTEGER);
-    if (box2.type === "mdat") payload ??= box2;
-    if (box2.type === "ftyp" || box2.type === "moov") {
-      await load(at, box2.end);
-      found.set(box2.type, buf.subarray(at - bufAt, box2.end - bufAt));
+    stageStarted = Date.now();
+    await putTasks([
+      ...publication.blobs.map((blob) => () => publisher.putBlob(blob)),
+      ...publication.storedBlobs.map((blob) => () => publisher.referenceStoredBlob(blob))
+    ]);
+    logPlanStage(log, "upload", stageStarted);
+    stageStarted = Date.now();
+    await publisher.commitManifest(canonicalJsonStringify(publication.manifest));
+    logPlanStage(log, "manifest", stageStarted);
+    return publication.manifest;
+  } catch (error) {
+    try {
+      await publisher.abort();
+    } catch {
     }
-    at = box2.end;
+    throw error;
   }
-  const [ftyp, moov] = [found.get("ftyp"), found.get("moov")];
-  if (moov.length !== moovSize(moov)) throw new Error("[mp4Stitch] moov is cut off");
-  return { ftyp, moov, payloadStart: payload.bodyStart, payloadEnd: payload.end };
-}
-var moovSize = (moov) => boxAt(moov, 0, 0, Number.MAX_SAFE_INTEGER).end;
-function readTracks(moov) {
-  const root = boxAt(moov, 0, 0, moov.length);
-  return childBoxes(moov, root).filter((box2) => box2.type === "trak").map((trak) => readTrack(moov, trak));
 }
-function rows(buf, table, columns, countAt = 4) {
-  const count = buf.readUInt32BE(table.bodyStart + countAt);
-  const first = table.bodyStart + countAt + 4;
-  return Array.from(
-    { length: count },
-    (_, row) => Array.from(
-      { length: columns },
-      (_2, col) => buf.readUInt32BE(first + (row * columns + col) * 4)
-    )
-  );
+async function publishPlanV2FromV1(executionPlanDir, publisher) {
+  return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
-function readMediaTime(moov, trak) {
-  const edts = findChild(moov, trak, "edts");
-  if (!edts) return 0;
-  const elst = child(moov, edts, "elst");
-  const wide = moov[elst.bodyStart] === 1;
-  const entries = moov.readUInt32BE(elst.bodyStart + 4);
-  for (let i = 0, at = elst.bodyStart + 8; i < entries; i++, at += wide ? 20 : 12) {
-    const offset = at + (wide ? 8 : 4);
-    const mediaTime = wide ? Number(moov.readBigInt64BE(offset)) : moov.readInt32BE(offset);
-    if (mediaTime !== -1) return mediaTime;
+async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
+  const stagingRoot = mkdtempSync7(join39(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
+  const digests = /* @__PURE__ */ new Map();
+  try {
+    await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
+      executionPlanSizeLimitBytes: Number.MAX_SAFE_INTEGER,
+      deferVideoExtraction: true,
+      remoteFiles: options.remoteFiles,
+      digests,
+      // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
+      whileAudioMixes: () => putBlobs(
+        publisher,
+        listFiles(join39(stagingRoot, "compiled")).map(
+          (file) => publishBlobFor(file.absolutePath, digests)
+        )
+      ),
+      chunksCarryAudio: options.chunksCarryAudio,
+      sliceChunkAudio: true
+    });
+    return await publishExecutionPlan(stagingRoot, publisher, { digests, log: config.logger });
+  } catch (error) {
+    try {
+      await publisher.abort();
+    } catch {
+    }
+    throw error;
+  } finally {
+    rmSync13(stagingRoot, { recursive: true, force: true });
   }
-  return 0;
-}
-function readSizes(moov, stsz) {
-  const fixedSize = moov.readUInt32BE(stsz.bodyStart + 4);
-  if (!fixedSize) return rows(moov, stsz, 1, 8).map(([size]) => size);
-  return Array(moov.readUInt32BE(stsz.bodyStart + 8)).fill(fixedSize);
-}
-function readSync4(moov, stbl, sampleCount) {
-  const stss = findChild(moov, stbl, "stss");
-  if (!stss) return null;
-  const sync = Array(sampleCount).fill(false);
-  for (const [n] of rows(moov, stss, 1)) sync[n - 1] = true;
-  return sync;
-}
-function readChunkOffsets(moov, stbl) {
-  const stco = findChild(moov, stbl, "stco");
-  if (stco) return rows(moov, stco, 1).map(([offset]) => offset);
-  return rows(moov, child(moov, stbl, "co64"), 2).map(([hi, lo]) => hi * 2 ** 32 + lo);
 }
-function readSamplesPerChunk(moov, stbl, chunkCount) {
-  const stsc = rows(moov, child(moov, stbl, "stsc"), 3);
-  return stsc.flatMap(([firstChunk, perChunk, description], i) => {
-    if (description !== 1) throw new Error("[mp4Stitch] chunk uses more than one sample entry");
-    const nextFirst = stsc[i + 1]?.[0] ?? chunkCount + 1;
-    return Array(nextFirst - firstChunk).fill(perChunk);
+async function planV2(projectDir, config, planV2Dir) {
+  if (existsSync25(planV2Dir)) {
+    throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
+  }
+  const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
+  const manifest = await planV2WithPublisher(projectDir, config, publisher, {
+    stagingParentDir: dirname15(planV2Dir)
   });
+  return resultFromManifest(planV2Dir, manifest);
 }
-function readTrack(moov, trak) {
-  const mdia = child(moov, trak, "mdia");
-  const hdlr = child(moov, mdia, "hdlr");
-  const stbl = child(moov, child(moov, mdia, "minf"), "stbl");
-  if (findChild(moov, stbl, "ctts")) throw new Error("[mp4Stitch] chunk has ctts (B-frames)");
-  const stts = rows(moov, child(moov, stbl, "stts"), 2);
-  const durations = stts.flatMap(([n, delta]) => Array(n).fill(delta));
-  const sizes = readSizes(moov, child(moov, stbl, "stsz"));
-  const chunkOffsets = readChunkOffsets(moov, stbl);
-  const samplesPerChunk = readSamplesPerChunk(moov, stbl, chunkOffsets.length);
-  if (durations.length !== sizes.length || sum(samplesPerChunk) !== sizes.length) {
-    throw new Error("[mp4Stitch] sample tables disagree on the sample count");
-  }
-  const stsd = child(moov, stbl, "stsd");
+function resultFromManifest(planV2Dir, manifest) {
   return {
-    trak,
-    handler: moov.toString("latin1", hdlr.bodyStart + 8, hdlr.bodyStart + 12),
-    timescale: timescaleOf(moov, child(moov, mdia, "mdhd")),
-    mediaTime: readMediaTime(moov, trak),
-    stsd: moov.subarray(stsd.start, stsd.end),
-    durations,
-    sizes,
-    sync: readSync4(moov, stbl, sizes.length),
-    samplesPerChunk,
-    chunkOffsets
+    planDir: planV2Dir,
+    manifestPath: join39(planV2Dir, "plan.json"),
+    planProtocol: PLAN_PROTOCOL_V2,
+    planHash: manifest.planHash,
+    sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
+    chunkCount: manifest.chunkCount,
+    totalFrames: manifest.totalFrames,
+    fps: manifest.fps,
+    width: manifest.width,
+    height: manifest.height,
+    format: manifest.format,
+    ffmpegVersion: manifest.ffmpegVersion,
+    producerVersion: manifest.producerVersion,
+    limitations: manifest.limitations
   };
 }
-function sum(values) {
-  return values.reduce((total, value) => total + value, 0);
+function getPlanV2ExecutionPlanHash(plan2) {
+  return plan2.sourcePlanV1Hash;
 }
-function box(type, ...body) {
-  const header = Buffer.alloc(8);
-  header.writeUInt32BE(8 + sum(body.map((part) => part.length)));
-  header.write(type, 4, "latin1");
-  return Buffer.concat([header, ...body]);
+function readString2(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new PlanV2IntegrityError(`${field} must be a non-empty string`);
+  }
+  return value;
 }
-function fullBox(type, version, body) {
-  return box(type, Buffer.from([version, 0, 0, 0]), body);
+function readPositiveInteger2(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new PlanV2IntegrityError(`${field} must be a positive integer`);
+  }
+  return value;
 }
-function u32s(values) {
-  const buf = Buffer.alloc(values.length * 4);
-  values.forEach((value, i) => buf.writeUInt32BE(value, i * 4));
-  return buf;
+function readNonNegativeInteger2(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new PlanV2IntegrityError(`${field} must be a non-negative integer`);
+  }
+  return value;
 }
-function runs(values) {
-  const out = [];
-  for (const value of values) {
-    const last = out.at(-1);
-    if (last && last[1] === value) last[0]++;
-    else out.push([1, value]);
+function readSupportedFps(value) {
+  if (!isDistributedFps(value)) {
+    throw new PlanV2IntegrityError(
+      `dimensions.fpsNum must be one of ${DISTRIBUTED_FPS.join(", ")}`
+    );
   }
-  return out;
+  return value;
 }
-function rebuild(buf, parent, replace) {
-  const parts = childBoxes(buf, parent).map(
-    (box2) => replace[box2.type]?.(box2) ?? buf.subarray(box2.start, box2.end)
-  );
-  return box(parent.type, ...parts);
+function readExecutionPlanFps(dimensions) {
+  const fpsDen = readPositiveInteger2(dimensions.fpsDen, "dimensions.fpsDen");
+  if (fpsDen !== 1) {
+    throw new PlanV2IntegrityError("dimensions.fpsDen must be 1 for plan v2");
+  }
+  return readSupportedFps(dimensions.fpsNum);
 }
-var DURATION_AT = {
-  mvhd: [16, 24],
-  mdhd: [16, 24],
-  tkhd: [20, 28]
-};
-function withDuration(buf, target, duration) {
-  const copy = Buffer.from(buf.subarray(target.start, target.end));
-  const body = target.bodyStart - target.start;
-  const wide = copy[body] === 1;
-  const at = body + DURATION_AT[target.type][wide ? 1 : 0];
-  if (wide) copy.writeBigUInt64BE(BigInt(duration), at);
-  else if (duration <= 4294967295) copy.writeUInt32BE(duration, at);
-  else throw new Error(`[mp4Stitch] ${target.type} duration ${duration} needs a version 1 box`);
-  return copy;
+function readDistributedFormat(value) {
+  if (value !== "mp4" && value !== "mov" && value !== "webm" && value !== "png-sequence") {
+    throw new PlanV2IntegrityError("dimensions.format is unsupported");
+  }
+  return value;
 }
-function timescaleOf(buf, header) {
-  return buf.readUInt32BE(header.bodyStart + (buf[header.bodyStart] === 1 ? 20 : 12));
+function parseArtifact(value, index) {
+  if (!isRecord3(value)) throw new PlanV2IntegrityError(`artifacts[${index}] must be an object`);
+  const path = readString2(value.path, `artifacts[${index}].path`);
+  assertSafeRelativePath(path);
+  if (!isSha256(value.sha256)) {
+    throw new PlanV2IntegrityError(`artifacts[${index}].sha256 must be a lowercase sha256`);
+  }
+  const sizeBytes = value.sizeBytes;
+  if (typeof sizeBytes !== "number" || !Number.isInteger(sizeBytes) || sizeBytes < 0) {
+    throw new PlanV2IntegrityError(`artifacts[${index}].sizeBytes must be a non-negative integer`);
+  }
+  let chunks;
+  if (value.chunks === "all") {
+    chunks = "all";
+  } else if (isNonNegativeIntegerArray(value.chunks)) {
+    chunks = value.chunks;
+  } else {
+    throw new PlanV2IntegrityError(`artifacts[${index}].chunks is invalid`);
+  }
+  if (typeof value.assembler !== "boolean") {
+    throw new PlanV2IntegrityError(`artifacts[${index}].assembler must be boolean`);
+  }
+  return {
+    path,
+    sha256: value.sha256,
+    sizeBytes,
+    chunks,
+    assembler: value.assembler
+  };
 }
-function buildStbl(stsd, track) {
-  const stts = runs(track.durations);
-  const stsc = [];
-  let firstChunk = 1;
-  for (const [count, perChunk] of runs(track.samplesPerChunk)) {
-    stsc.push([firstChunk, perChunk, 1]);
-    firstChunk += count;
+function parsePlanV2Manifest(value) {
+  if (!isRecord3(value)) throw new PlanV2IntegrityError("manifest must be an object");
+  if (!isRecord3(value.protocol) || value.protocol.schemaVersion !== PLAN_PROTOCOL_V2.schemaVersion || value.protocol.artifactLayout !== PLAN_PROTOCOL_V2.artifactLayout || value.protocol.hashSchema !== PLAN_PROTOCOL_V2.hashSchema) {
+    throw new PlanV2IntegrityError("manifest protocol is not the supported v2 descriptor");
   }
-  const co64 = Buffer.alloc(4 + track.chunkOffsets.length * 8);
-  co64.writeUInt32BE(track.chunkOffsets.length);
-  track.chunkOffsets.forEach((offset, i) => co64.writeBigUInt64BE(BigInt(offset), 4 + i * 8));
-  const syncSamples = track.sync?.flatMap((isSync, i) => isSync ? [i + 1] : []) ?? null;
-  return box(
-    "stbl",
-    stsd,
-    fullBox("stts", 0, u32s([stts.length, ...stts.flat()])),
-    ...syncSamples ? [fullBox("stss", 0, u32s([syncSamples.length, ...syncSamples]))] : [],
-    fullBox("stsc", 0, u32s([stsc.length, ...stsc.flat()])),
-    fullBox("stsz", 0, u32s([0, track.sizes.length, ...track.sizes])),
-    fullBox("co64", 0, co64)
-  );
+  if (!isSha256(value.planHash) || !isSha256(value.sourcePlanV1Hash)) {
+    throw new PlanV2IntegrityError("manifest hashes must be lowercase sha256 digests");
+  }
+  if (!Array.isArray(value.artifacts)) throw new PlanV2IntegrityError("artifacts must be an array");
+  const artifacts = value.artifacts.map(parseArtifact);
+  const paths = /* @__PURE__ */ new Set();
+  for (const artifact of artifacts) {
+    if (paths.has(artifact.path))
+      throw new PlanV2IntegrityError(`duplicate artifact path: ${artifact.path}`);
+    paths.add(artifact.path);
+  }
+  if (!paths.has("plan.json"))
+    throw new PlanV2IntegrityError("manifest must include the local execution plan.json artifact");
+  if (!isRecord3(value.limitations) || value.limitations.videoDependencyMode !== "exact-rendered-frames" && value.limitations.videoDependencyMode !== "full-source-pack" && value.limitations.videoDependencyMode !== "source-extract") {
+    throw new PlanV2IntegrityError("unsupported video dependency mode");
+  }
+  const parsed = {
+    protocol: PLAN_PROTOCOL_V2,
+    planHash: value.planHash,
+    sourcePlanV1Hash: value.sourcePlanV1Hash,
+    chunkCount: readPositiveInteger2(value.chunkCount, "chunkCount"),
+    totalFrames: readPositiveInteger2(value.totalFrames, "totalFrames"),
+    fps: readSupportedFps(value.fps),
+    width: readPositiveInteger2(value.width, "width"),
+    height: readPositiveInteger2(value.height, "height"),
+    format: readDistributedFormat(value.format),
+    ffmpegVersion: readString2(value.ffmpegVersion, "ffmpegVersion"),
+    producerVersion: readString2(value.producerVersion, "producerVersion"),
+    limitations: { videoDependencyMode: value.limitations.videoDependencyMode },
+    artifacts
+  };
+  const { planHash: _planHash, ...payload } = parsed;
+  const expectedHash = computeManifestHash(payload);
+  if (expectedHash !== parsed.planHash) {
+    throw new PlanV2IntegrityError("manifest integrity hash mismatch");
+  }
+  for (const [index, artifact] of parsed.artifacts.entries()) {
+    if (artifact.chunks !== "all" && artifact.chunks.some((chunkIndex) => chunkIndex >= parsed.chunkCount)) {
+      throw new PlanV2IntegrityError(`artifacts[${index}].chunks contains an out-of-range index`);
+    }
+  }
+  return parsed;
 }
-var codecOf = (track) => track.stsd.toString("latin1", 20, 24);
-var sameTrack = (track, plan2) => track.handler === plan2.handler && track.timescale === plan2.timescale && codecOf(track) === codecOf(plan2);
-function planTracksOf(tracks, plan2, index) {
-  let next = 0;
-  const matched = plan2.map((planTrack) => {
-    const track = tracks[next];
-    if (track && sameTrack(track, planTrack)) return tracks[next++];
-    if (planTrack.handler === "soun") return null;
-    throw new Error(`[mp4Stitch] chunk ${index} tracks differ from chunk 0`);
-  });
-  if (next !== tracks.length)
-    throw new Error(`[mp4Stitch] chunk ${index} tracks differ from chunk 0`);
-  for (const track of tracks) {
-    if (track.handler === "vide" && track.mediaTime !== 0) {
-      throw new Error(`[mp4Stitch] chunk ${index} video starts at media time ${track.mediaTime}`);
+function readPlanV2Manifest(planV2Dir) {
+  const manifestPath = join39(planV2Dir, "plan.json");
+  if (!existsSync25(manifestPath)) {
+    throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
+  }
+  const value = readJsonFile(manifestPath, "v2 manifest");
+  return parsePlanV2Manifest(value);
+}
+function listPlanV2ArtifactsForTarget(manifest, target) {
+  if (target.role === "chunk") {
+    if (!Number.isInteger(target.chunkIndex) || target.chunkIndex < 0 || target.chunkIndex >= manifest.chunkCount) {
+      throw new PlanV2IntegrityError(`chunkIndex ${String(target.chunkIndex)} is out of range`);
     }
+    return manifest.artifacts.filter(
+      (artifact) => artifact.chunks === "all" || artifact.chunks.some((chunkIndex) => chunkIndex === target.chunkIndex)
+    );
   }
-  return matched;
+  return manifest.artifacts.filter((artifact) => artifact.assembler);
 }
-function buildStitchedHeader(layouts) {
-  const plan2 = readTracks(layouts[0].moov);
-  const chunks = layouts.map((layout, i) => planTracksOf(readTracks(layout.moov), plan2, i));
-  const payloadBases = [];
-  let payloadBytes = 0;
-  for (const layout of layouts) {
-    payloadBases.push(payloadBytes);
-    payloadBytes += layout.payloadEnd - layout.payloadStart;
+function verifyBlob(planV2Dir, artifact) {
+  const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
+  if (!existsSync25(sourcePath)) {
+    throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
+  }
+  const stats = statSync9(sourcePath);
+  if (!stats.isFile() || stats.size !== artifact.sizeBytes) {
+    throw new PlanV2IntegrityError(`artifact size mismatch for ${artifact.path}`);
+  }
+  if (sha256File(sourcePath) !== artifact.sha256) {
+    throw new PlanV2IntegrityError(`artifact hash mismatch for ${artifact.path}`);
+  }
+  return sourcePath;
+}
+function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}) {
+  if (existsSync25(destinationDir)) {
+    throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
+  }
+  const manifest = readPlanV2Manifest(planV2Dir);
+  const artifacts = listPlanV2ArtifactsForTarget(manifest, target);
+  const remoteSources = options.remoteSources ?? {};
+  assertRemoteSources(remoteSources, artifacts);
+  const audioArtifact = artifacts.find((artifact) => isPlanAudioArtifactPath(artifact.path));
+  const verified = artifacts.filter((artifact) => !Object.hasOwn(remoteSources, artifact.path)).map((artifact) => ({
+    artifact,
+    sourcePath: verifyBlob(planV2Dir, artifact)
+  }));
+  mkdirSync15(dirname15(destinationDir), { recursive: true });
+  const tempDir = mkdtempSync7(join39(dirname15(destinationDir), ".plan-v2-materialize-"));
+  try {
+    for (const { artifact, sourcePath } of verified) {
+      const destinationPath = join39(tempDir, ...artifact.path.split("/"));
+      mkdirSync15(dirname15(destinationPath), { recursive: true });
+      copyFileSync6(sourcePath, destinationPath);
+    }
+    if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
+    writeFileSync11(
+      join39(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      canonicalJsonStringify({
+        manifest,
+        target,
+        ...Object.keys(remoteSources).length > 0 ? { remoteSources } : {}
+      }),
+      "utf-8"
+    );
+    renameSync7(tempDir, destinationDir);
+  } catch (error) {
+    rmSync13(tempDir, { recursive: true, force: true });
+    throw error;
   }
-  const template = layouts[0].moov;
-  const root = boxAt(template, 0, 0, template.length);
-  const movieTimescale = timescaleOf(template, child(template, root, "mvhd"));
-  const buildMoov = (dataStart2) => {
-    const traks = plan2.map((track, t) => {
-      const parts = chunks.flatMap((tracks, chunk) => {
-        const part = tracks[t];
-        return part ? [{ ...part, chunk }] : [];
-      });
-      const merged = {
-        durations: parts.flatMap((part) => part.durations),
-        sizes: parts.flatMap((part) => part.sizes),
-        sync: parts.every((part) => !part.sync) ? null : parts.flatMap((part) => part.sync ?? part.sizes.map(() => true)),
-        samplesPerChunk: parts.flatMap((part) => part.samplesPerChunk),
-        chunkOffsets: parts.flatMap(
-          (part) => part.chunkOffsets.map((offset) => {
-            const i = part.chunk;
-            const { payloadStart, payloadEnd } = layouts[i];
-            if (offset < payloadStart || offset >= payloadEnd) {
-              throw new Error(`[mp4Stitch] chunk ${i} has samples outside its mdat`);
-            }
-            return offset - payloadStart + payloadBases[i] + dataStart2;
-          })
-        )
-      };
-      const mediaDuration = sum(merged.durations);
-      const shown = Math.round(
-        (mediaDuration - track.mediaTime) * movieTimescale / track.timescale
-      );
-      const elst = Buffer.alloc(24);
-      elst.writeUInt32BE(1);
-      elst.writeBigUInt64BE(BigInt(shown), 4);
-      elst.writeBigInt64BE(BigInt(track.mediaTime), 12);
-      elst.writeUInt32BE(65536, 20);
-      const edts = track.mediaTime ? box("edts", fullBox("elst", 1, elst)) : Buffer.alloc(0);
-      const trak = rebuild(template, track.trak, {
-        tkhd: (tkhd) => Buffer.concat([withDuration(template, tkhd, shown), edts]),
-        edts: () => Buffer.alloc(0),
-        mdia: (mdia) => rebuild(template, mdia, {
-          mdhd: (mdhd) => withDuration(template, mdhd, mediaDuration),
-          minf: (minf) => rebuild(template, minf, { stbl: () => buildStbl(track.stsd, merged) })
-        })
-      });
-      return { trak, shown };
-    });
-    let next = 0;
-    return rebuild(template, root, {
-      mvhd: (mvhd) => withDuration(template, mvhd, Math.max(...traks.map((t) => t.shown))),
-      trak: () => traks[next++].trak
-    });
+  return {
+    planDir: destinationDir,
+    target,
+    planHash: manifest.planHash,
+    sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
+    artifactCount: artifacts.length,
+    sizeBytes: artifacts.reduce((sum2, artifact) => sum2 + artifact.sizeBytes, 0),
+    // 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 ? join39(destinationDir, audioArtifact.path) : null : null
   };
-  const ftyp = layouts[0].ftyp;
-  const dataStart = ftyp.length + buildMoov(0).length + 16;
-  const mdat = Buffer.alloc(16);
-  mdat.writeUInt32BE(1);
-  mdat.write("mdat", 4, "latin1");
-  mdat.writeBigUInt64BE(BigInt(16 + payloadBytes), 8);
-  return Buffer.concat([ftyp, buildMoov(dataStart), mdat]);
 }
-function fileRange(path) {
-  return async (start, end) => {
-    const file = await open(path, "r", 384);
-    try {
-      const buf = Buffer.alloc(end - start);
-      const { bytesRead } = await file.read(buf, 0, buf.length, start);
-      return buf.subarray(0, bytesRead);
-    } finally {
-      await file.close();
+function assertRemoteSources(remoteSources, artifacts) {
+  if (!isRecord3(remoteSources)) throw new PlanV2IntegrityError("remoteSources must be an object");
+  for (const [path, url] of Object.entries(remoteSources)) {
+    const artifact = artifacts.find((candidate) => candidate.path === path);
+    if (!artifact || !isPlanV2DeferredSourceArtifact(artifact)) {
+      throw new PlanV2IntegrityError(`remote source is not a selected deferred video: ${path}`);
     }
-  };
+    if (typeof url !== "string" || !/^https?:\/\//.test(url)) {
+      throw new PlanV2IntegrityError(`remote source for ${path} must be an http(s) URL`);
+    }
+  }
 }
-async function copyPayload(path, layout, index, out) {
-  const { payloadStart, payloadEnd } = layout;
-  const payload = createReadStream5(path, { start: payloadStart, end: payloadEnd - 1 });
-  await pipeline(payload, out, { end: false });
-  if (payload.bytesRead !== payloadEnd - payloadStart) {
-    throw new Error(
-      `[mp4Stitch] chunk ${index} mdat holds ${payload.bytesRead} of ${payloadEnd - payloadStart} payload bytes`
+function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
+  return readValidatedPlanV2Materialization(planDir, expectedTarget)?.manifest ?? null;
+}
+function readValidatedPlanV2Materialization(planDir, expectedTarget) {
+  const markerPath = join39(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  if (!existsSync25(markerPath)) return null;
+  const marker = readJsonFile(markerPath, "materialization marker");
+  if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
+    throw new PlanV2IntegrityError("malformed materialization marker");
+  }
+  const target = marker.target;
+  if (target.role !== expectedTarget.role || expectedTarget.role === "chunk" && target.chunkIndex !== expectedTarget.chunkIndex) {
+    throw new PlanV2IntegrityError(
+      "materialization target does not match requested execution role"
     );
   }
-}
-async function writeStitchedMp4(chunkPaths, outputPath) {
-  const layouts = await Promise.all(chunkPaths.map((path) => readMp4Layout(fileRange(path))));
-  const header = buildStitchedHeader(layouts);
-  mkdirSync14(dirname15(outputPath), { recursive: true });
-  const workDir = mkdtempSync7(`${outputPath}.stitch-`);
-  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(join38(workDir, "out.mp4"), outputPath);
-  } finally {
-    out.destroy();
-    rmSync13(workDir, { recursive: true, force: true });
+  const manifest = parsePlanV2Manifest(marker.manifest);
+  const required = listPlanV2ArtifactsForTarget(manifest, expectedTarget);
+  const remoteSources = marker.remoteSources ?? {};
+  assertRemoteSources(remoteSources, required);
+  for (const artifact of required) {
+    if (Object.hasOwn(remoteSources, artifact.path)) continue;
+    const path = join39(planDir, ...artifact.path.split("/"));
+    if (!existsSync25(path) || statSync9(path).size !== artifact.sizeBytes) {
+      throw new PlanV2IntegrityError(
+        `materialized artifact missing or truncated: ${artifact.path}`
+      );
+    }
+    if (sha256File(path) !== artifact.sha256) {
+      throw new PlanV2IntegrityError(`materialized artifact hash mismatch: ${artifact.path}`);
+    }
   }
+  return { manifest, remoteSources };
 }
 
+// ../producer/src/services/distributed/planV2Execution.ts
+import { mkdtempSync as mkdtempSync9, rmSync as rmSync16 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join42 } from "path";
+
 // ../producer/src/services/distributed/assemble.ts
+import {
+  cpSync as cpSync3,
+  existsSync as existsSync26,
+  mkdirSync as mkdirSync16,
+  mkdtempSync as mkdtempSync8,
+  readFileSync as readFileSync13,
+  readdirSync as readdirSync10,
+  renameSync as renameSync8,
+  rmSync as rmSync14,
+  statSync as statSync10,
+  writeFileSync as writeFileSync12
+} from "fs";
+import { dirname as dirname16, join as join40 } from "path";
 function cfrRateControlArgs(locked) {
   const preset = getEncoderPreset(locked.quality ?? "standard", "mp4");
   if (locked.crf == null && locked.bitrate) {
@@ -17571,8 +17748,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync25(dirname16(outputPath))) {
-    mkdirSync15(dirname16(outputPath), { recursive: true });
+  if (!existsSync26(dirname16(outputPath))) {
+    mkdirSync16(dirname16(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync8(`${outputPath}.assemble-work-`);
   const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
@@ -17594,8 +17771,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join39(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync25(audioPath) ? audioPath : null;
+    const finalPath = join40(workDir, `output.${format}`);
+    const audio = audioPath !== null && existsSync26(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameSync8(finalPath, outputPath);
     log.info("[assemble] stage timings", {
@@ -17613,7 +17790,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync25(outputPath) ? statSync10(outputPath).size : 0;
+  const fileSize = existsSync26(outputPath) ? statSync10(outputPath).size : 0;
   return {
     outputPath,
     durationMs: Date.now() - start,
@@ -17622,25 +17799,25 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join39(planDir, "plan.json");
-  const chunksJsonPath = join39(planDir, "meta", "chunks.json");
-  if (!existsSync25(planJsonPath)) {
+  const planJsonPath = join40(planDir, "plan.json");
+  const chunksJsonPath = join40(planDir, "meta", "chunks.json");
+  if (!existsSync26(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
-  const plan2 = JSON.parse(readFileSync12(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync13(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync25(chunksJsonPath)) {
+  if (!existsSync26(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
-  const chunks = JSON.parse(readFileSync12(chunksJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
   if (chunkPaths.length !== chunks.length) {
     throw new Error(
       `[assemble] chunkPaths length (${chunkPaths.length}) does not match chunks.json length (${chunks.length}). Adapters must pass one path per chunk, ordered by index.`
     );
   }
   for (const path of chunkPaths) {
-    if (!existsSync25(path)) {
+    if (!existsSync26(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -17650,7 +17827,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 = join39(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join40(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = [
     ...videoInputArgs(ctx, chunkPaths),
     "-c:v",
@@ -17688,7 +17865,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join39(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join40(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -17728,9 +17905,9 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join39(workDir, "concat-list.txt");
+  const listPath = join40(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
-  writeFileSync11(listPath, `${body}
+  writeFileSync12(listPath, `${body}
 `, "utf-8");
   return ["-r", fpsArg, "-f", "concat", "-safe", "0", "-i", listPath];
 }
@@ -17761,9 +17938,9 @@ function chunksAreStitchedMp4(planDir, cfr) {
   return true;
 }
 function chunksCarryAudio(planDir) {
-  const encoderJsonPath = join39(planDir, "meta", "encoder.json");
-  if (!existsSync25(encoderJsonPath)) return false;
-  return JSON.parse(readFileSync12(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  if (!existsSync26(encoderJsonPath)) return false;
+  return JSON.parse(readFileSync13(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
 }
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
@@ -17771,11 +17948,11 @@ 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 = join39(planDir, "meta", "encoder.json");
-  if (!existsSync25(encoderJsonPath)) {
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
+  if (!existsSync26(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
-  const encoderJson = JSON.parse(readFileSync12(encoderJsonPath, "utf-8"));
+  const encoderJson = JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
   if (encoderJson.encoder === "libx265-software") {
     throw new Error(
       `[assemble] cfr=true is not yet supported with codec: "h265". The cfr re-encode pass uses libx264 and would silently transcode the h265 chunks. Either disable cfr or render with codec: "h264".`
@@ -17784,8 +17961,8 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync25(outputPath)) rmSync14(outputPath, { recursive: true, force: true });
-  mkdirSync15(outputPath, { recursive: true });
+  if (existsSync26(outputPath)) rmSync14(outputPath, { recursive: true, force: true });
+  mkdirSync16(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
     if (!statSync10(chunkDir).isDirectory()) {
@@ -17798,8 +17975,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       throw new Error(`[assemble] png-sequence chunk has no frames: ${chunkDir}`);
     }
     for (const frame of frames) {
-      const dst = join39(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join39(chunkDir, frame), dst);
+      const dst = join40(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join40(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -17808,14 +17985,14 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       `[assemble] png-sequence frame count mismatch: merged ${globalIdx} frames vs plan.totalFrames=${totalFrames}. Using on-disk count.`
     );
   }
-  if (audioPath !== null && existsSync25(audioPath)) {
-    const sidecar = join39(outputPath, MIXED_AUDIO_FILENAME);
+  if (audioPath !== null && existsSync26(audioPath)) {
+    const sidecar = join40(outputPath, MIXED_AUDIO_FILENAME);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
   for (const name of readdirSync10(outputPath)) {
     try {
-      fileSize += statSync10(join39(outputPath, name)).size;
+      fileSize += statSync10(join40(outputPath, name)).size;
     } catch {
     }
   }
@@ -17829,105 +18006,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // ../producer/src/services/distributed/renderChunk.ts
 import { randomBytes } from "crypto";
-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) {
-  const firstPacketAt = (frame) => Math.min(
-    grid.packetCount,
-    Math.max(
-      0,
-      Math.ceil(
-        (frame * fps.den * grid.sampleRate - grid.firstStart * fps.num) / (grid.packetSamples * fps.num)
-      )
-    )
-  );
-  const first = index === 0 ? 0 : firstPacketAt(chunks[index].startFrame);
-  const end = index === chunks.length - 1 ? grid.packetCount : firstPacketAt(chunks[index + 1].startFrame);
-  if (end <= first) return null;
-  const cutSeconds = (packet) => (grid.firstStart + packet * grid.packetSamples - grid.packetSamples / 2) / grid.sampleRate;
-  const seekSeconds = index === 0 ? null : cutSeconds(first);
-  const durationSeconds = end === grid.packetCount ? null : cutSeconds(end) - (seekSeconds ?? 0);
-  return { seekSeconds, durationSeconds, firstPacket: first, packetCount: end - first };
-}
-async function probeAacPacketGrid(audioPath) {
-  const probe = await runFfprobeJson([
-    "-v",
-    "error",
-    "-select_streams",
-    "a:0",
-    "-show_entries",
-    "stream=sample_rate,time_base,nb_frames:packet=pts,duration",
-    "-read_intervals",
-    "%+#1",
-    "-of",
-    "json",
-    "--",
-    audioPath
-  ]);
-  const stream = probe.streams?.[0] ?? {};
-  const packet = probe.packets?.[0] ?? {};
-  const sampleRate = Number(stream.sample_rate);
-  const [tbNum = NaN, tbDen = NaN] = String(stream.time_base).split("/").map(Number);
-  const toSamples = (ticks) => Number(ticks) * sampleRate * tbNum / tbDen;
-  const grid = {
-    sampleRate,
-    firstStart: toSamples(packet.pts),
-    packetSamples: toSamples(packet.duration),
-    packetCount: Number(stream.nb_frames)
-  };
-  const counts = [grid.sampleRate, grid.packetSamples, grid.packetCount];
-  if (!Number.isFinite(grid.firstStart) || !counts.every((n) => Number.isFinite(n) && n > 0)) {
-    throw new Error(`[chunkAudio] could not read the AAC packet grid: ${JSON.stringify(probe)}`);
-  }
-  return grid;
-}
-function chunkMuxArgs(input, cut) {
-  if (!cut) return ["-i", input.videoPath, "-map", "0:v:0"];
-  const seek = cut.seekSeconds === null ? [] : ["-ss", cut.seekSeconds.toFixed(6)];
-  const length = cut.durationSeconds === null ? [] : ["-t", cut.durationSeconds.toFixed(6)];
-  const exact = seek.length ? ["-copypriorss", "0"] : [];
-  return [
-    ...["-i", input.videoPath, ...seek, ...length, "-i", input.audioPath],
-    ...["-map", "0:v:0", "-map", "1:a:0", ...exact]
-  ];
-}
-async function muxChunkWithAudio(input) {
-  const grid = input.audioPath ? await probeAacPacketGrid(input.audioPath) : null;
-  const cut = grid ? audioCutForChunk(grid, input.chunks, input.chunkIndex, input.fps) : null;
-  const args = [...chunkMuxArgs(input, cut), "-c", "copy"];
-  appendRenderProvenanceArgs(args, input.outputPath);
-  args.push("-y", input.outputPath);
-  const result = await runFfmpeg(args, { signal: input.signal, timeout: input.timeoutMs });
-  if (!result.success) {
-    throw new Error(
-      `[chunkAudio] chunk mux failed: ${describeFfmpegFailure(result, input.timeoutMs)}`
-    );
-  }
-  const slice = input.chunks[input.chunkIndex];
-  const expected = { video: slice.endFrame - slice.startFrame };
-  if (cut) expected.audio = cut.packetCount;
-  const probe = await runFfprobeJson([
-    "-v",
-    "error",
-    "-count_packets",
-    "-show_entries",
-    "stream=codec_type,nb_read_packets",
-    "-of",
-    "json",
-    "--",
-    input.outputPath
-  ]);
-  for (const [type, count] of Object.entries(expected)) {
-    const packets = Number(probe.streams?.find((s) => s.codec_type === type)?.nb_read_packets ?? 0);
-    if (packets !== count) {
-      throw new Error(`[chunkAudio] ${type} packets in chunk ${packets}, expected ${count}`);
-    }
-  }
-}
-
-// ../producer/src/services/distributed/renderChunk.ts
+import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync14, readdirSync as readdirSync11, rmSync as rmSync15, writeFileSync as writeFileSync13 } from "fs";
+import { join as join41 } from "path";
 var LEGACY_DISTRIBUTED_VP9_CPU_USED = 2;
 function validatePlanVideosForChunk(value) {
   try {
@@ -17992,10 +18072,10 @@ async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBe
   return !await probe(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
 }
 function hashChunkOutput(outputPath, kind) {
-  if (kind === "file") return sha256Hex(readFileSync13(outputPath));
+  if (kind === "file") return sha256Hex(readFileSync14(outputPath));
   const entries = readdirSync11(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync13(join40(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync14(join41(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -18012,16 +18092,16 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join40(planDir, "plan.json");
-  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join40(planDir, "meta", "chunks.json");
-  if (!existsSync26(planJsonPath)) {
+  const planJsonPath = join41(planDir, "plan.json");
+  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join41(planDir, "meta", "chunks.json");
+  if (!existsSync27(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
     );
   }
-  const plan2 = JSON.parse(readFileSync13(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync14(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk);
   const planHashStarted = Date.now();
   const v2Materialization = readValidatedPlanV2Materialization(planDir, {
@@ -18031,20 +18111,20 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   const v2Manifest = v2Materialization?.manifest ?? null;
   const remoteSources = v2Materialization?.remoteSources ?? {};
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync26(required)) {
+    if (!existsSync27(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
       );
     }
   }
-  const encoder = JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
-  const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const encoder = JSON.parse(readFileSync14(encoderJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync14(chunksJsonPath, "utf-8"));
+  const videosJsonPath = join41(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync26(videosJsonPath)) {
+  if (existsSync27(videosJsonPath)) {
     try {
-      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync13(videosJsonPath, "utf-8")));
+      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync14(videosJsonPath, "utf-8")));
     } catch (err) {
       if (err instanceof RenderChunkValidationError) throw err;
       throw new RenderChunkValidationError(
@@ -18070,8 +18150,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       `[renderChunk] chunk ${chunkIndex} has non-positive frame count: ${framesInChunk}`
     );
   }
-  const compiledDir = join40(planDir, "compiled");
-  if (!existsSync26(compiledDir)) {
+  const compiledDir = join41(planDir, "compiled");
+  if (!existsSync27(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -18127,9 +18207,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       forceScreenshotExplicitlyOptedOut: !encoder.forceScreenshot
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
-    mkdirSync16(workDir, { recursive: true });
-    const framesDir = join40(workDir, "captured-frames");
-    mkdirSync16(framesDir, { recursive: true });
+    mkdirSync17(workDir, { recursive: true });
+    const framesDir = join41(workDir, "captured-frames");
+    mkdirSync17(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const deferredVideoFrames = planVideos ? await extractDeferredVideoFramesForChunk({
       planDir,
@@ -18175,7 +18255,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync13(join40(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync14(join41(compiledDir, "index.html"), "utf-8"),
       // The plan ships a deferred source only to chunks that show it; don't wait on the rest.
       skipReadinessVideoIds: deferredVideoFrames.filter((video) => video.framePaths.size === 0 || remoteVideoIds.has(video.videoId)).map((video) => video.videoId),
       videoMetadataHints: collectVideoMetadataHints(remoteVideos)
@@ -18309,7 +18389,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         },
         resetForScreenshotRetry: () => {
           rmSync15(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          mkdirSync16(framesDir, { recursive: true });
+          mkdirSync17(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
           job.framesRendered = 0;
@@ -18340,10 +18420,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
       const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
       if (isPngSequence) {
-        if (!existsSync26(outputChunkPath)) mkdirSync16(outputChunkPath, { recursive: true });
+        if (!existsSync27(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join40(outputChunkPath, "..");
-        if (!existsSync26(outDir)) mkdirSync16(outDir, { recursive: true });
+        const outDir = join41(outputChunkPath, "..");
+        if (!existsSync27(outDir)) mkdirSync17(outDir, { recursive: true });
       }
       const encodeStarted = Date.now();
       await runEncodeStage({
@@ -18386,9 +18466,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
         gopSize: framesInChunk
       });
       if (encoder.chunksCarryAudio) {
+        const audioScratchPath = `${outputChunkPath}.audio.m4a`;
         await muxChunkWithAudio({
           videoPath: videoOnlyPath,
-          audioPath: resolvePlanAudioPath(planDir),
+          audioPath: chunkAudioSource(planDir, chunkIndex, audioScratchPath),
           outputPath: outputChunkPath,
           chunks,
           chunkIndex,
@@ -18396,6 +18477,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
           timeoutMs: cfg.ffmpegProcessTimeout
         });
         rmSync15(videoOnlyPath, { force: true });
+        rmSync15(audioScratchPath, { force: true });
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
@@ -18434,7 +18516,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       producerVersion: plan2.producerVersion,
       ffmpegVersion
     };
-    writeFileSync12(perfPath, `${JSON.stringify(perfPayload, null, 2)}
+    writeFileSync13(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
       rmSync15(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
@@ -18466,8 +18548,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
 
 // ../producer/src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
-  const workRoot = mkdtempSync9(join41(tmpdir5(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join41(workRoot, "plan");
+  const workRoot = mkdtempSync9(join42(tmpdir5(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join42(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath);
@@ -18476,8 +18558,8 @@ async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync9(join41(tmpdir5(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join41(workRoot, "plan");
+  const workRoot = mkdtempSync9(join42(tmpdir5(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join42(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -18497,9 +18579,9 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
 }
 
 // ../producer/src/services/distributed/projectHash.ts
-import { readdirSync as readdirSync12, readFileSync as readFileSync14, realpathSync as realpathSync2, statSync as statSync11 } from "fs";
+import { readdirSync as readdirSync12, readFileSync as readFileSync15, realpathSync as realpathSync2, statSync as statSync11 } from "fs";
 import { createHash as createHash7 } from "crypto";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 
 export {
   createConsoleLogger,