@hyperframes/producer 0.9.15 → 0.9.17

package/dist/index.js

@@ -9,12 +9,12 @@ import {
 // src/services/renderOrchestrator.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync10,
-  readdirSync as readdirSync5,
-  rmSync as rmSync10,
-  statSync as statSync8,
-  writeFileSync as writeFileSync6,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync12,
+  readdirSync as readdirSync6,
+  rmSync as rmSync12,
+  statSync as statSync9,
+  writeFileSync as writeFileSync7,
   copyFileSync as copyFileSync5,
   appendFileSync
 } from "fs";
@@ -29,16 +29,14 @@ import {
   toFps as toFps2
 } from "@hyperframes/core";
 import { HF_AUDIO_GROUP_TAG } from "@hyperframes/core/audio-groups";
-import { extractStandaloneEntryFromIndex, isTemplateEntry } from "@hyperframes/core/compiler";
 import { HTML_BODY_CSS_HEIGHT_FIRST_RE, HTML_BODY_CSS_WIDTH_FIRST_RE } from "@hyperframes/parsers";
-import { readTextFile as readTextFile2 } from "@hyperframes/parsers/asset-resolution";
 import {
   extractMediaMetadata as extractMediaMetadata4,
   resolveConfig as resolveConfig2,
   closeCaptureSession as closeCaptureSession8,
   createCaptureSession as createCaptureSession8,
   initializeSession as initializeSession8,
-  createVideoFrameInjector,
+  createVideoFrameInjector as createVideoFrameInjector2,
   getEncoderPreset as getEncoderPreset3,
   distributeFrames as distributeFrames2,
   distributeFramesInterleaved as distributeFramesInterleaved2,
@@ -62,13 +60,14 @@ import {
   isDrawElementCaptureError,
   getDrawElementVerificationDetails,
   augmentProtocolTimeoutError,
-  augmentPageNavigationTimeoutError
+  augmentPageNavigationTimeoutError,
+  displaySize
 } from "@hyperframes/engine";
 import {
   referenceBackgroundResult,
   createReferenceBackgroundRecorder
 } from "@hyperframes/engine";
-import { join as join28, dirname as dirname12, resolve as resolve8 } from "path";
+import { join as join31, dirname as dirname13, resolve as resolve8 } from "path";
 import { totalmem as totalmem2 } from "node:os";
 import { randomUUID } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -2017,6 +2016,7 @@ import {
   getCapturePerfSummary as getCapturePerfSummary2,
   initializeSession as initializeSession2,
   prepareCaptureSessionForReuse as prepareCaptureSessionForReuse2,
+  resolveDeVerifyMinDb as resolveDeVerifyMinDb2,
   shouldDisableBrowserPoolForParallelWorker,
   spawnStreamingEncoder as spawnStreamingEncoder2
 } from "@hyperframes/engine";
@@ -3887,42 +3887,47 @@ function createDrainFrameGuard(args) {
       sizes.push(buf.length);
       if (sizes.length > 60) sizes.shift();
     }
-    const truth = session.deVerifyFrames?.get(idx);
-    if (truth) {
-      let db;
-      try {
-        db = await psnrDb(buf, truth);
-      } catch (err) {
-        log.warn("[Render] drawElement self-verify sample skipped (psnr infrastructure)", {
-          frame: idx,
-          error: err instanceof Error ? err.message : String(err)
-        });
-        return buf;
-      }
-      if (db < verifyMinDb) {
-        const dumpDir = await mkdtemp(join9(tmpdir(), "hf-de-verify-fail-")).catch(() => null);
-        if (dumpDir) {
-          await Promise.all([
-            writeFile(join9(dumpDir, `frame-${idx}-de.jpg`), buf),
-            writeFile(join9(dumpDir, `frame-${idx}-truth.jpg`), truth)
-          ]).catch(() => {
-          });
-        }
-        throw new DrawElementVerificationError(
-          `drawElement self-verify failed at frame ${idx}: ${db.toFixed(1)}dB < ${verifyMinDb}dB vs pre-injection screenshot${dumpDir ? ` (pair: ${dumpDir})` : ""}`,
-          { kind: "psnr", frameIndex: idx, failedDb: db, verifyThresholdDb: verifyMinDb }
-        );
-      }
-      stats.verifyChecked += 1;
-      stats.verifyMinDb = stats.verifyMinDb === void 0 ? db : Math.min(stats.verifyMinDb, db);
-      log.info("[Render] drawElement self-verify passed", {
-        frame: idx,
-        psnrDb: db === Infinity ? "inf" : Number(db.toFixed(1))
-      });
-    }
+    await verifyDrawElementSample(session, idx, buf, { log, stats, verifyMinDb });
     return buf;
   };
 }
