@openclaw/crabline 0.1.10 → 0.1.12

package/dist/src/servers/whatsapp-baileys-websocket.js

@@ -1,12 +1,12 @@
 import { Buffer } from "node:buffer";
 import { ProtocolAddress, SessionCipher, SessionRecord } from "libsignal";
-import { aesDecryptGCM, aesEncryptGCM, Curve, encodeBigEndian, hkdf, NOISE_MODE, NOISE_WA_HEADER, sha256, signedKeyPair, } from "./whatsapp-wire/crypto.js";
+import { aesDecryptGCM, aesEncryptGCM, Curve, encodeBigEndian, ensureSignalPublicKey, generateSignalKeyPair, hkdf, NOISE_MODE, NOISE_WA_HEADER, sha256, signedKeyPair, scrubSignalPublicKey, } from "./whatsapp-wire/crypto.js";
 import { decodeBinaryNode, encodeBinaryNode, S_WHATSAPP_NET, } from "./whatsapp-wire/binary-node.js";
 import { decodeHandshakeMessage, encodeHandshakeMessage } from "./whatsapp-wire/handshake.js";
 import { KEY_BUNDLE_TYPE, xmppPreKey, xmppSignedPreKey } from "./whatsapp-wire/signal.js";
 import { WebSocket, WebSocketServer } from "ws";
 import { closeWebSocketServer } from "./websocket.js";
-import { canonicalizeWhatsAppUserCorrelationJid } from "./whatsapp-jid.js";
+import { canonicalizeWhatsAppChatCorrelationJid, canonicalizeWhatsAppUserCorrelationJid, } from "./whatsapp-jid.js";
 // Keep the local server independent from Baileys at runtime. Tests use Baileys
 // as a black-box client to verify this narrow WhatsApp Web wire subset.
 const EMPTY_BUFFER = Buffer.alloc(0);
@@ -20,9 +20,17 @@ export const MAX_WHATSAPP_NOISE_FRAMES_PER_MESSAGE = 1_024;
 export const WHATSAPP_WEBSOCKET_SEND_TIMEOUT_MS = 5_000;
 const MAX_PENDING_WEBSOCKET_BYTES = 8 * 1024 * 1024;
 const MAX_PENDING_WEBSOCKET_MESSAGES = 32;
+const MAX_WHATSAPP_PENDING_ACKNOWLEDGEMENTS = 10_000;
+const MAX_WHATSAPP_PENDING_ACKNOWLEDGEMENT_AGE_MS = 5 * 60 * 1_000;
+const MAX_WHATSAPP_RECENT_ACKNOWLEDGEMENTS = 10_000;
+const MAX_NODE_TIMER_DELAY_MS = 2_147_483_647;
 export const MAX_WHATSAPP_WEBSOCKET_FRAGMENTS = 1_024;
 export const MAX_WHATSAPP_SIGNAL_BUNDLES = 1_024;
+export const MAX_WHATSAPP_SIGNAL_PREKEYS_PER_BUNDLE = 32;
+export const MAX_WHATSAPP_SIGNAL_SESSIONS_PER_BUNDLE = 32;
 export const MAX_WHATSAPP_WEBSOCKET_CLOSE_REASON_BYTES = 123;
+export const WHATSAPP_MESSAGE_ACCEPTANCE_TIMEOUT_MS = 5_000;
+export const WHATSAPP_SIGNAL_PREKEY_RESERVATION_TTL_MS = 5 * 60 * 1_000;
 const WHATSAPP_NOISE_CERT_CHAIN = Buffer.from("CncKMwjjAhADGiCRKg7Kg1iu4CSulwLBaxX51Tefw6VXGgZqcr5OEbXIRiDQ04bOBijQjZ/TBhJA34Bj82jAHhLpCWBNVBlGnFDieamd8+138S57uMt9ke9mrn5r4+VepwBPKEgHjob6bR70rlCmWDkxZv+CfVjIAxJ2CjIIAxAAGiAcUamsMDmUxsjQuS6hh4pTNHZZnMWZ++o1mX2aqQzOYiCAka6+Bij/3rfcBhJAJw8pRkhTn+1IcOJQVN1OlZg6uikYnCumyO7acFVVX3U3QPXsGSq2TCbCbWrebSC593Su43EgprIDlfU8ZgWFBw==", "base64");
 export function resolveMaxPendingWhatsAppInboundMessages(value) {
     const resolved = value ?? MAX_PENDING_INBOUND_MESSAGES;
@@ -31,27 +39,271 @@ export function resolveMaxPendingWhatsAppInboundMessages(value) {
     }
     return resolved;
 }
