@oxidezap/baileyrs 0.0.32 → 0.1.0

package/lib/Socket/messages.d.ts

@@ -10,8 +10,11 @@ import type { SocketContext } from './types.js';
  * it across the delete and restore it on a fresh contextInfo.
  *
  * Mutates `msg` in place.
+ *
+ * `contentType` is a parameter so the send path can hand over the type it has
+ * already resolved rather than have it scanned out of `msg` a second time.
  */
-export declare function stripContextInfoForBridge(msg: WAMessageContent): void;
+export declare function stripContextInfoForBridge(msg: WAMessageContent, contentType?: keyof WAProto.IMessage | undefined): void;
 export declare const makeMessageMethods: (ctx: SocketContext) => {
     sendMessage: (jid: string, content: AnyMessageContent, options?: Omit<MessageGenerationOptions, 'waClient' | 'logger' | 'userJid' | 'mediaInNote'>) => Promise<WAMessage>;
     updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;

package/lib/Socket/messages.js

@@ -1,4 +1,4 @@
-import { encodeProto } from 'whatsapp-rust-bridge';
+import { encodeProto } from '@oxidezap/whatsapp-rust-bridge';
 import { planMessageRelay } from '../Compatibility/message-relay.js';
 import { receiptMessageKeys } from '../Compatibility/message-keys.js';
 import { WAProto } from '../Types/index.js';
@@ -22,9 +22,11 @@ function getMediaContent(content) {
  * it across the delete and restore it on a fresh contextInfo.
  *
  * Mutates `msg` in place.
+ *
+ * `contentType` is a parameter so the send path can hand over the type it has
+ * already resolved rather than have it scanned out of `msg` a second time.
  */
-export function stripContextInfoForBridge(msg) {
-    const contentType = getContentType(msg);
+export function stripContextInfoForBridge(msg, contentType = getContentType(msg)) {
     const pinAddOnDuration = contentType === 'pinInChatMessage' ? msg.messageContextInfo?.messageAddOnDurationInSecs : undefined;
     delete msg.messageContextInfo;
     if (pinAddOnDuration !== undefined && pinAddOnDuration !== null) {
@@ -85,7 +87,7 @@ export const makeMessageMethods = (ctx) => ({
                 return fullMsg;
             }
         }
-        stripContextInfoForBridge(msg);
+        stripContextInfoForBridge(msg, contentType);
         let msgId;
         const msgBytes = encodeProto('Message', msg);
         if (jid === 'status@broadcast' && options?.statusJidList?.length) {

package/lib/Socket/newsletter.d.ts

@@ -1,8 +1,8 @@
 import type { SocketContext } from './types.js';
 export declare const makeNewsletterMethods: (ctx: SocketContext) => {
-    newsletterCreate: (name: string, description?: string) => Promise<import("whatsapp-rust-bridge").NewsletterMetadataResult>;
-    newsletterMetadata: (jid: string) => Promise<import("whatsapp-rust-bridge").NewsletterMetadataResult>;
-    newsletterSubscribe: (jid: string) => Promise<import("whatsapp-rust-bridge").NewsletterMetadataResult>;
+    newsletterCreate: (name: string, description?: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
+    newsletterMetadata: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
+    newsletterSubscribe: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
     newsletterUnsubscribe: (jid: string) => Promise<void>;
     newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
     /**

package/lib/Socket/terminal-close-reporter.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Reports the terminal `connection.update { close }` — exactly once, after
+ * teardown, and never silently not at all.
+ *
+ * That sentence is the whole contract this branch sells, and getting it wrong
+ * has two opposite failure modes, both bad:
+ *
+ *  - **Not reported.** The consumer's handler never runs, so it never builds a
+ *    replacement socket. A bot offline with nothing in its logs — the original
+ *    bug this branch exists to fix.
+ *  - **Reported early, or twice.** The replacement socket overlaps the old
+ *    one's auth-store flush and `free()`, or every listener sees two terminal
+ *    notifications for one socket and a handler that cleans up on close loops.
+ *
+ * Keeping both away used to be inline logic split across the dispatcher hook
+ * and `logout()`, sharing a counter and a promise. Nine separate bugs came out
+ * of that in review — a publish that could never run, a throwing listener
+ * taking the process down, `logout()` resolving before the close it caused,
+ * the watchdog not releasing its waiters, a suppression check that also
+ * matched non-terminal teardown, a fallback that did not count itself. Every
+ * one was a different way of answering the same question, so it is one object
+ * now, with the answer in one place.
+ */
+import type { ILogger } from '../Utils/logger.js';
+/**
+ * How long teardown may run before the close is reported anyway.
+ *
+ * A deliberate trade of one guarantee for the other: past this point the close
+ * goes out with teardown still running, because losing the event entirely is
+ * the worse of the two failures. Teardown takes milliseconds in practice, so
+ * reaching this means a consumer end handler or a store flush never settled —
+ * and the error logged alongside says exactly that. Generous rather than
+ * tight, since firing early is the harmful direction.
+ */
+export declare const TERMINAL_CLOSE_PUBLISH_TIMEOUT_MS = 60000;
+export interface TerminalCloseReporter {
+    /**
+     * Run `teardown`, then publish. Used by the dispatcher, which learns about
+     * the close first and hands over the publishing so the socket can finish
+     * releasing its resources before a consumer can react.
+     *
+     * Never rejects and never leaves `publish` uncalled: teardown failures are
+     * logged, a throwing listener is contained, and a teardown that hangs is
+     * cut short by the watchdog.
+     */
+    reportAfter: (teardown: () => Promise<void>, publish: () => void) => void;
+    /**
+     * Publish immediately, for a close nothing else will announce — a `logout()`
+     * with no live client, or one whose `logout()` threw before the bridge
+     * dispatched anything.
+     */
+    reportNow: (publish: () => void) => void;
+    /**
+     * Whether a terminal close has been *claimed* — reported, or reported-and-
+     * still-tearing-down. Not "published": `reportAfter` publishes only once
+     * teardown finishes, so a check keyed on delivery would see `false` right
+     * after the bridge announced the logout and let `logout()` add a second
+     * close of its own.
+     *
+     * `logout()` uses this rather than "is the socket closing", which is also
+     * true for a plain `end()` — and those report nothing, so keying off them
+     * would let a logout racing one finish with no close at all.
+     */
+    hasReported: () => boolean;
+    /**
+     * Settles once the most recent report has been published — the moment the
+     * consumer sees it, not the moment teardown finishes, so a waiter is not
+     * left hanging when the watchdog is what released the event.
+     *
+     * Resolves immediately when nothing has been reported.
+     */
+    published: () => Promise<void>;
+}
+export declare const makeTerminalCloseReporter: (opts: {
+    logger: ILogger;
+    /** Overridable for tests; production uses the constant above. */
+    publishTimeoutMs?: number;
+}) => TerminalCloseReporter;
+//# sourceMappingURL=terminal-close-reporter.d.ts.map

package/lib/Socket/terminal-close-reporter.js

@@ -0,0 +1,108 @@
+/**
+ * Reports the terminal `connection.update { close }` — exactly once, after
+ * teardown, and never silently not at all.
+ *
+ * That sentence is the whole contract this branch sells, and getting it wrong
+ * has two opposite failure modes, both bad:
+ *
+ *  - **Not reported.** The consumer's handler never runs, so it never builds a
+ *    replacement socket. A bot offline with nothing in its logs — the original
+ *    bug this branch exists to fix.
+ *  - **Reported early, or twice.** The replacement socket overlaps the old
+ *    one's auth-store flush and `free()`, or every listener sees two terminal
+ *    notifications for one socket and a handler that cleans up on close loops.
+ *
+ * Keeping both away used to be inline logic split across the dispatcher hook
+ * and `logout()`, sharing a counter and a promise. Nine separate bugs came out
+ * of that in review — a publish that could never run, a throwing listener
+ * taking the process down, `logout()` resolving before the close it caused,
+ * the watchdog not releasing its waiters, a suppression check that also
+ * matched non-terminal teardown, a fallback that did not count itself. Every
+ * one was a different way of answering the same question, so it is one object
+ * now, with the answer in one place.
+ */
+/**
+ * How long teardown may run before the close is reported anyway.
+ *
+ * A deliberate trade of one guarantee for the other: past this point the close
+ * goes out with teardown still running, because losing the event entirely is
+ * the worse of the two failures. Teardown takes milliseconds in practice, so
+ * reaching this means a consumer end handler or a store flush never settled —
+ * and the error logged alongside says exactly that. Generous rather than
+ * tight, since firing early is the harmful direction.
+ */
+export const TERMINAL_CLOSE_PUBLISH_TIMEOUT_MS = 60000;
+export const makeTerminalCloseReporter = (opts) => {
+    const { logger } = opts;
+    const publishTimeoutMs = opts.publishTimeoutMs ?? TERMINAL_CLOSE_PUBLISH_TIMEOUT_MS;
+    /** Claims, not deliveries — see `hasReported`. */
+    let claimed = 0;
+    let publishedPromise;
+    /** One publish per claim, whatever gets there first, and never throwing. */
+    const makeOnce = (publish, settle) => {
+        let done = false;
+        return () => {
+            if (done)
+                return;
+            done = true;
+            try {
+                publish();
+            }
+            catch (err) {
+                // `publish` emits on the consumer's bus. Letting this escape
+                // would surface as an unhandled rejection on a detached chain —
+                // process exit under Node's default handler.
+                logger.error({ err }, 'connection.update listener threw on the terminal close');
+            }
+            settle();
+        };
+    };
+    return {
+        reportAfter: (teardown, publish) => {
+            claimed++;
+            let settle;
+            publishedPromise = new Promise(resolve => {
+                settle = resolve;
+            });
+            const publishOnce = makeOnce(publish, settle);
+            // Deliberately referenced: a pending promise does not keep Node's
+            // event loop alive, so an unref'd timer lets a minimal bot exit
+            // before it can publish — and the close handler that would have
+            // built the replacement never runs, which is what this guards.
+            // Cleared the moment teardown settles, so it holds the loop only
+            // while one is in flight.
+            const watchdog = setTimeout(() => {
+                logger.error({ afterMs: publishTimeoutMs }, 'socket teardown is still running; reporting the close anyway');
+                publishOnce();
+            }, publishTimeoutMs);
+            const finish = (err) => {
+                clearTimeout(watchdog);
+                if (err)
+                    logger.error({ err }, 'socket teardown failed after a terminal disconnect');
+                publishOnce();
+            };
+            // `teardown()` is called inside the try because it can throw
+            // *synchronously*, before returning a promise — `.then` would never
+            // run and the close would stay unpublished until the watchdog, or
+            // forever if the timer were ever removed. The no-silent-failure
+            // promise has to hold for that path too.
+            try {
+                void teardown().then(() => finish(), finish);
+            }
+            catch (err) {
+                finish(err);
+            }
+        },
+        reportNow: publish => {
+            claimed++;
+            let settle;
+            publishedPromise = new Promise(resolve => {
+                settle = resolve;
+            });
+            makeOnce(publish, settle)();
+        },
+        hasReported: () => claimed > 0,
+        published: () => publishedPromise ?? Promise.resolve()
+    };
+};
+//# sourceMappingURL=terminal-close-reporter.js.map

package/lib/Socket/terminal-close.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Which bridge disconnects end the socket for good.
+ *
+ * This mirrors one decision that lives in the Rust engine, so keep it honest:
+ * `whatsapp-rust` clears `enable_auto_reconnect` and breaks out of its run loop
+ * on exactly these, and retries everything else on the WA Web Fibonacci backoff
+ * (`client/lifecycle.rs`).
+ *
+ * The socket layer needs the answer because `WasmWhatsAppClient.run()` returns
+ * `void` — it spawns the loop as a background task, so the loop's exit is not
+ * observable from JS (`whatsapp_rust_bridge.d.ts`, `run(): void`). Until the
+ * bridge exposes loop completion, this table is how the socket knows a client
+ * has become dead weight that only `free()` can reclaim.
+ *
+ * The upstream Baileys contract this buys us: `connection.update { close }`
+ * means "this socket is finished, build a new one" — which is what every
+ * consumer written against upstream already assumes, because upstream has no
+ * auto-reconnect at all. Transient drops therefore never surface as `close`;
+ * they surface as `connecting`.
+ *
+ * Events deliberately absent from the terminal set, and why:
+ *  - `disconnected` — the engine only dispatches `Event::Disconnected` for an
+ *    *unexpected* loop exit, and every terminal path sets `expected_disconnect`
+ *    first, which suppresses it (`client/lifecycle.rs`). So this one is the
+ *    "engine is retrying" signal — with one exception the dispatcher handles:
+ *    under `setAutoReconnect(false)` the run loop dispatches `Disconnected`
+ *    and only *then* tests the flag and breaks out, which makes the very same
+ *    event terminal. Absence from this list means "not terminal on its own",
+ *    not "never terminal".
+ *  - `streamError` — reaches JS only from the engine's catch-all `<stream:error>`
+ *    branch (unknown code, `<ack/>`, `<xml-not-well-formed>`); the coded ones
+ *    (401/409/515/516/429/503) dispatch their own events instead. Every case
+ *    that gets here keeps the connection or recycles it deliberately.
+ *  - `pairError` — pairing failed, but the engine keeps its loop and re-emits a
+ *    QR; nothing about the client is dead.
+ */
+/** True when the engine will keep retrying after this `<failure>`. */
+export declare const isReconnectableConnectFailure: (reason: number | undefined) => boolean;
+//# sourceMappingURL=terminal-close.d.ts.map

package/lib/Socket/terminal-close.js

@@ -0,0 +1,51 @@
+/**
+ * Which bridge disconnects end the socket for good.
+ *
+ * This mirrors one decision that lives in the Rust engine, so keep it honest:
+ * `whatsapp-rust` clears `enable_auto_reconnect` and breaks out of its run loop
+ * on exactly these, and retries everything else on the WA Web Fibonacci backoff
+ * (`client/lifecycle.rs`).
+ *
+ * The socket layer needs the answer because `WasmWhatsAppClient.run()` returns
+ * `void` — it spawns the loop as a background task, so the loop's exit is not
+ * observable from JS (`whatsapp_rust_bridge.d.ts`, `run(): void`). Until the
+ * bridge exposes loop completion, this table is how the socket knows a client
+ * has become dead weight that only `free()` can reclaim.
+ *
+ * The upstream Baileys contract this buys us: `connection.update { close }`
+ * means "this socket is finished, build a new one" — which is what every
+ * consumer written against upstream already assumes, because upstream has no
+ * auto-reconnect at all. Transient drops therefore never surface as `close`;
+ * they surface as `connecting`.
+ *
+ * Events deliberately absent from the terminal set, and why:
+ *  - `disconnected` — the engine only dispatches `Event::Disconnected` for an
+ *    *unexpected* loop exit, and every terminal path sets `expected_disconnect`
+ *    first, which suppresses it (`client/lifecycle.rs`). So this one is the
+ *    "engine is retrying" signal — with one exception the dispatcher handles:
+ *    under `setAutoReconnect(false)` the run loop dispatches `Disconnected`
+ *    and only *then* tests the flag and breaks out, which makes the very same
+ *    event terminal. Absence from this list means "not terminal on its own",
+ *    not "never terminal".
+ *  - `streamError` — reaches JS only from the engine's catch-all `<stream:error>`
+ *    branch (unknown code, `<ack/>`, `<xml-not-well-formed>`); the coded ones
+ *    (401/409/515/516/429/503) dispatch their own events instead. Every case
+ *    that gets here keeps the connection or recycles it deliberately.
+ *  - `pairError` — pairing failed, but the engine keeps its loop and re-emits a
+ *    QR; nothing about the client is dead.
+ */
+/**
+ * `ConnectFailureReason` wire codes the engine retries — the JS mirror of
+ * `ConnectFailureReason::should_reconnect()`, which matches only
+ * `InternalServerError | ServiceUnavailable`.
+ *
+ * A `<failure>` with no reason at all is NOT retried: the engine parses it as
+ * `Unknown(0)`, which fails `should_reconnect()`.
+ */
+const RECONNECTABLE_CONNECT_FAILURE_REASONS = new Set([
+    500, // InternalServerError
+    503 // ServiceUnavailable
+]);
+/** True when the engine will keep retrying after this `<failure>`. */
+export const isReconnectableConnectFailure = (reason) => reason !== undefined && RECONNECTABLE_CONNECT_FAILURE_REASONS.has(reason);
+//# sourceMappingURL=terminal-close.js.map

package/lib/Socket/transport.d.ts

@@ -1,4 +1,4 @@
-import type { JsHttpClientConfig, JsTransportCallbacks } from 'whatsapp-rust-bridge';
+import type { JsHttpClientConfig, JsTransportCallbacks } from '@oxidezap/whatsapp-rust-bridge';
 import type { ILogger } from '../Utils/logger.js';
 interface TransportConfig {
     waWebSocketUrl: string | URL;

package/lib/Socket/types.d.ts

@@ -1,5 +1,5 @@
 import type { EventEmitter } from 'events';
-import type { WasmWhatsAppClient } from 'whatsapp-rust-bridge';
+import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import type { Contact, SocketConfig } from '../Types/index.js';
 import type { makeEventBuffer } from '../Utils/event-buffer.js';
 import type { ILogger } from '../Utils/logger.js';

package/lib/Types/Auth.d.ts

@@ -1,5 +1,5 @@
 import type { Buffer } from 'node:buffer';
-import type { JsStoreCallbacks } from 'whatsapp-rust-bridge';
+import type { JsStoreCallbacks } from '@oxidezap/whatsapp-rust-bridge';
 import type { proto } from '../WAProto/runtime.js';
 import type { Contact } from './Contact.js';
 import type { MinimalMessage } from './Message.js';

package/lib/Types/Message.d.ts

@@ -1,6 +1,6 @@
 import type { Readable } from 'stream';
 import type { URL } from 'url';
-import type { MediaType as BridgeMediaType, UploadMediaResult, WasmWhatsAppClient } from 'whatsapp-rust-bridge';
+import type { MediaType as BridgeMediaType, UploadMediaResult, WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import type { WAMessageAddressingMode as WAMessageAddressingModeType } from '../Compatibility/public-api/enum-types.js';
 import { proto } from '../WAProto/runtime.js';
 import type { MediaType } from '../Defaults/index.js';

package/lib/Types/Socket.d.ts

@@ -1,8 +1,8 @@
 import type { Agent } from 'node:https';
 import type { URL } from 'url';
-import type { CacheConfig, DevicePropsInput } from 'whatsapp-rust-bridge';
+import type { CacheConfig, DevicePropsInput } from '@oxidezap/whatsapp-rust-bridge';
 import type { proto } from '../WAProto/runtime.js';
-export type { DeviceAppVersion, DeviceHistorySyncConfig, DevicePlatformType, DevicePropsInput } from 'whatsapp-rust-bridge';
+export type { DeviceAppVersion, DeviceHistorySyncConfig, DevicePlatformType, DevicePropsInput } from '@oxidezap/whatsapp-rust-bridge';
 import type { ILogger } from '../Utils/logger.js';
 import type { AuthenticationState, LIDMapping, SignalAuthState } from './Auth.js';
 import type { GroupMetadata } from './GroupMetadata.js';

package/lib/Utils/crypto.d.ts

@@ -1,7 +1,7 @@
-import { hkdf, md5 } from 'whatsapp-rust-bridge';
+import { hkdf, md5 } from '@oxidezap/whatsapp-rust-bridge';
 import type { KeyPair } from '../Types/Auth.js';
 export { hkdf, md5 };
-export type { HkdfInfo } from 'whatsapp-rust-bridge';
+export type { HkdfInfo } from '@oxidezap/whatsapp-rust-bridge';
 /** Prefix Signal's version byte when the public key is in raw 32-byte form. */
 export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike>;
 export declare const Curve: {

package/lib/Utils/crypto.js

@@ -1,5 +1,5 @@
 import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto';
-import { calculateAgreement, calculateSignature, generateKeyPair, hkdf, md5, verifySignature } from 'whatsapp-rust-bridge';
+import { calculateAgreement, calculateSignature, generateKeyPair, hkdf, md5, verifySignature } from '@oxidezap/whatsapp-rust-bridge';
 import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
 import { aesCbc256Decrypt, aesCbc256Encrypt, aesGcm256Decrypt, aesGcm256Encrypt, hmacDigest } from '../Platform/crypto.js';
 export { hkdf, md5 };

package/lib/Utils/event-buffer.js

@@ -362,6 +362,37 @@ export const makeEventBuffer = (logger) => {
     let flushPendingTimeout;
     ev.on('event', (events) => {
         for (const event of Object.keys(events)) {
+            if (event === 'connection.update') {
+                // Delivered listener by listener, unlike every other event.
+                // `EventEmitter.emit()` stops at the first listener that throws,
+                // so one bad handler would keep the rest — including the app's
+                // reconnect handler — from ever seeing a terminal `close`, and
+                // the bot would stay offline. This is the lifecycle channel;
+                // losing delivery here is the failure mode the socket's whole
+                // close contract exists to prevent.
+                // `rawListeners`, not `listeners`: the latter unwraps `once()`
+                // handlers to the function underneath, so calling that would
+                // never run the wrapper that unregisters them and the listener
+                // would stay subscribed for every later update. `once` is not on
+                // `BaileysEventEmitter` today, so this is unreachable rather than
+                // broken — but the two differ only in this respect and the raw
+                // one is the correct primitive for calling listeners by hand.
+                for (const listener of ev.rawListeners(event)) {
+                    try {
+                        // `.call(ev, …)` so `this` is still the emitter, as it
+                        // would be under `emit()`. A listener declared as a
+                        // normal function that does `this.off('connection.update', …)`
+                        // — a common self-removing pattern — would otherwise
+                        // throw on `undefined` and be swallowed by the catch.
+                        ;
+                        listener.call(ev, events[event]);
+                    }
+                    catch (err) {
+                        logger.error({ err, event }, 'connection.update listener threw; continuing with the rest');
+                    }
+                }
+                continue;
+            }
             ev.emit(event, events[event]);
         }
     });

package/lib/Utils/logger.d.ts

@@ -1,4 +1,4 @@
-import P from 'pino';
+import type { Logger } from 'pino';
 export interface ILogger {
     level: string;
     child(obj: Record<string, unknown>): ILogger;
@@ -8,6 +8,6 @@ export interface ILogger {
     warn(obj: unknown, msg?: string): void;
     error(obj: unknown, msg?: string): void;
 }
-declare const _default: P.Logger<never, boolean>;
+declare const _default: Logger;
 export default _default;
 //# sourceMappingURL=logger.d.ts.map

package/lib/Utils/logger.js

@@ -1,27 +1,124 @@
-import P from 'pino';
-export default P({
-    name: 'baileyrs',
-    level: process.env.BAILEYRS_LOG_LEVEL || 'info',
-    timestamp: () => `,"time":"${new Date().toJSON()}"`,
-    redact: {
-        paths: [
-            'creds',
-            'authState',
-            'noiseKey',
-            'signedIdentityKey',
-            'advSecretKey',
-            'privateKey',
-            'secretKey',
-            'preKey.privateKey',
-            '*.creds',
-            '*.authState',
-            '*.noiseKey',
-            '*.signedIdentityKey',
-            '*.advSecretKey',
-            '*.privateKey',
-            '*.secretKey'
-        ],
-        censor: '[REDACTED]'
+import { createRequire } from 'node:module';
+const DEFAULT_LEVEL = 'info';
+const REDACTED_PATHS = [
+    'creds',
+    'authState',
+    'noiseKey',
+    'signedIdentityKey',
+    'advSecretKey',
+    'privateKey',
+    'secretKey',
+    'preKey.privateKey',
+    '*.creds',
+    '*.authState',
+    '*.noiseKey',
+    '*.signedIdentityKey',
+    '*.advSecretKey',
+    '*.privateKey',
+    '*.secretKey'
+];
+/**
+ * Deferred because building pino at module evaluation cost ~10 MB of RSS in every
+ * importing process: ~4.5 MB for pino's module graph, the rest for the Date/ICU
+ * machinery V8 materializes when the configured `timestamp` runs — which pino
+ * calls while *constructing* the logger. Applications that pass their own
+ * `SocketConfig.logger` never needed any of it.
+ *
+ * `require` rather than a dynamic `import`, because ILogger's methods are
+ * synchronous: an async resolution would have to drop or queue the first lines.
+ */
+let rootLogger;
+const resolveRootLogger = () => {
+    if (!rootLogger) {
+        const requireFrom = createRequire(import.meta.url);
+        const pino = requireFrom('pino');
+        rootLogger = pino({
+            name: 'baileyrs',
+            level: process.env.BAILEYRS_LOG_LEVEL || DEFAULT_LEVEL,
+            timestamp: () => `,"time":"${new Date().toJSON()}"`,
+            redact: { paths: REDACTED_PATHS, censor: '[REDACTED]' }
+        });
     }
-});
+    return rootLogger;
+};
+const createDeferredLogger = (bindings, parent, childOptions) => {
+    let resolved;
+    let pendingLevel;
+    const members = new Map();
+    const resolve = () => {
+        if (!resolved) {
+            const source = parent ? parent.resolve() : resolveRootLogger();
+            resolved = bindings ? source.child(bindings, childOptions) : source;
+            if (pendingLevel !== undefined)
+                resolved.level = pendingLevel;
+        }
+        return resolved;
+    };
+    const peekLevel = () => resolved?.level ??
+        pendingLevel ??
+        childOptions?.level ??
+        parent?.level() ??
+        process.env.BAILEYRS_LOG_LEVEL ??
+        DEFAULT_LEVEL;
+    const self = { level: peekLevel, resolve };
+    // Hoisted so `logger.child` keeps the stable identity a plain property has.
+    const child = (extra, options) => createDeferredLogger(extra, self, options);
+    // Typed as pino's Logger, not ILogger: narrowing would reject `logger.fatal(...)`
+    // at compile time even though the proxy forwards it.
+    const target = {};
+    return new Proxy(target, {
+        get(_target, property) {
+            if (property === 'child')
+                return child;
+            if (property === 'level' && !resolved)
+                return peekLevel();
+            const cached = members.get(property);
+            if (cached !== undefined)
+                return cached;
+            const logger = resolve();
+            const value = logger[property];
+            if (typeof value !== 'function')
+                return value;
+            const bound = value.bind(logger);
+            members.set(property, bound);
+            return bound;
+        },
+        set(_target, property, value) {
+            if (property === 'level' && !resolved) {
+                pendingLevel = value;
+                return true;
+            }
+            ;
+            resolve()[property] = value;
+            // Whole cache, not just this key: pino swaps its log methods for noops
+            // when `level` changes, so a cached `info` would stay silent forever.
+            members.clear();
+            return true;
+        },
+        has(_target, property) {
+            return property === 'child' || property === 'level' || property in resolve();
+        },
+        deleteProperty(_target, property) {
+            members.delete(property);
+            delete resolve()[property];
+            return true;
+        },
+        defineProperty(_target, property, descriptor) {
+            // Forwarded, or the definition would land on the empty target while
+            // every other trap kept answering from the resolved logger.
+            members.clear();
+            return Reflect.defineProperty(resolve(), property, descriptor);
+        },
+        ownKeys() {
+            return Reflect.ownKeys(resolve());
+        },
+        getOwnPropertyDescriptor(_target, property) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(resolve(), property);
+            // Forced configurable: the proxy target is an empty extensible object,
+            // and reporting a non-configurable key it does not own is a TypeError.
+            return descriptor && { ...descriptor, configurable: true };
+        }
+    });
+};
+export default createDeferredLogger();
 //# sourceMappingURL=logger.js.map

package/lib/Utils/messages.d.ts

@@ -1,6 +1,6 @@
 import { Buffer } from 'node:buffer';
 import { Readable } from 'node:stream';
-import type { WasmWhatsAppClient } from 'whatsapp-rust-bridge';
+import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import { type MediaType } from '../Defaults/index.js';
 import type { AnyMediaMessageContent, AnyMessageContent, MessageContentGenerationOptions, MessageGenerationOptions, MessageGenerationOptionsFromContent, MessageUserReceipt, WAMessage, WAMessageContent, WAMessageKey } from '../Types/index.js';
 import { WAProto } from '../Types/index.js';
@@ -57,6 +57,17 @@ export type DownloadMediaMessageContext = {
  */
 export declare const downloadMediaMessage: <Type extends 'buffer' | 'stream'>(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer<ArrayBufferLike> : Readable>;
 export declare const _registerActiveBridgeClient: (client: WasmWhatsAppClient, logger?: ILogger) => void;
+/**
+ * Drop the module-level pointer when `sock.end()` frees the client it points
+ * at. Without this the global keeps a strong reference to a freed
+ * `WasmWhatsAppClient`, so the next standalone `downloadContentFromMessage()`
+ * call reaches into a null wasm pointer and fails with an opaque
+ * wasm-bindgen error instead of the actionable "no bridge client" Boom.
+ *
+ * Identity-checked on purpose: a multi-account host that ends socket A after
+ * creating socket B must not clear B's registration.
+ */
+export declare const _unregisterActiveBridgeClient: (client: WasmWhatsAppClient) => void;
 /**
  * Upstream-Baileys-compatible standalone media download. Builds a synthetic
  * `WAMessage` from the supplied media subcontent (image/video/audio/etc fields)