@hyperframes/producer 0.8.205 → 0.8.207

package/dist/index.js

@@ -2,19 +2,19 @@
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
   existsSync as existsSync16,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync8,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync5,
-  rmSync as rmSync11,
-  statSync as statSync7,
-  writeFileSync as writeFileSync5,
-  copyFileSync as copyFileSync4,
+  rmSync as rmSync10,
+  statSync as statSync8,
+  writeFileSync as writeFileSync6,
+  copyFileSync as copyFileSync5,
   appendFileSync
 } from "fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import {
   chainCapture,
-  fpsToNumber as fpsToNumber9,
+  fpsToNumber as fpsToNumber8,
   HF_COLOR_GRADING_ATTR,
   HF_VFX_ATTR,
   parseVfxChain,
@@ -56,7 +56,7 @@ import {
   augmentProtocolTimeoutError,
   augmentPageNavigationTimeoutError
 } from "@hyperframes/engine";
-import { join as join26, dirname as dirname10, resolve as resolve7 } from "path";
+import { join as join27, dirname as dirname11, resolve as resolve8 } from "path";
 import { totalmem as totalmem2 } from "node:os";
 import { randomUUID } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -80,6 +80,7 @@ import { Readable } from "node:stream";
 import { join, extname, resolve as resolve2, sep } from "node:path";
 import { injectScriptsAtHeadStart, injectScriptsIntoHtml } from "@hyperframes/core/compiler";
 import { fpsToNumber } from "@hyperframes/core";
+import { stripSdrPngColourTags } from "@hyperframes/core/compiler/png-colour-tags";
 
 // src/services/hyperframeRuntimeLoader.ts
 import { createHash } from "node:crypto";
@@ -196,11 +197,11 @@ var defaultLogger = createConsoleLogger("info");
 
 // src/services/fileServer.ts
 var readFileAsync = promisify(readFile);
