zapo-js 0.2.0 → 0.3.0

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

@@ -0,0 +1,14 @@
+import type { BinaryNode } from '../../transport/types';
+export interface AbPropResponseEntry {
+    readonly configCode: number;
+    readonly configValue: string | null;
+}
+export interface AbPropSyncResult {
+    readonly abKey: string | null;
+    readonly hash: string | null;
+    readonly refresh: number | null;
+    readonly refreshId: number | null;
+    readonly isDeltaUpdate: boolean;
+    readonly props: readonly AbPropResponseEntry[];
+}
+export declare function parseAbPropsIqResult(node: BinaryNode): AbPropSyncResult;

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

@@ -0,0 +1,17 @@
+import type { BinaryNode } from '../../transport/types';
+export interface ParsedRegistrationCode {
+    readonly kind: 'registration_code';
+    readonly code: string;
+    readonly expiryTimestampMs: number;
+    readonly fromDeviceId: string;
+}
+export interface ParsedAccountTakeoverNotice {
+    readonly kind: 'account_takeover_notice';
+    readonly serverToken: string;
+    readonly attemptTimestampMs: number;
+    readonly newDeviceName?: string;
+    readonly newDevicePlatform?: string;
+    readonly newDeviceAppVersion?: string;
+}
+export type ParsedRegistrationNotification = ParsedRegistrationCode | ParsedAccountTakeoverNotice | null;
+export declare function parseRegistrationNotification(node: BinaryNode): ParsedRegistrationNotification;

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

@@ -1,4 +1,4 @@
-import type { WaIncomingBaseEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaGroupEvent } from './types';
+import type { WaAccountTakeoverNoticeEvent, WaGroupEvent, WaIncomingBaseEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaRegistrationCodeEvent } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaConnectionCode, WaDisconnectReason } from '../protocol/stream';
 import type { BinaryNode } from '../transport/types';
@@ -27,10 +27,15 @@ type IncomingGroupNotificationHandlerOptions = IncomingAckRuntime & {
     readonly emitGroupEvent: (event: WaGroupEvent) => void;
     readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
 };
