zapo-js 1.6.2 → 1.7.0

package/dist/esm/client/persistence/ephemeral-setting.js

@@ -0,0 +1,116 @@
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { pickIncomingEphemeralSettingTimestamp } from '../../message/context-info.js';
+import { isGroupJid } from '../../protocol/jid.js';
+import { normalizeEphemeralSettingSeconds } from '../../protocol/message.js';
+import { longToNumber, toError } from '../../util/primitives.js';
+/**
+ * Persists a 1:1 `EPHEMERAL_SETTING` protocol message so outgoing sends pick up
+ * the peer's change without waiting for history sync. Groups are skipped –
+ * their timer comes from group notifications, not protocol messages.
+ */
+export function persistIncomingEphemeralSetting(options) {
+    const { logger, writeBehind, event, protocolMessage, chatMetadataStore } = options;
+    const chatJid = event.key.remoteJid;
+    if (!chatJid || event.key.isGroup || isGroupJid(chatJid)) {
+        return;
+    }
+    const expiration = protocolMessage.ephemeralExpiration ?? 0;
+    const rawTimestamp = protocolMessage.ephemeralSettingTimestamp !== undefined &&
+        protocolMessage.ephemeralSettingTimestamp !== null
+        ? longToNumber(protocolMessage.ephemeralSettingTimestamp)
+        : event.timestampSeconds;
+    const settingTimestamp = rawTimestamp !== undefined ? normalizeEphemeralSettingSeconds(rawTimestamp) : undefined;
+    void chatMetadataStore
+        .upsertChatMetadata({
+        chatJid,
+        ephemeralExpiration: expiration,
+        ...(settingTimestamp !== undefined
+            ? { ephemeralSettingTimestamp: settingTimestamp }
+            : {}),
+        updatedAtMs: Date.now()
+    })
+        .catch((error) => {
+        logger.debug('failed to cache incoming ephemeral setting', {
+            jid: chatJid,
+            message: toError(error).message
+        });
+    });
+    try {
+        writeBehind.persistThread({
+            jid: chatJid,
+            ephemeralExpiration: expiration,
+            ...(settingTimestamp !== undefined
+                ? { ephemeralSettingTimestamp: settingTimestamp }
+                : {})
+        });
+    }
+    catch (error) {
+        logger.warn('failed to persist incoming ephemeral setting', {
+            jid: chatJid,
+            expiration,
+            message: toError(error).message
+        });
+    }
+}
+/**
+ * Builds the inbound observer that refreshes the chat-metadata cache from
+ * ordinary traffic. A peer stamps `contextInfo.ephemeralSettingTimestamp` on
+ * every message in a disappearing chat, making it the only continuously
+ * refreshed source - history sync and `EPHEMERAL_SETTING` are point-in-time.
+ *
+ * Never blocks and never rejects: the store round-trip is fire-and-forget.
+ * Messages repeating a value share one round-trip, so the batch an offline
+ * resume delivers costs a single read instead of one per message, while a
+ * message carrying a *different* value still gets its own round-trip rather
+ * than being swallowed by the one in flight.
+ *
+ * A write skips a setting older than the cached one, mirroring how the peer
+ * resolves it: highest timestamp wins. That check is not atomic with the
+ * write, so two round-trips that both read a cold cache can still land out of
+ * order and leave the older value behind. The next message from the chat
+ * corrects it, and a stale-but-older stamp loses to the peer's own value
+ * anyway, so this is not worth serializing the receive path over.
+ */
+export function createEphemeralObserver(options) {
+    const { logger, chatMetadataStore } = options;
+    const dedup = new PromiseDedup();
+    return (event) => {
+        const expiration = event.expirationSeconds;
+        if (expiration === undefined || expiration <= 0) {
+            return;
+        }
+        const chatJid = event.key.remoteJid;
+        if (!chatJid || event.key.isGroup || event.key.isNewsletter || isGroupJid(chatJid)) {
+            return;
+        }
+        const raw = pickIncomingEphemeralSettingTimestamp(event.message);
+        if (raw === undefined) {
+            return;
+        }
+        const settingTimestamp = normalizeEphemeralSettingSeconds(raw);
+        void dedup
+            .run(`observe:${chatJid}:${expiration}:${settingTimestamp}`, async () => {
+            const cached = await chatMetadataStore.getChatMetadata(chatJid);
+            if (cached?.ephemeralSettingTimestamp === settingTimestamp &&
+                cached.ephemeralExpiration === expiration) {
+                return;
+            }
+            if (cached?.ephemeralSettingTimestamp !== undefined &&
+                cached.ephemeralSettingTimestamp > settingTimestamp) {
+                return;
+            }
+            await chatMetadataStore.upsertChatMetadata({
+                chatJid,
+                ephemeralExpiration: expiration,
+                ephemeralSettingTimestamp: settingTimestamp,
+                updatedAtMs: Date.now()
+            });
+        })
+            .catch((error) => {
+            logger.debug('failed to cache observed ephemeral setting', {
+                jid: chatJid,
+                message: toError(error).message
+            });
+        });
+    };
+}

