zapo-js 1.6.2 → 1.7.0

package/dist/abprops-spec.d.ts

@@ -0,0 +1,10 @@
+import { type WaAbPropName } from '../spec/abprops';
+export { WA_ABPROPS, WA_ABPROPS_BY_CODE, WA_ABPROPS_SPECIAL_EARLY, WA_ABPROPS_USED_BEFORE_INIT, WA_GROUP_ABPROPS, WA_GROUP_ABPROPS_BY_CODE } from '../spec/abprops';
+export type { WaAbProp, WaAbPropName, WaAbPropType, WaAbPropValue, WaAbPropValueByName, WaAbPropValueOf, WaGroupAbPropName, WaGroupAbPropValueByName } from '../spec/abprops';
+/**
+ * Resolves the client-side prop name for a wire config code.
+ *
+ * Returns `undefined` for codes this build does not know about - the server
+ * advertises props from newer bundles, and WA Web drops those rows too.
+ */
+export declare function resolveAbPropNameByCode(configCode: number): WaAbPropName | undefined;

package/dist/abprops-spec.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WA_GROUP_ABPROPS_BY_CODE = exports.WA_GROUP_ABPROPS = exports.WA_ABPROPS_USED_BEFORE_INIT = exports.WA_ABPROPS_SPECIAL_EARLY = exports.WA_ABPROPS_BY_CODE = exports.WA_ABPROPS = void 0;
+exports.resolveAbPropNameByCode = resolveAbPropNameByCode;
+const abprops_1 = require("../spec/abprops");
+var abprops_2 = require("../spec/abprops");
+Object.defineProperty(exports, "WA_ABPROPS", { enumerable: true, get: function () { return abprops_2.WA_ABPROPS; } });
+Object.defineProperty(exports, "WA_ABPROPS_BY_CODE", { enumerable: true, get: function () { return abprops_2.WA_ABPROPS_BY_CODE; } });
+Object.defineProperty(exports, "WA_ABPROPS_SPECIAL_EARLY", { enumerable: true, get: function () { return abprops_2.WA_ABPROPS_SPECIAL_EARLY; } });
+Object.defineProperty(exports, "WA_ABPROPS_USED_BEFORE_INIT", { enumerable: true, get: function () { return abprops_2.WA_ABPROPS_USED_BEFORE_INIT; } });
+Object.defineProperty(exports, "WA_GROUP_ABPROPS", { enumerable: true, get: function () { return abprops_2.WA_GROUP_ABPROPS; } });
+Object.defineProperty(exports, "WA_GROUP_ABPROPS_BY_CODE", { enumerable: true, get: function () { return abprops_2.WA_GROUP_ABPROPS_BY_CODE; } });
+// The reverse map is emitted with numeric literal keys, so it cannot be indexed
+// with a plain `number`. Widening it keeps the lookup a single property read and
+// avoids allocating a parallel Map with 2000+ entries at module init.
+const AB_PROP_NAME_BY_CODE = abprops_1.WA_ABPROPS_BY_CODE;
+/**
+ * Resolves the client-side prop name for a wire config code.
+ *
+ * Returns `undefined` for codes this build does not know about - the server
+ * advertises props from newer bundles, and WA Web drops those rows too.
+ */
+function resolveAbPropNameByCode(configCode) {
+    return AB_PROP_NAME_BY_CODE[configCode];
+}

package/dist/client/WaClient.d.ts

