@hyperframes/engine 0.8.177 → 0.8.179

package/dist/services/__fixtures__/loopback.d.ts

@@ -3,3 +3,5 @@ import { type Browser } from "puppeteer-core";
 /** Listens on a free loopback port and returns the server's origin. */
 export declare function listenOnLoopback(server: Server): Promise<string>;
 export declare function launchTestChrome(executablePath: string | undefined): Promise<Browser>;
+/** Closes a test Chrome, killing it when close hangs (seen on Windows runners) so afterAll never times out. */
+export declare function closeTestChrome(browser: Browser | undefined, timeoutMs?: number): Promise<void>;

package/dist/services/__fixtures__/loopback.js

@@ -14,3 +14,18 @@ export function launchTestChrome(executablePath) {
         args: ["--no-sandbox", "--disable-dev-shm-usage"],
     });
 }
+/** Closes a test Chrome, killing it when close hangs (seen on Windows runners) so afterAll never times out. */
+export async function closeTestChrome(browser, timeoutMs = 5_000) {
+    if (!browser)
+        return;
+    let timer;
+    const closed = await Promise.race([
+        browser.close().then(() => true, () => false),
+        new Promise((resolve) => (timer = setTimeout(resolve, timeoutMs, false))),
+    ]);
+    clearTimeout(timer);
+    if (closed)
+        return;
+    browser.process()?.kill("SIGKILL");
+    await browser.disconnect().catch(() => undefined);
+}

package/dist/services/audioMixer.d.ts

@@ -33,4 +33,5 @@ export declare function parseAudioElements(html: string): AudioElement[];
 export declare function processCompositionAudio(elements: AudioElement[], baseDir: string, workDir: string, outputPath: string, totalDuration: number, signal?: AbortSignal, config?: Partial<Pick<EngineConfig, "ffmpegProcessTimeout" | "audioGain">> & {
     /** Serialised master bus chain, from `parseMasterFxChain`. */
     masterFxChain?: string;
+    urlByAbsentLocalPath?: ReadonlyMap<string, string>;
 }, compiledDir?: string): Promise<MixResult>;

package/dist/services/audioMixer.js

