@oxidezap/baileyrs 0.0.26 → 0.0.28

package/lib/Socket/index.js

@@ -1,26 +1,39 @@
 import { Buffer } from 'node:buffer';
 import { randomBytes } from 'node:crypto';
-import { EventEmitter } from 'node:events';
 import { createWhatsAppClient, encodeProto, initWasmEngine } from 'whatsapp-rust-bridge';
-import { DEFAULT_CONNECTION_CONFIG } from "../Defaults/index.js";
-import { DisconnectReason } from "../Types/index.js";
-import { Boom } from "../Utils/boom.js";
-import { makeEventBuffer } from "../Utils/event-buffer.js";
-import { _registerActiveBridgeClient, downloadMediaMessage } from "../Utils/messages.js";
-import { makeNativeCryptoProvider } from "../Utils/native-crypto-provider.js";
-import { wrapLegacyStore } from "../Utils/wrap-legacy-store.js";
-import { assertNodeErrorFree } from "../WABinary/generic-utils.js";
-import { makeBlockingMethods } from "./blocking.js";
-import { makeChatActionMethods } from "./chat-actions.js";
-import { makeContactMethods } from "./contacts.js";
-import { makeEventHandler } from "./events.js";
-import { makeGroupMethods } from "./groups.js";
-import { makeMessageMethods } from "./messages.js";
-import { makeNewsletterMethods } from "./newsletter.js";
-import { makePresenceMethods } from "./presence.js";
-import { makeProfileMethods } from "./profile.js";
-import { mapReachoutTimelock } from "./reachout.js";
-import { makeHttpClient, makeTransport } from "./transport.js";
+import { normalizeSocketAuthenticationState } from '../Compatibility/internal/auth-state.js';
+import { makeMutex } from '../Compatibility/internal/make-mutex.js';
+import { isNativeMemoryStore } from '../Compatibility/internal/native-memory-store.js';
+import { makeLazyTransactionKeyStore } from '../Compatibility/internal/signal-key-store.js';
+import { toBridgeMediaType } from '../Compatibility/media-type.js';
+import { bindSignalRepositoryContext, makeDefaultSignalRepository } from '../Compatibility/signal-repository.js';
+import { bridgeBusinessProfileToBaileys } from '../Compatibility/socket-results.js';
+import { makeStanzaResponseMethods } from '../Compatibility/stanza-responses.js';
+import { makeParticipatingRefreshHandler } from '../Compatibility/participating-refresh.js';
+import { makeTaggedMessageWaiter } from '../Compatibility/tagged-message-waiter.js';
+import { isRawNodeForwardingEnabled, WebSocketClient } from '../Compatibility/websocket-client.js';
+import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
+import { DisconnectReason } from '../Types/index.js';
+import { Boom } from '../Utils/boom.js';
+import { makeEventBuffer } from '../Utils/event-buffer.js';
+import { _registerActiveBridgeClient, downloadMediaMessage } from '../Utils/messages.js';
+import { makeNativeCryptoProvider } from '../Utils/native-crypto-provider.js';
+import { wrapLegacyStore } from '../Utils/wrap-legacy-store.js';
+import { assertNodeErrorFree } from '../WABinary/generic-utils.js';
+import { makeBlockingMethods } from './blocking.js';
+import { makeChatActionMethods } from './chat-actions.js';
+import { makeContactMethods } from './contacts.js';
+import { makeCommunityMethods } from './communities.js';
+import { makeEventHandlers } from './events.js';
+import { makeGroupMethods } from './groups.js';
+import { makeMessageMethods } from './messages.js';
+import { makeNewsletterMethods } from './newsletter.js';
+import { makePreKeyMethods } from './prekeys.js';
+import { makePresenceMethods } from './presence.js';
+import { makeProfileMethods } from './profile.js';
+import { mapReachoutTimelock } from './reachout.js';
+import { makeHttpClient, makeTransport } from './transport.js';
+import { makeUSyncMethods } from './usync.js';
 let wasmInitialized = false;
 /**
  * Default mapping for the legacy `browser[1]` slot — preserved so users on the
@@ -48,207 +61,21 @@ const browserToPlatformType = (browser) => {
             return 'CHROME';
     }
 };
-/**
- * Returns a no-op `SignalKeyStore`-shaped facade. baileyrs hands this out from
- * `sock.authState.keys` when no legacy `auth.keys` was provided so that
- * upstream-Baileys code paths (typically post-error cleanup like
- * `keys.set({ 'sender-key': { [groupId]: null } })`) don't crash on a missing
- * `.set` method. The Rust bridge owns the real Signal state — this facade is
- * deliberately inert; reads come back empty and writes are dropped after a
- * `debug` log so the call site stays traceable.
- */
-function noopKeyStore(logger) {
-    return {
-        get: async () => ({}),
-        set: async (data) => {
-            const types = Object.keys(data).filter(k => data[k]);
-            if (types.length) {
-                logger.debug({ types }, 'authState.keys.set called — bridge owns Signal state, dropping no-op');
-            }
-        },
-        clear: async () => {
-            logger.debug('authState.keys.clear called — no-op (bridge state is not cleared from JS)');
-        }
-    };
-}
-/** Build the signalRepository object that delegates to the bridge */
-function makeSignalRepository(ctx) {
-    return {
-        decryptMessage: async (opts) => {
-            return (await ctx.getClient()).signalDecryptMessage(opts.jid, opts.type, opts.ciphertext);
-        },
-        encryptMessage: async (opts) => {
-            return (await ctx.getClient()).signalEncryptMessage(opts.jid, opts.data);
-        },
-        decryptGroupMessage: async (opts) => {
-            return (await ctx.getClient()).signalDecryptGroupMessage(opts.group, opts.authorJid, opts.msg);
-        },
-        encryptGroupMessage: async (opts) => {
-            return (await ctx.getClient()).signalEncryptGroupMessage(opts.group, opts.data, opts.meId);
-        },
-        processSenderKeyDistributionMessage: async () => { },
-        injectE2ESession: async () => { },
-        validateSession: async (jid) => {
-            const exists = await (await ctx.getClient()).signalValidateSession(jid);
-            return { exists };
-        },
-        jidToSignalProtocolAddress: (jid) => {
-            try {
-                return ctx.getClientSync().jidToSignalProtocolAddress(jid);
-            }
-            catch {
-                return `${jid}.0`;
-            }
-        },
-        migrateSession: async () => {
-            return { migrated: 0, skipped: 0, total: 0 };
-        },
-        deleteSession: async (jids) => {
-            return (await ctx.getClient()).signalDeleteSessions(jids);
-        },
-        /**
-         * Bidirectional LID ↔ PN lookup. Mirrors the upstream Baileys
-         * `signalRepository.lidMapping` API.
-         *
-         * Pure passthrough to the bridge — `client.lidForPn` / `client.pnForLid`
-         * delegate to the core's `get_lid_pn_entry`, which is cache-aside as
-         * of whatsapp-rust PR #565: hits the in-memory `lid_pn_cache` first
-         * and falls through to `backend.get_pn_mapping` / `get_lid_mapping`
-         * (so JsStoreCallbacks-backed sessions resolve every persisted
-         * mapping without warm-up needing a list primitive).
-         */
-        lidMapping: {
-            getLIDForPN: async (pn) => {
-                const client = await ctx.getClient();
-                return (await client.lidForPn(pn)) ?? null;
-            },
-            getPNForLID: async (lid) => {
-                const client = await ctx.getClient();
-                return (await client.pnForLid(lid)) ?? null;
-            },
-            /**
-             * Batch variant of `getLIDForPN`. Upstream Baileys' equivalent
-             * coalesces in-flight requests and de-duplicates inputs; we run
-             * the lookups in parallel and return the same `LIDMapping[]`
-             * shape so callers (e.g. `process-message.ts`) keep working.
-             *
-             * Uses `Promise.allSettled` so one bridge-side failure (e.g.
-             * malformed JID, transient cache miss) doesn't reject the
-             * whole batch and lose every successful lookup. Failures are
-             * logged at debug and skipped.
-             *
-             * Returns `null` (not `[]`) when the input list is empty, to
-             * mirror upstream's "absent" sentinel.
-             */
-            getLIDsForPNs: async (pns) => {
-                if (pns.length === 0)
-                    return null;
-                const client = await ctx.getClient();
-                const unique = [...new Set(pns)];
-                const settled = await Promise.allSettled(unique.map(async (pn) => {
-                    const lid = (await client.lidForPn(pn)) ?? null;
-                    return lid ? { pn, lid } : null;
-                }));
-                const resolved = [];
-                for (const r of settled) {
-                    if (r.status === 'fulfilled') {
-                        if (r.value)
-                            resolved.push(r.value);
-                    }
-                    else {
-                        ctx.logger.debug({ err: r.reason }, 'getLIDsForPNs: lookup rejected — skipping');
-                    }
-                }
-                return resolved;
-            },
-            getPNsForLIDs: async (lids) => {
-                if (lids.length === 0)
-                    return null;
-                const client = await ctx.getClient();
-                const unique = [...new Set(lids)];
-                const settled = await Promise.allSettled(unique.map(async (lid) => {
-                    const pn = (await client.pnForLid(lid)) ?? null;
-                    return pn ? { pn, lid } : null;
-                }));
-                const resolved = [];
-                for (const r of settled) {
-                    if (r.status === 'fulfilled') {
-                        if (r.value)
-                            resolved.push(r.value);
-                    }
-                    else {
-                        ctx.logger.debug({ err: r.reason }, 'getPNsForLIDs: lookup rejected — skipping');
-                    }
-                }
-                return resolved;
-            },
-            /**
-             * No-op shim. The Rust bridge auto-learns LID↔PN mappings inside
-             * `decode_message` / `usync` and persists them through
-             * `JsStoreCallbacks` — upstream Baileys callers (notably
-             * `process-message.ts` re-feeding mappings from `historySync`)
-             * keep type-checking, but we don't need to write back.
-             *
-             * Logs at debug so unexpected paths stay traceable.
-             */
-            storeLIDPNMappings: async (pairs) => {
-                if (pairs.length === 0)
-                    return;
-                ctx.logger.debug({ count: pairs.length }, 'lidMapping.storeLIDPNMappings — bridge auto-learns, no-op');
-            }
-        }
-    };
-}
 /** Build the ws EventEmitter with auto-enable raw node forwarding */
