zapo-js 1.6.2 → 1.7.0

package/dist/client/coordinators/WaPrivacyCoordinator.d.ts

@@ -1,40 +1,90 @@
+import { type WaBlocklistResult, type WaPrivacyDisallowedListResult, type WaPrivacySettings } from '../events/privacy';
+import type { Logger } from '../../infra/log/types';
 import { type WaPrivacyDisallowedListSettingName, type WaPrivacySettingName, type WaPrivacySettingValueMap } from '../../protocol/privacy';
 import type { SignalUserJidPair } from '../../signal/api/SignalDeviceSyncApi';
 import type { BinaryNode } from '../../transport/types';
-export type WaPrivacySettings = {
-    readonly [K in WaPrivacySettingName]?: WaPrivacySettingValueMap[K];
-};
-export interface WaPrivacyDisallowedListResult {
-    readonly jids: readonly string[];
-    readonly dhash?: string;
+/** JIDs to add to / remove from a category's disallowed list. */
+export interface WaPrivacyDisallowedListInput {
+    readonly add?: readonly string[];
+    readonly remove?: readonly string[];
 }
-export interface WaBlocklistResult {
-    readonly jids: readonly string[];
-    readonly dhash?: string;
+/** A disallowed list the server reported as changed, tagged with its category. */
+export interface WaPrivacyDisallowedListUpdate extends WaPrivacyDisallowedListResult {
+    readonly setting: WaPrivacyDisallowedListSettingName;
+}
+/** Everything an account-sync privacy refresh pulls back. */
+export interface WaPrivacyAccountSyncResult {
+    readonly settings: WaPrivacySettings;
+    /**
+     * Only the lists the server reported as changed - a category sitting off
+     * `contact_blacklist` answers with no list at all and is left out.
+     */
+    readonly disallowedLists: readonly WaPrivacyDisallowedListUpdate[];
 }
 /**
  * Coordinates privacy queries/mutations: per-category settings, blocklist,
  * and the per-category disallowed lists. Accessed via {@link WaClient.privacy}.
  */
 export interface WaPrivacyCoordinator {
-    /** Fetches the current value of every privacy category. */
+    /**
+     * Fetches the current value of every privacy category. A change made on
+     * another device reaches this client on its own and surfaces as a
+     * `privacy` event, so polling this is only needed for the initial read.
+     */
     readonly getPrivacySettings: () => Promise<WaPrivacySettings>;
     /**
-     * Updates a single privacy category to a new {@link WaPrivacyValue}.
+     * Updates a single privacy category to a new value, returning the `dhash`
+     * the server echoes back - the version stamp of that category's
+     * disallowed list, present only while the category sits on
+     * `'contact_blacklist'` (`null` otherwise).
      *
      * The `'contact_blacklist'` value (a deny-list of specific contacts on
-     * top of `'contacts'`/`'all'`) only flips the **mode** here - you must
-     * separately populate the per-category disallowed list with
-     * {@link getDisallowedList} + the corresponding app-state mutation, or
-     * the deny-list stays empty.
+     * top of `'contacts'`/`'all'`) only flips the **mode** here and leaves the
+     * list empty. Populate it with {@link setDisallowedList}, which carries
+     * the mode and the entries in one stanza.
      */
-    readonly setPrivacySetting: <S extends WaPrivacySettingName>(setting: S, value: WaPrivacySettingValueMap[S]) => Promise<void>;
+    readonly setPrivacySetting: <S extends WaPrivacySettingName>(setting: S, value: WaPrivacySettingValueMap[S]) => Promise<string | null>;
     /**
      * Fetches the per-category disallowed list (the JIDs explicitly excluded
-     * from `contact_blacklist`/`contact_whitelist` style settings).
+     * while the category sits on `'contact_blacklist'`). Returns an empty
+     * list when the category is on any other value.
      */
     readonly getDisallowedList: (category: WaPrivacyDisallowedListSettingName) => Promise<WaPrivacyDisallowedListResult>;
-    /** Returns the current account-wide blocklist. */
+    /**
+     * Adds/removes JIDs on a category's disallowed list, switching the
+     * category to `'contact_blacklist'` in the same stanza (the server has no
+     * separate deny-list endpoint). Inputs accept phone jids, LID jids, or
+     * bare phone numbers and are resolved to both addressing forms, like
+     * {@link blockUser}.
+     *
+     * The write is versioned by a `dhash` the coordinator reads right before
+     * sending; if another device mutated the list in between, the server
+     * answers `409` and the call refetches the stamp and retries once.
+     * Returns the new `dhash`.
+     */
+    readonly setDisallowedList: (category: WaPrivacyDisallowedListSettingName, input: WaPrivacyDisallowedListInput) => Promise<string | null>;
+    /**
+     * Refetches everything an account-sync privacy update covers: the whole
+     * category set plus the disallowed lists of
+     * {@link WA_PRIVACY_ACCOUNT_SYNC_DISALLOWED_LISTS}, queried in parallel.
+     * The result is both returned and emitted as the `privacy` event, so the
+     * client's view stays consistent no matter who triggered the refresh.
+     * Categories and lists are separate queries, so a change landing
+     * mid-refresh can leave the two halves a version apart.
+     *
+     * Concurrent calls are deduplicated: one issued while another is still in
+     * flight joins it and resolves with the same snapshot.
+     *
+     * This is what runs on its own when another device changes a setting -
+     * the notification carrying the change is a trigger, not a payload to act
+     * on. Call it directly only to force a refresh.
+     */
+    readonly refreshFromAccountSync: () => Promise<WaPrivacyAccountSyncResult>;
+    /**
+     * Returns the current account-wide blocklist. Blocks/unblocks performed
+     * on another device are refetched through the same dirty-bit path as
+     * {@link getPrivacySettings} and re-emitted as `blocklist`.
+     */
     readonly getBlocklist: () => Promise<WaBlocklistResult>;
     /**
      * Blocks a user (account-wide blocklist). Accepts a phone-number jid, a
@@ -57,10 +107,38 @@ export interface WaPrivacyCoordinator {
      */
     readonly unblockUser: (jid: string) => Promise<void>;
 }
+/**
+ * Account-sync driving surface, kept off {@link WaPrivacyCoordinator} because
+ * it is the client's to call, not the consumer's: `WaClient.privacy` narrows
+ * to the public interface.
+ */
+export interface WaPrivacyCoordinatorRuntime extends WaPrivacyCoordinator {
+    /**
+     * Queues a refresh, restarting the quiet window on every call so a burst
+     * of `account_sync` notifications collapses into a single refetch instead
+     * of one per stanza (each costs five queries). A refresh already in
+     * flight is waited out rather than joined: its queries went out before
+     * the change landed, so its snapshot would not carry the new value.
+     */
+    readonly scheduleAccountSyncRefresh: () => void;
+    /**
+     * Drops a queued refresh so a disconnect does not leave a refetch to fire
+     * against a closed connection. A refresh already in flight still runs to
+     * completion.
+     */
+    readonly stopAccountSyncRefresh: () => void;
+}
 interface WaPrivacyCoordinatorOptions {
+    readonly logger: Logger;
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
     readonly resolveUserJidPair: (userJid: string) => Promise<SignalUserJidPair>;
+    /**
+     * The account's own LID, when it has one. Its presence marks the account
+     * as LID-migrated, which every disallowed-list stanza has to declare.
+     */
+    readonly getSelfLid: () => string | null;
+    readonly emitPrivacy: (event: WaPrivacyAccountSyncResult) => void;
 }
 /** Builds a {@link WaPrivacyCoordinator} backed by the given IQ query function. */
-export declare function createPrivacyCoordinator(options: WaPrivacyCoordinatorOptions): WaPrivacyCoordinator;
+export declare function createPrivacyCoordinator(options: WaPrivacyCoordinatorOptions): WaPrivacyCoordinatorRuntime;
 export {};

package/dist/client/coordinators/WaPrivacyCoordinator.js

@@ -1,94 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPrivacyCoordinator = createPrivacyCoordinator;
+const privacy_1 = require("../events/privacy");
+const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
+const defaults_1 = require("../../protocol/defaults");
 const jid_1 = require("../../protocol/jid");
 const nodes_1 = require("../../protocol/nodes");
-const privacy_1 = require("../../protocol/privacy");
-const privacy_2 = require("../../transport/node/builders/privacy");
-const helpers_1 = require("../../transport/node/helpers");
+const privacy_2 = require("../../protocol/privacy");
+const privacy_3 = require("../../transport/node/builders/privacy");
 const query_1 = require("../../transport/node/query");
-const IGNORED_SERVER_CATEGORIES = new Set([
-    'pix',
-    'linked_profiles',
-    'stickers',
-    'dependentaccountmessages',
-    'cover_photo',
-    'dependent_account_calling',
-    'groupcreation'
-]);
-const VALID_PRIVACY_VALUES = new Set(Object.values(privacy_1.WA_PRIVACY_VALUES));
-function isValidPrivacyValue(value) {
-    return value !== privacy_1.WA_PRIVACY_VALUES.ERROR && VALID_PRIVACY_VALUES.has(value);
-}
-function parsePrivacySettings(result) {
-    const privacyNode = (0, helpers_1.findNodeChild)(result, nodes_1.WA_NODE_TAGS.PRIVACY);
-    if (!privacyNode) {
-        return {};
-    }
-    const settings = {};
-    const categories = (0, helpers_1.getNodeChildrenByTag)(privacyNode, privacy_1.WA_PRIVACY_TAGS.CATEGORY);
-    for (let i = 0; i < categories.length; i += 1) {
-        const node = categories[i];
-        const name = node.attrs.name;
-        const value = node.attrs.value;
-        if (!name || !value) {
-            continue;
-        }
-        if (IGNORED_SERVER_CATEGORIES.has(name)) {
-            continue;
-        }
-        if (!isValidPrivacyValue(value)) {
-            continue;
-        }
-        const settingName = privacy_1.WA_PRIVACY_CATEGORY_TO_SETTING[name];
-        if (settingName) {
-            settings[settingName] = value;
-        }
-    }
-    return settings;
-}
-function parseDisallowedList(result) {
-    const privacyNode = (0, helpers_1.findNodeChild)(result, nodes_1.WA_NODE_TAGS.PRIVACY);
-    if (!privacyNode) {
-        return { jids: [] };
-    }
-    const listNode = (0, helpers_1.findNodeChild)(privacyNode, privacy_1.WA_PRIVACY_TAGS.LIST);
-    if (!listNode) {
-        return { jids: [] };
-    }
-    const dhash = listNode.attrs.dhash;
-    const userNodes = (0, helpers_1.getNodeChildrenByTag)(listNode, privacy_1.WA_PRIVACY_TAGS.USER);
-    const jids = new Array(userNodes.length);
-    let jidsCount = 0;
-    for (let i = 0; i < userNodes.length; i += 1) {
-        const jid = userNodes[i].attrs.jid;
-        if (jid) {
-            jids[jidsCount] = jid;
-            jidsCount += 1;
-        }
-    }
-    jids.length = jidsCount;
-    return { jids, dhash };
-}
-function parseBlocklist(result) {
-    const listNode = (0, helpers_1.findNodeChild)(result, nodes_1.WA_NODE_TAGS.LIST);
-    if (!listNode) {
-        return { jids: [] };
-    }
-    const dhash = listNode.attrs.dhash;
-    const itemNodes = (0, helpers_1.getNodeChildren)(listNode);
-    const jids = new Array(itemNodes.length);
-    let jidsCount = 0;
-    for (let i = 0; i < itemNodes.length; i += 1) {
-        const jid = itemNodes[i].attrs.jid;
-        if (jid) {
-            jids[jidsCount] = jid;
-            jidsCount += 1;
-        }
-    }
-    jids.length = jidsCount;
-    return { jids, dhash };
-}
+const primitives_1 = require("../../util/primitives");
 /**
  * Resolves a blocklist input into both addressing forms via
  * `resolveUserJidPair` (device-list cache first, usync fallback for phone
@@ -106,43 +27,173 @@ async function resolveBlocklistTarget(options, jid) {
     }
     return { lidJid: null, pnJid: pair.pnJid ?? normalized };
 }
+const ACCOUNT_SYNC_REFRESH_KEY = 'account-sync';
+/**
+ * A `409` on a disallowed-list write means the `dhash` we sent no longer
+ * matches the server's: another device changed the list in between.
+ */
+function isStaleDhashResult(node) {
+    if (node.tag !== nodes_1.WA_NODE_TAGS.IQ || node.attrs.type === nodes_1.WA_IQ_TYPES.RESULT) {
+        return false;
+    }
+    const error = (0, query_1.parseIqError)(node);
+    return error.numericCode === 409 || error.code === '409';
+}
+/**
+ * Resolves a disallowed-list input into `<user>` entries. Unlike the blocklist
+ * the server takes both actions in one stanza, so add/remove are resolved
+ * together and keep their relative order.
+ */
+async function resolveDisallowedListEntries(options, input) {
+    const entries = [];
+    const actions = [
+        { action: privacy_2.WA_PRIVACY_LIST_ACTIONS.ADD, jids: input.add ?? [] },
+        { action: privacy_2.WA_PRIVACY_LIST_ACTIONS.REMOVE, jids: input.remove ?? [] }
+    ];
+    for (const { action, jids } of actions) {
+        for (const jid of jids) {
+            const target = await resolveBlocklistTarget(options, jid);
+            entries.push({ action, lidJid: target.lidJid, pnJid: target.pnJid });
+        }
+    }
+    if (entries.length === 0) {
+        throw new Error('setDisallowedList requires at least one add/remove entry');
+    }
+    return entries;
+}
 /** Builds a {@link WaPrivacyCoordinator} backed by the given IQ query function. */
 function createPrivacyCoordinator(options) {
     const { queryWithContext } = options;
+    const usesLidAddressing = () => options.getSelfLid() !== null;
+    let refreshTimer = null;
+    let refreshStopped = false;
+    let activeRefresh = null;
+    const refreshDedup = new PromiseDedup_1.PromiseDedup();
+    const queryDisallowedList = async (category) => {
+        const node = (0, privacy_3.buildGetPrivacyDisallowedListIq)(category, usesLidAddressing());
+        const result = await queryWithContext('privacy.getDisallowedList', node, undefined, {
+            category
+        });
+        (0, query_1.assertIqResult)(result, 'privacy.getDisallowedList');
+        return result;
+    };
+    const readDisallowedList = async (category) => (0, privacy_1.parseDisallowedList)(await queryDisallowedList(category));
+    const runAccountSyncRefresh = async () => {
+        const settingsNode = await queryWithContext('privacy.getSettings', (0, privacy_3.buildGetPrivacySettingsIq)());
+        (0, query_1.assertIqResult)(settingsNode, 'privacy.getSettings');
+        const listNodes = await Promise.all(privacy_2.WA_PRIVACY_ACCOUNT_SYNC_DISALLOWED_LISTS.map(async (setting) => ({
+            setting,
+            node: await queryDisallowedList(privacy_2.WA_PRIVACY_SETTING_TO_CATEGORY[setting])
+        })));
+        const disallowedLists = [];
+        for (const { setting, node } of listNodes) {
+            const update = (0, privacy_1.parseDisallowedListUpdate)(node);
+            if (update) {
+                disallowedLists.push({ setting, ...update });
+            }
+        }
+        const result = {
+            settings: (0, privacy_1.parsePrivacySettings)(settingsNode),
+            disallowedLists
+        };
+        options.emitPrivacy(result);
+        return result;
+    };
+    /**
+     * Joins a refresh already in flight instead of racing it, so concurrent
+     * callers share one round of queries and one emit.
+     */
+    const dedupedRefresh = () => {
+        const running = refreshDedup.run(ACCOUNT_SYNC_REFRESH_KEY, runAccountSyncRefresh);
+        activeRefresh = running;
+        return running;
+    };
+    /**
+     * Refresh for a change the server just announced. It must not join a
+     * refresh already in flight: that one's queries went out before the
+     * change landed, so joining it would emit a snapshot without the new
+     * value and nothing would refetch. Waiting for it first guarantees a read
+     * issued after the notification.
+     */
+    const followUpRefresh = async () => {
+        if (refreshStopped) {
+            return;
+        }
+        await activeRefresh?.catch(() => undefined);
+        if (refreshStopped) {
+            return;
+        }
+        await dedupedRefresh();
+    };
+    const writeDisallowedList = async (category, entries, dhash) => {
+        const node = (0, privacy_3.buildSetPrivacyDisallowedListIq)(category, entries, dhash, usesLidAddressing());
+        return queryWithContext('privacy.setDisallowedList', node, undefined, {
+            category,
+            entries: entries.length
+        });
+    };
     return {
         getPrivacySettings: async () => {
-            const node = (0, privacy_2.buildGetPrivacySettingsIq)();
+            const node = (0, privacy_3.buildGetPrivacySettingsIq)();
             const result = await queryWithContext('privacy.getSettings', node);
             (0, query_1.assertIqResult)(result, 'privacy.getSettings');
-            return parsePrivacySettings(result);
+            return (0, privacy_1.parsePrivacySettings)(result);
         },
         setPrivacySetting: async (setting, value) => {
-            const category = privacy_1.WA_PRIVACY_SETTING_TO_CATEGORY[setting];
-            const node = (0, privacy_2.buildSetPrivacyCategoryIq)(category, value);
+            const category = privacy_2.WA_PRIVACY_SETTING_TO_CATEGORY[setting];
+            const node = (0, privacy_3.buildSetPrivacyCategoryIq)(category, value);
             const result = await queryWithContext('privacy.setSetting', node, undefined, {
                 category,
                 value
             });
             (0, query_1.assertIqResult)(result, 'privacy.setSetting');
+            return (0, privacy_1.parsePrivacyCategoryDhash)(result, category);
         },
-        getDisallowedList: async (setting) => {
-            const category = privacy_1.WA_PRIVACY_SETTING_TO_CATEGORY[setting];
-            const node = (0, privacy_2.buildGetPrivacyDisallowedListIq)(category);
-            const result = await queryWithContext('privacy.getDisallowedList', node, undefined, {
-                category
-            });
-            (0, query_1.assertIqResult)(result, 'privacy.getDisallowedList');
-            return parseDisallowedList(result);
+        getDisallowedList: async (setting) => readDisallowedList(privacy_2.WA_PRIVACY_SETTING_TO_CATEGORY[setting]),
+        setDisallowedList: async (setting, input) => {
+            const category = privacy_2.WA_PRIVACY_SETTING_TO_CATEGORY[setting];
+            const entries = await resolveDisallowedListEntries(options, input);
+            const current = await readDisallowedList(category);
+            let result = await writeDisallowedList(category, entries, current.dhash ?? null);
+            if (isStaleDhashResult(result)) {
+                const refreshed = await readDisallowedList(category);
+                result = await writeDisallowedList(category, entries, refreshed.dhash ?? null);
+            }
+            (0, query_1.assertIqResult)(result, 'privacy.setDisallowedList');
+            return (0, privacy_1.parsePrivacyCategoryDhash)(result, category);
+        },
+        refreshFromAccountSync: () => dedupedRefresh(),
+        scheduleAccountSyncRefresh: () => {
+            refreshStopped = false;
+            if (refreshTimer !== null) {
+                clearTimeout(refreshTimer);
+            }
+            refreshTimer = setTimeout(() => {
+                refreshTimer = null;
+                void followUpRefresh().catch((error) => {
+                    options.logger.warn('account_sync privacy refresh failed', {
+                        message: (0, primitives_1.toError)(error).message
+                    });
+                });
+            }, defaults_1.WA_DEFAULTS.PRIVACY_ACCOUNT_SYNC_DEBOUNCE_MS);
+            refreshTimer.unref?.();
+        },
+        stopAccountSyncRefresh: () => {
+            refreshStopped = true;
+            if (refreshTimer !== null) {
+                clearTimeout(refreshTimer);
+                refreshTimer = null;
+            }
         },
         getBlocklist: async () => {
-            const node = (0, privacy_2.buildGetBlocklistIq)();
+            const node = (0, privacy_3.buildGetBlocklistIq)();
             const result = await queryWithContext('privacy.getBlocklist', node);
             (0, query_1.assertIqResult)(result, 'privacy.getBlocklist');
-            return parseBlocklist(result);
+            return (0, privacy_1.parseBlocklist)(result);
         },
         blockUser: async (jid) => {
             const target = await resolveBlocklistTarget(options, jid);
-            const node = (0, privacy_2.buildBlocklistBlockIq)(target);
+            const node = (0, privacy_3.buildBlocklistBlockIq)(target);
             const result = await queryWithContext('privacy.blockUser', node, undefined, {
                 jid: target.lidJid ?? target.pnJid
             });
@@ -151,7 +202,7 @@ function createPrivacyCoordinator(options) {
         unblockUser: async (jid) => {
             const target = await resolveBlocklistTarget(options, jid);
             const unblockJid = target.lidJid ?? target.pnJid;
-            const node = (0, privacy_2.buildBlocklistUnblockIq)(unblockJid);
+            const node = (0, privacy_3.buildBlocklistUnblockIq)(unblockJid);
             const result = await queryWithContext('privacy.unblockUser', node, undefined, {
                 jid: unblockJid
             });

package/dist/client/coordinators/WaRetryCoordinator.d.ts

@@ -1,3 +1,4 @@
+import type { WaAbPropName } from '../../abprops-spec';
 import type { WaAuthCredentials } from '../../auth/types';
 import type { WaIncomingMessageEvent } from '../types';
 import type { Logger } from '../../infra/log/types';
@@ -48,6 +49,11 @@ interface WaRetryCoordinatorOptions {
      * or privacy-gated recipients nack them with error 463.
      */
     readonly resolvePrivacyTokenNode?: (recipientJid: string) => Promise<BinaryNode | null>;
+    /**
+     * Server-synced AB props. Only `placeholder_message_resend_maximum_days_limit`
+     * is read; falls back to the spec default when unwired.
+     */
+    readonly getAbPropNumber?: (name: WaAbPropName) => number;
 }
 export declare class WaRetryCoordinator {
     private readonly deps;
@@ -88,6 +94,22 @@ export declare class WaRetryCoordinator {
     private getRetrySessionBaseKey;
     private cleanupRetrySessionBaseKeys;
     private isSenderFromOwnAccount;
+    /**
+     * Queues a `PLACEHOLDER_MESSAGE_RESEND` peer request for a message the server
+     * delivered as `<unavailable/>` (no `<enc>` to decrypt, so no retry receipt).
+     * Returns `false` when the placeholder is unrecoverable, too old, or this
+     * session is the primary. The payload surfaces later as a `message` event.
+     */
+    onUnavailableMessage(context: WaRetryDecryptFailureContext): boolean;
+    private getPlaceholderResendMaxAgeSeconds;
+    /**
+     * Builds the message key the primary indexes the message under: the chat is
+     * the `from`, or the `recipient` for a self-sent 1:1, always without the
+     * `:device` segment. The participant rides along only for an incoming
+     * group/broadcast message. Asking with the raw device-addressed `from`
+     * matches nothing and the resend comes back empty.
+     */
+    private buildPlaceholderResendKey;
     private enqueuePlaceholderResend;
     private flushPlaceholderBatch;
 }

package/dist/client/coordinators/WaRetryCoordinator.js

@@ -14,7 +14,9 @@ const replay_1 = require("../../retry/replay");
 const keygen_1 = require("../../signal/registration/keygen");
 const global_1 = require("../../transport/node/builders/global");
 const retry_1 = require("../../transport/node/builders/retry");
+const helpers_1 = require("../../transport/node/helpers");
 const bytes_1 = require("../../util/bytes");
+const coercion_1 = require("../../util/coercion");
 const collections_1 = require("../../util/collections");
 const primitives_1 = require("../../util/primitives");
 const RETRY_CLEANUP_INTERVAL_MS = 30000;
@@ -26,8 +28,10 @@ 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;
-const PLACEHOLDER_RESEND_MAX_AGE_SECONDS = 30 * 24 * 60 * 60;
+const PLACEHOLDER_RESEND_FALLBACK_MAX_AGE_DAYS = 14;
 const PLACEHOLDER_RESEND_IN_FLIGHT_MAX = 256;
+const PLACEHOLDER_RESEND_TIMEOUT_MS = 120000;
+const DAY_SECONDS = 24 * 60 * 60;
 const PLACEHOLDER_RESEND_SKIP_SUBTYPES = new Set([
     'bot_unavailable_fanout',
     'hosted_unavailable_fanout',
@@ -50,6 +54,30 @@ function getRemoteRetryReasonLogFields(reason) {
         remoteRetryReasonName: getRetryReasonName(reason) ?? 'missing_in_retry_receipt'
     };
 }
+/**
+ * Returns the placeholder subtype the primary never resends (bot fanout, hosted
+ * account, consumed view-once), or `null` when the message is recoverable.
+ */
+function resolvePlaceholderResendSkipSubtype(node) {
+    const subtype = node.attrs.subtype;
+    if (typeof subtype === 'string' && PLACEHOLDER_RESEND_SKIP_SUBTYPES.has(subtype)) {
+        return subtype;
+    }
+    const unavailable = (0, helpers_1.findNodeChild)(node, 'unavailable');
+    if (!unavailable) {
+        return null;
+    }
+    if ((0, helpers_1.findNodeChild)(node, 'bot')) {
+        return 'bot_unavailable_fanout';
+    }
+    if (unavailable.attrs.hosted === 'true') {
+        return 'hosted_unavailable_fanout';
+    }
+    if (unavailable.attrs.type === 'view_once') {
+        return 'view_once_unavailable_fanout';
+    }
+    return null;
+}
 class WaRetryCoordinator {
     constructor(options) {
         this.nextRetryCleanupAtMs = 0;
@@ -768,6 +796,42 @@ class WaRetryCoordinator {
         const meJid = credentials?.meJid;
         return !!meJid && (0, jid_1.parseSignalAddressFromJid)(meJid).user === senderUser;
     }
+    /**
+     * Queues a `PLACEHOLDER_MESSAGE_RESEND` peer request for a message the server
+     * delivered as `<unavailable/>` (no `<enc>` to decrypt, so no retry receipt).
+     * Returns `false` when the placeholder is unrecoverable, too old, or this
+     * session is the primary. The payload surfaces later as a `message` event.
+     */
+    onUnavailableMessage(context) {
+        return this.enqueuePlaceholderResend(context);
+    }
+    getPlaceholderResendMaxAgeSeconds() {
+        const days = (0, coercion_1.tryAsNumber)(this.deps.getAbPropNumber?.('placeholder_message_resend_maximum_days_limit'));
+        return ((days !== null && days > 0 ? days : PLACEHOLDER_RESEND_FALLBACK_MAX_AGE_DAYS) *
+            DAY_SECONDS);
+    }
+    /**
+     * Builds the message key the primary indexes the message under: the chat is
+     * the `from`, or the `recipient` for a self-sent 1:1, always without the
+     * `:device` segment. The participant rides along only for an incoming
+     * group/broadcast message. Asking with the raw device-addressed `from`
+     * matches nothing and the resend comes back empty.
+     */
+    buildPlaceholderResendKey(context) {
+        const fromMe = this.isSenderFromOwnAccount(context);
+        const isGroupOrBroadcast = (0, jid_1.isGroupOrBroadcastJid)(context.from);
+        const chatJid = fromMe && !isGroupOrBroadcast
+            ? (context.messageNode.attrs.recipient ?? context.from)
+            : context.from;
+        return {
+            remoteJid: (0, jid_1.toUserJid)(chatJid),
+            id: context.stanzaId,
+            fromMe,
+            ...(!fromMe && isGroupOrBroadcast && context.participant
+                ? { participant: (0, jid_1.toUserJid)(context.participant) }
+                : {})
+        };
+    }
     enqueuePlaceholderResend(context) {
         if (!this.deps.peerDataOperation || !this.deps.emitIncomingMessage) {
             return false;
@@ -775,14 +839,18 @@ class WaRetryCoordinator {
         if (this.deps.isMobilePrimary?.()) {
             return false;
         }
-        const subtype = context.messageNode.attrs.subtype;
-        if (typeof subtype === 'string' && PLACEHOLDER_RESEND_SKIP_SUBTYPES.has(subtype)) {
+        const skipSubtype = resolvePlaceholderResendSkipSubtype(context.messageNode);
+        if (skipSubtype !== null) {
+            this.deps.logger.trace('placeholder resend skipped: unrecoverable placeholder', {
+                id: context.stanzaId,
+                subtype: skipSubtype
+            });
             return false;
         }
         const timestampSeconds = context.t ? Number(context.t) : Date.now() / 1000;
         if (Number.isFinite(timestampSeconds)) {
             const ageSeconds = Date.now() / 1000 - timestampSeconds;
-            if (ageSeconds > PLACEHOLDER_RESEND_MAX_AGE_SECONDS) {
+            if (ageSeconds > this.getPlaceholderResendMaxAgeSeconds()) {
                 return false;
             }
         }
@@ -797,12 +865,7 @@ class WaRetryCoordinator {
             return false;
         }
         this.placeholderInFlight.add(context.stanzaId);
-        this.placeholderQueue.push({
-            remoteJid: context.from,
-            id: context.stanzaId,
-            fromMe: this.isSenderFromOwnAccount(context),
-            participant: context.participant
-        });
+        this.placeholderQueue.push(this.buildPlaceholderResendKey(context));
         if (this.placeholderTimer === null) {
             this.placeholderTimer = setTimeout(() => {
                 this.placeholderTimer = null;
@@ -831,7 +894,7 @@ class WaRetryCoordinator {
                             participant: item.participant
                         }
                     }))
-                });
+                }, { timeoutMs: PLACEHOLDER_RESEND_TIMEOUT_MS });
                 const meJid = this.deps.getCurrentCredentials()?.meJid;
                 for (const result of results) {
                     const bytes = result.placeholderMessageResendResponse?.webMessageInfoBytes;

package/dist/client/events/dirty.d.ts

@@ -1,4 +1,5 @@
 import type { WaAuthCredentials } from '../../auth/types';
+import { type WaBlocklistResult } from '../events/privacy';
 import type { Logger } from '../../infra/log/types';
 import type { BinaryNode } from '../../transport/types';
 export interface WaDirtyBit {
@@ -14,6 +15,8 @@ interface WaDirtySyncRuntime {
     readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly syncAppState: () => Promise<void>;
     readonly generateUsyncSid: () => Promise<string>;
+    readonly syncAccountPrivacy: () => Promise<void>;
+    readonly emitBlocklist: (blocklist: WaBlocklistResult) => void;
     readonly newsletterListSubscribed?: () => Promise<unknown>;
 }
 export declare function parseDirtyBits(nodes: readonly BinaryNode[], logger: Logger): readonly WaDirtyBit[];