@hyperframes/producer 0.8.186 → 0.8.189

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync8,
   readdirSync as readdirSync5,
-  rmSync as rmSync9,
+  rmSync as rmSync10,
   statSync as statSync6,
   writeFileSync as writeFileSync5,
   copyFileSync as copyFileSync4,
@@ -55,7 +55,7 @@ import {
   augmentProtocolTimeoutError,
   augmentPageNavigationTimeoutError
 } from "@hyperframes/engine";
-import { join as join26, dirname as dirname10, resolve as resolve7 } from "path";
+import { join as join25, dirname as dirname10, resolve as resolve7 } from "path";
 import { totalmem as totalmem2 } from "node:os";
 import { randomUUID } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -4336,6 +4336,7 @@ function computeSegmentPlanHash(input) {
     input.useGpu ? "gpu" : "cpu",
     `${input.outputWidth}x${input.outputHeight}`,
     input.motionBlur,
+    input.pageMotionBlur ?? "",
     input.captureQuality === void 0 ? "" : String(input.captureQuality)
   ].join(" ");
   return createHash2("sha256").update(ordered).digest("hex").slice(0, 16);
@@ -7193,7 +7194,9 @@ async function discoverMediaFromBrowser(page) {
       const tagName = isImage ? "image" : htmlEl.tagName.toLowerCase() === "video" ? "video" : "audio";
       const id = htmlEl.getAttribute("data-hf-render-id") || htmlEl.id || (isImage ? autoImageIds.get(htmlEl) : void 0);
       if (!id) return;
-      const src = htmlEl.currentSrc || htmlEl.src || htmlEl.getAttribute("src") || "";
+      const ownSrc = htmlEl.getAttribute("src");
+      const blankSrc = ownSrc !== null && ownSrc.trim() === "" && !htmlEl.querySelector("source[src]");
+      const src = blankSrc ? "" : htmlEl.currentSrc || htmlEl.src || ownSrc || "";
       const start = parseFloat(htmlEl.getAttribute("data-start") || "0");
       const endRaw = htmlEl.getAttribute("data-end");
       const durationRaw = htmlEl.getAttribute("data-duration");
@@ -8696,771 +8699,1209 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
+import { rmSync as rmSync8 } from "node:fs";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
   processCompositionAudio
 } from "@hyperframes/engine";
-function triggerFirst(failures, trigger) {
-  return [trigger, ...(failures ?? []).filter((failure) => failure !== trigger)];
+
+// src/services/render/audioPadTrim.ts
+import { spawn } from "node:child_process";
+import { mkdtempSync as mkdtempSync3, renameSync as renameSync4, rmSync as rmSync7 } from "node:fs";
+import { dirname as dirname7, join as join17 } from "node:path";
+import {
+  DEFAULT_CONFIG,
+  describeFfmpegFailure as describeFfmpegFailure2,
+  encodeAac,
+  extractAudioMetadata as extractAudioMetadata3,
+  getFfprobeBinary,
+  ManagedChildProcess,
+  runFfmpeg as runFfmpeg4,
+  trackChildProcess
+} from "@hyperframes/engine";
+import { redactKnownPaths, redactTelemetryString as redactTelemetryString3 } from "@hyperframes/core";
+
+// src/services/render/audioTruePeak.ts
+import {
+  aacSegmentCount,
+  describeFfmpegFailure,
+  extractAudioMetadata as extractAudioMetadata2,
+  runFfmpeg as runFfmpeg3
+} from "@hyperframes/engine";
+var toDbfs = (token) => token.toLowerCase() === "-inf" ? Number.NEGATIVE_INFINITY : Number(token);
+function checkedDbfs(value) {
+  if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY) {
+    throw new Error("[audioTruePeak] FFmpeg did not report AAC true peak");
+  }
+  return value;
 }
-async function runAudioStage(input) {
-  const {
-    projectDir,
-    workDir,
-    compiledDir,
-    duration,
-    ffmpegProcessTimeout,
-    audioGain,
-    audios,
-    masterFxChain,
-    urlByAbsentLocalPath,
-    keepEncoderInputAt,
-    abortSignal,
-    assertNotAborted,
-    log
-  } = input;
-  const stage3Start = Date.now();
-  const audioOutputPath = join17(workDir, MIXED_AUDIO_FILENAME);
-  let hasAudio = false;
-  let audioError;
-  let audioFailures;
-  if (audios.length > 0) {
-    let audioResult;
-    try {
-      audioResult = await processCompositionAudio(
-        audios,
-        projectDir,
-        join17(workDir, "audio-work"),
-        audioOutputPath,
-        duration,
-        abortSignal,
-        {
-          ffmpegProcessTimeout,
-          audioGain,
-          masterFxChain,
-          urlByAbsentLocalPath,
-          keepEncoderInputAt
-        },
-        compiledDir
-      );
-    } catch (err) {
-      assertNotAborted();
-      const detail = err instanceof Error ? err.message : String(err);
-      return {
-        audioOutputPath,
-        hasAudio: false,
-        audioProcessMs: Date.now() - stage3Start,
-        audioError: detail,
-        // Synthesised rather than left undefined. The warning policy reads
-        // owner, retryability, reason and stage off this list, so reporting the
-        // FATAL failure — the one that took the whole mix down — with an empty
-        // one gave it strictly less classification than a single dropped track
-        // gets, which is the opposite of what this stage exists to do.
-        // "internal" is the honest bucket: the stages enumerate ffmpeg steps
-        // and this is the FX render, which is none of them.
-        audioFailures: [
-          {
-            stage: "internal",
-            reason: "internal",
-            owner: "system",
-            retryable: false,
-            detail: detail.slice(0, 2e3)
-          }
-        ]
-      };
-    }
-    assertNotAborted();
-    const interrupted = audioResult.failures?.find(
-      (failure) => failure.reason === "external_interruption"
-    );
-    if (interrupted) {
-      throw encoderFailureError("Audio processing failed", {
-        error: interrupted.detail,
-        failureReason: "external_interruption",
-        audioFailures: audioFailureDiagnostics(triggerFirst(audioResult.failures, interrupted))
-      });
-    }
-    hasAudio = audioResult.success;
-    audioFailures = audioResult.failures;
-    if (!hasAudio) {
-      audioError = audioResult.error ?? "audio mix failed for an unknown reason";
-      for (const failure of audioResult.failures ?? []) {
-        log?.warn("Audio track failed", {
-          elementId: failure.elementId,
-          stage: failure.stage,
-          reason: failure.reason,
-          owner: failure.owner,
-          retryable: failure.retryable,
-          detail: failure.detail
-        });
-      }
+async function scanTruePeak(audioPath, trim, timeoutMs, signal) {
+  let firstBlock;
+  let laterBlocks = Number.NEGATIVE_INFINITY;
+  let partialLine = "";
+  const readLines = (chunk) => {
+    const lines = (partialLine + chunk).split(/\r|\n/);
+    partialLine = lines.pop() ?? "";
+    for (const line of lines) {
+      const ftpk = /FTPK:([^d]*)dBFS/.exec(line)?.[1];
+      if (!ftpk) continue;
+      const block = Math.max(...ftpk.trim().split(/\s+/).map(toDbfs));
+      if (firstBlock === void 0) firstBlock = block;
+      else laterBlocks = Math.max(laterBlocks, block);
     }
+  };
+  const result = await runFfmpeg3(
+    ["-i", audioPath, "-map", "0:a:0", "-vn", "-af", `${trim}ebur128=peak=true`, "-f", "null", "-"],
+    { signal, timeout: timeoutMs, onStderr: readLines }
+  );
+  if (!result.success) {
+    throw new Error(`[audioTruePeak] ${describeFfmpegFailure(result, timeoutMs)}`);
   }
-  const audioProcessMs = Date.now() - stage3Start;
+  const summary = [...result.stderr.matchAll(/^\s*Peak:\s*([+-]?(?:[\d.]+|inf)) dBFS$/gim)];
   return {
-    audioOutputPath,
-    hasAudio,
-    audioProcessMs,
-    audioError,
-    audioFailures
+    peak: checkedDbfs(toDbfs(summary.at(-1)?.[1] ?? "nan")),
+    firstBlock: checkedDbfs(firstBlock ?? Number.NEGATIVE_INFINITY),
+    laterBlocks: checkedDbfs(laterBlocks)
   };
 }
-
-// src/services/render/stages/captureStage.ts
-import { existsSync as existsSync12, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
-import { join as join18 } from "node:path";
-import {
-  classifyCaptureFailure as classifyCaptureFailure2,
-  frameFileExtension,
-  captureFrame,
-  captureFrameToBufferPipelined as captureFrameToBufferPipelined2,
-  verifyDiskDrawElementSamples,
-  writeCapturedFrame,
-  closeCaptureSession as closeCaptureSession5,
-  completeDeferredDrawElementInit as completeDeferredDrawElementInit3,
-  createCaptureSession as createCaptureSession5,
-  getCapturePerfSummary as getCapturePerfSummary3,
-  initializeSession as initializeSession5,
-  prepareCaptureSessionForReuse as prepareCaptureSessionForReuse3
-} from "@hyperframes/engine";
-function shouldAllowAdaptiveCaptureRetry(workerCount, _explicitlyConfigured) {
-  return workerCount > 1;
+async function measureTruePeakDbfs(audioPath, options) {
+  const { timeoutMs, signal } = options;
+  const wholeFile = async () => (await scanTruePeak(audioPath, "", timeoutMs, signal)).peak;
+  const { durationSeconds, sampleRate } = await extractAudioMetadata2(audioPath, { signal });
+  const block = 4800;
+  const count = sampleRate === 48e3 && Number.isFinite(durationSeconds) ? aacSegmentCount(durationSeconds) : 1;
+  if (count === 1) return wholeFile();
+  const cut = (k) => k * Math.floor(durationSeconds * 10 / count) * block;
+  const peers = new AbortController();
+  const segmentSignal = signal ? AbortSignal.any([signal, peers.signal]) : peers.signal;
+  const scans = await Promise.all(
+    Array.from({ length: count }, (_, k) => {
+      const start = k === 0 ? 0 : cut(k) - block;
+      const end = k === count - 1 ? "" : `:end_sample=${cut(k + 1)}`;
+      return scanTruePeak(
+        audioPath,
+        `atrim=start_sample=${start}${end},`,
+        timeoutMs,
+        segmentSignal
+      );
+    })
+  ).catch((error) => {
+    peers.abort();
+    throw error;
+  });
+  const last = scans[count - 1];
+  const counted = Math.max(scans[0].peak, ...scans.slice(1).map((scan) => scan.laterBlocks));
+  if (last.peak > last.firstBlock || last.peak <= counted) return Math.max(counted, last.peak);
+  return wholeFile();
 }
-var JPEG_RAW_RGBA_DIVISOR = 8;
-var HIGH_QUALITY_JPEG_RAW_RGBA_DIVISOR = 4;
-var DISK_PROJECTION_SAMPLE_FRAMES = 10;
-function estimateDiskCaptureBytes(totalFrames, captureOptions) {
-  const scale = captureOptions.deviceScaleFactor ?? 1;
-  const outputWidth = Math.ceil(captureOptions.width * scale);
-  const outputHeight = Math.ceil(captureOptions.height * scale);
-  const rawBytes = Math.ceil(totalFrames) * outputWidth * outputHeight * 4;
-  return frameFileExtension(captureOptions.format) === "jpg" ? Math.ceil(
-    rawBytes / ((captureOptions.quality ?? 80) > 80 ? HIGH_QUALITY_JPEG_RAW_RGBA_DIVISOR : JPEG_RAW_RGBA_DIVISOR)
-  ) : rawBytes;
+
+// src/services/render/audioPadTrim.ts
+var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
+var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
+var AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB = 0.5;
+var MAX_TRUE_PEAK_CORRECTION_PASSES = 3;
+function aacTruePeakCorrectionFilter(targetDurationSeconds, attenuationDb) {
+  return `volume=${attenuationDb.toFixed(3)}dB,apad,atrim=0:${formatSeconds(targetDurationSeconds)}`;
 }
-function freeDiskBytesAt(path) {
-  try {
-    const stat = statfsSync2(path);
-    return stat.bavail * stat.bsize;
-  } catch {
-    return null;
+function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, targetDurationSeconds) {
+  const delta = targetDurationSeconds - sourceDurationSeconds;
+  const targetSec = formatSeconds(targetDurationSeconds);
+  if (Math.abs(delta) < AUDIO_DURATION_TOLERANCE_SECONDS) {
+    return {
+      operation: "copy",
+      steps: [{ kind: "copy", args: ["-i", audioPath, "-c:a", "copy", "-y", outputPath] }],
+      cleanupPaths: []
+    };
   }
-}
-function inspectDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeDiskBytes = freeDiskBytesAt) {
-  const freeBytes = freeDiskBytes(framesDir);
-  const estimatedBytes = estimateDiskCaptureBytes(totalFrames, captureOptions);
-  if (freeBytes === null || estimatedBytes <= freeBytes * 0.9) {
-    return { available: true, estimatedBytes, freeBytes };
+  if (delta > 0) {
+    return {
+      operation: "pad",
+      steps: [{ kind: "normalize", filter: `apad,atrim=0:${targetSec}` }],
+      cleanupPaths: []
+    };
   }
-  return { available: false, estimatedBytes, freeBytes };
+  return {
+    operation: "trim",
+    steps: [{ kind: "trim", filter: `atrim=duration=${targetSec},asetpts=PTS-STARTPTS` }],
+    cleanupPaths: []
+  };
 }
-function diskCaptureRemedy(cfg, outputFormat, durationSeconds, workerCount) {
-  const oneWorker = explainStreamingEncodeGate(cfg, outputFormat, 1, durationSeconds);
-  if (workerCount > 1 && oneWorker.enabled) {
-    return `This render stores frames because it captures with ${workerCount} workers. Free up disk space, or re-run this render with --workers 1 to stream frames into the encoder instead. One worker is slower, so keep the default worker count for renders that fit on disk.`;
-  }
-  switch (oneWorker.reason) {
-    case "format_excluded":
-      return `${outputFormat} output stores every frame at any worker count. Free up disk space or render to mp4.`;
-    case "disabled_by_config":
-      return "PRODUCER_ENABLE_STREAMING_ENCODE=false sends every render to disk. Free up disk space or unset it.";
-    case "duration_cap":
-      return "The streaming duration cap (PRODUCER_STREAMING_ENCODE_DURATION_CAP_ENABLED=true) sends renders longer than PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS to disk at any worker count. Free up disk space, unset the cap, or use --low-memory-mode, which streams past it on one worker.";
-    default:
-      return "Free up disk space.";
-  }
+function formatSeconds(sec) {
+  return sec.toFixed(6);
 }
-function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remedy) {
-  const basisNote = basis === "measured" ? ` (measured from the first ${DISK_PROJECTION_SAMPLE_FRAMES} frames)` : "";
-  return new Error(
-    `Disk capture may need ~${(needBytes / 1e6).toFixed(1)} MB of temporary frame storage${basisNote}, but only ${(freeBytes / 1e6).toFixed(1)} MB is free at ${framesDir}. Disk capture stores every frame as an image file (JPEG, or PNG for alpha). ${remedy}`
-  );
+function sanitizeProbeFailure(reason, paths) {
+  const message = reason instanceof Error ? reason.message : String(reason);
+  const keepFfmpegsLastLineUncapped = Number.POSITIVE_INFINITY;
+  return redactTelemetryString3(redactKnownPaths(message, paths), keepFfmpegsLastLineUncapped);
 }
-function assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, remedy, freeDiskBytes) {
-  const headroom = inspectDiskCaptureHeadroom(
-    framesDir,
-    totalFrames,
-    captureOptions,
-    freeDiskBytes
-  );
-  if (headroom.available) return;
-  throw diskCaptureShortfallError(
-    headroom.estimatedBytes,
-    headroom.freeBytes,
-    framesDir,
-    "estimate",
-    remedy
+async function padOrTrimAudioToVideoFrameCount(input) {
+  const probeVideo = input.probeVideoFrameInfo ?? ((videoPath) => defaultProbeVideoFrameInfo(videoPath, input.signal));
+  const probeAudio = input.probeAudioInfo ?? defaultProbeAudioInfo;
+  const timeoutMs = input.timeoutMs ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
+  const runner = input.runFfmpeg ?? ((args) => defaultRunFfmpeg(args, timeoutMs, input.signal));
+  const encode = input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal);
+  const probeTruePeak = input.probeAudioTruePeakDbfs ?? (input.runFfmpeg || input.encodeAac ? void 0 : (audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }));
+  const [videoResult, audioResult] = await Promise.allSettled([
+    probeVideo(input.videoPath),
+    probeAudio(input.audioPath, input.signal)
+  ]);
+  const probePaths = [input.videoPath, input.audioPath, input.outputPath];
+  if (videoResult.status === "rejected") {
+    return failResult(
+      input.outputPath,
+      0,
+      audioResult.status === "fulfilled" ? audioResult.value.durationSeconds : 0,
+      `audioPadTrim: failed to probe video: ${sanitizeProbeFailure(
+        videoResult.reason,
+        probePaths
+      )}`
+    );
+  }
+  if (audioResult.status === "rejected") {
+    return failResult(
+      input.outputPath,
+      0,
+      0,
+      `audioPadTrim: failed to probe audio: ${sanitizeProbeFailure(
+        audioResult.reason,
+        probePaths
+      )}`
+    );
+  }
+  const videoInfo = videoResult.value;
+  const audioInfo = audioResult.value;
+  if (!Number.isFinite(videoInfo.frameCount) || videoInfo.frameCount <= 0 || !Number.isFinite(videoInfo.fpsNum) || videoInfo.fpsNum <= 0 || !Number.isFinite(videoInfo.fpsDen) || videoInfo.fpsDen <= 0) {
+    return failResult(
+      input.outputPath,
+      0,
+      audioInfo.durationSeconds,
+      `audioPadTrim: invalid video frame info: ${JSON.stringify(videoInfo)}`
+    );
+  }
+  const targetDurationSeconds = videoInfo.frameCount * videoInfo.fpsDen / videoInfo.fpsNum;
+  const plan2 = buildPadTrimAudioPlan(
+    input.audioPath,
+    input.outputPath,
+    audioInfo.durationSeconds,
+    targetDurationSeconds
   );
-}
-function measureCaptureFrameBytes(workDir, framesDir) {
-  let total = sampleDirectoryBytes(framesDir);
-  if (!existsSync12(workDir)) return total;
-  for (const attempt of readdirSync3(workDir)) {
-    if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join18(workDir, attempt));
-      continue;
-    }
-    if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join18(workDir, attempt);
-    for (const name of readdirSync3(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join18(attemptDir, name));
+  try {
+    for (const step of plan2.steps) {
+      const ffmpegResult = step.kind === "copy" ? await runner(step.args) : await encode(input.audioPath, input.outputPath, targetDurationSeconds, step.filter);
+      if (!ffmpegResult.success) {
+        return {
+          success: false,
+          outputPath: input.outputPath,
+          targetDurationSeconds,
+          sourceDurationSeconds: audioInfo.durationSeconds,
+          operation: plan2.operation,
+          error: ffmpegResult.error,
+          failureReason: ffmpegResult.failureReason
+        };
+      }
     }
+  } catch (err) {
+    return {
+      success: false,
+      outputPath: input.outputPath,
+      targetDurationSeconds,
+      sourceDurationSeconds: audioInfo.durationSeconds,
+      operation: plan2.operation,
+      error: `audioPadTrim: failed to materialize ${plan2.operation}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  } finally {
+    for (const path of plan2.cleanupPaths) rmSync7(path, { force: true });
   }
-  return total;
-}
-function createDiskCaptureProjection(input) {
-  const { framesDir, totalFrames, measureBytes, remedy, freeDiskBytes = freeDiskBytesAt } = input;
-  let checked = false;
-  return (capturedFrames) => {
-    if (checked || capturedFrames < DISK_PROJECTION_SAMPLE_FRAMES) return;
-    const measured = measureBytes();
-    if (measured <= 0) return;
-    checked = true;
-    const remaining = totalFrames - capturedFrames;
-    const freeBytes = freeDiskBytes(framesDir);
-    if (remaining <= 0 || freeBytes === null) return;
-    const needBytes = Math.ceil(measured / capturedFrames * remaining);
-    if (needBytes > freeBytes * 0.9) {
-      throw diskCaptureShortfallError(needBytes, freeBytes, framesDir, "measured", remedy);
+  let loweredDb = 0;
+  if (probeTruePeak) {
+    const correction = await enforceAacTruePeak({
+      audioPath: input.outputPath,
+      targetDurationSeconds,
+      signal: input.signal,
+      probeTruePeak,
+      encode
+    });
+    if (!correction.success) {
+      return {
+        success: false,
+        outputPath: input.outputPath,
+        targetDurationSeconds,
+        sourceDurationSeconds: audioInfo.durationSeconds,
+        operation: plan2.operation,
+        error: correction.error,
+        failureReason: correction.failureReason
+      };
     }
+    loweredDb = correction.loweredDb ?? 0;
+  }
+  return {
+    success: true,
+    outputPath: input.outputPath,
+    targetDurationSeconds,
+    sourceDurationSeconds: audioInfo.durationSeconds,
+    operation: plan2.operation,
+    ...loweredDb > 0 ? { audioLoweredDb: loweredDb } : {}
   };
 }
-async function runCaptureStage(input) {
-  const {
-    fileServer,
-    workDir,
-    framesDir,
-    job,
-    totalFrames,
-    cfg,
-    plan: plan2,
-    log,
-    captureAttempts,
-    buildCaptureOptions,
-    createRenderVideoFrameInjector,
-    abortSignal,
-    onProgress,
-    frameRange,
-    dedupPerfs
-  } = input;
-  let { probeSession } = input;
-  let { workerCount } = plan2;
-  const { forceScreenshot } = plan2;
-  let lastBrowserConsole = [];
-  let captureBeyondViewport = probeSession?.options.captureBeyondViewport;
-  const captureCfg = cfg.forceScreenshot === forceScreenshot ? cfg : { ...cfg, forceScreenshot };
-  if (frameRange !== void 0) {
-    if (!Number.isFinite(frameRange.startFrame) || !Number.isFinite(frameRange.endFrame) || frameRange.startFrame < 0 || frameRange.endFrame <= frameRange.startFrame) {
-      throw new Error(
-        `[captureStage] invalid frameRange: ${JSON.stringify(frameRange)}. Expected non-negative startFrame strictly less than endFrame.`
+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) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }),
+    encode: defaultAacEncoder(timeoutMs, input.signal, input.sourcePath)
+  });
+}
+async function enforceAacTruePeak(input) {
+  let scratchDir;
+  try {
+    scratchDir = mkdtempSync3(join17(dirname7(input.audioPath), ".true-peak-"));
+    const correctedPath = join17(scratchDir, "audio.m4a");
+    const measurements = [];
+    let attenuationDb = 0;
+    let measuredPath = input.audioPath;
+    for (let pass = 0; pass <= MAX_TRUE_PEAK_CORRECTION_PASSES; pass += 1) {
+      const truePeakDbfs = await input.probeTruePeak(measuredPath, input.signal);
+      measurements.push(
+        `pass ${pass}: ${truePeakDbfs.toFixed(3)} dBFS at ${attenuationDb.toFixed(3)} dB attenuation`
       );
-    }
-    const rangeFrames = frameRange.endFrame - frameRange.startFrame;
-    if (rangeFrames !== totalFrames) {
-      throw new Error(
-        `[captureStage] frameRange size (${rangeFrames}) must equal totalFrames (${totalFrames}). Received frameRange=${JSON.stringify(frameRange)}.`
+      if (Number.isNaN(truePeakDbfs) || truePeakDbfs === Number.POSITIVE_INFINITY) {
+        return { success: false, error: "audioPadTrim: FFmpeg reported an invalid true peak" };
+      }
+      if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
+        if (measuredPath !== correctedPath) return { success: true };
+        renameSync4(correctedPath, input.audioPath);
+        return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
+      }
+      if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
+      const headroomDb = AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB * 2 ** pass;
+      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - headroomDb - truePeakDbfs;
+      const result = await input.encode(
+        input.audioPath,
+        correctedPath,
+        input.targetDurationSeconds,
+        aacTruePeakCorrectionFilter(input.targetDurationSeconds, attenuationDb)
       );
+      if (!result.success) {
+        return {
+          success: false,
+          error: sanitizeProbeFailure(
+            result.error ?? "audioPadTrim: failed to constrain AAC true peak",
+            [input.audioPath, correctedPath]
+          ),
+          failureReason: result.failureReason
+        };
+      }
+      measuredPath = correctedPath;
     }
+    return {
+      success: false,
+      error: `audioPadTrim: AAC true peak remained above ${AAC_DELIVERY_TRUE_PEAK_DBFS} dBFS after ${MAX_TRUE_PEAK_CORRECTION_PASSES} correction passes; ${measurements.join("; ")}`
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `audioPadTrim: failed to validate AAC true peak: ${sanitizeProbeFailure(
+        err,
+        scratchDir ? [input.audioPath, scratchDir] : [input.audioPath]
+      )}`
+    };
+  } finally {
+    if (scratchDir) rmSync7(scratchDir, { recursive: true, force: true });
   }
-  const captureOptions = buildCaptureOptions();
-  const remedy = diskCaptureRemedy(cfg, job.config.format ?? "mp4", job.duration ?? 0, workerCount);
-  assertDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, remedy);
-  const checkDiskProjection = createDiskCaptureProjection({
-    framesDir,
-    totalFrames,
-    measureBytes: () => measureCaptureFrameBytes(workDir, framesDir),
-    remedy
-  });
-  if (workerCount > 1) {
-    const attempts = await executeDiskCaptureWithAdaptiveRetry({
-      serverUrl: fileServer.url,
-      workDir,
-      framesDir,
-      totalFrames,
-      initialWorkerCount: workerCount,
-      allowRetry: shouldAllowAdaptiveCaptureRetry(workerCount, job.config.workers !== void 0),
-      frameExt: frameFileExtension(captureOptions.format),
-      captureOptions,
-      createBeforeCaptureHook: createRenderVideoFrameInjector,
-      abortSignal,
-      frameRangeStart: frameRange?.startFrame,
-      dedupPerfs,
-      onProgress: (progress) => {
-        if (progress.latestWorkerPhase) {
-          if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
-          return;
-        }
-        if (progress.landedFrame) input.onFrameLanded?.(progress.landedFrame);
-        job.framesRendered = progress.capturedFrames;
-        checkDiskProjection(progress.capturedFrames);
-        const frameProgress = progress.capturedFrames / progress.totalFrames;
-        reportFrameProgress(
-          job,
-          `Capturing frame ${progress.capturedFrames}/${progress.totalFrames} (${progress.activeWorkers} workers)`,
-          Math.round(25 + frameProgress * 45),
-          onProgress,
-          progress.capturedFrames,
-          progress.totalFrames
-        );
-      },
-      cfg: captureCfg,
-      log
-    });
-    captureAttempts.push(...attempts);
-    const lastAttempt = attempts[attempts.length - 1];
-    if (lastAttempt) {
-      workerCount = lastAttempt.workers;
+}
+function failResult(outputPath, target, source, error) {
+  return {
+    success: false,
+    outputPath,
+    targetDurationSeconds: target,
+    sourceDurationSeconds: source,
+    operation: "copy",
+    error
+  };
+}
+async function defaultProbeVideoFrameInfo(videoPath, signal) {
+  const fastInfo = await runFfprobeJson(
+    [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-show_entries",
+      "stream=nb_frames,r_frame_rate",
+      "-of",
+      "json",
+      "--",
+      videoPath
+    ],
+    signal
+  );
+  let stream = fastInfo.streams?.[0];
+  const fastCount = Number(stream?.nb_frames);
+  if (stream && Number.isFinite(fastCount) && fastCount > 0) {
+    return { frameCount: fastCount, ...parseFrameRate(stream.r_frame_rate ?? "") };
+  }
+  const slowInfo = await runFfprobeJson(
+    [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-count_packets",
+      "-show_entries",
+      "stream=nb_read_packets,r_frame_rate",
+      "-of",
+      "json",
+      "--",
+      videoPath
+    ],
+    signal
+  );
+  stream = slowInfo.streams?.[0];
+  if (!stream) throw new Error(`ffprobe found no video stream in ${videoPath}`);
+  const slowCount = Number(stream.nb_read_packets);
+  if (!Number.isFinite(slowCount) || slowCount <= 0) {
+    throw new Error(`ffprobe returned no frame count: ${JSON.stringify(stream)}`);
+  }
+  return { frameCount: slowCount, ...parseFrameRate(stream.r_frame_rate ?? "") };
+}
+function parseFrameRate(rate) {
+  const [n, d] = rate.split("/");
+  const fpsNum = Number(n);
+  const fpsDen = d === void 0 ? 1 : Number(d);
+  if (!Number.isFinite(fpsNum) || !Number.isFinite(fpsDen) || fpsNum <= 0 || fpsDen <= 0) {
+    throw new Error(`Invalid r_frame_rate: ${JSON.stringify(rate)}`);
+  }
+  return { fpsNum, fpsDen };
+}
+async function defaultProbeAudioInfo(audioPath, signal) {
+  const metadata = await extractAudioMetadata3(audioPath, { signal });
+  return {
+    durationSeconds: metadata.durationSeconds,
+    sampleRate: metadata.sampleRate,
+    channels: metadata.channels,
+    audioCodec: metadata.audioCodec
+  };
+}
+async function defaultRunFfmpeg(args, timeoutMs, signal) {
+  return toStepResult(await runFfmpeg4(args, { signal, timeout: timeoutMs }), timeoutMs);
+}
+function defaultAacEncoder(timeoutMs, signal, pcmSourcePath) {
+  return async (inputPath, outputPath, durationSeconds, filter) => {
+    const options = pcmSourcePath ? { signal, timeout: timeoutMs, filter } : { signal, timeout: timeoutMs, filter, segments: 1 };
+    return toStepResult(
+      await encodeAac(pcmSourcePath ?? inputPath, outputPath, durationSeconds, options),
+      timeoutMs
+    );
+  };
+}
+function toStepResult(result, timeoutMs) {
+  if (result.success) return { success: true };
+  return {
+    success: false,
+    error: `[audioPadTrim] ${describeFfmpegFailure2(result, timeoutMs)}`,
+    failureReason: result.failureReason
+  };
+}
+async function runFfprobeJson(args, signal) {
+  if (!args.includes("--")) {
+    throw new Error('[audioPadTrim] ffprobe args must terminate options with "--".');
+  }
+  const proc = spawn(getFfprobeBinary(), args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  trackChildProcess(proc);
+  let stdout = "";
+  proc.stdout.on("data", (data) => {
+    stdout += data.toString();
+  });
+  const managed = new ManagedChildProcess(proc, {
+    signal,
+    deadlineAtMs: Date.now() + 3e4
+  });
+  const outcome = await managed.wait();
+  if (outcome.reason === "spawn_error") {
+    if (outcome.error?.code === "ENOENT") {
+      throw new Error("[audioPadTrim] ffprobe not found. Please install FFmpeg.");
     }
-    if (probeSession) {
-      captureBeyondViewport = probeSession.options.captureBeyondViewport;
-      lastBrowserConsole = probeSession.browserConsoleBuffer;
-      await closeCaptureSession5(probeSession);
-      probeSession = null;
+    throw outcome.error ?? new Error(outcome.stderr);
+  }
+  if (outcome.reason !== "exit" || outcome.exitCode !== 0) {
+    const probed = args[args.length - 1];
+    const scrubbed = redactKnownPaths(outcome.stderr, probed === void 0 ? [] : [probed]);
+    throw new Error(`ffprobe ${outcome.reason}: ${redactTelemetryString3(scrubbed, 2e3)}`);
+  }
+  try {
+    return JSON.parse(stdout);
+  } catch (err) {
+    throw new Error(`Failed to parse ffprobe output: ${err.message}`);
+  }
+}
+
+// src/services/render/stages/audioStage.ts
+function assertAudioNotInterrupted(failures) {
+  const interrupted = failures?.find((failure) => failure.reason === "external_interruption");
+  if (!interrupted) return;
+  throw encoderFailureError("Audio processing failed", {
+    error: interrupted.detail,
+    failureReason: "external_interruption",
+    audioFailures: audioFailureDiagnostics([
+      interrupted,
+      ...(failures ?? []).filter((failure) => failure !== interrupted)
+    ])
+  });
+}
+async function runAudioStage(input) {
+  const stageStart = Date.now();
+  const pcmSourcePath = join18(input.workDir, "audio-source.wav");
+  const duration = input.totalFrames * input.fps.den / input.fps.num;
+  try {
+    const result = await mixAudioForDelivery(input, duration, pcmSourcePath);
+    let audioLoweredDb;
+    if (result.hasAudio) {
+      const peak = await constrainAacTruePeak({
+        audioPath: result.audioOutputPath,
+        sourcePath: pcmSourcePath,
+        targetDurationSeconds: duration,
+        signal: input.abortSignal,
+        timeoutMs: input.ffmpegProcessTimeout
+      });
+      if (!peak.success) throw encoderFailureError("Audio true-peak check failed", peak);
+      audioLoweredDb = peak.loweredDb;
     }
-  } else {
-    const sequential = await runSequentialDiskCapture(
-      input,
-      captureOptions,
-      captureCfg,
-      checkDiskProjection
-    );
-    probeSession = null;
-    lastBrowserConsole = sequential.lastBrowserConsole;
-    captureBeyondViewport = sequential.captureBeyondViewport;
+    return { ...result, audioLoweredDb, audioProcessMs: Date.now() - stageStart };
+  } finally {
+    rmSync8(pcmSourcePath, { force: true });
   }
-  return { workerCount, probeSession, lastBrowserConsole, captureBeyondViewport };
 }
-async function runSequentialDiskCapture(input, captureOptions, captureCfg, checkDiskProjection) {
+async function mixAudioForDelivery(input, duration, pcmSourcePath) {
   const {
-    fileServer,
-    framesDir,
-    totalFrames,
-    log,
-    createRenderVideoFrameInjector,
+    projectDir,
+    workDir,
+    compiledDir,
+    ffmpegProcessTimeout,
+    audioGain,
+    audios,
+    masterFxChain,
+    urlByAbsentLocalPath,
     abortSignal,
     assertNotAborted,
-    frameRange
+    log
   } = input;
-  let { probeSession } = input;
-  let lastBrowserConsole = [];
-  let captureBeyondViewport;
-  const { rangeStart, rangeEnd } = resolveCaptureRange(frameRange, totalFrames);
-  const rangeFrames = rangeEnd - rangeStart;
-  const frameExt = frameFileExtension(captureOptions.format);
-  let transientRetriesUsed = 0;
-  let resumeFrom = 0;
-  while (true) {
-    const videoInjector = createRenderVideoFrameInjector();
-    const session = probeSession ?? await createCaptureSession5(
-      fileServer.url,
-      framesDir,
-      captureOptions,
-      videoInjector,
-      captureCfg
-    );
-    captureBeyondViewport = session.options.captureBeyondViewport;
+  const audioOutputPath = join18(workDir, MIXED_AUDIO_FILENAME);
+  let hasAudio = false;
+  let audioError;
+  let audioFailures;
+  if (audios.length > 0) {
+    let audioResult;
     try {
-      if (probeSession) {
-        prepareCaptureSessionForReuse3(session, framesDir, videoInjector);
-        probeSession = null;
-      }
-      await ensureSessionReady(session);
-      assertNotAborted();
-      lastBrowserConsole = session.browserConsoleBuffer;
-      await captureSessionFrames(session, {
-        input,
-        rangeStart,
-        rangeEnd,
-        resumeFrom,
-        checkDiskProjection
-      });
-      break;
-    } catch (error) {
-      lastBrowserConsole = session.browserConsoleBuffer;
-      const resume = planTransientResume(error, {
+      audioResult = await processCompositionAudio(
+        audios,
+        projectDir,
+        join18(workDir, "audio-work"),
+        audioOutputPath,
+        duration,
         abortSignal,
-        rangeFrames,
-        framesDir,
-        frameExt,
-        retriesUsed: transientRetriesUsed
-      });
-      if (resume !== null) {
-        transientRetriesUsed++;
-        resumeFrom = resume;
-        log.warn(
-          "[Render] Transient browser failure during sequential capture; retrying once with a fresh session.",
-          {
-            resumeFrom,
-            rangeFrames,
-            transientRetriesUsed,
-            error: error instanceof Error ? error.message : String(error)
-          }
-        );
-        continue;
+        {
+          ffmpegProcessTimeout,
+          audioGain,
+          masterFxChain,
+          urlByAbsentLocalPath,
+          keepEncoderInputAt: pcmSourcePath
+        },
+        compiledDir
+      );
+    } catch (err) {
+      assertNotAborted();
+      const detail = err instanceof Error ? err.message : String(err);
+      return {
+        audioOutputPath,
+        hasAudio: false,
+        audioError: detail,
+        // Synthesised rather than left undefined. The warning policy reads
+        // owner, retryability, reason and stage off this list, so reporting the
+        // FATAL failure — the one that took the whole mix down — with an empty
+        // one gave it strictly less classification than a single dropped track
+        // gets, which is the opposite of what this stage exists to do.
+        // "internal" is the honest bucket: the stages enumerate ffmpeg steps
+        // and this is the FX render, which is none of them.
+        audioFailures: [
+          {
+            stage: "internal",
+            reason: "internal",
+            owner: "system",
+            retryable: false,
+            detail: detail.slice(0, 2e3)
+          }
+        ]
+      };
+    }
+    assertNotAborted();
+    assertAudioNotInterrupted(audioResult.failures);
+    hasAudio = audioResult.success;
+    audioFailures = audioResult.failures;
+    if (!hasAudio) {
+      audioError = audioResult.error ?? "audio mix failed for an unknown reason";
+      for (const failure of audioResult.failures ?? []) {
+        log?.warn("Audio track failed", {
+          elementId: failure.elementId,
+          stage: failure.stage,
+          reason: failure.reason,
+          owner: failure.owner,
+          retryable: failure.retryable,
+          detail: failure.detail
+        });
       }
-      throw wrapCaptureStageError(error, lastBrowserConsole);
-    } finally {
-      lastBrowserConsole = session.browserConsoleBuffer;
-      await closeCaptureSession5(session);
     }
   }
-  return { lastBrowserConsole, captureBeyondViewport };
+  return {
+    audioOutputPath,
+    hasAudio,
+    audioError,
+    audioFailures
+  };
 }
-function resolveCaptureRange(frameRange, totalFrames) {
-  return { rangeStart: frameRange?.startFrame ?? 0, rangeEnd: frameRange?.endFrame ?? totalFrames };
+
+// src/services/render/stages/captureStage.ts
+import { existsSync as existsSync12, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
+import { join as join19 } from "node:path";
+import {
+  classifyCaptureFailure as classifyCaptureFailure2,
+  frameFileExtension,
+  captureFrame,
+  captureFrameToBufferPipelined as captureFrameToBufferPipelined2,
+  verifyDiskDrawElementSamples,
+  writeCapturedFrame,
+  closeCaptureSession as closeCaptureSession5,
+  completeDeferredDrawElementInit as completeDeferredDrawElementInit3,
+  createCaptureSession as createCaptureSession5,
+  getCapturePerfSummary as getCapturePerfSummary3,
+  initializeSession as initializeSession5,
+  prepareCaptureSessionForReuse as prepareCaptureSessionForReuse3
+} from "@hyperframes/engine";
+function shouldAllowAdaptiveCaptureRetry(workerCount, _explicitlyConfigured) {
+  return workerCount > 1;
 }
-function planTransientResume(error, ctx) {
-  const failure = classifyCaptureFailure2(error, { signal: ctx.abortSignal });
-  const missing = findMissingFrameRanges(ctx.rangeFrames, ctx.framesDir, ctx.frameExt);
-  const [firstMissing] = missing;
-  if (!firstMissing) return null;
-  return isTransientCaptureRetryEligible(failure.kind, missing, ctx.retriesUsed) ? firstMissing.startFrame : null;
+var JPEG_RAW_RGBA_DIVISOR = 8;
+var HIGH_QUALITY_JPEG_RAW_RGBA_DIVISOR = 4;
+var DISK_PROJECTION_SAMPLE_FRAMES = 10;
+function estimateDiskCaptureBytes(totalFrames, captureOptions) {
+  const scale = captureOptions.deviceScaleFactor ?? 1;
+  const outputWidth = Math.ceil(captureOptions.width * scale);
+  const outputHeight = Math.ceil(captureOptions.height * scale);
+  const rawBytes = Math.ceil(totalFrames) * outputWidth * outputHeight * 4;
+  return frameFileExtension(captureOptions.format) === "jpg" ? Math.ceil(
+    rawBytes / ((captureOptions.quality ?? 80) > 80 ? HIGH_QUALITY_JPEG_RAW_RGBA_DIVISOR : JPEG_RAW_RGBA_DIVISOR)
+  ) : rawBytes;
 }
-async function ensureSessionReady(session) {
-  if (!session.isInitialized) {
-    await initializeSession5(session);
-    return;
-  }
-  if (process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true") {
-    await completeDeferredDrawElementInit3(session);
+function freeDiskBytesAt(path) {
+  try {
+    const stat = statfsSync2(path);
+    return stat.bavail * stat.bsize;
+  } catch {
+    return null;
   }
 }
-async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resumeFrom, checkDiskProjection }) {
-  const { job, framesDir, dedupPerfs, assertNotAborted, onProgress } = input;
-  const rangeFrames = rangeEnd - rangeStart;
-  const reportFrame = (fileIndex) => {
-    job.framesRendered = fileIndex + 1;
-    checkDiskProjection(fileIndex + 1);
-    reportFrameProgress(
-      job,
-      `Capturing frame ${fileIndex + 1}/${rangeFrames}`,
-      Math.round(25 + (fileIndex + 1) / rangeFrames * 45),
-      onProgress,
-      fileIndex + 1,
-      rangeFrames
-    );
-  };
-  if (session.workerEncodeEnabled) {
-    let prev = null;
-    const drainPrev = async () => {
-      if (!prev) return;
-      assertNotAborted();
-      const buf = await prev.encodeResult;
-      writeCapturedFrame(session, prev.fileIndex, buf);
-      reportFrame(prev.fileIndex);
-    };
-    for (let i = resumeFrom; i < rangeFrames; i++) {
-      assertNotAborted();
-      const absoluteIdx = rangeStart + i;
-      const time = absoluteIdx * job.config.fps.den / job.config.fps.num;
-      const { encodeResult } = await captureFrameToBufferPipelined2(session, i, time);
-      await drainPrev();
-      prev = { fileIndex: i, encodeResult };
-    }
-    await drainPrev();
-  } else {
-    for (let i = resumeFrom; i < rangeFrames; i++) {
-      assertNotAborted();
-      const absoluteIdx = rangeStart + i;
-      const time = absoluteIdx * job.config.fps.den / job.config.fps.num;
-      await captureFrame(session, i, time);
-      reportFrame(i);
-    }
+function inspectDiskCaptureHeadroom(framesDir, totalFrames, captureOptions, freeDiskBytes = freeDiskBytesAt) {
+  const freeBytes = freeDiskBytes(framesDir);
+  const estimatedBytes = estimateDiskCaptureBytes(totalFrames, captureOptions);
+  if (freeBytes === null || estimatedBytes <= freeBytes * 0.9) {
+    return { available: true, estimatedBytes, freeBytes };
   }
-  await verifyDiskDrawElementSamples(
-    session,
-    {
-      workerId: 0,
-      startFrame: rangeStart + resumeFrom,
-      endFrame: rangeEnd,
-      outputDir: framesDir,
-      outputFrameOffset: rangeStart
-    },
-    false
-  );
-  dedupPerfs.push(getCapturePerfSummary3(session));
+  return { available: false, estimatedBytes, freeBytes };
 }
-
-// src/services/render/stages/captureHdrStage.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join22 } from "node:path";
-import {
-  closeCaptureSession as closeCaptureSession7,
-  cloneCaptureWarnings as cloneCaptureWarnings2,
-  createCaptureSession as createCaptureSession7,
-  initTransparentBackground as initTransparentBackground2,
-  initializeSession as initializeSession7,
-  spawnStreamingEncoder as spawnStreamingEncoder3
-} from "@hyperframes/engine";
-import { fpsToNumber as fpsToNumber8 } from "@hyperframes/core";
-
-// src/services/hdrImageTransferCache.ts
-import { convertTransfer as convertTransfer2 } from "@hyperframes/engine";
-var DEFAULT_MAX_BYTES = 200 * 1024 * 1024;
-function createHdrImageTransferCache(options = {}) {
-  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-  if (!Number.isInteger(maxBytes) || maxBytes < 0) {
-    throw new Error(
-      `createHdrImageTransferCache: maxBytes must be a non-negative integer, got ${String(maxBytes)}`
-    );
+function diskCaptureRemedy(cfg, outputFormat, durationSeconds, workerCount) {
+  const oneWorker = explainStreamingEncodeGate(cfg, outputFormat, 1, durationSeconds);
+  if (workerCount > 1 && oneWorker.enabled) {
+    return `This render stores frames because it captures with ${workerCount} workers. Free up disk space, or re-run this render with --workers 1 to stream frames into the encoder instead. One worker is slower, so keep the default worker count for renders that fit on disk.`;
   }
-  const entries = /* @__PURE__ */ new Map();
-  let totalBytes = 0;
-  function makeKey(imageId, targetTransfer) {
-    return `${imageId}|${targetTransfer}`;
+  switch (oneWorker.reason) {
+    case "format_excluded":
+      return `${outputFormat} output stores every frame at any worker count. Free up disk space or render to mp4.`;
+    case "disabled_by_config":
+      return "PRODUCER_ENABLE_STREAMING_ENCODE=false sends every render to disk. Free up disk space or unset it.";
+    case "duration_cap":
+      return "The streaming duration cap (PRODUCER_STREAMING_ENCODE_DURATION_CAP_ENABLED=true) sends renders longer than PRODUCER_STREAMING_ENCODE_MAX_DURATION_SECONDS to disk at any worker count. Free up disk space, unset the cap, or use --low-memory-mode, which streams past it on one worker.";
+    default:
+      return "Free up disk space.";
   }
-  function evictUntilRoom(needed) {
-    while (totalBytes + needed > maxBytes && entries.size > 0) {
-      const lruKey = entries.keys().next().value;
-      if (lruKey === void 0) break;
-      const evicted = entries.get(lruKey);
-      if (evicted) totalBytes -= evicted.byteLength;
-      entries.delete(lruKey);
+}
+function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remedy) {
+  const basisNote = basis === "measured" ? ` (measured from the first ${DISK_PROJECTION_SAMPLE_FRAMES} frames)` : "";
+  return new Error(
+    `Disk capture may need ~${(needBytes / 1e6).toFixed(1)} MB of temporary frame storage${basisNote}, but only ${(freeBytes / 1e6).toFixed(1)} MB is free at ${framesDir}. Disk capture stores every frame as an image file (JPEG, or PNG for alpha). ${remedy}`
+  );
+}
+function measureCaptureFrameBytes(workDir, framesDir) {
+  let total = sampleDirectoryBytes(framesDir);
+  if (!existsSync12(workDir)) return total;
+  for (const attempt of readdirSync3(workDir)) {
+    if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
+      total += sampleDirectoryBytes(join19(workDir, attempt));
+      continue;
+    }
+    if (!/^capture-attempt-\d+$/.test(attempt)) continue;
+    const attemptDir = join19(workDir, attempt);
+    for (const name of readdirSync3(attemptDir)) {
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join19(attemptDir, name));
     }
   }
-  return {
-    getConverted(imageId, sourceTransfer, targetTransfer, source) {
-      if (sourceTransfer === targetTransfer) {
-        return source;
-      }
-      if (maxBytes === 0) {
-        const fresh = Buffer.from(source);
-        convertTransfer2(fresh, sourceTransfer, targetTransfer);
-        return fresh;
-      }
-      const key = makeKey(imageId, targetTransfer);
-      const existing = entries.get(key);
-      if (existing) {
-        entries.delete(key);
-        entries.set(key, existing);
-        return existing;
-      }
-      const converted = Buffer.from(source);
-      convertTransfer2(converted, sourceTransfer, targetTransfer);
-      if (converted.byteLength > maxBytes) {
-        return converted;
-      }
-      evictUntilRoom(converted.byteLength);
-      entries.set(key, converted);
-      totalBytes += converted.byteLength;
-      return converted;
-    },
-    size() {
-      return entries.size;
-    },
-    bytesUsed() {
-      return totalBytes;
+  return total;
+}
+function createDiskCaptureProjection(input) {
+  const { framesDir, totalFrames, measureBytes, remedy, freeDiskBytes = freeDiskBytesAt } = input;
+  let checked = false;
+  return (capturedFrames) => {
+    if (checked || capturedFrames < DISK_PROJECTION_SAMPLE_FRAMES) return;
+    const measured = measureBytes();
+    if (measured <= 0) return;
+    checked = true;
+    const remaining = totalFrames - capturedFrames;
+    const freeBytes = freeDiskBytes(framesDir);
+    if (remaining <= 0 || freeBytes === null) return;
+    const needBytes = Math.ceil(measured / capturedFrames * remaining);
+    if (needBytes > freeBytes * 0.9) {
+      throw diskCaptureShortfallError(needBytes, freeBytes, framesDir, "measured", remedy);
     }
   };
 }
-
-// src/services/render/stages/captureHdrSequentialLoop.ts
-import { join as join19 } from "node:path";
-import {
-  TRANSITIONS,
-  crossfade
-} from "@hyperframes/engine";
-async function runSequentialLayeredFrameLoop(input) {
+async function runCaptureStage(input) {
   const {
+    fileServer,
+    workDir,
+    framesDir,
     job,
-    log,
-    width,
-    height,
     totalFrames,
-    nativeHdrIds,
-    nativeHdrImageIds,
-    hdrCompositeCtx,
-    hdrPerf,
-    hdrEncoder,
-    domSession,
-    transitionRanges,
-    sceneElements,
-    compositeTransfer,
-    hdrTargetTransfer,
-    hdrVideoEndTimes,
-    cleanedUpVideos,
-    hdrVideoFrameSources,
-    debugDumpEnabled,
-    debugDumpDir,
-    assertNotAborted,
-    onProgress
+    cfg,
+    plan: plan2,
+    log,
+    captureAttempts,
+    buildCaptureOptions,
+    createRenderVideoFrameInjector,
+    abortSignal,
+    onProgress,
+    frameRange,
+    dedupPerfs
   } = input;
-  const beforeCaptureHook = domSession.onBeforeCapture;
-  const bufSize = width * height * 6;
-  const hasTransitions = transitionRanges.length > 0;
-  const transitionBuffers = hasTransitions ? {
-    bufferA: Buffer.alloc(bufSize),
-    bufferB: Buffer.alloc(bufSize),
-    output: Buffer.alloc(bufSize)
-  } : null;
-  const normalCanvas = Buffer.alloc(bufSize);
-  for (let i = 0; i < totalFrames; i++) {
-    assertNotAborted();
-    const time = i * job.config.fps.den / job.config.fps.num;
-    if (hdrPerf) hdrPerf.frames += 1;
-    const stackingInfo = await seekInjectAndQueryStacking(
-      domSession.page,
-      time,
-      beforeCaptureHook,
-      nativeHdrIds,
-      hdrPerf,
-      "frameSeekMs",
-      "frameInjectMs",
-      "stackingQueryMs"
-    );
-    const activeTransition = transitionRanges.find((t) => i >= t.startFrame && i <= t.endFrame);
-    if (i % 30 === 0 && (log.isLevelEnabled?.("debug") ?? true)) {
-      const hdrEl = stackingInfo.find((e) => e.isHdr);
-      log.debug("[Render] HDR layer composite frame", {
-        frame: i,
-        time: time.toFixed(2),
-        hdrElement: hdrEl ? { z: hdrEl.zIndex, visible: hdrEl.visible, width: hdrEl.width } : null,
-        stackingCount: stackingInfo.length,
-        activeTransition: activeTransition?.shader
-      });
-    }
-    if (activeTransition && transitionBuffers) {
-      if (hdrPerf) hdrPerf.transitionFrames += 1;
-      const transitionTimingStart = Date.now();
-      const progress = activeTransition.endFrame === activeTransition.startFrame ? 1 : (i - activeTransition.startFrame) / (activeTransition.endFrame - activeTransition.startFrame);
-      const sceneAIds = new Set(sceneElements[activeTransition.fromScene] ?? []);
-      const sceneBIds = new Set(sceneElements[activeTransition.toScene] ?? []);
-      timeHdrPhase(hdrPerf, "canvasClearMs", () => {
-        transitionBuffers.bufferA.fill(0);
-        transitionBuffers.bufferB.fill(0);
-      });
-      const sceneCaptures = [
-        [transitionBuffers.bufferA, sceneAIds],
-        [transitionBuffers.bufferB, sceneBIds]
-      ];
-      for (const [sceneBuf, sceneIds] of sceneCaptures) {
-        assertNotAborted();
-        await captureSceneIntoBuffer({
-          session: domSession,
-          sceneBuf,
-          sceneIds,
-          stackingInfo,
-          time,
-          width,
-          height,
-          nativeHdrIds,
-          nativeHdrImageIds,
-          beforeCaptureHook,
-          hdrCompositeCtx,
-          compositeTransfer,
-          hdrTargetTransfer,
-          hdrPerf,
-          log,
-          frameIdx: i
-        });
-      }
-      const shaderName = activeTransition.shader;
-      const transitionFn = shaderName ? TRANSITIONS[shaderName] ?? crossfade : crossfade;
-      transitionFn(
-        transitionBuffers.bufferA,
-        transitionBuffers.bufferB,
-        transitionBuffers.output,
-        width,
-        height,
-        progress
-      );
-      addHdrTiming(hdrPerf, "transitionCompositeMs", transitionTimingStart);
-      await timeHdrPhaseAsync(
-        hdrPerf,
-        "encoderWriteMs",
-        async () => ensureFrameWritten(await hdrEncoder.writeFrame(transitionBuffers.output), i, hdrEncoder)
-      );
-    } else {
-      if (hdrPerf) hdrPerf.normalFrames += 1;
-      timeHdrPhase(hdrPerf, "canvasClearMs", () => normalCanvas.fill(0));
-      await timeHdrPhaseAsync(
-        hdrPerf,
-        "normalCompositeMs",
-        () => compositeHdrFrame(hdrCompositeCtx, normalCanvas, time, stackingInfo, void 0, i)
+  let { probeSession } = input;
+  let { workerCount } = plan2;
+  const { forceScreenshot } = plan2;
+  let lastBrowserConsole = [];
+  let captureBeyondViewport = probeSession?.options.captureBeyondViewport;
+  const captureCfg = cfg.forceScreenshot === forceScreenshot ? cfg : { ...cfg, forceScreenshot };
+  if (frameRange !== void 0) {
+    if (!Number.isFinite(frameRange.startFrame) || !Number.isFinite(frameRange.endFrame) || frameRange.startFrame < 0 || frameRange.endFrame <= frameRange.startFrame) {
+      throw new Error(
+        `[captureStage] invalid frameRange: ${JSON.stringify(frameRange)}. Expected non-negative startFrame strictly less than endFrame.`
       );
-      if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
-        writeFileExclusiveSync(
-          join19(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
-          normalCanvas
-        );
-      }
-      await timeHdrPhaseAsync(
-        hdrPerf,
-        "encoderWriteMs",
-        async () => ensureFrameWritten(await hdrEncoder.writeFrame(normalCanvas), i, hdrEncoder)
+    }
+    const rangeFrames = frameRange.endFrame - frameRange.startFrame;
+    if (rangeFrames !== totalFrames) {
+      throw new Error(
+        `[captureStage] frameRange size (${rangeFrames}) must equal totalFrames (${totalFrames}). Received frameRange=${JSON.stringify(frameRange)}.`
       );
     }
-    cleanupEndedHdrVideos({
-      time,
-      activeTransition,
-      hdrVideoEndTimes,
-      cleanedUpVideos,
-      hdrVideoFrameSources,
-      sceneElements,
+  }
+  const captureOptions = buildCaptureOptions();
+  const remedy = diskCaptureRemedy(cfg, job.config.format ?? "mp4", job.duration ?? 0, workerCount);
+  const checkDiskProjection = createDiskCaptureProjection({
+    framesDir,
+    totalFrames,
+    measureBytes: () => measureCaptureFrameBytes(workDir, framesDir),
+    remedy
+  });
+  if (workerCount > 1) {
+    const attempts = await executeDiskCaptureWithAdaptiveRetry({
+      serverUrl: fileServer.url,
+      workDir,
+      framesDir,
+      totalFrames,
+      initialWorkerCount: workerCount,
+      allowRetry: shouldAllowAdaptiveCaptureRetry(workerCount, job.config.workers !== void 0),
+      frameExt: frameFileExtension(captureOptions.format),
+      captureOptions,
+      createBeforeCaptureHook: createRenderVideoFrameInjector,
+      abortSignal,
+      frameRangeStart: frameRange?.startFrame,
+      dedupPerfs,
+      onProgress: (progress) => {
+        if (progress.latestWorkerPhase) {
+          if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
+          return;
+        }
+        if (progress.landedFrame) input.onFrameLanded?.(progress.landedFrame);
+        job.framesRendered = progress.capturedFrames;
+        checkDiskProjection(progress.capturedFrames);
+        const frameProgress = progress.capturedFrames / progress.totalFrames;
+        reportFrameProgress(
+          job,
+          `Capturing frame ${progress.capturedFrames}/${progress.totalFrames} (${progress.activeWorkers} workers)`,
+          Math.round(25 + frameProgress * 45),
+          onProgress,
+          progress.capturedFrames,
+          progress.totalFrames
+        );
+      },
+      cfg: captureCfg,
       log
     });
-    job.framesRendered = i + 1;
-    reportFrameProgress(
-      job,
-      `Layered composite frame ${i + 1}/${job.totalFrames}`,
-      Math.round(25 + (i + 1) / totalFrames * 55),
-      onProgress,
-      i + 1,
-      totalFrames
+    captureAttempts.push(...attempts);
+    const lastAttempt = attempts[attempts.length - 1];
+    if (lastAttempt) {
+      workerCount = lastAttempt.workers;
+    }
+    if (probeSession) {
+      captureBeyondViewport = probeSession.options.captureBeyondViewport;
+      lastBrowserConsole = probeSession.browserConsoleBuffer;
+      await closeCaptureSession5(probeSession);
+      probeSession = null;
+    }
+  } else {
+    const sequential = await runSequentialDiskCapture(
+      input,
+      captureOptions,
+      captureCfg,
+      checkDiskProjection
     );
+    probeSession = null;
+    lastBrowserConsole = sequential.lastBrowserConsole;
+    captureBeyondViewport = sequential.captureBeyondViewport;
+  }
+  return { workerCount, probeSession, lastBrowserConsole, captureBeyondViewport };
+}
+async function runSequentialDiskCapture(input, captureOptions, captureCfg, checkDiskProjection) {
+  const {
+    fileServer,
+    framesDir,
+    totalFrames,
+    log,
+    createRenderVideoFrameInjector,
+    abortSignal,
+    assertNotAborted,
+    frameRange
+  } = input;
+  let { probeSession } = input;
+  let lastBrowserConsole = [];
+  let captureBeyondViewport;
+  const { rangeStart, rangeEnd } = resolveCaptureRange(frameRange, totalFrames);
+  const rangeFrames = rangeEnd - rangeStart;
+  const frameExt = frameFileExtension(captureOptions.format);
+  let transientRetriesUsed = 0;
+  let resumeFrom = 0;
+  while (true) {
+    const videoInjector = createRenderVideoFrameInjector();
+    const session = probeSession ?? await createCaptureSession5(
+      fileServer.url,
+      framesDir,
+      captureOptions,
+      videoInjector,
+      captureCfg
+    );
+    captureBeyondViewport = session.options.captureBeyondViewport;
+    try {
+      if (probeSession) {
+        prepareCaptureSessionForReuse3(session, framesDir, videoInjector);
+        probeSession = null;
+      }
+      await ensureSessionReady(session);
+      assertNotAborted();
+      lastBrowserConsole = session.browserConsoleBuffer;
+      await captureSessionFrames(session, {
+        input,
+        rangeStart,
+        rangeEnd,
+        resumeFrom,
+        checkDiskProjection
+      });
+      break;
+    } catch (error) {
+      lastBrowserConsole = session.browserConsoleBuffer;
+      const resume = planTransientResume(error, {
+        abortSignal,
+        rangeFrames,
+        framesDir,
+        frameExt,
+        retriesUsed: transientRetriesUsed
+      });
+      if (resume !== null) {
+        transientRetriesUsed++;
+        resumeFrom = resume;
+        log.warn(
+          "[Render] Transient browser failure during sequential capture; retrying once with a fresh session.",
+          {
+            resumeFrom,
+            rangeFrames,
+            transientRetriesUsed,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+        continue;
+      }
+      throw wrapCaptureStageError(error, lastBrowserConsole);
+    } finally {
+      lastBrowserConsole = session.browserConsoleBuffer;
+      await closeCaptureSession5(session);
+    }
+  }
+  return { lastBrowserConsole, captureBeyondViewport };
+}
+function resolveCaptureRange(frameRange, totalFrames) {
+  return { rangeStart: frameRange?.startFrame ?? 0, rangeEnd: frameRange?.endFrame ?? totalFrames };
+}
+function planTransientResume(error, ctx) {
+  const failure = classifyCaptureFailure2(error, { signal: ctx.abortSignal });
+  const missing = findMissingFrameRanges(ctx.rangeFrames, ctx.framesDir, ctx.frameExt);
+  const [firstMissing] = missing;
+  if (!firstMissing) return null;
+  return isTransientCaptureRetryEligible(failure.kind, missing, ctx.retriesUsed) ? firstMissing.startFrame : null;
+}
+async function ensureSessionReady(session) {
+  if (!session.isInitialized) {
+    await initializeSession5(session);
+    return;
+  }
+  if (process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true") {
+    await completeDeferredDrawElementInit3(session);
+  }
+}
+async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resumeFrom, checkDiskProjection }) {
+  const { job, framesDir, dedupPerfs, assertNotAborted, onProgress } = input;
+  const rangeFrames = rangeEnd - rangeStart;
+  const reportFrame = (fileIndex) => {
+    job.framesRendered = fileIndex + 1;
+    checkDiskProjection(fileIndex + 1);
+    reportFrameProgress(
+      job,
+      `Capturing frame ${fileIndex + 1}/${rangeFrames}`,
+      Math.round(25 + (fileIndex + 1) / rangeFrames * 45),
+      onProgress,
+      fileIndex + 1,
+      rangeFrames
+    );
+  };
+  if (session.workerEncodeEnabled) {
+    let prev = null;
+    const drainPrev = async () => {
+      if (!prev) return;
+      assertNotAborted();
+      const buf = await prev.encodeResult;
+      writeCapturedFrame(session, prev.fileIndex, buf);
+      reportFrame(prev.fileIndex);
+    };
+    for (let i = resumeFrom; i < rangeFrames; i++) {
+      assertNotAborted();
+      const absoluteIdx = rangeStart + i;
+      const time = absoluteIdx * job.config.fps.den / job.config.fps.num;
+      const { encodeResult } = await captureFrameToBufferPipelined2(session, i, time);
+      await drainPrev();
+      prev = { fileIndex: i, encodeResult };
+    }
+    await drainPrev();
+  } else {
+    for (let i = resumeFrom; i < rangeFrames; i++) {
+      assertNotAborted();
+      const absoluteIdx = rangeStart + i;
+      const time = absoluteIdx * job.config.fps.den / job.config.fps.num;
+      await captureFrame(session, i, time);
+      reportFrame(i);
+    }
   }
+  await verifyDiskDrawElementSamples(
+    session,
+    {
+      workerId: 0,
+      startFrame: rangeStart + resumeFrom,
+      endFrame: rangeEnd,
+      outputDir: framesDir,
+      outputFrameOffset: rangeStart
+    },
+    false
+  );
+  dedupPerfs.push(getCapturePerfSummary3(session));
 }
 
-// src/services/render/stages/captureHdrHybridLoop.ts
-import { join as join21 } from "node:path";
+// src/services/render/stages/captureHdrStage.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join23 } from "node:path";
 import {
-  TRANSITIONS as TRANSITIONS2,
-  closeCaptureSession as closeCaptureSession6,
-  createCaptureSession as createCaptureSession6,
-  createFrameReorderBuffer as createFrameReorderBuffer2,
-  crossfade as crossfade2,
-  initTransparentBackground,
-  initializeSession as initializeSession6
+  closeCaptureSession as closeCaptureSession7,
+  cloneCaptureWarnings as cloneCaptureWarnings2,
+  createCaptureSession as createCaptureSession7,
+  initTransparentBackground as initTransparentBackground2,
+  initializeSession as initializeSession7,
+  spawnStreamingEncoder as spawnStreamingEncoder3
 } from "@hyperframes/engine";
+import { fpsToNumber as fpsToNumber8 } from "@hyperframes/core";
 
-// src/services/shaderTransitionWorkerPool.ts
-import { Worker } from "node:worker_threads";
-import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
-import { dirname as dirname7, join as join20 } from "node:path";
-import { createRequire } from "node:module";
-import { existsSync as existsSync13 } from "node:fs";
-import { cpus as cpus2 } from "node:os";
-function resolveWorkerEntry(explicit) {
-  if (explicit && explicit.length > 0) {
-    return { path: explicit, isTs: explicit.endsWith(".ts") };
+// src/services/hdrImageTransferCache.ts
+import { convertTransfer as convertTransfer2 } from "@hyperframes/engine";
+var DEFAULT_MAX_BYTES = 200 * 1024 * 1024;
+function createHdrImageTransferCache(options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  if (!Number.isInteger(maxBytes) || maxBytes < 0) {
+    throw new Error(
+      `createHdrImageTransferCache: maxBytes must be a non-negative integer, got ${String(maxBytes)}`
+    );
   }
-  const override = process.env.HF_SHADER_WORKER_ENTRY;
-  if (override && override.length > 0) {
-    const isTs = override.endsWith(".ts");
-    return { path: override, isTs };
+  const entries = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  function makeKey(imageId, targetTransfer) {
+    return `${imageId}|${targetTransfer}`;
   }
-  const moduleDir = dirname7(fileURLToPath3(import.meta.url));
-  const jsPath = join20(moduleDir, "shaderTransitionWorker.js");
-  if (existsSync13(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join20(moduleDir, "shaderTransitionWorker.ts");
-  return { path: tsPath, isTs: true };
-}
-function buildExecArgv(entryIsTs) {
-  const inherited = [...process.execArgv];
-  if (!entryIsTs) return inherited;
-  const hasLoader = inherited.some(
-    (a) => a.includes("tsx/esm") || a.includes("ts-node/esm") || a.includes("--import")
-  );
-  if (hasLoader) return inherited;
-  try {
-    const require2 = createRequire(import.meta.url);
-    const tsxEsm = require2.resolve("tsx/esm");
-    inherited.push("--import", pathToFileURL(tsxEsm).href);
-  } catch {
+  function evictUntilRoom(needed) {
+    while (totalBytes + needed > maxBytes && entries.size > 0) {
+      const lruKey = entries.keys().next().value;
+      if (lruKey === void 0) break;
+      const evicted = entries.get(lruKey);
+      if (evicted) totalBytes -= evicted.byteLength;
+      entries.delete(lruKey);
+    }
   }
-  return inherited;
+  return {
+    getConverted(imageId, sourceTransfer, targetTransfer, source) {
+      if (sourceTransfer === targetTransfer) {
+        return source;
+      }
+      if (maxBytes === 0) {
+        const fresh = Buffer.from(source);
+        convertTransfer2(fresh, sourceTransfer, targetTransfer);
+        return fresh;
+      }
+      const key = makeKey(imageId, targetTransfer);
+      const existing = entries.get(key);
+      if (existing) {
+        entries.delete(key);
+        entries.set(key, existing);
+        return existing;
+      }
+      const converted = Buffer.from(source);
+      convertTransfer2(converted, sourceTransfer, targetTransfer);
+      if (converted.byteLength > maxBytes) {
+        return converted;
+      }
+      evictUntilRoom(converted.byteLength);
+      entries.set(key, converted);
+      totalBytes += converted.byteLength;
+      return converted;
+    },
+    size() {
+      return entries.size;
+    },
+    bytesUsed() {
+      return totalBytes;
+    }
+  };
+}
+
+// src/services/render/stages/captureHdrSequentialLoop.ts
+import { join as join20 } from "node:path";
+import {
+  TRANSITIONS,
+  crossfade
+} from "@hyperframes/engine";
+async function runSequentialLayeredFrameLoop(input) {
+  const {
+    job,
+    log,
+    width,
+    height,
+    totalFrames,
+    nativeHdrIds,
+    nativeHdrImageIds,
+    hdrCompositeCtx,
+    hdrPerf,
+    hdrEncoder,
+    domSession,
+    transitionRanges,
+    sceneElements,
+    compositeTransfer,
+    hdrTargetTransfer,
+    hdrVideoEndTimes,
+    cleanedUpVideos,
+    hdrVideoFrameSources,
+    debugDumpEnabled,
+    debugDumpDir,
+    assertNotAborted,
+    onProgress
+  } = input;
+  const beforeCaptureHook = domSession.onBeforeCapture;
+  const bufSize = width * height * 6;
+  const hasTransitions = transitionRanges.length > 0;
+  const transitionBuffers = hasTransitions ? {
+    bufferA: Buffer.alloc(bufSize),
+    bufferB: Buffer.alloc(bufSize),
+    output: Buffer.alloc(bufSize)
+  } : null;
+  const normalCanvas = Buffer.alloc(bufSize);
+  for (let i = 0; i < totalFrames; i++) {
+    assertNotAborted();
+    const time = i * job.config.fps.den / job.config.fps.num;
+    if (hdrPerf) hdrPerf.frames += 1;
+    const stackingInfo = await seekInjectAndQueryStacking(
+      domSession.page,
+      time,
+      beforeCaptureHook,
+      nativeHdrIds,
+      hdrPerf,
+      "frameSeekMs",
+      "frameInjectMs",
+      "stackingQueryMs"
+    );
+    const activeTransition = transitionRanges.find((t) => i >= t.startFrame && i <= t.endFrame);
+    if (i % 30 === 0 && (log.isLevelEnabled?.("debug") ?? true)) {
+      const hdrEl = stackingInfo.find((e) => e.isHdr);
+      log.debug("[Render] HDR layer composite frame", {
+        frame: i,
+        time: time.toFixed(2),
+        hdrElement: hdrEl ? { z: hdrEl.zIndex, visible: hdrEl.visible, width: hdrEl.width } : null,
+        stackingCount: stackingInfo.length,
+        activeTransition: activeTransition?.shader
+      });
+    }
+    if (activeTransition && transitionBuffers) {
+      if (hdrPerf) hdrPerf.transitionFrames += 1;
+      const transitionTimingStart = Date.now();
+      const progress = activeTransition.endFrame === activeTransition.startFrame ? 1 : (i - activeTransition.startFrame) / (activeTransition.endFrame - activeTransition.startFrame);
+      const sceneAIds = new Set(sceneElements[activeTransition.fromScene] ?? []);
+      const sceneBIds = new Set(sceneElements[activeTransition.toScene] ?? []);
+      timeHdrPhase(hdrPerf, "canvasClearMs", () => {
+        transitionBuffers.bufferA.fill(0);
+        transitionBuffers.bufferB.fill(0);
+      });
+      const sceneCaptures = [
+        [transitionBuffers.bufferA, sceneAIds],
+        [transitionBuffers.bufferB, sceneBIds]
+      ];
+      for (const [sceneBuf, sceneIds] of sceneCaptures) {
+        assertNotAborted();
+        await captureSceneIntoBuffer({
+          session: domSession,
+          sceneBuf,
+          sceneIds,
+          stackingInfo,
+          time,
+          width,
+          height,
+          nativeHdrIds,
+          nativeHdrImageIds,
+          beforeCaptureHook,
+          hdrCompositeCtx,
+          compositeTransfer,
+          hdrTargetTransfer,
+          hdrPerf,
+          log,
+          frameIdx: i
+        });
+      }
+      const shaderName = activeTransition.shader;
+      const transitionFn = shaderName ? TRANSITIONS[shaderName] ?? crossfade : crossfade;
+      transitionFn(
+        transitionBuffers.bufferA,
+        transitionBuffers.bufferB,
+        transitionBuffers.output,
+        width,
+        height,
+        progress
+      );
+      addHdrTiming(hdrPerf, "transitionCompositeMs", transitionTimingStart);
+      await timeHdrPhaseAsync(
+        hdrPerf,
+        "encoderWriteMs",
+        async () => ensureFrameWritten(await hdrEncoder.writeFrame(transitionBuffers.output), i, hdrEncoder)
+      );
+    } else {
+      if (hdrPerf) hdrPerf.normalFrames += 1;
+      timeHdrPhase(hdrPerf, "canvasClearMs", () => normalCanvas.fill(0));
+      await timeHdrPhaseAsync(
+        hdrPerf,
+        "normalCompositeMs",
+        () => compositeHdrFrame(hdrCompositeCtx, normalCanvas, time, stackingInfo, void 0, i)
+      );
+      if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
+        writeFileExclusiveSync(
+          join20(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          normalCanvas
+        );
+      }
+      await timeHdrPhaseAsync(
+        hdrPerf,
+        "encoderWriteMs",
+        async () => ensureFrameWritten(await hdrEncoder.writeFrame(normalCanvas), i, hdrEncoder)
+      );
+    }
+    cleanupEndedHdrVideos({
+      time,
+      activeTransition,
+      hdrVideoEndTimes,
+      cleanedUpVideos,
+      hdrVideoFrameSources,
+      sceneElements,
+      log
+    });
+    job.framesRendered = i + 1;
+    reportFrameProgress(
+      job,
+      `Layered composite frame ${i + 1}/${job.totalFrames}`,
+      Math.round(25 + (i + 1) / totalFrames * 55),
+      onProgress,
+      i + 1,
+      totalFrames
+    );
+  }
+}
+
+// src/services/render/stages/captureHdrHybridLoop.ts
+import { join as join22 } from "node:path";
+import {
+  TRANSITIONS as TRANSITIONS2,
+  closeCaptureSession as closeCaptureSession6,
+  createCaptureSession as createCaptureSession6,
+  createFrameReorderBuffer as createFrameReorderBuffer2,
+  crossfade as crossfade2,
+  initTransparentBackground,
+  initializeSession as initializeSession6
+} from "@hyperframes/engine";
+
+// src/services/shaderTransitionWorkerPool.ts
+import { Worker } from "node:worker_threads";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+import { dirname as dirname8, join as join21 } from "node:path";
+import { createRequire } from "node:module";
+import { existsSync as existsSync13 } from "node:fs";
+import { cpus as cpus2 } from "node:os";
+function resolveWorkerEntry(explicit) {
+  if (explicit && explicit.length > 0) {
+    return { path: explicit, isTs: explicit.endsWith(".ts") };
+  }
+  const override = process.env.HF_SHADER_WORKER_ENTRY;
+  if (override && override.length > 0) {
+    const isTs = override.endsWith(".ts");
+    return { path: override, isTs };
+  }
+  const moduleDir = dirname8(fileURLToPath3(import.meta.url));
+  const jsPath = join21(moduleDir, "shaderTransitionWorker.js");
+  if (existsSync13(jsPath)) return { path: jsPath, isTs: false };
+  const tsPath = join21(moduleDir, "shaderTransitionWorker.ts");
+  return { path: tsPath, isTs: true };
+}
+function buildExecArgv(entryIsTs) {
+  const inherited = [...process.execArgv];
+  if (!entryIsTs) return inherited;
+  const hasLoader = inherited.some(
+    (a) => a.includes("tsx/esm") || a.includes("ts-node/esm") || a.includes("--import")
+  );
+  if (hasLoader) return inherited;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const tsxEsm = require2.resolve("tsx/esm");
+    inherited.push("--import", pathToFileURL(tsxEsm).href);
+  } catch {
+  }
+  return inherited;
 }
 async function createShaderTransitionWorkerPool(opts) {
   const cpuCount = Math.max(1, cpus2().length);
@@ -9812,7 +10253,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join21(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join22(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -9998,7 +10439,7 @@ async function runCaptureHdrStage(input) {
         if (hdrVideoFrameSources.has(v.id)) hdrVideoEndTimes.set(v.id, v.end);
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-      const debugDumpDir = debugDumpEnabled ? join22(framesDir, "debug-composite") : null;
+      const debugDumpDir = debugDumpEnabled ? join23(framesDir, "debug-composite") : null;
       if (debugDumpDir && !existsSync14(debugDumpDir)) {
         mkdirSync7(debugDumpDir, { recursive: true });
       }
@@ -10158,19 +10599,19 @@ import {
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync4,
   readFileSync as readFileSync7,
-  rmSync as rmSync7,
+  rmSync as rmSync9,
   statSync as statSync5,
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname8, join as join24 } from "node:path";
+import { dirname as dirname9, join as join24 } from "node:path";
 import {
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
   formatFfmpegError,
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME2,
   resolveConfig,
-  runFfmpeg as runFfmpeg3,
+  runFfmpeg as runFfmpeg5,
   spawnStreamingEncoder as spawnStreamingEncoder4
 } from "@hyperframes/engine";
 import {
@@ -10179,791 +10620,354 @@ import {
 } from "@hyperframes/core";
 
 // src/services/render/stages/gifEncodeArgs.ts
-import { join as join23 } from "node:path";
+import { frameSequencePath } from "@hyperframes/engine";
 function fpsToFfmpegArg2(fps) {
   return fps.den === 1 ? String(fps.num) : `${fps.num}/${fps.den}`;
 }
-var KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA = ["-reinit_filter", "0"];
-var WRITE_EVERY_FRAME_WHOLE = ["-gifflags", "0"];
-var FAIL_ON_UNREADABLE_FRAME_INSTEAD_OF_ENDING_THERE = ["-xerror"];
-function framesInput(input, fpsArg) {
-  return [
-    ...FAIL_ON_UNREADABLE_FRAME_INSTEAD_OF_ENDING_THERE,
-    "-framerate",
-    fpsArg,
-    ...KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA,
-    "-i",
-    join23(input.framesDir, input.framePattern)
-  ];
-}
-function buildGifPalettegenArgs(input) {
-  const fpsArg = fpsToFfmpegArg2(input.fps);
-  const transparency = input.preserveAlpha ? ":reserve_transparent=1" : "";
-  return [
-    "-y",
-    ...framesInput(input, fpsArg),
-    "-vf",
-    `fps=${fpsArg},palettegen=stats_mode=diff${transparency}`,
-    input.palettePath
-  ];
-}
-function buildGifPaletteuseArgs(input) {
-  const fpsArg = fpsToFfmpegArg2(input.fps);
-  const transparency = input.preserveAlpha ? ":alpha_threshold=128" : "";
-  return [
-    "-y",
-    ...framesInput(input, fpsArg),
-    "-i",
-    input.palettePath,
-    "-lavfi",
-    `fps=${fpsArg} [x]; [x][1:v] paletteuse=dither=sierra2_4a${transparency}`,
-    "-loop",
-    String(input.loop),
-    ...input.wholeFrames ? WRITE_EVERY_FRAME_WHOLE : [],
-    input.outputPath
-  ];
-}
-
-// src/services/render/stages/encodeStage.ts
-import { frameFileExtension as frameFileExtension2 } from "@hyperframes/engine";
-function resolveGifLoop(loop) {
-  const resolved = loop ?? 0;
-  if (!Number.isInteger(resolved) || resolved < 0 || resolved > 65535) {
-    throw new Error(`[Render] gifLoop must be an integer between 0 and 65535 (got ${resolved})`);
-  }
-  return resolved;
-}
-function gifEncodeFailure(startTime, outputPath, error, failureReason) {
-  return {
-    success: false,
-    outputPath,
-    durationMs: Date.now() - startTime,
-    framesEncoded: 0,
-    fileSize: 0,
-    error,
-    failureReason
-  };
-}
-async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
-  const { outputPath } = argsInput;
-  const result = await runFfmpeg3(buildGifPaletteuseArgs({ ...argsInput, wholeFrames: true }), run);
-  if (!result.success) {
-    const error = formatFfmpegError(result.exitCode, result.stderr);
-    return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
-  }
-  const gif = readFileSync7(outputPath);
-  if (!clearGifFramesBeforeNext(gif)) {
-    const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
-    return gifEncodeFailure(startTime, outputPath, error);
-  }
-  writeFileSync4(outputPath, gif);
-  return null;
-}
-async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
-  const startTime = Date.now();
-  const files = readdirSync4(framesDir).filter((file) => file.match(/\.(jpg|jpeg|png)$/i));
-  const frameCount = files.length;
-  if (frameCount === 0) {
-    return gifEncodeFailure(startTime, outputPath, "[FFmpeg] No frame files found in directory");
-  }
-  const argsInput = {
-    framesDir,
-    framePattern,
-    palettePath: input.palettePath,
-    outputPath,
-    fps: input.fps,
-    loop: input.loop,
-    preserveAlpha: input.preserveAlpha
-  };
-  try {
-    const run = { signal: input.signal, timeout: input.timeout };
-    for (const args of [buildGifPalettegenArgs(argsInput), buildGifPaletteuseArgs(argsInput)]) {
-      const result = await runFfmpeg3(args, run);
-      if (!result.success) {
-        const error = formatFfmpegError(result.exitCode, result.stderr);
-        return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
-      }
-    }
-    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync7(outputPath)) !== false) {
-      const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
-      if (failure) return failure;
-    }
-    const fileSize = existsSync15(outputPath) ? statSync5(outputPath).size : 0;
-    return {
-      success: true,
-      outputPath,
-      durationMs: Date.now() - startTime,
-      framesEncoded: frameCount,
-      fileSize
-    };
-  } finally {
-    rmSync7(input.palettePath, { force: true });
-  }
-}
-function startEncodeProgress(job, stage, onProgress) {
-  const total = job.totalFrames ?? 0;
-  updateJobStatus(job, "encoding", stage, 75, onProgress, {
-    code: "encode",
-    ...total > 0 && { done: 0, total }
-  });
-  return (frames = total) => reportEncodeProgress(job, frames, total, onProgress, 75);
-}
-function resolveEngineConfig(input) {
-  return input.engineConfig ?? input.job.config.producerConfig ?? resolveConfig();
-}
-function videoEncoderOptions(input, engineCfg) {
-  const { job, preset } = input;
-  return {
-    fps: job.config.fps,
-    width: input.width,
-    height: input.height,
-    codec: preset.codec,
-    preset: preset.preset,
-    quality: input.effectiveQuality,
-    bitrate: input.effectiveBitrate,
-    pixelFormat: preset.pixelFormat,
-    vp9CpuUsed: engineCfg.vp9CpuUsed,
-    useGpu: job.config.useGpu,
-    hdr: preset.hdr,
-    // Distributed chunk renders pass these so the encoder writes closed-GOP
-    // keyframes that survive `-f concat -c copy` at assemble time. In-process
-    // renders leave both undefined → preserves the existing open-GOP output.
-    lockGopForChunkConcat: input.lockGopForChunkConcat === true,
-    gopSize: input.gopSize
-  };
-}
-function canEncodeWhileCapturing(input, workerCount, cpuCount) {
-  return workerCount > 1 && workerCount < cpuCount && !input.isPngSequence && !input.isGif && !input.enableChunkedEncode && input.preset.codec === "h264" && !input.preset.hdr && input.job.config.useGpu !== true && input.captureImageFormat === "jpeg" && input.lockGopForChunkConcat !== true;
-}
-async function readLandedFrame(workerPath, mergedPath) {
-  if (workerPath !== void 0) {
-    try {
-      return await readFile2(workerPath);
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-  }
-  return readFile2(mergedPath);
-}
-function encodeWhileCapturing(input, totalFrames) {
-  const engineCfg = resolveEngineConfig(input);
-  const stop = new AbortController();
-  const signal = input.abortSignal ? AbortSignal.any([input.abortSignal, stop.signal]) : stop.signal;
-  const landed = /* @__PURE__ */ new Map();
-  let captureDone = false;
-  let framesFed = 0;
-  let wake = null;
-  const nudge = () => {
-    wake?.();
-    wake = null;
-  };
-  signal.addEventListener("abort", nudge, { once: true });
-  let reportFed = null;
-  const encoder = spawnStreamingEncoder4(
-    input.videoOnlyPath,
-    { ...videoEncoderOptions(input, engineCfg), imageFormat: "jpeg" },
-    signal,
-    engineCfg
-  );
-  const fed = (async () => {
-    const stream = await encoder;
-    for (let next = 0; next < totalFrames; next++) {
-      while (!landed.has(next) && !captureDone && !signal.aborted) {
-        await new Promise((resolve12) => wake = resolve12);
-      }
-      if (signal.aborted) return;
-      const mergedPath = join24(input.framesDir, formatCaptureFrameName(next, "jpg"));
-      const frame = await readLandedFrame(landed.get(next), mergedPath);
-      landed.delete(next);
-      if (!await stream.writeFrame(frame)) {
-        throw new Error(stream.getExitError() ?? "encoder exited before the last frame");
-      }
-      framesFed++;
-      reportFed?.(framesFed);
-    }
-  })().then(
-    () => void 0,
-    (error) => error ?? new Error("encode failed")
-  );
-  const closeEncoder = async () => (await encoder.catch(() => null))?.close();
-  return {
-    onFrameLanded: (frame) => {
-      landed.set(frame.index, frame.path);
-      nudge();
-    },
-    finish: async () => {
-      const start = Date.now();
-      captureDone = true;
-      input.log.info("[Render] Encoded frames while capturing", {
-        framesFed,
-        totalFrames
-      });
-      const encoded = startEncodeProgress(input.job, "Encoding video", input.onProgress);
-      reportFed = encoded;
-      nudge();
-      const failure = await fed;
-      const result = await closeEncoder();
-      input.assertNotAborted();
-      if (failure === void 0 && result?.success) {
-        encoded();
-        return { encodeMs: Date.now() - start };
-      }
-      input.log.warn(
-        "[Render] Encoding while capturing failed; encoding the frames after capture",
-        {
-          error: String(failure ?? result?.error)
-        }
-      );
-      return runEncodeStage(input);
-    },
-    abort: async () => {
-      stop.abort();
-      await fed;
-      await closeEncoder();
-    },
-    get framesFed() {
-      return framesFed;
-    }
-  };
-}
-async function runEncodeStage(input) {
-  const {
-    job,
-    log,
-    outputPath,
-    framesDir,
-    videoOnlyPath,
-    needsAlpha,
-    hasAudio,
-    audioOutputPath,
-    isPngSequence,
-    isGif,
-    enableChunkedEncode,
-    chunkedEncodeSize,
-    abortSignal,
-    assertNotAborted,
-    onProgress
-  } = input;
-  const stage5Start = Date.now();
-  if (isPngSequence) {
-    const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync15(outputPath)) mkdirSync8(outputPath, { recursive: true });
-    const captured = readdirSync4(framesDir).filter((name) => name.endsWith(".png")).sort();
-    if (captured.length === 0) {
-      throw new Error(
-        `[Render] png-sequence output requested but no PNGs were captured to ${framesDir}`
-      );
-    }
-    captured.forEach((name, i) => {
-      const dst = join24(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync3(join24(framesDir, name), dst);
-    });
-    if (hasAudio && audioOutputPath && existsSync15(audioOutputPath)) {
-      copyFileSync3(audioOutputPath, join24(outputPath, MIXED_AUDIO_FILENAME2));
-      log.info(
-        `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
-      );
-    }
-    encoded();
-    return { encodeMs: Date.now() - stage5Start };
-  }
-  const engineCfg = resolveEngineConfig(input);
-  if (isGif) {
-    const encoded = startEncodeProgress(job, "Encoding GIF", onProgress);
-    if (hasAudio) {
-      log.warn("[Render] GIF output does not support audio; audio tracks will be ignored.");
-    }
-    const frameExt2 = frameFileExtension2(input.captureImageFormat);
-    const framePattern2 = `frame_%06d.${frameExt2}`;
-    const loop = resolveGifLoop(job.config.gifLoop);
-    const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
-      fps: job.config.fps,
-      loop,
-      palettePath: join24(dirname8(videoOnlyPath), "gif-palette.png"),
-      preserveAlpha: needsAlpha,
-      signal: abortSignal,
-      timeout: engineCfg.ffmpegEncodeTimeout
-    });
-    assertNotAborted();
-    if (!encodeResult2.success) {
-      throw encoderFailureError("Encoding failed", encodeResult2);
-    }
-    encoded();
-    return { encodeMs: Date.now() - stage5Start };
-  }
-  const onFramesEncoded = startEncodeProgress(job, "Encoding video", onProgress);
-  const baseScaledEncodeTimeout = Math.ceil((job.duration ?? 0) * 4e3);
-  const scaledEncodeTimeout = baseScaledEncodeTimeout * (job.config.quality === "high" ? 6 : 1);
-  const videoEngineCfg = scaledEncodeTimeout > engineCfg.ffmpegEncodeTimeout ? { ...engineCfg, ffmpegEncodeTimeout: scaledEncodeTimeout } : engineCfg;
-  const frameExt = frameFileExtension2(input.captureImageFormat);
-  const framePattern = `frame_%06d.${frameExt}`;
-  const encoderOpts = videoEncoderOptions(input, engineCfg);
-  const encodeResult = enableChunkedEncode ? await encodeFramesChunkedConcat(
-    framesDir,
-    framePattern,
-    videoOnlyPath,
-    encoderOpts,
-    chunkedEncodeSize,
-    abortSignal,
-    videoEngineCfg,
-    onFramesEncoded
-  ) : await encodeFramesFromDir(
-    framesDir,
-    framePattern,
-    videoOnlyPath,
-    encoderOpts,
-    abortSignal,
-    videoEngineCfg,
-    onFramesEncoded
-  );
-  assertNotAborted();
-  if (!encodeResult.success) {
-    throw encoderFailureError("Encoding failed", encodeResult);
-  }
-  onFramesEncoded();
-  return { encodeMs: Date.now() - stage5Start };
-}
-
-// src/services/render/stages/assembleStage.ts
-import { applyFaststart, muxVideoWithAudio, packageHls } from "@hyperframes/engine";
-import { extname as extname3 } from "node:path";
-
-// src/services/render/audioPadTrim.ts
-import { spawn } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, renameSync as renameSync4, rmSync as rmSync8 } from "node:fs";
-import { dirname as dirname9, join as join25 } from "node:path";
-import {
-  DEFAULT_CONFIG,
-  describeFfmpegFailure as describeFfmpegFailure2,
-  encodeAac,
-  extractAudioMetadata as extractAudioMetadata3,
-  getFfprobeBinary,
-  ManagedChildProcess,
-  runFfmpeg as runFfmpeg5,
-  trackChildProcess
-} from "@hyperframes/engine";
-import { redactKnownPaths, redactTelemetryString as redactTelemetryString3 } from "@hyperframes/core";
-
-// src/services/render/audioTruePeak.ts
-import {
-  aacSegmentCount,
-  describeFfmpegFailure,
-  extractAudioMetadata as extractAudioMetadata2,
-  runFfmpeg as runFfmpeg4
-} from "@hyperframes/engine";
-var toDbfs = (token) => token.toLowerCase() === "-inf" ? Number.NEGATIVE_INFINITY : Number(token);
-function checkedDbfs(value) {
-  if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY) {
-    throw new Error("[audioTruePeak] FFmpeg did not report AAC true peak");
-  }
-  return value;
-}
-async function scanTruePeak(audioPath, trim, timeoutMs, signal) {
-  let firstBlock;
-  let laterBlocks = Number.NEGATIVE_INFINITY;
-  let partialLine = "";
-  const readLines = (chunk) => {
-    const lines = (partialLine + chunk).split(/\r|\n/);
-    partialLine = lines.pop() ?? "";
-    for (const line of lines) {
-      const ftpk = /FTPK:([^d]*)dBFS/.exec(line)?.[1];
-      if (!ftpk) continue;
-      const block = Math.max(...ftpk.trim().split(/\s+/).map(toDbfs));
-      if (firstBlock === void 0) firstBlock = block;
-      else laterBlocks = Math.max(laterBlocks, block);
-    }
-  };
-  const result = await runFfmpeg4(
-    ["-i", audioPath, "-map", "0:a:0", "-vn", "-af", `${trim}ebur128=peak=true`, "-f", "null", "-"],
-    { signal, timeout: timeoutMs, onStderr: readLines }
-  );
-  if (!result.success) {
-    throw new Error(`[audioTruePeak] ${describeFfmpegFailure(result, timeoutMs)}`);
-  }
-  const summary = [...result.stderr.matchAll(/^\s*Peak:\s*([+-]?(?:[\d.]+|inf)) dBFS$/gim)];
-  return {
-    peak: checkedDbfs(toDbfs(summary.at(-1)?.[1] ?? "nan")),
-    firstBlock: checkedDbfs(firstBlock ?? Number.NEGATIVE_INFINITY),
-    laterBlocks: checkedDbfs(laterBlocks)
-  };
-}
-async function measureTruePeakDbfs(audioPath, options) {
-  const { timeoutMs, signal } = options;
-  const wholeFile = async () => (await scanTruePeak(audioPath, "", timeoutMs, signal)).peak;
-  const { durationSeconds, sampleRate } = await extractAudioMetadata2(audioPath, { signal });
-  const block = 4800;
-  const count = sampleRate === 48e3 && Number.isFinite(durationSeconds) ? aacSegmentCount(durationSeconds) : 1;
-  if (count === 1) return wholeFile();
-  const cut = (k) => k * Math.floor(durationSeconds * 10 / count) * block;
-  const peers = new AbortController();
-  const segmentSignal = signal ? AbortSignal.any([signal, peers.signal]) : peers.signal;
-  const scans = await Promise.all(
-    Array.from({ length: count }, (_, k) => {
-      const start = k === 0 ? 0 : cut(k) - block;
-      const end = k === count - 1 ? "" : `:end_sample=${cut(k + 1)}`;
-      return scanTruePeak(
-        audioPath,
-        `atrim=start_sample=${start}${end},`,
-        timeoutMs,
-        segmentSignal
-      );
-    })
-  ).catch((error) => {
-    peers.abort();
-    throw error;
-  });
-  const last = scans[count - 1];
-  const counted = Math.max(scans[0].peak, ...scans.slice(1).map((scan) => scan.laterBlocks));
-  if (last.peak > last.firstBlock || last.peak <= counted) return Math.max(counted, last.peak);
-  return wholeFile();
-}
-
-// src/services/render/audioPadTrim.ts
-var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
-var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
-var AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB = 0.5;
-var MAX_TRUE_PEAK_CORRECTION_PASSES = 3;
-function aacTruePeakCorrectionFilter(targetDurationSeconds, attenuationDb) {
-  return `volume=${attenuationDb.toFixed(3)}dB,apad,atrim=0:${formatSeconds(targetDurationSeconds)}`;
-}
-function buildPadTrimAudioPlan(audioPath, outputPath, sourceDurationSeconds, targetDurationSeconds) {
-  const delta = targetDurationSeconds - sourceDurationSeconds;
-  const targetSec = formatSeconds(targetDurationSeconds);
-  if (Math.abs(delta) < AUDIO_DURATION_TOLERANCE_SECONDS) {
-    return {
-      operation: "copy",
-      steps: [{ kind: "copy", args: ["-i", audioPath, "-c:a", "copy", "-y", outputPath] }],
-      cleanupPaths: []
-    };
-  }
-  if (delta > 0) {
-    return {
-      operation: "pad",
-      steps: [{ kind: "normalize", filter: `apad,atrim=0:${targetSec}` }],
-      cleanupPaths: []
-    };
-  }
-  return {
-    operation: "trim",
-    steps: [{ kind: "trim", filter: `atrim=duration=${targetSec},asetpts=PTS-STARTPTS` }],
-    cleanupPaths: []
-  };
-}
-function formatSeconds(sec) {
-  return sec.toFixed(6);
-}
-function sanitizeProbeFailure(reason, paths) {
-  const message = reason instanceof Error ? reason.message : String(reason);
-  const keepFfmpegsLastLineUncapped = Number.POSITIVE_INFINITY;
-  return redactTelemetryString3(redactKnownPaths(message, paths), keepFfmpegsLastLineUncapped);
-}
-async function padOrTrimAudioToVideoFrameCount(input) {
-  const probeVideo = input.probeVideoFrameInfo ?? ((videoPath) => defaultProbeVideoFrameInfo(videoPath, input.signal));
-  const probeAudio = input.probeAudioInfo ?? defaultProbeAudioInfo;
-  const timeoutMs = input.timeoutMs ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const runner = input.runFfmpeg ?? ((args) => defaultRunFfmpeg(args, timeoutMs, input.signal));
-  const encode = input.encodeAac ?? defaultAacEncoder(timeoutMs, input.signal);
-  const probeTruePeak = input.probeAudioTruePeakDbfs ?? (input.runFfmpeg || input.encodeAac ? void 0 : (audioPath, signal) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }));
-  const [videoResult, audioResult] = await Promise.allSettled([
-    probeVideo(input.videoPath),
-    probeAudio(input.audioPath, input.signal)
-  ]);
-  const probePaths = [input.videoPath, input.audioPath, input.outputPath];
-  if (videoResult.status === "rejected") {
-    return failResult(
-      input.outputPath,
-      0,
-      audioResult.status === "fulfilled" ? audioResult.value.durationSeconds : 0,
-      `audioPadTrim: failed to probe video: ${sanitizeProbeFailure(
-        videoResult.reason,
-        probePaths
-      )}`
-    );
-  }
-  if (audioResult.status === "rejected") {
-    return failResult(
-      input.outputPath,
-      0,
-      0,
-      `audioPadTrim: failed to probe audio: ${sanitizeProbeFailure(
-        audioResult.reason,
-        probePaths
-      )}`
-    );
-  }
-  const videoInfo = videoResult.value;
-  const audioInfo = audioResult.value;
-  if (!Number.isFinite(videoInfo.frameCount) || videoInfo.frameCount <= 0 || !Number.isFinite(videoInfo.fpsNum) || videoInfo.fpsNum <= 0 || !Number.isFinite(videoInfo.fpsDen) || videoInfo.fpsDen <= 0) {
-    return failResult(
-      input.outputPath,
-      0,
-      audioInfo.durationSeconds,
-      `audioPadTrim: invalid video frame info: ${JSON.stringify(videoInfo)}`
-    );
-  }
-  const targetDurationSeconds = videoInfo.frameCount * videoInfo.fpsDen / videoInfo.fpsNum;
-  const plan2 = buildPadTrimAudioPlan(
-    input.audioPath,
-    input.outputPath,
-    audioInfo.durationSeconds,
-    targetDurationSeconds
-  );
-  try {
-    for (const step of plan2.steps) {
-      const ffmpegResult = step.kind === "copy" ? await runner(step.args) : await encode(input.audioPath, input.outputPath, targetDurationSeconds, step.filter);
-      if (!ffmpegResult.success) {
-        return {
-          success: false,
-          outputPath: input.outputPath,
-          targetDurationSeconds,
-          sourceDurationSeconds: audioInfo.durationSeconds,
-          operation: plan2.operation,
-          error: ffmpegResult.error,
-          failureReason: ffmpegResult.failureReason
-        };
-      }
-    }
-  } catch (err) {
-    return {
-      success: false,
-      outputPath: input.outputPath,
-      targetDurationSeconds,
-      sourceDurationSeconds: audioInfo.durationSeconds,
-      operation: plan2.operation,
-      error: `audioPadTrim: failed to materialize ${plan2.operation}: ${err instanceof Error ? err.message : String(err)}`
-    };
-  } finally {
-    for (const path of plan2.cleanupPaths) rmSync8(path, { force: true });
-  }
-  let loweredDb = 0;
-  if (probeTruePeak) {
-    const correction = await enforceAacTruePeak({
-      audioPath: input.outputPath,
-      targetDurationSeconds,
-      signal: input.signal,
-      probeTruePeak,
-      encode
-    });
-    if (!correction.success) {
-      return {
-        success: false,
-        outputPath: input.outputPath,
-        targetDurationSeconds,
-        sourceDurationSeconds: audioInfo.durationSeconds,
-        operation: plan2.operation,
-        error: correction.error,
-        failureReason: correction.failureReason
-      };
-    }
-    loweredDb = correction.loweredDb ?? 0;
+var KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA = ["-reinit_filter", "0"];
+var WRITE_EVERY_FRAME_WHOLE = ["-gifflags", "0"];
+var FAIL_ON_UNREADABLE_FRAME_INSTEAD_OF_ENDING_THERE = ["-xerror"];
+function framesInput(input, fpsArg) {
+  return [
+    ...FAIL_ON_UNREADABLE_FRAME_INSTEAD_OF_ENDING_THERE,
+    "-framerate",
+    fpsArg,
+    ...KEEP_FILTER_GRAPH_WHEN_FRAMES_DROP_ALPHA,
+    "-i",
+    frameSequencePath(input.framesDir, input.framePattern)
+  ];
+}
+function buildGifPalettegenArgs(input) {
+  const fpsArg = fpsToFfmpegArg2(input.fps);
+  const transparency = input.preserveAlpha ? ":reserve_transparent=1" : "";
+  return [
+    "-y",
+    ...framesInput(input, fpsArg),
+    "-vf",
+    `fps=${fpsArg},palettegen=stats_mode=diff${transparency}`,
+    input.palettePath
+  ];
+}
+function buildGifPaletteuseArgs(input) {
+  const fpsArg = fpsToFfmpegArg2(input.fps);
+  const transparency = input.preserveAlpha ? ":alpha_threshold=128" : "";
+  return [
+    "-y",
+    ...framesInput(input, fpsArg),
+    "-i",
+    input.palettePath,
+    "-lavfi",
+    `fps=${fpsArg} [x]; [x][1:v] paletteuse=dither=sierra2_4a${transparency}`,
+    "-loop",
+    String(input.loop),
+    ...input.wholeFrames ? WRITE_EVERY_FRAME_WHOLE : [],
+    input.outputPath
+  ];
+}
+
+// src/services/render/stages/encodeStage.ts
+import { frameFileExtension as frameFileExtension2 } from "@hyperframes/engine";
+function resolveGifLoop(loop) {
+  const resolved = loop ?? 0;
+  if (!Number.isInteger(resolved) || resolved < 0 || resolved > 65535) {
+    throw new Error(`[Render] gifLoop must be an integer between 0 and 65535 (got ${resolved})`);
   }
+  return resolved;
+}
+function gifEncodeFailure(startTime, outputPath, error, failureReason) {
   return {
-    success: true,
-    outputPath: input.outputPath,
-    targetDurationSeconds,
-    sourceDurationSeconds: audioInfo.durationSeconds,
-    operation: plan2.operation,
-    ...loweredDb > 0 ? { audioLoweredDb: loweredDb } : {}
+    success: false,
+    outputPath,
+    durationMs: Date.now() - startTime,
+    framesEncoded: 0,
+    fileSize: 0,
+    error,
+    failureReason
   };
 }
-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) => measureTruePeakDbfs(audioPath, { timeoutMs, signal }),
-    encode: defaultAacEncoder(timeoutMs, input.signal, input.sourcePath)
-  });
+async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
+  const { outputPath } = argsInput;
+  const result = await runFfmpeg5(buildGifPaletteuseArgs({ ...argsInput, wholeFrames: true }), run);
+  if (!result.success) {
+    const error = formatFfmpegError(result.exitCode, result.stderr);
+    return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
+  }
+  const gif = readFileSync7(outputPath);
+  if (!clearGifFramesBeforeNext(gif)) {
+    const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
+    return gifEncodeFailure(startTime, outputPath, error);
+  }
+  writeFileSync4(outputPath, gif);
+  return null;
 }