+type IncomingRegistrationNotificationHandlerOptions = IncomingAckRuntime & {
+    readonly emitRegistrationCode: (event: WaRegistrationCodeEvent) => void;
+    readonly emitAccountTakeoverNotice: (event: WaAccountTakeoverNoticeEvent) => void;
+};
 export declare function createIncomingBaseEvent(node: BinaryNode): WaIncomingBaseEvent;
 export declare function createIncomingReceiptHandler(options: IncomingReceiptHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingFailureHandler(options: IncomingFailureHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingNotificationHandler(options: IncomingNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingRegistrationNotificationHandler(options: IncomingRegistrationNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingGroupNotificationHandler(options: IncomingGroupNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createInfoBulletinNotificationEvent(node: BinaryNode, type: string, details?: Readonly<Record<string, unknown>>): WaIncomingNotificationEvent;
 export declare function createUnhandledIncomingNodeEvent(node: BinaryNode, reason?: string): WaIncomingUnhandledStanzaEvent;

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

@@ -1,9 +1,11 @@
 import type { WriteBehindPersistence } from './persistence/WriteBehindPersistence';
 import type { WaIncomingMessageEvent } from './types';
 import type { Logger } from '../infra/log/types';
+import type { WaMessageSecretStore } from '../store/contracts/message-secret.store';
 interface WaPersistIncomingMailboxOptions {
     readonly logger: Logger;
     readonly writeBehind: WriteBehindPersistence;
+    readonly messageSecretStore: WaMessageSecretStore;
     readonly event: WaIncomingMessageEvent;
 }
 export declare function persistIncomingMailboxEntities(options: WaPersistIncomingMailboxOptions): void;

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

@@ -0,0 +1,31 @@
+import type { Readable } from 'node:stream';
+import type { WaMediaOptions } from './types';
+import type { Logger } from '../infra/log/types';
+import type { WaSendMediaMessage } from '../message/types';
+export interface ProcessedMediaFields {
+    readonly jpegThumbnail?: Uint8Array;
+    readonly pngThumbnail?: Uint8Array;
+    readonly width?: number;
+    readonly height?: number;
+    readonly seconds?: number;
+    readonly waveform?: Uint8Array;
+    readonly isAnimated?: boolean;
+    readonly firstFrameLength?: number;
+}
+export declare function readFileHead(filePath: string, bytes: number): Promise<Uint8Array>;
+interface WebpAnimInfo {
+    readonly isAnimated: true;
+    readonly firstFrameLength: number;
+}
+export declare function parseWebpAnimation(data: Uint8Array): WebpAnimInfo | null;
+export declare function isReadableStream(value: unknown): value is Readable;
+export declare function cleanupTempFile(filePath: string): Promise<void>;
+export interface ResolvedMediaInputs {
+    readonly processorInput?: Uint8Array | string;
+    readonly uploadMedia: Uint8Array | Readable;
+    readonly tempFilePath?: string;
+}
+export declare function resolveMediaInputs(shouldProcess: boolean, raw: Uint8Array | ArrayBuffer | Readable | string): Promise<ResolvedMediaInputs>;
+export declare function hasMediaProcessingTasks(media: WaMediaOptions | undefined, content: WaSendMediaMessage): boolean;
+export declare function runMediaProcessor(media: WaMediaOptions | undefined, input: Uint8Array | string | undefined, content: WaSendMediaMessage, logger: Logger): Promise<ProcessedMediaFields>;
+export {};

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

@@ -1,3 +1,4 @@
+import type { WaMediaOptions } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaMediaConn } from '../media/types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
@@ -11,6 +12,7 @@ export interface WaMediaMessageOptions {
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
     readonly getMediaConnCache: () => WaMediaConn | null;
     readonly setMediaConnCache: (mediaConn: WaMediaConn | null) => void;
+    readonly media?: WaMediaOptions;
 }
 export declare function buildMediaMessageContent(options: WaMediaMessageOptions, content: WaSendMessageContent): Promise<Proto.IMessage>;
 export declare function getMediaConn(options: WaMediaMessageOptions, forceRefresh?: boolean): Promise<WaMediaConn>;

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

@@ -1,6 +1,6 @@
 import type { WaWriteBehindOptions } from '../types';
 import type { Logger } from '../../infra/log/types';
-import type { BackgroundQueueFlushResult } from '../../infra/perf/BackgroundQueue';
+import { type BackgroundQueueFlushResult } from '../../infra/perf/BackgroundQueue';
 import type { WaContactStore, WaStoredContactRecord } from '../../store/contracts/contact.store';
 import type { WaMessageStore, WaStoredMessageRecord } from '../../store/contracts/message.store';
 import type { WaStoredThreadRecord, WaThreadStore } from '../../store/contracts/thread.store';

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

@@ -1,5 +1,7 @@
 import type { AppStateCollectionName } from '../appstate/types';
-import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions } from '../auth/types';
+import type { WaAuthClientOptions, WaAuthCredentials, WaAuthDangerousOptions, WaAuthSocketOptions } from '../auth/types';
+import type { WaMediaProcessor } from '../media/processor';
+import type { WaDecodedAddon } from '../message/addon-crypto';
 import type { WaMessagePublishOptions } from '../message/types';
 import type { Proto } from '..';
 import type { WaConnectionCode, WaConnectionOpenReason, WaDisconnectReason } from '../protocol/stream';
@@ -13,12 +15,16 @@ export interface WaClientProxyOptions {
 export interface WaLogoutStoreClearOptions {
     readonly auth?: boolean;
     readonly signal?: boolean;
+    readonly preKey?: boolean;
+    readonly session?: boolean;
+    readonly identity?: boolean;
     readonly senderKey?: boolean;
     readonly appState?: boolean;
     readonly retry?: boolean;
     readonly participants?: boolean;
     readonly deviceList?: boolean;
     readonly messages?: boolean;
+    readonly messageSecret?: boolean;
     readonly threads?: boolean;
     readonly contacts?: boolean;
     readonly privacyToken?: boolean;
@@ -44,7 +50,70 @@ export interface WaClientOptions extends WaAuthClientOptions, WaAuthSocketOption
         readonly emitSnapshotMutations?: boolean;
     };
     readonly privacyToken?: WaPrivacyTokenOptions;
+    readonly addons?: WaAddonOptions;
     readonly logoutStoreClear?: WaLogoutStoreClearOptions;
+    readonly media?: WaMediaOptions;
+    /**
+     * Test-only overrides intended for running against a fake server.
+     *
+     * These hooks **do not** bypass any security checks — they only swap in
+     * test fixtures (e.g. a different root CA) so the full verification code
+     * path still runs end-to-end. If you actually need to skip a check, use
+     * `dangerous` instead.
+     */
+    readonly testHooks?: WaClientTestHooks;
+    /**
+     * Dangerous escape hatches. **Do not enable in production.** Each flag here
+     * disables a security check the production code path enforces.
+     */
+    readonly dangerous?: WaClientDangerousOptions;
+}
+export interface WaClientDangerousOptions extends WaAuthDangerousOptions {
+    /**
+     * Skip the XEdDSA signature check on incoming group sender-key messages.
+     * Ciphertexts will be decrypted even if the trailing signature does not
+     * verify against the stored sender signing public key.
+     */
+    readonly disableSenderKeySignatureVerification?: boolean;
+    /**
+     * Skip HMAC verification across the app-state sync pipeline: per-mutation
+     * value and index MACs, snapshot MACs, and patch MACs. Tampered server
+     * payloads will be accepted as long as the ciphertext decrypts cleanly.
+     */
+    readonly disableAppStateMacVerification?: boolean;
+    /**
+     * Skip the truncated HMAC-SHA256 check on encrypted media payloads
+     * during download. Tampered ciphertexts will still be decrypted.
+     */
+    readonly disableMediaMacVerification?: boolean;
+}
+export interface WaClientTestHooks {
+    /**
+     * Override the noise certificate-chain root CA used to verify the
+     * server's static key during the handshake.
+     *
+     * The default is the production WhatsApp root. Tests against a fake
+     * server inject the fake server's ephemeral root here so that the lib
+     * still runs the full certificate-verification code path against a
+     * chain signed by a known key — no validation logic is bypassed.
+     */
+    readonly noiseRootCa?: WaNoiseRootCaOverride;
+}
+export interface WaNoiseRootCaOverride {
+    /** Serialized X25519 public key (32 bytes raw, no version prefix). */
+    readonly publicKey: Uint8Array;
+    /** Serial number that intermediate certificates issued by this root must declare. */
+    readonly serial: number;
+}
+export interface WaMediaOptions {
+    readonly processor?: WaMediaProcessor;
+    readonly generateThumbnail?: boolean;
+    readonly generateProbe?: boolean;
+    readonly generateWaveform?: boolean;
+    readonly generateStickerThumbnail?: boolean;
+}
+export interface WaAddonOptions {
+    readonly autoDecrypt?: boolean;
 }
 export interface WaPrivacyTokenOptions {
     readonly tcTokenDurationS?: number;
@@ -136,6 +205,26 @@ export interface WaIncomingNotificationEvent extends WaIncomingBaseEvent {
     readonly classification?: 'core' | 'out_of_scope' | 'unknown' | 'info_bulletin';
     readonly details?: Readonly<Record<string, unknown>>;
 }
+export interface WaRegistrationCodeEvent extends WaIncomingBaseEvent {
+    readonly code: string;
+    readonly expiryTimestampMs: number;
+    readonly fromDeviceId: string;
+}
+export interface WaAccountTakeoverNoticeEvent extends WaIncomingBaseEvent {
+    readonly serverToken: string;
+    readonly attemptTimestampMs: number;
+    readonly newDeviceName?: string;
+    readonly newDevicePlatform?: string;
+    readonly newDeviceAppVersion?: string;
+}
+export type WaAddonKind = 'reaction' | 'poll_vote' | 'event_response' | 'comment';
+export interface WaIncomingAddonEvent extends WaIncomingBaseEvent {
+    readonly kind: WaAddonKind;
+    readonly targetMessageId: string;
+    readonly senderJid: string;
+    readonly decrypted: WaDecodedAddon;
+    readonly raw: Proto.IMessage;
+}
 export interface WaIncomingFailureEvent extends WaIncomingBaseEvent {
     readonly failureReason?: number;
     readonly failureCode?: number;
@@ -284,12 +373,15 @@ export interface WaClientEventMap {
         readonly frame: Uint8Array;
     }) => void;
     readonly message: (event: WaIncomingMessageEvent) => void;
+    readonly message_addon: (event: WaIncomingAddonEvent) => void;
     readonly message_protocol: (event: WaIncomingProtocolMessageEvent) => void;
     readonly message_receipt: (event: WaIncomingReceiptEvent) => void;
     readonly presence: (event: WaIncomingPresenceEvent) => void;
     readonly chatstate: (event: WaIncomingChatstateEvent) => void;
     readonly call: (event: WaIncomingCallEvent) => void;
     readonly notification: (event: WaIncomingNotificationEvent) => void;
+    readonly registration_code_received: (event: WaRegistrationCodeEvent) => void;
+    readonly account_takeover_notice: (event: WaAccountTakeoverNoticeEvent) => void;
     readonly failure: (event: WaIncomingFailureEvent) => void;
     readonly stanza_error: (event: WaIncomingBaseEvent) => void;
     readonly stanza_unhandled: (event: WaIncomingUnhandledStanzaEvent) => void;
@@ -297,6 +389,13 @@ export interface WaClientEventMap {
     readonly chat_event: (event: WaChatEvent) => void;
     readonly history_sync_chunk: (event: WaHistorySyncChunkEvent) => void;
     readonly privacy_token_update: (event: WaPrivacyTokenUpdateEvent) => void;
+    readonly offline_resume: (event: WaOfflineResumeEvent) => void;
+}
+export interface WaOfflineResumeEvent {
+    readonly status: 'resuming' | 'complete';
+    readonly totalStanzas: number;
+    readonly remainingStanzas: number;
+    readonly forced: boolean;
 }
 export interface WaPrivacyTokenUpdateEvent {
     readonly jid: string;

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

@@ -8,3 +8,4 @@ export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent }
 export { buildNonce } from '../core/nonce';
 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';
+export { xeddsaSign, xeddsaVerify } from '../core/xeddsa';

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

@@ -9,7 +9,7 @@ export type CryptoKey = webcrypto.CryptoKey;
 export declare function sha256(value: Uint8Array): Promise<Uint8Array>;
 export declare function sha1(value: Uint8Array): Promise<Uint8Array>;
 export declare function sha512(value: Uint8Array): Promise<Uint8Array>;
-export declare function md5Bytes(input: string): Uint8Array;
+export declare function md5Bytes(input: string | Uint8Array): Uint8Array;
 export declare function importAesGcmKey(raw: Uint8Array, usages: ('encrypt' | 'decrypt')[]): Promise<webcrypto.CryptoKey>;
 export declare function aesGcmEncrypt(key: webcrypto.CryptoKey, nonce: Uint8Array, plaintext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
 export declare function aesGcmDecrypt(key: webcrypto.CryptoKey, nonce: Uint8Array, ciphertext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;

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

@@ -1,3 +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>;
+export declare const randomBytesAsync: (size: number) => Promise<Uint8Array>;

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

@@ -0,0 +1,2 @@
+export declare function xeddsaVerify(curvePublicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
+export declare function xeddsaSign(privateKey: Uint8Array, message: Uint8Array): Promise<Uint8Array>;

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

@@ -1,2 +1,3 @@
 export declare const X25519_PKCS8_PREFIX: Uint8Array<ArrayBufferLike>;
+export declare const X25519_SPKI_PREFIX: Uint8Array<ArrayBufferLike>;
 export declare const ED25519_PKCS8_PREFIX: Uint8Array<ArrayBufferLike>;

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

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

package/dist/types/index.d.ts

@@ -1,12 +1,13 @@
 export { WaClient } from '@client';
 export type { WaClientEventMap, WaClientOptions, WaClientProxyOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions, WaWriteBehindOptions } from '@client';
 export type { WaBlocklistResult, WaPrivacyCoordinator, WaPrivacyDisallowedListResult, WaPrivacySettings } from './client/coordinators/WaPrivacyCoordinator';
+export type { WaAuthCredentials } from './auth/types';
 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, WaCreateStoreOptions, WaDeviceListSnapshot, WaDeviceListStore, WaMessageStore, WaParticipantsSnapshot, WaParticipantsStore, WaRetryStore, WaSenderKeyStore, WaSignalStore, WaStoredContactRecord, WaStoredMessageRecord, WaStoredThreadRecord, WaStore, WaStoreBackend, WaStoreSession, WaThreadStore } from '@store';
+export type { WaAppStateCollectionStoreState, WaAppStateStore, WaAuthStore, WaContactStore, WaCreateStoreOptions, WaDeviceListSnapshot, WaDeviceListStore, WaMessageStore, WaParticipantsSnapshot, WaParticipantsStore, WaRetryStore, WaSenderKeyStore, WaSessionStore, WaSignalStore, WaIdentityStore, WaPreKeyStore, 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/log/ConsoleLogger.d.ts

@@ -1,4 +1,4 @@
-import type { LogLevel, Logger } from '../log/types';
+import type { Logger, LogLevel } from '../log/types';
 export declare class ConsoleLogger implements Logger {
     readonly level: LogLevel;
     private readonly minLevelPriority;

package/dist/types/infra/log/PinoLogger.d.ts

@@ -1,4 +1,4 @@
-import type { LogLevel, Logger } from '../log/types';
+import type { Logger, LogLevel } from '../log/types';
 type PinoLikeLogger = {
     level: string;
     trace: (...args: unknown[]) => void;

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

@@ -1,5 +1,6 @@
 type StoreTask<T> = () => Promise<T>;
 export declare class StoreLock {
+    private static readonly _noop;
     private readonly chains;
     private closed;
     run<T>(key: string, task: StoreTask<T>): Promise<T>;

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

@@ -1,12 +1,21 @@
-import type { Readable } from 'node:stream';
-import type { MediaCryptoType, WaMediaDecryptReadableOptions, WaMediaDecryptionResult, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaFileEncryptionResult, WaMediaReadableDecryptionResult, WaMediaReadableEncryptionResult } from './types';
+import { type Readable } from 'node:stream';
+import type { MediaCryptoType, WaMediaDecryptionResult, WaMediaDecryptReadableOptions, 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 encryptToFile(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable): Promise<WaMediaFileEncryptionResult>;
+    static encryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Uint8Array, options?: {
+        readonly sidecar?: boolean;
+        readonly firstFrameLength?: number;
+    }): Promise<WaMediaEncryptionResult>;
+    static decryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, ciphertextHmac: Uint8Array, expectedFileSha256?: Uint8Array, expectedFileEncSha256?: Uint8Array, skipMacVerification?: boolean): Promise<WaMediaDecryptionResult>;
+    static encryptReadable(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable, options?: {
+        readonly sidecar?: boolean;
+        readonly firstFrameLength?: number;
+    }): Promise<WaMediaReadableEncryptionResult>;
+    static encryptToFile(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable, options?: {
+        readonly sidecar?: boolean;
+        readonly firstFrameLength?: number;
+    }): 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,11 +1,10 @@
-import { Readable } from 'node:stream';
+import type { Readable } from 'node:stream';
 import type { MediaCryptoType, WaMediaReadableDecryptionResult, WaMediaTransferClientOptions } from './types';
 interface StreamDownloadRequest {
     readonly url?: string;
     readonly directPath?: string;
     readonly hosts?: readonly string[];
     readonly headers?: Readonly<Record<string, string>>;
-    readonly dispatcher?: WaMediaTransferClientOptions['defaultDownloadDispatcher'];
     readonly agent?: WaMediaTransferClientOptions['defaultDownloadAgent'];
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
@@ -51,11 +50,9 @@ export declare class WaMediaTransferClient {
     private readonly defaultTimeoutMs;
     private readonly defaultMaxReadBytes;
     private readonly defaultHeaders;
-    private readonly defaultUploadDispatcher;
-    private readonly defaultDownloadDispatcher;
     private readonly defaultUploadAgent;
     private readonly defaultDownloadAgent;
-    private gotModulePromise;
+    private readonly skipMacVerification;
     constructor(options?: WaMediaTransferClientOptions);
     downloadStream(request: StreamDownloadRequest): Promise<StreamTransferResponse>;
     downloadBytes(request: StreamDownloadRequest): Promise<Uint8Array>;
@@ -64,12 +61,7 @@ export declare class WaMediaTransferClient {
     downloadAndDecrypt(request: EncryptedDownloadRequest): Promise<Uint8Array>;
     downloadAndDecryptStream(request: EncryptedDownloadRequest): Promise<WaMediaReadableDecryptionResult>;
     readResponseBytes(response: StreamTransferResponse, maxBytes?: number): Promise<Uint8Array>;
-    private transferRequest;
-    private fetchWithDispatcher;
-    private toFetchTransferResponse;
-    private gotWithAgent;
-    private loadGotModule;
-    private toGotTransferResponse;
+    private httpRequest;
     private resolveTransferRequest;
     private prepareEncryptedUpload;
     private assertSuccessfulResponse;

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

@@ -7,4 +7,6 @@ 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 SIDECAR_CHUNK_SIZE = 65536;
+export declare const SIDECAR_HMAC_SIZE = 10;
 export declare const MEDIA_UPLOAD_PATHS: Readonly<Record<'image' | 'video' | 'audio' | 'document' | 'sticker' | 'gif' | 'ptt' | 'ptv', string>>;

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

@@ -2,3 +2,4 @@ export { WaMediaTransferClient } from './WaMediaTransferClient';
 export { parseMediaConnResponse } from './conn';
 export type { WaMediaConn } from './types';
 export { WaMediaCrypto } from './WaMediaCrypto';
+export type { WaMediaProcessor, WaMediaProcessorImageResult, WaMediaProcessorInput, WaMediaProcessorProbeResult, WaMediaProcessorStickerThumbnailResult, WaMediaProcessorWaveformResult } from './processor';

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

@@ -0,0 +1,28 @@
+import type { Readable } from 'node:stream';
+export interface WaMediaProcessorImageResult {
+    readonly jpegThumbnail: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+}
+export interface WaMediaProcessorStickerThumbnailResult {
+    readonly pngThumbnail: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+}
+export interface WaMediaProcessorProbeResult {
+    readonly durationSeconds?: number;
+    readonly width?: number;
+    readonly height?: number;
+}
+export interface WaMediaProcessorWaveformResult {
+    readonly waveform: Uint8Array;
+    readonly durationSeconds: number;
+}
+export type WaMediaProcessorInput = Uint8Array | Readable | string;
+export interface WaMediaProcessor {
+    readonly generateImageThumbnail?: (input: WaMediaProcessorInput, maxEdge: number) => Promise<WaMediaProcessorImageResult>;
+    readonly generateVideoThumbnail?: (input: WaMediaProcessorInput, maxEdge: number) => Promise<WaMediaProcessorImageResult | null>;
+    readonly probeMedia?: (input: WaMediaProcessorInput) => Promise<WaMediaProcessorProbeResult>;
+    readonly computeWaveform?: (input: WaMediaProcessorInput) => Promise<WaMediaProcessorWaveformResult | null>;
+    readonly generateStickerThumbnail?: (input: WaMediaProcessorInput, maxEdge: number) => Promise<WaMediaProcessorStickerThumbnailResult>;
+}

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

@@ -1,6 +1,6 @@
 import type { Readable } from 'node:stream';
 import type { Logger } from '../infra/log/types';
-import type { WaProxyAgent, WaProxyDispatcher } from '../transport/types';
+import type { WaProxyAgent } from '../transport/types';
 export type MediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'ptv';
 export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'history' | 'md-app-state';
 export interface WaMediaConnHost {
@@ -18,10 +18,9 @@ export interface WaMediaTransferClientOptions {
     readonly defaultTimeoutMs?: number;
     readonly defaultMaxReadBytes?: number;
     readonly defaultHeaders?: Readonly<Record<string, string>>;
-    readonly defaultUploadDispatcher?: WaProxyDispatcher;
-    readonly defaultDownloadDispatcher?: WaProxyDispatcher;
     readonly defaultUploadAgent?: WaProxyAgent;
     readonly defaultDownloadAgent?: WaProxyAgent;
+    readonly skipMacVerification?: boolean;
 }
 export interface WaMediaDerivedKeys {
     readonly iv: Uint8Array;
@@ -33,6 +32,8 @@ export interface WaMediaEncryptionResult {
     readonly ciphertextHmac: Uint8Array;
     readonly fileSha256: Uint8Array;
     readonly fileEncSha256: Uint8Array;
+    readonly streamingSidecar?: Uint8Array;
+    readonly firstFrameSidecar?: Uint8Array;
 }
 export interface WaMediaDecryptionResult {
     readonly plaintext: Uint8Array;
@@ -45,6 +46,8 @@ export interface WaMediaReadableEncryptionResult {
         readonly fileSha256: Uint8Array;
         readonly fileEncSha256: Uint8Array;
         readonly plaintextLength: number;
+        readonly streamingSidecar?: Uint8Array;
+        readonly firstFrameSidecar?: Uint8Array;
     }>;
 }
 export interface WaMediaReadableDecryptionResult {
@@ -60,10 +63,13 @@ export interface WaMediaFileEncryptionResult {
     readonly fileSha256: Uint8Array;
     readonly fileEncSha256: Uint8Array;
     readonly plaintextLength: number;
+    readonly streamingSidecar?: Uint8Array;
+    readonly firstFrameSidecar?: Uint8Array;
 }
 export interface WaMediaDecryptReadableOptions {
     readonly mediaType: MediaCryptoType;
     readonly mediaKey: Uint8Array;
     readonly expectedFileSha256?: Uint8Array;
     readonly expectedFileEncSha256?: Uint8Array;
+    readonly skipMacVerification?: boolean;
 }

package/dist/types/message/addon-crypto.d.ts

@@ -1,13 +1,18 @@
+import type { WaAddonKind } from '../client/types';
 import { WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret';
+import { type Proto } from '..';
+import type { WaMessageSecretEntry, WaMessageSecretStore } from '../store/contracts/message-secret.store';
+import type { WaMessageStore } from '../store/contracts/message.store';
 type WaAddonBytes = Uint8Array | ArrayBuffer | ArrayBufferView;
-export declare function shouldUseAddonAdditionalData(modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES]): boolean;
+type ModificationType = (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+export declare function shouldUseAddonAdditionalData(modificationType: ModificationType): boolean;
 export declare function buildAddonAdditionalData(stanzaId: string, addOnSenderJid: string): Uint8Array;
 export declare function encryptAddonPayload(input: {
     readonly messageSecret: WaAddonBytes;
     readonly stanzaId: string;
     readonly parentMsgOriginalSender: string;
     readonly modificationSender: string;
-    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+    readonly modificationType: ModificationType;
     readonly payload: WaAddonBytes;
     readonly iv: WaAddonBytes;
     readonly additionalData?: WaAddonBytes;
@@ -17,9 +22,35 @@ export declare function decryptAddonPayload(input: {
     readonly stanzaId: string;
     readonly parentMsgOriginalSender: string;
     readonly modificationSender: string;
-    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+    readonly modificationType: ModificationType;
     readonly ciphertext: WaAddonBytes;
     readonly iv: WaAddonBytes;
     readonly additionalData?: WaAddonBytes;
 }): Promise<Uint8Array>;
+export interface WaIdentifiedEncAddon {
+    readonly kind: WaAddonKind;
+    readonly targetMessageKey: Proto.IMessageKey;
+    readonly encPayload: Uint8Array;
+    readonly encIv: Uint8Array;
+    readonly modificationType: ModificationType;
+    readonly raw: Proto.IMessage;
+}
+export declare function identifyEncryptedAddon(message: Proto.IMessage): WaIdentifiedEncAddon | null;
+export type WaDecodedAddon = {
+    readonly kind: 'reaction';
+    readonly reaction: Proto.Message.IReactionMessage;
+} | {
+    readonly kind: 'poll_vote';
+    readonly pollVote: Proto.Message.IPollVoteMessage;
+    readonly selectedOptionNames: readonly string[] | null;
+} | {
+    readonly kind: 'event_response';
+    readonly eventResponse: Proto.Message.IEventResponseMessage;
+} | {
+    readonly kind: 'comment';
+    readonly comment: Proto.Message.ICommentMessage;
+};
+export declare function decodeAddonPlaintext(kind: WaAddonKind, plaintext: Uint8Array): WaDecodedAddon;
+export declare function resolveParentMessageSecret(targetMessageId: string, messageSecretStore: WaMessageSecretStore, messageStore: WaMessageStore): Promise<WaMessageSecretEntry | null>;
+export declare function resolvePollOptionNames(selectedOptions: readonly Uint8Array[], pollCreationMessageId: string, messageStore: WaMessageStore): Promise<readonly string[] | null>;
 export {};

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

@@ -1,7 +1,9 @@
 import type { WaSendMediaMessage } from './types';
-import type { Proto } from '..';
+import { type Proto } from '..';
 export declare function isSendMediaMessage(content: unknown): content is WaSendMediaMessage;
+export declare function unwrapMessage(message: Proto.IMessage): Proto.IMessage;
 export declare function resolveMessageTypeAttr(message: Proto.IMessage): string;
+export declare function needsSecretPersistence(message: Proto.IMessage): boolean;
 export declare function resolveEditAttr(message: Proto.IMessage, subtype?: string): string | null;
 export declare function resolveEncMediaType(message: Proto.IMessage): string | null;
 export interface MessageMetaAttrs {

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

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