@hyperframes/producer 0.9.19 → 0.9.21

package/dist/public-server.js

@@ -2,7 +2,7 @@
 
 // src/server.ts
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync13,
   statSync as statSync11,
   mkdtempSync as mkdtempSync4,
@@ -26,7 +26,7 @@ import {
 // src/services/renderOrchestrator.ts
 import { audioFailureDiagnostics as audioFailureDiagnostics2 } from "@hyperframes/engine";
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync6,
   rmSync as rmSync12,
@@ -427,6 +427,68 @@ ${seededRandomBlock}
     }
   };
 
+  // Timers set once rendering has started run on film time: each seek fires every timer due by then, in
+  // due order. Until a seek after the page reports ready, timers keep the wall clock: setup code waits on
+  // them while the renderer may already be seeking.
+  var rendering = false;
+  var timerQueue = [];
+  var nextTimerId = 1000000000;
+  var firingDepth = 0;
+  function addTimer(callback, delay, args, repeats) {
+    // A timer set from a firing timer waits at least 1 ms, so a zero-delay chain cannot stall a seek.
+    var ms = Math.max(firingDepth > 0 ? 1 : 0, Number(delay) || 0);
+    var entry = { id: nextTimerId++, callback: callback, args: args, due: virtualNowMs + ms, every: repeats ? Math.max(1, ms) : 0, cancelled: false };
+    timerQueue.push(entry);
+    return entry.id;
+  }
+  function cancelTimer(id) {
+    for (var i = 0; i < timerQueue.length; i++) {
+      if (timerQueue[i].id === id) {
+        timerQueue[i].cancelled = true;
+        return true;
+      }
+    }
+    return false;
+  }
+  function fireDueTimers(untilMs) {
+    // Frame times are fractional, so a timer due on a frame lands a rounding error past it; it still fires on it.
+    untilMs += 0.000001;
+    while (true) {
+      var next = null;
+      for (var i = 0; i < timerQueue.length; i++) {
+        var candidate = timerQueue[i];
+        if (!candidate.cancelled && candidate.due <= untilMs && (next === null || candidate.due < next.due)) next = candidate;
+      }
+      if (next === null) break;
+      var dueMs = next.due;
+      if (next.every) next.due += next.every;
+      else next.cancelled = true;
+      virtualNowMs = dueMs;
+      firingDepth++;
+      try {
+        next.callback.apply(window, next.args);
+      } catch (err) {
+        originalSetTimeout(function() { throw err; }, 0);
+      }
+      firingDepth--;
+    }
+    timerQueue = timerQueue.filter(function(entry) { return !entry.cancelled; });
+  }
+  window.setTimeout = function(callback, delay) {
+    if (!rendering || typeof callback !== "function") return originalSetTimeout.apply(null, arguments);
+    return addTimer(callback, delay, Array.prototype.slice.call(arguments, 2), false);
+  };
+  window.setInterval = function(callback, delay) {
+    if (!rendering || typeof callback !== "function") return originalSetInterval.apply(null, arguments);
+    return addTimer(callback, delay, Array.prototype.slice.call(arguments, 2), true);
+  };
+  window.clearTimeout = function(id) {
+    if (!cancelTimer(id)) originalClearTimeout(id);
+  };
+  window.clearInterval = function(id) {
+    if (!cancelTimer(id)) originalClearInterval(id);
+  };
+
   window.__HF_VIRTUAL_TIME__ = {
     originalSetTimeout: originalSetTimeout,
     originalClearTimeout: originalClearTimeout,
@@ -436,8 +498,10 @@ ${seededRandomBlock}
     originalCancelAnimationFrame: originalCancelAnimationFrame,
     seekToTime: function(nextTimeMs) {
       var safeTimeMs = Math.max(0, Number(nextTimeMs) || 0);
+      if (window.__renderReady === true) rendering = true;
+      ${seekToTimeReseedCall}fireDueTimers(safeTimeMs);
       virtualNowMs = safeTimeMs;
-      ${seekToTimeReseedCall}flushAnimationFrame();
+      flushAnimationFrame();
       return virtualNowMs;
     },
     getTime: function() {
@@ -932,7 +996,7 @@ function resolveDeliveryEncoderOptions(config) {
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync,
   rmSync,
   symlinkSync,
@@ -952,7 +1016,9 @@ import {
   relative as nodeRelative,
   isAbsolute as nodeIsAbsolute
 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
 var DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? // fileURLToPath (not URL.pathname): on Windows .pathname is "/D:/..." which
 // resolves to a bogus renders dir.
 nodeResolve(fileURLToPath2(import.meta.url), "../../..", "renders");
@@ -990,6 +1056,13 @@ function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS
   const absoluteOutputPath = nodeResolve(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
+function resolveCompositionSrc(projectDir, src) {
+  const rooted = (value) => nodeResolve(projectDir, value.replace(/^(?:\.?[\\/])+/, ""));
+  const decoded = rooted(decodedUrlPath(src));
+  if (!isPathInside2(decoded, projectDir)) return null;
+  const raw = rooted(src);
+  return !existsSync3(decoded) && isPathInside2(raw, projectDir) && existsSync3(raw) ? raw : decoded;
+}
 
 // src/services/render/shared.ts
 var BROWSER_MEDIA_EPSILON = 1e-4;
@@ -1193,7 +1266,7 @@ var materializePathModule = {
   isAbsolute
 };
 var materializeFileSystem = {
-  existsSync: existsSync3,
+  existsSync: existsSync4,
   mkdirSync,
   symlinkSync,
   cpSync,
@@ -1495,7 +1568,7 @@ var RenderExecutionContext = class {
 };
 
 // src/services/render/artifactTransaction.ts
-import { closeSync as closeSync2, existsSync as existsSync5, fstatSync as fstatSync2, openSync as openSync2, readSync, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync6, fstatSync as fstatSync2, openSync as openSync2, readSync, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
 import { basename as basename3, dirname as dirname4, extname as extname2, join as join5, resolve as resolve4 } from "node:path";
 import { HLS_MASTER_PLAYLIST, HLS_VIDEO_PLAYLIST, renameWithRetry } from "@hyperframes/engine";
 
@@ -1508,7 +1581,7 @@ import {
 
 // src/services/render/renderDirOwner.ts
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   lstatSync,
   mkdtempSync,
   readFileSync as readFileSync2,
@@ -1583,7 +1656,7 @@ function newestWriteMs(path) {
 }
 function isAbandoned(dir, ownerlessIdleMs, now) {
   try {
-    if (!lstatSync(dir).isDirectory() || existsSync4(join4(dir, TRANSACTION_BACKUP))) return false;
+    if (!lstatSync(dir).isDirectory() || existsSync5(join4(dir, TRANSACTION_BACKUP))) return false;
     const owner = ownerState(dir);
     if (owner === "gone") return true;
     return owner === "none" && ownerlessIdleMs !== void 0 && now - newestWriteMs(dir) >= ownerlessIdleMs;
@@ -1615,7 +1688,7 @@ function createRenderWorkDir(prefix, outputDir) {
 
 // src/services/render/artifactTransaction.ts
 var defaultFileSystem = {
-  existsSync: existsSync5,
+  existsSync: existsSync6,
   renameSync: (source, destination) => renameWithRetry(source, destination),
   rmSync: rmSync3
 };
@@ -1769,7 +1842,7 @@ var ArtifactTransaction = class {
   async assertDirectoryExpectation(expected, files) {
     for (const required of expected.requiredFiles ?? []) {
       const path = join5(this.stagingPath, required);
-      if (!existsSync5(path)) {
+      if (!existsSync6(path)) {
         throw new Error(`Render artifact directory is missing ${required}: ${this.stagingPath}`);
       }
       assertReadableNonEmptyFile(path);
@@ -2018,7 +2091,7 @@ function replanAfterFailure(plan, failure) {
 }
 
 // src/services/render/stages/captureSegmentedStage.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, rmSync as rmSync6, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, rmSync as rmSync6, statSync as statSync3 } from "node:fs";
 import { join as join10 } from "node:path";
 import {
   captureFrameToBuffer as captureFrameToBuffer2,
@@ -2315,6 +2388,19 @@ function aggregateBeginFrameReuse(perfs) {
   if (noDamageFrames + hasDamageFrames === 0) return void 0;
   return { noDamageFrames, hasDamageFrames };
 }
+function aggregateMotionBlur(perfs) {
+  const ran = perfs.flatMap((p) => p.motionBlur ?? []).filter((m) => m.tier || m.failedFrames > 0);
+  const first = ran[0];
+  if (!first) return void 0;
+  return {
+    tier: first.tier ?? ran.find((m) => m.tier)?.tier ?? null,
+    reasonCode: first.reasonCode,
+    movers: first.movers,
+    failedFrames: ran.reduce((sum, m) => sum + m.failedFrames, 0),
+    readEvents: ran.some((m) => m.readEvents),
+    fingerprint: ran.find((m) => m.fingerprint)?.fingerprint ?? null
+  };
+}
 function buildRenderPerfSummary(input) {
   return {
     renderId: input.job.id,
@@ -2365,6 +2451,7 @@ function buildRenderPerfSummary(input) {
     staticDedup: aggregateDedup(input.dedupPerfs),
     chromeMemory: aggregateChromeMemory(input.dedupPerfs),
     beginFrameReuse: aggregateBeginFrameReuse(input.dedupPerfs),
+    motionBlur: aggregateMotionBlur(input.dedupPerfs),
     drawElement: aggregateDrawElement(
       input.dedupPerfs,
       input.drawElement ?? { selfVerifyFallback: false }
@@ -3839,6 +3926,21 @@ function raceAgainstStall(promise, deadlineMs, input, signal) {
     );
   });
 }
+function createSessionInitBudget(input) {
+  const initStallMs = Math.max(SESSION_INIT_STALL_MS, resolveCaptureStallTimeoutMs());
+  const setup = createStallClock();
+  return (work, stalled) => raceAgainstStall(
+    work,
+    initStallMs - setup.idle(0),
+    {
+      session: stalled,
+      frameIndex: input.frameIndex,
+      totalFrames: input.totalFrames,
+      stallTimeoutMs: initStallMs
+    },
+    input.abortSignal
+  );
+}
 function createDrainFrameGuard(args) {
   const { log, stats, frameTime } = args;
   const verifyMinDb = resolveDeVerifyMinDb();
@@ -4311,14 +4413,11 @@ async function runCaptureStreamingStage(input) {
       let resumes = 0;
       for (; ; ) {
         const videoInjector = createRenderVideoFrameInjector();
-        const initStallMs = Math.max(SESSION_INIT_STALL_MS, resolveCaptureStallTimeoutMs());
-        const setup = createStallClock();
-        const withinInitBudget = (work, stalled) => raceAgainstStall(
-          work,
-          initStallMs - setup.idle(0),
-          { session: stalled, frameIndex: resume.from, totalFrames, stallTimeoutMs: initStallMs },
+        const withinInitBudget = createSessionInitBudget({
+          frameIndex: resume.from,
+          totalFrames,
           abortSignal
-        );
+        });
         const openSession = async () => {
           const opening = createCaptureSession(
             fileServer.url,
@@ -4596,7 +4695,7 @@ async function captureSegmentToEncoder(ctx, segment) {
       path: segmentPath,
       // Recorded so resume can prove the file on disk is the one that
       // finished; absent only in unit tests, whose fake encoder writes none.
-      bytes: existsSync6(segmentPath) ? statSync3(segmentPath).size : 0
+      bytes: existsSync7(segmentPath) ? statSync3(segmentPath).size : 0
     });
     return encodeResult;
   } finally {
@@ -4626,14 +4725,29 @@ function defaultSessionFactory(input) {
         });
         probeSession = null;
       }
-      const session = probeSession ?? await openSegmentedSession(input, injector);
+      const withinInitBudget = createSessionInitBudget({
+        frameIndex: input.job.framesRendered ?? 0,
+        totalFrames: input.totalFrames,
+        abortSignal: input.abortSignal
+      });
+      const openSession = async () => {
+        const opening = openSegmentedSession(input, injector);
+        try {
+          return await withinInitBudget(opening, OPENING_CAPTURE_SESSION);
+        } catch (error) {
+          void opening.then(closeCaptureSession2, () => {
+          });
+          throw error;
+        }
+      };
+      const session = probeSession ?? await openSession();
       if (probeSession) {
         openSegmentedSessionReuse(input, probeSession, injector);
         probeSession = null;
       }
       try {
-        if (!session.isInitialized) await initializeSession2(session);
-        await completeDeferredDrawElementInit2(session);
+        if (!session.isInitialized) await withinInitBudget(initializeSession2(session), session);
+        await withinInitBudget(completeDeferredDrawElementInit2(session), session);
       } catch (error) {
         await closeCaptureSession2(session).catch(() => {
         });
@@ -5565,7 +5679,7 @@ function trackSegmentFramePeak(frames, rootDir, onPeak) {
 
 // src/services/render/segmentManifest.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync4, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync8, 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";
@@ -5613,7 +5727,7 @@ function isManifest(value) {
 }
 function readSegmentManifest(segmentDir) {
   const path = join15(segmentDir, MANIFEST_FILENAME);
-  if (!existsSync7(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf-8"));
     return isManifest(parsed) ? parsed : null;
@@ -5642,7 +5756,7 @@ async function validateCompletedSegments(manifest, expectedHash, probeFrames) {
   const ok = /* @__PURE__ */ new Set();
   if (manifest.planHash !== expectedHash) return ok;
   for (const entry of manifest.completed) {
-    if (!existsSync7(entry.path)) continue;
+    if (!existsSync8(entry.path)) continue;
     const size = statSync5(entry.path).size;
     if (size <= 0 || size !== entry.bytes) continue;
     const frames = await probeFrames(entry.path);
@@ -5782,7 +5896,7 @@ var ALLOWED_STRING_DATA_KEYS = /* @__PURE__ */ new Set([
   "stagePhase",
   // Full-fidelity fast-capture fallback trigger — the specific reason
   // drawElement gated off ("filter:blur", "filter:drop-shadow",
-  // "backdrop-filter", "clip-path", "at_risk_timeline", "swiftshader", …).
+  // "backdrop-filter", "clip-path", "at_risk_timeline", "swiftshader", "webgl_unavailable", …).
   // Populated on the `capture_fallback_profile` checkpoint emitted by
   // `fallbackCaptureProfile.ts` when the operator opts into
   // `HF_PROFILE_FALLBACK_CAPTURE=true` so downstream metric consumers can
@@ -6221,17 +6335,17 @@ function countAuthoredTimedClips(html) {
 }
 
 // src/services/render/stages/compileStage.ts
-import { existsSync as existsSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync12, 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 { decodedUrlPath as decodedUrlPath2 } from "@hyperframes/parsers/asset-paths";
 import { createHash as createHash6 } from "node:crypto";
-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 { createReadStream as createReadStream2, existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join18, dirname as dirname8, resolve as resolve7, basename as basename4, relative as relative2, sep as sep2 } from "path";
 import { parseHTML as parseHTML5 } from "linkedom";
 import {
   COMPOSITION_SOURCE_URL,
@@ -6477,7 +6591,7 @@ import {
 
 // src/services/animatedGifPrep.ts
 import { createHash as createHash4 } from "node:crypto";
-import { copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync5, rmSync as rmSync9, statSync as statSync6 } from "node:fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync9, 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";
@@ -6516,14 +6630,14 @@ function resolveLocalImageSourcePath(src, options) {
   const { basePath } = splitUrlSuffix(trimmed);
   const normalizedBase = normalizeRelPath(basePath);
   const mapped = options.sourceAssets?.get(trimmed) ?? options.sourceAssets?.get(basePath) ?? options.sourceAssets?.get(normalizedBase);
-  if (mapped && existsSync8(mapped)) return mapped;
+  if (mapped && existsSync9(mapped)) return mapped;
   if (isHttpUrl(trimmed)) return null;
   const projectRelative = basePath.startsWith("/") ? basePath.slice(1) : basePath;
   const candidates = [
     isAbsolute2(basePath) ? basePath : resolve5(options.projectDir, projectRelative),
     resolve5(options.downloadDir, normalizedBase)
   ];
-  return candidates.find((candidate) => existsSync8(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync9(candidate)) ?? null;
 }
 function isUsableFile(path) {
   try {
@@ -6634,10 +6748,10 @@ 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(dirname6(input.cachePath))) {
+  if (!existsSync9(dirname6(input.cachePath))) {
     mkdirSync7(dirname6(input.cachePath), { recursive: true });
   }
-  if (!existsSync8(dirname6(input.outputPath))) {
+  if (!existsSync9(dirname6(input.outputPath))) {
     mkdirSync7(dirname6(input.outputPath), { recursive: true });
   }
   if (!isUsableFile(input.cachePath)) {
@@ -7112,7 +7226,7 @@ import { createStudioPositionSeekReapplyScript } from "@hyperframes/studio-serve
 import { getPositionEditsRenderScript } from "@hyperframes/core/runtime/position-edits-render";
 
 // src/services/assetMediaType.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import {
   fingerprintElementId,
   isNotMediaPayload,
@@ -7185,7 +7299,7 @@ async function preflightCompositionAssetMediaTypes(input) {
       input.projectDir,
       input.compiledDir
     );
-    if (!existsSync9(resolvedPath)) continue;
+    if (!existsSync10(resolvedPath)) continue;
     byPath.set(resolvedPath, [...byPath.get(resolvedPath) ?? [], reference]);
   }
   const mismatches = [];
@@ -7273,6 +7387,14 @@ Check that each file referenced by data-composition-src contains valid HTML with
     this.problems = problems;
   }
 };
+function normalizeCompositionSrcs(html, projectDir) {
+  return html.replace(/(\bdata-composition-src=)(["'])([^"']*)\2/g, (whole, name, quote, value) => {
+    if (!value.includes("%") && !value.startsWith("/")) return whole;
+    const file = resolveCompositionSrc(projectDir, value);
+    if (file === null) return whole;
+    return `${name}${quote}${relative2(projectDir, file).split(sep2).join("/")}${quote}`;
+  });
+}
 function assertSubCompositionsUsable(html, projectDir, visited = /* @__PURE__ */ new Set()) {
   const { document: document2 } = parseHTML5(html);
   const hosts = [...document2.querySelectorAll("[data-composition-src]")];
@@ -7281,7 +7403,11 @@ function assertSubCompositionsUsable(html, projectDir, visited = /* @__PURE__ */
     const srcPath = el.getAttribute("data-composition-src");
     if (!srcPath) continue;
     if (isUnresolvedAssetPlaceholder(srcPath)) continue;
-    const filePath = resolve7(projectDir, srcPath);
+    const filePath = resolveCompositionSrc(projectDir, srcPath);
+    if (filePath === null) {
+      problems.push({ srcPath, detail: "it is outside the project folder" });
+      continue;
+    }
     if (visited.has(filePath)) continue;
     const read = readProjectFile(filePath);
     if (read.kind === "missing") {
@@ -7427,7 +7553,7 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
   let filePath = src;
   if (isHttpUrl(src)) {
     const remoteDir = join18(downloadDir, REMOTE_MEDIA_SUBDIR);
-    if (!existsSync10(remoteDir)) mkdirSync9(remoteDir, { recursive: true });
+    if (!existsSync11(remoteDir)) mkdirSync9(remoteDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, remoteDir, void 0, void 0, void 0, {
         onTelemetry: logRemoteDownloadTelemetry
@@ -7436,11 +7562,11 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
       return { duration: null, resolvedPath: src };
     }
   } else {
-    filePath = decodedUrlPath(src);
+    filePath = decodedUrlPath2(src);
     if (!filePath.startsWith("/")) filePath = join18(baseDir, filePath);
     filePath = urlByAbsentLocalPath?.get(filePath) ?? filePath;
   }
-  if (!isHttpUrl(filePath) && !existsSync10(filePath)) {
+  if (!isHttpUrl(filePath) && !existsSync11(filePath)) {
     return { duration: null, resolvedPath: filePath };
   }
   const withSrcContext = (error) => {
@@ -7581,7 +7707,8 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
   for (const el of compEls) {
     const srcPath = el.getAttribute("data-composition-src");
     if (!srcPath) continue;
-    const filePath = resolve7(projectDir, srcPath);
+    const filePath = resolveCompositionSrc(projectDir, srcPath);
+    if (filePath === null) continue;
     if (visited.has(filePath)) {
       continue;
     }
@@ -7589,7 +7716,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, visited = /*
     if (read.kind !== "file") {
       continue;
     }
-    const rawSubHtml = read.text;
+    const rawSubHtml = normalizeCompositionSrcs(read.text, projectDir);
     const nestedVisited = new Set(visited);
     nestedVisited.add(filePath);
     workItems.push({ srcPath, filePath, rawSubHtml, nestedVisited });
@@ -7777,8 +7904,9 @@ function inlineSubCompositions(html, subCompositions, projectDir, variableOverri
       resolveHtml: (srcPath) => {
         let compHtml = subCompositions.get(srcPath) || null;
         if (!compHtml) {
-          const read = readProjectFile(resolve7(projectDir, srcPath));
-          if (read.kind === "file") {
+          const filePath = resolveCompositionSrc(projectDir, srcPath);
+          const read = filePath ? readProjectFile(filePath) : null;
+          if (read?.kind === "file") {
             compHtml = rewriteUnresolvableGsapToCdn(read.text, projectDir, srcPath);
           }
         }
@@ -7787,7 +7915,7 @@ function inlineSubCompositions(html, subCompositions, projectDir, variableOverri
       parseHtml: (htmlStr) => parseHTML5(htmlStr).document,
       // Mirrors the preview bundler: a sub-composition's SIBLING assets resolve
       // against its own directory, project-root refs stay as authored.
-      assetExists: (path) => existsSync10(resolve7(projectDir, path)),
+      assetExists: (path) => existsSync11(resolve7(projectDir, path)),
       // Preserve the authored root wrapper as a child of the host, matching
       // the preview bundler's shape (htmlBundler.ts's prepareFlattenedInnerRoot,
       // which the runtime compositionLoader mirrors with its own copy for the
@@ -7978,7 +8106,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync10(absPath)) return null;
+    if (!existsSync11(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -8028,7 +8156,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)) mkdirSync9(remoteDir, { recursive: true });
+  if (!existsSync11(remoteDir)) mkdirSync9(remoteDir, { recursive: true });
   const urlToLocal = /* @__PURE__ */ new Map();
   await Promise.all(
     [...urlSet].map(async (url) => {
@@ -8210,14 +8338,14 @@ function projectStylesheetFontFamilies(html, projectDir) {
   for (const [tag] of html.matchAll(/<link\b[^>]*\brel=["']stylesheet["'][^>]*>/gi)) {
     const href = /\bhref=["']([^"']+)["']/i.exec(tag)?.[1];
     if (!href || /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(href)) continue;
-    const sheet = resolve7(projectDir, decodedUrlPath(href).replace(/^(?:\.?\/)+/, ""));
-    if (!isPathInside2(sheet, projectDir) || !existsSync10(sheet)) continue;
+    const sheet = resolve7(projectDir, decodedUrlPath2(href).replace(/^(?:\.?\/)+/, ""));
+    if (!isPathInside2(sheet, projectDir) || !existsSync11(sheet)) continue;
     for (const face of extractFontFaceBlocks(readFileSync7(sheet, "utf8"))) {
       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 path = decodedUrlPath2(url);
         const file = path.startsWith("/") ? resolve7(projectDir, `.${path}`) : resolve7(dirname8(sheet), path);
-        return isPathInside2(file, projectDir) && existsSync10(file);
+        return isPathInside2(file, projectDir) && existsSync11(file);
       });
       if (family && shipsFile) families.push(family);
     }
@@ -8352,7 +8480,7 @@ function renderGsapDist() {
 }
 function rewriteUnresolvableGsapToCdn(html, projectDir, compSrcPath) {
   let gsapDist;
-  const exists = (path) => existsSync10(resolve7(projectDir, path));
+  const exists = (path) => existsSync11(resolve7(projectDir, path));
   return html.replace(
     /(<script\b[^>]*\bsrc=["'])([^"']*gsap[^"']*\/dist\/([^"']+))(["'][^>]*>)/gi,
     (full, prefix, src, file, suffix) => {
@@ -8369,7 +8497,7 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
   const entryPath = relative2(projectDir, htmlPath).replace(/\\/g, "/");
   if (!entryPath.includes("/")) return html;
   const { document: document2 } = parseHTML5(html);
-  const assetExists = (path) => existsSync10(resolve7(projectDir, path));
+  const assetExists = (path) => existsSync11(resolve7(projectDir, path));
   rewriteAssetPaths(
     document2.querySelectorAll("[src], [href], [srcset]"),
     entryPath,
@@ -8391,7 +8519,10 @@ function rebaseDirectEntryAssetPaths(html, projectDir, htmlPath) {
 }
 async function compileForRender(projectDir, htmlPath, downloadDir, options = {}) {
   const entryHtml = rebaseDirectEntryAssetPaths(readTextFile(htmlPath), projectDir, htmlPath);
-  const rawHtml = rewriteUnresolvableGsapToCdn(entryHtml, projectDir);
+  const rawHtml = normalizeCompositionSrcs(
+    rewriteUnresolvableGsapToCdn(entryHtml, projectDir),
+    projectDir
+  );
   assertSubCompositionsUsable(rawHtml, projectDir);
   const probes = /* @__PURE__ */ new Map();
   const { html: compiledHtml, unresolvedCompositions } = await compileHtmlFile(
@@ -8936,7 +9067,7 @@ function resolveEntryHtmlPath(input) {
   const rawEntry = readTextFile2(htmlPath);
   if (entryFile === "index.html" || !isTemplateEntry(rawEntry)) return htmlPath;
   const projectIndexPath = join19(projectDir, "index.html");
-  if (!existsSync11(projectIndexPath)) {
+  if (!existsSync12(projectIndexPath)) {
     throw new Error(
       `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
     );
@@ -9770,7 +9901,7 @@ function validateRenderDuration(input) {
 }
 
 // src/services/render/stages/extractVideosStage.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { join as join21 } from "node:path";
 import {
   classifyVideoExtractionError,
@@ -10040,7 +10171,7 @@ async function runExtractVideosStage(input) {
     const probeFailures = await Promise.all(
       composition.videos.map(async (v) => {
         const videoPath = resolveProjectRelativeSrc3(v.src, projectDir, compiledDir);
-        if (!existsSync12(videoPath)) return null;
+        if (!existsSync13(videoPath)) return null;
         try {
           const attempted = extractionPolicy.maxTransientRetries === 0 ? { result: await extractMediaMetadata3(videoPath), retries: 0 } : await runVideoExtractionWithRetry2(() => extractMediaMetadata3(videoPath), {
             signal: abortSignal,
@@ -10078,7 +10209,7 @@ async function runExtractVideosStage(input) {
     const probed = await Promise.all(
       composition.images.map(async (img) => {
         const imgPath = resolveProjectRelativeSrc3(img.src, projectDir, compiledDir);
-        if (!existsSync12(imgPath)) return null;
+        if (!existsSync13(imgPath)) return null;
         const colorSpace = await probeColorSpaceSafely(imgPath, log);
         if (isHdrColorSpace2(colorSpace)) {
           nativeHdrImageIds.add(img.id);
@@ -10198,7 +10329,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) && !existsSync12(readFrom)) return null;
+      if (!isHttpUrl2(readFrom) && !existsSync13(readFrom)) return null;
       const metadata = await extractMediaMetadata3(readFrom);
       const window2 = await resolveFinalFrameExtractionWindow2(
         readFrom,
@@ -10218,7 +10349,7 @@ async function appendVideoAudioFromProbe(input) {
 }
 
 // src/services/render/videoLayerPassthroughPlan.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import {
   buildVideoLayerInput,
   isHttpUrl as isHttpUrl3,
@@ -10286,7 +10417,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 (!existsSync13(path)) return { reason: "source_missing" };
+  if (!existsSync14(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(
@@ -10301,7 +10432,7 @@ async function planVideoLayerPassthrough(input) {
 }
 
 // src/services/render/stages/audioStage.ts
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } from "node:fs";
 import { join as join24 } from "node:path";
 import {
   MIXED_AUDIO_FILENAME,
@@ -10312,7 +10443,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/render/audioDeliveryLimit.ts
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { dirname as dirname10, join as join23 } from "node:path";
 import {
   applyAudioFxChain,
@@ -10821,7 +10952,7 @@ async function limitDeliveryPeaks(input, deps = {
   applyChain: applyAudioFxChain,
   encode: encodeAac2,
   rename: renameWithRetry6,
-  sourceExists: existsSync14
+  sourceExists: existsSync15
 }) {
   const { audioPath, sourcePath, signal, timeoutMs } = input;
   if (!deps.sourceExists(sourcePath)) return { success: true };
@@ -10916,7 +11047,7 @@ async function runAudioStageScoped(input) {
       );
       audioLoweredDb = guard.loweredDb;
       input.log?.info("[audio] phases", { ...result.audioPhaseMs, guard: Date.now() - guardStart });
-      if (input.keepDeliverySource && !guard.sourceStale && existsSync15(pcmSourcePath)) {
+      if (input.keepDeliverySource && !guard.sourceStale && existsSync16(pcmSourcePath)) {
         deliverySourcePath = pcmSourcePath;
       }
     }
@@ -11044,7 +11175,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 }
 
 // src/services/render/stages/captureStage.ts
-import { existsSync as existsSync16, readdirSync as readdirSync4, statfsSync as statfsSync2 } from "node:fs";
+import { existsSync as existsSync17, readdirSync as readdirSync4, statfsSync as statfsSync2 } from "node:fs";
 import { join as join25 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
@@ -11115,7 +11246,7 @@ function diskCaptureShortfallError(needBytes, freeBytes, framesDir, basis, remed
 }
 function measureCaptureFrameBytes(workDir, framesDir) {
   let total = sampleDirectoryBytes(framesDir);
-  if (!existsSync16(workDir)) return total;
+  if (!existsSync17(workDir)) return total;
   for (const attempt of readdirSync4(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
       total += sampleDirectoryBytes(join25(workDir, attempt));
@@ -11300,7 +11431,11 @@ async function runSequentialDiskCapture(input, captureOptions, captureCfg, check
         prepareCaptureSessionForReuse3(session, framesDir, videoInjector);
         probeSession = null;
       }
-      await ensureSessionReady(session);
+      await ensureSessionReady(session, {
+        frameIndex: resumeFrom,
+        totalFrames,
+        abortSignal: input.abortSignal
+      });
       assertAttemptActive();
       lastBrowserConsole = session.browserConsoleBuffer;
       await captureSessionFrames(session, {
@@ -11352,13 +11487,13 @@ function planTransientResume(error, ctx) {
   if (!firstMissing) return null;
   return isTransientCaptureRetryEligible(failure.kind, missing, ctx.retriesUsed) ? firstMissing.startFrame : null;
 }
-async function ensureSessionReady(session) {
+async function ensureSessionReady(session, budget) {
   if (!session.isInitialized) {
     await initializeSession5(session);
     return;
   }
   if (process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true") {
-    await completeDeferredDrawElementInit3(session);
+    await createSessionInitBudget(budget)(completeDeferredDrawElementInit3(session), session);
   }
 }
 async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resumeFrom, checkDiskProjection }) {
@@ -11418,7 +11553,7 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 }
 
 // src/services/render/stages/captureHdrStage.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10 } from "node:fs";
 import { join as join29 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
@@ -11664,7 +11799,7 @@ import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 import { dirname as dirname11, join as join27 } from "node:path";
 import { createRequire } from "node:module";
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
 function resolveWorkerEntry(explicit) {
   if (explicit && explicit.length > 0) {
@@ -11677,7 +11812,7 @@ function resolveWorkerEntry(explicit) {
   }
   const moduleDir = dirname11(fileURLToPath3(import.meta.url));
   const jsPath = join27(moduleDir, "shaderTransitionWorker.js");
-  if (existsSync17(jsPath)) return { path: jsPath, isTs: false };
+  if (existsSync18(jsPath)) return { path: jsPath, isTs: false };
   const tsPath = join27(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
@@ -12238,7 +12373,7 @@ async function runCaptureHdrStage(input) {
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
       const debugDumpDir = debugDumpEnabled ? join29(framesDir, "debug-composite") : null;
-      if (debugDumpDir && !existsSync18(debugDumpDir)) {
+      if (debugDumpDir && !existsSync19(debugDumpDir)) {
         mkdirSync10(debugDumpDir, { recursive: true });
       }
       const compositeTransfer = resolveCompositeTransfer(hasHdrContent, effectiveHdr);
@@ -12395,7 +12530,7 @@ async function runCaptureHdrStage(input) {
 // src/services/render/stages/encodeStage.ts
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync11,
   readdirSync as readdirSync5,
   readFileSync as readFileSync8,
@@ -12529,7 +12664,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
-    const fileSize = existsSync19(outputPath) ? statSync8(outputPath).size : 0;
+    const fileSize = existsSync20(outputPath) ? statSync8(outputPath).size : 0;
     return {
       success: true,
       outputPath,
@@ -12690,7 +12825,7 @@ async function runEncodeStage(input) {
   const stage5Start = Date.now();
   if (isPngSequence) {
     const encoded = startEncodeProgress(job, "Writing PNG sequence", onProgress);
-    if (!existsSync19(outputPath)) mkdirSync11(outputPath, { recursive: true });
+    if (!existsSync20(outputPath)) mkdirSync11(outputPath, { recursive: true });
     const captured = readdirSync5(framesDir).filter((name) => name.endsWith(".png")).sort();
     if (captured.length === 0) {
       throw new Error(
@@ -12701,7 +12836,7 @@ async function runEncodeStage(input) {
       const dst = join30(outputPath, formatExportFrameName(i, "png"));
       copyFileSync4(join30(framesDir, name), dst);
     });
-    if (hasAudio && audioOutputPath && existsSync19(audioOutputPath)) {
+    if (hasAudio && audioOutputPath && existsSync20(audioOutputPath)) {
       copyFileSync4(audioOutputPath, join30(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
@@ -13090,7 +13225,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
     const framePath = join31(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    const missing = !existsSync20(framePath) || statSync9(framePath).size <= 8;
+    const missing = !existsSync21(framePath) || statSync9(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
     } else if (!missing && rangeStart !== null) {
@@ -13215,7 +13350,7 @@ function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
     const framePath = join31(framesDir, formatCaptureFrameName(frameIndex, frameExt));
-    if (existsSync20(framePath)) captured++;
+    if (existsSync21(framePath)) captured++;
   }
   return captured;
 }
@@ -13880,7 +14015,7 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
   validateDeliveryEncoderConfig(job.config);
   const debugDir = resolveRenderDebugDir();
   const outputDir = dirname13(outputPath);
-  if (!existsSync20(outputDir)) mkdirSync12(outputDir, { recursive: true });
+  if (!existsSync21(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;
@@ -14022,7 +14157,7 @@ async function executeRenderPipeline(input) {
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
     assertConfiguredFfmpegBinariesExist();
-    if (!existsSync20(workDir)) mkdirSync12(workDir, { recursive: true });
+    if (!existsSync21(workDir)) mkdirSync12(workDir, { recursive: true });
     if (job.config.debug) {
       log.info("[Render] Debug artifacts enabled", { workDir, logPath });
     }
@@ -14052,7 +14187,7 @@ async function executeRenderPipeline(input) {
     });
     const entryFile = job.config.entryFile || "index.html";
     const htmlPath = join31(projectDir, entryFile);
-    if (!existsSync20(htmlPath)) {
+    if (!existsSync21(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
@@ -14367,9 +14502,11 @@ async function executeRenderPipeline(input) {
     );
     pendingAudio = audioStage.catch(() => void 0);
     const stage4Start = Date.now();
-    updateJobStatus(job, "rendering", "Starting frame capture", 25, onProgress, {
+    const EFFECT_SCAN_STAGE = "Checking effects";
+    const startingFrameCapture = () => updateJobStatus(job, "rendering", "Starting frame capture", 25, onProgress, {
       code: "start_browsers"
     });
+    startingFrameCapture();
     if (!fileServer) {
       const fileServerStart = observability.stageStart("file_server", { reused: false });
       try {
@@ -14394,7 +14531,7 @@ async function executeRenderPipeline(input) {
       throw new Error("File server failed to initialize before frame capture");
     }
     const framesDir = join31(workDir, "captured-frames");
-    if (!existsSync20(framesDir)) mkdirSync12(framesDir, { recursive: true });
+    if (!existsSync21(framesDir)) mkdirSync12(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
     });
@@ -14402,6 +14539,7 @@ async function executeRenderPipeline(input) {
       chromePath: resolveHeadlessShellPath(cfg),
       browserTimeout: cfg.browserTimeout
     });
+    startingFrameCapture();
     captureForceScreenshot = applyConcreteGpuScreenshotClamp(
       captureForceScreenshot,
       resolvedBrowserGpuMode,
@@ -14450,10 +14588,13 @@ async function executeRenderPipeline(input) {
       onEffectScanProgress: (scanned, total) => updateJobStatus(
         job,
         "rendering",
-        `Checking effects, ${scanned} of ${total} frames`,
+        `${EFFECT_SCAN_STAGE}, ${scanned} of ${total} frames`,
         25,
         onProgress
       ),
+      onEffectScanEnd: () => {
+        if (job.currentStage.startsWith(EFFECT_SCAN_STAGE)) startingFrameCapture();
+      },
       requiresWebGpu: compositionRequiresWebGpu2(compiled.html),
       // Live route for Chrome memory (spec §5 Phase −1). The aggregate route
       // through CapturePerfSummary only exists on success; a mid-capture
@@ -14721,6 +14862,7 @@ async function executeRenderPipeline(input) {
       } finally {
         calibrationFrames?.release();
       }
+      startingFrameCapture();
       captureCalibration = outcome.calibration;
       calibrationEvaluateTimedOut = outcome.calibrationEvaluateTimedOut;
       captureForceScreenshot = outcome.forceScreenshot;
@@ -15779,7 +15921,7 @@ async function executeRenderPipeline(input) {
       })
     );
     const totalElapsed = Date.now() - pipelineStart;
-    const tmpPeakBytes = existsSync20(workDir) ? sampleDirectoryBytes(workDir) : 0;
+    const tmpPeakBytes = existsSync21(workDir) ? sampleDirectoryBytes(workDir) : 0;
     recordTransientRetryObservability();
     observability.checkpoint("pipeline", "artifact validated", { totalElapsedMs: totalElapsed });
     const observabilitySummary = observability.summary({
@@ -15860,7 +16002,7 @@ async function executeRenderPipeline(input) {
       }
     }
     if (job.config.debug) {
-      if (!isPngSequence && !isHls && existsSync20(stagedOutputPath)) {
+      if (!isPngSequence && !isHls && existsSync21(stagedOutputPath)) {
         const debugOutput = join31(workDir, `output${videoExt}`);
         copyFileSync5(stagedOutputPath, debugOutput);
       }
@@ -15972,7 +16114,7 @@ async function executeRenderPipeline(input) {
 
 // src/services/hyperframeLint.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   readFileSync as readFileSync9,
   statSync as statSync10,
   openSync as openSync5,
@@ -15980,7 +16122,7 @@ import {
   closeSync as closeSync5,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve9, join as join32, 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 sep3 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -16026,7 +16168,7 @@ function readEntryHtml(filePath) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve9(projectDir);
-  if (!existsSync21(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
+  if (!existsSync22(absProjectDir) || !statSync10(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -16035,7 +16177,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
   for (const entryFile of entryCandidates) {
     const absoluteEntryPath = resolve9(absProjectDir, entryFile);
     const entryRelativePath = relative3(absProjectDir, absoluteEntryPath);
-    if (entryRelativePath === ".." || entryRelativePath.startsWith(`..${sep2}`) || isAbsolute3(entryRelativePath)) {
+    if (entryRelativePath === ".." || entryRelativePath.startsWith(`..${sep3}`) || isAbsolute3(entryRelativePath)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
     const html = readEntryHtml(absoluteEntryPath);
@@ -16095,7 +16237,7 @@ async function runHyperframeLint(prepared) {
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { dirname as dirname14, join as join33 } from "node:path";
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
   const log = options.logger ?? defaultLogger2();
@@ -16172,7 +16314,7 @@ function resolveWorkerEntry2() {
   const here = dirname14(fileURLToPath5(import.meta.url));
   const candidates = [join33(here, "healthWorkerThread.js"), join33(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
-    if (existsSync22(candidate)) return candidate;
+    if (existsSync23(candidate)) return candidate;
   }
   return void 0;
 }
@@ -16212,7 +16354,7 @@ import {
   createReferenceBackgroundRecorder as createReferenceBackgroundRecorder2
 } from "@hyperframes/engine";
 import { audioFailureDiagnostics as audioFailureDiagnostics3 } from "@hyperframes/engine";
-import { extname as extname4, isAbsolute as isAbsolute4, join as join34, relative as relative4, sep as sep3 } from "node:path";
+import { extname as extname4, isAbsolute as isAbsolute4, join as join34, relative as relative4, sep as sep4 } from "node:path";
 import {
   fpsToNumber as fpsToNumber9,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -16459,6 +16601,7 @@ function assertDistributedOptions(value) {
     "chunkSize",
     "maxParallelChunks",
     "targetChunkFrames",
+    "minParallelChunks",
     "planDirSizeLimitBytes"
   ]) {
     assertOptionalInteger(value, field, 1);
@@ -16720,7 +16863,7 @@ function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   const { input, cleanupProjectDir } = prepared;
   const absoluteOutputPath = resolveOutputPath(input.projectDir, input.outputPath, rendersDir, log);
   const outputDir = dirname15(absoluteOutputPath);
-  if (!existsSync23(outputDir)) mkdirSync13(outputDir, { recursive: true });
+  if (!existsSync24(outputDir)) mkdirSync13(outputDir, { recursive: true });
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
@@ -16761,11 +16904,11 @@ function prepareProjectDirectory(projectDir, options) {
   const candidate = nonEmptyString(projectDir);
   if (!candidate) return null;
   const absProjectDir = resolve10(candidate);
-  if (!existsSync23(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
+  if (!existsSync24(absProjectDir) || !statSync11(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entry = options.entryFile || "index.html";
-  if (!existsSync23(resolve10(absProjectDir, entry))) {
+  if (!existsSync24(resolve10(absProjectDir, entry))) {
     return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
   }
   return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -16857,7 +17000,7 @@ function cleanupTempDir(dir, log) {
   }
 }
 function outputFileSize(path) {
-  return existsSync23(path) ? statSync11(path).size : 0;
+  return existsSync24(path) ? statSync11(path).size : 0;
 }
 function createBlockingProgressReporter(log, requestId) {
   let lastLoggedPct = -10;
@@ -17161,7 +17304,7 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync23(artifact.path)) {
+    if (!existsSync24(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }