@hyperframes/producer 0.8.173 → 0.8.175

package/dist/distributed.js

@@ -210,11 +210,11 @@ function getHfEarlyStub() {
 
 // src/services/fileServer.ts
 var readFileAsync = promisify(readFile);
-function isPathInside(child, parent, options = {}) {
+function isPathInside(child2, parent, options = {}) {
   const { resolveSymlinks = false, pathModule } = options;
   const resolveFn = pathModule?.resolve ?? resolve2;
   const separator = pathModule?.sep ?? sep;
-  const resolvedChild = resolveFn(child);
+  const resolvedChild = resolveFn(child2);
   const resolvedParent = resolveFn(parent);
   const normalizedChild = resolveSymlinks && existsSync2(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
   const normalizedParent = resolveSymlinks && existsSync2(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
@@ -3115,7 +3115,7 @@ async function embedLocalFontFaces(html, projectDir) {
               embeddedPaths.add(localPath);
               continue;
             }
-            dataUri = await toDataUri(font.buffer, ext);
+            dataUri = await toDataUri(font.buffer, ext, { compressToWoff2: false });
             dataUriByAbsolutePath.set(absPath, dataUri);
             defaultLogger.info(
               `[Compiler] Embedded local font file: ${localPath} (${(font.buffer.length / 1024).toFixed(0)} KB \u2192 data URI)`
@@ -4558,7 +4558,7 @@ var VideoExtractionStageError = class extends Error {
       affectedElementCount: failure.count
     }))
   )) {
-    const total = failures.reduce((sum, failure) => sum + failure.count, 0);
+    const total = failures.reduce((sum2, failure) => sum2 + failure.count, 0);
     const breakdown = failures.map((failure) => `${failure.kind}=${failure.count}`).join(",");
     super(`Video extraction failed for ${total} source(s) [${code}; ${breakdown}]`);
     this.code = code;
@@ -5822,6 +5822,16 @@ async function padOrTrimAudioToVideoFrameCount(input) {
     ...loweredDb > 0 ? { audioLoweredDb: loweredDb } : {}
   };
 }
+async function constrainAacTruePeak(input) {
+  const timeoutMs = input.timeoutMs ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
+  return enforceAacTruePeak({
+    audioPath: input.audioPath,
+    targetDurationSeconds: input.targetDurationSeconds,
+    signal: input.signal,
+    probeTruePeak: (audioPath, signal) => defaultProbeAudioTruePeakDbfs(audioPath, timeoutMs, signal),
+    runner: (args) => defaultRunFfmpeg(args, timeoutMs, input.signal)
+  });
+}
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
@@ -6170,7 +6180,7 @@ function countCapturedFrames(totalFrames, framesDir, frameExt) {
   return captured;
 }
 function countFrameRanges(ranges) {
-  return ranges.reduce((sum, range) => sum + (range.endFrame - range.startFrame), 0);
+  return ranges.reduce((sum2, range) => sum2 + (range.endFrame - range.startFrame), 0);
 }
 async function executeDiskCaptureWithAdaptiveRetry(options) {
   const attempts = [];
@@ -7207,15 +7217,15 @@ var ChunkExceedsWorkerTimeoutError = class extends Error {
 function resolveMaxParallelChunks(config, totalFrames, megapixels, log = defaultLogger) {
   if (config.maxParallelChunks !== void 0) return config.maxParallelChunks;
   const { workerTimeoutSeconds, workerConcurrency } = config;
-  const pinsChunking = config.chunkSize !== void 0 || config.targetChunkFrames !== void 0;
-  if (pinsChunking || workerTimeoutSeconds === void 0 && workerConcurrency === void 0) {
-    return DEFAULT_MAX_PARALLEL_CHUNKS;
-  }
-  const secondsPerFrame = ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels;
   const wave = Math.min(
     workerConcurrency ?? DEFAULT_MAX_PARALLEL_CHUNKS,
     MAX_PARALLEL_CHUNKS_CEILING
   );
+  const pinsChunking = config.chunkSize !== void 0 || config.targetChunkFrames !== void 0;
+  if (pinsChunking || workerTimeoutSeconds === void 0 && workerConcurrency === void 0) {
+    return wave;
+  }
+  const secondsPerFrame = ESTIMATED_SECONDS_PER_MEGAPIXEL_FRAME * megapixels;
   const minFramesPerChunk = Math.ceil(ESTIMATED_CHUNK_OVERHEAD_SECONDS / secondsPerFrame);
   const wide = Math.max(1, Math.min(wave, Math.floor(totalFrames / minFramesPerChunk)));
   if (workerTimeoutSeconds === void 0) return wide;
@@ -7232,7 +7242,7 @@ function resolveMaxParallelChunks(config, totalFrames, megapixels, log = default
   }
   if (needed > wave) {
     log.warn(
-      `[plan] ${needed} chunks are needed to keep each under the ${workerTimeoutSeconds} s worker time limit, but the plan assumes ${wave} workers at once, so the render runs in ${Math.ceil(needed / wave)} waves. Raise --concurrency to ${needed} to render in one wave (Lambda: hyperframes lambda deploy --concurrency ${needed}).`,
+      `[plan] ${needed} chunks are needed to keep each under the ${workerTimeoutSeconds} s worker time limit, but the plan assumes ${wave} workers at once, so the render runs in ${Math.ceil(needed / wave)} waves. Raise --concurrency to ${needed} to render in one wave (Lambda: hyperframes lambda deploy --concurrency ${needed}, or a higher account concurrency quota).`,
       { needed, workerConcurrency: wave, workerTimeoutSeconds }
     );
   }
@@ -7407,21 +7417,6 @@ function buildLockedRenderConfig(input) {
 function carriesChunkAudio(config, options) {
   return options.chunksCarryAudio === true && config.format === "mp4" && config.cfr !== true;
 }
-async function fitPlanAudioToFrames(audioPath, workDir, totalFrames, fps, run) {
-  const fittedPath = join18(workDir, "audio-fitted.m4a");
-  const result = await padOrTrimAudioToVideoFrameCount({
-    videoPath: audioPath,
-    probeVideoFrameInfo: async () => ({ frameCount: totalFrames, fpsNum: fps, fpsDen: 1 }),
-    audioPath,
-    outputPath: fittedPath,
-    signal: run.signal,
-    timeoutMs: run.timeoutMs
-  });
-  if (!result.success) {
-    throw encoderFailureError("[plan] audio pad/trim failed", result);
-  }
-  renameSync3(fittedPath, audioPath);
-}
 function resolveEncoderTriple(config) {
   if (config.format === "mp4") {
     return resolveMp4EncoderTriple(config.codec);
@@ -7719,13 +7714,15 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     "utf-8"
   );
   const digests = options.digests ?? /* @__PURE__ */ new Map();
+  const chunksCarryAudio2 = carriesChunkAudio(config, options);
+  const audioSeconds = chunksCarryAudio2 ? totalFrames / config.fps : probeResult.duration;
   stageStarted = Date.now();
   const [audioOutcome, overlapOutcome] = await Promise.allSettled([
     runAudioStage({
       projectDir,
       workDir,
       compiledDir: finalCompiledDir,
-      duration: probeResult.duration,
+      duration: audioSeconds,
       ffmpegProcessTimeout: cfg.ffmpegProcessTimeout,
       audioGain: cfg.audioGain,
       audios: composition.audios,
@@ -7755,12 +7752,16 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult.hasAudio && existsSync13(audioResult.audioOutputPath)) {
     renameSync3(audioResult.audioOutputPath, planAudioPath);
   }
-  const chunksCarryAudio2 = carriesChunkAudio(config, options);
   if (chunksCarryAudio2 && existsSync13(planAudioPath)) {
-    await fitPlanAudioToFrames(planAudioPath, workDir, totalFrames, config.fps, {
+    stageStarted = Date.now();
+    const peak = await constrainAacTruePeak({
+      audioPath: planAudioPath,
+      targetDurationSeconds: audioSeconds,
       signal: abortSignal,
       timeoutMs: cfg.ffmpegProcessTimeout
     });
+    if (!peak.success) throw encoderFailureError("[plan] audio true-peak check failed", peak);
+    logPlanStage(log, "audio-peak", stageStarted);
   }
   const ffmpegVersion = await readFfmpegVersion();
   const producerVersion = readProducerVersion();
@@ -7845,8 +7846,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     producerVersion
   };
 }
-async function plan(projectDir, config, planDir) {
-  const executionPlan = await buildLocalExecutionPlan(projectDir, config, planDir);
+async function plan(projectDir, config, planDir, options = {}) {
+  const executionPlan = await buildLocalExecutionPlan(projectDir, config, planDir, options);
   return {
     planDir: executionPlan.executionPlanDir,
     planProtocol: PLAN_PROTOCOL_V1,
@@ -8091,7 +8092,7 @@ function resolveExtractedVideoOutputDir(planDir, videoId) {
 }
 function artifactTargets(path, videoDependencies, chunksCarryAudio2) {
   if (isPlanAudioArtifactPath(path)) {
-    return { chunks: chunksCarryAudio2 ? "all" : [], assembler: true };
+    return chunksCarryAudio2 ? { chunks: "all", assembler: false } : { chunks: [], assembler: true };
   }
   if (path === "plan.json" || path === "meta/chunks.json" || path === "meta/encoder.json") {
     return { chunks: "all", assembler: true };
@@ -8652,7 +8653,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir) {
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
     artifactCount: artifacts.length,
-    sizeBytes: artifacts.reduce((sum, artifact) => sum + artifact.sizeBytes, 0),
+    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.
@@ -8689,24 +8690,24 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
 }
 
 // src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync6, rmSync as rmSync12 } from "node:fs";
+import { mkdtempSync as mkdtempSync7, rmSync as rmSync13 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
   cpSync as cpSync3,
   existsSync as existsSync16,
-  mkdirSync as mkdirSync11,
-  mkdtempSync as mkdtempSync5,
+  mkdirSync as mkdirSync12,
+  mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync10,
   readdirSync as readdirSync7,
-  renameSync as renameSync6,
-  rmSync as rmSync10,
+  renameSync as renameSync7,
+  rmSync as rmSync11,
   statSync as statSync7,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname11, join as join22 } from "node:path";
+import { dirname as dirname12, join as join23 } from "node:path";
 import {
   appendRenderProvenanceArgs,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -8717,6 +8718,353 @@ import {
   runFfmpeg as runFfmpeg5
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
+
+// src/services/distributed/mp4Stitch.ts
+import {
+  createReadStream as createReadStream4,
+  createWriteStream,
+  mkdirSync as mkdirSync11,
+  mkdtempSync as mkdtempSync5,
+  renameSync as renameSync6,
+  rmSync as rmSync10
+} from "node:fs";
+import { open } from "node:fs/promises";
+import { dirname as dirname11, join as join22 } from "node:path";
+import { finished, pipeline } from "node: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 child(buf, parent, type) {
+  const found = findChild(buf, parent, type);
+  if (!found) throw new Error(`[mp4Stitch] ${parent.type} has no ${type}`);
+  return found;
+}
+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()]}`);
+    }
+    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 };
+}
+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)
+    )
+  );
+}
+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 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 readSync2(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: readSync2(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);
+  mkdirSync11(dirname11(outputPath), { recursive: true });
+  const workDir = mkdtempSync5(`${outputPath}.stitch-`);
+  const out = createWriteStream(join22(workDir, "out.mp4"));
+  try {
+    out.write(header);
+    for (const [i, path] of chunkPaths.entries()) await copyPayload(path, layouts[i], i, out);
+    out.end();
+    await finished(out);
+    renameSync6(join22(workDir, "out.mp4"), outputPath);
+  } finally {
+    out.destroy();
+    rmSync10(workDir, { recursive: true, force: true });
+  }
+}
+
+// src/services/distributed/assemble.ts
 function cfrRateControlArgs(locked) {
   const preset = getEncoderPreset5(locked.quality ?? "standard", "mp4");
   if (locked.crf == null && locked.bitrate) {
@@ -8732,12 +9080,21 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   if (plan2.dimensions.format === "png-sequence") {
     return mergePngFrameDirs(chunkPaths, outputPath, plan2.totalFrames, audioPath, start);
   }
+  if (chunksAreStitchedMp4(planDir, cfr)) {
+    await writeStitchedMp4(chunkPaths, outputPath);
+    return {
+      outputPath,
+      durationMs: Date.now() - start,
+      framesEncoded: plan2.totalFrames,
+      fileSize: statSync7(outputPath).size
+    };
+  }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync16(dirname11(outputPath))) {
-    mkdirSync11(dirname11(outputPath), { recursive: true });
+  if (!existsSync16(dirname12(outputPath))) {
+    mkdirSync12(dirname12(outputPath), { recursive: true });
   }
-  const workDir = mkdtempSync5(`${outputPath}.assemble-work-`);
+  const workDir = mkdtempSync6(`${outputPath}.assemble-work-`);
   const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
   const stageMs = {};
   const ctx = {
@@ -8745,7 +9102,6 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
     format,
     fps,
     fpsArg: fpsToFfmpegArg3(fps),
-    chunkSeconds: chunksCarryAudio(planDir) ? plan2.chunks.map((chunk) => (chunk.endFrame - chunk.startFrame) * fps.den / fps.num) : null,
     signal: options?.abortSignal,
     timeout: resolveConfig4().ffmpegProcessTimeout,
     log,
@@ -8758,10 +9114,10 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join22(workDir, `output.${format}`);
+    const finalPath = join23(workDir, `output.${format}`);
     const audio = audioPath !== null && existsSync16(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
-    renameSync6(finalPath, outputPath);
+    renameSync7(finalPath, outputPath);
     log.info("[assemble] stage timings", {
       ...stageMs,
       chunks: chunkPaths.length,
@@ -8769,7 +9125,7 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
     });
   } finally {
     try {
-      rmSync10(workDir, { recursive: true, force: true });
+      rmSync11(workDir, { recursive: true, force: true });
     } catch (err) {
       log.warn("[assemble] failed to remove work dir", {
         workDir,
@@ -8786,8 +9142,8 @@ async function assemble(planDir, chunkPaths, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join22(planDir, "plan.json");
-  const chunksJsonPath = join22(planDir, "meta", "chunks.json");
+  const planJsonPath = join23(planDir, "plan.json");
+  const chunksJsonPath = join23(planDir, "meta", "chunks.json");
   if (!existsSync16(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
@@ -8808,13 +9164,13 @@ function readAssemblePlan(planDir, chunkPaths) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
-  return { ...plan2, chunks };
+  return plan2;
 }
 function videoInputArgs(ctx, videoSources) {
-  return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg, ctx.chunkSeconds);
+  return videoSources.length === 1 ? ["-i", videoSources[0]] : concatDemuxerInput(videoSources, ctx.workDir, ctx.fpsArg);
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join22(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join23(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = [
     ...videoInputArgs(ctx, chunkPaths),
     "-c:v",
@@ -8852,7 +9208,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join22(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join23(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -8891,15 +9247,10 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     throw encoderFailureError("[assemble] audio mux failed", muxResult);
   }
 }
-function concatDemuxerInput(chunkPaths, workDir, fpsArg, chunkSeconds) {
-  const listPath = join22(workDir, "concat-list.txt");
-  const head = chunkSeconds ? ["stream", "exact_stream_id 1"] : [];
-  const body = chunkPaths.map((path, i) => {
-    const line = `file '${path.replace(/'/g, "'\\''")}'`;
-    return chunkSeconds ? `${line}
-duration ${chunkSeconds[i].toFixed(6)}` : line;
-  });
-  writeFileSync8(listPath, `${[...head, ...body].join("\n")}
+function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
+  const listPath = join23(workDir, "concat-list.txt");
+  const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
+  writeFileSync8(listPath, `${body}
 `, "utf-8");
   return ["-r", fpsArg, "-f", "concat", "-safe", "0", "-i", listPath];
 }
@@ -8908,7 +9259,7 @@ async function probeJoinedFrameInfo(videoPaths, fps, signal) {
     videoPaths.map((path) => defaultProbeVideoFrameInfo(path, signal))
   );
   return {
-    frameCount: infos.reduce((sum, info) => sum + info.frameCount, 0),
+    frameCount: infos.reduce((sum2, info) => sum2 + info.frameCount, 0),
     fpsNum: fps.num,
     fpsDen: fps.den
   };
@@ -8922,8 +9273,15 @@ async function runAssembleFfmpeg(args, step, signal, timeout) {
     });
   }
 }
+function chunksAreStitchedMp4(planDir, cfr) {
+  if (!chunksCarryAudio(planDir)) return false;
+  if (cfr) {
+    throw new Error("[assemble] cfr=true cannot re-encode a plan whose mp4 chunks carry audio");
+  }
+  return true;
+}
 function chunksCarryAudio(planDir) {
-  const encoderJsonPath = join22(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join23(planDir, "meta", "encoder.json");
   if (!existsSync16(encoderJsonPath)) return false;
   return JSON.parse(readFileSync10(encoderJsonPath, "utf-8")).chunksCarryAudio === true;
 }
@@ -8933,7 +9291,7 @@ 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 = join22(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join23(planDir, "meta", "encoder.json");
   if (!existsSync16(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
@@ -8946,8 +9304,8 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync16(outputPath)) rmSync10(outputPath, { recursive: true, force: true });
-  mkdirSync11(outputPath, { recursive: true });
+  if (existsSync16(outputPath)) rmSync11(outputPath, { recursive: true, force: true });
+  mkdirSync12(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
     if (!statSync7(chunkDir).isDirectory()) {
@@ -8960,8 +9318,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 = join22(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join22(chunkDir, frame), dst);
+      const dst = join23(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join23(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -8971,13 +9329,13 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
     );
   }
   if (audioPath !== null && existsSync16(audioPath)) {
-    const sidecar = join22(outputPath, MIXED_AUDIO_FILENAME4);
+    const sidecar = join23(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
   for (const name of readdirSync7(outputPath)) {
     try {
-      fileSize += statSync7(join22(outputPath, name)).size;
+      fileSize += statSync7(join23(outputPath, name)).size;
     } catch {
     }
   }
@@ -8991,8 +9349,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync11, readdirSync as readdirSync8, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "node:fs";
-import { extname as extname4, join as join23 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, readFileSync as readFileSync11, readdirSync as readdirSync8, rmSync as rmSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { extname as extname4, join as join24 } from "node:path";
 import {
   assertSwiftShader,
   BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE3,
@@ -9198,7 +9556,7 @@ function frameNumberFromFileName(name) {
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
   const result = [];
   for (const v of videos) {
-    const outputDir = join23(planDir, "video-frames", v.videoId);
+    const outputDir = join24(planDir, "video-frames", v.videoId);
     if (!existsSync17(outputDir)) {
       throw new Error(
         `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
@@ -9217,7 +9575,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
       if (!frameName) continue;
       const frameNumber = indexMode === "sparse-v2" ? frameNumberFromFileName(frameName) : null;
       const frameIndex = frameNumber === null ? i : frameNumber - 1;
-      framePaths.set(frameIndex, join23(outputDir, frameName));
+      framePaths.set(frameIndex, join24(outputDir, frameName));
     }
     result.push({
       videoId: v.videoId,
@@ -9239,13 +9597,13 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
   return result;
 }
 function contiguousRuns(sortedIndexes) {
-  const runs = [];
+  const runs2 = [];
   for (const index of sortedIndexes) {
-    const last = runs[runs.length - 1];
+    const last = runs2[runs2.length - 1];
     if (last && last.firstFrame + last.frames === index) last.frames++;
-    else runs.push({ firstFrame: index, frames: 1 });
+    else runs2.push({ firstFrame: index, frames: 1 });
   }
-  return runs;
+  return runs2;
 }
 async function extractDeferredVideoFramesForChunk(input) {
   const deferred = input.planVideos.extracted.filter((video) => video.deferredRange);
@@ -9270,13 +9628,13 @@ async function extractDeferredVideoFramesForChunk(input) {
   }
   return Promise.all(
     deferred.map(async (video) => {
-      const outputDir = join23(input.outputRoot, video.videoId);
+      const outputDir = join24(input.outputRoot, video.videoId);
       const indexes = [...shown.get(video.videoId) ?? []].sort((a, b) => a - b);
       if (indexes.length === 0) {
         return { ...video, outputDir, framePaths: /* @__PURE__ */ new Map(), ownedByLookup: false };
       }
       const range = video.deferredRange;
-      const sourcePath = join23(input.planDir, ...range.sourcePath.split("/"));
+      const sourcePath = join24(input.planDir, ...range.sourcePath.split("/"));
       if (!existsSync17(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
@@ -9312,7 +9670,7 @@ function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync11(outputPath));
   const entries = readdirSync8(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync11(join23(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync11(join24(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -9329,9 +9687,9 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join23(planDir, "plan.json");
-  const encoderJsonPath = join23(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join23(planDir, "meta", "chunks.json");
+  const planJsonPath = join24(planDir, "plan.json");
+  const encoderJsonPath = join24(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join24(planDir, "meta", "chunks.json");
   if (!existsSync17(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -9355,7 +9713,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   }
   const encoder = JSON.parse(readFileSync11(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync11(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join23(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join24(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync17(videosJsonPath)) {
     try {
@@ -9385,7 +9743,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       `[renderChunk] chunk ${chunkIndex} has non-positive frame count: ${framesInChunk}`
     );
   }
-  const compiledDir = join23(planDir, "compiled");
+  const compiledDir = join24(planDir, "compiled");
   if (!existsSync17(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -9442,9 +9800,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       forceScreenshotExplicitlyOptedOut: !encoder.forceScreenshot
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
-    mkdirSync12(workDir, { recursive: true });
-    const framesDir = join23(workDir, "captured-frames");
-    mkdirSync12(framesDir, { recursive: true });
+    mkdirSync13(workDir, { recursive: true });
+    const framesDir = join24(workDir, "captured-frames");
+    mkdirSync13(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? createFrameLookupTable3(
       planVideos.videos,
@@ -9497,7 +9855,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       // `beginFrameTimeTicks` is host-independent. Only chunks ever set this.
       lockWarmupTicks: true,
       requiresWebGpu: compositionRequiresWebGpu3(
-        readFileSync11(join23(compiledDir, "index.html"), "utf-8")
+        readFileSync11(join24(compiledDir, "index.html"), "utf-8")
       )
     };
     const chunkWorkerCount = calculateOptimalWorkers2(framesInChunk, void 0, cfg);
@@ -9628,8 +9986,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
           return observedMode;
         },
         resetForScreenshotRetry: () => {
-          rmSync11(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          mkdirSync12(framesDir, { recursive: true });
+          rmSync12(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          mkdirSync13(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
           job.framesRendered = 0;
@@ -9660,10 +10018,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
       const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
       const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
       if (isPngSequence) {
-        if (!existsSync17(outputChunkPath)) mkdirSync12(outputChunkPath, { recursive: true });
+        if (!existsSync17(outputChunkPath)) mkdirSync13(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join23(outputChunkPath, "..");
-        if (!existsSync17(outDir)) mkdirSync12(outDir, { recursive: true });
+        const outDir = join24(outputChunkPath, "..");
+        if (!existsSync17(outDir)) mkdirSync13(outDir, { recursive: true });
       }
       const encodeStarted = Date.now();
       await runEncodeStage({
@@ -9715,7 +10073,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
           fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
           timeoutMs: cfg.ffmpegProcessTimeout
         });
-        rmSync11(videoOnlyPath, { force: true });
+        rmSync12(videoOnlyPath, { force: true });
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
@@ -9757,8 +10115,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
     writeFileSync9(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
-      rmSync11(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-      rmSync11(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync12(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync12(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     } catch (err) {
       log.warn("[renderChunk] failed to remove work dir", {
         workDir,
@@ -9786,18 +10144,18 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath) {
-  const workRoot = mkdtempSync6(join24(tmpdir2(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join24(workRoot, "plan");
+  const workRoot = mkdtempSync7(join25(tmpdir2(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join25(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath);
   } finally {
-    rmSync12(workRoot, { recursive: true, force: true });
+    rmSync13(workRoot, { recursive: true, force: true });
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync6(join24(tmpdir2(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join24(workRoot, "plan");
+  const workRoot = mkdtempSync7(join25(tmpdir2(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join25(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -9812,7 +10170,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync12(workRoot, { recursive: true, force: true });
+    rmSync13(workRoot, { recursive: true, force: true });
   }
 }
 
@@ -10061,7 +10419,7 @@ function validateIntDimension(field, value) {
 // src/services/distributed/projectHash.ts
 import { readdirSync as readdirSync9, readFileSync as readFileSync12 } from "node:fs";
 import { createHash as createHash6 } from "node:crypto";
-import { join as join25, relative as relative7 } from "node:path";
+import { join as join26, relative as relative7 } from "node:path";
 function hashProjectDir(projectDir) {
   const hash = createHash6("sha256");
   const files = [];
@@ -10070,7 +10428,7 @@ function hashProjectDir(projectDir) {
       (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
     )) {
       if (isRoot && PLAN_PROJECT_DIR_SKIP_SEGMENTS.has(entry.name)) continue;
-      const full = join25(dir, entry.name);
+      const full = join26(dir, entry.name);
       if (entry.isDirectory()) walk(full, false);
       else if (entry.isFile()) files.push(full);
     }
@@ -10127,6 +10485,8 @@ export {
   assemble,
   assembleV2,
   buildChunkSlices,
+  buildStitchedHeader,
+  chunksAreStitchedMp4,
   createPlanV2FromExecutionPlan,
   createPlanV2FromV1,
   getDistributedRenderCapabilities,
@@ -10136,11 +10496,13 @@ export {
   listPlanV2ArtifactsForTarget,
   materializePlanV2Target,
   measurePlanDirBytes,
+  muxChunkWithAudio,
   plan,
   planV2,
   planV2WithPublisher,
   publishPlanV2FromExecutionPlan,
   publishPlanV2FromV1,
+  readMp4Layout,
   readPlanProtocol,
   readPlanProtocolV1,
   readPlanV2Manifest,