zapo-js 1.6.2 → 1.7.0

package/dist/client/coordinators/WaMessageCoordinator.js

@@ -9,12 +9,26 @@ const messages_1 = require("../messaging/messages");
 const constants_1 = require("../../media/constants");
 const addon_crypto_1 = require("../../message/crypto/addon-crypto");
 const content_1 = require("../../message/encode/content");
+const group_history_1 = require("../../message/kinds/group-history");
 const _proto_1 = require("../../proto");
 const jid_1 = require("../../protocol/jid");
 const client_1 = require("../../transport/node/mex/client");
 const bytes_1 = require("../../util/bytes");
 const coercion_1 = require("../../util/coercion");
 const primitives_1 = require("../../util/primitives");
+/** MIME type the group-history bundle is uploaded and advertised under. */
+const GROUP_HISTORY_BUNDLE_MIMETYPE = 'application/protobuf';
+/** Oldest `messageTimestamp` across `messages`, in seconds; `undefined` when none carries one. */
+function oldestTimestampSeconds(messages) {
+    let oldest;
+    for (let index = 0; index < messages.length; index += 1) {
+        const timestamp = (0, primitives_1.longToNumber)(messages[index].messageTimestamp);
+        if (timestamp > 0 && (oldest === undefined || timestamp < oldest)) {
+            oldest = timestamp;
+        }
+    }
+    return oldest;
+}
 function parseReachoutTimelockMexResponse(data) {
     const root = data?.xwa2_fetch_account_reachout_timelock;
     return {
@@ -73,6 +87,8 @@ class WaMessageCoordinator {
         this.emitAddon = deps.emitAddon;
         this.mexSocket = deps.mexSocket;
         this.peerDataOperation = deps.peerDataOperation;
+        this.isGroupHistorySendEnabled = deps.isGroupHistorySendEnabled;
+        this.getAbPropNumber = deps.getAbPropNumber;
     }
     /**
      * Asks the server to backfill older messages for `chatJid` beyond what
@@ -89,13 +105,7 @@ class WaMessageCoordinator {
      */
     async requestHistorySync(input) {
         const chatJid = (0, jid_1.normalizeRecipientJid)(input.chatJid);
-        if (input.count !== undefined) {
-            if (!Number.isFinite(input.count) ||
-                !Number.isSafeInteger(input.count) ||
-                input.count <= 0) {
-                throw new Error(`invalid count: ${input.count}`);
-            }
-        }
+        const onDemandMsgCount = (0, coercion_1.resolveOptionalPositive)(input.count, 'count');
         if (input.oldestMsgTimestampMs !== undefined) {
             if (!Number.isFinite(input.oldestMsgTimestampMs) ||
                 !Number.isSafeInteger(input.oldestMsgTimestampMs) ||
@@ -113,10 +123,155 @@ class WaMessageCoordinator {
             ...(input.oldestMsgTimestampMs === undefined
                 ? {}
                 : { oldestMsgTimestampMs: input.oldestMsgTimestampMs }),
-            ...(input.count === undefined ? {} : { onDemandMsgCount: input.count })
+            ...(onDemandMsgCount === undefined ? {} : { onDemandMsgCount })
         };
         return this.peerDataOperation.send(_proto_1.proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND, { historySyncOnDemandRequest });
     }
+    /**
+     * Shares recent group history with members who joined after the fact - the
+     * counterpart of the `group_history_bundle` event on the receiving side.
+     *
+     * Sends two messages: the bundle itself, encrypted per device and fanned
+     * out **only** to `toJids` (never to the whole group), followed by a hidden
+     * notice addressed to everyone so other clients can render the "history was
+     * shared" marker.
+     *
+     * WhatsApp gates the sender side per account through the `group_history_send`
+     * AB-prop and rejects the stanza with SMAX_INVALID when it is off, so this
+     * throws up front rather than spending an upload. Admin-only groups
+     * (`memberShareGroupHistoryMode: 'admin_share'`) reject a share from a
+     * regular member server-side - read `client.group.queryGroupMetadata()`
+     * first if you want to check that too.
+     *
+     * @throws when the account is not allowed to share group history, when
+     * `groupJid` is not a group, when any of `toJids` is not a current member
+     * (or is this account), or when there is nothing to bundle.
+     * @example
+     * ```ts
+     * await client.message.shareGroupHistory('12036@g.us', {
+     *     toJids: ['5511999999999@s.whatsapp.net'],
+     *     count: 50
+     * })
+     * ```
+     */
+    async shareGroupHistory(groupJid, input) {
+        const normalizedGroupJid = (0, jid_1.normalizeRecipientJid)(groupJid);
+        if (!(0, jid_1.isGroupJid)(normalizedGroupJid)) {
+            throw new Error(`shareGroupHistory requires a group jid: ${normalizedGroupJid}`);
+        }
+        if (input.toJids.length === 0) {
+            throw new Error('shareGroupHistory requires at least one recipient');
+        }
+        const messageLimit = (0, coercion_1.resolvePositive)(input.count, this.getAbPropNumber('group_history_message_count_limit'), 'count');
+        if (!this.isGroupHistorySendEnabled()) {
+            throw new Error('shareGroupHistory is disabled for this account (group_history_send is off)');
+        }
+        const audience = await this.messageDispatch.resolveGroupHistoryAudience(normalizedGroupJid, input.toJids);
+        if (audience.requestedSelf) {
+            throw new Error('shareGroupHistory cannot share history with this account itself');
+        }
+        if (audience.unknownJids.length > 0) {
+            throw new Error(`shareGroupHistory recipients are not members of the group (addressing mode: ${audience.addressingMode}): ${audience.unknownJids.join(', ')}`);
+        }
+        if (audience.historyReceivers.length === 0) {
+            throw new Error('shareGroupHistory resolved no recipients');
+        }
+        const messages = input.messages ??
+            (await this.loadGroupHistoryMessages(normalizedGroupJid, messageLimit, input.sinceMs));
+        if (messages.length === 0) {
+            throw new Error('shareGroupHistory found no messages to share');
+        }
+        const { compressed } = await (0, group_history_1.encodeGroupHistoryBundle)(messages, input.outOfWindowPinnedMessages);
+        const upload = await (0, messages_1.uploadMedia)(this.mediaUploadOptions, {
+            source: compressed,
+            cryptoType: 'group-history',
+            uploadPath: constants_1.MEDIA_UPLOAD_PATHS['group-history'],
+            contentType: GROUP_HISTORY_BUNDLE_MIMETYPE,
+            sidecar: false,
+            logLabel: 'group history bundle upload'
+        });
+        const oldestInWindow = oldestTimestampSeconds(messages);
+        const oldestPin = oldestTimestampSeconds(input.outOfWindowPinnedMessages ?? []);
+        const oldestInBundle = oldestPin === undefined
+            ? oldestInWindow
+            : oldestInWindow === undefined
+                ? oldestPin
+                : Math.min(oldestInWindow, oldestPin);
+        const metadata = {
+            historyReceivers: audience.historyReceivers,
+            nonHistoryReceivers: audience.nonHistoryReceivers,
+            messageCount: messages.length,
+            oldestMessageTimestampInWindow: oldestInWindow,
+            oldestMessageTimestampInBundle: oldestInBundle
+        };
+        const bundleResult = await this.send(normalizedGroupJid, {
+            messageHistoryBundle: {
+                mimetype: GROUP_HISTORY_BUNDLE_MIMETYPE,
+                fileSha256: upload.fileSha256,
+                fileEncSha256: upload.fileEncSha256,
+                mediaKey: upload.mediaKey,
+                directPath: upload.directPath,
+                mediaKeyTimestamp: this.mediaUploadOptions.serverClock.nowSeconds(),
+                messageHistoryMetadata: metadata
+            }
+        });
+        let noticeMessageId;
+        try {
+            noticeMessageId = (await this.send(normalizedGroupJid, {
+                messageHistoryNotice: { messageHistoryMetadata: metadata }
+            })).id;
+        }
+        catch (error) {
+            this.logger.warn('group history notice failed after the bundle was delivered', {
+                groupJid: normalizedGroupJid,
+                id: bundleResult.id,
+                receiverCount: audience.historyReceivers.length,
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+        this.logger.debug('shared group history', {
+            groupJid: normalizedGroupJid,
+            id: bundleResult.id,
+            messagesCount: messages.length,
+            receiverCount: audience.historyReceivers.length
+        });
+        return {
+            bundleMessageId: bundleResult.id,
+            noticeMessageId,
+            messagesCount: messages.length,
+            historyReceivers: audience.historyReceivers,
+            nonHistoryReceivers: audience.nonHistoryReceivers
+        };
+    }
+    /**
+     * Reads the most recent messages of a group back out of the mailbox store
+     * and rebuilds the `WebMessageInfo` shape a bundle carries. Yields nothing
+     * when the `messages` store domain is `'none'`.
+     */
+    async loadGroupHistoryMessages(groupJid, limit, sinceMs) {
+        const records = await this.messageStore.listByThread(groupJid, limit);
+        const messages = [];
+        for (let index = 0; index < records.length; index += 1) {
+            const record = records[index];
+            if (!record.messageBytes) {
+                continue;
+            }
+            if (sinceMs !== undefined && (record.timestampMs ?? 0) < sinceMs) {
+                continue;
+            }
+            messages[messages.length] = {
+                key: {
+                    id: record.id,
+                    remoteJid: groupJid,
+                    fromMe: record.fromMe,
+                    participant: record.participantJid ?? record.senderJid
+                },
+                message: _proto_1.proto.Message.decode(record.messageBytes),
+                messageTimestamp: Math.floor((record.timestampMs ?? 0) / 1000)
+            };
+        }
+        return messages;
+    }
     /**
      * Fetches the server-side "reachout" timelock that throttles cold outreach
      * to non-contacts, returning the active window when enforcement is on.

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

@@ -17,11 +17,13 @@ import type { SenderKeyManager } from '../../signal/group/SenderKeyManager';
 import type { SignalSessionResolver } from '../../signal/session/resolver';
 import type { SignalProtocol } from '../../signal/session/SignalProtocol';
 import type { SignalAddress } from '../../signal/types';
+import type { WaChatMetadataStore } from '../../store/contracts/chat-metadata.store';
 import type { WaDeviceListStore } from '../../store/contracts/device-list.store';
 import type { WaIdentityStore } from '../../store/contracts/identity.store';
 import type { WaMessageSecretStore } from '../../store/contracts/message-secret.store';
 import type { WaSessionStore } from '../../store/contracts/session.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { WaThreadStore } from '../../store/contracts/thread.store';
 import type { BinaryNode } from '../../transport/types';
 import type { ServerClock } from '../../util/clock';
 interface WaMessageDispatchCoordinatorOptions {
@@ -45,6 +47,8 @@ interface WaMessageDispatchCoordinatorOptions {
     readonly sessionStore: WaSessionStore;
     readonly identityStore: WaIdentityStore;
     readonly deviceListStore: WaDeviceListStore;
+    readonly threadStore: WaThreadStore;
+    readonly chatMetadataStore: WaChatMetadataStore;
     readonly signalDeviceSync: SignalDeviceSyncApi;
     readonly messageSecretStore: WaMessageSecretStore;
     /**
@@ -66,6 +70,32 @@ interface WaMessageDispatchCoordinatorOptions {
     readonly mobileMessageIdFormat?: () => boolean;
     readonly serverClock: ServerClock;
 }
+/** Membership split behind a group-history share, in the group's addressing mode. */
+export interface WaGroupHistoryAudience {
+    /** Members the bundle is addressed to. */
+    readonly historyReceivers: readonly string[];
+    /** Members in the group who are not receiving it. */
+    readonly nonHistoryReceivers: readonly string[];
+    /** Requested JIDs that are not current members of the group. */
+    readonly unknownJids: readonly string[];
+    /** Whether the caller asked to share with this account itself. */
+    readonly requestedSelf: boolean;
+    readonly addressingMode: 'pn' | 'lid';
+}
+/**
+ * Narrows a group's participant list to the members a group-history bundle is
+ * addressed to, plus the sender so its own devices keep a copy. Receivers are
+ * intersected with the live participant list, so a stale receiver entry cannot
+ * pull a non-member into the fanout. Any other message keeps the full list.
+ *
+ * Receivers must be written in the group's addressing mode - a PN entry for a
+ * LID-addressed group does not match and is reported through `onDropped`.
+ *
+ * @throws when no receiver matches a current member. Sending to the sender's
+ * own devices alone counts as no match: it would look like a delivered share
+ * while nobody received anything.
+ */
+export declare function restrictGroupHistoryTargets(message: Proto.IMessage, participantUserJids: readonly string[], senderJid: string, onDropped?: (droppedJids: readonly string[], totalExpected: number) => void): readonly string[];
 export declare class WaMessageDispatchCoordinator {
     private readonly deps;
     private readonly mobileMessageIdFormat;
@@ -74,6 +104,24 @@ export declare class WaMessageDispatchCoordinator {
     private readonly privacyTokenDedup;
     private readonly distributionDedup;
     constructor(options: WaMessageDispatchCoordinatorOptions);
+    /**
+     * Per-chat disappearing settings from the cache, falling back to the
+     * durable thread record on a cold miss and warming the cache with it. A
+     * chat with no disappearing mode is cached as expiration `0` rather than
+     * left absent, so the archive is not re-read on every send to it; the
+     * incoming writers overwrite that entry the moment the chat turns it on.
+     * A failing archive degrades the send to "no ephemeral fields" instead of
+     * rejecting it - the store is opt-in persistence, not a send dependency.
+     */
+    private resolveChatMetadata;
+    /**
+     * Disappearing-message fields for a send into a chat with the mode on, or
+     * `{}` when nothing resolves. Both chat kinds report initiator
+     * `CHANGED_IN_CHAT` when nothing more specific is stored; the trigger comes
+     * from the group metadata for a group and defaults to `CHAT_SETTING` for
+     * 1:1, and is omitted when a group reports none.
+     */
+    private resolveChatEphemeral;
     publishMessageNode(node: BinaryNode, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
     publishEncryptedMessage(input: WaEncryptedMessageInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
     publishSignalMessage(input: WaSignalMessagePublishInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
@@ -119,6 +167,22 @@ export declare class WaMessageDispatchCoordinator {
     requestAppStateSyncKeys(keyIds: readonly Uint8Array[]): Promise<readonly string[]>;
     sendAppStateSyncKeyShare(toDeviceJid: string, keys: readonly WaAppStateSyncKey[], missingKeyIds?: readonly Uint8Array[]): Promise<void>;
     mutateGroupMetadataCacheFromGroupEvent(event: WaGroupEvent): Promise<void>;
+    /**
+     * Splits a group's members into the ones a history bundle is being shared
+     * with and the rest, normalizing everything to the group's addressing mode
+     * so the receiver list written into the proto matches what the fanout can
+     * actually resolve. This account is excluded from both lists.
+     *
+     * Requested JIDs that are not current members come back in `unknownJids`
+     * instead of being silently dropped - sharing history with a non-member is
+     * a caller mistake worth surfacing.
+     */
+    resolveGroupHistoryAudience(groupJid: string, requestedJids: readonly string[]): Promise<WaGroupHistoryAudience>;
+    /**
+     * A group-history bundle goes to the members named in `historyReceivers`
+     * rather than to the whole group, so it takes the per-device direct fanout
+     * instead of the group sender key.
+     */
     private shouldUseGroupDirectPath;
     private publishGroupDirectMessage;
     private buildBotSidecarParticipant;

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageDispatchCoordinator = void 0;
+exports.restrictGroupHistoryTargets = restrictGroupHistoryTargets;
 const _crypto_1 = require("../../crypto");
 const primitives_1 = require("../../crypto/core/primitives");
 const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
@@ -20,6 +21,58 @@ const binary_1 = require("../../transport/binary");
 const message_1 = require("../../transport/node/builders/message");
 const bytes_1 = require("../../util/bytes");
 const primitives_2 = require("../../util/primitives");
+/**
+ * Members a group-history bundle is addressed to. Empty for every other
+ * message, which is what keeps the restricted fanout scoped to bundles.
+ */
+function resolveGroupHistoryReceivers(message) {
+    const metadata = (0, content_1.unwrapMessage)(message).messageHistoryBundle?.messageHistoryMetadata;
+    return metadata?.historyReceivers ?? [];
+}
+/**
+ * Narrows a group's participant list to the members a group-history bundle is
+ * addressed to, plus the sender so its own devices keep a copy. Receivers are
+ * intersected with the live participant list, so a stale receiver entry cannot
+ * pull a non-member into the fanout. Any other message keeps the full list.
+ *
+ * Receivers must be written in the group's addressing mode - a PN entry for a
+ * LID-addressed group does not match and is reported through `onDropped`.
+ *
+ * @throws when no receiver matches a current member. Sending to the sender's
+ * own devices alone counts as no match: it would look like a delivered share
+ * while nobody received anything.
+ */
+function restrictGroupHistoryTargets(message, participantUserJids, senderJid, onDropped) {
+    const receivers = resolveGroupHistoryReceivers(message);
+    if (receivers.length === 0) {
+        return participantUserJids;
+    }
+    const pending = new Set();
+    for (let index = 0; index < receivers.length; index += 1) {
+        pending.add((0, jid_1.toUserJid)(receivers[index]));
+    }
+    const senderUserJid = (0, jid_1.toUserJid)(senderJid);
+    const targets = [];
+    let matchedReceivers = 0;
+    for (let index = 0; index < participantUserJids.length; index += 1) {
+        const participant = participantUserJids[index];
+        const participantUserJid = (0, jid_1.toUserJid)(participant);
+        if (pending.delete(participantUserJid)) {
+            matchedReceivers += 1;
+            targets[targets.length] = participant;
+        }
+        else if (participantUserJid === senderUserJid) {
+            targets[targets.length] = participant;
+        }
+    }
+    if (pending.size > 0 && onDropped) {
+        onDropped([...pending], receivers.length);
+    }
+    if (matchedReceivers === 0) {
+        throw new Error('group history bundle resolved no receivers in the group');
+    }
+    return targets;
+}
 class WaMessageDispatchCoordinator {
     constructor(options) {
         this.icdcDedup = new PromiseDedup_1.PromiseDedup();
@@ -29,6 +82,82 @@ class WaMessageDispatchCoordinator {
         this.mobileMessageIdFormat = options.mobileMessageIdFormat ?? (() => false);
         this.serverClock = options.serverClock;
     }
+    /**
+     * Per-chat disappearing settings from the cache, falling back to the
+     * durable thread record on a cold miss and warming the cache with it. A
+     * chat with no disappearing mode is cached as expiration `0` rather than
+     * left absent, so the archive is not re-read on every send to it; the
+     * incoming writers overwrite that entry the moment the chat turns it on.
+     * A failing archive degrades the send to "no ephemeral fields" instead of
+     * rejecting it - the store is opt-in persistence, not a send dependency.
+     */
+    async resolveChatMetadata(chatJid) {
+        try {
+            const cached = await this.deps.chatMetadataStore.getChatMetadata(chatJid);
+            if (cached) {
+                return cached;
+            }
+            const thread = await this.deps.threadStore.getByJid(chatJid);
+            const expiration = thread?.ephemeralExpiration ?? 0;
+            const settingTimestamp = expiration > 0 ? thread?.ephemeralSettingTimestamp : undefined;
+            const snapshot = {
+                chatJid,
+                ephemeralExpiration: expiration,
+                ...(settingTimestamp !== undefined
+                    ? { ephemeralSettingTimestamp: settingTimestamp }
+                    : {}),
+                updatedAtMs: Date.now()
+            };
+            await this.deps.chatMetadataStore.upsertChatMetadata(snapshot);
+            return snapshot;
+        }
+        catch (error) {
+            this.deps.logger.debug('chat metadata lookup failed, sending without ephemeral fields', {
+                jid: chatJid,
+                message: (0, primitives_2.toError)(error).message
+            });
+            return null;
+        }
+    }
+    /**
+     * Disappearing-message fields for a send into a chat with the mode on, or
+     * `{}` when nothing resolves. Both chat kinds report initiator
+     * `CHANGED_IN_CHAT` when nothing more specific is stored; the trigger comes
+     * from the group metadata for a group and defaults to `CHAT_SETTING` for
+     * 1:1, and is omitted when a group reports none.
+     */
+    async resolveChatEphemeral(recipientJid) {
+        if ((0, jid_1.isGroupJid)(recipientJid)) {
+            const settings = await this.deps.groupMetadataCache.resolveEphemeralSettings(recipientJid);
+            if (!settings) {
+                return {};
+            }
+            return {
+                expirationSeconds: settings.expirationSeconds,
+                disappearingModeInitiator: _proto_1.proto.DisappearingMode.Initiator.CHANGED_IN_CHAT,
+                ...(settings.trigger !== undefined
+                    ? {
+                        disappearingModeTrigger: settings.trigger
+                    }
+                    : {})
+            };
+        }
+        const chat = await this.resolveChatMetadata(recipientJid);
+        const expiration = chat?.ephemeralExpiration;
+        if (expiration === undefined || expiration <= 0) {
+            return {};
+        }
+        const stored = chat?.ephemeralSettingTimestamp;
+        const settingTimestamp = stored !== undefined ? (0, constants_1.normalizeEphemeralSettingSeconds)(stored) : undefined;
+        return {
+            expirationSeconds: expiration,
+            disappearingModeInitiator: _proto_1.proto.DisappearingMode.Initiator.CHANGED_IN_CHAT,
+            disappearingModeTrigger: _proto_1.proto.DisappearingMode.Trigger.CHAT_SETTING,
+            ...(settingTimestamp !== undefined
+                ? { ephemeralSettingTimestamp: settingTimestamp }
+                : {})
+        };
+    }
     async publishMessageNode(node, options = {}) {
         this.deps.logger.trace('wa client publish message node', {
             tag: node.tag,
@@ -149,17 +278,34 @@ class WaMessageDispatchCoordinator {
                 this.withResolvedMessageId(options)
             ]);
         }
+        const isGroupRecipient = (0, jid_1.isGroupJid)(recipientJid);
+        const directRecipientJid = isGroupRecipient
+            ? recipientJid
+            : await this.resolveDirectRecipientLid((0, jid_1.toUserJid)(recipientJid));
         let optionsCtx = options.contextInfo;
         if (options.expirationSeconds !== undefined) {
             optionsCtx = { ...optionsCtx, expirationSeconds: options.expirationSeconds };
         }
-        if ((0, jid_1.isGroupJid)(recipientJid) &&
-            optionsCtx?.expirationSeconds === undefined &&
-            !options.disableGroupEphemeralAutoInject) {
-            const cachedEphemeral = await this.deps.groupMetadataCache.resolveEphemeral(recipientJid);
-            if (cachedEphemeral !== null && cachedEphemeral > 0) {
-                optionsCtx = { ...optionsCtx, expirationSeconds: cachedEphemeral };
-            }
+        if (options.ephemeralSettingTimestamp !== undefined) {
+            optionsCtx = {
+                ...optionsCtx,
+                ephemeralSettingTimestamp: options.ephemeralSettingTimestamp
+            };
+        }
+        if (options.disappearingModeTrigger !== undefined) {
+            optionsCtx = {
+                ...optionsCtx,
+                disappearingModeTrigger: options.disappearingModeTrigger
+            };
+        }
+        const autoInjectDisabled = isGroupRecipient
+            ? options.disableGroupEphemeralAutoInject
+            : options.disableDirectEphemeralAutoInject;
+        if (optionsCtx?.expirationSeconds === undefined && !autoInjectDisabled) {
+            optionsCtx = {
+                ...(await this.resolveChatEphemeral(directRecipientJid)),
+                ...optionsCtx
+            };
         }
         const ctx = (0, context_info_1.resolveSendContextInfo)({
             contentLevel: pickContentContextInfo(content),
@@ -285,9 +431,6 @@ class WaMessageDispatchCoordinator {
             customNodes: customNodes.length > 0 ? customNodes : undefined,
             sendOptions
         };
-        const directRecipientJid = isGroup
-            ? recipientJid
-            : await this.resolveDirectRecipientLid((0, jid_1.toUserJid)(recipientJid));
         const peerRecipientPn = isGroup
             ? undefined
             : await this.resolvePeerRecipientPn((0, jid_1.toUserJid)(recipientJid), directRecipientJid);
@@ -550,9 +693,59 @@ class WaMessageDispatchCoordinator {
     async mutateGroupMetadataCacheFromGroupEvent(event) {
         await this.deps.groupMetadataCache.mutateFromGroupEvent(event);
     }
-    // noop for now
+    /**
+     * Splits a group's members into the ones a history bundle is being shared
+     * with and the rest, normalizing everything to the group's addressing mode
+     * so the receiver list written into the proto matches what the fanout can
+     * actually resolve. This account is excluded from both lists.
+     *
+     * Requested JIDs that are not current members come back in `unknownJids`
+     * instead of being silently dropped - sharing history with a non-member is
+     * a caller mistake worth surfacing.
+     */
+    async resolveGroupHistoryAudience(groupJid, requestedJids) {
+        const participants = await this.deps.groupMetadataCache.resolveParticipantUsers(groupJid);
+        const meJid = this.requireCurrentMeJid('shareGroupHistory');
+        const addressingMode = this.resolveGroupAddressingMode(participants, groupJid);
+        const meUserJid = (0, jid_1.toUserJid)(this.resolveSenderForAddressingMode(addressingMode, meJid));
+        const pending = new Set();
+        for (let index = 0; index < requestedJids.length; index += 1) {
+            pending.add((0, jid_1.toUserJid)((0, jid_1.normalizeRecipientJid)(requestedJids[index])));
+        }
+        const historyReceivers = [];
+        const nonHistoryReceivers = [];
+        for (let index = 0; index < participants.length; index += 1) {
+            const participantUserJid = (0, jid_1.toUserJid)(participants[index]);
+            if (participantUserJid === meUserJid) {
+                continue;
+            }
+            if (pending.delete(participantUserJid)) {
+                historyReceivers[historyReceivers.length] = participantUserJid;
+            }
+            else {
+                nonHistoryReceivers[nonHistoryReceivers.length] = participantUserJid;
+            }
+        }
+        const requestedSelf = pending.delete(meUserJid);
+        const unknownJids = [];
+        for (const jid of pending) {
+            unknownJids[unknownJids.length] = jid;
+        }
+        return {
+            historyReceivers,
+            nonHistoryReceivers,
+            unknownJids,
+            requestedSelf,
+            addressingMode
+        };
+    }
+    /**
+     * A group-history bundle goes to the members named in `historyReceivers`
+     * rather than to the whole group, so it takes the per-device direct fanout
+     * instead of the group sender key.
+     */
     shouldUseGroupDirectPath(message) {
-        return false;
+        return resolveGroupHistoryReceivers(message).length > 0;
     }
     async publishGroupDirectMessage(groupJid, envelope, retryContext = {}) {
         const { message, plaintext, type, edit, mediatype, sendOptions } = envelope;
@@ -562,8 +755,16 @@ class WaMessageDispatchCoordinator {
             : await this.deps.groupMetadataCache.resolveParticipantUsers(groupJid);
         const addressingMode = retryContext.forceAddressingMode ??
             this.resolveGroupAddressingMode(participantUserJids, groupJid);
-        const senderForPhash = this.resolveSenderForAddressingMode(addressingMode, meJid);
-        const fanoutDeviceJids = await this.deps.fanoutResolver.resolveGroupParticipantDeviceJids(participantUserJids);
+        const senderJid = this.resolveSenderForAddressingMode(addressingMode, meJid);
+        const targetUserJids = restrictGroupHistoryTargets(message, participantUserJids, senderJid, (droppedJids, totalExpected) => {
+            this.deps.logger.warn('group history receivers missing from the participant list', {
+                groupJid,
+                droppedCount: droppedJids.length,
+                totalExpected,
+                sample: droppedJids.slice(0, 3)
+            });
+        });
+        const fanoutDeviceJids = await this.deps.fanoutResolver.resolveGroupParticipantDeviceJids(targetUserJids);
         if (fanoutDeviceJids.length === 0) {
             throw new Error('group direct send resolved no target devices');
         }
@@ -618,22 +819,10 @@ class WaMessageDispatchCoordinator {
                 break;
             }
         }
-        const phashTargets = new Array(resolvedFanoutTargets.length + 1);
-        let phashTargetCount = 0;
-        for (let index = 0; index < resolvedFanoutTargets.length; index += 1) {
-            const candidate = resolvedFanoutTargets[index].jid;
-            if ((0, jid_1.isHostedDeviceJid)(candidate))
-                continue;
-            phashTargets[phashTargetCount] = candidate;
-            phashTargetCount += 1;
-        }
-        phashTargets[phashTargetCount] = senderForPhash;
-        phashTargets.length = phashTargetCount + 1;
-        const localPhash = (0, phash_1.computePhashV2)(phashTargets);
         const reportingArtifacts = await this.tryBuildReportingTokenArtifacts({
             message,
             stanzaId: sendOptions.id,
-            senderUserJid: (0, jid_1.toUserJid)(senderForPhash),
+            senderUserJid: (0, jid_1.toUserJid)(senderJid),
             remoteJid: groupJid,
             context: 'group_direct'
         });
@@ -645,7 +834,6 @@ class WaMessageDispatchCoordinator {
             type,
             id: sendOptions.id,
             edit,
-            phash: localPhash,
             addressingMode,
             participants,
             deviceIdentity: shouldAttachDeviceIdentity
@@ -671,7 +859,7 @@ class WaMessageDispatchCoordinator {
         const ackError = result.ack.error;
         const serverPhash = result.ack.phash;
         const serverAddressingMode = result.ack.addressingMode;
-        const hasPhashMismatch = !!serverPhash && serverPhash !== localPhash;
+        const hasPhashMismatch = !!serverPhash;
         const hasAddressingMismatch = !!serverAddressingMode && serverAddressingMode !== addressingMode;
         const hasAddressingError = ackError === constants_1.WA_NACK_REASONS.STALE_GROUP_ADDRESSING_MODE;
         if (!retryContext.retried &&
@@ -679,7 +867,6 @@ class WaMessageDispatchCoordinator {
             this.deps.logger.warn('group direct publish acknowledged with mismatch metadata', {
                 id: result.id,
                 groupJid,
-                localPhash,
                 serverPhash,
                 localAddressingMode: addressingMode,
                 serverAddressingMode,