@japofc/baileys 2.1.0

package/lib/Defaults/index.d.ts

@@ -0,0 +1,154 @@
+export const UNAUTHORIZED_CODES: number[];
+export const BIZ_BOT_SUPPORT_PAYLOAD: "{\"version\":1,\"is_ai_message\":true,\"should_upload_client_logs\":false,\"should_show_system_message\":false,\"ticket_id\":\"7004947587700716\",\"citation_items\":[],\"ticket_locale\":\"us\"}";
+export const DEFAULT_ORIGIN: "https://web.whatsapp.com";
+export const CALL_VIDEO_PREFIX: "https://call.whatsapp.com/video/";
+export const CALL_AUDIO_PREFIX: "https://call.whatsapp.com/voice/";
+export const DONATE_URL: "";
+export const LIBRARY_NAME: "japofc/baileys";
+export const COMPANION_DEVICE_VERSION: {
+    primary: number;
+    secondary: number;
+    tertiary: number;
+};
+export const DEF_CALLBACK_PREFIX: "CB:";
+export const DEF_TAG_PREFIX: "TAG:";
+export const PHONE_CONNECTION_CB: "CB:Pong";
+export const WA_ADV_ACCOUNT_SIG_PREFIX: any;
+export const WA_ADV_DEVICE_SIG_PREFIX: any;
+export const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX: any;
+export const WA_ADV_HOSTED_DEVICE_SIG_PREFIX: any;
+export const WA_DEFAULT_EPHEMERAL: number;
+/** Status messages older than 24 hours are considered expired */
+export const STATUS_EXPIRY_SECONDS: number;
+/** WA Web enforces a 14-day maximum age for placeholder resend requests */
+export const PLACEHOLDER_MAX_AGE_SECONDS: number;
+export const NOISE_MODE: "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+export const DICT_VERSION: 3;
+export const KEY_BUNDLE_TYPE: any;
+export const NOISE_WA_HEADER: any;
+export const LEXER_REGEX: RegExp;
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export const URL_REGEX: RegExp;
+export namespace WA_CERT_DETAILS {
+    let SERIAL: number;
+    let ISSUER: string;
+    let PUBLIC_KEY: any;
+}
+export const PROCESSABLE_HISTORY_TYPES: any[];
+export namespace DEFAULT_CACHE_TTLS {
+    let SIGNAL_STORE: number;
+    let MSG_RETRY: number;
+    let CALL_OFFER: number;
+    let USER_DEVICES: number;
+}
+export namespace DEFAULT_CONNECTION_CONFIG {
+    export { version };
+    export let browser: any[];
+    export let waWebSocketUrl: string;
+    export let connectTimeoutMs: number;
+    export let keepAliveIntervalMs: number;
+    export let logger: any;
+    export let emitOwnEvents: boolean;
+    export let defaultQueryTimeoutMs: number;
+    export let customUploadHosts: never[];
+    export let retryRequestDelayMs: number;
+    export let maxMsgRetryCount: number;
+    export let fireInitQueries: boolean;
+    export let auth: undefined;
+    export let markOnlineOnConnect: boolean;
+    export let syncFullHistory: boolean;
+    export function patchMessageBeforeSending(msg: any): any;
+    export function shouldSyncHistoryMessage({ syncType }: {
+        syncType: any;
+    }): boolean;
+    export function shouldIgnoreJid(): boolean;
+    export let linkPreviewImageThumbnailWidth: number;
+    export namespace transactionOpts {
+        let maxCommitRetries: number;
+        let delayBetweenTriesMs: number;
+    }
+    export let eventBufferTimeoutMs: number;
+    export let statusBroadcastDelayMs: number;
+    export let albumDelayMs: number;
+    export let phashRetryEnabled: boolean;
+    export let generateHighQualityLinkPreview: boolean;
+    export let enableAutoSessionRecreation: boolean;
+    export let enableRecentMessageCache: boolean;
+    export let options: {};
+    export namespace appStateMacVerification {
+        let patch: boolean;
+        let snapshot: boolean;
+    }
+    export let countryCode: string;
+    export function getMessage(): Promise<undefined>;
+    export function cachedGroupMetadata(): Promise<undefined>;
+    export { makeLibSignalRepository as makeSignalRepository };
+}
+export const MEDIA_PATH_MAP: {
+    image: string;
+    video: string;
+    document: string;
+    audio: string;
+    sticker: string;
+    'sticker-pack': string;
+    'thumbnail-sticker-pack': string;
+    'thumbnail-link': string;
+    'thumbnail-image': string;
+    'thumbnail-video': string;
+    'thumbnail-document': string;
+    'product-catalog-image': string;
+    'md-app-state': string;
+    'md-msg-hist': string;
+    'biz-cover-photo': string;
+};
+export const NEWSLETTER_MEDIA_PATH_MAP: {
+    image: string;
+    video: string;
+    document: string;
+    audio: string;
+    sticker: string;
+    'thumbnail-link': string;
+};
+export const MEDIA_HKDF_KEY_MAPPING: {
+    audio: string;
+    document: string;
+    gif: string;
+    image: string;
+    ppic: string;
+    product: string;
+    ptt: string;
+    'sticker-pack': string;
+    'thumbnail-sticker-pack': string;
+    sticker: string;
+    video: string;
+    'thumbnail-document': string;
+    'thumbnail-image': string;
+    'thumbnail-video': string;
+    'thumbnail-link': string;
+    'md-msg-hist': string;
+    'md-app-state': string;
+    'product-catalog-image': string;
+    'payment-bg-image': string;
+    ptv: string;
+    'biz-cover-photo': string;
+    location: string;
+    contact: string;
+    'voip-token': string;
+};
+export const MEDIA_KEYS: string[];
+/** 120s timeout for history sync stall detection, same as WA Web's handleChunkProgress / restartPausedTimer (g = 120) */
+export const HISTORY_SYNC_PAUSED_TIMEOUT_MS: 120000;
+export const MIN_PREKEY_COUNT: 5;
+export const INITIAL_PREKEY_COUNT: 812;
+export const UPLOAD_TIMEOUT: 30000;
+export namespace TimeMs {
+    let Minute: number;
+    let Hour: number;
+    let Day: number;
+    let Week: number;
+}
+declare const version: number[];
+import { makeLibSignalRepository } from '../Signal/libsignal.js';
+export {};
+/** Media direction/type tag used across media helpers (typed loosely). */
+export type MediaType = any;

