recker 1.0.2-0 → 1.0.3

package/dist/plugins/grpc-web.d.ts

@@ -0,0 +1,80 @@
+import type { Client } from '../core/client.js';
+export interface GrpcWebOptions {
+    baseUrl: string;
+    metadata?: Record<string, string>;
+    timeout?: number;
+    textFormat?: boolean;
+}
+export interface GrpcMetadata {
+    [key: string]: string;
+}
+export interface GrpcCallOptions {
+    metadata?: GrpcMetadata;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+export interface GrpcStatus {
+    code: number;
+    message: string;
+    details?: unknown;
+}
+export interface GrpcResponse<T> {
+    message: T;
+    metadata: GrpcMetadata;
+    status: GrpcStatus;
+}
+export interface UnaryCall<TRequest, TResponse> {
+    (request: TRequest, options?: GrpcCallOptions): Promise<GrpcResponse<TResponse>>;
+}
+export interface ServerStreamCall<TRequest, TResponse> {
+    (request: TRequest, options?: GrpcCallOptions): AsyncGenerator<TResponse, void, unknown>;
+}
+export declare const GrpcStatusCode: {
+    readonly OK: 0;
+    readonly CANCELLED: 1;
+    readonly UNKNOWN: 2;
+    readonly INVALID_ARGUMENT: 3;
+    readonly DEADLINE_EXCEEDED: 4;
+    readonly NOT_FOUND: 5;
+    readonly ALREADY_EXISTS: 6;
+    readonly PERMISSION_DENIED: 7;
+    readonly RESOURCE_EXHAUSTED: 8;
+    readonly FAILED_PRECONDITION: 9;
+    readonly ABORTED: 10;
+    readonly OUT_OF_RANGE: 11;
+    readonly UNIMPLEMENTED: 12;
+    readonly INTERNAL: 13;
+    readonly UNAVAILABLE: 14;
+    readonly DATA_LOSS: 15;
+    readonly UNAUTHENTICATED: 16;
+};
+export type GrpcStatusCodeType = typeof GrpcStatusCode[keyof typeof GrpcStatusCode];
+export declare class GrpcError extends Error {
+    readonly code: GrpcStatusCodeType;
+    readonly metadata: GrpcMetadata;
+    readonly details?: unknown;
+    constructor(status: GrpcStatus, metadata?: GrpcMetadata);
+    static fromCode(code: GrpcStatusCodeType, message: string): GrpcError;
+}
+export interface MessageCodec<T> {
+    encode(message: T): Uint8Array;
+    decode(data: Uint8Array): T;
+}
+export declare function jsonCodec<T>(): MessageCodec<T>;
+export declare class GrpcWebClient {
+    private client;
+    private options;
+    constructor(client: Client, options: GrpcWebOptions);
+    unary<TRequest, TResponse>(service: string, method: string, request: TRequest, codec: MessageCodec<TRequest> & MessageCodec<TResponse>, options?: GrpcCallOptions): Promise<GrpcResponse<TResponse>>;
+    serverStream<TRequest, TResponse>(service: string, method: string, request: TRequest, codec: MessageCodec<TRequest> & MessageCodec<TResponse>, options?: GrpcCallOptions): AsyncGenerator<TResponse, void, unknown>;
+    service<T extends Record<string, unknown>>(serviceName: string, methods: T): T;
+    private parseUnaryResponse;
+}
+export declare function createGrpcWebClient(client: Client, options: GrpcWebOptions): GrpcWebClient;
+export declare function grpcWeb(): (client: Client) => void;
+declare module '../core/client.js' {
+    interface Client {
+        grpcWeb(options?: Partial<GrpcWebOptions>): GrpcWebClient;
+    }
+}
+//# sourceMappingURL=grpc-web.d.ts.map

package/dist/plugins/grpc-web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc-web.d.ts","sourceRoot":"","sources":["../../src/plugins/grpc-web.ts"],"names":[],"mappings":"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"}

package/dist/plugins/grpc-web.js

@@ -0,0 +1,261 @@
+export const GrpcStatusCode = {
+    OK: 0,
+    CANCELLED: 1,
+    UNKNOWN: 2,
+    INVALID_ARGUMENT: 3,
+    DEADLINE_EXCEEDED: 4,
+    NOT_FOUND: 5,
+    ALREADY_EXISTS: 6,
+    PERMISSION_DENIED: 7,
+    RESOURCE_EXHAUSTED: 8,
+    FAILED_PRECONDITION: 9,
+    ABORTED: 10,
+    OUT_OF_RANGE: 11,
+    UNIMPLEMENTED: 12,
+    INTERNAL: 13,
+    UNAVAILABLE: 14,
+    DATA_LOSS: 15,
+    UNAUTHENTICATED: 16,
+};
+export class GrpcError extends Error {
+    code;
+    metadata;
+    details;
+    constructor(status, metadata = {}) {
+        super(status.message);
+        this.name = 'GrpcError';
+        this.code = status.code;
+        this.metadata = metadata;
+        this.details = status.details;
+    }
+    static fromCode(code, message) {
+        return new GrpcError({ code, message }, {});
+    }
+}
+export function jsonCodec() {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        encode(message) {
+            return encoder.encode(JSON.stringify(message));
+        },
+        decode(data) {
+            return JSON.parse(decoder.decode(data));
+        },
+    };
+}
+function encodeGrpcFrame(data, isTrailers = false) {
+    const frame = new Uint8Array(5 + data.length);
+    frame[0] = isTrailers ? 128 : 0;
+    const view = new DataView(frame.buffer);
+    view.setUint32(1, data.length, false);
+    frame.set(data, 5);
+    return frame;
+}
+function decodeGrpcFrames(data) {
+    const frames = [];
+    let offset = 0;
+    while (offset < data.length) {
+        if (offset + 5 > data.length)
+            break;
+        const flags = data[offset];
+        const isTrailers = (flags & 128) !== 0;
+        const view = new DataView(data.buffer, data.byteOffset + offset + 1, 4);
+        const length = view.getUint32(0, false);
+        if (offset + 5 + length > data.length)
+            break;
+        const payload = data.slice(offset + 5, offset + 5 + length);
+        frames.push({ isTrailers, payload });
+        offset += 5 + length;
+    }
+    return frames;
+}
+function parseTrailers(data) {
+    const decoder = new TextDecoder();
+    const text = decoder.decode(data);
+    const metadata = {};
+    for (const line of text.split('\r\n')) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.slice(0, colonIndex).trim().toLowerCase();
+            const value = line.slice(colonIndex + 1).trim();
+            metadata[key] = value;
+        }
+    }
+    return metadata;
+}
+export class GrpcWebClient {
+    client;
+    options;
+    constructor(client, options) {
+        this.client = client;
+        this.options = {
+            baseUrl: options.baseUrl,
+            metadata: options.metadata ?? {},
+            timeout: options.timeout ?? 30000,
+            textFormat: options.textFormat ?? true,
+        };
+    }
+    async unary(service, method, request, codec, options) {
+        const url = `${this.options.baseUrl}/${service}/${method}`;
+        const encoded = codec.encode(request);
+        const frame = encodeGrpcFrame(encoded);
+        const contentType = this.options.textFormat
+            ? 'application/grpc-web-text'
+            : 'application/grpc-web+proto';
+        const body = this.options.textFormat
+            ? btoa(String.fromCharCode(...frame))
+            : frame;
+        const headers = {
+            'Content-Type': contentType,
+            'Accept': contentType,
+            'X-Grpc-Web': '1',
+            ...this.options.metadata,
+            ...options?.metadata,
+        };
+        const requestOptions = {
+            headers,
+            timeout: options?.timeout ?? this.options.timeout,
+            signal: options?.signal,
+        };
+        const response = await this.client.post(url, body, requestOptions);
+        return this.parseUnaryResponse(response, codec);
+    }
+    async *serverStream(service, method, request, codec, options) {
+        const url = `${this.options.baseUrl}/${service}/${method}`;
+        const encoded = codec.encode(request);
+        const frame = encodeGrpcFrame(encoded);
+        const contentType = this.options.textFormat
+            ? 'application/grpc-web-text'
+            : 'application/grpc-web+proto';
+        const body = this.options.textFormat
+            ? btoa(String.fromCharCode(...frame))
+            : frame;
+        const headers = {
+            'Content-Type': contentType,
+            'Accept': contentType,
+            'X-Grpc-Web': '1',
+            ...this.options.metadata,
+            ...options?.metadata,
+        };
+        const response = await this.client.post(url, body, {
+            headers,
+            timeout: options?.timeout ?? this.options.timeout,
+            signal: options?.signal,
+        });
+        const stream = response.read();
+        if (!stream) {
+            throw new GrpcError({ code: GrpcStatusCode.INTERNAL, message: 'No response body' }, {});
+        }
+        const reader = stream.getReader();
+        let buffer = new Uint8Array(0);
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (value) {
+                    let chunk = value;
+                    if (this.options.textFormat) {
+                        const text = new TextDecoder().decode(value);
+                        const decoded = atob(text);
+                        chunk = new Uint8Array(decoded.length);
+                        for (let i = 0; i < decoded.length; i++) {
+                            chunk[i] = decoded.charCodeAt(i);
+                        }
+                    }
+                    const newBuffer = new Uint8Array(buffer.length + chunk.length);
+                    newBuffer.set(buffer);
+                    newBuffer.set(chunk, buffer.length);
+                    buffer = newBuffer;
+                    const frames = decodeGrpcFrames(buffer);
+                    let consumedBytes = 0;
+                    for (const frame of frames) {
+                        consumedBytes += 5 + frame.payload.length;
+                        if (frame.isTrailers) {
+                            const trailers = parseTrailers(frame.payload);
+                            const status = parseInt(trailers['grpc-status'] ?? '0', 10);
+                            const message = trailers['grpc-message'] ?? '';
+                            if (status !== GrpcStatusCode.OK) {
+                                throw new GrpcError({ code: status, message }, trailers);
+                            }
+                        }
+                        else {
+                            yield codec.decode(frame.payload);
+                        }
+                    }
+                    if (consumedBytes > 0) {
+                        buffer = buffer.slice(consumedBytes);
+                    }
+                }
+                if (done)
+                    break;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    service(serviceName, methods) {
+        const service = {};
+        for (const [methodName, _config] of Object.entries(methods)) {
+            service[methodName] = async (request, options) => {
+                const codec = jsonCodec();
+                return this.unary(serviceName, methodName, request, codec, options);
+            };
+        }
+        return service;
+    }
+    async parseUnaryResponse(response, codec) {
+        let data;
+        if (this.options.textFormat) {
+            const text = await response.text();
+            const decoded = atob(text);
+            data = new Uint8Array(decoded.length);
+            for (let i = 0; i < decoded.length; i++) {
+                data[i] = decoded.charCodeAt(i);
+            }
+        }
+        else {
+            const blob = await response.blob();
+            data = new Uint8Array(await blob.arrayBuffer());
+        }
+        const frames = decodeGrpcFrames(data);
+        let message;
+        let metadata = {};
+        let status = { code: GrpcStatusCode.OK, message: '' };
+        for (const frame of frames) {
+            if (frame.isTrailers) {
+                metadata = parseTrailers(frame.payload);
+                status = {
+                    code: parseInt(metadata['grpc-status'] ?? '0', 10),
+                    message: metadata['grpc-message'] ?? '',
+                };
+            }
+            else {
+                message = codec.decode(frame.payload);
+            }
+        }
+        const headerStatus = response.headers.get('grpc-status');
+        if (headerStatus) {
+            status.code = parseInt(headerStatus, 10);
+            status.message = response.headers.get('grpc-message') ?? '';
+        }
+        if (status.code !== GrpcStatusCode.OK) {
+            throw new GrpcError(status, metadata);
+        }
+        if (message === undefined) {
+            throw new GrpcError({ code: GrpcStatusCode.INTERNAL, message: 'No message in response' }, metadata);
+        }
+        return { message, metadata, status };
+    }
+}
+export function createGrpcWebClient(client, options) {
+    return new GrpcWebClient(client, options);
+}
+export function grpcWeb() {
+    return (client) => {
+        client.grpcWeb = (options) => {
+            const baseUrl = options?.baseUrl ?? client.config?.baseUrl ?? '';
+            return createGrpcWebClient(client, { baseUrl, ...options });
+        };
+    };
+}

package/dist/plugins/har-player.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"har-player.d.ts","sourceRoot":"","sources":["../../src/plugins/har-player.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA6C,MAAM,mBAAmB,CAAC;AAItF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAgBD,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAqE3D"}
+{"version":3,"file":"har-player.d.ts","sourceRoot":"","sources":["../../src/plugins/har-player.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA6C,MAAM,mBAAmB,CAAC;AAKtF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAgBD,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAuF3D"}

package/dist/plugins/har-player.js

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { HttpResponse } from '../core/response.js';
+import { ReckerError } from '../core/errors.js';
 export function harPlayer(options) {
     let entries = [];
     try {
@@ -8,7 +9,11 @@ export function harPlayer(options) {
         entries = har.log.entries;
     }
     catch (err) {
-        console.warn(`[Recker] Failed to load HAR file: ${options.path}`, err);
+        throw new ReckerError(`Failed to load HAR file: ${options.path}`, undefined, undefined, [
+            'Ensure the HAR file exists at the specified path.',
+            'Check that the file is valid JSON.',
+            'Verify the HAR file has the correct structure (log.entries).'
+        ]);
     }
     const matchEntry = (req, entry) => {
         if (req.method !== entry.request.method)
@@ -43,7 +48,11 @@ export function harPlayer(options) {
             return new HttpResponse(nativeRes);
         }
         if (options.strict) {
-            throw new Error(`[Recker HAR Player] No matching recording found for ${req.method} ${req.url}`);
+            throw new ReckerError(`[Recker HAR Player] No matching recording found for ${req.method} ${req.url}`, req, undefined, [
+                'Ensure the HAR file contains an entry for this URL/method.',
+                'Normalize query parameters or body to match the recorded request.',
+                'Regenerate the HAR with the exact same request.'
+            ]);
         }
         return next(req);
     };

package/dist/plugins/hls.d.ts

@@ -0,0 +1,33 @@
+import { Client } from '../core/client.js';
+export interface Variant {
+    url: string;
+    bandwidth?: number;
+    resolution?: string;
+}
+export interface Segment {
+    url: string;
+    duration: number;
+    sequence: number;
+    key?: KeyInfo;
+}
+export interface KeyInfo {
+    method: string;
+    uri?: string;
+    iv?: string;
+}
+export interface HlsHooks {
+    onManifest?: (manifest: string, url: string) => string | void;
+    onVariantSelected?: (variants: Variant[], defaultSelected: Variant) => Variant | void;
+    onSegment?: (segment: Segment) => Segment | void | null;
+    onKey?: (key: KeyInfo) => KeyInfo | void;
+}
+export interface HlsOptions extends HlsHooks {
+    concurrency?: number;
+    merge?: boolean;
+    live?: boolean;
+    duration?: number;
+    onInfo?: (message: string) => void;
+    onError?: (error: Error) => void;
+}
+export declare function downloadHls(client: Client, manifestUrl: string, outputPath: string, options?: HlsOptions): Promise<void>;
+//# sourceMappingURL=hls.d.ts.map

package/dist/plugins/hls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hls.d.ts","sourceRoot":"","sources":["../../src/plugins/hls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAK3C,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,QAAQ;IAEvB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAE9D,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,CAAC;IAEtF,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;IAExD,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,CAAC;CAC1C;AAED,MAAM,WAAW,UAAW,SAAQ,QAAQ;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAmHD,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,UAAe,iBA+JzB"}

package/dist/plugins/hls.js

@@ -0,0 +1,225 @@
+import { createWriteStream } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { mkdir, readdir, readFile, rm } from 'node:fs/promises';
+function parseM3u8(content, baseUrl) {
+    const lines = content.split('\n');
+    const segments = [];
+    let currentDuration = 0;
+    let mediaSequence = 0;
+    let targetDuration = 5;
+    let endList = false;
+    let currentKey;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        if (line.startsWith('#EXT-X-TARGETDURATION:')) {
+            targetDuration = parseFloat(line.split(':')[1]);
+        }
+        else if (line.startsWith('#EXT-X-MEDIA-SEQUENCE:')) {
+            mediaSequence = parseInt(line.split(':')[1], 10);
+        }
+        else if (line.startsWith('#EXT-X-ENDLIST')) {
+            endList = true;
+        }
+        else if (line.startsWith('#EXT-X-KEY:')) {
+            const attrs = line.substring(11);
+            const methodMatch = attrs.match(/METHOD=([^,]+)/);
+            const uriMatch = attrs.match(/URI="([^"]+)"/);
+            const ivMatch = attrs.match(/IV=([^,]+)/);
+            if (methodMatch) {
+                currentKey = {
+                    method: methodMatch[1],
+                    uri: uriMatch ? uriMatch[1] : undefined,
+                    iv: ivMatch ? ivMatch[1] : undefined
+                };
+            }
+        }
+        else if (line.startsWith('#EXTINF:')) {
+            const durationStr = line.substring(8).split(',', 1)[0];
+            currentDuration = parseFloat(durationStr);
+        }
+        else if (!line.startsWith('#')) {
+            let url = line;
+            if (!url.startsWith('http')) {
+                try {
+                    const base = new URL(baseUrl);
+                    const basePath = base.pathname.substring(0, base.pathname.lastIndexOf('/') + 1);
+                    url = new URL(url, base.origin + basePath).toString();
+                }
+                catch {
+                }
+            }
+            segments.push({
+                url,
+                duration: currentDuration,
+                sequence: 0,
+                key: currentKey
+            });
+        }
+    }
+    segments.forEach((seg, idx) => {
+        seg.sequence = mediaSequence + idx;
+    });
+    return { segments, targetDuration, endList, mediaSequence };
+}
+function parseVariants(content, baseUrl) {
+    const lines = content.split('\n');
+    const variants = [];
+    let currentBandwidth;
+    let currentResolution;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        if (line.startsWith('#EXT-X-STREAM-INF:')) {
+            const bwMatch = line.match(/BANDWIDTH=(\d+)/);
+            const resMatch = line.match(/RESOLUTION=(\d+x\d+)/);
+            if (bwMatch)
+                currentBandwidth = parseInt(bwMatch[1], 10);
+            if (resMatch)
+                currentResolution = resMatch[1];
+        }
+        else if (!line.startsWith('#')) {
+            let url = line;
+            if (!url.startsWith('http')) {
+                try {
+                    const base = new URL(baseUrl);
+                    const basePath = base.pathname.substring(0, base.pathname.lastIndexOf('/') + 1);
+                    url = new URL(url, base.origin + basePath).toString();
+                }
+                catch { }
+            }
+            variants.push({
+                url,
+                bandwidth: currentBandwidth,
+                resolution: currentResolution
+            });
+        }
+    }
+    return variants;
+}
+export async function downloadHls(client, manifestUrl, outputPath, options = {}) {
+    const merge = options.merge !== false;
+    const concurrency = options.concurrency || 5;
+    const isLive = options.live === true;
+    const maxDuration = options.duration || (isLive ? Infinity : 0);
+    const info = options.onInfo || (() => { });
+    const error = options.onError || ((err) => { throw err; });
+    const seenSegments = new Set();
+    const outputDir = merge ? dirname(outputPath) : outputPath;
+    await mkdir(outputDir, { recursive: true });
+    const tempDir = join(outputDir, `.tmp_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+    if (merge) {
+        await mkdir(tempDir, { recursive: true });
+    }
+    let currentManifestUrl = manifestUrl;
+    try {
+        let initialManifest = await client.get(currentManifestUrl).text();
+        if (options.onManifest) {
+            const modified = options.onManifest(initialManifest, currentManifestUrl);
+            if (typeof modified === 'string')
+                initialManifest = modified;
+        }
+        if (initialManifest.includes('#EXT-X-STREAM-INF')) {
+            const variants = parseVariants(initialManifest, currentManifestUrl);
+            if (variants.length > 0) {
+                let selected = variants[variants.length - 1];
+                if (options.onVariantSelected) {
+                    const userSelected = options.onVariantSelected(variants, selected);
+                    if (userSelected)
+                        selected = userSelected;
+                }
+                currentManifestUrl = selected.url;
+                info(`Master playlist detected. Switching to variant: ${currentManifestUrl}`);
+            }
+        }
+    }
+    catch (err) {
+        error(new Error(`Failed to fetch initial manifest: ${err}`));
+        return;
+    }
+    const { RequestRunner } = await import('../runner/request-runner.js');
+    const runner = new RequestRunner({ concurrency });
+    const startTime = Date.now();
+    let recording = true;
+    while (recording) {
+        try {
+            let content = await client.get(currentManifestUrl).text();
+            if (options.onManifest) {
+                const modified = options.onManifest(content, currentManifestUrl);
+                if (typeof modified === 'string')
+                    content = modified;
+            }
+            const playlist = parseM3u8(content, currentManifestUrl);
+            let newSegments = playlist.segments.filter(s => !seenSegments.has(s.url));
+            if (options.onSegment) {
+                const filtered = [];
+                for (const seg of newSegments) {
+                    if (seg.key && options.onKey) {
+                        const modifiedKey = options.onKey(seg.key);
+                        if (modifiedKey)
+                            seg.key = modifiedKey;
+                    }
+                    const res = options.onSegment(seg);
+                    if (res === null)
+                        continue;
+                    if (res)
+                        filtered.push(res);
+                    else
+                        filtered.push(seg);
+                }
+                newSegments = filtered;
+            }
+            if (newSegments.length > 0) {
+                info(`Found ${newSegments.length} new segments.`);
+                await runner.run(newSegments, async (seg) => {
+                    seenSegments.add(seg.url);
+                    const fileDest = merge
+                        ? join(tempDir, `${seg.sequence.toString().padStart(10, '0')}.ts`)
+                        : join(outputDir, `segment_${seg.sequence}.ts`);
+                    await client.get(seg.url).write(fileDest);
+                });
+            }
+            if (!isLive || playlist.endList) {
+                recording = false;
+                break;
+            }
+            if (maxDuration > 0 && (Date.now() - startTime) > maxDuration) {
+                info('Max duration reached. Stopping.');
+                recording = false;
+                break;
+            }
+            const waitTime = Math.max(1000, (playlist.targetDuration * 1000) / 2);
+            await new Promise(r => setTimeout(r, waitTime));
+        }
+        catch (err) {
+            if (isLive) {
+                info(`Error fetching live manifest, retrying: ${err.message}`);
+                const waitTime = 5000;
+                await new Promise(r => setTimeout(r, waitTime));
+            }
+            else {
+                error(new Error(`HLS download failed: ${err.message}`));
+                recording = false;
+            }
+        }
+    }
+    if (merge) {
+        info('Merging segments...');
+        const dest = createWriteStream(outputPath);
+        const files = (await readdir(tempDir)).sort();
+        for (const file of files) {
+            if (!file.endsWith('.ts'))
+                continue;
+            const chunk = await readFile(join(tempDir, file));
+            dest.write(chunk);
+        }
+        dest.end();
+        await rm(tempDir, { recursive: true, force: true });
+        info(`Saved to ${outputPath}`);
+    }
+    else {
+        info(`Download complete.`);
+    }
+}