@@ -935,6 +935,7 @@ export async function processCompositionAudio(elements, baseDir, workDir, output
             if (!isHttpUrl(srcPath)) {
                 // Same browser-URL path semantics as videos.
                 srcPath = resolveProjectRelativeSrc(element.src, baseDir, compiledDir);
+                srcPath = config?.urlByAbsentLocalPath?.get(srcPath) ?? srcPath;
             }
             if (isHttpUrl(srcPath)) {
                 try {

package/dist/services/browserManager.js

@@ -10,7 +10,7 @@ import { execSync } from "child_process";
 import { existsSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { chromeMajorCeiling, exceedsChromeCeiling } from "./chromeHostCeiling.js";
+import { chromeMajorCeiling, compareBrowserVersionsDescending, exceedsChromeCeiling, isManagedChromeDir, pickSharedShell, } from "./chromeHostCeiling.js";
 import { DEFAULT_CONFIG } from "../config.js";
 import { getSystemTotalMb, LOW_MEMORY_TOTAL_MB_THRESHOLD } from "./systemMemory.js";
 import { describeWslGpuAccess, detectWsl } from "./wslHost.js";
@@ -103,28 +103,6 @@ async function readWebGlInfo(browser) {
         };
     });
 }
-function compareBrowserVersionsDescending(left, right) {
-    const parse = (value) => {
-        const version = value.slice(value.indexOf("-") + 1);
-        const segments = [];
-        for (const segment of version.split(".")) {
-            const parsed = Number.parseInt(segment, 10);
-            if (!Number.isFinite(parsed))
-                break;
-            segments.push(parsed);
-        }
-        return segments;
-    };
-    const leftSegments = parse(left);
-    const rightSegments = parse(right);
-    const length = Math.max(leftSegments.length, rightSegments.length);
-    for (let index = 0; index < length; index += 1) {
-        const difference = (rightSegments[index] ?? 0) - (leftSegments[index] ?? 0);
-        if (difference !== 0)
-            return difference;
-    }
-    return 0;
-}
 const CACHED_HEADLESS_SHELL_EXECUTABLES = {
     "darwin/arm64": ["chrome-headless-shell-mac-arm64", "chrome-headless-shell"],
     "darwin/x64": ["chrome-headless-shell-mac-x64", "chrome-headless-shell"],
@@ -172,6 +150,33 @@ function findCachedHeadlessShell(baseDir) {
     }
     return undefined;
 }
+function findSharedHeadlessShell(baseDir) {
+    const executable = cachedHeadlessShellExecutable();
+    if (!executable || !existsSync(baseDir))
+        return undefined;
+    try {
+        return pickSharedShell(readdirSync(baseDir), (version) => {
+            const binary = join(baseDir, version, ...executable);
+            return isNonEmptyFile(binary) ? binary : undefined;
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function findManagedHeadlessShell(baseDir) {
+    const executable = cachedHeadlessShellExecutable();
+    if (!executable || !existsSync(baseDir))
+        return undefined;
+    try {
+        const version = readdirSync(baseDir).find(isManagedChromeDir);
+        const binary = version && join(baseDir, version, ...executable);
+        return binary && isNonEmptyFile(binary) ? binary : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Resolve chrome-headless-shell binary for deterministic BeginFrame rendering.
  * Checks config.chromePath, then PRODUCER_HEADLESS_SHELL_PATH env var,
@@ -197,8 +202,11 @@ export function resolveHeadlessShellPath(config) {
         }
         return envPath;
     }
-    const home = homedir();
-    return (findCachedHeadlessShell(join(home, ".cache", "hyperframes", "chrome", "chrome-headless-shell")) ?? findCachedHeadlessShell(join(home, ".cache", "puppeteer", "chrome-headless-shell")));
+    const ours = join(homedir(), ".cache", "hyperframes", "chrome", "chrome-headless-shell");
+    const shared = join(homedir(), ".cache", "puppeteer", "chrome-headless-shell");
+    return (findManagedHeadlessShell(ours) ??
+        findSharedHeadlessShell(shared) ??
+        findCachedHeadlessShell(ours));
 }
 /** Full Chrome for Testing in Puppeteer's cache (`@puppeteer/browsers install chrome@...`), newest first. */
 export function resolveFullChromePath() {

package/dist/services/chromeHostCeiling.d.ts

@@ -2,3 +2,12 @@
 export declare function chromeMajorCeiling(hostPlatform?: string, hostRelease?: string): number | undefined;
 /** True when a cache dir name (`mac-152.0.1.2`) or build id (`152.0.1.2`) is newer than the ceiling. */
 export declare function exceedsChromeCeiling(versionName: string, ceiling: number | undefined): boolean;
+export declare function managedChromeVersion(hostPlatform?: string, hostRelease?: string): string;
+export declare const isManagedChromeDir: (versionName: string) => boolean;
+/** Newest first, by numeric build (`linux-148.0.1` before `linux-99.0.1`). */
+export declare function compareBrowserVersionsDescending(left: string, right: string): number;
+/** Whether a shell loads a blank page and exits: an old build can die at launch on a newer OS. Asked once per path. */
+export declare function shellStarts(binary: string): boolean;
+/** The shared Puppeteer cache's shell: the managed build, else the newest under the host's ceiling that starts.
+ * `shell` names a version dir's executable, or undefined when it holds no usable file. */
+export declare function pickSharedShell(versions: readonly string[], shell: (version: string) => string | undefined): string | undefined;

package/dist/services/chromeHostCeiling.js

@@ -1,3 +1,5 @@
+import { spawnSync } from "node:child_process";
+import { debuglog } from "node:util";
 import { release } from "node:os";
 /** Chrome 151 dropped macOS 12 and older (Darwin < 22); 150 is the last major that launches there. */
 const MACOS_12_LAST_CHROME_MAJOR = 150;
@@ -14,3 +16,67 @@ export function exceedsChromeCeiling(versionName, ceiling) {
     const major = Number.parseInt(versionName.slice(versionName.indexOf("-") + 1), 10);
     return major > ceiling;
 }
+// Deliberately Beta, not Canary: 153.0.8000.0 measured identical to this build on every probe. macOS 12 gets 150,
+// the last headless shell that launches there; it exposes canvas.drawElementImage under CanvasDrawElement.
+const CHROME_VERSION = "152.0.7977.30";
+const MACOS_12_CHROME_VERSION = "150.0.7871.124";
+export function managedChromeVersion(hostPlatform = process.platform, hostRelease = release()) {
+    return chromeMajorCeiling(hostPlatform, hostRelease) === undefined
+        ? CHROME_VERSION
+        : MACOS_12_CHROME_VERSION;
+}
+export const isManagedChromeDir = (versionName) => versionName.slice(versionName.indexOf("-") + 1) === managedChromeVersion();
+/** Newest first, by numeric build (`linux-148.0.1` before `linux-99.0.1`). */
+export function compareBrowserVersionsDescending(left, right) {
+    const parse = (value) => {
+        const version = value.slice(value.indexOf("-") + 1);
+        const segments = [];
+        for (const segment of version.split(".")) {
+            const parsed = Number.parseInt(segment, 10);
+            if (!Number.isFinite(parsed))
+                break;
+            segments.push(parsed);
+        }
+        return segments;
+    };
+    const leftSegments = parse(left);
+    const rightSegments = parse(right);
+    const length = Math.max(leftSegments.length, rightSegments.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (rightSegments[index] ?? 0) - (leftSegments[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}
+const starts = new Map();
+const debug = debuglog("hyperframes:browser");
+/** Whether a shell loads a blank page and exits: an old build can die at launch on a newer OS. Asked once per path. */
+export function shellStarts(binary) {
+    let answer = starts.get(binary);
+    if (answer === undefined) {
+        const probe = ["--no-sandbox", "--dump-dom", "about:blank"];
+        answer = spawnSync(binary, probe, { stdio: "ignore", timeout: 10_000 })?.status === 0;
+        if (!answer)
+            debug("skipping %s: it did not start", binary);
+        starts.set(binary, answer);
+    }
+    return answer;
+}
+/** The shared Puppeteer cache's shell: the managed build, else the newest under the host's ceiling that starts.
+ * `shell` names a version dir's executable, or undefined when it holds no usable file. */
+export function pickSharedShell(versions, shell) {
+    const managed = versions.find(isManagedChromeDir);
+    const pinned = managed && shell(managed);
+    if (pinned)
+        return pinned;
+    const ceiling = chromeMajorCeiling();
+    for (const version of [...versions].sort(compareBrowserVersionsDescending)) {
+        if (version === managed || exceedsChromeCeiling(version, ceiling))
+            continue;
+        const binary = shell(version);
+        if (binary && shellStarts(binary))
+            return binary;
+    }
+    return undefined;
+}

package/dist/services/videoFrameExtractor.d.ts

@@ -107,6 +107,7 @@ export interface ExtractionOptions {
     deferRangeExtraction?: boolean;
     /** Directories the caller rewrites on every render (downloaded media); their sources are cached by content. */
     contentKeyedDirs?: readonly string[];
+    urlByAbsentLocalPath?: ReadonlyMap<string, string>;
 }
 export declare const EXTRACT_CACHE_MIN_AGE_MS: number;
 /**
@@ -240,7 +241,8 @@ export interface ImageElement {
     end: number;
 }
 export declare function parseImageElements(html: string): ImageElement[];
-export declare function extractVideoFramesRange(videoPath: string, videoId: string, startTime: number, duration: number, options: ExtractionOptions, signal?: AbortSignal, config?: Partial<Pick<EngineConfig, "ffmpegProcessTimeout">>, 
+export declare function extractVideoFramesRange(...args: Parameters<typeof extractVideoFramesRangeUnredacted>): Promise<ExtractedFrames>;
+declare function extractVideoFramesRangeUnredacted(videoPath: string, videoId: string, startTime: number, duration: number, options: ExtractionOptions, signal?: AbortSignal, config?: Partial<Pick<EngineConfig, "ffmpegProcessTimeout">>, 
 /** Frames go straight here, with no per-videoId subdir (the cache layer's keyed entry). */
 outputDirOverride?: string): Promise<ExtractedFrames>;
 export declare function classifyFfmpegSpawnError(error: unknown, stderr?: string): VideoSourceExtractionError;

package/dist/services/videoFrameExtractor.js

@@ -18,6 +18,7 @@ import { resolveReferencedStart } from "./referenceResolver.js";
 import { isKnownInactiveTimelineWindow } from "./mediaTimelineWindow.js";
 import { extractFinalVideoFrameTimestamp, extractMediaMetadata, } from "../utils/ffprobe.js";
 import { inputAlphaOpaqueWarning, probeInputAlphaPlane } from "../utils/alphaPlaneProbe.js";
+import { redactUrlQueriesInError, urlInputArgs } from "../utils/urlInput.js";
 import { analyzeCompositionHdr, isHdrColorSpace as isHdrColorSpaceUtil, } from "../utils/hdr.js";
 import { downloadToTemp, isHttpUrl, safeDownloadUrlIdentity, UrlDownloadError, writeUrlDownloadTelemetry, } from "../utils/urlDownloader.js";
 import { runFfmpeg } from "../utils/runFfmpeg.js";
@@ -418,7 +419,9 @@ export function parseImageElements(html) {
 }
 /** The first shown frame's colour tags; see {@link firstFrameColourArgs}. */
 async function readFirstFrameColour(videoPath, signal) {
-    const result = await runFfmpeg(firstFrameColourArgs(videoPath), { signal });
+    const result = await runFfmpeg([...urlInputArgs(videoPath), ...firstFrameColourArgs(videoPath)], {
+        signal,
+    });
     return parseFirstFrameColour(result.stderr);
 }
 /** Chrome plays untagged VP9 and AV1 as BT.601, H.264 and VP8 as BT.709 from 720 coded lines (assumed for the rest). */
@@ -516,7 +519,15 @@ async function runSegmentedExtraction(job) {
     }
     return ran[ran.length - 1];
 }
-export async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, 
+export async function extractVideoFramesRange(...args) {
+    try {
+        return await extractVideoFramesRangeUnredacted(...args);
+    }
+    catch (error) {
+        throw redactUrlQueriesInError(error);
+    }
+}
+async function extractVideoFramesRangeUnredacted(videoPath, videoId, startTime, duration, options, signal, config, 
 /** Frames go straight here, with no per-videoId subdir (the cache layer's keyed entry). */
 outputDirOverride) {
     const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
@@ -555,7 +566,7 @@ outputDirOverride) {
     if (options.frameRanges && (!sampleAtOutputFps || metadata.isVFR)) {
         throw new Error("frameRanges extraction needs a constant-frame-rate source");
     }
-    const args = [];
+    const args = urlInputArgs(videoPath);
     if (decodeWithVideoToolbox) {
         args.push("-hwaccel", "videotoolbox");
     }
@@ -1129,6 +1140,11 @@ export async function extractAllVideoFrames(videos, baseDir, options, signal, co
             if (!isHttpUrl(videoPath)) {
                 videoPath = resolveProjectRelativeSrc(video.src, baseDir, compiledDir);
             }
+            const remoteUrl = options.urlByAbsentLocalPath?.get(videoPath);
+            if (remoteUrl) {
+                resolvedVideos.push({ video, videoPath: remoteUrl });
+                continue;
+            }
             if (isHttpUrl(videoPath)) {
                 const downloadDir = join(options.outputDir, DOWNLOAD_SUBDIR);
                 mkdirSync(downloadDir, { recursive: true });

package/dist/utils/ffprobe.js

@@ -5,6 +5,7 @@ import { chunkCrc32 } from "./crc32.js";
 import { StringDecoder } from "node:string_decoder";
 import { basename } from "path";
 import { redactTelemetryString } from "@hyperframes/core";
+import { urlInputArgs } from "./urlInput.js";
 import { FFPROBE_PATH_ENV, getFfprobeBinary } from "./ffmpegBinaries.js";
 import { ManagedChildProcess } from "./managedChildProcess.js";
 import { trackChildProcess } from "./processTracker.js";
@@ -56,7 +57,15 @@ async function runFfprobe(filePath, argsWithoutInput, signal, stdoutOptions) {
         throw new Error('[FFmpeg] Refusing to probe "-": stdin is not a supported input path.');
     }
     const command = getFfprobeBinary();
-    const proc = spawn(command, ["-v", "error", ...argsWithoutInput, "--", filePath], {
+    const args = [
+        "-v",
+        "error",
+        ...urlInputArgs(filePath, { tool: "ffprobe" }),
+        ...argsWithoutInput,
+        "--",
+        filePath,
+    ];
+    const proc = spawn(command, args, {
         // Nothing is ever written to the child's stdin; leaving it as a pipe is
         // what lets a stdin-reading invocation block indefinitely.
         stdio: ["ignore", "pipe", "pipe"],
@@ -593,7 +602,10 @@ export async function extractMediaMetadata(filePath) {
         // ffprobe ran at all, which is exactly the build it exists to cover: one
         // that reports gbr but does not decode cICP. An HDR PQ PNG then resolved
         // colorTransfer "" and graded SDR.
-        const cicp = colorTransfer && colorPrimaries && colorSpaceVal ? null : stillImage()?.colorSpace;
+        const isPng = output !== null && isPngImageProbe(output);
+        const cicp = !isPng || (colorTransfer && colorPrimaries && colorSpaceVal)
+            ? null
+            : stillImage()?.colorSpace;
         const merged = {
             colorTransfer: colorTransfer || cicp?.colorTransfer || "",
             colorPrimaries: colorPrimaries || cicp?.colorPrimaries || "",

package/dist/utils/managedChildProcess.d.ts

@@ -26,7 +26,9 @@ export declare class ManagedChildProcess {
     private readonly outcomePromise;
     private resolveOutcome;
     private requestedReason;
-    private stderrTail;
+    private rawStderrTail;
+    private rawStderrTailCut;
+    private readonly stderrDecoder;
     private spawned;
     private settled;
     private deadlineTimer;
@@ -37,6 +39,8 @@ export declare class ManagedChildProcess {
     get isSettled(): boolean;
     markActivity(): void;
     private readonly onStderr;
+    private get maxBytes();
+    private redactedStderrTail;
     private readonly onSpawn;
     private readonly onClose;
     private readonly onError;

package/dist/utils/managedChildProcess.js

@@ -1,5 +1,8 @@
+import { StringDecoder } from "node:string_decoder";
+import { redactUrlQueryStrings } from "@hyperframes/core";
 const DEFAULT_TERMINATION_GRACE_MS = 2_000;
 const DEFAULT_STDERR_MAX_BYTES = 64 * 1024;
+const RAW_STDERR_SLACK_FACTOR = 2;
 /** Owns cancellation, escalation, stderr and reaping for one child process. */
 export class ManagedChildProcess {
     child;
@@ -9,7 +12,9 @@ export class ManagedChildProcess {
     outcomePromise;
     resolveOutcome;
     requestedReason = null;
-    stderrTail = Buffer.alloc(0);
+    rawStderrTail = "";
+    rawStderrTailCut = false;
+    stderrDecoder = new StringDecoder("utf8");
     spawned = false;
     settled = false;
     deadlineTimer = null;
@@ -47,13 +52,21 @@ export class ManagedChildProcess {
     }
     onStderr = (data) => {
         const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        const maxBytes = this.options.stderrMaxBytes ?? DEFAULT_STDERR_MAX_BYTES;
-        this.stderrTail = Buffer.concat([this.stderrTail, chunk]);
-        if (this.stderrTail.byteLength > maxBytes) {
-            this.stderrTail = this.stderrTail.subarray(this.stderrTail.byteLength - maxBytes);
-        }
+        const joined = this.rawStderrTail + this.stderrDecoder.write(chunk);
+        this.rawStderrTail = lastBytes(joined, RAW_STDERR_SLACK_FACTOR * this.maxBytes);
+        if (this.rawStderrTail !== joined)
+            this.rawStderrTailCut = true;
         this.options.onStderr?.(chunk.toString());
     };
+    get maxBytes() {
+        return this.options.stderrMaxBytes ?? DEFAULT_STDERR_MAX_BYTES;
+    }
+    redactedStderrTail() {
+        const raw = this.rawStderrTailCut
+            ? withoutTokenSeveredByCut(this.rawStderrTail)
+            : this.rawStderrTail;
+        return lastBytes(redactUrlQueryStrings(raw), this.maxBytes);
+    }
     onSpawn = () => {
         this.spawned = true;
     };
@@ -62,7 +75,7 @@ export class ManagedChildProcess {
             reason: this.requestedReason ?? "exit",
             exitCode,
             signal,
-            stderr: this.stderrTail.toString(),
+            stderr: this.redactedStderrTail(),
             durationMs: this.now() - this.startedAtMs,
         });
     };
@@ -73,7 +86,7 @@ export class ManagedChildProcess {
             reason: "spawn_error",
             exitCode: null,
             signal: null,
-            stderr: this.stderrTail.length > 0 ? this.stderrTail.toString() : error.message,
+            stderr: this.rawStderrTail.length > 0 ? this.redactedStderrTail() : error.message,
             durationMs: this.now() - this.startedAtMs,
             error,
         });
@@ -145,3 +158,12 @@ export class ManagedChildProcess {
         this.escalationTimer = null;
     }
 }
+function lastBytes(text, maxBytes) {
+    return Buffer.byteLength(text) > maxBytes
+        ? Buffer.from(text).subarray(-maxBytes).toString()
+        : text;
+}
+function withoutTokenSeveredByCut(text) {
+    const firstSpace = text.search(/\s/);
+    return firstSpace < 0 ? "" : text.slice(firstSpace);
+}

package/dist/utils/urlInput.d.ts

@@ -0,0 +1,7 @@
+/** ffmpeg and ffprobe skip TLS certificate checks unless told to; an https input must be verified. */
+export declare function urlInputArgs(input: string, { tool, caBundles, }?: {
+    tool?: "ffmpeg" | "ffprobe";
+    caBundles?: readonly string[];
+}): string[];
+/** A signed URL grants access until it expires: strip query strings from every string field of an error and its causes. */
+export declare function redactUrlQueriesInError<T>(error: T): T;

package/dist/utils/urlInput.js

@@ -0,0 +1,34 @@
+import { existsSync } from "node:fs";
+import { redactUrlQueryStrings } from "@hyperframes/core";
+// The Lambda nodejs image (Amazon Linux 2023) ships the first; Debian/Ubuntu the second; macOS the third.
+const CA_BUNDLES = [
+    "/etc/pki/tls/certs/ca-bundle.crt",
+    "/etc/ssl/certs/ca-certificates.crt",
+    "/etc/ssl/cert.pem",
+];
+// Lambda's ffprobe 4.0 accepts these but not -reconnect_on_network_error; a stalled read fails after 30 s.
+const RECONNECT_ARGS = ["-rw_timeout", "30000000", "-reconnect", "1", "-reconnect_delay_max", "2"];
+/** ffmpeg and ffprobe skip TLS certificate checks unless told to; an https input must be verified. */
+export function urlInputArgs(input, { tool = "ffmpeg", caBundles = CA_BUNDLES, } = {}) {
+    if (!/^https:\/\//i.test(input))
+        return [];
+    const caFile = caBundles.find((path) => existsSync(path));
+    if (!caFile) {
+        throw new Error(`[FFmpeg] cannot verify TLS for an https input: no CA bundle at ${caBundles.join(", ")}`);
+    }
+    const networkRetry = tool === "ffmpeg" ? ["-reconnect_on_network_error", "1"] : [];
+    return ["-tls_verify", "1", "-ca_file", caFile, ...RECONNECT_ARGS, ...networkRetry];
+}
+/** A signed URL grants access until it expires: strip query strings from every string field of an error and its causes. */
+export function redactUrlQueriesInError(error) {
+    if (!(error instanceof Error))
+        return error;
+    const fields = error;
+    for (const key of ["message", "stack", ...Object.keys(error)]) {
+        if (typeof fields[key] === "string")
+            fields[key] = redactUrlQueryStrings(fields[key]);
+    }
+    if (error.cause !== error)
+        redactUrlQueriesInError(error.cause);
+    return error;
+}

package/package.json

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