-function makeWsEmitter(getClient) {
-    const ws = new EventEmitter();
-    let rawNodeEnabled = false;
-    const originalOn = ws.on.bind(ws);
-    ws.on = (event, listener) => {
-        if (typeof event === 'string' && event.startsWith('CB:') && !rawNodeEnabled) {
-            rawNodeEnabled = true;
-            try {
-                getClient()?.setRawNodeForwarding(true);
-            }
-            catch {
-                // bridge not ready yet — will enable when it initializes
-            }
-        }
-        return originalOn(event, listener);
-    };
-    Object.defineProperty(ws, 'isOpen', {
-        get: () => getClient()?.isConnected() ?? false,
-        enumerable: true
-    });
-    // Upstream Baileys exposes `sock.ws.socket.readyState` (the underlying
-    // WebSocket's standard property) and a lot of bots — keep-alive timers,
-    // reconnect heuristics, "is the link up?" checks — read it directly.
-    // baileyrs has no JS-side WebSocket (the noise socket lives inside the
-    // Rust core), but the only thing those callers care about is the same
-    // two-value answer the standard WebSocket constants encode:
-    //   1 = OPEN, 3 = CLOSED — same numeric values WHATWG defines.
-    // Anything other than 1 means "not usable", so collapsing the
-    // CONNECTING/CLOSING transitional states to CLOSED preserves the
-    // branching every realistic caller does (`readyState === 1`).
-    const socketShim = {};
-    Object.defineProperty(socketShim, 'readyState', {
-        get: () => (getClient()?.isConnected() ? 1 : 3),
-        enumerable: true
-    });
-    Object.defineProperty(ws, 'socket', {
-        value: socketShim,
-        enumerable: true,
-        configurable: true
-    });
-    return { ws, isRawNodeEnabled: () => rawNodeEnabled };
-}
 const makeWASocket = (config) => {
     const fullConfig = { ...DEFAULT_CONNECTION_CONFIG, ...config };
-    const { auth, logger } = fullConfig;
-    const ev = makeEventBuffer();
+    const { logger } = fullConfig;
+    const auth = normalizeSocketAuthenticationState(fullConfig.auth);
+    const getExposedKeys = makeLazyTransactionKeyStore(auth.keys, logger, fullConfig.transactionOpts);
+    const ev = makeEventBuffer(logger);
+    // Upstream mutates authState.creds before notifying user listeners. Register
+    // this first so `ev.on('creds.update', saveCreds)` persists the merged state
+    // rather than the pre-pair placeholder.
+    ev.on('creds.update', update => Object.assign(auth.creds, update));
     let client;
+    let readyClient;
     let user;
-    const { ws, isRawNodeEnabled } = makeWsEmitter(() => client);
+    const ws = new WebSocketClient(fullConfig.waWebSocketUrl, fullConfig, () => client);
     let tagEpoch = 0;
     // Per-socket random prefix avoids collisions between sockets created
     // in the same millisecond. Date.now()-based prefixes (the previous
@@ -270,17 +97,27 @@ const makeWASocket = (config) => {
         fullConfig,
         ws,
         getUser: () => user,
+        getMe: () => {
+            const me = auth.creds.me;
+            const id = user?.id ?? me?.id;
+            if (!id)
+                return undefined;
+            return { ...me, id, ...(user?.lid ? { lid: user.lid } : {}) };
+        },
         setUser: u => {
             user = u;
         },
-        getClient: async () => {
-            await initPromise;
-            if (initError) {
-                throw new Boom('Bridge client failed to initialize: ' + initError.message, { statusCode: 500 });
-            }
-            if (!client)
-                throw new Boom('Client not initialized', { statusCode: 500 });
-            return client;
+        getClient: () => {
+            if (readyClient)
+                return readyClient;
+            return initPromise.then(() => {
+                if (initError) {
+                    throw new Boom('Bridge client failed to initialize: ' + initError.message, { statusCode: 500 });
+                }
+                if (!client)
+                    throw new Boom('Client not initialized', { statusCode: 500 });
+                return client;
+            });
         },
         getClientSync: () => {
             if (!client)
@@ -288,7 +125,28 @@ const makeWASocket = (config) => {
             return client;
         }
     };
-    const handleEvent = makeEventHandler(ctx, {
+    // The native repository delegates Signal state directly to the core and does
+    // not need the standalone transaction facade. Keep that facade lazy for the
+    // public authState and custom repository contracts that can observe it.
+    const signalAuthState = {
+        creds: auth.creds,
+        keys: fullConfig.makeSignalRepository === makeDefaultSignalRepository ? auth.keys : getExposedKeys()
+    };
+    bindSignalRepositoryContext(signalAuthState, ctx);
+    const signalRepository = fullConfig.makeSignalRepository(signalAuthState, logger);
+    const devicesMutex = makeMutex();
+    const messageMutex = makeMutex();
+    const receiptMutex = makeMutex();
+    const appStatePatchMutex = makeMutex();
+    const notificationMutex = makeMutex();
+    const activeCallContexts = new Map();
+    const groupMethods = makeGroupMethods(ctx);
+    const communityMethods = makeCommunityMethods(ctx, groupMethods);
+    const refreshParticipating = makeParticipatingRefreshHandler(ctx, {
+        groupFetchAllParticipating: groupMethods.groupFetchAllParticipating,
+        communityFetchAllParticipating: communityMethods.communityFetchAllParticipating
+    });
+    const eventHandlers = makeEventHandlers(ctx, {
         onPairSuccess: data => {
             pairedAccount = data;
             client
@@ -297,7 +155,17 @@ const makeWASocket = (config) => {
                 cachedAccount = acc ?? undefined;
             })
                 .catch(() => { });
-        }
+        },
+        onIncomingCall: event => {
+            const { callId, callCreator, type } = event.action;
+            if (type === 'reject' || type === 'accept' || type === 'timeout' || type === 'terminate') {
+                activeCallContexts.delete(callId);
+            }
+            else if (callCreator) {
+                activeCallContexts.set(callId, { peer: event.from, callCreator });
+            }
+        },
+        onDirtyState: event => refreshParticipating(event.dirtyType)
     });
     const init = async () => {
         if (!wasmInitialized) {
@@ -315,15 +183,20 @@ const makeWASocket = (config) => {
         // got to enter, then crash when the next state ('open' / 'close')
         // references prerequisites that the missed event was supposed to set
         // up.
-        queueMicrotask(() => ev.emit('connection.update', { connection: 'connecting' }));
+        queueMicrotask(() => ev.emit('connection.update', {
+            connection: 'connecting',
+            receivedPendingNotifications: false,
+            qr: undefined
+        }));
         // Auto-promote upstream-Baileys-style `auth: { creds, keys }` to a
         // `JsStoreCallbacks`-shaped store via `wrapLegacyStore`. The synthetic
         // `saveCreds` callback re-emits `creds.update` so the bot's existing
         // `ev.on('creds.update', saveCreds)` listener handles persistence —
         // matches the lifecycle hook every upstream-Baileys setup already
         // wires, so migration needs zero changes to the auth block.
-        let bridgeStore = auth.store ?? null;
-        if (!bridgeStore && auth.creds && auth.keys) {
+        const useNativeMemory = auth.store ? isNativeMemoryStore(auth.store) : false;
+        let bridgeStore = useNativeMemory ? null : (auth.store ?? null);
+        if (!bridgeStore && !useNativeMemory && auth.creds && auth.keys) {
             const legacyState = { creds: auth.creds, keys: auth.keys };
             const wrapped = await wrapLegacyStore(legacyState, async () => {
                 ev.emit('creds.update', auth.creds);
@@ -336,7 +209,12 @@ const makeWASocket = (config) => {
             autoWrappedStore = wrapped;
             logger.debug('auth: auto-wrapped legacy {creds, keys} via wrapLegacyStore');
         }
-        client = await createWhatsAppClient(makeTransport(fullConfig), makeHttpClient(fullConfig), handleEvent, bridgeStore, fullConfig.cache ?? null, fullConfig.version);
+        if (useNativeMemory)
+            logger.debug('auth: using socket-local native memory backend');
+        client = await createWhatsAppClient(makeTransport(fullConfig), makeHttpClient(fullConfig), eventHandlers, bridgeStore, fullConfig.cache ?? null, fullConfig.version, fullConfig.wantedPreKeyCount ?? null);
+        if (fullConfig.pushName) {
+            await client.setInitialPushName(fullConfig.pushName);
+        }
         // Make this client the fallback for standalone helpers like
         // downloadContentFromMessage that have no socket reference.
         _registerActiveBridgeClient(client, logger);
@@ -364,7 +242,7 @@ const makeWASocket = (config) => {
         if (browserName === 'Android') {
             await client.setClientProfile({ preset: 'android', osVersion: osName });
         }
-        if (isRawNodeEnabled()) {
+        if (isRawNodeForwardingEnabled(ws)) {
             client.setRawNodeForwarding(true);
         }
         // `run()` is fire-and-forget by design (the bridge runs the read
@@ -393,20 +271,35 @@ const makeWASocket = (config) => {
         }
     };
     let initError;
-    const initPromise = init().catch(err => {
+    const initPromise = init()
+        .then(() => {
+        if (client)
+            readyClient = Promise.resolve(client);
+    })
+        .catch(err => {
         initError = err instanceof Error ? err : new Error(String(err));
         logger.error({ err }, 'failed to initialize bridge client');
     });
-    const end = async () => {
+    let ended = false;
+    const socketEndHandlers = [
+        () => activeCallContexts.clear()
+    ];
+    const end = async (error) => {
+        if (ended) {
+            logger.trace({ trace: error?.stack }, 'connection already closed');
+            return;
+        }
+        ended = true;
         const c = client;
-        client = undefined;
         if (c) {
             try {
-                await c.disconnect();
+                await ws.close();
             }
             catch {
                 /* ignore */
             }
+            client = undefined;
+            readyClient = undefined;
             // Barrier: bridge cleanup paths fired during `disconnect()` may
             // emit `set()` calls that are still queued as microtasks /
             // `setImmediate` callbacks at this point. Two yields to the
@@ -442,6 +335,14 @@ const makeWASocket = (config) => {
             if (firstFlushError)
                 throw firstFlushError;
         }
+        for (const handler of socketEndHandlers) {
+            try {
+                await handler(error);
+            }
+            catch (handlerError) {
+                logger.error({ err: handlerError }, 'error in socket end handler');
+            }
+        }
     };
     const logout = async (msg) => {
         user = undefined;
@@ -453,30 +354,49 @@ const makeWASocket = (config) => {
                 /* ignore */
             }
         }
+        const logoutError = new Boom(msg || 'Logged out', { statusCode: DisconnectReason.loggedOut });
         ev.emit('connection.update', {
             connection: 'close',
             lastDisconnect: {
-                error: new Boom(msg || 'Logged out', { statusCode: DisconnectReason.loggedOut }),
+                error: logoutError,
                 date: new Date()
             }
         });
-        await end();
+        await end(logoutError);
+    };
+    const registerSocketEndHandler = (handler) => {
+        socketEndHandlers.push(handler);
     };
     const waitForConnectionUpdate = (check, timeoutMs) => {
         return new Promise((resolve, reject) => {
             let timeout;
-            const listener = (update) => {
-                if (check(update)) {
-                    ev.off('connection.update', listener);
-                    if (timeout)
-                        clearTimeout(timeout);
+            const cleanup = () => {
+                ev.off('connection.update', listener);
+                if (timeout)
+                    clearTimeout(timeout);
+            };
+            const listener = async (update) => {
+                if (update.connection === 'close') {
+                    cleanup();
+                    reject(update.lastDisconnect?.error ??
+                        new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+                    return;
+                }
+                try {
+                    if (!(await check(update)))
+                        return;
+                    cleanup();
                     resolve();
                 }
+                catch (error) {
+                    cleanup();
+                    reject(error);
+                }
             };
             ev.on('connection.update', listener);
             if (timeoutMs) {
                 timeout = setTimeout(() => {
-                    ev.off('connection.update', listener);
+                    cleanup();
                     reject(new Boom('Timed out waiting for connection update', { statusCode: 408 }));
                 }, timeoutMs);
                 // Don't keep the process alive if the caller has already stopped
@@ -485,6 +405,24 @@ const makeWASocket = (config) => {
             }
         });
     };
+    const fetchReachoutTimelock = async () => {
+        const payload = await (await ctx.getClient()).fetchReachoutTimelock();
+        const state = mapReachoutTimelock(payload) ?? { isActive: false };
+        ev.emit('connection.update', { reachoutTimeLock: state });
+        return state;
+    };
+    const query = async (node, timeoutMs) => {
+        if (!node.attrs.id)
+            node.attrs.id = generateMessageTag();
+        const result = (await (await ctx.getClient()).queryNode(node, timeoutMs));
+        assertNodeErrorFree(result);
+        return result;
+    };
+    const waitForMessage = makeTaggedMessageWaiter(ws, logger, fullConfig.defaultQueryTimeoutMs);
+    const usyncMethods = makeUSyncMethods({
+        queryNode: query,
+        queryUsync: async (typedQuery) => (await ctx.getClient()).queryUsync(typedQuery)
+    });
     const sock = {
         ev,
         logger,
@@ -520,22 +458,18 @@ const makeWASocket = (config) => {
             return {
                 creds: {
                     ...auth.creds,
-                    me: user ? { id: user.id, lid: user.lid } : undefined,
-                    account: cachedAccount,
-                    platform: pairedAccount?.platform
+                    ...(user ? { me: { ...auth.creds.me, id: user.id, lid: user.lid } } : {}),
+                    ...(cachedAccount ? { account: cachedAccount } : {}),
+                    ...(pairedAccount?.platform ? { platform: pairedAccount.platform } : {})
                 },
-                // `keys` is a no-op facade for upstream-Baileys code that pokes
-                // at the legacy SignalKeyStore (e.g. clearing sender-keys after a
-                // decrypt error: `keys.set({ 'sender-key': { [groupId]: null } })`).
-                // In baileyrs the bridge owns all Signal state, so writes here
-                // would silently no-op even if we delegated them — the real
-                // sender-key store is internal to Rust. We expose stable methods
-                // that don't crash, log at debug for traceability, and return
-                // empty results from `.get` so callers fall through to whatever
-                // regen path they already have.
-                keys: auth.keys ?? noopKeyStore(logger)
+                keys: getExposedKeys()
             };
         },
+        devicesMutex,
+        messageMutex,
+        receiptMutex,
+        appStatePatchMutex,
+        notificationMutex,
         generateMessageTag,
         sendNode: async (frame) => {
             return (await ctx.getClient()).sendNode(frame);
@@ -546,67 +480,8 @@ const makeWASocket = (config) => {
         getUSyncDevices: async (jids, useCache, ignoreZeroDevices) => {
             return (await ctx.getClient()).getUSyncDevices(jids, useCache, ignoreZeroDevices);
         },
-        waitForMessage: (msgId, timeoutMs) => {
-            return new Promise((resolve, reject) => {
-                const timeout = timeoutMs ?? fullConfig.defaultQueryTimeoutMs;
-                let timer;
-                const tag = `TAG:${msgId}`;
-                // Use `on`+explicit `off` instead of `once`. Two callers
-                // awaiting the same id (rare but legal — can happen when an
-                // id is reused for retries, or when both an `<ack>` and an
-                // `<iq result>` carry the same id) would otherwise have the
-                // second listener silently consumed by the first emit.
-                const onRecv = (data) => {
-                    if (timer)
-                        clearTimeout(timer);
-                    ws.off(tag, listener);
-                    resolve(data);
-                };
-                const listener = onRecv;
-                ws.on(tag, listener);
-                if (timeout) {
-                    timer = setTimeout(() => {
-                        ws.off(tag, listener);
-                        reject(new Boom('Timed out waiting for message', { statusCode: DisconnectReason.timedOut }));
-                    }, timeout);
-                    // Query timers shouldn't keep the process alive past sock.end()
-                    // if the caller has given up — same pattern as use-bridge-store.
-                    timer.unref();
-                }
-            });
-        },
-        query: async (node, timeoutMs) => {
-            if (!node.attrs.id) {
-                node.attrs.id = generateMessageTag();
-            }
-            const msgId = node.attrs.id;
-            const tag = `TAG:${msgId}`;
-            // Snapshot the listeners on this tag BEFORE attaching ours so a
-            // sendNode failure can remove only what we added — never another
-            // caller's listener. `removeAllListeners(tag)` was the prior
-            // behavior; it could nuke a parallel `waitForMessage` belonging
-            // to a different consumer.
-            const before = ws.listeners(tag);
-            const resultPromise = sock.waitForMessage(msgId, timeoutMs);
-            try {
-                await sock.sendNode(node);
-            }
-            catch (err) {
-                const ours = ws.listeners(tag).filter(l => !before.includes(l));
-                for (const l of ours)
-                    ws.off(tag, l);
-                throw err;
-            }
-            const result = await resultPromise;
-            // Mirror upstream `Socket/socket.ts:217-220`: a stanza with an
-            // `<error>` child is a server-rejection. Throw a Boom carrying
-            // the error code so consumers branching on
-            // `lastDisconnect.error.statusCode` / `.data` can react. Without
-            // this, code expecting upstream semantics treats a 403 / 405
-            // error response as success and reads garbage attrs.
-            assertNodeErrorFree(result);
-            return result;
-        },
+        waitForMessage,
+        query,
         sendRawMessage: async (data) => {
             return (await ctx.getClient()).sendRawMessage(data instanceof Uint8Array ? data : new Uint8Array(data));
         },
@@ -614,13 +489,11 @@ const makeWASocket = (config) => {
             const bytes = encodeProto('Message', message);
             return (await ctx.getClient()).createParticipantNodesBytes(jids, bytes, extraAttrs ?? {});
         },
-        signalRepository: makeSignalRepository(ctx),
-        /** @deprecated Pre-key management is handled by the Rust bridge. */
-        uploadPreKeys: async () => { },
-        /** @deprecated Pre-key management is handled by the Rust bridge. */
-        uploadPreKeysToServerIfRequired: async () => { },
+        signalRepository,
+        ...makePreKeyMethods(ctx),
         end,
         logout,
+        registerSocketEndHandler,
         waitForConnectionUpdate,
         setAutoReconnect: (enabled) => {
             client?.setAutoReconnect(enabled);
@@ -632,15 +505,15 @@ const makeWASocket = (config) => {
          * caller hears about the protocol mistake instead of the bridge silently
          * sending nothing.
          */
-        sendPresenceUpdate: async (presence, toJid) => {
+        sendPresenceUpdate: async (type, toJid) => {
             const c = await ctx.getClient();
-            if (presence === 'available' || presence === 'unavailable') {
-                return c.sendPresence(presence);
+            if (type === 'available' || type === 'unavailable') {
+                return c.sendPresence(type);
             }
             if (!toJid) {
-                throw new Boom(`sendPresenceUpdate('${presence}') requires a target jid`, { statusCode: 400 });
+                throw new Boom(`sendPresenceUpdate('${type}') requires a target jid`, { statusCode: 400 });
             }
-            return c.sendChatState(toJid, presence);
+            return c.sendChatState(toJid, type);
         },
         /**
          * Plaintext media upload helper, source-compatible with the upstream
@@ -650,9 +523,10 @@ const makeWASocket = (config) => {
          */
         waUploadToServer: async (data, opts) => {
             const bytes = data instanceof Uint8Array && !Buffer.isBuffer(data) ? data : new Uint8Array(data);
-            return (await ctx.getClient()).uploadMedia(bytes, opts.mediaType);
+            return (await ctx.getClient()).uploadMedia(bytes, toBridgeMediaType(opts.mediaType));
         },
-        fetchPrivacySettings: async () => {
+        fetchPrivacySettings: async (force) => {
+            void force;
             return (await ctx.getClient()).fetchPrivacySettings();
         },
         updatePrivacySetting: async (category, value) => {
@@ -680,10 +554,9 @@ const makeWASocket = (config) => {
             await (await ctx.getClient()).updateDefaultDisappearingMode(duration);
         },
         rejectCall: async (callId, callFrom) => {
-            await (await ctx.getClient()).rejectCall(callId, callFrom);
-        },
-        fetchStatus: async (...jids) => {
-            return (await ctx.getClient()).fetchStatus(jids);
+            const context = activeCallContexts.get(callId);
+            await (await ctx.getClient()).rejectCall(callId, context?.peer ?? callFrom, context?.callCreator ?? callFrom);
+            activeCallContexts.delete(callId);
         },
         /**
          * Fetch the account's current reachout-timelock state from the server.
@@ -698,30 +571,27 @@ const makeWASocket = (config) => {
          * effect for parity with the push path. Returns the same state for
          * callers that prefer awaiting.
          */
-        fetchReachoutTimelock: async () => {
-            const payload = await (await ctx.getClient()).fetchReachoutTimelock();
-            const state = mapReachoutTimelock(payload) ?? { isActive: false };
-            ev.emit('connection.update', { reachoutTimeLock: state });
-            return state;
-        },
+        fetchReachoutTimelock,
+        /** Upstream Baileys-compatible name. */
+        fetchAccountReachoutTimelock: fetchReachoutTimelock,
         getBusinessProfile: async (jid) => {
-            return (await ctx.getClient()).getBusinessProfile(jid);
+            return bridgeBusinessProfileToBaileys(await (await ctx.getClient()).getBusinessProfile(jid));
         },
         fetchMessageHistory: async (count, oldestMsgKey, oldestMsgTimestamp) => {
-            return (await ctx.getClient()).fetchMessageHistory(count, oldestMsgKey.remoteJid || '', oldestMsgKey.id || '', oldestMsgKey.fromMe || false, oldestMsgTimestamp);
-        },
-        groupMemberAddMode: async (jid, mode) => {
-            await (await ctx.getClient()).groupMemberAddMode(jid, mode);
+            return (await ctx.getClient()).fetchMessageHistory(count, oldestMsgKey.remoteJid || '', oldestMsgKey.id || '', oldestMsgKey.fromMe || false, typeof oldestMsgTimestamp === 'number' ? oldestMsgTimestamp : oldestMsgTimestamp.toNumber());
         },
         sendStatusMessage: async (message, recipients) => {
             const bytes = encodeProto('Message', message);
             return (await ctx.getClient()).sendStatusMessageBytes(bytes, recipients);
         },
         ...makeMessageMethods(ctx),
-        ...makeGroupMethods(ctx),
+        ...groupMethods,
+        ...communityMethods,
         ...makeContactMethods(ctx),
         ...makeProfileMethods(ctx),
         ...makeChatActionMethods(ctx),
+        ...usyncMethods,
+        ...makeStanzaResponseMethods(ctx),
         ...makePresenceMethods(ctx),
         ...makeBlockingMethods(ctx),
         ...makeNewsletterMethods(ctx),