zapo-js 0.1.0

package/dist/infra/perf/BoundedTaskQueue.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundedTaskQueue = exports.BoundedTaskQueueFullError = void 0;
+class BoundedTaskQueueFullError extends Error {
+    constructor(message = 'queue is full') {
+        super(message);
+        this.code = 'BOUNDED_TASK_QUEUE_FULL';
+        this.name = 'BoundedTaskQueueFullError';
+    }
+}
+exports.BoundedTaskQueueFullError = BoundedTaskQueueFullError;
+class BoundedTaskQueue {
+    constructor(maxQueueSize = 256, maxConcurrency = 1) {
+        if (maxQueueSize <= 0) {
+            throw new Error('maxQueueSize must be > 0');
+        }
+        if (maxConcurrency <= 0) {
+            throw new Error('maxConcurrency must be > 0');
+        }
+        this.maxQueueSize = maxQueueSize;
+        this.maxConcurrency = maxConcurrency;
+        this.queue = [];
+        this.head = 0;
+        this.running = 0;
+    }
+    enqueue(task) {
+        if (this.pending() >= this.maxQueueSize) {
+            return Promise.reject(new BoundedTaskQueueFullError());
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                task,
+                resolve: (value) => resolve(value),
+                reject
+            });
+            this.drain();
+        });
+    }
+    pending() {
+        return this.queue.length - this.head;
+    }
+    inFlight() {
+        return this.running;
+    }
+    drain() {
+        while (this.running < this.maxConcurrency && this.head < this.queue.length) {
+            const item = this.queue[this.head++];
+            this.running++;
+            item.task()
+                .then(item.resolve)
+                .catch(item.reject)
+                .finally(() => {
+                this.running--;
+                this.compactIfNeeded();
+                this.drain();
+            });
+        }
+    }
+    compactIfNeeded() {
+        if (this.head < 1024 || this.head * 2 < this.queue.length) {
+            return;
+        }
+        this.queue.splice(0, this.head);
+        this.head = 0;
+    }
+}
+exports.BoundedTaskQueue = BoundedTaskQueue;