package/dist/esm/client/persistence/group-history.js

@@ -0,0 +1,145 @@
+import { downloadHistoryBlob, flushPendingWrites } from '../persistence/history-blob.js';
+import { decodeGroupHistoryBundle } from '../../message/kinds/group-history.js';
+import { proto } from '../../proto.js';
+import { isGroupJid, toUserJid } from '../../protocol/jid.js';
+import { longToNumber, toError } from '../../util/primitives.js';
+const GROUP_HISTORY_MAX_PENDING_WRITES = 1024;
+export async function runGroupHistoryBundle(deps, input) {
+    try {
+        await processGroupHistoryBundle(deps, input);
+    }
+    catch (error) {
+        deps.logger.warn('failed to process group history bundle', {
+            groupJid: input.groupJid,
+            id: input.bundleMessageId,
+            message: toError(error).message
+        });
+    }
+}
+export async function processGroupHistoryBundle(deps, input) {
+    const logger = deps.logger.child({
+        groupJid: input.groupJid,
+        id: input.bundleMessageId
+    });
+    if (!isGroupJid(input.groupJid)) {
+        logger.debug('skipping group history bundle outside a group');
+        return;
+    }
+    if (!isHistoryReceiver(deps, input.bundle)) {
+        logger.debug('skipping group history bundle not addressed to this account');
+        return;
+    }
+    const nowMs = Date.now();
+    const bundleTtlSeconds = deps.getAbPropNumber('group_history_bundle_time_limit_receiver_enforcement_secs');
+    if (input.sentAtSeconds !== undefined &&
+        nowMs > (input.sentAtSeconds + bundleTtlSeconds) * 1000) {
+        logger.debug('skipping expired group history bundle', {
+            sentAtSeconds: input.sentAtSeconds,
+            bundleTtlSeconds
+        });
+        return;
+    }
+    const blob = await downloadHistoryBlob(deps.mediaTransfer, input.bundle, 'group-history', 'group history bundle');
+    const history = await decodeGroupHistoryBundle(blob);
+    const messageTtlSeconds = deps.getAbPropNumber('group_history_messages_time_limit_receiver_enforcement_secs');
+    const pendingWrites = [];
+    const dropped = { foreignChat: 0, ephemeralExpired: 0, tooOld: 0, stub: 0 };
+    let messagesCount = 0;
+    let oldestTimestampMs;
+    for (const source of [
+        { messages: history.messages, skipAgeCheck: false },
+        { messages: history.outOfWindowPinnedMessages, skipAgeCheck: true }
+    ]) {
+        for (const webMsg of source.messages) {
+            if (!webMsg.key?.id || !webMsg.message) {
+                dropped.stub += 1;
+                continue;
+            }
+            if (webMsg.key.remoteJid && webMsg.key.remoteJid !== input.groupJid) {
+                dropped.foreignChat += 1;
+                continue;
+            }
+            const timestampSeconds = longToNumber(webMsg.messageTimestamp);
+            if (isEphemeralExpired(webMsg, timestampSeconds, nowMs)) {
+                dropped.ephemeralExpired += 1;
+                continue;
+            }
+            if (!source.skipAgeCheck &&
+                timestampSeconds > 0 &&
+                (timestampSeconds + 2 * messageTtlSeconds) * 1000 < nowMs) {
+                dropped.tooOld += 1;
+                continue;
+            }
+            const timestampMs = timestampSeconds * 1000;
+            if (timestampMs > 0 &&
+                (oldestTimestampMs === undefined || timestampMs < oldestTimestampMs)) {
+                oldestTimestampMs = timestampMs;
+            }
+            pendingWrites[pendingWrites.length] = deps.writeBehind.persistMessageAsync({
+                id: webMsg.key.id,
+                threadJid: input.groupJid,
+                senderJid: webMsg.key.participant ?? undefined,
+                fromMe: webMsg.key.fromMe === true,
+                timestampMs: timestampMs || undefined,
+                messageBytes: proto.Message.encode(webMsg.message).finish()
+            });
+            if (pendingWrites.length >= GROUP_HISTORY_MAX_PENDING_WRITES) {
+                await flushPendingWrites(pendingWrites);
+            }
+            messagesCount += 1;
+        }
+    }
+    await flushPendingWrites(pendingWrites);
+    const droppedCount = dropped.foreignChat + dropped.ephemeralExpired + dropped.tooOld + dropped.stub;
+    logger.debug('processed group history bundle', {
+        messagesCount,
+        outOfWindowPinsCount: history.outOfWindowPinnedMessages.length,
+        droppedCount,
+        dropped
+    });
+    const event = {
+        groupJid: input.groupJid,
+        senderJid: input.senderJid,
+        bundleMessageId: input.bundleMessageId,
+        messagesCount,
+        outOfWindowPinsCount: history.outOfWindowPinnedMessages.length,
+        droppedCount,
+        oldestTimestampMs,
+        historyReceivers: [...(input.bundle.messageHistoryMetadata?.historyReceivers ?? [])]
+    };
+    deps.emitEvent('group_history_bundle', event);
+}
+/**
+ * A bundle is only ours to process when this account is listed in
+ * `historyReceivers`. The list may address us by either PN or LID, so both
+ * forms of the local identity are compared.
+ */
+function isHistoryReceiver(deps, bundle) {
+    const receivers = bundle.messageHistoryMetadata?.historyReceivers;
+    if (!receivers || receivers.length === 0) {
+        return false;
+    }
+    const meUserJid = deps.meJid ? toUserJid(deps.meJid) : null;
+    const meUserLid = deps.meLid ? toUserJid(deps.meLid) : null;
+    if (!meUserJid && !meUserLid) {
+        return false;
+    }
+    for (let index = 0; index < receivers.length; index += 1) {
+        const receiver = toUserJid(receivers[index]);
+        if (receiver === meUserJid || receiver === meUserLid) {
+            return true;
+        }
+    }
+    return false;
+}
+function isEphemeralExpired(webMsg, timestampSeconds, nowMs) {
+    const duration = webMsg.ephemeralDuration;
+    if (!duration) {
+        return false;
+    }
+    const startSeconds = longToNumber(webMsg.ephemeralStartTimestamp) || timestampSeconds;
+    if (startSeconds <= 0) {
+        return false;
+    }
+    return (startSeconds + duration) * 1000 <= nowMs;
+}

