@hyperframes/producer 0.9.10 → 0.9.12

package/dist/distributed.js

@@ -1463,31 +1463,6 @@ function resolveCaptureStallTimeoutMs() {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_CAPTURE_STALL_MS;
 }
 
-// src/services/render/segmentManifest.ts
-import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
-
-// src/services/render/hdrMode.ts
-import {
-  analyzeCompositionHdr,
-  formatHdrAutoPromotionWarning,
-  gradingKeepsSdr,
-  HDR_AUTO_PROMOTION_PIPELINE,
-  isHdrColorSpace,
-  sanitizeHdrAutoPromotionAsset
-} from "@hyperframes/engine";
-function formatCarriesHdr(format) {
-  return format === "mp4";
-}
-function rendersSdrOnly(config, media) {
-  return config.hdrMode === "force-sdr" || gradingKeepsSdr(config.hdrMode, media) || !formatCarriesHdr(config.format ?? "mp4");
-}
-
-// src/services/render/captureBeyondViewport.ts
-function resolveVideoCaptureBeyondViewport(videoCount) {
-  if (videoCount <= 0) return void 0;
-  return true;
-}
-
 // src/services/render/captureCost.ts
 import { fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
 import {
@@ -1574,6 +1549,31 @@ async function measureCaptureCostFromSession(session, totalFrames, fps, log) {
   };
 }
 
+// src/services/render/segmentManifest.ts
+import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
+
+// src/services/render/hdrMode.ts
+import {
+  analyzeCompositionHdr,
+  formatHdrAutoPromotionWarning,
+  gradingKeepsSdr,
+  HDR_AUTO_PROMOTION_PIPELINE,
+  isHdrColorSpace,
+  sanitizeHdrAutoPromotionAsset
+} from "@hyperframes/engine";
+function formatCarriesHdr(format) {
+  return format === "mp4";
+}
+function rendersSdrOnly(config, media) {
+  return config.hdrMode === "force-sdr" || gradingKeepsSdr(config.hdrMode, media) || !formatCarriesHdr(config.format ?? "mp4");
+}
+
+// src/services/render/captureBeyondViewport.ts
+function resolveVideoCaptureBeyondViewport(videoCount) {
+  if (videoCount <= 0) return void 0;
+  return true;
+}
+
 // src/services/render/observability.ts
 import { redactTelemetryString } from "@hyperframes/core";
 import { CaptureFailure as CaptureFailure2 } from "@hyperframes/engine";

package/dist/index.js

@@ -4857,203 +4857,8 @@ function startRenderEtaGuard(options) {
   return stop;
 }
 
-// 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 join11 } from "node:path";
-import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
-var MANIFEST_FILENAME = "segments.json";
-function computeSegmentPlanHash(input) {
-  const ordered = [
-    input.compositionHash,
-    input.cliVersion,
-    String(input.totalFrames),
-    String(input.segmentFrames),
-    `${input.fps.num}/${input.fps.den}`,
-    `${input.width}x${input.height}`,
-    input.codec,
-    input.preset,
-    input.quality === void 0 ? "" : String(input.quality),
-    input.bitrate ?? "",
-    input.pixelFormat ?? "",
-    input.imageFormat,
-    input.useGpu ? "gpu" : "cpu",
-    `${input.outputWidth}x${input.outputHeight}`,
-    input.motionBlur,
-    input.pageMotionBlur ?? "",
-    input.captureQuality === void 0 ? "" : String(input.captureQuality)
-  ];
-  const delivery = [input.maxBitrate, input.bufferSize, input.gopSize].map((v) => v ?? "");
-  if (delivery.some((v) => v !== "")) ordered.push(...delivery.map(String));
-  return createHash2("sha256").update(ordered.join(" ")).digest("hex").slice(0, 16);
-}
-function segmentDirFor(projectRendersDir, planHash) {
-  return join11(projectRendersDir, ".hf-segments", planHash);
-}
-function hasNumber(value, key) {
-  return key in value && typeof Reflect.get(value, key) === "number";
-}
-function hasString(value, key) {
-  return key in value && typeof Reflect.get(value, key) === "string";
-}
-function isEntry(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return hasNumber(value, "index") && hasNumber(value, "startFrame") && hasNumber(value, "endFrame") && hasString(value, "path") && hasNumber(value, "bytes") && hasString(value, "completedAt");
-}
-function isManifest(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const completed = Reflect.get(value, "completed");
-  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 = join11(segmentDir, MANIFEST_FILENAME);
-  if (!existsSync7(path)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
-    return isManifest(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function writeSegmentManifest(segmentDir, manifest) {
-  mkdirSync4(segmentDir, { recursive: true });
-  const tmp = join11(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
-  writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
-  renameWithRetry2(tmp, join11(segmentDir, MANIFEST_FILENAME));
-}
-async function probeSegmentFrameCount(path, probe) {
-  try {
-    const meta = await probe(path);
-    if (!Number.isFinite(meta.videoStreamDurationSeconds) || !Number.isFinite(meta.fps))
-      return null;
-    if (meta.fps <= 0) return null;
-    return Math.round(meta.videoStreamDurationSeconds * meta.fps);
-  } catch {
-    return null;
-  }
-}
-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;
-    const size = statSync4(entry.path).size;
-    if (size <= 0 || size !== entry.bytes) continue;
-    const frames = await probeFrames(entry.path);
-    if (frames !== entry.endFrame - entry.startFrame) continue;
-    ok.add(entry.index);
-  }
-  return ok;
-}
-
-// src/services/render/hdrMode.ts
-import {
-  analyzeCompositionHdr,
-  formatHdrAutoPromotionWarning,
-  gradingKeepsSdr,
-  HDR_AUTO_PROMOTION_PIPELINE,
-  isHdrColorSpace,
-  sanitizeHdrAutoPromotionAsset
-} from "@hyperframes/engine";
-function formatDowngradeWarning(outputFormat, forcedHdrWithoutSources) {
-  const hdrSourceReason = forcedHdrWithoutSources ? "HDR was forced without detected HDR sources" : "HDR source detected";
-  const formatReason = outputFormat === "hls" ? "HLS output is SDR-only (H.264 in MPEG-TS)" : "HDR + alpha is not supported";
-  return `[Render] ${hdrSourceReason}, but format is "${outputFormat}", so falling back to SDR. ${formatReason}. Use --format mp4 for HDR10 output.`;
-}
-function findRenderHdrAutoPromotionTrigger(input) {
-  for (const extracted of input.extractionResult?.extracted ?? []) {
-    if (!isHdrColorSpace(extracted.metadata.colorSpace)) continue;
-    const source = input.videos.find(({ id }) => id === extracted.videoId)?.src;
-    if (source) return source;
-  }
-  return input.images.find(({ id }) => input.nativeHdrImageIds.has(id))?.src;
-}
-function logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource) {
-  const keptSdr = hasHdrSource && gradingKeepsSdr(hdrMode, input.media);
-  if (keptSdr) {
-    input.log.warn(
-      "[Render] HDR source detected, but color grading is SDR-only, so rendering SDR: HDR sources are tone-mapped before the grade. Use --hdr to force HDR output (grades stay SDR)."
-    );
-  } else if (effectiveHdr && [...input.media.videos, ...input.media.images].some((m) => m.graded)) {
-    input.log.warn(
-      "[Render] HDR output with graded media: color grading is SDR-only, so graded elements are graded in SDR and placed in the HDR output."
-    );
-  }
-  return keptSdr;
-}
-function logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, hasHdrSource) {
-  const keptSdrForGrading = logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource);
-  if (forcedHdrWithoutSources) {
-    input.log.warn(
-      "[Render] HDR forced by --hdr flag, but no HDR sources were detected, defaulting to HLG. SDR-only compositions may look perceptually wrong on HDR displays."
-    );
-  }
-  if (!effectiveHdr) {
-    if (keptSdrForGrading) return;
-    input.log.info(
-      hdrMode === "force-sdr" ? "[Render] SDR forced by --sdr flag" : "[Render] No HDR sources detected, rendering SDR"
-    );
-    return;
-  }
-  if (hdrMode === "auto") {
-    input.log.warn(
-      formatHdrAutoPromotionWarning({
-        triggeringAsset: sanitizeHdrAutoPromotionAsset(
-          input.autoPromotionTrigger ?? "an HDR-tagged asset"
-        ),
-        output: HDR_AUTO_PROMOTION_PIPELINE
-      })
-    );
-    return;
-  }
-  const reason = forcedHdrWithoutSources ? "forced by --hdr flag (no HDR sources detected, defaulting to HLG)" : "forced by --hdr flag";
-  input.log.info(
-    `[Render] HDR ${reason}, output: ${effectiveHdr.transfer.toUpperCase()} (BT.2020, 10-bit H.265)`
-  );
-}
-function formatCarriesHdr(format) {
-  return format === "mp4";
-}
-function rendersSdrOnly(config, media) {
-  return config.hdrMode === "force-sdr" || gradingKeepsSdr(config.hdrMode, media) || !formatCarriesHdr(config.format ?? "mp4");
-}
-function resolveEffectiveHdrMode(input) {
-  const hdrMode = input.hdrMode ?? "auto";
-  const videoColorSpaces = (input.extractionResult?.extracted ?? []).map(
-    (ext) => ext.metadata.colorSpace
-  );
-  const allColorSpaces = [...videoColorSpaces, ...input.imageColorSpaces];
-  const info = allColorSpaces.length > 0 ? analyzeCompositionHdr(allColorSpaces) : null;
-  let effectiveHdr;
-  let forcedHdrWithoutSources = false;
-  if (hdrMode === "force-sdr" || gradingKeepsSdr(hdrMode, input.media)) {
-    effectiveHdr = void 0;
-  } else if (hdrMode === "force-hdr") {
-    if (info?.hasHdr && info.dominantTransfer) {
-      effectiveHdr = { transfer: info.dominantTransfer };
-    } else {
-      effectiveHdr = { transfer: "hlg" };
-      forcedHdrWithoutSources = true;
-    }
-  } else if (info?.hasHdr && info.dominantTransfer) {
-    effectiveHdr = { transfer: info.dominantTransfer };
-  }
-  if (effectiveHdr && !formatCarriesHdr(input.outputFormat)) {
-    input.log.warn(formatDowngradeWarning(input.outputFormat, forcedHdrWithoutSources));
-    effectiveHdr = void 0;
-  }
-  logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, info?.hasHdr === true);
-  return effectiveHdr;
-}
-
-// src/services/render/captureBeyondViewport.ts
-function resolveVideoCaptureBeyondViewport(videoCount) {
-  if (videoCount <= 0) return void 0;
-  return true;
-}
-
 // src/services/render/captureCost.ts
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 import { fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
 import {
   calculateOptimalWorkers,
@@ -5258,6 +5063,7 @@ async function runCaptureCalibration(input) {
   let probeSession = input.probeSession;
   let forceScreenshot = input.forceScreenshot;
   let lastBrowserConsole = [];
+  let calibrationEvaluateTimedOut = false;
   const fps = fpsToNumber4(job.config.fps);
   const sessionRef = { current: null };
   const runOneCalibration = async (sessionDir, sessionCfg) => {
@@ -5298,11 +5104,12 @@ async function runCaptureCalibration(input) {
   });
   let calibration;
   try {
-    calibration = await runOneCalibration(join12(workDir, "capture-calibration"), calibrationCfg);
+    calibration = await runOneCalibration(join11(workDir, "capture-calibration"), calibrationCfg);
   } catch (error) {
     const shouldFallback = !forceScreenshot && shouldFallbackToScreenshotAfterCalibrationError(error);
     if (!shouldFallback) {
       calibration = createFailedCaptureCalibrationEstimate("calibration-failed");
+      calibrationEvaluateTimedOut = isEvaluateTimeout(error);
       log.warn("[Render] Auto-worker calibration failed; using conservative worker budget.", {
         protocolTimeout: calibrationCfg.protocolTimeout,
         error: error instanceof Error ? error.message : String(error)
@@ -5331,11 +5138,12 @@ async function runCaptureCalibration(input) {
       const screenshotCfg = createCaptureCalibrationConfig({ ...cfg, forceScreenshot: true });
       try {
         calibration = await runOneCalibration(
-          join12(workDir, "capture-calibration-screenshot"),
+          join11(workDir, "capture-calibration-screenshot"),
           screenshotCfg
         );
       } catch (fallbackError) {
         calibration = createFailedCaptureCalibrationEstimate("calibration-screenshot-failed");
+        calibrationEvaluateTimedOut = isEvaluateTimeout(fallbackError);
         log.warn(
           "[Render] Screenshot auto-worker calibration failed after BeginFrame fallback; using conservative worker budget.",
           {
@@ -5352,7 +5160,16 @@ async function runCaptureCalibration(input) {
       });
     }
   }
-  return { calibration, forceScreenshot, probeSession, lastBrowserConsole };
+  return {
+    calibration,
+    forceScreenshot,
+    probeSession,
+    lastBrowserConsole,
+    calibrationEvaluateTimedOut
+  };
+}
+function isEvaluateTimeout(error) {
+  return /Runtime\.evaluate timed out/i.test(normalizeErrorMessage(error));
 }
 function shouldFallbackToScreenshotAfterCalibrationError(error) {
   const message = normalizeErrorMessage(error);
@@ -5361,6 +5178,224 @@ function shouldFallbackToScreenshotAfterCalibrationError(error) {
   );
 }
 
+// src/services/render/pageNeverReady.ts
+var PAGE_NEVER_READY = "PAGE_NEVER_READY";
+var PageNeverReadyError = class extends Error {
+  code = PAGE_NEVER_READY;
+  // The producer server reads these off the error for the wire envelope.
+  owner = "user";
+  retryable = false;
+  constructor(cause) {
+    super(
+      "The composition page never became ready: it did not answer browser commands during calibration or capture, and no frame was captured. Its script may never return.",
+      { cause }
+    );
+    this.name = "PageNeverReadyError";
+  }
+};
+function checkPageNeverReady(input) {
+  const { calibrationEvaluateTimedOut, framesRendered, error } = input;
+  if (!calibrationEvaluateTimedOut || framesRendered > 0 || !isEvaluateTimeout(error)) {
+    return void 0;
+  }
+  return new PageNeverReadyError(error);
+}
+
+// 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 { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
+var MANIFEST_FILENAME = "segments.json";
+function computeSegmentPlanHash(input) {
+  const ordered = [
+    input.compositionHash,
+    input.cliVersion,
+    String(input.totalFrames),
+    String(input.segmentFrames),
+    `${input.fps.num}/${input.fps.den}`,
+    `${input.width}x${input.height}`,
+    input.codec,
+    input.preset,
+    input.quality === void 0 ? "" : String(input.quality),
+    input.bitrate ?? "",
+    input.pixelFormat ?? "",
+    input.imageFormat,
+    input.useGpu ? "gpu" : "cpu",
+    `${input.outputWidth}x${input.outputHeight}`,
+    input.motionBlur,
+    input.pageMotionBlur ?? "",
+    input.captureQuality === void 0 ? "" : String(input.captureQuality)
+  ];
+  const delivery = [input.maxBitrate, input.bufferSize, input.gopSize].map((v) => v ?? "");
+  if (delivery.some((v) => v !== "")) ordered.push(...delivery.map(String));
+  return createHash2("sha256").update(ordered.join(" ")).digest("hex").slice(0, 16);
+}
+function segmentDirFor(projectRendersDir, planHash) {
+  return join12(projectRendersDir, ".hf-segments", planHash);
+}
+function hasNumber(value, key) {
+  return key in value && typeof Reflect.get(value, key) === "number";
+}
+function hasString(value, key) {
+  return key in value && typeof Reflect.get(value, key) === "string";
+}
+function isEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return hasNumber(value, "index") && hasNumber(value, "startFrame") && hasNumber(value, "endFrame") && hasString(value, "path") && hasNumber(value, "bytes") && hasString(value, "completedAt");
+}
+function isManifest(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const completed = Reflect.get(value, "completed");
+  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);
+  if (!existsSync7(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    return isManifest(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeSegmentManifest(segmentDir, manifest) {
+  mkdirSync4(segmentDir, { recursive: true });
+  const tmp = join12(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
+  writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
+  renameWithRetry2(tmp, join12(segmentDir, MANIFEST_FILENAME));
+}
+async function probeSegmentFrameCount(path, probe) {
+  try {
+    const meta = await probe(path);
+    if (!Number.isFinite(meta.videoStreamDurationSeconds) || !Number.isFinite(meta.fps))
+      return null;
+    if (meta.fps <= 0) return null;
+    return Math.round(meta.videoStreamDurationSeconds * meta.fps);
+  } catch {
+    return null;
+  }
+}
+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;
+    const size = statSync4(entry.path).size;
+    if (size <= 0 || size !== entry.bytes) continue;
+    const frames = await probeFrames(entry.path);
+    if (frames !== entry.endFrame - entry.startFrame) continue;
+    ok.add(entry.index);
+  }
+  return ok;
+}
+
+// src/services/render/hdrMode.ts
+import {
+  analyzeCompositionHdr,
+  formatHdrAutoPromotionWarning,
+  gradingKeepsSdr,
+  HDR_AUTO_PROMOTION_PIPELINE,
+  isHdrColorSpace,
+  sanitizeHdrAutoPromotionAsset
+} from "@hyperframes/engine";
+function formatDowngradeWarning(outputFormat, forcedHdrWithoutSources) {
+  const hdrSourceReason = forcedHdrWithoutSources ? "HDR was forced without detected HDR sources" : "HDR source detected";
+  const formatReason = outputFormat === "hls" ? "HLS output is SDR-only (H.264 in MPEG-TS)" : "HDR + alpha is not supported";
+  return `[Render] ${hdrSourceReason}, but format is "${outputFormat}", so falling back to SDR. ${formatReason}. Use --format mp4 for HDR10 output.`;
+}
+function findRenderHdrAutoPromotionTrigger(input) {
+  for (const extracted of input.extractionResult?.extracted ?? []) {
+    if (!isHdrColorSpace(extracted.metadata.colorSpace)) continue;
+    const source = input.videos.find(({ id }) => id === extracted.videoId)?.src;
+    if (source) return source;
+  }
+  return input.images.find(({ id }) => input.nativeHdrImageIds.has(id))?.src;
+}
+function logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource) {
+  const keptSdr = hasHdrSource && gradingKeepsSdr(hdrMode, input.media);
+  if (keptSdr) {
+    input.log.warn(
+      "[Render] HDR source detected, but color grading is SDR-only, so rendering SDR: HDR sources are tone-mapped before the grade. Use --hdr to force HDR output (grades stay SDR)."
+    );
+  } else if (effectiveHdr && [...input.media.videos, ...input.media.images].some((m) => m.graded)) {
+    input.log.warn(
+      "[Render] HDR output with graded media: color grading is SDR-only, so graded elements are graded in SDR and placed in the HDR output."
+    );
+  }
+  return keptSdr;
+}
+function logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, hasHdrSource) {
+  const keptSdrForGrading = logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource);
+  if (forcedHdrWithoutSources) {
+    input.log.warn(
+      "[Render] HDR forced by --hdr flag, but no HDR sources were detected, defaulting to HLG. SDR-only compositions may look perceptually wrong on HDR displays."
+    );
+  }
+  if (!effectiveHdr) {
+    if (keptSdrForGrading) return;
+    input.log.info(
+      hdrMode === "force-sdr" ? "[Render] SDR forced by --sdr flag" : "[Render] No HDR sources detected, rendering SDR"
+    );
+    return;
+  }
+  if (hdrMode === "auto") {
+    input.log.warn(
+      formatHdrAutoPromotionWarning({
+        triggeringAsset: sanitizeHdrAutoPromotionAsset(
+          input.autoPromotionTrigger ?? "an HDR-tagged asset"
+        ),
+        output: HDR_AUTO_PROMOTION_PIPELINE
+      })
+    );
+    return;
+  }
+  const reason = forcedHdrWithoutSources ? "forced by --hdr flag (no HDR sources detected, defaulting to HLG)" : "forced by --hdr flag";
+  input.log.info(
+    `[Render] HDR ${reason}, output: ${effectiveHdr.transfer.toUpperCase()} (BT.2020, 10-bit H.265)`
+  );
+}
+function formatCarriesHdr(format) {
+  return format === "mp4";
+}
+function rendersSdrOnly(config, media) {
+  return config.hdrMode === "force-sdr" || gradingKeepsSdr(config.hdrMode, media) || !formatCarriesHdr(config.format ?? "mp4");
+}
+function resolveEffectiveHdrMode(input) {
+  const hdrMode = input.hdrMode ?? "auto";
+  const videoColorSpaces = (input.extractionResult?.extracted ?? []).map(
+    (ext) => ext.metadata.colorSpace
+  );
+  const allColorSpaces = [...videoColorSpaces, ...input.imageColorSpaces];
+  const info = allColorSpaces.length > 0 ? analyzeCompositionHdr(allColorSpaces) : null;
+  let effectiveHdr;
+  let forcedHdrWithoutSources = false;
+  if (hdrMode === "force-sdr" || gradingKeepsSdr(hdrMode, input.media)) {
+    effectiveHdr = void 0;
+  } else if (hdrMode === "force-hdr") {
+    if (info?.hasHdr && info.dominantTransfer) {
+      effectiveHdr = { transfer: info.dominantTransfer };
+    } else {
+      effectiveHdr = { transfer: "hlg" };
+      forcedHdrWithoutSources = true;
+    }
+  } else if (info?.hasHdr && info.dominantTransfer) {
+    effectiveHdr = { transfer: info.dominantTransfer };
+  }
+  if (effectiveHdr && !formatCarriesHdr(input.outputFormat)) {
+    input.log.warn(formatDowngradeWarning(input.outputFormat, forcedHdrWithoutSources));
+    effectiveHdr = void 0;
+  }
+  logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, info?.hasHdr === true);
+  return effectiveHdr;
+}
+
+// src/services/render/captureBeyondViewport.ts
+function resolveVideoCaptureBeyondViewport(videoCount) {
+  if (videoCount <= 0) return void 0;
+  return true;
+}
+
 // src/services/render/observability.ts
 import { createHash as createHash3 } from "node:crypto";
 import { redactTelemetryString } from "@hyperframes/core";
@@ -13446,6 +13481,7 @@ async function executeRenderPipeline(input) {
   const onProgress = execution.onProgress;
   const tooSlow = new AbortController();
   let tooSlowError;
+  let calibrationEvaluateTimedOut = false;
   const executionSignal = job.config.maxRenderMs ? AbortSignal.any([tooSlow.signal, ...execution.signal ? [execution.signal] : []]) : execution.signal;
   let fileServer = null;
   let probeSession = null;
@@ -14188,6 +14224,7 @@ async function executeRenderPipeline(input) {
         { heartbeatMessage: "browser calibrating (frames not started)" }
       );
       captureCalibration = outcome.calibration;
+      calibrationEvaluateTimedOut = outcome.calibrationEvaluateTimedOut;
       captureForceScreenshot = outcome.forceScreenshot;
       updateCaptureObservability({ forceScreenshot: captureForceScreenshot });
       probeSession = outcome.probeSession;
@@ -15338,7 +15375,12 @@ async function executeRenderPipeline(input) {
     await eventPublisher.flush();
   } catch (caught) {
     await pendingAudio;
-    const error = surfaceScriptFailure(tooSlowError ?? caught, job);
+    const pageNeverReady = checkPageNeverReady({
+      calibrationEvaluateTimedOut,
+      framesRendered: job.framesRendered ?? 0,
+      error: caught
+    });
+    const error = surfaceScriptFailure(tooSlowError ?? pageNeverReady ?? caught, job);
     if (!tooSlowError && (error instanceof RenderCancelledError || executionSignal?.aborted)) {
       job.error = error instanceof Error ? error.message : "render_cancelled";
       updateJobStatus(job, "cancelled", "Render cancelled", job.progress, onProgress);
@@ -19801,7 +19843,8 @@ var SAFE_RENDER_ERROR_CODES = /* @__PURE__ */ new Set([
   "VIDEO_EXTRACTION_FAILED",
   "ENCODER_INTERRUPTED",
   "RENDER_TOO_SLOW",
-  "RENDER_STAGE_STALLED"
+  "RENDER_STAGE_STALLED",
+  "PAGE_NEVER_READY"
 ]);
 function extractSafeRenderErrorCode(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) return void 0;

package/dist/public-server.js

@@ -4870,203 +4870,8 @@ function startRenderEtaGuard(options) {
   return stop;
 }
 
-// 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 join11 } from "node:path";
-import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
-var MANIFEST_FILENAME = "segments.json";
-function computeSegmentPlanHash(input) {
-  const ordered = [
-    input.compositionHash,
-    input.cliVersion,
-    String(input.totalFrames),
-    String(input.segmentFrames),
-    `${input.fps.num}/${input.fps.den}`,
-    `${input.width}x${input.height}`,
-    input.codec,
-    input.preset,
-    input.quality === void 0 ? "" : String(input.quality),
-    input.bitrate ?? "",
-    input.pixelFormat ?? "",
-    input.imageFormat,
-    input.useGpu ? "gpu" : "cpu",
-    `${input.outputWidth}x${input.outputHeight}`,
-    input.motionBlur,
-    input.pageMotionBlur ?? "",
-    input.captureQuality === void 0 ? "" : String(input.captureQuality)
-  ];
-  const delivery = [input.maxBitrate, input.bufferSize, input.gopSize].map((v) => v ?? "");
-  if (delivery.some((v) => v !== "")) ordered.push(...delivery.map(String));
-  return createHash2("sha256").update(ordered.join(" ")).digest("hex").slice(0, 16);
-}
-function segmentDirFor(projectRendersDir, planHash) {
-  return join11(projectRendersDir, ".hf-segments", planHash);
-}
-function hasNumber(value, key) {
-  return key in value && typeof Reflect.get(value, key) === "number";
-}
-function hasString(value, key) {
-  return key in value && typeof Reflect.get(value, key) === "string";
-}
-function isEntry(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return hasNumber(value, "index") && hasNumber(value, "startFrame") && hasNumber(value, "endFrame") && hasString(value, "path") && hasNumber(value, "bytes") && hasString(value, "completedAt");
-}
-function isManifest(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const completed = Reflect.get(value, "completed");
-  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 = join11(segmentDir, MANIFEST_FILENAME);
-  if (!existsSync7(path)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
-    return isManifest(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function writeSegmentManifest(segmentDir, manifest) {
-  mkdirSync4(segmentDir, { recursive: true });
-  const tmp = join11(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
-  writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
-  renameWithRetry2(tmp, join11(segmentDir, MANIFEST_FILENAME));
-}
-async function probeSegmentFrameCount(path, probe) {
-  try {
-    const meta = await probe(path);
-    if (!Number.isFinite(meta.videoStreamDurationSeconds) || !Number.isFinite(meta.fps))
-      return null;
-    if (meta.fps <= 0) return null;
-    return Math.round(meta.videoStreamDurationSeconds * meta.fps);
-  } catch {
-    return null;
-  }
-}
-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;
-    const size = statSync4(entry.path).size;
-    if (size <= 0 || size !== entry.bytes) continue;
-    const frames = await probeFrames(entry.path);
-    if (frames !== entry.endFrame - entry.startFrame) continue;
-    ok.add(entry.index);
-  }
-  return ok;
-}
-
-// src/services/render/hdrMode.ts
-import {
-  analyzeCompositionHdr,
-  formatHdrAutoPromotionWarning,
-  gradingKeepsSdr,
-  HDR_AUTO_PROMOTION_PIPELINE,
-  isHdrColorSpace,
-  sanitizeHdrAutoPromotionAsset
-} from "@hyperframes/engine";
-function formatDowngradeWarning(outputFormat, forcedHdrWithoutSources) {
-  const hdrSourceReason = forcedHdrWithoutSources ? "HDR was forced without detected HDR sources" : "HDR source detected";
-  const formatReason = outputFormat === "hls" ? "HLS output is SDR-only (H.264 in MPEG-TS)" : "HDR + alpha is not supported";
-  return `[Render] ${hdrSourceReason}, but format is "${outputFormat}", so falling back to SDR. ${formatReason}. Use --format mp4 for HDR10 output.`;
-}
-function findRenderHdrAutoPromotionTrigger(input) {
-  for (const extracted of input.extractionResult?.extracted ?? []) {
-    if (!isHdrColorSpace(extracted.metadata.colorSpace)) continue;
-    const source = input.videos.find(({ id }) => id === extracted.videoId)?.src;
-    if (source) return source;
-  }
-  return input.images.find(({ id }) => input.nativeHdrImageIds.has(id))?.src;
-}
-function logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource) {
-  const keptSdr = hasHdrSource && gradingKeepsSdr(hdrMode, input.media);
-  if (keptSdr) {
-    input.log.warn(
-      "[Render] HDR source detected, but color grading is SDR-only, so rendering SDR: HDR sources are tone-mapped before the grade. Use --hdr to force HDR output (grades stay SDR)."
-    );
-  } else if (effectiveHdr && [...input.media.videos, ...input.media.images].some((m) => m.graded)) {
-    input.log.warn(
-      "[Render] HDR output with graded media: color grading is SDR-only, so graded elements are graded in SDR and placed in the HDR output."
-    );
-  }
-  return keptSdr;
-}
-function logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, hasHdrSource) {
-  const keptSdrForGrading = logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource);
-  if (forcedHdrWithoutSources) {
-    input.log.warn(
-      "[Render] HDR forced by --hdr flag, but no HDR sources were detected, defaulting to HLG. SDR-only compositions may look perceptually wrong on HDR displays."
-    );
-  }
-  if (!effectiveHdr) {
-    if (keptSdrForGrading) return;
-    input.log.info(
-      hdrMode === "force-sdr" ? "[Render] SDR forced by --sdr flag" : "[Render] No HDR sources detected, rendering SDR"
-    );
-    return;
-  }
-  if (hdrMode === "auto") {
-    input.log.warn(
-      formatHdrAutoPromotionWarning({
-        triggeringAsset: sanitizeHdrAutoPromotionAsset(
-          input.autoPromotionTrigger ?? "an HDR-tagged asset"
-        ),
-        output: HDR_AUTO_PROMOTION_PIPELINE
-      })
-    );
-    return;
-  }
-  const reason = forcedHdrWithoutSources ? "forced by --hdr flag (no HDR sources detected, defaulting to HLG)" : "forced by --hdr flag";
-  input.log.info(
-    `[Render] HDR ${reason}, output: ${effectiveHdr.transfer.toUpperCase()} (BT.2020, 10-bit H.265)`
-  );
-}
-function formatCarriesHdr(format) {
-  return format === "mp4";
-}
-function rendersSdrOnly(config, media) {
-  return config.hdrMode === "force-sdr" || gradingKeepsSdr(config.hdrMode, media) || !formatCarriesHdr(config.format ?? "mp4");
-}
-function resolveEffectiveHdrMode(input) {
-  const hdrMode = input.hdrMode ?? "auto";
-  const videoColorSpaces = (input.extractionResult?.extracted ?? []).map(
-    (ext) => ext.metadata.colorSpace
-  );
-  const allColorSpaces = [...videoColorSpaces, ...input.imageColorSpaces];
-  const info = allColorSpaces.length > 0 ? analyzeCompositionHdr(allColorSpaces) : null;
-  let effectiveHdr;
-  let forcedHdrWithoutSources = false;
-  if (hdrMode === "force-sdr" || gradingKeepsSdr(hdrMode, input.media)) {
-    effectiveHdr = void 0;
-  } else if (hdrMode === "force-hdr") {
-    if (info?.hasHdr && info.dominantTransfer) {
-      effectiveHdr = { transfer: info.dominantTransfer };
-    } else {
-      effectiveHdr = { transfer: "hlg" };
-      forcedHdrWithoutSources = true;
-    }
-  } else if (info?.hasHdr && info.dominantTransfer) {
-    effectiveHdr = { transfer: info.dominantTransfer };
-  }
-  if (effectiveHdr && !formatCarriesHdr(input.outputFormat)) {
-    input.log.warn(formatDowngradeWarning(input.outputFormat, forcedHdrWithoutSources));
-    effectiveHdr = void 0;
-  }
-  logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, info?.hasHdr === true);
-  return effectiveHdr;
-}
-
-// src/services/render/captureBeyondViewport.ts
-function resolveVideoCaptureBeyondViewport(videoCount) {
-  if (videoCount <= 0) return void 0;
-  return true;
-}
-
 // src/services/render/captureCost.ts
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 import { fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
 import {
   calculateOptimalWorkers,
@@ -5271,6 +5076,7 @@ async function runCaptureCalibration(input) {
   let probeSession = input.probeSession;
   let forceScreenshot = input.forceScreenshot;
   let lastBrowserConsole = [];
+  let calibrationEvaluateTimedOut = false;
   const fps = fpsToNumber4(job.config.fps);
   const sessionRef = { current: null };
   const runOneCalibration = async (sessionDir, sessionCfg) => {
@@ -5311,11 +5117,12 @@ async function runCaptureCalibration(input) {
   });
   let calibration;
   try {
-    calibration = await runOneCalibration(join12(workDir, "capture-calibration"), calibrationCfg);
+    calibration = await runOneCalibration(join11(workDir, "capture-calibration"), calibrationCfg);
   } catch (error) {
     const shouldFallback = !forceScreenshot && shouldFallbackToScreenshotAfterCalibrationError(error);
     if (!shouldFallback) {
       calibration = createFailedCaptureCalibrationEstimate("calibration-failed");
+      calibrationEvaluateTimedOut = isEvaluateTimeout(error);
       log.warn("[Render] Auto-worker calibration failed; using conservative worker budget.", {
         protocolTimeout: calibrationCfg.protocolTimeout,
         error: error instanceof Error ? error.message : String(error)
@@ -5344,11 +5151,12 @@ async function runCaptureCalibration(input) {
       const screenshotCfg = createCaptureCalibrationConfig({ ...cfg, forceScreenshot: true });
       try {
         calibration = await runOneCalibration(
-          join12(workDir, "capture-calibration-screenshot"),
+          join11(workDir, "capture-calibration-screenshot"),
           screenshotCfg
         );
       } catch (fallbackError) {
         calibration = createFailedCaptureCalibrationEstimate("calibration-screenshot-failed");
+        calibrationEvaluateTimedOut = isEvaluateTimeout(fallbackError);
         log.warn(
           "[Render] Screenshot auto-worker calibration failed after BeginFrame fallback; using conservative worker budget.",
           {
@@ -5365,7 +5173,16 @@ async function runCaptureCalibration(input) {
       });
     }
   }
-  return { calibration, forceScreenshot, probeSession, lastBrowserConsole };
+  return {
+    calibration,
+    forceScreenshot,
+    probeSession,
+    lastBrowserConsole,
+    calibrationEvaluateTimedOut
+  };
+}
+function isEvaluateTimeout(error) {
+  return /Runtime\.evaluate timed out/i.test(normalizeErrorMessage(error));
 }
 function shouldFallbackToScreenshotAfterCalibrationError(error) {
   const message = normalizeErrorMessage(error);
@@ -5374,6 +5191,224 @@ function shouldFallbackToScreenshotAfterCalibrationError(error) {
   );
 }
 
+// src/services/render/pageNeverReady.ts
+var PAGE_NEVER_READY = "PAGE_NEVER_READY";
+var PageNeverReadyError = class extends Error {
+  code = PAGE_NEVER_READY;
+  // The producer server reads these off the error for the wire envelope.
+  owner = "user";
+  retryable = false;
+  constructor(cause) {
+    super(
+      "The composition page never became ready: it did not answer browser commands during calibration or capture, and no frame was captured. Its script may never return.",
+      { cause }
+    );
+    this.name = "PageNeverReadyError";
+  }
+};
+function checkPageNeverReady(input) {
+  const { calibrationEvaluateTimedOut, framesRendered, error } = input;
+  if (!calibrationEvaluateTimedOut || framesRendered > 0 || !isEvaluateTimeout(error)) {
+    return void 0;
+  }
+  return new PageNeverReadyError(error);
+}
+
+// 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 { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
+var MANIFEST_FILENAME = "segments.json";
+function computeSegmentPlanHash(input) {
+  const ordered = [
+    input.compositionHash,
+    input.cliVersion,
+    String(input.totalFrames),
+    String(input.segmentFrames),
+    `${input.fps.num}/${input.fps.den}`,
+    `${input.width}x${input.height}`,
+    input.codec,
+    input.preset,
+    input.quality === void 0 ? "" : String(input.quality),
+    input.bitrate ?? "",
+    input.pixelFormat ?? "",
+    input.imageFormat,
+    input.useGpu ? "gpu" : "cpu",
+    `${input.outputWidth}x${input.outputHeight}`,
+    input.motionBlur,
+    input.pageMotionBlur ?? "",
+    input.captureQuality === void 0 ? "" : String(input.captureQuality)
+  ];
+  const delivery = [input.maxBitrate, input.bufferSize, input.gopSize].map((v) => v ?? "");
+  if (delivery.some((v) => v !== "")) ordered.push(...delivery.map(String));
+  return createHash2("sha256").update(ordered.join(" ")).digest("hex").slice(0, 16);
+}
+function segmentDirFor(projectRendersDir, planHash) {
+  return join12(projectRendersDir, ".hf-segments", planHash);
+}
+function hasNumber(value, key) {
+  return key in value && typeof Reflect.get(value, key) === "number";
+}
+function hasString(value, key) {
+  return key in value && typeof Reflect.get(value, key) === "string";
+}
+function isEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return hasNumber(value, "index") && hasNumber(value, "startFrame") && hasNumber(value, "endFrame") && hasString(value, "path") && hasNumber(value, "bytes") && hasString(value, "completedAt");
+}
+function isManifest(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const completed = Reflect.get(value, "completed");
+  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);
+  if (!existsSync7(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    return isManifest(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeSegmentManifest(segmentDir, manifest) {
+  mkdirSync4(segmentDir, { recursive: true });
+  const tmp = join12(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
+  writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
+  renameWithRetry2(tmp, join12(segmentDir, MANIFEST_FILENAME));
+}
+async function probeSegmentFrameCount(path, probe) {
+  try {
+    const meta = await probe(path);
+    if (!Number.isFinite(meta.videoStreamDurationSeconds) || !Number.isFinite(meta.fps))
+      return null;
+    if (meta.fps <= 0) return null;
+    return Math.round(meta.videoStreamDurationSeconds * meta.fps);
+  } catch {
+    return null;
+  }
+}
+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;
+    const size = statSync4(entry.path).size;
+    if (size <= 0 || size !== entry.bytes) continue;
+    const frames = await probeFrames(entry.path);
+    if (frames !== entry.endFrame - entry.startFrame) continue;
+    ok.add(entry.index);
+  }
+  return ok;
+}
+
+// src/services/render/hdrMode.ts
+import {
+  analyzeCompositionHdr,
+  formatHdrAutoPromotionWarning,
+  gradingKeepsSdr,
+  HDR_AUTO_PROMOTION_PIPELINE,
+  isHdrColorSpace,
+  sanitizeHdrAutoPromotionAsset
+} from "@hyperframes/engine";
+function formatDowngradeWarning(outputFormat, forcedHdrWithoutSources) {
+  const hdrSourceReason = forcedHdrWithoutSources ? "HDR was forced without detected HDR sources" : "HDR source detected";
+  const formatReason = outputFormat === "hls" ? "HLS output is SDR-only (H.264 in MPEG-TS)" : "HDR + alpha is not supported";
+  return `[Render] ${hdrSourceReason}, but format is "${outputFormat}", so falling back to SDR. ${formatReason}. Use --format mp4 for HDR10 output.`;
+}
+function findRenderHdrAutoPromotionTrigger(input) {
+  for (const extracted of input.extractionResult?.extracted ?? []) {
+    if (!isHdrColorSpace(extracted.metadata.colorSpace)) continue;
+    const source = input.videos.find(({ id }) => id === extracted.videoId)?.src;
+    if (source) return source;
+  }
+  return input.images.find(({ id }) => input.nativeHdrImageIds.has(id))?.src;
+}
+function logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource) {
+  const keptSdr = hasHdrSource && gradingKeepsSdr(hdrMode, input.media);
+  if (keptSdr) {
+    input.log.warn(
+      "[Render] HDR source detected, but color grading is SDR-only, so rendering SDR: HDR sources are tone-mapped before the grade. Use --hdr to force HDR output (grades stay SDR)."
+    );
+  } else if (effectiveHdr && [...input.media.videos, ...input.media.images].some((m) => m.graded)) {
+    input.log.warn(
+      "[Render] HDR output with graded media: color grading is SDR-only, so graded elements are graded in SDR and placed in the HDR output."
+    );
+  }
+  return keptSdr;
+}
+function logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, hasHdrSource) {
+  const keptSdrForGrading = logGradingResolution(input, hdrMode, effectiveHdr, hasHdrSource);
+  if (forcedHdrWithoutSources) {
+    input.log.warn(
+      "[Render] HDR forced by --hdr flag, but no HDR sources were detected, defaulting to HLG. SDR-only compositions may look perceptually wrong on HDR displays."
+    );
+  }
+  if (!effectiveHdr) {
+    if (keptSdrForGrading) return;
+    input.log.info(
+      hdrMode === "force-sdr" ? "[Render] SDR forced by --sdr flag" : "[Render] No HDR sources detected, rendering SDR"
+    );
+    return;
+  }
+  if (hdrMode === "auto") {
+    input.log.warn(
+      formatHdrAutoPromotionWarning({
+        triggeringAsset: sanitizeHdrAutoPromotionAsset(
+          input.autoPromotionTrigger ?? "an HDR-tagged asset"
+        ),
+        output: HDR_AUTO_PROMOTION_PIPELINE
+      })
+    );
+    return;
+  }
+  const reason = forcedHdrWithoutSources ? "forced by --hdr flag (no HDR sources detected, defaulting to HLG)" : "forced by --hdr flag";
+  input.log.info(
+    `[Render] HDR ${reason}, output: ${effectiveHdr.transfer.toUpperCase()} (BT.2020, 10-bit H.265)`
+  );
+}
+function formatCarriesHdr(format) {
+  return format === "mp4";
+}
+function rendersSdrOnly(config, media) {
+  return config.hdrMode === "force-sdr" || gradingKeepsSdr(config.hdrMode, media) || !formatCarriesHdr(config.format ?? "mp4");
+}
+function resolveEffectiveHdrMode(input) {
+  const hdrMode = input.hdrMode ?? "auto";
+  const videoColorSpaces = (input.extractionResult?.extracted ?? []).map(
+    (ext) => ext.metadata.colorSpace
+  );
+  const allColorSpaces = [...videoColorSpaces, ...input.imageColorSpaces];
+  const info = allColorSpaces.length > 0 ? analyzeCompositionHdr(allColorSpaces) : null;
+  let effectiveHdr;
+  let forcedHdrWithoutSources = false;
+  if (hdrMode === "force-sdr" || gradingKeepsSdr(hdrMode, input.media)) {
+    effectiveHdr = void 0;
+  } else if (hdrMode === "force-hdr") {
+    if (info?.hasHdr && info.dominantTransfer) {
+      effectiveHdr = { transfer: info.dominantTransfer };
+    } else {
+      effectiveHdr = { transfer: "hlg" };
+      forcedHdrWithoutSources = true;
+    }
+  } else if (info?.hasHdr && info.dominantTransfer) {
+    effectiveHdr = { transfer: info.dominantTransfer };
+  }
+  if (effectiveHdr && !formatCarriesHdr(input.outputFormat)) {
+    input.log.warn(formatDowngradeWarning(input.outputFormat, forcedHdrWithoutSources));
+    effectiveHdr = void 0;
+  }
+  logHdrResolution(input, hdrMode, effectiveHdr, forcedHdrWithoutSources, info?.hasHdr === true);
+  return effectiveHdr;
+}
+
+// src/services/render/captureBeyondViewport.ts
+function resolveVideoCaptureBeyondViewport(videoCount) {
+  if (videoCount <= 0) return void 0;
+  return true;
+}
+
 // src/services/render/observability.ts
 import { createHash as createHash3 } from "node:crypto";
 import { redactTelemetryString } from "@hyperframes/core";
@@ -13422,6 +13457,7 @@ async function executeRenderPipeline(input) {
   const onProgress = execution.onProgress;
   const tooSlow = new AbortController();
   let tooSlowError;
+  let calibrationEvaluateTimedOut = false;
   const executionSignal = job.config.maxRenderMs ? AbortSignal.any([tooSlow.signal, ...execution.signal ? [execution.signal] : []]) : execution.signal;
   let fileServer = null;
   let probeSession = null;
@@ -14164,6 +14200,7 @@ async function executeRenderPipeline(input) {
         { heartbeatMessage: "browser calibrating (frames not started)" }
       );
       captureCalibration = outcome.calibration;
+      calibrationEvaluateTimedOut = outcome.calibrationEvaluateTimedOut;
       captureForceScreenshot = outcome.forceScreenshot;
       updateCaptureObservability({ forceScreenshot: captureForceScreenshot });
       probeSession = outcome.probeSession;
@@ -15314,7 +15351,12 @@ async function executeRenderPipeline(input) {
     await eventPublisher.flush();
   } catch (caught) {
     await pendingAudio;
-    const error = surfaceScriptFailure(tooSlowError ?? caught, job);
+    const pageNeverReady = checkPageNeverReady({
+      calibrationEvaluateTimedOut,
+      framesRendered: job.framesRendered ?? 0,
+      error: caught
+    });
+    const error = surfaceScriptFailure(tooSlowError ?? pageNeverReady ?? caught, job);
     if (!tooSlowError && (error instanceof RenderCancelledError || executionSignal?.aborted)) {
       job.error = error instanceof Error ? error.message : "render_cancelled";
       updateJobStatus(job, "cancelled", "Render cancelled", job.progress, onProgress);
@@ -16013,7 +16055,8 @@ var SAFE_RENDER_ERROR_CODES = /* @__PURE__ */ new Set([
   "VIDEO_EXTRACTION_FAILED",
   "ENCODER_INTERRUPTED",
   "RENDER_TOO_SLOW",
-  "RENDER_STAGE_STALLED"
+  "RENDER_STAGE_STALLED",
+  "PAGE_NEVER_READY"
 ]);
 function extractSafeRenderErrorCode(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) return void 0;

package/dist/services/render/captureCost.d.ts

@@ -86,6 +86,8 @@ export interface CaptureCalibrationOutcome {
     probeSession: CaptureSession | null;
     /** Buffer of whichever session was active last; the sequencer uses it for the error-path tail. */
     lastBrowserConsole: string[];
+    /** The final calibration failure was a `Runtime.evaluate` timeout: the page never answered. */
+    calibrationEvaluateTimedOut: boolean;
 }
 /**
  * Run the auto-worker capture-cost calibration, including the
@@ -108,6 +110,7 @@ export declare function runCaptureCalibration(input: {
     /** Throws `RenderCancelledError` when the caller's abort signal fires. */
     assertNotAborted: () => void;
 }): Promise<CaptureCalibrationOutcome>;
+export declare function isEvaluateTimeout(error: unknown): boolean;
 /**
  * Same as `runCaptureCalibration`'s error-classification check, but
  * exported separately because the sequencer also calls it from the

package/dist/services/render/pageNeverReady.d.ts

@@ -0,0 +1,6 @@
+/** Calibration and capture both timed out on `Runtime.evaluate` with no frame captured. */
+export declare function checkPageNeverReady(input: {
+    calibrationEvaluateTimedOut: boolean;
+    framesRendered: number;
+    error: unknown;
+}): Error | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/producer",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "HTML-to-video rendering engine using Chrome's BeginFrame API",
   "repository": {
     "type": "git",
@@ -35,11 +35,11 @@
     "postcss": "^8.4.0",
     "puppeteer": "~25.11.0",
     "puppeteer-core": "^25.11.0",
-    "@hyperframes/engine": "0.9.10",
-    "@hyperframes/lint": "0.9.10",
-    "@hyperframes/parsers": "0.9.10",
-    "@hyperframes/studio-server": "0.9.10",
-    "@hyperframes/core": "0.9.10"
+    "@hyperframes/core": "0.9.12",
+    "@hyperframes/engine": "0.9.12",
+    "@hyperframes/lint": "0.9.12",
+    "@hyperframes/parsers": "0.9.12",
+    "@hyperframes/studio-server": "0.9.12"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",
@@ -48,7 +48,7 @@
     "tsx": "^4.21.0",
     "typescript": "^5.7.2",
     "vitest": "^4.1.11",
-    "@hyperframes/aws-lambda": "0.9.10"
+    "@hyperframes/aws-lambda": "0.9.12"
   },
   "engines": {
     "node": ">=22"