-async function enforceAacTruePeak(input) {
-  let scratchDir;
+async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
+  const startTime = Date.now();
+  const files = readdirSync4(framesDir).filter((file) => file.match(/\.(jpg|jpeg|png)$/i));
+  const frameCount = files.length;
+  if (frameCount === 0) {
+    return gifEncodeFailure(startTime, outputPath, "[FFmpeg] No frame files found in directory");
+  }
+  const argsInput = {
+    framesDir,
+    framePattern,
+    palettePath: input.palettePath,
+    outputPath,
+    fps: input.fps,
+    loop: input.loop,
+    preserveAlpha: input.preserveAlpha
+  };
   try {
-    scratchDir = mkdtempSync3(join25(dirname9(input.audioPath), ".true-peak-"));
-    const correctedPath = join25(scratchDir, "audio.m4a");
-    const measurements = [];
-    let attenuationDb = 0;
-    let measuredPath = input.audioPath;
-    for (let pass = 0; pass <= MAX_TRUE_PEAK_CORRECTION_PASSES; pass += 1) {
-      const truePeakDbfs = await input.probeTruePeak(measuredPath, input.signal);
-      measurements.push(
-        `pass ${pass}: ${truePeakDbfs.toFixed(3)} dBFS at ${attenuationDb.toFixed(3)} dB attenuation`
-      );
-      if (Number.isNaN(truePeakDbfs) || truePeakDbfs === Number.POSITIVE_INFINITY) {
-        return { success: false, error: "audioPadTrim: FFmpeg reported an invalid true peak" };
-      }
-      if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
-        if (measuredPath !== correctedPath) return { success: true };
-        renameSync4(correctedPath, input.audioPath);
-        return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
-      }
-      if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
-      const headroomDb = AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB * 2 ** pass;
-      attenuationDb += AAC_DELIVERY_TRUE_PEAK_DBFS - headroomDb - truePeakDbfs;
-      const result = await input.encode(
-        input.audioPath,
-        correctedPath,
-        input.targetDurationSeconds,
-        aacTruePeakCorrectionFilter(input.targetDurationSeconds, attenuationDb)
-      );
+    const run = { signal: input.signal, timeout: input.timeout };
+    for (const args of [buildGifPalettegenArgs(argsInput), buildGifPaletteuseArgs(argsInput)]) {
+      const result = await runFfmpeg5(args, run);
       if (!result.success) {
-        return {
-          success: false,
-          error: sanitizeProbeFailure(
-            result.error ?? "audioPadTrim: failed to constrain AAC true peak",
-            [input.audioPath, correctedPath]
-          ),
-          failureReason: result.failureReason
-        };
+        const error = formatFfmpegError(result.exitCode, result.stderr);
+        return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
       }
-      measuredPath = correctedPath;
     }
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync7(outputPath)) !== false) {
+      const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
+      if (failure) return failure;
+    }
+    const fileSize = existsSync15(outputPath) ? statSync5(outputPath).size : 0;
     return {
-      success: false,
-      error: `audioPadTrim: AAC true peak remained above ${AAC_DELIVERY_TRUE_PEAK_DBFS} dBFS after ${MAX_TRUE_PEAK_CORRECTION_PASSES} correction passes; ${measurements.join("; ")}`
-    };
-  } catch (err) {
-    return {
-      success: false,
-      error: `audioPadTrim: failed to validate AAC true peak: ${sanitizeProbeFailure(
-        err,
-        scratchDir ? [input.audioPath, scratchDir] : [input.audioPath]
-      )}`
+      success: true,
+      outputPath,
+      durationMs: Date.now() - startTime,
+      framesEncoded: frameCount,
+      fileSize
     };
   } finally {
-    if (scratchDir) rmSync8(scratchDir, { recursive: true, force: true });
+    rmSync9(input.palettePath, { force: true });
   }
 }
