@hyperframes/producer 0.9.15 → 0.9.17

package/dist/public-server.js

@@ -2,15 +2,15 @@
 
 // src/server.ts
 import {
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync11,
-  statSync as statSync10,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync13,
+  statSync as statSync11,
   mkdtempSync as mkdtempSync4,
-  writeFileSync as writeFileSync7,
-  rmSync as rmSync11,
+  writeFileSync as writeFileSync8,
+  rmSync as rmSync13,
   createReadStream as createReadStream3
 } from "node:fs";
-import { resolve as resolve10, dirname as dirname14, join as join32 } from "node:path";
+import { resolve as resolve10, dirname as dirname15, join as join35 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -26,12 +26,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";
@@ -46,16 +46,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,
@@ -79,13 +77,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";
@@ -2030,6 +2029,7 @@ import {
   getCapturePerfSummary as getCapturePerfSummary2,
   initializeSession as initializeSession2,
   prepareCaptureSessionForReuse as prepareCaptureSessionForReuse2,
+  resolveDeVerifyMinDb as resolveDeVerifyMinDb2,
   shouldDisableBrowserPoolForParallelWorker,
   spawnStreamingEncoder as spawnStreamingEncoder2
 } from "@hyperframes/engine";
@@ -3900,42 +3900,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;
@@ -4399,6 +4404,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();
@@ -4415,6 +4421,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);
@@ -4523,6 +4530,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();
@@ -4537,6 +4548,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 {
@@ -4589,16 +4619,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 {
@@ -4613,12 +4643,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
@@ -4631,6 +4661,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;
@@ -4642,12 +4685,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,
@@ -4658,6 +4703,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,
@@ -4677,7 +4724,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})`, {
@@ -4745,6 +4793,7 @@ async function concatResumedRun(run, segmentPaths) {
     input.abortSignal,
     input.cfg
   );
+  removeJoinedSegments(run, segmentPaths);
   return {
     success: true,
     encodeMs: 0,
@@ -4819,6 +4868,7 @@ async function runCaptureSegmentedStage(input) {
     input.abortSignal,
     input.cfg
   );
+  removeJoinedSegments(run, segmentPaths);
   return {
     success: true,
     encodeMs: run.totals.encodeMs,
@@ -5250,10 +5300,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 runs = [];
+  for (const index of sortedIndexes) {
+    const last = runs[runs.length - 1];
+    if (last && last.firstFrame + last.frames === index) last.frames++;
+    else runs.push({ firstFrame: index, frames: 1 });
+  }
+  return runs;
+}
+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(
+    (sum, video) => sum + (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 child2 = join14(path, entry.name);
+    try {
+      bytes += entry.isDirectory() ? directoryBytes(child2) : statSync4(child2).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) {
@@ -5281,7 +5594,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";
@@ -5299,7 +5612,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"));
@@ -5309,10 +5622,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 {
@@ -5330,7 +5643,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;
@@ -5873,7 +6186,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,
@@ -5908,14 +6221,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,
@@ -6161,8 +6477,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";
@@ -6211,7 +6527,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;
@@ -6318,11 +6634,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()}`;
@@ -6346,10 +6662,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;
     }
   }
@@ -6405,7 +6721,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);
@@ -6432,8 +6748,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,
@@ -6470,15 +6786,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";
 
@@ -6718,14 +7034,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`;
@@ -6743,8 +7059,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)) {
@@ -6752,7 +7068,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();
@@ -6773,7 +7089,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);
@@ -6785,8 +7101,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 };
 }
@@ -7110,8 +7426,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
@@ -7121,7 +7437,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)) {
@@ -7282,7 +7598,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,
@@ -7712,7 +8028,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) => {
@@ -7759,7 +8075,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)"
   );
@@ -7774,7 +8090,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)"
   );
@@ -7790,7 +8106,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
@@ -7900,7 +8216,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);
@@ -7942,7 +8258,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}")`)
@@ -8614,11 +8930,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,
@@ -8629,8 +8970,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,
@@ -8638,7 +8980,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();
@@ -8695,7 +9037,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join16(workDir, "compiled"),
+    compiledDir: join19(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -8741,7 +9083,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,
@@ -8950,7 +9292,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
@@ -8980,7 +9322,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
@@ -9065,7 +9407,7 @@ async function runProbeStage(input) {
           });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join17(workDir, "probe-screenshot"),
+            join20(workDir, "probe-screenshot"),
             captureOpts,
             null,
             { ...probeCfg, forceScreenshot: true }
