zapo-js 1.4.0 → 1.5.0

package/dist/esm/auth/pairing/companion-host.js

@@ -0,0 +1,140 @@
+import { aesCtrDecrypt, aesCtrEncrypt, aesGcmDecrypt, hkdf, pbkdf2Sha256, randomBytesAsync, toRawPubKey, X25519 } from '../../crypto/index.js';
+import { proto } from '../../proto.js';
+import { WA_PAIRING_KDF_INFO } from '../../protocol/index.js';
+import { computeAdvIdentityHmac, generateDeviceIdentityAccountSignature, signKeyIndexList } from '../../signal/index.js';
+import { concatBytes, decodeBase64Url, TEXT_ENCODER, uint8Equal } from '../../util/bytes.js';
+const PEM_HKDF_INFO = TEXT_ENCODER.encode('Canonical Ent Companion Nonce Encrypt');
+const PBKDF2_ITERATIONS = 131072;
+const PAIRING_AES_KEY_BYTES = 32;
+/**
+ * Parses a companion pairing QR of the form
+ * `ref,noisePubB64,identityPubB64,advSecretB64,platform`. The `ref` may itself
+ * contain commas, so the four trailing fields are taken from the end.
+ *
+ * @throws when fewer than 5 comma-separated fields are present.
+ */
+export function parseCompanionQr(qr) {
+    const parts = qr.split(',');
+    if (parts.length < 5) {
+        throw new Error(`companion qr must have at least 5 comma-separated parts, got ${parts.length}`);
+    }
+    const platform = parts[parts.length - 1];
+    const advSecretB64 = parts[parts.length - 2];
+    const identityPubB64 = parts[parts.length - 3];
+    const noisePubB64 = parts[parts.length - 4];
+    const ref = parts.slice(0, parts.length - 4).join(',');
+    return {
+        ref,
+        noisePublicKey: decodeBase64Url(noisePubB64, 'companionQr.noisePublicKey'),
+        identityPublicKey: decodeBase64Url(identityPubB64, 'companionQr.identityPublicKey'),
+        advSecretKey: decodeBase64Url(advSecretB64, 'companionQr.advSecretKey'),
+        platform
+    };
+}
+/**
+ * Builds the account-signed `ADVSignedKeyIndexList` bytes for the current device
+ * set. The zero-valued `accountType` enum is omitted to match the phone's byte
+ * layout.
+ */
+export async function buildSignedKeyIndexList(input) {
+    const details = proto.ADVKeyIndexList.encode({
+        rawId: input.rawId,
+        timestamp: input.timestampSeconds,
+        currentIndex: input.currentIndex,
+        validIndexes: [...input.validIndexes]
+    }).finish();
+    const accountSignature = await signKeyIndexList(details, input.accountIdentityKeyPair);
+    return proto.ADVSignedKeyIndexList.encode({ details, accountSignature }).finish();
+}
+/**
+ * Builds the signed device identity and key-index list for a linking companion.
+ * The byte layout mirrors WhatsApp's phone (and the in-repo fake-server
+ * reference): the zero-valued `accountType`/`deviceType` enum fields are omitted
+ * so the signed `details` match what the companion verifies.
+ */
+export async function buildSignedCompanionIdentity(input) {
+    const accountSignatureKey = toRawPubKey(input.accountIdentityKeyPair.pubKey);
+    const details = proto.ADVDeviceIdentity.encode({
+        rawId: input.rawId,
+        timestamp: input.timestampSeconds,
+        keyIndex: input.keyIndex
+    }).finish();
+    const accountSignature = await generateDeviceIdentityAccountSignature(details, input.companionIdentityPublicKey, input.accountIdentityKeyPair);
+    const signedIdentity = proto.ADVSignedDeviceIdentity.encode({
+        details,
+        accountSignatureKey,
+        accountSignature
+    }).finish();
+    const hmac = computeAdvIdentityHmac(input.advSecretKey, signedIdentity);
+    const deviceIdentityBytes = proto.ADVSignedDeviceIdentityHMAC.encode({
+        details: signedIdentity,
+        hmac
+    }).finish();
+    const keyIndexListBytes = await buildSignedKeyIndexList({
+        accountIdentityKeyPair: input.accountIdentityKeyPair,
+        rawId: input.rawId,
+        currentIndex: input.keyIndex,
+        timestampSeconds: input.timestampSeconds,
+        validIndexes: input.validIndexes
+    });
+    return { deviceIdentityBytes, keyIndexListBytes };
+}
+/**
+ * Derives the `<pem>` AES-GCM key the phone ships in the pair-device upload:
+ * `HKDF-SHA256(ikm = advSecret, salt = companionNoisePublicKey, info)`. Not yet
+ * verified against a live server from this implementation; see
+ * `CompanionHostOptions.includePem`.
+ */
+export function derivePemKey(advSecretKey, companionNoisePublicKey) {
+    return hkdf(advSecretKey, companionNoisePublicKey, PEM_HKDF_INFO, 32);
+}
+/**
+ * Link-code handshake, primary step 1: unwrap the companion ephemeral with the
+ * pairing code, generate the primary ephemeral, compute the shared ECDH secret,
+ * and wrap the primary ephemeral for the `primary_hello` stanza. Mirror of the
+ * companion's `createCompanionHello` + primary-ephemeral unwrap.
+ */
+export async function preparePrimaryHello(args) {
+    if (args.wrappedCompanionEphemeralPub.length < 48) {
+        throw new Error(`wrapped companion ephemeral pub too short: ${args.wrappedCompanionEphemeralPub.length} bytes (need >= 48)`);
+    }
+    const codeBytes = TEXT_ENCODER.encode(args.pairingCode);
+    const companionCipherKey = await pbkdf2Sha256(codeBytes, args.wrappedCompanionEphemeralPub.subarray(0, 32), PBKDF2_ITERATIONS, PAIRING_AES_KEY_BYTES);
+    const companionEphemeralPub = aesCtrDecrypt(companionCipherKey, args.wrappedCompanionEphemeralPub.subarray(32, 48), args.wrappedCompanionEphemeralPub.subarray(48));
+    const [primaryEphemeralKeyPair, salt, counter] = await Promise.all([
+        X25519.generateKeyPair(),
+        randomBytesAsync(32),
+        randomBytesAsync(16)
+    ]);
+    const primaryCipherKey = await pbkdf2Sha256(codeBytes, salt, PBKDF2_ITERATIONS, PAIRING_AES_KEY_BYTES);
+    const encrypted = aesCtrEncrypt(primaryCipherKey, counter, primaryEphemeralKeyPair.pubKey);
+    const sharedEphemeral = await X25519.scalarMult(primaryEphemeralKeyPair.privKey, companionEphemeralPub);
+    return {
+        primaryEphemeralKeyPair,
+        wrappedPrimaryEphemeralPub: concatBytes([salt, counter, encrypted]),
+        sharedEphemeral
+    };
+}
+/**
+ * Link-code handshake, primary step 2: decrypt the `companion_finish` key bundle
+ * and derive the shared `advSecret` (byte-identical to what the companion
+ * derives). Validates that the bundle binds both identities.
+ *
+ * @throws when the bundle's embedded identities do not match.
+ */
+export async function completePrimaryHandshake(args) {
+    const bundleEncryptionKey = hkdf(args.sharedEphemeral, args.wrappedKeyBundle.subarray(0, 32), WA_PAIRING_KDF_INFO.LINK_CODE_BUNDLE, 32);
+    const plaintextBundle = aesGcmDecrypt(bundleEncryptionKey, args.wrappedKeyBundle.subarray(32, 44), args.wrappedKeyBundle.subarray(44));
+    const bundleCompanionIdentity = plaintextBundle.subarray(0, 32);
+    const bundlePrimaryIdentity = plaintextBundle.subarray(32, 64);
+    const bundleSecret = plaintextBundle.subarray(64);
+    const rawCompanionIdentity = toRawPubKey(args.companionIdentityPub);
+    if (!uint8Equal(bundlePrimaryIdentity, toRawPubKey(args.primaryIdentityKeyPair.pubKey))) {
+        throw new Error('link-code bundle primary identity mismatch');
+    }
+    if (!uint8Equal(bundleCompanionIdentity, rawCompanionIdentity)) {
+        throw new Error('link-code bundle companion identity mismatch');
+    }
+    const sharedIdentity = await X25519.scalarMult(args.primaryIdentityKeyPair.privKey, rawCompanionIdentity);
+    return hkdf(concatBytes([args.sharedEphemeral, sharedIdentity, bundleSecret]), null, WA_PAIRING_KDF_INFO.ADV_SECRET, 32);
+}