package/lib/Defaults/index.js

@@ -0,0 +1,178 @@
+import { proto } from '../../WAProto/index.js';
+import { makeLibSignalRepository } from '../Signal/libsignal.js';
+import { Browsers } from '../Utils/browser-utils.js';
+import logger from '../Utils/logger.js';
+// JAP@Fix: disamain sama baseline yang dipake pas diff WAProto (lihat
+// WAProto/CHANGELOG-proto-upgrade.md — sempet lebih baru dari fallback
+// lama, jadi socket ngaku versi lebih tua dari field yang udah didukung
+// proto-nya sendiri). Ini cuma fallback kalau fetchLatestBaileysVersion()
+// gagal total (mis. GitHub gak bisa diakses) — tetap worth di-update
+// berkala, dan runtime tetap disaranin pake fetchLatestWaWebVersion()
+// dulu (parse sw.js langsung) baru fallback ke fetchLatestBaileysVersion()
+// / konstanta ini, karena fetchLatestBaileysVersion resmi Baileys ada
+// history bug isLatest:true padahal versinya stale (upstream#2679).
+const version = [2, 3000, 1046350168];
+// JAP@Fix (bug 65): this was an untracked, uncommented magic number inline
+// inside generateRegistrationNode() in validate-connection.js — a *second*,
+// independent hardcoded version (WA's "companion/device-props" version sent
+// during device pairing, distinct from `version` above which is the WA Web
+// client version used for appVersion/buildHash). It can go stale the exact
+// same way `version` can (same failure mode as upstream#2370/#2485),
+// but unlike `version`, it isn't covered by fetchLatestWaWebVersion(),
+// fetchLatestBaileysVersion(), or fetchBestWaVersion() — none of those touch
+// it, so it was silently unmaintained. Named + documented here so it's at
+// least visible and update-able; still worth bumping periodically by hand.
+export const COMPANION_DEVICE_VERSION = { primary: 10, secondary: 15, tertiary: 7 };
+export const UNAUTHORIZED_CODES = [401, 403, 419];
+export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
+export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
+export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
+export const CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
+export const DONATE_URL = ''; // JAP@Fix: cleared the donate URL fallback
+export const LIBRARY_NAME = 'japofc/baileys';
+export const DEF_CALLBACK_PREFIX = 'CB:';
+export const DEF_TAG_PREFIX = 'TAG:';
+export const PHONE_CONNECTION_CB = 'CB:Pong';
+export const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+export const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+export const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+export const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
+export const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+/** Status messages older than 24 hours are considered expired */
+export const STATUS_EXPIRY_SECONDS = 24 * 60 * 60;
+/** WA Web enforces a 14-day maximum age for placeholder resend requests */
+export const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 24 * 60 * 60;
+export const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
+export const DICT_VERSION = 3;
+export const KEY_BUNDLE_TYPE = Buffer.from([5]);
+export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]); // last is "DICT_VERSION"
+export const LEXER_REGEX = /(\/\/.*|\/\*[\s\S]*?\*\/|#.*)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[\s\S]*?`)|(\b[a-zA-Z_]\w*\b)(?=\s*\()|(\b[a-zA-Z_]\w*\b)|(\b\d+(?:\.\d+)?\b)|(\s+|[^\w\s]+)/g;
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export const URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
+export const WA_CERT_DETAILS = {
+    SERIAL: 0,
+    ISSUER: 'WhatsAppLongTerm1',
+    PUBLIC_KEY: Buffer.from('142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b', 'hex')
+};
+export const PROCESSABLE_HISTORY_TYPES = [
+    proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
+    proto.HistorySync.HistorySyncType.PUSH_NAME,
+    proto.HistorySync.HistorySyncType.RECENT,
+    proto.HistorySync.HistorySyncType.FULL,
+    proto.HistorySync.HistorySyncType.ON_DEMAND,
+    proto.HistorySync.HistorySyncType.NON_BLOCKING_DATA,
+    proto.HistorySync.HistorySyncType.INITIAL_STATUS_V3
+];
+export const DEFAULT_CACHE_TTLS = {
+    SIGNAL_STORE: 5 * 60, // 5 minutes
+    MSG_RETRY: 60 * 60, // 1 hour
+    CALL_OFFER: 5 * 60, // 5 minutes
+    USER_DEVICES: 5 * 60 // 5 minutes
+};
+export const DEFAULT_CONNECTION_CONFIG = {
+    version: version,
+    browser: Browsers.macOS('Chrome'),
+    waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
+    connectTimeoutMs: 20000,
+    keepAliveIntervalMs: 15000,
+    logger: logger.child({ class: 'baileys' }),
+    emitOwnEvents: true,
+    defaultQueryTimeoutMs: 60000,
+    customUploadHosts: [],
+    retryRequestDelayMs: 250,
+    maxMsgRetryCount: 3,
+    fireInitQueries: true,
+    auth: undefined,
+    markOnlineOnConnect: true,
+    syncFullHistory: true,
+    patchMessageBeforeSending: msg => msg,
+    shouldSyncHistoryMessage: ({ syncType }) => {
+        return syncType !== proto.HistorySync.HistorySyncType.FULL;
+    },
+    shouldIgnoreJid: () => false,
+    linkPreviewImageThumbnailWidth: 480, // JAP@Fix: was 192 — too small, bumped to 480
+    transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
+    eventBufferTimeoutMs: 30000, // JAP@Fix (bug 25): configurable — increase if bot is heavy load
+    statusBroadcastDelayMs: 1500, // JAP@Fix (bug 5): configurable delay between status broadcasts — default 1500ms
+    albumDelayMs: 1500, // JAP@Fix (bug 5): configurable delay between album message sends — default 1500ms
+    phashRetryEnabled: false, // JAP@Fix (bug 54/55): enable phash retry on ack (caution: can cause loops if not careful)
+    generateHighQualityLinkPreview: true,
+    enableAutoSessionRecreation: true,
+    enableRecentMessageCache: true,
+    options: {},
+    appStateMacVerification: {
+        patch: false,
+        snapshot: false
+    },
+    countryCode: 'US',
+    // JAP@Fix (bug 15): default returns undefined — every retry request will fail unless overridden.
+    // Override this in your makeWASocket config to return messages from your store:
+    //   getMessage: async (key) => store.loadMessage(key.remoteJid, key.id)?.message
+    getMessage: async () => undefined,
+    cachedGroupMetadata: async () => undefined,
+    makeSignalRepository: makeLibSignalRepository
+};
+export const MEDIA_PATH_MAP = {
+    image: '/mms/image',
+    video: '/mms/video',
+    document: '/mms/document',
+    audio: '/mms/audio',
+    sticker: '/mms/image',
+    'sticker-pack': '/mms/sticker-pack',
+    'thumbnail-sticker-pack': '/mms/thumbnail-sticker-pack',
+    'thumbnail-link': '/mms/image',
+    'thumbnail-image': '/mms/image',
+    'thumbnail-video': '/mms/video',
+    'thumbnail-document': '/mms/document',
+    'product-catalog-image': '/product/image',
+    'md-app-state': '',
+    'md-msg-hist': '/mms/md-app-state',
+    'biz-cover-photo': '/pps/biz-cover-photo'
+};
+// JAP@Changes 06-02-26 --- Add newsletter media path for "/m1/" instead of "/o1/" (⁠≧⁠▽⁠≦⁠)
+export const NEWSLETTER_MEDIA_PATH_MAP = {
+    image: '/newsletter/newsletter-image',
+    video: '/newsletter/newsletter-video',
+    document: '/newsletter/newsletter-document',
+    audio: '/newsletter/newsletter-audio',
+    sticker: '/newsletter/newsletter-image',
+    'thumbnail-link': '/newsletter/newsletter-thumbnail-link'
+};
+export const MEDIA_HKDF_KEY_MAPPING = {
+    audio: 'Audio',
+    document: 'Document',
+    gif: 'Video',
+    image: 'Image',
+    ppic: '',
+    product: 'Image',
+    ptt: 'Audio',
+    'sticker-pack': 'Sticker Pack',
+    'thumbnail-sticker-pack': 'Sticker Pack Thumbnail',
+    sticker: 'Image',
+    video: 'Video',
+    'thumbnail-document': 'Document Thumbnail',
+    'thumbnail-image': 'Image Thumbnail',
+    'thumbnail-video': 'Video Thumbnail',
+    'thumbnail-link': 'Link Thumbnail',
+    'md-msg-hist': 'History',
+    'md-app-state': 'App State',
+    'product-catalog-image': 'Product Catalog Image',
+    'payment-bg-image': 'Payment Background',
+    ptv: 'Video',
+    'biz-cover-photo': 'Image',
+    location: 'Location',
+    contact: 'Contact',
+    'voip-token': 'Voip Token'
+};
+export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+/** 120s timeout for history sync stall detection, same as WA Web's handleChunkProgress / restartPausedTimer (g = 120) */
+export const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120000;
+export const MIN_PREKEY_COUNT = 5;
+export const INITIAL_PREKEY_COUNT = 812;
+export const UPLOAD_TIMEOUT = 30000; // 30 seconds
+export const TimeMs = {
+    Minute: 60 * 1000,
+    Hour: 60 * 60 * 1000,
+    Day: 24 * 60 * 60 * 1000,
+    Week: 7 * 24 * 60 * 60 * 1000
+};

package/lib/Framework/Bot.d.ts

@@ -0,0 +1,61 @@
+import type { Context } from './Context.js';
+import type { SessionManager } from './SessionManager.js';
+import type { StatsManager } from './StatsManager.js';
+import type { SQLiteStore } from './Store/SQLiteStore.js';
+
+export interface BotConfig {
+    /** Passed straight to makeWASocket() (auth, logger, browser, …). */
+    socketConfig?: any;
+    /** SQLite path for sessions/stats. Default: 'baileys_store.db'. */
+    dbPath?: string;
+    /** Enable group StatsManager. Default off. */
+    enableStats?: boolean;
+    /**
+     * Resolve the freshest WA Web version via fetchBestWaVersion() on every
+     * start()/reconnect (WA sw.js -> baileys fork -> hardcoded fallback).
+     * Default true; set false or pin `socketConfig.version` to opt out.
+     */
+    versionCheck?: boolean;
+    logger?: any;
+}
+
+/**
+ * Resolve the socketConfig a Bot connects with: injects the freshest WA Web
+ * version via fetchBestWaVersion() unless `versionCheck: false` or
+ * `socketConfig.version` is pinned. Pure and never throws.
+ */
+export function resolveSocketVersionConfig(config: BotConfig, logger?: any): Promise<any>;
+
+export type BotMiddleware = (ctx: Context, next: () => Promise<void>) => Promise<void> | void;
+export type BotCommandHandler = (ctx: Context) => Promise<void> | void;
+
+export class Bot {
+    constructor(config: BotConfig);
+    middlewares: BotMiddleware[];
+    messageQueue: any[];
+    isConnected: boolean;
+    reconnectAttempts: number;
+    socket: any | null;
+    sessions: SessionManager | null;
+    stats: StatsManager | null;
+    store: SQLiteStore | null;
+    config: BotConfig;
+    logger: any;
+    /** Register a middleware function (Express/Koa-style `use()`/`next()`). */
+    use(middleware: BotMiddleware): this;
+    /** Register a `!command` handler (exact match or prefix + whitespace). */
+    command(cmd: string, handler: BotCommandHandler): this;
+    /** Register a handler that fires on any non-empty text. */
+    onText(handler: BotCommandHandler): this;
+    /** Send a message — queues automatically when disconnected. */
+    sendMessage(jid: string, content: any, options?: any): Promise<any>;
+    /** Drain queued messages after reconnect. */
+    drainQueue(): void;
+    /** Reject and clear the message queue. */
+    rejectQueue(reason: any): void;
+    /** Start the socket and wire all event handlers. */
+    start(): Promise<void>;
+    executeMiddlewares(ctx: Context): Promise<void>;
+    /** Gracefully stop the bot (cancels reconnect, rejects queue, closes stores). */
+    stop(): void;
+}

package/lib/Framework/Bot.js

@@ -0,0 +1,248 @@
+import { Boom } from '@hapi/boom';
+import makeWASocket from '../Socket/index.js';
+import { DisconnectReason } from '../Types/index.js';
+import { isJidGroup } from '../WABinary/index.js';
+import defaultLogger from '../Utils/logger.js';
+import { fetchBestWaVersion } from '../Utils/generics.js';
+import { SQLiteStore } from './Store/SQLiteStore.js';
+import { Context } from './Context.js';
+import { SessionManager } from './SessionManager.js';
+import { StatsManager } from './StatsManager.js';
+
+// JAP@Framework --- high-level Bot class: middleware routing (Express/Koa-style
+// `use()`/`next()`), a `!command` dispatcher, an outgoing message queue that
+// survives disconnects, and exponential-backoff auto-reconnect.
+//
+// Kept from upstream's fix pass:
+//  - command boundary check: `!sticker` no longer matches `!stickerSpam`
+//  - queue is rejected (not left hanging) on DisconnectReason.loggedOut
+//  - stats.observeMessage runs inside the per-message try block, so a
+//    SQLite error can't silently skip middleware for that message
+//  - reconnect timer handle is stored so stop()/restart() can cancel it
+//
+// JAP@Fix vs upstream: SQLiteStore/StatsManager are now created through an
+// async factory (see Store/SQLiteStore.js) instead of a synchronous
+// constructor, since better-sqlite3 is lazy-loaded as an optional peer dep
+// in this fork. That means store/session/stats setup moved out of the Bot
+// constructor and into start() — the socket is only created *after* the
+// store is ready, so no message can arrive before sessions/stats exist.
+/**
+ * Resolve the socketConfig a Bot should connect with. Exported as a pure
+ * function so the wiring is unit-testable without opening a real socket.
+ * Skips the lookup when `versionCheck: false` or `socketConfig.version` is
+ * pinned; never throws (worst case returns socketConfig untouched).
+ */
+export const resolveSocketVersionConfig = async (config, logger = defaultLogger) => {
+    const socketConfig = config.socketConfig ?? {};
+    if (config.versionCheck === false || socketConfig.version) {
+        return socketConfig;
+    }
+    try {
+        const { version, source, isLatest } = await fetchBestWaVersion();
+        logger.info({ version, source, isLatest }, 'resolved WA Web version');
+        return { ...socketConfig, version };
+    }
+    catch (err) {
+        // fetchBestWaVersion never throws by contract, but a Framework
+        // start() must not be able to die on a version lookup either way.
+        logger.warn({ err }, 'version lookup failed — using default');
+        return socketConfig;
+    }
+};
+
+export class Bot {
+    constructor(config) {
+        this.middlewares = [];
+        this.messageQueue = [];
+        this.isConnected = false;
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.BASE_RECONNECT_DELAY = 1000;
+        this.MAX_RECONNECT_DELAY = 30000;
+        this.socket = null;
+        this.sessions = null;
+        this.stats = null;
+        this.store = null;
+        this.config = config;
+        this.logger = config.logger ?? defaultLogger.child({ module: 'Framework.Bot' });
+    }
+
+    /** Register a middleware function */
+    use(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+
+    /**
+     * Register a command handler.
+     * Uses exact match OR prefix + whitespace so '!sticker' does NOT
+     * match '!stickerSpam' or '!stickerset'.
+     */
+    command(cmd, handler) {
+        this.use(async (ctx, next) => {
+            const text = ctx.text;
+            if (text === cmd || text?.startsWith(cmd + ' ')) {
+                await handler(ctx);
+            }
+            await next();
+        });
+        return this;
+    }
+
+    /** Register a handler that fires on any non-empty text */
+    onText(handler) {
+        this.use(async (ctx, next) => {
+            if (ctx.text) {
+                await handler(ctx);
+            }
+            await next();
+        });
+        return this;
+    }
+
+    /** Send a message — queues automatically when socket is disconnected */
+    async sendMessage(jid, content, options = {}) {
+        if (this.isConnected && this.socket) {
+            return this.socket.sendMessage(jid, content, options);
+        }
+        return new Promise((resolve, reject) => {
+            this.messageQueue.push({ jid, content, options, resolve, reject });
+            this.logger.info({ queueLength: this.messageQueue.length }, 'socket not connected — message queued');
+        });
+    }
+
+    /** Drain queued messages after reconnect. */
+    drainQueue() {
+        if (!this.isConnected || !this.socket || this.messageQueue.length === 0)
+            return;
+        this.logger.info({ pending: this.messageQueue.length }, 'draining message queue');
+        const queue = [...this.messageQueue];
+        this.messageQueue = [];
+        for (const msg of queue) {
+            this.socket.sendMessage(msg.jid, msg.content, msg.options).then(msg.resolve).catch(msg.reject);
+        }
+    }
+
+    /** Reject and clear the message queue. Called on loggedOut so callers don't hang forever. */
+    rejectQueue(reason) {
+        const queue = [...this.messageQueue];
+        this.messageQueue = [];
+        for (const msg of queue) {
+            msg.reject(new Boom(reason, { statusCode: 401 }));
+        }
+        if (queue.length > 0) {
+            this.logger.warn({ rejected: queue.length }, 'message queue rejected — session terminated');
+        }
+    }
+
+    /**
+     * JAP@Fix (bug 66): the Bot always connected with whatever `version` sat
+     * in socketConfig — usually nothing, i.e. the hardcoded Defaults constant.
+     * That is the exact stale-version footgun fetchBestWaVersion() was written
+     * for (405 rejections at pairing once WA bumps its minimum, upstream#2370/
+     * #2485), and the Framework never actually used it. Now every start()
+     * (and therefore every auto-reconnect) resolves the freshest version
+     * through the documented chain: WA's own sw.js -> baileys fork -> the
+     * hardcoded fallback. Never throws; offline it behaves exactly as before.
+     * Opt out with `versionCheck: false` or pin `socketConfig.version`.
+     */
+    async #resolveSocketConfig() {
+        return resolveSocketVersionConfig(this.config, this.logger);
+    }
+
+    /** Start the socket and wire all event handlers */
+    async start() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // JAP@Fix: store/sessions must exist before the socket can receive
+        // any message, so this now awaits creation instead of doing it
+        // synchronously in the constructor.
+        if (!this.store) {
+            const dbPath = this.config.dbPath ?? 'baileys_store.db';
+            this.store = await SQLiteStore.create(dbPath);
+            this.sessions = new SessionManager(this.store);
+        }
+        this.socket = makeWASocket(await this.#resolveSocketConfig());
+        if (this.config.enableStats && !this.stats) {
+            this.stats = await StatsManager.create(this.config.dbPath ?? 'baileys_store.db', jid => this.socket.groupMetadata(jid));
+        }
+        this.socket.ev.on('messages.upsert', async ({ messages, type }) => {
+            if (type !== 'notify')
+                return;
+            for (const msg of messages) {
+                const ctx = new Context(this, msg);
+                try {
+                    if (this.stats && ctx.remoteJid && isJidGroup(ctx.remoteJid)) {
+                        const participant = msg.key.participant || msg.participant;
+                        if (participant) {
+                            const isSticker = !!msg.message?.stickerMessage;
+                            this.stats.observeMessage(ctx.remoteJid, participant, isSticker);
+                        }
+                    }
+                    await this.executeMiddlewares(ctx);
+                }
+                catch (err) {
+                    this.logger.error({ err }, 'error executing middleware');
+                }
+            }
+        });
+        this.socket.ev.on('connection.update', update => {
+            const { connection, lastDisconnect } = update;
+            if (connection === 'open') {
+                this.logger.info('bot connected');
+                this.isConnected = true;
+                this.reconnectAttempts = 0;
+                this.drainQueue();
+            }
+            if (connection === 'close') {
+                this.isConnected = false;
+                const error = lastDisconnect?.error;
+                const statusCode = error?.output?.statusCode;
+                const isLoggedOut = statusCode === DisconnectReason.loggedOut;
+                this.logger.warn({ statusCode }, 'connection closed');
+                if (isLoggedOut) {
+                    this.rejectQueue('session terminated (logged out)');
+                    this.logger.info('session logged out — not reconnecting');
+                }
+                else {
+                    this.reconnectAttempts++;
+                    const delay = Math.min(this.MAX_RECONNECT_DELAY, this.BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts - 1));
+                    this.logger.info({ delay, attempt: this.reconnectAttempts }, 'scheduling reconnect');
+                    this.reconnectTimer = setTimeout(() => {
+                        this.reconnectTimer = null;
+                        this.start().catch(err => {
+                            this.logger.error({ err }, 'reconnect failed');
+                        });
+                    }, delay);
+                }
+            }
+        });
+    }
+
+    async executeMiddlewares(ctx) {
+        let index = -1;
+        const dispatch = async (i) => {
+            if (i <= index)
+                throw new Error('next() called multiple times');
+            index = i;
+            const middleware = this.middlewares[i];
+            if (middleware) {
+                await middleware(ctx, () => dispatch(i + 1));
+            }
+        };
+        await dispatch(0);
+    }
+
+    /** Gracefully stop the bot */
+    stop() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.rejectQueue('bot stopped');
+        this.store?.close();
+        this.stats?.close();
+    }
+}

package/lib/Framework/Context.d.ts

@@ -0,0 +1,21 @@
+import type { Bot } from './Bot.js';
+
+/** Wraps a WAMessage with reply/react/session/media helpers for command handlers. */
+export class Context {
+    constructor(bot: Bot, message: any);
+    bot: Bot;
+    message: any;
+    readonly remoteJid: string | undefined;
+    /** Text content, including image/video/document captions. */
+    readonly text: string | undefined;
+    readonly quoted: any;
+    session(): any;
+    setSession(data: any): void;
+    updateSession(updater: (prev: any) => any): void;
+    clearSession(): void;
+    /** Reply quoting the original message. Throws when remoteJid is missing. */
+    reply(content: any, options?: any): Promise<void>;
+    react(emoji: string): Promise<void>;
+    replySticker(inputPathOrBuffer: string | Buffer, metadata?: { packname?: string; author?: string }): Promise<void>;
+    replyVoiceNote(inputPathOrBuffer: string | Buffer): Promise<void>;
+}