@hyperframes/engine 0.8.190 → 0.8.191

package/dist/services/audioMixer.d.ts

@@ -37,5 +37,6 @@ export declare function processCompositionAudio(elements: AudioElement[], baseDi
     /** Serialised master bus chain, from `parseMasterFxChain`. */
     masterFxChain?: string;
     urlByAbsentLocalPath?: ReadonlyMap<string, string>;
+    audioSidecarUrlByLocalPath?: ReadonlyMap<string, string>;
     keepEncoderInputAt?: string;
 }, compiledDir?: string): Promise<MixResult>;

package/dist/services/audioMixer.js

@@ -503,9 +503,10 @@ export function parseAudioElements(html) {
     return elements;
 }
 const FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE = ["-xerror"];
+const SIDECAR_WARM_UP_SECONDS = 1;
 /** Decode `duration` s of audio from `mediaStart` in Chrome's media time. Until every stream has
  * started, an input seek snaps audio to the video's first keyframe, so read by timestamp instead. */
-async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config) {
+async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config, audioSidecarUrl) {
     const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
     const outputDir = dirname(outputPath);
     if (!existsSync(outputDir))
@@ -527,13 +528,18 @@ async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, durat
     const timestampTrim = inputSeek
         ? null
         : `atrim=start=${start}:end=${formatFilterNumber(mediaStart + sourceDuration)},asetpts=PTS-${start}/TB,aresample=async=1:first_pts=0`;
-    const outputArgs = preparedAudioOutputArgs(metadata, normalizedPlaybackRate, duration, timestampTrim);
+    const fromSidecar = audioSidecarUrl !== undefined && inputSeek && normalizedPlaybackRate === 1;
+    const warmUp = fromSidecar ? Math.min(SIDECAR_WARM_UP_SECONDS, mediaStart) : 0;
+    const outputArgs = preparedAudioOutputArgs(metadata, normalizedPlaybackRate, duration, warmUp > 0 ? `atrim=start=${warmUp},asetpts=PTS-STARTPTS` : timestampTrim);
+    const readFrom = fromSidecar ? audioSidecarUrl : srcPath;
     const args = [
         ...(readsUrl ? FAIL_ON_READ_ERROR_INSTEAD_OF_ENDING_THERE : []),
-        ...urlInputArgs(srcPath),
-        ...(inputSeek ? ["-ss", String(mediaStart), "-t", String(sourceDuration)] : []),
+        ...urlInputArgs(readFrom),
+        ...(inputSeek
+            ? ["-ss", String(mediaStart - warmUp), "-t", String(sourceDuration + warmUp)]
+            : []),
         "-i",
-        srcPath,
+        readFrom,
     ];
     args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
     if (normalizedPlaybackRate !== 1)
@@ -1062,11 +1068,13 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
         try {
             let srcPath = element.src;
             let readInPlace = false;
+            let audioSidecarUrl;
             if (!isHttpUrl(srcPath)) {
                 // Same browser-URL path semantics as videos.
                 srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
                 const remoteUrl = config?.urlByAbsentLocalPath?.get(srcPath);
                 if (remoteUrl) {
+                    audioSidecarUrl = config?.audioSidecarUrlByLocalPath?.get(srcPath);
                     srcPath = remoteUrl;
                     readInPlace = true;
                 }
@@ -1123,7 +1131,7 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
             let audioSrcPath = srcPath;
             if (element.type === "video") {
                 const extractedPath = join(workDir, `${element.id}-extracted.wav`);
-                const extractResult = await extractAudioSegment(srcPath, extractedPath, "extract", element.mediaStart, element.end - element.start, element.playbackRate, effectiveSignal, config);
+                const extractResult = await extractAudioSegment(srcPath, extractedPath, "extract", element.mediaStart, element.end - element.start, element.playbackRate, effectiveSignal, config, audioSidecarUrl);
                 if (!extractResult.success) {
                     failures.push(extractResult.failure
                         ? { ...extractResult.failure, elementId: element.id }

package/dist/services/drawElementService.js

@@ -934,6 +934,7 @@ export async function produceDrawElementFrameBatch(page, times, width, height, q
             try {
                 if (aw.__hf && typeof aw.__hf.seek === "function")
                     aw.__hf.seek(t);
+                await aw.__hfWaitForSeekCompletion?.();
                 await aw.__hfDecodeDynamicCssBackgroundImages?.();
                 aw.__hf3d?.update();
                 const accel = (aw.__hf_accel_canvases ?? []).filter((c) => root.contains(c));

package/dist/services/frameCapture.d.ts

@@ -98,6 +98,7 @@ export interface CaptureSession {
      * our console output.
      */
     pendingTimelineIds?: string[];
+    isolatedCompositions?: IsolatedComposition[];
     /** The render's shared memo when the caller passed one, else this session's own. */
     subTimelineWaitMemo: SubTimelineWaitMemo;
     /** Structured readiness warnings surfaced to the producer's render policy. */
@@ -164,6 +165,12 @@ export interface CaptureSession {
      * drawElement intermittently returns an anomalously small (blank) frame with no
      * throw; a frame far below the running median is re-captured via screenshot. */
     deFrameSizes?: number[];
+    /** Absolute floor of the serial drawElement size guard. Starts at 20000 bytes and drops to
+     * half of a small frame that redraws byte-identically. */
+    deAbsFloor?: number;
+    /** The last small drawElement frame that redrew byte-identically; an equal frame is kept
+     * without a redraw. */
+    deAcceptedSmall?: Buffer;
     /** Last non-deduped encode result, reused for a static frame on the drawElement
      * worker-encode path (mirrors `lastFrameBuffer` on the screenshot path). Only set
      * when static-frame dedup is armed on the drawElement path. */
@@ -404,16 +411,25 @@ export interface HfDiagnostic {
 }
 export declare function buildZeroDurationDiagnostic(diag: HfDiagnostic): string;
 export declare function pollHfReady(page: Page, timeoutMs: number, intervalMs?: number): Promise<void>;
-export declare function waitForSubCompositionTimelines(session: CaptureSession, page: Page, timeoutMs: number): Promise<void>;
+export declare function waitForSubCompositionTimelines(session: CaptureSession, page: Page, timeoutMs: number, options?: {
+    scriptErrorGraceMs?: number;
+}): Promise<void>;
+export interface IsolatedComposition {
+    compositionId: string;
+    elementId: string | null;
+}
 export interface SubTimelinePollOptions {
     intervalMs?: number;
     getScriptLoadFailures?: () => readonly string[];
     scriptFailureGraceMs?: number;
+    getPageErrors?: () => readonly string[];
+    scriptErrorGraceMs?: number;
     onPending?: (ids: readonly string[]) => void;
     shouldStop?: () => boolean;
     knownUnregisteredIds?: readonly string[];
 }
-export declare function pollSubCompositionTimelines(page: Page, timeoutMs: number, { intervalMs, getScriptLoadFailures, scriptFailureGraceMs, onPending, shouldStop, knownUnregisteredIds, }?: SubTimelinePollOptions): Promise<SubTimelineWaitOutcome>;
+export declare function pollSubCompositionTimelines(page: Page, timeoutMs: number, { intervalMs, getScriptLoadFailures, scriptFailureGraceMs, getPageErrors, scriptErrorGraceMs, onPending, shouldStop, knownUnregisteredIds, }?: SubTimelinePollOptions): Promise<SubTimelineWaitOutcome>;
+export declare function pollVideosReady(page: Page, skipIds: readonly string[], timeoutMs: number, intervalMs?: number): Promise<boolean>;
 /** @internal exported for unit testing only */
 export declare function pollImagesReady(page: Page, timeoutMs: number, intervalMs?: number): Promise<boolean>;
 export declare function waitForImagesReady(page: Page, timeoutMs: number, onUnloaded: (sources: string) => void): Promise<boolean>;

package/dist/services/frameCapture.js

@@ -1202,16 +1202,61 @@ async function listUnregisteredTimelineIds(page) {
     // Builds a warning, so it must never throw: normalise a loosely typed result.
     return Array.isArray(evaluated) ? evaluated.map((id) => String(id)) : [];
 }
-export async function waitForSubCompositionTimelines(session, page, timeoutMs) {
+function isScriptFailure(session) {
+    const outcome = session.subTimelineWaitOutcome;
+    return outcome === "script_failure" || (outcome === "timeout" && session.pageErrors.length > 0);
+}
+/** A nested composition whose script threw gets an empty timeline, but only while another nested timeline is live. */
+async function isolateUnregisteredCompositions(page) {
+    const isolated = await page.evaluate(`(function() {
+    var timelines = (window.__timelines = window.__timelines || {});
+    var out = [];
+    if (!window.gsap) return out;
+    var broken = [];
+    var live = 0;
+    var hosts = document.querySelectorAll("[data-composition-id]");
+    for (var i = 0; i < hosts.length; i++) {
+      var host = hosts[i];
+      var id = host.getAttribute("data-composition-id");
+      if (!id || host.hasAttribute("data-no-timeline")) continue;
+      var isRoot = !host.parentElement || !host.parentElement.closest("[data-composition-id]");
+      if (timelines[id]) {
+        if (!isRoot) live++;
+      } else if (isRoot) {
+        return out;
+      } else {
+        broken.push(host);
+      }
+    }
+    if (live === 0) return out;
+    broken.forEach(function(host) {
+      var tl = window.gsap.timeline({ paused: true });
+      var duration = parseFloat(host.getAttribute("data-duration"));
+      if (duration > 0) tl.set({}, {}, duration);
+      var id = host.getAttribute("data-composition-id");
+      timelines[id] = tl;
+      out.push({ compositionId: id, elementId: host.id || host.getAttribute("data-hf-id") || null });
+    });
+    if (out.length && typeof window.__hfForceTimelineRebind === "function") window.__hfForceTimelineRebind();
+    return out;
+  })()`);
+    return Array.isArray(isolated) ? isolated : [];
+}
+export async function waitForSubCompositionTimelines(session, page, timeoutMs, options = {}) {
     const memo = session.subTimelineWaitMemo;
     session.subTimelineWaitOutcome = await pollSubCompositionTimelines(page, timeoutMs, {
         getScriptLoadFailures: () => session.scriptLoadFailures,
+        getPageErrors: () => session.pageErrors,
+        scriptErrorGraceMs: options.scriptErrorGraceMs,
         onPending: (ids) => {
             session.pendingTimelineIds = [...ids];
         },
         shouldStop: () => session.vfxFailure !== undefined,
         knownUnregisteredIds: memo.unregisteredIds,
     });
+    if (isScriptFailure(session) && session.scriptLoadFailures.length === 0) {
+        session.isolatedCompositions = await isolateUnregisteredCompositions(page);
+    }
     // Only a clean full-length timeout is replayed: a VFX stop ends early, and page or script
     // errors must reach each session so it can still classify the wait as a script failure.
     const cleanTimeout = session.subTimelineWaitOutcome === "timeout" &&
@@ -1222,7 +1267,7 @@ export async function waitForSubCompositionTimelines(session, page, timeoutMs) {
         memo.unregisteredIds = session.pendingTimelineIds ?? [];
     }
 }
-export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2_000, onPending, shouldStop, knownUnregisteredIds = [], } = {}) {
+export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2_000, getPageErrors, scriptErrorGraceMs = 5_000, onPending, shouldStop, knownUnregisteredIds = [], } = {}) {
     // Hosts may opt out of the timeline wait with `data-no-timeline` —
     // compositions driven purely by CSS animations / rAF (the render-compat
     // contract) never register window.__timelines[id], and without the opt-out
@@ -1244,6 +1289,8 @@ export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs
     const deadline = start + timeoutMs;
     let ready = false;
     let scriptFailureBail = false;
+    // A page error is given its grace from when it first appeared, not from when the poll began.
+    let errorSeenAt;
     for (;;) {
         ready = Boolean(await page.evaluate(expression));
         if (ready || shouldStop?.())
@@ -1252,12 +1299,18 @@ export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs
         if (now >= deadline)
             break;
         const failures = getScriptLoadFailures?.() ?? [];
-        if (failures.length > 0 && now - start >= scriptFailureGraceMs) {
+        const errors = getPageErrors?.() ?? [];
+        const failed = failures.length > 0 ? failures : errors;
+        const graceMs = failures.length > 0 ? scriptFailureGraceMs : scriptErrorGraceMs;
+        if (failed.length > 0)
+            errorSeenAt ??= now;
+        const sinceFailure = failures.length > 0 ? now - start : now - (errorSeenAt ?? now);
+        if (failed.length > 0 && sinceFailure >= graceMs) {
             scriptFailureBail = true;
             console.warn(`[FrameCapture] Sub-composition timeline wait cut short after ${now - start}ms: ` +
-                `script resource(s) failed to load (${failures.join(", ")}), so ` +
+                `script(s) failed (${failed.join(", ")}), so ` +
                 `the timeline registration they carry can never arrive. ` +
-                `Fix the script reference; the render proceeds without those animations.`);
+                `Fix the script.`);
             break;
         }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
@@ -1294,11 +1347,13 @@ export async function pollSubCompositionTimelines(page, timeoutMs, { intervalMs
     }
     return scriptFailureBail ? "script_failure" : "timeout";
 }
-async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
+export async function pollVideosReady(page, skipIds, timeoutMs, intervalMs = 100) {
     const check = async () => {
         return Boolean(await page.evaluate((skipIdList) => {
             const skip = new Set(skipIdList);
-            const vids = Array.from(document.querySelectorAll("video")).filter((v) => !skip.has(v.id));
+            const vids = Array.from(document.querySelectorAll("video"))
+                .filter((v) => !skip.has(v.id))
+                .filter((v) => !v.closest("[data-hidden]"));
             return (vids.length === 0 ||
                 vids.every((v) => {
                     const ve = v;
@@ -1449,16 +1504,33 @@ export function recordSubTimelineWarning(session, timeoutMs) {
     const outcome = session.subTimelineWaitOutcome;
     if (outcome === "ready" || !outcome)
         return;
-    const threwThenTimedOut = outcome === "timeout" && session.pageErrors.length > 0;
-    const scriptFailure = outcome === "script_failure" || threwThenTimedOut;
+    const threwThenTimedOut = session.pageErrors.length > 0 && session.scriptLoadFailures.length === 0;
+    const scriptFailure = isScriptFailure(session);
     const sources = [...session.scriptLoadFailures, ...session.pageErrors];
     const pending = session.pendingTimelineIds ?? [];
     const pendingSuffix = pending.length > 0 ? ` (still unregistered: ${pending.join(", ")})` : "";
+    const isolated = session.isolatedCompositions ?? [];
+    if (isolated.length > 0) {
+        recordCaptureWarnings(session, [
+            {
+                code: "script_error_isolated",
+                message: `A composition script failed, so its animation was skipped and the render went on: ` +
+                    `${isolated.map((c) => c.elementId ?? c.compositionId).join(", ")} (${sources.join(", ")}).`,
+                details: {
+                    sources,
+                    pendingCompositionIds: [...pending],
+                    isolatedElements: isolated,
+                    failureOwner: "user",
+                },
+            },
+        ]);
+        return;
+    }
     recordCaptureWarnings(session, [
         {
             code: scriptFailure ? "sub_timeline_script_failure" : "sub_timeline_readiness_timeout",
             message: threwThenTimedOut
-                ? `A composition script threw and a timeline did not register within ${timeoutMs}ms` +
+                ? `A composition script threw before its timeline registered` +
                     `${pendingSuffix} (${sources.join(", ")}). Fix the error; a composition animated by ` +
                     `CSS or rAF rather than a GSAP timeline must mark its host with data-no-timeline.`
                 : scriptFailure
@@ -1802,6 +1874,7 @@ export async function initializeSession(session) {
                 const skip = new Set(skipIdList);
                 return Array.from(document.querySelectorAll("video"))
                     .filter((v) => !skip.has(v.id))
+                    .filter((v) => !v.closest("[data-hidden]"))
                     .filter((v) => v.readyState < 2 && !v.error)
                     .map((v) => v.src || v.getAttribute("src") || "(no src)")
                     .join(", ");
@@ -1914,6 +1987,7 @@ export async function initializeSession(session) {
                 const skip = new Set(skipIdList);
                 return Array.from(document.querySelectorAll("video"))
                     .filter((v) => !skip.has(v.id))
+                    .filter((v) => !v.closest("[data-hidden]"))
                     .filter((v) => v.readyState < 2 && !v.error)
                     .map((v) => v.src || v.getAttribute("src") || "(no src)")
                     .join(", ");
@@ -2925,6 +2999,50 @@ export function resolveSessionMotionBlur(session) {
     }
     return plan;
 }
+/**
+ * Size guard for a serial drawElement frame. A frame far below the rolling median may be a
+ * dropped paint record, which is intermittent, so the frame is drawn once more: a byte-identical
+ * redraw is real content (a flat or dark frame) and is kept, as the streaming drain guard in the
+ * producer keeps it. Segmented capture reaches only this guard, so it must judge a small frame
+ * the same way, or a render that passes in one pass fails when segmented (GH #5685). A redraw
+ * that differs and is still small throws, and the caller restarts on a fresh screenshot page.
+ */
+async function judgeSmallDrawElementFrame(session, frameIndex, buffer, redraw) {
+    const sizes = (session.deFrameSizes ??= []);
+    const sorted = sizes.length >= 12 ? [...sizes].sort((a, b) => a - b) : null;
+    const median = sorted ? (sorted[sorted.length >> 1] ?? 0) : 0;
+    const floor = Math.max(session.deAbsFloor ?? 20000, median * 0.12);
+    let kept = buffer;
+    if (buffer.length < floor && !session.deAcceptedSmall?.equals(buffer)) {
+        const suspect = () => new DrawElementCaptureError(frameIndex, `suspect small frame (${buffer.length}B < ${Math.round(floor)}B)`);
+        // Under BeginFrame control the page paints only on the frame already sent for this index,
+        // so a second draw reads the same snapshot and cannot tell a drop from real content.
+        if (session.beginFrameTimeTicks > 0)
+            throw suspect();
+        const retry = await redraw();
+        if (retry.equals(buffer)) {
+            // Halving the floor keeps a run of similar flat frames from redrawing every frame.
+            session.deAbsFloor = Math.min(session.deAbsFloor ?? 20000, Math.floor(buffer.length / 2));
+            session.deAcceptedSmall = buffer;
+        }
+        else if (retry.length < floor) {
+            throw suspect();
+        }
+        else {
+            kept = retry;
+        }
+    }
+    if (sizes.length >= 60)
+        sizes.shift();
+    sizes.push(kept.length);
+    return kept;
+}
+/** Seek to `time` again and draw the frame once more, for {@link judgeSmallDrawElementFrame}. */
+async function redrawDrawElementFrame(session, frameIndex, time, seekOptions, heldVideoTime) {
+    const { page, options } = session;
+    await prepareFrameForCapture(session, frameIndex, time, seekOptions, heldVideoTime);
+    return captureDrawElementFrame(page, options.width, options.height, options.format ?? "jpeg", options.quality ?? 80, true);
+}
 /** 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;
@@ -2976,20 +3094,8 @@ async function captureFrameSurface(session, frameIndex, time, seekOptions, heldV
             session.beginFrameTimeTicks === 0);
             // A tiny JPEG may be a dropped paint record. Never screenshot this page:
             // its injected canvas can still hold the preceding frame's bitmap.
-            // Restart on a fresh screenshot page even if this was a simple valid frame.
             if ((options.format ?? "jpeg") !== "png" && process.env.HF_FORCE_DRAWELEMENT !== "1") {
-                const sizes = (session.deFrameSizes ??= []);
-                const sorted = sizes.length >= 12 ? [...sizes].sort((a, b) => a - b) : null;
-                const median = sorted ? (sorted[sorted.length >> 1] ?? 0) : 0;
-                const floor = Math.max(20000, median * 0.12);
-                if (screenshotBuffer.length < floor) {
-                    throw new DrawElementCaptureError(frameIndex, `suspect small frame (${screenshotBuffer.length}B < ${Math.round(floor)}B)`);
-                }
-                else {
-                    if (sizes.length >= 60)
-                        sizes.shift();
-                    sizes.push(screenshotBuffer.length);
-                }
+                screenshotBuffer = await judgeSmallDrawElementFrame(session, frameIndex, screenshotBuffer, () => redrawDrawElementFrame(session, frameIndex, time, seekOptions, heldVideoTime));
             }
         }
         catch (err) {

package/dist/types.d.ts

@@ -22,7 +22,7 @@ export type SubTimelineWaitOutcome = "ready" | "timeout" | "script_failure";
 export interface SubTimelineWaitMemo {
     unregisteredIds?: readonly string[];
 }
-export type CaptureWarningCode = "media_readiness_timeout" | "media_load_failed" | "audio_processing_failed" | "sub_timeline_readiness_timeout" | "sub_timeline_script_failure" | "vfx_failure" | "live_map_detected";
+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. */
 export interface CaptureWarning {
     code: CaptureWarningCode;
@@ -31,6 +31,10 @@ export interface CaptureWarning {
         mediaType?: "image" | "video" | "audio";
         sources?: string[];
         pendingCompositionIds?: string[];
+        isolatedElements?: Array<{
+            compositionId: string;
+            elementId: string | null;
+        }>;
         timeoutMs?: number;
         audioFailures?: AudioFailureDiagnostic[];
         failureReasons?: string[];

package/dist/utils/ffprobe.d.ts

@@ -51,6 +51,8 @@ export interface AudioMetadata {
     bitrate?: number;
     /** Seconds after the file's media time 0 at which its last audio or video stream starts. */
     latestStreamLeadSeconds?: number;
+    audioStreamLeadSeconds?: number;
+    audioStreamCount?: number;
 }
 interface FFProbeStream {
     codec_type: string;

package/dist/utils/ffprobe.js

@@ -774,6 +774,8 @@ export async function extractAudioMetadata(filePath, options) {
             audioCodec,
             bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : undefined,
             latestStreamLeadSeconds: latestStreamLeadSeconds(output),
+            audioStreamLeadSeconds: streamLeadSeconds(output, audioStream),
+            audioStreamCount: output.streams.filter((s) => s.codec_type === "audio").length,
         };
     })();
     if (options?.signal)
@@ -858,8 +860,7 @@ async function probeDecodedAudioDuration(filePath, sampleRate, startSeconds, con
     return lastFrame.timestamp + lastFrame.nbSamples / sampleRate - startSeconds;
 }
 const keyframeCache = new Map();
-/** Intervals beyond this cause seeking issues in the headless renderer and
- *  audio/video desync — the sole threshold for `isProblematic` below. */
+/** Advisory threshold for seeking cost; GOP length alone does not establish incorrect output. */
 const PROBLEMATIC_KEYFRAME_INTERVAL_SECONDS = 2;
 /**
  * Checks keyframe intervals in a video stream; intervals over the threshold below flag `isProblematic`.

package/package.json

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