@hyperframes/producer 0.9.11 → 0.9.13

package/dist/public-server.js

@@ -1237,27 +1237,25 @@ function createMemorySampler(intervalMs = 250) {
   };
 }
 var warnedSymlinkFallback = false;
+var copyCannotFix = (error) => ["ENOSPC", "EDQUOT", "EEXIST", "ENOENT"].includes(
+  error?.code ?? ""
+);
 function tryWindowsFrameJunction(fileSystem, src, dest) {
   if (process.platform !== "win32") return false;
   try {
     fileSystem.symlinkSync(src, dest, "junction");
     return true;
   } catch (error) {
-    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
-    if (["EPERM", "EACCES", "UNKNOWN", "EINVAL", "ENOSYS", "EOPNOTSUPP", "ENOTSUP"].includes(
-      code ?? ""
-    )) {
-      return false;
-    }
-    throw error;
+    if (copyCannotFix(error)) throw error;
+    return false;
   }
 }
 function linkOrCopyFrameDir(fileSystem, src, dest) {
   try {
     fileSystem.symlinkSync(src, dest, "dir");
   } catch (err) {
+    if (copyCannotFix(err)) throw err;
     const code = err?.code;
-    if (code !== "EPERM" && code !== "EACCES" && code !== "UNKNOWN") throw err;
     if (tryWindowsFrameJunction(fileSystem, src, dest)) return;
     if (!warnedSymlinkFallback) {
       warnedSymlinkFallback = true;
@@ -4870,203 +4868,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 +5074,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 +5115,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 +5149,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 +5171,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 +5189,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";
@@ -9473,13 +9506,20 @@ var VideoExtractionStageError = class extends Error {
    */
   publicMetadata;
 };
-function throwIfEncoderInterrupted(result) {
+function throwIfHostFailure(result) {
   const interrupted = result.errors.find((failure) => failure.kind === "external_interruption");
-  if (!interrupted) return;
-  throw encoderFailureError("Video frame extraction failed", {
-    error: String(interrupted.error),
-    failureReason: "external_interruption"
-  });
+  if (interrupted) {
+    throw encoderFailureError("Video frame extraction failed", {
+      error: String(interrupted.error),
+      failureReason: "external_interruption"
+    });
+  }
+  const full = result.errors.filter((failure) => failure.kind === "disk_full").length;
+  if (full === 0) return;
+  throw Object.assign(
+    new Error(`ENOSPC: no space left on device, extracting the frames of ${full} video source(s)`),
+    { code: "ENOSPC" }
+  );
 }
 function buildVideoExtractionStageError(result) {
   if (result.success && result.errors.length === 0) return null;
@@ -9694,7 +9734,7 @@ async function runExtractVideosStage(input) {
     );
     extractionResult.phaseBreakdown.transientRetries = (extractionResult.phaseBreakdown.transientRetries ?? 0) + hdrProbeTransientRetries;
     assertNotAborted();
-    throwIfEncoderInterrupted(extractionResult);
+    throwIfHostFailure(extractionResult);
     failureToEnforce = applyVideoExtractionFailurePolicy(extractionResult, extractionPolicy, log);
     materializeExtractedFramesForCompiledDir(extractionResult.extracted, compiledDir, {
       materializeSymlinks
@@ -12832,6 +12872,22 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       }
       const remainingCount = countFrameRanges(remaining);
       const madeProgress = captureAttemptMadeProgress(frameCount, remainingCount);
+      if (options.allowRetry && !madeProgress && (currentWorkers > 1 || initializationRetriesUsed === 0 && failure.kind === "protocol_timeout") && /\bNetwork\.enable timed out|Navigation timeout of \d+ ms exceeded/i.test(failure.message)) {
+        initializationRetriesUsed++;
+        const nextWorkers2 = getNextRetryWorkerCount(currentWorkers);
+        options.log.warn(
+          "[Render] Browser initialization timed out; retrying with fewer workers.",
+          {
+            fromWorkers: currentWorkers,
+            toWorkers: nextWorkers2,
+            error: failure.message
+          }
+        );
+        currentWorkers = nextWorkers2;
+        missingRanges = remaining;
+        attempt++;
+        continue;
+      }
       if (options.allowRetry && isTransientCaptureRetryEligible(failure.kind, remaining, transientRetriesUsed)) {
         transientRetriesUsed++;
         options.log.warn(
@@ -12849,22 +12905,6 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
         pendingTransientRetry = true;
         continue;
       }
-      if (options.allowRetry && !madeProgress && initializationRetriesUsed === 0 && failure.kind === "protocol_timeout" && /\bNetwork\.enable timed out/i.test(failure.message)) {
-        initializationRetriesUsed++;
-        const nextWorkers2 = getNextRetryWorkerCount(currentWorkers);
-        options.log.warn(
-          "[Render] Browser initialization timed out; retrying once with fresh sessions.",
-          {
-            fromWorkers: currentWorkers,
-            toWorkers: nextWorkers2,
-            error: failure.message
-          }
-        );
-        currentWorkers = nextWorkers2;
-        missingRanges = remaining;
-        attempt++;
-        continue;
-      }
       if (!madeProgress) {
         options.log.warn(
           "[Render] Capture attempt made no forward progress; composition is likely structurally broken, not retrying.",
@@ -13422,6 +13462,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 +14205,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 +15356,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 +16060,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;