@@ -27,6 +27,7 @@ declare class WaClientImpl extends EventEmitter {
     private readonly appStateSync;
     private readonly mediaTransfer;
     private readonly writeBehind;
+    private readonly observeEphemeralSetting;
     private connectPromise;
     private acceptingIncomingEvents;
     private activeIncomingHandlers;
@@ -74,6 +75,16 @@ declare class WaClientImpl extends EventEmitter {
     getClockSkewMs(): number | null;
     private bindNodeTransportEvents;
     private handleIncomingMessageEvent;
+    /**
+     * Kicks off the group-history bundle download when the incoming message
+     * carries one. Fire-and-forget: the blob can be large, and the incoming
+     * handler must not stall behind a CDN fetch.
+     *
+     * The download outlives the handler that started it, so it takes a slot of
+     * its own in the drain accounting - `disconnect()` and `clearStoredState()`
+     * must not flush or wipe the stores while a bundle is still writing.
+     */
+    private tryProcessGroupHistoryBundle;
     private queryWithContext;
     private handleIncomingFrame;
     /**

package/dist/client/WaClient.js

@@ -3,12 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaClient = void 0;
 const node_events_1 = require("node:events");
 const ignore_key_1 = require("./messaging/ignore-key");
+const ephemeral_setting_1 = require("./persistence/ephemeral-setting");
+const group_history_1 = require("./persistence/group-history");
 const history_sync_1 = require("./persistence/history-sync");
 const mailbox_1 = require("./persistence/mailbox");
 const WriteBehindPersistence_1 = require("./persistence/WriteBehindPersistence");
 const install_1 = require("./plugins/install");
 const WaClientFactory_1 = require("./WaClientFactory");
 const ConsoleLogger_1 = require("../infra/log/ConsoleLogger");
+const content_1 = require("../message/encode/content");
 const _proto_1 = require("../proto");
 const constants_1 = require("../protocol/constants");
 const jid_1 = require("../protocol/jid");
@@ -45,6 +48,10 @@ class WaClientImpl extends node_events_1.EventEmitter {
             threadStore: this.stores.threads,
             contactStore: this.stores.contacts
         }, this.logger, this.options.writeBehind);
+        this.observeEphemeralSetting = (0, ephemeral_setting_1.createEphemeralObserver)({
+            logger: this.logger,
+            chatMetadataStore: this.stores.chatMetadata
+        });
         const dependencies = (0, WaClientFactory_1.buildWaClientDependencies)({
             base,
             runtime: {
@@ -185,6 +192,7 @@ class WaClientImpl extends node_events_1.EventEmitter {
         }
         try {
             this.emit('message', event);
+            this.observeEphemeralSetting(event);
             void (0, mailbox_1.persistIncomingMailboxEntities)({
                 logger: this.logger,
                 writeBehind: this.writeBehind,
@@ -210,6 +218,9 @@ class WaClientImpl extends node_events_1.EventEmitter {
                     });
                 });
             }
+            if (this.options.history?.groupBundles === true && event.message && !event.key.fromMe) {
+                this.tryProcessGroupHistoryBundle(event);
+            }
             const protocolMessage = event.message?.protocolMessage;
             if (!protocolMessage) {
                 return;
@@ -261,6 +272,7 @@ class WaClientImpl extends node_events_1.EventEmitter {
                     await (0, history_sync_1.runHistorySyncNotification)({
                         logger: this.logger,
                         mediaTransfer: this.mediaTransfer,
+                        chatMetadataStore: this.stores.chatMetadata,
                         writeBehind: this.writeBehind,
                         emitEvent: this.emit.bind(this),
                         onPrivacyTokens: (conversations) => this.deps.trustedContactToken.hydrateFromHistorySync(conversations),
@@ -273,6 +285,16 @@ class WaClientImpl extends node_events_1.EventEmitter {
                 }
                 return;
             }
+            if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING) {
+                (0, ephemeral_setting_1.persistIncomingEphemeralSetting)({
+                    logger: this.logger,
+                    writeBehind: this.writeBehind,
+                    chatMetadataStore: this.stores.chatMetadata,
+                    event,
+                    protocolMessage
+                });
+                return;
+            }
             if (SYNC_RELATED_PROTOCOL_TYPES.has(protocolType)) {
                 this.logger.info('incoming sync-related protocol message', {
                     id: event.key.id,
@@ -291,6 +313,43 @@ class WaClientImpl extends node_events_1.EventEmitter {
             this.leaveIncomingHandler();
         }
     }
+    /**
+     * Kicks off the group-history bundle download when the incoming message
+     * carries one. Fire-and-forget: the blob can be large, and the incoming
+     * handler must not stall behind a CDN fetch.
+     *
+     * The download outlives the handler that started it, so it takes a slot of
+     * its own in the drain accounting - `disconnect()` and `clearStoredState()`
+     * must not flush or wipe the stores while a bundle is still writing.
+     */
+    tryProcessGroupHistoryBundle(event) {
+        const bundle = (0, content_1.unwrapMessage)(event.message ?? {}).messageHistoryBundle;
+        const groupJid = event.key.remoteJid;
+        if (!bundle || !groupJid) {
+            return;
+        }
+        if (!this.tryEnterIncomingHandler()) {
+            return;
+        }
+        const credentials = this.deps.authClient.getCurrentCredentials();
+        void (0, group_history_1.runGroupHistoryBundle)({
+            logger: this.logger,
+            mediaTransfer: this.mediaTransfer,
+            writeBehind: this.writeBehind,
+            emitEvent: this.emit.bind(this),
+            meJid: credentials?.meJid,
+            meLid: credentials?.meLid,
+            getAbPropNumber: (name) => this.deps.abPropsCoordinator.getConfigValue(name)
+        }, {
+            bundle,
+            groupJid,
+            senderJid: event.key.participant ?? undefined,
+            bundleMessageId: event.key.id,
+            sentAtSeconds: event.timestampSeconds
+        }).finally(() => {
+            this.leaveIncomingHandler();
+        });
+    }
     async queryWithContext(context, node, timeoutMs = this.options.iqTimeoutMs ?? constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, contextData = {}, options = {}) {
         return (0, query_1.queryWithContext)(async (queryNode, queryTimeoutMs) => this.deps.lowLevelCoordinator.query(queryNode, queryTimeoutMs, options), this.logger, context, node, timeoutMs, contextData);
     }
@@ -365,6 +424,7 @@ class WaClientImpl extends node_events_1.EventEmitter {
      * your own backoff.
      */
     async disconnect() {
+        this.deps.privacyCoordinator.stopAccountSyncRefresh();
         await this.pauseIncomingEventsAndWaitDrain();
         const writeBehindFlush = await this.writeBehind.flush(this.options.writeBehind?.flushTimeoutMs);
         if (writeBehindFlush.remaining > 0) {

package/dist/client/WaClientFactory.d.ts

@@ -18,7 +18,7 @@ import { WaMobileCoordinator } from './coordinators/WaMobileCoordinator';
 import { type WaNewsletterCoordinator } from './coordinators/WaNewsletterCoordinator';
 import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator';
 import { type WaPresenceCoordinator } from './coordinators/WaPresenceCoordinator';
-import { type WaPrivacyCoordinator } from './coordinators/WaPrivacyCoordinator';
+import { type WaPrivacyCoordinatorRuntime } from './coordinators/WaPrivacyCoordinator';
 import { type WaProfileCoordinator } from './coordinators/WaProfileCoordinator';
 import { WaRetryCoordinator } from './coordinators/WaRetryCoordinator';
 import { type WaStatusCoordinator } from './coordinators/WaStatusCoordinator';
@@ -110,7 +110,7 @@ export interface WaClientDependencies {
     readonly statusCoordinator: WaStatusCoordinator;
     readonly broadcastListCoordinator: WaBroadcastListCoordinator;
     readonly newsletterCoordinator: WaNewsletterCoordinator;
-    readonly privacyCoordinator: WaPrivacyCoordinator;
+    readonly privacyCoordinator: WaPrivacyCoordinatorRuntime;
     readonly profileCoordinator: WaProfileCoordinator;
     readonly businessCoordinator: WaBusinessCoordinator;
     readonly botCoordinator: WaBotCoordinator;

package/dist/client/WaClientFactory.js

@@ -149,6 +149,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 +245,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 +271,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,
@@ -371,12 +374,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 +422,8 @@ function buildWaClientDependencies(input) {
             }
             return {
                 participants: participantJids,
-                ephemeral: metadata.ephemeral
+                ephemeral: metadata.ephemeral,
+                ephemeralTrigger: metadata.ephemeralTrigger
             };
         },
         logger
@@ -470,6 +478,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 +522,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 +549,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 +662,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 +709,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 +725,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 +910,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.