zapo-js 0.3.0 → 1.0.0

package/dist/esm/infra/log/PinoLogger.js

@@ -16,27 +16,53 @@ async function loadPinoFactory() {
         throw new Error('optional dependency "pino" is not installed. Install with: npm i pino');
     }
 }
+/**
+ * {@link Logger} adapter over a Pino-shaped logger instance. Construct it
+ * directly when you already have a configured Pino logger, or use
+ * {@link createPinoLogger} to build one with the optional `pino` /
+ * `pino-pretty` dependencies.
+ */
 export class PinoLogger {
+    /**
+     * @param logger Pino-compatible underlying logger.
+     * @param level  Minimum level to emit (also forwarded to `logger.level`).
+     */
     constructor(logger, level = 'info') {
         this.logger = logger;
         this.level = level;
         this.logger.level = level;
     }
+    /** Emits a `trace` record. */
     trace(message, context) {
         this.write('trace', message, context);
     }
+    /** Emits a `debug` record. */
     debug(message, context) {
         this.write('debug', message, context);
     }
+    /** Emits an `info` record. */
     info(message, context) {
         this.write('info', message, context);
     }
+    /** Emits a `warn` record. */
     warn(message, context) {
         this.write('warn', message, context);
     }
+    /** Emits an `error` record. */
     error(message, context) {
         this.write('error', message, context);
     }
+    /**
+     * Returns a derived logger that pre-binds `bindings` into every log
+     * call's context. Delegates to the underlying pino `child()` when
+     * available; otherwise wraps with a parent + bindings merge.
+     */
+    child(bindings) {
+        if (typeof this.logger.child === 'function') {
+            return new PinoLogger(this.logger.child(bindings), this.level);
+        }
+        return new BoundLogger(this, bindings);
+    }
     write(level, message, context) {
         if (context === null || context === undefined) {
             this.logger[level](message);
@@ -51,6 +77,44 @@ export class PinoLogger {
         this.logger[level](message);
     }
 }
+/**
+ * Fallback {@link Logger} that pre-binds context fields by merging them
+ * into every call before delegating to a parent logger. Used when the
+ * underlying logger does not support `child()` natively.
+ */
+class BoundLogger {
+    constructor(parent, bindings) {
+        this.parent = parent;
+        this.level = parent.level;
+        this.bindings = bindings;
+    }
+    trace(message, context) {
+        this.parent.trace(message, this.merge(context));
+    }
+    debug(message, context) {
+        this.parent.debug(message, this.merge(context));
+    }
+    info(message, context) {
+        this.parent.info(message, this.merge(context));
+    }
+    warn(message, context) {
+        this.parent.warn(message, this.merge(context));
+    }
+    error(message, context) {
+        this.parent.error(message, this.merge(context));
+    }
+    child(bindings) {
+        return new BoundLogger(this.parent, { ...this.bindings, ...bindings });
+    }
+    merge(context) {
+        return context ? { ...this.bindings, ...context } : this.bindings;
+    }
+}
+/**
+ * Dynamically loads `pino` (and optionally `pino-pretty` when `pretty` is set),
+ * configures it with the given options, and wraps it in a {@link PinoLogger}.
+ * Throws if the optional `pino` dependency is not installed.
+ */
 export async function createPinoLogger(options = {}) {
     const level = options.level ?? 'info';
     const pino = await loadPinoFactory();

package/dist/esm/infra/log/types.js

@@ -1,11 +1,13 @@
 function noop() { }
 export function createNoopLogger(level = 'trace') {
-    return {
+    const logger = {
         level,
         trace: noop,
         debug: noop,
         info: noop,
         warn: noop,
-        error: noop
+        error: noop,
+        child: () => logger
     };
+    return logger;
 }

package/dist/esm/infra/perf/BackgroundQueue.js

@@ -1,22 +1,20 @@
+import { resolvePositive } from '../../util/coercion.js';
 import { toError } from '../../util/primitives.js';
 const DEFAULT_MAX_PENDING_KEYS = 4096;
 const DEFAULT_FLUSH_TIMEOUT_MS = 5000;
+const DEFAULT_MAX_BATCH_SIZE = 250;
 const RETRY_BACKOFF_BASE_MS = 100;
 const RETRY_BACKOFF_MAX_MS = 2000;
 export class BackgroundQueue {
     constructor(writer, options = {}) {
         this.writer = writer;
         this.coalesce = options.coalesce ?? ((_p, i) => i);
-        const maxPendingKeys = options.maxPendingKeys ?? DEFAULT_MAX_PENDING_KEYS;
-        if (!Number.isSafeInteger(maxPendingKeys) || maxPendingKeys < 1) {
-            throw new Error('BackgroundQueue maxPendingKeys must be a positive integer');
-        }
-        this.maxPendingKeys = maxPendingKeys;
-        const maxWriteConcurrency = options.maxWriteConcurrency ?? 1;
-        if (!Number.isSafeInteger(maxWriteConcurrency) || maxWriteConcurrency < 1) {
-            throw new Error('BackgroundQueue maxWriteConcurrency must be a positive integer');
-        }
-        this.maxWriteConcurrency = maxWriteConcurrency;
+        this.maxPendingKeys = resolvePositive(options.maxPendingKeys, DEFAULT_MAX_PENDING_KEYS, 'maxPendingKeys');
+        this.maxWriteConcurrency = resolvePositive(options.maxWriteConcurrency, 1, 'maxWriteConcurrency');
+        this.batchWriter = options.batchWriter ?? null;
+        this.maxBatchSize = this.batchWriter
+            ? resolvePositive(options.maxBatchSize, DEFAULT_MAX_BATCH_SIZE, 'maxBatchSize')
+            : DEFAULT_MAX_BATCH_SIZE;
         const flushTimeoutMs = options.flushTimeoutMs ?? DEFAULT_FLUSH_TIMEOUT_MS;
         if (!Number.isFinite(flushTimeoutMs) || flushTimeoutMs < 1) {
             throw new Error('BackgroundQueue flushTimeoutMs must be a positive finite number');
@@ -227,7 +225,15 @@ export class BackgroundQueue {
     }
     async drainLoop() {
         while (true) {
-            const batch = this.takeBatch();
+            if (this.batchWriter) {
+                const batch = this.takeBatch(this.maxBatchSize);
+                if (batch.length === 0) {
+                    return;
+                }
+                await this.processBatch(batch);
+                continue;
+            }
+            const batch = this.takeBatch(this.maxWriteConcurrency);
             if (batch.length === 0) {
                 return;
             }
@@ -242,9 +248,9 @@ export class BackgroundQueue {
             await Promise.all(tasks);
         }
     }
-    takeBatch() {
+    takeBatch(limit) {
         const batch = [];
-        for (let i = 0; i < this.maxWriteConcurrency; i += 1) {
+        for (let i = 0; i < limit; i += 1) {
             const next = this.takeNext();
             if (!next) {
                 break;
@@ -253,6 +259,42 @@ export class BackgroundQueue {
         }
         return batch;
     }
+    async processBatch(batch) {
+        const batchWriter = this.batchWriter;
+        if (!batchWriter) {
+            throw new Error('processBatch called without batchWriter');
+        }
+        this.inFlight += batch.length;
+        const payload = new Array(batch.length);
+        for (let i = 0; i < batch.length; i += 1) {
+            payload[i] = { key: batch[i].key, value: batch[i].entry.value };
+        }
+        try {
+            await batchWriter(payload);
+            this.flushedCount += batch.length;
+            for (const item of batch) {
+                this.resolveEntry(item.entry);
+            }
+        }
+        catch (error) {
+            for (const item of batch) {
+                if (this.retryDisabled) {
+                    this.discardEntry(item.key, item.entry);
+                }
+                else {
+                    const merged = this.mergeForRetry(item.key, item.entry);
+                    const attempt = merged.attempt + 1;
+                    merged.attempt = attempt;
+                    this.invokeOnError(item.key, error, attempt);
+                    this.scheduleRetry(item.key, merged, this.retryDelayMs(attempt));
+                }
+            }
+        }
+        finally {
+            this.inFlight -= batch.length;
+            this.notifyStateChange();
+        }
+    }
     async processEntry(key, entry) {
         this.inFlight += 1;
         try {

package/dist/esm/media/constants.js

@@ -3,7 +3,7 @@ export const DEFAULT_MEDIA_HOSTS = Object.freeze([
     'mmg-fallback.whatsapp.net'
 ]);
 export const MEDIA_CONN_CACHE_GRACE_MS = 30000;
-export const MEDIA_HKDF_SIZE = 112;
+export const MEDIA_HKDF_SIZE = 80;
 export const IV_SIZE = 16;
 export const ENC_KEY_START = 16;
 export const ENC_KEY_END = 48;
@@ -20,5 +20,36 @@ export const MEDIA_UPLOAD_PATHS = Object.freeze({
     sticker: '/mms/sticker',
     gif: '/mms/gif',
     ptt: '/mms/ptt',
-    ptv: '/mms/video'
+    ptv: '/mms/video',
+    'ads-image': '/mms/ads-image',
+    'ads-video': '/mms/ads-video',
+    'group-history': '/mms/group-history',
+    'md-app-state': '/mms/md-app-state',
+    'md-msg-hist': '/mms/md-msg-hist',
+    'music-artwork': '/mms/music-artwork',
+    'newsletter-music-artwork': '/mms/newsletter-music-artwork',
+    'sticker-pack': '/mms/sticker-pack',
+    'thumbnail-document': '/mms/thumbnail-document',
+    'thumbnail-image': '/mms/thumbnail-image',
+    'thumbnail-link': '/mms/thumbnail-link',
+    'thumbnail-sticker-pack': '/mms/thumbnail-sticker-pack',
+    'thumbnail-video': '/mms/thumbnail-video',
+    'waffle-image': '/mms/waffle-image',
+    'waffle-video': '/mms/waffle-video'
+});
+export const PPS_UPLOAD_PATHS = Object.freeze({
+    photo: '/pps/photo',
+    'biz-cover-photo': '/pps/biz-cover-photo'
+});
+export const NEWSLETTER_MEDIA_UPLOAD_PATHS = Object.freeze({
+    image: '/newsletter/newsletter-image',
+    video: '/newsletter/newsletter-video',
+    audio: '/newsletter/newsletter-audio',
+    document: '/newsletter/newsletter-document',
+    sticker: '/newsletter/newsletter-sticker',
+    'sticker-pack': '/newsletter/newsletter-sticker-pack',
+    gif: '/newsletter/newsletter-gif',
+    ptt: '/newsletter/newsletter-ptt',
+    ptv: '/newsletter/newsletter-ptv',
+    'thumbnail-link': '/newsletter/newsletter-thumbnail-link'
 });

package/dist/esm/media/crypto/WaMediaCrypto.js

@@ -0,0 +1,374 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { stat, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { PassThrough } from 'node:stream';
+import { hkdf } from '../../crypto/core/hkdf.js';
+import { aesCbcDecrypt, aesCbcEncrypt, hmacSha256Sign, sha256 } from '../../crypto/core/primitives.js';
+import { randomBytesAsync } from '../../crypto/core/random.js';
+import { ENC_KEY_END, ENC_KEY_START, HMAC_TRUNCATED_SIZE, IV_SIZE, MAC_KEY_END, MAC_KEY_START, MEDIA_HKDF_SIZE, SIDECAR_CHUNK_SIZE, SIDECAR_HMAC_SIZE } from '../constants.js';
+import { getWaMediaHkdfInfo, WA_APP_STATE_KEY_TYPES } from '../../protocol/constants.js';
+import { assertByteLength, concatBytes, EMPTY_BYTES, toBytesView, toChunkBytes, uint8TimingSafeEqual } from '../../util/bytes.js';
+import { toError } from '../../util/primitives.js';
+const AES_BLOCK_SIZE = 16;
+function computeFirstFrameSidecar(macKey, iv, ciphertext, firstFrameLength) {
+    const aligned = Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
+    const digest = hmacSha256Sign(macKey, [iv, ciphertext.subarray(0, aligned)]);
+    return digest.subarray(0, SIDECAR_HMAC_SIZE);
+}
+class SidecarAccumulator {
+    constructor(macKey, estimatedSize = 0) {
+        this.resultOffset = 0;
+        this.totalPushed = 0;
+        this.windowOffset = 0;
+        this.nextChunkStart = 0;
+        this.macKey = macKey;
+        this.window = new Uint8Array(IV_SIZE + SIDECAR_CHUNK_SIZE);
+        const safeEstimate = Number.isFinite(estimatedSize) && estimatedSize > 0 ? estimatedSize : 0;
+        const estimated = Math.max(Math.ceil(safeEstimate / SIDECAR_CHUNK_SIZE) + 1, 16);
+        this.result = new Uint8Array(estimated * SIDECAR_HMAC_SIZE);
+    }
+    push(data) {
+        let srcOffset = 0;
+        while (srcOffset < data.byteLength) {
+            const windowEnd = this.nextChunkStart + IV_SIZE + SIDECAR_CHUNK_SIZE;
+            const remaining = windowEnd - this.totalPushed;
+            const toCopy = Math.min(remaining, data.byteLength - srcOffset);
+            this.window.set(data.subarray(srcOffset, srcOffset + toCopy), this.windowOffset);
+            this.windowOffset += toCopy;
+            this.totalPushed += toCopy;
+            srcOffset += toCopy;
+            if (this.totalPushed === windowEnd) {
+                this.flushChunk();
+            }
+        }
+    }
+    finish() {
+        if (this.windowOffset > 0) {
+            this.flushChunk();
+        }
+        return this.result.subarray(0, this.resultOffset);
+    }
+    flushChunk() {
+        const digest = createHmac('sha256', this.macKey)
+            .update(this.window.subarray(0, this.windowOffset))
+            .digest();
+        if (this.resultOffset + SIDECAR_HMAC_SIZE > this.result.byteLength) {
+            const grown = new Uint8Array(this.result.byteLength * 2);
+            grown.set(this.result);
+            this.result = grown;
+        }
+        this.result.set(digest.subarray(0, SIDECAR_HMAC_SIZE), this.resultOffset);
+        this.resultOffset += SIDECAR_HMAC_SIZE;
+        this.nextChunkStart += SIDECAR_CHUNK_SIZE;
+        const overlapSrc = this.window.subarray(this.windowOffset - IV_SIZE, this.windowOffset);
+        this.window.set(overlapSrc, 0);
+        this.windowOffset = IV_SIZE;
+    }
+}
+/**
+ * WhatsApp media payload encryption/decryption (AES-256-CBC + HMAC-SHA-256 +
+ * SHA-256 hashes + streaming sidecar). Buffer-only and streaming variants are
+ * provided for upload, download, and disk-staged encryption.
+ */
+export class WaMediaCrypto {
+    /** Generates a fresh 32-byte media key suitable for {@link deriveKeys}. */
+    static async generateMediaKey() {
+        return randomBytesAsync(32);
+    }
+    /**
+     * Derives the per-type AES IV, AES key, and MAC key from `mediaKey` using
+     * HKDF with the {@link getWaMediaHkdfInfo} context.
+     */
+    static deriveKeys(mediaType, mediaKey) {
+        assertByteLength(mediaKey, 32, `invalid media key length ${mediaKey.byteLength}, expected 32`);
+        const info = mediaTypeToHkdfInfo(mediaType);
+        const expanded = hkdf(mediaKey, null, info, MEDIA_HKDF_SIZE);
+        return {
+            iv: expanded.subarray(0, IV_SIZE),
+            encKey: expanded.subarray(ENC_KEY_START, ENC_KEY_END),
+            macKey: expanded.subarray(MAC_KEY_START, MAC_KEY_END)
+        };
+    }
+    /**
+     * Encrypts an in-memory buffer with the streaming sidecar (unless disabled)
+     * and an optional first-frame sidecar for instant-thumbnail playback.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async encryptBytes(mediaType, mediaKey, plaintext, options) {
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const ciphertext = aesCbcEncrypt(keys.encKey, keys.iv, plaintext);
+        const mac = hmacSha256Sign(keys.macKey, [keys.iv, ciphertext]);
+        const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
+        const ciphertextHmac = concatBytes([ciphertext, signature]);
+        let streamingSidecar;
+        if (options?.sidecar !== false) {
+            const acc = new SidecarAccumulator(keys.macKey, plaintext.byteLength);
+            acc.push(keys.iv);
+            acc.push(ciphertext);
+            acc.push(signature);
+            streamingSidecar = acc.finish();
+        }
+        const firstFrameSidecar = options?.firstFrameLength !== undefined
+            ? computeFirstFrameSidecar(keys.macKey, keys.iv, ciphertext, options.firstFrameLength)
+            : undefined;
+        const fileSha256 = sha256(plaintext);
+        const fileEncSha256 = sha256(ciphertextHmac);
+        return {
+            ciphertextHmac,
+            fileSha256,
+            fileEncSha256,
+            streamingSidecar,
+            firstFrameSidecar
+        };
+    }
+    /**
+     * Decrypts an in-memory `ciphertext||mac` buffer. Verifies the encrypted
+     * SHA-256, the MAC, and (when supplied) the plaintext SHA-256. Pass
+     * `skipMacVerification` only when the MAC was checked elsewhere.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async decryptBytes(mediaType, mediaKey, ciphertextHmac, expectedFileSha256, expectedFileEncSha256, skipMacVerification = false) {
+        if (ciphertextHmac.byteLength < HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${ciphertextHmac.byteLength}`);
+        }
+        if (expectedFileEncSha256) {
+            const computedEncHash = sha256(ciphertextHmac);
+            if (!uint8TimingSafeEqual(computedEncHash, expectedFileEncSha256)) {
+                throw new Error('encrypted file hash mismatch');
+            }
+        }
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const ciphertext = ciphertextHmac.subarray(0, ciphertextHmac.byteLength - HMAC_TRUNCATED_SIZE);
+        const expectedMac = ciphertextHmac.subarray(ciphertextHmac.byteLength - HMAC_TRUNCATED_SIZE);
+        if (!skipMacVerification) {
+            const mac = hmacSha256Sign(keys.macKey, [keys.iv, ciphertext]);
+            const signature = mac.subarray(0, HMAC_TRUNCATED_SIZE);
+            if (!uint8TimingSafeEqual(signature, expectedMac)) {
+                throw new Error('media MAC mismatch');
+            }
+        }
+        const plaintext = aesCbcDecrypt(keys.encKey, keys.iv, ciphertext);
+        const fileSha256 = sha256(plaintext);
+        if (expectedFileSha256 && !uint8TimingSafeEqual(fileSha256, expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        const fileEncSha256 = expectedFileEncSha256 ?? sha256(ciphertextHmac);
+        return { plaintext, fileSha256, fileEncSha256 };
+    }
+    /**
+     * Streaming encrypt – returns an `encrypted` Readable plus a `metadata`
+     * promise that resolves with hashes/sidecars after the stream ends.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async encryptReadable(mediaType, mediaKey, plaintext, options) {
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const encrypted = new PassThrough();
+        const metadata = pumpEncryption(plaintext, encrypted, keys, options?.sidecar !== false, options?.firstFrameLength, options?.expectedFileSize);
+        return { encrypted, metadata };
+    }
+    /**
+     * Encrypts `plaintext` to a temporary file in `tmpdir()` and returns its
+     * path/size/hashes. The file is removed on failure; call
+     * {@link cleanupEncryptedFile} after a successful upload.
+     */
+    static async encryptToFile(mediaType, mediaKey, plaintext, options) {
+        const keys = WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const filePath = join(tmpdir(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        const output = createWriteStream(filePath);
+        try {
+            const metadata = await pumpEncryption(plaintext, output, keys, options?.sidecar !== false, options?.firstFrameLength, options?.expectedFileSize);
+            const fileSize = (await stat(filePath)).size;
+            return { filePath, fileSize, ...metadata };
+        }
+        catch (error) {
+            await unlink(filePath).catch(() => undefined);
+            throw error;
+        }
+    }
+    /** Removes a temporary file produced by {@link encryptToFile}; missing files are ignored. */
+    static async cleanupEncryptedFile(filePath) {
+        await unlink(filePath).catch(() => undefined);
+    }
+    /**
+     * Streaming decrypt – returns a `plaintext` Readable plus a `metadata`
+     * promise that resolves with the verified hashes after the stream ends
+     * (or rejects on MAC/hash failure).
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async decryptReadable(encrypted, options) {
+        const keys = WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
+        const plaintext = new PassThrough();
+        const metadata = pumpDecryption(encrypted, plaintext, keys, options);
+        return { plaintext, metadata };
+    }
+    /** Returns the ciphertext byte length (AES-CBC padded + 10-byte MAC) for a given plaintext size. */
+    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 + HMAC_TRUNCATED_SIZE;
+    }
+}
+async function pumpEncryption(plaintext, output, keys, computeSidecar, firstFrameLength, expectedFileSize) {
+    const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    const plainHash = createHash('sha256');
+    const encHash = createHash('sha256');
+    const hmac = createHmac('sha256', keys.macKey);
+    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey, expectedFileSize) : null;
+    const ffTarget = firstFrameLength !== undefined
+        ? IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
+        : 0;
+    const ffChunks = ffTarget > 0 ? [keys.iv] : [];
+    let ffCollected = ffTarget > 0 ? IV_SIZE : 0;
+    let plaintextLength = 0;
+    hmac.update(keys.iv);
+    sidecar?.push(keys.iv);
+    const consumeCiphertext = async (raw) => {
+        if (raw.byteLength === 0)
+            return;
+        const bytes = toBytesView(raw);
+        hmac.update(bytes);
+        encHash.update(bytes);
+        sidecar?.push(bytes);
+        if (ffCollected < ffTarget) {
+            const need = ffTarget - ffCollected;
+            ffChunks.push(bytes.subarray(0, Math.min(need, bytes.byteLength)));
+            ffCollected += bytes.byteLength;
+        }
+        await writeChunkToWritable(output, bytes);
+    };
+    try {
+        for await (const chunk of plaintext) {
+            const plainChunk = toChunkBytes(chunk);
+            if (plainChunk.byteLength === 0)
+                continue;
+            plaintextLength += plainChunk.byteLength;
+            plainHash.update(plainChunk);
+            await consumeCiphertext(cipher.update(plainChunk));
+        }
+        await consumeCiphertext(cipher.final());
+        const signature = toBytesView(hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE));
+        encHash.update(signature);
+        sidecar?.push(signature);
+        await writeChunkToWritable(output, signature);
+        await endWritable(output);
+        let firstFrameSidecar;
+        if (ffTarget > 0) {
+            const ffDigest = hmacSha256Sign(keys.macKey, ffChunks);
+            firstFrameSidecar = ffDigest.subarray(0, SIDECAR_HMAC_SIZE);
+        }
+        return {
+            fileSha256: toBytesView(plainHash.digest()),
+            fileEncSha256: toBytesView(encHash.digest()),
+            plaintextLength,
+            streamingSidecar: sidecar?.finish(),
+            firstFrameSidecar
+        };
+    }
+    catch (error) {
+        const normalized = toError(error);
+        output.destroy(normalized);
+        throw normalized;
+    }
+}
+async function writeChunkToWritable(stream, chunk) {
+    if (chunk.byteLength === 0) {
+        return;
+    }
+    if (stream.write(chunk)) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const onDrain = () => {
+            stream.off('error', onError);
+            resolve();
+        };
+        const onError = (err) => {
+            stream.off('drain', onDrain);
+            reject(err);
+        };
+        stream.once('drain', onDrain);
+        stream.once('error', onError);
+    });
+}
+async function endWritable(stream) {
+    return new Promise((resolve, reject) => {
+        stream.on('error', reject);
+        stream.end(() => resolve());
+    });
+}
+async function pumpDecryption(encrypted, plaintext, keys, options) {
+    const decipher = createDecipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    const plainHash = createHash('sha256');
+    const encHash = createHash('sha256');
+    const hmac = createHmac('sha256', keys.macKey);
+    let trailing = EMPTY_BYTES;
+    hmac.update(keys.iv);
+    try {
+        for await (const chunk of encrypted) {
+            const bytes = toChunkBytes(chunk);
+            if (bytes.byteLength === 0) {
+                continue;
+            }
+            encHash.update(bytes);
+            const merged = trailing.byteLength === 0 ? bytes : concatBytes([trailing, bytes]);
+            if (merged.byteLength <= HMAC_TRUNCATED_SIZE) {
+                trailing = merged;
+                continue;
+            }
+            const ciphertextChunk = merged.subarray(0, merged.byteLength - HMAC_TRUNCATED_SIZE);
+            trailing = toBytesView(merged.subarray(merged.byteLength - HMAC_TRUNCATED_SIZE));
+            hmac.update(ciphertextChunk);
+            const dec = decipher.update(ciphertextChunk);
+            if (dec.byteLength > 0) {
+                const decBytes = toBytesView(dec);
+                plainHash.update(decBytes);
+                await writeChunkToWritable(plaintext, decBytes);
+            }
+        }
+        if (trailing.byteLength !== HMAC_TRUNCATED_SIZE) {
+            throw new Error(`ciphertext too short: ${trailing.byteLength}`);
+        }
+        if (!options.skipMacVerification) {
+            const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
+            if (!uint8TimingSafeEqual(signature, trailing)) {
+                throw new Error('media MAC mismatch');
+            }
+        }
+        const finalDec = decipher.final();
+        if (finalDec.byteLength > 0) {
+            const bytes = toBytesView(finalDec);
+            plainHash.update(bytes);
+            await writeChunkToWritable(plaintext, bytes);
+        }
+        const fileSha256 = toBytesView(plainHash.digest());
+        const fileEncSha256 = toBytesView(encHash.digest());
+        if (options.expectedFileEncSha256 &&
+            !uint8TimingSafeEqual(fileEncSha256, options.expectedFileEncSha256)) {
+            throw new Error('encrypted file hash mismatch');
+        }
+        if (options.expectedFileSha256 &&
+            !uint8TimingSafeEqual(fileSha256, options.expectedFileSha256)) {
+            throw new Error('plaintext file hash mismatch');
+        }
+        plaintext.end();
+        return { fileSha256, fileEncSha256 };
+    }
+    catch (error) {
+        const normalized = toError(error);
+        plaintext.destroy(normalized);
+        throw normalized;
+    }
+}
+function mediaTypeToHkdfInfo(mediaType) {
+    if (mediaType === 'ptv') {
+        return getWaMediaHkdfInfo('video');
+    }
+    if (mediaType === 'history') {
+        return getWaMediaHkdfInfo(WA_APP_STATE_KEY_TYPES.MD_MSG_HIST);
+    }
+    return getWaMediaHkdfInfo(mediaType);
+}

package/dist/esm/media/index.js

@@ -1,3 +1,4 @@
-export { WaMediaTransferClient } from './WaMediaTransferClient.js';
-export { parseMediaConnResponse } from './conn.js';
-export { WaMediaCrypto } from './WaMediaCrypto.js';
+export { WaMediaTransferClient } from './transfer/WaMediaTransferClient.js';
+export { parseMediaConnResponse } from './transfer/conn.js';
+export { DEFAULT_MEDIA_HOSTS, MEDIA_UPLOAD_PATHS, NEWSLETTER_MEDIA_UPLOAD_PATHS, PPS_UPLOAD_PATHS } from './constants.js';
+export { WaMediaCrypto } from './crypto/WaMediaCrypto.js';