package/dist/esm/client/persistence/history-blob.js

@@ -0,0 +1,34 @@
+import { decodeProtoBytes } from '../../util/bytes.js';
+/**
+ * Fetches and decrypts a history blob. `label` prefixes the field errors so a
+ * failure names which payload was malformed.
+ *
+ * @throws when `directPath` is absent or a key/hash field is missing.
+ */
+export async function downloadHistoryBlob(mediaTransfer, source, mediaType, label) {
+    if (!source.directPath) {
+        throw new Error(`${label} missing directPath`);
+    }
+    const mediaKey = decodeProtoBytes(source.mediaKey, `${label} mediaKey`);
+    const fileSha256 = decodeProtoBytes(source.fileSha256, `${label} fileSha256`);
+    const fileEncSha256 = decodeProtoBytes(source.fileEncSha256, `${label} fileEncSha256`);
+    return mediaTransfer.downloadAndDecrypt({
+        directPath: source.directPath,
+        mediaType,
+        mediaKey,
+        fileSha256,
+        fileEncSha256
+    });
+}
+/**
+ * Awaits an accumulating write batch and empties it in place, so the caller can
+ * keep filling the same array instead of allocating a new one per chunk.
+ */
+export async function flushPendingWrites(pendingWrites) {
+    if (pendingWrites.length === 0) {
+        return;
+    }
+    const settled = Promise.all(pendingWrites);
+    pendingWrites.length = 0;
+    await settled;
+}