+async function verifyDrawElementSample(session, idx, buf, ctx) {
+  const { log, stats, verifyMinDb } = ctx;
+  const truth = session.deVerifyFrames?.get(idx);
+  if (!truth) return;
+  let db;
+  try {
+    db = await psnrDb(buf, truth);
+  } catch (err) {
+    log.warn("[Render] drawElement self-verify sample skipped (psnr infrastructure)", {
+      frame: idx,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  if (db < verifyMinDb) {
+    const dumpDir = await mkdtemp(join9(tmpdir(), "hf-de-verify-fail-")).catch(() => null);
+    if (dumpDir) {
+      await Promise.all([
+        writeFile(join9(dumpDir, `frame-${idx}-de.jpg`), buf),
+        writeFile(join9(dumpDir, `frame-${idx}-truth.jpg`), truth)
+      ]).catch(() => {
+      });
+    }
+    throw new DrawElementVerificationError(
+      `drawElement self-verify failed at frame ${idx}: ${db.toFixed(1)}dB < ${verifyMinDb}dB vs pre-injection screenshot${dumpDir ? ` (pair: ${dumpDir})` : ""}`,
+      { kind: "psnr", frameIndex: idx, failedDb: db, verifyThresholdDb: verifyMinDb }
+    );
+  }
+  if (stats) {
+    stats.verifyChecked += 1;
+    stats.verifyMinDb = stats.verifyMinDb === void 0 ? db : Math.min(stats.verifyMinDb, db);
+  }
+  log.info("[Render] drawElement self-verify passed", {
+    frame: idx,
+    psnrDb: db === Infinity ? "inf" : Number(db.toFixed(1))
+  });
+}
 async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEncoder, reorderBuffer, assertNotAborted, onProgress, log, stats, abortSignal, resume, risk) {
   let prev = null;
   const frameTime = (i) => i * job.config.fps.den / job.config.fps.num;
@@ -4386,6 +4391,7 @@ async function runCaptureStreamingStage(input) {
             );
           } else {
             const stallTimeoutMs = resolveCaptureStallTimeoutMs();
+            const verifyMinDb = resolveDeVerifyMinDb();
             let lastProgressAt = Date.now();
             for (let i = resume.from; i < totalFrames; i++) {
               assertNotAborted();
@@ -4402,6 +4408,7 @@ async function runCaptureStreamingStage(input) {
                 { session, frameIndex: i, totalFrames, stallTimeoutMs: budget },
                 abortSignal
               );
+              await verifyDrawElementSample(session, i, buffer, { log, verifyMinDb });
               await reorderBuffer.waitForFrame(i);
               ensureFrameWritten(await currentEncoder.writeFrame(buffer), i, currentEncoder);
               reorderBuffer.advanceTo(i + 1);
@@ -4510,6 +4517,10 @@ async function captureSegmentFrames(ctx, segment, encoder) {
       },
       ctx.abortSignal
     );
+    await verifyDrawElementSample(ctx.session, i, buffer, {
+      log: ctx.log,
+      verifyMinDb: ctx.verifyMinDb
+    });
     ensureFrameWritten(await encoder.writeFrame(buffer), i, encoder);
     ctx.job.framesRendered = i + 1;
     lastProgressAt = Date.now();
@@ -4524,6 +4535,25 @@ async function captureSegmentFrames(ctx, segment, encoder) {
   }
 }
 async function captureSegment(ctx, segment) {
+  const { frames } = ctx;
+  if (!frames) return captureSegmentToEncoder(ctx, segment);
+  try {
+    reportFrameProgress(
+      ctx.job,
+      `Reading video for segment ${segment.index + 1}/${ctx.segmentCount}`,
+      Math.round(25 + segment.startFrame / ctx.totalFrames * 55),
+      ctx.onProgress,
+      segment.startFrame,
+      ctx.totalFrames
+    );
+    await frames.prepare(segment);
+    ctx.assertNotAborted();
+    return await captureSegmentToEncoder(ctx, segment);
+  } finally {
+    frames.release();
+  }
+}
+async function captureSegmentToEncoder(ctx, segment) {
   const segmentPath = segmentOutputPath(ctx.segmentDir, segment.index);
   let encoder;
   try {
@@ -4576,16 +4606,16 @@ var DEFAULT_DEPS = {
 function defaultSessionFactory(input) {
   let probeSession = input.probeSession;
   return {
-    create: async () => {
+    create: async (injector = input.createRenderVideoFrameInjector) => {
       const probeCannotCaptureEveryFrame = Boolean(probeSession?.deRiskFrames?.size);
       if (probeSession && probeCannotCaptureEveryFrame) {
         await closeCaptureSession2(probeSession).catch(() => {
         });
         probeSession = null;
       }
-      const session = probeSession ?? await openSegmentedSession(input);
+      const session = probeSession ?? await openSegmentedSession(input, injector);
       if (probeSession) {
-        openSegmentedSessionReuse(input, probeSession);
+        openSegmentedSessionReuse(input, probeSession, injector);
         probeSession = null;
       }
       try {
@@ -4600,12 +4630,12 @@ function defaultSessionFactory(input) {
     }
   };
 }
-function openSegmentedSessionReuse(input, session) {
-  prepareCaptureSessionForReuse2(session, input.framesDir, input.createRenderVideoFrameInjector());
+function openSegmentedSessionReuse(input, session, injector) {
+  prepareCaptureSessionForReuse2(session, input.framesDir, injector());
 }
-async function openSegmentedSession(input) {
+async function openSegmentedSession(input, injector) {
   const captureCfg = input.cfg.forceScreenshot === input.plan.forceScreenshot ? input.cfg : { ...input.cfg, forceScreenshot: input.plan.forceScreenshot };
-  const videoInjector = input.createRenderVideoFrameInjector();
+  const videoInjector = injector();
   const captureOptions = { ...input.buildCaptureOptions(), deFrameFallback: false };
   const ownBrowser = shouldDisableBrowserPoolForParallelWorker({
     parallel: (input.workerCount ?? 1) > 1
@@ -4618,6 +4648,19 @@ async function openSegmentedSession(input) {
     ownBrowser ? { ...captureCfg, enableBrowserPool: false } : captureCfg
   );
 }
+function removeJoinedSegments(run, segmentPaths) {
+  if (!run.input.segmentVideoFrames || run.input.job.config.keepSegments === true) return;
+  for (const path of segmentPaths) {
+    try {
+      run.deps.removeFile(path);
+    } catch (err) {
+      run.input.log.warn("[Render] could not remove a joined segment file", {
+        path,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
 async function concatSegments(concat, segmentPaths, videoOnlyPath, abortSignal, cfg) {
   const result = await concat(segmentPaths, videoOnlyPath, abortSignal, cfg);
   if (result.success) return;
@@ -4629,12 +4672,14 @@ async function concatSegments(concat, segmentPaths, videoOnlyPath, abortSignal,
 async function createSegmentWorker(run, id) {
   const { input, deps } = run;
   const factory = input.sessionFactoryForWorker?.(id) ?? run.sessionFactory;
+  const frames = input.segmentVideoFrames?.forWorker();
   return {
     id,
     factory,
     sessionSegments: 0,
     ctx: {
-      session: await factory.create(),
+      session: await factory.create(frames && (() => frames.hook)),
+      frames,
       job: input.job,
       cfg: input.cfg,
       totalFrames: input.totalFrames,
@@ -4645,6 +4690,8 @@ async function createSegmentWorker(run, id) {
       spawnEncoder: deps.spawnEncoder,
       captureFrame: deps.captureFrame,
       stallTimeoutMs: resolveCaptureStallTimeoutMs(),
+      log: input.log,
+      verifyMinDb: resolveDeVerifyMinDb2(),
       abortSignal: input.abortSignal,
       assertNotAborted: input.assertNotAborted,
       onProgress: input.onProgress,
@@ -4664,7 +4711,8 @@ async function recycleWorkerSession(run, worker, why) {
   run.input.dedupPerfs.push(getCapturePerfSummary2(worker.ctx.session));
   const memory = worker.ctx.session.chromeMemory?.stats();
   await run.deps.closeSession(worker.ctx.session);
-  worker.ctx.session = await worker.factory.create();
+  const { frames } = worker.ctx;
+  worker.ctx.session = await worker.factory.create(frames && (() => frames.hook));
   worker.sessionSegments = 0;
   if (why === "cadence") run.totals.browserRecycles += 1;
   run.input.log.info(`[Render] segment browser recycled (${why})`, {
@@ -4732,6 +4780,7 @@ async function concatResumedRun(run, segmentPaths) {
     input.abortSignal,
     input.cfg
   );
+  removeJoinedSegments(run, segmentPaths);
   return {
     success: true,
     encodeMs: 0,
@@ -4806,6 +4855,7 @@ async function runCaptureSegmentedStage(input) {
     input.abortSignal,
     input.cfg
   );
+  removeJoinedSegments(run, segmentPaths);
   return {
     success: true,
     encodeMs: run.totals.encodeMs,
@@ -5237,10 +5287,273 @@ function checkPageNeverReady(input) {
   return new PageNeverReadyError(error);
 }
 
+// src/services/render/deferredVideoFrames.ts
+import { mkdirSync as mkdirSync4, rmSync as rmSync7 } from "node:fs";
+import { dirname as dirname5, join as join12 } from "node:path";
+import {
+  createFrameLookupTable,
+  extractVideoFramesRange,
+  runVideoExtractionWithRetry
+} from "@hyperframes/engine";
+function contiguousRuns(sortedIndexes) {
+  const runs2 = [];
+  for (const index of sortedIndexes) {
+    const last = runs2[runs2.length - 1];
+    if (last && last.firstFrame + last.frames === index) last.frames++;
+    else runs2.push({ firstFrame: index, frames: 1 });
+  }
+  return runs2;
+}
+function shownDeferredFrameIndexes(source, frames, fps) {
+  const shown = /* @__PURE__ */ new Map();
+  const deferred = source.extracted.filter((video) => video.deferredRange);
+  if (deferred.length === 0) return shown;
+  const table = createFrameLookupTable(
+    source.videos,
+    deferred.map((video) => ({
+      ...video,
+      outputDir: "",
+      framePaths: new Map(Array.from({ length: video.totalFrames }, (_, i) => [i, String(i)]))
+    })),
+    resolveRenderFpsConfig(fps).value
+  );
+  for (const frame of frames) {
+    const globalTime = frame * fps.den / fps.num;
+    for (const [videoId, payload] of table.getActiveFramePayloads(globalTime)) {
+      const indexes = shown.get(videoId) ?? /* @__PURE__ */ new Set();
+      indexes.add(payload.frameIndex);
+      shown.set(videoId, indexes);
+    }
+  }
+  return shown;
+}
+async function extractDeferredFrames(input) {
+  const deferred = input.extracted.filter((video) => video.deferredRange);
+  if (deferred.length === 0) return [];
+  const shown = shownDeferredFrameIndexes(input, input.frames, input.fps);
+  return Promise.all(
+    deferred.map(async (video) => {
+      const outputDir = join12(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 extracted = await extractVideoFramesRange(
+        input.sourceOf(video),
+        video.videoId,
+        range.startTime,
+        range.durationSeconds,
+        {
+          fps: input.fps,
+          outputDir: input.outputRoot,
+          format: range.format,
+          frameRanges: contiguousRuns(indexes),
+          shownBox: input.shownBoxes?.get(video.videoId)
+        },
+        input.signal,
+        input.cfg
+      );
+      const missing = indexes.find((index) => !extracted.framePaths.has(index));
+      if (missing !== void 0) throw input.onMissingFrame(video, missing);
+      return { ...video, outputDir, framePaths: extracted.framePaths, ownedByLookup: false };
+    })
+  );
+}
+async function extractAllDeferredFrames(extracted, input) {
+  const framesTotal = extracted.reduce(
+    (sum2, video) => sum2 + (video.deferredRange ? video.totalFrames : 0),
+    0
+  );
+  let framesDone = 0;
+  for (const video of extracted) {
+    const range = video.deferredRange;
+    if (!range) continue;
+    const { result: filled } = await runVideoExtractionWithRetry(
+      () => extractVideoFramesRange(
+        input.sourceOf?.(video) ?? video.srcPath,
+        video.videoId,
+        range.startTime,
+        range.durationSeconds,
+        { fps: input.fps, outputDir: dirname5(video.outputDir), format: range.format },
+        input.signal,
+        input.cfg
+      ),
+      {
+        signal: input.signal,
+        maxTransientRetries: input.maxTransientRetries,
+        onRetry: () => {
+          rmSync7(video.outputDir, { recursive: true, force: true });
+          mkdirSync4(video.outputDir, { recursive: true });
+        }
+      }
+    );
+    if (filled.framePaths.size < video.totalFrames) {
+      throw new Error(
+        `[Render] video ${JSON.stringify(video.videoId)} has ${filled.framePaths.size} frames; it was expected to have ${video.totalFrames} frames.`
+      );
+    }
+    video.framePaths = filled.framePaths;
+    delete video.deferredRange;
+    framesDone += video.totalFrames;
+    input.onProgress?.(framesDone, framesTotal);
+  }
+}
+
+// src/services/render/segmentVideoFrames.ts
+import { mkdirSync as mkdirSync5, rmSync as rmSync8 } from "node:fs";
+import { join as join13 } from "node:path";
+import {
+  createFrameLookupTable as createFrameLookupTable2,
+  createVideoFrameInjector
+} from "@hyperframes/engine";
+function segmentFramesDir(rootDir, index) {
+  return join13(rootDir, "segment-frames", `segment_${String(index).padStart(5, "0")}`);
+}
+function createSegmentVideoFrames(input) {
+  const extractFrames = input.extractFrames ?? extractDeferredFrames;
+  const sourceOf = input.sourceOf ?? ((video) => video.srcPath);
+  const fullyExtracted = input.extracted.filter((video) => !video.deferredRange);
+  const tableFor = async (frames, dir) => {
+    const sliced = await extractFrames({
+      videos: input.videos,
+      extracted: input.extracted,
+      frames,
+      fps: input.fps,
+      outputRoot: dir,
+      cfg: input.cfg,
+      signal: input.abortSignal,
+      sourceOf,
+      onMissingFrame: (video, index) => new Error(
+        `[Render] video ${JSON.stringify(video.videoId)} has no frame ${index}; it was expected to have ${video.totalFrames} frames.`
+      )
+    });
+    return createFrameLookupTable2(
+      input.videos,
+      [...fullyExtracted, ...sliced],
+      resolveRenderFpsConfig(input.fps).value
+    );
+  };
+  const injectorFor = async (frames, dir) => createVideoFrameInjector(await tableFor(frames, dir), input.injectorOptions);
+  let onDemandCalls = 0;
+  const onDemandHook = () => Object.assign(
+    async (page, time, heldVideoTime) => {
+      const dir = join13(
+        input.rootDir,
+        "segment-frames",
+        `on-demand_${String(onDemandCalls++).padStart(5, "0")}`
+      );
+      try {
+        const frames = [time, heldVideoTime].filter((t) => t !== void 0).map((t) => Math.round(t * input.fps.num / input.fps.den));
+        const injector = await injectorFor(frames, dir);
+        await injector?.(page, time, heldVideoTime);
+      } finally {
+        rmSync8(dir, { recursive: true, force: true });
+      }
+    },
+    { fresh: onDemandHook }
+  );
+  return {
+    async forFrames(frames, name) {
+      const dir = join13(input.rootDir, "segment-frames", name);
+      const release = () => rmSync8(dir, { recursive: true, force: true });
+      try {
+        release();
+        mkdirSync5(dir, { recursive: true });
+        const table = await tableFor([...frames], dir);
+        return { injector: () => createVideoFrameInjector(table, input.injectorOptions), release };
+      } catch (error) {
+        release();
+        throw error;
+      }
+    },
+    forWorker() {
+      let injector = null;
+      let folder = null;
+      const onDemand = onDemandHook();
+      const release = () => {
+        injector = null;
+        if (folder) rmSync8(folder, { recursive: true, force: true });
+        folder = null;
+      };
+      return {
+        hook: Object.assign(
+          (page, time, heldVideoTime) => (injector ?? onDemand)(page, time, heldVideoTime),
+          { fresh: onDemandHook }
+        ),
+        release,
+        async prepare(segment) {
+          release();
+          const dir = segmentFramesDir(input.rootDir, segment.index);
+          folder = dir;
+          try {
+            rmSync8(dir, { recursive: true, force: true });
+            mkdirSync5(dir, { recursive: true });
+            injector = await injectorFor(
+              Array.from(
+                { length: segment.endFrame - segment.startFrame },
+                (_, i) => segment.startFrame + i
+              ),
+              dir
+            );
+          } catch (error) {
+            release();
+            throw error;
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/services/render/videoFrameWindow.ts
+import { readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+import { join as join14 } from "node:path";
+function shouldWindowVideoFrames(args) {
+  return args.segmented && args.env.HF_VIDEO_FRAME_WINDOW?.trim().toLowerCase() === "true";
+}
+function directoryBytes(path) {
+  let bytes = 0;
+  let entries;
+  try {
+    entries = readdirSync3(path, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const child3 = join14(path, entry.name);
+    try {
+      bytes += entry.isDirectory() ? directoryBytes(child3) : statSync4(child3).size;
+    } catch {
+    }
+  }
+  return bytes;
+}
+function trackSegmentFramePeak(frames, rootDir, onPeak) {
+  let peak = 0;
+  return {
+    forFrames: (frameIndexes, name) => frames.forFrames(frameIndexes, name),
+    forWorker() {
+      const worker = frames.forWorker();
+      return {
+        ...worker,
+        async prepare(segment) {
+          await worker.prepare(segment);
+          const held = directoryBytes(join14(rootDir, "segment-frames"));
+          if (held > peak) {
+            peak = held;
+            onPeak(peak);
+          }
+        }
+      };
+    }
+  };
+}
+
 // src/services/render/segmentManifest.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync4, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join15 } from "node:path";
 import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
 var MANIFEST_FILENAME = "segments.json";
 function computeSegmentPlanHash(input) {
@@ -5268,7 +5581,7 @@ function computeSegmentPlanHash(input) {
   return createHash2("sha256").update(ordered.join(" ")).digest("hex").slice(0, 16);
 }
 function segmentDirFor(projectRendersDir, planHash) {
-  return join12(projectRendersDir, ".hf-segments", planHash);
+  return join15(projectRendersDir, ".hf-segments", planHash);
 }
 function hasNumber(value, key) {
   return key in value && typeof Reflect.get(value, key) === "number";
@@ -5286,7 +5599,7 @@ function isManifest(value) {
   return Reflect.get(value, "version") === 1 && hasString(value, "planHash") && hasNumber(value, "totalFrames") && hasNumber(value, "segmentFrames") && Array.isArray(completed) && completed.every(isEntry);
 }
 function readSegmentManifest(segmentDir) {
-  const path = join12(segmentDir, MANIFEST_FILENAME);
+  const path = join15(segmentDir, MANIFEST_FILENAME);
   if (!existsSync7(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf-8"));
@@ -5296,10 +5609,10 @@ function readSegmentManifest(segmentDir) {
   }
 }
 function writeSegmentManifest(segmentDir, manifest) {
-  mkdirSync4(segmentDir, { recursive: true });
-  const tmp = join12(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
+  mkdirSync6(segmentDir, { recursive: true });
+  const tmp = join15(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
   writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
-  renameWithRetry2(tmp, join12(segmentDir, MANIFEST_FILENAME));
+  renameWithRetry2(tmp, join15(segmentDir, MANIFEST_FILENAME));
 }
 async function probeSegmentFrameCount(path, probe) {
   try {
@@ -5317,7 +5630,7 @@ async function validateCompletedSegments(manifest, expectedHash, probeFrames) {
   if (manifest.planHash !== expectedHash) return ok;
   for (const entry of manifest.completed) {
     if (!existsSync7(entry.path)) continue;
-    const size = statSync4(entry.path).size;
+    const size = statSync5(entry.path).size;
     if (size <= 0 || size !== entry.bytes) continue;
     const frames = await probeFrames(entry.path);
     if (frames !== entry.endFrame - entry.startFrame) continue;
@@ -5860,7 +6173,7 @@ function computeVideoFrameCoverage(videos, extracted, fps) {
   for (const video of videos) {
     const entry = byId.get(video.id);
     const expectedFrames = expectedFramesForVideo(video, entry, fps);
-    const capturedFrames = entry ? entry.framePaths.size : 0;
+    const capturedFrames = entry ? entry.deferredRange ? entry.totalFrames : entry.framePaths.size : 0;
     const ratio = expectedFrames === 0 ? 1 : capturedFrames / expectedFrames;
     reports.push({
       videoId: video.id,
@@ -5895,14 +6208,17 @@ function countAuthoredTimedClips(html) {
 }
 
 // src/services/render/stages/compileStage.ts
-import { join as join16 } from "node:path";
+import { existsSync as existsSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join19 } from "node:path";
 import { suggestMatchingPreset } from "@hyperframes/core";
+import { extractStandaloneEntryFromIndex, isTemplateEntry } from "@hyperframes/core/compiler";
+import { readTextFile as readTextFile2 } from "@hyperframes/parsers/asset-resolution";
 
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
 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 { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join18, dirname as dirname8, resolve as resolve7, basename as basename4, relative as relative2 } from "path";
 import { parseHTML as parseHTML5 } from "linkedom";
 import {
   COMPOSITION_SOURCE_URL,
@@ -6148,8 +6464,8 @@ import {
 
 // src/services/animatedGifPrep.ts
 import { createHash as createHash4 } from "node:crypto";
-import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync7, statSync as statSync5 } from "node:fs";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join13, resolve as resolve5 } from "node:path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync5, rmSync as rmSync9, statSync as statSync6 } from "node:fs";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join16, resolve as resolve5 } from "node:path";
 import { parseHTML as parseHTML3 } from "linkedom";
 import { parseAnimatedGifMetadata } from "@hyperframes/core";
 import { DEFAULT_VP9_CPU_USED, runFfmpeg as runFfmpeg2, renameWithRetry as renameWithRetry3 } from "@hyperframes/engine";
@@ -6198,7 +6514,7 @@ function resolveLocalImageSourcePath(src, options) {
 }
 function isUsableFile(path) {
   try {
-    const stat = statSync5(path);
+    const stat = statSync6(path);
     return stat.isFile() && stat.size > 0;
   } catch {
     return false;
@@ -6305,11 +6621,11 @@ async function runAnimatedGifTranscode(request) {
   throw result.error ?? new Error(`Animated GIF transcode failed (${result.exitCode}): ${result.stderr.slice(-500)}`);
 }
 async function ensurePreparedWebm(input) {
-  if (!existsSync8(dirname5(input.cachePath))) {
-    mkdirSync5(dirname5(input.cachePath), { recursive: true });
+  if (!existsSync8(dirname6(input.cachePath))) {
+    mkdirSync7(dirname6(input.cachePath), { recursive: true });
   }
-  if (!existsSync8(dirname5(input.outputPath))) {
-    mkdirSync5(dirname5(input.outputPath), { recursive: true });
+  if (!existsSync8(dirname6(input.outputPath))) {
+    mkdirSync7(dirname6(input.outputPath), { recursive: true });
   }
   if (!isUsableFile(input.cachePath)) {
     const tmpPath = `${input.cachePath}.tmp-${process.pid}-${Date.now()}`;
@@ -6333,10 +6649,10 @@ async function ensurePreparedWebm(input) {
       if (!isUsableFile(input.cachePath)) {
         renameWithRetry3(tmpPath, input.cachePath);
       } else {
-        rmSync7(tmpPath, { force: true });
+        rmSync9(tmpPath, { force: true });
       }
     } catch (error) {
-      rmSync7(tmpPath, { force: true });
+      rmSync9(tmpPath, { force: true });
       throw error;
     }
   }
@@ -6392,7 +6708,7 @@ function replaceImageWithVideo(input) {
   return video;
 }
 async function prepareAnimatedGifInputs(html, options) {
-  const outputDir = options.outputDir ?? join13(options.downloadDir, PREPARED_GIF_SUBDIR);
+  const outputDir = options.outputDir ?? join16(options.downloadDir, PREPARED_GIF_SUBDIR);
   const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_GIF_SUBDIR);
   const cacheDir = options.cacheDir ?? outputDir;
   const { document: document2 } = parseHTML3(html);
@@ -6419,8 +6735,8 @@ async function prepareAnimatedGifInputs(html, options) {
     );
     const hash = computePreparedGifHash(bytes, loopIterations, padSeconds);
     const filename = `${CACHE_SCHEMA}-${hash.slice(0, 24)}.webm`;
-    const cachePath = join13(cacheDir, filename);
-    const outputPath = join13(outputDir, filename);
+    const cachePath = join16(cacheDir, filename);
+    const outputPath = join16(outputDir, filename);
     const outputSrc = `${outputSrcPrefix}/${filename}`;
     await ensurePreparedWebm({
       sourcePath,
@@ -6457,15 +6773,15 @@ import { createHash as createHash5 } from "node:crypto";
 import {
   closeSync as closeSync4,
   copyFileSync as copyFileSync3,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync8,
   openSync as openSync4,
   readFileSync as readFileSync6,
   readSync as readSync3,
-  rmSync as rmSync8,
-  statSync as statSync6,
+  rmSync as rmSync10,
+  statSync as statSync7,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname6, join as join14, resolve as resolve6 } from "node:path";
+import { dirname as dirname7, join as join17, resolve as resolve6 } from "node:path";
 import { parseHTML as parseHTML4 } from "linkedom";
 import { renameWithRetry as renameWithRetry4, runFfmpeg as runFfmpeg3, runFfprobe } from "@hyperframes/engine";
 
@@ -6705,14 +7021,14 @@ function resolveImageSource(src, options) {
 }
 function isUsableFile2(path) {
   try {
-    return statSync6(path).size > 0;
+    return statSync7(path).size > 0;
   } catch {
     return false;
   }
 }
 async function ensurePreparedJpeg(source, cachePath, outputPath, options) {
-  mkdirSync6(dirname6(cachePath), { recursive: true });
-  mkdirSync6(dirname6(outputPath), { recursive: true });
+  mkdirSync8(dirname7(cachePath), { recursive: true });
+  mkdirSync8(dirname7(outputPath), { recursive: true });
   if (!isUsableFile2(cachePath)) {
     const tmpPath = `${cachePath}.tmp-${process.pid}-${Date.now()}`;
     const inlinePath = `${tmpPath}.heic`;
@@ -6730,8 +7046,8 @@ async function ensurePreparedJpeg(source, cachePath, outputPath, options) {
       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 });
+      rmSync10(tmpPath, { force: true });
+      rmSync10(inlinePath, { force: true });
     }
   }
   if (resolve6(outputPath) !== resolve6(cachePath) && !isUsableFile2(outputPath)) {
@@ -6739,7 +7055,7 @@ async function ensurePreparedJpeg(source, cachePath, outputPath, options) {
   }
 }
 async function prepareHeifImageInputs(html, options) {
-  const outputDir = options.outputDir ?? join14(options.downloadDir, PREPARED_HEIF_SUBDIR);
+  const outputDir = options.outputDir ?? join17(options.downloadDir, PREPARED_HEIF_SUBDIR);
   const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_HEIF_SUBDIR);
   const cacheDir = options.cacheDir ?? outputDir;
   const preparedAssets = /* @__PURE__ */ new Map();
@@ -6760,7 +7076,7 @@ async function prepareHeifImageInputs(html, options) {
   await Promise.all(
     [...unique].map(
       ([filename, source]) => withMediaProbeSlot(
-        () => ensurePreparedJpeg(source, join14(cacheDir, filename), join14(outputDir, filename), options)
+        () => ensurePreparedJpeg(source, join17(cacheDir, filename), join17(outputDir, filename), options)
       ).catch((error) => {
         if (!options.onFailure) throw error;
         failed.add(filename);
@@ -6772,8 +7088,8 @@ async function prepareHeifImageInputs(html, options) {
     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) });
+    preparedAssets.set(outputSrc, join17(outputDir, filename));
+    preparedImages.push({ sourceSrc: src, outputSrc, outputPath: join17(outputDir, filename) });
   }
   return { html: document2.toString(), preparedAssets, preparedImages };
 }
@@ -7097,8 +7413,8 @@ function detectShaderTransitionUsage(html) {
 async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, downloadDir, tagName, elementIdentity, log, urlByAbsentLocalPath, probes) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    const remoteDir = join15(downloadDir, REMOTE_MEDIA_SUBDIR);
-    if (!existsSync10(remoteDir)) mkdirSync7(remoteDir, { recursive: true });
+    const remoteDir = join18(downloadDir, REMOTE_MEDIA_SUBDIR);
+    if (!existsSync10(remoteDir)) mkdirSync9(remoteDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, remoteDir, void 0, void 0, void 0, {
         onTelemetry: logRemoteDownloadTelemetry
@@ -7108,7 +7424,7 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
     }
   } else {
     filePath = decodedUrlPath(src);
-    if (!filePath.startsWith("/")) filePath = join15(baseDir, filePath);
+    if (!filePath.startsWith("/")) filePath = join18(baseDir, filePath);
     filePath = urlByAbsentLocalPath?.get(filePath) ?? filePath;
   }
   if (!isHttpUrl(filePath) && !existsSync10(filePath)) {
@@ -7269,7 +7585,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     workItems.map(async (item) => {
       const { html: compiledSub } = await compileHtmlFile(
         rewriteUnresolvableGsapToCdn(item.rawSubHtml, projectDir, item.srcPath),
-        dirname7(item.filePath),
+        dirname8(item.filePath),
         downloadDir,
         void 0,
         urlByAbsentLocalPath,
@@ -7699,7 +8015,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)) mkdirSync7(remoteDir, { recursive: true });
+  if (!existsSync10(remoteDir)) mkdirSync9(remoteDir, { recursive: true });
   const urlToLocal = /* @__PURE__ */ new Map();
   await Promise.all(
     [...urlSet].map(async (url) => {
@@ -7746,7 +8062,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote media download failed",
     "Localized remote media source(s)"
   );
@@ -7761,7 +8077,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote image download failed",
     "Localized remote image source(s)"
   );
@@ -7777,7 +8093,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
@@ -7887,7 +8203,7 @@ function projectStylesheetFontFamilies(html, projectDir) {
       const family = /font-family\s*:\s*([^;}]+)/i.exec(face)?.[1]?.trim().replace(/^['"]|['"]$/g, "");
       const shipsFile = [...face.matchAll(LOCAL_FONTFACE_URL_RE)].some(([, url = ""]) => {
         const path = decodedUrlPath(url);
-        const file = path.startsWith("/") ? resolve7(projectDir, `.${path}`) : resolve7(dirname7(sheet), path);
+        const file = path.startsWith("/") ? resolve7(projectDir, `.${path}`) : resolve7(dirname8(sheet), path);
         return isPathInside2(file, projectDir) && existsSync10(file);
       });
       if (family && shipsFile) families.push(family);
@@ -7932,7 +8248,7 @@ function localizeFontFaceUrls(html, downloadDir) {
   return downloadAndRewriteUrls(
     collectFontFaceUrls(html),
     html,
-    join15(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
     (h, url, relPath) => h.replaceAll(`url(${url})`, `url("${relPath}")`)
@@ -8604,11 +8920,36 @@ function adaptAspectAgnosticResolution(requested, aspectAgnostic, width, height,
   });
   return flipped;
 }
+function resolveEntryHtmlPath(input) {
+  const { projectDir, workDir, entryFile, log } = input;
+  const htmlPath = join19(projectDir, entryFile);
+  const rawEntry = readTextFile2(htmlPath);
+  if (entryFile === "index.html" || !isTemplateEntry(rawEntry)) return htmlPath;
+  const projectIndexPath = join19(projectDir, "index.html");
+  if (!existsSync11(projectIndexPath)) {
+    throw new Error(
+      `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
+    );
+  }
+  const standaloneHtml = extractStandaloneEntryFromIndex(
+    readTextFile2(projectIndexPath),
+    entryFile,
+    rawEntry
+  );
+  if (!standaloneHtml) {
+    throw new Error(
+      `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
+    );
+  }
+  const wrapperPath = join19(workDir, "standalone-entry.html");
+  writeFileSync5(wrapperPath, standaloneHtml, "utf-8");
+  log.info("Extracted standalone entry from index.html host context", { entryFile });
+  return wrapperPath;
+}
 async function runCompileStage(input) {
   const {
     projectDir,
     workDir,
-    htmlPath,
     entryFile,
     job,
     cfg,
@@ -8619,8 +8960,9 @@ async function runCompileStage(input) {
     allowSystemFontCapture,
     abortSignal
   } = input;
+  const htmlPath = resolveEntryHtmlPath({ projectDir, workDir, entryFile, log });
   const compileStart = Date.now();
-  const compiled = await compileForRender(projectDir, htmlPath, join16(workDir, "downloads"), {
+  const compiled = await compileForRender(projectDir, htmlPath, join19(workDir, "downloads"), {
     log,
     failClosedFontFetch: failClosedFontFetch === true,
     allowSystemFontCapture,
@@ -8628,7 +8970,7 @@ async function runCompileStage(input) {
     variables: input.variables,
     urlByAbsentLocalPath: input.urlByAbsentLocalPath,
     pageMotionBlur: input.pageMotionBlur,
-    animatedGifCacheDir: cfg.extractCacheDir ? join16(cfg.extractCacheDir, "animated-gif") : void 0,
+    animatedGifCacheDir: cfg.extractCacheDir ? join19(cfg.extractCacheDir, "animated-gif") : void 0,
     ffmpegProcessTimeout: cfg.ffmpegProcessTimeout
   });
   assertNotAborted();
@@ -8685,7 +9027,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join16(workDir, "compiled"),
+    compiledDir: join19(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -8731,7 +9073,7 @@ async function runCompileStage(input) {
 
 // src/services/render/stages/probeStage.ts
 import { createHash as createHash7 } from "node:crypto";
-import { basename as basename5, join as join17 } from "node:path";
+import { basename as basename5, join as join20 } from "node:path";
 import { parseHTML as parseHTML6 } from "linkedom";
 import {
   closeCaptureSession as closeCaptureSession4,
@@ -8940,7 +9282,7 @@ async function runProbeStage(input) {
       });
       fileServer = await createFileServer({
         projectDir,
-        compiledDir: join17(workDir, "compiled"),
+        compiledDir: join20(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM],
         fps: job.config.fps
@@ -8970,7 +9312,7 @@ async function runProbeStage(input) {
           log.info("Creating capture session...", { attempt, maxAttempts: PROBE_MAX_ATTEMPTS });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join17(workDir, "probe"),
+            join20(workDir, "probe"),
             captureOpts,
             null,
             probeCfg
@@ -9055,7 +9397,7 @@ async function runProbeStage(input) {
           });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join17(workDir, "probe-screenshot"),
+            join20(workDir, "probe-screenshot"),
             captureOpts,
             null,
             { ...probeCfg, forceScreenshot: true }
@@ -9093,7 +9435,7 @@ async function runProbeStage(input) {
             compiled,
             resolutions,
             projectDir,
-            join17(workDir, "downloads")
+            join20(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -9284,7 +9626,7 @@ async function runProbeStage(input) {
     }
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join17(workDir, "compiled"),
+      compiledDir: join20(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -9450,11 +9792,11 @@ function validateDistributedDuration(input) {
 }
 
 // src/services/render/stages/extractVideosStage.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join21 } from "node:path";
 import {
   classifyVideoExtractionError,
-  createFrameLookupTable,
+  createFrameLookupTable as createFrameLookupTable3,
   detectTransfer,
   extractAllVideoFrames,
   extractMediaMetadata as extractMediaMetadata3,
@@ -9466,7 +9808,7 @@ import {
   resolveVideoExtractionWindow as resolveVideoExtractionWindow2,
   isHttpUrl as isHttpUrl2,
   resolveProjectRelativeSrc as resolveProjectRelativeSrc3,
-  runVideoExtractionWithRetry,
+  runVideoExtractionWithRetry as runVideoExtractionWithRetry2,
   safeVideoExtractionSourceIdentity,
   videoAudioId as videoAudioId2
 } from "@hyperframes/engine";
@@ -9725,9 +10067,9 @@ async function runExtractVideosStage(input) {
     const probeFailures = await Promise.all(
       composition.videos.map(async (v) => {
         const videoPath = resolveProjectRelativeSrc3(v.src, projectDir, compiledDir);
-        if (!existsSync11(videoPath)) return null;
+        if (!existsSync12(videoPath)) return null;
         try {
-          const attempted = extractionPolicy.maxTransientRetries === 0 ? { result: await extractMediaMetadata3(videoPath), retries: 0 } : await runVideoExtractionWithRetry(() => extractMediaMetadata3(videoPath), {
+          const attempted = extractionPolicy.maxTransientRetries === 0 ? { result: await extractMediaMetadata3(videoPath), retries: 0 } : await runVideoExtractionWithRetry2(() => extractMediaMetadata3(videoPath), {
             signal: abortSignal,
             maxTransientRetries: extractionPolicy.maxTransientRetries,
             onRetry: () => {
@@ -9763,7 +10105,7 @@ async function runExtractVideosStage(input) {
     const probed = await Promise.all(
       composition.images.map(async (img) => {
         const imgPath = resolveProjectRelativeSrc3(img.src, projectDir, compiledDir);
-        if (!existsSync11(imgPath)) return null;
+        if (!existsSync12(imgPath)) return null;
         const colorSpace = await probeColorSpaceSafely(imgPath, log);
         if (isHdrColorSpace2(colorSpace)) {
           nativeHdrImageIds.add(img.id);
@@ -9797,14 +10139,14 @@ async function runExtractVideosStage(input) {
       // because short boundary counts can differ by one frame.
       {
         fps: job.config.fps,
-        outputDir: join18(compiledDir, "__hyperframes_video_frames"),
+        outputDir: join21(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
         toneMapHdrToSdr: rendersSdrOnly(job.config, composition),
         timelineEnd: composition.duration,
         maxTransientRetries: extractionPolicy.maxTransientRetries,
         collectProbeFailures: extractionPolicy.failureMode === "enforce",
         deferRangeExtraction,
-        contentKeyedDirs: [join18(compiledDir, REMOTE_MEDIA_SUBDIR)],
+        contentKeyedDirs: [join21(compiledDir, REMOTE_MEDIA_SUBDIR)],
         urlByAbsentLocalPath,
         onProgress: ({ planned = 0, done = 0 }) => {
           framesPlanned += planned;
@@ -9824,7 +10166,7 @@ async function runExtractVideosStage(input) {
       materializeSymlinks
     });
     if (extractionResult.extracted.length > 0) {
-      frameLookup = createFrameLookupTable(
+      frameLookup = createFrameLookupTable3(
         composition.videos,
         extractionResult.extracted,
         resolveRenderFpsConfig(job.config.fps).value
@@ -9883,7 +10225,7 @@ async function appendVideoAudioFromProbe(input) {
     videos.map(async (video) => {
       const path = isHttpUrl2(video.src) ? video.src : resolveProjectRelativeSrc3(video.src, projectDir, compiledDir);
       const readFrom = urlByAbsentLocalPath?.get(path) ?? path;
-      if (!isHttpUrl2(readFrom) && !existsSync11(readFrom)) return null;
+      if (!isHttpUrl2(readFrom) && !existsSync12(readFrom)) return null;
       const metadata = await extractMediaMetadata3(readFrom);
       const window2 = await resolveFinalFrameExtractionWindow2(
         readFrom,
@@ -9903,7 +10245,7 @@ async function appendVideoAudioFromProbe(input) {
 }
 
 // src/services/render/videoLayerPassthroughPlan.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import {
   buildVideoLayerInput,
   isHttpUrl as isHttpUrl3,
@@ -9971,7 +10313,7 @@ async function planVideoLayerPassthrough(input) {
   const { video } = q;
   if (isHttpUrl3(video.src)) return { reason: "remote_source" };
   const path = resolveProjectRelativeSrc4(video.src, input.projectDir, input.compiledDir);
-  if (!existsSync12(path)) return { reason: "source_missing" };
+  if (!existsSync13(path)) return { reason: "source_missing" };
   const layout = await probeVideoLayout(input.page, video.id, input.canvas, input.duration);
   if ("reason" in layout) return layout;
   const layer = await buildVideoLayerInput(
@@ -9986,8 +10328,8 @@ async function planVideoLayerPassthrough(input) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { existsSync as existsSync14 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync15 } from "node:fs";
+import { join as join24 } from "node:path";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
@@ -9997,8 +10339,8 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/render/audioDeliveryLimit.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { dirname as dirname9, join as join20 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { dirname as dirname10, join as join23 } from "node:path";
 import {
   applyAudioFxChain,
   describeFfmpegFailure as describeFfmpegFailure3,
@@ -10009,7 +10351,7 @@ import {
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
 import { mkdtempSync as mkdtempSync3 } from "node:fs";
-import { dirname as dirname8, join as join19 } from "node:path";
+import { dirname as dirname9, join as join22 } from "node:path";
 import {
   DEFAULT_CONFIG,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -10288,7 +10630,7 @@ async function constrainAacTruePeak(input) {
 }
 async function cutSource(input, scratchDir, attenuationDb) {
   if (!input.sourcePath || !input.rewriteSource) return true;
-  const cutPath = join19(scratchDir, "source.wav");
+  const cutPath = join22(scratchDir, "source.wav");
   try {
     const result = await input.rewriteSource(input.sourcePath, cutPath, gainFilter(attenuationDb));
     if (!result.success) throw new Error(result.error);
@@ -10302,8 +10644,8 @@ async function cutSource(input, scratchDir, attenuationDb) {
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
-    scratchDir = mkdtempSync3(join19(dirname8(input.audioPath), ".true-peak-"));
-    const correctedPath = join19(scratchDir, "audio.m4a");
+    scratchDir = mkdtempSync3(join22(dirname9(input.audioPath), ".true-peak-"));
+    const correctedPath = join22(scratchDir, "audio.m4a");
     const measurements = [];
     let attenuationDb = 0;
     let sourcePeakDbfs;
@@ -10494,31 +10836,57 @@ async function runFfprobeJson(args, signal) {
 }
 
 // src/services/render/audioDeliveryLimit.ts
-var LIMIT_CEILING_DBTP = AAC_DELIVERY_TRUE_PEAK_DBFS - 2;
-var LIMIT_CHAIN = {
+var LIMIT_PASSES = 3;
+var LOWEST_CEILING_DBTP = AAC_DELIVERY_TRUE_PEAK_DBFS - 2;
+var PASS_HEADROOM_DB = 0.05;
+var limitChain = (ceiling) => ({
   version: 1,
-  nodes: [{ type: "truepeak", id: "delivery", params: { ceiling: LIMIT_CEILING_DBTP } }]
-};
+  nodes: [{ type: "truepeak", id: "delivery", params: { ceiling } }]
+});
 async function limitDeliveryPeaks(input, deps = {
   measure: measureTruePeakDbfs,
   applyChain: applyAudioFxChain,
   encode: encodeAac2,
   rename: renameWithRetry6,
-  sourceExists: existsSync13
+  sourceExists: existsSync14
 }) {
   const { audioPath, sourcePath, signal, timeoutMs } = input;
   if (!deps.sourceExists(sourcePath)) return { success: true };
   const peak = await deps.measure(audioPath, { timeoutMs, signal });
   if (peak <= AAC_DELIVERY_TRUE_PEAK_DBFS) return { success: true };
-  const limitedPath = join20(dirname9(sourcePath), "audio-source-limited.wav");
+  const alternating = ["a", "b"].map(
+    (k) => join23(dirname10(sourcePath), `audio-source-limited-${k}.wav`)
+  );
+  let encodedFrom;
+  let ceiling = AAC_DELIVERY_TRUE_PEAK_DBFS;
+  for (let pass = 0; pass < LIMIT_PASSES; pass++) {
+    const limitedPath = alternating[pass % 2];
+    const result = await limitPass(input, deps, ceiling, limitedPath);
+    if ("encodeFailure" in result) return result.encodeFailure;
+    if ("limitFailed" in result) break;
+    encodedFrom = limitedPath;
+    if (result.peak <= AAC_DELIVERY_TRUE_PEAK_DBFS || ceiling <= LOWEST_CEILING_DBTP) break;
+    ceiling = Math.max(
+      ceiling - (result.peak - AAC_DELIVERY_TRUE_PEAK_DBFS) - PASS_HEADROOM_DB,
+      LOWEST_CEILING_DBTP
+    );
+  }
+  if (encodedFrom) deps.rename(encodedFrom, sourcePath, { copyFallback: true });
+  return { success: true };
+}
+async function limitPass(input, deps, ceiling, limitedPath) {
+  const { audioPath, sourcePath, signal, timeoutMs } = input;
   try {
-    await deps.applyChain(sourcePath, LIMIT_CHAIN, limitedPath, { trackId: "delivery", signal });
+    await deps.applyChain(sourcePath, limitChain(ceiling), limitedPath, {
+      trackId: "delivery",
+      signal
+    });
   } catch (error) {
     if (signal?.aborted) throw error;
     input.warn?.("[audio] true-peak limit failed, the whole-mix cut applies", {
       error: error instanceof Error ? error.message : String(error)
     });
-    return { success: true };
+    return { limitFailed: true };
   }
   const encoded = await deps.encode(limitedPath, audioPath, input.targetDurationSeconds, {
     signal,
@@ -10526,13 +10894,14 @@ async function limitDeliveryPeaks(input, deps = {
   });
   if (!encoded.success) {
     return {
-      success: false,
-      error: `[audioDeliveryLimit] ${describeFfmpegFailure3(encoded, timeoutMs)}`,
-      failureReason: encoded.failureReason
+      encodeFailure: {
+        success: false,
+        error: `[audioDeliveryLimit] ${describeFfmpegFailure3(encoded, timeoutMs)}`,
+        failureReason: encoded.failureReason
+      }
     };
   }
-  deps.rename(limitedPath, sourcePath, { copyFallback: true });
-  return { success: true };
+  return { peak: await deps.measure(audioPath, { timeoutMs, signal }) };
 }
 
 // src/services/render/stages/audioStage.ts
@@ -10558,7 +10927,7 @@ function runAudioStage(input) {
 }
 async function runAudioStageScoped(input) {
   const stageStart = Date.now();
-  const pcmSourcePath = join21(input.workDir, "audio-source.wav");
+  const pcmSourcePath = join24(input.workDir, "audio-source.wav");
   const duration = input.totalFrames * input.fps.den / input.fps.num;
   let deliverySourcePath;
   try {
@@ -10574,7 +10943,7 @@ async function runAudioStageScoped(input) {
       );
       audioLoweredDb = guard.loweredDb;
       input.log?.info("[audio] phases", { ...result.audioPhaseMs, guard: Date.now() - guardStart });
-      if (input.keepDeliverySource && !guard.sourceStale && existsSync14(pcmSourcePath)) {
+      if (input.keepDeliverySource && !guard.sourceStale && existsSync15(pcmSourcePath)) {
         deliverySourcePath = pcmSourcePath;
       }
     }
@@ -10623,7 +10992,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     assertNotAborted,
     log
   } = input;
-  const audioOutputPath = join21(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join24(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -10634,7 +11003,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join21(workDir, "audio-work"),
+        join24(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -10702,8 +11071,8 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 }
 
 // src/services/render/stages/captureStage.ts
-import { existsSync as existsSync15, readdirSync as readdirSync3, statfsSync as statfsSync2 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync4, statfsSync as statfsSync2 } from "node:fs";
+import { join as join25 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
   frameFileExtension,
@@ -10773,16 +11142,16 @@ function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remed
 }
 function measureCaptureFrameBytes(workDir, framesDir) {
   let total = sampleDirectoryBytes(framesDir);
-  if (!existsSync15(workDir)) return total;
-  for (const attempt of readdirSync3(workDir)) {
+  if (!existsSync16(workDir)) return total;
+  for (const attempt of readdirSync4(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join22(workDir, attempt));
+      total += sampleDirectoryBytes(join25(workDir, attempt));
       continue;
     }
     if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join22(workDir, attempt);
-    for (const name of readdirSync3(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join22(attemptDir, name));
+    const attemptDir = join25(workDir, attempt);
+    for (const name of readdirSync4(attemptDir)) {
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join25(attemptDir, name));
     }
   }
   return total;
@@ -11076,8 +11445,8 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 }
 
 // src/services/render/stages/captureHdrStage.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10 } from "node:fs";
+import { join as join29 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
   cloneCaptureWarnings as cloneCaptureWarnings2,
@@ -11149,7 +11518,7 @@ function createHdrImageTransferCache(options = {}) {
 }
 
 // src/services/render/stages/captureHdrSequentialLoop.ts
-import { join as join23 } from "node:path";
+import { join as join26 } from "node:path";
 import {
   TRANSITIONS,
   crossfade
@@ -11274,7 +11643,7 @@ async function runSequentialLayeredFrameLoop(input) {
       );
       if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
         writeFileExclusiveSync(
-          join23(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          join26(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
       }
@@ -11306,7 +11675,7 @@ async function runSequentialLayeredFrameLoop(input) {
 }
 
 // src/services/render/stages/captureHdrHybridLoop.ts
-import { join as join25 } from "node:path";
+import { join as join28 } from "node:path";
 import {
   TRANSITIONS as TRANSITIONS2,
   closeCaptureSession as closeCaptureSession6,
@@ -11320,9 +11689,9 @@ import {
 // src/services/shaderTransitionWorkerPool.ts
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
-import { dirname as dirname10, join as join24 } from "node:path";
+import { dirname as dirname11, join as join27 } from "node:path";
 import { createRequire } from "node:module";
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
 function resolveWorkerEntry(explicit) {
   if (explicit && explicit.length > 0) {
@@ -11333,10 +11702,10 @@ function resolveWorkerEntry(explicit) {
     const isTs = override.endsWith(".ts");
     return { path: override, isTs };
   }
-  const moduleDir = dirname10(fileURLToPath3(import.meta.url));
-  const jsPath = join24(moduleDir, "shaderTransitionWorker.js");
-  if (existsSync16(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join24(moduleDir, "shaderTransitionWorker.ts");
+  const moduleDir = dirname11(fileURLToPath3(import.meta.url));
+  const jsPath = join27(moduleDir, "shaderTransitionWorker.js");
+  if (existsSync17(jsPath)) return { path: jsPath, isTs: false };
+  const tsPath = join27(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -11704,7 +12073,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join25(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join28(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -11895,9 +12264,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 ? join26(framesDir, "debug-composite") : null;
-      if (debugDumpDir && !existsSync17(debugDumpDir)) {
-        mkdirSync8(debugDumpDir, { recursive: true });
+      const debugDumpDir = debugDumpEnabled ? join29(framesDir, "debug-composite") : null;
+      if (debugDumpDir && !existsSync18(debugDumpDir)) {
+        mkdirSync10(debugDumpDir, { recursive: true });
       }
       const compositeTransfer = resolveCompositeTransfer(hasHdrContent, effectiveHdr);
       const hdrTargetTransfer = compositeTransfer === "srgb" ? void 0 : compositeTransfer;
@@ -12053,16 +12422,16 @@ async function runCaptureHdrStage(input) {
 // src/services/render/stages/encodeStage.ts
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync9,
-  readdirSync as readdirSync4,
+  existsSync as existsSync19,
+  mkdirSync as mkdirSync11,
+  readdirSync as readdirSync5,
   readFileSync as readFileSync8,
-  rmSync as rmSync9,
-  statSync as statSync7,
-  writeFileSync as writeFileSync5
+  rmSync as rmSync11,
+  statSync as statSync8,
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname11, join as join27 } from "node:path";
+import { dirname as dirname12, join as join30 } from "node:path";
 import {
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
@@ -12155,12 +12524,12 @@ async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
     const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
     return gifEncodeFailure(startTime, outputPath, error);
   }
-  writeFileSync5(outputPath, gif);
+  writeFileSync6(outputPath, gif);
   return null;
 }
 async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
   const startTime = Date.now();
-  const files = readdirSync4(framesDir).filter((file) => file.match(/\.(jpg|jpeg|png)$/i));
+  const files = readdirSync5(framesDir).filter((file) => file.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
     return gifEncodeFailure(startTime, outputPath, "[FFmpeg] No frame files found in directory");
@@ -12187,7 +12556,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync18(outputPath) ? statSync7(outputPath).size : 0;
+    const fileSize = existsSync19(outputPath) ? statSync8(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -12196,7 +12565,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       fileSize
     };
   } finally {
-    rmSync9(input.palettePath, { force: true });
+    rmSync11(input.palettePath, { force: true });
   }
 }
 function startEncodeProgress(job, stage, onProgress) {
@@ -12273,7 +12642,7 @@ function encodeWhileCapturing(input, totalFrames) {
         await new Promise((resolve13) => wake = resolve13);
       }
       if (signal.aborted) return;
-      const mergedPath = join27(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const mergedPath = join30(input.framesDir, formatCaptureFrameName(next, "jpg"));
       const frame = await readLandedFrame(landed.get(next), mergedPath);
       landed.delete(next);
       if (!await stream.writeFrame(frame)) {
@@ -12348,19 +12717,19 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync18(outputPath)) mkdirSync9(outputPath, { recursive: true });
-    const captured = readdirSync4(framesDir).filter((name) => name.endsWith(".png")).sort();
+    if (!existsSync19(outputPath)) mkdirSync11(outputPath, { recursive: true });
+    const captured = readdirSync5(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
         `[Render] png-sequence output requested but no PNGs were captured to ${framesDir}`
       );
     }
     captured.forEach((name, i) => {
-      const dst = join27(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync4(join27(framesDir, name), dst);
+      const dst = join30(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync4(join30(framesDir, name), dst);
     });
-    if (hasAudio && audioOutputPath && existsSync18(audioOutputPath)) {
-      copyFileSync4(audioOutputPath, join27(outputPath, MIXED_AUDIO_FILENAME2));
+    if (hasAudio && audioOutputPath && existsSync19(audioOutputPath)) {
+      copyFileSync4(audioOutputPath, join30(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
       );
@@ -12380,7 +12749,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join27(dirname11(videoOnlyPath), "gif-palette.png"),
+      palettePath: join30(dirname12(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -12586,14 +12955,14 @@ function sampleDirectoryBytes(dir) {
     if (!current) continue;
     let entries = [];
     try {
-      entries = readdirSync5(current);
+      entries = readdirSync6(current);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const full = join28(current, name);
+      const full = join31(current, name);
       try {
-        const st = statSync8(full);
+        const st = statSync9(full);
         if (st.isDirectory()) {
           stack.push(full);
         } else if (st.isFile()) {
@@ -12741,18 +13110,14 @@ function hasUsableVideoDimensions(metadata) {
   return Number.isFinite(metadata.width) && Number.isFinite(metadata.height) && metadata.width > 0 && metadata.height > 0;
 }
 function collectVideoMetadataHints(extractedVideos) {
-  return extractedVideos.filter((video) => hasUsableVideoDimensions(video.metadata)).map((video) => ({
-    id: video.videoId,
-    width: video.metadata.width,
-    height: video.metadata.height
-  })).sort((a, b) => a.id.localeCompare(b.id));
+  return extractedVideos.filter((video) => hasUsableVideoDimensions(video.metadata)).map((video) => ({ id: video.videoId, ...displaySize(video.metadata) })).sort((a, b) => a.id.localeCompare(b.id));
 }
 function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join28(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync19(framePath) || statSync8(framePath).size <= 8;
+    const framePath = join31(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const missing = !existsSync20(framePath) || statSync9(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -12768,7 +13133,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) => join28(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
+  const outputDirFor = (batchIndex, workerId) => join31(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
   if (stride > 1) {
     const spans = /* @__PURE__ */ new Map();
     for (const range of ranges) {
@@ -12828,8 +13193,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 join28(systemTempDir, "hf-render-");
-  return join28(dirname12(outputPath), `work-${jobId}-`);
+  if (platform2 === "win32" || platform2 === "darwin") return join31(systemTempDir, "hf-render-");
+  return join31(dirname13(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -12876,8 +13241,8 @@ 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 = join28(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    if (existsSync19(framePath)) captured++;
+    const framePath = join31(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    if (existsSync20(framePath)) captured++;
   }
   return captured;
 }
@@ -12902,7 +13267,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join28(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join31(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -13534,19 +13899,19 @@ function deVerifyFallbackTelemetry(err) {
   };
 }
 function resolveRenderDebugDir() {
-  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve8(process.env.PRODUCER_RENDERS_DIR, "..") : resolve8(dirname12(fileURLToPath4(import.meta.url)), "../..");
-  return join28(producerRoot, ".debug");
+  const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve8(process.env.PRODUCER_RENDERS_DIR, "..") : resolve8(dirname13(fileURLToPath4(import.meta.url)), "../..");
+  return join31(producerRoot, ".debug");
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
   validateDeliveryEncoderConfig(job.config);
   const debugDir = resolveRenderDebugDir();
-  const outputDir = dirname12(outputPath);
-  if (!existsSync19(outputDir)) mkdirSync10(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join28(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
+  const outputDir = dirname13(outputPath);
+  if (!existsSync20(outputDir)) mkdirSync12(outputDir, { recursive: true });
+  const workDir = job.config.debug ? join31(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join28(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join31(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -13560,7 +13925,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
       log.info("KEEP_TEMP=1, leaving workDir on disk for inspection", { workDir });
       return;
     }
-    rmSync10(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    rmSync12(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   });
   try {
     await executeRenderPipeline({
@@ -13608,7 +13973,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join28(workDir, "perf-summary.json");
+  const perfOutputPath = join31(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig2() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -13684,7 +14049,7 @@ async function executeRenderPipeline(input) {
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
     assertConfiguredFfmpegBinariesExist();
-    if (!existsSync19(workDir)) mkdirSync10(workDir, { recursive: true });
+    if (!existsSync20(workDir)) mkdirSync12(workDir, { recursive: true });
     if (job.config.debug) {
       log.info("[Render] Debug artifacts enabled", { workDir, logPath });
     }
@@ -13713,36 +14078,11 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join28(projectDir, entryFile);
-    if (!existsSync19(htmlPath)) {
+    const htmlPath = join31(projectDir, entryFile);
+    if (!existsSync20(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
-    const rawEntry = readTextFile2(htmlPath);
-    if (entryFile !== "index.html" && isTemplateEntry(rawEntry)) {
-      const wrapperPath = join28(workDir, "standalone-entry.html");
-      const projectIndexPath = join28(projectDir, "index.html");
-      if (!existsSync19(projectIndexPath)) {
-        throw new Error(
-          `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
-        );
-      }
-      const standaloneHtml = extractStandaloneEntryFromIndex(
-        readTextFile2(projectIndexPath),
-        entryFile,
-        rawEntry
-      );
-      if (!standaloneHtml) {
-        throw new Error(
-          `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
-        );
-      }
-      writeFileSync6(wrapperPath, standaloneHtml, "utf-8");
-      htmlPath = wrapperPath;
-      log.info("Extracted standalone entry from index.html host context", {
-        entryFile
-      });
-    }
     const stage1Start = Date.now();
     updateJobStatus(job, "preprocessing", "Compiling composition", 5, onProgress, {
       code: "compile"
@@ -13754,7 +14094,6 @@ async function executeRenderPipeline(input) {
       () => runCompileStage({
         projectDir,
         workDir,
-        htmlPath,
         entryFile,
         job,
         cfg,
@@ -13916,7 +14255,7 @@ async function executeRenderPipeline(input) {
           canvas: { width, height },
           page: probeSession.page,
           projectDir,
-          compiledDir: join28(workDir, "compiled")
+          compiledDir: join31(workDir, "compiled")
         });
         if (videoLayerPlan.videoId === void 0) {
           log.info(`[Render] Video layer passthrough off: ${videoLayerPlan.reason}`);
@@ -13934,7 +14273,22 @@ async function executeRenderPipeline(input) {
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress, {
       code: "extract_video"
     });
-    const compiledDir = join28(workDir, "compiled");
+    const compiledDir = join31(workDir, "compiled");
+    const segmentsCapture = (layeredOrEffectRoute) => shouldSegmentCapture({
+      env: process.env,
+      durationSeconds: probeResult.duration,
+      outputFormat,
+      layeredOrEffectRoute,
+      streamingOk: shouldUseStreamingEncode(cfg, outputFormat, 1, probeResult.duration)
+    });
+    const segmentedForWindow = segmentsCapture(compiled.hasShaderTransitions);
+    const windowVideoFrames = job.config.motionBlur === void 0 && shouldWindowVideoFrames({ env: process.env, segmented: segmentedForWindow });
+    if (!windowVideoFrames && shouldWindowVideoFrames({ env: process.env, segmented: true })) {
+      const reason = job.config.motionBlur !== void 0 ? "motion blur" : outputFormat !== "mp4" && outputFormat !== "mov" ? `${outputFormat} output` : "capture is not segmented";
+      log.info("[Render] HF_VIDEO_FRAME_WINDOW is set but this render extracts every frame", {
+        reason
+      });
+    }
     const extractResult = await observeRenderStage(
       observability,
       "video_extract",
@@ -13951,6 +14305,7 @@ async function executeRenderPipeline(input) {
         assertNotAborted,
         // Local staging can use links; distributed plan() alone requires real copies.
         materializeSymlinks: false,
+        deferRangeExtraction: windowVideoFrames ? true : void 0,
         onProgress
       })
     );
@@ -14047,7 +14402,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer({
           projectDir,
-          compiledDir: join28(workDir, "compiled"),
+          compiledDir: join31(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -14065,8 +14420,8 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join28(workDir, "captured-frames");
-    if (!existsSync19(framesDir)) mkdirSync10(framesDir, { recursive: true });
+    const framesDir = join31(workDir, "captured-frames");
+    if (!existsSync20(framesDir)) mkdirSync12(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
     });
@@ -14144,7 +14499,55 @@ async function executeRenderPipeline(input) {
     });
     const buildPrepCaptureOptions = () => stopPrepSessionOnScriptFailure(buildCaptureOptions());
     const buildWorkerCaptureOptions = () => withScriptFailureStop(buildCaptureOptions(), job, log);
-    const createRenderVideoFrameInjector = () => createVideoFrameInjector(frameLookup, frameCacheOptions(cfg, workerCount));
+    let videoFrameWindow = windowVideoFrames && (extractionResult?.extracted.some((video) => video.deferredRange) ?? false);
+    if (windowVideoFrames) {
+      const extracted = extractionResult?.extracted ?? [];
+      log.info("[Render] Video frame window", {
+        windowed: extracted.filter((video) => video.deferredRange).length,
+        fullyExtracted: extracted.filter((video) => !video.deferredRange).length
+      });
+    }
+    const buildSegmentVideoFrames = () => trackSegmentFramePeak(
+      createSegmentVideoFrames({
+        videos: composition.videos,
+        extracted: extractionResult?.extracted ?? [],
+        fps: job.config.fps,
+        rootDir: workDir,
+        cfg,
+        injectorOptions: frameCacheOptions(cfg, workerCount),
+        abortSignal: executionSignal
+      }),
+      workDir,
+      (bytes) => updateCaptureObservability({ videoFrameWindowPeakBytes: bytes })
+    );
+    const createRenderVideoFrameInjector = () => createVideoFrameInjector2(frameLookup, frameCacheOptions(cfg, workerCount));
+    const extractDeferredVideoFrames = async () => {
+      videoFrameWindow = false;
+      updateCaptureObservability({ videoFrameWindow: "off" });
+      const extracted = extractionResult?.extracted ?? [];
+      const videoCount = extracted.filter((video) => video.deferredRange).length;
+      const startedAt = Date.now();
+      log.info("[Render] Extracting the frames of the videos a window would have held back", {
+        videoCount
+      });
+      await observeRenderStage(
+        observability,
+        "video_extract_deferred",
+        { videoCount },
+        () => extractAllDeferredFrames(extracted, {
+          fps: job.config.fps,
+          cfg,
+          signal: executionSignal,
+          maxTransientRetries: resolveVideoExtractionPolicy().maxTransientRetries,
+          onProgress: (done, total) => reportExtractProgress(job, done, total, onProgress)
+        })
+      );
+      assertNotAborted();
+      log.info("[Render] Extracted the deferred video frames", {
+        videoCount,
+        elapsedMs: Date.now() - startedAt
+      });
+    };
     let captureCalibration;
     const htmlInCanvasDetected = compiled.renderModeHints.reasons.some(
       (r) => r.code === "htmlInCanvas"
@@ -14310,32 +14713,41 @@ async function executeRenderPipeline(input) {
       updateJobStatus(job, "rendering", "Measuring capture speed", 25, onProgress, {
         code: "start_browsers"
       });
-      const outcome = await observeRenderStage(
-        observability,
-        "capture_calibration",
-        captureStageObservationData({
-          forceScreenshot: captureForceScreenshot,
-          // Override the default `capturing` — calibration writes probe
-          // frames only, not `job.framesRendered`, so heartbeats reporting
-          // `framesCompleted: 0` misread as broken. Field signal
-          // ts=1784019503.
-          stagePhase: "calibrating"
-        }),
-        () => runCaptureCalibration({
-          cfg: calibrationCaptureConfig(cfg),
-          fileServer: activeFileServer,
-          workDir,
-          log,
-          job,
-          totalFrames,
-          forceScreenshot: captureForceScreenshot,
-          probeSession,
-          buildCaptureOptions: buildPrepCaptureOptions,
-          createRenderVideoFrameInjector,
-          assertNotAborted
-        }),
-        { heartbeatMessage: "browser calibrating (frames not started)" }
-      );
+      const calibrationFrames = videoFrameWindow ? await buildSegmentVideoFrames().forFrames(
+        selectCaptureCalibrationFrames(totalFrames),
+        "calibration"
+      ) : void 0;
+      let outcome;
+      try {
+        outcome = await observeRenderStage(
+          observability,
+          "capture_calibration",
+          captureStageObservationData({
+            forceScreenshot: captureForceScreenshot,
+            // Override the default `capturing` — calibration writes probe
+            // frames only, not `job.framesRendered`, so heartbeats reporting
+            // `framesCompleted: 0` misread as broken. Field signal
+            // ts=1784019503.
+            stagePhase: "calibrating"
+          }),
+          () => runCaptureCalibration({
+            cfg: calibrationCaptureConfig(cfg),
+            fileServer: activeFileServer,
+            workDir,
+            log,
+            job,
+            totalFrames,
+            forceScreenshot: captureForceScreenshot,
+            probeSession,
+            buildCaptureOptions: buildPrepCaptureOptions,
+            createRenderVideoFrameInjector: calibrationFrames ? calibrationFrames.injector : createRenderVideoFrameInjector,
+            assertNotAborted
+          }),
+          { heartbeatMessage: "browser calibrating (frames not started)" }
+        );
+      } finally {
+        calibrationFrames?.release();
+      }
       captureCalibration = outcome.calibration;
       calibrationEvaluateTimedOut = outcome.calibrationEvaluateTimedOut;
       captureForceScreenshot = outcome.forceScreenshot;
@@ -14567,7 +14979,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join28(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join31(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -14668,13 +15080,7 @@ async function executeRenderPipeline(input) {
       // excluded routes are the ones whose concat-copy or capture loop the
       // segment contract does not cover (webm VP9 concat is fragile, HDR and
       // shader transitions run their own compositor).
-      useSegmentedCapture: shouldSegmentCapture({
-        env: process.env,
-        durationSeconds: job.duration,
-        outputFormat,
-        layeredOrEffectRoute: hasHdrContent || compiled.hasShaderTransitions,
-        streamingOk: shouldUseStreamingEncode(cfg, outputFormat, 1, job.duration)
-      }),
+      useSegmentedCapture: segmentsCapture(hasHdrContent || compiled.hasShaderTransitions),
       useLayeredComposite,
       usePageSideCompositing: usePageSideCompositingForTransitions,
       hasHdrContent,
@@ -14714,10 +15120,14 @@ async function executeRenderPipeline(input) {
       deWorkerInversion,
       deParallelRouter
     });
+    if (videoFrameWindow && capturePlan.kind !== "sdr_segmented")
+      await extractDeferredVideoFrames();
+    updateCaptureObservability({ videoFrameWindow: videoFrameWindow ? "on" : "off" });
     observability.checkpoint("capture_strategy", "resolved", {
       plan: capturePlan.kind,
       workerCount: capturePlan.workerCount,
       forceScreenshot: capturePlan.forceScreenshot,
+      videoFrameWindow: videoFrameWindow ? "on" : "off",
       captureBeyondViewport: resolvedCaptureBeyondViewport ?? null,
       useStreamingEncode: capturePlan.kind === "sdr_streaming",
       useLayeredComposite: capturePlan.kind === "hdr_layered",
@@ -14855,7 +15265,7 @@ async function executeRenderPipeline(input) {
           pageMotionBlur: job.config.pageMotionBlur,
           captureQuality: captureOptions.quality
         });
-        const segmentDir = segmentDirFor(join28(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join31(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -14870,10 +15280,10 @@ async function executeRenderPipeline(input) {
             });
           }
           if (completedSegments.size === 0) {
-            rmSync10(segmentDir, { recursive: true, force: true });
+            rmSync12(segmentDir, { recursive: true, force: true });
           }
         } else {
-          rmSync10(segmentDir, { recursive: true, force: true });
+          rmSync12(segmentDir, { recursive: true, force: true });
         }
         const emptySegmentManifest = () => ({
           version: 1,
@@ -14923,6 +15333,7 @@ async function executeRenderPipeline(input) {
               },
               buildCaptureOptions: buildWorkerCaptureOptions,
               createRenderVideoFrameInjector,
+              segmentVideoFrames: videoFrameWindow ? buildSegmentVideoFrames() : void 0,
               abortSignal: executionSignal,
               assertNotAborted,
               onProgress,
@@ -14974,7 +15385,7 @@ async function executeRenderPipeline(input) {
             probeSession = null;
             await closeOrphanedProbeForRetry(orphaned, closeCaptureSession8, log, "segmented");
           }
-          rmSync10(segmentDir, { recursive: true, force: true });
+          rmSync12(segmentDir, { recursive: true, force: true });
           completedSegments = /* @__PURE__ */ new Set();
           segmentManifest = emptySegmentManifest();
           dedupPerfs.length = 0;
@@ -15013,11 +15424,12 @@ async function executeRenderPipeline(input) {
           );
           updateCaptureObservability({ segmentRetries: segmentedRes.segmentRetries });
           if (job.config.keepSegments !== true) {
-            rmSync10(segmentDir, { recursive: true, force: true });
+            rmSync12(segmentDir, { recursive: true, force: true });
           }
         } else {
           capturePlan = replanAfterFailure(capturePlan, { kind: "streaming_unavailable" });
           syncCapturePlan();
+          if (videoFrameWindow) await extractDeferredVideoFrames();
           probeSession = null;
           observability.checkpoint(
             "capture_segmented",
@@ -15288,8 +15700,8 @@ async function executeRenderPipeline(input) {
             "capture_disk",
             "drawElement capture failed; retrying with a fresh screenshot session"
           );
-          rmSync10(framesDir, { recursive: true, force: true });
-          mkdirSync10(framesDir, { recursive: true });
+          rmSync12(framesDir, { recursive: true, force: true });
+          mkdirSync12(framesDir, { recursive: true });
           resetCaptureAttemptProgress(job);
           dedupPerfs.length = 0;
           cfg.useDrawElement = false;
@@ -15394,7 +15806,7 @@ async function executeRenderPipeline(input) {
       })
     );
     const totalElapsed = Date.now() - pipelineStart;
-    const tmpPeakBytes = existsSync19(workDir) ? sampleDirectoryBytes(workDir) : 0;
+    const tmpPeakBytes = existsSync20(workDir) ? sampleDirectoryBytes(workDir) : 0;
     recordTransientRetryObservability();
     observability.checkpoint("pipeline", "artifact validated", { totalElapsedMs: totalElapsed });
     const observabilitySummary = observability.summary({
@@ -15466,7 +15878,7 @@ async function executeRenderPipeline(input) {
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync6(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync7(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -15475,8 +15887,8 @@ async function executeRenderPipeline(input) {
       }
     }
     if (job.config.debug) {
-      if (!isPngSequence && !isHls && existsSync19(stagedOutputPath)) {
-        const debugOutput = join28(workDir, `output${videoExt}`);
+      if (!isPngSequence && !isHls && existsSync20(stagedOutputPath)) {
+        const debugOutput = join31(workDir, `output${videoExt}`);
         copyFileSync5(stagedOutputPath, debugOutput);
       }
     }
@@ -15590,15 +16002,15 @@ import {
   REFERENCE_BACKGROUND_FIELD as REFERENCE_BACKGROUND_FIELD4,
   referenceBackgroundResult as referenceBackgroundResult6
 } from "@hyperframes/engine";
-import { mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync7, readFileSync as readFileSync14, rmSync as rmSync16 } from "node:fs";
-import { join as join42 } from "node:path";
+import { mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync7, readFileSync as readFileSync14, rmSync as rmSync18 } from "node:fs";
+import { join as join45 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 
 // src/services/distributed/mp4Stitch.ts
-import { createReadStream as createReadStream3, createWriteStream, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, rmSync as rmSync11 } from "node:fs";
+import { createReadStream as createReadStream3, createWriteStream, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync4, rmSync as rmSync13 } from "node:fs";
 import { open } from "node:fs/promises";
 import { renameWithRetry as renameWithRetry7 } from "@hyperframes/engine";
-import { dirname as dirname13, join as join29 } from "node:path";
+import { dirname as dirname14, join as join32 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
@@ -15962,18 +16374,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(dirname13(outputPath), { recursive: true });
+  mkdirSync13(dirname14(outputPath), { recursive: true });
   const workDir = mkdtempSync4(`${outputPath}.stitch-`);
-  const out = createWriteStream(join29(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);
-    renameWithRetry7(join29(workDir, "out.mp4"), outputPath);
+    renameWithRetry7(join32(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
-    rmSync11(workDir, { recursive: true, force: true });
+    rmSync13(workDir, { recursive: true, force: true });
   }
 }
 
@@ -15987,13 +16399,13 @@ import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframe
 import {
   copyFileSync as copyFileSync6,
   cpSync as cpSync2,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   linkSync,
-  mkdirSync as mkdirSync14,
-  rmSync as rmSync12,
-  writeFileSync as writeFileSync9
+  mkdirSync as mkdirSync16,
+  rmSync as rmSync14,
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { extname as extname6, isAbsolute as isAbsolute3, join as join37, relative as relative5, sep as sep2 } from "node:path";
+import { extname as extname6, isAbsolute as isAbsolute3, join as join40, relative as relative5, sep as sep2 } from "node:path";
 import {
   fpsToNumber as fpsToNumber9,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -16009,28 +16421,26 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/distributed/planFrameCost.ts
-import { join as join32 } from "node:path";
+import { join as join35 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession9,
   createCaptureSession as createCaptureSession9,
-  createFrameLookupTable as createFrameLookupTable3,
+  createFrameLookupTable as createFrameLookupTable4,
   initializeSession as initializeSession9
 } from "@hyperframes/engine";
 
 // src/services/distributed/chunkFrames.ts
-import { existsSync as existsSync21, readdirSync as readdirSync6 } from "node:fs";
-import { extname as extname4, join as join31 } from "node:path";
+import { existsSync as existsSync22, readdirSync as readdirSync7 } from "node:fs";
+import { extname as extname4, join as join34 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
-  createFrameLookupTable as createFrameLookupTable2,
-  createVideoFrameInjector as createVideoFrameInjector2,
-  extractVideoFramesRange
+  createVideoFrameInjector as createVideoFrameInjector3
 } from "@hyperframes/engine";
 
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
-import { dirname as dirname14, join as join30 } from "node:path";
-import { existsSync as existsSync20, readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname15, join as join33 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
 import {
@@ -16045,8 +16455,8 @@ function isPlanAudioArtifactPath(path) {
 }
 function resolvePlanAudioPath(planDir) {
   for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
-    const candidate = join30(planDir, name);
-    if (existsSync20(candidate)) return candidate;
+    const candidate = join33(planDir, name);
+    if (existsSync21(candidate)) return candidate;
   }
   return null;
 }
@@ -16303,11 +16713,11 @@ function buildSyntheticRenderJob(input) {
 var cachedProducerVersion = null;
 function readProducerVersion() {
   if (cachedProducerVersion !== null) return cachedProducerVersion;
-  const startDir = dirname14(fileURLToPath5(import.meta.url));
+  const startDir = dirname15(fileURLToPath5(import.meta.url));
   let current = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = join30(current, "package.json");
-    if (existsSync20(candidate)) {
+    const candidate = join33(current, "package.json");
+    if (existsSync21(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
         if (pkg.name === "@hyperframes/producer" && typeof pkg.version === "string") {
@@ -16317,7 +16727,7 @@ function readProducerVersion() {
       } catch {
       }
     }
-    const parent = dirname14(current);
+    const parent = dirname15(current);
     if (parent === current) break;
     current = parent;
   }
@@ -16342,11 +16752,11 @@ var RenderChunkValidationError = class extends Error {
 };
 function createChunkVideoFrameInjectorFactory(frameLookup, options) {
   if (!(frameLookup instanceof Promise))
-    return () => createVideoFrameInjector2(frameLookup, options);
+    return () => createVideoFrameInjector3(frameLookup, options);
   return () => {
     let hook;
     return async (page, time, heldVideoTime) => {
-      hook ??= createVideoFrameInjector2(await frameLookup, options);
+      hook ??= createVideoFrameInjector3(await frameLookup, options);
       await hook?.(page, time, heldVideoTime);
     };
   };
@@ -16360,14 +16770,14 @@ function frameNumberFromFileName(name) {
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
   const result = [];
   for (const v of videos) {
-    const outputDir = join31(planDir, "video-frames", v.videoId);
-    if (!existsSync21(outputDir)) {
+    const outputDir = join34(planDir, "video-frames", v.videoId);
+    if (!existsSync22(outputDir)) {
       throw new Error(
         `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
       );
     }
     const ext = (extname4(v.framePattern) || ".jpg").toLowerCase();
-    const frames = readdirSync6(outputDir).filter((name) => name.toLowerCase().endsWith(ext)).sort((left, right) => {
+    const frames = readdirSync7(outputDir).filter((name) => name.toLowerCase().endsWith(ext)).sort((left, right) => {
       const leftNumber = frameNumberFromFileName(left);
       const rightNumber = frameNumberFromFileName(right);
       if (leftNumber === null || rightNumber === null) return left.localeCompare(right);
@@ -16379,7 +16789,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, join31(outputDir, frameName));
+      framePaths.set(frameIndex, join34(outputDir, frameName));
     }
     result.push({
       videoId: v.videoId,
@@ -16396,15 +16806,6 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
   }
   return result;
 }
-function contiguousRuns(sortedIndexes) {
-  const runs2 = [];
-  for (const index of sortedIndexes) {
-    const last = runs2[runs2.length - 1];
-    if (last && last.firstFrame + last.frames === index) last.frames++;
-    else runs2.push({ firstFrame: index, frames: 1 });
-  }
-  return runs2;
-}
 function buildChunkCaptureOptions(input) {
   const { dimensions, encoder } = input;
   const videoCaptureBeyondViewport = resolveVideoCaptureBeyondViewport(input.videoCount);
@@ -16427,28 +16828,19 @@ function buildChunkCaptureOptions(input) {
     requiresWebGpu: compositionRequiresWebGpu3(input.html)
   };
 }
-function shownDeferredFrameIndexes(planVideos, frames, fps) {
-  const shown = /* @__PURE__ */ new Map();
-  const deferred = planVideos.extracted.filter((video) => video.deferredRange);
-  if (deferred.length === 0) return shown;
-  const table = createFrameLookupTable2(
-    planVideos.videos,
-    deferred.map((video) => ({
-      ...video,
-      outputDir: "",
-      framePaths: new Map(Array.from({ length: video.totalFrames }, (_, i) => [i, String(i)]))
-    })),
-    resolveRenderFpsConfig(fps).value
+function planExtractedFrames(planVideos) {
+  return planVideos.extracted.map((video) => ({
+    ...video,
+    outputDir: "",
+    framePaths: /* @__PURE__ */ new Map()
+  }));
+}
+function shownPlanFrameIndexes(planVideos, frames, fps) {
+  return shownDeferredFrameIndexes(
+    { videos: planVideos.videos, extracted: planExtractedFrames(planVideos) },
+    frames,
+    fps
   );
-  for (const frame of frames) {
-    const globalTime = frame * fps.den / fps.num;
-    for (const [videoId, payload] of table.getActiveFramePayloads(globalTime)) {
-      const indexes = shown.get(videoId) ?? /* @__PURE__ */ new Set();
-      indexes.add(payload.frameIndex);
-      shown.set(videoId, indexes);
-    }
-  }
-  return shown;
 }
 async function extractDeferredVideoFramesForChunk(input) {
   const deferred = input.planVideos.extracted.filter((video) => video.deferredRange);
@@ -16465,49 +16857,32 @@ async function extractDeferredVideoFramesForChunk(input) {
       url: remoteSources[path].split("?")[0]
     });
   }
-  if (deferred.length === 0) return [];
-  const shown = shownDeferredFrameIndexes(input.planVideos, input.frames, input.fps);
-  return Promise.all(
-    deferred.map(async (video) => {
-      const outputDir = join31(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 planned = new Map(input.planVideos.extracted.map((video) => [video.videoId, video]));
+  return extractDeferredFrames({
+    videos: input.planVideos.videos,
+    extracted: planExtractedFrames(input.planVideos),
+    frames: input.frames,
+    fps: input.fps,
+    outputRoot: input.outputRoot,
+    cfg: input.cfg,
+    shownBoxes: input.shownBoxes,
+    sourceOf: (video) => {
+      const range = planned.get(video.videoId).deferredRange;
       const remoteUrl = remoteSources[range.sourcePath];
-      const sourcePath = remoteUrl ?? join31(input.planDir, ...range.sourcePath.split("/"));
-      if (remoteUrl === void 0 && !existsSync21(sourcePath)) {
+      const sourcePath = remoteUrl ?? join34(input.planDir, ...range.sourcePath.split("/"));
+      if (remoteUrl === void 0 && !existsSync22(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
           `[renderChunk] planDir is missing the source for video ${JSON.stringify(video.videoId)}: ${range.sourcePath}`
         );
       }
-      const extracted = await extractVideoFramesRange(
-        sourcePath,
-        video.videoId,
-        range.startTime,
-        range.durationSeconds,
-        {
-          fps: input.fps,
-          outputDir: input.outputRoot,
-          format: range.format,
-          frameRanges: contiguousRuns(indexes),
-          shownBox: input.shownBoxes?.get(video.videoId)
-        },
-        void 0,
-        input.cfg
-      );
-      const missing = indexes.find((index) => !extracted.framePaths.has(index));
-      if (missing !== void 0) {
-        throw new RenderChunkValidationError(
-          INVALID_VIDEO_METADATA,
-          `[renderChunk] video ${JSON.stringify(video.videoId)} has no frame ${missing}; the plan expected ${video.totalFrames} frames from ${range.sourcePath}.`
-        );
-      }
-      return { ...video, outputDir, framePaths: extracted.framePaths, ownedByLookup: false };
-    })
-  );
+      return sourcePath;
+    },
+    onMissingFrame: (video, index) => new RenderChunkValidationError(
+      INVALID_VIDEO_METADATA,
+      `[renderChunk] video ${JSON.stringify(video.videoId)} has no frame ${index}; the plan expected ${video.totalFrames} frames from ${planned.get(video.videoId).deferredRange.sourcePath}.`
+    )
+  });
 }
 
 // src/services/distributed/planFrameCost.ts
@@ -16525,12 +16900,12 @@ async function measurePlanSecondsPerFrame(input) {
       planVideos,
       frames: sampled,
       fps: fpsRatio,
-      outputRoot: join32(workDir, "frame-cost-video-frames"),
+      outputRoot: join35(workDir, "frame-cost-video-frames"),
       cfg: input.cfg
     })
   ];
-  const lookup = extracted.length > 0 ? createFrameLookupTable3(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
-  const compiledDir = join32(planDir, "compiled");
+  const lookup = extracted.length > 0 ? createFrameLookupTable4(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
+  const compiledDir = join35(planDir, "compiled");
   const fileServer = await createFileServer({
     projectDir: compiledDir,
     compiledDir,
@@ -16542,7 +16917,7 @@ async function measurePlanSecondsPerFrame(input) {
   try {
     session = await createCaptureSession9(
       fileServer.url,
-      join32(workDir, "frame-cost"),
+      join35(workDir, "frame-cost"),
       buildChunkCaptureOptions({
         dimensions: { ...input, fpsNum: fps, fpsDen: 1 },
         encoder: input,
@@ -16639,7 +17014,7 @@ function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
 }
 
 // src/services/render/planReferenceBackground.ts
-import { join as join33 } from "node:path";
+import { join as join36 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession10,
   createCaptureSession as createCaptureSession10,
@@ -16652,14 +17027,14 @@ async function readPlanReferenceBackground(input) {
   try {
     server = await createFileServer({
       projectDir: input.projectDir,
-      compiledDir: join33(input.workDir, "compiled"),
+      compiledDir: join36(input.workDir, "compiled"),
       port: 0,
       preHeadScripts: [VIRTUAL_TIME_SHIM],
       fps: input.options.fps
     });
     session = await createCaptureSession10(
       server.url,
-      join33(input.workDir, "reference"),
+      join36(input.workDir, "reference"),
       {
         ...input.options,
         requiresWebGpu: false
@@ -16695,8 +17070,8 @@ async function readPlanReferenceBackground(input) {
 }
 
 // src/services/render/stages/freezePlan.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync10, readdirSync as readdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join34, relative as relative3, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync14, readFileSync as readFileSync10, readdirSync as readdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join37, relative as relative3, resolve as resolve9 } from "node:path";
 import {
   REFERENCE_BACKGROUND_FIELD,
   referenceBackgroundResult as referenceBackgroundResult3
@@ -16889,7 +17264,7 @@ function planFileSha256(absolutePath, digests) {
   return sha256;
 }
 async function prehashPlanFiles(dir, digests) {
-  if (!existsSync22(dir)) return;
+  if (!existsSync23(dir)) return;
   for (const { absolutePath } of listPlanFiles(dir)) {
     if (!digests.has(absolutePath)) digests.set(absolutePath, await sha256FileAsync(absolutePath));
   }
@@ -16912,9 +17287,9 @@ function listPlanFiles(planDir) {
   const results = [];
   const rootResolved = resolve9(planDir);
   function walk(dir) {
-    const entries = readdirSync7(dir, { withFileTypes: true });
+    const entries = readdirSync8(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join34(dir, entry.name);
+      const full = join37(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile()) {
@@ -16955,19 +17330,19 @@ 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);
-  writeFileSync7(join34(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
+  writeFileSync8(join37(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
 }
 function readPlanRemoteFiles(planDir) {
-  const path = join34(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
-  return existsSync22(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
+  const path = join37(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
+  return existsSync23(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join34(planDir, "plan.json");
-  const encoderJsonPath = join34(planDir, "meta", "encoder.json");
-  if (!existsSync22(planJsonPath)) {
+  const planJsonPath = join37(planDir, "plan.json");
+  const encoderJsonPath = join37(planDir, "meta", "encoder.json");
+  if (!existsSync23(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
-  if (!existsSync22(encoderJsonPath)) {
+  if (!existsSync23(encoderJsonPath)) {
     throw new Error(`[freezePlan] meta/encoder.json missing: ${encoderJsonPath}`);
   }
   const planJson = JSON.parse(readFileSync10(planJsonPath, "utf-8"));
@@ -16997,21 +17372,21 @@ async function freezePlan(input) {
     hasAudio,
     digests
   } = input;
-  if (!existsSync22(planDir)) {
+  if (!existsSync23(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
-  const metaDir = join34(planDir, "meta");
-  if (!existsSync22(metaDir)) mkdirSync12(metaDir, { recursive: true });
-  writeFileSync7(
-    join34(metaDir, "composition.json"),
+  const metaDir = join37(planDir, "meta");
+  if (!existsSync23(metaDir)) mkdirSync14(metaDir, { recursive: true });
+  writeFileSync8(
+    join37(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
 `,
     "utf-8"
   );
   const encoderForCanonical = stripUndefined(encoder);
   const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync7(join34(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync7(join34(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+  writeFileSync8(join37(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync8(join37(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
@@ -17036,8 +17411,8 @@ async function freezePlan(input) {
     duration: durationSeconds,
     hasAudio
   };
-  const planJsonPath = join34(planDir, "plan.json");
-  writeFileSync7(planJsonPath, `${JSON.stringify(planJson, null, 2)}
+  const planJsonPath = join37(planDir, "plan.json");
+  writeFileSync8(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
 }
@@ -17078,9 +17453,9 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 }
 
 // src/services/distributed/chunkAudio.ts
-import { closeSync as closeSync6, existsSync as existsSync23, ftruncateSync, mkdirSync as mkdirSync13, openSync as openSync6, readFileSync as readFileSync11 } from "node:fs";
-import { writeFileSync as writeFileSync8, writeSync } from "node:fs";
-import { join as join35 } from "node:path";
+import { closeSync as closeSync6, existsSync as existsSync24, ftruncateSync, mkdirSync as mkdirSync15, openSync as openSync6, readFileSync as readFileSync11 } from "node:fs";
+import { writeFileSync as writeFileSync9, writeSync } from "node:fs";
+import { join as join38 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure4, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
 function audioCutForChunk(grid, chunks, index, fps) {
   const firstPacketAt = (frame) => Math.min(
@@ -17168,7 +17543,7 @@ async function writeChunkAudioSlices(input) {
   });
   const bytes = readFileSync11(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
-  mkdirSync13(join35(input.planDir, SLICE_DIR), { recursive: true });
+  mkdirSync15(join38(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
     const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
     if (!cut) return;
@@ -17176,17 +17551,17 @@ async function writeChunkAudioSlices(input) {
     const start = offsets[cut.firstPacket];
     layout.partStarts[index] = start;
     const end = offsets[last] + track.sizes[last];
-    writeFileSync8(join35(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
+    writeFileSync9(join38(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
   });
   const frame = [bytes.subarray(0, payloadStart), bytes.subarray(payloadEnd)];
-  writeFileSync8(join35(input.planDir, SLICE_FRAME), Buffer.concat(frame));
-  writeFileSync8(join35(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
+  writeFileSync9(join38(input.planDir, SLICE_FRAME), Buffer.concat(frame));
+  writeFileSync9(join38(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
 }
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
-  const layoutPath = join35(planDir, SLICE_LAYOUT);
-  if (!existsSync23(layoutPath)) return resolvePlanAudioPath(planDir);
+  const layoutPath = join38(planDir, SLICE_LAYOUT);
+  if (!existsSync24(layoutPath)) return resolvePlanAudioPath(planDir);
   const layout = JSON.parse(readFileSync11(layoutPath, "utf-8"));
-  const frame = readFileSync11(join35(planDir, SLICE_FRAME));
+  const frame = readFileSync11(join38(planDir, SLICE_FRAME));
   const fd = openSync6(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
@@ -17199,7 +17574,7 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync11(join35(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync11(join38(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
@@ -17254,8 +17629,8 @@ async function muxChunkWithAudio(input) {
 
 // src/services/distributed/planSize.ts
 import { createHash as createHash9 } from "node:crypto";
-import { lstatSync as lstatSync2, readdirSync as readdirSync8 } from "node:fs";
-import { extname as extname5, join as join36, relative as relative4 } from "node:path";
+import { lstatSync as lstatSync2, readdirSync as readdirSync9 } from "node:fs";
+import { extname as extname5, join as join39, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -17362,12 +17737,12 @@ function recordFile(result, components, rootDir, rootKind, filePath) {
 function walkRegularFiles(dir, visit) {
   let entries;
   try {
-    entries = readdirSync8(dir, { withFileTypes: true });
+    entries = readdirSync9(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const full = join36(dir, entry.name);
+    const full = join39(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -17579,13 +17954,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join37("meta", "composition.json"),
-  join37("meta", "encoder.json"),
-  join37("meta", "chunks.json")
+  join40("meta", "composition.json"),
+  join40("meta", "encoder.json"),
+  join40("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync12(join37(planDir, relativePath), { force: true });
+    rmSync14(join40(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -17740,19 +18115,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join37(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join40(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 && (existsSync24(join37(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync25(join40(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 = join37(input.planDir, ...result.split("/"));
-      mkdirSync14(join37(input.planDir, "video-sources"), { recursive: true });
+      const destination = join40(input.planDir, ...result.split("/"));
+      mkdirSync16(join40(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -17772,7 +18147,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     useGpu: false,
     browserGpuMode: "software"
   });
-  if (!existsSync24(planDir)) mkdirSync14(planDir, { recursive: true });
+  if (!existsSync25(planDir)) mkdirSync16(planDir, { recursive: true });
   const log = config.logger ?? defaultLogger;
   const sizeLimitBytes = options.executionPlanSizeLimitBytes ?? config.planDirSizeLimitBytes ?? PLAN_DIR_SIZE_LIMIT_BYTES;
   const abortSignal = config.abortSignal;
@@ -17801,15 +18176,15 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     variables: config.variables
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join37(projectDir, entryFile);
-  if (!existsSync24(htmlPath)) {
+  const htmlPath = join40(projectDir, entryFile);
+  if (!existsSync25(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join37(planDir, ".plan-work");
-  rmSync12(workDir, { recursive: true, force: true });
-  mkdirSync14(workDir, { recursive: true });
-  const compiledDir = join37(workDir, "compiled");
-  mkdirSync14(compiledDir, { recursive: true });
+  const workDir = join40(planDir, ".plan-work");
+  rmSync14(workDir, { recursive: true, force: true });
+  mkdirSync16(workDir, { recursive: true });
+  const compiledDir = join40(workDir, "compiled");
+  mkdirSync16(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
     recursive: true,
@@ -17822,10 +18197,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join37(planDir, "compiled");
+  const finalCompiledDir = join40(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
-  const remoteLocalPath = (rel) => join37(projectDir, ...rel.split("/"));
+  const remoteLocalPath = (rel) => join40(projectDir, ...rel.split("/"));
   for (const [, file] of remoteFiles) {
     declareContentAddressedUrl(file.url, file.sha256);
     if (file.probeFactsUrl) declareProbeFactsUrl(file.url, file.probeFactsUrl);
@@ -17846,7 +18221,6 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     urlByAbsentLocalPath,
     projectDir,
     workDir,
-    htmlPath,
     entryFile,
     job,
     cfg,
@@ -18029,17 +18403,17 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   let stageStarted = Date.now();
   const extractResult = await extractPlanVideos(c, options.deferVideoExtraction);
   logPlanStage(log, "extract", stageStarted);
-  const stagedVideoFrames = join37(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join37(planDir, "video-frames");
-  if (existsSync24(videoFramesDst)) rmSync12(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join37(planDir, "video-sources");
-  rmSync12(videoSourcesDir, { recursive: true, force: true });
-  if (existsSync24(stagedVideoFrames)) {
+  const stagedVideoFrames = join40(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join40(planDir, "video-frames");
+  if (existsSync25(videoFramesDst)) rmSync14(videoFramesDst, { recursive: true, force: true });
+  const videoSourcesDir = join40(planDir, "video-sources");
+  rmSync14(videoSourcesDir, { recursive: true, force: true });
+  if (existsSync25(stagedVideoFrames)) {
     renameWithRetry8(stagedVideoFrames, videoFramesDst);
   } else {
-    mkdirSync14(videoFramesDst, { recursive: true });
+    mkdirSync16(videoFramesDst, { recursive: true });
   }
-  if (existsSync24(finalCompiledDir)) rmSync12(finalCompiledDir, { recursive: true, force: true });
+  if (existsSync25(finalCompiledDir)) rmSync14(finalCompiledDir, { recursive: true, force: true });
   renameWithRetry8(compiledDir, finalCompiledDir);
   const shipVideoSource = createVideoSourceShipper({
     planDir,
@@ -18069,7 +18443,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync14(join37(planDir, "meta"), { recursive: true });
+  mkdirSync16(join40(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -18078,8 +18452,8 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       sizeBytes
     }))
   );
-  writeFileSync9(
-    join37(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+  writeFileSync10(
+    join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -18158,11 +18532,11 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
-  const planAudioPath = join37(planDir, PLAN_AUDIO_RELATIVE_PATH);
-  if (audioResult?.hasAudio && existsSync24(audioResult.audioOutputPath)) {
+  const planAudioPath = join40(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  if (audioResult?.hasAudio && existsSync25(audioResult.audioOutputPath)) {
     renameWithRetry8(audioResult.audioOutputPath, planAudioPath);
   }
-  if (chunksCarryAudio && existsSync24(planAudioPath)) {
+  if (chunksCarryAudio && existsSync25(planAudioPath)) {
     if (options.sliceChunkAudio) {
       stageStarted = Date.now();
       await writeChunkAudioSlices({
@@ -18208,7 +18582,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     format: config.format
   };
   try {
-    rmSync12(workDir, { recursive: true, force: true });
+    rmSync14(workDir, { recursive: true, force: true });
   } catch (err) {
     log.warn("[plan] failed to remove temp work dir", {
       workDir,
@@ -18280,9 +18654,9 @@ async function plan(projectDir, config, planDir, options = {}) {
 
 // src/services/distributed/renderChunk.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync13, readdirSync as readdirSync10, rmSync as rmSync15, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync19, readFileSync as readFileSync13, readdirSync as readdirSync11, rmSync as rmSync17, writeFileSync as writeFileSync13 } from "node:fs";
 import { cpus as cpus3 } from "node:os";
-import { join as join41 } from "node:path";
+import { join as join44 } from "node:path";
 import {
   assertSwiftShader,
   BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE4,
@@ -18290,7 +18664,7 @@ import {
   classifyCaptureFailure as classifyCaptureFailure4,
   closeCaptureSession as closeCaptureSession11,
   createCaptureSession as createCaptureSession11,
-  createFrameLookupTable as createFrameLookupTable5,
+  createFrameLookupTable as createFrameLookupTable6,
   deriveBeginFrameProbeTimeTicks as deriveBeginFrameProbeTimeTicks2,
   getEncoderPreset as getEncoderPreset5,
   initializeSession as initializeSession10,
@@ -18307,34 +18681,34 @@ import {
 } from "@hyperframes/engine";
 import {
   copyFileSync as copyFileSync8,
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   lstatSync as lstatSync3,
-  mkdirSync as mkdirSync16,
+  mkdirSync as mkdirSync18,
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync12,
-  readdirSync as readdirSync9,
-  rmSync as rmSync14,
-  statSync as statSync10,
-  writeFileSync as writeFileSync11
+  readdirSync as readdirSync10,
+  rmSync as rmSync16,
+  statSync as statSync11,
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname16, isAbsolute as isAbsolute4, join as join40, relative as relative6, resolve as resolve10, sep as sep3 } from "node:path";
+import { dirname as dirname17, isAbsolute as isAbsolute4, join as join43, relative as relative6, resolve as resolve10, sep as sep3 } from "node:path";
 import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
-import { createFrameLookupTable as createFrameLookupTable4, renameWithRetry as renameWithRetry10 } from "@hyperframes/engine";
+import { createFrameLookupTable as createFrameLookupTable5, renameWithRetry as renameWithRetry10 } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Publisher.ts
 import {
   copyFileSync as copyFileSync7,
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   linkSync as linkSync2,
-  mkdirSync as mkdirSync15,
+  mkdirSync as mkdirSync17,
   mkdtempSync as mkdtempSync5,
-  rmSync as rmSync13,
-  statSync as statSync9,
-  writeFileSync as writeFileSync10
+  rmSync as rmSync15,
+  statSync as statSync10,
+  writeFileSync as writeFileSync11
 } from "node:fs";
 import { renameWithRetry as renameWithRetry9 } from "@hyperframes/engine";
-import { dirname as dirname15, join as join39 } from "node:path";
+import { dirname as dirname16, join as join42 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -18349,7 +18723,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join38 } from "node:path";
+import { join as join41 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -18359,7 +18733,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 join41(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
@@ -18394,27 +18768,27 @@ var LocalPlanV2ArtifactPublisher = class {
   #linkFile;
   #committed = false;
   constructor(destinationDir, options = {}) {
-    if (existsSync25(destinationDir)) {
+    if (existsSync26(destinationDir)) {
       throw new PlanV2IntegrityError(`output directory already exists: ${destinationDir}`);
     }
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
-    mkdirSync15(dirname15(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync5(join39(dirname15(destinationDir), ".plan-v2-publish-"));
+    mkdirSync17(dirname16(destinationDir), { recursive: true });
+    this.temporaryDir = mkdtempSync5(join42(dirname16(destinationDir), ".plan-v2-publish-"));
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
-    const sourceSize = statSync9(blob.sourcePath).size;
+    const sourceSize = statSync10(blob.sourcePath).size;
     if (sourceSize !== blob.sizeBytes) {
       throw new PlanV2IntegrityError(
         `published blob size changed for ${digest}: expected ${blob.sizeBytes}, got ${sourceSize}`
       );
     }
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
-    if (existsSync25(destinationPath)) return;
-    mkdirSync15(dirname15(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync5(join39(dirname15(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join39(stagingDir, "blob");
+    if (existsSync26(destinationPath)) return;
+    mkdirSync17(dirname16(destinationPath), { recursive: true });
+    const stagingDir = mkdtempSync5(join42(dirname16(destinationPath), ".plan-v2-blob-"));
+    const temporaryPath = join42(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -18424,24 +18798,24 @@ var LocalPlanV2ArtifactPublisher = class {
       }
       renameWithRetry9(temporaryPath, destinationPath);
     } finally {
-      rmSync13(stagingDir, { recursive: true, force: true });
+      rmSync15(stagingDir, { recursive: true, force: true });
     }
   }
   async commitManifest(manifestBytes) {
     for (const digest of new Set(manifestDigests(manifestBytes))) {
-      if (!existsSync25(planV2BlobPath(this.temporaryDir, digest))) {
+      if (!existsSync26(planV2BlobPath(this.temporaryDir, digest))) {
         throw new PlanV2IntegrityError(
           `cannot commit manifest before referenced blob is durable: ${digest}`
         );
       }
     }
-    writeFileSync10(join39(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync11(join42(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameWithRetry9(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
   async abort() {
     if (!this.#committed) {
-      rmSync13(this.temporaryDir, { recursive: true, force: true });
+      rmSync15(this.temporaryDir, { recursive: true, force: true });
     }
   }
 };
@@ -18479,8 +18853,8 @@ function listFiles(root) {
   const files = [];
   const rootResolved = resolve10(root);
   function walk(dir) {
-    for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-      const absolutePath = join40(dir, entry.name);
+    for (const entry of readdirSync10(dir, { withFileTypes: true })) {
+      const absolutePath = join43(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -18507,13 +18881,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join40(executionPlanDir, "video-frames");
-  if (!existsSync26(videoRoot)) return;
-  for (const videoEntry of readdirSync9(videoRoot, { withFileTypes: true })) {
+  const videoRoot = join43(executionPlanDir, "video-frames");
+  if (!existsSync27(videoRoot)) return;
+  for (const videoEntry of readdirSync10(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join40(videoRoot, videoEntry.name);
-    if (readdirSync9(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join40(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+    const videoDir = join43(videoRoot, videoEntry.name);
+    if (readdirSync10(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
+      const sentinelPath = join43(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -18560,15 +18934,15 @@ 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, join43(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
-    const frameNames = readdirSync9(outputDir).sort();
+    const frameNames = readdirSync10(outputDir).sort();
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join40(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join43(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -18587,7 +18961,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join40(outputDir, frameName));
+      framePaths.set(frameIndex, join43(outputDir, frameName));
     }
     return {
       ...video,
@@ -18608,11 +18982,11 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync26(videosPath)) return;
+  const videosPath = join43(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync27(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 });
+    mkdirSync18(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
   }
 }
 function parseChunkSlices(value) {
@@ -18642,13 +19016,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join40(executionPlanDir, "video-frames");
-  const hasExtractedFrames = existsSync26(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join40(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
-  if (!existsSync26(videosPath)) {
+  const videoRoot = join43(executionPlanDir, "video-frames");
+  const hasExtractedFrames = existsSync27(videoRoot) && listFiles(videoRoot).length > 0;
+  const videosPath = join43(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  if (!existsSync27(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 = join43(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -18656,7 +19030,7 @@ function buildVideoChunkDependencies(executionPlanDir, dimensions) {
   const extracted = listVideoFramePaths(executionPlanDir, parsedVideos);
   const fpsNum = readPositiveInteger2(dimensions.fpsNum, "dimensions.fpsNum");
   const fpsDen = readPositiveInteger2(dimensions.fpsDen, "dimensions.fpsDen");
-  const table = createFrameLookupTable4(
+  const table = createFrameLookupTable5(
     parsedVideos.videos,
     extracted,
     resolveRenderFpsConfig({ num: fpsNum, den: fpsDen }).value
@@ -18702,22 +19076,22 @@ function computeManifestHash(manifest) {
   return sha256Hex(`${PLAN_V2_HASH_PREFIX}${canonicalJsonStringify(manifestPayload(manifest))}`);
 }
 function writeBlob(sourcePath, destinationPath) {
-  if (existsSync26(destinationPath)) return;
-  mkdirSync16(dirname16(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync6(join40(dirname16(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join40(temporaryDir, "blob");
+  if (existsSync27(destinationPath)) return;
+  mkdirSync18(dirname17(destinationPath), { recursive: true });
+  const temporaryDir = mkdtempSync6(join43(dirname17(destinationPath), ".plan-v2-blob-"));
+  const temporaryPath = join43(temporaryDir, "blob");
   try {
     copyFileSync8(sourcePath, temporaryPath);
     renameWithRetry10(temporaryPath, destinationPath);
   } finally {
-    rmSync14(temporaryDir, { recursive: true, force: true });
+    rmSync16(temporaryDir, { recursive: true, force: true });
   }
 }
 function publishBlobFor(absolutePath, digests) {
   return {
     sourcePath: absolutePath,
     sha256: planFileSha256(absolutePath, digests),
-    sizeBytes: statSync10(absolutePath).size
+    sizeBytes: statSync11(absolutePath).size
   };
 }
 async function putBlobs(publisher, blobs) {
@@ -18741,8 +19115,8 @@ async function putTasks(tasks) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join40(executionPlanDir, "plan.json");
-  if (!existsSync26(executionPlanPath)) {
+  const executionPlanPath = join43(executionPlanDir, "plan.json");
+  if (!existsSync27(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
   const executionPlanValue = readJsonFile(executionPlanPath, "execution plan.json");
@@ -18769,7 +19143,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(join43(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) {
@@ -18822,28 +19196,28 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   };
 }
 function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
-  if (existsSync26(planV2Dir)) {
+  if (existsSync27(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publication = buildPlanV2Publication(executionPlanDir);
   if (publication.storedBlobs.length > 0) {
     throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
   }
-  mkdirSync16(dirname16(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync6(join40(dirname16(planV2Dir), ".plan-v2-build-"));
+  mkdirSync18(dirname17(planV2Dir), { recursive: true });
+  const tempDir = mkdtempSync6(join43(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(
+      join43(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
     renameWithRetry10(tempDir, planV2Dir);
     return resultFromManifest(planV2Dir, publication.manifest);
   } catch (error) {
-    rmSync14(tempDir, { recursive: true, force: true });
+    rmSync16(tempDir, { recursive: true, force: true });
     throw error;
   }
 }
@@ -18877,7 +19251,7 @@ async function publishExecutionPlan(executionPlanDir, publisher, { digests, log
   }
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync6(join40(options.stagingParentDir ?? tmpdir3(), ".execution-plan-"));
+  const stagingRoot = mkdtempSync6(join43(options.stagingParentDir ?? tmpdir3(), ".execution-plan-"));
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -18888,7 +19262,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(join43(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -18904,16 +19278,16 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
     }
     throw error;
   } finally {
-    rmSync14(stagingRoot, { recursive: true, force: true });
+    rmSync16(stagingRoot, { recursive: true, force: true });
   }
 }
 async function planV2(projectDir, config, planV2Dir) {
-  if (existsSync26(planV2Dir)) {
+  if (existsSync27(planV2Dir)) {
     throw new PlanV2IntegrityError(`output directory already exists: ${planV2Dir}`);
   }
   const publisher = new LocalPlanV2ArtifactPublisher(planV2Dir);
   const manifest = await planV2WithPublisher(projectDir, config, publisher, {
-    stagingParentDir: dirname16(planV2Dir)
+    stagingParentDir: dirname17(planV2Dir)
   });
   return resultFromManifest(planV2Dir, manifest);
 }
@@ -18925,7 +19299,7 @@ function resultFromManifest(planV2Dir, manifest) {
       isRecord3(executionPlan) ? executionPlan[REFERENCE_BACKGROUND_FIELD3] : void 0
     ),
     planDir: planV2Dir,
-    manifestPath: join40(planV2Dir, "plan.json"),
+    manifestPath: join43(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -19061,8 +19435,8 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join40(planV2Dir, "plan.json");
-  if (!existsSync26(manifestPath)) {
+  const manifestPath = join43(planV2Dir, "plan.json");
+  if (!existsSync27(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
   const value = readJsonFile(manifestPath, "v2 manifest");
@@ -19081,10 +19455,10 @@ function listPlanV2ArtifactsForTarget(manifest, target) {
 }
 function verifyBlob(planV2Dir, artifact) {
   const sourcePath = planV2BlobPath(planV2Dir, artifact.sha256);
-  if (!existsSync26(sourcePath)) {
+  if (!existsSync27(sourcePath)) {
     throw new PlanV2IntegrityError(`missing content-addressed artifact ${artifact.sha256}`);
   }
-  const stats = statSync10(sourcePath);
+  const stats = statSync11(sourcePath);
   if (!stats.isFile() || stats.size !== artifact.sizeBytes) {
     throw new PlanV2IntegrityError(`artifact size mismatch for ${artifact.path}`);
   }
@@ -19094,7 +19468,7 @@ function verifyBlob(planV2Dir, artifact) {
   return sourcePath;
 }
 function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}) {
-  if (existsSync26(destinationDir)) {
+  if (existsSync27(destinationDir)) {
     throw new PlanV2IntegrityError(`materialization destination already exists: ${destinationDir}`);
   }
   const manifest = readPlanV2Manifest(planV2Dir);
@@ -19106,17 +19480,17 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     artifact,
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
-  mkdirSync16(dirname16(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync6(join40(dirname16(destinationDir), ".plan-v2-materialize-"));
+  mkdirSync18(dirname17(destinationDir), { recursive: true });
+  const tempDir = mkdtempSync6(join43(dirname17(destinationDir), ".plan-v2-materialize-"));
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join40(tempDir, ...artifact.path.split("/"));
-      mkdirSync16(dirname16(destinationPath), { recursive: true });
+      const destinationPath = join43(tempDir, ...artifact.path.split("/"));
+      mkdirSync18(dirname17(destinationPath), { recursive: true });
       copyFileSync8(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
-    writeFileSync11(
-      join40(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+    writeFileSync12(
+      join43(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({
         manifest,
         target,
@@ -19126,7 +19500,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     );
     renameWithRetry10(tempDir, destinationDir);
   } catch (error) {
-    rmSync14(tempDir, { recursive: true, force: true });
+    rmSync16(tempDir, { recursive: true, force: true });
     throw error;
   }
   return {
@@ -19139,7 +19513,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 ? join43(destinationDir, audioArtifact.path) : null : null
   };
 }
 function assertRemoteSources(remoteSources, artifacts) {
@@ -19158,8 +19532,8 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   return readValidatedPlanV2Materialization(planDir, expectedTarget)?.manifest ?? null;
 }
 function readValidatedPlanV2Materialization(planDir, expectedTarget) {
-  const markerPath = join40(planDir, PLAN_V2_MATERIALIZATION_MARKER);
-  if (!existsSync26(markerPath)) return null;
+  const markerPath = join43(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  if (!existsSync27(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
     throw new PlanV2IntegrityError("malformed materialization marker");
@@ -19176,8 +19550,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) || statSync10(path).size !== artifact.sizeBytes) {
+    const path = join43(planDir, ...artifact.path.split("/"));
+    if (!existsSync27(path) || statSync11(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
       );
@@ -19295,9 +19669,9 @@ async function beginFrameSessionNeedsScreenshotFallback(session, probe = probeBe
 }
 function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync13(outputPath));
-  const entries = readdirSync10(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
+  const entries = readdirSync11(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync13(join41(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync13(join44(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -19314,10 +19688,10 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join41(planDir, "plan.json");
-  const encoderJsonPath = join41(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join41(planDir, "meta", "chunks.json");
-  if (!existsSync27(planJsonPath)) {
+  const planJsonPath = join44(planDir, "plan.json");
+  const encoderJsonPath = join44(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join44(planDir, "meta", "chunks.json");
+  if (!existsSync28(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir is missing required artifact: ${planJsonPath}`
@@ -19333,7 +19707,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const v2Manifest = v2Materialization?.manifest ?? null;
   const remoteSources = v2Materialization?.remoteSources ?? {};
   for (const required of [encoderJsonPath, chunksJsonPath]) {
-    if (!existsSync27(required)) {
+    if (!existsSync28(required)) {
       throw new RenderChunkValidationError(
         MISSING_PLAN_ARTIFACT,
         `[renderChunk] planDir is missing required artifact: ${required}`
@@ -19342,9 +19716,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const encoder = JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join41(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join44(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
-  if (existsSync27(videosJsonPath)) {
+  if (existsSync28(videosJsonPath)) {
     try {
       planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync13(videosJsonPath, "utf-8")));
     } catch (err) {
@@ -19374,8 +19748,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const range = resolveChunkFrameRange(slice, chunkIndex, options?.frameRange);
   const framesInChunk = range.endFrame - range.startFrame;
-  const compiledDir = join41(planDir, "compiled");
-  if (!existsSync27(compiledDir)) {
+  const compiledDir = join44(planDir, "compiled");
+  if (!existsSync28(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
       `[renderChunk] planDir missing compiled/ directory: ${compiledDir}`
@@ -19431,14 +19805,14 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       forceScreenshotExplicitlyOptedOut: !encoder.forceScreenshot
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
-    mkdirSync17(workDir, { recursive: true });
-    const framesDir = join41(workDir, "captured-frames");
-    mkdirSync17(framesDir, { recursive: true });
+    mkdirSync19(workDir, { recursive: true });
+    const framesDir = join44(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 };
     const deferredVideos = planVideos?.extracted.filter((video) => video.deferredRange) ?? [];
-    const shownFrames = planVideos ? shownDeferredFrameIndexes(planVideos, chunkFrameNumbers, chunkFps) : /* @__PURE__ */ new Map();
+    const shownFrames = planVideos ? shownPlanFrameIndexes(planVideos, chunkFrameNumbers, chunkFps) : /* @__PURE__ */ new Map();
     const remoteVideoIds = new Set(
       planVideos?.extracted.filter(
         (video) => video.deferredRange && Object.hasOwn(remoteSources, video.deferredRange.sourcePath)
@@ -19457,7 +19831,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync13(join41(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync13(join44(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)
@@ -19592,7 +19966,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       deferredVideoFrames.catch(() => {
       });
       const videoFrameLookup = planVideos && planVideos.extracted.length > 0 ? deferredVideoFrames.then(
-        (deferred) => createFrameLookupTable5(
+        (deferred) => createFrameLookupTable6(
           planVideos.videos,
           [
             ...rebuildExtractedFramesFromPlanDir(
@@ -19625,10 +19999,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 (!existsSync27(outputChunkPath)) mkdirSync17(outputChunkPath, { recursive: true });
+        if (!existsSync28(outputChunkPath)) mkdirSync19(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join41(outputChunkPath, "..");
-        if (!existsSync27(outDir)) mkdirSync17(outDir, { recursive: true });
+        const outDir = join44(outputChunkPath, "..");
+        if (!existsSync28(outDir)) mkdirSync19(outDir, { recursive: true });
       }
       const encodeInput = {
         job,
@@ -19744,9 +20118,9 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           return observedChunkCaptureMode(capturePerfs);
         },
         resetForScreenshotRetry: () => {
-          rmSync15(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          rmSync17(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
           boxesMeasured();
-          mkdirSync17(framesDir, { recursive: true });
+          mkdirSync19(framesDir, { recursive: true });
           capturePerfs.length = 0;
           captureAttempts.length = 0;
           job.framesRendered = 0;
@@ -19790,8 +20164,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
           fps: { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen },
           timeoutMs: cfg.ffmpegProcessTimeout
         });
-        rmSync15(videoOnlyPath, { force: true });
-        rmSync15(audioScratchPath, { force: true });
+        rmSync17(videoOnlyPath, { force: true });
+        rmSync17(audioScratchPath, { force: true });
       }
       encodeStageMs = Date.now() - encodeStarted;
     } finally {
@@ -19838,11 +20212,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       producerVersion: plan2.producerVersion,
       ffmpegVersion
     };
-    writeFileSync12(perfPath, `${JSON.stringify(perfPayload, null, 2)}
+    writeFileSync13(perfPath, `${JSON.stringify(perfPayload, null, 2)}
 `, "utf-8");
     try {
-      rmSync15(workDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-      rmSync15(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,
@@ -19901,11 +20275,11 @@ async function renderSpan(projectDir, config, span, outputPath) {
   if (config.cfr === true) {
     throw new RenderSpanUnsupportedError("--start/--end cannot be combined with a cfr re-encode.");
   }
-  const workDir = mkdtempSync7(join42(tmpdir4(), "hf-render-span-"));
+  const workDir = mkdtempSync7(join45(tmpdir4(), "hf-render-span-"));
   try {
-    const planDir = join42(workDir, "plan");
-    const partsDir = join42(workDir, "parts");
-    mkdirSync18(partsDir, { recursive: true });
+    const planDir = join45(workDir, "plan");
+    const partsDir = join45(workDir, "parts");
+    mkdirSync20(partsDir, { recursive: true });
     const planned = await plan(
       projectDir,
       { ...config, rejectOnSystemFonts: false, failClosedFontFetch: false },
@@ -19919,7 +20293,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       planned.totalFrames
     );
     const slices = JSON.parse(
-      readFileSync14(join42(planDir, "meta", "chunks.json"), "utf-8")
+      readFileSync14(join45(planDir, "meta", "chunks.json"), "utf-8")
     );
     const parts = [];
     for (const slice of slices) {
@@ -19929,7 +20303,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       };
       if (range.endFrame <= range.startFrame) continue;
       throwIfAborted(config.abortSignal);
-      const part = join42(partsDir, `part-${String(parts.length).padStart(4, "0")}.mp4`);
+      const part = join45(partsDir, `part-${String(parts.length).padStart(4, "0")}.mp4`);
       await renderChunk(planDir, slice.index, part, { frameRange: range });
       parts.push(part);
     }
@@ -19942,7 +20316,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       framesEncoded: endFrame - startFrame
     };
   } finally {
-    rmSync16(workDir, { recursive: true, force: true });
+    rmSync18(workDir, { recursive: true, force: true });
   }
 }
 
@@ -20518,7 +20892,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/index.ts
-import { createVideoFrameInjector as createVideoFrameInjector3 } from "@hyperframes/engine";
+import { createVideoFrameInjector as createVideoFrameInjector4 } from "@hyperframes/engine";
 
 // src/config.ts
 import {
@@ -20528,15 +20902,15 @@ import {
 
 // src/server.ts
 import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync19,
-  statSync as statSync12,
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync21,
+  statSync as statSync13,
   mkdtempSync as mkdtempSync8,
-  writeFileSync as writeFileSync13,
-  rmSync as rmSync17,
+  writeFileSync as writeFileSync14,
+  rmSync as rmSync19,
   createReadStream as createReadStream5
 } from "node:fs";
-import { resolve as resolve12, dirname as dirname18, join as join45 } from "node:path";
+import { resolve as resolve12, dirname as dirname19, join as join48 } from "node:path";
 import { tmpdir as tmpdir5 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -20551,15 +20925,15 @@ import {
 
 // src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   readFileSync as readFileSync15,
-  statSync as statSync11,
+  statSync as statSync12,
   openSync as openSync7,
   fstatSync as fstatSync3,
   closeSync as closeSync7,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve11, join as join43, relative as relative7, isAbsolute as isAbsolute5, sep as sep4 } from "node:path";
+import { resolve as resolve11, join as join46, relative as relative7, isAbsolute as isAbsolute5, sep as sep4 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -20593,7 +20967,7 @@ function readEntryHtml(filePath) {
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
       return null;
-    if (!statSync11(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    if (!statSync12(filePath, { throwIfNoEntry: false })?.isFile()) return null;
     throw error;
   }
   try {
@@ -20605,7 +20979,7 @@ function readEntryHtml(filePath) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve11(projectDir);
-  if (!existsSync28(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
+  if (!existsSync29(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -20627,7 +21001,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join43(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join46(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -20673,8 +21047,8 @@ 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 dirname17, join as join44 } from "node:path";
-import { existsSync as existsSync29 } from "node:fs";
+import { dirname as dirname18, join as join47 } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -20748,10 +21122,10 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname17(fileURLToPath6(import.meta.url));
-  const candidates = [join44(here, "healthWorkerThread.js"), join44(here, "healthWorkerThread.ts")];
+  const here = dirname18(fileURLToPath6(import.meta.url));
+  const candidates = [join47(here, "healthWorkerThread.js"), join47(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync29(candidate)) return candidate;
+    if (existsSync30(candidate)) return candidate;
   }
   return void 0;
 }
@@ -20896,8 +21270,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 = dirname18(absoluteOutputPath);
-  if (!existsSync30(outputDir)) mkdirSync19(outputDir, { recursive: true });
+  const outputDir = dirname19(absoluteOutputPath);
+  if (!existsSync31(outputDir)) mkdirSync21(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -20938,11 +21312,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve12(candidate);
-  if (!existsSync30(absProjectDir) || !statSync12(absProjectDir).isDirectory()) {
+  if (!existsSync31(absProjectDir) || !statSync13(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync30(resolve12(absProjectDir, entry))) {
+  if (!existsSync31(resolve12(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -20963,8 +21337,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir5();
-  const tempProjectDir = mkdtempSync8(join45(tempRoot, "producer-project-"));
-  writeFileSync13(join45(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync8(join48(tempRoot, "producer-project-"));
+  writeFileSync14(join48(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -21025,7 +21399,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync17(dir, { recursive: true, force: true });
+    rmSync19(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -21034,7 +21408,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync30(path) ? statSync12(path).size : 0;
+  return existsSync31(path) ? statSync13(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -21338,11 +21712,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync30(artifact.path)) {
+    if (!existsSync31(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync12(artifact.path);
+    const stats = statSync13(artifact.path);
     return new Response(createReadStream5(artifact.path), {
       headers: {
         "content-type": "video/mp4",
@@ -21433,9 +21807,9 @@ import {
 import { quantizeTimeToFrame, MEDIA_VISUAL_STYLE_PROPERTIES } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync10, rmSync as rmSync19 } from "node:fs";
+import { mkdtempSync as mkdtempSync10, rmSync as rmSync21 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
-import { join as join47 } from "node:path";
+import { join as join50 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
@@ -21444,16 +21818,16 @@ import {
 } from "@hyperframes/engine";
 import {
   cpSync as cpSync3,
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync22,
   mkdtempSync as mkdtempSync9,
   readFileSync as readFileSync16,
-  readdirSync as readdirSync11,
-  rmSync as rmSync18,
-  statSync as statSync13,
-  writeFileSync as writeFileSync14
+  readdirSync as readdirSync12,
+  rmSync as rmSync20,
+  statSync as statSync14,
+  writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname19, join as join46 } from "node:path";
+import { dirname as dirname20, join as join49 } from "node:path";
 import {
   appendRateCapArgs as appendRateCapArgs2,
   appendRenderProvenanceArgs as appendRenderProvenanceArgs2,
@@ -21494,13 +21868,13 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       outputPath,
       durationMs: Date.now() - start,
       framesEncoded: plan2.totalFrames,
-      fileSize: statSync13(outputPath).size
+      fileSize: statSync14(outputPath).size
     };
   }
   const format = plan2.dimensions.format;
   const cfrEncoder = cfr ? readCfrEncoder(planDir, format) : null;
-  if (!existsSync31(dirname19(outputPath))) {
-    mkdirSync20(dirname19(outputPath), { recursive: true });
+  if (!existsSync32(dirname20(outputPath))) {
+    mkdirSync22(dirname20(outputPath), { recursive: true });
   }
   const workDir = mkdtempSync9(`${outputPath}.assemble-work-`);
   const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
@@ -21522,8 +21896,8 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join46(workDir, `output.${format}`);
-    const audio = audioPath !== null && existsSync31(audioPath) ? audioPath : null;
+    const finalPath = join49(workDir, `output.${format}`);
+    const audio = audioPath !== null && existsSync32(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameWithRetry11(finalPath, outputPath);
     log.info("[assemble] stage timings", {
@@ -21533,7 +21907,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
     });
   } finally {
     try {
-      rmSync18(workDir, { recursive: true, force: true });
+      rmSync20(workDir, { recursive: true, force: true });
     } catch (err) {
       log.warn("[assemble] failed to remove work dir", {
         workDir,
@@ -21541,7 +21915,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
       });
     }
   }
-  const fileSize = existsSync31(outputPath) ? statSync13(outputPath).size : 0;
+  const fileSize = existsSync32(outputPath) ? statSync14(outputPath).size : 0;
   return {
     ...referenceBackgroundResult8(plan2[REFERENCE_BACKGROUND_FIELD6]),
     outputPath,
@@ -21551,15 +21925,15 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join46(planDir, "plan.json");
-  const chunksJsonPath = join46(planDir, "meta", "chunks.json");
-  if (!existsSync31(planJsonPath)) {
+  const planJsonPath = join49(planDir, "plan.json");
+  const chunksJsonPath = join49(planDir, "meta", "chunks.json");
+  if (!existsSync32(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
   const plan2 = JSON.parse(readFileSync16(planJsonPath, "utf-8"));
   readPlanProtocolV1(plan2, DISTRIBUTED_RENDER_CAPABILITIES.roles.assembler);
   validatePlanV2MaterializedTarget(planDir, { role: "assembler" });
-  if (!existsSync31(chunksJsonPath)) {
+  if (!existsSync32(chunksJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/chunks.json: ${chunksJsonPath}`);
   }
   const chunks = JSON.parse(readFileSync16(chunksJsonPath, "utf-8"));
@@ -21574,7 +21948,7 @@ function readAssemblePlan(planDir, chunkPaths) {
     }
   }
   for (const path of chunkPaths.flat()) {
-    if (!existsSync31(path)) {
+    if (!existsSync32(path)) {
       throw new Error(`[assemble] chunk path does not exist: ${path}`);
     }
   }
@@ -21603,7 +21977,7 @@ function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
   return args;
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join46(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join49(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
@@ -21630,7 +22004,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join46(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join49(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -21670,9 +22044,9 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join46(workDir, "concat-list.txt");
+  const listPath = join49(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
-  writeFileSync14(listPath, `${body}
+  writeFileSync15(listPath, `${body}
 `, "utf-8");
   return ["-r", fpsArg, "-f", "concat", "-safe", "0", "-i", listPath];
 }
@@ -21708,12 +22082,12 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync16(join46(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync16(join49(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
-  const encoderJsonPath = join46(planDir, "meta", "encoder.json");
-  if (!existsSync31(encoderJsonPath)) return {};
+  const encoderJsonPath = join49(planDir, "meta", "encoder.json");
+  if (!existsSync32(encoderJsonPath)) return {};
   return JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
 }
 function readCfrEncoder(planDir, format) {
@@ -21722,8 +22096,8 @@ function readCfrEncoder(planDir, format) {
       `[assemble] cfr=true is only supported for format="mp4" (got "${format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
     );
   }
-  const encoderJsonPath = join46(planDir, "meta", "encoder.json");
-  if (!existsSync31(encoderJsonPath)) {
+  const encoderJsonPath = join49(planDir, "meta", "encoder.json");
+  if (!existsSync32(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
   const encoderJson = JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
@@ -21735,22 +22109,22 @@ function readCfrEncoder(planDir, format) {
   return encoderJson;
 }
 function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, startTimeMs) {
-  if (existsSync31(outputPath)) rmSync18(outputPath, { recursive: true, force: true });
-  mkdirSync20(outputPath, { recursive: true });
+  if (existsSync32(outputPath)) rmSync20(outputPath, { recursive: true, force: true });
+  mkdirSync22(outputPath, { recursive: true });
   let globalIdx = 0;
   for (const chunkDir of chunkPaths) {
-    if (!statSync13(chunkDir).isDirectory()) {
+    if (!statSync14(chunkDir).isDirectory()) {
       throw new Error(
         `[assemble] png-sequence chunk must be a directory: ${chunkDir} (got a file)`
       );
     }
-    const frames = readdirSync11(chunkDir).filter((name) => name.endsWith(".png")).sort();
+    const frames = readdirSync12(chunkDir).filter((name) => name.endsWith(".png")).sort();
     if (frames.length === 0) {
       throw new Error(`[assemble] png-sequence chunk has no frames: ${chunkDir}`);
     }
     for (const frame of frames) {
-      const dst = join46(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join46(chunkDir, frame), dst);
+      const dst = join49(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join49(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -21759,14 +22133,14 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       `[assemble] png-sequence frame count mismatch: merged ${globalIdx} frames vs plan.totalFrames=${totalFrames}. Using on-disk count.`
     );
   }
-  if (audioPath !== null && existsSync31(audioPath)) {
-    const sidecar = join46(outputPath, MIXED_AUDIO_FILENAME4);
+  if (audioPath !== null && existsSync32(audioPath)) {
+    const sidecar = join49(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
-  for (const name of readdirSync11(outputPath)) {
+  for (const name of readdirSync12(outputPath)) {
     try {
-      fileSize += statSync13(join46(outputPath, name)).size;
+      fileSize += statSync14(join49(outputPath, name)).size;
     } catch {
     }
   }
@@ -21780,18 +22154,18 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
-  const workRoot = mkdtempSync10(join47(tmpdir6(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join47(workRoot, "plan");
+  const workRoot = mkdtempSync10(join50(tmpdir6(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join50(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath, options);
   } finally {
-    rmSync19(workRoot, { recursive: true, force: true });
+    rmSync21(workRoot, { recursive: true, force: true });
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync10(join47(tmpdir6(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join47(workRoot, "plan");
+  const workRoot = mkdtempSync10(join50(tmpdir6(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join50(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,
@@ -21806,7 +22180,7 @@ async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
       options
     );
   } finally {
-    rmSync19(workRoot, { recursive: true, force: true });
+    rmSync21(workRoot, { recursive: true, force: true });
   }
 }
 
@@ -21857,7 +22231,7 @@ export {
   createRenderHandlers,
   createRenderJob,
   createRenderRequest,
-  createVideoFrameInjector3 as createVideoFrameInjector,
+  createVideoFrameInjector4 as createVideoFrameInjector,
   defaultLogger,
   distributedConfigFromRequest,
   executeRenderJob,