zapo-js 1.1.1 → 1.1.2

package/dist/client/coordinators/WaRetryCoordinator.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaRetryCoordinator = void 0;
+const keys_1 = require("../../crypto/core/keys");
+const BoundedTaskQueue_1 = require("../../infra/perf/BoundedTaskQueue");
 const incoming_1 = require("../../message/primitives/incoming");
 const _proto_1 = require("../../proto");
 const constants_1 = require("../../protocol/constants");
@@ -17,6 +19,10 @@ const collections_1 = require("../../util/collections");
 const primitives_1 = require("../../util/primitives");
 const RETRY_CLEANUP_INTERVAL_MS = 30000;
 const RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES = 8192;
+// Decrypt-failure handling runs off the inbound pipeline (keys-section builds
+// serialize on the prekey lock and hit the store); excess under flood is dropped.
+const DECRYPT_FAILURE_QUEUE_MAX_SIZE = 1024;
+const DECRYPT_FAILURE_QUEUE_MAX_CONCURRENCY = 8;
 const PLACEHOLDER_RESEND_RETRY_THRESHOLD = 3;
 const PLACEHOLDER_RESEND_BATCH_SIZE = 32;
 const PLACEHOLDER_RESEND_DEBOUNCE_MS = 200;
@@ -58,22 +64,46 @@ class WaRetryCoordinator {
             signalProtocol: options.signalProtocol,
             sessionResolver: options.sessionResolver,
             getCurrentCredentials: options.getCurrentCredentials,
-            resolveUserIcdc: options.resolveUserIcdc
+            resolveUserIcdc: options.resolveUserIcdc,
+            resolvePrivacyTokenNode: options.resolvePrivacyTokenNode
         });
         this.retryProcessingByMessageId = new Map();
         this.retrySessionBaseKeys = new Map();
+        this.decryptFailureQueue = new BoundedTaskQueue_1.BoundedTaskQueue(DECRYPT_FAILURE_QUEUE_MAX_SIZE, DECRYPT_FAILURE_QUEUE_MAX_CONCURRENCY);
     }