package/dist/esm/client/persistence/history-sync.js

@@ -1,7 +1,9 @@
 import { promisify } from 'node:util';
 import { unzip } from 'node:zlib';
+import { downloadHistoryBlob, flushPendingWrites } from '../persistence/history-blob.js';
 import { proto } from '../../proto.js';
 import { isUserJid } from '../../protocol/jid.js';
+import { normalizeEphemeralSettingSeconds } from '../../protocol/message.js';
 import { decodeProtoBytes, toBytesView } from '../../util/bytes.js';
 import { longToNumber, toError } from '../../util/primitives.js';
 const unzipAsync = promisify(unzip);
@@ -123,6 +125,25 @@ export async function processHistorySyncNotification(deps, notification) {
             deps.logger.debug('skipping history sync conversation without thread jid');
             continue;
         }
+        const ephemeralExpiration = conversation.ephemeralExpiration ?? undefined;
+        const ephemeralSettingTimestamp = normalizeEphemeralSettingSeconds(longToNumber(conversation.ephemeralSettingTimestamp)) || undefined;
+        if (deps.chatMetadataStore && ephemeralExpiration !== undefined) {
+            pendingWrites[pendingWrites.length] = deps.chatMetadataStore
+                .upsertChatMetadata({
+                chatJid: threadJid,
+                ephemeralExpiration,
+                ...(ephemeralSettingTimestamp !== undefined
+                    ? { ephemeralSettingTimestamp }
+                    : {}),
+                updatedAtMs: nowMs
+            })
+                .catch((error) => {
+                deps.logger.debug('failed to cache history sync chat metadata', {
+                    jid: threadJid,
+                    message: toError(error).message
+                });
+            });
+        }
         pendingWrites[pendingWrites.length] = deps.writeBehind.persistThreadAsync({
             jid: threadJid,
             name: conversation.name ?? undefined,
@@ -131,7 +152,8 @@ export async function processHistorySyncNotification(deps, notification) {
             pinned: conversation.pinned ?? undefined,
             muteEndMs: longToNumber(conversation.muteEndTime) || undefined,
             markedAsUnread: conversation.markedAsUnread ?? undefined,
-            ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
+            ephemeralExpiration,
+            ephemeralSettingTimestamp
         });
         if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
             await flushPendingWrites(pendingWrites);
@@ -228,29 +250,9 @@ export async function processHistorySyncNotification(deps, notification) {
         await deps.onProcessed(syncType);
     }
 }
