@openclaw/crabline 0.1.9 → 0.1.10

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

@@ -1,14 +1,274 @@
 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 { 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";
 // 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);
 const IV_LENGTH = 12;
+const MAX_PENDING_INBOUND_MESSAGES = 1_000;
+export const MAX_WHATSAPP_NOISE_FRAME_BYTES = 2 * 1024 * 1024;
+export const MAX_WHATSAPP_WEBSOCKET_BUFFERED_BYTES = 4 * 1024 * 1024;
+export const MAX_WHATSAPP_WEBSOCKET_MESSAGE_BYTES = 4 * 1024 * 1024;
+export const MAX_WHATSAPP_NOISE_BUFFER_CHUNKS = 1_024;
+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;
+export const MAX_WHATSAPP_WEBSOCKET_FRAGMENTS = 1_024;
+export const MAX_WHATSAPP_SIGNAL_BUNDLES = 1_024;
+export const MAX_WHATSAPP_WEBSOCKET_CLOSE_REASON_BYTES = 123;
 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;
+    if (!Number.isSafeInteger(resolved) || resolved < 1) {
+        throw new Error("WhatsApp maxPendingInboundMessages must be a positive safe integer.");
+    }
+    return resolved;
+}
+export class WhatsAppSignalBundleStore {
+    maxBundles;
+    #bundles = new Map();
+    #lidByPhoneNumber = new Map();
+    #sessions = new Map();
+    constructor(maxBundles = MAX_WHATSAPP_SIGNAL_BUNDLES) {
+        this.maxBundles = maxBundles;
+        if (!Number.isSafeInteger(maxBundles) || maxBundles < 1) {
+            throw new Error("WhatsApp maxSignalBundles must be a positive safe integer.");
+        }
+    }
+    get size() {
+        return this.#bundles.size;
+    }
+    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));
+    }
+    resolveMany(jids) {
+        const uniqueNewIdentities = new Set();
+        const identityKeys = [];
+        for (const jid of jids) {
+            const canonical = canonicalizeWhatsAppUserCorrelationJid(jid);
+            if (!canonical) {
+                throw new Error(`Invalid WhatsApp signal bundle JID: ${jid}.`);
+            }
+            const identityKey = signalBundleIdentityKey(canonical);
+            identityKeys.push(identityKey);
+            if (!this.#bundles.has(identityKey)) {
+                uniqueNewIdentities.add(identityKey);
+            }
+        }
+        if (this.#bundles.size + uniqueNewIdentities.size > this.maxBundles) {
+            throw new Error(`WhatsApp signal bundle limit exceeded (${this.maxBundles}).`);
+        }
+        return identityKeys.map((identityKey) => this.#resolve(identityKey));
+    }
+    async decryptDirectMessage(params) {
+        const recipientJid = canonicalizeWhatsAppUserCorrelationJid(params.recipientJid);
+        const recipientIdentityKey = recipientJid ? signalBundleIdentityKey(recipientJid) : undefined;
+        const mappedLidIdentityKey = recipientIdentityKey
+            ? this.#lidByPhoneNumber.get(recipientIdentityKey)
+            : undefined;
+        const identityKey = mappedLidIdentityKey && this.#bundles.has(mappedLidIdentityKey)
+            ? mappedLidIdentityKey
+            : recipientIdentityKey;
+        const bundle = identityKey ? this.#bundles.get(identityKey) : undefined;
+        if (!identityKey || !bundle) {
+            return undefined;
+        }
+        const remoteAddress = signalProtocolAddress(params.remoteJid);
+        if (!remoteAddress) {
+            return undefined;
+        }
+        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;
+                }
+                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 = {
+            identityKey,
+            preKey: Curve.generateKeyPair(),
+            preKeyId: 1,
+            registrationId: 1,
+            signedPreKey: signedKeyPair(identityKey, 1),
+        };
+        this.#bundles.set(bundleKey, bundle);
+        return bundle;
+    }
+}
+export function createSerializedMessageHandler(processMessage, onError, options = {}) {
+    const maxPendingBytes = options.maxPendingBytes ?? MAX_PENDING_WEBSOCKET_BYTES;
+    const maxPendingMessages = options.maxPendingMessages ?? MAX_PENDING_WEBSOCKET_MESSAGES;
+    const sizeOf = options.sizeOf ?? (() => 1);
+    let failed = false;
+    let pendingBytes = 0;
+    let pendingMessages = 0;
+    let pending = Promise.resolve();
+    const fail = (error) => {
+        if (!failed) {
+            failed = true;
+            onError(error);
+        }
+    };
+    return (message) => {
+        if (failed) {
+            return pending;
+        }
+        const messageBytes = sizeOf(message);
+        if (!Number.isSafeInteger(messageBytes) || messageBytes < 0) {
+            fail(new Error("WhatsApp WebSocket message size must be a non-negative safe integer."));
+            return pending;
+        }
+        if (pendingMessages >= maxPendingMessages || pendingBytes + messageBytes > maxPendingBytes) {
+            fail(new Error("WhatsApp WebSocket inbound backlog limit exceeded."));
+            return pending;
+        }
+        pendingMessages += 1;
+        pendingBytes += messageBytes;
+        const next = pending
+            .then(async () => {
+            if (!failed) {
+                await processMessage(message);
+            }
+        })
+            .finally(() => {
+            pendingMessages -= 1;
+            pendingBytes -= messageBytes;
+        });
+        pending = next.catch((error) => {
+            fail(error);
+        });
+        return pending;
+    };
+}
+export class WhatsAppNoiseFrameDecoder {
+    #bufferedBytes = 0;
+    #chunks = [];
+    #expectIntro = true;
+    #offset = 0;
+    get bufferedBytes() {
+        return this.#bufferedBytes;
+    }
+    decodeFrames(data) {
+        let chunk = rawDataToBuffer(data);
+        if (this.#expectIntro) {
+            chunk = removeNoiseIntroHeader(chunk);
+            this.#expectIntro = false;
+        }
+        if (chunk.length > 0) {
+            if (this.#chunks.length >= MAX_WHATSAPP_NOISE_BUFFER_CHUNKS) {
+                throw new Error(`WhatsApp Noise buffer exceeds ${MAX_WHATSAPP_NOISE_BUFFER_CHUNKS} chunks.`);
+            }
+            this.#chunks.push(chunk);
+            this.#bufferedBytes += chunk.length;
+        }
+        const frames = [];
+        while (this.#bufferedBytes >= 3) {
+            const size = (this.#peekByte(0) << 16) | (this.#peekByte(1) << 8) | this.#peekByte(2);
+            if (size > MAX_WHATSAPP_NOISE_FRAME_BYTES) {
+                throw new Error(`WhatsApp Noise frame exceeds ${MAX_WHATSAPP_NOISE_FRAME_BYTES} bytes.`);
+            }
+            if (this.#bufferedBytes < size + 3) {
+                break;
+            }
+            if (frames.length >= MAX_WHATSAPP_NOISE_FRAMES_PER_MESSAGE) {
+                throw new Error(`WhatsApp Noise message exceeds ${MAX_WHATSAPP_NOISE_FRAMES_PER_MESSAGE} frames.`);
+            }
+            this.#consume(3);
+            frames.push(this.#read(size));
+        }
+        return frames;
+    }
+    #consume(length) {
+        let remaining = length;
+        while (remaining > 0) {
+            const chunk = this.#chunks[0];
+            if (!chunk) {
+                throw new Error("Unexpected end of WhatsApp Noise frame buffer.");
+            }
+            const available = chunk.length - this.#offset;
+            const consumed = Math.min(available, remaining);
+            this.#offset += consumed;
+            this.#bufferedBytes -= consumed;
+            remaining -= consumed;
+            if (this.#offset === chunk.length) {
+                this.#chunks.shift();
+                this.#offset = 0;
+            }
+        }
+    }
+    #peekByte(index) {
+        let remaining = index + this.#offset;
+        for (const chunk of this.#chunks) {
+            if (remaining < chunk.length) {
+                return chunk[remaining];
+            }
+            remaining -= chunk.length;
+        }
+        throw new Error("Unexpected end of WhatsApp Noise frame buffer.");
+    }
+    #read(length) {
+        const result = Buffer.allocUnsafe(length);
+        let resultOffset = 0;
+        while (resultOffset < length) {
+            const chunk = this.#chunks[0];
+            if (!chunk) {
+                throw new Error("Unexpected end of WhatsApp Noise frame buffer.");
+            }
+            const copied = chunk.copy(result, resultOffset, this.#offset, Math.min(chunk.length, this.#offset + length - resultOffset));
+            this.#offset += copied;
+            this.#bufferedBytes -= copied;
+            resultOffset += copied;
+            if (this.#offset === chunk.length) {
+                this.#chunks.shift();
+                this.#offset = 0;
+            }
+        }
+        return result;
+    }
+}
 class TransportState {
     encKey;
     decKey;
@@ -31,9 +291,8 @@ class BaileysNoiseServer {
     #counter = 0;
     #decKey;
     #encKey;
-    #expectIntro = true;
+    #frames = new WhatsAppNoiseFrameDecoder();
     #hash;
-    #inBytes = Buffer.alloc(0);
     #salt;
     #serverEphemeralKey;
     #serverStaticKey;
@@ -47,28 +306,7 @@ class BaileysNoiseServer {
         this.#authenticate(NOISE_WA_HEADER);
     }
     decodeFrames(data) {
-        let chunk = Buffer.from(Buffer.isBuffer(data) ? data : Buffer.from(data));
-        if (this.#expectIntro) {
-            chunk = this.#removeIntroHeader(chunk);
-            this.#expectIntro = false;
-        }
-        this.#inBytes = this.#inBytes.length ? Buffer.concat([this.#inBytes, chunk]) : chunk;
-        const frames = [];
-        while (this.#inBytes.length >= 3) {
-            const head0 = this.#inBytes[0];
-            const head1 = this.#inBytes[1];
-            const head2 = this.#inBytes[2];
-            if (head0 === undefined || head1 === undefined || head2 === undefined) {
-                break;
-            }
-            const size = (head0 << 16) | (head1 << 8) | head2;
-            if (this.#inBytes.length < size + 3) {
-                break;
-            }
-            frames.push(this.#inBytes.subarray(3, size + 3));
-            this.#inBytes = this.#inBytes.subarray(size + 3);
-        }
-        return frames;
+        return this.#frames.decodeFrames(data);
     }
     async decodeTransportNode(frame) {
         if (!this.#transport) {
@@ -140,66 +378,65 @@ class BaileysNoiseServer {
         this.#decKey = readKey;
         this.#counter = 0;
     }
-    #removeIntroHeader(chunk) {
-        if (chunk.subarray(0, NOISE_WA_HEADER.length).equals(NOISE_WA_HEADER)) {
-            return chunk.subarray(NOISE_WA_HEADER.length);
-        }
-        if (chunk.length >= 11 && chunk.subarray(0, 2).toString("utf8") === "ED" && chunk[3] === 1) {
-            const routingInfoPrefix = chunk[4];
-            if (routingInfoPrefix === undefined) {
-                throw new Error("Invalid Baileys Noise routing header.");
-            }
-            const routingInfoLength = (routingInfoPrefix << 16) | chunk.readUInt16BE(5);
-            const headerLength = 7 + routingInfoLength + NOISE_WA_HEADER.length;
-            if (chunk.subarray(headerLength - NOISE_WA_HEADER.length, headerLength).equals(NOISE_WA_HEADER)) {
-                return chunk.subarray(headerLength);
-            }
-        }
-        throw new Error("Invalid Baileys Noise intro header.");
-    }
 }
 class WhatsAppBaileysWebSocketSession {
     socket;
     params;
     #handshakeState = "client-hello";
+    #handleSerializedMessage;
     #noise = new BaileysNoiseServer();
     constructor(socket, params) {
         this.socket = socket;
         this.params = params;
+        this.#handleSerializedMessage = createSerializedMessageHandler((data) => this.#handleMessage(data), (error) => {
+            const close = resolveWhatsAppWebSocketClose(error);
+            this.socket.close(close.code, close.reason);
+        }, {
+            sizeOf: rawDataByteLength,
+        });
+    }
+    get isOpen() {
+        return this.#handshakeState === "open" && this.socket.readyState === WebSocket.OPEN;
     }
     handleMessage(data) {
-        void this.#handleMessage(data).catch((error) => {
-            this.socket.close(1011, error instanceof Error ? error.message : String(error));
-        });
+        void this.#handleSerializedMessage(data);
     }
