zapo-js 1.6.2 → 1.7.1

package/dist/client/WaClientFactory.js

@@ -100,6 +100,7 @@ function resolveWaClientBase(options, logger) {
         sessionId,
         deviceBrowser: device.browser,
         deviceOsDisplayName: device.osDisplayName,
+        deviceOsVersion: device.osVersion ?? undefined,
         devicePlatform: device.platform,
         urls: options.urls ?? options.chatSocketUrls ?? constants_1.WA_DEFAULTS.CHAT_SOCKET_URLS,
         iqTimeoutMs: options.iqTimeoutMs ?? constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS,
@@ -124,7 +125,7 @@ function createIncomingNodeRuntime(input) {
     const { logger, emitEvent, authClient, connectionManager, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, sendNode, syncAppState, disconnect, clearStoredCredentials, getCurrentCredentials, handleClientDirtyBits, incomingMessageAckOptions } = input;
     return {
         handleStreamControlResult: streamControl.handleStreamControlResult,
-        persistSuccessAttributes: (attributes) => authClient.persistSuccessAttributes(attributes),
+        persistSuccessAttributes: (attributes) => authClient.persistSuccessAttributes(attributes, { countsAsLogin: true }),
         emitSuccessNode: (node) => emitEvent('debug_connection_success', { node }),
         updateClockSkewFromSuccess: (serverUnixSeconds) => connectionManager.updateClockSkewFromSuccess(serverUnixSeconds),
         shouldWarmupMediaConn: () => !!(getCurrentCredentials()?.meJid && connectionManager.isConnected()),
@@ -149,6 +150,7 @@ function createIncomingNodeRuntime(input) {
         emitIncomingFailure: (event) => emitEvent('stream_failure', event),
         emitIncomingErrorStanza: (event) => emitEvent('stanza_error', event),
         emitIncomingNotification: (event) => emitEvent('debug_notification', event),
+        emitOfflineThreadMetadata: (event) => emitEvent('offline_thread_metadata', event),
         emitMexNotification: (event) => emitEvent('mex_notification', event),
         emitRegistrationCode: (event) => emitEvent('mobile_registration_code', event),
         emitAccountTakeoverNotice: (event) => emitEvent('mobile_account_takeover_notice', event),
@@ -244,6 +246,15 @@ function buildWaClientDependencies(input) {
             allowPrivateHosts: linkPreviewOptions.allowPrivateHosts,
             proxy: linkPreviewOptions.proxy ?? options.proxy?.linkPreview
         });
+    const createLinkPreviewResolver = (surface) => (content) => (0, link_preview_1.resolveLinkPreview)(content.text, content.linkPreview, {
+        logger,
+        mediaTransfer,
+        getMediaConn: () => (0, messages_1.getMediaConn)(mediaMessageBuildOptions),
+        fetcher: linkPreviewFetcher,
+        options: linkPreviewOptions,
+        serverClock,
+        surface
+    });
     const mediaMessageBuildOptions = {
         logger,
         mediaTransfer,
@@ -261,14 +272,7 @@ function buildWaClientDependencies(input) {
         },
         serverClock,
         media: options.media,
-        linkPreviewResolver: (content) => (0, link_preview_1.resolveLinkPreview)(content.text, content.linkPreview, {
-            logger,
-            mediaTransfer,
-            getMediaConn: () => (0, messages_1.getMediaConn)(mediaMessageBuildOptions),
-            fetcher: linkPreviewFetcher,
-            options: linkPreviewOptions,
-            serverClock
-        })
+        linkPreviewResolver: createLinkPreviewResolver()
     };
     const messageClient = new WaMessageClient_1.WaMessageClient({
         logger,
@@ -329,6 +333,7 @@ function buildWaClientDependencies(input) {
     const authClient = new WaAuthClient_1.WaAuthClient({
         deviceBrowser: options.deviceBrowser,
         deviceOsDisplayName: options.deviceOsDisplayName,
+        deviceOsVersion: options.deviceOsVersion,
         devicePlatform: options.devicePlatform,
         requireFullSync: options.requireFullSync,
         version: options.version,
@@ -371,12 +376,16 @@ function buildWaClientDependencies(input) {
         generateStanzaId: () => messageDispatch.generateOutgoingMessageId(),
         mediaTransfer,
         getMediaConn: () => (0, messages_1.getMediaConn)(mediaMessageBuildOptions),
+        linkPreviewResolver: createLinkPreviewResolver('newsletter'),
         getAbPropString: (name) => abPropsCoordinator.getConfigValue(name),
         logger
     });
     const privacyCoordinator = (0, WaPrivacyCoordinator_1.createPrivacyCoordinator)({
+        logger,
         queryWithContext: runtime.queryWithContext,
-        resolveUserJidPair: (userJid) => signalDeviceSync.resolveUserJidPair(userJid)
+        resolveUserJidPair: (userJid) => signalDeviceSync.resolveUserJidPair(userJid),
+        getSelfLid: () => getCurrentCredentials()?.meLid ?? null,
+        emitPrivacy: (event) => runtime.emitEvent('privacy', event)
     });
     const businessCoordinator = (0, WaBusinessCoordinator_1.createBusinessCoordinator)({
         queryWithContext: runtime.queryWithContext,
@@ -415,7 +424,8 @@ function buildWaClientDependencies(input) {
             }
             return {
                 participants: participantJids,
-                ephemeral: metadata.ephemeral
+                ephemeral: metadata.ephemeral,
+                ephemeralTrigger: metadata.ephemeralTrigger
             };
         },
         logger
@@ -470,6 +480,8 @@ function buildWaClientDependencies(input) {
         sessionStore: sessionStore.session,
         identityStore: sessionStore.identity,
         deviceListStore: sessionStore.deviceList,
+        threadStore: sessionStore.threads,
+        chatMetadataStore: sessionStore.chatMetadata,
         signalDeviceSync,
         messageSecretStore: sessionStore.messageSecret,
         persistAllMessageSecrets: options.addons?.persistAllSecrets === true,
@@ -512,7 +524,9 @@ function buildWaClientDependencies(input) {
         trustedContactToken,
         emitAddon: (event) => runtime.emitEvent('message_addon', event),
         mexSocket: { query: runtime.query },
-        peerDataOperation
+        peerDataOperation,
+        isGroupHistorySendEnabled: () => abPropsCoordinator.getConfigValue('group_history_send'),
+        getAbPropNumber: (name) => abPropsCoordinator.getConfigValue(name)
     });
     const retryCoordinator = new WaRetryCoordinator_1.WaRetryCoordinator({
         logger,
@@ -537,7 +551,8 @@ function buildWaClientDependencies(input) {
                 .handleIncomingMessageEvent(event)
                 .catch((err) => runtime.handleError((0, primitives_1.toError)(err)));
         },
-        isMobilePrimary
+        isMobilePrimary,
+        getAbPropNumber: (name) => abPropsCoordinator.getConfigValue(name)
     });
     const botCoordinator = (0, WaBotCoordinator_1.createBotCoordinator)({
         logger,
@@ -649,6 +664,7 @@ function buildWaClientDependencies(input) {
     const disconnectWithClientSideEffects = async (reason, isLogout, code) => {
         abPropsCoordinator.reset();
         offlineResume.reset();
+        privacyCoordinator.stopAccountSyncRefresh();
         await connectionManager?.disconnect();
         runtime.emitEvent('connection', {
             status: 'close',
@@ -695,6 +711,7 @@ function buildWaClientDependencies(input) {
         signalProtocol,
         senderKeyManager,
         onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
+        requestPlaceholderResend: (context) => retryCoordinator.onUnavailableMessage(context),
         emitIncomingMessage: (event) => {
             void runtime
                 .handleIncomingMessageEvent(event)
@@ -710,6 +727,10 @@ function buildWaClientDependencies(input) {
         getCurrentCredentials,
         syncAppState: runtime.syncAppState,
         generateUsyncSid,
+        syncAccountPrivacy: async () => {
+            await privacyCoordinator.refreshFromAccountSync();
+        },
+        emitBlocklist: (blocklist) => runtime.emitEvent('blocklist', blocklist),
         newsletterListSubscribed: () => newsletterCoordinator.listSubscribed()
     }, dirtyBits);
     const offlineResume = new WaOfflineResumeCoordinator_1.WaOfflineResumeCoordinator({
@@ -891,6 +912,25 @@ function buildWaClientDependencies(input) {
             return false;
         }
     });
+    incomingNode.registerIncomingHandler({
+        tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+        subtype: constants_1.WA_NOTIFICATION_TYPES.ACCOUNT_SYNC,
+        prepend: true,
+        /**
+         * The stanza carries the changed `<category>` inline, but it is a
+         * trigger only: the payload is a partial view, so the whole set is
+         * refetched instead. Observer only - returning false keeps the
+         * generic notification handler responsible for the ack and the
+         * `debug_notification` emit, leaving wire behavior unchanged.
+         */
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (node) => {
+            if ((0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.PRIVACY)) {
+                privacyCoordinator.scheduleAccountSyncRefresh();
+            }
+            return false;
+        }
+    });
     incomingNode.registerIncomingHandler({
         tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
         subtype: constants_1.WA_NOTIFICATION_TYPES.DEVICES,

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

@@ -1,5 +1,5 @@
+import { type WaAbPropName, type WaAbPropValue } from '../../abprops-spec';
 import type { Logger } from '../../infra/log/types';
-import { type AbPropName, type AbPropValue } from '../../protocol/abprops';
 import type { BinaryNode } from '../../transport/types';
 type WaAbPropsRuntime = {
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
@@ -16,7 +16,7 @@ export declare class WaAbPropsCoordinator {
         readonly logger: Logger;
         readonly runtime: WaAbPropsRuntime;
     });
-    getConfigValue<T extends AbPropValue>(name: AbPropName): T;
+    getConfigValue<T extends WaAbPropValue>(name: WaAbPropName): T;
     sync(): void;
     reset(): void;
     private startSync;

package/dist/client/coordinators/WaAbPropsCoordinator.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaAbPropsCoordinator = void 0;
+const _abprops_spec_1 = require("../../abprops-spec");
 const abprops_1 = require("../events/abprops");
 const abprops_2 = require("../../protocol/abprops");
 const constants_1 = require("../../protocol/constants");
 const abprops_3 = require("../../transport/node/builders/abprops");
 const primitives_1 = require("../../util/primitives");
+// The generated table types every entry with literal `code` / `defaultValue`
+// types. Reading through a widened view keeps a lookup by a non-literal name
+// from expanding into a 2000-member union at every call site.
+const AB_PROPS = _abprops_spec_1.WA_ABPROPS;
 class WaAbPropsCoordinator {
     constructor(options) {
         this.logger = options.logger;
@@ -21,7 +26,7 @@ class WaAbPropsCoordinator {
         if (cached !== undefined) {
             return cached;
         }
-        return abprops_2.AB_PROP_CONFIGS[name].defaultValue;
+        return AB_PROPS[name].defaultValue;
     }
     sync() {
         if (this.syncPromise) {
@@ -104,11 +109,11 @@ class WaAbPropsCoordinator {
         let applied = 0;
         for (let i = 0; i < result.props.length; i += 1) {
             const entry = result.props[i];
-            const name = (0, abprops_2.resolveAbPropNameByCode)(entry.configCode);
+            const name = (0, _abprops_spec_1.resolveAbPropNameByCode)(entry.configCode);
             if (!name) {
                 continue;
             }
-            const config = abprops_2.AB_PROP_CONFIGS[name];
+            const config = AB_PROPS[name];
             const parsed = parseConfigValue(entry.configValue, config.type, config.defaultValue);
             this.cache.set(name, parsed);
             applied += 1;
@@ -123,6 +128,8 @@ class WaAbPropsCoordinator {
     }
 }
 exports.WaAbPropsCoordinator = WaAbPropsCoordinator;
+// parseInt, not a digits-only parse: negative values are in band, several props
+// ship -1 as their default. Divergence: WA Web caches NaN, we keep the default.
 function parseConfigValue(value, type, defaultValue) {
     if (value === null) {
         return defaultValue;
@@ -131,7 +138,12 @@ function parseConfigValue(value, type, defaultValue) {
         return value === '1' || value === 'true' || value === 'True';
     }
     if (type === 'int') {
-        return (0, primitives_1.parseOptionalInt)(value) ?? defaultValue;
+        const parsed = Number.parseInt(value, 10);
+        return Number.isNaN(parsed) ? defaultValue : parsed;
+    }
+    if (type === 'float') {
+        const parsed = Number.parseFloat(value);
+        return Number.isNaN(parsed) ? defaultValue : parsed;
     }
     return value;
 }

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

@@ -1,7 +1,7 @@
 import type { WaAuthCredentials, WaSuccessPersistAttributes } from '../../auth/types';
 import type { WaOfflineResumeCoordinator } from '../coordinators/WaOfflineResumeCoordinator';
 import type { WaDirtyBit } from '../events/dirty';
-import type { WaAccountTakeoverNoticeEvent, WaBusinessEvent, WaGroupEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingErrorStanzaEvent, WaIncomingFailureEvent, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingReceiptEvent, WaIncomingStanzaFilter, WaIncomingUnhandledStanzaEvent, WaMexNotificationEvent, WaPictureEvent, WaRegistrationCodeEvent } from '../types';
+import type { WaAccountTakeoverNoticeEvent, WaBusinessEvent, WaGroupEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingErrorStanzaEvent, WaIncomingFailureEvent, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingReceiptEvent, WaIncomingStanzaFilter, WaIncomingUnhandledStanzaEvent, WaMexNotificationEvent, WaOfflineThreadMetadataEvent, WaPictureEvent, WaRegistrationCodeEvent } from '../types';
 import type { Logger } from '../../infra/log/types';
 import type { WaConnectionCode, WaDisconnectReason } from '../../protocol/stream';
 import { type WaStreamControlNodeResult } from '../../transport/stream/parse';
@@ -31,6 +31,7 @@ interface WaIncomingNodeRuntime {
     readonly emitIncomingFailure: (event: WaIncomingFailureEvent) => void;
     readonly emitIncomingErrorStanza: (event: WaIncomingErrorStanzaEvent) => void;
     readonly emitIncomingNotification: (event: WaIncomingNotificationEvent) => void;
+    readonly emitOfflineThreadMetadata: (event: WaOfflineThreadMetadataEvent) => void;
     readonly emitMexNotification: (event: WaMexNotificationEvent) => void;
     readonly emitRegistrationCode: (event: WaRegistrationCodeEvent) => void;
     readonly emitAccountTakeoverNotice: (event: WaAccountTakeoverNoticeEvent) => void;

package/dist/client/coordinators/WaIncomingNodeCoordinator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaIncomingNodeCoordinator = void 0;
 const chatstate_1 = require("../events/chatstate");
 const incoming_1 = require("../events/incoming");
+const offline_1 = require("../events/offline");
 const presence_1 = require("../events/presence");
 const constants_1 = require("../../protocol/constants");
 const helpers_1 = require("../../transport/node/helpers");
@@ -381,6 +382,9 @@ class WaIncomingNodeCoordinator {
                 if (child.tag === 'offline') {
                     this.offlineResume.handleOfflineComplete((0, primitives_1.parseOptionalInt)(child.attrs.count) ?? 0);
                 }
+                if (child.tag === 'thread_metadata') {
+                    this.runtime.emitOfflineThreadMetadata((0, offline_1.parseOfflineThreadMetadata)(child));
+                }
                 handled = true;
             }
         }

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

@@ -1,4 +1,5 @@
 import type { Readable } from 'node:stream';
+import type { WaAbPropName } from '../../abprops-spec';
 import type { WaMessageDispatchCoordinator } from '../coordinators/WaMessageDispatchCoordinator';
 import type { WaTrustedContactTokenCoordinator } from '../coordinators/WaTrustedContactTokenCoordinator';
 import { type WaUploadMediaSource } from '../media';
@@ -25,6 +26,65 @@ export interface WaMessageCoordinatorDeps {
     readonly emitAddon: (event: WaIncomingAddonEvent) => void;
     readonly mexSocket: WaMexQuerySocket;
     readonly peerDataOperation: PeerDataOperationRequester;
+    /**
+     * Server-synced `group_history_send` AB-prop. WhatsApp gates the sender
+     * side per account, and rejects the stanza with SMAX_INVALID when it is
+     * off, so {@link WaMessageCoordinator.shareGroupHistory} checks it before
+     * spending an upload.
+     */
+    readonly isGroupHistorySendEnabled: () => boolean;
+    /**
+     * Reads a server-synced numeric AB-prop, falling back to its shipped
+     * default. Sole source for the group-history message-count limit, so a
+     * server-side change takes effect without a release.
+     */
+    readonly getAbPropNumber: (name: WaAbPropName) => number;
+}
+export interface WaShareGroupHistoryInput {
+    /**
+     * Members to share the history with. Must be current members of the group,
+     * written in the group's own addressing mode - a LID-addressed group only
+     * matches `@lid` entries, and a PN one only matches `@s.whatsapp.net`.
+     * Anything else throws, naming the mode the group uses. Read the mode off
+     * `client.group.queryGroupMetadata()`, whose participants carry both forms.
+     */
+    readonly toJids: readonly string[];
+    /**
+     * How many of the most recent messages to read from the mailbox store.
+     * Defaults to WhatsApp's `group_history_message_count_limit` (100).
+     * Ignored when {@link messages} is supplied - that list is bundled as-is.
+     */
+    readonly count?: number;
+    /**
+     * Only read messages at or after this timestamp (ms) from the mailbox
+     * store. Ignored when {@link messages} is supplied.
+     */
+    readonly sinceMs?: number;
+    /**
+     * Messages to bundle, bypassing the mailbox store entirely - {@link count}
+     * and {@link sinceMs} do not apply, so the caller owns the windowing.
+     * Required when the `messages` store domain is `'none'` (the default),
+     * since there is nothing to read back in that case.
+     */
+    readonly messages?: readonly Proto.IWebMessageInfo[];
+    /**
+     * Pinned messages older than the shared window. The receiver injects these
+     * regardless of the age cutoff it applies to `messages`.
+     */
+    readonly outOfWindowPinnedMessages?: readonly Proto.IWebMessageInfo[];
+}
+export interface WaShareGroupHistoryResult {
+    /** Stanza id of the bundle message, fanned out only to `historyReceivers`. */
+    readonly bundleMessageId: string;
+    /**
+     * Stanza id of the notice message, sent to the whole group. Absent when the
+     * notice failed to send: the bundle still reached its receivers, so do not
+     * retry the share - it would upload and deliver the history a second time.
+     */
+    readonly noticeMessageId?: string;
+    readonly messagesCount: number;
+    readonly historyReceivers: readonly string[];
+    readonly nonHistoryReceivers: readonly string[];
 }
 export interface WaRequestHistorySyncInput {
     /** Chat the older messages should be fetched from. */
@@ -111,6 +171,8 @@ export declare class WaMessageCoordinator {
     private readonly emitAddon;
     private readonly mexSocket;
     private readonly peerDataOperation;
+    private readonly isGroupHistorySendEnabled;
+    private readonly getAbPropNumber;
     constructor(deps: WaMessageCoordinatorDeps);
     /**
      * Asks the server to backfill older messages for `chatJid` beyond what
@@ -128,6 +190,40 @@ export declare class WaMessageCoordinator {
     requestHistorySync(input: WaRequestHistorySyncInput): Promise<{
         readonly messageId: string;
     }>;
+    /**
+     * 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
+     * })
+     * ```
+     */
+    shareGroupHistory(groupJid: string, input: WaShareGroupHistoryInput): Promise<WaShareGroupHistoryResult>;
+    /**
+     * 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'`.
+     */
+    private loadGroupHistoryMessages;
     /**
      * 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/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.