-function failResult(outputPath, target, source, error) {
-  return {
-    success: false,
-    outputPath,
-    targetDurationSeconds: target,
-    sourceDurationSeconds: source,
-    operation: "copy",
-    error
-  };
-}
-async function defaultProbeVideoFrameInfo(videoPath, signal) {
-  const fastInfo = await runFfprobeJson(
-    [
-      "-v",
-      "error",
-      "-select_streams",
-      "v:0",
-      "-show_entries",
-      "stream=nb_frames,r_frame_rate",
-      "-of",
-      "json",
-      "--",
-      videoPath
-    ],
-    signal
-  );
-  let stream = fastInfo.streams?.[0];
-  const fastCount = Number(stream?.nb_frames);
-  if (stream && Number.isFinite(fastCount) && fastCount > 0) {
-    return { frameCount: fastCount, ...parseFrameRate(stream.r_frame_rate ?? "") };
-  }
-  const slowInfo = await runFfprobeJson(
-    [
-      "-v",
-      "error",
-      "-select_streams",
-      "v:0",
-      "-count_packets",
-      "-show_entries",
-      "stream=nb_read_packets,r_frame_rate",
-      "-of",
-      "json",
-      "--",
-      videoPath
-    ],
-    signal
-  );
-  stream = slowInfo.streams?.[0];
-  if (!stream) throw new Error(`ffprobe found no video stream in ${videoPath}`);
-  const slowCount = Number(stream.nb_read_packets);
-  if (!Number.isFinite(slowCount) || slowCount <= 0) {
-    throw new Error(`ffprobe returned no frame count: ${JSON.stringify(stream)}`);
-  }
-  return { frameCount: slowCount, ...parseFrameRate(stream.r_frame_rate ?? "") };
+function startEncodeProgress(job, stage, onProgress) {
+  const total = job.totalFrames ?? 0;
+  updateJobStatus(job, "encoding", stage, 75, onProgress, {
+    code: "encode",
+    ...total > 0 && { done: 0, total }
+  });
+  return (frames = total) => reportEncodeProgress(job, frames, total, onProgress, 75);
 }
-function parseFrameRate(rate) {
-  const [n, d] = rate.split("/");
-  const fpsNum = Number(n);
-  const fpsDen = d === void 0 ? 1 : Number(d);
-  if (!Number.isFinite(fpsNum) || !Number.isFinite(fpsDen) || fpsNum <= 0 || fpsDen <= 0) {
-    throw new Error(`Invalid r_frame_rate: ${JSON.stringify(rate)}`);
-  }
-  return { fpsNum, fpsDen };
+function resolveEngineConfig(input) {
+  return input.engineConfig ?? input.job.config.producerConfig ?? resolveConfig();
 }
-async function defaultProbeAudioInfo(audioPath, signal) {
-  const metadata = await extractAudioMetadata3(audioPath, { signal });
+function videoEncoderOptions(input, engineCfg) {
+  const { job, preset } = input;
   return {
-    durationSeconds: metadata.durationSeconds,
-    sampleRate: metadata.sampleRate,
-    channels: metadata.channels,
-    audioCodec: metadata.audioCodec
+    fps: job.config.fps,
+    width: input.width,
+    height: input.height,
+    codec: preset.codec,
+    preset: preset.preset,
+    quality: input.effectiveQuality,
+    bitrate: input.effectiveBitrate,
+    pixelFormat: preset.pixelFormat,
+    vp9CpuUsed: engineCfg.vp9CpuUsed,
+    useGpu: job.config.useGpu,
+    hdr: preset.hdr,
+    // Distributed chunk renders pass these so the encoder writes closed-GOP
+    // keyframes that survive `-f concat -c copy` at assemble time. In-process
+    // renders leave both undefined → preserves the existing open-GOP output.
+    lockGopForChunkConcat: input.lockGopForChunkConcat === true,
+    gopSize: input.gopSize
   };
 }
-async function defaultRunFfmpeg(args, timeoutMs, signal) {
-  return toStepResult(await runFfmpeg5(args, { signal, timeout: timeoutMs }), timeoutMs);
+function canEncodeWhileCapturing(input, workerCount, cpuCount) {
+  return workerCount > 1 && workerCount < cpuCount && !input.isPngSequence && !input.isGif && !input.enableChunkedEncode && input.preset.codec === "h264" && !input.preset.hdr && input.job.config.useGpu !== true && input.captureImageFormat === "jpeg" && input.lockGopForChunkConcat !== true;
+}
+async function readLandedFrame(workerPath, mergedPath) {
+  if (workerPath !== void 0) {
+    try {
+      return await readFile2(workerPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  return readFile2(mergedPath);
 }
-function defaultAacEncoder(timeoutMs, signal, pcmSourcePath) {
-  return async (inputPath, outputPath, durationSeconds, filter) => {
-    const options = pcmSourcePath ? { signal, timeout: timeoutMs, filter } : { signal, timeout: timeoutMs, filter, segments: 1 };
-    return toStepResult(
-      await encodeAac(pcmSourcePath ?? inputPath, outputPath, durationSeconds, options),
-      timeoutMs
-    );
+function encodeWhileCapturing(input, totalFrames) {
+  const engineCfg = resolveEngineConfig(input);
+  const stop = new AbortController();
+  const signal = input.abortSignal ? AbortSignal.any([input.abortSignal, stop.signal]) : stop.signal;
+  const landed = /* @__PURE__ */ new Map();
+  let captureDone = false;
+  let framesFed = 0;
+  let wake = null;
+  const nudge = () => {
+    wake?.();
+    wake = null;
   };
-}
-function toStepResult(result, timeoutMs) {
-  if (result.success) return { success: true };
+  signal.addEventListener("abort", nudge, { once: true });
+  let reportFed = null;
+  const encoder = spawnStreamingEncoder4(
+    input.videoOnlyPath,
+    { ...videoEncoderOptions(input, engineCfg), imageFormat: "jpeg" },
+    signal,
+    engineCfg
+  );
+  const fed = (async () => {
+    const stream = await encoder;
+    for (let next = 0; next < totalFrames; next++) {
+      while (!landed.has(next) && !captureDone && !signal.aborted) {
+        await new Promise((resolve12) => wake = resolve12);
+      }
+      if (signal.aborted) return;
+      const mergedPath = join24(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const frame = await readLandedFrame(landed.get(next), mergedPath);
+      landed.delete(next);
+      if (!await stream.writeFrame(frame)) {
+        throw new Error(stream.getExitError() ?? "encoder exited before the last frame");
+      }
+      framesFed++;
+      reportFed?.(framesFed);
+    }
+  })().then(
+    () => void 0,
+    (error) => error ?? new Error("encode failed")
+  );
+  const closeEncoder = async () => (await encoder.catch(() => null))?.close();
   return {
-    success: false,
-    error: `[audioPadTrim] ${describeFfmpegFailure2(result, timeoutMs)}`,
-    failureReason: result.failureReason
+    onFrameLanded: (frame) => {
+      landed.set(frame.index, frame.path);
+      nudge();
+    },
+    finish: async () => {
+      const start = Date.now();
+      captureDone = true;
+      input.log.info("[Render] Encoded frames while capturing", {
+        framesFed,
+        totalFrames
+      });
+      const encoded = startEncodeProgress(input.job, "Encoding video", input.onProgress);
+      reportFed = encoded;
+      nudge();
+      const failure = await fed;
+      const result = await closeEncoder();
+      input.assertNotAborted();
+      if (failure === void 0 && result?.success) {
+        encoded();
+        return { encodeMs: Date.now() - start };
+      }
+      input.log.warn(
+        "[Render] Encoding while capturing failed; encoding the frames after capture",
+        {
+          error: String(failure ?? result?.error)
+        }
+      );
+      return runEncodeStage(input);
+    },
+    abort: async () => {
+      stop.abort();
+      await fed;
+      await closeEncoder();
+    },
+    get framesFed() {
+      return framesFed;
+    }
   };
 }
-async function runFfprobeJson(args, signal) {
-  if (!args.includes("--")) {
-    throw new Error('[audioPadTrim] ffprobe args must terminate options with "--".');
-  }
-  const proc = spawn(getFfprobeBinary(), args, {
-    stdio: ["ignore", "pipe", "pipe"],
-    windowsHide: true
-  });
-  trackChildProcess(proc);
-  let stdout = "";
-  proc.stdout.on("data", (data) => {
-    stdout += data.toString();
-  });
-  const managed = new ManagedChildProcess(proc, {
-    signal,
-    deadlineAtMs: Date.now() + 3e4
-  });
-  const outcome = await managed.wait();
-  if (outcome.reason === "spawn_error") {
-    if (outcome.error?.code === "ENOENT") {
-      throw new Error("[audioPadTrim] ffprobe not found. Please install FFmpeg.");
+async function runEncodeStage(input) {
+  const {
+    job,
+    log,
+    outputPath,
+    framesDir,
+    videoOnlyPath,
+    needsAlpha,
+    hasAudio,
+    audioOutputPath,
+    isPngSequence,
+    isGif,
+    enableChunkedEncode,
+    chunkedEncodeSize,
+    abortSignal,
+    assertNotAborted,
+    onProgress
+  } = input;
+  const stage5Start = Date.now();
+  if (isPngSequence) {
+    const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
+    if (!existsSync15(outputPath)) mkdirSync8(outputPath, { recursive: true });
+    const captured = readdirSync4(framesDir).filter((name) => name.endsWith(".png")).sort();
+    if (captured.length === 0) {
+      throw new Error(
+        `[Render] png-sequence output requested but no PNGs were captured to ${framesDir}`
+      );
     }
-    throw outcome.error ?? new Error(outcome.stderr);
+    captured.forEach((name, i) => {
+      const dst = join24(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync3(join24(framesDir, name), dst);
+    });
+    if (hasAudio && audioOutputPath && existsSync15(audioOutputPath)) {
+      copyFileSync3(audioOutputPath, join24(outputPath, MIXED_AUDIO_FILENAME2));
+      log.info(
+        `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
+      );
+    }
+    encoded();
+    return { encodeMs: Date.now() - stage5Start };
   }
-  if (outcome.reason !== "exit" || outcome.exitCode !== 0) {
-    const probed = args[args.length - 1];
-    const scrubbed = redactKnownPaths(outcome.stderr, probed === void 0 ? [] : [probed]);
-    throw new Error(`ffprobe ${outcome.reason}: ${redactTelemetryString3(scrubbed, 2e3)}`);
+  const engineCfg = resolveEngineConfig(input);
+  if (isGif) {
+    const encoded = startEncodeProgress(job, "Encoding GIF", onProgress);
+    if (hasAudio) {
+      log.warn("[Render] GIF output does not support audio; audio tracks will be ignored.");
+    }
+    const frameExt2 = frameFileExtension2(input.captureImageFormat);
+    const framePattern2 = `frame_%06d.${frameExt2}`;
+    const loop = resolveGifLoop(job.config.gifLoop);
+    const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
+      fps: job.config.fps,
+      loop,
+      palettePath: join24(dirname9(videoOnlyPath), "gif-palette.png"),
+      preserveAlpha: needsAlpha,
+      signal: abortSignal,
+      timeout: engineCfg.ffmpegEncodeTimeout
+    });
+    assertNotAborted();
+    if (!encodeResult2.success) {
+      throw encoderFailureError("Encoding failed", encodeResult2);
+    }
+    encoded();
+    return { encodeMs: Date.now() - stage5Start };
   }
-  try {
-    return JSON.parse(stdout);
-  } catch (err) {
-    throw new Error(`Failed to parse ffprobe output: ${err.message}`);
+  const onFramesEncoded = startEncodeProgress(job, "Encoding video", onProgress);
+  const baseScaledEncodeTimeout = Math.ceil((job.duration ?? 0) * 4e3);
+  const scaledEncodeTimeout = baseScaledEncodeTimeout * (job.config.quality === "high" ? 6 : 1);
+  const videoEngineCfg = scaledEncodeTimeout > engineCfg.ffmpegEncodeTimeout ? { ...engineCfg, ffmpegEncodeTimeout: scaledEncodeTimeout } : engineCfg;
+  const frameExt = frameFileExtension2(input.captureImageFormat);
+  const framePattern = `frame_%06d.${frameExt}`;
+  const encoderOpts = videoEncoderOptions(input, engineCfg);
+  const encodeResult = enableChunkedEncode ? await encodeFramesChunkedConcat(
+    framesDir,
+    framePattern,
+    videoOnlyPath,
+    encoderOpts,
+    chunkedEncodeSize,
+    abortSignal,
+    videoEngineCfg,
+    onFramesEncoded
+  ) : await encodeFramesFromDir(
+    framesDir,
+    framePattern,
+    videoOnlyPath,
+    encoderOpts,
+    abortSignal,
+    videoEngineCfg,
+    onFramesEncoded
+  );
+  assertNotAborted();
+  if (!encodeResult.success) {
+    throw encoderFailureError("Encoding failed", encodeResult);
   }
+  onFramesEncoded();
+  return { encodeMs: Date.now() - stage5Start };
 }
 
 // src/services/render/stages/assembleStage.ts
+import { applyFaststart, muxVideoWithAudio, packageHls } from "@hyperframes/engine";
+import { extname as extname3 } from "node:path";
 function recordLimiterAttenuation(job, audioLoweredDb) {
   if (audioLoweredDb === void 0) return;
   job.audioLoweredDb = audioLoweredDb;
@@ -11129,7 +11133,7 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries) {
-      const full = join26(current, name);
+      const full = join25(current, name);
       try {
         const st = statSync6(full);
         if (st.isDirectory()) {
@@ -11277,7 +11281,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join26(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join25(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     const missing = !existsSync16(framePath) || statSync6(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
@@ -11300,7 +11304,7 @@ function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, ran
       workerId,
       startFrame: rangeStart + range.startFrame,
       endFrame: rangeStart + range.endFrame,
-      outputDir: join26(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
+      outputDir: join25(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`),
       outputFrameOffset: rangeStart
     }));
     batches.push(batch);
@@ -11328,8 +11332,8 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform2 = process.platform, systemTempDir = tmpdir2()) {
-  if (platform2 === "win32" || platform2 === "darwin") return join26(systemTempDir, "hf-render-");
-  return join26(dirname10(outputPath), `work-${jobId}-`);
+  if (platform2 === "win32" || platform2 === "darwin") return join25(systemTempDir, "hf-render-");
+  return join25(dirname10(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -11361,7 +11365,7 @@ The composition is too large for the available memory. To reduce memory pressure
 function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join26(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join25(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     if (existsSync16(framePath)) captured++;
   }
   return captured;
@@ -11387,7 +11391,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join26(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join25(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -11956,17 +11960,17 @@ function deVerifyFallbackTelemetry(err) {
 }
 function resolveRenderDebugDir() {
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve7(process.env.PRODUCER_RENDERS_DIR, "..") : resolve7(dirname10(fileURLToPath4(import.meta.url)), "../..");
-  return join26(producerRoot, ".debug");
+  return join25(producerRoot, ".debug");
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
   const debugDir = resolveRenderDebugDir();
   const outputDir = dirname10(outputPath);
   if (!existsSync16(outputDir)) mkdirSync9(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join26(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
+  const workDir = job.config.debug ? join25(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join26(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join25(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -11980,7 +11984,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
       log.info("KEEP_TEMP=1, leaving workDir on disk for inspection", { workDir });
       return;
     }
-    rmSync9(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    rmSync10(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   });
   try {
     await executeRenderPipeline({
@@ -12024,7 +12028,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join26(workDir, "perf-summary.json");
+  const perfOutputPath = join25(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig2() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -12123,15 +12127,15 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join26(projectDir, entryFile);
+    let htmlPath = join25(projectDir, entryFile);
     if (!existsSync16(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync8(htmlPath, "utf-8");
     if (entryFile !== "index.html" && isTemplateEntry(rawEntry)) {
-      const wrapperPath = join26(workDir, "standalone-entry.html");
-      const projectIndexPath = join26(projectDir, "index.html");
+      const wrapperPath = join25(workDir, "standalone-entry.html");
+      const projectIndexPath = join25(projectDir, "index.html");
       if (!existsSync16(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
@@ -12294,7 +12298,7 @@ async function executeRenderPipeline(input) {
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress, {
       code: "extract_video"
     });
-    const compiledDir = join26(workDir, "compiled");
+    const compiledDir = join25(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -12382,7 +12386,8 @@ async function executeRenderPipeline(input) {
         projectDir,
         workDir,
         compiledDir,
-        duration: probeResult.duration,
+        totalFrames: probeResult.totalFrames,
+        fps: job.config.fps,
         ffmpegProcessTimeout: cfg.ffmpegProcessTimeout,
         audioGain: cfg.audioGain,
         audios: composition.audios,
@@ -12394,6 +12399,7 @@ async function executeRenderPipeline(input) {
     );
     const { audioOutputPath, hasAudio } = audioResult;
     perfStages.audioProcessMs = audioResult.audioProcessMs;
+    recordLimiterAttenuation(job, audioResult.audioLoweredDb);
     if (audioResult.audioError) {
       const audioFailures = audioResult.audioFailures ?? [];
       const failureOwner = audioFailures.length === 0 ? void 0 : audioFailures.some((failure) => failure.owner === "system") ? "system" : "user";
@@ -12426,7 +12432,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer({
           projectDir,
-          compiledDir: join26(workDir, "compiled"),
+          compiledDir: join25(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -12444,7 +12450,7 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join26(workDir, "captured-frames");
+    const framesDir = join25(workDir, "captured-frames");
     if (!existsSync16(framesDir)) mkdirSync9(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
@@ -12894,7 +12900,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join26(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join25(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -13137,9 +13143,10 @@ async function executeRenderPipeline(input) {
           outputWidth: captureCompositionWidth ?? width,
           outputHeight: captureCompositionHeight ?? height,
           motionBlur: job.config.motionBlur ? JSON.stringify(job.config.motionBlur) : "",
+          pageMotionBlur: job.config.pageMotionBlur,
           captureQuality: captureOptions.quality
         });
-        const segmentDir = segmentDirFor(join26(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join25(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -13154,10 +13161,10 @@ async function executeRenderPipeline(input) {
             });
           }
           if (completedSegments.size === 0) {
-            rmSync9(segmentDir, { recursive: true, force: true });
+            rmSync10(segmentDir, { recursive: true, force: true });
           }
         } else {
-          rmSync9(segmentDir, { recursive: true, force: true });
+          rmSync10(segmentDir, { recursive: true, force: true });
         }
         const segmentManifest = readSegmentManifest(segmentDir) ?? {
           version: 1,
@@ -13238,7 +13245,7 @@ async function executeRenderPipeline(input) {
           );
           updateCaptureObservability({ segmentRetries: segmentedRes.segmentRetries });
           if (job.config.keepSegments !== true) {
-            rmSync9(segmentDir, { recursive: true, force: true });
+            rmSync10(segmentDir, { recursive: true, force: true });
           }
         } else {
           capturePlan = replanAfterFailure(capturePlan, { kind: "streaming_unavailable" });
@@ -13507,7 +13514,7 @@ async function executeRenderPipeline(input) {
             "capture_disk",
             "drawElement capture failed; retrying with a fresh screenshot session"
           );
-          rmSync9(framesDir, { recursive: true, force: true });
+          rmSync10(framesDir, { recursive: true, force: true });
           mkdirSync9(framesDir, { recursive: true });
           resetCaptureAttemptProgress(job);
           dedupPerfs.length = 0;
@@ -13694,7 +13701,7 @@ async function executeRenderPipeline(input) {
     }
     if (job.config.debug) {
       if (!isPngSequence && !isHls && existsSync16(stagedOutputPath)) {
-        const debugOutput = join26(workDir, `output${videoExt}`);
+        const debugOutput = join25(workDir, `output${videoExt}`);
         copyFileSync4(stagedOutputPath, debugOutput);
       }
     }
@@ -13824,10 +13831,10 @@ import {
   linkSync,
   mkdirSync as mkdirSync13,
   renameSync as renameSync6,
-  rmSync as rmSync11,
+  rmSync as rmSync12,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { extname as extname6, isAbsolute as isAbsolute3, join as join34, relative as relative5, sep as sep2 } from "node:path";
+import { extname as extname6, isAbsolute as isAbsolute3, join as join33, relative as relative5, sep as sep2 } from "node:path";
 import {
   fpsToNumber as fpsToNumber10,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -13839,7 +13846,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/distributed/planFrameCost.ts
-import { join as join29 } from "node:path";
+import { join as join28 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession9,
   createCaptureSession as createCaptureSession9,
@@ -13849,7 +13856,7 @@ import {
 
 // src/services/distributed/chunkFrames.ts
 import { existsSync as existsSync18, readdirSync as readdirSync6 } from "node:fs";
-import { extname as extname4, join as join28 } from "node:path";
+import { extname as extname4, join as join27 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
   createFrameLookupTable as createFrameLookupTable2,
@@ -13859,7 +13866,7 @@ import {
 
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
-import { dirname as dirname11, join as join27 } from "node:path";
+import { dirname as dirname11, join as join26 } from "node:path";
 import { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
@@ -13875,7 +13882,7 @@ function isPlanAudioArtifactPath(path) {
 }
 function resolvePlanAudioPath(planDir) {
   for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
-    const candidate = join27(planDir, name);
+    const candidate = join26(planDir, name);
     if (existsSync17(candidate)) return candidate;
   }
   return null;
@@ -14131,7 +14138,7 @@ function readProducerVersion() {
   const startDir = dirname11(fileURLToPath5(import.meta.url));
   let current = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = join27(current, "package.json");
+    const candidate = join26(current, "package.json");
     if (existsSync17(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
@@ -14184,7 +14191,7 @@ function frameNumberFromFileName(name) {
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
   const result = [];
   for (const v of videos) {
-    const outputDir = join28(planDir, "video-frames", v.videoId);
+    const outputDir = join27(planDir, "video-frames", v.videoId);
     if (!existsSync18(outputDir)) {
       throw new Error(
         `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
@@ -14203,7 +14210,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, join28(outputDir, frameName));
+      framePaths.set(frameIndex, join27(outputDir, frameName));
     }
     result.push({
       videoId: v.videoId,
@@ -14245,7 +14252,7 @@ function buildChunkCaptureOptions(input) {
     skipReadinessVideoIds: input.skipReadinessVideoIds,
     videoMetadataHints: input.videoMetadataHints,
     ...videoCaptureBeyondViewport !== void 0 ? { captureBeyondViewport: videoCaptureBeyondViewport } : {},
-    pageMotionBlur: "distributed-render",
+    pageMotionBlur: encoder.pageMotionBlur ?? "distributed-render",
     // A fixed warmup count keeps `beginFrameTimeTicks` host-independent.
     lockWarmupTicks: true,
     requiresWebGpu: compositionRequiresWebGpu3(input.html)
@@ -14293,14 +14300,14 @@ async function extractDeferredVideoFramesForChunk(input) {
   const shown = shownDeferredFrameIndexes(input.planVideos, input.frames, input.fps);
   return Promise.all(
     deferred.map(async (video) => {
-      const outputDir = join28(input.outputRoot, video.videoId);
+      const outputDir = join27(input.outputRoot, video.videoId);
       const indexes = [...shown.get(video.videoId) ?? []].sort((a, b) => a - b);
       if (indexes.length === 0) {
         return { ...video, outputDir, framePaths: /* @__PURE__ */ new Map(), ownedByLookup: false };
       }
       const range = video.deferredRange;
       const remoteUrl = remoteSources[range.sourcePath];
-      const sourcePath = remoteUrl ?? join28(input.planDir, ...range.sourcePath.split("/"));
+      const sourcePath = remoteUrl ?? join27(input.planDir, ...range.sourcePath.split("/"));
       if (remoteUrl === void 0 && !existsSync18(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
@@ -14349,12 +14356,12 @@ async function measurePlanSecondsPerFrame(input) {
       planVideos,
       frames: sampled,
       fps: fpsRatio,
-      outputRoot: join29(workDir, "frame-cost-video-frames"),
+      outputRoot: join28(workDir, "frame-cost-video-frames"),
       cfg: input.cfg
     })
   ];
   const lookup = extracted.length > 0 ? createFrameLookupTable3(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
-  const compiledDir = join29(planDir, "compiled");
+  const compiledDir = join28(planDir, "compiled");
   const fileServer = await createFileServer({
     projectDir: compiledDir,
     compiledDir,
@@ -14366,7 +14373,7 @@ async function measurePlanSecondsPerFrame(input) {
   try {
     session = await createCaptureSession9(
       fileServer.url,
-      join29(workDir, "frame-cost"),
+      join28(workDir, "frame-cost"),
       buildChunkCaptureOptions({
         dimensions: { ...input, fpsNum: fps, fpsDen: 1 },
         encoder: input,
@@ -14388,7 +14395,7 @@ async function measurePlanSecondsPerFrame(input) {
 
 // src/services/render/stages/freezePlan.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join30, relative as relative3, resolve as resolve8 } from "node:path";
+import { join as join29, relative as relative3, resolve as resolve8 } from "node:path";
 
 // src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
@@ -14606,7 +14613,7 @@ function listPlanFiles(planDir) {
   function walk(dir) {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join30(dir, entry.name);
+      const full = join29(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile()) {
@@ -14647,15 +14654,15 @@ var PLAN_REMOTE_FILES_RELATIVE_PATH = "meta/remote-files.json";
 function writePlanRemoteFiles(planDir, files) {
   if (files.length === 0) return;
   const sorted = [...files].sort((a, b) => a.path < b.path ? -1 : 1);
-  writeFileSync6(join30(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
+  writeFileSync6(join29(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
 }
 function readPlanRemoteFiles(planDir) {
-  const path = join30(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
+  const path = join29(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
   return existsSync19(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join30(planDir, "plan.json");
-  const encoderJsonPath = join30(planDir, "meta", "encoder.json");
+  const planJsonPath = join29(planDir, "plan.json");
+  const encoderJsonPath = join29(planDir, "meta", "encoder.json");
   if (!existsSync19(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
@@ -14692,18 +14699,18 @@ async function freezePlan(input) {
   if (!existsSync19(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
-  const metaDir = join30(planDir, "meta");
+  const metaDir = join29(planDir, "meta");
   if (!existsSync19(metaDir)) mkdirSync10(metaDir, { recursive: true });
   writeFileSync6(
-    join30(metaDir, "composition.json"),
+    join29(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
 `,
     "utf-8"
   );
   const encoderForCanonical = stripUndefined(encoder);
   const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync6(join30(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync6(join30(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+  writeFileSync6(join29(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync6(join29(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
@@ -14727,7 +14734,7 @@ async function freezePlan(input) {
     duration: durationSeconds,
     hasAudio
   };
-  const planJsonPath = join30(planDir, "plan.json");
+  const planJsonPath = join29(planDir, "plan.json");
   writeFileSync6(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
@@ -14771,7 +14778,7 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 // src/services/distributed/chunkAudio.ts
 import { closeSync as closeSync6, existsSync as existsSync20, ftruncateSync, mkdirSync as mkdirSync12, openSync as openSync5, readFileSync as readFileSync11 } from "node:fs";
 import { writeFileSync as writeFileSync7, writeSync } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join31 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg6 } from "@hyperframes/engine";
 
 // src/services/distributed/mp4Stitch.ts
@@ -14781,10 +14788,10 @@ import {
   mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync4,
   renameSync as renameSync5,
-  rmSync as rmSync10
+  rmSync as rmSync11
 } from "node:fs";
 import { open } from "node:fs/promises";
-import { dirname as dirname12, join as join31 } from "node:path";
+import { dirname as dirname12, join as join30 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -15150,16 +15157,16 @@ async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
   const header = audioPath ? buildStitchedHeader(layouts.slice(1), layouts[0]) : buildStitchedHeader(layouts);
   mkdirSync11(dirname12(outputPath), { recursive: true });
   const workDir = mkdtempSync4(`${outputPath}.stitch-`);
-  const out = createWriteStream(join31(workDir, "out.mp4"));
+  const out = createWriteStream(join30(workDir, "out.mp4"));
   try {
     out.write(header);
     for (const [i, path] of sourcePaths.entries()) await copyPayload(path, layouts[i], i, out);
     out.end();
     await finished(out);
-    renameSync5(join31(workDir, "out.mp4"), outputPath);
+    renameSync5(join30(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
-    rmSync10(workDir, { recursive: true, force: true });
+    rmSync11(workDir, { recursive: true, force: true });
   }
 }
 
@@ -15250,7 +15257,7 @@ async function writeChunkAudioSlices(input) {
   });
   const bytes = readFileSync11(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
-  mkdirSync12(join32(input.planDir, SLICE_DIR), { recursive: true });
+  mkdirSync12(join31(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
     const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
     if (!cut) return;
@@ -15258,17 +15265,17 @@ async function writeChunkAudioSlices(input) {
     const start = offsets[cut.firstPacket];
     layout.partStarts[index] = start;
     const end = offsets[last] + track.sizes[last];
-    writeFileSync7(join32(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
+    writeFileSync7(join31(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
   });
   const frame = [bytes.subarray(0, payloadStart), bytes.subarray(payloadEnd)];
-  writeFileSync7(join32(input.planDir, SLICE_FRAME), Buffer.concat(frame));
-  writeFileSync7(join32(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
+  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 = join32(planDir, SLICE_LAYOUT);
+  const layoutPath = join31(planDir, SLICE_LAYOUT);
   if (!existsSync20(layoutPath)) return resolvePlanAudioPath(planDir);
   const layout = JSON.parse(readFileSync11(layoutPath, "utf-8"));
-  const frame = readFileSync11(join32(planDir, SLICE_FRAME));
+  const frame = readFileSync11(join31(planDir, SLICE_FRAME));
   const fd = openSync5(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
@@ -15281,7 +15288,7 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync11(join32(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync11(join31(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
@@ -15337,7 +15344,7 @@ async function muxChunkWithAudio(input) {
 // src/services/distributed/planSize.ts
 import { createHash as createHash7 } from "node:crypto";
 import { lstatSync as lstatSync2, readdirSync as readdirSync8 } from "node:fs";
-import { extname as extname5, join as join33, relative as relative4 } from "node:path";
+import { extname as extname5, join as join32, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -15449,7 +15456,7 @@ function walkRegularFiles(dir, visit) {
     return;
   }
   for (const entry of entries) {
-    const full = join33(dir, entry.name);
+    const full = join32(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -15524,7 +15531,6 @@ function chunkSizingUsesFrameCost(config) {
 }
 var CHUNK_EXCEEDS_WORKER_TIMEOUT = "CHUNK_EXCEEDS_WORKER_TIMEOUT";
 var ChunkExceedsWorkerTimeoutError = class extends Error {
-  // fallow-ignore-next-line unused-class-member
   code = CHUNK_EXCEEDS_WORKER_TIMEOUT;
   constructor(predictedChunkSeconds, workerTimeoutSeconds) {
     super(
@@ -15587,7 +15593,6 @@ var PlanTooLargeError = class extends Error {
 };
 var FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED = "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED";
 var FormatNotSupportedInDistributedError = class extends Error {
-  // fallow-ignore-next-line unused-class-member
   code = FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED;
   format;
   reason;
@@ -15659,13 +15664,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join34("meta", "composition.json"),
-  join34("meta", "encoder.json"),
-  join34("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) {
-    rmSync11(join34(planDir, relativePath), { force: true });
+    rmSync12(join33(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -15724,6 +15729,7 @@ function buildLockedRenderConfig(input) {
     chunkCount: input.chunkCount,
     runtimeEnv: input.runtimeEnv,
     variables: config.variables,
+    pageMotionBlur: config.pageMotionBlur,
     ...input.chunksCarryAudio ? { chunksCarryAudio: true } : {},
     ...input.separateAudio ? { separateAudio: true } : {}
   };
@@ -15797,19 +15803,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join34(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 && (existsSync21(join34(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync21(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 = join34(input.planDir, ...result.split("/"));
-      mkdirSync13(join34(input.planDir, "video-sources"), { recursive: true });
+      const destination = join33(input.planDir, ...result.split("/"));
+      mkdirSync13(join33(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -15821,7 +15827,7 @@ function createVideoSourceShipper(input) {
   };
 }
 function plansSeparateAudio(config, options) {
-  return options.deferAudio === true && config.format === "mp4" && config.cfr !== true;
+  return options.deferAudio === true && config.format !== "png-sequence" && config.cfr !== true;
 }
 async function compilePlanComposition(projectDir, config, planDir, options) {
   rejectUnsupportedDistributedFormat(config);
@@ -15858,14 +15864,14 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join34(projectDir, entryFile);
+  const htmlPath = join33(projectDir, entryFile);
   if (!existsSync21(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join34(planDir, ".plan-work");
-  rmSync11(workDir, { recursive: true, force: true });
+  const workDir = join33(planDir, ".plan-work");
+  rmSync12(workDir, { recursive: true, force: true });
   mkdirSync13(workDir, { recursive: true });
-  const compiledDir = join34(workDir, "compiled");
+  const compiledDir = join33(workDir, "compiled");
   mkdirSync13(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
@@ -15879,10 +15885,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join34(planDir, "compiled");
+  const finalCompiledDir = join33(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
-  const remoteLocalPath = (rel) => join34(projectDir, ...rel.split("/"));
+  const remoteLocalPath = (rel) => join33(projectDir, ...rel.split("/"));
   const urlByAbsentLocalPath = new Map(
     remoteFiles.map(([rel, file]) => [remoteLocalPath(rel), file.url])
   );
@@ -15981,22 +15987,21 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     forceScreenshot,
     width,
     height,
-    probeResult,
     totalFrames
   };
 }
-function mixPlanAudio(c, compiledDir, seconds, pcmPath) {
+function mixPlanAudio(c, compiledDir) {
   return runAudioStage({
     projectDir: c.projectDir,
     workDir: c.workDir,
     compiledDir,
     urlByAbsentLocalPath: c.urlByAbsentLocalPath,
-    duration: seconds,
+    totalFrames: c.totalFrames,
+    fps: c.job.config.fps,
     ffmpegProcessTimeout: c.cfg.ffmpegProcessTimeout,
     audioGain: c.cfg.audioGain,
     audios: c.composition.audios,
     masterFxChain: c.composition.masterFxChain,
-    ...pcmPath ? { keepEncoderInputAt: pcmPath } : {},
     abortSignal: c.abortSignal,
     assertNotAborted: c.assertNotAborted
   });
@@ -16020,16 +16025,6 @@ async function extractPlanVideos(c, deferRangeExtraction) {
   }
   return extractResult;
 }
-async function holdPlanAudioPeak(c, audioPath, pcmPath, seconds) {
-  const peak = await constrainAacTruePeak({
-    audioPath,
-    ...existsSync21(pcmPath) ? { sourcePath: pcmPath } : {},
-    targetDurationSeconds: seconds,
-    signal: c.abortSignal,
-    timeoutMs: c.cfg.ffmpegProcessTimeout
-  }).finally(() => rmSync11(pcmPath, { force: true }));
-  if (!peak.success) throw encoderFailureError("[plan] audio true-peak check failed", peak);
-}
 async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, options = {}) {
   const planDir = executionPlanDir;
   const c = await compilePlanComposition(projectDir, config, planDir, options);
@@ -16051,7 +16046,6 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     forceScreenshot,
     width,
     height,
-    probeResult,
     totalFrames
   } = c;
   const megapixels = compileResult.outputWidth * compileResult.outputHeight / 1e6;
@@ -16067,17 +16061,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   let stageStarted = Date.now();
   const extractResult = await extractPlanVideos(c, options.deferVideoExtraction);
   logPlanStage(log, "extract", stageStarted);
-  const stagedVideoFrames = join34(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join34(planDir, "video-frames");
-  if (existsSync21(videoFramesDst)) rmSync11(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join34(planDir, "video-sources");
-  rmSync11(videoSourcesDir, { recursive: true, force: true });
+  const stagedVideoFrames = join33(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join33(planDir, "video-frames");
+  if (existsSync21(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join33(planDir, "video-sources");
+  rmSync12(videoSourcesDir, { recursive: true, force: true });
   if (existsSync21(stagedVideoFrames)) {
     renameSync6(stagedVideoFrames, videoFramesDst);
   } else {
     mkdirSync13(videoFramesDst, { recursive: true });
   }
-  if (existsSync21(finalCompiledDir)) rmSync11(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync21(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
   renameSync6(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -16107,7 +16101,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync13(join34(planDir, "meta"), { recursive: true });
+  mkdirSync13(join33(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -16117,23 +16111,16 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }))
   );
   writeFileSync8(
-    join34(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+    join33(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
   const digests = options.digests ?? /* @__PURE__ */ new Map();
   const separateAudio = plansSeparateAudio(config, options);
   const chunksCarryAudio = !separateAudio && carriesChunkAudio(config, options);
-  const audioSeconds = chunksCarryAudio ? totalFrames / config.fps : probeResult.duration;
-  const planMixPcmPath = join34(workDir, "plan-mix.wav");
   stageStarted = Date.now();
   const [audioOutcome, overlapOutcome, frameCostOutcome] = await Promise.allSettled([
-    separateAudio ? null : mixPlanAudio(
-      c,
-      finalCompiledDir,
-      audioSeconds,
-      chunksCarryAudio ? planMixPcmPath : void 0
-    ).finally(() => logPlanStage(log, "audio", stageStarted)),
+    separateAudio ? null : mixPlanAudio(c, finalCompiledDir).finally(() => logPlanStage(log, "audio", stageStarted)),
     (async () => {
       for (const dir of [finalCompiledDir, videoFramesDst, videoSourcesDir]) {
         await prehashPlanFiles(dir, digests);
@@ -16186,14 +16173,11 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
-  const planAudioPath = join34(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  const planAudioPath = join33(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult?.hasAudio && existsSync21(audioResult.audioOutputPath)) {
     renameSync6(audioResult.audioOutputPath, planAudioPath);
   }
   if (chunksCarryAudio && existsSync21(planAudioPath)) {
-    stageStarted = Date.now();
-    await holdPlanAudioPeak(c, planAudioPath, planMixPcmPath, audioSeconds);
-    logPlanStage(log, "audio-peak", stageStarted);
     if (options.sliceChunkAudio) {
       stageStarted = Date.now();
       await writeChunkAudioSlices({
@@ -16238,7 +16222,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     format: config.format
   };
   try {
-    rmSync11(workDir, { recursive: true, force: true });
+    rmSync12(workDir, { recursive: true, force: true });
   } catch (err) {
     log.warn("[plan] failed to remove temp work dir", {
       workDir,
@@ -16343,6 +16327,9 @@ function validateDistributedRenderConfig(config) {
   }
   validateIntDimension("config.width", config.width);
   validateIntDimension("config.height", config.height);
+  if (config.pageMotionBlur !== void 0 && config.pageMotionBlur !== "off") {
+    throw new InvalidConfigError("config.pageMotionBlur", 'must be "off" when provided');
+  }
   if (!ALLOWED_FORMATS.includes(config.format)) {
     throw new InvalidConfigError(
       "config.format",
@@ -16716,6 +16703,7 @@ function distributedConfigFromRequest(request, runtime = {}) {
     codec: distributed.codec,
     quality: options.quality,
     crf: options.crf,
+    pageMotionBlur: options.pageMotionBlur,
     bitrate: options.videoBitrate,
     videoFrameFormat: options.videoFrameFormat,
     outputResolution: options.outputResolution,
@@ -16762,6 +16750,7 @@ function renderRequestFromDistributedConfig(input) {
     format: config.format,
     distributed,
     ...optionalProperty("crf", config.crf),
+    ...optionalProperty("pageMotionBlur", config.pageMotionBlur),
     ...optionalProperty("videoBitrate", config.bitrate),
     ...optionalProperty("videoFrameFormat", config.videoFrameFormat),
     ...optionalProperty("outputResolution", config.outputResolution),
@@ -16808,10 +16797,10 @@ import {
   statSync as statSync8,
   mkdtempSync as mkdtempSync5,
   writeFileSync as writeFileSync9,
-  rmSync as rmSync12,
+  rmSync as rmSync13,
   createReadStream as createReadStream5
 } from "node:fs";
-import { resolve as resolve10, dirname as dirname14, join as join37 } from "node:path";
+import { resolve as resolve10, dirname as dirname14, join as join36 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -16829,7 +16818,7 @@ import {
   closeSync as closeSync7,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve9, join as join35, relative as relative6, isAbsolute as isAbsolute4, sep as sep3 } from "node:path";
+import { resolve as resolve9, join as join34, relative as relative6, isAbsolute as isAbsolute4, sep as sep3 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -16897,7 +16886,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join35(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join34(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -16943,7 +16932,7 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { dirname as dirname13, join as join36 } from "node:path";
+import { dirname as dirname13, join as join35 } from "node:path";
 import { existsSync as existsSync23 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -17019,7 +17008,7 @@ function defaultLogger2() {
 }
 function resolveWorkerEntry2() {
   const here = dirname13(fileURLToPath6(import.meta.url));
-  const candidates = [join36(here, "healthWorkerThread.js"), join36(here, "healthWorkerThread.ts")];
+  const candidates = [join35(here, "healthWorkerThread.js"), join35(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync23(candidate)) return candidate;
   }
@@ -17157,6 +17146,7 @@ function buildRenderJobConfig(input, outputPath, log) {
       outputResolution: input.outputResolution,
       outputResolutionAspectAgnostic: input.outputResolutionAspectAgnostic,
       videoFrameFormat: input.videoFrameFormat,
+      pageMotionBlur: input.pageMotionBlur,
       hdrMode: toRenderHdrMode(input.outputDynamicRange)
     }
   });
@@ -17232,8 +17222,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync5(join37(tempRoot, "producer-project-"));
-  writeFileSync9(join37(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 },
@@ -17244,7 +17234,11 @@ function materializeInlineProject(html, options) {
 async function prepareRenderBody(body) {
   const overrideError = validateRenderOverrides(body);
   if (overrideError) return { error: overrideError };
-  const options = parseRenderOptions(body);
+  const pageMotionBlur = body.pageMotionBlur;
+  if (pageMotionBlur !== void 0 && pageMotionBlur !== "off") {
+    return { error: "pageMotionBlur must be off when supplied" };
+  }
+  const options = { ...parseRenderOptions(body), pageMotionBlur };
   const project = prepareProjectDirectory(body.projectDir, options);
   if (project) return project;
   const source = await resolveInlineRenderHtml(body);
@@ -17290,7 +17284,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync12(dir, { recursive: true, force: true });
+    rmSync13(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -17699,12 +17693,12 @@ import {
   readFileSync as readFileSync13,
   readdirSync as readdirSync9,
   renameSync as renameSync8,
-  rmSync as rmSync14,
+  rmSync as rmSync15,
   statSync as statSync10,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname16, isAbsolute as isAbsolute5, join as join40, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
+import { dirname as dirname16, isAbsolute as isAbsolute5, join as join39, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
 import { DISTRIBUTED_FPS as DISTRIBUTED_FPS2, isDistributedFps as isDistributedFps3 } from "@hyperframes/core";
 import { createFrameLookupTable as createFrameLookupTable4 } from "@hyperframes/engine";
 
@@ -17716,11 +17710,11 @@ import {
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync6,
   renameSync as renameSync7,
-  rmSync as rmSync13,
+  rmSync as rmSync14,
   statSync as statSync9,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname15, join as join39 } from "node:path";
+import { dirname as dirname15, join as join38 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -17735,7 +17729,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join38 } from "node:path";
+import { join as join37 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -17745,7 +17739,7 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join38(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join37(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
@@ -17786,7 +17780,7 @@ var LocalPlanV2ArtifactPublisher = class {
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
     mkdirSync15(dirname15(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync6(join39(dirname15(destinationDir), ".plan-v2-publish-"));
+    this.temporaryDir = mkdtempSync6(join38(dirname15(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -17799,8 +17793,8 @@ var LocalPlanV2ArtifactPublisher = class {
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
     if (existsSync25(destinationPath)) return;
     mkdirSync15(dirname15(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync6(join39(dirname15(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join39(stagingDir, "blob");
+    const stagingDir = mkdtempSync6(join38(dirname15(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join38(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -17810,7 +17804,7 @@ var LocalPlanV2ArtifactPublisher = class {
       }
       renameSync7(temporaryPath, destinationPath);
     } finally {
-      rmSync13(stagingDir, { recursive: true, force: true });
+      rmSync14(stagingDir, { recursive: true, force: true });
     }
   }
   async commitManifest(manifestBytes) {
@@ -17821,13 +17815,13 @@ var LocalPlanV2ArtifactPublisher = class {
         );
       }
     }
-    writeFileSync10(join39(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync10(join38(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameSync7(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
     if (!this.#committed) {
-      rmSync13(this.temporaryDir, { recursive: true, force: true });
+      rmSync14(this.temporaryDir, { recursive: true, force: true });
     }
   }
 };
@@ -17866,7 +17860,7 @@ function listFiles(root) {
   const rootResolved = resolve11(root);
   function walk(dir) {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const absolutePath = join40(dir, entry.name);
+      const absolutePath = join39(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -17893,13 +17887,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join40(executionPlanDir, "video-frames");
+  const videoRoot = join39(executionPlanDir, "video-frames");
   if (!existsSync26(videoRoot)) return;
   for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join40(videoRoot, videoEntry.name);
+    const videoDir = join39(videoRoot, videoEntry.name);
     if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join40(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+      const sentinelPath = join39(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -17946,7 +17940,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join40(outputDir, String(index)));
+        framePaths2.set(index, join39(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
@@ -17954,7 +17948,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join40(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join39(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -17973,7 +17967,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join40(outputDir, frameName));
+      framePaths.set(frameIndex, join39(outputDir, frameName));
     }
     return {
       ...video,
@@ -17994,7 +17988,7 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join39(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   if (!existsSync26(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
@@ -18023,13 +18017,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join40(executionPlanDir, "video-frames");
+  const videoRoot = join39(executionPlanDir, "video-frames");
   const hasExtractedFrames = existsSync26(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join40(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join39(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   if (!existsSync26(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join40(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);
@@ -18085,13 +18079,13 @@ function computeManifestHash(manifest) {
 function writeBlob(sourcePath, destinationPath) {
   if (existsSync26(destinationPath)) return;
   mkdirSync16(dirname16(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync7(join40(dirname16(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join40(temporaryDir, "blob");
+  const temporaryDir = mkdtempSync7(join39(dirname16(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join39(temporaryDir, "blob");
   try {
     copyFileSync7(sourcePath, temporaryPath);
     renameSync8(temporaryPath, destinationPath);
   } finally {
-    rmSync14(temporaryDir, { recursive: true, force: true });
+    rmSync15(temporaryDir, { recursive: true, force: true });
   }
 }
 function publishBlobFor(absolutePath, digests) {
@@ -18122,7 +18116,7 @@ async function putTasks(tasks) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join40(executionPlanDir, "plan.json");
+  const executionPlanPath = join39(executionPlanDir, "plan.json");
   if (!existsSync26(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
@@ -18150,7 +18144,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  const encoder = readJsonFile(join40(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  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) {
@@ -18211,20 +18205,20 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
     throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
   }
   mkdirSync16(dirname16(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync7(join40(dirname16(planV2Dir), ".plan-v2-build-"));
+  const tempDir = mkdtempSync7(join39(dirname16(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
     writeFileSync11(
-      join40(tempDir, "plan.json"),
+      join39(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
     renameSync8(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
-    rmSync14(tempDir, { recursive: true, force: true });
+    rmSync15(tempDir, { recursive: true, force: true });
     throw error;
   }
 }
@@ -18264,7 +18258,7 @@ async function publishPlanV2FromV1(executionPlanDir, publisher) {
   return publishPlanV2FromExecutionPlan(executionPlanDir, publisher);
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync7(join40(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync7(join39(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -18275,7 +18269,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
       // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
       whileAudioMixes: () => putBlobs(
         publisher,
-        listFiles(join40(stagingRoot, "compiled")).map(
+        listFiles(join39(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -18291,7 +18285,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
     }
     throw error;
   } finally {
-    rmSync14(stagingRoot, { recursive: true, force: true });
+    rmSync15(stagingRoot, { recursive: true, force: true });
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
@@ -18307,7 +18301,7 @@ async function planV2(projectDir, config, planV2Dir) {
 function resultFromManifest(planV2Dir, manifest) {
   return {
     planDir: planV2Dir,
-    manifestPath: join40(planV2Dir, "plan.json"),
+    manifestPath: join39(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -18443,7 +18437,7 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join40(planV2Dir, "plan.json");
+  const manifestPath = join39(planV2Dir, "plan.json");
   if (!existsSync26(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
@@ -18489,16 +18483,16 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
   mkdirSync16(dirname16(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync7(join40(dirname16(destinationDir), ".plan-v2-materialize-"));
+  const tempDir = mkdtempSync7(join39(dirname16(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join40(tempDir, ...artifact.path.split("/"));
+      const destinationPath = join39(tempDir, ...artifact.path.split("/"));
       mkdirSync16(dirname16(destinationPath), { recursive: true });
       copyFileSync7(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
     writeFileSync11(
-      join40(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      join39(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({
         manifest,
         target,
@@ -18508,7 +18502,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     );
     renameSync8(tempDir, destinationDir);
   } catch (error) {
-    rmSync14(tempDir, { recursive: true, force: true });
+    rmSync15(tempDir, { recursive: true, force: true });
     throw error;
   }
   return {
@@ -18521,7 +18515,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     // 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 ? join40(destinationDir, audioArtifact.path) : null : null
+    audioPath: target.role === "assembler" ? audioArtifact ? join39(destinationDir, audioArtifact.path) : null : null
   };
 }
 function assertRemoteSources(remoteSources, artifacts) {
@@ -18540,7 +18534,7 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   return readValidatedPlanV2Materialization(planDir, expectedTarget)?.manifest ?? null;
 }
 function readValidatedPlanV2Materialization(planDir, expectedTarget) {
-  const markerPath = join40(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  const markerPath = join39(planDir, PLAN_V2_MATERIALIZATION_MARKER);
   if (!existsSync26(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
@@ -18558,7 +18552,7 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   assertRemoteSources(remoteSources, required);
   for (const artifact of required) {
     if (Object.hasOwn(remoteSources, artifact.path)) continue;
-    const path = join40(planDir, ...artifact.path.split("/"));
+    const path = join39(planDir, ...artifact.path.split("/"));
     if (!existsSync26(path) || statSync10(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
@@ -18572,9 +18566,9 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
 }
 
 // src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync9, rmSync as rmSync17 } from "node:fs";
+import { mkdtempSync as mkdtempSync9, rmSync as rmSync18 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join43 } from "node:path";
+import { join as join42 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
@@ -18585,11 +18579,11 @@ import {
   readFileSync as readFileSync14,
   readdirSync as readdirSync10,
   renameSync as renameSync9,
-  rmSync as rmSync15,
+  rmSync as rmSync16,
   statSync as statSync11,
   writeFileSync as writeFileSync12
 } from "node:fs";
-import { dirname as dirname17, join as join41 } from "node:path";
+import { dirname as dirname17, join as join40 } from "node:path";
 import {
   appendRenderProvenanceArgs as appendRenderProvenanceArgs2,
   describeFfmpegFailure as describeFfmpegFailure4,
@@ -18597,7 +18591,8 @@ import {
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME4,
   muxVideoWithAudio as muxVideoWithAudio2,
   resolveConfig as resolveConfig6,
-  runFfmpeg as runFfmpeg7
+  runFfmpeg as runFfmpeg7,
+  appendSoftwareEncoderThreadsArg
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
 function cfrRateControlArgs(locked) {
@@ -18651,7 +18646,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join41(workDir, `output.${format}`);
+    const finalPath = join40(workDir, `output.${format}`);
     const audio = audioPath !== null && existsSync27(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameSync9(finalPath, outputPath);
@@ -18662,7 +18657,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     });
   } finally {
     try {
-      rmSync15(workDir, { recursive: true, force: true });
+      rmSync16(workDir, { recursive: true, force: true });
     } catch (err) {
       log.warn("[assemble] failed to remove work dir", {
         workDir,
@@ -18679,8 +18674,8 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join41(planDir, "plan.json");
-  const chunksJsonPath = join41(planDir, "meta", "chunks.json");
+  const planJsonPath = join40(planDir, "plan.json");
+  const chunksJsonPath = join40(planDir, "meta", "chunks.json");
   if (!existsSync27(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
@@ -18711,10 +18706,9 @@ function readAssemblePlan(planDir, chunkPaths) {
 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 = join41(ctx.workDir, `cfr.${ctx.format}`);
-  const cfrArgs = [
-    ...videoInputArgs(ctx, chunkPaths),
+function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
+  const args = [
+    ...inputArgs,
     "-c:v",
     "libx264",
     ...cfrRateControlArgs(encoder),
@@ -18723,8 +18717,14 @@ async function reencodeCfr(ctx, chunkPaths, encoder) {
     "-fps_mode",
     "cfr",
     "-r",
-    ctx.fpsArg
+    fpsArg
   ];
+  appendSoftwareEncoderThreadsArg(args);
+  return args;
+}
+async function reencodeCfr(ctx, chunkPaths, encoder) {
+  const cfrOutputPath = join40(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
   await ctx.timed(
@@ -18750,7 +18750,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join41(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join40(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -18790,7 +18790,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join41(workDir, "concat-list.txt");
+  const listPath = join40(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync12(listPath, `${body}
 `, "utf-8");
@@ -18818,6 +18818,7 @@ async function runAssembleFfmpeg(args, step, signal, timeout) {
 function chunksAreStitchedMp4(planDir, cfr) {
   const { chunksCarryAudio, separateAudio } = lockedAudio(planDir);
   if (!chunksCarryAudio && !separateAudio) return false;
+  if (planFormat(planDir) !== "mp4") return false;
   if (cfr) {
     throw new Error("[assemble] cfr=true cannot re-encode a plan whose mp4 chunks are stitched");
   }
@@ -18826,8 +18827,12 @@ function chunksAreStitchedMp4(planDir, cfr) {
 function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
+function planFormat(planDir) {
+  const plan2 = JSON.parse(readFileSync14(join40(planDir, "plan.json"), "utf-8"));
+  return plan2.dimensions.format;
+}
 function lockedAudio(planDir) {
-  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
   if (!existsSync27(encoderJsonPath)) return {};
   return JSON.parse(readFileSync14(encoderJsonPath, "utf-8"));
 }
@@ -18837,7 +18842,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 = join41(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join40(planDir, "meta", "encoder.json");
   if (!existsSync27(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
@@ -18850,7 +18855,7 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync27(outputPath)) rmSync15(outputPath, { recursive: true, force: true });
+  if (existsSync27(outputPath)) rmSync16(outputPath, { recursive: true, force: true });
   mkdirSync17(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
@@ -18864,8 +18869,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 = join41(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join41(chunkDir, frame), dst);
+      const dst = join40(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join40(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -18875,13 +18880,13 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
     );
   }
   if (audioPath !== null && existsSync27(audioPath)) {
-    const sidecar = join41(outputPath, MIXED_AUDIO_FILENAME4);
+    const sidecar = join40(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
   for (const name of readdirSync10(outputPath)) {
     try {
-      fileSize += statSync11(join41(outputPath, name)).size;
+      fileSize += statSync11(join40(outputPath, name)).size;
     } catch {
     }
   }
@@ -18895,8 +18900,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync18, readFileSync as readFileSync15, readdirSync as readdirSync11, rmSync as rmSync16, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join42 } from "node:path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync18, readFileSync as readFileSync15, readdirSync as readdirSync11, rmSync as rmSync17, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join41 } from "node:path";
 import {
   assertSwiftShader,
   BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE4,
@@ -18998,7 +19003,7 @@ function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync15(outputPath));
   const entries = readdirSync11(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync15(join42(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync15(join41(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -19015,9 +19020,9 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join42(planDir, "plan.json");
-  const encoderJsonPath = join42(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join42(planDir, "meta", "chunks.json");
+  const planJsonPath = join41(planDir, "plan.json");
+  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join41(planDir, "meta", "chunks.json");
   if (!existsSync28(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -19043,7 +19048,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const encoder = JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync15(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join42(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join41(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync28(videosJsonPath)) {
     try {
@@ -19075,7 +19080,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const range = resolveChunkFrameRange(slice, chunkIndex, options?.frameRange);
   const framesInChunk = range.endFrame - range.startFrame;
-  const compiledDir = join42(planDir, "compiled");
+  const compiledDir = join41(planDir, "compiled");
   if (!existsSync28(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -19133,7 +19138,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
     mkdirSync18(workDir, { recursive: true });
-    const framesDir = join42(workDir, "captured-frames");
+    const framesDir = join41(workDir, "captured-frames");
     mkdirSync18(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
@@ -19158,7 +19163,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync15(join42(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync15(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: deferredVideos.filter(
         (video) => !shownFrames.get(video.videoId)?.size || remoteVideoIds.has(video.videoId)
@@ -19334,7 +19339,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           return observedMode;
         },
         resetForScreenshotRetry: () => {
-          rmSync16(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          rmSync17(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
           mkdirSync18(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
@@ -19372,7 +19377,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       if (isPngSequence) {
         if (!existsSync28(outputChunkPath)) mkdirSync18(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join42(outputChunkPath, "..");
+        const outDir = join41(outputChunkPath, "..");
         if (!existsSync28(outDir)) mkdirSync18(outDir, { recursive: true });
       }
       const encodeStarted = Date.now();
@@ -19427,8 +19432,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
           timeoutMs: cfg.ffmpegProcessTimeout
         });
-        rmSync16(videoOnlyPath, { force: true });
-        rmSync16(audioScratchPath, { force: true });
+        rmSync17(videoOnlyPath, { force: true });
+        rmSync17(audioScratchPath, { force: true });
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
@@ -19474,8 +19479,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     writeFileSync13(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
-      rmSync16(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-      rmSync16(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync17(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      rmSync17(videoFramesDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     } catch (err) {
       log.warn("[renderChunk] failed to remove work dir", {
         workDir,
@@ -19504,18 +19509,18 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
-  const workRoot = mkdtempSync9(join43(tmpdir5(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join43(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, options);
   } finally {
-    rmSync17(workRoot, { recursive: true, force: true });
+    rmSync18(workRoot, { recursive: true, force: true });
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync9(join43(tmpdir5(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join43(workRoot, "plan");
+  const workRoot = mkdtempSync9(join42(tmpdir5(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join42(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -19530,7 +19535,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync17(workRoot, { recursive: true, force: true });
+    rmSync18(workRoot, { recursive: true, force: true });
   }
 }