+async function awaitWithAbort(operation, signal) {
+    if (!signal) {
+        return await operation;
+    }
+    signal.throwIfAborted();
+    return await new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        void operation.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}
 export class WhatsAppSignalBundleStore {
     maxBundles;
+    maxPendingAcknowledgements;
+    maxRecentAcknowledgements;
+    maxPendingAcknowledgementAgeMs;
+    now;
+    #acknowledgedMessageIds = new Map();
     #bundles = new Map();
     #lidByPhoneNumber = new Map();
+    #maxPreKeysPerBundle;
+    #maxSessionsPerBundle;
+    #maxTerminalAcceptances;
+    #messagePreKeyProtections = new Map();
+    #messageAcceptanceTimeoutMs;
+    #pendingAcknowledgements = new Map();
+    #pendingTransactions = new Map();
+    #persistedMessageIds = new Map();
+    #preKeyReservationTtlMs;
     #sessions = new Map();
-    constructor(maxBundles = MAX_WHATSAPP_SIGNAL_BUNDLES) {
+    #terminalAcceptances = new Map();
+    constructor(maxBundles = MAX_WHATSAPP_SIGNAL_BUNDLES, maxPendingAcknowledgements = MAX_WHATSAPP_PENDING_ACKNOWLEDGEMENTS, maxRecentAcknowledgements = MAX_WHATSAPP_RECENT_ACKNOWLEDGEMENTS, maxPendingAcknowledgementAgeMs = MAX_WHATSAPP_PENDING_ACKNOWLEDGEMENT_AGE_MS, now = Date.now, options = {}) {
         this.maxBundles = maxBundles;
+        this.maxPendingAcknowledgements = maxPendingAcknowledgements;
+        this.maxRecentAcknowledgements = maxRecentAcknowledgements;
+        this.maxPendingAcknowledgementAgeMs = maxPendingAcknowledgementAgeMs;
+        this.now = now;
+        const maxPreKeysPerBundle = options.maxPreKeysPerBundle ?? MAX_WHATSAPP_SIGNAL_PREKEYS_PER_BUNDLE;
+        const maxSessionsPerBundle = options.maxSessionsPerBundle ?? MAX_WHATSAPP_SIGNAL_SESSIONS_PER_BUNDLE;
+        const messageAcceptanceTimeoutMs = options.messageAcceptanceTimeoutMs ?? WHATSAPP_MESSAGE_ACCEPTANCE_TIMEOUT_MS;
+        const preKeyReservationTtlMs = options.preKeyReservationTtlMs ?? WHATSAPP_SIGNAL_PREKEY_RESERVATION_TTL_MS;
         if (!Number.isSafeInteger(maxBundles) || maxBundles < 1) {
             throw new Error("WhatsApp maxSignalBundles must be a positive safe integer.");
         }
+        if (!Number.isSafeInteger(maxSessionsPerBundle) || maxSessionsPerBundle < 1) {
+            throw new Error("WhatsApp maxSignalSessionsPerBundle must be a positive safe integer.");
+        }
+        if (!Number.isSafeInteger(maxPreKeysPerBundle) || maxPreKeysPerBundle < 1) {
+            throw new Error("WhatsApp maxSignalPreKeysPerBundle must be a positive safe integer.");
+        }
+        if (!Number.isSafeInteger(messageAcceptanceTimeoutMs) ||
+            messageAcceptanceTimeoutMs < 1 ||
+            messageAcceptanceTimeoutMs > MAX_NODE_TIMER_DELAY_MS) {
+            throw new Error(`WhatsApp messageAcceptanceTimeoutMs must be a positive integer no greater than ${MAX_NODE_TIMER_DELAY_MS}.`);
+        }
+        if (!Number.isSafeInteger(preKeyReservationTtlMs) || preKeyReservationTtlMs < 1) {
+            throw new Error("WhatsApp preKeyReservationTtlMs must be a positive safe integer.");
+        }
+        if (!Number.isSafeInteger(maxPendingAcknowledgements) || maxPendingAcknowledgements < 1) {
+            throw new Error("WhatsApp maxPendingAcknowledgements must be a positive safe integer.");
+        }
+        if (!Number.isSafeInteger(maxRecentAcknowledgements) || maxRecentAcknowledgements < 1) {
+            throw new Error("WhatsApp maxRecentAcknowledgements must be a positive safe integer.");
+        }
+        if (!Number.isSafeInteger(maxPendingAcknowledgementAgeMs) ||
+            maxPendingAcknowledgementAgeMs < 1) {
+            throw new Error("WhatsApp maxPendingAcknowledgementAgeMs must be a positive safe integer.");
+        }
+        this.#maxPreKeysPerBundle = maxPreKeysPerBundle;
+        this.#maxSessionsPerBundle = maxSessionsPerBundle;
+        this.#maxTerminalAcceptances = Math.min(Number.MAX_SAFE_INTEGER, maxPendingAcknowledgements + maxRecentAcknowledgements);
+        this.#messageAcceptanceTimeoutMs = messageAcceptanceTimeoutMs;
+        this.#preKeyReservationTtlMs = preKeyReservationTtlMs;
     }
     get size() {
         return this.#bundles.size;
     }
+    get lidMappingSize() {
+        return this.#lidByPhoneNumber.size;
+    }
+    get sessionCount() {
+        let count = 0;
+        for (const sessions of this.#sessions.values()) {
+            count += sessions.size;
+        }
+        return count;
+    }
+    async acceptMessageOnce(messageKey, operation, options = {}) {
+        this.#recoverExpiredPendingAcknowledgements();
+        const pendingAcceptance = this.#pendingAcknowledgements.get(messageKey);
+        if (pendingAcceptance) {
+            return await pendingAcceptance.acceptance;
+        }
+        const terminalAcceptance = this.#terminalAcceptances.get(messageKey);
+        if (terminalAcceptance) {
+            this.#terminalAcceptances.delete(messageKey);
+            this.#terminalAcceptances.set(messageKey, terminalAcceptance);
+            throw terminalAcceptance.error;
+        }
+        if (this.#acknowledgedMessageIds.delete(messageKey)) {
+            this.#acknowledgedMessageIds.set(messageKey, true);
+            return true;
+        }
+        if (this.#terminalAcceptances.size + this.#pendingAcknowledgements.size >=
+            this.#maxTerminalAcceptances) {
+            throw new Error(`WhatsApp terminal acceptance limit exceeded (${this.#maxTerminalAcceptances}).`);
+        }
+        if (this.#pendingAcknowledgements.size >= this.maxPendingAcknowledgements) {
+            throw new Error(`WhatsApp pending acknowledgement limit exceeded (${this.maxPendingAcknowledgements}).`);
+        }
+        const timeoutMs = options.timeoutMs ?? this.#messageAcceptanceTimeoutMs;
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_NODE_TIMER_DELAY_MS) {
+            throw new Error(`WhatsApp message acceptance timeout must be a positive integer no greater than ${MAX_NODE_TIMER_DELAY_MS}.`);
+        }
+        options.signal?.throwIfAborted();
+        const controller = new AbortController();
+        const operationPromise = Promise.resolve().then(() => operation(controller.signal));
+        let terminalFenced = false;
+        const fenceTerminalAcceptance = (error) => {
+            if (terminalFenced) {
+                return;
+            }
+            terminalFenced = true;
+            controller.abort(error);
+            const terminalDrain = Promise.all([
+                operationPromise.then(() => undefined, () => undefined),
+                Promise.resolve()
+                    .then(() => options.terminalDrain?.())
+                    .then((disposition) => disposition ?? "retryable", () => "retryable"),
+            ]).then(([, disposition]) => disposition);
+            this.#rememberTerminalAcceptance(messageKey, error, terminalDrain);
+        };
+        const abortFromOwner = () => {
+            const reason = options.signal?.reason;
+            fenceTerminalAcceptance(reason instanceof Error ? reason : new Error("WhatsApp message acceptance cancelled."));
+        };
+        if (options.signal?.aborted) {
+            abortFromOwner();
+        }
+        else {
+            options.signal?.addEventListener("abort", abortFromOwner, { once: true });
+        }
+        const timeout = setTimeout(() => {
+            const error = new Error("WhatsApp message acceptance timed out.");
+            fenceTerminalAcceptance(error);
+            try {
+                options.onTerminalTimeout?.();
+            }
+            catch { }
+        }, timeoutMs);
+        timeout.unref();
+        let pendingAcknowledgement;
+        const acceptance = Promise.resolve().then(async () => {
+            try {
+                const accepted = await awaitWithAbort(operationPromise, controller.signal);
+                if (!accepted) {
+                    if (this.#pendingAcknowledgements.get(messageKey) === pendingAcknowledgement) {
+                        this.#pendingAcknowledgements.delete(messageKey);
+                    }
+                    return false;
+                }
+                if (pendingAcknowledgement.acknowledged) {
+                    if (this.#pendingAcknowledgements.get(messageKey) === pendingAcknowledgement) {
+                        this.#pendingAcknowledgements.delete(messageKey);
+                    }
+                    this.#rememberAcknowledgedMessage(messageKey);
+                }
+                else {
+                    pendingAcknowledgement.acceptedAt = this.now();
+                }
+                return true;
+            }
+            catch (error) {
+                if (this.#pendingAcknowledgements.get(messageKey) === pendingAcknowledgement) {
+                    this.#pendingAcknowledgements.delete(messageKey);
+                }
+                throw error;
+            }
+            finally {
+                clearTimeout(timeout);
+                options.signal?.removeEventListener("abort", abortFromOwner);
+            }
+        });
+        pendingAcknowledgement = {
+            acceptance,
+            acceptedAt: undefined,
+            acknowledged: false,
+        };
+        this.#pendingAcknowledgements.set(messageKey, pendingAcknowledgement);
+        return await acceptance;
+    }
+    markMessageAcknowledged(peerJid, messageId) {
+        const peer = canonicalizeWhatsAppChatCorrelationJid(peerJid);
+        if (peer && messageId) {
+            const messageKey = `${peer}\0${messageId}`;
+            this.#recoverExpiredPendingAcknowledgements();
+            const pendingAcknowledgement = this.#pendingAcknowledgements.get(messageKey);
+            if (!pendingAcknowledgement) {
+                return;
+            }
+            if (pendingAcknowledgement.acceptedAt === undefined) {
+                pendingAcknowledgement.acknowledged = true;
+                return;
+            }
+            this.#pendingAcknowledgements.delete(messageKey);
+            this.#rememberAcknowledgedMessage(messageKey);
+        }
+    }
+    hasPersistedMessage(messageKey) {
+        return this.#persistedMessageIds.has(messageKey);
+    }
+    clearPersistedMessage(messageKey) {
+        this.#persistedMessageIds.delete(messageKey);
+        this.releaseMessagePreKeyProtection(messageKey);
+    }
+    releaseMessagePreKeyProtection(messageKey) {
+        const protections = this.#messagePreKeyProtections.get(messageKey);
+        if (!protections) {
+            return;
+        }
+        this.#messagePreKeyProtections.delete(messageKey);
+        for (const [identityKey, preKeyIds] of protections) {
+            const bundle = this.#bundles.get(identityKey);
+            if (!bundle) {
+                continue;
+            }
+            for (const preKeyId of preKeyIds) {
+                const references = bundle.protectedPreKeyIds.get(preKeyId) ?? 0;
+                if (references <= 1) {
+                    bundle.protectedPreKeyIds.delete(preKeyId);
+                }
+                else {
+                    bundle.protectedPreKeyIds.set(preKeyId, references - 1);
+                }
+            }
+        }
+    }
     associateLid(phoneNumberJid, lidJid) {
         const phoneNumber = canonicalizeWhatsAppUserCorrelationJid(phoneNumberJid);
         const lid = canonicalizeWhatsAppUserCorrelationJid(lidJid);
         if (!phoneNumber?.endsWith("@s.whatsapp.net") || !lid?.endsWith("@lid")) {
             throw new Error("Invalid WhatsApp PN/LID signal mapping.");
         }
-        this.#lidByPhoneNumber.set(signalBundleIdentityKey(phoneNumber), signalBundleIdentityKey(lid));
+        const phoneNumberKey = signalBundleIdentityKey(phoneNumber);
+        this.#lidByPhoneNumber.delete(phoneNumberKey);
+        this.#lidByPhoneNumber.set(phoneNumberKey, signalBundleIdentityKey(lid));
+        if (this.#lidByPhoneNumber.size > this.maxBundles) {
+            const oldestPhoneNumber = this.#lidByPhoneNumber.keys().next().value;
+            if (oldestPhoneNumber !== undefined) {
+                this.#lidByPhoneNumber.delete(oldestPhoneNumber);
+            }
+        }
+    }
+    resolveAssociatedLid(phoneNumberJid) {
+        const phoneNumber = canonicalizeWhatsAppUserCorrelationJid(phoneNumberJid);
+        if (!phoneNumber?.endsWith("@s.whatsapp.net")) {
+            return undefined;
+        }
+        return this.#lidByPhoneNumber.get(signalBundleIdentityKey(phoneNumber));
     }
     resolveMany(jids) {
         const uniqueNewIdentities = new Set();
@@ -68,74 +320,326 @@ export class WhatsAppSignalBundleStore {
             }
         }
         if (this.#bundles.size + uniqueNewIdentities.size > this.maxBundles) {
+            // Published bundle identities stay stable for the store lifetime.
             throw new Error(`WhatsApp signal bundle limit exceeded (${this.maxBundles}).`);
         }
-        return identityKeys.map((identityKey) => this.#resolve(identityKey));
+        const stagedNewBundles = new Map();
+        const stagedReservations = new Map();
+        const reservationNow = this.now();
+        const stagedForIdentity = (identityKey) => {
+            let bundle = this.#bundles.get(identityKey) ?? stagedNewBundles.get(identityKey);
+            if (!bundle) {
+                bundle = this.#createBundle();
+                stagedNewBundles.set(identityKey, bundle);
+            }
+            let staged = stagedReservations.get(identityKey);
+            if (!staged) {
+                const preKeys = new Map(bundle.preKeys);
+                const preKeyReservations = new Map(bundle.preKeyReservations);
+                for (const [preKeyId, reservedAt] of preKeyReservations) {
+                    if (reservationNow - reservedAt >= this.#preKeyReservationTtlMs &&
+                        !bundle.protectedPreKeyIds.has(preKeyId)) {
+                        preKeyReservations.delete(preKeyId);
+                        preKeys.delete(preKeyId);
+                    }
+                }
+                staged = {
+                    availablePreKeyIds: bundle.availablePreKeyIds.filter((id) => preKeys.has(id)),
+                    bundle,
+                    nextPreKeyId: bundle.nextPreKeyId,
+                    preKeyReservations,
+                    preKeys,
+                };
+                stagedReservations.set(identityKey, staged);
+            }
+            return staged;
+        };
+        const requestedPreKeys = new Map();
+        for (const identityKey of identityKeys) {
+            requestedPreKeys.set(identityKey, (requestedPreKeys.get(identityKey) ?? 0) + 1);
+        }
+        for (const [identityKey, requested] of requestedPreKeys) {
+            const staged = stagedForIdentity(identityKey);
+            const available = staged.availablePreKeyIds.length;
+            const creatable = Math.max(0, this.#maxPreKeysPerBundle - staged.preKeys.size - staged.bundle.pendingPreKeyIds.size);
+            if (requested > available + creatable) {
+                throw new Error(`WhatsApp Signal prekey reservation limit exceeded (${this.#maxPreKeysPerBundle}).`);
+            }
+        }
+        const reservedBundles = identityKeys.map((identityKey) => {
+            const staged = stagedForIdentity(identityKey);
+            const { bundle } = staged;
+            let preKeyId = staged.availablePreKeyIds.shift();
+            if (preKeyId === undefined) {
+                const created = this.#createPreKey(staged.preKeys, staged.nextPreKeyId, staged.bundle.pendingPreKeyIds);
+                preKeyId = created.id;
+                staged.preKeys.set(created.id, created.keyPair);
+                staged.nextPreKeyId = created.nextPreKeyId;
+            }
+            const preKey = staged.preKeys.get(preKeyId);
+            if (!preKey) {
+                throw new Error("WhatsApp Signal prekey reservation is unavailable.");
+            }
+            staged.preKeyReservations.set(preKeyId, reservationNow);
+            return {
+                identityKey: bundle.identityKey,
+                preKey,
+                preKeyId,
+                registrationId: bundle.registrationId,
+                signedPreKey: bundle.signedPreKey,
+            };
+        });
+        for (const [identityKey, bundle] of stagedNewBundles) {
+            this.#bundles.set(identityKey, bundle);
+        }
+        for (const staged of stagedReservations.values()) {
+            staged.bundle.availablePreKeyIds = staged.availablePreKeyIds;
+            staged.bundle.nextPreKeyId = staged.nextPreKeyId;
+            staged.bundle.preKeyReservations = staged.preKeyReservations;
+            staged.bundle.preKeys = staged.preKeys;
+        }
+        return reservedBundles;
     }
     async decryptDirectMessage(params) {
+        const result = await this.transactDirectMessage({
+            ...params,
+            accept: async (plaintext) => plaintext,
+        });
+        if (result.status === "decrypt-failed") {
+            throw result.error;
+        }
+        return result.status === "accepted" ? result.value : undefined;
+    }
+    async transactDirectMessage(params) {
+        params.signal?.throwIfAborted();
         const recipientJid = canonicalizeWhatsAppUserCorrelationJid(params.recipientJid);
         const recipientIdentityKey = recipientJid ? signalBundleIdentityKey(recipientJid) : undefined;
         const mappedLidIdentityKey = recipientIdentityKey
-            ? this.#lidByPhoneNumber.get(recipientIdentityKey)
+            ? this.resolveAssociatedLid(recipientIdentityKey)
             : undefined;
         const identityKey = mappedLidIdentityKey && this.#bundles.has(mappedLidIdentityKey)
             ? mappedLidIdentityKey
             : recipientIdentityKey;
         const bundle = identityKey ? this.#bundles.get(identityKey) : undefined;
         if (!identityKey || !bundle) {
-            return undefined;
+            return { status: "unavailable" };
         }
         const remoteAddress = signalProtocolAddress(params.remoteJid);
         if (!remoteAddress) {
-            return undefined;
+            return { status: "unavailable" };
         }
-        const sessions = this.#sessions.get(identityKey) ?? new Map();
-        this.#sessions.set(identityKey, sessions);
-        const stagedSessions = new Map();
-        const storage = {
-            async loadSession(id) {
-                const session = stagedSessions.get(id) ?? sessions.get(id);
-                return session ? cloneSignalSession(session) : undefined;
-            },
-            async storeSession(id, session) {
-                stagedSessions.set(id, cloneSignalSession(session));
-            },
-            isTrustedIdentity: () => true,
-            async loadPreKey(id) {
-                if (String(id) !== String(bundle.preKeyId)) {
-                    return undefined;
+        const address = new ProtocolAddress(remoteAddress.name, remoteAddress.deviceId);
+        // Capacity checks, staged writes, and commits stay atomic per recipient bundle.
+        return await this.#runTransaction(identityKey, async () => {
+            params.signal?.throwIfAborted();
+            const sessions = this.#sessions.get(identityKey) ?? new Map();
+            const sessionLimitError = new Error("WhatsApp Signal session limit exceeded.");
+            const maxSessionsPerBundle = this.#maxSessionsPerBundle;
+            let stagedNewSessionCount = 0;
+            const stagedPreKeyRemovals = new Set();
+            const stagedSessions = new Map();
+            const storage = {
+                async loadSession(id) {
+                    const session = stagedSessions.get(id) ?? sessions.get(id);
+                    return session ? cloneSignalSession(session) : undefined;
+                },
+                async storeSession(id, session) {
+                    if (!sessions.has(id) && !stagedSessions.has(id)) {
+                        if (sessions.size + stagedNewSessionCount >= maxSessionsPerBundle) {
+                            throw sessionLimitError;
+                        }
+                        stagedNewSessionCount += 1;
+                    }
+                    stagedSessions.set(id, cloneSignalSession(session));
+                },
+                isTrustedIdentity: () => true,
+                loadPreKey: async (id) => {
+                    const preKey = bundle.preKeys.get(Number(id));
+                    if (preKey && params.messageKey) {
+                        this.#protectMessagePreKey(params.messageKey, identityKey, Number(id));
+                    }
+                    return preKey ? signalKeyPair(preKey) : undefined;
+                },
+                removePreKey(id) {
+                    stagedPreKeyRemovals.add(id);
+                },
+                loadSignedPreKey: () => signalKeyPair(bundle.signedPreKey.keyPair),
+                getOurRegistrationId: () => bundle.registrationId,
+                getOurIdentity: () => signalKeyPair(bundle.identityKey),
+            };
+            const cipher = new SessionCipher(storage, address);
+            let plaintext;
+            try {
+                plaintext =
+                    params.type === "pkmsg"
+                        ? await cipher.decryptPreKeyWhisperMessage(params.ciphertext)
+                        : await cipher.decryptWhisperMessage(params.ciphertext);
+            }
+            catch (error) {
+                if (error === sessionLimitError) {
+                    return { status: "rejected" };
                 }
-                return signalKeyPair(bundle.preKey);
-            },
-            removePreKey: () => undefined,
-            loadSignedPreKey: () => signalKeyPair(bundle.signedPreKey.keyPair),
-            getOurRegistrationId: () => bundle.registrationId,
-            getOurIdentity: () => signalKeyPair(bundle.identityKey),
-        };
-        const cipher = new SessionCipher(storage, new ProtocolAddress(remoteAddress.name, remoteAddress.deviceId));
-        const plaintext = params.type === "pkmsg"
-            ? await cipher.decryptPreKeyWhisperMessage(params.ciphertext)
-            : await cipher.decryptWhisperMessage(params.ciphertext);
-        for (const [id, session] of stagedSessions) {
-            sessions.set(id, session);
-        }
-        return plaintext;
-    }
-    #resolve(bundleKey) {
-        const existing = this.#bundles.get(bundleKey);
-        if (existing) {
-            return existing;
-        }
-        const identityKey = Curve.generateKeyPair();
-        const bundle = {
+                return { error, status: "decrypt-failed" };
+            }
+            params.signal?.throwIfAborted();
+            let stagedNextPreKeyId = bundle.nextPreKeyId;
+            const stagedPreKeyIds = new Set();
+            const replacementPreKeys = [...stagedPreKeyRemovals]
+                .filter((id) => bundle.preKeys.has(id))
+                .map(() => {
+                const unavailableIds = new Set([...bundle.pendingPreKeyIds, ...stagedPreKeyIds]);
+                const created = this.#createPreKey(bundle.preKeys, stagedNextPreKeyId, unavailableIds);
+                stagedNextPreKeyId = created.nextPreKeyId;
+                stagedPreKeyIds.add(created.id);
+                return created;
+            });
+            for (const replacementPreKey of replacementPreKeys) {
+                bundle.pendingPreKeyIds.add(replacementPreKey.id);
+            }
+            bundle.nextPreKeyId = stagedNextPreKeyId;
+            try {
+                const accepted = await awaitWithAbort(Promise.resolve().then(() => params.accept(plaintext)), params.signal);
+                if (accepted === undefined) {
+                    return { status: "rejected" };
+                }
+                params.signal?.throwIfAborted();
+                for (const [id, session] of stagedSessions) {
+                    sessions.set(id, session);
+                }
+                if (stagedSessions.size > 0) {
+                    this.#sessions.set(identityKey, sessions);
+                }
+                for (const id of stagedPreKeyRemovals) {
+                    bundle.preKeyReservations.delete(id);
+                    bundle.preKeys.delete(id);
+                }
+                for (const replacementPreKey of replacementPreKeys) {
+                    bundle.preKeys.set(replacementPreKey.id, replacementPreKey.keyPair);
+                    bundle.availablePreKeyIds.push(replacementPreKey.id);
+                }
+                return { status: "accepted", value: accepted };
+            }
+            finally {
+                for (const replacementPreKey of replacementPreKeys) {
+                    bundle.pendingPreKeyIds.delete(replacementPreKey.id);
+                }
+            }
+        });
+    }
+    #createBundle() {
+        const identityKey = generateSignalKeyPair();
+        return {
+            availablePreKeyIds: [],
             identityKey,
-            preKey: Curve.generateKeyPair(),
-            preKeyId: 1,
+            nextPreKeyId: 1,
+            pendingPreKeyIds: new Set(),
+            preKeyReservations: new Map(),
+            preKeys: new Map(),
+            protectedPreKeyIds: new Map(),
             registrationId: 1,
             signedPreKey: signedKeyPair(identityKey, 1),
         };
-        this.#bundles.set(bundleKey, bundle);
-        return bundle;
+    }
+    #createPreKey(preKeys, startingId, stagedIds = new Set()) {
+        let id = startingId;
+        while (preKeys.has(id) || stagedIds.has(id)) {
+            id = id === 0xff_ff_ff ? 1 : id + 1;
+            if (id === startingId) {
+                throw new Error("WhatsApp Signal prekey identifier space exhausted.");
+            }
+        }
+        return {
+            id,
+            keyPair: generateSignalKeyPair(),
+            nextPreKeyId: id === 0xff_ff_ff ? 1 : id + 1,
+        };
+    }
+    #recoverExpiredPendingAcknowledgements() {
+        const now = this.now();
+        for (const [messageKey, pendingAcknowledgement] of this.#pendingAcknowledgements) {
+            const { acceptedAt } = pendingAcknowledgement;
+            if (acceptedAt === undefined) {
+                continue;
+            }
+            if (now - acceptedAt < this.maxPendingAcknowledgementAgeMs) {
+                continue;
+            }
+            this.#pendingAcknowledgements.delete(messageKey);
+            this.#rememberAcknowledgedMessage(messageKey);
+        }
+    }
+    #rememberAcknowledgedMessage(messageKey) {
+        this.#acknowledgedMessageIds.delete(messageKey);
+        this.#acknowledgedMessageIds.set(messageKey, true);
+        if (this.#acknowledgedMessageIds.size > this.maxRecentAcknowledgements) {
+            const oldestMessageKey = this.#acknowledgedMessageIds.keys().next().value;
+            if (oldestMessageKey !== undefined) {
+                this.#acknowledgedMessageIds.delete(oldestMessageKey);
+            }
+        }
+    }
+    #rememberPersistedMessage(messageKey) {
+        this.#persistedMessageIds.delete(messageKey);
+        this.#persistedMessageIds.set(messageKey, true);
+        if (this.#persistedMessageIds.size > this.maxRecentAcknowledgements) {
+            const oldestMessageKey = this.#persistedMessageIds.keys().next().value;
+            if (oldestMessageKey !== undefined) {
+                this.#persistedMessageIds.delete(oldestMessageKey);
+                this.releaseMessagePreKeyProtection(oldestMessageKey);
+            }
+        }
+    }
+    #protectMessagePreKey(messageKey, identityKey, preKeyId) {
+        let protections = this.#messagePreKeyProtections.get(messageKey);
+        if (!protections) {
+            protections = new Map();
+            this.#messagePreKeyProtections.set(messageKey, protections);
+        }
+        let preKeyIds = protections.get(identityKey);
+        if (!preKeyIds) {
+            preKeyIds = new Set();
+            protections.set(identityKey, preKeyIds);
+        }
+        if (preKeyIds.has(preKeyId)) {
+            return;
+        }
+        preKeyIds.add(preKeyId);
+        const bundle = this.#bundles.get(identityKey);
+        if (bundle) {
+            bundle.protectedPreKeyIds.set(preKeyId, (bundle.protectedPreKeyIds.get(preKeyId) ?? 0) + 1);
+        }
+    }
+    #rememberTerminalAcceptance(messageKey, error, drain) {
+        const terminalAcceptance = { error };
+        this.#terminalAcceptances.set(messageKey, terminalAcceptance);
+        void drain.then((disposition) => {
+            if (this.#terminalAcceptances.get(messageKey) === terminalAcceptance) {
+                this.#terminalAcceptances.delete(messageKey);
+            }
+            if (disposition === "acknowledged") {
+                this.#rememberAcknowledgedMessage(messageKey);
+            }
+            else if (disposition === "persisted") {
+                this.#rememberPersistedMessage(messageKey);
+            }
+        });
+    }
+    async #runTransaction(key, operation) {
+        return await this.#runSerialized(this.#pendingTransactions, key, operation);
+    }
+    async #runSerialized(pending, key, operation) {
+        const previous = pending.get(key) ?? Promise.resolve();
+        const result = previous.catch(() => undefined).then(operation);
+        const settled = result.then(() => undefined, () => undefined);
+        pending.set(key, settled);
+        try {
+            return await result;
+        }
+        finally {
+            if (pending.get(key) === settled) {
+                pending.delete(key);
+            }
+        }
     }
 }
 export function createSerializedMessageHandler(processMessage, onError, options = {}) {
@@ -382,6 +886,7 @@ class BaileysNoiseServer {
 class WhatsAppBaileysWebSocketSession {
     socket;
     params;
+    #acceptanceAbort = new AbortController();
     #handshakeState = "client-hello";
     #handleSerializedMessage;
     #noise = new BaileysNoiseServer();
@@ -399,7 +904,12 @@ class WhatsAppBaileysWebSocketSession {
         return this.#handshakeState === "open" && this.socket.readyState === WebSocket.OPEN;
     }
     handleMessage(data) {
-        void this.#handleSerializedMessage(data);
+        return this.#handleSerializedMessage(data);
+    }
+    abortAcceptance(reason) {
+        if (!this.#acceptanceAbort.signal.aborted) {
+            this.#acceptanceAbort.abort(reason);
+        }
     }
     async deliverInboundMessage(message) {
         if (!this.isOpen) {
@@ -450,32 +960,33 @@ class WhatsAppBaileysWebSocketSession {
         }
         if (node.tag === "message") {
             const peer = requireAttr(node, "to");
-            const normalizedMessage = await normalizeAcceptedBaileysMessage({
+            const messageId = requireAttr(node, "id");
+            const accepted = await persistAcceptedBaileysMessage({
+                acceptanceSignal: this.#acceptanceAbort.signal,
+                appendEvent: this.params.appendEvent,
                 node,
+                onAcceptanceTimeout: () => {
+                    const close = resolveWhatsAppWebSocketClose(new Error("WhatsApp message acceptance timed out."));
+                    this.socket.close(close.code, close.reason);
+                },
+                path: this.params.path,
                 remoteJid: this.params.selfJid,
                 signalBundles: this.params.signalBundles,
             });
+            if (!accepted) {
+                return;
+            }
             await this.#sendNode({
                 attrs: {
                     class: "message",
                     from: peer,
-                    id: requireAttr(node, "id"),
+                    id: messageId,
                     to: this.params.selfJid,
                     ...(node.attrs.type ? { type: node.attrs.type } : {}),
                 },
                 tag: "ack",
             });
-            if (normalizedMessage) {
-                await this.params.appendEvent({
-                    accepted: true,
-                    at: new Date().toISOString(),
-                    body: normalizedMessage,
-                    method: "WEBSOCKET",
-                    path: this.params.path,
-                    query: {},
-                    type: "api",
-                });
-            }
+            this.params.signalBundles.markMessageAcknowledged(peer, messageId);
         }
     }
     #createIqResult(node) {
@@ -621,7 +1132,11 @@ class WhatsAppBaileysWebSocketSession {
             content: [
                 { attrs: {}, content: encodeBigEndian(bundle.registrationId), tag: "registration" },
                 { attrs: {}, content: KEY_BUNDLE_TYPE, tag: "type" },
-                { attrs: {}, content: bundle.identityKey.public, tag: "identity" },
+                {
+                    attrs: {},
+                    content: scrubSignalPublicKey(bundle.identityKey.public),
+                    tag: "identity",
+                },
                 xmppSignedPreKey(bundle.signedPreKey),
                 xmppPreKey(bundle.preKey, bundle.preKeyId),
             ],
@@ -742,8 +1257,9 @@ function truncateWebSocketCloseReason(reason) {
     return result;
 }
 export function attachWhatsAppBaileysWebSocketServer(params) {
-    const signalBundles = new WhatsAppSignalBundleStore();
+    const signalBundles = new WhatsAppSignalBundleStore(undefined, undefined, undefined, undefined, undefined, { messageAcceptanceTimeoutMs: params.messageAcceptanceTimeoutMs });
     const sessions = new Set();
+    const pendingSessionMessages = new Set();
     const pendingMessages = [];
     const maxPendingInboundMessages = resolveMaxPendingWhatsAppInboundMessages(params.maxPendingInboundMessages);
     let pendingReservations = 0;
@@ -809,20 +1325,39 @@ export function attachWhatsAppBaileysWebSocketServer(params) {
             signalBundles,
         });
         sessions.add(session);
-        socket.once("close", () => sessions.delete(session));
+        socket.once("close", () => {
+            session.abortAcceptance(new Error("WhatsApp WebSocket closed."));
+            sessions.delete(session);
+        });
         socket.on("error", () => {
+            session.abortAcceptance(new Error("WhatsApp WebSocket failed."));
             sessions.delete(session);
             socket.terminate();
         });
-        socket.on("message", (data) => session.handleMessage(data));
+        socket.on("message", (data) => {
+            const pending = session.handleMessage(data);
+            pendingSessionMessages.add(pending);
+            void pending.then(() => pendingSessionMessages.delete(pending), () => pendingSessionMessages.delete(pending));
+        });
     });
     return {
         async close() {
             closing = true;
             params.httpServer.off("upgrade", handleUpgrade);
             pendingMessages.length = 0;
+            for (const session of sessions) {
+                session.abortAcceptance(new Error("WhatsApp WebSocket server is shutting down."));
+            }
             await closeWebSocketServer(wss);
+            const messageResults = await Promise.allSettled([...pendingSessionMessages]);
             await flushPromise;
+            const messageErrors = messageResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (messageErrors.length === 1) {
+                throw messageErrors[0];
+            }
+            if (messageErrors.length > 1) {
+                throw new AggregateError(messageErrors, "WhatsApp WebSocket message drain failed.");
+            }
         },
         prepareInboundMessage(message) {
             if (pendingMessages.length + pendingReservations >= maxPendingInboundMessages) {
@@ -909,45 +1444,133 @@ function removeNoiseIntroHeader(chunk) {
 function children(node) {
     return Array.isArray(node.content) ? node.content : [];
 }
-async function normalizeAcceptedBaileysMessage(params) {
+export async function persistAcceptedBaileysMessage(params) {
     const peer = canonicalizeWhatsAppUserCorrelationJid(params.node.attrs.to ?? "");
     const messageId = params.node.attrs.id;
     if (!peer || !messageId) {
-        return undefined;
-    }
-    const candidates = encryptedMessageCandidates(params.node);
-    const remoteCorrelationJid = canonicalizeWhatsAppUserCorrelationJid(params.remoteJid);
-    candidates.sort((left, right) => {
-        const leftIsSelf = canonicalizeWhatsAppUserCorrelationJid(left.recipientJid) === remoteCorrelationJid;
-        const rightIsSelf = canonicalizeWhatsAppUserCorrelationJid(right.recipientJid) === remoteCorrelationJid;
-        return Number(leftIsSelf) - Number(rightIsSelf);
+        return false;
+    }
+    const messageKey = `${peer}\0${messageId}`;
+    const wasPreviouslyPersisted = params.signalBundles.hasPersistedMessage(messageKey);
+    let persistenceSucceeded = wasPreviouslyPersisted;
+    let operationSettled;
+    const operationSettlement = new Promise((resolve) => {
+        operationSettled = resolve;
     });
-    for (const candidate of candidates) {
+    let requiresSignalCommit = wasPreviouslyPersisted;
+    let signalCommitSucceeded = false;
+    const pendingAcceptanceOperations = new Set();
+    const trackAcceptanceOperation = (operation) => {
+        pendingAcceptanceOperations.add(operation);
+        void operation.then(() => {
+            persistenceSucceeded = true;
+            pendingAcceptanceOperations.delete(operation);
+        }, () => pendingAcceptanceOperations.delete(operation));
+        return operation;
+    };
+    const drainAcceptanceOperations = async () => {
+        while (pendingAcceptanceOperations.size > 0) {
+            await Promise.allSettled([...pendingAcceptanceOperations]);
+        }
+        await operationSettlement;
+        if (!persistenceSucceeded) {
+            params.signalBundles.releaseMessagePreKeyProtection(messageKey);
+            return "retryable";
+        }
+        if (!requiresSignalCommit || signalCommitSucceeded) {
+            params.signalBundles.releaseMessagePreKeyProtection(messageKey);
+            return "acknowledged";
+        }
+        return "persisted";
+    };
+    const accepted = await params.signalBundles.acceptMessageOnce(messageKey, async (acceptanceSignal) => {
         try {
-            const decrypted = await params.signalBundles.decryptDirectMessage({
-                ciphertext: candidate.ciphertext,
-                recipientJid: candidate.recipientJid,
-                remoteJid: params.remoteJid,
-                type: candidate.type,
+            acceptanceSignal.throwIfAborted();
+            const candidates = encryptedMessageCandidates(params.node);
+            requiresSignalCommit = candidates.length > 0;
+            if (candidates.length === 0) {
+                if (!wasPreviouslyPersisted) {
+                    await awaitWithAbort(trackAcceptanceOperation(params.appendEvent({
+                        accepted: true,
+                        at: new Date().toISOString(),
+                        body: sanitizeNodeForJson(params.node),
+                        method: "WEBSOCKET",
+                        path: params.path,
+                        query: {},
+                        type: "api",
+                    })), acceptanceSignal);
+                }
+                return true;
+            }
+            const remoteCorrelationJid = canonicalizeWhatsAppUserCorrelationJid(params.remoteJid);
+            candidates.sort((left, right) => {
+                const leftIsSelf = canonicalizeWhatsAppUserCorrelationJid(left.recipientJid) === remoteCorrelationJid;
+                const rightIsSelf = canonicalizeWhatsAppUserCorrelationJid(right.recipientJid) === remoteCorrelationJid;
+                return Number(leftIsSelf) - Number(rightIsSelf);
             });
-            const text = decrypted ? readWhatsAppConversation(unpadRandomMax16(decrypted)) : undefined;
-            if (text) {
-                return {
-                    key: {
-                        fromMe: true,
-                        id: messageId,
-                        remoteJid: peer,
+            for (const candidate of candidates) {
+                const result = await params.signalBundles.transactDirectMessage({
+                    accept: async (decrypted) => {
+                        let text;
+                        try {
+                            text = readWhatsAppConversation(unpadRandomMax16(decrypted));
+                        }
+                        catch {
+                            text = undefined;
+                        }
+                        const message = text
+                            ? {
+                                key: {
+                                    fromMe: true,
+                                    id: messageId,
+                                    remoteJid: peer,
+                                },
+                                message: { conversation: text },
+                                messageTimestamp: Math.floor(Date.now() / 1000),
+                            }
+                            : undefined;
+                        if (!wasPreviouslyPersisted) {
+                            await awaitWithAbort(trackAcceptanceOperation(params.appendEvent({
+                                accepted: true,
+                                at: new Date().toISOString(),
+                                body: message ?? sanitizeNodeForJson(params.node),
+                                method: "WEBSOCKET",
+                                path: params.path,
+                                query: {},
+                                type: "api",
+                            })), acceptanceSignal);
+                        }
+                        return true;
                     },
-                    message: { conversation: text },
-                    messageTimestamp: Math.floor(Date.now() / 1000),
-                };
+                    ciphertext: candidate.ciphertext,
+                    messageKey,
+                    recipientJid: candidate.recipientJid,
+                    remoteJid: params.remoteJid,
+                    signal: acceptanceSignal,
+                    type: candidate.type,
+                });
+                if (result.status === "accepted") {
+                    signalCommitSucceeded = true;
+                    return true;
+                }
             }
+            return false;
         }
-        catch {
-            // Other participant envelopes may not belong to this mock server identity.
+        finally {
+            if (!acceptanceSignal.aborted && !signalCommitSucceeded) {
+                params.signalBundles.releaseMessagePreKeyProtection(messageKey);
+            }
+            operationSettled();
         }
+    }, {
+        onTerminalTimeout: params.onAcceptanceTimeout,
+        signal: params.acceptanceSignal,
+        terminalDrain: drainAcceptanceOperations,
+    });
+    if (accepted) {
+        params.signalBundles.clearPersistedMessage(messageKey);
     }
-    return undefined;
+    return accepted;
 }
 function encryptedMessageCandidates(node) {
     const result = [];
@@ -973,29 +1596,29 @@ function encryptedMessageCandidates(node) {
 function signalKeyPair(pair) {
     return {
         privKey: Buffer.from(pair.private),
-        pubKey: pair.public.length === 33
-            ? Buffer.from(pair.public)
-            : Buffer.concat([KEY_BUNDLE_TYPE, pair.public]),
+        pubKey: ensureSignalPublicKey(pair.public),
     };
 }
 function cloneSignalSession(session) {
     return SessionRecord.deserialize(session.serialize());
 }
 export function signalBundleIdentityKey(jid) {
-    return jid.replace(/:\d+(?=@)/u, "");
+    return jid.replace(/(?:_\d+)?(?::\d+)?(?=@)/u, "");
 }
 function signalProtocolAddress(jid) {
-    const match = /^(\d{7,15})(?::(\d+))?@(s\.whatsapp\.net|lid)$/iu.exec(jid);
+    const match = /^(\d{7,15})(?:_(\d+))?(?::(\d+))?@(s\.whatsapp\.net|lid)$/iu.exec(jid);
     if (!match) {
         return undefined;
     }
-    const deviceId = Number(match[2] ?? "0");
+    const deviceId = Number(match[3] ?? "0");
     if (!Number.isSafeInteger(deviceId) || deviceId < 0) {
         return undefined;
     }
+    const agent = match[2];
+    const server = match[4].toLowerCase();
     return {
         deviceId,
-        name: match[3].toLowerCase() === "lid" ? `${match[1]}_1` : match[1],
+        name: agent !== undefined ? `${match[1]}_${agent}` : server === "lid" ? `${match[1]}_1` : match[1],
     };
 }
 function unpadRandomMax16(value) {
@@ -1030,6 +1653,7 @@ function readWhatsAppConversation(message) {
         : undefined;
     return nestedMessage ? readWhatsAppConversation(nestedMessage) : undefined;
 }
+const MAX_WHATSAPP_PROTOBUF_GROUP_DEPTH = 64;
 function readProtobufLengthDelimitedFields(value) {
     const fields = new Map();
     let offset = 0;
@@ -1055,20 +1679,66 @@ function readProtobufLengthDelimitedFields(value) {
             continue;
         }
         if (wireType === 0) {
-            offset = readProtobufVarint(value, offset).offset;
+            offset = skipWhatsAppProtobufField(value, offset, fieldNumber, wireType, 0);
             continue;
         }
-        if (wireType === 1) {
-            offset += 8;
-            continue;
+        offset = skipWhatsAppProtobufField(value, offset, fieldNumber, wireType, 0);
+    }
+    return fields;
+}
+function skipWhatsAppProtobufField(value, offset, fieldNumber, wireType, groupDepth) {
+    if (wireType === 0) {
+        return readProtobufVarint(value, offset).offset;
+    }
+    if (wireType === 1) {
+        const end = offset + 8;
+        if (end > value.length) {
+            throw new Error("Invalid WhatsApp protobuf fixed64 field.");
         }
-        if (wireType === 5) {
-            offset += 4;
-            continue;
+        return end;
+    }
+    if (wireType === 2) {
+        const length = readProtobufVarint(value, offset);
+        const end = length.offset + length.value;
+        if (end > value.length) {
+            throw new Error("Invalid WhatsApp protobuf length.");
         }
-        throw new Error(`Unsupported WhatsApp protobuf wire type: ${wireType}.`);
+        return end;
     }
-    return fields;
+    if (wireType === 3) {
+        if (groupDepth >= MAX_WHATSAPP_PROTOBUF_GROUP_DEPTH) {
+            throw new Error("WhatsApp protobuf group nesting exceeds the supported depth.");
+        }
+        let nestedOffset = offset;
+        while (nestedOffset < value.length) {
+            const tag = readProtobufVarint(value, nestedOffset);
+            nestedOffset = tag.offset;
+            const nestedFieldNumber = tag.value >>> 3;
+            const nestedWireType = tag.value & 7;
+            if (nestedFieldNumber < 1) {
+                throw new Error("Invalid WhatsApp protobuf field.");
+            }
+            if (nestedWireType === 4) {
+                if (nestedFieldNumber !== fieldNumber) {
+                    throw new Error("Mismatched WhatsApp protobuf end group.");
+                }
+                return nestedOffset;
+            }
+            nestedOffset = skipWhatsAppProtobufField(value, nestedOffset, nestedFieldNumber, nestedWireType, groupDepth + 1);
+        }
+        throw new Error("Unterminated WhatsApp protobuf group.");
+    }
+    if (wireType === 4) {
+        throw new Error("Unexpected WhatsApp protobuf end group.");
+    }
+    if (wireType === 5) {
+        const end = offset + 4;
+        if (end > value.length) {
+            throw new Error("Invalid WhatsApp protobuf fixed32 field.");
+        }
+        return end;
+    }
+    throw new Error(`Unsupported WhatsApp protobuf wire type: ${wireType}.`);
 }
 function readProtobufVarint(value, start) {
     let result = 0;