pagespeed-quest 0.9.0 → 0.10.0

package/build/recording.js

@@ -1,11 +1,58 @@
-import { startRecording } from 'rust-http-playback-proxy';
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+import Net from 'net';
+import Path from 'path';
+import { Proxy as RustProxy, startRecording } from 'rust-http-playback-proxy';
 import { InventoryRepository } from './inventory.js';
+async function getAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = Net.createServer();
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => resolve(port));
+            }
+            else {
+                server.close(() => reject(new Error('Failed to get port from server address')));
+            }
+        });
+        server.on('error', reject);
+    });
+}
+async function waitForPort(port, timeoutMs = 60000) {
+    const startTime = Date.now();
+    let delay = 50;
+    while (Date.now() - startTime < timeoutMs) {
+        try {
+            await new Promise((resolve, reject) => {
+                const socket = Net.createConnection({ port, host: '127.0.0.1' });
+                socket.on('connect', () => {
+                    socket.destroy();
+                    resolve();
+                });
+                socket.on('error', reject);
+                socket.setTimeout(1000, () => {
+                    socket.destroy();
+                    reject(new Error('Connection timeout'));
+                });
+            });
+            return;
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay = Math.min(delay * 1.5, 500);
+        }
+    }
+    throw new Error(`Timeout waiting for port ${port} to become available`);
+}
 export class RecordingProxy {
     rustProxy;
     inventoryRepository;
     entryUrl;
     deviceType;
     requestedPort;
+    excludePatterns;
     dependency;
     constructor(options, dependency) {
         options ||= {};
@@ -18,16 +65,30 @@ export class RecordingProxy {
         this.deviceType = options.deviceType;
         // Port
         this.requestedPort = options.port;
+        // Exclude patterns
+        this.excludePatterns = options.excludePatterns;
     }
     async start() {
         this.dependency.logger?.info(`Starting recording proxy...`);
         const proxyPort = this.requestedPort || 0;
-        this.rustProxy = await startRecording({
-            entryUrl: this.entryUrl,
-            deviceType: this.deviceType,
-            inventoryDir: this.inventoryRepository.dirPath,
-            port: proxyPort,
-        });
+        if (this.excludePatterns && this.excludePatterns.length > 0) {
+            // Use direct binary spawn to support -x exclude patterns
+            this.rustProxy = await startRecordingWithExclude({
+                entryUrl: this.entryUrl,
+                deviceType: this.deviceType,
+                inventoryDir: this.inventoryRepository.dirPath,
+                port: proxyPort,
+                excludePatterns: this.excludePatterns,
+            });
+        }
+        else {
+            this.rustProxy = await startRecording({
+                entryUrl: this.entryUrl,
+                deviceType: this.deviceType,
+                inventoryDir: this.inventoryRepository.dirPath,
+                port: proxyPort,
+            });
+        }
         this.dependency.logger?.info(`Recording proxy started on port ${this.rustProxy.port}`);
     }
     get port() {
@@ -51,6 +112,62 @@ export class RecordingProxy {
         }
     }
 }
+function getProxyBinaryPath() {
+    const require = createRequire(import.meta.url);
+    // Resolve the main entry point (which is allowed by exports) and derive package root
+    const mainPath = require.resolve('rust-http-playback-proxy');
+    // mainPath is like .../node_modules/rust-http-playback-proxy/dist/index.js
+    const pkgDir = Path.resolve(Path.dirname(mainPath), '..');
+    const platform = process.platform === 'win32' ? 'windows' : process.platform;
+    const arch = process.arch;
+    const ext = process.platform === 'win32' ? '.exe' : '';
+    return Path.join(pkgDir, 'bin', `${platform}-${arch}`, `http-playback-proxy${ext}`);
+}
+async function startRecordingWithExclude(options) {
+    const binaryPath = getProxyBinaryPath();
+    let port;
+    if (options.port === undefined || options.port === 0) {
+        port = await getAvailablePort();
+    }
+    else {
+        port = options.port;
+    }
+    const deviceType = options.deviceType || 'mobile';
+    const inventoryDir = options.inventoryDir || './inventory';
+    const args = ['recording'];
+    if (options.entryUrl) {
+        args.push(options.entryUrl);
+    }
+    args.push('--port', port.toString());
+    args.push('--device', deviceType);
+    args.push('--inventory', inventoryDir);
+    for (const pattern of options.excludePatterns) {
+        args.push('--exclude', pattern);
+    }
+    const proc = spawn(binaryPath, args, {
+        stdio: ['ignore', 'inherit', 'inherit'],
+        detached: false,
+    });
+    const proxy = new RustProxy('recording', port, inventoryDir, options.entryUrl, deviceType);
+    proxy.setProcess(proc);
+    let exited = false;
+    proc.on('exit', (code) => {
+        exited = true;
+        if (code !== 0 && code !== null) {
+            console.error(`Proxy process exited early with code ${code}`);
+        }
+    });
+    try {
+        await waitForPort(port, 15000);
+    }
+    catch (err) {
+        if (exited) {
+            throw new Error('Proxy process exited before port became available');
+        }
+        throw err;
+    }
+    return proxy;
+}
 export async function withRecordingProxy(options, dependency, cb) {
     const proxy = new RecordingProxy(options, dependency);
     await proxy.start();
@@ -61,4 +178,4 @@ export async function withRecordingProxy(options, dependency, cb) {
         await proxy.stop();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recording.js","sourceRoot":"","sources":["../src/recording.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,GAAG,MAAM,KAAK,CAAA;AACrB,OAAO,IAAI,MAAM,MAAM,CAAA;AAEvB,OAAO,EAAE,KAAK,IAAI,SAAS,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAapD,KAAK,UAAU,gBAAgB;IAC7B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,MAAM,GAAG,GAAG,CAAC,YAAY,EAAE,CAAA;QACjC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE;YACjC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,EAAE,CAAA;YAChC,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAC3C,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;gBACzB,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;YACnC,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC,CAAC,CAAA;YACjF,CAAC;QACH,CAAC,CAAC,CAAA;QACF,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;IAC5B,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,KAAK,UAAU,WAAW,CAAC,IAAY,EAAE,SAAS,GAAG,KAAK;IACxD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;IAC5B,IAAI,KAAK,GAAG,EAAE,CAAA;IACd,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE,CAAC;QAC1C,IAAI,CAAC;YACH,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBAC1C,MAAM,MAAM,GAAG,GAAG,CAAC,gBAAgB,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAA;gBAChE,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;oBACxB,MAAM,CAAC,OAAO,EAAE,CAAA;oBAChB,OAAO,EAAE,CAAA;gBACX,CAAC,CAAC,CAAA;gBACF,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;gBAC1B,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE;oBAC3B,MAAM,CAAC,OAAO,EAAE,CAAA;oBAChB,MAAM,CAAC,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAA;gBACzC,CAAC,CAAC,CAAA;YACJ,CAAC,CAAC,CAAA;YACF,OAAM;QACR,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAA;YAC1D,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,GAAG,EAAE,GAAG,CAAC,CAAA;QACpC,CAAC;IACH,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,sBAAsB,CAAC,CAAA;AACzE,CAAC;AAED,MAAM,OAAO,cAAc;IACzB,SAAS,CAAY;IACrB,mBAAmB,CAAsB;IACzC,QAAQ,CAAS;IACjB,UAAU,CAAa;IACvB,aAAa,CAAS;IACtB,eAAe,CAAW;IAC1B,UAAU,CAA0B;IAEpC,YAAY,OAA+B,EAAE,UAAqC;QAChF,OAAO,KAAK,EAAE,CAAA;QACd,IAAI,CAAC,UAAU,GAAG,UAAU,IAAI,EAAE,CAAA;QAElC,uBAAuB;QACvB,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,IAAI,IAAI,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;QAE7G,YAAY;QACZ,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAA;QAEhC,cAAc;QACd,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAA;QAEpC,OAAO;QACP,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,IAAI,CAAA;QAEjC,mBAAmB;QACnB,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAA;IAChD,CAAC;IAED,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,6BAA6B,CAAC,CAAA;QAE3D,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,IAAI,CAAC,CAAA;QAEzC,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5D,yDAAyD;YACzD,IAAI,CAAC,SAAS,GAAG,MAAM,yBAAyB,CAAC;gBAC/C,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,YAAY,EAAE,IAAI,CAAC,mBAAmB,CAAC,OAAO;gBAC9C,IAAI,EAAE,SAAS;gBACf,eAAe,EAAE,IAAI,CAAC,eAAe;aACtC,CAAC,CAAA;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,SAAS,GAAG,MAAM,cAAc,CAAC;gBACpC,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,YAAY,EAAE,IAAI,CAAC,mBAAmB,CAAC,OAAO;gBAC9C,IAAI,EAAE,SAAS;aAChB,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,mCAAmC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAA;IACxF,CAAC;IAED,IAAI,IAAI;QACN,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAA;QACzD,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAA;IAC5B,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAA;IACzC,CAAC;IAED,KAAK,CAAC,IAAI;QACR,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,6BAA6B,CAAC,CAAA;YAE3D,sEAAsE;YACtE,6EAA6E;YAC7E,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAA;YAE3B,0DAA0D;YAC1D,qEAAqE;YACrE,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAA;YAEzD,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,yBAAyB,CAAC,CAAA;QACzD,CAAC;IACH,CAAC;CACF;AAUD,SAAS,kBAAkB;IACzB,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IAC9C,qFAAqF;IACrF,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAA;IAC5D,2EAA2E;IAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAA;IACzD,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAA;IAC5E,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;IACzB,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAA;IACtD,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,IAAI,IAAI,EAAE,EAAE,sBAAsB,GAAG,EAAE,CAAC,CAAA;AACrF,CAAC;AAED,KAAK,UAAU,yBAAyB,CAAC,OAAyC;IAChF,MAAM,UAAU,GAAG,kBAAkB,EAAE,CAAA;IAEvC,IAAI,IAAY,CAAA;IAChB,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;QACrD,IAAI,GAAG,MAAM,gBAAgB,EAAE,CAAA;IACjC,CAAC;SAAM,CAAC;QACN,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;IACrB,CAAC;IAED,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,QAAQ,CAAA;IACjD,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,IAAI,aAAa,CAAA;IAE1D,MAAM,IAAI,GAAG,CAAC,WAAW,CAAC,CAAA;IAE1B,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC7B,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAA;IACpC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;IACjC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,CAAA;IAEtC,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;QAC9C,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IACjC,CAAC;IAED,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,EAAE,IAAI,EAAE;QACnC,KAAK,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC;QACvC,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAA;IAEF,MAAM,KAAK,GAAG,IAAI,SAAS,CAAC,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;IAC1F,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;IAEtB,IAAI,MAAM,GAAG,KAAK,CAAA;IAClB,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;QACvB,MAAM,GAAG,IAAI,CAAA;QACb,IAAI,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChC,OAAO,CAAC,KAAK,CAAC,wCAAwC,IAAI,EAAE,CAAC,CAAA;QAC/D,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC;QACH,MAAM,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAChC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAA;QACtE,CAAC;QACD,MAAM,GAAG,CAAA;IACX,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,OAA8B,EAC9B,UAAoC,EACpC,EAA4C;IAE5C,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;IACrD,MAAM,KAAK,CAAC,KAAK,EAAE,CAAA;IACnB,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,KAAK,CAAC,CAAA;IACjB,CAAC;YAAS,CAAC;QACT,MAAM,KAAK,CAAC,IAAI,EAAE,CAAA;IACpB,CAAC;AACH,CAAC"}

package/build/throttling.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Transform, TransformCallback } from 'stream';
+export declare class ThrottlingLog {
+    ms: number;
+    bytes: number;
+}
+export declare class Throttle {
+    flushIntervalMs: number;
+    limitBytes: number;
+    currentBytes: number;
+    interval?: ReturnType<typeof setInterval>;
+    logs: ThrottlingLog[];
+    constructor(limitBytes: number, flushIntervalMs?: number);
+    static fromMbps(mbps: number, flushIntervalMs?: number): Throttle;
+    computeCapacity(): {
+        consumed: number;
+        carryover: number;
+    };
+    start(): void;
+    stop(): void;
+    checkAndStack(bytes: number): boolean;
+    simpleReport(unitMs?: number): {
+        maxBytesPerUnit: number;
+        avgBytesPerUnit: number;
+    };
+}
+export declare class ThrottlingTransform extends Transform {
+    throttle: Throttle;
+    retryIntervalMs: number;
+    constructor(throttle: Throttle, retryIntervalMs: number);
+    _transform(chunk: string | Buffer, _: string, done: TransformCallback): void;
+}

package/build/throttling.js

@@ -0,0 +1,89 @@
+import { Transform } from 'stream';
+export class ThrottlingLog {
+    ms;
+    bytes;
+}
+export class Throttle {
+    flushIntervalMs;
+    limitBytes;
+    currentBytes = 0;
+    interval;
+    logs = [];
+    constructor(limitBytes, flushIntervalMs) {
+        this.limitBytes = limitBytes;
+        this.flushIntervalMs = flushIntervalMs ?? 100;
+    }
+    static fromMbps(mbps, flushIntervalMs) {
+        const bytesPerSec = (mbps * 1024 * 1024) / 8;
+        const limitBytes = Math.floor((bytesPerSec * flushIntervalMs) / 1000);
+        return new Throttle(limitBytes, flushIntervalMs);
+    }
+    computeCapacity() {
+        const consumed = Math.min(this.currentBytes, this.limitBytes);
+        const carryover = this.currentBytes - consumed;
+        return { consumed, carryover };
+    }
+    start() {
+        this.interval = setInterval(() => {
+            const c = this.computeCapacity();
+            this.logs.push({
+                ms: Date.now(),
+                bytes: c.consumed,
+            });
+            this.currentBytes = c.carryover;
+        }, this.flushIntervalMs);
+    }
+    stop() {
+        if (this.interval)
+            clearInterval(this.interval);
+    }
+    checkAndStack(bytes) {
+        if (!this.interval)
+            throw new Error('Throttle is not started');
+        if (this.currentBytes >= this.limitBytes) {
+            return false;
+        }
+        this.currentBytes += bytes;
+        return true;
+    }
+    simpleReport(unitMs = 1000) {
+        const bySec = new Map();
+        for (const log of this.logs) {
+            const unit = Math.floor(log.ms / unitMs);
+            if (!bySec.has(unit))
+                bySec.set(unit, 0);
+            bySec.set(unit, bySec.get(unit) + log.bytes);
+        }
+        const values = Array.from(bySec.values());
+        const maxBytesPerUnit = Math.max(...values);
+        const avgBytesPerUnit = Math.floor(values.reduce((a, b) => a + b, 0) / bySec.size) / 1024 / 1024;
+        return {
+            maxBytesPerUnit,
+            avgBytesPerUnit,
+        };
+    }
+}
+export class ThrottlingTransform extends Transform {
+    throttle;
+    retryIntervalMs;
+    constructor(throttle, retryIntervalMs) {
+        super();
+        this.throttle = throttle;
+        this.retryIntervalMs = retryIntervalMs;
+    }
+    _transform(chunk, _, done) {
+        if (this.throttle.checkAndStack(chunk.length)) {
+            this.push(chunk);
+            done();
+            return;
+        }
+        const interval = setInterval(() => {
+            if (this.throttle.checkAndStack(chunk.length)) {
+                clearInterval(interval);
+                this.push(chunk);
+                done();
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhyb3R0bGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy90aHJvdHRsaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQXFCLE1BQU0sUUFBUSxDQUFBO0FBRXJELE1BQU0sT0FBTyxhQUFhO0lBQ3hCLEVBQUUsQ0FBUTtJQUNWLEtBQUssQ0FBUTtDQUNkO0FBRUQsTUFBTSxPQUFPLFFBQVE7SUFDbkIsZUFBZSxDQUFTO0lBQ3hCLFVBQVUsQ0FBUztJQUNuQixZQUFZLEdBQUcsQ0FBQyxDQUFBO0lBQ2hCLFFBQVEsQ0FBaUM7SUFDekMsSUFBSSxHQUFvQixFQUFFLENBQUE7SUFFMUIsWUFBWSxVQUFrQixFQUFFLGVBQXdCO1FBQ3RELElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFBO1FBQzVCLElBQUksQ0FBQyxlQUFlLEdBQUcsZUFBZSxJQUFJLEdBQUcsQ0FBQTtJQUMvQyxDQUFDO0lBRUQsTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFZLEVBQUUsZUFBd0I7UUFDcEQsTUFBTSxXQUFXLEdBQUcsQ0FBQyxJQUFJLEdBQUcsSUFBSSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUM1QyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsV0FBVyxHQUFHLGVBQWUsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFBO1FBQ3JFLE9BQU8sSUFBSSxRQUFRLENBQUMsVUFBVSxFQUFFLGVBQWUsQ0FBQyxDQUFBO0lBQ2xELENBQUM7SUFFRCxlQUFlO1FBQ2IsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQTtRQUM3RCxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsWUFBWSxHQUFHLFFBQVEsQ0FBQTtRQUM5QyxPQUFPLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxDQUFBO0lBQ2hDLENBQUM7SUFFRCxLQUFLO1FBQ0gsSUFBSSxDQUFDLFFBQVEsR0FBRyxXQUFXLENBQUMsR0FBRyxFQUFFO1lBQy9CLE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQTtZQUNoQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztnQkFDYixFQUFFLEVBQUUsSUFBSSxDQUFDLEdBQUcsRUFBRTtnQkFDZCxLQUFLLEVBQUUsQ0FBQyxDQUFDLFFBQVE7YUFDbEIsQ0FBQyxDQUFBO1lBQ0YsSUFBSSxDQUFDLFlBQVksR0FBRyxDQUFDLENBQUMsU0FBUyxDQUFBO1FBQ2pDLENBQUMsRUFBRSxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUE7SUFDMUIsQ0FBQztJQUVELElBQUk7UUFDRixJQUFJLElBQUksQ0FBQyxRQUFRO1lBQUUsYUFBYSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUNqRCxDQUFDO0lBRUQsYUFBYSxDQUFDLEtBQWE7UUFDekIsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRO1lBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyx5QkFBeUIsQ0FBQyxDQUFBO1FBQzlELElBQUksSUFBSSxDQUFDLFlBQVksSUFBSSxJQUFJLENBQUMsVUFBVSxFQUFFO1lBQ3hDLE9BQU8sS0FBSyxDQUFBO1NBQ2I7UUFDRCxJQUFJLENBQUMsWUFBWSxJQUFJLEtBQUssQ0FBQTtRQUMxQixPQUFPLElBQUksQ0FBQTtJQUNiLENBQUM7SUFFRCxZQUFZLENBQUMsTUFBTSxHQUFHLElBQUk7UUFDeEIsTUFBTSxLQUFLLEdBQXdCLElBQUksR0FBRyxFQUFFLENBQUE7UUFDNUMsS0FBSyxNQUFNLEdBQUcsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFO1lBQzNCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUUsR0FBRyxNQUFNLENBQUMsQ0FBQTtZQUN4QyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUM7Z0JBQUUsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUE7WUFDeEMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUE7U0FDN0M7UUFFRCxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFBO1FBQ3pDLE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQTtRQUMzQyxNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLEdBQUcsSUFBSSxDQUFBO1FBRWhHLE9BQU87WUFDTCxlQUFlO1lBQ2YsZUFBZTtTQUNoQixDQUFBO0lBQ0gsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLG1CQUFvQixTQUFRLFNBQVM7SUFDaEQsUUFBUSxDQUFXO0lBQ25CLGVBQWUsQ0FBUztJQUV4QixZQUFZLFFBQWtCLEVBQUUsZUFBdUI7UUFDckQsS0FBSyxFQUFFLENBQUE7UUFDUCxJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQTtRQUN4QixJQUFJLENBQUMsZUFBZSxHQUFHLGVBQWUsQ0FBQTtJQUN4QyxDQUFDO0lBRUQsVUFBVSxDQUFDLEtBQXNCLEVBQUUsQ0FBUyxFQUFFLElBQXVCO1FBQ25FLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQzdDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7WUFDaEIsSUFBSSxFQUFFLENBQUE7WUFDTixPQUFNO1NBQ1A7UUFFRCxNQUFNLFFBQVEsR0FBRyxXQUFXLENBQUMsR0FBRyxFQUFFO1lBQ2hDLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxFQUFFO2dCQUM3QyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUE7Z0JBQ3ZCLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7Z0JBQ2hCLElBQUksRUFBRSxDQUFBO2FBQ1A7UUFDSCxDQUFDLENBQUMsQ0FBQTtJQUNKLENBQUM7Q0FDRiJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pagespeed-quest",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "description": "A framework for efficient web front-end speed improvement",
   "main": "build/index.js",
@@ -50,21 +50,21 @@
     "postinstall": "node scripts/postinstall.js"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "dependencies": {
     "commander": "^11.1.0",
     "execa": "^9.3.1",
     "iconv-lite": "^0.6.3",
     "jschardet": "^3.0.0",
-    "lighthouse": "^12.2.1",
+    "lighthouse": "^13.0.3",
     "node-html-to-image": "^5.0.0",
     "node-watch": "^0.7.4",
     "pino": "^9.4.0",
     "pino-pretty": "^11.2.2",
     "prettier": "^2.1.1",
     "puppeteer": "^24.31.0",
-    "rust-http-playback-proxy": "^0.7.1",
+    "rust-http-playback-proxy": "0.9.0",
     "tmp-promise": "^3.0.3"
   },
   "devDependencies": {

package/scripts/postinstall.js

@@ -10,7 +10,7 @@ import { dirname, join } from 'path'
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
-const LOADSHOW_VERSION = 'v1.4.0'
+const LOADSHOW_VERSION = 'v1.5.0'
 const LOADSHOW_REPO = 'ideamans/go-loadshow'
 
 const WEBSHOT_VERSION = 'v0.2.1'