@@ -9103,7 +9445,7 @@ async function runProbeStage(input) {
             compiled,
             resolutions,
             projectDir,
-            join17(workDir, "downloads")
+            join20(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -9294,7 +9636,7 @@ async function runProbeStage(input) {
     }
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join17(workDir, "compiled"),
+      compiledDir: join20(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -9428,11 +9770,11 @@ function validateRenderDuration(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,
@@ -9444,7 +9786,7 @@ import {
   resolveVideoExtractionWindow as resolveVideoExtractionWindow2,
   isHttpUrl as isHttpUrl2,
   resolveProjectRelativeSrc as resolveProjectRelativeSrc3,
-  runVideoExtractionWithRetry,
+  runVideoExtractionWithRetry as runVideoExtractionWithRetry2,
   safeVideoExtractionSourceIdentity,
   videoAudioId as videoAudioId2
 } from "@hyperframes/engine";
@@ -9698,9 +10040,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: () => {
@@ -9736,7 +10078,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);
@@ -9770,14 +10112,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;
@@ -9797,7 +10139,7 @@ async function runExtractVideosStage(input) {
       materializeSymlinks
     });
     if (extractionResult.extracted.length > 0) {
-      frameLookup = createFrameLookupTable(
+      frameLookup = createFrameLookupTable3(
         composition.videos,
         extractionResult.extracted,
         resolveRenderFpsConfig(job.config.fps).value
@@ -9856,7 +10198,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,
@@ -9876,7 +10218,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,
@@ -9944,7 +10286,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(
@@ -9959,8 +10301,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,
@@ -9970,8 +10312,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,
@@ -9982,7 +10324,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,
@@ -10261,7 +10603,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);
@@ -10275,8 +10617,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;
@@ -10467,31 +10809,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,
@@ -10499,13 +10867,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
@@ -10531,7 +10900,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 {
@@ -10547,7 +10916,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;
       }
     }
@@ -10596,7 +10965,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;
@@ -10607,7 +10976,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join21(workDir, "audio-work"),
+        join24(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -10675,8 +11044,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,
@@ -10746,16 +11115,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;
@@ -11049,8 +11418,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,
@@ -11122,7 +11491,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
@@ -11247,7 +11616,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
         );
       }
@@ -11279,7 +11648,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,
@@ -11293,9 +11662,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) {
@@ -11306,10 +11675,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) {
@@ -11677,7 +12046,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
             );
           }
@@ -11868,9 +12237,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;
@@ -12026,16 +12395,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,
@@ -12128,12 +12497,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");
@@ -12160,7 +12529,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,
@@ -12169,7 +12538,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) {
@@ -12246,7 +12615,7 @@ function encodeWhileCapturing(input, totalFrames) {
         await new Promise((resolve11) => wake = resolve11);
       }
       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)) {
@@ -12321,19 +12690,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}`
       );
@@ -12353,7 +12722,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
@@ -12559,14 +12928,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()) {
@@ -12714,18 +13083,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) {
@@ -12741,7 +13106,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) {
@@ -12801,8 +13166,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) {
@@ -12849,8 +13214,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;
 }
@@ -12875,7 +13240,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,
@@ -13507,19 +13872,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,
@@ -13533,7 +13898,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({
@@ -13581,7 +13946,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,
@@ -13657,7 +14022,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 });
     }
@@ -13686,36 +14051,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"
@@ -13727,7 +14067,6 @@ async function executeRenderPipeline(input) {
       () => runCompileStage({
         projectDir,
         workDir,
-        htmlPath,
         entryFile,
         job,
         cfg,
@@ -13889,7 +14228,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}`);
@@ -13907,7 +14246,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",
@@ -13924,6 +14278,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
       })
     );
@@ -14020,7 +14375,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
@@ -14038,8 +14393,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"
     });
@@ -14117,7 +14472,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"
@@ -14283,32 +14686,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;
@@ -14540,7 +14952,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);
@@ -14641,13 +15053,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,
@@ -14687,10 +15093,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",
@@ -14828,7 +15238,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);
@@ -14843,10 +15253,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,
@@ -14896,6 +15306,7 @@ async function executeRenderPipeline(input) {
               },
               buildCaptureOptions: buildWorkerCaptureOptions,
               createRenderVideoFrameInjector,
+              segmentVideoFrames: videoFrameWindow ? buildSegmentVideoFrames() : void 0,
               abortSignal: executionSignal,
               assertNotAborted,
               onProgress,
@@ -14947,7 +15358,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;
@@ -14986,11 +15397,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",
@@ -15261,8 +15673,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;
@@ -15367,7 +15779,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({
@@ -15439,7 +15851,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,
@@ -15448,8 +15860,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);
       }
     }
