zapo-js 0.2.0 → 1.0.0

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

@@ -1,6 +1,7 @@
+import { buildRecoveredIncomingEvent } from '../../message/primitives/incoming.js';
 import { proto } from '../../proto.js';
-import { WA_MESSAGE_TAGS } from '../../protocol/constants.js';
-import { isGroupOrBroadcastJid, normalizeDeviceJid, parseJidFull } from '../../protocol/jid.js';
+import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES } from '../../protocol/constants.js';
+import { isGroupOrBroadcastJid, isHostedDeviceJid, normalizeDeviceJid, parseJidFull, parseSignalAddressFromJid, toUserJid } from '../../protocol/jid.js';
 import { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON } from '../../retry/constants.js';
 import { parseRetryReceiptRequest, pickRetryStateMax } from '../../retry/parse.js';
 import { mapRetryReasonFromError } from '../../retry/reason.js';
@@ -13,6 +14,16 @@ import { setBoundedMapEntry } from '../../util/collections.js';
 import { toError } from '../../util/primitives.js';
 const RETRY_CLEANUP_INTERVAL_MS = 30000;
 const RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES = 8192;
+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_IN_FLIGHT_MAX = 256;
+const PLACEHOLDER_RESEND_SKIP_SUBTYPES = new Set([
+    'bot_unavailable_fanout',
+    'hosted_unavailable_fanout',
+    'view_once_unavailable_fanout'
+]);
 function getRetryReasonName(code) {
     if (code === undefined) {
         return undefined;
@@ -33,25 +44,18 @@ function getRemoteRetryReasonLogFields(reason) {
 export class WaRetryCoordinator {
     constructor(options) {
         this.nextRetryCleanupAtMs = 0;
-        this.logger = options.logger;
-        this.retryStore = options.retryStore;
-        this.retryTtlMs = this.retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
-        this.signalStore = options.signalStore;
-        this.senderKeyStore = options.senderKeyStore;
-        this.signalProtocol = options.signalProtocol;
-        this.signalDeviceSync = options.signalDeviceSync;
-        this.signalMissingPreKeysSync = options.signalMissingPreKeysSync;
-        this.sendNode = options.sendNode;
-        this.getCurrentMeJid = options.getCurrentMeJid;
-        this.getCurrentMeLid = options.getCurrentMeLid;
-        this.getCurrentSignedIdentity = options.getCurrentSignedIdentity;
+        this.placeholderInFlight = new Set();
+        this.placeholderQueue = [];
+        this.placeholderTimer = null;
+        this.deps = options;
+        this.retryTtlMs = options.retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
         this.retryReplayService = new WaRetryReplayService({
-            logger: this.logger,
+            logger: options.logger,
             messageClient: options.messageClient,
-            signalProtocol: this.signalProtocol,
-            getCurrentMeJid: this.getCurrentMeJid,
-            getCurrentMeLid: this.getCurrentMeLid,
-            getCurrentSignedIdentity: this.getCurrentSignedIdentity
+            signalProtocol: options.signalProtocol,
+            sessionResolver: options.sessionResolver,
+            getCurrentCredentials: options.getCurrentCredentials,
+            resolveUserIcdc: options.resolveUserIcdc
         });
         this.retryProcessingByMessageId = new Map();
         this.retrySessionBaseKeys = new Map();
@@ -62,11 +66,14 @@ export class WaRetryCoordinator {
             if (!prepared) {
                 return false;
             }
+            if (prepared.delegatedToPlaceholderResend) {
+                return true;
+            }
             await this.sendDecryptFailureRetryReceipt(context, prepared);
             return true;
         }
         catch (sendError) {
-            this.logger.warn('failed to send retry receipt for decrypt failure', {
+            this.deps.logger.warn('failed to send retry receipt for decrypt failure', {
                 id: context.stanzaId,
                 from: context.from,
                 participant: context.participant,
@@ -83,8 +90,9 @@ export class WaRetryCoordinator {
         try {
             await this.maybeCleanupRetryStore(Date.now());
             const expectedToJids = [];
-            const meJid = this.getCurrentMeJid()?.trim();
-            const meLid = this.getCurrentMeLid()?.trim();
+            const credentials = this.deps.getCurrentCredentials();
+            const meJid = credentials?.meJid?.trim();
+            const meLid = credentials?.meLid?.trim();
             if (meJid) {
                 expectedToJids.push(meJid);
             }
@@ -99,7 +107,7 @@ export class WaRetryCoordinator {
             await this.handleParsedRetryRequest(receiptNode, request);
         }
         catch (error) {
-            this.logger.warn('failed handling incoming retry request', {
+            this.deps.logger.warn('failed handling incoming retry request', {
                 id: receiptNode.attrs.id,
                 from: receiptNode.attrs.from,
                 participant: receiptNode.attrs.participant,
@@ -114,13 +122,14 @@ export class WaRetryCoordinator {
     }
     isRetryReceiptNode(node) {
         return (node.tag === WA_MESSAGE_TAGS.RECEIPT &&
-            (node.attrs.type === 'retry' || node.attrs.type === 'enc_rekey_retry'));
+            (node.attrs.type === WA_MESSAGE_TYPES.RECEIPT_TYPE_RETRY ||
+                node.attrs.type === WA_MESSAGE_TYPES.RECEIPT_TYPE_ENC_REKEY_RETRY));
     }
     async prepareDecryptFailureRetry(context, error) {
         const nowMs = Date.now();
-        const registrationInfo = await this.signalStore.getRegistrationInfo();
+        const registrationInfo = await this.deps.signalStore.getRegistrationInfo();
         if (!registrationInfo) {
-            this.logger.warn('retry receipt skipped: missing local registration info', {
+            this.deps.logger.warn('retry receipt skipped: missing local registration info', {
                 id: context.stanzaId,
                 from: context.from
             });
@@ -128,23 +137,41 @@ export class WaRetryCoordinator {
         }
         const requester = context.participant ?? context.from;
         const expiresAtMs = nowMs + this.retryTtlMs;
-        const retryCount = await this.retryStore.incrementInboundCounter(context.stanzaId, requester, nowMs, expiresAtMs);
+        const retryCount = await this.deps.retryStore.incrementInboundCounter(context.stanzaId, requester, nowMs, expiresAtMs);
+        const delegatedToPlaceholderResend = retryCount >= PLACEHOLDER_RESEND_RETRY_THRESHOLD &&
+            this.enqueuePlaceholderResend(context);
+        if (delegatedToPlaceholderResend) {
+            return {
+                registrationId: registrationInfo.registrationId,
+                retryCount,
+                retryReason: mapRetryReasonFromError(error),
+                timestamp: context.t ?? String(Math.trunc(nowMs / 1000)),
+                delegatedToPlaceholderResend: true
+            };
+        }
+        const senderDeviceJid = context.participant ?? context.from;
+        const forceKeysForHosted = senderDeviceJid ? isHostedDeviceJid(senderDeviceJid) : false;
         return {
             registrationId: registrationInfo.registrationId,
             retryCount,
-            retryKeys: retryCount >= RETRY_KEYS_MIN_COUNT
-                ? await this.buildRetryKeysSection(registrationInfo.identityKeyPair.pubKey)
+            retryKeys: forceKeysForHosted || retryCount >= RETRY_KEYS_MIN_COUNT
+                ? ((await this.buildRetryKeysSection(registrationInfo.identityKeyPair.pubKey, {
+                    stanzaId: context.stanzaId,
+                    from: context.from
+                })) ?? undefined)
                 : undefined,
             retryReason: mapRetryReasonFromError(error),
-            timestamp: context.t ?? String(Math.trunc(nowMs / 1000))
+            timestamp: context.t ?? String(Math.trunc(nowMs / 1000)),
+            delegatedToPlaceholderResend: false
         };
     }
     async sendDecryptFailureRetryReceipt(context, prepared) {
+        const recipient = context.recipient ?? this.resolvePeerRetryRecipient(context);
         const retryReceiptNode = buildRetryReceiptNode({
             stanzaId: context.stanzaId,
             to: context.from,
             participant: context.participant,
-            recipient: context.recipient,
+            recipient,
             originalMsgId: context.stanzaId,
             retryCount: prepared.retryCount,
             t: prepared.timestamp,
@@ -153,19 +180,40 @@ export class WaRetryCoordinator {
             categoryPeer: context.messageNode.attrs.category === 'peer',
             keys: prepared.retryKeys
         });
-        await this.sendNode(retryReceiptNode);
-        this.logger.debug('sent retry receipt for decrypt failure', {
+        await this.deps.sendNode(retryReceiptNode);
+        this.deps.logger.trace('sent retry receipt for decrypt failure', {
             id: context.stanzaId,
             to: context.from,
             participant: context.participant,
+            recipient,
             retryCount: prepared.retryCount,
             reason: prepared.retryReason,
             withKeys: prepared.retryKeys !== undefined
         });
     }
+    resolvePeerRetryRecipient(context) {
+        if (!context.participant) {
+            return undefined;
+        }
+        const meLid = this.deps.getCurrentCredentials()?.meLid;
+        if (!meLid) {
+            return undefined;
+        }
+        try {
+            const participantUser = toUserJid(context.participant);
+            const meUserLid = toUserJid(meLid);
+            if (participantUser !== meUserLid) {
+                return undefined;
+            }
+            return meUserLid;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async handleParsedRetryRequest(receiptNode, request) {
-        if (request.type === 'enc_rekey_retry') {
-            this.logger.info('received enc_rekey_retry request (voip path deferred)', {
+        if (request.type === WA_MESSAGE_TYPES.RECEIPT_TYPE_ENC_REKEY_RETRY) {
+            this.deps.logger.debug('received enc_rekey_retry request (voip path deferred)', {
                 id: request.stanzaId,
                 originalMsgId: request.originalMsgId,
                 from: request.from,
@@ -184,34 +232,35 @@ export class WaRetryCoordinator {
         if (!prepared) {
             return;
         }
+        const requestLogger = this.deps.logger.child({
+            id: request.stanzaId,
+            originalMsgId: request.originalMsgId,
+            requester: prepared.requesterJid
+        });
         const resendResult = await this.retryReplayService.resendOutboundMessage(prepared.outbound, prepared.requesterJid, request.retryCount);
         if (resendResult === 'ineligible') {
-            this.logger.info('retry request marked ineligible for resend', {
-                id: request.stanzaId,
-                originalMsgId: request.originalMsgId,
-                requester: prepared.requesterJid,
+            requestLogger.debug('retry request marked ineligible for resend', {
                 mode: prepared.outbound.replayMode
             });
             return;
         }
-        this.logger.info('retry request processed and resent', {
-            id: request.stanzaId,
-            originalMsgId: request.originalMsgId,
-            requester: prepared.requesterJid,
+        requestLogger.debug('retry request processed and resent', {
             mode: prepared.outbound.replayMode,
             remoteRetryCount: request.retryCount,
             ...getRemoteRetryReasonLogFields(request.retryReason)
         });
     }
     async prepareRetryResend(request) {
+        const requestLogger = this.deps.logger.child({
+            id: request.stanzaId,
+            originalMsgId: request.originalMsgId
+        });
         const requesterJid = request.participant ?? request.from ?? null;
         if (!requesterJid) {
-            this.logger.warn('retry request ignored: missing requester jid', {
-                id: request.stanzaId,
-                originalMsgId: request.originalMsgId
-            });
+            requestLogger.warn('retry request ignored: missing requester jid');
             return null;
         }
+        const requesterLogger = requestLogger.child({ requester: requesterJid });
         let requesterAddress;
         let requesterNormalizedDeviceJid;
         try {
@@ -220,39 +269,26 @@ export class WaRetryCoordinator {
             requesterNormalizedDeviceJid = requesterParsed.normalizedJid;
         }
         catch (error) {
-            this.logger.info('retry request rejected: invalid requester jid', {
-                id: request.stanzaId,
-                originalMsgId: request.originalMsgId,
-                requester: requesterJid,
+            requesterLogger.debug('retry request rejected: invalid requester jid', {
                 message: toError(error).message
             });
             return null;
         }
         if (request.retryCount >= MAX_RETRY_ATTEMPTS) {
-            this.logger.info('retry request rejected: retry count exceeded', {
-                id: request.stanzaId,
-                originalMsgId: request.originalMsgId,
-                requester: requesterJid,
+            requesterLogger.debug('retry request rejected: retry count exceeded', {
                 remoteRetryCount: request.retryCount,
                 ...getRemoteRetryReasonLogFields(request.retryReason)
             });
             return null;
         }
-        const outbound = await this.retryStore.getOutboundMessage(request.originalMsgId);
+        const outbound = await this.deps.retryStore.getOutboundMessage(request.originalMsgId);
         if (!outbound) {
-            this.logger.info('retry request ignored: outbound message not found', {
-                id: request.stanzaId,
-                originalMsgId: request.originalMsgId,
-                requester: requesterJid
-            });
+            requesterLogger.debug('retry request ignored: outbound message not found');
             return null;
         }
         const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!sessionReady) {
-            this.logger.info('retry request rejected: missing compatible session', {
-                id: request.stanzaId,
-                originalMsgId: request.originalMsgId,
-                requester: requesterJid,
+            requesterLogger.debug('retry request rejected: missing compatible session', {
                 remoteRetryCount: request.retryCount,
                 ...getRemoteRetryReasonLogFields(request.retryReason)
             });
@@ -260,10 +296,7 @@ export class WaRetryCoordinator {
         }
         const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!authorization.authorized) {
-            this.logger.info('retry request rejected', {
-                id: request.stanzaId,
-                originalMsgId: request.originalMsgId,
-                requester: requesterJid,
+            requesterLogger.debug('retry request rejected', {
                 reason: authorization.reason,
                 remoteRetryCount: request.retryCount,
                 ...getRemoteRetryReasonLogFields(request.retryReason)
@@ -286,7 +319,8 @@ export class WaRetryCoordinator {
             return;
         }
         const receiptType = receiptNode.attrs.type;
-        if (receiptType === 'retry' || receiptType === 'enc_rekey_retry') {
+        if (receiptType === WA_MESSAGE_TYPES.RECEIPT_TYPE_RETRY ||
+            receiptType === WA_MESSAGE_TYPES.RECEIPT_TYPE_ENC_REKEY_RETRY) {
             return;
         }
         const nextState = this.mapOutboundStateFromReceiptType(receiptType);
@@ -294,7 +328,7 @@ export class WaRetryCoordinator {
             return;
         }
         await this.runRetryTaskSerialized(messageId, async () => {
-            const current = await this.retryStore.getOutboundMessage(messageId);
+            const current = await this.deps.retryStore.getOutboundMessage(messageId);
             if (!current) {
                 return;
             }
@@ -302,17 +336,17 @@ export class WaRetryCoordinator {
             const expiresAtMs = nowMs + this.retryTtlMs;
             const merged = pickRetryStateMax(current.state, nextState);
             if (merged !== current.state) {
-                await this.retryStore.updateOutboundMessageState(messageId, merged, nowMs, expiresAtMs);
+                await this.deps.retryStore.updateOutboundMessageState(messageId, merged, nowMs, expiresAtMs);
             }
             const requesterJid = receiptNode.attrs.participant ?? receiptNode.attrs.from;
             if (!requesterJid) {
                 return;
             }
             try {
-                await this.retryStore.markOutboundRequesterDelivered(messageId, normalizeDeviceJid(requesterJid), nowMs, expiresAtMs);
+                await this.deps.retryStore.markOutboundRequesterDelivered(messageId, normalizeDeviceJid(requesterJid), nowMs, expiresAtMs);
             }
             catch (error) {
-                this.logger.warn('failed to update outbound requester delivery state', {
+                this.deps.logger.warn('failed to update outbound requester delivery state', {
                     id: messageId,
                     requester: requesterJid,
                     message: toError(error).message
@@ -335,17 +369,20 @@ export class WaRetryCoordinator {
             }
         }
     }
-    async buildRetryKeysSection(identity) {
+    async buildRetryKeysSection(identity, logContext) {
         const [signedPreKey, preKey] = await Promise.all([
-            this.signalStore.getSignedPreKey(),
-            this.signalStore.getOrGenSinglePreKey(generatePreKeyPair)
+            this.deps.signalStore.getSignedPreKey(),
+            this.deps.preKeyStore.getOrGenSinglePreKey(generatePreKeyPair)
         ]);
         if (!signedPreKey) {
-            this.logger.warn('retry keys section skipped: signed prekey unavailable');
-            return undefined;
+            this.deps.logger.warn('retry keys section skipped: signed prekey unavailable', {
+                id: logContext.stanzaId,
+                from: logContext.from
+            });
+            return null;
         }
-        await this.signalStore.markKeyAsUploaded(preKey.keyId);
-        const signedIdentity = this.getCurrentSignedIdentity();
+        await this.deps.preKeyStore.markKeyAsUploaded(preKey.keyId);
+        const signedIdentity = this.deps.getCurrentCredentials()?.signedIdentity;
         return {
             identity,
             key: {
@@ -363,13 +400,18 @@ export class WaRetryCoordinator {
         };
     }
     async updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
+        const requestLogger = this.deps.logger.child({
+            id: request.stanzaId,
+            originalMsgId: request.originalMsgId,
+            requester: requesterJid
+        });
         const [, currentSession] = await Promise.all([
             this.markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress),
-            this.signalStore.getSession(requesterAddress)
+            this.deps.sessionStore.getSession(requesterAddress)
         ]);
         const regIdMismatch = !!currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId;
         if (regIdMismatch && !request.keyBundle) {
-            await this.signalStore.deleteSession(requesterAddress);
+            await this.deps.sessionStore.deleteSession(requesterAddress);
         }
         if (request.keyBundle) {
             if (!request.keyBundle.key || !request.keyBundle.skey.signature) {
@@ -377,32 +419,26 @@ export class WaRetryCoordinator {
             }
             if (request.offline) {
                 if (!currentSession) {
-                    this.logger.info('retry request rejected: offline retry missing existing session', {
-                        id: request.stanzaId,
-                        originalMsgId: request.originalMsgId,
-                        requester: requesterJid,
+                    requestLogger.debug('retry request rejected: offline retry missing existing session', {
                         remoteRetryCount: request.retryCount,
                         ...getRemoteRetryReasonLogFields(request.retryReason)
                     });
-                    await this.signalStore.deleteSession(requesterAddress);
+                    await this.deps.sessionStore.deleteSession(requesterAddress);
                     return false;
                 }
                 if (regIdMismatch) {
-                    this.logger.info('retry request rejected: offline retry registration id mismatch', {
-                        id: request.stanzaId,
-                        originalMsgId: request.originalMsgId,
-                        requester: requesterJid,
+                    requestLogger.debug('retry request rejected: offline retry registration id mismatch', {
                         remoteRetryCount: request.retryCount,
                         ...getRemoteRetryReasonLogFields(request.retryReason)
                     });
-                    await this.signalStore.deleteSession(requesterAddress);
+                    await this.deps.sessionStore.deleteSession(requesterAddress);
                     return false;
                 }
             }
             else if (regIdMismatch) {
-                await this.signalStore.deleteSession(requesterAddress);
+                await this.deps.sessionStore.deleteSession(requesterAddress);
             }
-            await this.signalProtocol.establishOutgoingSession(requesterAddress, {
+            await this.deps.signalProtocol.establishOutgoingSession(requesterAddress, {
                 regId: request.regId,
                 identity: request.keyBundle.identity,
                 signedKey: {
@@ -425,14 +461,14 @@ export class WaRetryCoordinator {
         if (!fetched) {
             return false;
         }
-        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
+        await this.deps.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
         return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
     }
     async applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         if (request.retryCount < 2) {
             return true;
         }
-        const currentSession = await this.signalStore.getSession(requesterAddress);
+        const currentSession = await this.deps.sessionStore.getSession(requesterAddress);
         const sessionBaseKey = currentSession?.aliceBaseKey ?? null;
         if (!sessionBaseKey) {
             return true;
@@ -446,8 +482,8 @@ export class WaRetryCoordinator {
         if (!saved || !uint8Equal(saved.baseKey, sessionBaseKey)) {
             return true;
         }
-        await this.signalStore.deleteSession(requesterAddress);
-        this.logger.info('retry request forcing session refresh due to repeated base key', {
+        await this.deps.sessionStore.deleteSession(requesterAddress);
+        this.deps.logger.debug('retry request forcing session refresh due to repeated base key', {
             id: request.stanzaId,
             originalMsgId: request.originalMsgId,
             requester: requesterJid,
@@ -458,7 +494,7 @@ export class WaRetryCoordinator {
         if (!fetched) {
             return false;
         }
-        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
+        await this.deps.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
         return true;
     }
     async markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress) {
@@ -466,17 +502,17 @@ export class WaRetryCoordinator {
             return;
         }
         try {
-            const deleted = await this.senderKeyStore.markForgetSenderKey(request.from, [
+            const deleted = await this.deps.senderKeyStore.markForgetSenderKey(request.from, [
                 requesterAddress
             ]);
-            this.logger.debug('marked sender key as stale for group retry requester', {
+            this.deps.logger.debug('marked sender key as stale for group retry requester', {
                 groupJid: request.from,
                 requester: requesterJid,
                 deleted
             });
         }
         catch (error) {
-            this.logger.warn('failed to mark sender key as stale for group retry requester', {
+            this.deps.logger.warn('failed to mark sender key as stale for group retry requester', {
                 groupJid: request.from,
                 requester: requesterJid,
                 message: toError(error).message
@@ -484,8 +520,9 @@ export class WaRetryCoordinator {
         }
     }
     async fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, requesterRegistrationId) {
+        const requesterLogger = this.deps.logger.child({ requester: requesterJid });
         try {
-            const results = await this.signalMissingPreKeysSync.fetchMissingPreKeys([
+            const results = await this.deps.signalMissingPreKeysSync.fetchMissingPreKeys([
                 {
                     userJid: `${requesterAddress.user}@${requesterAddress.server}`,
                     devices: [
@@ -498,16 +535,14 @@ export class WaRetryCoordinator {
             ]);
             const first = results[0];
             if (!first || !('devices' in first)) {
-                this.logger.warn('missing prekeys fetch returned user error', {
-                    requester: requesterJid,
+                requesterLogger.debug('missing prekeys fetch returned user error', {
                     errorText: first && 'errorText' in first ? first.errorText : 'unknown'
                 });
                 return null;
             }
             const matched = first.devices.find((device) => normalizeDeviceJid(device.deviceJid) === requesterNormalizedDeviceJid);
             if (!matched) {
-                this.logger.warn('missing prekeys fetch did not return requested device', {
-                    requester: requesterJid,
+                requesterLogger.debug('missing prekeys fetch did not return requested device', {
                     devices: first.devices.length
                 });
                 return null;
@@ -515,8 +550,7 @@ export class WaRetryCoordinator {
             return matched.bundle;
         }
         catch (error) {
-            this.logger.warn('failed to fetch missing prekeys for retry requester', {
-                requester: requesterJid,
+            requesterLogger.debug('failed to fetch missing prekeys for retry requester', {
                 message: toError(error).message
             });
             return null;
@@ -528,10 +562,10 @@ export class WaRetryCoordinator {
         }
         let requesterStatus = null;
         try {
-            requesterStatus = await this.retryStore.getOutboundRequesterStatus(outbound.messageId, requesterNormalizedDeviceJid);
+            requesterStatus = await this.deps.retryStore.getOutboundRequesterStatus(outbound.messageId, toUserJid(requesterNormalizedDeviceJid));
         }
         catch (error) {
-            this.logger.warn('failed to resolve outbound requester status from retry store', {
+            this.deps.logger.warn('failed to resolve outbound requester status from retry store', {
                 id: request.stanzaId,
                 originalMsgId: request.originalMsgId,
                 requester: requesterJid,
@@ -564,7 +598,7 @@ export class WaRetryCoordinator {
             if (requesterNormalizedDeviceJid === normalizeDeviceJid(requesterUser)) {
                 return true;
             }
-            const synced = await this.signalDeviceSync.syncDeviceList([requesterUser]);
+            const synced = await this.deps.signalDeviceSync.syncDeviceList([requesterUser]);
             const target = synced.find((entry) => entry.jid === requesterUser);
             if (!target) {
                 return false;
@@ -577,7 +611,7 @@ export class WaRetryCoordinator {
             return false;
         }
         catch (error) {
-            this.logger.warn('retry authorization failed while syncing requester device list', {
+            this.deps.logger.warn('retry authorization failed while syncing requester device list', {
                 requester: requesterJid,
                 message: toError(error).message
             });
@@ -585,25 +619,25 @@ export class WaRetryCoordinator {
         }
     }
     mapOutboundStateFromReceiptType(type) {
-        if (type === 'read') {
+        if (type === WA_MESSAGE_TYPES.RECEIPT_TYPE_READ) {
             return 'read';
         }
-        if (type === 'played') {
+        if (type === WA_MESSAGE_TYPES.RECEIPT_TYPE_PLAYED) {
             return 'played';
         }
         if (type === undefined ||
             type === '' ||
-            type === 'delivery' ||
-            type === 'sender' ||
-            type === 'inactive' ||
-            type === 'peer_msg') {
+            type === WA_MESSAGE_TYPES.RECEIPT_TYPE_DELIVERY ||
+            type === WA_MESSAGE_TYPES.RECEIPT_TYPE_SENDER ||
+            type === WA_MESSAGE_TYPES.RECEIPT_TYPE_INACTIVE ||
+            type === WA_MESSAGE_TYPES.RECEIPT_TYPE_PEER) {
             return 'delivered';
         }
         return null;
     }
     async sendRetryAckSafe(receiptNode) {
         if (!receiptNode.attrs.id || !receiptNode.attrs.from) {
-            this.logger.warn('retry ack skipped: missing receipt id/from', {
+            this.deps.logger.warn('retry ack skipped: missing receipt id/from', {
                 hasId: receiptNode.attrs.id !== undefined,
                 hasFrom: receiptNode.attrs.from !== undefined,
                 participant: receiptNode.attrs.participant,
@@ -612,14 +646,14 @@ export class WaRetryCoordinator {
             return;
         }
         try {
-            await this.sendNode(buildAckNode({
+            await this.deps.sendNode(buildAckNode({
                 kind: 'receipt',
                 node: receiptNode,
                 retryType: true
             }));
         }
         catch (error) {
-            this.logger.warn('failed to send retry ack', {
+            this.deps.logger.warn('failed to send retry ack', {
                 id: receiptNode.attrs.id,
                 from: receiptNode.attrs.from,
                 participant: receiptNode.attrs.participant,
@@ -634,10 +668,10 @@ export class WaRetryCoordinator {
         this.nextRetryCleanupAtMs = nowMs + RETRY_CLEANUP_INTERVAL_MS;
         this.cleanupRetrySessionBaseKeys(nowMs);
         try {
-            await this.retryStore.cleanupExpired(nowMs);
+            await this.deps.retryStore.cleanupExpired(nowMs);
         }
         catch (error) {
-            this.logger.warn('retry store cleanup failed', {
+            this.deps.logger.warn('retry store cleanup failed', {
                 message: toError(error).message
             });
         }
@@ -672,4 +706,103 @@ export class WaRetryCoordinator {
             this.retrySessionBaseKeys.delete(key);
         }
     }
+    isSenderFromOwnAccount(context) {
+        const senderUser = parseSignalAddressFromJid(context.participant ?? context.from).user;
+        const credentials = this.deps.getCurrentCredentials();
+        const meLid = credentials?.meLid;
+        if (meLid && parseSignalAddressFromJid(meLid).user === senderUser)
+            return true;
+        const meJid = credentials?.meJid;
+        return !!meJid && parseSignalAddressFromJid(meJid).user === senderUser;
+    }
+    enqueuePlaceholderResend(context) {
+        if (!this.deps.peerDataOperation || !this.deps.emitIncomingMessage) {
+            return false;
+        }
+        const subtype = context.messageNode.attrs.subtype;
+        if (typeof subtype === 'string' && PLACEHOLDER_RESEND_SKIP_SUBTYPES.has(subtype)) {
+            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) {
+                return false;
+            }
+        }
+        if (this.placeholderInFlight.has(context.stanzaId)) {
+            return true;
+        }
+        if (this.placeholderInFlight.size >= PLACEHOLDER_RESEND_IN_FLIGHT_MAX) {
+            this.deps.logger.warn('placeholder resend: in-flight set saturated, dropping enqueue', {
+                id: context.stanzaId,
+                maxInFlight: PLACEHOLDER_RESEND_IN_FLIGHT_MAX
+            });
+            return false;
+        }
+        this.placeholderInFlight.add(context.stanzaId);
+        this.placeholderQueue.push({
+            remoteJid: context.from,
+            id: context.stanzaId,
+            fromMe: this.isSenderFromOwnAccount(context),
+            participant: context.participant
+        });
+        if (this.placeholderTimer === null) {
+            this.placeholderTimer = setTimeout(() => {
+                this.placeholderTimer = null;
+                void this.flushPlaceholderBatch();
+            }, PLACEHOLDER_RESEND_DEBOUNCE_MS);
+        }
+        return true;
+    }
+    async flushPlaceholderBatch() {
+        const peerDataOperation = this.deps.peerDataOperation;
+        const emitIncomingMessage = this.deps.emitIncomingMessage;
+        if (!peerDataOperation || !emitIncomingMessage) {
+            this.placeholderQueue = [];
+            this.placeholderInFlight.clear();
+            return;
+        }
+        while (this.placeholderQueue.length > 0) {
+            const batch = this.placeholderQueue.splice(0, PLACEHOLDER_RESEND_BATCH_SIZE);
+            try {
+                const results = await peerDataOperation.request(proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND, {
+                    placeholderMessageResendRequest: batch.map((item) => ({
+                        messageKey: {
+                            remoteJid: item.remoteJid,
+                            id: item.id,
+                            fromMe: item.fromMe,
+                            participant: item.participant
+                        }
+                    }))
+                });
+                for (const result of results) {
+                    const bytes = result.placeholderMessageResendResponse?.webMessageInfoBytes;
+                    if (!bytes) {
+                        continue;
+                    }
+                    try {
+                        const recovered = proto.WebMessageInfo.decode(bytes);
+                        emitIncomingMessage(buildRecoveredIncomingEvent(recovered));
+                    }
+                    catch (error) {
+                        this.deps.logger.warn('placeholder resend: failed to decode WebMessageInfo', {
+                            message: toError(error).message
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.deps.logger.warn('placeholder resend: request failed', {
+                    batchSize: batch.length,
+                    message: toError(error).message
+                });
+            }
+            finally {
+                for (const item of batch) {
+                    this.placeholderInFlight.delete(item.id);
+                }
+            }
+        }
+    }
 }