package/dist/media/WaMediaCrypto.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaMediaCrypto = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_events_1 = require("node:events");
+const node_stream_1 = require("node:stream");
+const hkdf_1 = require("../crypto/core/hkdf");
+const primitives_1 = require("../crypto/core/primitives");
+const random_1 = require("../crypto/core/random");
+const constants_1 = require("./constants");
+const constants_2 = require("../protocol/constants");
+const bytes_1 = require("../util/bytes");
+const primitives_2 = require("../util/primitives");
+class WaMediaCrypto {
+    static async generateMediaKey() {
+        return (0, random_1.randomBytesAsync)(32);
+    }
+    static async deriveKeys(mediaType, mediaKey) {
+        if (mediaKey.byteLength !== 32) {
+            throw new Error(`invalid media key length ${mediaKey.byteLength}, expected 32`);
+        }
+        const info = mediaTypeToHkdfInfo(mediaType);
+        const expanded = await (0, hkdf_1.hkdf)(mediaKey, null, info, constants_1.MEDIA_HKDF_SIZE);
+        return {
+            iv: expanded.subarray(0, constants_1.IV_SIZE),
+            encKey: expanded.subarray(constants_1.ENC_KEY_START, constants_1.ENC_KEY_END),
+            macKey: expanded.subarray(constants_1.MAC_KEY_START, constants_1.MAC_KEY_END),
+            refKey: expanded.subarray(constants_1.MAC_KEY_END, constants_1.MEDIA_HKDF_SIZE)
+        };
+    }
+    static async encryptBytes(mediaType, mediaKey, plaintext) {
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const [aesKey, macKey] = await Promise.all([
+            (0, primitives_1.importAesCbcKey)(keys.encKey),
+            (0, primitives_1.importHmacKey)(keys.macKey)
+        ]);
+        const ciphertext = await (0, primitives_1.aesCbcEncrypt)(aesKey, keys.iv, plaintext);
+        const ivCiphertext = (0, bytes_1.concatBytes)([keys.iv, ciphertext]);
+        const mac = await (0, primitives_1.hmacSign)(macKey, ivCiphertext);
+        const signature = mac.subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+        const ciphertextHmac = (0, bytes_1.concatBytes)([ciphertext, signature]);
+        const [fileSha256, fileEncSha256] = await Promise.all([
+            (0, primitives_1.sha256)(plaintext),
+            (0, primitives_1.sha256)(ciphertextHmac)
+        ]);
+        return { ciphertextHmac, fileSha256, fileEncSha256 };
+    }
+    static async decryptBytes(mediaType, mediaKey, ciphertextHmac, expectedFileSha256, expectedFileEncSha256) {
+        if (ciphertextHmac.byteLength < constants_1.HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${ciphertextHmac.byteLength}`);
+        }
+        if (expectedFileEncSha256) {
+            const computedEncHash = await (0, primitives_1.sha256)(ciphertextHmac);
+            if (!(0, bytes_1.uint8Equal)(computedEncHash, expectedFileEncSha256)) {
+                throw new Error('encrypted file hash mismatch');
+            }
+        }
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const ciphertext = ciphertextHmac.subarray(0, ciphertextHmac.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
+        const expectedMac = ciphertextHmac.subarray(ciphertextHmac.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
+        const ivCiphertext = (0, bytes_1.concatBytes)([keys.iv, ciphertext]);
+        const [macKey, aesKey] = await Promise.all([
+            (0, primitives_1.importHmacKey)(keys.macKey),
+            (0, primitives_1.importAesCbcKey)(keys.encKey)
+        ]);
+        const mac = await (0, primitives_1.hmacSign)(macKey, ivCiphertext);
+        const signature = mac.subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+        if (!(0, bytes_1.uint8TimingSafeEqual)(signature, expectedMac)) {
+            throw new Error('media MAC mismatch');
+        }
+        const plaintext = await (0, primitives_1.aesCbcDecrypt)(aesKey, keys.iv, ciphertext);
+        const fileSha256 = await (0, primitives_1.sha256)(plaintext);
+        if (expectedFileSha256 && !(0, bytes_1.uint8Equal)(fileSha256, expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        const fileEncSha256 = expectedFileEncSha256 ?? (await (0, primitives_1.sha256)(ciphertextHmac));
+        return { plaintext, fileSha256, fileEncSha256 };
+    }
+    static async encryptReadable(mediaType, mediaKey, plaintext) {
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const encrypted = new node_stream_1.PassThrough();
+        const metadata = pumpEncryption(plaintext, encrypted, keys);
+        return { encrypted, metadata };
+    }
+    static async decryptReadableToBytes(encrypted, options) {
+        const decrypted = await WaMediaCrypto.decryptReadable(encrypted, options);
+        const [plaintext, metadata] = await Promise.all([
+            (0, bytes_1.readAllBytes)(decrypted.plaintext),
+            decrypted.metadata
+        ]);
+        return {
+            plaintext,
+            fileSha256: metadata.fileSha256,
+            fileEncSha256: metadata.fileEncSha256
+        };
+    }
+    static async decryptReadable(encrypted, options) {
+        const keys = await WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
+        const plaintext = new node_stream_1.PassThrough();
+        const metadata = pumpDecryption(encrypted, plaintext, keys, options);
+        return { plaintext, metadata };
+    }
+    static encryptedLength(plaintextLength) {
+        if (!Number.isFinite(plaintextLength) || plaintextLength < 0) {
+            throw new Error(`invalid plaintext length ${plaintextLength}`);
+        }
+        const paddedLength = Math.ceil((plaintextLength + 1) / 16) * 16;
+        return paddedLength + constants_1.HMAC_TRUNCATED_SIZE;
+    }
+}
+exports.WaMediaCrypto = WaMediaCrypto;
+async function pumpEncryption(plaintext, encrypted, keys) {
+    const plainHash = (0, node_crypto_1.createHash)('sha256');
+    const encHash = (0, node_crypto_1.createHash)('sha256');
+    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
+    const cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    hmac.update(keys.iv);
+    try {
+        for await (const chunk of plaintext) {
+            const plainChunk = (0, bytes_1.toChunkBytes)(chunk);
+            if (plainChunk.byteLength === 0) {
+                continue;
+            }
+            plainHash.update(plainChunk);
+            const encryptedChunk = cipher.update(plainChunk);
+            if (encryptedChunk.byteLength > 0) {
+                hmac.update(encryptedChunk);
+                encHash.update(encryptedChunk);
+                await writeChunk(encrypted, encryptedChunk);
+            }
+        }
+        const encryptedFinal = cipher.final();
+        if (encryptedFinal.byteLength > 0) {
+            hmac.update(encryptedFinal);
+            encHash.update(encryptedFinal);
+            await writeChunk(encrypted, encryptedFinal);
+        }
+        const signature = hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+        encHash.update(signature);
+        await writeChunk(encrypted, signature);
+        encrypted.end();
+        return {
+            fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
+            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest())
+        };
+    }
+    catch (error) {
+        const normalized = (0, primitives_2.toError)(error);
+        encrypted.destroy(normalized);
+        throw normalized;
+    }
+}
+async function pumpDecryption(encrypted, plaintext, keys, options) {
+    const plainHash = (0, node_crypto_1.createHash)('sha256');
+    const encHash = (0, node_crypto_1.createHash)('sha256');
+    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
+    const decipher = (0, node_crypto_1.createDecipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    hmac.update(keys.iv);
+    try {
+        let trailing = bytes_1.EMPTY_BYTES;
+        for await (const chunk of encrypted) {
+            const bytes = (0, bytes_1.toChunkBytes)(chunk);
+            if (bytes.byteLength === 0) {
+                continue;
+            }
+            encHash.update(bytes);
+            const merged = trailing.byteLength === 0 ? bytes : (0, bytes_1.concatBytes)([trailing, bytes]);
+            if (merged.byteLength <= constants_1.HMAC_TRUNCATED_SIZE) {
+                trailing = merged;
+                continue;
+            }
+            const ciphertextChunk = merged.subarray(0, merged.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
+            trailing = merged.subarray(merged.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
+            hmac.update(ciphertextChunk);
+            const plainChunk = decipher.update(ciphertextChunk);
+            if (plainChunk.byteLength > 0) {
+                plainHash.update(plainChunk);
+                await writeChunk(plaintext, plainChunk);
+            }
+        }
+        if (trailing.byteLength !== constants_1.HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${trailing.byteLength}`);
+        }
+        const signature = hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+        if (!(0, bytes_1.uint8TimingSafeEqual)(signature, trailing)) {
+            throw new Error('media MAC mismatch');
+        }
+        const plainFinal = decipher.final();
+        if (plainFinal.byteLength > 0) {
+            plainHash.update(plainFinal);
+            await writeChunk(plaintext, plainFinal);
+        }
+        const fileSha256 = (0, bytes_1.toBytesView)(plainHash.digest());
+        const fileEncSha256 = (0, bytes_1.toBytesView)(encHash.digest());
+        if (options.expectedFileEncSha256 &&
+            !(0, bytes_1.uint8Equal)(fileEncSha256, options.expectedFileEncSha256)) {
+            throw new Error('encrypted file hash mismatch');
+        }
+        if (options.expectedFileSha256 && !(0, bytes_1.uint8Equal)(fileSha256, options.expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        plaintext.end();
+        return { fileSha256, fileEncSha256 };
+    }
+    catch (error) {
+        const normalized = (0, primitives_2.toError)(error);
+        plaintext.destroy(normalized);
+        throw normalized;
+    }
+}
+function mediaTypeToHkdfInfo(mediaType) {
+    if (mediaType === 'ptv') {
+        return (0, constants_2.getWaMediaHkdfInfo)('video');
+    }
+    if (mediaType === 'history') {
+        return (0, constants_2.getWaMediaHkdfInfo)(constants_2.WA_APP_STATE_KEY_TYPES.MD_MSG_HIST);
+    }
+    return (0, constants_2.getWaMediaHkdfInfo)(mediaType);
+}
+async function writeChunk(stream, chunk) {
+    if (chunk.byteLength === 0) {
+        return;
+    }
+    if (stream.write(chunk)) {
+        return;
+    }
+    await (0, node_events_1.once)(stream, 'drain');
+}

package/dist/media/WaMediaTransferClient.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaMediaTransferClient = void 0;
+const node_stream_1 = require("node:stream");
+const constants_1 = require("./constants");
+const WaMediaCrypto_1 = require("./WaMediaCrypto");
+const constants_2 = require("../protocol/constants");
+const bytes_1 = require("../util/bytes");
+const primitives_1 = require("../util/primitives");
+class WaMediaTransferClient {
+    constructor(options = {}) {
+        this.logger = options.logger;
+        this.defaultHosts = options.defaultHosts ?? constants_1.DEFAULT_MEDIA_HOSTS;
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? constants_2.WA_DEFAULTS.MEDIA_TIMEOUT_MS;
+        this.defaultMaxReadBytes = options.defaultMaxReadBytes;
+        this.defaultHeaders = options.defaultHeaders ?? {};
+    }
+    async downloadStream(request) {
+        const { urls, headers, timeoutMs } = this.resolveTransferRequest(request);
+        this.logger?.debug('media download stream start', {
+            urls: urls.length,
+            timeoutMs
+        });
+        return this.executeTransfer(urls, timeoutMs, request.signal, {
+            responseLog: 'media download stream response',
+            send: (url, signal) => fetch(url, {
+                method: 'GET',
+                headers,
+                signal
+            })
+        });
+    }
+    async downloadBytes(request) {
+        const response = await this.downloadStream(request);
+        await this.assertSuccessfulResponse(response);
+        if (!response.body) {
+            return bytes_1.EMPTY_BYTES;
+        }
+        return this.readAllBytesWithLimit(response.body, request.maxBytes);
+    }
+    async uploadStream(request) {
+        const bodyIsBytes = request.body instanceof Uint8Array;
+        const { urls, headers, timeoutMs } = this.resolveTransferRequest(request, {
+            'content-type': request.contentType,
+            'content-length': request.contentLength !== null && request.contentLength !== undefined
+                ? String(request.contentLength)
+                : undefined
+        });
+        const uploadUrls = bodyIsBytes ? urls : urls.slice(0, 1);
+        if (!bodyIsBytes && urls.length > 1) {
+            this.logger?.warn('upload stream fallback disabled for non-replayable body', {
+                attemptedHosts: urls.length
+            });
+        }
+        const method = request.method ?? 'POST';
+        this.logger?.debug('media upload stream start', {
+            urls: uploadUrls.length,
+            timeoutMs,
+            method
+        });
+        return this.executeTransfer(uploadUrls, timeoutMs, request.signal, {
+            responseLog: 'media upload stream response',
+            send: async (url, signal) => {
+                if (bodyIsBytes) {
+                    return fetch(url, {
+                        method,
+                        headers,
+                        signal,
+                        body: request.body
+                    });
+                }
+                return fetch(url, {
+                    method,
+                    headers,
+                    signal,
+                    body: request.body,
+                    duplex: 'half'
+                });
+            }
+        });
+    }
+    async uploadEncrypted(request) {
+        this.logger?.info('media encrypted upload start', {
+            mediaType: request.mediaType
+        });
+        const mediaKey = request.mediaKey ?? (await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey());
+        const prepared = await this.prepareEncryptedUpload(request, mediaKey);
+        let transfer;
+        try {
+            transfer = await this.uploadStream({
+                url: request.url,
+                directPath: request.directPath,
+                hosts: request.hosts,
+                headers: request.headers,
+                timeoutMs: request.timeoutMs,
+                signal: request.signal,
+                method: request.method,
+                body: prepared.body,
+                contentLength: prepared.contentLength,
+                contentType: request.contentType
+            });
+        }
+        catch (error) {
+            await prepared.cleanup((0, primitives_1.toError)(error));
+            throw error;
+        }
+        const metadata = await prepared.metadata;
+        this.logger?.info('media encrypted upload completed', {
+            status: transfer.status
+        });
+        return {
+            transfer,
+            mediaKey,
+            fileSha256: metadata.fileSha256,
+            fileEncSha256: metadata.fileEncSha256
+        };
+    }
+    async downloadAndDecrypt(request) {
+        this.logger?.info('media encrypted download start', {
+            mediaType: request.mediaType
+        });
+        const decrypted = await this.downloadAndDecryptStream(request);
+        try {
+            const [plaintext] = await Promise.all([
+                this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes),
+                decrypted.metadata
+            ]);
+            this.logger?.info('media encrypted download completed', {
+                byteLength: plaintext.byteLength
+            });
+            return plaintext;
+        }
+        catch (error) {
+            decrypted.plaintext.destroy((0, primitives_1.toError)(error));
+            throw error;
+        }
+    }
+    async downloadAndDecryptStream(request) {
+        const response = await this.downloadStream(request);
+        await this.assertSuccessfulResponse(response);
+        const body = this.requireResponseBody(response);
+        const decrypted = await WaMediaCrypto_1.WaMediaCrypto.decryptReadable(body, {
+            mediaType: request.mediaType,
+            mediaKey: request.mediaKey,
+            expectedFileSha256: request.fileSha256,
+            expectedFileEncSha256: request.fileEncSha256
+        });
+        decrypted.metadata.catch(() => undefined);
+        this.logger?.debug('media encrypted download stream ready', {
+            mediaType: request.mediaType
+        });
+        return {
+            plaintext: decrypted.plaintext,
+            metadata: decrypted.metadata
+        };
+    }
+    async readResponseBytes(response, maxBytes) {
+        if (!response.body) {
+            return bytes_1.EMPTY_BYTES;
+        }
+        return this.readAllBytesWithLimit(response.body, maxBytes);
+    }
+    resolveTransferRequest(request, extraHeaders) {
+        const headers = this.mergeHeaders(request.headers);
+        for (const [key, value] of Object.entries(extraHeaders ?? {})) {
+            if (value !== undefined) {
+                headers[key.toLowerCase()] = value;
+            }
+        }
+        return {
+            urls: this.resolveUrls(request.url, request.directPath, request.hosts),
+            headers,
+            timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs
+        };
+    }
+    async executeTransfer(urls, timeoutMs, signal, options) {
+        const result = await this.fetchWithFallback(urls, timeoutMs, signal, options.send);
+        this.logger?.trace(options.responseLog, {
+            url: result.url,
+            status: result.response.status
+        });
+        return this.toResponse(result.url, result.response);
+    }
+    async prepareEncryptedUpload(request, mediaKey) {
+        if (request.plaintext instanceof Uint8Array) {
+            const encrypted = await WaMediaCrypto_1.WaMediaCrypto.encryptBytes(request.mediaType, mediaKey, request.plaintext);
+            return {
+                body: encrypted.ciphertextHmac,
+                contentLength: encrypted.ciphertextHmac.byteLength,
+                metadata: Promise.resolve({
+                    fileSha256: encrypted.fileSha256,
+                    fileEncSha256: encrypted.fileEncSha256
+                }),
+                cleanup: async () => undefined
+            };
+        }
+        const prepared = await WaMediaCrypto_1.WaMediaCrypto.encryptReadable(request.mediaType, mediaKey, request.plaintext);
+        return {
+            body: prepared.encrypted,
+            contentLength: request.contentLength !== null && request.contentLength !== undefined
+                ? WaMediaCrypto_1.WaMediaCrypto.encryptedLength(request.contentLength)
+                : undefined,
+            metadata: prepared.metadata,
+            cleanup: async (error) => {
+                prepared.encrypted.destroy(error);
+                await prepared.metadata.catch(() => undefined);
+            }
+        };
+    }
+    async assertSuccessfulResponse(response) {
+        if (response.ok) {
+            return;
+        }
+        await this.drainBody(response.body);
+        throw new Error(`download failed with status ${response.status} for ${response.url}`);
+    }
+    requireResponseBody(response) {
+        if (response.body) {
+            return response.body;
+        }
+        throw new Error(`download response body is empty for ${response.url}`);
+    }
+    resolveUrls(url, directPath, hosts) {
+        const resolved = [];
+        if (url) {
+            resolved.push(url);
+        }
+        if (directPath) {
+            if (directPath.startsWith('https://') || directPath.startsWith('http://')) {
+                resolved.push(directPath);
+            }
+            else {
+                const normalizedPath = directPath.startsWith('/') ? directPath : `/${directPath}`;
+                for (const host of hosts ?? this.defaultHosts) {
+                    resolved.push(`https://${host}${normalizedPath}`);
+                }
+            }
+        }
+        if (resolved.length === 0) {
+            throw new Error('missing transfer url/directPath');
+        }
+        return Array.from(new Set(resolved));
+    }
+    mergeHeaders(headers) {
+        const merged = {};
+        for (const [key, value] of Object.entries(this.defaultHeaders)) {
+            merged[key.toLowerCase()] = value;
+        }
+        for (const [key, value] of Object.entries(headers ?? {})) {
+            merged[key.toLowerCase()] = value;
+        }
+        return merged;
+    }
+    readAllBytesWithLimit(stream, maxBytes) {
+        return (0, bytes_1.readAllBytes)(stream, {
+            maxBytes: maxBytes ?? this.defaultMaxReadBytes
+        });
+    }
+    async fetchWithFallback(urls, timeoutMs, signal, send) {
+        let lastError = null;
+        for (let index = 0; index < urls.length; index += 1) {
+            const url = urls[index];
+            const abort = this.createAbortContext(timeoutMs, signal);
+            try {
+                const response = await send(url, abort.signal);
+                const shouldFallback = response.status >= 500 && index < urls.length - 1;
+                if (!shouldFallback) {
+                    return { url, response };
+                }
+                await this.cancelWebBody(response.body);
+                this.logger?.warn('transfer fallback to next host', {
+                    url,
+                    status: response.status
+                });
+            }
+            catch (error) {
+                const normalized = (0, primitives_1.toError)(error);
+                lastError = normalized;
+                if (abort.signal.aborted && signal?.aborted) {
+                    throw normalized;
+                }
+                if (index === urls.length - 1) {
+                    throw normalized;
+                }
+                this.logger?.warn('transfer host failed, trying next host', {
+                    url,
+                    message: normalized.message
+                });
+            }
+            finally {
+                abort.cleanup();
+            }
+        }
+        throw lastError ?? new Error('transfer failed');
+    }
+    createAbortContext(timeoutMs, externalSignal) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort(new Error(`transfer timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        let onExternalAbort = null;
+        if (externalSignal) {
+            onExternalAbort = () => controller.abort(externalSignal.reason);
+            if (externalSignal.aborted) {
+                onExternalAbort();
+            }
+            else {
+                externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+            }
+        }
+        return {
+            signal: controller.signal,
+            cleanup: () => {
+                clearTimeout(timer);
+                if (externalSignal && onExternalAbort) {
+                    externalSignal.removeEventListener('abort', onExternalAbort);
+                }
+            }
+        };
+    }
+    toResponse(url, response) {
+        return {
+            url,
+            status: response.status,
+            ok: response.ok,
+            headers: this.headersToRecord(response.headers),
+            body: response.body
+                ? node_stream_1.Readable.fromWeb(response.body)
+                : null
+        };
+    }
+    headersToRecord(headers) {
+        const output = {};
+        for (const [key, value] of headers.entries()) {
+            output[key] = value;
+        }
+        return output;
+    }
+    async cancelWebBody(body) {
+        if (!body) {
+            return;
+        }
+        try {
+            await body.cancel();
+        }
+        catch {
+            // ignore cancel errors from remote resets
+        }
+    }
+    async drainBody(body) {
+        if (!body) {
+            return;
+        }
+        try {
+            for await (const chunk of body) {
+                void chunk;
+            }
+        }
+        catch {
+            // ignore drain errors
+        }
+    }
+}
+exports.WaMediaTransferClient = WaMediaTransferClient;

package/dist/media/conn.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMediaConnResponse = parseMediaConnResponse;
+const constants_1 = require("../protocol/constants");
+const helpers_1 = require("../transport/node/helpers");
+const query_1 = require("../transport/node/query");
+function parseMediaConnResponse(node, nowMs) {
+    (0, query_1.assertIqResult)(node, 'media_conn');
+    const mediaConnNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.MEDIA_CONN);
+    if (!mediaConnNode) {
+        throw new Error('media_conn response is missing media_conn node');
+    }
+    const auth = mediaConnNode.attrs.auth;
+    if (!auth) {
+        throw new Error('media_conn response is missing auth');
+    }
+    const ttlRaw = Number.parseInt(mediaConnNode.attrs.ttl ?? '0', 10);
+    if (!Number.isFinite(ttlRaw) || ttlRaw <= 0) {
+        throw new Error('media_conn response has invalid ttl');
+    }
+    const expiresAtMs = ttlRaw >= 1000000000 ? ttlRaw * 1000 : nowMs + ttlRaw * 1000;
+    const hosts = (0, helpers_1.getNodeChildrenByTag)(mediaConnNode, constants_1.WA_NODE_TAGS.HOST)
+        .map((host) => ({
+        hostname: host.attrs.hostname ?? '',
+        isFallback: host.attrs.type === 'fallback'
+    }))
+        .filter((host) => host.hostname.length > 0);
+    if (hosts.length === 0) {
+        throw new Error('media_conn response contains no hosts');
+    }
+    return {
+        auth,
+        expiresAtMs,
+        hosts
+    };
+}