@@ -15560,15 +15972,15 @@ async function executeRenderPipeline(input) {
 
 // src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   readFileSync as readFileSync9,
-  statSync as statSync9,
+  statSync as statSync10,
   openSync as openSync5,
   fstatSync as fstatSync3,
   closeSync as closeSync5,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve9, join as join29, relative as relative3, isAbsolute as isAbsolute3, sep as sep2 } from "node:path";
+import { resolve as resolve9, join as join32, relative as relative3, isAbsolute as isAbsolute3, sep as sep2 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -15602,7 +16014,7 @@ function readEntryHtml(filePath) {
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
       return null;
-    if (!statSync9(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    if (!statSync10(filePath, { throwIfNoEntry: false })?.isFile()) return null;
     throw error;
   }
   try {
@@ -15614,7 +16026,7 @@ function readEntryHtml(filePath) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve9(projectDir);
-  if (!existsSync20(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
+  if (!existsSync21(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -15636,7 +16048,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join29(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join32(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -15682,8 +16094,8 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { dirname as dirname13, join as join30 } from "node:path";
-import { existsSync as existsSync21 } from "node:fs";
+import { dirname as dirname14, join as join33 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -15757,10 +16169,10 @@ function defaultLogger2() {
   };
 }
 function resolveWorkerEntry2() {
-  const here = dirname13(fileURLToPath5(import.meta.url));
-  const candidates = [join30(here, "healthWorkerThread.js"), join30(here, "healthWorkerThread.ts")];
+  const here = dirname14(fileURLToPath5(import.meta.url));
+  const candidates = [join33(here, "healthWorkerThread.js"), join33(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync21(candidate)) return candidate;
+    if (existsSync22(candidate)) return candidate;
   }
   return void 0;
 }
@@ -15800,7 +16212,7 @@ import {
   createReferenceBackgroundRecorder as createReferenceBackgroundRecorder2
 } from "@hyperframes/engine";
 import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframes/engine";
-import { extname as extname4, isAbsolute as isAbsolute4, join as join31, relative as relative4, sep as sep3 } from "node:path";
+import { extname as extname4, isAbsolute as isAbsolute4, join as join34, relative as relative4, sep as sep3 } from "node:path";
 import {
   fpsToNumber as fpsToNumber9,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -15819,16 +16231,14 @@ import {
 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 {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
-  createFrameLookupTable as createFrameLookupTable2,
-  createVideoFrameInjector as createVideoFrameInjector2,
-  extractVideoFramesRange
+  createVideoFrameInjector as createVideoFrameInjector3
 } from "@hyperframes/engine";
 
 // src/services/distributed/shared.ts
@@ -15919,9 +16329,9 @@ var PLAN_ROOT_CATEGORY = {
 var PLAN_DIR_SIZE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join31("meta", "composition.json"),
-  join31("meta", "encoder.json"),
-  join31("meta", "chunks.json")
+  join34("meta", "composition.json"),
+  join34("meta", "encoder.json"),
+  join34("meta", "chunks.json")
 ];
 
 // src/services/distributed/renderConfigValidation.ts
@@ -16309,8 +16719,8 @@ function buildRenderJobConfig(input, outputPath, log) {
 function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
-  const outputDir = dirname14(absoluteOutputPath);
-  if (!existsSync22(outputDir)) mkdirSync11(outputDir, { recursive: true });
+  const outputDir = dirname15(absoluteOutputPath);
+  if (!existsSync23(outputDir)) mkdirSync13(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -16351,11 +16761,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve10(candidate);
-  if (!existsSync22(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
+  if (!existsSync23(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync22(resolve10(absProjectDir, entry))) {
+  if (!existsSync23(resolve10(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -16376,8 +16786,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir3();
-  const tempProjectDir = mkdtempSync4(join32(tempRoot, "producer-project-"));
-  writeFileSync7(join32(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync4(join35(tempRoot, "producer-project-"));
+  writeFileSync8(join35(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -16438,7 +16848,7 @@ function createArtifactStore(ttlMs) {
 function cleanupTempDir(dir, log) {
   if (!dir) return;
   try {
-    rmSync11(dir, { recursive: true, force: true });
+    rmSync13(dir, { recursive: true, force: true });
   } catch (error) {
     log.warn("Failed to cleanup temp project dir", {
       cleanupProjectDir: dir,
@@ -16447,7 +16857,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync22(path) ? statSync10(path).size : 0;
+  return existsSync23(path) ? statSync11(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -16751,11 +17161,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync22(artifact.path)) {
+    if (!existsSync23(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync10(artifact.path);
+    const stats = statSync11(artifact.path);
     return new Response(createReadStream3(artifact.path), {
       headers: {
         "content-type": "video/mp4",