package/dist/esm/client/WaClient.js

@@ -12,7 +12,7 @@ import { normalizeDeviceJid } from '../protocol/jid.js';
 import { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS } from '../protocol/stream.js';
 import { buildRemoveCompanionDeviceIq } from '../transport/node/builders/device.js';
 import { assertIqResult, queryWithContext as queryNodeWithContext } from '../transport/node/query.js';
-import { fetchLatestWaWebVersion } from '../transport/wa-web-version-fetcher.js';
+import { fetchLatestWaMobileVersion, fetchLatestWaWebVersion } from '../transport/wa-version-fetcher.js';
 import { toError } from '../util/primitives.js';
 const SYNC_RELATED_PROTOCOL_TYPES = new Set([
     proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST,
@@ -70,13 +70,14 @@ class WaClientImpl extends EventEmitter {
         this.deps = dependencies;
         this.appStateSync = dependencies.appStateSync;
         this.mediaTransfer = dependencies.mediaTransfer;
-        this.disposePlugins = installWaClientPlugins(this, {
+        this.pluginInstallInput = {
             options: this.options,
             logger: this.logger,
             stores: this.stores,
             deps: this.deps,
             queryWithContext: this.queryWithContext.bind(this)
-        }, this.options.plugins ?? []);
+        };
+        this.installPlugins();
         this.bindNodeTransportEvents();
         this.on('connection', (event) => {
             if (event.status !== 'close')
@@ -85,22 +86,43 @@ class WaClientImpl extends EventEmitter {
                 return;
             if (event.reason !== WA_DISCONNECT_REASONS.FAILURE_CLIENT_TOO_OLD)
                 return;
-            this.logger.warn('wa rejected the connect with client_too_old: the zapo default WA Web version is outdated. ' +
-                'Auto-recovering by fetching the current version from web.whatsapp.com – ' +
+            this.logger.warn('wa rejected the connect with client_too_old: the zapo default WA version is outdated. ' +
+                'Auto-recovering by fetching the current version from the public source – ' +
                 'please upgrade zapo so the shipped default catches up.');
             void this.runClientTooOldRecover();
         });
+        this.on('connection', (event) => {
+            if (event.status !== 'open')
+                return;
+            void this.deps.mobileCoordinator.reconcileCompanions().catch((error) => {
+                this.logger.debug('companion reconcile on connect failed', {
+                    message: toError(error).message
+                });
+            });
+        });
+    }
+    installPlugins() {
+        this.disposePlugins = installWaClientPlugins(this, this.pluginInstallInput, this.options.plugins ?? []);
     }
     async runClientTooOldRecover() {
         try {
             if (this.connectPromise) {
                 await this.connectPromise.catch(() => undefined);
             }
-            const latest = await fetchLatestWaWebVersion();
+            const mobile = this.deps.isMobilePrimary();
+            const latest = mobile
+                ? await fetchLatestWaMobileVersion()
+                : await fetchLatestWaWebVersion();
             this.logger.info('client_too_old auto-recover: reconnecting', {
+                transport: mobile ? 'mobile' : 'web',
                 version: latest.version
             });
-            this.deps.authClient.setNextConnectVersion(latest.version);
+            if (mobile) {
+                this.deps.authClient.setNextConnectMobileAppVersion(latest.version);
+            }
+            else {
+                this.deps.authClient.setNextConnectVersion(latest.version);
+            }
             await this.connect();
         }
         catch (error) {
@@ -306,6 +328,9 @@ class WaClientImpl extends EventEmitter {
             this.logger.trace('wa client connect already in-flight');
             return this.connectPromise;
         }
+        if (!this.disposePlugins) {
+            this.installPlugins();
+        }
         this.writeBehind.restart();
         this.acceptingIncomingEvents = true;
         this.connectPromise = this.deps.connectionManager
@@ -329,11 +354,12 @@ class WaClientImpl extends EventEmitter {
     }
     /**
      * Closes the transport gracefully: pauses incoming events, flushes the
-     * write-behind persistence queue, and emits a `connection` close event
-     * with reason `client_disconnected`. Does not clear stored credentials -
-     * call {@link connect} again to resume the same session. There is no
-     * built-in auto-reconnect; subscribe to `connection: { status: 'close' }`
-     * and decide your own backoff.
+     * write-behind persistence queue, disposes installed plugins, and emits a
+     * `connection` close event with reason `client_disconnected`. Does not
+     * clear stored credentials - call {@link connect} again to resume the same
+     * session, which reinstalls the plugins. There is no built-in
+     * auto-reconnect; subscribe to `connection: { status: 'close' }` and decide
+     * your own backoff.
      */
     async disconnect() {
         await this.pauseIncomingEventsAndWaitDrain();
@@ -450,6 +476,14 @@ class WaClientImpl extends EventEmitter {
     get email() {
         return this.deps.emailCoordinator;
     }
+    /**
+     * Mobile coordinator: host and manage companion devices linked to this
+     * mobile-primary account (link via QR or pairing code, list, revoke).
+     * Requires a registered primary session. See {@link WaMobileCoordinator}.
+     */
+    get mobile() {
+        return this.deps.mobileCoordinator;
+    }
     /**
      * Unpairs this companion device by removing it server-side. Requires an
      * authenticated session; throws when no `meJid` is present.

package/dist/esm/client/WaClientFactory.js

@@ -13,6 +13,7 @@ import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordina
 import { createLowLevelCoordinator } from './coordinators/WaLowLevelCoordinator.js';
 import { WaMessageCoordinator } from './coordinators/WaMessageCoordinator.js';
 import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator.js';
+import { WaMobileCoordinator } from './coordinators/WaMobileCoordinator.js';
 import { createNewsletterCoordinator } from './coordinators/WaNewsletterCoordinator.js';
 import { WaOfflineResumeCoordinator } from './coordinators/WaOfflineResumeCoordinator.js';
 import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator.js';
@@ -38,7 +39,7 @@ import { processNewsletterLiveUpdates } from '../message/kinds/newsletter.js';
 import { handleIncomingMessageAck } from '../message/primitives/incoming.js';
 import { createPeerDataOperationRequester } from '../message/primitives/peer-data-operation.js';
 import { WaMessageClient } from '../message/WaMessageClient.js';
-import { getWaCompanionPlatformId, WA_DEFAULTS, WA_DISCONNECT_REASONS, WA_NEWSLETTER_NOTIFICATION_TAGS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES, WA_PRIVACY_TOKEN_NOTIFICATION_TYPE } from '../protocol/constants.js';
+import { resolveWaDeviceIdentity, WA_DEFAULTS, WA_DISCONNECT_REASONS, WA_NEWSLETTER_NOTIFICATION_TAGS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES, WA_PRIVACY_TOKEN_NOTIFICATION_TYPE } from '../protocol/constants.js';
 import { isNewsletterJid, isOwnAccountJid, parseSignalAddressFromJid, toUserJid } from '../protocol/jid.js';
 import { WA_PRESENCE_TYPES } from '../protocol/presence.js';
 import { createOutboundRetryTracker } from '../retry/tracker.js';
@@ -61,7 +62,6 @@ import { WaNodeTransport } from '../transport/node/WaNodeTransport.js';
 import { isProxyTransport, toProxyAgent } from '../transport/proxy.js';
 import { createServerClock } from '../util/clock.js';
 import { toError } from '../util/primitives.js';
-import { getRuntimeOsDisplayName } from '../util/runtime.js';
 function assertProxyTransport(value, path) {
     if (value === undefined) {
         return;
@@ -85,7 +85,7 @@ function validateProxyOptions(options) {
 }
 export function resolveWaClientBase(options, logger) {
     validateProxyOptions(options);
-    const deviceBrowser = options.deviceBrowser ?? WA_DEFAULTS.DEVICE_BROWSER;
+    const device = resolveWaDeviceIdentity(options);
     const sessionId = options.sessionId.trim();
     if (sessionId.length === 0) {
         throw new Error('sessionId must be a non-empty string');
@@ -94,9 +94,9 @@ export function resolveWaClientBase(options, logger) {
     const normalizedOptions = Object.freeze({
         ...options,
         sessionId,
-        deviceBrowser,
-        deviceOsDisplayName: options.deviceOsDisplayName ?? getRuntimeOsDisplayName(),
-        devicePlatform: options.devicePlatform ?? getWaCompanionPlatformId(deviceBrowser),
+        deviceBrowser: device.browser,
+        deviceOsDisplayName: device.osDisplayName,
+        devicePlatform: device.platform,
         urls: options.urls ?? options.chatSocketUrls ?? WA_DEFAULTS.CHAT_SOCKET_URLS,
         iqTimeoutMs: options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS,
         nodeQueryTimeoutMs: options.nodeQueryTimeoutMs ?? WA_DEFAULTS.NODE_QUERY_TIMEOUT_MS,
@@ -451,6 +451,7 @@ export function buildWaClientDependencies(input) {
     });
     messageDispatch = new WaMessageDispatchCoordinator({
         logger,
+        emitMessageSend: (event) => runtime.emitEvent('message_send', event),
         messageClient,
         retryTracker,
         sessionResolver,
@@ -587,6 +588,7 @@ export function buildWaClientDependencies(input) {
         serverClock,
         emitSnapshotMutations: options.chatEvents?.emitSnapshotMutations === true,
         emitMutation: (event) => runtime.emitEvent('mutation', event),
+        emitMutationSend: (event) => runtime.emitEvent('mutation_send', event),
         nctSaltSink: (salt) => trustedContactToken.handleNctSaltSync(salt),
         contactSink: runtime.persistContact,
         pushNameSink: (name) => {
@@ -1013,6 +1015,20 @@ export function buildWaClientDependencies(input) {
         isConnected: () => connectionManager?.isConnected() ?? false,
         defaultIqTimeoutMs: options.iqTimeoutMs
     });
+    const mobileCoordinator = new WaMobileCoordinator({
+        logger,
+        authClient,
+        messageDispatch,
+        chatCoordinator: appStateMutations,
+        deviceSync: signalDeviceSync,
+        appStateStore: sessionStore.appState,
+        queryWithContext: runtime.queryWithContext,
+        emitEvent: runtime.emitEvent,
+        registerIncomingHandler: (registration) => incomingNode.registerIncomingHandler(registration),
+        isMobilePrimary,
+        persistence: options.companionHost?.persistence,
+        includePem: options.companionHost?.includePem
+    });
     return {
         nodeTransport,
         nodeOrchestrator,
@@ -1053,6 +1069,8 @@ export function buildWaClientDependencies(input) {
         connectionManager,
         trustedContactToken,
         abPropsCoordinator,
-        peerDataOperation
+        peerDataOperation,
+        mobileCoordinator,
+        isMobilePrimary
     };
 }

package/dist/esm/client/coordinators/WaAppStateMutationCoordinator.js

@@ -11,6 +11,8 @@ const WA_APP_STATE_MUTATION_FLUSH_SUCCESS_STATES = new Set([
     WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE
 ]);
 const WA_APP_STATE_ARCHIVE_RANGE_DEFAULT_LIMIT = 256;
+/** Placeholder MACs for locally-emitted mutation events (the parser ignores them). */
+const WA_EMPTY_MUTATION_MAC = new Uint8Array(0);
 function buildMutationIndexFromSchema(schema, indexArgs) {
     const parts = new Array(schema.indexParts.length);
     const args = indexArgs;
@@ -157,7 +159,6 @@ function buildRemoveMutationFromSchema(input) {
         collection: input.schema.collection,
         operation: 'remove',
         index: buildMutationIndexFromSchema(input.schema, input.indexArgs),
-        previousValue: { timestamp: input.timestamp },
         version: input.schema.version,
         timestamp: input.timestamp
     };
@@ -177,6 +178,7 @@ export class WaAppStateMutationCoordinator {
         this.serverClock = options.serverClock;
         this.archiveRangeLimit = resolvePositive(options.archiveRangeLimit, WA_APP_STATE_ARCHIVE_RANGE_DEFAULT_LIMIT, 'WaAppStateMutationCoordinatorOptions.archiveRangeLimit');
         this.emitMutation = options.emitMutation;
+        this.emitMutationSend = options.emitMutationSend;
         this.emitSnapshotMutations = options.emitSnapshotMutations === true;
         this.nctSaltSink = options.nctSaltSink;
         this.contactSink = options.contactSink;
@@ -614,9 +616,43 @@ export class WaAppStateMutationCoordinator {
     async enqueueAndFlush(mutations) {
         for (const mutation of mutations) {
             this.enqueueMutation(mutation);
+            this.emitLocalMutation(mutation);
         }
         await this.flushMutations();
     }
+    /**
+     * Surfaces an action this client is sending via the outbound `mutation_send`
+     * event, so consumers can observe their own change at action time. Parse
+     * failures are swallowed (best-effort).
+     */
+    emitLocalMutation(input) {
+        if (!this.emitMutationSend)
+            return;
+        const value = input.operation === 'set' ? input.value : null;
+        try {
+            const event = parseAppStateMutationEvent({
+                collection: input.collection,
+                operation: input.operation,
+                source: 'local',
+                index: input.index,
+                value,
+                version: input.version,
+                indexMac: WA_EMPTY_MUTATION_MAC,
+                valueMac: WA_EMPTY_MUTATION_MAC,
+                keyId: WA_EMPTY_MUTATION_MAC,
+                timestamp: input.timestamp
+            });
+            if (event)
+                this.emitMutationSend(event);
+        }
+        catch (error) {
+            this.logger.debug('failed to emit local app-state mutation event', {
+                collection: input.collection,
+                index: input.index,
+                message: toError(error).message
+            });
+        }
+    }
     enqueueMutation(mutation) {
         const key = `${mutation.collection}\u0001${mutation.index}`;
         if (this.pendingMutations.has(key)) {

package/dist/esm/client/coordinators/WaGroupCoordinator.js

@@ -2,6 +2,7 @@ import { parseParticipants as parseGroupEventParticipants } from '../events/grou
 import { WA_DEFAULTS } from '../../protocol/defaults.js';
 import { WA_GROUP_PARTICIPANT_TYPES } from '../../protocol/group.js';
 import { parseJidFull } from '../../protocol/jid.js';
+import { WA_ADDRESSING_MODES } from '../../protocol/message.js';
 import { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/nodes.js';
 import { WA_GROUP_NOTIFICATION_TAGS } from '../../protocol/notification.js';
 import { buildListParticipatingGroupsIq } from '../../transport/node/builders/account-sync.js';
@@ -87,7 +88,11 @@ function parseGroupCommons(target) {
         ? findNodeChild(membershipApprovalNode, WA_NODE_TAGS.GROUP_JOIN)
         : undefined;
     const addressingModeRaw = attrs.addressing_mode;
-    const addressingMode = addressingModeRaw === 'lid' ? 'lid' : addressingModeRaw === 'pn' ? 'pn' : undefined;
+    const addressingMode = addressingModeRaw === WA_ADDRESSING_MODES.LID
+        ? WA_ADDRESSING_MODES.LID
+        : addressingModeRaw === WA_ADDRESSING_MODES.PN
+            ? WA_ADDRESSING_MODES.PN
+            : undefined;
     const rawJid = attrs.id ?? attrs.jid ?? '';
     const jid = rawJid && !rawJid.includes('@') ? `${rawJid}@${WA_DEFAULTS.GROUP_SERVER}` : rawJid;
     return {

package/dist/esm/client/coordinators/WaMessageDispatchCoordinator.js

@@ -11,7 +11,7 @@ import { wrapDeviceSentMessage } from '../../message/encode/device-sent.js';
 import { writeRandomPadMax16 } from '../../message/encode/padding.js';
 import { buildBotInvokeProtoCopy, extractInvokedBotJid, genBotMsgSecret } from '../../message/kinds/bot.js';
 import { proto } from '../../proto.js';
-import { WA_DEFAULTS, WA_NACK_REASONS } from '../../protocol/constants.js';
+import { WA_ADDRESSING_MODES, WA_DEFAULTS, WA_NACK_REASONS } from '../../protocol/constants.js';
 import { canonicalizeOwnAccountJid, isBotJid, isGroupJid, isHostedDeviceJid, isLidJid, isNewsletterJid, isUserJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parseSignalAddressFromJid, signalAddressKey, toUserJid } from '../../protocol/jid.js';
 import { encodeBinaryNode } from '../../transport/binary/index.js';
 import { buildButtonAddonNode, buildDirectMessageFanoutNode, buildGroupSenderKeyMessageNode, buildMetaNode } from '../../transport/node/builders/message.js';
@@ -200,6 +200,16 @@ export class WaMessageDispatchCoordinator {
             }
             : withViewOnce;
         const upload = built.upload;
+        if (this.deps.emitMessageSend) {
+            try {
+                this.deps.emitMessageSend({ to: recipientJid, id: sendOptions.id, message });
+            }
+            catch (error) {
+                this.deps.logger.debug('message_send emit failed', {
+                    message: toError(error).message
+                });
+            }
+        }
         const messageWithOverride = options.messageSecret
             ? {
                 ...message,
@@ -891,17 +901,17 @@ export class WaMessageDispatchCoordinator {
     resolveGroupAddressingMode(participantUserJids, groupJid) {
         for (let index = 0; index < participantUserJids.length; index += 1) {
             if (isLidJid(participantUserJids[index])) {
-                return 'lid';
+                return WA_ADDRESSING_MODES.LID;
             }
         }
         this.deps.logger.trace('group addressing mode resolved to pn (default)', {
             groupJid,
             participants: participantUserJids.length
         });
-        return 'pn';
+        return WA_ADDRESSING_MODES.PN;
     }
     resolveSenderForAddressingMode(addressingMode, meJid) {
-        if (addressingMode === 'lid') {
+        if (addressingMode === WA_ADDRESSING_MODES.LID) {
             const meLid = this.deps.getCurrentCredentials()?.meLid;
             if (meLid && meLid.includes('@')) {
                 try {