@hyperframes/engine 0.8.202 → 0.8.204

package/dist/services/browserManager.d.ts

@@ -48,6 +48,7 @@ interface BeginFrameProbeResult {
     supported: boolean;
     detail: string;
     durationMs: number;
+    timedOut?: boolean;
 }
 declare function closeBrowserAfterFailedProbe(browser: Browser, timeoutMs?: number): Promise<void>;
 declare function probeBeginFrameSupport(browser: Browser, timeoutMs?: number): Promise<BeginFrameProbeResult>;

package/dist/services/browserManager.js

@@ -245,22 +245,25 @@ const BEGINFRAME_ONLY_FLAGS = new Set([
 function stripBeginFrameFlags(args) {
     return args.filter((a) => !BEGINFRAME_ONLY_FLAGS.has(a));
 }
+class BeginFrameProbeTimeout extends Error {
+}
 const BEGINFRAME_PROBE_TIMEOUT_MS = 2000;
+const BEGINFRAME_PROBE_RETRY_TIMEOUT_MS = 8000;
 const BEGINFRAME_PROBE_CLEANUP_TIMEOUT_MS = 250;
 async function awaitBeforeDeadline(operation, deadline, label) {
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) {
-        throw new Error(`beginFrame probe timeout before ${label}`);
+        throw new BeginFrameProbeTimeout(`beginFrame probe timeout before ${label}`);
     }
-    return rejectAfter(operation, remainingMs, `beginFrame probe timeout during ${label}`);
+    return rejectAfter(operation, remainingMs, new BeginFrameProbeTimeout(`beginFrame probe timeout during ${label}`));
 }
-async function rejectAfter(operation, timeoutMs, message) {
+async function rejectAfter(operation, timeoutMs, error) {
     let timeout;
     try {
         return await Promise.race([
             operation,
             new Promise((_, reject) => {
-                timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+                timeout = setTimeout(() => reject(typeof error === "string" ? new Error(error) : error), timeoutMs);
             }),
         ]);
     }
@@ -345,7 +348,8 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
             await awaitBeforeDeadline(new Promise((resolveDelay) => setTimeout(resolveDelay, 10)), deadline, `screenshot retry delay ${attempts}`);
         }
         if (!isPng) {
-            throw new Error(`beginFrame screenshot returned ${bytes.length} bytes after ` +
+            const Failure = bytes.length === 0 ? BeginFrameProbeTimeout : Error;
+            throw new Failure(`beginFrame screenshot returned ${bytes.length} bytes after ` +
                 `${attempts} attempts in ${Date.now() - started}ms with signature ` +
                 `${bytes.length >= 4 ? bytes.subarray(0, 4).toString("hex") : "<empty>"}`);
         }
@@ -362,6 +366,7 @@ async function probeBeginFrameSupport(browser, timeoutMs = BEGINFRAME_PROBE_TIME
             supported: false,
             detail: error instanceof Error ? error.message : String(error),
             durationMs: Date.now() - started,
+            timedOut: error instanceof BeginFrameProbeTimeout,
         };
     }
     if (page && !(await settleWithin(page.close(), BEGINFRAME_PROBE_CLEANUP_TIMEOUT_MS))) {
@@ -653,42 +658,43 @@ async function launchBrowser(fingerprint) {
     const env = launchEnv(fingerprint);
     let captureMode = fingerprint.requestedCaptureMode;
     let browser;
+    const launch = (args) => ppt.launch({
+        ...sigintLaunchOptions(),
+        headless: true,
+        args: withHyperframesBrowserMarker(args),
+        defaultViewport: null,
+        executablePath: fingerprint.executablePath,
+        env,
+        timeout: fingerprint.browserTimeoutMs,
+        protocolTimeout: fingerprint.protocolTimeoutMs,
+    });
+    const probe = (target, timeoutMs) => probeBeginFrameSupport(target, timeoutMs).catch((error) => ({
+        supported: true,
+        detail: `probe harness error ignored: ${error instanceof Error ? error.message : String(error)}`,
+        durationMs: 0,
+        timedOut: false,
+    }));
     try {
-        browser = await ppt.launch({
-            ...sigintLaunchOptions(),
-            headless: true,
-            args: withHyperframesBrowserMarker(fingerprint.args),
-            defaultViewport: null,
-            executablePath: fingerprint.executablePath,
-            env,
-            timeout: fingerprint.browserTimeoutMs,
-            protocolTimeout: fingerprint.protocolTimeoutMs,
-        });
+        browser = await launch(fingerprint.args);
         const browserVersion = await browser.version().catch(() => "unknown");
         const gpuFlags = fingerprint.args.filter((a) => a.startsWith("--use-gl=") || a.startsWith("--use-angle="));
         console.error(`[BrowserManager] Browser launched (${browserVersion}, ${captureMode}, gl=${gpuFlags.join(" ") || "default"}, headlessShell=${!!fingerprint.executablePath}, platform=${process.platform})`);
         if (captureMode === "beginframe") {
-            const probe = await probeBeginFrameSupport(browser).catch((error) => ({
-                supported: true,
-                detail: `probe harness error ignored: ${error instanceof Error ? error.message : String(error)}`,
-                durationMs: 0,
-            }));
-            if (!probe.supported) {
+            let result = await probe(browser);
+            if (!result.supported && result.timedOut) {
+                console.warn(`[BrowserManager] HeadlessExperimental.beginFrame probe timed out after ${result.durationMs}ms: ` +
+                    `${result.detail}; retrying once with a longer budget.`);
+                await closeBrowserAfterFailedProbe(browser);
+                browser = await launch(fingerprint.args);
+                result = await probe(browser, BEGINFRAME_PROBE_RETRY_TIMEOUT_MS);
+            }
+            if (!result.supported) {
                 await closeBrowserAfterFailedProbe(browser);
                 browser = undefined;
-                console.warn(`[BrowserManager] HeadlessExperimental.beginFrame probe failed after ${probe.durationMs}ms: ` +
-                    `${probe.detail}; falling back to screenshot mode.`);
+                console.warn(`[BrowserManager] HeadlessExperimental.beginFrame probe failed after ${result.durationMs}ms: ` +
+                    `${result.detail}; falling back to screenshot mode.`);
                 captureMode = "screenshot";
-                browser = await ppt.launch({
-                    ...sigintLaunchOptions(),
-                    headless: true,
-                    args: withHyperframesBrowserMarker(stripBeginFrameFlags([...fingerprint.args])),
-                    defaultViewport: null,
-                    executablePath: fingerprint.executablePath,
-                    env,
-                    timeout: fingerprint.browserTimeoutMs,
-                    protocolTimeout: fingerprint.protocolTimeoutMs,
-                });
+                browser = await launch(stripBeginFrameFlags([...fingerprint.args]));
             }
         }
         return { browser, captureMode };

package/dist/services/frameCapture.js

@@ -834,7 +834,6 @@ async function installMediaPageHooks(page, options) {
         await page.evaluateOnNewDocument(holdRenderFrameVideos, options.skipReadinessVideoIds, MEDIA_RENDER_ID_ATTR);
     }
 }
-// fallow-ignore-next-line unit-size
 export async function createCaptureSession(serverUrl, outputDir, options, onBeforeCapture = null, config) {
     if (!existsSync(outputDir))
         mkdirSync(outputDir, { recursive: true });
@@ -1845,7 +1844,6 @@ export function classifyPageError(details, projectScripts) {
     const owned = (url) => url !== undefined && (projectScripts.has(url) || url.startsWith(COMPOSITION_SOURCE_URL));
     return urls.some(owned) ? `runtime-error:${firstLine}` : null;
 }
-// fallow-ignore-next-line unit-size
 export async function initializeSession(session) {
     const { page, serverUrl } = session;
     // Forward browser console to host. HyperFrames runtime logs get a dedicated
@@ -3765,7 +3763,7 @@ export async function closeCaptureSession(session) {
         session.chromeMemory.stop();
         // One last sample so the summary reflects the session's end state, not a
         // point up to `intervalMs` earlier. Best effort; the page may be gone.
-        await session.chromeMemory.sampleOnce();
+        await waitForCloseWithTimeout(session.chromeMemory.sampleOnce());
     }
     if (session.page && !session.pageReleased) {
         const blur = await describePageMotionBlurAtEnd(session.page);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/engine",
-  "version": "0.8.202",
+  "version": "0.8.204",
   "description": "Seekable web page to video rendering engine (Puppeteer + FFmpeg)",
   "repository": {
     "type": "git",
@@ -50,8 +50,8 @@
     "linkedom": "^0.18.12",
     "puppeteer": "^25.8.0",
     "puppeteer-core": "^25.8.0",
-    "@hyperframes/core": "^0.8.202",
-    "@hyperframes/parsers": "^0.8.202"
+    "@hyperframes/parsers": "^0.8.204",
+    "@hyperframes/core": "^0.8.204"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",