zapo-js 1.5.0 → 1.5.1

package/dist/client/coordinators/WaAppStateMutationCoordinator.js

@@ -761,8 +761,8 @@ class WaAppStateMutationCoordinator {
             statusPrivacy: {
                 mode: modeValue,
                 userJid,
-                ...(input.shareToFB === undefined ? {} : { shareToFB: input.shareToFB }),
-                ...(input.shareToIG === undefined ? {} : { shareToIG: input.shareToIG })
+                ...(input.shareToFB === undefined ? {} : { shareToFb: input.shareToFB }),
+                ...(input.shareToIG === undefined ? {} : { shareToIg: input.shareToIG })
             }
         };
         const timestamp = this.serverClock.nowMs();

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -318,7 +318,7 @@ class WaMessageDispatchCoordinator {
         }
         try {
             const results = await this.deps.signalDeviceSync.queryLidsByPhoneJids([pnUserJid]);
-            const match = results.find((entry) => entry.phoneJid === pnUserJid);
+            const match = results.find((entry) => entry.queriedJid === pnUserJid);
             if (match?.lidJid)
                 return match.lidJid;
         }

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

@@ -758,8 +758,8 @@ export class WaAppStateMutationCoordinator {
             statusPrivacy: {
                 mode: modeValue,
                 userJid,
-                ...(input.shareToFB === undefined ? {} : { shareToFB: input.shareToFB }),
-                ...(input.shareToIG === undefined ? {} : { shareToIG: input.shareToIG })
+                ...(input.shareToFB === undefined ? {} : { shareToFb: input.shareToFB }),
+                ...(input.shareToIG === undefined ? {} : { shareToIg: input.shareToIG })
             }
         };
         const timestamp = this.serverClock.nowMs();

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

@@ -315,7 +315,7 @@ export class WaMessageDispatchCoordinator {
         }
         try {
             const results = await this.deps.signalDeviceSync.queryLidsByPhoneJids([pnUserJid]);
-            const match = results.find((entry) => entry.phoneJid === pnUserJid);
+            const match = results.find((entry) => entry.queriedJid === pnUserJid);
             if (match?.lidJid)
                 return match.lidJid;
         }

package/dist/esm/signal/api/SignalDeviceSyncApi.js

@@ -1,8 +1,8 @@
 import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { WA_DEFAULTS, WA_NODE_TAGS, WA_USYNC_CONTEXTS } from '../../protocol/constants.js';
-import { buildDeviceJid, isHostedDeviceId, splitJid, toUserJid } from '../../protocol/jid.js';
+import { buildDeviceJid, isHostedDeviceId, parsePhoneJid, splitJid, toUserJid } from '../../protocol/jid.js';
 import { buildUsyncIq, iterateUsyncUsers, parseUsyncResultEnvelope } from '../../transport/node/builders/usync.js';