-async function flushPendingWrites(pendingWrites) {
-    if (pendingWrites.length === 0) {
-        return;
-    }
-    const settled = Promise.all(pendingWrites);
-    pendingWrites.length = 0;
-    await settled;
-}
 async function downloadHistorySyncBlob(deps, notification) {
     if (notification.initialHistBootstrapInlinePayload) {
         return decodeProtoBytes(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');
     }
-    if (!notification.directPath) {
-        throw new Error('history sync notification missing directPath');
-    }
-    const mediaKey = decodeProtoBytes(notification.mediaKey, 'history sync mediaKey');
-    const fileSha256 = decodeProtoBytes(notification.fileSha256, 'history sync fileSha256');
-    const fileEncSha256 = decodeProtoBytes(notification.fileEncSha256, 'history sync fileEncSha256');
-    return deps.mediaTransfer.downloadAndDecrypt({
-        directPath: notification.directPath,
-        mediaType: 'history',
-        mediaKey,
-        fileSha256,
-        fileEncSha256
-    });
+    return downloadHistoryBlob(deps.mediaTransfer, notification, 'history', 'history sync');
 }

package/dist/esm/crypto/core/xeddsa.js

@@ -5,17 +5,30 @@ import { clampCurvePrivateKeyInPlace, montgomeryToEdwardsPublic } from '../curve
 import { encodeExtendedPoint, scalarMultBase } from '../math/edwards.js';
 import { bigIntToBytesLE, bytesToBigIntLE } from '../math/le.js';
 import { modGroup } from '../math/mod.js';
-import { assertByteLength, concatBytes } from '../../util/bytes.js';
+import { resolveNativeCryptoBackend } from '../nativeBackend.js';
+import { assertByteLength, concatBytes, toBytesView } from '../../util/bytes.js';
 const PREFIX_SIGNATURE_RANDOM = new Uint8Array([
     0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 ]);
+const nativeBinding = (() => {
+    if (process.env.ZAPO_XEDDSA_FORCE_JS)
+        return null;
+    const mod = resolveNativeCryptoBackend();
+    if (mod && typeof mod.xeddsaSign === 'function' && typeof mod.xeddsaVerify === 'function') {
+        return { xeddsaSign: mod.xeddsaSign, xeddsaVerify: mod.xeddsaVerify };
+    }
+    return null;
+})();
 /**
  * Verifies an XEdDSA signature over `message` against an X25519 (Montgomery)
  * public key, converting to the Edwards form internally. Returns `false`
  * on shape mismatch instead of throwing.
  */
 export async function xeddsaVerify(curvePublicKey, message, signature) {
+    if (nativeBinding) {
+        return nativeBinding.xeddsaVerify(curvePublicKey, message, signature);
+    }
     if (signature.length !== 64) {
         return false;
     }
@@ -40,6 +53,9 @@ export async function xeddsaVerify(curvePublicKey, message, signature) {
  */
 export async function xeddsaSign(privateKey, message) {
     assertByteLength(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
+    if (nativeBinding) {
+        return toBytesView(nativeBinding.xeddsaSign(privateKey, message));
+    }
     const clampedPrivateKey = clampCurvePrivateKeyInPlace(privateKey);
     const privateScalar = bytesToBigIntLE(clampedPrivateKey);
     const encodedPublic = encodeExtendedPoint(scalarMultBase(privateScalar));

package/dist/esm/crypto/curves/X25519.js

@@ -5,7 +5,17 @@ import { X25519_PKCS8_PREFIX, X25519_SPKI_PREFIX } from '../curves/constants.js'
 import { pkcs8FromRawPrivate } from '../curves/types.js';
 import { FE_ONE } from '../math/constants.js';
 import { fe, feAdd, feFromBytes, feInv, feMul, fePack, feSub } from '../math/fe.js';
+import { resolveNativeCryptoBackend } from '../nativeBackend.js';
 import { assertByteLength, concatBytes, decodeBase64Url, toBytesView } from '../../util/bytes.js';
+const nativeX25519ScalarMult = (() => {
+    if (process.env.ZAPO_X25519_FORCE_JS)
+        return null;
+    const mod = resolveNativeCryptoBackend();
+    if (mod && typeof mod.x25519ScalarMult === 'function') {
+        return mod.x25519ScalarMult;
+    }
+    return null;
+})();
 const diffieHellmanWithCallback = diffieHellman;
 let diffieHellmanAsync = null;
 let diffieHellmanAsyncProbed = false;
@@ -115,6 +125,9 @@ export class X25519 {
     static async scalarMult(privKey, pubKey) {
         assertByteLength(privKey, 32, 'x25519 private key must be 32 bytes');
         assertByteLength(pubKey, 32, 'x25519 public key must be 32 bytes');
+        if (nativeX25519ScalarMult) {
+            return toBytesView(nativeX25519ScalarMult(privKey, pubKey));
+        }
         const opts = {
             privateKey: x25519PrivateKeyObject(privKey),
             publicKey: x25519PublicKeyObject(pubKey)

package/dist/esm/crypto/nativeBackend.js

@@ -0,0 +1,93 @@
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+/**
+ * Resolves the optional native crypto accelerator backend shared by the
+ * X25519 and XEdDSA paths. Selected via `ZAPO_NATIVE_BACKEND`:
+ *
+ *   - `auto` (default) – try the NAPI addon first, then the WASM build,
+ *                        then no accelerator.
+ *   - `napi`           – only the compiled Rust NAPI addon (`@zapo-js/native`).
+ *   - `wasm`           – only the wasm-bindgen build of the same Rust core.
+ *                        The shipped artifact targets the web (ESM glue +
+ *                        explicit init) so one build serves browsers and
+ *                        Node; loading it here relies on `require(esm)`,
+ *                        available unflagged on Node 20.19+ / 22.12+.
+ *   - `js` / `none`    – no accelerator; callers fall back to the pure-JS
+ *                        (and `node:crypto`) implementations.
+ *
+ * The module is resolved once and memoised. A failed backend resolves to
+ * `null` (or, under `auto`, falls through to the next one) so callers
+ * transparently fall back to JS. An absent backend stays silent - that is
+ * the expected shape of an optional accelerator - but a present-yet-broken
+ * one (corrupt binary, ABI mismatch, unsupported runtime) emits a process
+ * warning with code `ZAPO_NATIVE_LOAD_FAILED` so the degradation is
+ * visible. The per-primitive `ZAPO_X25519_FORCE_JS` / `ZAPO_XEDDSA_FORCE_JS`
+ * escape hatches are honoured by the callers, not here.
+ */
+import { readFileSync } from 'node:fs';
+import { toError } from '../util/primitives.js';
+const WASM_MODULE_SPECIFIER = '@zapo-js/native/wasm/pkg/zapo_native_wasm.js';
+const WASM_BINARY_SPECIFIER = '@zapo-js/native/wasm/pkg/zapo_native_wasm_bg.wasm';
+function loadWasmBackend() {
+    const mod = require(WASM_MODULE_SPECIFIER);
+    const wasmBytes = readFileSync(require.resolve(WASM_BINARY_SPECIFIER));
+    mod.initSync({ module: wasmBytes });
+    return mod;
+}
+let cached;
+const ABSENCE_TOKENS = {
+    napi: ["'@zapo-js/native'", 'binding.js', 'Cannot find native binding'],
+    wasm: ["'@zapo-js/native'", 'zapo_native_wasm.js']
+};
+/**
+ * Classifies a backend load failure: `true` means the backend is simply not
+ * available on this install (missing optional package, entry file absent,
+ * no prebuilt binary, ESM build without `require`) and the fallback should
+ * stay silent; `false` means the backend is present but broken and the
+ * degradation deserves a process warning.
+ */
+export function isBackendAbsence(backend, error) {
+    if (error instanceof ReferenceError) {
+        return error.message.includes('require is not defined');
+    }
+    const { code, message } = (error ?? {});
+    if (typeof message !== 'string')
+        return false;
+    const notFound = code === 'MODULE_NOT_FOUND' || code === 'ERR_MODULE_NOT_FOUND';
+    if (!notFound && !message.includes('Cannot find native binding'))
+        return false;
+    return ABSENCE_TOKENS[backend].some((token) => message.includes(token));
+}
+function warnLoadFailure(backend, error) {
+    process.emitWarning('failed to load native crypto accelerator, falling back', {
+        code: 'ZAPO_NATIVE_LOAD_FAILED',
+        detail: `${backend}: ${toError(error).message}`
+    });
+}
+export function resolveNativeCryptoBackend() {
+    if (cached !== undefined)
+        return cached;
+    const backend = (process.env.ZAPO_NATIVE_BACKEND ?? 'auto').toLowerCase();
+    cached = null;
+    if (backend === 'js' || backend === 'none')
+        return cached;
+    if (backend === 'napi' || backend === 'auto') {
+        try {
+            cached = require('@zapo-js/native');
+        }
+        catch (error) {
+            if (!isBackendAbsence('napi', error))
+                warnLoadFailure('napi', error);
+        }
+    }
+    if (cached === null && (backend === 'wasm' || backend === 'auto')) {
+        try {
+            cached = loadWasmBackend();
+        }
+        catch (error) {
+            if (!isBackendAbsence('wasm', error))
+                warnLoadFailure('wasm', error);
+        }
+    }
+    return cached;
+}

package/dist/esm/index.js

@@ -7,6 +7,7 @@ export { createFileCompanionHostPersistence } from './client/persistence/compani
 export { parseUsyncResultEnvelope } from './transport/node/builders/usync.js';
 export { getContentType, resolveEncMediaType, resolveMessageTarget, unwrapMessage } from './message/encode/content.js';
 export { getContextInfo } from './message/context-info.js';
+export { decodeGroupHistoryBundle, encodeGroupHistoryBundle } from './message/kinds/group-history.js';
 export { resolveMediaPayload } from './message/encode/media-payload.js';
 export { unpadPkcs7, writeRandomPadMax16 } from './message/encode/padding.js';
 export { fetchLatestWaWebVersion, fetchLatestWaMobileVersion } from './transport/wa-version-fetcher.js';
@@ -14,7 +15,8 @@ export { ConsoleLogger } from './infra/log/ConsoleLogger.js';
 export { PinoLogger, createPinoLogger } from './infra/log/PinoLogger.js';
 export { createNoopLogger } from './infra/log/types.js';
 export { WA_VERSION } from './version-spec.js';
+export { resolveAbPropNameByCode, WA_ABPROPS, WA_ABPROPS_BY_CODE, WA_ABPROPS_SPECIAL_EARLY, WA_ABPROPS_USED_BEFORE_INIT, WA_GROUP_ABPROPS, WA_GROUP_ABPROPS_BY_CODE } from './abprops-spec.js';
 export { createStore, WaAuthMemoryStore } from './store/index.js';
 export { delay } from './util/async.js';
-export { buildDeviceJid, canonicalizeSignalJid, canonicalizeSignalServer, getLoginIdentity, getWaCompanionPlatformId, getWaMediaHkdfInfo, isBotJid, isBroadcastJid, isGroupJid, isGroupOrBroadcastJid, isHostedDeviceId, isHostedDeviceJid, isHostedServer, isLidJid, isNewsletterJid, isStatusBroadcastJid, isUserJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parsePhoneJid, parseSignalAddressFromJid, signalAddressKey, splitJid, toUserJid, WA_ACCOUNT_SYNC_PROTOCOLS, WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE, WA_BROWSERS, WA_BUSINESS_HOURS_DAYS, WA_BUSINESS_HOURS_MODES, WA_COMPANION_PLATFORM_IDS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_DISCONNECT_REASONS, WA_IQ_TYPES, WA_LOGOUT_REASONS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_MEDIA_HKDF_INFO, WA_NODE_TAGS, WA_PAIRING_KDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO, WA_READY_STATES, WA_RETRYABLE_ACK_CODES, WA_SIGNALING, WA_STREAM_SIGNALING, WA_SUPPORTED_DIRTY_TYPES, WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES, WA_XMLNS } from './protocol/index.js';
+export { buildDeviceJid, canonicalizeSignalJid, canonicalizeSignalServer, getLoginIdentity, getWaCompanionPlatformId, getWaMediaHkdfInfo, isBotJid, isBroadcastJid, isGroupJid, isGroupOrBroadcastJid, isHostedDeviceId, isHostedDeviceJid, isHostedServer, isLidJid, isNewsletterJid, isStatusBroadcastJid, isUserJid, normalizeDeviceJid, normalizeRecipientJid, parseJidFull, parsePhoneJid, parseSignalAddressFromJid, signalAddressKey, splitJid, toUserJid, WA_ACCOUNT_SYNC_PROTOCOLS, WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE, WA_BROWSERS, WA_BUSINESS_HOURS_DAYS, WA_BUSINESS_HOURS_MODES, WA_COMPANION_PLATFORM_IDS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_DISCONNECT_REASONS, WA_IQ_TYPES, WA_LOGOUT_REASONS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_MEDIA_HKDF_INFO, WA_NODE_TAGS, WA_PAIRING_KDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO, WA_READY_STATES, WA_RETRYABLE_ACK_CODES, WA_SIGNALING, WA_STREAM_SIGNALING, WA_SUPPORTED_DIRTY_TYPES, WA_PRIVACY_ACCOUNT_SYNC_DISALLOWED_LISTS, WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_SETTING_VALUES, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES, WA_XMLNS } from './protocol/index.js';
 export { proto } from './proto.js';

package/dist/esm/message/context-info.js

@@ -1,4 +1,5 @@
 import { isGroupOrBroadcastJid, toUserJid } from '../protocol/jid.js';
+import { longToNumber } from '../util/primitives.js';
 export function buildContextInfoProto(input) {
     const ctx = {};
     if (input.quotedMessageId !== undefined)
@@ -20,6 +21,20 @@ export function buildContextInfoProto(input) {
         ctx.isSpoiler = input.isSpoiler;
     if (input.expirationSeconds !== undefined)
         ctx.expiration = input.expirationSeconds;
+    if (input.ephemeralSettingTimestamp !== undefined) {
+        ctx.ephemeralSettingTimestamp = input.ephemeralSettingTimestamp;
+    }
+    if (input.disappearingModeInitiator !== undefined ||
+        input.disappearingModeTrigger !== undefined) {
+        ctx.disappearingMode = {
+            ...(input.disappearingModeInitiator !== undefined
+                ? { initiator: input.disappearingModeInitiator }
+                : {}),
+            ...(input.disappearingModeTrigger !== undefined
+                ? { trigger: input.disappearingModeTrigger }
+                : {})
+        };
+    }
     if (input.groupSubject !== undefined)
         ctx.groupSubject = input.groupSubject;
     if (input.parentGroupJid !== undefined)
@@ -73,6 +88,30 @@ export function pickIncomingExpirationSeconds(message) {
     }
     return undefined;
 }
+/**
+ * Reads `contextInfo.ephemeralSettingTimestamp` (Unix seconds) from the first
+ * submessage that carries it. Peers stamp it on every message in a disappearing
+ * chat, which makes it the only continuously-refreshed source for the setting -
+ * history sync and `EPHEMERAL_SETTING` are point-in-time.
+ */
+export function pickIncomingEphemeralSettingTimestamp(message) {
+    if (!message)
+        return undefined;
+    const inner = message.ephemeralMessage?.message ?? message;
+    for (const key of Object.keys(inner)) {
+        const value = inner[key];
+        if (value &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            !(value instanceof Uint8Array)) {
+            const stamp = value.contextInfo?.ephemeralSettingTimestamp;
+            if (stamp !== undefined && stamp !== null) {
+                return longToNumber(stamp);
+            }
+        }
+    }
+    return undefined;
+}
 function pickContextInfoTarget(message) {
     for (const key of Object.keys(message)) {
         const value = message[key];

package/dist/esm/message/encode/content.js

@@ -1,15 +1,31 @@
 import { proto } from '../../proto.js';
 import { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_POLL_META_TYPES, WA_STANZA_MSG_TYPES } from '../../protocol/constants.js';
+/**
+ * Content keys that carry a payload but do not end in `Message`, so the
+ * substring match below would miss them.
+ */
+const UNSUFFIXED_CONTENT_KEYS = new Set([
+    'conversation',
+    'messageHistoryBundle',
+    'messageHistoryNotice'
+]);
 /**
  * Returns the content-type key of a message - `'conversation'`,
- * `'imageMessage'`, `'extendedTextMessage'`, etc. - or `undefined` for an empty
- * message. `senderKeyDistributionMessage` is skipped so group messages report
- * their real payload type rather than the piggy-backed sender-key.
+ * `'imageMessage'`, `'extendedTextMessage'`, `'messageHistoryBundle'`, etc. -
+ * or `undefined` for an empty message. `senderKeyDistributionMessage` is
+ * skipped so group messages report their real payload type rather than the
+ * piggy-backed sender-key.
+ *
+ * A key that is present but holds `null`/`undefined` carries no payload and is
+ * skipped, so an explicitly-cleared field cannot mask the real content.
  */
 export function getContentType(content) {
     if (!content)
         return undefined;
-    const key = Object.keys(content).find((k) => (k === 'conversation' || k.includes('Message')) && k !== 'senderKeyDistributionMessage');
+    const key = Object.keys(content).find((k) => content[k] !== null &&
+        content[k] !== undefined &&
+        (UNSUFFIXED_CONTENT_KEYS.has(k) || k.includes('Message')) &&
+        k !== 'senderKeyDistributionMessage');
     return key;
 }
 /**

package/dist/esm/message/encode/media-payload.js

@@ -28,7 +28,7 @@ function buildPayload(mediaType, fields) {
  * lacks the `directPath` / `mediaKey` needed to fetch and decrypt the blob (a
  * non-`Uint8Array` `mediaKey` also yields `null`). Supported kinds: image,
  * video (gif when `gifPlayback`), audio (ptt when `ptt`), document, sticker,
- * ptv.
+ * ptv, and the group-history bundle shared with a member after they join.
  *
  * @example
  * ```ts
@@ -56,5 +56,7 @@ export function resolveMediaPayload(message) {
         return buildPayload('sticker', msg.stickerMessage);
     if (msg.ptvMessage)
         return buildPayload('ptv', msg.ptvMessage);
+    if (msg.messageHistoryBundle)
+        return buildPayload('group-history', msg.messageHistoryBundle);
     return null;
 }