-    async onDecryptFailure(context, error) {
+    onDecryptFailure(context, error) {
+        // Deferred to the bounded queue: building the receipt inline would stall
+        // the inbound node pipeline.
+        void this.decryptFailureQueue
+            .enqueue(() => this.handleDecryptFailure(context, error))
+            .catch((queueError) => {
+            if (queueError instanceof BoundedTaskQueue_1.BoundedTaskQueueFullError) {
+                this.deps.logger.warn('decrypt-failure retry dropped: queue saturated', {
+                    id: context.stanzaId,
+                    from: context.from,
+                    participant: context.participant
+                });
+                return;
+            }
+            this.deps.logger.warn('failed to schedule decrypt-failure retry', {
+                id: context.stanzaId,
+                from: context.from,
+                participant: context.participant,
+                message: (0, primitives_1.toError)(queueError).message
+            });
+        });
+        return Promise.resolve(true);
+    }
+    async handleDecryptFailure(context, error) {
         try {
             const prepared = await this.prepareDecryptFailureRetry(context, error);
-            if (!prepared) {
-                return false;
+            if (prepared && !prepared.delegatedToPlaceholderResend) {
+                await this.sendDecryptFailureRetryReceipt(context, prepared);
             }
-            if (prepared.delegatedToPlaceholderResend) {
-                return true;
-            }
-            await this.sendDecryptFailureRetryReceipt(context, prepared);
-            return true;
+            // Ack the failed stanza even on the give-up path: the retry receipt
+            // asks for a resend but does not consume the message, so without the
+            // ack it is redelivered on every offline resume.
+            await this.sendDecryptFailureAck(context);
         }
         catch (sendError) {
             this.deps.logger.warn('failed to send retry receipt for decrypt failure', {
@@ -82,7 +112,6 @@ class WaRetryCoordinator {
                 participant: context.participant,
                 message: (0, primitives_1.toError)(sendError).message
             });
-            return false;
         }
     }
     async handleIncomingRetryReceipt(receiptNode) {
@@ -141,6 +170,17 @@ class WaRetryCoordinator {
         const requester = context.participant ?? context.from;
         const expiresAtMs = nowMs + this.retryTtlMs;
         const retryCount = await this.deps.retryStore.incrementInboundCounter(context.stanzaId, requester, nowMs, expiresAtMs);
+        if (retryCount > constants_2.MAX_RETRY_ATTEMPTS) {
+            // Give up past the ceiling: each attempt rebuilds an expensive keys
+            // section, so an uncapped retry on redelivered backlog hammers the store.
+            this.deps.logger.debug('retry receipt skipped: inbound retry limit exceeded', {
+                id: context.stanzaId,
+                from: context.from,
+                participant: context.participant,
+                retryCount
+            });
+            return null;
+        }
         const delegatedToPlaceholderResend = retryCount >= PLACEHOLDER_RESEND_RETRY_THRESHOLD &&
             this.enqueuePlaceholderResend(context);
         if (delegatedToPlaceholderResend) {
@@ -194,6 +234,35 @@ class WaRetryCoordinator {
             withKeys: prepared.retryKeys !== undefined
         });
     }
+    async sendDecryptFailureAck(context) {
+        if (!context.stanzaId || !context.from) {
+            return;
+        }
+        try {
+            await this.deps.sendNode((0, global_1.buildAckNode)({
+                kind: 'message',
+                node: context.messageNode,
+                id: context.stanzaId,
+                to: context.from,
+                participant: context.participant,
+                from: this.deps.getCurrentCredentials()?.meJid ?? undefined,
+                error: constants_1.WA_NACK_REASONS.UNHANDLED_ERROR
+            }));
+            this.deps.logger.trace('acked undecryptable stanza', {
+                id: context.stanzaId,
+                from: context.from,
+                participant: context.participant
+            });
+        }
+        catch (error) {
+            this.deps.logger.warn('failed to ack undecryptable stanza', {
+                id: context.stanzaId,
+                from: context.from,
+                participant: context.participant,
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+    }
     async handleParsedRetryRequest(receiptNode, request) {
         if (request.type === constants_1.WA_MESSAGE_TYPES.RECEIPT_TYPE_ENC_REKEY_RETRY) {
             this.deps.logger.debug('received enc_rekey_retry request (voip path deferred)', {
@@ -367,14 +436,14 @@ class WaRetryCoordinator {
         await this.deps.preKeyStore.markKeyAsUploaded(preKey.keyId);
         const signedIdentity = this.deps.getCurrentCredentials()?.signedIdentity;
         return {
-            identity,
+            identity: (0, keys_1.toRawPubKey)(identity),
             key: {
                 id: preKey.keyId,
-                publicKey: preKey.keyPair.pubKey
+                publicKey: (0, keys_1.toRawPubKey)(preKey.keyPair.pubKey)
             },
             skey: {
                 id: signedPreKey.keyId,
-                publicKey: signedPreKey.keyPair.pubKey,
+                publicKey: (0, keys_1.toRawPubKey)(signedPreKey.keyPair.pubKey),
                 signature: signedPreKey.signature
             },
             deviceIdentity: signedIdentity
@@ -702,6 +771,9 @@ class WaRetryCoordinator {
         if (!this.deps.peerDataOperation || !this.deps.emitIncomingMessage) {
             return false;
         }
+        if (this.deps.isMobilePrimary?.()) {
+            return false;
+        }
         const subtype = context.messageNode.attrs.subtype;
         if (typeof subtype === 'string' && PLACEHOLDER_RESEND_SKIP_SUBTYPES.has(subtype)) {
             return false;
@@ -759,6 +831,7 @@ class WaRetryCoordinator {
                         }
                     }))
                 });
+                const meJid = this.deps.getCurrentCredentials()?.meJid;
                 for (const result of results) {
                     const bytes = result.placeholderMessageResendResponse?.webMessageInfoBytes;
                     if (!bytes) {
@@ -766,7 +839,7 @@ class WaRetryCoordinator {
                     }
                     try {
                         const recovered = _proto_1.proto.WebMessageInfo.decode(bytes);
-                        emitIncomingMessage((0, incoming_1.buildRecoveredIncomingEvent)(recovered));
+                        emitIncomingMessage((0, incoming_1.buildRecoveredIncomingEvent)(recovered, meJid));
                     }
                     catch (error) {
                         this.deps.logger.warn('placeholder resend: failed to decode WebMessageInfo', {

package/dist/esm/appstate/sync/WaAppStateSyncClient.js

@@ -35,20 +35,33 @@ export class WaAppStateSyncClient {
         this.sendKeyShare = options.sendKeyShare;
         this.triggerSync = options.triggerSync;
         this.crypto = new WaAppStateCrypto(undefined, options.skipMacVerification === true);
-        this.mobilePrimary = options.mobilePrimary ?? false;
+        this.mobilePrimary = options.mobilePrimary ?? (() => false);
         this.syncContext = null;
         this.syncPromise = null;
     }
     /**
      * Returns the active app-state sync key, generating and persisting a new
      * one when the store is empty (used during initial setup).
+     *
+     * The key id mirrors the primary device layout: 2 big-endian bytes of
+     * device id followed by a 4 big-endian byte epoch. `keyEpoch` and
+     * `pickActiveSyncKey` read that structure, so a shorter id would make the
+     * generated key invisible to active-key selection.
      */
     async ensureInitialSyncKey() {
         const existing = await this.store.getActiveSyncKey();
         if (existing) {
             return existing;
         }
-        const keyIdBytes = await randomBytesAsync(2);
+        const deviceId = this.resolveDeviceIndex() ?? 0;
+        const epoch = await randomIntAsync(1, 65537);
+        const keyIdBytes = new Uint8Array(6);
+        keyIdBytes[0] = (deviceId >>> 8) & 0xff;
+        keyIdBytes[1] = deviceId & 0xff;
+        keyIdBytes[2] = (epoch >>> 24) & 0xff;
+        keyIdBytes[3] = (epoch >>> 16) & 0xff;
+        keyIdBytes[4] = (epoch >>> 8) & 0xff;
+        keyIdBytes[5] = epoch & 0xff;
         const keyData = await randomBytesAsync(32);
         const rawId = await randomIntAsync(0, 4294967295);
         const key = {
@@ -61,6 +74,7 @@ export class WaAppStateSyncClient {
         this.crypto.clearCache();
         this.logger.info('app-state initial sync key generated (mobile primary)', {
             keyId: bytesToHex(keyIdBytes),
+            epoch,
             rawId
         });
         return key;
@@ -386,17 +400,18 @@ export class WaAppStateSyncClient {
     async buildCollectionSyncRequest(collection, pendingByCollection, activeSyncKey) {
         const collectionState = await this.getCollectionState(collection);
         const hasPersistedState = collectionState.initialized;
+        const requestSnapshot = !this.mobilePrimary() && !hasPersistedState;
         const attrs = {
             name: collection,
             version: String(hasPersistedState ? collectionState.version : APP_STATE_DEFAULT_COLLECTION_VERSION),
-            return_snapshot: hasPersistedState ? 'false' : 'true'
+            return_snapshot: requestSnapshot ? 'true' : 'false'
         };
         const children = [];
         const pendingMutations = pendingByCollection.get(collection) ?? [];
         let outgoingContext;
         let skippedUpload = false;
         if (pendingMutations.length > 0) {
-            if (!hasPersistedState) {
+            if (!hasPersistedState && !this.mobilePrimary()) {
                 skippedUpload = true;
                 this.logger.debug('app-state skipped outgoing patch upload until snapshot bootstrap', {
                     collection,
@@ -435,7 +450,7 @@ export class WaAppStateSyncClient {
             content: [
                 {
                     tag: WA_NODE_TAGS.SYNC,
-                    attrs: this.mobilePrimary ? { data_namespace: '3' } : {},
+                    attrs: this.mobilePrimary() ? { data_namespace: '3' } : {},
                     content: collectionNodes
                 }
             ]
@@ -470,20 +485,19 @@ export class WaAppStateSyncClient {
             return this.createCollectionOutcome(collection, payload.state, payload.version);
         }
         const pendingMutationsCount = pendingByCollection.get(collection)?.length ?? 0;
-        if (payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT ||
-            payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE) {
+        const isConflict = payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT ||
+            payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE;
+        if (isConflict) {
             shouldRefetch =
                 payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE ||
                     pendingMutationsCount > 0;
-            return this.createCollectionOutcome(collection, payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT
-                ? pendingMutationsCount > 0
-                    ? WA_APP_STATE_COLLECTION_STATES.CONFLICT
-                    : WA_APP_STATE_COLLECTION_STATES.SUCCESS
-                : payload.state, payload.version, shouldRefetch);
         }
         try {
             let appliedMutations = [];
-            if (payload.snapshotReference) {
+            if (payload.snapshotReference && this.mobilePrimary()) {
+                collectionLogger.debug('app-state ignoring server snapshot on primary device');
+            }
+            else if (payload.snapshotReference) {
                 const downloader = options.downloadExternalBlob;
                 if (!downloader) {
                     throw new Error(`snapshot for ${payload.collection} requires external blob downloader`);
@@ -522,12 +536,19 @@ export class WaAppStateSyncClient {
                     payload.state === WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE ||
                     (payload.state === WA_APP_STATE_COLLECTION_STATES.SUCCESS &&
                         skippedUploadCollections.has(collection));
+            const resolvedState = !isConflict
+                ? payload.state
+                : payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT
+                    ? pendingMutationsCount > 0
+                        ? WA_APP_STATE_COLLECTION_STATES.CONFLICT
+                        : WA_APP_STATE_COLLECTION_STATES.SUCCESS
+                    : payload.state;
             collectionLogger.debug('app-state collection processed', {
-                state: payload.state,
+                state: resolvedState,
                 version: payload.version,
                 appliedMutations: appliedMutations.length
             });
-            return this.createCollectionOutcome(collection, payload.state, payload.version, shouldRefetch, collectionStateChanged, appliedMutations);
+            return this.createCollectionOutcome(collection, resolvedState, payload.version, shouldRefetch, collectionStateChanged, appliedMutations);
         }
         catch (error) {
             if (error instanceof WaAppStateMissingKeyError) {

package/dist/esm/auth/credentials-flow.js

@@ -30,6 +30,8 @@ export async function loadOrCreateCredentials(args) {
     }
     await restoreSignalStore(args.signalStore, args.preKeyStore, existing);
     args.logger.trace('auth credentials restored into signal store');
+    // A mobile primary has no self-signed device-identity and no key-index-list:
+    // both are companion-only (set at pairing). Do not re-add them here.
     return existing;
 }
 export async function persistCredentials(args, credentials) {
@@ -129,7 +131,7 @@ export async function buildCommsConfig(logger, credentials, socketOptions, clien
         noise: {
             clientStaticKeyPair: credentials.noiseKeyPair,
             isRegistered: registered,
-            serverStaticKey: credentials.serverStaticKey,
+            serverStaticKey: registered ? credentials.serverStaticKey : undefined,
             routingInfo: credentials.routingInfo,
             trustedRootCa: clientOptions.noiseTrustedRootCa,
             verifyCertificateChain: clientOptions.disableNoiseCertificateChainVerification

package/dist/esm/client/WaClientFactory.js

@@ -210,7 +210,7 @@ export function buildWaClientDependencies(input) {
         logger,
         defaultTimeoutMs: options.nodeQueryTimeoutMs,
         hostDomain: WA_DEFAULTS.HOST_DOMAIN,
-        mobileIqIdFormat: options.mobileTransport !== undefined
+        mobileIqIdFormat: () => isMobilePrimary()
     });
     const keepAlive = new WaKeepAlive({
         logger,
@@ -352,6 +352,7 @@ export function buildWaClientDependencies(input) {
         }
     });
     const getCurrentCredentials = authClient.getCurrentCredentials.bind(authClient);
+    const isMobilePrimary = () => options.mobileTransport !== undefined || Boolean(getCurrentCredentials()?.deviceInfo);
     const groupCoordinator = createGroupCoordinator({
         queryWithContext: runtime.queryWithContext,
         mexSocket: { query: runtime.query }
@@ -477,7 +478,7 @@ export function buildWaClientDependencies(input) {
             additionalAttributes: sendOptions.additionalAttributes
         }),
         getIcdcHashLength: () => abPropsCoordinator.getConfigValue('md_icdc_hash_length'),
-        mobileMessageIdFormat: options.mobileTransport !== undefined,
+        mobileMessageIdFormat: isMobilePrimary,
         serverClock
     });
     const presenceCoordinator = createPresenceCoordinator({
@@ -517,12 +518,15 @@ export function buildWaClientDependencies(input) {
         sendNode: runtime.sendNode,
         getCurrentCredentials,
         resolveUserIcdc: (userJid) => messageDispatch.resolveUserIcdc(userJid),
+        resolvePrivacyTokenNode: (recipientJid) => trustedContactToken.resolveTokenForMessage(recipientJid),
+        // Placeholder resend asks the primary phone (a peer) for the plaintext.
         peerDataOperation,
         emitIncomingMessage: (event) => {
             void runtime
                 .handleIncomingMessageEvent(event)
                 .catch((err) => runtime.handleError(toError(err)));
-        }
+        },
+        isMobilePrimary
     });
     const botCoordinator = createBotCoordinator({
         logger,
@@ -546,7 +550,7 @@ export function buildWaClientDependencies(input) {
             await messageDispatch.requestAppStateSyncKeys(keyIds);
         },
         skipMacVerification: options.dangerous?.disableAppStateMacVerification,
-        mobilePrimary: options.mobileTransport !== undefined,
+        mobilePrimary: isMobilePrimary,
         isOwnAccountDevice: (deviceJid) => {
             const credentials = getCurrentCredentials();
             if (!credentials)
@@ -560,6 +564,18 @@ export function buildWaClientDependencies(input) {
             await runtime.syncAppState();
         }
     });
+    // Persists a pushName change and re-broadcasts presence carrying it (how the
+    // name reaches peers on primary connections). No-op when unchanged, which
+    // also collapses the app-state echo of our own SettingPushName write.
+    const applyOwnPushName = async (name) => {
+        if (getCurrentCredentials()?.meDisplayName === name) {
+            return;
+        }
+        await authClient.persistSuccessAttributes({ meDisplayName: name });
+        if (connectionManager?.isConnected()) {
+            await presenceCoordinator.send();
+        }
+    };
     const appStateMutations = new WaAppStateMutationCoordinator({
         logger,
         messageStore: sessionStore.messages,
@@ -570,7 +586,12 @@ export function buildWaClientDependencies(input) {
         emitSnapshotMutations: options.chatEvents?.emitSnapshotMutations === true,
         emitMutation: (event) => runtime.emitEvent('mutation', event),
         nctSaltSink: (salt) => trustedContactToken.handleNctSaltSync(salt),
-        contactSink: runtime.persistContact
+        contactSink: runtime.persistContact,
+        pushNameSink: (name) => {
+            void applyOwnPushName(name).catch((error) => logger.debug('apply own pushName from app-state sync failed', {
+                message: toError(error).message
+            }));
+        }
     });
     const profileCoordinator = createProfileCoordinator({
         queryWithContext: runtime.queryWithContext,
@@ -578,6 +599,7 @@ export function buildWaClientDependencies(input) {
         mexSocket: { query: runtime.query },
         queryLidsByPhoneJids: (phoneJids) => signalDeviceSync.queryLidsByPhoneJids(phoneJids),
         mutations: appStateMutations,
+        applyOwnPushName,
         logger
     });
     const statusCoordinator = createStatusCoordinator({
@@ -975,7 +997,7 @@ export function buildWaClientDependencies(input) {
             abPropsCoordinator,
             markOnlineOnConnect: options.markOnlineOnConnect ?? false
         }),
-        mobilePrimary: options.mobileTransport !== undefined,
+        mobilePrimary: isMobilePrimary,
         appStateSync
     });
     const lowLevelCoordinator = createLowLevelCoordinator({

package/dist/esm/client/connection/WaConnectionManager.js

@@ -246,6 +246,9 @@ export class WaConnectionManager {
             if (!serverStaticKey) {
                 this.logger.trace('no server static key available to persist');
             }
+            else if (!credentials.meJid) {
+                this.logger.trace('skipping server static key persist while unregistered');
+            }
             else {
                 await this.authClient.persistServerStaticKey(serverStaticKey);
                 this.assertLifecycleCurrent(lifecycleGeneration, 'start comms');

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

@@ -180,6 +180,7 @@ export class WaAppStateMutationCoordinator {
         this.emitSnapshotMutations = options.emitSnapshotMutations === true;
         this.nctSaltSink = options.nctSaltSink;
         this.contactSink = options.contactSink;
+        this.pushNameSink = options.pushNameSink;
         this.pendingMutations = new Map();
         this.flushPromise = null;
     }
@@ -227,11 +228,10 @@ export class WaAppStateMutationCoordinator {
     emitEventsFromSyncResult(syncResult) {
         for (const collectionResult of syncResult.collections) {
             const mutations = collectionResult.mutations ?? [];
-            // Persistence sinks (contact store, ...): run on the last-wins
-            // mutation per key INCLUDING snapshot sources, so pair-time
-            // bootstrap of the address book always lands in the store even
-            // when public events are suppressed for snapshot mutations.
-            if (this.contactSink) {
+            // Persistence sinks (contact store, own pushName): run on the
+            // last-wins mutation per key INCLUDING snapshot sources, so
+            // pair-time bootstrap lands even when snapshot events are suppressed.
+            if (this.contactSink || this.pushNameSink) {
                 const sinkLastIndex = new Map();
                 for (let i = 0; i < mutations.length; i += 1) {
                     const m = mutations[i];
@@ -252,6 +252,16 @@ export class WaAppStateMutationCoordinator {
                             message: toError(error).message
                         });
                     }
+                    try {
+                        this.handlePushNameMutation(m);
+                    }
+                    catch (error) {
+                        this.logger.debug('pushName sink failed', {
+                            collection: m.collection,
+                            index: m.index,
+                            message: toError(error).message
+                        });
+                    }
                 }
             }
             const lastMutationIndexByKey = new Map();
@@ -356,6 +366,20 @@ export class WaAppStateMutationCoordinator {
             lastUpdatedMs
         });
     }
+    handlePushNameMutation(mutation) {
+        if (!this.pushNameSink)
+            return;
+        // A `set` under the literal index ["setting_pushName"]; cheap reject
+        // before reading the value.
+        if (mutation.operation !== 'set')
+            return;
+        if (!mutation.index.includes('setting_pushName'))
+            return;
+        const name = mutation.value?.pushNameSetting?.name;
+        if (typeof name !== 'string')
+            return;
+        this.pushNameSink(name);
+    }
     /**
      * Mutes or unmutes a chat. `muteEndTimestampMs` is required when
      * `muted` is `true` and must be a non-negative safe-integer epoch.

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 } from '../../protocol/constants.js';
+import { WA_DEFAULTS, WA_NACK_REASONS } from '../../protocol/constants.js';
 import { isBotJid, isGroupJid, isHostedDeviceJid, isLidJid, isNewsletterJid, 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';
@@ -23,7 +23,7 @@ export class WaMessageDispatchCoordinator {
         this.privacyTokenDedup = new PromiseDedup();
         this.distributionDedup = new PromiseDedup();
         this.deps = options;
-        this.mobileMessageIdFormat = options.mobileMessageIdFormat ?? false;
+        this.mobileMessageIdFormat = options.mobileMessageIdFormat ?? (() => false);
         this.serverClock = options.serverClock;
     }
     async publishMessageNode(node, options = {}) {
@@ -654,7 +654,7 @@ export class WaMessageDispatchCoordinator {
         const serverAddressingMode = result.ack.addressingMode;
         const hasPhashMismatch = !!serverPhash && serverPhash !== localPhash;
         const hasAddressingMismatch = !!serverAddressingMode && serverAddressingMode !== addressingMode;
-        const hasAddressingError = ackError === 421;
+        const hasAddressingError = ackError === WA_NACK_REASONS.STALE_GROUP_ADDRESSING_MODE;
         if (!retryContext.retried &&
             (hasPhashMismatch || hasAddressingMismatch || hasAddressingError)) {
             this.deps.logger.warn('group direct publish acknowledged with mismatch metadata', {
@@ -829,7 +829,7 @@ export class WaMessageDispatchCoordinator {
         const serverAddressingMode = result.ack.addressingMode;
         const hasPhashMismatch = !!serverPhash && serverPhash !== localPhash;
         const hasAddressingMismatch = !!serverAddressingMode && serverAddressingMode !== addressingMode;
-        const hasAddressingError = ackError === 421;
+        const hasAddressingError = ackError === WA_NACK_REASONS.STALE_GROUP_ADDRESSING_MODE;
         if (!retryContext.retried &&
             (hasPhashMismatch || hasAddressingMismatch || hasAddressingError)) {
             this.deps.logger.warn('group message publish acknowledged with mismatch metadata', {
@@ -1191,7 +1191,7 @@ export class WaMessageDispatchCoordinator {
             const meUserJid = toUserJid(this.requireCurrentMeJid('sendMessage'));
             const timestampBytes = new Uint8Array(8);
             const dv = new DataView(timestampBytes.buffer, timestampBytes.byteOffset, timestampBytes.byteLength);
-            if (this.mobileMessageIdFormat) {
+            if (this.mobileMessageIdFormat()) {
                 dv.setBigUint64(0, BigInt(Date.now()), false);
                 const digest = md5Bytes([
                     timestampBytes,
@@ -1213,7 +1213,7 @@ export class WaMessageDispatchCoordinator {
             this.deps.logger.warn('failed to generate message id, falling back to random', {
                 message: toError(error).message
             });
-            if (this.mobileMessageIdFormat) {
+            if (this.mobileMessageIdFormat()) {
                 const bytes = await randomBytesAsync(16);
                 bytes[0] = 0xac;
                 return bytesToHex(bytes).toUpperCase();

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

@@ -16,7 +16,7 @@ export class WaPassiveTasksCoordinator {
         this.signedPreKeyServerErrorBackoffMs =
             options.signedPreKeyServerErrorBackoffMs ?? SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS;
         this.runtime = options.runtime;
-        this.mobilePrimary = options.mobilePrimary ?? false;
+        this.mobilePrimary = options.mobilePrimary ?? (() => false);
         this.appStateSync = options.appStateSync;
         this.passiveTasksPromise = null;
     }
@@ -59,7 +59,7 @@ export class WaPassiveTasksCoordinator {
             return;
         }
         this.runtime.syncAbProps();
-        if (this.mobilePrimary && this.appStateSync) {
+        if (this.mobilePrimary() && this.appStateSync) {
             await this.appStateSync.ensureInitialSyncKey().catch((error) => {
                 this.logger.warn('app-state initial key generation failed', {
                     message: toError(error).message
@@ -146,7 +146,7 @@ export class WaPassiveTasksCoordinator {
         const response = await this.runtime.queryWithContext('prekeys.upload', uploadNode, WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: preKeys.length,
             lastPreKeyId
-        }, this.mobilePrimary ? { useSystemId: true } : undefined);
+        }, this.mobilePrimary() ? { useSystemId: true } : undefined);
         if (response.attrs.type === WA_IQ_TYPES.RESULT) {
             // Mark uploaded key first so the serverHasPreKeys flag never commits ahead of local key progress.
             await this.preKeyStore.markKeyAsUploaded(lastPreKeyId);

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

@@ -192,7 +192,7 @@ function buildTextStatusMutationInput(input) {
 }
 /** Builds a {@link WaProfileCoordinator} from its IQ/MEX/SID dependencies. */
 export function createProfileCoordinator(options) {
-    const { queryWithContext, generateSid, mexSocket, queryLidsByPhoneJids, mutations, logger } = options;
+    const { queryWithContext, generateSid, mexSocket, queryLidsByPhoneJids, mutations, applyOwnPushName, logger } = options;
     return {
         getProfilePicture: async (jid, type, existingId) => {
             const node = buildGetProfilePictureIq(jid, type, existingId);
@@ -242,6 +242,9 @@ export function createProfileCoordinator(options) {
             assertIqResult(result, 'profile.setStatus');
         },
         setPushName: async (name) => {
+            // Local apply first: the app-state echo of this same write then
+            // collapses into a no-op via applyOwnPushName's idempotency guard.
+            await applyOwnPushName(name);
             await mutations.set({ schema: 'SettingPushName', name });
         },
         getProfiles: async (jids) => {