-    deliverInboundMessage(message) {
-        if (this.#handshakeState !== "open" || this.socket.readyState !== WebSocket.OPEN) {
-            return;
+    async deliverInboundMessage(message) {
+        if (!this.isOpen) {
+            return false;
+        }
+        try {
+            await this.#sendNode(createInboundMessageNode(message));
+            return true;
+        }
+        catch {
+            this.socket.terminate();
+            return false;
         }
-        this.#sendNode(createInboundMessageNode(message));
     }
     async #handleMessage(data) {
         for (const frame of this.#noise.decodeFrames(data)) {
             if (this.#handshakeState === "client-hello") {
-                this.socket.send(this.#noise.createServerHello(frame));
+                await sendWhatsAppWebSocketPayload(this.socket, this.#noise.createServerHello(frame));
                 this.#handshakeState = "client-finish";
                 continue;
             }
             if (this.#handshakeState === "client-finish") {
                 this.#noise.finishClientHandshake(frame);
                 this.#handshakeState = "open";
-                this.#sendNode({
+                await this.#sendNode({
                     attrs: {
                         lid: lidForJid(this.params.selfJid),
                         t: unixSeconds(),
                     },
                     tag: "success",
                 });
-                this.#sendNode({
+                await this.#sendNode({
                     attrs: {},
                     content: [{ attrs: { count: "0" }, tag: "offline" }],
                     tag: "ib",
                 });
+                this.params.onOpen(this);
                 continue;
             }
             await this.#handleNode(await this.#noise.decodeTransportNode(frame));
@@ -208,19 +445,37 @@ class WhatsAppBaileysWebSocketSession {
     async #handleNode(node) {
         await this.#recordNode(node);
         if (node.tag === "iq") {
-            this.#sendNode(this.#createIqResult(node));
+            await this.#sendNode(this.#createIqResult(node));
             return;
         }
         if (node.tag === "message") {
-            this.#sendNode({
+            const peer = requireAttr(node, "to");
+            const normalizedMessage = await normalizeAcceptedBaileysMessage({
+                node,
+                remoteJid: this.params.selfJid,
+                signalBundles: this.params.signalBundles,
+            });
+            await this.#sendNode({
                 attrs: {
-                    class: "receipt",
+                    class: "message",
+                    from: peer,
                     id: requireAttr(node, "id"),
-                    to: requireAttr(node, "to"),
-                    type: "server",
+                    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",
+                });
+            }
         }
     }
     #createIqResult(node) {
