@hyperframes/engine 0.8.198 → 0.8.200

package/dist/services/frameCapture.d.ts

@@ -19,7 +19,10 @@ export type { CaptureOptions, CaptureResult, CaptureBufferResult, CapturePerfSum
 /** Called after seeking, before screenshot. Use for video frame injection or other pre-capture work.
  * `heldVideoTime` (motion-blur samples only) is the output frame's time: a video on screen at
  * both times shows its frame for `heldVideoTime`, so footage does not smear. */
-export type BeforeCaptureHook = (page: Page, time: number, heldVideoTime?: number) => Promise<void>;
+export type BeforeCaptureHook = ((page: Page, time: number, heldVideoTime?: number) => Promise<void>) & {
+    /** A hook with state of its own, for a second page; absent when the hook cannot be copied. */
+    fresh?: () => BeforeCaptureHook | null;
+};
 /** The per-frame wait a capture is in, worded for the stall error a user reads. */
 type CaptureStep = "seeking the timeline" | "decoding CSS background images" | "injecting video frames" | "waiting for page seek handlers" | "loading color-grading LUTs" | "compositing the page" | "capturing the frame";
 export interface CaptureSession {
@@ -161,6 +164,13 @@ export interface CaptureSession {
      * Empty/undefined when the predictor produces no frames.
      */
     clipBoundaryFrames?: Set<number>;
+    /**
+     * Frames drawElement cannot reproduce, for the caller to capture with a screenshot session.
+     * Set only when the caller can (worker-encode pipeline); drawElement capture throws on these.
+     */
+    deRiskFrames?: Set<number>;
+    /** The effects behind {@link deRiskFrames}, for the capture log. */
+    deRiskReason?: string;
     /** Rolling drawElement frame byte-sizes (last ~60), for silent-blank-drop detection:
      * drawElement intermittently returns an anomalously small (blank) frame with no
      * throw; a frame far below the running median is re-captured via screenshot. */
@@ -761,6 +771,8 @@ export declare function getCompositionDuration(session: CaptureSession): Promise
  * timeline passed verification while the drained output bottomed at 30.9 dB.
  */
 export declare function computeDeVerifySampleFractions(k: number): number[];
+/** Seeks the page the truth is read from; callbacks run unless suppressed (suppressed, a count-up's text is stale). */
+export declare function seekDeVerifyTruth(page: Page, t: number, suppressEvents: boolean): Promise<void>;
 /**
  * Percentile of a positive-real sample set (nearest-rank; matches how the
  * existing {@link medianOf} p50 helper picks the middle index). `p` is a

package/dist/services/frameCapture.js

@@ -9,7 +9,7 @@
  */
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
-import { COMPOSITION_SOURCE_URL, MEDIA_RENDER_ID_ATTR, quantizeSeekTime, quantizeTimeToFrame, fpsToNumber, resolveAuthoredTimingWindow, } from "@hyperframes/core";
+import { COMPOSITION_SOURCE_URL, MEDIA_RENDER_ID_ATTR, quantizeSeekTime, quantizeTimeToFrame, fpsToNumber, resolveAuthoredTimingWindow, SCENE_CALLBACK_ERROR_PREFIX, } from "@hyperframes/core";
 import { holdRenderFrameVideos } from "./renderFrameVideoHold.js";
 import { DrawElementCaptureError } from "./drawElementCaptureError.js";
 import { encodePng } from "../utils/alphaBlit.js";
@@ -19,7 +19,9 @@ import { describePageMotionBlur, describePageMotionBlurAtEnd, installPageMotionB
 import { acquireBrowser, releaseBrowser, forceReleaseBrowser, buildChromeArgs, resolveBrowserGpuMode, captureWithoutWaylandDisplay, resolveHeadlessShellPath, compositionRequiresWebGpu, assertWebGpuAdapterAvailable, usesSoftwareWebGpu, } from "./browserManager.js";
 import { beginFrameCapture, ensureRenderFrameSiblings, getCdpSession, pageContentExceedsCaptureHeight, pageScreenshotCapture, initTransparentBackground, shouldDefaultCaptureBeyondViewport, } from "./screenshotService.js";
 import { classifyGpuRenderer, detectGpuBackend, injectDrawElementCanvas, captureDrawElementFrame, resolveDrawElementCaptureMode, instrumentAcceleratedCanvases, initDrawElementWorkerEncode, cleanupDrawElementWorkerEncode, produceDrawElementFrame, produceDrawElementFrameBatch, DE_CANVAS_NOT_INITIALIZED_CODE, } from "./drawElementService.js";
-import { initThreeDProjection, detectCssEffectRisk } from "./threeDProjection.js";
+import { initThreeDProjection, scanCssEffects } from "./threeDProjection.js";
+import { planRiskFrames, scanCssEffectLiveFrames, riskSessionFits, withFramesAfterCallback, MAX_RISK_FRAME_FRACTION, } from "./riskFrames.js";
+import { getAvailableMemoryMb } from "./systemMemory.js";
 import { isPsnrFilterAvailable } from "../utils/psnrFilterAvailability.js";
 import { DEFAULT_CONFIG, applyConcreteGpuScreenshotClamp } from "../config.js";
 import { cloneCaptureWarnings } from "./captureWarning.js";
@@ -585,18 +587,37 @@ async function initDrawElementOrTransparentBackground(session, page, logInitPhas
             // path — drawElementImage can't reproduce either, producing 18–49 dB
             // damaged frames (community eval). Fall back to the platform baseline.
             // HF_FAST_CAPTURE_CSSFX=true bypasses for R&D.
+            // Frames this render captures by screenshot instead (see CaptureSession.deRiskFrames);
+            // only a session whose caller can hand them over (worker-encode pipeline) may keep drawElement.
+            const perFrame = session.options.deFrameFallback === true &&
+                drawElementWorkerEncodeEligible(session, transparent) &&
+                !forceDE;
+            const riskFrames = new Set();
+            const riskReasons = [];
+            let cssFrames = 0;
+            const routeWholeRender = async (reason, trigger, message) => {
+                session.deGateReason = reason;
+                session.deFallbackTrigger = trigger;
+                console.log(`[engine] fast capture falls back to ${session.launchCaptureMode} capture: ${message}`);
+                await routeToFallback();
+            };
             if (!forceDE && process.env.HF_FAST_CAPTURE_CSSFX !== "true") {
-                const cssFx = await detectCssEffectRisk(page);
+                const cssFx = (await scanCssEffects(page, false)).reason;
                 if (cssFx) {
-                    session.deGateReason = `css_effect:${(cssFx.split(":")[0] ?? "").replace(/[^a-z-]/gi, "")}`;
-                    // Full specific effect from `detectCssEffectRisk` (e.g. "filter:blur",
+                    // Full specific effect from `scanCssEffects` (e.g. "filter:blur",
                     // "mix-blend-mode", "webgl-context") — `deGateReason` keeps its
                     // low-cardinality prefix, `deFallbackTrigger` the full value.
-                    session.deFallbackTrigger = cssFx;
-                    console.log(`[engine] fast capture falls back to ${session.launchCaptureMode} capture: ` +
-                        `${cssFx} detected (drawElementImage cannot reproduce it; see fast-capture-limitations.md)`);
-                    await routeToFallback();
-                    return;
+                    const gateReason = `css_effect:${(cssFx.split(":")[0] ?? "").replace(/[^a-z-]/gi, "")}`;
+                    const gateMessage = `${cssFx} detected (drawElementImage cannot reproduce it; see fast-capture-limitations.md)`;
+                    cssFrames = perFrame ? await renderFrameCount(session, page) : 0;
+                    const live = cssFrames > 0 ? await cssEffectRiskFrames(session, cssFrames) : null;
+                    if (!live) {
+                        await routeWholeRender(gateReason, cssFx, gateMessage);
+                        return;
+                    }
+                    for (const f of live)
+                        riskFrames.add(f);
+                    riskReasons.push(cssFx);
                 }
             }
             // Lim 7: timeline-interval at-risk predictor. Walk window.__timelines and
@@ -622,15 +643,36 @@ async function initDrawElementOrTransparentBackground(session, page, logInitPhas
                 const fractionFloor = Number(process.env.HF_FAST_CAPTURE_INTERVAL_FRACTION ?? "0");
                 logInitPhase(`timeline at-risk predictor: ${atRisk.size}/${totalFrames} frames (${Math.round(atRiskFraction * 100)}%)`);
                 if (atRisk.size > 0 && atRiskFraction > fractionFloor) {
-                    session.deGateReason = "at_risk_timeline";
-                    session.deFallbackTrigger = "at_risk_timeline";
-                    console.log(`[engine] fast capture falls back to ${session.launchCaptureMode} capture: ` +
-                        `${atRisk.size}/${totalFrames} frames animate a compositor-incompatible prop ` +
-                        `(blend/3D/clip/mask); drawElementImage drops these mid-animation ` +
-                        `(deterministic timeline gate; see fast-capture-limitations.md Lim 7)`);
-                    await routeToFallback();
+                    if (perFrame) {
+                        for (const f of atRisk)
+                            riskFrames.add(f);
+                        riskReasons.push("at_risk_timeline");
+                    }
+                    else {
+                        await routeWholeRender("at_risk_timeline", "at_risk_timeline", `${atRisk.size}/${totalFrames} frames animate a compositor-incompatible prop ` +
+                            `(blend/3D/clip/mask); drawElementImage drops these mid-animation ` +
+                            `(deterministic timeline gate; see fast-capture-limitations.md Lim 7)`);
+                        return;
+                    }
+                }
+            }
+            if (riskFrames.size > 0) {
+                const total = cssFrames > 0 ? cssFrames : await renderFrameCount(session, page);
+                const plan = total > 0 ? planRiskFrames(riskFrames, total) : null;
+                if (!plan) {
+                    await routeWholeRender("risk_frames", riskReasons.join("+"), `${riskFrames.size}/${total} frames need screenshot capture (${riskReasons.join(", ")}), ` +
+                        `too many to keep fast capture for the rest`);
+                    return;
+                }
+                if (!riskSessionFits(getAvailableMemoryMb(), session.options.width * session.options.height)) {
+                    await routeWholeRender("risk_session_memory", riskReasons.join("+"), `${plan.size} frames need screenshot capture (${riskReasons.join(", ")}) but too little ` +
+                        `memory is available for per-frame capture`);
                     return;
                 }
+                session.deRiskFrames = plan;
+                session.deRiskReason = riskReasons.join("+");
+                logInitPhase(`fast capture keeps ${total - plan.size}/${total} frames; ${plan.size} frame(s) ` +
+                    `capture by screenshot (${session.deRiskReason})`);
             }
             // Rewrite CSS 3D contexts into WebGL-projected canvases BEFORE the
             // layoutsubtree canvas goes in (rects are measured in normal layout).
@@ -653,6 +695,10 @@ async function initDrawElementOrTransparentBackground(session, page, logInitPhas
             // passed) and the DOM is still normal (canvas not yet injected, so the
             // verification screenshots are valid). drawElement-path only; see armStaticDedup.
             await armStaticDedup(session, page, logInitPhase);
+            // A static frame reuses the previous drawElement capture; a risk frame is captured by
+            // another session, so its neighbours must not reuse across it.
+            for (const f of session.deRiskFrames ?? [])
+                session.staticFrames?.delete(f);
             // Video comps on injector-less sessions (probe sessions initialize before
             // video extraction) DEFER the rest of the drawElement init: ground-truth
             // screenshots would capture black <video> boxes, and once the canvas is
@@ -673,6 +719,49 @@ async function initDrawElementOrTransparentBackground(session, page, logInitPhas
         await initTransparentBackground(session.page);
     }
 }
+/** Worker-encode pipeline: macOS hardware GPU path only, JPEG output only. */
+function drawElementWorkerEncodeEligible(session, transparent) {
+    return ((session.config?.enableDrawElementWorkerEncode ?? false) &&
+        !transparent &&
+        session.beginFrameTimeTicks === 0);
+}
+/**
+ * The frames a CSS effect shows on, or null when it cannot be bounded. Scans in a throwaway
+ * session: the scan seeks the timeline end to end, which this page's render must not inherit.
+ */
+async function cssEffectRiskFrames(session, totalFrames) {
+    let scratch = null;
+    try {
+        scratch = await createCaptureSession(session.serverUrl, session.outputDir, { ...session.options, onMemorySample: undefined }, null, {
+            ...session.config,
+            useDrawElement: false,
+            staticFrameDedup: false,
+            enableBrowserPool: false,
+        });
+        await initializeSession(scratch);
+        const scan = await scanCssEffects(scratch.page, true);
+        if (!scan.reason || !scan.bounded)
+            return null;
+        const fps = fpsToNumber(session.options.fps);
+        const live = await scanCssEffectLiveFrames(scratch.page, fps, totalFrames, totalFrames * MAX_RISK_FRAME_FRACTION);
+        return live && withFramesAfterCallback(live, scan.callbackFrom, fps, totalFrames);
+    }
+    catch (error) {
+        console.log(`[engine] fast capture: effect scan failed (${error instanceof Error ? error.message : String(error)})`);
+        return null;
+    }
+    finally {
+        if (scratch)
+            await closeCaptureSession(scratch).catch(() => { });
+    }
+}
+/** Frames the render will capture, from the producer's duration when it set one. */
+async function renderFrameCount(session, page) {
+    const duration = session.options.compositionDurationSeconds ??
+        (await page.evaluate(() => window.__hf?.duration ?? 0));
+    const total = Math.ceil(duration * fpsToNumber(session.options.fps));
+    return isStaticDedupFrameAnalysisSafe(total) ? total : 0;
+}
 /**
  * The tail of drawElement init: self-verification ground truth (pre-injection),
  * canvas injection, capture-mode flip, clip-boundary predictor, worker-encode.
@@ -712,9 +801,7 @@ async function finalizeDrawElementInit(session, page, logInitPhase, opts) {
     // Worker-encode pipeline: macOS hardware GPU path only (syncToPaintEvent=true,
     // beginFrameTimeTicks=0). Skip for BeginFrame (Linux/Docker) and transparent
     // (PNG) output — those use the existing synchronous path unchanged.
-    const workerEncodeEnabled = (session.config?.enableDrawElementWorkerEncode ?? false) &&
-        !transparent &&
-        session.beginFrameTimeTicks === 0;
+    const workerEncodeEnabled = drawElementWorkerEncodeEligible(session, transparent);
     if (workerEncodeEnabled) {
         await initDrawElementWorkerEncode(page);
         session.workerEncodeEnabled = true;
@@ -737,6 +824,16 @@ export async function completeDeferredDrawElementInit(session) {
     });
     session.deInitDeferred = false;
 }
+/**
+ * Media elements are addressed by a document-unique render id, not by the per-file element id.
+ * Installed before any page script runs, on the render page and the self-check's truth page alike.
+ */
+async function installMediaPageHooks(page, options) {
+    await installMediaRenderIdBridge(page);
+    if (options.skipReadinessVideoIds?.length) {
+        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))
@@ -903,12 +1000,7 @@ async function constructCaptureSession(input) {
             w.__name = (fn, _name) => fn;
         }
     });
-    // Media elements are addressed by a document-unique render id, not by the
-    // per-file element id. Install the resolvers before any page script runs.
-    await installMediaRenderIdBridge(page);
-    if (options.skipReadinessVideoIds?.length) {
-        await page.evaluateOnNewDocument(holdRenderFrameVideos, options.skipReadinessVideoIds, MEDIA_RENDER_ID_ATTR);
-    }
+    await installMediaPageHooks(page, options);
     // Fast capture: record accelerated canvases (webgl/webgl2/webgpu) and force
     // preserveDrawingBuffer before any page script can create a context — their
     // paint records freeze at the first frame, so captureDrawElementFrame
@@ -1693,6 +1785,16 @@ function recordConsoleScriptError(session, error) {
     const message = new VfxFailureError(error).message;
     recordCaptureWarnings(session, [{ code: "vfx_failure", message, details: { sources: [error] } }]);
 }
+// Every worker page hits the same scene callback error; the render log names it once.
+function loggedEarlierInRender(session, text) {
+    if (!text.startsWith(SCENE_CALLBACK_ERROR_PREFIX))
+        return false;
+    const logged = (session.subTimelineWaitMemo.loggedSceneCallbackErrors ??= []);
+    if (logged.includes(text))
+        return true;
+    logged.push(text);
+    return false;
+}
 function recordPageError(session, error) {
     if (error && !session.pageErrors.includes(error))
         session.pageErrors.push(error);
@@ -1753,8 +1855,9 @@ export async function initializeSession(session) {
         const text = msg.text();
         const locationUrl = msg.location()?.url ?? "";
         const diagnostic = formatConsoleDiagnostic(type, text, locationUrl);
-        if (!diagnostic.suppressHostLog)
+        if (!diagnostic.suppressHostLog && !loggedEarlierInRender(session, text)) {
             console.log(diagnostic.text);
+        }
         appendBrowserDiagnostic(session, diagnostic.text);
         // A blocked script can never register its timeline (#3352); a thrown one may still, so it only counts on timeout.
         const scriptFailure = classifyConsoleScriptFailure(type, text);
@@ -2538,6 +2641,7 @@ export async function createStaticVerificationPage(session) {
                 w.__name = (fn, _name) => fn;
             }
         });
+        await installMediaPageHooks(page, session.options);
         if (session.options.variables && Object.keys(session.options.variables).length > 0) {
             const variablesJson = JSON.stringify(session.options.variables);
             await page.evaluateOnNewDocument((json) => {
@@ -3046,6 +3150,15 @@ async function redrawDrawElementFrame(session, frameIndex, time, seekOptions, he
     await prepareFrameForCapture(session, frameIndex, time, seekOptions, heldVideoTime);
     return captureDrawElementFrame(page, options.width, options.height, options.format ?? "jpeg", options.quality ?? 80, true);
 }
+/**
+ * Fails the attempt on a frame in {@link CaptureSession.deRiskFrames}. Callers that hand those
+ * frames to a screenshot session never reach it; any other caller restarts by screenshot.
+ */
+function assertNotRiskFrame(session, frameIndex) {
+    if (session.deRiskFrames?.has(frameIndex)) {
+        throw new DrawElementCaptureError(frameIndex, "frame needs screenshot capture, which this capture path cannot hand over");
+    }
+}
 /** Seek to `time` and capture one surface with the session's capture mode. */
 async function captureFrameSurface(session, frameIndex, time, seekOptions, heldVideoTime) {
     const { page, options } = session;
@@ -3078,6 +3191,7 @@ async function captureFrameSurface(session, frameIndex, time, seekOptions, heldV
         throw new DrawElementCaptureError(frameIndex, "boundary screenshot requested on an injected canvas page");
     }
     else if (session.captureMode === "drawelement") {
+        assertNotRiskFrame(session, frameIndex);
         // Advance compositor state via BeginFrame when available (Linux headless-shell);
         // on macOS the compositor advances naturally without BeginFrame.
         if (session.beginFrameTimeTicks > 0) {
@@ -3403,6 +3517,7 @@ export async function captureFrameToBuffer(session, frameIndex, time) {
 export async function captureFrameToBufferPipelined(session, frameIndex, time) {
     const { page, options } = session;
     const startTime = Date.now();
+    assertNotRiskFrame(session, frameIndex);
     // Task B: static-frame dedup (worker path). Reuse the prior frame's encode result
     // and skip the seek + drawElement + encode entirely. Same predicate as the serial
     // path; clip-cut frames are excluded from staticFrames so they always capture.
@@ -3527,6 +3642,8 @@ export async function captureFramesBatchPipelined(session, frameIndices, times)
         throw new Error("[FrameCapture] Session not initialized");
     }
     assertVfxIntact(session);
+    for (const frameIndex of frameIndices)
+        assertNotRiskFrame(session, frameIndex);
     const startTime = Date.now();
     const fps = fpsToNumber(options.fps);
     const quantized = times.map((t) => quantizeTimeToFrame(t, fps));
@@ -3774,6 +3891,14 @@ export function computeDeVerifySampleFractions(k) {
         return [0.95];
     return [...Array.from({ length: k - 1 }, (_, i) => (i + 1) / k), 0.95];
 }
+/** Seeks the page the truth is read from; callbacks run unless suppressed (suppressed, a count-up's text is stale). */
+export async function seekDeVerifyTruth(page, t, suppressEvents) {
+    await page.evaluate((tt, suppress) => {
+        const hf = window.__hf;
+        if (hf && typeof hf.seek === "function")
+            hf.seek(tt, { suppressEvents: suppress });
+    }, t, suppressEvents);
+}
 async function captureDeVerificationFrames(session, page, logInitPhase) {
     // Explicit HF_DE_VERIFY wins; otherwise the session's own sample count
     // (raised by the parallel coordinator for multi-worker DE), then default 4.
@@ -3819,48 +3944,58 @@ async function captureDeVerificationFrames(session, page, logInitPhase) {
     // would share the corruption, PSNR would pass on the damaged output.
     // Seeking 0 → ascending reproduces the render's own seek order.
     const fractions = computeDeVerifySampleFractions(k);
-    const seekTo = async (t) => {
-        await page.evaluate((tt) => {
-            const hf = window.__hf;
-            if (hf && typeof hf.seek === "function")
-                hf.seek(tt, { suppressEvents: true });
-        }, t);
-    };
-    await seekTo(quantizeTimeToFrame(0, fps));
-    // Force one frame so lazy tween initialization paints at t=0 state.
-    await pageScreenshotCapture(page, session.options);
+    // The truth is read on a disposable page, so callbacks that run there cannot change the render's
+    // own page. A video comp needs an injector of its own for it (the render's tracks its page).
+    const truthInjector = session.onBeforeCapture?.fresh?.() ?? null;
+    const disposable = session.onBeforeCapture && truthInjector === null
+        ? null
+        : await createStaticVerificationPage(session).catch(() => {
+            logInitPhase("self-verify truth page unavailable; reading it on the render page");
+            return null;
+        });
+    const isolated = disposable !== null;
+    const truthPage = disposable ?? page;
+    const injectFrames = isolated
+        ? (truthInjector ?? session.onBeforeCapture)
+        : session.onBeforeCapture;
+    const seekTo = (t) => seekDeVerifyTruth(truthPage, t, !isolated);
     const frames = new Map();
-    for (const f of fractions) {
-        let idx = Math.min(totalFrames - 1, Math.max(1, Math.round(totalFrames * f)));
-        // Nudge off clip-cut boundaries (±1-frame desync is legitimate there);
-        // if the nudge saturates on a boundary index, skip the sample entirely.
-        let guard = 0;
-        while (boundary.has(idx) && guard++ < 6)
-            idx = Math.min(totalFrames - 1, idx + 2);
-        if (boundary.has(idx))
-            continue;
-        if (frames.has(idx))
-            continue;
-        const t = quantizeTimeToFrame(idx / fps, fps);
-        await seekTo(t);
-        // Video frame injection (same hook the real capture paths run) — without
-        // it, <video> elements screenshot black and every video comp would
-        // false-positive into the screenshot fallback.
-        if (session.onBeforeCapture)
-            await session.onBeforeCapture(page, t);
-        // Double-capture: the first screenshot forces a frame, which is what runs
-        // rAF-driven callbacks (count-up text counters land a tick after seek()
-        // returns — a single immediate screenshot captures stale text and
-        // false-positives the verify: 3bea8c73 28.7dB vs a truth missing its stat
-        // values while the DE frame was correct). NOTE: waiting on rAF via
-        // evaluate instead deadlocks — headless only fires rAF when a frame is
-        // produced, and nothing produces one until a screenshot asks.
-        await pageScreenshotCapture(page, session.options);
-        frames.set(idx, await pageScreenshotCapture(page, session.options));
-    }
-    // Leave the page at frame 0 so the render's first seek starts from the
-    // same state as an unverified render.
-    await seekTo(quantizeTimeToFrame(0, fps));
+    try {
+        await seekTo(quantizeTimeToFrame(0, fps));
+        // Force one frame so lazy tween initialization paints at t=0 state.
+        await pageScreenshotCapture(truthPage, session.options);
+        for (const f of fractions) {
+            let idx = Math.min(totalFrames - 1, Math.max(1, Math.round(totalFrames * f)));
+            // Nudge off clip-cut boundaries (±1-frame desync is legitimate there);
+            // if the nudge saturates on a boundary index, skip the sample entirely.
+            let guard = 0;
+            const skip = (i) => boundary.has(i) || session.deRiskFrames?.has(i) === true;
+            while (skip(idx) && guard++ < 6)
+                idx = Math.min(totalFrames - 1, idx + 2);
+            if (skip(idx))
+                continue;
+            if (frames.has(idx))
+                continue;
+            const t = quantizeTimeToFrame(idx / fps, fps);
+            await seekTo(t);
+            // Video frame injection (same hook the real capture paths run) — without
+            // it, <video> elements screenshot black and every video comp would
+            // false-positive into the screenshot fallback.
+            await injectFrames?.(truthPage, t);
+            // The first screenshot forces a frame, which runs rAF-driven callbacks (a count-up lands
+            // a tick after seek()); waiting on rAF via evaluate deadlocks, headless fires it only
+            // when a frame is produced.
+            await pageScreenshotCapture(truthPage, session.options);
+            frames.set(idx, await pageScreenshotCapture(truthPage, session.options));
+        }
+        // The render's own page goes back to frame 0 so its first seek starts like an unverified render.
+        if (!isolated)
+            await seekTo(quantizeTimeToFrame(0, fps));
+    }
+    finally {
+        if (isolated)
+            await truthPage.close().catch(() => { });
+    }
     session.deVerifyFrames = frames;
     logInitPhase(`drawElement self-verify armed: ${frames.size} ground-truth frame(s) @ [${[...frames.keys()].join(", ")}] of ${totalFrames}`);
 }
@@ -3946,6 +4081,7 @@ export function getCapturePerfSummary(session) {
         deVerifyArmed: session.deVerifyFrames?.size ?? 0,
         deVerifyInitMs: session.deVerifyInitMs ?? 0,
         deBoundaryFrames: session.clipBoundaryFrames?.size ?? 0,
+        deRiskFrames: session.deRiskFrames?.size ?? 0,
         deNcprFallbacks: ncprFallbacks,
         deFrameTimeouts: session.deFrameTimeouts ?? 0,
     };

package/dist/services/parallelCoordinator.js

@@ -760,9 +760,11 @@ export async function executeParallelCapture(serverUrl, workDir, tasks, captureO
     };
     const parallel = tasks.length > 1;
     const deVerifySamples = resolveParallelDeVerifySamples(captureOptions.deVerifySamples, tasks.length);
-    const workerCaptureOptions = deVerifySamples === captureOptions.deVerifySamples
-        ? captureOptions
-        : { ...captureOptions, deVerifySamples };
+    const workerCaptureOptions = {
+        ...captureOptions,
+        deVerifySamples,
+        deFrameFallback: false,
+    };
     const peerController = new AbortController();
     const workerSignal = signal
         ? AbortSignal.any([signal, peerController.signal])

package/dist/services/riskFrames.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Which frames drawElement capture cannot reproduce, so those frames alone are captured by
+ * screenshot and the rest keep the fast path.
+ */
+import type { Page } from "puppeteer-core";
+/**
+ * Above this share of risk frames the second browser and the switching cost outweigh the fast
+ * frames, so the whole render captures by screenshot as it always has.
+ */
+export declare const MAX_RISK_FRAME_FRACTION = 0.6;
+/** Peak memory per-frame capture adds over a screenshot render at 1080p: 1002 to 2001 MB measured. */
+export declare const RISK_RENDER_ADDED_BYTES = 1000000000;
+/** Memory that must still be available once the screenshot browser is open. */
+export declare const RISK_RENDER_HEADROOM_BYTES = 1500000000;
+/** Risk ranges closer than this many frames are joined, so capture never alternates modes. */
+export declare const RISK_RANGE_HYSTERESIS_FRAMES = 12;
+/**
+ * Frames where a recorded effect element shows. Seeks the page forward, so use a throwaway one.
+ * Null once more than `maxFrames` frames qualify.
+ */
+export declare function scanCssEffectLiveFrames(page: Page, fps: number, totalFrames: number, maxFrames: number): Promise<Set<number> | null>;
+/**
+ * The given frames with a one-frame margin, ranges closer than {@link RISK_RANGE_HYSTERESIS_FRAMES}
+ * joined. Null when they cover more than {@link MAX_RISK_FRAME_FRACTION} of the render.
+ */
+export declare function planRiskFrames(frames: Iterable<number>, totalFrames: number): Set<number> | null;
+/** `live` plus every frame from just before the first callback to the end of the render. */
+export declare function withFramesAfterCallback(live: Set<number>, callbackFrom: number | null, fps: number, totalFrames: number): Set<number>;
+/** Whether the render fits: what it adds, scaled by output pixels, leaves the headroom. */
+export declare function riskSessionFits(availableMb: number, outputPixels: number): boolean;

package/dist/services/riskFrames.js

@@ -0,0 +1,101 @@
+/**
+ * Which frames drawElement capture cannot reproduce, so those frames alone are captured by
+ * screenshot and the rest keep the fast path.
+ */
+import { quantizeTimeToFrame } from "@hyperframes/core";
+/** Frames per page round trip while scanning; a scan is one in-page loop per chunk. */
+const SCAN_CHUNK_FRAMES = 240;
+/**
+ * Above this share of risk frames the second browser and the switching cost outweigh the fast
+ * frames, so the whole render captures by screenshot as it always has.
+ */
+export const MAX_RISK_FRAME_FRACTION = 0.6;
+/** Peak memory per-frame capture adds over a screenshot render at 1080p: 1002 to 2001 MB measured. */
+export const RISK_RENDER_ADDED_BYTES = 1_000_000_000;
+/** Memory that must still be available once the screenshot browser is open. */
+export const RISK_RENDER_HEADROOM_BYTES = 1_500_000_000;
+const PIXELS_1080P = 1920 * 1080;
+/** Risk ranges closer than this many frames are joined, so capture never alternates modes. */
+export const RISK_RANGE_HYSTERESIS_FRAMES = 12;
+/**
+ * Frames where a recorded effect element shows. Seeks the page forward, so use a throwaway one.
+ * Null once more than `maxFrames` frames qualify.
+ */
+export async function scanCssEffectLiveFrames(page, fps, totalFrames, maxFrames) {
+    const live = new Set();
+    for (let from = 0; from < totalFrames; from += SCAN_CHUNK_FRAMES) {
+        const times = [];
+        for (let f = from; f < Math.min(totalFrames, from + SCAN_CHUNK_FRAMES); f++) {
+            times.push(quantizeTimeToFrame(f / fps, fps));
+        }
+        const hits = await page.evaluate(async (ts) => {
+            const w = window;
+            const targets = w.__hfCssFxTargets ?? [];
+            // A hidden element still shows a descendant that sets `visibility: visible` itself.
+            const paints = (el) => getComputedStyle(el).visibility !== "hidden" ||
+                Array.from(el.querySelectorAll("*")).some((d) => getComputedStyle(d).visibility === "visible");
+            const shows = (el) => {
+                for (let n = el; n; n = n.parentElement) {
+                    const cs = getComputedStyle(n);
+                    if (cs.display === "none" || Number(cs.opacity) === 0)
+                        return false;
+                }
+                return paints(el);
+            };
+            const out = [];
+            for (let i = 0; i < ts.length; i++) {
+                w.__hf?.seek?.(ts[i]);
+                await w.__hfWaitForSeekCompletion?.();
+                if (targets.some(shows))
+                    out.push(i);
+            }
+            return out;
+        }, times);
+        for (const i of hits)
+            live.add(from + i);
+        if (live.size > maxFrames)
+            break;
+    }
+    return live.size > maxFrames ? null : live;
+}
+/**
+ * The given frames with a one-frame margin, ranges closer than {@link RISK_RANGE_HYSTERESIS_FRAMES}
+ * joined. Null when they cover more than {@link MAX_RISK_FRAME_FRACTION} of the render.
+ */
+export function planRiskFrames(frames, totalFrames) {
+    const sorted = [...new Set(frames)].sort((a, b) => a - b);
+    const plan = new Set();
+    let rangeStart = -1;
+    let rangeEnd = -1;
+    const flush = () => {
+        for (let f = Math.max(0, rangeStart - 1); f <= Math.min(totalFrames - 1, rangeEnd + 1); f++) {
+            plan.add(f);
+        }
+    };
+    for (const f of sorted) {
+        if (rangeStart >= 0 && f - rangeEnd <= RISK_RANGE_HYSTERESIS_FRAMES) {
+            rangeEnd = f;
+            continue;
+        }
+        if (rangeStart >= 0)
+            flush();
+        rangeStart = f;
+        rangeEnd = f;
+    }
+    if (rangeStart >= 0)
+        flush();
+    return plan.size > totalFrames * MAX_RISK_FRAME_FRACTION ? null : plan;
+}
+/** `live` plus every frame from just before the first callback to the end of the render. */
+export function withFramesAfterCallback(live, callbackFrom, fps, totalFrames) {
+    if (callbackFrom === null)
+        return live;
+    for (let f = Math.max(0, Math.floor(callbackFrom * fps) - 1); f < totalFrames; f++)
+        live.add(f);
+    return live;
+}
+/** Whether the render fits: what it adds, scaled by output pixels, leaves the headroom. */
+export function riskSessionFits(availableMb, outputPixels) {
+    const rss = RISK_RENDER_ADDED_BYTES * Math.max(1, outputPixels / PIXELS_1080P);
+    return availableMb * 1024 * 1024 - rss >= RISK_RENDER_HEADROOM_BYTES;
+}

package/dist/services/systemMemory.d.ts

@@ -49,3 +49,5 @@ export declare const LOW_MEMORY_TOTAL_MB_THRESHOLD = 8192;
  * small VMs, small Lambda tiers, small containers) are detected correctly.
  */
 export declare function isLowMemorySystem(totalMb?: number): boolean;
+/** Memory available in MiB: on macOS and Linux, counting pages the OS reclaims on demand. */
+export declare function getAvailableMemoryMb(): number;

package/dist/services/systemMemory.js

@@ -7,8 +7,9 @@
  * They all need the same "how much memory does this box have" reading, so
  * it lives here once instead of being re-derived inline.
  */
+import { execSync } from "child_process";
 import { readFileSync } from "fs";
-import { totalmem } from "os";
+import { freemem, platform, totalmem } from "os";
 const BYTES_PER_MIB = 1024 * 1024;
 const BYTES_PER_MIB_BIGINT = BigInt(BYTES_PER_MIB);
 // These are the paths as seen from INSIDE a container, where the runtime
@@ -154,3 +155,39 @@ export const LOW_MEMORY_TOTAL_MB_THRESHOLD = 8192;
 export function isLowMemorySystem(totalMb = getSystemTotalMb()) {
     return totalMb <= LOW_MEMORY_TOTAL_MB_THRESHOLD;
 }
+/** Memory available in MiB: on macOS and Linux, counting pages the OS reclaims on demand. */
+export function getAvailableMemoryMb() {
+    const fallback = Math.trunc(freemem() / BYTES_PER_MIB);
+    if (platform() === "darwin") {
+        try {
+            const raw = execSync("vm_stat", { encoding: "utf-8", timeout: 5000 });
+            const pageSize = parseInt(raw.match(/page size of (\d+)/)?.[1] ?? "0", 10);
+            if (!pageSize)
+                return fallback;
+            const pages = (key) => parseInt(raw.match(new RegExp(`${key}:\\s+(\\d+)`))?.[1] ?? "0", 10);
+            const available = (pages("Pages free") +
+                pages("Pages inactive") +
+                pages("Pages purgeable") +
+                pages("Pages speculative")) *
+                pageSize;
+            return available > 0 ? Math.trunc(available / BYTES_PER_MIB) : fallback;
+        }
+        catch {
+            return fallback;
+        }
+    }
+    if (platform() === "linux") {
+        try {
+            const meminfo = readFileSync("/proc/meminfo", "utf-8");
+            const match = meminfo.match(/MemAvailable:\s+(\d+)\s+kB/);
+            if (match) {
+                return Math.trunc(parseInt(match[1], 10) / 1024);
+            }
+            return fallback;
+        }
+        catch {
+            return fallback;
+        }
+    }
+    return fallback;
+}

package/dist/services/threeDProjection.d.ts

@@ -77,3 +77,17 @@ export declare function initThreeDProjection(page: Page): Promise<ThreeDProjecti
  * Returns the first matched effect name (for logging) or null.
  */
 export declare function detectCssEffectRisk(page: Page): Promise<string | null>;
+/** What {@link scanCssEffects} found. */
+export interface CssEffectScan {
+    /** First effect matched, in scan order (computed, stylesheet, tween vars, WebGL), or null. */
+    reason: string | null;
+    /** False when a match is not tied to an element (unmatched rule, CSS animation, WebGL). */
+    bounded: boolean;
+    /** Seconds at which the first timeline callback can fire; the effect can show anywhere after. */
+    callbackFrom: number | null;
+}
+/**
+ * Which CSS effects drawElementImage cannot reproduce. `collect: true` scans past the first match
+ * and leaves the elements carrying an effect in `window.__hfCssFxTargets`.
+ */
+export declare function scanCssEffects(page: Page, collect: boolean): Promise<CssEffectScan>;

package/dist/services/threeDProjection.js

@@ -864,6 +864,13 @@ export async function initThreeDProjection(page) {
  * Returns the first matched effect name (for logging) or null.
  */
 export async function detectCssEffectRisk(page) {
+    return (await scanCssEffects(page, false)).reason;
+}
+/**
+ * Which CSS effects drawElementImage cannot reproduce. `collect: true` scans past the first match
+ * and leaves the elements carrying an effect in `window.__hfCssFxTargets`.
+ */
+export async function scanCssEffects(page, collect) {
     try {
         // MUST NOT seek the timeline here. Driving `window.__hf.seek` to sample
         // frames renders GSAP `.from()` / overlapping tweens out of forward order and
@@ -874,10 +881,23 @@ export async function detectCssEffectRisk(page) {
         // 1e5a1165: the Pong scene's scale/rotation tween lands wrong, 19.8 dB / 27
         // damaged frames; the fix restored it to baseline parity, 43 dB / 0). So we
         // detect the same effects seek-free, four ways:
-        return await page.evaluate(() => {
+        return await page.evaluate((collectAll) => {
             const root = document.querySelector("[data-composition-id]");
             if (!root)
-                return null;
+                return { reason: null, bounded: true, callbackFrom: null };
+            let reason = null;
+            let bounded = true;
+            const targets = new Set();
+            // A match on `els` (null: not tied to any element). Returns true to stop the scan.
+            const hit = (name, els) => {
+                reason = reason ?? name;
+                if (els && els.length > 0)
+                    for (const el of Array.from(els))
+                        targets.add(el);
+                else
+                    bounded = false;
+                return !collectAll;
+            };
             // (1) Computed styles at the current (init/t0) state — effects present in
             // the base render.
             const scanComputed = () => {
@@ -885,28 +905,51 @@ export async function detectCssEffectRisk(page) {
                 for (const el of els) {
                     const cs = getComputedStyle(el);
                     const bf = cs.backdropFilter || cs.webkitBackdropFilter || "";
-                    if (bf && bf !== "none")
-                        return "backdrop-filter";
+                    if (bf && bf !== "none" && hit("backdrop-filter", [el]))
+                        return true;
                     const f = cs.filter || "";
-                    if (f && f !== "none" && f.indexOf("blur(") !== -1)
-                        return "filter:blur";
-                    if (f && f !== "none" && f.indexOf("drop-shadow(") !== -1)
-                        return "filter:drop-shadow";
+                    if (f && f !== "none" && f.indexOf("blur(") !== -1 && hit("filter:blur", [el])) {
+                        return true;
+                    }
+                    if (f &&
+                        f !== "none" &&
+                        f.indexOf("drop-shadow(") !== -1 &&
+                        hit("filter:drop-shadow", [el])) {
+                        return true;
+                    }
                     const mbm = cs.mixBlendMode || "";
-                    if (mbm && mbm !== "normal")
-                        return "mix-blend-mode";
+                    if (mbm && mbm !== "normal" && hit("mix-blend-mode", [el]))
+                        return true;
                     const an = cs.animationName || "";
                     const ad = cs.animationDuration || "0s";
-                    if (an && an !== "none" && ad !== "0s" && parseFloat(ad) > 0)
-                        return "css-animation";
+                    if (an &&
+                        an !== "none" &&
+                        ad !== "0s" &&
+                        parseFloat(ad) > 0 &&
+                        hit("css-animation", null)) {
+                        return true;
+                    }
                 }
-                return null;
+                return false;
             };
             // (2) Stylesheet rules — an effect applied later via a class swap won't be
             // computed at t0, but the rule that declares it exists up front. This
             // replaces the old per-frame scrub scan seek-free (conservative: a declared
             // rule ⇒ gate, even if applied only mid-timeline).
             const scanStyleSheets = () => {
+                // The elements a style rule can apply to now; a pseudo-element's effect shows only while
+                // its owner does. Empty when the rule is not a plain style rule or matches nothing yet.
+                const ruleTargets = (rule) => {
+                    const selector = rule.selectorText;
+                    if (!selector)
+                        return [];
+                    try {
+                        return Array.from(root.querySelectorAll(selector.replace(/::?(before|after|first-line|first-letter|marker|placeholder|selection|backdrop)/g, "")));
+                    }
+                    catch {
+                        return [];
+                    }
+                };
                 for (const sheet of Array.from(document.styleSheets)) {
                     let rules = null;
                     try {
@@ -917,63 +960,96 @@ export async function detectCssEffectRisk(page) {
                     }
                     for (const rule of Array.from(rules ?? [])) {
                         const txt = rule.cssText || "";
+                        let name = null;
                         if (/backdrop-filter\s*:\s*(?!none)/i.test(txt))
-                            return "backdrop-filter";
-                        if (/(?:^|[^-])filter\s*:[^;{}]*blur\(/i.test(txt))
-                            return "filter:blur";
-                        if (/(?:^|[^-])filter\s*:[^;{}]*drop-shadow\(/i.test(txt)) {
-                            return "filter:drop-shadow";
+                            name = "backdrop-filter";
+                        else if (/(?:^|[^-])filter\s*:[^;{}]*blur\(/i.test(txt))
+                            name = "filter:blur";
+                        else if (/(?:^|[^-])filter\s*:[^;{}]*drop-shadow\(/i.test(txt)) {
+                            name = "filter:drop-shadow";
                         }
-                        if (/mix-blend-mode\s*:\s*(?!normal)/i.test(txt))
-                            return "mix-blend-mode";
+                        else if (/mix-blend-mode\s*:\s*(?!normal)/i.test(txt))
+                            name = "mix-blend-mode";
+                        if (name && hit(name, ruleTargets(rule)))
+                            return true;
                     }
                 }
-                return null;
+                return false;
             };
             // (3) GSAP tween vars — effects animated by GSAP writing inline
             // filter / backdropFilter / mixBlendMode (never present in a stylesheet).
             const scanTweenVars = () => {
                 const walk = (tl) => {
                     if (typeof tl.getChildren !== "function")
-                        return null;
+                        return false;
                     for (const c of tl.getChildren(false, true, true)) {
-                        const sub = walk(c);
-                        if (sub)
-                            return sub;
+                        if (walk(c))
+                            return true;
                         const vars = c.vars || {};
                         for (const k of Object.keys(vars)) {
                             const kl = k.toLowerCase();
+                            let name = null;
                             if (kl.includes("blend"))
-                                return "mix-blend-mode";
-                            if (kl.includes("backdrop"))
-                                return "backdrop-filter";
-                            if (kl === "filter" && /blur\(/i.test(String(vars[k] ?? "")))
-                                return "filter:blur";
-                            if (kl === "filter" && /drop-shadow\(/i.test(String(vars[k] ?? ""))) {
-                                return "filter:drop-shadow";
+                                name = "mix-blend-mode";
+                            else if (kl.includes("backdrop"))
+                                name = "backdrop-filter";
+                            else if (kl === "filter" && /blur\(/i.test(String(vars[k] ?? ""))) {
+                                name = "filter:blur";
                             }
+                            else if (kl === "filter" && /drop-shadow\(/i.test(String(vars[k] ?? ""))) {
+                                name = "filter:drop-shadow";
+                            }
+                            if (!name)
+                                continue;
+                            const els = (typeof c.targets === "function" ? c.targets() : []).filter((t) => t instanceof Element);
+                            if (hit(name, els))
+                                return true;
                         }
                     }
-                    return null;
+                    return false;
                 };
                 const tls = window.__timelines || {};
                 for (const tl of Object.values(tls)) {
-                    const r = walk(tl);
-                    if (r)
-                        return r;
+                    if (walk(tl))
+                        return true;
                 }
-                return null;
+                return false;
             };
             // (4) WebGL context — seek-invariant, recorded at context creation.
             const scanWebgl = () => {
                 const aw = window;
                 const accel = (aw.__hf_accel_canvases ?? []).filter((c) => root.contains(c));
-                return accel.length > 0 ? "webgl-context" : null;
+                return accel.length > 0 && hit("webgl-context", null);
             };
-            return scanComputed() || scanStyleSheets() || scanTweenVars() || scanWebgl();
-        });
+            for (const scan of [scanComputed, scanStyleSheets, scanTweenVars, scanWebgl]) {
+                if (scan())
+                    break;
+            }
+            const calls = ["onStart", "onUpdate", "onComplete", "onRepeat", "onReverseComplete"];
+            const firstCallback = (node, offset) => {
+                const start = offset + (typeof node.startTime === "function" ? node.startTime() : 0);
+                let first = calls.some((k) => typeof node.vars?.[k] === "function") ? start : Infinity;
+                if (typeof node.getChildren === "function") {
+                    for (const child of node.getChildren(false, true, true)) {
+                        first = Math.min(first, firstCallback(child, start));
+                    }
+                }
+                return first;
+            };
+            const timelines = window
+                .__timelines;
+            const callbackStart = reason
+                ? Math.min(Infinity, ...Object.values(timelines ?? {}).map((tl) => firstCallback(tl, 0)))
+                : Infinity;
+            window.__hfCssFxTargets = [...targets];
+            return {
+                reason,
+                bounded,
+                callbackFrom: Number.isFinite(callbackStart) ? callbackStart : null,
+            };
+        }, collect);
     }
     catch {
-        return null;
+        return { reason: null, bounded: true, callbackFrom: null };
     }
 }

package/dist/services/videoFrameInjector.js

@@ -148,7 +148,7 @@ export function createVideoFrameInjector(frameLookup, config) {
         lastCacheTouchByDir.set(cacheDir, now);
     }
     // fallow-ignore-next-line complexity
-    return async (page, time, heldVideoTime) => {
+    const inject = async (page, time, heldVideoTime) => {
         for (const cacheDir of frameLookup.frameDirs())
             renewCacheLease(cacheDir);
         const activePayloads = frameLookup.getActiveFramePayloads(time);
@@ -205,6 +205,7 @@ export function createVideoFrameInjector(frameLookup, config) {
             }
         }
     };
+    return Object.assign(inject, { fresh: () => createVideoFrameInjector(frameLookup, config) });
 }
 /**
  * Hide specific video elements by ID. Used in Pass 1 of the HDR pipeline so

package/dist/types.d.ts

@@ -16,11 +16,12 @@ export type PageMotionBlurOff = "off" | "hdr-render" | "layered-composite" | "di
  */
 export type SubTimelineWaitOutcome = "ready" | "timeout" | "script_failure";
 /**
- * Shared by every capture session of one render: composition ids whose timeline
- * wait already timed out, so later sessions report the timeout without waiting again.
+ * Shared by every capture session of one render: timeline waits that already timed out
+ * (so later sessions skip the wait), and scene callback errors the render log already shows.
  */
 export interface SubTimelineWaitMemo {
     unregisteredIds?: readonly string[];
+    loggedSceneCallbackErrors?: string[];
 }
 export type CaptureWarningCode = "media_readiness_timeout" | "media_load_failed" | "audio_processing_failed" | "sub_timeline_readiness_timeout" | "sub_timeline_script_failure" | "script_error_isolated" | "vfx_failure" | "live_map_detected";
 /** Structured correctness warning produced while preparing a capture session. */
@@ -221,6 +222,7 @@ export interface CaptureOptions {
      * Clamped to 0..8 like the env knob; HF_DE_VERIFY, when set, still wins.
      */
     deVerifySamples?: number;
+    deFrameFallback?: boolean;
 }
 export interface CaptureVideoMetadataHint {
     id: string;
@@ -382,6 +384,7 @@ export interface CapturePerfSummary {
     deVerifyInitMs: number;
     /** Clip-cut boundary frames routed to per-frame screenshot (Lim 6). */
     deBoundaryFrames: number;
+    deRiskFrames: number;
     /** Per-frame "No cached paint record" screenshot fallbacks during capture. */
     deNcprFallbacks: number;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/engine",
-  "version": "0.8.198",
+  "version": "0.8.200",
   "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/parsers": "^0.8.198",
-    "@hyperframes/core": "^0.8.198"
+    "@hyperframes/core": "^0.8.200",
+    "@hyperframes/parsers": "^0.8.200"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",