-import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { findNodeChild, getNodeChildrenByTag, getNodeTextContent } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
 import { createUsyncSidGenerator, logUsyncProtocolErrors } from '../../transport/node/usync.js';
 /**
@@ -112,22 +112,21 @@ export class SignalDeviceSyncApi {
         const parsedByPhoneJid = new Map();
         for (let index = 0; index < parsed.length; index += 1) {
             const entry = parsed[index];
-            const phoneJid = entry.phoneJid ?? entry.jid;
-            parsedByPhoneJid.set(phoneJid, {
-                phoneJid,
+            parsedByPhoneJid.set(entry.jid, {
+                phoneJid: entry.phoneJid ?? entry.jid,
                 lidJid: entry.lidJid,
-                exists: entry.exists
+                exists: entry.exists,
+                invalid: entry.invalid
             });
         }
         const result = new Array(normalizedPhoneJids.length);
         let found = 0;
         for (let index = 0; index < normalizedPhoneJids.length; index += 1) {
-            const phoneJid = normalizedPhoneJids[index];
-            const resolved = parsedByPhoneJid.get(phoneJid) ?? {
-                phoneJid,
-                lidJid: null,
-                exists: false
-            };
+            const queriedJid = normalizedPhoneJids[index];
+            const hit = parsedByPhoneJid.get(queriedJid);
+            const resolved = hit
+                ? { queriedJid, ...hit }
+                : { queriedJid, phoneJid: queriedJid, lidJid: null, exists: false, invalid: false };
             if (resolved.exists) {
                 found += 1;
             }
@@ -151,24 +150,23 @@ export class SignalDeviceSyncApi {
         if (!this.deviceListStore || results.length === 0)
             return;
         const nowMs = Date.now();
-        const lidByPhoneJid = new Map();
-        const phoneJids = [];
+        const lidByQueriedJid = new Map();
+        const queriedJids = [];
         for (const entry of results) {
-            if (entry.lidJid && entry.phoneJid) {
-                lidByPhoneJid.set(entry.phoneJid, entry.lidJid);
-                phoneJids.push(entry.phoneJid);
+            if (entry.lidJid) {
+                lidByQueriedJid.set(entry.queriedJid, entry.lidJid);
+                queriedJids.push(entry.queriedJid);
             }
         }
-        if (phoneJids.length === 0)
+        if (queriedJids.length === 0)
             return;
-        const existing = await this.deviceListStore.getUserDevicesBatch(phoneJids, nowMs);
+        const existing = await this.deviceListStore.getUserDevicesBatch(queriedJids, nowMs);
         const updates = [];
-        for (let index = 0; index < phoneJids.length; index += 1) {
+        for (let index = 0; index < queriedJids.length; index += 1) {
             const snapshot = existing[index];
             if (!snapshot)
                 continue;
-            const phoneJid = phoneJids[index];
-            const lidJid = lidByPhoneJid.get(phoneJid);
+            const lidJid = lidByQueriedJid.get(queriedJids[index]);
             if (!lidJid || snapshot.altUserJid === lidJid)
                 continue;
             updates.push({
@@ -271,7 +269,13 @@ export class SignalDeviceSyncApi {
             if (!userJid) {
                 continue;
             }
-            const normalizedUserJid = this.normalizeUserJid(userJid);
+            const normalizedUserJid = this.tryNormalizeUserJid(userJid);
+            if (normalizedUserJid === null) {
+                this.logger.debug('signal device sync skipping user node with invalid jid', {
+                    jid: userJid
+                });
+                continue;
+            }
             if (!requestedSet.has(normalizedUserJid)) {
                 continue;
             }
@@ -292,55 +296,107 @@ export class SignalDeviceSyncApi {
             throw new Error('signal lid sync response missing usync envelope');
         }
         const requestedSet = new Set(requestedUsers);
-        const parsed = new Array(userNodes.length);
-        let parsedCount = 0;
+        const parsed = [];
+        const lidUserErrors = [];
         for (let index = 0; index < userNodes.length; index += 1) {
             const userNode = userNodes[index];
-            const userJid = userNode.attrs.jid;
-            if (!userJid) {
+            const rawUserJid = userNode.attrs.jid;
+            if (!rawUserJid) {
                 continue;
             }
-            const normalizedUserJid = this.normalizeUserJid(userJid);
-            const normalizedPhoneJid = userNode.attrs.pn_jid
-                ? this.normalizeUserJid(userNode.attrs.pn_jid)
+            const resolvedJid = this.tryNormalizeUserJid(rawUserJid);
+            const pnJid = userNode.attrs.pn_jid
+                ? this.tryNormalizeUserJid(userNode.attrs.pn_jid)
+                : null;
+            const phoneJid = pnJid ?? resolvedJid;
+            const lidNode = findNodeChild(userNode, WA_NODE_TAGS.LID);
+            const lidErrorNode = lidNode ? findNodeChild(lidNode, WA_NODE_TAGS.ERROR) : null;
+            if (lidErrorNode) {
+                lidUserErrors.push({
+                    jid: resolvedJid ?? rawUserJid,
+                    code: lidErrorNode.attrs.code,
+                    text: lidErrorNode.attrs.text
+                });
+            }
+            const lidJid = !lidErrorNode && lidNode?.attrs.val
+                ? this.tryNormalizeUserJid(lidNode.attrs.val)
                 : null;
-            const wasRequested = requestedSet.has(normalizedUserJid) ||
-                (normalizedPhoneJid !== null && requestedSet.has(normalizedPhoneJid));
-            if (!wasRequested) {
+            const contactNodes = getNodeChildrenByTag(userNode, WA_NODE_TAGS.CONTACT);
+            let matched = false;
+            for (let c = 0; c < contactNodes.length; c += 1) {
+                const contactNode = contactNodes[c];
+                const inputJid = this.recoverContactJid(contactNode);
+                if (inputJid === null || !requestedSet.has(inputJid)) {
+                    continue;
+                }
+                matched = true;
+                const invalid = resolvedJid === null || contactNode.attrs.type === 'invalid';
+                parsed.push({
+                    jid: inputJid,
+                    phoneJid: phoneJid ?? inputJid,
+                    lidJid,
+                    exists: !invalid &&
+                        this.parseLidSyncContactExists(contactNode, inputJid, lidJid !== null),
+                    invalid
+                });
+            }
+            if (matched) {
                 continue;
             }
-            const lidNode = findNodeChild(userNode, WA_NODE_TAGS.LID);
-            const contactNode = findNodeChild(userNode, WA_NODE_TAGS.CONTACT);
-            if (!lidNode) {
-                parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
-                parsedCount += 1;
+            if (resolvedJid === null) {
+                this.logger.debug('signal lid sync skipping user node with invalid jid', {
+                    jid: rawUserJid
+                });
                 continue;
             }
-            const errorNode = findNodeChild(lidNode, WA_NODE_TAGS.ERROR);
-            if (errorNode) {
-                this.logger.warn('signal lid sync user error', {
-                    jid: normalizedUserJid,
-                    code: errorNode.attrs.code,
-                    text: errorNode.attrs.text
+            const requestedKey = requestedSet.has(resolvedJid)
+                ? resolvedJid
+                : pnJid !== null && requestedSet.has(pnJid)
+                    ? pnJid
+                    : null;
+            if (requestedKey === null) {
+                this.logger.debug('signal lid sync unmatched user (no contact echo)', {
+                    jid: resolvedJid,
+                    pnJid
                 });
-                parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
-                parsedCount += 1;
                 continue;
             }
-            const lidJid = lidNode.attrs.val ? this.normalizeUserJid(lidNode.attrs.val) : null;
-            parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, lidJid);
-            parsedCount += 1;
+            const contactNode = findNodeChild(userNode, WA_NODE_TAGS.CONTACT);
+            parsed.push({
+                jid: requestedKey,
+                phoneJid: phoneJid ?? requestedKey,
+                lidJid,
+                exists: this.parseLidSyncContactExists(contactNode, requestedKey, lidJid !== null),
+                invalid: false
+            });
+        }
+        if (lidUserErrors.length > 0) {
+            this.logger.warn('signal lid sync user errors', {
+                droppedCount: lidUserErrors.length,
+                totalExpected: requestedUsers.length,
+                sample: lidUserErrors.slice(0, 3)
+            });
         }
-        parsed.length = parsedCount;
         return parsed;
     }
-    buildLidSyncResult(jid, phoneJid, contactNode, lidJid) {
-        return {
-            jid,
-            lidJid,
-            phoneJid,
-            exists: this.parseLidSyncContactExists(contactNode, jid, lidJid !== null)
-        };
+    /**
+     * Recovers the queried phone JID from a `<contact>` echo. Each `<contact>` in a
+     * usync response echoes the `+<number>` we sent (base64 text content), so it maps
+     * a response node back to the exact input - even when the server corrected the
+     * `<user jid>` or rejected it as `jid='undefined'`. Returns `null` when there is
+     * no decodable phone echo.
+     */
+    recoverContactJid(contactNode) {
+        const echoed = getNodeTextContent(contactNode);
+        if (!echoed) {
+            return null;
+        }
+        try {
+            return parsePhoneJid(echoed);
+        }
+        catch {
+            return null;
+        }
     }
     parseLidSyncContactExists(contactNode, userJid, defaultExists) {
         if (!contactNode) {
@@ -401,7 +457,10 @@ export class SignalDeviceSyncApi {
         let normalizedCount = 0;
         const dedup = new Set();
         for (let index = 0; index < userJids.length; index += 1) {
-            const normalizedJid = this.normalizeUserJid(userJids[index]);
+            const normalizedJid = toUserJid(userJids[index], {
+                canonicalizeSignalServer: true,
+                hostDomain: this.hostDomain
+            });
             if (dedup.has(normalizedJid)) {
                 continue;
             }
@@ -412,10 +471,21 @@ export class SignalDeviceSyncApi {
         normalized.length = normalizedCount;
         return normalized;
     }
-    normalizeUserJid(jid) {
-        return toUserJid(jid, {
-            canonicalizeSignalServer: true,
-            hostDomain: this.hostDomain
-        });
+    /**
+     * Canonicalizes a user jid, returning `null` instead of throwing when the input
+     * is not a valid jid (for example the literal `'undefined'` the server returns
+     * for an invalid contact). Lets a single malformed response node be skipped
+     * without discarding the rest of the batch.
+     */
+    tryNormalizeUserJid(jid) {
+        try {
+            return toUserJid(jid, {
+                canonicalizeSignalServer: true,
+                hostDomain: this.hostDomain
+            });
+        }
+        catch {
+            return null;
+        }
     }
 }

package/dist/signal/api/SignalDeviceSyncApi.d.ts

@@ -11,9 +11,23 @@ interface SignalDeviceSyncApiOptions {
     readonly generateSid?: WaUsyncSidGenerator;
 }
 export interface SignalLidSyncResult {
+    /**
+     * The phone jid the caller queried (normalized), so results can be correlated
+     * back to the input by value rather than by array position. Equals `phoneJid`
+     * unless the server corrected the number.
+     */
+    readonly queriedJid: string;
+    /** The server's canonical/corrected phone jid (e.g. BR 9th digit added). */
     readonly phoneJid: string;
     readonly lidJid: string | null;
     readonly exists: boolean;
+    /**
+     * `true` when the server rejected the number as malformed (`<user
+     * jid='undefined'>` with `<contact type='invalid'>`) - distinct from a
+     * well-formed number that simply has no WhatsApp account (`exists: false`,
+     * `invalid: false`).
+     */
+    readonly invalid: boolean;
 }
 /**
  * Resolves the device list and LID mapping for a set of users via the `usync`
@@ -55,10 +69,23 @@ export declare class SignalDeviceSyncApi {
     private makeLidSyncRequest;
     private parseDeviceSyncResponse;
     private parseLidSyncResponse;
-    private buildLidSyncResult;
+    /**
+     * Recovers the queried phone JID from a `<contact>` echo. Each `<contact>` in a
+     * usync response echoes the `+<number>` we sent (base64 text content), so it maps
+     * a response node back to the exact input - even when the server corrected the
+     * `<user jid>` or rejected it as `jid='undefined'`. Returns `null` when there is
+     * no decodable phone echo.
+     */
+    private recoverContactJid;
     private parseLidSyncContactExists;
     private parseUserDeviceJids;
     private normalizeUsers;
-    private normalizeUserJid;
+    /**
+     * Canonicalizes a user jid, returning `null` instead of throwing when the input
+     * is not a valid jid (for example the literal `'undefined'` the server returns
+     * for an invalid contact). Lets a single malformed response node be skipped
+     * without discarding the rest of the batch.
+     */
+    private tryNormalizeUserJid;
 }
 export {};

package/dist/signal/api/SignalDeviceSyncApi.js

@@ -115,22 +115,21 @@ class SignalDeviceSyncApi {
         const parsedByPhoneJid = new Map();
         for (let index = 0; index < parsed.length; index += 1) {
             const entry = parsed[index];
-            const phoneJid = entry.phoneJid ?? entry.jid;
-            parsedByPhoneJid.set(phoneJid, {
-                phoneJid,
+            parsedByPhoneJid.set(entry.jid, {
+                phoneJid: entry.phoneJid ?? entry.jid,
                 lidJid: entry.lidJid,
-                exists: entry.exists
+                exists: entry.exists,
+                invalid: entry.invalid
             });
         }
         const result = new Array(normalizedPhoneJids.length);
         let found = 0;
         for (let index = 0; index < normalizedPhoneJids.length; index += 1) {
-            const phoneJid = normalizedPhoneJids[index];
-            const resolved = parsedByPhoneJid.get(phoneJid) ?? {
-                phoneJid,
-                lidJid: null,
-                exists: false
-            };
+            const queriedJid = normalizedPhoneJids[index];
+            const hit = parsedByPhoneJid.get(queriedJid);
+            const resolved = hit
+                ? { queriedJid, ...hit }
+                : { queriedJid, phoneJid: queriedJid, lidJid: null, exists: false, invalid: false };
             if (resolved.exists) {
                 found += 1;
             }
@@ -154,24 +153,23 @@ class SignalDeviceSyncApi {
         if (!this.deviceListStore || results.length === 0)
             return;
         const nowMs = Date.now();
-        const lidByPhoneJid = new Map();
-        const phoneJids = [];
+        const lidByQueriedJid = new Map();
+        const queriedJids = [];
         for (const entry of results) {
-            if (entry.lidJid && entry.phoneJid) {
-                lidByPhoneJid.set(entry.phoneJid, entry.lidJid);
-                phoneJids.push(entry.phoneJid);
+            if (entry.lidJid) {
+                lidByQueriedJid.set(entry.queriedJid, entry.lidJid);
+                queriedJids.push(entry.queriedJid);
             }
         }
-        if (phoneJids.length === 0)
+        if (queriedJids.length === 0)
             return;
-        const existing = await this.deviceListStore.getUserDevicesBatch(phoneJids, nowMs);
+        const existing = await this.deviceListStore.getUserDevicesBatch(queriedJids, nowMs);
         const updates = [];
-        for (let index = 0; index < phoneJids.length; index += 1) {
+        for (let index = 0; index < queriedJids.length; index += 1) {
             const snapshot = existing[index];
             if (!snapshot)
                 continue;
-            const phoneJid = phoneJids[index];
-            const lidJid = lidByPhoneJid.get(phoneJid);
+            const lidJid = lidByQueriedJid.get(queriedJids[index]);
             if (!lidJid || snapshot.altUserJid === lidJid)
                 continue;
             updates.push({
@@ -274,7 +272,13 @@ class SignalDeviceSyncApi {
             if (!userJid) {
                 continue;
             }
-            const normalizedUserJid = this.normalizeUserJid(userJid);
+            const normalizedUserJid = this.tryNormalizeUserJid(userJid);
+            if (normalizedUserJid === null) {
+                this.logger.debug('signal device sync skipping user node with invalid jid', {
+                    jid: userJid
+                });
+                continue;
+            }
             if (!requestedSet.has(normalizedUserJid)) {
                 continue;
             }
@@ -295,55 +299,107 @@ class SignalDeviceSyncApi {
             throw new Error('signal lid sync response missing usync envelope');
         }
         const requestedSet = new Set(requestedUsers);
-        const parsed = new Array(userNodes.length);
-        let parsedCount = 0;
+        const parsed = [];
+        const lidUserErrors = [];
         for (let index = 0; index < userNodes.length; index += 1) {
             const userNode = userNodes[index];
-            const userJid = userNode.attrs.jid;
-            if (!userJid) {
+            const rawUserJid = userNode.attrs.jid;
+            if (!rawUserJid) {
                 continue;
             }
-            const normalizedUserJid = this.normalizeUserJid(userJid);
-            const normalizedPhoneJid = userNode.attrs.pn_jid
-                ? this.normalizeUserJid(userNode.attrs.pn_jid)
+            const resolvedJid = this.tryNormalizeUserJid(rawUserJid);
+            const pnJid = userNode.attrs.pn_jid
+                ? this.tryNormalizeUserJid(userNode.attrs.pn_jid)
+                : null;
+            const phoneJid = pnJid ?? resolvedJid;
+            const lidNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.LID);
+            const lidErrorNode = lidNode ? (0, helpers_1.findNodeChild)(lidNode, constants_1.WA_NODE_TAGS.ERROR) : null;
+            if (lidErrorNode) {
+                lidUserErrors.push({
+                    jid: resolvedJid ?? rawUserJid,
+                    code: lidErrorNode.attrs.code,
+                    text: lidErrorNode.attrs.text
+                });
+            }
+            const lidJid = !lidErrorNode && lidNode?.attrs.val
+                ? this.tryNormalizeUserJid(lidNode.attrs.val)
                 : null;
-            const wasRequested = requestedSet.has(normalizedUserJid) ||
-                (normalizedPhoneJid !== null && requestedSet.has(normalizedPhoneJid));
-            if (!wasRequested) {
+            const contactNodes = (0, helpers_1.getNodeChildrenByTag)(userNode, constants_1.WA_NODE_TAGS.CONTACT);
+            let matched = false;
+            for (let c = 0; c < contactNodes.length; c += 1) {
+                const contactNode = contactNodes[c];
+                const inputJid = this.recoverContactJid(contactNode);
+                if (inputJid === null || !requestedSet.has(inputJid)) {
+                    continue;
+                }
+                matched = true;
+                const invalid = resolvedJid === null || contactNode.attrs.type === 'invalid';
+                parsed.push({
+                    jid: inputJid,
+                    phoneJid: phoneJid ?? inputJid,
+                    lidJid,
+                    exists: !invalid &&
+                        this.parseLidSyncContactExists(contactNode, inputJid, lidJid !== null),
+                    invalid
+                });
+            }
+            if (matched) {
                 continue;
             }
-            const lidNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.LID);
-            const contactNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.CONTACT);
-            if (!lidNode) {
-                parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
-                parsedCount += 1;
+            if (resolvedJid === null) {
+                this.logger.debug('signal lid sync skipping user node with invalid jid', {
+                    jid: rawUserJid
+                });
                 continue;
             }
-            const errorNode = (0, helpers_1.findNodeChild)(lidNode, constants_1.WA_NODE_TAGS.ERROR);
-            if (errorNode) {
-                this.logger.warn('signal lid sync user error', {
-                    jid: normalizedUserJid,
-                    code: errorNode.attrs.code,
-                    text: errorNode.attrs.text
+            const requestedKey = requestedSet.has(resolvedJid)
+                ? resolvedJid
+                : pnJid !== null && requestedSet.has(pnJid)
+                    ? pnJid
+                    : null;
+            if (requestedKey === null) {
+                this.logger.debug('signal lid sync unmatched user (no contact echo)', {
+                    jid: resolvedJid,
+                    pnJid
                 });
-                parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null);
-                parsedCount += 1;
                 continue;
             }
-            const lidJid = lidNode.attrs.val ? this.normalizeUserJid(lidNode.attrs.val) : null;
-            parsed[parsedCount] = this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, lidJid);
-            parsedCount += 1;
+            const contactNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.CONTACT);
+            parsed.push({
+                jid: requestedKey,
+                phoneJid: phoneJid ?? requestedKey,
+                lidJid,
+                exists: this.parseLidSyncContactExists(contactNode, requestedKey, lidJid !== null),
+                invalid: false
+            });
+        }
+        if (lidUserErrors.length > 0) {
+            this.logger.warn('signal lid sync user errors', {
+                droppedCount: lidUserErrors.length,
+                totalExpected: requestedUsers.length,
+                sample: lidUserErrors.slice(0, 3)
+            });
         }
-        parsed.length = parsedCount;
         return parsed;
     }
-    buildLidSyncResult(jid, phoneJid, contactNode, lidJid) {
-        return {
-            jid,
-            lidJid,
-            phoneJid,
-            exists: this.parseLidSyncContactExists(contactNode, jid, lidJid !== null)
-        };
+    /**
+     * Recovers the queried phone JID from a `<contact>` echo. Each `<contact>` in a
+     * usync response echoes the `+<number>` we sent (base64 text content), so it maps
+     * a response node back to the exact input - even when the server corrected the
+     * `<user jid>` or rejected it as `jid='undefined'`. Returns `null` when there is
+     * no decodable phone echo.
+     */
+    recoverContactJid(contactNode) {
+        const echoed = (0, helpers_1.getNodeTextContent)(contactNode);
+        if (!echoed) {
+            return null;
+        }
+        try {
+            return (0, jid_1.parsePhoneJid)(echoed);
+        }
+        catch {
+            return null;
+        }
     }
     parseLidSyncContactExists(contactNode, userJid, defaultExists) {
         if (!contactNode) {
@@ -404,7 +460,10 @@ class SignalDeviceSyncApi {
         let normalizedCount = 0;
         const dedup = new Set();
         for (let index = 0; index < userJids.length; index += 1) {
-            const normalizedJid = this.normalizeUserJid(userJids[index]);
+            const normalizedJid = (0, jid_1.toUserJid)(userJids[index], {
+                canonicalizeSignalServer: true,
+                hostDomain: this.hostDomain
+            });
             if (dedup.has(normalizedJid)) {
                 continue;
             }
@@ -415,11 +474,22 @@ class SignalDeviceSyncApi {
         normalized.length = normalizedCount;
         return normalized;
     }
-    normalizeUserJid(jid) {
-        return (0, jid_1.toUserJid)(jid, {
-            canonicalizeSignalServer: true,
-            hostDomain: this.hostDomain
-        });
+    /**
+     * Canonicalizes a user jid, returning `null` instead of throwing when the input
+     * is not a valid jid (for example the literal `'undefined'` the server returns
+     * for an invalid contact). Lets a single malformed response node be skipped
+     * without discarding the rest of the batch.
+     */
+    tryNormalizeUserJid(jid) {
+        try {
+            return (0, jid_1.toUserJid)(jid, {
+                canonicalizeSignalServer: true,
+                hostDomain: this.hostDomain
+            });
+        }
+        catch {
+            return null;
+        }
     }
 }
 exports.SignalDeviceSyncApi = SignalDeviceSyncApi;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zapo-js",
-    "version": "1.5.0",
+    "version": "1.5.1",
     "description": "High-performance WhatsApp Web TypeScript library",
     "license": "MIT",
     "author": "vinikjkkj <contact@vinicius.email> (https://github.com/vinikjkkj)",