@@ -239,7 +494,25 @@ class WhatsAppBaileysWebSocketSession {
             return { attrs, content: [{ attrs: {}, tag: "digest" }], tag: "iq" };
         }
         if (node.attrs.xmlns === "encrypt" && child?.tag === "key") {
-            return { attrs, content: [this.#createKeyList(child)], tag: "iq" };
+            try {
+                return { attrs, content: [this.#createKeyList(child)], tag: "iq" };
+            }
+            catch (error) {
+                return {
+                    attrs: { ...attrs, type: "error" },
+                    content: [
+                        {
+                            attrs: {
+                                code: "400",
+                                text: error instanceof Error ? error.message : String(error),
+                                type: "modify",
+                            },
+                            tag: "error",
+                        },
+                    ],
+                    tag: "iq",
+                };
+            }
         }
         if (node.attrs.xmlns === "usync" && child?.tag === "usync") {
             return { attrs, content: [this.#createUSyncResult(child)], tag: "iq" };
@@ -301,6 +574,18 @@ class WhatsAppBaileysWebSocketSession {
             };
         }
         if (node.attrs.xmlns === "w:g2") {
+            if (node.attrs.type !== "get" || child?.tag !== "query") {
+                return {
+                    attrs: { ...attrs, type: "error" },
+                    content: [
+                        {
+                            attrs: { code: "501", text: "unsupported group operation", type: "cancel" },
+                            tag: "error",
+                        },
+                    ],
+                    tag: "iq",
+                };
+            }
             return {
                 attrs,
                 content: [
@@ -322,14 +607,15 @@ class WhatsAppBaileysWebSocketSession {
     }
     #createKeyList(keyNode) {
         const users = children(keyNode).filter((child) => child.tag === "user");
+        const jids = users.map((userNode) => requireAttr(userNode, "jid"));
+        const bundles = this.params.signalBundles.resolveMany(jids);
         return {
             attrs: {},
-            content: users.map((userNode) => this.#createKeyUser(requireAttr(userNode, "jid"))),
+            content: jids.map((jid, index) => this.#createKeyUser(jid, bundles[index])),
             tag: "list",
         };
     }
-    #createKeyUser(jid) {
-        const bundle = resolveSignalBundle(this.params.signalBundles, jid);
+    #createKeyUser(jid, bundle) {
         return {
             attrs: { jid },
             content: [
@@ -364,6 +650,10 @@ class WhatsAppBaileysWebSocketSession {
         };
     }
     #createUSyncUser(jid) {
+        const lid = lidForJid(jid);
+        if (canonicalizeWhatsAppUserCorrelationJid(jid)?.endsWith("@s.whatsapp.net")) {
+            this.params.signalBundles.associateLid(jid, lid);
+        }
         return {
             attrs: { jid },
             content: [
@@ -378,7 +668,7 @@ class WhatsAppBaileysWebSocketSession {
                     ],
                     tag: "devices",
                 },
-                { attrs: { val: lidForJid(jid) }, tag: "lid" },
+                { attrs: { val: lid }, tag: "lid" },
             ],
             tag: "user",
         };
@@ -393,23 +683,114 @@ class WhatsAppBaileysWebSocketSession {
             type: "api",
         });
     }
-    #sendNode(node) {
-        this.socket.send(this.#noise.encodeNode(node));
+    async #sendNode(node) {
+        await sendWhatsAppWebSocketPayload(this.socket, this.#noise.encodeNode(node));
     }
 }
+export async function sendWhatsAppWebSocketPayload(socket, payload) {
+    if (socket.readyState !== WebSocket.OPEN) {
+        throw new Error("WhatsApp WebSocket is not open.");
+    }
+    if (socket.bufferedAmount + payload.byteLength > MAX_WHATSAPP_WEBSOCKET_BUFFERED_BYTES) {
+        socket.terminate();
+        throw new Error("WhatsApp WebSocket outbound buffer limit exceeded.");
+    }
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        const timeout = setTimeout(() => {
+            socket.terminate();
+            finish(new Error("WhatsApp WebSocket send timed out."));
+        }, WHATSAPP_WEBSOCKET_SEND_TIMEOUT_MS);
+        try {
+            socket.send(payload, finish);
+        }
+        catch (error) {
+            finish(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
+export function resolveWhatsAppWebSocketClose(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = /(?:backlog|exceeds|limit|payload is too large|too many)/iu.test(message)
+        ? 1009
+        : /(?:baileys|binary node|handshake|noise|protocol|unexpected end|unsupported|invalid)/iu.test(message)
+            ? 1002
+            : 1011;
+    return { code, reason: truncateWebSocketCloseReason(message) };
+}
+function truncateWebSocketCloseReason(reason) {
+    let result = "";
+    for (const character of reason) {
+        if (Buffer.byteLength(result + character) > MAX_WHATSAPP_WEBSOCKET_CLOSE_REASON_BYTES) {
+            break;
+        }
+        result += character;
+    }
+    return result;
+}
 export function attachWhatsAppBaileysWebSocketServer(params) {
-    const signalBundles = new Map();
+    const signalBundles = new WhatsAppSignalBundleStore();
     const sessions = new Set();
-    const wss = new WebSocketServer({ noServer: true });
+    const pendingMessages = [];
+    const maxPendingInboundMessages = resolveMaxPendingWhatsAppInboundMessages(params.maxPendingInboundMessages);
+    let pendingReservations = 0;
+    let closing = false;
+    let flushPromise = Promise.resolve();
+    const webSocketServerOptions = {
+        maxBufferedChunks: MAX_WHATSAPP_WEBSOCKET_FRAGMENTS,
+        maxFragments: MAX_WHATSAPP_WEBSOCKET_FRAGMENTS,
+        maxPayload: MAX_WHATSAPP_WEBSOCKET_MESSAGE_BYTES,
+        noServer: true,
+    };
+    const wss = new WebSocketServer(webSocketServerOptions);
+    const flushPendingMessages = () => {
+        const next = flushPromise.then(async () => {
+            while (pendingMessages.length > 0) {
+                if (closing) {
+                    return;
+                }
+                const message = pendingMessages[0];
+                if (!message) {
+                    return;
+                }
+                const results = await Promise.all([...sessions].map((session) => session.deliverInboundMessage(message)));
+                if (!results.some(Boolean)) {
+                    return;
+                }
+                pendingMessages.shift();
+            }
+        });
+        flushPromise = next.catch(() => undefined);
+        return next;
+    };
+    const rejectUpgrade = (socket, response) => {
+        socket.end(response, () => socket.destroy());
+    };
     const handleUpgrade = (request, socket, head) => {
-        const url = new URL(request.url ?? "/", "http://127.0.0.1");
+        const url = parseWhatsAppWebSocketUpgradeUrl(request.url);
+        if (!url) {
+            rejectUpgrade(socket, "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+            return;
+        }
         if (url.pathname !== params.path) {
             socket.destroy();
             return;
         }
         if (url.searchParams.get("access_token") !== params.accessToken) {
-            socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
-            socket.destroy();
+            rejectUpgrade(socket, "HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
             return;
         }
         wss.handleUpgrade(request, socket, head, (ws) => {
@@ -420,40 +801,299 @@ export function attachWhatsAppBaileysWebSocketServer(params) {
     wss.on("connection", (socket) => {
         const session = new WhatsAppBaileysWebSocketSession(socket, {
             appendEvent: params.appendEvent,
+            onOpen: () => {
+                void flushPendingMessages();
+            },
             path: params.path,
             selfJid: params.selfJid,
             signalBundles,
         });
         sessions.add(session);
         socket.once("close", () => sessions.delete(session));
+        socket.on("error", () => {
+            sessions.delete(session);
+            socket.terminate();
+        });
         socket.on("message", (data) => session.handleMessage(data));
     });
     return {
         async close() {
+            closing = true;
             params.httpServer.off("upgrade", handleUpgrade);
-            for (const client of wss.clients) {
-                client.close();
-            }
-            await new Promise((resolve, reject) => {
-                wss.close((error) => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-                    resolve();
-                });
-            });
+            pendingMessages.length = 0;
+            await closeWebSocketServer(wss);
+            await flushPromise;
         },
-        deliverInboundMessage(message) {
-            for (const session of sessions) {
-                session.deliverInboundMessage(message);
+        prepareInboundMessage(message) {
+            if (pendingMessages.length + pendingReservations >= maxPendingInboundMessages) {
+                return undefined;
             }
+            let reserved = true;
+            let settled = false;
+            pendingReservations += 1;
+            const releaseReservation = () => {
+                if (reserved) {
+                    reserved = false;
+                    pendingReservations -= 1;
+                }
+            };
+            return {
+                cancel() {
+                    if (!settled) {
+                        settled = true;
+                        releaseReservation();
+                    }
+                },
+                async commit() {
+                    if (settled) {
+                        throw new Error("WhatsApp inbound delivery reservation is already settled.");
+                    }
+                    settled = true;
+                    try {
+                        releaseReservation();
+                        if (pendingMessages.length >= maxPendingInboundMessages) {
+                            throw new Error("WhatsApp inbound delivery reservation exceeded queue capacity.");
+                        }
+                        pendingMessages.push(message);
+                        await flushPendingMessages();
+                        return pendingMessages.includes(message) ? "queued" : "delivered";
+                    }
+                    finally {
+                        releaseReservation();
+                    }
+                },
+            };
         },
     };
 }
+export function parseWhatsAppWebSocketUpgradeUrl(requestTarget) {
+    try {
+        return new URL(requestTarget ?? "/", "http://127.0.0.1");
+    }
+    catch {
+        return undefined;
+    }
+}
+function rawDataByteLength(data) {
+    if (Array.isArray(data)) {
+        return data.reduce((total, chunk) => total + chunk.byteLength, 0);
+    }
+    return data.byteLength;
+}
+function rawDataToBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return Buffer.concat(data);
+    }
+    return Buffer.from(data);
+}
+function removeNoiseIntroHeader(chunk) {
+    if (chunk.subarray(0, NOISE_WA_HEADER.length).equals(NOISE_WA_HEADER)) {
+        return chunk.subarray(NOISE_WA_HEADER.length);
+    }
+    if (chunk.length >= 11 && chunk.subarray(0, 2).toString("utf8") === "ED" && chunk[3] === 1) {
+        const routingInfoPrefix = chunk[4];
+        if (routingInfoPrefix === undefined) {
+            throw new Error("Invalid Baileys Noise routing header.");
+        }
+        const routingInfoLength = (routingInfoPrefix << 16) | chunk.readUInt16BE(5);
+        const headerLength = 7 + routingInfoLength + NOISE_WA_HEADER.length;
+        if (chunk.subarray(headerLength - NOISE_WA_HEADER.length, headerLength).equals(NOISE_WA_HEADER)) {
+            return chunk.subarray(headerLength);
+        }
+    }
+    throw new Error("Invalid Baileys Noise intro header.");
+}
 function children(node) {
     return Array.isArray(node.content) ? node.content : [];
 }
+async function normalizeAcceptedBaileysMessage(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);
+    });
+    for (const candidate of candidates) {
+        try {
+            const decrypted = await params.signalBundles.decryptDirectMessage({
+                ciphertext: candidate.ciphertext,
+                recipientJid: candidate.recipientJid,
+                remoteJid: params.remoteJid,
+                type: candidate.type,
+            });
+            const text = decrypted ? readWhatsAppConversation(unpadRandomMax16(decrypted)) : undefined;
+            if (text) {
+                return {
+                    key: {
+                        fromMe: true,
+                        id: messageId,
+                        remoteJid: peer,
+                    },
+                    message: { conversation: text },
+                    messageTimestamp: Math.floor(Date.now() / 1000),
+                };
+            }
+        }
+        catch {
+            // Other participant envelopes may not belong to this mock server identity.
+        }
+    }
+    return undefined;
+}
+function encryptedMessageCandidates(node) {
+    const result = [];
+    const visit = (current, recipientJid) => {
+        const nextRecipient = current.tag === "to" ? current.attrs.jid : recipientJid;
+        if (current.tag === "enc" &&
+            nextRecipient &&
+            (current.attrs.type === "msg" || current.attrs.type === "pkmsg") &&
+            current.content instanceof Uint8Array) {
+            result.push({
+                ciphertext: current.content,
+                recipientJid: nextRecipient,
+                type: current.attrs.type,
+            });
+        }
+        for (const child of children(current)) {
+            visit(child, nextRecipient);
+        }
+    };
+    visit(node);
+    return result;
+}
+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]),
+    };
+}
+function cloneSignalSession(session) {
+    return SessionRecord.deserialize(session.serialize());
+}
+export function signalBundleIdentityKey(jid) {
+    return jid.replace(/:\d+(?=@)/u, "");
+}
+function signalProtocolAddress(jid) {
+    const match = /^(\d{7,15})(?::(\d+))?@(s\.whatsapp\.net|lid)$/iu.exec(jid);
+    if (!match) {
+        return undefined;
+    }
+    const deviceId = Number(match[2] ?? "0");
+    if (!Number.isSafeInteger(deviceId) || deviceId < 0) {
+        return undefined;
+    }
+    return {
+        deviceId,
+        name: match[3].toLowerCase() === "lid" ? `${match[1]}_1` : match[1],
+    };
+}
+function unpadRandomMax16(value) {
+    const buffer = Buffer.from(value);
+    const padding = buffer.at(-1);
+    if (!padding || padding > 16 || padding > buffer.length) {
+        throw new Error("Invalid WhatsApp message padding.");
+    }
+    for (let index = buffer.length - padding; index < buffer.length; index += 1) {
+        if (buffer[index] !== padding) {
+            throw new Error("Invalid WhatsApp message padding.");
+        }
+    }
+    return buffer.subarray(0, buffer.length - padding);
+}
+function readWhatsAppConversation(message) {
+    const fields = readProtobufLengthDelimitedFields(message);
+    const conversation = readUtf8(fields.get(1)?.[0]);
+    if (conversation?.trim()) {
+        return conversation;
+    }
+    const extendedText = fields.get(6)?.[0];
+    const extendedConversation = extendedText
+        ? readUtf8(readProtobufLengthDelimitedFields(extendedText).get(1)?.[0])
+        : undefined;
+    if (extendedConversation?.trim()) {
+        return extendedConversation;
+    }
+    const deviceSentMessage = fields.get(31)?.[0];
+    const nestedMessage = deviceSentMessage
+        ? readProtobufLengthDelimitedFields(deviceSentMessage).get(2)?.[0]
+        : undefined;
+    return nestedMessage ? readWhatsAppConversation(nestedMessage) : undefined;
+}
+function readProtobufLengthDelimitedFields(value) {
+    const fields = new Map();
+    let offset = 0;
+    while (offset < value.length) {
+        const tag = readProtobufVarint(value, offset);
+        offset = tag.offset;
+        const fieldNumber = tag.value >>> 3;
+        const wireType = tag.value & 7;
+        if (fieldNumber < 1) {
+            throw new Error("Invalid WhatsApp protobuf field.");
+        }
+        if (wireType === 2) {
+            const length = readProtobufVarint(value, offset);
+            offset = length.offset;
+            const end = offset + length.value;
+            if (end > value.length) {
+                throw new Error("Invalid WhatsApp protobuf length.");
+            }
+            const entries = fields.get(fieldNumber) ?? [];
+            entries.push(value.subarray(offset, end));
+            fields.set(fieldNumber, entries);
+            offset = end;
+            continue;
+        }
+        if (wireType === 0) {
+            offset = readProtobufVarint(value, offset).offset;
+            continue;
+        }
+        if (wireType === 1) {
+            offset += 8;
+            continue;
+        }
+        if (wireType === 5) {
+            offset += 4;
+            continue;
+        }
+        throw new Error(`Unsupported WhatsApp protobuf wire type: ${wireType}.`);
+    }
+    return fields;
+}
+function readProtobufVarint(value, start) {
+    let result = 0;
+    let shift = 0;
+    let offset = start;
+    while (offset < value.length && shift <= 28) {
+        const byte = value[offset++];
+        result += (byte & 0x7f) * 2 ** shift;
+        if ((byte & 0x80) === 0) {
+            if (!Number.isSafeInteger(result)) {
+                break;
+            }
+            return { offset, value: result };
+        }
+        shift += 7;
+    }
+    throw new Error("Invalid WhatsApp protobuf varint.");
+}
+function readUtf8(value) {
+    if (!value) {
+        return undefined;
+    }
+    const text = Buffer.from(value).toString("utf8");
+    return Buffer.from(text, "utf8").equals(Buffer.from(value)) ? text : undefined;
+}
 function createInboundMessageNode(message) {
     const from = message.key.remoteJid;
     const attrs = {
@@ -521,22 +1161,6 @@ function lidForJid(jid) {
     const user = jid.split("@", 1)[0]?.split(":", 1)[0] ?? "15550000000";
     return `${user}@lid`;
 }
-function resolveSignalBundle(signalBundles, jid) {
-    const existing = signalBundles.get(jid);
-    if (existing) {
-        return existing;
-    }
-    const identityKey = Curve.generateKeyPair();
-    const bundle = {
-        identityKey,
-        preKey: Curve.generateKeyPair(),
-        preKeyId: 1,
-        registrationId: 1,
-        signedPreKey: signedKeyPair(identityKey, 1),
-    };
-    signalBundles.set(jid, bundle);
-    return bundle;
-}
 function sanitizeNodeForJson(value) {
     if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
         return { base64: Buffer.from(value).toString("base64"), type: "Buffer" };