-function isPathInside(child2, parent, options = {}) {
+function isPathInside(child3, parent, options = {}) {
   const { resolveSymlinks = false, pathModule } = options;
   const resolveFn = pathModule?.resolve ?? resolve2;
   const separator = pathModule?.sep ?? sep;
-  const resolvedChild = resolveFn(child2);
+  const resolvedChild = resolveFn(child3);
   const resolvedParent = resolveFn(parent);
   const normalizedChild = resolveSymlinks && existsSync2(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
   const normalizedParent = resolveSymlinks && existsSync2(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
@@ -720,6 +721,18 @@ function createFileServer(options) {
         html = isIndex ? injectScriptsIntoHtml(html, headScripts, bodyScripts, stripEmbeddedRuntime) : html;
         return c.text(html, 200, { "Content-Type": contentType });
       }
+      if (ext === ".png") {
+        const untagged = stripSdrPngColourTags(await readFileAsync(fd));
+        if (untagged) {
+          const headers = {
+            "Content-Type": contentType,
+            "Content-Length": String(untagged.length)
+          };
+          return new Response(c.req.method === "HEAD" ? null : new Uint8Array(untagged), {
+            headers
+          });
+        }
+      }
       const totalSize = stat.size;
       const rangeHeader = c.req.header("range");
       const rangeRequest = parseRangeHeader(rangeHeader, totalSize);
@@ -747,7 +760,8 @@ function createFileServer(options) {
       const stream = createReadStream(filePath, {
         fd,
         autoClose: true,
-        ...range ? { start: range.start, end: range.end } : {}
+        start: range?.start ?? 0,
+        ...range ? { end: range.end } : {}
       });
       streamOwnsFd = true;
       try {
@@ -761,10 +775,10 @@ function createFileServer(options) {
       if (!streamOwnsFd) closeSync(fd);
     }
   });
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const connections = /* @__PURE__ */ new Set();
     const server = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" }, (info) => {
-      resolve12({
+      resolve13({
         url: `http://localhost:${info.port}`,
         port: info.port,
         addPreHeadScript: (script) => {
@@ -796,7 +810,7 @@ function outputUsesH264Pipeline(format) {
 }
 
 // src/services/render/hlsConfig.ts
-import { fpsToNumber as fpsToNumber2 } from "@hyperframes/core";
+import { keyframeIntervalToGopSize } from "@hyperframes/engine";
 var DEFAULT_HLS_SEGMENT_SECONDS = 4;
 function validateHlsRenderConfig(config) {
   if (config.format !== "hls") return;
@@ -821,7 +835,7 @@ function resolveHlsSegmentSeconds(config) {
   return config.hlsSegmentSeconds ?? DEFAULT_HLS_SEGMENT_SECONDS;
 }
 function resolveHlsGopSize(fps, segmentSeconds) {
-  return Math.max(1, Math.round(fpsToNumber2(fps) * segmentSeconds));
+  return keyframeIntervalToGopSize(fps, segmentSeconds);
 }
 function resolveHlsEncoderGopLock(outputFormat, fps, segmentSeconds) {
   if (outputFormat !== "hls") return { lockGopForChunkConcat: false, gopSize: void 0 };
@@ -831,6 +845,41 @@ function resolveHlsEncoderGopLock(outputFormat, fps, segmentSeconds) {
   };
 }
 
+// src/services/render/deliveryEncoder.ts
+import { appendRateCapArgs, keyframeIntervalToGopSize as keyframeIntervalToGopSize2 } from "@hyperframes/engine";
+function validateDeliveryEncoderConfig(config) {
+  const { keyframeIntervalSeconds, maxBitrate, bufferSize, format } = config;
+  if (keyframeIntervalSeconds === void 0 && maxBitrate === void 0 && bufferSize === void 0)
+    return;
+  if (keyframeIntervalSeconds !== void 0) {
+    if (!Number.isFinite(keyframeIntervalSeconds) || keyframeIntervalSeconds <= 0) {
+      throw new Error(
+        `keyframeIntervalSeconds must be a positive number of seconds; got ${keyframeIntervalSeconds}`
+      );
+    }
+    if (format === "hls") {
+      throw new Error(
+        "keyframeIntervalSeconds does not apply to hls; hlsSegmentSeconds sets its keyframes"
+      );
+    }
+  }
+  if (format !== void 0 && format !== "mp4") {
+    throw new Error(`keyframeIntervalSeconds and maxBitrate apply to mp4 renders, not ${format}`);
+  }
+  appendRateCapArgs([], { maxBitrate, bufferSize });
+}
+function chunkGopFrames(framesInChunk, intervalFrames) {
+  return Math.min(framesInChunk, intervalFrames ?? framesInChunk);
+}
+function resolveDeliveryEncoderOptions(config) {
+  const { maxBitrate, bufferSize, keyframeIntervalSeconds } = config;
+  const gop = keyframeIntervalSeconds === void 0 ? resolveHlsEncoderGopLock(config.format ?? "mp4", config.fps, config.hlsSegmentSeconds) : {
+    lockGopForChunkConcat: true,
+    gopSize: keyframeIntervalToGopSize2(config.fps, keyframeIntervalSeconds)
+  };
+  return { maxBitrate, bufferSize, ...gop };
+}
+
 // src/services/render/shared.ts
 import {
   copyFileSync,
@@ -1271,8 +1320,8 @@ var OrderedRenderEventPublisher = class {
     let timer;
     const drained = await Promise.race([
       this.tail.then(() => true),
-      new Promise((resolve12) => {
-        timer = setTimeout(() => resolve12(false), FLUSH_TIMEOUT_MS);
+      new Promise((resolve13) => {
+        timer = setTimeout(() => resolve13(false), FLUSH_TIMEOUT_MS);
       })
     ]);
     clearTimeout(timer);
@@ -1850,7 +1899,7 @@ function replanSegmentedAfterFailure(plan2, failure) {
   const keepSegmenting = failure.kind === "draw_element_verification" || failure.kind === "draw_element_capture";
   return createCapturePlan({
     ...plan2,
-    forceScreenshot: keepSegmenting || failure.kind === "capture_failure",
+    forceScreenshot: plan2.forceScreenshot || keepSegmenting || failure.kind === "capture_failure",
     useStreamingEncode: true,
     useLayeredComposite: false,
     useSegmentedCapture: keepSegmenting,
@@ -1920,7 +1969,7 @@ import { CaptureFailure, classifyCaptureFailure } from "@hyperframes/engine";
 
 // src/services/render/perfSummary.ts
 import { arch, cpus, platform, totalmem } from "node:os";
-import { fpsToNumber as fpsToNumber3 } from "@hyperframes/core";
+import { fpsToNumber as fpsToNumber2 } from "@hyperframes/core";
 
 // src/services/render/hdrPerf.ts
 function createHdrPerfCollector() {
@@ -2191,7 +2240,7 @@ function buildRenderPerfSummary(input) {
     // payloads (CLI telemetry, regression-harness reports) where a single
     // number is friendlier than `{num,den}`. Callers needing the rational
     // back can read `job.config.fps`.
-    fps: fpsToNumber3(input.job.config.fps),
+    fps: fpsToNumber2(input.job.config.fps),
     quality: input.job.config.quality,
     workers: input.workerCount,
     workerSizing: input.workerSizing,
@@ -2776,7 +2825,7 @@ import {
   resolveVideoExtractionWindow,
   runFfmpeg
 } from "@hyperframes/engine";
-import { fpsToFfmpegArg, fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
+import { fpsToFfmpegArg, fpsToNumber as fpsToNumber3 } from "@hyperframes/core";
 
 // src/services/hdrFrameWindows.ts
 import { closeSync as closeSync3, constants as constants2, openSync as openSync3, rmSync as rmSync4 } from "node:fs";
@@ -3079,7 +3128,7 @@ async function extractHdrVideoFrames(args) {
   const runFfmpegImpl = args.runFfmpegImpl ?? runFfmpeg;
   const extractMediaMetadataImpl = args.extractMediaMetadataImpl ?? extractMediaMetadata2;
   const resolveFinalFrameExtractionWindowImpl = args.resolveFinalFrameExtractionWindowImpl ?? resolveFinalFrameExtractionWindow;
-  const fps = fpsToNumber4(job.config.fps);
+  const fps = fpsToNumber3(job.config.fps);
   const out = /* @__PURE__ */ new Map();
   mkdirSync2(framesDir, { recursive: true });
   let scratchBytes = 0;
@@ -3616,7 +3665,7 @@ var SequentialCaptureStallError = class extends Error {
   }
 };
 function raceAgainstStall(promise, deadlineMs, input, signal) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const timer = setTimeout(
       () => {
         reject(
@@ -3635,7 +3684,7 @@ function raceAgainstStall(promise, deadlineMs, input, signal) {
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve12(value);
+        resolve13(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -3917,7 +3966,6 @@ async function runCaptureStreamingStage(input) {
     const reorderBuffer = createFrameReorderBuffer(0, totalFrames);
     if (workerCount > 1) {
       const deParallelStream = forceParallelStream === true || process.env.HF_DE_PARALLEL_STREAM === "true";
-      const tasks = deParallelStream ? distributeFramesInterleaved(totalFrames, workerCount, workDir) : distributeFrames(totalFrames, workerCount, workDir);
       const parallelStats = {
         verifyChecked: 0,
         blankSuspects: 0,
@@ -3930,143 +3978,158 @@ async function runCaptureStreamingStage(input) {
         frameTime: (i) => i * job.config.fps.den / job.config.fps.num
       });
       let parallelGuardRan = false;
-      let parallelDrainError = null;
-      const onFrameBuffer = async (frameIndex, buffer, workerSession) => {
-        try {
-          if (deParallelStream && workerSession.captureMode === "drawelement") {
-            parallelGuardRan = true;
-            buffer = await parallelGuard(workerSession, frameIndex, buffer);
-          }
-          await reorderBuffer.waitForFrame(frameIndex);
-          ensureFrameWritten(await currentEncoder.writeFrame(buffer), frameIndex, currentEncoder);
-          reorderBuffer.advanceTo(frameIndex + 1);
-        } catch (err) {
-          const e = err instanceof Error ? err : new Error(String(err));
-          if (!parallelDrainError) {
-            parallelDrainError = e;
-            reorderBuffer.abort(e);
+      let writtenFrames = 0;
+      let resumeFrom = 0;
+      let resumedAfterStall = false;
+      let workerResults;
+      for (; ; ) {
+        const parallelReorder = createFrameReorderBuffer(resumeFrom, totalFrames);
+        const tasks = deParallelStream ? distributeFramesInterleaved(totalFrames - resumeFrom, workerCount, workDir, resumeFrom) : distributeFrames(totalFrames - resumeFrom, workerCount, workDir, resumeFrom);
+        let parallelDrainError = null;
+        const onFrameBuffer = async (frameIndex, buffer, workerSession) => {
+          try {
+            if (deParallelStream && workerSession.captureMode === "drawelement") {
+              parallelGuardRan = true;
+              buffer = await parallelGuard(workerSession, frameIndex, buffer);
+            }
+            await parallelReorder.waitForFrame(frameIndex);
+            ensureFrameWritten(await currentEncoder.writeFrame(buffer), frameIndex, currentEncoder);
+            parallelReorder.advanceTo(frameIndex + 1);
+            writtenFrames = frameIndex + 1;
+          } catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            if (!parallelDrainError) {
+              parallelDrainError = e;
+              parallelReorder.abort(e);
+            }
+            throw e;
           }
-          throw e;
+        };
+        const captureLabel = input.parallelCaptureLabel ?? "worker";
+        let watchdogArmed = false;
+        const stallController = new AbortController();
+        const forwardParentAbort = () => stallController.abort();
+        if (abortSignal) {
+          if (abortSignal.aborted) stallController.abort();
+          else abortSignal.addEventListener("abort", forwardParentAbort, { once: true });
         }
-      };
-      const captureLabel = input.parallelCaptureLabel ?? "worker";
-      let watchdogArmed = false;
-      const stallController = new AbortController();
-      const forwardParentAbort = () => stallController.abort();
-      if (abortSignal) {
-        if (abortSignal.aborted) stallController.abort();
-        else abortSignal.addEventListener("abort", forwardParentAbort, { once: true });
-      }
-      const stallTimeoutMs = resolveCaptureStallTimeoutMs();
-      let lastCapturedFrames = 0;
-      let lastProgressAt = Date.now();
-      const workerPhases = /* @__PURE__ */ new Map();
-      const phaseSummary = () => [...workerPhases.entries()].sort(([left], [right]) => left - right).map(([workerId, detail]) => `worker=${workerId} ${detail}`).join("; ");
-      let stalled = false;
-      const stallTimer = setInterval(
-        () => {
-          if (!watchdogArmed || Date.now() - lastProgressAt <= stallTimeoutMs) return;
-          stalled = true;
-          const stallErr = new ParallelCaptureStallError({
-            variant: "drain",
-            captureLabel,
-            stallTimeoutMs,
-            lastCapturedFrames,
-            totalFrames,
-            phaseSummary: phaseSummary()
-          });
-          reorderBuffer.abort(stallErr);
-          stallController.abort();
-        },
-        Math.min(stallTimeoutMs, DE_STALL_POLL_MS)
-      );
-      let workerResults;
-      try {
-        workerResults = await executeParallelCapture(
-          fileServer.url,
-          workDir,
-          tasks,
-          buildCaptureOptions(),
-          createRenderVideoFrameInjector,
-          stallController.signal,
-          (progress) => {
-            if (progress.latestWorkerPhase) {
-              const phase = progress.latestWorkerPhase;
-              const detail = `phase=${phase.phase} frame=${phase.frameIndex ?? "n/a"} browser=${phase.browserExecutable} version=${phase.browserVersion} CanvasDrawElement=${phase.canvasDrawElement} gpu=${phase.gpuBackend}`;
-              workerPhases.set(phase.workerId, detail);
-              if (phase.phase === "frame_capture" && !watchdogArmed) {
-                watchdogArmed = true;
+        const stallTimeoutMs = resolveCaptureStallTimeoutMs();
+        let lastCapturedFrames = 0;
+        let lastProgressAt = Date.now();
+        const workerPhases = /* @__PURE__ */ new Map();
+        const phaseDetail = (phase) => `phase=${phase.phase} frame=${phase.frameIndex ?? "n/a"} step=${phase.readStep?.() ?? "n/a"} browser=${phase.browserExecutable} version=${phase.browserVersion} CanvasDrawElement=${phase.canvasDrawElement} gpu=${phase.gpuBackend}`;
+        const phaseSummary = () => [...workerPhases.entries()].sort(([left], [right]) => left - right).map(([workerId, detail]) => `worker=${workerId} ${detail}`).join("; ");
+        let stalled = false;
+        const stallTimer = setInterval(
+          () => {
+            if (!watchdogArmed || Date.now() - lastProgressAt <= stallTimeoutMs) return;
+            stalled = true;
+            const stallErr = new ParallelCaptureStallError({
+              variant: "drain",
+              captureLabel,
+              stallTimeoutMs,
+              lastCapturedFrames: resumeFrom + lastCapturedFrames,
+              totalFrames,
+              phaseSummary: phaseSummary()
+            });
+            parallelReorder.abort(stallErr);
+            stallController.abort();
+          },
+          Math.min(stallTimeoutMs, DE_STALL_POLL_MS)
+        );
+        try {
+          workerResults = await executeParallelCapture(
+            fileServer.url,
+            workDir,
+            tasks,
+            buildCaptureOptions(),
+            createRenderVideoFrameInjector,
+            stallController.signal,
+            (progress) => {
+              if (progress.latestWorkerPhase) {
+                const phase = progress.latestWorkerPhase;
+                workerPhases.set(phase.workerId, phaseDetail(phase));
+                if (phase.phase === "frame_capture" && !watchdogArmed) {
+                  watchdogArmed = true;
+                  lastProgressAt = Date.now();
+                }
+                log.info("[Render] Parallel capture worker phase", {
+                  workerId: phase.workerId,
+                  phase: phase.phase,
+                  frameIndex: phase.frameIndex,
+                  browserExecutable: phase.browserExecutable,
+                  browserVersion: phase.browserVersion,
+                  canvasDrawElement: phase.canvasDrawElement,
+                  gpuBackend: phase.gpuBackend
+                });
+                if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
+                return;
+              }
+              if (progress.capturedFrames > lastCapturedFrames) {
+                lastCapturedFrames = progress.capturedFrames;
                 lastProgressAt = Date.now();
+                watchdogArmed = true;
+              }
+              const doneFrames = resumeFrom + progress.capturedFrames;
+              job.framesRendered = doneFrames;
+              const frameProgress = doneFrames / totalFrames;
+              reportFrameProgress(
+                job,
+                `Streaming frame ${doneFrames}/${totalFrames} (${workerCount} workers)`,
+                Math.round(25 + frameProgress * 55),
+                onProgress,
+                doneFrames,
+                totalFrames
+              );
+            },
+            onFrameBuffer,
+            // Interleaved DE workers each get their own browser process: co-tenant pages starve
+            // each other's paint events.
+            deParallelStream ? { ...captureCfg, enableBrowserPool: false } : captureCfg,
+            {
+              // A worker died: release parked peers with its original failure, not the stall the
+              // watchdog raises later.
+              onWorkerOperation: (phase) => workerPhases.set(phase.workerId, phaseDetail(phase)),
+              onWorkerFailure: (failure) => {
+                if (parallelDrainError) return;
+                parallelDrainError = failure;
+                parallelReorder.abort(failure);
               }
-              log.info("[Render] Parallel capture worker phase", {
-                workerId: phase.workerId,
-                phase: phase.phase,
-                frameIndex: phase.frameIndex,
-                browserExecutable: phase.browserExecutable,
-                browserVersion: phase.browserVersion,
-                canvasDrawElement: phase.canvasDrawElement,
-                gpuBackend: phase.gpuBackend
-              });
-              if (progress.capturedFrames === 0) reportWorkerStartup(job, progress, onProgress);
-              return;
-            }
-            if (progress.capturedFrames > lastCapturedFrames) {
-              lastCapturedFrames = progress.capturedFrames;
-              lastProgressAt = Date.now();
-              watchdogArmed = true;
             }
-            job.framesRendered = progress.capturedFrames;
-            const frameProgress = progress.capturedFrames / progress.totalFrames;
-            reportFrameProgress(
-              job,
-              `Streaming frame ${progress.capturedFrames}/${progress.totalFrames} (${workerCount} workers)`,
-              Math.round(25 + frameProgress * 55),
-              onProgress,
-              progress.capturedFrames,
-              progress.totalFrames
+          );
+        } catch (err) {
+          if (stalled && abortSignal?.aborted !== true && captureLabel === "BeginFrame" && !resumedAfterStall && writtenFrames > resumeFrom) {
+            resumedAfterStall = true;
+            log.warn(
+              "[Render] Parallel BeginFrame capture stalled; resuming from the first unwritten frame",
+              {
+                resumeFrom: writtenFrames,
+                totalFrames,
+                workerPhases: phaseSummary()
+              }
             );
-          },
-          onFrameBuffer,
-          // Interleaved DE workers each need their own browser PROCESS:
-          // pages co-tenant in one browser share one compositor, whose
-          // internal frame scheduling deprioritizes non-active pages — their
-          // canvas `paint` events starve and the drawElement paint-wait slows
-          // ~3x (measured: 86s vs 30s on a 3,245-frame rAF comp). This is
-          // Chromium's internal frame-production scheduling on ALL platforms,
-          // NOT the Linux-only HeadlessExperimental.beginFrame capture mode.
-          deParallelStream ? { ...captureCfg, enableBrowserPool: false } : captureCfg,
-          {
-            // A worker died (Target closed, Page crashed, launch failure).
-            // Its frames are gone and peers are parked in waitForFrame on the
-            // first of them; release them with the ORIGINAL failure so the
-            // orchestrator sees a transient browser error it knows how to
-            // retry, not the stall the watchdog would have raised a minute
-            // later. First failure wins, same as the drain guard above.
-            onWorkerFailure: (failure) => {
-              if (parallelDrainError) return;
-              parallelDrainError = failure;
-              reorderBuffer.abort(failure);
-            }
+            resumeFrom = writtenFrames;
+            continue;
           }
-        );
-      } catch (err) {
-        if (parallelDrainError) throw poolFailure(parallelDrainError, probeSession);
-        if (stalled && abortSignal?.aborted !== true) {
-          throw new ParallelCaptureStallError({
-            variant: "pool",
-            captureLabel,
-            stallTimeoutMs,
-            lastCapturedFrames,
-            totalFrames,
-            phaseSummary: phaseSummary()
-          });
+          if (parallelDrainError) throw poolFailure(parallelDrainError, probeSession);
+          if (stalled && abortSignal?.aborted !== true) {
+            throw new ParallelCaptureStallError({
+              variant: "pool",
+              captureLabel,
+              stallTimeoutMs,
+              lastCapturedFrames: resumeFrom + lastCapturedFrames,
+              totalFrames,
+              phaseSummary: phaseSummary()
+            });
+          }
+          throw poolFailure(err, probeSession);
+        } finally {
+          clearInterval(stallTimer);
+          abortSignal?.removeEventListener("abort", forwardParentAbort);
         }
-        throw poolFailure(err, probeSession);
-      } finally {
-        clearInterval(stallTimer);
-        abortSignal?.removeEventListener("abort", forwardParentAbort);
+        if (parallelDrainError) throw poolFailure(parallelDrainError, probeSession);
+        break;
       }
-      if (parallelDrainError) throw poolFailure(parallelDrainError, probeSession);
       pushWorkerDedupPerfs(workerResults, dedupPerfs);
       const workerPageErrors = [];
       pushWorkerPageErrors(workerResults, workerPageErrors);
@@ -4227,7 +4290,7 @@ function segmentEncoderOptions(base, segment) {
   return {
     ...base,
     lockGopForChunkConcat: true,
-    gopSize: segment.endFrame - segment.startFrame
+    gopSize: Math.min(base.gopSize ?? Infinity, segment.endFrame - segment.startFrame)
   };
 }
 var SegmentEncoderSpawnError = class extends Error {
@@ -4321,6 +4384,12 @@ function defaultSessionFactory(input) {
   let probeSession = input.probeSession;
   return {
     create: async () => {
+      const probeCannotCaptureEveryFrame = Boolean(probeSession?.deRiskFrames?.size);
+      if (probeSession && probeCannotCaptureEveryFrame) {
+        await closeCaptureSession2(probeSession).catch(() => {
+        });
+        probeSession = null;
+      }
       const session = probeSession ?? await openSegmentedSession(input);
       if (probeSession) {
         openSegmentedSessionReuse(input, probeSession);
@@ -4651,8 +4720,10 @@ function computeSegmentPlanHash(input) {
     input.motionBlur,
     input.pageMotionBlur ?? "",
     input.captureQuality === void 0 ? "" : String(input.captureQuality)
-  ].join(" ");
-  return createHash2("sha256").update(ordered).digest("hex").slice(0, 16);
+  ];
+  const delivery = [input.maxBitrate, input.bufferSize, input.gopSize].map((v) => v ?? "");
+  if (delivery.some((v) => v !== "")) ordered.push(...delivery.map(String));
+  return createHash2("sha256").update(ordered.join(" ")).digest("hex").slice(0, 16);
 }
 function segmentDirFor(projectRendersDir, planHash) {
   return join11(projectRendersDir, ".hf-segments", planHash);
@@ -4799,7 +4870,7 @@ function resolveVideoCaptureBeyondViewport(videoCount) {
 
 // src/services/render/captureCost.ts
 import { join as join12 } from "node:path";
-import { fpsToNumber as fpsToNumber5 } from "@hyperframes/core";
+import { fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
 import {
   calculateOptimalWorkers,
   captureFrameToBuffer as captureFrameToBuffer3,
@@ -5003,7 +5074,7 @@ async function runCaptureCalibration(input) {
   let probeSession = input.probeSession;
   let forceScreenshot = input.forceScreenshot;
   let lastBrowserConsole = [];
-  const fps = fpsToNumber5(job.config.fps);
+  const fps = fpsToNumber4(job.config.fps);
   const sessionRef = { current: null };
   const runOneCalibration = async (sessionDir, sessionCfg) => {
     log.info("Launching browser for capture calibration...");
@@ -5463,7 +5534,7 @@ function emitFallbackCaptureProfile(recorder, perfSummaries, env = process.env)
 // src/services/render/videoFrameCoverage.ts
 import { parseHTML } from "linkedom";
 import {
-  fpsToNumber as fpsToNumber6,
+  fpsToNumber as fpsToNumber5,
   normalizeRateSpec,
   sourceTimeAt,
   toFps
@@ -5498,7 +5569,7 @@ function resolveVideoCoverageThreshold(envValue = process.env.HF_VIDEO_COVERAGE_
   return parsed;
 }
 function expectedFramesForClip(start, end, fps, rounding = "ceil") {
-  const fpsValue = fpsToNumber6(toFps(fps));
+  const fpsValue = fpsToNumber5(toFps(fps));
   if (!Number.isFinite(start) || !Number.isFinite(end) || !Number.isFinite(fpsValue)) return 0;
   if (fpsValue <= 0) return 0;
   const duration = Math.max(0, end - start);
@@ -5563,15 +5634,15 @@ function countAuthoredTimedClips(html) {
 }
 
 // src/services/render/stages/compileStage.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { suggestMatchingPreset } from "@hyperframes/core";
 
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
-import { createHash as createHash5 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join14, dirname as dirname6, resolve as resolve6, basename as basename4, relative as relative2 } from "path";
-import { parseHTML as parseHTML4 } from "linkedom";
+import { createHash as createHash6 } from "node:crypto";
+import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7 } from "fs";
+import { join as join15, dirname as dirname7, resolve as resolve7, basename as basename4, relative as relative2 } from "path";
+import { parseHTML as parseHTML5 } from "linkedom";
 import {
   COMPOSITION_SOURCE_URL,
   compileTimingAttrs,
@@ -5847,7 +5918,7 @@ function readLoopOverride(el) {
   }
   return null;
 }
-function resolveGifSourcePath(src, options) {
+function resolveLocalImageSourcePath(src, options) {
   const trimmed = src.trim();
   if (!trimmed || trimmed.startsWith("data:")) return null;
   const { basePath } = splitUrlSuffix(trimmed);
@@ -6070,7 +6141,7 @@ async function prepareAnimatedGifInputs(html, options) {
     const img = images[i];
     const src = (img.getAttribute("src") || "").trim();
     if (!hasGifExtension(src)) continue;
-    const sourcePath = resolveGifSourcePath(src, options);
+    const sourcePath = resolveLocalImageSourcePath(src, options);
     if (!sourcePath) continue;
     const bytes = readFileSync5(sourcePath);
     const metadata = parseAnimatedGifMetadata(bytes);
@@ -6118,19 +6189,74 @@ async function prepareAnimatedGifInputs(html, options) {
   };
 }
 
-// src/services/htmlCompiler.ts
-import { createStudioPositionSeekReapplyScript } from "@hyperframes/studio-server/manual-edits-render-script";
-import { getPositionEditsRenderScript } from "@hyperframes/core/runtime/position-edits-render";
-
-// src/services/assetMediaType.ts
-import { existsSync as existsSync9 } from "node:fs";
+// src/services/heifImagePrep.ts
+import { createHash as createHash5 } from "node:crypto";
 import {
-  fingerprintElementId,
-  isNotMediaPayload,
-  NotMediaPayloadError,
-  probeMediaProfile,
-  resolveProjectRelativeSrc as resolveProjectRelativeSrc2
-} from "@hyperframes/engine";
+  closeSync as closeSync4,
+  copyFileSync as copyFileSync3,
+  mkdirSync as mkdirSync6,
+  openSync as openSync4,
+  readFileSync as readFileSync6,
+  readSync as readSync3,
+  rmSync as rmSync8,
+  statSync as statSync6,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { dirname as dirname6, join as join14, resolve as resolve6 } from "node:path";
+import { parseHTML as parseHTML4 } from "linkedom";
+import { renameWithRetry as renameWithRetry4, runFfmpeg as runFfmpeg3, runFfprobe } from "@hyperframes/engine";
+
+// src/services/heifRotation.ts
+function* boxes(buf, start, end) {
+  let at = start;
+  while (at + 8 <= end) {
+    let size = buf.readUInt32BE(at);
+    let header = 8;
+    if (size === 1 && at + 16 <= end) {
+      size = Number(buf.readBigUInt64BE(at + 8));
+      header = 16;
+    } else if (size === 0) {
+      size = end - at;
+    }
+    if (size < header || at + size > end) return;
+    yield { type: buf.toString("latin1", at + 4, at + 8), start: at + header, end: at + size };
+    at += size;
+  }
+}
+function child(buf, parent, type, skip = 0) {
+  return [...boxes(buf, parent.start + skip, parent.end)].filter((box2) => box2.type === type);
+}
+function readHeifPrimaryRotation(buf) {
+  try {
+    const root = { type: "", start: 0, end: buf.length };
+    const meta = child(buf, root, "meta")[0];
+    const pitm = meta && child(buf, meta, "pitm", 4)[0];
+    const iprp = meta && child(buf, meta, "iprp", 4)[0];
+    const ipco = iprp && child(buf, iprp, "ipco")[0];
+    if (!pitm || !ipco || !iprp) return 0;
+    const primaryId = buf[pitm.start] === 0 ? buf.readUInt16BE(pitm.start + 4) : buf.readUInt32BE(pitm.start + 4);
+    const props = [...boxes(buf, ipco.start, ipco.end)];
+    for (const ipma of child(buf, iprp, "ipma")) {
+      const version = buf[ipma.start];
+      const wide = (buf[ipma.start + 3] & 1) === 1;
+      let at = ipma.start + 8;
+      for (let n = buf.readUInt32BE(ipma.start + 4); n > 0 && at < ipma.end; n--) {
+        const id = version < 1 ? buf.readUInt16BE(at) : buf.readUInt32BE(at);
+        at += version < 1 ? 2 : 4;
+        const count = buf[at++];
+        for (let i = 0; i < count; i++) {
+          const index = wide ? buf.readUInt16BE(at) & 32767 : buf[at] & 127;
+          at += wide ? 2 : 1;
+          const prop = props[index - 1];
+          if (id === primaryId && prop?.type === "irot")
+            return (buf[prop.start] & 3) * 90;
+        }
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
 
 // src/utils/semaphore.ts
 var Semaphore = class {
@@ -6145,10 +6271,10 @@ var Semaphore = class {
       this.active++;
       return () => this.release();
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve13) => {
       this.queue.push(() => {
         this.active++;
-        resolve12(() => this.release());
+        resolve13(() => this.release());
       });
     });
   }
@@ -6179,7 +6305,229 @@ async function withMediaProbeSlot(operation) {
   }
 }
 
+// src/services/heifImagePrep.ts
+var PREPARED_HEIF_SUBDIR = "_heif_images";
+var CACHE_SCHEMA2 = "hfheif-v1";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var HEIF_IMAGE_CONVERSION_FAILED = "HEIF_IMAGE_CONVERSION_FAILED";
+var HEIF_TOOL_UNAVAILABLE = "HEIF_TOOL_UNAVAILABLE";
+var HEIF_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "hevc", "hevx", "heim", "heis", "mif1", "msf1"]);
+var AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+var DATA_URL_RE = /^data:image\/(?:heic|heif)(?:-sequence)?;base64,(.*)$/is;
+var HeifImageConversionError = class extends Error {
+  code = HEIF_IMAGE_CONVERSION_FAILED;
+  owner = "user";
+  retryable = false;
+  constructor(label, reason) {
+    super(
+      `Could not convert HEIC/HEIF image ${label} to JPEG: ${reason}. Re-export the photo as JPEG or PNG and update its src.`
+    );
+    this.name = "HeifImageConversionError";
+  }
+};
+var HeifToolUnavailableError = class extends Error {
+  code = HEIF_TOOL_UNAVAILABLE;
+  owner = "system";
+  retryable = false;
+  constructor(label, reason) {
+    super(
+      `Could not convert HEIC/HEIF image ${label}: ${reason}. Converting HEIC needs ffmpeg and ffprobe 7.0 or newer with the hevc decoder.`
+    );
+    this.name = "HeifToolUnavailableError";
+  }
+};
+var TOOL_FAILURE_RE = /(?:ffmpeg|ffprobe) not found|ENOENT|Option not found|Unrecognized option|Unknown decoder|Decoder \S+ not found/i;
+function isHeifBytes(head) {
+  const bytes = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
+  if (bytes.length < 16 || bytes.toString("ascii", 4, 8) !== "ftyp") return false;
+  const boxEnd = Math.min(bytes.readUInt32BE(0), bytes.length);
+  if (boxEnd < 16) return false;
+  const brands = [bytes.toString("ascii", 8, 12)];
+  for (let offset = 16; offset + 4 <= boxEnd; offset += 4) {
+    brands.push(bytes.toString("ascii", offset, offset + 4));
+  }
+  return !brands.some((b) => AVIF_BRANDS.has(b)) && brands.some((b) => HEIF_BRANDS.has(b));
+}
+function readHead(path) {
+  let fd;
+  try {
+    fd = openSync4(path, "r");
+    const buf = Buffer.alloc(4096);
+    return buf.subarray(0, readSync3(fd, buf, 0, buf.length, 0));
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) closeSync4(fd);
+  }
+}
+async function probeJson(path, withGroups) {
+  const stdout = await runFfprobe(
+    path,
+    withGroups ? ["-show_stream_groups", "-show_streams", "-of", "json"] : ["-show_streams", "-of", "json"]
+  );
+  return JSON.parse(stdout);
+}
+var ROTATION_FILTER = {
+  0: "",
+  90: "transpose=2",
+  180: "hflip,vflip",
+  270: "transpose=1"
+};
+function primaryGrid(probed) {
+  const groups = probed.stream_groups ?? [];
+  return (groups.find((g) => g.disposition?.default === 1) ?? groups[0])?.components?.[0];
+}
+async function convertHeifToJpeg(request) {
+  const probed = await probeJson(request.inputPath, true);
+  const grid = primaryGrid(probed);
+  const rotation = readHeifPrimaryRotation(readFileSync6(request.inputPath));
+  const filters = [];
+  let inputs = [];
+  let size = probed.streams?.[0];
+  if (grid?.subcomponents?.length) {
+    size = grid;
+    const layout = grid.subcomponents.map(
+      (t) => `${t.tile_horizontal_offset}_${t.tile_vertical_offset}`
+    );
+    inputs = grid.subcomponents.map((t) => `[0:${t.stream_index}]`);
+    filters.push(
+      `${inputs.join("")}xstack=inputs=${inputs.length}:layout=${layout.join("|")}`,
+      `crop=${grid.width}:${grid.height}:${grid.horizontal_offset ?? 0}:${grid.vertical_offset ?? 0}`
+    );
+  }
+  if (!size?.width || !size.height) throw new Error("no declared image size");
+  if (rotation && grid) filters.push(ROTATION_FILTER[rotation]);
+  const mapArgs = filters.length > 0 ? ["-filter_complex", `${filters.join(",")}[v]`, "-map", "[v]"] : [];
+  const result = await runFfmpeg3(
+    [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-i",
+      request.inputPath,
+      ...mapArgs,
+      "-frames:v",
+      "1",
+      "-q:v",
+      "2",
+      "-f",
+      "mjpeg",
+      "-y",
+      request.outputPath
+    ],
+    { timeout: request.timeoutMs ?? DEFAULT_TIMEOUT_MS }
+  );
+  if (!result.success) {
+    throw result.error ?? new Error(`ffmpeg exited ${result.exitCode}: ${result.stderr.slice(-300)}`);
+  }
+  const out = (await probeJson(request.outputPath, false)).streams?.[0];
+  const same = out?.width === size.width && out.height === size.height;
+  const swapped = out?.width === size.height && out.height === size.width;
+  if (!same && !swapped) {
+    throw new Error(
+      `wrong size: decoded ${out?.width}x${out?.height}, file declares ${size.width}x${size.height}`
+    );
+  }
+}
+function resolveImageSource(src, options) {
+  const data = DATA_URL_RE.exec(src);
+  if (data) {
+    const bytes = Buffer.from(data[1], "base64");
+    return isHeifBytes(bytes.subarray(0, 4096)) ? { path: null, bytes, label: '"inline image"' } : null;
+  }
+  const path = resolveLocalImageSourcePath(src, options);
+  const head = path ? readHead(path) : null;
+  if (!path || !head || !isHeifBytes(head)) return null;
+  return { path, bytes: readFileSync6(path), label: `"${splitUrlSuffix(src).basePath}"` };
+}
+function isUsableFile2(path) {
+  try {
+    return statSync6(path).size > 0;
+  } catch {
+    return false;
+  }
+}
+async function ensurePreparedJpeg(source, cachePath, outputPath, options) {
+  mkdirSync6(dirname6(cachePath), { recursive: true });
+  mkdirSync6(dirname6(outputPath), { recursive: true });
+  if (!isUsableFile2(cachePath)) {
+    const tmpPath = `${cachePath}.tmp-${process.pid}-${Date.now()}`;
+    const inlinePath = `${tmpPath}.heic`;
+    const inputPath = source.path ?? inlinePath;
+    try {
+      if (!source.path) writeFileSync4(inlinePath, source.bytes);
+      await (options.transcode ?? convertHeifToJpeg)({
+        inputPath,
+        outputPath: tmpPath,
+        timeoutMs: options.timeoutMs
+      });
+      if (!isUsableFile2(tmpPath)) throw new Error("conversion produced an empty file");
+      renameWithRetry4(tmpPath, cachePath);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw TOOL_FAILURE_RE.test(reason) ? new HeifToolUnavailableError(source.label, reason) : new HeifImageConversionError(source.label, reason);
+    } finally {
+      rmSync8(tmpPath, { force: true });
+      rmSync8(inlinePath, { force: true });
+    }
+  }
+  if (resolve6(outputPath) !== resolve6(cachePath) && !isUsableFile2(outputPath)) {
+    copyFileSync3(cachePath, outputPath);
+  }
+}
+async function prepareHeifImageInputs(html, options) {
+  const outputDir = options.outputDir ?? join14(options.downloadDir, PREPARED_HEIF_SUBDIR);
+  const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_HEIF_SUBDIR);
+  const cacheDir = options.cacheDir ?? outputDir;
+  const preparedAssets = /* @__PURE__ */ new Map();
+  const preparedImages = [];
+  if (!/<img\b/i.test(html)) return { html, preparedAssets, preparedImages };
+  const { document: document2 } = parseHTML4(html);
+  const found = [];
+  for (const img of Array.from(document2.querySelectorAll("img[src]"))) {
+    const src = (img.getAttribute("src") || "").trim();
+    const source = src ? resolveImageSource(src, options) : null;
+    if (!source) continue;
+    const hash = createHash5("sha256").update(CACHE_SCHEMA2).update("\0").update(source.bytes).digest("hex");
+    found.push({ img, src, source, filename: `${CACHE_SCHEMA2}-${hash.slice(0, 24)}.jpg` });
+  }
+  if (found.length === 0) return { html, preparedAssets, preparedImages };
+  const unique = new Map(found.map((item) => [item.filename, item.source]));
+  const failed = /* @__PURE__ */ new Set();
+  await Promise.all(
+    [...unique].map(
+      ([filename, source]) => withMediaProbeSlot(
+        () => ensurePreparedJpeg(source, join14(cacheDir, filename), join14(outputDir, filename), options)
+      ).catch((error) => {
+        if (!options.onFailure) throw error;
+        failed.add(filename);
+        options.onFailure(error);
+      })
+    )
+  );
+  for (const { img, src, filename } of found) {
+    if (failed.has(filename)) continue;
+    const outputSrc = `${outputSrcPrefix}/${filename}`;
+    img.setAttribute("src", outputSrc);
+    preparedAssets.set(outputSrc, join14(outputDir, filename));
+    preparedImages.push({ sourceSrc: src, outputSrc, outputPath: join14(outputDir, filename) });
+  }
+  return { html: document2.toString(), preparedAssets, preparedImages };
+}
+
+// src/services/htmlCompiler.ts
+import { createStudioPositionSeekReapplyScript } from "@hyperframes/studio-server/manual-edits-render-script";
+import { getPositionEditsRenderScript } from "@hyperframes/core/runtime/position-edits-render";
+
 // src/services/assetMediaType.ts
+import { existsSync as existsSync9 } from "node:fs";
+import {
+  fingerprintElementId,
+  isNotMediaPayload,
+  NotMediaPayloadError,
+  probeMediaProfile,
+  resolveProjectRelativeSrc as resolveProjectRelativeSrc2
+} from "@hyperframes/engine";
 var ASSET_MEDIA_TYPE_MISMATCH = "ASSET_MEDIA_TYPE_MISMATCH";
 var AssetMediaTypeMismatchError = class extends Error {
   code = ASSET_MEDIA_TYPE_MISMATCH;
@@ -6289,7 +6637,7 @@ function logRemoteDownloadTelemetry(event) {
 }
 var INFERRED_MEDIA_DURATION_ATTR = "data-hf-inferred-duration";
 function parseSubCompHtmlForValidity(html) {
-  return parseHTML4(html).document;
+  return parseHTML5(html).document;
 }
 function endsWithSourceUrl(code) {
   const trimmed = code.trimEnd();
@@ -6297,7 +6645,7 @@ function endsWithSourceUrl(code) {
   return lastLine.startsWith("//# sourceURL=") || lastLine.startsWith("//@ sourceURL=");
 }
 function prepareCompositionScripts(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   for (const el of document2.querySelectorAll("script:not([src])")) {
     const isModule = (el.getAttribute("type") || "").trim().toLowerCase() === "module";
     const runsAsScript = isModule || isJavaScriptType(el);
@@ -6334,14 +6682,14 @@ Check that each file referenced by data-composition-src contains valid HTML with
   }
 };
 function assertSubCompositionsUsable(html, projectDir, visited = /* @__PURE__ */ new Set()) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const hosts = [...document2.querySelectorAll("[data-composition-src]")];
   const problems = [];
   for (const el of hosts) {
     const srcPath = el.getAttribute("data-composition-src");
     if (!srcPath) continue;
     if (isUnresolvedAssetPlaceholder(srcPath)) continue;
-    const filePath = resolve6(projectDir, srcPath);
+    const filePath = resolve7(projectDir, srcPath);
     if (visited.has(filePath)) continue;
     const read = readProjectFile(filePath);
     if (read.kind === "missing") {
@@ -6397,7 +6745,7 @@ function runtimeRoot(document2) {
 }
 function detectRenderModeHints(html, pageMotionBlur) {
   const reasons = [];
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   if (document2.querySelector("canvas[layoutsubtree]")) {
     reasons.push({
       code: "htmlInCanvas",
@@ -6439,7 +6787,7 @@ function detectThreeDTransformUsage(html) {
 }
 var BACKGROUND_IMAGE_DECL_PATTERN = /(?:^|;|\{)\s*background(?:-image)?\s*:[^;}]*(?:\bgradient\s*\(|url\s*\()/i;
 function detectAncestorBackgroundImage(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const root = document2.querySelector("[data-composition-id]");
   if (!root) return false;
   const ancestors = [];
@@ -6483,10 +6831,10 @@ function detectShaderTransitionUsage(html) {
   }
   return false;
 }
-async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, downloadDir, tagName, elementIdentity, log, urlByAbsentLocalPath) {
+async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, downloadDir, tagName, elementIdentity, log, urlByAbsentLocalPath, probes) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync10(downloadDir)) mkdirSync6(downloadDir, { recursive: true });
+    if (!existsSync10(downloadDir)) mkdirSync7(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir, void 0, void 0, void 0, {
         onTelemetry: logRemoteDownloadTelemetry
@@ -6496,7 +6844,7 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
     }
   } else {
     filePath = decodedUrlPath(src);
-    if (!filePath.startsWith("/")) filePath = join14(baseDir, filePath);
+    if (!filePath.startsWith("/")) filePath = join15(baseDir, filePath);
     filePath = urlByAbsentLocalPath?.get(filePath) ?? filePath;
   }
   if (!isHttpUrl(filePath) && !existsSync10(filePath)) {
@@ -6510,50 +6858,57 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
     if (error instanceof Error && error.stack) wrapped.stack = error.stack;
     return wrapped;
   };
-  return withMediaProbeSlot(async () => {
-    let profile;
+  const probe = () => withMediaProbeSlot(async () => {
     try {
       await assertMediaPayload(filePath, elementIdentity);
-      profile = await probeMediaProfile2(filePath);
-    } catch (error) {
-      if (tagName !== "video") {
-        if (error instanceof NotMediaPayloadError2) {
-          log?.warn(
-            `[compile] Audio "${elementIdentity}" (${src}) is a text document, not a media file, so the element is dropped from the render. Point it at a rendered media file.`
-          );
-        }
-        return { duration: null, resolvedPath: filePath };
+      const profile = await probeMediaProfile2(filePath);
+      if (tagName === "video") {
+        return { profile, fileDuration: (await extractMediaMetadata(filePath)).durationSeconds };
       }
-      throw withSrcContext(error);
-    }
-    assertAssetMediaTypeProfile(tagName === "video" ? "video" : "audio", profile, elementIdentity);
-    let metadata;
-    if (tagName === "video") {
       try {
-        metadata = await extractMediaMetadata(filePath);
-      } catch (error) {
-        throw withSrcContext(error);
-      }
-    } else {
-      try {
-        metadata = await extractAudioMetadata(filePath);
+        return { profile, fileDuration: (await extractAudioMetadata(filePath)).durationSeconds };
       } catch {
-        return { duration: null, resolvedPath: filePath };
+        return { profile, fileDuration: null };
       }
+    } catch (error) {
+      return { error };
     }
-    const fileDuration = metadata.durationSeconds;
-    const duration = resolveNaturalMediaTimelineDurationFromValues(
-      fileDuration,
-      mediaStart,
-      playbackRate
-    );
-    return { duration, resolvedPath: filePath };
   });
+  const key = `${tagName}\0${filePath}`;
+  let probed = probes?.get(key);
+  if (!probed) {
+    probed = probe();
+    probes?.set(key, probed);
+  }
+  const outcome = await probed;
+  if ("error" in outcome) {
+    if (tagName !== "video") {
+      if (outcome.error instanceof NotMediaPayloadError2) {
+        log?.warn(
+          `[compile] Audio "${elementIdentity}" (${src}) is a text document, not a media file, so the element is dropped from the render. Point it at a rendered media file.`
+        );
+      }
+      return { duration: null, resolvedPath: filePath };
+    }
+    throw withSrcContext(outcome.error);
+  }
+  assertAssetMediaTypeProfile(
+    tagName === "video" ? "video" : "audio",
+    outcome.profile,
+    elementIdentity
+  );
+  if (outcome.fileDuration === null) return { duration: null, resolvedPath: filePath };
+  const duration = resolveNaturalMediaTimelineDurationFromValues(
+    outcome.fileDuration,
+    mediaStart,
+    playbackRate
+  );
+  return { duration, resolvedPath: filePath };
 }
 function markInferredVariableMediaDurations(html, unresolvedMedia) {
   const unresolvedIds = new Set(unresolvedMedia.map((element) => element.id));
   if (unresolvedIds.size === 0) return html;
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   let changed = false;
   for (const element of document2.querySelectorAll("video[data-var-src], audio[data-var-src]")) {
     if (!unresolvedIds.has(element.id)) continue;
@@ -6562,7 +6917,7 @@ function markInferredVariableMediaDurations(html, unresolvedMedia) {
   }
   return changed ? document2.toString() : html;
 }
-async function compileHtmlFile(html, baseDir, downloadDir, log, urlByAbsentLocalPath) {
+async function compileHtmlFile(html, baseDir, downloadDir, log, urlByAbsentLocalPath, probes) {
   const { html: staticCompiled, unresolved } = compileTimingAttrs(html);
   const mediaUnresolved = unresolved.filter(
     (el) => (el.tagName === "video" || el.tagName === "audio") && el.src
@@ -6579,7 +6934,8 @@ async function compileHtmlFile(html, baseDir, downloadDir, log, urlByAbsentLocal
         el.tagName,
         el.id,
         log,
-        urlByAbsentLocalPath
+        urlByAbsentLocalPath,
+        probes
       ).then(({ duration }) => ({ id: el.id, duration }))
     )
   );
@@ -6600,7 +6956,9 @@ async function compileHtmlFile(html, baseDir, downloadDir, log, urlByAbsentLocal
         downloadDir,
         el.tagName,
         el.id,
-        log
+        log,
+        void 0,
+        probes
       );
       return { id: el.id, tagName: el.tagName, duration: el.duration, maxDuration, src: el.src };
     })
@@ -6622,15 +6980,15 @@ async function compileHtmlFile(html, baseDir, downloadDir, log, urlByAbsentLocal
   compiledHtml = compiledHtml.replace(/(<audio\b[^>]*)\s+crossorigin(?:=["'][^"']*["'])?/gi, "$1");
   return { html: compiledHtml, unresolvedCompositions };
 }
-async function parseSubCompositions(html, projectDir, downloadDir, visited = /* @__PURE__ */ new Set(), urlByAbsentLocalPath) {
+async function parseSubCompositions(html, projectDir, downloadDir, visited = /* @__PURE__ */ new Set(), urlByAbsentLocalPath, probes) {
   const subCompositions = /* @__PURE__ */ new Map();
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const compEls = document2.querySelectorAll("[data-composition-src]");
   const workItems = [];
   for (const el of compEls) {
     const srcPath = el.getAttribute("data-composition-src");
     if (!srcPath) continue;
-    const filePath = resolve6(projectDir, srcPath);
+    const filePath = resolve7(projectDir, srcPath);
     if (visited.has(filePath)) {
       continue;
     }
@@ -6647,17 +7005,19 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
         rewriteUnresolvableGsapToCdn(item.rawSubHtml, projectDir, item.srcPath),
-        dirname6(item.filePath),
+        dirname7(item.filePath),
         downloadDir,
         void 0,
-        urlByAbsentLocalPath
+        urlByAbsentLocalPath,
+        probes
       );
       const nested = await parseSubCompositions(
         compiledSub,
         projectDir,
         downloadDir,
         item.nestedVisited,
-        urlByAbsentLocalPath
+        urlByAbsentLocalPath,
+        probes
       );
       return {
         srcPath: item.srcPath,
@@ -6675,7 +7035,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
   return { subCompositions };
 }
 function promoteCssImportsToLinkTags(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   if (!head) return html;
   const importRe = /@import\s+url\(\s*['"]?([^'")\s]+)['"]?\s*\)\s*;?/gi;
@@ -6744,7 +7104,7 @@ var ProducerHostIdentityMap = class extends Map {
   }
 };
 function coalesceHeadStylesAndBodyScripts(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   const body = document2.querySelector("body");
   if (!head && !body) return html;
@@ -6795,7 +7155,7 @@ function coalesceHeadStylesAndBodyScripts(html) {
   return document2.toString();
 }
 function inlineSubCompositions(html, subCompositions, projectDir, variableOverrides = {}) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   const body = document2.querySelector("body");
   const hosts = Array.from(document2.querySelectorAll("[data-composition-src]"));
@@ -6824,17 +7184,17 @@ function inlineSubCompositions(html, subCompositions, projectDir, variableOverri
       resolveHtml: (srcPath) => {
         let compHtml = subCompositions.get(srcPath) || null;
         if (!compHtml) {
-          const read = readProjectFile(resolve6(projectDir, srcPath));
+          const read = readProjectFile(resolve7(projectDir, srcPath));
           if (read.kind === "file") {
             compHtml = rewriteUnresolvableGsapToCdn(read.text, projectDir, srcPath);
           }
         }
         return compHtml;
       },
-      parseHtml: (htmlStr) => parseHTML4(htmlStr).document,
+      parseHtml: (htmlStr) => parseHTML5(htmlStr).document,
       // Mirrors the preview bundler: a sub-composition's SIBLING assets resolve
       // against its own directory, project-root refs stay as authored.
-      assetExists: (path) => existsSync10(resolve6(projectDir, path)),
+      assetExists: (path) => existsSync10(resolve7(projectDir, path)),
       // Preserve the authored root wrapper as a child of the host, matching
       // the preview bundler's shape (htmlBundler.ts's prepareFlattenedInnerRoot,
       // which the runtime compositionLoader mirrors with its own copy for the
@@ -6935,7 +7295,7 @@ ${html}
 </html>`;
 }
 function injectTextRenderingRule(html) {
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const head = document2.querySelector("head");
   if (!head) return html;
   if (document2.querySelector("style[data-hyperframes-text-rendering]")) {
@@ -6959,7 +7319,7 @@ function matchesScriptIntegrity(bytes, metadata) {
     (alg) => hashes.some((hash) => hash[1]?.toLowerCase() === alg)
   );
   if (!strongest) return true;
-  const actual = createHash5(strongest).update(bytes).digest();
+  const actual = createHash6(strongest).update(bytes).digest();
   return hashes.some(
     (hash) => hash[1]?.toLowerCase() === strongest && actual.equals(Buffer.from(hash[2], "base64"))
   );
@@ -6967,7 +7327,7 @@ function matchesScriptIntegrity(bytes, metadata) {
 async function inlineExternalScripts(html) {
   const fullHtml = ensureFullDocument(html);
   const wrappedFragment = fullHtml !== html;
-  const { document: document2 } = parseHTML4(fullHtml);
+  const { document: document2 } = parseHTML5(fullHtml);
   const scripts = document2.querySelectorAll("script[src]");
   const externalScripts = [];
   for (const el of scripts) {
@@ -7016,12 +7376,12 @@ ${safeText}
   return wrappedFragment ? document2.body.innerHTML || "" : document2.toString();
 }
 function collectExternalAssets(html, projectDir) {
-  const absProjectDir = resolve6(projectDir);
+  const absProjectDir = resolve7(projectDir);
   const externalAssets = /* @__PURE__ */ new Map();
   function processPath(rawPath) {
     const trimmed = rawPath.trim();
     if (isNonRelativeUrl(trimmed)) return null;
-    const absPath = resolve6(absProjectDir, trimmed);
+    const absPath = resolve7(absProjectDir, trimmed);
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
@@ -7030,7 +7390,7 @@ function collectExternalAssets(html, projectDir) {
     externalAssets.set(safeKey, absPath);
     return safeKey;
   }
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   for (const el of document2.querySelectorAll("[src], [href]")) {
     for (const attr of ["src", "href"]) {
       const val = (el.getAttribute(attr) || "").trim();
@@ -7075,7 +7435,7 @@ var REMOTE_SOURCE_TAG_RE = /<source\b[^>]*?\bsrc\s*=\s*["'](https?:\/\/[^"']+)["
 var REMOTE_IMG_TAG_RE = /<img\b[^>]*?(?<![\w-])src\s*=\s*["'](https?:\/\/[^"']+)["'][^>]*>/gi;
 async function downloadAndRewriteUrls(urlSet, html, remoteDir, warnLabel, logLabel, extraRewrite) {
   if (urlSet.size === 0) return { html, remoteMediaAssets: /* @__PURE__ */ new Map() };
-  if (!existsSync10(remoteDir)) mkdirSync6(remoteDir, { recursive: true });
+  if (!existsSync10(remoteDir)) mkdirSync7(remoteDir, { recursive: true });
   const urlToLocal = /* @__PURE__ */ new Map();
   await Promise.all(
     [...urlSet].map(async (url) => {
@@ -7122,7 +7482,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote media download failed",
     "Localized remote media source(s)"
   );
@@ -7137,7 +7497,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote image download failed",
     "Localized remote image source(s)"
   );
@@ -7153,7 +7513,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
@@ -7288,7 +7648,7 @@ async function localizeRemoteFontFaces(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     processed,
-    join14(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
     (h, url, relPath) => h.replaceAll(`url(${url})`, `url("${relPath}")`)
@@ -7333,7 +7693,7 @@ async function embedLocalFontFaces(html, projectDir) {
       while ((urlMatch = urlRe.exec(block)) !== null) {
         const localPath = urlMatch[1];
         if (!localPath || embeddedPaths.has(localPath)) continue;
-        const absPath = localPath.startsWith("/") ? localPath : resolve6(projectDir, localPath);
+        const absPath = localPath.startsWith("/") ? localPath : resolve7(projectDir, localPath);
         if (!isPathInside2(absPath, projectDir)) continue;
         const ext = absPath.match(/\.(woff2?|ttf|otf|ttc)$/i)?.[1]?.toLowerCase() ?? "ttf";
         try {
@@ -7382,7 +7742,7 @@ function renderGsapDist() {
 }
 function rewriteUnresolvableGsapToCdn(html, projectDir, compSrcPath) {
   let gsapDist;
-  const exists = (path) => existsSync10(resolve6(projectDir, path));
+  const exists = (path) => existsSync10(resolve7(projectDir, path));
   return html.replace(
     /(<script\b[^>]*\bsrc=["'])([^"']*gsap[^"']*\/dist\/([^"']+))(["'][^>]*>)/gi,
     (full, prefix, src, file, suffix) => {
@@ -7398,8 +7758,8 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
   if (!isPathInside2(htmlPath, projectDir)) return html;
   const entryPath = relative2(projectDir, htmlPath).replace(/\\/g, "/");
   if (!entryPath.includes("/")) return html;
-  const { document: document2 } = parseHTML4(html);
-  const assetExists = (path) => existsSync10(resolve6(projectDir, path));
+  const { document: document2 } = parseHTML5(html);
+  const assetExists = (path) => existsSync10(resolve7(projectDir, path));
   rewriteAssetPaths(
     document2.querySelectorAll("[src], [href]"),
     entryPath,
@@ -7421,25 +7781,28 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
 }
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
   const entryHtml = rebaseDirectEntryAssetPaths(
-    readFileSync6(htmlPath, "utf-8"),
+    readFileSync7(htmlPath, "utf-8"),
     projectDir,
     htmlPath
   );
   const rawHtml = rewriteUnresolvableGsapToCdn(entryHtml, projectDir);
   assertSubCompositionsUsable(rawHtml, projectDir);
+  const probes = /* @__PURE__ */ new Map();
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
     rawHtml,
     projectDir,
     downloadDir,
     options.log,
-    options.urlByAbsentLocalPath
+    options.urlByAbsentLocalPath,
+    probes
   );
   const { subCompositions } = await parseSubCompositions(
     compiledHtml,
     projectDir,
     downloadDir,
     void 0,
-    options.urlByAbsentLocalPath
+    options.urlByAbsentLocalPath,
+    probes
   );
   const fullHtml = ensureFullDocument(compiledHtml);
   const inlinedHtml = inlineSubCompositions(
@@ -7491,12 +7854,26 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   const { html: htmlWithLocalImages, remoteMediaAssets: remoteImageAssets } = await localizeRemoteImageSources(htmlWithLocalMedia, downloadDir);
   const { html: htmlWithLocalBg, remoteMediaAssets: remoteBgAssets } = await localizeRemoteBackgroundImages(htmlWithLocalImages, downloadDir);
   const { html: htmlWithLocalizedFonts, remoteMediaAssets: remoteFontAssets } = await localizeRemoteFontFaces(htmlWithLocalBg, downloadDir);
+  const {
+    html: htmlWithJpegs,
+    preparedAssets: preparedHeifAssets,
+    preparedImages: preparedHeifImages
+  } = await prepareHeifImageInputs(htmlWithLocalizedFonts, {
+    projectDir,
+    downloadDir,
+    cacheDir: options.animatedGifCacheDir,
+    sourceAssets: remoteImageAssets,
+    timeoutMs: options.ffmpegProcessTimeout
+  });
+  if (preparedHeifImages.length > 0) {
+    defaultLogger.info(`[Compiler] Converted ${preparedHeifImages.length} HEIC image(s) to JPEG`);
+  }
   const gifSourceAssets = new Map(remoteImageAssets);
   const {
     html: htmlWithPreparedGifs,
     preparedAssets: preparedGifAssets,
     preparedGifs
-  } = await prepareAnimatedGifInputs(htmlWithLocalizedFonts, {
+  } = await prepareAnimatedGifInputs(htmlWithJpegs, {
     projectDir,
     downloadDir,
     cacheDir: options.animatedGifCacheDir,
@@ -7523,11 +7900,17 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   for (const [relPath, absPath] of preparedGifAssets) {
     externalAssets.set(relPath, absPath);
   }
+  for (const [relPath, absPath] of preparedHeifAssets) {
+    externalAssets.set(relPath, absPath);
+  }
   const { videos, audios, images, droppedMediaIds } = collectRenderMedia(html);
   const masterFxChain = parseMasterFxChain(html);
+  const advised = /* @__PURE__ */ new Set();
   for (const video of videos) {
     if (isHttpUrl(video.src)) continue;
-    const videoPath = resolve6(projectDir, video.src);
+    const videoPath = resolve7(projectDir, video.src);
+    if (advised.has(videoPath)) continue;
+    advised.add(videoPath);
     const reencode = `ffmpeg -i "${video.src}" -c:v libx264 -r 30 -g 30 -keyint_min 30 -movflags +faststart -c:a copy output.mp4`;
     (async () => {
       const metadata = await withMediaProbeSlot(() => extractMediaMetadata(videoPath));
@@ -7547,7 +7930,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
     })().catch(() => {
     });
   }
-  const { document: document2 } = parseHTML4(html);
+  const { document: document2 } = parseHTML5(html);
   const rootEl = document2.querySelector("[data-composition-id]");
   const width = rootEl ? parseInt(rootEl.getAttribute("data-width") || "1080", 10) : 1080;
   const height = rootEl ? parseInt(rootEl.getAttribute("data-height") || "1920", 10) : 1920;
@@ -7954,7 +8337,7 @@ async function runCompileStage(input) {
     abortSignal
   } = input;
   const compileStart = Date.now();
-  const compiled = await compileForRender(projectDir, htmlPath, join15(workDir, "downloads"), {
+  const compiled = await compileForRender(projectDir, htmlPath, join16(workDir, "downloads"), {
     log,
     failClosedFontFetch: failClosedFontFetch === true,
     allowSystemFontCapture,
@@ -7962,7 +8345,7 @@ async function runCompileStage(input) {
     variables: input.variables,
     urlByAbsentLocalPath: input.urlByAbsentLocalPath,
     pageMotionBlur: input.pageMotionBlur,
-    animatedGifCacheDir: cfg.extractCacheDir ? join15(cfg.extractCacheDir, "animated-gif") : void 0,
+    animatedGifCacheDir: cfg.extractCacheDir ? join16(cfg.extractCacheDir, "animated-gif") : void 0,
     ffmpegProcessTimeout: cfg.ffmpegProcessTimeout
   });
   assertNotAborted();
@@ -8018,7 +8401,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join15(workDir, "compiled"),
+    compiledDir: join16(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -8063,8 +8446,8 @@ async function runCompileStage(input) {
 }
 
 // src/services/render/stages/probeStage.ts
-import { join as join16 } from "node:path";
-import { parseHTML as parseHTML5 } from "linkedom";
+import { join as join17 } from "node:path";
+import { parseHTML as parseHTML6 } from "linkedom";
 import {
   closeCaptureSession as closeCaptureSession4,
   compositionRequiresWebGpu,
@@ -8078,13 +8461,14 @@ import {
 } from "@hyperframes/engine";
 import {
   MEDIA_RENDER_ID_ATTR as MEDIA_RENDER_ID_ATTR2,
-  fpsToNumber as fpsToNumber7,
+  fpsToNumber as fpsToNumber6,
   normalizeRateSpec as normalizeRateSpec3,
   readMediaStart as readMediaStart2,
   shiftRateLane as shiftRateLane2,
   sourceTimeAt as sourceTimeAt3,
   timeAtSourceTime
 } from "@hyperframes/core";
+import { parseHostVariableValues as parseHostVariableValues2, readDeclaredDefaults as readDeclaredDefaults2 } from "@hyperframes/core/compiler";
 import { extractMediaSrcMutations } from "@hyperframes/parsers";
 
 // src/services/render/stages/probeFailures.ts
@@ -8111,7 +8495,7 @@ function durationToFrameCount(duration, fps) {
 }
 function hasScriptedAudioVolumeAutomation(html, audioCount) {
   if (audioCount <= 0) return false;
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   const scriptBodies = [...document2.querySelectorAll("script")].map((script) => script.textContent ?? "").join("\n");
   if (!scriptBodies) return false;
   return /\.\s*volume\s*=/i.test(scriptBodies) || /\b(?:gsap|tl|timeline|tween)\s*\.\s*(?:to|fromTo|set)\s*\([\s\S]{0,2000}\bvolume\s*:/i.test(
@@ -8119,23 +8503,30 @@ function hasScriptedAudioVolumeAutomation(html, audioCount) {
   );
 }
 function hasAutoStartVideos(html) {
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   return document2.querySelector("video[data-hf-auto-start]") !== null;
 }
+function variableHasValue(element, variableId, variables) {
+  if (variables && Object.hasOwn(variables, variableId)) return true;
+  for (let scope = element.parentElement; scope; scope = scope.parentElement) {
+    if (Object.hasOwn(parseHostVariableValues2(scope), variableId)) return true;
+    if (Object.hasOwn(readDeclaredDefaults2(scope), variableId)) return true;
+  }
+  return Object.hasOwn(readDeclaredDefaults2(element.ownerDocument.documentElement), variableId);
+}
 function hasVariableBoundMedia(html, variables) {
-  if (!variables || Object.keys(variables).length === 0) return false;
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   return Array.from(
     document2.querySelectorAll(
       "img[data-var-src], audio[data-var-src], video[data-var-src], source[data-var-src]"
     )
   ).some((element) => {
     const variableId = element.getAttribute("data-var-src")?.trim();
-    return Boolean(variableId && Object.hasOwn(variables, variableId));
+    return Boolean(variableId && variableHasValue(element, variableId, variables));
   });
 }
 function authoredMediaStarts(html) {
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   const starts = /* @__PURE__ */ new Map();
   for (const media of document2.querySelectorAll("video, audio")) {
     const id = media.getAttribute(MEDIA_RENDER_ID_ATTR2) || media.getAttribute("id");
@@ -8172,7 +8563,7 @@ function reconcileBrowserMediaEnd(existingEnd, projectedEnd, sourceChanged, dura
   return existingEnd <= 0 ? projectedEnd : Math.min(existingEnd, projectedEnd);
 }
 function hasRuntimeMediaChanges(html) {
-  const { document: document2 } = parseHTML5(html);
+  const { document: document2 } = parseHTML6(html);
   const scriptBodies = [...document2.querySelectorAll("script")].map(
     (script) => script.textContent ?? ""
   );
@@ -8255,7 +8646,7 @@ async function runProbeStage(input) {
       });
       fileServer = await createFileServer({
         projectDir,
-        compiledDir: join16(workDir, "compiled"),
+        compiledDir: join17(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM],
         fps: job.config.fps
@@ -8284,7 +8675,7 @@ async function runProbeStage(input) {
           log.info("Creating capture session...", { attempt, maxAttempts: PROBE_MAX_ATTEMPTS });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join16(workDir, "probe"),
+            join17(workDir, "probe"),
             captureOpts,
             null,
             probeCfg
@@ -8369,7 +8760,7 @@ async function runProbeStage(input) {
           });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join16(workDir, "probe-screenshot"),
+            join17(workDir, "probe-screenshot"),
             captureOpts,
             null,
             { ...probeCfg, forceScreenshot: true }
@@ -8405,7 +8796,7 @@ async function runProbeStage(input) {
             compiled,
             resolutions,
             projectDir,
-            join16(workDir, "downloads")
+            join17(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -8557,7 +8948,7 @@ async function runProbeStage(input) {
           session.page,
           composition.audios.map((audio) => audio.id),
           composition.duration,
-          fpsToNumber7(job.config.fps)
+          fpsToNumber6(job.config.fps)
         );
         assertNotAborted();
         if (automation.length > 0) {
@@ -8596,7 +8987,7 @@ async function runProbeStage(input) {
     }
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join16(workDir, "compiled"),
+      compiledDir: join17(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -8620,7 +9011,7 @@ async function runProbeStage(input) {
   }
   const browserProbeMs = Date.now() - probeStart;
   const duration = composition.duration;
-  const totalFrames = durationToFrameCount(duration, fpsToNumber7(job.config.fps));
+  const totalFrames = durationToFrameCount(duration, fpsToNumber6(job.config.fps));
   if (duration <= 0) {
     const diagnostics = [];
     try {
@@ -8761,7 +9152,7 @@ function validateDistributedDuration(input) {
 
 // src/services/render/stages/extractVideosStage.ts
 import { existsSync as existsSync11 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import {
   classifyVideoExtractionError,
   createFrameLookupTable,
@@ -9081,14 +9472,14 @@ async function runExtractVideosStage(input) {
       // because short boundary counts can differ by one frame.
       {
         fps: job.config.fps,
-        outputDir: join17(compiledDir, "__hyperframes_video_frames"),
+        outputDir: join18(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
         toneMapHdrToSdr: job.config.hdrMode === "force-sdr",
         timelineEnd: composition.duration,
         maxTransientRetries: extractionPolicy.maxTransientRetries,
         collectProbeFailures: extractionPolicy.failureMode === "enforce",
         deferRangeExtraction,
-        contentKeyedDirs: [join17(compiledDir, REMOTE_MEDIA_SUBDIR)],
+        contentKeyedDirs: [join18(compiledDir, REMOTE_MEDIA_SUBDIR)],
         urlByAbsentLocalPath
       },
       abortSignal,
@@ -9155,18 +9546,19 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { join as join19 } from "node:path";
-import { rmSync as rmSync9 } from "node:fs";
+import { join as join20 } from "node:path";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
-  processCompositionAudio
+  processCompositionAudio,
+  removeScratch as removeScratch2,
+  collectScratchLeftovers
 } from "@hyperframes/engine";
 
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, rmSync as rmSync8 } from "node:fs";
-import { dirname as dirname7, join as join18 } from "node:path";
+import { mkdtempSync as mkdtempSync3 } from "node:fs";
+import { dirname as dirname8, join as join19 } from "node:path";
 import {
   DEFAULT_CONFIG,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -9174,8 +9566,9 @@ import {
   extractAudioMetadata as extractAudioMetadata3,
   getFfprobeBinary,
   ManagedChildProcess,
-  renameWithRetry as renameWithRetry4,
-  runFfmpeg as runFfmpeg4,
+  removeScratch,
+  renameWithRetry as renameWithRetry5,
+  runFfmpeg as runFfmpeg5,
   trackChildProcess
 } from "@hyperframes/engine";
 import { redactKnownPaths, redactTelemetryString as redactTelemetryString3 } from "@hyperframes/core";
@@ -9185,7 +9578,7 @@ import {
   aacSegmentCount,
   describeFfmpegFailure,
   extractAudioMetadata as extractAudioMetadata2,
-  runFfmpeg as runFfmpeg3
+  runFfmpeg as runFfmpeg4
 } from "@hyperframes/engine";
 var toDbfs = (token) => token.toLowerCase() === "-inf" ? Number.NEGATIVE_INFINITY : Number(token);
 function checkedDbfs(value) {
@@ -9209,7 +9602,7 @@ async function scanTruePeak(audioPath, trim, timeoutMs, signal) {
       else laterBlocks = Math.max(laterBlocks, block);
     }
   };
-  const result = await runFfmpeg3(
+  const result = await runFfmpeg4(
     ["-i", audioPath, "-map", "0:a:0", "-vn", "-af", `${trim}ebur128=peak=true`, "-f", "null", "-"],
     { signal, timeout: timeoutMs, onStderr: readLines }
   );
@@ -9369,7 +9762,7 @@ async function padOrTrimAudioToVideoFrameCount(input) {
       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 });
+    for (const path of plan2.cleanupPaths) removeScratch(path);
   }
   let loweredDb = 0;
   if (probeTruePeak) {
@@ -9416,8 +9809,8 @@ async function constrainAacTruePeak(input) {
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
-    scratchDir = mkdtempSync3(join18(dirname7(input.audioPath), ".true-peak-"));
-    const correctedPath = join18(scratchDir, "audio.m4a");
+    scratchDir = mkdtempSync3(join19(dirname8(input.audioPath), ".true-peak-"));
+    const correctedPath = join19(scratchDir, "audio.m4a");
     const measurements = [];
     let attenuationDb = 0;
     let sourcePeakDbfs;
@@ -9432,7 +9825,7 @@ async function enforceAacTruePeak(input) {
       }
       if (truePeakDbfs <= AAC_DELIVERY_TRUE_PEAK_DBFS) {
         if (measuredPath !== correctedPath) return { success: true };
-        renameWithRetry4(correctedPath, input.audioPath);
+        renameWithRetry5(correctedPath, input.audioPath, { copyFallback: true });
         return { success: true, loweredDb: Number((-attenuationDb).toFixed(2)) };
       }
       if (pass === MAX_TRUE_PEAK_CORRECTION_PASSES) break;
@@ -9473,7 +9866,7 @@ async function enforceAacTruePeak(input) {
       )}`
     };
   } finally {
-    if (scratchDir) rmSync8(scratchDir, { recursive: true, force: true });
+    if (scratchDir) removeScratch(scratchDir);
   }
 }
 function failResult(outputPath, target, source, error) {
@@ -9550,7 +9943,7 @@ async function defaultProbeAudioInfo(audioPath, signal) {
   };
 }
 async function defaultRunFfmpeg(args, timeoutMs, signal) {
-  return toStepResult(await runFfmpeg4(args, { signal, timeout: timeoutMs }), timeoutMs);
+  return toStepResult(await runFfmpeg5(args, { signal, timeout: timeoutMs }), timeoutMs);
 }
 function defaultAacEncoder(timeoutMs, signal, pcmSourcePath) {
   return async (inputPath, outputPath, durationSeconds, filter) => {
@@ -9618,9 +10011,17 @@ function assertAudioNotInterrupted(failures) {
     ])
   });
 }
-async function runAudioStage(input) {
+function runAudioStage(input) {
+  return collectScratchLeftovers(
+    () => runAudioStageScoped(input),
+    (left) => {
+      if (left.length > 0) input.log?.warn("[audio] scratch left behind", { count: left.length });
+    }
+  );
+}
+async function runAudioStageScoped(input) {
   const stageStart = Date.now();
-  const pcmSourcePath = join19(input.workDir, "audio-source.wav");
+  const pcmSourcePath = join20(input.workDir, "audio-source.wav");
   const duration = input.totalFrames * input.fps.den / input.fps.num;
   try {
     const result = await mixAudioForDelivery(input, duration, pcmSourcePath);
@@ -9640,7 +10041,7 @@ async function runAudioStage(input) {
     }
     return { ...result, audioLoweredDb, audioProcessMs: Date.now() - stageStart };
   } finally {
-    rmSync9(pcmSourcePath, { force: true });
+    removeScratch2(pcmSourcePath);
   }
 }
 async function mixAudioForDelivery(input, duration, pcmSourcePath) {
@@ -9658,7 +10059,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     assertNotAborted,
     log
   } = input;
-  const audioOutputPath = join19(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join20(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -9669,7 +10070,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join19(workDir, "audio-work"),
+        join20(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -9738,7 +10139,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 
 // src/services/render/stages/captureStage.ts
 import { existsSync as existsSync12, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
   frameFileExtension,
@@ -9811,13 +10212,13 @@ function measureCaptureFrameBytes(workDir, framesDir) {
   if (!existsSync12(workDir)) return total;
   for (const attempt of readdirSync3(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join20(workDir, attempt));
+      total += sampleDirectoryBytes(join21(workDir, attempt));
       continue;
     }
     if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join20(workDir, attempt);
+    const attemptDir = join21(workDir, attempt);
     for (const name of readdirSync3(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join20(attemptDir, name));
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join21(attemptDir, name));
     }
   }
   return total;
@@ -10110,8 +10511,8 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 }
 
 // src/services/render/stages/captureHdrStage.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8 } from "node:fs";
+import { join as join25 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
   cloneCaptureWarnings as cloneCaptureWarnings2,
@@ -10120,7 +10521,7 @@ import {
   initializeSession as initializeSession7,
   spawnStreamingEncoder as spawnStreamingEncoder3
 } from "@hyperframes/engine";
-import { fpsToNumber as fpsToNumber8 } from "@hyperframes/core";
+import { fpsToNumber as fpsToNumber7 } from "@hyperframes/core";
 
 // src/services/hdrImageTransferCache.ts
 import { convertTransfer as convertTransfer2 } from "@hyperframes/engine";
@@ -10183,7 +10584,7 @@ function createHdrImageTransferCache(options = {}) {
 }
 
 // src/services/render/stages/captureHdrSequentialLoop.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import {
   TRANSITIONS,
   crossfade
@@ -10308,7 +10709,7 @@ async function runSequentialLayeredFrameLoop(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`),
           normalCanvas
         );
       }
@@ -10340,7 +10741,7 @@ async function runSequentialLayeredFrameLoop(input) {
 }
 
 // src/services/render/stages/captureHdrHybridLoop.ts
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 import {
   TRANSITIONS as TRANSITIONS2,
   closeCaptureSession as closeCaptureSession6,
@@ -10354,7 +10755,7 @@ import {
 // src/services/shaderTransitionWorkerPool.ts
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
-import { dirname as dirname8, join as join22 } from "node:path";
+import { dirname as dirname9, join as join23 } from "node:path";
 import { createRequire } from "node:module";
 import { existsSync as existsSync13 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
@@ -10367,10 +10768,10 @@ function resolveWorkerEntry(explicit) {
     const isTs = override.endsWith(".ts");
     return { path: override, isTs };
   }
-  const moduleDir = dirname8(fileURLToPath3(import.meta.url));
-  const jsPath = join22(moduleDir, "shaderTransitionWorker.js");
+  const moduleDir = dirname9(fileURLToPath3(import.meta.url));
+  const jsPath = join23(moduleDir, "shaderTransitionWorker.js");
   if (existsSync13(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join22(moduleDir, "shaderTransitionWorker.ts");
+  const tsPath = join23(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -10513,8 +10914,8 @@ async function createShaderTransitionWorkerPool(opts) {
       if (terminated) {
         throw new Error("shader-blend pool already terminated");
       }
-      return new Promise((resolve12, reject) => {
-        const task = traceEnabled ? { req, resolve: resolve12, reject, enqueuedAtMs: Date.now(), traceId: ++nextTaskId } : { req, resolve: resolve12, reject };
+      return new Promise((resolve13, reject) => {
+        const task = traceEnabled ? { req, resolve: resolve13, reject, enqueuedAtMs: Date.now(), traceId: ++nextTaskId } : { req, resolve: resolve13, reject };
         const idle = slots.find((s) => !s.busy && !s.dead);
         if (idle) {
           queue.unshift(task);
@@ -10738,7 +11139,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join23(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join24(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -10794,6 +11195,7 @@ async function runCaptureHdrStage(input) {
     preset,
     effectiveQuality,
     effectiveBitrate,
+    deliveryEncoder,
     fileServer,
     buildCaptureOptions,
     createRenderVideoFrameInjector,
@@ -10855,7 +11257,7 @@ async function runCaptureHdrStage(input) {
       }
       return map;
     });
-    const fpsDecimal = fpsToNumber8(job.config.fps);
+    const fpsDecimal = fpsToNumber7(job.config.fps);
     const transitionRanges = transitionMeta.map((t) => ({
       ...t,
       startFrame: Math.floor(t.time * fpsDecimal),
@@ -10883,6 +11285,7 @@ async function runCaptureHdrStage(input) {
         preset: preset.preset,
         quality: effectiveQuality,
         bitrate: effectiveBitrate,
+        ...deliveryEncoder,
         pixelFormat: preset.pixelFormat,
         hdr: preset.hdr,
         rawInputFormat: "rgb48le"
@@ -10926,9 +11329,9 @@ 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 ? join24(framesDir, "debug-composite") : null;
+      const debugDumpDir = debugDumpEnabled ? join25(framesDir, "debug-composite") : null;
       if (debugDumpDir && !existsSync14(debugDumpDir)) {
-        mkdirSync7(debugDumpDir, { recursive: true });
+        mkdirSync8(debugDumpDir, { recursive: true });
       }
       const compositeTransfer = resolveCompositeTransfer(hasHdrContent, effectiveHdr);
       const hdrTargetTransfer = compositeTransfer === "srgb" ? void 0 : compositeTransfer;
@@ -10942,7 +11345,7 @@ async function runCaptureHdrStage(input) {
         beforeCaptureHook: domSession.onBeforeCapture,
         width,
         height,
-        fps: fpsToNumber8(job.config.fps),
+        fps: fpsToNumber7(job.config.fps),
         compositeTransfer,
         nativeHdrImageIds,
         hdrImageBuffers,
@@ -11081,24 +11484,24 @@ async function runCaptureHdrStage(input) {
 
 // src/services/render/stages/encodeStage.ts
 import {
-  copyFileSync as copyFileSync3,
+  copyFileSync as copyFileSync4,
   existsSync as existsSync15,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
-  rmSync as rmSync10,
-  statSync as statSync6,
-  writeFileSync as writeFileSync4
+  readFileSync as readFileSync8,
+  rmSync as rmSync9,
+  statSync as statSync7,
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname9, join as join25 } from "node:path";
+import { dirname as dirname10, join as join26 } from "node:path";
 import {
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
   formatFfmpegError,
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME2,
   resolveConfig,
-  runFfmpeg as runFfmpeg5,
+  runFfmpeg as runFfmpeg6,
   spawnStreamingEncoder as spawnStreamingEncoder4
 } from "@hyperframes/engine";
 import {
@@ -11174,17 +11577,17 @@ function gifEncodeFailure(startTime, outputPath, error, failureReason) {
 }
 async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
   const { outputPath } = argsInput;
-  const result = await runFfmpeg5(buildGifPaletteuseArgs({ ...argsInput, wholeFrames: true }), run);
+  const result = await runFfmpeg6(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);
+  const gif = readFileSync8(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);
+  writeFileSync5(outputPath, gif);
   return null;
 }
 async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
@@ -11206,17 +11609,17 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
   try {
     const run = { signal: input.signal, timeout: input.timeout };
     for (const args of [buildGifPalettegenArgs(argsInput), buildGifPaletteuseArgs(argsInput)]) {
-      const result = await runFfmpeg5(args, run);
+      const result = await runFfmpeg6(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) {
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync8(outputPath)) !== false) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync15(outputPath) ? statSync6(outputPath).size : 0;
+    const fileSize = existsSync15(outputPath) ? statSync7(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -11225,7 +11628,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       fileSize
     };
   } finally {
-    rmSync10(input.palettePath, { force: true });
+    rmSync9(input.palettePath, { force: true });
   }
 }
 function startEncodeProgress(job, stage, onProgress) {
@@ -11249,6 +11652,8 @@ function videoEncoderOptions(input, engineCfg) {
     preset: preset.preset,
     quality: input.effectiveQuality,
     bitrate: input.effectiveBitrate,
+    maxBitrate: input.maxBitrate,
+    bufferSize: input.bufferSize,
     pixelFormat: preset.pixelFormat,
     vp9CpuUsed: engineCfg.vp9CpuUsed,
     useGpu: job.config.useGpu,
@@ -11297,10 +11702,10 @@ function encodeWhileCapturing(input, totalFrames) {
     const stream = await encoder;
     for (let next = 0; next < totalFrames; next++) {
       while (!landed.has(next) && !captureDone && !signal.aborted) {
-        await new Promise((resolve12) => wake = resolve12);
+        await new Promise((resolve13) => wake = resolve13);
       }
       if (signal.aborted) return;
-      const mergedPath = join25(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const mergedPath = join26(input.framesDir, formatCaptureFrameName(next, "jpg"));
       const frame = await readLandedFrame(landed.get(next), mergedPath);
       landed.delete(next);
       if (!await stream.writeFrame(frame)) {
@@ -11375,7 +11780,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync15(outputPath)) mkdirSync8(outputPath, { recursive: true });
+    if (!existsSync15(outputPath)) mkdirSync9(outputPath, { recursive: true });
     const captured = readdirSync4(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -11383,11 +11788,11 @@ async function runEncodeStage(input) {
       );
     }
     captured.forEach((name, i) => {
-      const dst = join25(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync3(join25(framesDir, name), dst);
+      const dst = join26(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync4(join26(framesDir, name), dst);
     });
     if (hasAudio && audioOutputPath && existsSync15(audioOutputPath)) {
-      copyFileSync3(audioOutputPath, join25(outputPath, MIXED_AUDIO_FILENAME2));
+      copyFileSync4(audioOutputPath, join26(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
       );
@@ -11407,7 +11812,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join25(dirname9(videoOnlyPath), "gif-palette.png"),
+      palettePath: join26(dirname10(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -11617,9 +12022,9 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries) {
-      const full = join26(current, name);
+      const full = join27(current, name);
       try {
-        const st = statSync7(full);
+        const st = statSync8(full);
         if (st.isDirectory()) {
           stack.push(full);
         } else if (st.isFile()) {
@@ -11766,8 +12171,8 @@ 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 missing = !existsSync16(framePath) || statSync7(framePath).size <= 8;
+    const framePath = join27(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const missing = !existsSync16(framePath) || statSync8(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -11783,7 +12188,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
 function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, rangeStart = 0, stride = 1) {
   const workersPerBatch = Math.max(1, Math.floor(maxWorkers));
   const batches = [];
-  const outputDirFor = (batchIndex, workerId) => join26(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
+  const outputDirFor = (batchIndex, workerId) => join27(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
   if (stride > 1) {
     const spans = /* @__PURE__ */ new Map();
     for (const range of ranges) {
@@ -11843,8 +12248,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 join27(systemTempDir, "hf-render-");
+  return join27(dirname11(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -11886,7 +12291,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 = join27(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     if (existsSync16(framePath)) captured++;
   }
   return captured;
@@ -11912,7 +12317,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 = join27(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -12518,18 +12923,19 @@ 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");
+  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve8(process.env.PRODUCER_RENDERS_DIR, "..") : resolve8(dirname11(fileURLToPath4(import.meta.url)), "../..");
+  return join27(producerRoot, ".debug");
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
+  validateDeliveryEncoderConfig(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 outputDir = dirname11(outputPath);
+  if (!existsSync16(outputDir)) mkdirSync10(outputDir, { recursive: true });
+  const workDir = job.config.debug ? join27(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 ? join27(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -12543,7 +12949,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
       log.info("KEEP_TEMP=1, leaving workDir on disk for inspection", { workDir });
       return;
     }
-    rmSync11(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    rmSync10(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   });
   try {
     await executeRenderPipeline({
@@ -12589,7 +12995,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join26(workDir, "perf-summary.json");
+  const perfOutputPath = join27(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig2() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -12601,11 +13007,14 @@ async function executeRenderPipeline(input) {
   const isGif = outputFormat === "gif";
   const isHls = outputFormat === "hls";
   const hlsSegmentSeconds = isHls ? resolveHlsSegmentSeconds(job.config) : void 0;
-  const hlsEncoderGopLock = resolveHlsEncoderGopLock(
-    outputFormat,
-    job.config.fps,
-    job.config.hlsSegmentSeconds
-  );
+  const deliveryEncoder = resolveDeliveryEncoderOptions({
+    format: outputFormat,
+    fps: job.config.fps,
+    hlsSegmentSeconds: job.config.hlsSegmentSeconds,
+    keyframeIntervalSeconds: job.config.keyframeIntervalSeconds,
+    maxBitrate: job.config.maxBitrate,
+    bufferSize: job.config.bufferSize
+  });
   const artifactTransaction = new ArtifactTransaction(
     outputPath,
     isPngSequence || isHls ? "directory" : "file",
@@ -12662,7 +13071,7 @@ async function executeRenderPipeline(input) {
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
     assertConfiguredFfmpegBinariesExist();
-    if (!existsSync16(workDir)) mkdirSync9(workDir, { recursive: true });
+    if (!existsSync16(workDir)) mkdirSync10(workDir, { recursive: true });
     if (job.config.debug) {
       log.info("[Render] Debug artifacts enabled", { workDir, logPath });
     }
@@ -12691,22 +13100,22 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join26(projectDir, entryFile);
+    let htmlPath = join27(projectDir, entryFile);
     if (!existsSync16(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readFileSync8(htmlPath, "utf-8");
+    const rawEntry = readFileSync9(htmlPath, "utf-8");
     if (entryFile !== "index.html" && isTemplateEntry(rawEntry)) {
-      const wrapperPath = join26(workDir, "standalone-entry.html");
-      const projectIndexPath = join26(projectDir, "index.html");
+      const wrapperPath = join27(workDir, "standalone-entry.html");
+      const projectIndexPath = join27(projectDir, "index.html");
       if (!existsSync16(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
       }
       const standaloneHtml = extractStandaloneEntryFromIndex(
-        readFileSync8(projectIndexPath, "utf-8"),
+        readFileSync9(projectIndexPath, "utf-8"),
         entryFile,
         rawEntry
       );
@@ -12715,7 +13124,7 @@ async function executeRenderPipeline(input) {
           `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
         );
       }
-      writeFileSync5(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync6(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -12845,7 +13254,7 @@ async function executeRenderPipeline(input) {
     validateRenderDuration({
       duration: probeResult.duration,
       totalFrames,
-      fps: fpsToNumber9(job.config.fps)
+      fps: fpsToNumber8(job.config.fps)
     });
     perfStages.browserProbeMs = probeResult.browserProbeMs;
     perfStages.compileMs = Date.now() - stage1Start;
@@ -12862,7 +13271,7 @@ async function executeRenderPipeline(input) {
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress, {
       code: "extract_video"
     });
-    const compiledDir = join26(workDir, "compiled");
+    const compiledDir = join27(workDir, "compiled");
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -12996,7 +13405,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer({
           projectDir,
-          compiledDir: join26(workDir, "compiled"),
+          compiledDir: join27(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -13014,8 +13423,8 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join26(workDir, "captured-frames");
-    if (!existsSync16(framesDir)) mkdirSync9(framesDir, { recursive: true });
+    const framesDir = join27(workDir, "captured-frames");
+    if (!existsSync16(framesDir)) mkdirSync10(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
     });
@@ -13486,7 +13895,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join26(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join27(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -13688,6 +14097,7 @@ async function executeRenderPipeline(input) {
             preset,
             effectiveQuality,
             effectiveBitrate,
+            deliveryEncoder,
             fileServer: activeFileServer,
             buildCaptureOptions,
             createRenderVideoFrameInjector,
@@ -13712,9 +14122,7 @@ async function executeRenderPipeline(input) {
     } else {
       let streamingHandled = false;
       if (capturePlan.kind === "sdr_segmented") {
-        const segmentedPlan = capturePlan;
         const captureFrameStart = Date.now();
-        resetCaptureAttemptProgress(job);
         const segmentFrames = resolveSegmentFrames(process.env);
         const segmentImageFormat = captureOptions.format || "jpeg";
         const segmentPlanHash = computeSegmentPlanHash({
@@ -13729,6 +14137,9 @@ async function executeRenderPipeline(input) {
           preset: preset.preset,
           quality: effectiveQuality,
           bitrate: effectiveBitrate,
+          maxBitrate: deliveryEncoder.maxBitrate,
+          bufferSize: deliveryEncoder.bufferSize,
+          gopSize: deliveryEncoder.gopSize,
           pixelFormat: preset.pixelFormat,
           imageFormat: segmentImageFormat,
           useGpu: job.config.useGpu === true,
@@ -13739,7 +14150,7 @@ async function executeRenderPipeline(input) {
           pageMotionBlur: job.config.pageMotionBlur,
           captureQuality: captureOptions.quality
         });
-        const segmentDir = segmentDirFor(join26(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join27(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -13754,71 +14165,129 @@ async function executeRenderPipeline(input) {
             });
           }
           if (completedSegments.size === 0) {
-            rmSync11(segmentDir, { recursive: true, force: true });
+            rmSync10(segmentDir, { recursive: true, force: true });
           }
         } else {
-          rmSync11(segmentDir, { recursive: true, force: true });
+          rmSync10(segmentDir, { recursive: true, force: true });
         }
-        const segmentManifest = readSegmentManifest(segmentDir) ?? {
+        const emptySegmentManifest = () => ({
           version: 1,
           planHash: segmentPlanHash,
           totalFrames,
           segmentFrames,
           completed: []
+        });
+        let segmentManifest = readSegmentManifest(segmentDir) ?? emptySegmentManifest();
+        const invokeSegmented = () => {
+          if (capturePlan.kind !== "sdr_segmented") {
+            throw new Error(`Cannot invoke segmented stage with ${capturePlan.kind} plan`);
+          }
+          const segmentedPlan = capturePlan;
+          resetCaptureAttemptProgress(job);
+          return observeRenderStage(
+            observability,
+            "capture_segmented",
+            captureStageObservationData(),
+            () => runCaptureSegmentedStage({
+              fileServer: activeFileServer,
+              workDir,
+              framesDir,
+              videoOnlyPath,
+              job,
+              totalFrames,
+              cfg,
+              plan: segmentedPlan,
+              log,
+              probeSession,
+              outputFormat,
+              streamingEncoderOptions: {
+                fps: job.config.fps,
+                width: captureCompositionWidth ?? width,
+                height: captureCompositionHeight ?? height,
+                codec: preset.codec,
+                preset: preset.preset,
+                quality: effectiveQuality,
+                bitrate: effectiveBitrate,
+                pixelFormat: preset.pixelFormat,
+                vp9CpuUsed: cfg.vp9CpuUsed,
+                useGpu: job.config.useGpu,
+                imageFormat: segmentImageFormat,
+                hdr: preset.hdr,
+                // Each segment sets its own GOP (at most the interval); hls never reaches this route.
+                ...deliveryEncoder
+              },
+              buildCaptureOptions,
+              createRenderVideoFrameInjector,
+              abortSignal: executionSignal,
+              assertNotAborted,
+              onProgress,
+              dedupPerfs,
+              segmentFrames,
+              segmentDir,
+              workerCount: segmentedPlan.workerCount,
+              browserRecycleEverySegments: resolveSegmentBrowserRecycle(process.env),
+              completedSegments,
+              onSegmentComplete: (entry) => {
+                segmentManifest.completed = [
+                  ...segmentManifest.completed.filter((e) => e.index !== entry.index),
+                  { ...entry, completedAt: (/* @__PURE__ */ new Date()).toISOString() }
+                ];
+                writeSegmentManifest(segmentDir, segmentManifest);
+              },
+              updateCaptureObservability
+            })
+          );
         };
-        const segmentedRes = await observeRenderStage(
-          observability,
-          "capture_segmented",
-          captureStageObservationData(),
-          () => runCaptureSegmentedStage({
-            fileServer: activeFileServer,
-            workDir,
-            framesDir,
-            videoOnlyPath,
-            job,
-            totalFrames,
-            cfg,
-            plan: segmentedPlan,
-            log,
-            probeSession,
-            outputFormat,
-            streamingEncoderOptions: {
-              fps: job.config.fps,
-              width: captureCompositionWidth ?? width,
-              height: captureCompositionHeight ?? height,
-              codec: preset.codec,
-              preset: preset.preset,
-              quality: effectiveQuality,
-              bitrate: effectiveBitrate,
-              pixelFormat: preset.pixelFormat,
-              vp9CpuUsed: cfg.vp9CpuUsed,
-              useGpu: job.config.useGpu,
-              imageFormat: segmentImageFormat,
-              hdr: preset.hdr
-              // No hlsEncoderGopLock here: each segment sets its own GOP to
-              // its own length, and hls never reaches this route.
-            },
-            buildCaptureOptions,
-            createRenderVideoFrameInjector,
-            abortSignal: executionSignal,
-            assertNotAborted,
-            onProgress,
-            dedupPerfs,
-            segmentFrames,
-            segmentDir,
-            workerCount: segmentedPlan.workerCount,
-            browserRecycleEverySegments: resolveSegmentBrowserRecycle(process.env),
-            completedSegments,
-            onSegmentComplete: (entry) => {
-              segmentManifest.completed = [
-                ...segmentManifest.completed.filter((e) => e.index !== entry.index),
-                { ...entry, completedAt: (/* @__PURE__ */ new Date()).toISOString() }
-              ];
-              writeSegmentManifest(segmentDir, segmentManifest);
-            },
-            updateCaptureObservability
-          })
-        );
+        let segmentedRes;
+        try {
+          segmentedRes = await invokeSegmented();
+        } catch (err) {
+          const isVerifyError = isDrawElementVerificationError(err);
+          const isDeStall = isDeRendererStallError(err);
+          if (!isVerifyError && !isDrawElementCaptureError(err) && !isDeStall || err instanceof RenderCancelledError || executionSignal?.aborted === true) {
+            throw err;
+          }
+          deSelfVerifyFallback = isVerifyError;
+          const t = deVerifyFallbackTelemetry(err);
+          deFallbackReason = isVerifyError ? t.reason : isDeStall ? "de_renderer_stall" : "capture_error";
+          deFallbackFailedDb = t.failedDb;
+          deFallbackFrameIndex = t.frameIndex;
+          deFallbackThresholdDb = t.thresholdDb;
+          log.warn(
+            "[Render] drawElement capture failed on the segmented path; re-rendering via screenshot",
+            {
+              error: err instanceof Error ? err.message : String(err)
+            }
+          );
+          observability.checkpoint(
+            "capture_segmented",
+            "drawElement capture failed; retrying with a fresh screenshot session"
+          );
+          if (probeSession) {
+            lastBrowserConsole = probeSession.browserConsoleBuffer;
+            const orphaned = probeSession;
+            probeSession = null;
+            await closeOrphanedProbeForRetry(orphaned, closeCaptureSession8, log, "segmented");
+          }
+          rmSync10(segmentDir, { recursive: true, force: true });
+          completedSegments = /* @__PURE__ */ new Set();
+          segmentManifest = emptySegmentManifest();
+          dedupPerfs.length = 0;
+          capturePlan = replanAfterFailure(capturePlan, {
+            kind: isVerifyError ? "draw_element_verification" : "draw_element_capture"
+          });
+          syncCapturePlan();
+          updateCaptureObservability({
+            forceScreenshot: capturePlan.forceScreenshot,
+            deSelfVerifyFallback,
+            deFallbackReason,
+            deFallbackFailedDb,
+            deFallbackFrameIndex,
+            deFallbackThresholdDb
+          });
+          segmentedRes = await invokeSegmented();
+          observability.clearFailure("capture_segmented");
+        }
         if (segmentedRes.success) {
           streamingHandled = true;
           workerCount = segmentedRes.workerCount;
@@ -13838,7 +14307,7 @@ async function executeRenderPipeline(input) {
           );
           updateCaptureObservability({ segmentRetries: segmentedRes.segmentRetries });
           if (job.config.keepSegments !== true) {
-            rmSync11(segmentDir, { recursive: true, force: true });
+            rmSync10(segmentDir, { recursive: true, force: true });
           }
         } else {
           capturePlan = replanAfterFailure(capturePlan, { kind: "streaming_unavailable" });
@@ -13891,7 +14360,7 @@ async function executeRenderPipeline(input) {
                 // assemble stage's `-c copy` segmentation cuts exactly on
                 // the segment boundary. Every other format leaves the
                 // encoder's open-GOP output untouched.
-                ...hlsEncoderGopLock
+                ...deliveryEncoder
               },
               buildCaptureOptions,
               createRenderVideoFrameInjector,
@@ -14054,7 +14523,7 @@ async function executeRenderPipeline(input) {
           engineConfig: cfg,
           // Same value the streaming encoder above spreads — the disk and
           // chunked-concat encoders need an identical GOP lock for HLS.
-          ...hlsEncoderGopLock,
+          ...deliveryEncoder,
           abortSignal: executionSignal,
           assertNotAborted,
           onProgress
@@ -14110,8 +14579,8 @@ async function executeRenderPipeline(input) {
             "capture_disk",
             "drawElement capture failed; retrying with a fresh screenshot session"
           );
-          rmSync11(framesDir, { recursive: true, force: true });
-          mkdirSync9(framesDir, { recursive: true });
+          rmSync10(framesDir, { recursive: true, force: true });
+          mkdirSync10(framesDir, { recursive: true });
           resetCaptureAttemptProgress(job);
           dedupPerfs.length = 0;
           cfg.useDrawElement = false;
@@ -14208,7 +14677,7 @@ async function executeRenderPipeline(input) {
       buildArtifactExpectation({
         outputFormat,
         durationSeconds: job.duration,
-        fps: fpsToNumber9(job.config.fps),
+        fps: fpsToNumber8(job.config.fps),
         expectedFrames: captureTotalFrames,
         width: outputWidth,
         height: outputHeight
@@ -14287,7 +14756,7 @@ async function executeRenderPipeline(input) {
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync5(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync6(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -14297,8 +14766,8 @@ async function executeRenderPipeline(input) {
     }
     if (job.config.debug) {
       if (!isPngSequence && !isHls && existsSync16(stagedOutputPath)) {
-        const debugOutput = join26(workDir, `output${videoExt}`);
-        copyFileSync4(stagedOutputPath, debugOutput);
+        const debugOutput = join27(workDir, `output${videoExt}`);
+        copyFileSync5(stagedOutputPath, debugOutput);
       }
     }
     await commitArtifactTransaction(artifactTransaction, () => {
@@ -14422,30 +14891,31 @@ import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
 // src/services/distributed/plan.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframes/engine";
 import {
-  copyFileSync as copyFileSync5,
+  copyFileSync as copyFileSync6,
   cpSync as cpSync2,
   existsSync as existsSync21,
   linkSync,
-  mkdirSync as mkdirSync13,
-  rmSync as rmSync13,
-  writeFileSync as writeFileSync8
+  mkdirSync as mkdirSync14,
+  rmSync as rmSync12,
+  writeFileSync as writeFileSync9
 } 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 join35, relative as relative5, sep as sep2 } from "node:path";
 import {
-  fpsToNumber as fpsToNumber10,
+  fpsToNumber as fpsToNumber9,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
 } from "@hyperframes/core";
 import {
   getEncoderPreset as getEncoderPreset4,
+  keyframeIntervalToGopSize as keyframeIntervalToGopSize3,
   normalizeVp9CpuUsed,
   resolveConfig as resolveConfig3,
   declareContentAddressedUrl,
-  renameWithRetry as renameWithRetry6,
+  renameWithRetry as renameWithRetry7,
   declareProbeFactsUrl
 } from "@hyperframes/engine";
 
 // src/services/distributed/planFrameCost.ts
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession9,
   createCaptureSession as createCaptureSession9,
@@ -14455,7 +14925,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 join29 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
   createFrameLookupTable as createFrameLookupTable2,
@@ -14465,8 +14935,8 @@ 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 { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname12, join as join28 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync10 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -14481,7 +14951,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 = join28(planDir, name);
     if (existsSync17(candidate)) return candidate;
   }
   return null;
@@ -14738,13 +15208,13 @@ function buildSyntheticRenderJob(input) {
 var cachedProducerVersion = null;
 function readProducerVersion() {
   if (cachedProducerVersion !== null) return cachedProducerVersion;
-  const startDir = dirname11(fileURLToPath5(import.meta.url));
+  const startDir = dirname12(fileURLToPath5(import.meta.url));
   let current = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = join27(current, "package.json");
+    const candidate = join28(current, "package.json");
     if (existsSync17(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync10(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
           cachedProducerVersion = pkg.version;
           return pkg.version;
@@ -14752,7 +15222,7 @@ function readProducerVersion() {
       } catch {
       }
     }
-    const parent = dirname11(current);
+    const parent = dirname12(current);
     if (parent === current) break;
     current = parent;
   }
@@ -14795,7 +15265,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 = join29(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.`
@@ -14814,7 +15284,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, join29(outputDir, frameName));
     }
     result.push({
       videoId: v.videoId,
@@ -14904,14 +15374,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 = join29(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 ?? join29(input.planDir, ...range.sourcePath.split("/"));
       if (remoteUrl === void 0 && !existsSync18(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
@@ -14960,12 +15430,12 @@ async function measurePlanSecondsPerFrame(input) {
       planVideos,
       frames: sampled,
       fps: fpsRatio,
-      outputRoot: join29(workDir, "frame-cost-video-frames"),
+      outputRoot: join30(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 = join30(planDir, "compiled");
   const fileServer = await createFileServer({
     projectDir: compiledDir,
     compiledDir,
@@ -14977,7 +15447,7 @@ async function measurePlanSecondsPerFrame(input) {
   try {
     session = await createCaptureSession9(
       fileServer.url,
-      join29(workDir, "frame-cost"),
+      join30(workDir, "frame-cost"),
       buildChunkCaptureOptions({
         dimensions: { ...input, fpsNum: fps, fpsDen: 1 },
         encoder: input,
@@ -15074,8 +15544,8 @@ function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
 }
 
 // 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 { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync11, readdirSync as readdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join31, relative as relative3, resolve as resolve9 } from "node:path";
 
 // src/services/distributed/planProtocol.ts
 var PLAN_SCHEMA_VERSION = 1;
@@ -15173,12 +15643,12 @@ function readPlanProtocolV1(planJson, capabilities = DISTRIBUTED_RENDER_CAPABILI
 }
 
 // src/services/render/stages/planHash.ts
-import { createHash as createHash6 } from "node:crypto";
-import { closeSync as closeSync4, createReadStream as createReadStream3, openSync as openSync4, readSync as readSync3 } from "node:fs";
+import { createHash as createHash7 } from "node:crypto";
+import { closeSync as closeSync5, createReadStream as createReadStream3, openSync as openSync5, readSync as readSync4 } from "node:fs";
 var PLAN_HASH_SCHEMA_PREFIX = "hyperframes-plan-hash-v1\0";
 var FIELD_DELIMITER = Buffer.from([0]);
 function computePlanHash(input) {
-  const hash = createHash6("sha256");
+  const hash = createHash7("sha256");
   hash.update(PLAN_HASH_SCHEMA_PREFIX, "utf8");
   hash.update(input.compositionHtml);
   hash.update(FIELD_DELIMITER);
@@ -15225,27 +15695,27 @@ function canonicalJsonStringify(value) {
   throw new TypeError(`canonicalJsonStringify: unsupported value type ${typeof value}`);
 }
 function sha256Hex(bytes) {
-  const h = createHash6("sha256");
+  const h = createHash7("sha256");
   h.update(bytes);
   return h.digest("hex");
 }
 function sha256File(path) {
-  const hash = createHash6("sha256");
+  const hash = createHash7("sha256");
   const buffer = Buffer.allocUnsafe(1024 * 1024);
-  const fd = openSync4(path, "r");
+  const fd = openSync5(path, "r");
   try {
     let bytesRead = 0;
     do {
-      bytesRead = readSync3(fd, buffer, 0, buffer.byteLength, null);
+      bytesRead = readSync4(fd, buffer, 0, buffer.byteLength, null);
       if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
     } while (bytesRead > 0);
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
   return hash.digest("hex");
 }
 async function sha256FileAsync(path) {
-  const hash = createHash6("sha256");
+  const hash = createHash7("sha256");
   for await (const chunk of createReadStream3(path, { highWaterMark: 1024 * 1024 })) {
     hash.update(chunk);
   }
@@ -15289,11 +15759,11 @@ function stripUndefined(value) {
 }
 function listPlanFiles(planDir) {
   const results = [];
-  const rootResolved = resolve8(planDir);
+  const rootResolved = resolve9(planDir);
   function walk(dir) {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join30(dir, entry.name);
+      const full = join31(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile()) {
@@ -15314,7 +15784,7 @@ function collectPlanAssetShas(planDir, digests) {
   const assets = [];
   for (const file of files) {
     if (file.planRelativePath === COMPILED_INDEX_RELATIVE_PATH) {
-      compositionHtml = readFileSync10(file.absolutePath);
+      compositionHtml = readFileSync11(file.absolutePath);
       continue;
     }
     if (HASH_EXCLUDED_PLAN_FILES.has(file.planRelativePath)) continue;
@@ -15334,23 +15804,23 @@ 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");
+  writeFileSync7(join31(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
 }
 function readPlanRemoteFiles(planDir) {
-  const path = join30(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync19(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
+  const path = join31(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
+  return existsSync19(path) ? JSON.parse(readFileSync11(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join30(planDir, "plan.json");
-  const encoderJsonPath = join30(planDir, "meta", "encoder.json");
+  const planJsonPath = join31(planDir, "plan.json");
+  const encoderJsonPath = join31(planDir, "meta", "encoder.json");
   if (!existsSync19(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
   if (!existsSync19(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
-  const planJson = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
-  const encoderConfigCanonicalJson = readFileSync10(encoderJsonPath, "utf-8");
+  const planJson = JSON.parse(readFileSync11(planJsonPath, "utf-8"));
+  const encoderConfigCanonicalJson = readFileSync11(encoderJsonPath, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   return computePlanHash({
     compositionHtml,
@@ -15379,18 +15849,18 @@ async function freezePlan(input) {
   if (!existsSync19(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
-  const metaDir = join30(planDir, "meta");
-  if (!existsSync19(metaDir)) mkdirSync10(metaDir, { recursive: true });
-  writeFileSync6(
-    join30(metaDir, "composition.json"),
+  const metaDir = join31(planDir, "meta");
+  if (!existsSync19(metaDir)) mkdirSync11(metaDir, { recursive: true });
+  writeFileSync7(
+    join31(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)}
+  writeFileSync7(join31(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync7(join31(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
@@ -15414,8 +15884,8 @@ async function freezePlan(input) {
     duration: durationSeconds,
     hasAudio
   };
-  const planJsonPath = join30(planDir, "plan.json");
-  writeFileSync6(planJsonPath, `${JSON.stringify(planJson, null, 2)}
+  const planJsonPath = join31(planDir, "plan.json");
+  writeFileSync7(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
 }
@@ -15456,16 +15926,16 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync5, 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 { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg6 } from "@hyperframes/engine";
+import { closeSync as closeSync6, existsSync as existsSync20, ftruncateSync, mkdirSync as mkdirSync13, openSync as openSync6, readFileSync as readFileSync12 } from "node:fs";
+import { writeFileSync as writeFileSync8, writeSync } from "node:fs";
+import { join as join33 } from "node:path";
+import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure3, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
 
 // src/services/distributed/mp4Stitch.ts
-import { createReadStream as createReadStream4, createWriteStream, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, rmSync as rmSync12 } from "node:fs";
+import { createReadStream as createReadStream4, createWriteStream, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync4, rmSync as rmSync11 } from "node:fs";
 import { open } from "node:fs/promises";
-import { renameWithRetry as renameWithRetry5 } from "@hyperframes/engine";
-import { dirname as dirname12, join as join31 } from "node:path";
+import { renameWithRetry as renameWithRetry6 } from "@hyperframes/engine";
+import { dirname as dirname13, join as join32 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -15478,16 +15948,16 @@ function boxAt(src, off, at, limit) {
   return { type: src.toString("latin1", off + 4, off + 8), start: at, bodyStart, end: at + size };
 }
 function childBoxes(buf, parent) {
-  const boxes = [];
-  for (let at = parent.bodyStart; at < parent.end; at = boxes.at(-1).end) {
-    boxes.push(boxAt(buf, at, at, parent.end));
+  const boxes2 = [];
+  for (let at = parent.bodyStart; at < parent.end; at = boxes2.at(-1).end) {
+    boxes2.push(boxAt(buf, at, at, parent.end));
   }
-  return boxes;
+  return boxes2;
 }
 function findChild(buf, parent, type) {
   return childBoxes(buf, parent).find((box2) => box2.type === type);
 }
-function child(buf, parent, type) {
+function child2(buf, parent, type) {
   const found = findChild(buf, parent, type);
   if (!found) throw new Error(`[mp4Stitch] ${parent.type} has no ${type}`);
   return found;
@@ -15539,7 +16009,7 @@ function rows(buf, table, columns, countAt = 4) {
 function readMediaTime(moov, trak) {
   const edts = findChild(moov, trak, "edts");
   if (!edts) return 0;
-  const elst = child(moov, edts, "elst");
+  const elst = child2(moov, edts, "elst");
   const wide = moov[elst.bodyStart] === 1;
   const entries = moov.readUInt32BE(elst.bodyStart + 4);
   for (let i = 0, at = elst.bodyStart + 8; i < entries; i++, at += wide ? 20 : 12) {
@@ -15554,7 +16024,7 @@ function readSizes(moov, stsz) {
   if (!fixedSize) return rows(moov, stsz, 1, 8).map(([size]) => size);
   return Array(moov.readUInt32BE(stsz.bodyStart + 8)).fill(fixedSize);
 }
-function readSync4(moov, stbl, sampleCount) {
+function readSync5(moov, stbl, sampleCount) {
   const stss = findChild(moov, stbl, "stss");
   if (!stss) return null;
   const sync = Array(sampleCount).fill(false);
@@ -15564,10 +16034,10 @@ function readSync4(moov, stbl, sampleCount) {
 function readChunkOffsets(moov, stbl) {
   const stco = findChild(moov, stbl, "stco");
   if (stco) return rows(moov, stco, 1).map(([offset]) => offset);
-  return rows(moov, child(moov, stbl, "co64"), 2).map(([hi, lo]) => hi * 2 ** 32 + lo);
+  return rows(moov, child2(moov, stbl, "co64"), 2).map(([hi, lo]) => hi * 2 ** 32 + lo);
 }
 function readSamplesPerChunk(moov, stbl, chunkCount) {
-  const stsc = rows(moov, child(moov, stbl, "stsc"), 3);
+  const stsc = rows(moov, child2(moov, stbl, "stsc"), 3);
   return stsc.flatMap(([firstChunk, perChunk, description], i) => {
     if (description !== 1) throw new Error("[mp4Stitch] chunk uses more than one sample entry");
     const nextFirst = stsc[i + 1]?.[0] ?? chunkCount + 1;
@@ -15575,28 +16045,28 @@ function readSamplesPerChunk(moov, stbl, chunkCount) {
   });
 }
 function readTrack(moov, trak) {
-  const mdia = child(moov, trak, "mdia");
-  const hdlr = child(moov, mdia, "hdlr");
-  const stbl = child(moov, child(moov, mdia, "minf"), "stbl");
+  const mdia = child2(moov, trak, "mdia");
+  const hdlr = child2(moov, mdia, "hdlr");
+  const stbl = child2(moov, child2(moov, mdia, "minf"), "stbl");
   if (findChild(moov, stbl, "ctts")) throw new Error("[mp4Stitch] chunk has ctts (B-frames)");
-  const stts = rows(moov, child(moov, stbl, "stts"), 2);
+  const stts = rows(moov, child2(moov, stbl, "stts"), 2);
   const durations = stts.flatMap(([n, delta]) => Array(n).fill(delta));
-  const sizes = readSizes(moov, child(moov, stbl, "stsz"));
+  const sizes = readSizes(moov, child2(moov, stbl, "stsz"));
   const chunkOffsets = readChunkOffsets(moov, stbl);
   const samplesPerChunk = readSamplesPerChunk(moov, stbl, chunkOffsets.length);
   if (durations.length !== sizes.length || sum(samplesPerChunk) !== sizes.length) {
     throw new Error("[mp4Stitch] sample tables disagree on the sample count");
   }
-  const stsd = child(moov, stbl, "stsd");
+  const stsd = child2(moov, stbl, "stsd");
   return {
     trak,
     handler: moov.toString("latin1", hdlr.bodyStart + 8, hdlr.bodyStart + 12),
-    timescale: timescaleOf(moov, child(moov, mdia, "mdhd")),
+    timescale: timescaleOf(moov, child2(moov, mdia, "mdhd")),
     mediaTime: readMediaTime(moov, trak),
     stsd: moov.subarray(stsd.start, stsd.end),
     durations,
     sizes,
-    sync: readSync4(moov, stbl, sizes.length),
+    sync: readSync5(moov, stbl, sizes.length),
     samplesPerChunk,
     chunkOffsets
   };
@@ -15737,9 +16207,9 @@ function buildStitchedHeader(layouts, audio) {
   }
   const template = layouts[0].moov;
   const root = boxAt(template, 0, 0, template.length);
-  const mvhd = child(template, root, "mvhd");
+  const mvhd = child2(template, root, "mvhd");
   const movieTimescale = timescaleOf(template, mvhd);
-  const chunkTrackIds = plan2.slice(0, chunkTrackCount).map((track) => idOf(template, child(template, track.trak, "tkhd")));
+  const chunkTrackIds = plan2.slice(0, chunkTrackCount).map((track) => idOf(template, child2(template, track.trak, "tkhd")));
   const audioTrackId = Math.max(...chunkTrackIds) + 1;
   const buildMoov = (dataStart2) => {
     const traks = plan2.map((track, t) => {
@@ -15829,18 +16299,18 @@ async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
   const sourcePaths = audioPath ? [audioPath, ...chunkPaths] : chunkPaths;
   const layouts = await Promise.all(sourcePaths.map((path) => readMp4Layout(fileRange(path))));
   const header = audioPath ? buildStitchedHeader(layouts.slice(1), layouts[0]) : buildStitchedHeader(layouts);
-  mkdirSync11(dirname12(outputPath), { recursive: true });
+  mkdirSync12(dirname13(outputPath), { recursive: true });
   const workDir = mkdtempSync4(`${outputPath}.stitch-`);
-  const out = createWriteStream(join31(workDir, "out.mp4"));
+  const out = createWriteStream(join32(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);
-    renameWithRetry5(join31(workDir, "out.mp4"), outputPath);
+    renameWithRetry6(join32(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
-    rmSync12(workDir, { recursive: true, force: true });
+    rmSync11(workDir, { recursive: true, force: true });
   }
 }
 
@@ -15929,9 +16399,9 @@ async function writeChunkAudioSlices(input) {
       offset += track.sizes[offsets.length - 1];
     }
   });
-  const bytes = readFileSync11(input.audioPath);
+  const bytes = readFileSync12(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
-  mkdirSync12(join32(input.planDir, SLICE_DIR), { recursive: true });
+  mkdirSync13(join33(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
     const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
     if (!cut) return;
@@ -15939,18 +16409,18 @@ 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));
+    writeFileSync8(join33(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));
+  writeFileSync8(join33(input.planDir, SLICE_FRAME), Buffer.concat(frame));
+  writeFileSync8(join33(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
 }
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
-  const layoutPath = join32(planDir, SLICE_LAYOUT);
+  const layoutPath = join33(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 fd = openSync5(scratchPath, "w");
+  const layout = JSON.parse(readFileSync12(layoutPath, "utf-8"));
+  const frame = readFileSync12(join33(planDir, SLICE_FRAME));
+  const fd = openSync6(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
     writeSync(
@@ -15962,12 +16432,12 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync11(join32(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync12(join33(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
   } finally {
-    closeSync5(fd);
+    closeSync6(fd);
   }
   return scratchPath;
 }
@@ -15987,7 +16457,7 @@ async function muxChunkWithAudio(input) {
   const args = [...chunkMuxArgs(input, cut), "-c", "copy"];
   appendRenderProvenanceArgs(args, input.outputPath);
   args.push("-y", input.outputPath);
-  const result = await runFfmpeg6(args, { signal: input.signal, timeout: input.timeoutMs });
+  const result = await runFfmpeg7(args, { signal: input.signal, timeout: input.timeoutMs });
   if (!result.success) {
     throw new Error(
       `[chunkAudio] chunk mux failed: ${describeFfmpegFailure3(result, input.timeoutMs)}`
@@ -16016,9 +16486,9 @@ async function muxChunkWithAudio(input) {
 }
 
 // src/services/distributed/planSize.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } 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 join34, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -16046,7 +16516,7 @@ var PLAN_ROOT_CATEGORY = {
   "plan.json": "metadata"
 };
 function hashComponent(value) {
-  return createHash7("sha256").update(value).digest("hex").slice(0, 12);
+  return createHash8("sha256").update(value).digest("hex").slice(0, 12);
 }
 function classifyFile(segments, rootKind) {
   const rootName = segments[0] ?? "";
@@ -16130,7 +16600,7 @@ function walkRegularFiles(dir, visit) {
     return;
   }
   for (const entry of entries) {
-    const full = join33(dir, entry.name);
+    const full = join34(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -16342,13 +16812,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join34("meta", "composition.json"),
-  join34("meta", "encoder.json"),
-  join34("meta", "chunks.json")
+  join35("meta", "composition.json"),
+  join35("meta", "encoder.json"),
+  join35("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync13(join34(planDir, relativePath), { force: true });
+    rmSync12(join35(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -16408,6 +16878,9 @@ function buildLockedRenderConfig(input) {
     preset,
     crf: config.crf,
     bitrate: config.bitrate,
+    maxBitrate: config.maxBitrate,
+    bufferSize: config.bufferSize,
+    keyframeIntervalFrames: config.keyframeIntervalSeconds === void 0 ? void 0 : keyframeIntervalToGopSize3({ num: config.fps, den: 1 }, config.keyframeIntervalSeconds),
     ...locksVp9CpuUsed,
     // GOP === chunkSize so every chunk's first frame is an IDR keyframe and
     // ffmpeg concat-copy round-trips losslessly.
@@ -16493,23 +16966,23 @@ 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 : join35(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(join35(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 = join35(input.planDir, ...result.split("/"));
+      mkdirSync14(join35(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
-        copyFileSync5(current, destination);
+        copyFileSync6(current, destination);
       }
     }
     shipped.set(srcPath, result);
@@ -16525,7 +16998,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync21(planDir)) mkdirSync13(planDir, { recursive: true });
+  if (!existsSync21(planDir)) mkdirSync14(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -16554,15 +17027,15 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join34(projectDir, entryFile);
+  const htmlPath = join35(projectDir, entryFile);
   if (!existsSync21(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join34(planDir, ".plan-work");
-  rmSync13(workDir, { recursive: true, force: true });
-  mkdirSync13(workDir, { recursive: true });
-  const compiledDir = join34(workDir, "compiled");
-  mkdirSync13(compiledDir, { recursive: true });
+  const workDir = join35(planDir, ".plan-work");
+  rmSync12(workDir, { recursive: true, force: true });
+  mkdirSync14(workDir, { recursive: true });
+  const compiledDir = join35(workDir, "compiled");
+  mkdirSync14(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
     recursive: true,
@@ -16575,10 +17048,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join34(planDir, "compiled");
+  const finalCompiledDir = join35(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
-  const remoteLocalPath = (rel) => join34(projectDir, ...rel.split("/"));
+  const remoteLocalPath = (rel) => join35(projectDir, ...rel.split("/"));
   for (const [, file] of remoteFiles) {
     declareContentAddressedUrl(file.url, file.sha256);
     if (file.probeFactsUrl) declareProbeFactsUrl(file.url, file.probeFactsUrl);
@@ -16652,7 +17125,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   validateDistributedDuration({
     duration: probeResult.duration,
     totalFrames,
-    fps: fpsToNumber10(job.config.fps)
+    fps: fpsToNumber9(job.config.fps)
   });
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
@@ -16764,18 +17237,18 @@ 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)) rmSync13(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join34(planDir, "video-sources");
-  rmSync13(videoSourcesDir, { recursive: true, force: true });
+  const stagedVideoFrames = join35(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join35(planDir, "video-frames");
+  if (existsSync21(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join35(planDir, "video-sources");
+  rmSync12(videoSourcesDir, { recursive: true, force: true });
   if (existsSync21(stagedVideoFrames)) {
-    renameWithRetry6(stagedVideoFrames, videoFramesDst);
+    renameWithRetry7(stagedVideoFrames, videoFramesDst);
   } else {
-    mkdirSync13(videoFramesDst, { recursive: true });
+    mkdirSync14(videoFramesDst, { recursive: true });
   }
-  if (existsSync21(finalCompiledDir)) rmSync13(finalCompiledDir, { recursive: true, force: true });
-  renameWithRetry6(compiledDir, finalCompiledDir);
+  if (existsSync21(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
+  renameWithRetry7(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
     projectDir,
@@ -16804,7 +17277,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync13(join34(planDir, "meta"), { recursive: true });
+  mkdirSync14(join35(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -16813,8 +17286,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       sizeBytes
     }))
   );
-  writeFileSync8(
-    join34(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+  writeFileSync9(
+    join35(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -16893,9 +17366,9 @@ 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 = join35(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult?.hasAudio && existsSync21(audioResult.audioOutputPath)) {
-    renameWithRetry6(audioResult.audioOutputPath, planAudioPath);
+    renameWithRetry7(audioResult.audioOutputPath, planAudioPath);
   }
   if (chunksCarryAudio && existsSync21(planAudioPath)) {
     if (options.sliceChunkAudio) {
@@ -16942,7 +17415,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     format: config.format
   };
   try {
-    rmSync13(workDir, { recursive: true, force: true });
+    rmSync12(workDir, { recursive: true, force: true });
   } catch (err) {
     log.warn("[plan] failed to remove temp work dir", {
       workDir,
@@ -17093,6 +17566,20 @@ function validateDistributedRenderConfig(config) {
       `must look like "10M" or "5000k"; got ${JSON.stringify(config.bitrate)}`
     );
   }
+  try {
+    validateDeliveryEncoderConfig({
+      format: config.format,
+      fps: { num: config.fps, den: 1 },
+      keyframeIntervalSeconds: config.keyframeIntervalSeconds,
+      maxBitrate: config.maxBitrate,
+      bufferSize: config.bufferSize
+    });
+  } catch (error) {
+    throw new InvalidConfigError(
+      "config.maxBitrate",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
   if (config.chunkSize !== void 0) {
     if (!Number.isInteger(config.chunkSize) || config.chunkSize < 1) {
       throw new InvalidConfigError(
@@ -17272,6 +17759,12 @@ function assertOptionalInteger(options, field, min = 0) {
     throw new Error(`Render request ${field} must be an integer >= ${min}`);
   }
 }
+function assertOptionalPositiveNumber(options, field) {
+  const value = options[field];
+  if (value !== void 0 && !(typeof value === "number" && value > 0)) {
+    throw new Error(`Render request ${field} must be a positive number`);
+  }
+}
 function assertOptionalString(options, field) {
   if (options[field] !== void 0 && typeof options[field] !== "string") {
     throw new Error(`Render request ${field} must be a string`);
@@ -17319,10 +17812,11 @@ function assertRequestOptionScalars(options) {
   assertOptionalInteger(options, "workers", 1);
   assertOptionalInteger(options, "maxRenderMs");
   assertOptionalInteger(options, "crf");
+  assertOptionalPositiveNumber(options, "keyframeIntervalSeconds");
   for (const field of ["useGpu", "debug", "outputResolutionAspectAgnostic"]) {
     assertOptionalBoolean(options, field);
   }
-  for (const field of ["entryFile", "videoBitrate"]) {
+  for (const field of ["entryFile", "videoBitrate", "maxBitrate", "bufferSize"]) {
     assertOptionalString(options, field);
   }
   assertOptionalEnum(options, "strictness", ["strict", "best-effort"]);
@@ -17425,6 +17919,9 @@ function distributedConfigFromRequest(request, runtime = {}) {
     crf: options.crf,
     pageMotionBlur: options.pageMotionBlur,
     bitrate: options.videoBitrate,
+    keyframeIntervalSeconds: options.keyframeIntervalSeconds,
+    maxBitrate: options.maxBitrate,
+    bufferSize: options.bufferSize,
     videoFrameFormat: options.videoFrameFormat,
     outputResolution: options.outputResolution,
     outputResolutionAspectAgnostic: options.outputResolutionAspectAgnostic,
@@ -17472,6 +17969,9 @@ function renderRequestFromDistributedConfig(input) {
     ...optionalProperty("crf", config.crf),
     ...optionalProperty("pageMotionBlur", config.pageMotionBlur),
     ...optionalProperty("videoBitrate", config.bitrate),
+    ...optionalProperty("keyframeIntervalSeconds", config.keyframeIntervalSeconds),
+    ...optionalProperty("maxBitrate", config.maxBitrate),
+    ...optionalProperty("bufferSize", config.bufferSize),
     ...optionalProperty("videoFrameFormat", config.videoFrameFormat),
     ...optionalProperty("outputResolution", config.outputResolution),
     ...optionalProperty("outputResolutionAspectAgnostic", config.outputResolutionAspectAgnostic),
@@ -17513,14 +18013,14 @@ import {
 // src/server.ts
 import {
   existsSync as existsSync24,
-  mkdirSync as mkdirSync14,
-  statSync as statSync9,
+  mkdirSync as mkdirSync15,
+  statSync as statSync10,
   mkdtempSync as mkdtempSync5,
-  writeFileSync as writeFileSync9,
-  rmSync as rmSync14,
+  writeFileSync as writeFileSync10,
+  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 resolve11, dirname as dirname15, join as join38 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -17532,14 +18032,14 @@ import { fetchPublicHttpsText as fetchPublicHttpsText2 } from "@hyperframes/engi
 // src/services/hyperframeLint.ts
 import {
   existsSync as existsSync22,
-  readFileSync as readFileSync12,
-  statSync as statSync8,
-  openSync as openSync6,
+  readFileSync as readFileSync13,
+  statSync as statSync9,
+  openSync as openSync7,
   fstatSync as fstatSync3,
-  closeSync as closeSync6,
+  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 resolve10, join as join36, 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)) {
@@ -17569,30 +18069,30 @@ function pickEntryFile(files, preferredEntryFile) {
 function readEntryHtml(filePath) {
   let fd;
   try {
-    fd = openSync6(filePath, constants3.O_RDONLY | constants3.O_NONBLOCK);
+    fd = openSync7(filePath, constants3.O_RDONLY | constants3.O_NONBLOCK);
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
       return null;
-    if (!statSync8(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    if (!statSync9(filePath, { throwIfNoEntry: false })?.isFile()) return null;
     throw error;
   }
   try {
     if (!fstatSync3(fd).isFile()) return null;
-    return readFileSync12(fd, "utf-8");
+    return readFileSync13(fd, "utf-8");
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
-  const absProjectDir = resolve9(projectDir);
-  if (!existsSync22(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
+  const absProjectDir = resolve10(projectDir);
+  if (!existsSync22(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
     (value) => typeof value === "string" && value.trim().length > 0
   );
   for (const entryFile of entryCandidates) {
-    const absoluteEntryPath = resolve9(absProjectDir, entryFile);
+    const absoluteEntryPath = resolve10(absProjectDir, entryFile);
     const entryRelativePath = relative6(absProjectDir, absoluteEntryPath);
     if (entryRelativePath === ".." || entryRelativePath.startsWith(`..${sep3}`) || isAbsolute4(entryRelativePath)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
@@ -17607,7 +18107,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: ${join36(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -17653,7 +18153,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 dirname14, join as join37 } from "node:path";
 import { existsSync as existsSync23 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -17672,12 +18172,12 @@ async function startHealthWorker(options = {}) {
     stdout: false,
     stderr: false
   });
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve13, reject) => {
     const onMessage = (msg) => {
       if (msg?.type === "listening") {
         worker.off("error", onError);
         worker.off("message", onMessage);
-        resolve12();
+        resolve13();
       } else if (msg?.type === "listen-error") {
         worker.off("error", onError);
         worker.off("message", onMessage);
@@ -17728,8 +18228,8 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname13(fileURLToPath6(import.meta.url));
-  const candidates = [join36(here, "healthWorkerThread.js"), join36(here, "healthWorkerThread.ts")];
+  const here = dirname14(fileURLToPath6(import.meta.url));
+  const candidates = [join37(here, "healthWorkerThread.js"), join37(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync23(candidate)) return candidate;
   }
@@ -17747,6 +18247,8 @@ var DEFAULT_SERVER_FPS = { num: 30, den: 1 };
 var SSE_KEEPALIVE_MS = 3e4;
 var SAFE_RENDER_ERROR_CODES = /* @__PURE__ */ new Set([
   "ASSET_MEDIA_TYPE_MISMATCH",
+  "HEIF_IMAGE_CONVERSION_FAILED",
+  "HEIF_TOOL_UNAVAILABLE",
   "NOT_MEDIA_PAYLOAD",
   "INVALID_VIDEO_METADATA",
   "VIDEO_SOURCE_UNRENDERABLE",
@@ -17821,7 +18323,7 @@ function parseRenderOptions(body) {
   const format = parseServerFormat(body.format);
   const outputDynamicRange = parseServerOutputDynamicRange(body.outputDynamicRange) ?? fromRenderHdrMode(parseLegacyServerHdrMode(body.hdrMode));
   const encoder = parseEncoderOptions(body, format ?? "mp4");
-  const { crf, videoBitrate, videoFrameFormat } = encoder.ok ? encoder.options : {};
+  const { crf, videoBitrate, videoFrameFormat, keyframeIntervalSeconds, maxBitrate, bufferSize } = encoder.ok ? encoder.options : {};
   const { variables, outputResolution, outputResolutionAspectAgnostic } = parseRenderOverrides(body);
   return {
     outputPath,
@@ -17831,6 +18333,9 @@ function parseRenderOptions(body) {
     maxRenderMs,
     crf,
     videoBitrate,
+    keyframeIntervalSeconds,
+    maxBitrate,
+    bufferSize,
     useGpu,
     debug,
     strictness,
@@ -17865,6 +18370,9 @@ function buildRenderJobConfig(input, outputPath, log) {
       maxRenderMs: input.maxRenderMs,
       crf: input.crf,
       videoBitrate: input.videoBitrate,
+      keyframeIntervalSeconds: input.keyframeIntervalSeconds,
+      maxBitrate: input.maxBitrate,
+      bufferSize: input.bufferSize,
       useGpu: input.useGpu,
       debug: input.debug,
       strictness: input.strictness,
@@ -17882,8 +18390,8 @@ function buildRenderJobConfig(input, outputPath, log) {
 function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
-  const outputDir = dirname14(absoluteOutputPath);
-  if (!existsSync24(outputDir)) mkdirSync14(outputDir, { recursive: true });
+  const outputDir = dirname15(absoluteOutputPath);
+  if (!existsSync24(outputDir)) mkdirSync15(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -17923,12 +18431,12 @@ var MAX_PREVIEW_HTML_BYTES = 20 * 1024 * 1024;
 function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
-  const absProjectDir = resolve10(candidate);
-  if (!existsSync24(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
+  const absProjectDir = resolve11(candidate);
+  if (!existsSync24(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync24(resolve10(absProjectDir, entry))) {
+  if (!existsSync24(resolve11(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -17949,8 +18457,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(join38(tempRoot, "producer-project-"));
+  writeFileSync10(join38(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -17975,7 +18483,7 @@ function resolveOutputPath(projectDir, outputCandidate, rendersDir, log) {
   try {
     return resolveRenderPaths(projectDir, outputCandidate, rendersDir).absoluteOutputPath;
   } catch (error) {
-    const fallbackPath = resolve10(rendersDir, `producer-fallback-${Date.now()}.mp4`);
+    const fallbackPath = resolve11(rendersDir, `producer-fallback-${Date.now()}.mp4`);
     log.warn("Failed to resolve output path, using fallback", {
       fallback: fallbackPath,
       error: error instanceof Error ? error.message : String(error)
@@ -18011,7 +18519,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync14(dir, { recursive: true, force: true });
+    rmSync13(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -18020,7 +18528,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync24(path) ? statSync9(path).size : 0;
+  return existsSync24(path) ? statSync10(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -18326,7 +18834,7 @@ function createRenderHandlers(options = {}) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync9(artifact.path);
+    const stats = statSync10(artifact.path);
     return new Response(createReadStream5(artifact.path), {
       headers: {
         "content-type": "video/mp4",
@@ -18393,7 +18901,7 @@ function startServer(options = {}) {
   process.on("SIGINT", () => shutdown("SIGINT"));
   return server;
 }
-var entryScript = process.argv[1] ? resolve10(process.argv[1]) : "";
+var entryScript = process.argv[1] ? resolve11(process.argv[1]) : "";
 var isPublicServerEntry = entryScript.endsWith("/public-server.js") || entryScript.endsWith("/src/server.ts");
 if (isPublicServerEntry) {
   const { values } = parseArgs({
@@ -18418,35 +18926,35 @@ import { quantizeTimeToFrame, MEDIA_VISUAL_STYLE_PROPERTIES } from "@hyperframes
 
 // src/services/distributed/planV2.ts
 import {
-  copyFileSync as copyFileSync7,
+  copyFileSync as copyFileSync8,
   existsSync as existsSync26,
   lstatSync as lstatSync3,
-  mkdirSync as mkdirSync16,
+  mkdirSync as mkdirSync17,
   mkdtempSync as mkdtempSync7,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   readdirSync as readdirSync9,
-  rmSync as rmSync16,
-  statSync as statSync11,
-  writeFileSync as writeFileSync11
+  rmSync as rmSync15,
+  statSync as statSync12,
+  writeFileSync as writeFileSync12
 } 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 dirname17, isAbsolute as isAbsolute5, join as join41, relative as relative7, resolve as resolve12, sep as sep4 } from "node:path";
 import { DISTRIBUTED_FPS as DISTRIBUTED_FPS2, isDistributedFps as isDistributedFps3 } from "@hyperframes/core";
-import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as renameWithRetry8 } from "@hyperframes/engine";
+import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as renameWithRetry9 } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Publisher.ts
 import {
-  copyFileSync as copyFileSync6,
+  copyFileSync as copyFileSync7,
   existsSync as existsSync25,
   linkSync as linkSync2,
-  mkdirSync as mkdirSync15,
+  mkdirSync as mkdirSync16,
   mkdtempSync as mkdtempSync6,
-  rmSync as rmSync15,
-  statSync as statSync10,
-  writeFileSync as writeFileSync10
+  rmSync as rmSync14,
+  statSync as statSync11,
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { renameWithRetry as renameWithRetry7 } from "@hyperframes/engine";
-import { dirname as dirname15, join as join39 } from "node:path";
+import { renameWithRetry as renameWithRetry8 } from "@hyperframes/engine";
+import { dirname as dirname16, join as join40 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -18461,7 +18969,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -18471,7 +18979,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 join39(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
@@ -18511,12 +19019,12 @@ 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-"));
+    mkdirSync16(dirname16(destinationDir), { recursive: true });
+    this.temporaryDir = mkdtempSync6(join40(dirname16(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
-    const sourceSize = statSync10(blob.sourcePath).size;
+    const sourceSize = statSync11(blob.sourcePath).size;
     if (sourceSize !== blob.sizeBytes) {
       throw new PlanV2IntegrityError(
         `published blob size changed for ${digest}: expected ${blob.sizeBytes}, got ${sourceSize}`
@@ -18524,19 +19032,19 @@ 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");
+    mkdirSync16(dirname16(destinationPath), { recursive: true });
+    const stagingDir = mkdtempSync6(join40(dirname16(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join40(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
       } catch (error) {
         if (!canFallbackToCopy(error)) throw error;
-        copyFileSync6(blob.sourcePath, temporaryPath);
+        copyFileSync7(blob.sourcePath, temporaryPath);
       }
-      renameWithRetry7(temporaryPath, destinationPath);
+      renameWithRetry8(temporaryPath, destinationPath);
     } finally {
-      rmSync15(stagingDir, { recursive: true, force: true });
+      rmSync14(stagingDir, { recursive: true, force: true });
     }
   }
   async commitManifest(manifestBytes) {
@@ -18547,13 +19055,13 @@ var LocalPlanV2ArtifactPublisher = class {
         );
       }
     }
-    writeFileSync10(join39(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
-    renameWithRetry7(this.temporaryDir, this.destinationDir);
+    writeFileSync11(join40(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    renameWithRetry8(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
     if (!this.#committed) {
-      rmSync15(this.temporaryDir, { recursive: true, force: true });
+      rmSync14(this.temporaryDir, { recursive: true, force: true });
     }
   }
 };
@@ -18572,7 +19080,7 @@ function isNonNegativeIntegerArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "number" && Number.isInteger(item) && item >= 0);
 }
 function readJsonFile(path, label) {
-  const contents = readFileSync13(path, "utf-8");
+  const contents = readFileSync14(path, "utf-8");
   try {
     const parsed = JSON.parse(contents);
     return parsed;
@@ -18589,10 +19097,10 @@ function assertSafeRelativePath(path) {
 }
 function listFiles(root) {
   const files = [];
-  const rootResolved = resolve11(root);
+  const rootResolved = resolve12(root);
   function walk(dir) {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const absolutePath = join40(dir, entry.name);
+      const absolutePath = join41(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -18619,13 +19127,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join40(executionPlanDir, "video-frames");
+  const videoRoot = join41(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 = join41(videoRoot, videoEntry.name);
     if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join40(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+      const sentinelPath = join41(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -18635,8 +19143,8 @@ function isExtractionCacheCompleteSentinelPath(path) {
   return segments.length === 3 && segments[0] === "video-frames" && segments[1] !== "" && segments[2] === EXTRACTION_CACHE_COMPLETE_SENTINEL;
 }
 function resolveExtractedVideoOutputDir(planDir, videoId) {
-  const videoRoot = resolve11(planDir, "video-frames");
-  const outputDir = resolve11(videoRoot, videoId);
+  const videoRoot = resolve12(planDir, "video-frames");
+  const outputDir = resolve12(videoRoot, videoId);
   if (outputDir === videoRoot || !outputDir.startsWith(`${videoRoot}${sep4}`)) {
     throw new PlanV2IntegrityError(`unsafe extracted video id: ${JSON.stringify(videoId)}`);
   }
@@ -18672,7 +19180,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, join41(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
@@ -18680,7 +19188,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(join41(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -18699,7 +19207,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join40(outputDir, frameName));
+      framePaths.set(frameIndex, join41(outputDir, frameName));
     }
     return {
       ...video,
@@ -18720,11 +19228,11 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join41(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) {
-    mkdirSync16(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
+    mkdirSync17(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
   }
 }
 function parseChunkSlices(value) {
@@ -18754,13 +19262,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join40(executionPlanDir, "video-frames");
+  const videoRoot = join41(executionPlanDir, "video-frames");
   const hasExtractedFrames = existsSync26(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join40(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join41(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 = join41(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -18797,7 +19305,7 @@ function collectChunkVideoDependencies(input) {
     for (let frame = chunk.startFrame; frame < chunk.endFrame; frame++) {
       const globalTime = frame * input.fpsDen / input.fpsNum;
       for (const [videoId, payload] of input.table.getActiveFramePayloads(globalTime)) {
-        const path = input.deferredSources.get(videoId) ?? relative7(resolve11(input.executionPlanDir), payload.framePath).split(sep4).join("/");
+        const path = input.deferredSources.get(videoId) ?? relative7(resolve12(input.executionPlanDir), payload.framePath).split(sep4).join("/");
         assertSafeRelativePath(path);
         const indexes = mutable.get(path) ?? /* @__PURE__ */ new Set();
         indexes.add(chunk.index);
@@ -18815,21 +19323,21 @@ 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");
+  mkdirSync17(dirname17(destinationPath), { recursive: true });
+  const temporaryDir = mkdtempSync7(join41(dirname17(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join41(temporaryDir, "blob");
   try {
-    copyFileSync7(sourcePath, temporaryPath);
-    renameWithRetry8(temporaryPath, destinationPath);
+    copyFileSync8(sourcePath, temporaryPath);
+    renameWithRetry9(temporaryPath, destinationPath);
   } finally {
-    rmSync16(temporaryDir, { recursive: true, force: true });
+    rmSync15(temporaryDir, { recursive: true, force: true });
   }
 }
 function publishBlobFor(absolutePath, digests) {
   return {
     sourcePath: absolutePath,
     sha256: planFileSha256(absolutePath, digests),
-    sizeBytes: statSync11(absolutePath).size
+    sizeBytes: statSync12(absolutePath).size
   };
 }
 async function putBlobs(publisher, blobs) {
@@ -18853,7 +19361,7 @@ async function putTasks(tasks) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join40(executionPlanDir, "plan.json");
+  const executionPlanPath = join41(executionPlanDir, "plan.json");
   if (!existsSync26(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
@@ -18881,7 +19389,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(join41(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) {
@@ -18941,21 +19449,21 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
   if (publication.storedBlobs.length > 0) {
     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-"));
+  mkdirSync17(dirname17(planV2Dir), { recursive: true });
+  const tempDir = mkdtempSync7(join41(dirname17(planV2Dir), ".plan-v2-build-"));
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
-    writeFileSync11(
-      join40(tempDir, "plan.json"),
+    writeFileSync12(
+      join41(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
-    renameWithRetry8(tempDir, planV2Dir);
+    renameWithRetry9(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
-    rmSync16(tempDir, { recursive: true, force: true });
+    rmSync15(tempDir, { recursive: true, force: true });
     throw error;
   }
 }
@@ -18995,7 +19503,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(join41(options.stagingParentDir ?? tmpdir4(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -19006,7 +19514,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(join41(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -19022,7 +19530,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
     }
     throw error;
   } finally {
-    rmSync16(stagingRoot, { recursive: true, force: true });
+    rmSync15(stagingRoot, { recursive: true, force: true });
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
@@ -19031,14 +19539,14 @@ async function planV2(projectDir, config, planV2Dir) {
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
   const manifest = await planV2WithPublisher(projectDir, config, publisher, {
-    stagingParentDir: dirname16(planV2Dir)
+    stagingParentDir: dirname17(planV2Dir)
   });
   return resultFromManifest(planV2Dir, manifest);
 }
 function resultFromManifest(planV2Dir, manifest) {
   return {
     planDir: planV2Dir,
-    manifestPath: join40(planV2Dir, "plan.json"),
+    manifestPath: join41(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -19174,7 +19682,7 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join40(planV2Dir, "plan.json");
+  const manifestPath = join41(planV2Dir, "plan.json");
   if (!existsSync26(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
@@ -19197,7 +19705,7 @@ function verifyBlob(planV2Dir, artifact) {
   if (!existsSync26(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
-  const stats = statSync11(sourcePath);
+  const stats = statSync12(sourcePath);
   if (!stats.isFile() || stats.size !== artifact.sizeBytes) {
     throw new PlanV2IntegrityError(`artifact size mismatch for ${artifact.path}`);
   }
@@ -19219,17 +19727,17 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     artifact,
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
-  mkdirSync16(dirname16(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync7(join40(dirname16(destinationDir), ".plan-v2-materialize-"));
+  mkdirSync17(dirname17(destinationDir), { recursive: true });
+  const tempDir = mkdtempSync7(join41(dirname17(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join40(tempDir, ...artifact.path.split("/"));
-      mkdirSync16(dirname16(destinationPath), { recursive: true });
-      copyFileSync7(sourcePath, destinationPath);
+      const destinationPath = join41(tempDir, ...artifact.path.split("/"));
+      mkdirSync17(dirname17(destinationPath), { recursive: true });
+      copyFileSync8(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
-    writeFileSync11(
-      join40(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+    writeFileSync12(
+      join41(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({
         manifest,
         target,
@@ -19237,9 +19745,9 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
       }),
       "utf-8"
     );
-    renameWithRetry8(tempDir, destinationDir);
+    renameWithRetry9(tempDir, destinationDir);
   } catch (error) {
-    rmSync16(tempDir, { recursive: true, force: true });
+    rmSync15(tempDir, { recursive: true, force: true });
     throw error;
   }
   return {
@@ -19252,7 +19760,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 ? join41(destinationDir, audioArtifact.path) : null : null
   };
 }
 function assertRemoteSources(remoteSources, artifacts) {
@@ -19271,7 +19779,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 = join41(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)) {
@@ -19289,8 +19797,8 @@ 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("/"));
-    if (!existsSync26(path) || statSync11(path).size !== artifact.sizeBytes) {
+    const path = join41(planDir, ...artifact.path.split("/"));
+    if (!existsSync26(path) || statSync12(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -19303,33 +19811,34 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
 }
 
 // src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync9, rmSync as rmSync19 } 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 join44 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
   cpSync as cpSync3,
   existsSync as existsSync27,
-  mkdirSync as mkdirSync17,
+  mkdirSync as mkdirSync18,
   mkdtempSync as mkdtempSync8,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   readdirSync as readdirSync10,
-  rmSync as rmSync17,
-  statSync as statSync12,
-  writeFileSync as writeFileSync12
+  rmSync as rmSync16,
+  statSync as statSync13,
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { dirname as dirname17, join as join41 } from "node:path";
+import { dirname as dirname18, join as join42 } from "node:path";
 import {
+  appendRateCapArgs as appendRateCapArgs2,
   appendRenderProvenanceArgs as appendRenderProvenanceArgs2,
   describeFfmpegFailure as describeFfmpegFailure4,
   getEncoderPreset as getEncoderPreset5,
   MIXED_AUDIO_FILENAME as MIXED_AUDIO_FILENAME4,
   muxVideoWithAudio as muxVideoWithAudio2,
   resolveConfig as resolveConfig6,
-  runFfmpeg as runFfmpeg7,
+  runFfmpeg as runFfmpeg8,
   appendSoftwareEncoderThreadsArg,
-  renameWithRetry as renameWithRetry9
+  renameWithRetry as renameWithRetry10
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
 function cfrRateControlArgs(locked) {
@@ -19355,13 +19864,13 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       outputPath,
       durationMs: Date.now() - start,
       framesEncoded: plan2.totalFrames,
-      fileSize: statSync12(outputPath).size
+      fileSize: statSync13(outputPath).size
     };
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync27(dirname17(outputPath))) {
-    mkdirSync17(dirname17(outputPath), { recursive: true });
+  if (!existsSync27(dirname18(outputPath))) {
+    mkdirSync18(dirname18(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync8(`${outputPath}.assemble-work-`);
   const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
@@ -19383,10 +19892,10 @@ 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 = join42(workDir, `output.${format}`);
     const audio = audioPath !== null && existsSync27(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
-    renameWithRetry9(finalPath, outputPath);
+    renameWithRetry10(finalPath, outputPath);
     log.info("[assemble] stage timings", {
       ...stageMs,
       chunks: chunkPaths.length,
@@ -19394,7 +19903,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     });
   } finally {
     try {
-      rmSync17(workDir, { recursive: true, force: true });
+      rmSync16(workDir, { recursive: true, force: true });
     } catch (err) {
       log.warn("[assemble] failed to remove work dir", {
         workDir,
@@ -19402,7 +19911,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync27(outputPath) ? statSync12(outputPath).size : 0;
+  const fileSize = existsSync27(outputPath) ? statSync13(outputPath).size : 0;
   return {
     outputPath,
     durationMs: Date.now() - start,
@@ -19411,18 +19920,18 @@ 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 = join42(planDir, "plan.json");
+  const chunksJsonPath = join42(planDir, "meta", "chunks.json");
   if (!existsSync27(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
-  const plan2 = JSON.parse(readFileSync14(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync15(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
   if (!existsSync27(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
-  const chunks = JSON.parse(readFileSync14(chunksJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync15(chunksJsonPath, "utf-8"));
   if (chunkPaths.length !== chunks.length) {
     throw new Error(
       `[assemble] chunkPaths length (${chunkPaths.length}) does not match chunks.json length (${chunks.length}). Adapters must pass one path per chunk, ordered by index.`
@@ -19456,11 +19965,14 @@ function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
     "-r",
     fpsArg
   ];
+  if (encoder.keyframeIntervalFrames !== void 0)
+    args.push("-g", String(encoder.keyframeIntervalFrames));
+  appendRateCapArgs2(args, encoder);
   appendSoftwareEncoderThreadsArg(args, "libx264");
   return args;
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join41(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join42(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
@@ -19487,7 +19999,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join41(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join42(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -19527,9 +20039,9 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join41(workDir, "concat-list.txt");
+  const listPath = join42(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
-  writeFileSync12(listPath, `${body}
+  writeFileSync13(listPath, `${body}
 `, "utf-8");
   return ["-r", fpsArg, "-f", "concat", "-safe", "0", "-i", listPath];
 }
@@ -19544,7 +20056,7 @@ async function probeJoinedFrameInfo(videoPaths, fps, signal) {
   };
 }
 async function runAssembleFfmpeg(args, step, signal, timeout) {
-  const result = await runFfmpeg7(args, { signal, timeout });
+  const result = await runFfmpeg8(args, { signal, timeout });
   if (!result.success) {
     throw encoderFailureError(`[assemble] ffmpeg ${step} failed`, {
       error: describeFfmpegFailure4(result, timeout),
@@ -19565,13 +20077,13 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync14(join41(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync15(join42(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
-  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join42(planDir, "meta", "encoder.json");
   if (!existsSync27(encoderJsonPath)) return {};
-  return JSON.parse(readFileSync14(encoderJsonPath, "utf-8"));
+  return JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
   if (format !== "mp4") {
@@ -19579,11 +20091,11 @@ function readCfrEncoder(planDir, format) {
       `[assemble] cfr=true is only supported for format="mp4" (got "${format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
     );
   }
-  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join42(planDir, "meta", "encoder.json");
   if (!existsSync27(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
-  const encoderJson = JSON.parse(readFileSync14(encoderJsonPath, "utf-8"));
+  const encoderJson = JSON.parse(readFileSync15(encoderJsonPath, "utf-8"));
   if (encoderJson.encoder === "libx265-software") {
     throw new Error(
       `[assemble] cfr=true is not yet supported with codec: "h265". The cfr re-encode pass uses libx264 and would silently transcode the h265 chunks. Either disable cfr or render with codec: "h264".`
@@ -19592,11 +20104,11 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync27(outputPath)) rmSync17(outputPath, { recursive: true, force: true });
-  mkdirSync17(outputPath, { recursive: true });
+  if (existsSync27(outputPath)) rmSync16(outputPath, { recursive: true, force: true });
+  mkdirSync18(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
-    if (!statSync12(chunkDir).isDirectory()) {
+    if (!statSync13(chunkDir).isDirectory()) {
       throw new Error(
         `[assemble] png-sequence chunk must be a directory: ${chunkDir} (got a file)`
       );
@@ -19606,8 +20118,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 = join42(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join42(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -19617,13 +20129,13 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
     );
   }
   if (audioPath !== null && existsSync27(audioPath)) {
-    const sidecar = join41(outputPath, MIXED_AUDIO_FILENAME4);
+    const sidecar = join42(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
   for (const name of readdirSync10(outputPath)) {
     try {
-      fileSize += statSync12(join41(outputPath, name)).size;
+      fileSize += statSync13(join42(outputPath, name)).size;
     } catch {
     }
   }
@@ -19637,9 +20149,9 @@ 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 rmSync18, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync19, readFileSync as readFileSync16, readdirSync as readdirSync11, rmSync as rmSync17, writeFileSync as writeFileSync14 } from "node:fs";
 import { cpus as cpus3 } from "node:os";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 import {
   assertSwiftShader,
   BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE4,
@@ -19758,10 +20270,10 @@ async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBe
   return !await probe(session.page, timeoutMs, probeTick, session.beginFrameIntervalMs);
 }
 function hashChunkOutput(outputPath, kind) {
-  if (kind === "file") return sha256Hex(readFileSync15(outputPath));
+  if (kind === "file") return sha256Hex(readFileSync16(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(readFileSync16(join43(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -19778,16 +20290,16 @@ 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 = join43(planDir, "plan.json");
+  const encoderJsonPath = join43(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join43(planDir, "meta", "chunks.json");
   if (!existsSync28(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
     );
   }
-  const plan2 = JSON.parse(readFileSync15(planJsonPath, "utf-8"));
+  const plan2 = JSON.parse(readFileSync16(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.chunk);
   const planHashStarted = Date.now();
   const v2Materialization = readValidatedPlanV2Materialization(planDir, {
@@ -19804,13 +20316,13 @@ 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 encoder = JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
+  const chunks = JSON.parse(readFileSync16(chunksJsonPath, "utf-8"));
+  const videosJsonPath = join43(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync28(videosJsonPath)) {
     try {
-      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync15(videosJsonPath, "utf-8")));
+      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync16(videosJsonPath, "utf-8")));
     } catch (err) {
       if (err instanceof RenderChunkValidationError) throw err;
       throw new RenderChunkValidationError(
@@ -19838,7 +20350,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 = join43(planDir, "compiled");
   if (!existsSync28(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -19895,9 +20407,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       forceScreenshotExplicitlyOptedOut: !encoder.forceScreenshot
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
-    mkdirSync18(workDir, { recursive: true });
-    const framesDir = join42(workDir, "captured-frames");
-    mkdirSync18(framesDir, { recursive: true });
+    mkdirSync19(workDir, { recursive: true });
+    const framesDir = join43(workDir, "captured-frames");
+    mkdirSync19(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
     const chunkFps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
@@ -19921,7 +20433,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: readFileSync16(join43(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)
@@ -20050,10 +20562,10 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       const effectiveBitrate = encoder.crf != null ? void 0 : encoder.bitrate;
       const videoOnlyPath = encoder.chunksCarryAudio ? `${outputChunkPath}.video.mp4` : outputChunkPath;
       if (isPngSequence) {
-        if (!existsSync28(outputChunkPath)) mkdirSync18(outputChunkPath, { recursive: true });
+        if (!existsSync28(outputChunkPath)) mkdirSync19(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join42(outputChunkPath, "..");
-        if (!existsSync28(outDir)) mkdirSync18(outDir, { recursive: true });
+        const outDir = join43(outputChunkPath, "..");
+        if (!existsSync28(outDir)) mkdirSync19(outDir, { recursive: true });
       }
       const encodeInput = {
         job,
@@ -20092,7 +20604,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
         // first frame is an IDR keyframe and concat-copy at assemble time
         // round-trips losslessly.
         lockGopForChunkConcat: !isPngSequence,
-        gopSize: framesInChunk
+        gopSize: chunkGopFrames(framesInChunk, encoder.keyframeIntervalFrames),
+        maxBitrate: encoder.maxBitrate,
+        bufferSize: encoder.bufferSize
       };
       const captureStarted = Date.now();
       captureMode = await runCaptureWithScreenshotFallback({
@@ -20164,8 +20678,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           return observedChunkCaptureMode(capturePerfs);
         },
         resetForScreenshotRetry: () => {
-          rmSync18(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          mkdirSync18(framesDir, { recursive: true });
+          rmSync17(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          mkdirSync19(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
           job.framesRendered = 0;
@@ -20207,8 +20721,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
           timeoutMs: cfg.ffmpegProcessTimeout
         });
-        rmSync18(videoOnlyPath, { force: true });
-        rmSync18(audioScratchPath, { force: true });
+        rmSync17(videoOnlyPath, { force: true });
+        rmSync17(audioScratchPath, { force: true });
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
@@ -20255,11 +20769,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       producerVersion: plan2.producerVersion,
       ffmpegVersion
     };
-    writeFileSync13(perfPath, `${JSON.stringify(perfPayload, null, 2)}
+    writeFileSync14(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
-      rmSync18(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-      rmSync18(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,
@@ -20288,18 +20802,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(join44(tmpdir5(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join44(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath, options);
   } finally {
-    rmSync19(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(join44(tmpdir5(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join44(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -20314,7 +20828,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync19(workRoot, { recursive: true, force: true });
+    rmSync18(workRoot, { recursive: true, force: true });
   }
 }
 
@@ -20322,7 +20836,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
 var READ_CHUNK_BYTES = 256 * 1024;
 
 // src/services/distributed/audioSidecar.ts
-import { extractAudioMetadata as extractAudioMetadata4, runFfmpeg as runFfmpeg8 } from "@hyperframes/engine";
+import { extractAudioMetadata as extractAudioMetadata4, runFfmpeg as runFfmpeg9 } from "@hyperframes/engine";
 var AUDIO_SIDECAR_MIN_BYTES = 32 * 1024 * 1024;
 
 // src/services/distributed/probeFacts.ts
@@ -20386,6 +20900,7 @@ export {
   localizeRemoteImageSources,
   localizeRemoteMediaSources,
   materializePlanV2Target,
+  mediaProfileMatchesElementType,
   normalizeErrorMessage,
   parseRenderRequest,
   plan,
@@ -20393,6 +20908,7 @@ export {
   planV2WithPublisher,
   prepareAnimatedGifInputs,
   prepareCaptureSessionForReuse4 as prepareCaptureSessionForReuse,
+  prepareHeifImageInputs,
   prepareHyperframeLintBody,
   publishPlanV2FromExecutionPlan,
   publishPlanV2FromV1,