@hyperframes/producer 0.9.12 → 0.9.14

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;
@@ -3756,6 +3754,7 @@ function createStallClock(now = () => Date.now()) {
 
 // src/services/render/stages/captureStreamingStage.ts
 var DEFAULT_CAPTURE_STALL_MS = 6e4;
+var SESSION_INIT_STALL_MS = 3e5;
 var DE_STALL_POLL_MS = 5e3;
 var STALL_ADVICE = "Chrome stopped answering. If another app is keeping the GPU or CPU busy (a 3D render, a game, another export), let it finish or render one job at a time, then retry.";
 function poolFailure(error, probeSession) {
@@ -3786,6 +3785,14 @@ function captureModeLabel(mode) {
   if (mode === "beginframe") return "BeginFrame";
   return "screenshot";
 }
+var OPENING_CAPTURE_SESSION = {
+  captureMode: "screenshot",
+  captureStep: "opening the capture session"
+};
+var OPENING_RISK_SESSION = {
+  captureMode: "screenshot",
+  captureStep: "opening the screenshot session for effect frames"
+};
 var SequentialCaptureStallError = class extends Error {
   captureMode;
   constructor(session, stallTimeoutMs, frameIndex, totalFrames) {
@@ -3935,7 +3942,12 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
   const guard = createDrainFrameGuard({ log, stats, frameTime });
   const guardFrame = (item, buf) => item.trusted ? Promise.resolve(buf) : guard(session, item.idx, buf);
   const captureRisk = async (idx) => {
-    await risk.open();
+    await raceAgainstStall(
+      risk.open(),
+      stallTimeoutMs - quiet.idle(0),
+      { session: OPENING_RISK_SESSION, frameIndex: idx, totalFrames, stallTimeoutMs },
+      abortSignal
+    );
     quiet.reset();
     return raceAgainstStall(
       risk.capture(idx, frameTime(idx)),
@@ -4294,19 +4306,38 @@ async function runCaptureStreamingStage(input) {
       let resumes = 0;
       for (; ; ) {
         const videoInjector = createRenderVideoFrameInjector();
-        const session = probeSession ?? await createCaptureSession(
-          fileServer.url,
-          framesDir,
-          buildCaptureOptions(),
-          videoInjector,
-          captureCfg
+        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 },
+          abortSignal
         );
+        const openSession = async () => {
+          const opening = createCaptureSession(
+            fileServer.url,
+            framesDir,
+            buildCaptureOptions(),
+            videoInjector,
+            captureCfg
+          );
+          try {
+            return await withinInitBudget(opening, OPENING_CAPTURE_SESSION);
+          } catch (error) {
+            void opening.then(closeCaptureSession, () => {
+            });
+            throw error;
+          }
+        };
+        const session = probeSession ?? await openSession();
         captureBeyondViewport = session.options.captureBeyondViewport;
         if (probeSession) {
           prepareCaptureSessionForReuse(session, framesDir, videoInjector);
           probeSession = null;
         }
         let riskSession = null;
+        let attemptClosed = false;
         const openRiskSession = async () => {
           const opened = await createCaptureSession(
             fileServer.url,
@@ -4320,6 +4351,10 @@ async function runCaptureStreamingStage(input) {
               enableBrowserPool: false
             }
           );
+          if (attemptClosed) {
+            await closeCaptureSession(opened);
+            throw new Error("[Render] Capture attempt ended while its screenshot session opened");
+          }
           riskSession = opened;
           await initializeSession(opened);
           return opened;
@@ -4327,9 +4362,9 @@ async function runCaptureStreamingStage(input) {
         let resumed = false;
         try {
           if (!session.isInitialized) {
-            await initializeSession(session);
+            await withinInitBudget(initializeSession(session), session);
           }
-          await completeDeferredDrawElementInit(session);
+          await withinInitBudget(completeDeferredDrawElementInit(session), session);
           assertNotAborted();
           lastBrowserConsole = session.browserConsoleBuffer;
           if (session.workerEncodeEnabled) {
@@ -4412,6 +4447,7 @@ async function runCaptureStreamingStage(input) {
           resumes++;
           resumed = true;
         } finally {
+          attemptClosed = true;
           lastBrowserConsole = session.browserConsoleBuffer;
           await closeCaptureSession(session);
           if (riskSession) await closeCaptureSession(riskSession);
@@ -5878,7 +5914,7 @@ import { suggestMatchingPreset } from "@hyperframes/core";
 // src/services/htmlCompiler.ts
 import { decodedUrlPath } from "@hyperframes/parsers/asset-paths";
 import { createHash as createHash6 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7 } from "fs";
 import { join as join15, dirname as dirname7, resolve as resolve7, basename as basename4, relative as relative2 } from "path";
 import { parseHTML as parseHTML5 } from "linkedom";
 import {
@@ -7853,6 +7889,25 @@ ${fontFaceBlocks.join("\n")}
   }
   return result;
 }
+function projectStylesheetFontFamilies(html, projectDir) {
+  const families = [];
+  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;
+    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 file = path.startsWith("/") ? resolve7(projectDir, `.${path}`) : resolve7(dirname7(sheet), path);
+        return isPathInside2(file, projectDir) && existsSync10(file);
+      });
+      if (family && shipsFile) families.push(family);
+    }
+  }
+  return families;
+}
 function collectFontFaceUrls(html) {
   const styleBlockRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
   const urlSet = /* @__PURE__ */ new Set();
@@ -7883,12 +7938,10 @@ function collectFontFaceUrls(html) {
   }
   return urlSet;
 }
-async function localizeRemoteFontFaces(html, downloadDir) {
-  const processed = await inlineExternalFontStylesheets(html);
-  const urlSet = collectFontFaceUrls(processed);
+function localizeFontFaceUrls(html, downloadDir) {
   return downloadAndRewriteUrls(
-    urlSet,
-    processed,
+    collectFontFaceUrls(html),
+    html,
     join15(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
@@ -8056,15 +8109,17 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   const hasShaderTransitions = detectShaderTransitionUsage(sanitizedHtml);
   const usesThreeDTransforms = detectThreeDTransformUsage(sanitizedHtml);
   const hasAncestorBackgroundImage = detectAncestorBackgroundImage(sanitizedHtml);
+  const fontSheetHtml = await inlineExternalFontStylesheets(
+    promoteCssImportsToLinkTags(sanitizedHtml)
+  );
   const normalizedFontHtml = normalizeSystemFontPrimaryFamilies(
-    injectTextRenderingRule(
-      coalesceHeadStylesAndBodyScripts(promoteCssImportsToLinkTags(sanitizedHtml))
-    )
+    injectTextRenderingRule(coalesceHeadStylesAndBodyScripts(fontSheetHtml))
   );
   const coalescedHtml = await injectDeterministicFontFaces(normalizedFontHtml, {
     logger: defaultLogger,
     failClosedFontFetch: options.failClosedFontFetch === true,
     allowSystemFontCapture: options.allowSystemFontCapture,
+    projectFontFamilies: projectStylesheetFontFamilies(fontSheetHtml, projectDir),
     abortSignal: options.abortSignal
   });
   const assembledHtml = await inlineExternalScripts(coalescedHtml);
@@ -8090,7 +8145,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
   );
   const { html: htmlWithLocalImages, remoteMediaAssets: remoteImageAssets } = await localizeRemoteImageSources(htmlWithLocalMedia, downloadDir);
   const { html: htmlWithLocalBg, remoteMediaAssets: remoteBgAssets } = await localizeRemoteBackgroundImages(htmlWithLocalImages, downloadDir);
-  const { html: htmlWithLocalizedFonts, remoteMediaAssets: remoteFontAssets } = await localizeRemoteFontFaces(htmlWithLocalBg, downloadDir);
+  const { html: htmlWithLocalizedFonts, remoteMediaAssets: remoteFontAssets } = await localizeFontFaceUrls(htmlWithLocalBg, downloadDir);
   const {
     html: htmlWithJpegs,
     preparedAssets: preparedHeifAssets,
@@ -9508,13 +9563,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;
@@ -9729,7 +9791,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
@@ -11921,7 +11983,7 @@ import {
   existsSync as existsSync17,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmSync as rmSync9,
   statSync as statSync7,
   writeFileSync as writeFileSync5
@@ -12015,7 +12077,7 @@ async function reencodeWithClearedWholeFrames(argsInput, run, startTime) {
     const error = formatFfmpegError(result.exitCode, result.stderr);
     return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
   }
-  const gif = readFileSync7(outputPath);
+  const gif = readFileSync8(outputPath);
   if (!clearGifFramesBeforeNext(gif)) {
     const error = "[FFmpeg] GIF output could not be parsed to clear its frames";
     return gifEncodeFailure(startTime, outputPath, error);
@@ -12048,7 +12110,7 @@ async function encodeGifFromDir(framesDir, framePattern, outputPath, input) {
         return gifEncodeFailure(startTime, outputPath, error, result.failureReason);
       }
     }
-    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync7(outputPath)) !== false) {
+    if (input.preserveAlpha && gifClearsAfterLeavingFrameInPlace(readFileSync8(outputPath)) !== false) {
       const failure = await reencodeWithClearedWholeFrames(argsInput, run, startTime);
       if (failure) return failure;
     }
@@ -12867,6 +12929,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(
@@ -12884,22 +12962,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.",
@@ -15450,7 +15512,7 @@ async function executeRenderPipeline(input) {
 // src/services/hyperframeLint.ts
 import {
   existsSync as existsSync19,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   statSync as statSync9,
   openSync as openSync5,
   fstatSync as fstatSync3,
@@ -15496,7 +15558,7 @@ function readEntryHtml(filePath) {
   }
   try {
     if (!fstatSync3(fd).isFile()) return null;
-    return readFileSync8(fd, "utf-8");
+    return readFileSync9(fd, "utf-8");
   } finally {
     closeSync5(fd);
   }

package/dist/services/render/stages/captureStreamingStage.d.ts

@@ -44,7 +44,10 @@ import type { ProducerLogger } from "../../../logger.js";
 import type { ProgressCallback, RenderJob } from "../../renderOrchestrator.js";
 import type { SdrStreamingCapturePlan } from "../capturePlan.js";
 export declare function resolveCaptureStallTimeoutMs(): number;
-type StalledSession = Pick<CaptureSession, "captureMode" | "captureStep">;
+type StalledSession = {
+    captureMode: CaptureSession["captureMode"];
+    captureStep?: string;
+};
 export declare function raceAgainstStall<T>(promise: Promise<T>, deadlineMs: number, input: {
     session: StalledSession;
     frameIndex: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/producer",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "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/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"
+    "@hyperframes/core": "0.9.14",
+    "@hyperframes/lint": "0.9.14",
+    "@hyperframes/engine": "0.9.14",
+    "@hyperframes/studio-server": "0.9.14",
+    "@hyperframes/parsers": "0.9.14"
   },
   "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.12"
+    "@hyperframes/aws-lambda": "0.9.14"
   },
   "engines": {
     "node": ">=22"