zapo-js 0.1.2 → 0.2.0

package/dist/types/client/tokens/tc-token.d.ts

@@ -0,0 +1,5 @@
+export declare function computeBucket(unixTimeS: number, durationS: number): number;
+export declare function tokenExpirationCutoffS(nowS: number, durationS: number, numBuckets: number): number;
+export declare function isTokenExpired(tokenTimestampS: number, nowS: number, durationS: number, numBuckets: number): boolean;
+export declare function shouldSendNewToken(senderTimestampS: number, nowS: number, senderDurationS: number): boolean;
+export declare function clampDuration(durationS: number, maxDurationS: number): number;

package/dist/types/client/types.d.ts

@@ -2,6 +2,7 @@ import type { AppStateCollectionName } from '../appstate/types';
 import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions } from '../auth/types';
 import type { WaMessagePublishOptions } from '../message/types';
 import type { Proto } from '..';
+import type { WaConnectionCode, WaConnectionOpenReason, WaDisconnectReason } from '../protocol/stream';
 import type { WaStore } from '../store/types';
 import type { BinaryNode, WaProxyTransport } from '../transport/types';
 export interface WaClientProxyOptions {
@@ -9,6 +10,19 @@ export interface WaClientProxyOptions {
     readonly mediaUpload?: WaProxyTransport;
     readonly mediaDownload?: WaProxyTransport;
 }
+export interface WaLogoutStoreClearOptions {
+    readonly auth?: boolean;
+    readonly signal?: boolean;
+    readonly senderKey?: boolean;
+    readonly appState?: boolean;
+    readonly retry?: boolean;
+    readonly participants?: boolean;
+    readonly deviceList?: boolean;
+    readonly messages?: boolean;
+    readonly threads?: boolean;
+    readonly contacts?: boolean;
+    readonly privacyToken?: boolean;
+}
 export interface WaClientOptions extends WaAuthClientOptions, WaAuthSocketOptions {
     readonly store: WaStore;
     readonly sessionId: string;
@@ -24,10 +38,25 @@ export interface WaClientOptions extends WaAuthClientOptions, WaAuthSocketOption
     readonly messageAckTimeoutMs?: number;
     readonly messageMaxAttempts?: number;
     readonly messageRetryDelayMs?: number;
+    readonly writeBehind?: WaWriteBehindOptions;
     readonly history?: WaHistorySyncOptions;
     readonly chatEvents?: {
         readonly emitSnapshotMutations?: boolean;
     };
+    readonly privacyToken?: WaPrivacyTokenOptions;
+    readonly logoutStoreClear?: WaLogoutStoreClearOptions;
+}
+export interface WaPrivacyTokenOptions {
+    readonly tcTokenDurationS?: number;
+    readonly tcTokenNumBuckets?: number;
+    readonly tcTokenSenderDurationS?: number;
+    readonly tcTokenSenderNumBuckets?: number;
+    readonly tcTokenMaxDurationS?: number;
+}
+export interface WaWriteBehindOptions {
+    readonly maxPendingKeys?: number;
+    readonly maxWriteConcurrency?: number;
+    readonly flushTimeoutMs?: number;
 }
 export interface WaHistorySyncOptions {
     readonly enabled?: boolean;
@@ -47,6 +76,7 @@ export interface WaSignalMessagePublishInput {
 export interface WaSendMessageOptions extends WaMessagePublishOptions {
     readonly id?: string;
     readonly expectedIdentity?: Uint8Array;
+    readonly subtype?: string;
 }
 export interface WaClearChatOptions {
     readonly deleteStarred?: boolean;
@@ -201,7 +231,19 @@ export interface WaChatEvent {
     readonly locked?: boolean;
     readonly deviceAgentId?: string;
 }
-export type WaEmptyEvent = Readonly<Record<string, never>>;
+export type WaConnectionEvent = {
+    readonly status: 'open';
+    readonly reason: WaConnectionOpenReason;
+    readonly code: null;
+    readonly isLogout: false;
+    readonly isNewLogin: boolean;
+} | {
+    readonly status: 'close';
+    readonly reason: WaDisconnectReason;
+    readonly code: WaConnectionCode | null;
+    readonly isLogout: boolean;
+    readonly isNewLogin: false;
+};
 export interface WaClientEventMap {
     readonly auth_qr: (event: {
         readonly qr: string;
@@ -222,8 +264,7 @@ export interface WaClientEventMap {
     readonly client_error: (event: {
         readonly error: Error;
     }) => void;
-    readonly connection_open: (event: WaEmptyEvent) => void;
-    readonly connection_close: (event: WaEmptyEvent) => void;
+    readonly connection: (event: WaConnectionEvent) => void;
     readonly transport_frame_in: (event: {
         readonly frame: Uint8Array;
     }) => void;
@@ -255,4 +296,11 @@ export interface WaClientEventMap {
     readonly group_event: (event: WaGroupEvent) => void;
     readonly chat_event: (event: WaChatEvent) => void;
     readonly history_sync_chunk: (event: WaHistorySyncChunkEvent) => void;
+    readonly privacy_token_update: (event: WaPrivacyTokenUpdateEvent) => void;
+}
+export interface WaPrivacyTokenUpdateEvent {
+    readonly jid: string;
+    readonly timestampS: number;
+    readonly type: string;
+    readonly source: 'notification' | 'history_sync';
 }

package/dist/types/crypto/core/index.d.ts

@@ -6,5 +6,5 @@ export { X25519 } from '../curves/X25519';
 export { hkdf, hkdfSplit } from '../core/hkdf';
 export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent } from '../core/keys';
 export { buildNonce } from '../core/nonce';
-export { randomBytesAsync, randomIntAsync } from '../core/random';
-export { type CryptoKey, sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt, ed25519VerifyRaw } from '../core/primitives';
+export { randomBytesAsync, randomFillAsync, randomIntAsync } from '../core/random';
+export { type CryptoKey, sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt } from '../core/primitives';

package/dist/types/crypto/core/nonce.d.ts

@@ -1,5 +1,7 @@
 /**
  * Builds a 12-byte nonce for AES-GCM encryption with counter in the last 4 bytes.
+ * Allocates a new buffer per call because concurrent Noise encrypt/decrypt operations
+ * may hold references to different nonces simultaneously.
  * Throws if counter exceeds uint32 range to prevent nonce reuse.
  */
 export declare function buildNonce(counter: number): Uint8Array;

package/dist/types/crypto/core/primitives.d.ts

@@ -22,4 +22,3 @@ export declare function hmacSign(key: webcrypto.CryptoKey, data: Uint8Array): Pr
 export declare function pbkdf2DeriveAesCtrKey(password: Uint8Array, salt: Uint8Array, iterations: number): Promise<CryptoKey>;
 export declare function aesCtrEncrypt(key: CryptoKey, counter: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
 export declare function aesCtrDecrypt(key: CryptoKey, counter: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
-export declare function ed25519VerifyRaw(publicKey: Uint8Array, signature: Uint8Array, message: Uint8Array): Promise<boolean>;

package/dist/types/crypto/core/random.d.ts

@@ -1,2 +1,3 @@
 export declare function randomBytesAsync(size: number): Promise<Uint8Array>;
+export declare function randomFillAsync(target: Uint8Array, offset?: number, size?: number): Promise<Uint8Array>;
 export declare const randomIntAsync: (min: number, max: number) => Promise<number>;

package/dist/types/crypto/index.d.ts

@@ -1 +1,2 @@
 export * from './core';
+export { X25519 } from './curves/X25519';

package/dist/types/crypto/math/constants.d.ts

@@ -1,7 +1,9 @@
+import { type Fe } from '../math/fe';
 import type { ExtendedPoint } from '../math/types';
 export declare const FIELD_P: bigint;
 export declare const GROUP_L: bigint;
-export declare const EDWARDS_D: bigint;
-export declare const TWO_D: bigint;
+export declare const FE_TWO_D: Fe;
+export declare const FE_ZERO: Fe;
+export declare const FE_ONE: Fe;
 export declare const BASE_POINT: ExtendedPoint;
 export declare const IDENTITY_POINT: ExtendedPoint;

package/dist/types/crypto/math/fe.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Field element arithmetic for GF(2^255-19).
+ * Representation: 16 limbs of 16 bits in Float64Array (tweetnacl style).
+ * Hot-path operations are allocation-free using pre-allocated temporaries.
+ */
+export type Fe = Float64Array;
+export declare function fe(): Fe;
+export declare function feCopy(o: Fe, a: Fe): void;
+export declare function feFromBigInt(n: bigint): Fe;
+export declare function feToBigInt(a: Fe): bigint;
+export declare function feFromBytes(o: Fe, s: Uint8Array): void;
+export declare function fePack(o: Uint8Array, n: Fe): void;
+export declare function feAdd(o: Fe, a: Fe, b: Fe): void;
+export declare function feSub(o: Fe, a: Fe, b: Fe): void;
+export declare function feNeg(o: Fe, a: Fe): void;
+/**
+ * Fully unrolled field multiplication with folded reduction.
+ * Computes o = a * b mod (2^255-19) using negacyclic convolution:
+ * t[i] = Σ a[j]*b[i-j] (direct) + 38 * Σ a[j]*b[i+16-j] (wrapped)
+ * All values in local variables for register allocation.
+ */
+export declare function feMul(o: Fe, a: Fe, b: Fe): void;
+/**
+ * Fully unrolled field squaring with folded reduction and symmetry.
+ * Exploits a[j]*a[k] == a[k]*a[j] to halve off-diagonal multiplications.
+ * Combined with negacyclic reduction: wrapped terms use a38[k] = 38*a[k].
+ */
+export declare function feSqr(o: Fe, a: Fe): void;
+export declare function feSqrN(o: Fe, a: Fe, n: number): void;
+export declare function feInv(o: Fe, a: Fe): void;

package/dist/types/crypto/math/mod.d.ts

@@ -1,5 +1,3 @@
-import { FIELD_P, GROUP_L } from '../math/constants';
-export { FIELD_P, GROUP_L };
 export declare function mod(value: bigint, modulus?: bigint): bigint;
 export declare function modGroup(value: bigint): bigint;
 export declare function modInv(value: bigint, modulus?: bigint): bigint;

package/dist/types/crypto/math/types.d.ts

@@ -1,6 +1,13 @@
+import type { Fe } from '../math/fe';
 export interface ExtendedPoint {
-    readonly x: bigint;
-    readonly y: bigint;
-    readonly z: bigint;
-    readonly t: bigint;
+    readonly x: Fe;
+    readonly y: Fe;
+    readonly z: Fe;
+    readonly t: Fe;
+}
+export interface MutablePoint {
+    x: Fe;
+    y: Fe;
+    z: Fe;
+    t: Fe;
 }

package/dist/types/index.d.ts

@@ -1,10 +1,12 @@
 export { WaClient } from '@client';
-export type { WaClientEventMap, WaClientOptions, WaClientProxyOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from '@client';
+export type { WaClientEventMap, WaClientOptions, WaClientProxyOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions, WaWriteBehindOptions } from '@client';
+export type { WaBlocklistResult, WaPrivacyCoordinator, WaPrivacyDisallowedListResult, WaPrivacySettings } from './client/coordinators/WaPrivacyCoordinator';
 export { ConsoleLogger } from './infra/log/ConsoleLogger';
 export { PinoLogger, createPinoLogger } from './infra/log/PinoLogger';
 export type { PinoLoggerOptions } from './infra/log/PinoLogger';
 export type { Logger, LogLevel } from './infra/log/types';
 export { createStore } from '@store';
-export type { WaAppStateCollectionStoreState, WaAppStateStore, WaAuthStore, WaContactStore, WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaDeviceListSnapshot, WaDeviceListStore, WaMessageStore, WaParticipantsSnapshot, WaParticipantsStore, WaRetryStore, WaSenderKeyStore, WaSignalStore, WaSqliteDriver, WaSqliteStorageOptions, WaStoredContactRecord, WaStoredMessageRecord, WaStoredThreadRecord, WaStore, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession, WaThreadStore } from '@store';
-export { getLoginIdentity, getWaCompanionPlatformId, getWaMediaHkdfInfo, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid, WA_ACCOUNT_SYNC_PROTOCOLS, WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_DISCONNECT_REASONS, WA_IQ_TYPES, WA_LOGOUT_REASONS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_MEDIA_HKDF_INFO, WA_NODE_TAGS, WA_PAIRING_KDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO, WA_READY_STATES, WA_RETRYABLE_ACK_CODES, WA_SIGNALING, WA_STREAM_SIGNALING, WA_SUPPORTED_DIRTY_TYPES, WA_XMLNS } from '@protocol';
+export type { WaAppStateCollectionStoreState, WaAppStateStore, WaAuthStore, WaContactStore, WaCreateStoreOptions, WaDeviceListSnapshot, WaDeviceListStore, WaMessageStore, WaParticipantsSnapshot, WaParticipantsStore, WaRetryStore, WaSenderKeyStore, WaSignalStore, WaStoredContactRecord, WaStoredMessageRecord, WaStoredThreadRecord, WaStore, WaStoreBackend, WaStoreSession, WaThreadStore } from '@store';
+export { getLoginIdentity, getWaCompanionPlatformId, getWaMediaHkdfInfo, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid, WA_ACCOUNT_SYNC_PROTOCOLS, WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_DISCONNECT_REASONS, WA_IQ_TYPES, WA_LOGOUT_REASONS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_MEDIA_HKDF_INFO, WA_NODE_TAGS, WA_PAIRING_KDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO, WA_READY_STATES, WA_RETRYABLE_ACK_CODES, WA_SIGNALING, WA_STREAM_SIGNALING, WA_SUPPORTED_DIRTY_TYPES, WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES, WA_XMLNS } from '@protocol';
+export type { WaPrivacyCategory, WaPrivacySettingName, WaPrivacyValue } from '@protocol';
 export { proto } from '.';

package/dist/types/infra/perf/BackgroundQueue.d.ts

@@ -0,0 +1,58 @@
+export interface BackgroundQueueOptions<K extends string, V> {
+    readonly coalesce?: (previous: V, incoming: V, key: K) => V;
+    readonly maxPendingKeys?: number;
+    readonly maxWriteConcurrency?: number;
+    readonly flushTimeoutMs?: number;
+    readonly onError?: (key: K, error: unknown, attempt: number) => void;
+    readonly onPressure?: (pendingKeys: number) => void;
+    readonly onDiscard?: (key: K, value: V) => void;
+}
+export interface BackgroundQueueFlushResult {
+    readonly flushed: number;
+    readonly remaining: number;
+}
+export declare class BackgroundQueue<K extends string, V> {
+    private readonly writer;
+    private readonly coalesce;
+    private readonly maxPendingKeys;
+    private readonly maxWriteConcurrency;
+    private readonly flushTimeoutMs;
+    private readonly onError?;
+    private readonly onPressure?;
+    private readonly onDiscard?;
+    private readonly pendingByKey;
+    private readonly retryTimersByKey;
+    private readonly stateWaiters;
+    private drainingPromise;
+    private inFlight;
+    private flushedCount;
+    private shutdownRequested;
+    private retryDisabled;
+    constructor(writer: (key: K, value: V) => Promise<void>, options?: BackgroundQueueOptions<K, V>);
+    enqueue(key: K, value: V): void;
+    enqueueAsync(key: K, value: V): Promise<void>;
+    private waitForCapacity;
+    private addPendingEntry;
+    private detachRetryEntry;
+    flush(timeoutMs?: number): Promise<BackgroundQueueFlushResult>;
+    destroy(timeoutMs?: number): Promise<BackgroundQueueFlushResult>;
+    private ensureDrain;
+    private drainLoop;
+    private takeBatch;
+    private processEntry;
+    private takeNext;
+    private mergeForRetry;
+    private retryDelayMs;
+    private scheduleRetry;
+    private resolveEntry;
+    private discardEntry;
+    private discardPending;
+    private remaining;
+    private trackedKeys;
+    private notifyStateChange;
+    private waitForStateChange;
+    private removeStateWaiter;
+    private invokeOnError;
+    private invokeOnPressure;
+    private invokeOnDiscard;
+}

package/dist/types/infra/perf/PromiseDedup.d.ts

@@ -0,0 +1,4 @@
+export declare class PromiseDedup {
+    private readonly inFlight;
+    run<T>(key: string, task: () => Promise<T>): Promise<T>;
+}

package/dist/types/infra/perf/SharedExclusiveGate.d.ts

@@ -0,0 +1,17 @@
+type SharedExclusiveTask<T> = () => Promise<T>;
+export declare class SharedExclusiveGate {
+    private activeShared;
+    private pendingExclusive;
+    private exclusiveActive;
+    private closed;
+    private readonly waiters;
+    runShared<T>(task: SharedExclusiveTask<T>): Promise<T>;
+    private runSharedSlow;
+    runExclusive<T>(task: SharedExclusiveTask<T>): Promise<T>;
+    close(): Promise<void>;
+    private acquireShared;
+    private acquireExclusive;
+    private notifyStateChange;
+    private waitForStateChange;
+}
+export {};

package/dist/types/infra/perf/StoreLock.d.ts

@@ -0,0 +1,10 @@
+type StoreTask<T> = () => Promise<T>;
+export declare class StoreLock {
+    private readonly chains;
+    private closed;
+    run<T>(key: string, task: StoreTask<T>): Promise<T>;
+    private runInternal;
+    runMany<T>(keys: readonly string[], task: StoreTask<T>): Promise<T>;
+    shutdown(): Promise<void>;
+}
+export {};

package/dist/types/media/WaMediaCrypto.d.ts

@@ -1,12 +1,13 @@
 import type { Readable } from 'node:stream';
-import type { MediaCryptoType, WaMediaDecryptReadableOptions, WaMediaDecryptionResult, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaReadableDecryptionResult, WaMediaReadableEncryptionResult } from './types';
+import type { MediaCryptoType, WaMediaDecryptReadableOptions, WaMediaDecryptionResult, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaFileEncryptionResult, WaMediaReadableDecryptionResult, WaMediaReadableEncryptionResult } from './types';
 export declare class WaMediaCrypto {
     static generateMediaKey(): Promise<Uint8Array>;
     static deriveKeys(mediaType: MediaCryptoType, mediaKey: Uint8Array): Promise<WaMediaDerivedKeys>;
     static encryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Uint8Array): Promise<WaMediaEncryptionResult>;
     static decryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, ciphertextHmac: Uint8Array, expectedFileSha256?: Uint8Array, expectedFileEncSha256?: Uint8Array): Promise<WaMediaDecryptionResult>;
     static encryptReadable(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable): Promise<WaMediaReadableEncryptionResult>;
-    static decryptReadableToBytes(encrypted: Readable, options: WaMediaDecryptReadableOptions): Promise<WaMediaDecryptionResult>;
+    static encryptToFile(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable): Promise<WaMediaFileEncryptionResult>;
+    static cleanupEncryptedFile(filePath: string): Promise<void>;
     static decryptReadable(encrypted: Readable, options: WaMediaDecryptReadableOptions): Promise<WaMediaReadableDecryptionResult>;
     static encryptedLength(plaintextLength: number): number;
 }

package/dist/types/media/WaMediaTransferClient.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from 'node:stream';
-import type { MediaCryptoType, WaMediaTransferClientOptions } from './types';
+import type { MediaCryptoType, WaMediaReadableDecryptionResult, WaMediaTransferClientOptions } from './types';
 interface StreamDownloadRequest {
     readonly url?: string;
     readonly directPath?: string;
@@ -37,6 +37,7 @@ interface EncryptedUploadResult {
     readonly mediaKey: Uint8Array;
     readonly fileSha256: Uint8Array;
     readonly fileEncSha256: Uint8Array;
+    readonly plaintextLength: number;
 }
 interface EncryptedDownloadRequest extends StreamDownloadRequest {
     readonly mediaType: MediaCryptoType;
@@ -44,13 +45,6 @@ interface EncryptedDownloadRequest extends StreamDownloadRequest {
     readonly fileSha256?: Uint8Array;
     readonly fileEncSha256?: Uint8Array;
 }
-interface EncryptedDownloadStream {
-    readonly plaintext: Readable;
-    readonly metadata: Promise<{
-        readonly fileSha256: Uint8Array;
-        readonly fileEncSha256: Uint8Array;
-    }>;
-}
 export declare class WaMediaTransferClient {
     private readonly logger?;
     private readonly defaultHosts;
@@ -68,7 +62,7 @@ export declare class WaMediaTransferClient {
     uploadStream(request: StreamUploadRequest): Promise<StreamTransferResponse>;
     uploadEncrypted(request: EncryptedUploadRequest): Promise<EncryptedUploadResult>;
     downloadAndDecrypt(request: EncryptedDownloadRequest): Promise<Uint8Array>;
-    downloadAndDecryptStream(request: EncryptedDownloadRequest): Promise<EncryptedDownloadStream>;
+    downloadAndDecryptStream(request: EncryptedDownloadRequest): Promise<WaMediaReadableDecryptionResult>;
     readResponseBytes(response: StreamTransferResponse, maxBytes?: number): Promise<Uint8Array>;
     private transferRequest;
     private fetchWithDispatcher;
@@ -77,15 +71,12 @@ export declare class WaMediaTransferClient {
     private loadGotModule;
     private toGotTransferResponse;
     private resolveTransferRequest;
-    private executeTransfer;
     private prepareEncryptedUpload;
     private assertSuccessfulResponse;
     private requireResponseBody;
     private resolveUrls;
-    private readAllBytesWithLimit;
     private fetchWithFallback;
     private createAbortContext;
-    private headersToRecord;
     private drainBody;
 }
 export {};

package/dist/types/media/constants.d.ts

@@ -7,4 +7,4 @@ export declare const ENC_KEY_END = 48;
 export declare const MAC_KEY_START = 48;
 export declare const MAC_KEY_END = 80;
 export declare const HMAC_TRUNCATED_SIZE = 10;
-export declare const MEDIA_UPLOAD_PATHS: Readonly<Record<'image' | 'video' | 'audio' | 'document' | 'sticker' | 'gif' | 'ptt', string>>;
+export declare const MEDIA_UPLOAD_PATHS: Readonly<Record<'image' | 'video' | 'audio' | 'document' | 'sticker' | 'gif' | 'ptt' | 'ptv', string>>;

package/dist/types/media/index.d.ts

@@ -1,4 +1,4 @@
 export { WaMediaTransferClient } from './WaMediaTransferClient';
 export { parseMediaConnResponse } from './conn';
-export type { WaMediaConn, WaMediaConnHost, WaMediaTransferClientOptions, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaDecryptionResult, WaMediaReadableEncryptionResult, WaMediaReadableDecryptionResult } from './types';
+export type { WaMediaConn } from './types';
 export { WaMediaCrypto } from './WaMediaCrypto';

package/dist/types/media/types.d.ts

@@ -1,8 +1,8 @@
 import type { Readable } from 'node:stream';
 import type { Logger } from '../infra/log/types';
 import type { WaProxyAgent, WaProxyDispatcher } from '../transport/types';
-export type MediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker';
-export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'ptv' | 'history' | 'md-app-state';
+export type MediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'ptv';
+export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'history' | 'md-app-state';
 export interface WaMediaConnHost {
     readonly hostname: string;
     readonly isFallback: boolean;
@@ -44,6 +44,7 @@ export interface WaMediaReadableEncryptionResult {
     readonly metadata: Promise<{
         readonly fileSha256: Uint8Array;
         readonly fileEncSha256: Uint8Array;
+        readonly plaintextLength: number;
     }>;
 }
 export interface WaMediaReadableDecryptionResult {
@@ -53,6 +54,13 @@ export interface WaMediaReadableDecryptionResult {
         readonly fileEncSha256: Uint8Array;
     }>;
 }
+export interface WaMediaFileEncryptionResult {
+    readonly filePath: string;
+    readonly fileSize: number;
+    readonly fileSha256: Uint8Array;
+    readonly fileEncSha256: Uint8Array;
+    readonly plaintextLength: number;
+}
 export interface WaMediaDecryptReadableOptions {
     readonly mediaType: MediaCryptoType;
     readonly mediaKey: Uint8Array;

package/dist/types/message/content.d.ts

@@ -2,3 +2,11 @@ import type { WaSendMediaMessage } from './types';
 import type { Proto } from '..';
 export declare function isSendMediaMessage(content: unknown): content is WaSendMediaMessage;
 export declare function resolveMessageTypeAttr(message: Proto.IMessage): string;
+export declare function resolveEditAttr(message: Proto.IMessage, subtype?: string): string | null;
+export declare function resolveEncMediaType(message: Proto.IMessage): string | null;
+export interface MessageMetaAttrs {
+    readonly polltype?: string;
+    readonly event_type?: string;
+    readonly view_once?: string;
+}
+export declare function resolveMetaAttrs(message: Proto.IMessage): MessageMetaAttrs | null;

package/dist/types/message/icdc.d.ts

@@ -0,0 +1,13 @@
+import type { Proto } from '..';
+import type { SignalAddress } from '../signal/types';
+import type { WaSignalStore } from '../store/contracts/signal.store';
+export interface IcdcMeta {
+    readonly keyHash: Uint8Array;
+    readonly timestamp: number | undefined;
+}
+export declare function computeDeviceKeyHash(identityKeys: readonly Uint8Array[]): Promise<Uint8Array>;
+export declare function resolveIcdcMeta(deviceJids: readonly string[], signalStore: WaSignalStore, updatedAtMs: number | undefined, localIdentity?: {
+    readonly address: SignalAddress;
+    readonly pubKey: Uint8Array;
+}): Promise<IcdcMeta | null>;
+export declare function injectDeviceListMetadata(message: Proto.IMessage, senderIcdc: IcdcMeta | null, recipientIcdc: IcdcMeta | null): Proto.IMessage;

package/dist/types/message/reporting-token.d.ts

@@ -15,5 +15,4 @@ export interface BuildReportingTokenArtifactsResult {
     readonly reportingTokenContent: Uint8Array;
     readonly reportingTokenKey: Uint8Array;
 }
-export declare function buildReportingTokenNode(input: BuildReportingTokenNodeInput): Promise<BinaryNode | null>;
 export declare function buildReportingTokenArtifacts(input: BuildReportingTokenNodeInput): Promise<BuildReportingTokenArtifactsResult | null>;

package/dist/types/message/types.d.ts

@@ -1,4 +1,4 @@
-import type { MediaKind } from '../media/types';
+import type { Readable } from 'node:stream';
 import type { Proto } from '..';
 import type { BinaryNode } from '../transport/types';
 export interface WaMessagePublishOptions {
@@ -21,18 +21,48 @@ export interface WaMessagePublishResult {
     readonly ackNode: BinaryNode;
     readonly ack: WaMessageAckMetadata;
 }
-export interface WaSendMediaMessage {
-    readonly type: MediaKind;
-    readonly media: Uint8Array | ArrayBuffer;
+type MediaInput = Uint8Array | ArrayBuffer | Readable;
+interface WaSendMediaBase {
+    readonly media: MediaInput;
     readonly mimetype: string;
+    readonly fileLength?: number;
+}
+interface WaSendImageMessage extends WaSendMediaBase {
+    readonly type: 'image';
+    readonly caption?: string;
+    readonly width?: number;
+    readonly height?: number;
+}
+interface WaSendVideoMessage extends WaSendMediaBase {
+    readonly type: 'video';
     readonly caption?: string;
-    readonly fileName?: string;
-    readonly ptt?: boolean;
     readonly gifPlayback?: boolean;
     readonly seconds?: number;
     readonly width?: number;
     readonly height?: number;
 }
+interface WaSendPtvMessage extends WaSendMediaBase {
+    readonly type: 'ptv';
+    readonly seconds?: number;
+    readonly width?: number;
+    readonly height?: number;
+}
+interface WaSendAudioMessage extends WaSendMediaBase {
+    readonly type: 'audio';
+    readonly ptt?: boolean;
+    readonly seconds?: number;
+}
+interface WaSendDocumentMessage extends WaSendMediaBase {
+    readonly type: 'document';
+    readonly caption?: string;
+    readonly fileName?: string;
+}
+interface WaSendStickerMessage extends WaSendMediaBase {
+    readonly type: 'sticker';
+    readonly width?: number;
+    readonly height?: number;
+}
+export type WaSendMediaMessage = WaSendImageMessage | WaSendVideoMessage | WaSendPtvMessage | WaSendAudioMessage | WaSendDocumentMessage | WaSendStickerMessage;
 export type WaSendMessageContent = string | Proto.IMessage | WaSendMediaMessage;
 export interface WaEncryptedMessageInput {
     readonly to: string;
@@ -43,16 +73,25 @@ export interface WaEncryptedMessageInput {
     readonly encCount?: number;
     readonly id?: string;
     readonly type?: string;
+    readonly edit?: string;
+    readonly mediatype?: string;
     readonly category?: string;
     readonly pushPriority?: string;
     readonly participant?: string;
     readonly deviceFanout?: string;
+    readonly metaNode?: BinaryNode;
 }
 export interface WaSendReceiptInput {
     readonly to: string;
     readonly id: string;
     readonly type?: string;
     readonly participant?: string;
+    readonly recipient?: string;
+    readonly category?: string;
     readonly from?: string;
     readonly t?: string;
+    readonly peerParticipantPn?: string;
+    readonly listIds?: readonly string[];
+    readonly content?: readonly BinaryNode[];
 }
+export {};

package/dist/types/protocol/appstate.d.ts

@@ -32,17 +32,6 @@ export declare const WA_APP_STATE_KDF_INFO: Readonly<{
     readonly MUTATION_KEYS: "WhatsApp Mutation Keys";
     readonly PATCH_INTEGRITY: "WhatsApp Patch Integrity";
 }>;
-export declare const WA_APP_STATE_CHAT_MUTATION_ACTIONS: Readonly<{
-    readonly STAR: "star";
-    readonly MUTE: "mute";
-    readonly PIN: "pin_v1";
-    readonly ARCHIVE: "archive";
-    readonly DELETE_MESSAGE_FOR_ME: "deleteMessageForMe";
-    readonly MARK_CHAT_AS_READ: "markChatAsRead";
-    readonly CLEAR_CHAT: "clearChat";
-    readonly DELETE_CHAT: "deleteChat";
-    readonly LOCK_CHAT: "lock";
-}>;
 export declare const WA_APP_STATE_CHAT_MUTATION_SPECS: Readonly<{
     readonly STAR: {
         readonly collection: "regular_high";

package/dist/types/protocol/constants.d.ts

@@ -1,12 +1,16 @@
 export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser';
 export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream';
+export { WA_CONNECTION_REASONS, WA_DISCONNECT_REASONS, WA_FAILURE_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream';
+export type { WaConnectionCode, WaConnectionOpenReason, WaDisconnectReason, WaFailureReasonCode, WaStreamErrorCode } from './stream';
 export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_ACTIONS, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
+export { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_POLL_META_TYPES, WA_RETRYABLE_ACK_CODES, WA_STANZA_MSG_TYPES } from './message';
+export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
 export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media';
 export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty';
 export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification';
+export { WA_PRIVACY_TOKEN_NOTIFICATION_TYPE, WA_PRIVACY_TOKEN_TAGS, WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from './privacy-token';
+export { WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES } from './privacy';
+export type { WaPrivacyCategory, WaPrivacySettingName, WaPrivacyValue } from './privacy';
 export { WA_DEFAULTS } from './defaults';
 export { WA_GROUP_PARTICIPANT_TYPES, type WaGroupSetting } from './group';
 export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync';

package/dist/types/protocol/defaults.d.ts

@@ -2,6 +2,12 @@ export declare const WA_DEFAULTS: Readonly<{
     readonly HOST_DOMAIN: "s.whatsapp.net";
     readonly GROUP_SERVER: "g.us";
     readonly BROADCAST_SERVER: "broadcast";
+    readonly LID_SERVER: "lid";
+    readonly HOSTED_SERVER: "hosted";
+    readonly HOSTED_LID_SERVER: "hosted.lid";
+    readonly HOSTED_DEVICE_ID: 99;
+    readonly MSGR_SERVER: "msgr";
+    readonly INTEROP_SERVER: "interop";
     readonly DEVICE_BROWSER: "firefox";
     readonly DEVICE_PLATFORM: string;
     readonly CHAT_SOCKET_URLS: readonly ["wss://web.whatsapp.com/ws/chat", "wss://web.whatsapp.com:5222/ws/chat"];

package/dist/types/protocol/index.d.ts

@@ -1,3 +1,2 @@
 export * from './constants';
-export { getLoginIdentity, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid } from './jid';
-export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync';
+export { buildDeviceJid, canonicalizeSignalJid, canonicalizeSignalServer, getLoginIdentity, isHostedDeviceId, isHostedDeviceJid, isHostedServer, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, signalAddressKey, toUserJid } from './jid';