@oxidezap/baileyrs 0.2.12 → 0.2.13

package/lib/Compatibility/encode-proto.d.ts

@@ -1,12 +1,16 @@
 /**
- * `encodeProto`, with the two inputs the bridge codec stopped accepting put back.
+ * `encodeProto`, with the three inputs the bridge codec refuses put back.
  *
  * From 0.8.0 the codec refuses an empty string where the schema declares a
  * 64-bit integer, and an unpaired surrogate in a text field. Both were written
  * before — as `0` and as U+FFFD — and upstream Baileys still encodes both, so a
  * message that used to reach the server would now throw in the caller's face.
- * This is where that is absorbed, so the strict contract stays true of the
- * bridge and the tolerant one stays true of this library.
+ * The codec also refuses enum names where the schema declares an enum
+ * (issue #109: `"NONE"` where an int32 goes on the wire), which upstream's
+ * `fromObject` resolves and its direct `encode` coerces — that repair lives in
+ * `repairProtoMessage`, next to the other two. This is where all three are
+ * absorbed, so the strict contract stays true of the bridge and the tolerant
+ * one stays true of this library.
  *
  * Repair on failure rather than check on write: the ordinary encode is exactly
  * the call it was before, with no scan of any field, and the repair runs only

package/lib/Compatibility/encode-proto.js

@@ -1,14 +1,18 @@
 import { encodeProto } from '@oxidezap/whatsapp-rust-bridge';
 import { repairProtoMessage } from './proto-runtime.js';
 /**
- * `encodeProto`, with the two inputs the bridge codec stopped accepting put back.
+ * `encodeProto`, with the three inputs the bridge codec refuses put back.
  *
  * From 0.8.0 the codec refuses an empty string where the schema declares a
  * 64-bit integer, and an unpaired surrogate in a text field. Both were written
  * before — as `0` and as U+FFFD — and upstream Baileys still encodes both, so a
  * message that used to reach the server would now throw in the caller's face.
- * This is where that is absorbed, so the strict contract stays true of the
- * bridge and the tolerant one stays true of this library.
+ * The codec also refuses enum names where the schema declares an enum
+ * (issue #109: `"NONE"` where an int32 goes on the wire), which upstream's
+ * `fromObject` resolves and its direct `encode` coerces — that repair lives in
+ * `repairProtoMessage`, next to the other two. This is where all three are
+ * absorbed, so the strict contract stays true of the bridge and the tolerant
+ * one stays true of this library.
  *
  * Repair on failure rather than check on write: the ordinary encode is exactly
  * the call it was before, with no scan of any field, and the repair runs only
@@ -22,8 +26,9 @@ export const encodeProtoCompat = (path, message) => {
     catch (error) {
         const repaired = repairProtoMessage(path, message);
         // Reference equality: nothing was coerced, so the failure is something this
-        // does not explain — an unmodelled type, a number no int64 can hold — and
-        // it has to keep propagating rather than be retried into a second throw.
+        // does not explain — an unmodelled type, a number no int64 can hold, an
+        // unknown enum name — and it has to keep propagating rather than be
+        // retried into a second throw.
         if (repaired === message)
             throw error;
         return encodeProto(path, repaired);

package/lib/Compatibility/proto-runtime.js

@@ -53,7 +53,7 @@ const UNPAIRED_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBF
 /**
  * Puts back what the codec used to do with an input it now refuses.
  *
- * Two cases, both measured against upstream Baileys, which still encodes both:
+ * Three cases, all measured against upstream Baileys, which still encodes them:
  *
  * - An empty string where the schema declares a 64-bit integer. Every one of the
  *   134 send-path failures this addresses carried exactly `''`; a string that is
@@ -62,6 +62,13 @@ const UNPAIRED_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBF
  * - An unpaired surrogate in a text field, replaced with U+FFFD. That is the
  *   substitution `TextEncoder` used to make, so the bytes are unchanged from what
  *   this library sent before.
+ * - An enum name where the schema declares an enum (issue #109: `"NONE"` where
+ *   an int32 goes on the wire). Upstream's `fromObject` resolves names to numbers
+ *   and its direct `encode` coerces any string with `| 0`, so a caller passing a
+ *   name never sees a throw. The bridge codec accepts only numbers (numeric
+ *   strings aside) and throws `invalid int32: "NONE"`. An unknown name is left to
+ *   throw rather than silenced to `0`: upstream's direct encode would write `0`
+ *   for it, but that puts a value on the wire nobody sent.
  *
  * Returns `item` itself when it has nothing to do, so the caller can tell a
  * repair from a failure it does not understand.
@@ -77,6 +84,36 @@ const repairScalar = (kind, item) => {
     const replaced = item.replace(UNPAIRED_SURROGATE, '\uFFFD');
     return replaced === item ? item : replaced;
 };
+/**
+ * Enum name to wire number, built per enum on the first repair that needs it.
+ *
+ * Only the repair path reads this, and only for a field that actually holds a
+ * string — a message the codec accepts never reaches here, and a numeric enum
+ * never touches a map. Each table is built once from the generated entries and
+ * then reused; an importer that never sends a refused value allocates nothing.
+ * A `Map` (not a plain object) so names like `__proto__` are keys, not hazards.
+ */
+let enumTablesById;
+const enumValueFor = (enumId, name) => {
+    if (enumId < 0 || enumId >= PROTO_ENUM_SCHEMAS.length)
+        return undefined;
+    enumTablesById ?? (enumTablesById = []);
+    let byName = enumTablesById[enumId];
+    if (byName === undefined) {
+        const entries = PROTO_ENUM_SCHEMAS[enumId]?.[1];
+        if (!entries)
+            return undefined;
+        byName = new Map();
+        for (let index = 0; index < entries.length; index += 2) {
+            const entryName = entries[index];
+            const entryValue = entries[index + 1];
+            if (typeof entryName === 'string' && typeof entryValue === 'number')
+                byName.set(entryName, entryValue);
+        }
+        enumTablesById[enumId] = byName;
+    }
+    return byName.get(name);
+};
 const longFromWords = (low, high, unsigned) => LongRuntime.fromBits(low, high, unsigned);
 /**
  * Split a decoded 64-bit value into the low/high words `longFromWords` takes.
@@ -254,12 +291,13 @@ const schemaIdFor = (path) => {
     return schemaIdsByPath.get(path);
 };
 /**
- * Coerces the two inputs the bridge codec stopped accepting back to what it
- * used to write, and returns `value` itself when there was nothing to coerce.
+ * Coerces the three inputs the bridge codec refuses back to what upstream
+ * Baileys writes, and returns `value` itself when there was nothing to coerce.
  *
  * Reference equality is the signal: the caller only reaches here after an
  * encode threw, and an unchanged result means the failure was something else
- * — a genuinely invalid number, a missing codec — which must keep propagating.
+ * — a genuinely invalid number, an unknown enum name, a missing codec — which
+ * must keep propagating.
  *
  * Copy-on-write throughout, like `projectForEncode`: a branch with nothing to
  * fix is shared, not rebuilt.
@@ -286,7 +324,16 @@ const repairMessage = (schemaId, value, ancestors) => {
         const current = value[field[0]];
         if (current === null || current === undefined)
             continue;
-        const repair = (item) => field[1] === PROTO_FIELD_KIND.message ? repairMessage(field[2], item, seen) : repairScalar(field[1], item);
+        const repair = (item) => {
+            if (field[1] === PROTO_FIELD_KIND.message)
+                return repairMessage(field[2], item, seen);
+            // `?? item`, not `|| item`: 0 is a valid wire value (e.g. `"NONE"`).
+            // Unknown names stay strings, so the retry still throws and the
+            // original failure keeps propagating instead of becoming a silent 0.
+            if (field[1] === PROTO_FIELD_KIND.enum && typeof item === 'string')
+                return enumValueFor(field[2], item) ?? item;
+            return repairScalar(field[1], item);
+        };
         let converted = current;
         if (field[3] & PROTO_FIELD_FLAG.repeated) {
             if (Array.isArray(current)) {
@@ -457,8 +504,8 @@ class ProtoCompatibilityRuntime {
                 throw new Error(`protobuf codec unavailable for ${path}`);
             const projected = this.projectForEncode(schemaId, message);
             const encoded = sourceCodec.encode(projected);
-            // The bridge refuses two inputs it used to accept silently, and upstream
-            // Baileys still encodes both. Repairing on failure rather than checking
+            // The bridge refuses three inputs it used to accept silently, and upstream
+            // Baileys still encodes all three. Repairing on failure rather than checking
             // every field on the way in is what keeps the ordinary encode free: a
             // message the codec accepts never reaches the repair, and one that does
             // not was already going to throw.

package/lib/Socket/events.js

@@ -22,7 +22,7 @@ import { buildGroupCreateStubMessage, buildGroupJoinRequestEvents, buildGroupNot
 import { emitMessageUpsert } from '../Compatibility/message-upsert.js';
 import { extractMessageCappingPayload } from './message-capping.js';
 import { mapReachoutTimelock } from './reachout.js';
-import { isReconnectableConnectFailure } from './terminal-close.js';
+import { isReconnectableConnectFailure, mapConnectFailureToDisconnect } from './terminal-close.js';
 const CANONICAL_MESSAGE_EVENT = 'message';
 const MESSAGE_UPSERT_APPEND = 'append';
 const MESSAGE_UPSERT_NOTIFY = 'notify';
@@ -191,41 +191,6 @@ const emitRetrying = (ctx) => ctx.ev.emit('connection.update', {
  * dispatcher for why `badSession` was the wrong home.
  */
 const CLIENT_OUTDATED_STATUS = 405;
-/**
- * Map bridge `ConnectFailureReason` wire codes (per the bridge's
- * `.d.ts` annotation) onto upstream Baileys' `DisconnectReason`.
- * Unknown codes fall through to `connectionClosed` so existing
- * reconnect heuristics keep working.
- *
- * Several cases here are belt-and-braces: the engine dispatches its own event
- * for `is_logged_out()` reasons (401/403/406) and for 405, so those never
- * reach `connectFailure` in practice. Kept because they cost nothing and the
- * engine's routing is not ours to depend on.
- */
-const mapConnectFailureToDisconnect = (reason) => {
-    switch (reason) {
-        case 401: // LoggedOut
-        case 403: // MainDeviceGone
-        case 406: // UnknownLogout
-            return DisconnectReason.loggedOut;
-        case 402: // TempBanned
-            return DisconnectReason.forbidden;
-        case 405: // ClientOutdated
-            return CLIENT_OUTDATED_STATUS;
-        case 411: // MultideviceMismatch (legacy alias)
-            return DisconnectReason.multideviceMismatch;
-        case 503: // ServiceUnavailable
-        case 501: // Experimental
-            return DisconnectReason.unavailableService;
-        case 408: // Timed out
-            return DisconnectReason.timedOut;
-        case 515: // RestartRequired
-            return DisconnectReason.restartRequired;
-        // 400, 409, 413, 414, 415, 418, 500, undefined → generic close
-        default:
-            return DisconnectReason.connectionClosed;
-    }
-};
 const describeTempBan = (code) => {
     switch (code) {
         case 101:

package/lib/Socket/groups.js

@@ -20,6 +20,27 @@ export const JOIN_APPROVAL_MODES = ['on', 'off'];
 // exact as a double, and that shape carries no methods. The helper reads both
 // forms, and reconstructs the high word instead of dropping it.
 const inviteExpirationNumber = (value) => toNumber(value);
+// The core's V4 join parser only accepts a `<group>`, `<community>` or
+// `<membership_approval_request>` child, but the server also answers a
+// successful join with a bare `<iq type="result">` (WA Web's own
+// `AcceptGroupAddResponseSuccess` variant requires no child at all — only the
+// result envelope whose `from` echoes the request's `to`). The core reports
+// that shape as an `IqError::ParseError`, which the bridge surfaces as
+// `kind: 'internal'`. Error stanzas never reach the parser (they become
+// `kind: 'server'` one layer below), so this substring can only mean the join
+// was accepted and the JID carrier is missing — never a rejection.
+const BARE_JOIN_SUCCESS_FRAGMENT = 'expected <group>, <community>, or <membership_approval_request> in join response';
+// A bare `<iq type="result">` join success, as described above. Anything else
+// (server rejections, timeouts, transport loss, protocol violations) must keep
+// propagating.
+const isBareJoinSuccess = (error) => {
+    if (!(error instanceof Error) || error.name !== 'WhatsAppError')
+        return false;
+    const kind = error.kind;
+    if (kind !== 'internal')
+        return false;
+    return typeof error.message === 'string' && error.message.includes(BARE_JOIN_SUCCESS_FRAGMENT);
+};
 export const makeGroupMethods = (ctx) => {
     const groupMetadata = async (jid) => {
         const metadata = await (await ctx.getClient()).getGroupMetadata(jid);
@@ -34,10 +55,22 @@ export const makeGroupMethods = (ctx) => {
     // oxlint-disable-next-line typescript/no-explicit-any -- the established public contract returns Promise<any>.
     ) => {
         const messageKey = typeof key === 'string' ? { remoteJid: key } : key;
-        if (!inviteMessage.groupJid || !inviteMessage.inviteCode || !messageKey.remoteJid) {
+        const groupJid = inviteMessage.groupJid;
+        if (!groupJid || !inviteMessage.inviteCode || !messageKey.remoteJid) {
             throw new TypeError('groupAcceptInviteV4 requires groupJid, inviteCode and inviter JID');
         }
-        const joinedJid = await (await ctx.getClient()).groupAcceptInviteV4(inviteMessage.groupJid, inviteMessage.inviteCode, inviteExpirationNumber(inviteMessage.inviteExpiration), messageKey.remoteJid);
+        let joinedJid;
+        try {
+            joinedJid = await (await ctx.getClient()).groupAcceptInviteV4(groupJid, inviteMessage.inviteCode, inviteExpirationNumber(inviteMessage.inviteExpiration), messageKey.remoteJid);
+        }
+        catch (error) {
+            // The join was accepted but the response carried no JID node.
+            // Baileys returns the envelope's `from` here, which echoes the
+            // request's `to` — the group JID we already hold.
+            if (!isBareJoinSuccess(error))
+                throw error;
+            joinedJid = groupJid;
+        }
         if (messageKey.id) {
             const expiredInvite = proto.Message.GroupInviteMessage.fromObject(inviteMessage);
             expiredInvite.inviteExpiration = 0;

package/lib/Socket/index.js

@@ -31,6 +31,7 @@ import { makeBridgeClientOwner } from './bridge-client-owner.js';
 import { warnUnsupportedConfig } from './unsupported-config.js';
 import { wrapBridgeClient } from './bridge-error-boundary.js';
 import { makeTerminalCloseReporter } from './terminal-close-reporter.js';
+import { mapConnectFailureToDisconnect } from './terminal-close.js';
 import { makeEventHandlers } from './events.js';
 import { makeGroupMethods } from './groups.js';
 import { makeInternalMethods, makeUnexpectedErrorReporter } from './internals.js';
@@ -71,6 +72,29 @@ const browserToPlatformType = (browser) => {
             return 'CHROME';
     }
 };
+const COMPLETION_FAILURE_CODES = new Map([
+    ['Generic', 400],
+    ['LoggedOut', 401],
+    ['TempBanned', 402],
+    ['AccountLocked', 403],
+    ['UnknownLogout', 406],
+    ['ClientOutdated', 405],
+    ['BadUserAgent', 409],
+    ['CatExpired', 413],
+    ['CatInvalid', 414],
+    ['NotFound', 415],
+    ['ClientUnknown', 418],
+    ['InternalServerError', 500],
+    ['Experimental', 501],
+    ['ServiceUnavailable', 503]
+]);
+const completionFailureCode = (reason) => {
+    const named = COMPLETION_FAILURE_CODES.get(reason);
+    if (named !== undefined)
+        return named;
+    const unknown = /^Unknown\((-?\d+)\)$/.exec(reason)?.[1];
+    return unknown === undefined ? undefined : Number(unknown);
+};
 /** Build the ws EventEmitter with auto-enable raw node forwarding */
 const makeWASocket = (config) => {
     const fullConfig = { ...DEFAULT_CONNECTION_CONFIG, ...config };
@@ -261,6 +285,37 @@ const makeWASocket = (config) => {
     let autoReconnectEnabled = true;
     /** Owns reporting the terminal close: once, after teardown, never not at all. */
     const terminalClose = makeTerminalCloseReporter({ logger });
+    const runCompletionError = (completion) => {
+        let statusCode = DisconnectReason.connectionClosed;
+        let message = 'Connection closed';
+        if (completion.reason === 'unknown') {
+            message = `Connection run ended: ${completion.detail}`;
+        }
+        else if (completion.reason === 'stopped') {
+            message = 'Connection run stopped';
+        }
+        else if (completion.reason === 'already-running') {
+            message = 'Connection run was already running';
+        }
+        else if (completion.reason === 'auto-reconnect-disabled') {
+            const protocol = completion.protocolError;
+            if (protocol?.kind === 'conflict') {
+                statusCode = DisconnectReason.connectionReplaced;
+                message = 'Connection replaced';
+            }
+            else if (protocol?.kind === 'stream-error') {
+                statusCode = mapConnectFailureToDisconnect(protocol.code);
+            }
+            else if (protocol?.kind === 'connect-failure') {
+                statusCode = mapConnectFailureToDisconnect(completionFailureCode(protocol.reason));
+            }
+            else if (completion.connection?.kind === 'server-close') {
+                message = completion.connection.reason;
+            }
+        }
+        return new Boom(message, { statusCode, data: { runCompletion: completion } });
+    };
+    const reportTerminalClose = (error, publish) => terminalClose.reportAfter(() => owner.close(error).finally(() => initPromise), publish);
     /**
      * Held in a reporter rather than captured, because `sock.onUnexpectedError`
      * is an assignable property: a consumer that replaces it has to be the one
@@ -401,7 +456,7 @@ const makeWASocket = (config) => {
             // is still owned. This waits for the real teardown, and cannot
             // deadlock because `reportAfter` runs it detached; nothing in the
             // teardown is waiting on this.
-            terminalClose.reportAfter(() => owner.close(error).finally(() => initPromise), publish);
+            reportTerminalClose(error, publish);
         },
         isAutoReconnectEnabled: () => autoReconnectEnabled,
         // Timers the dispatcher armed outlive the events that armed them, and
@@ -527,23 +582,46 @@ const makeWASocket = (config) => {
         // starting the read loop now would run against a handle about to go.
         if (owner.isClosing())
             return;
-        // `run()` spawns the connect/handshake/read/reconnect loop as a
-        // background task and returns `void` — it deliberately is not `async`,
-        // so that it does not hold a wasm-bindgen borrow on `self` that would
-        // block `disconnect()`.
-        //
-        // Consequence: the loop's exit is not observable from here. The engine
-        // clears `enable_auto_reconnect` and breaks out on every terminal
-        // disconnect (conflict/401/409/516, and any `<failure>` whose reason is
-        // not 500/503), and when it does, the `WasmWhatsAppClient` is dead
-        // weight that only `sock.end()` can free — nothing else can, because
-        // the bridge holds the JS event callbacks as wasm-bindgen externrefs,
-        // those close over `ctx`, and `ctx` closes over `client`, so the cycle
-        // crosses the JS/wasm boundary and no `FinalizationRegistry` fires.
-        // Freeing that automatically needs the bridge to expose loop completion
-        // (a terminal callback or an awaitable handle); until it does, the
-        // consumer has to call `sock.end()` on a terminal close.
+        // `run()` deliberately returns immediately so callers can use the
+        // client while supervision owns its background task. Registering the
+        // completion observer after it is started is safe: bridge 0.21.0 admits
+        // late observers against the stored result for this run generation.
         created.run();
+        const observedClient = created;
+        void created
+            .waitForRunCompletion()
+            .then(completion => {
+            // The owner identity is the socket generation fence. A completion
+            // from a client that teardown already released must never close a
+            // later socket using the same auth state.
+            if (owner.isClosing() || owner.peek() !== observedClient)
+                return;
+            const error = runCompletionError(completion);
+            reportTerminalClose(error, () => ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: { error, date: new Date() }
+            }));
+        }, error => {
+            if (owner.isClosing() || owner.peek() !== observedClient)
+                return;
+            const closeError = new Boom('Connection run ended without a completion result', {
+                statusCode: DisconnectReason.connectionClosed
+            });
+            reportTerminalClose(closeError, () => ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: { error: closeError, date: new Date() }
+            }));
+            try {
+                logger.error({ err: error }, 'bridge run completion observation failed');
+            }
+            catch {
+                // A consumer logger cannot prevent the terminal cleanup above.
+            }
+        })
+            .catch(() => {
+            // The reporter contains teardown and publish failures; this final guard
+            // also contains a consumer logger that throws from an observation path.
+        });
         initialized = true;
     };
     /**

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

@@ -1,39 +1,5 @@
-/**
- * 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;
+/** Map a typed bridge connect-failure code to Baileys' close status. */
+export declare const mapConnectFailureToDisconnect: (reason: number | undefined) => number;
 //# sourceMappingURL=terminal-close.d.ts.map

package/lib/Socket/terminal-close.js

@@ -1,3 +1,4 @@
+import { DisconnectReason } from '../Types/index.js';
 /**
  * Which bridge disconnects end the socket for good.
  *
@@ -6,11 +7,10 @@
  * 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 socket layer needs the answer for bridge events that classify a terminal
+ * close before the supervised run completion is observed. Bridge 0.21.0 also
+ * exposes `waitForRunCompletion()` for exits with no terminal event; that
+ * observer uses the same terminal-close reporter and owner as this table.
  *
  * The upstream Baileys contract this buys us: `connection.update { close }`
  * means "this socket is finished, build a new one" — which is what every
@@ -48,4 +48,28 @@ const RECONNECTABLE_CONNECT_FAILURE_REASONS = new Set([
 ]);
 /** True when the engine will keep retrying after this `<failure>`. */
 export const isReconnectableConnectFailure = (reason) => reason !== undefined && RECONNECTABLE_CONNECT_FAILURE_REASONS.has(reason);
+/** Map a typed bridge connect-failure code to Baileys' close status. */
+export const mapConnectFailureToDisconnect = (reason) => {
+    switch (reason) {
+        case 401:
+        case 403:
+        case 406:
+            return DisconnectReason.loggedOut;
+        case 402:
+            return DisconnectReason.forbidden;
+        case 405:
+            return 405;
+        case 411:
+            return DisconnectReason.multideviceMismatch;
+        case 503:
+        case 501:
+            return DisconnectReason.unavailableService;
+        case 408:
+            return DisconnectReason.timedOut;
+        case 515:
+            return DisconnectReason.restartRequired;
+        default:
+            return DisconnectReason.connectionClosed;
+    }
+};
 //# sourceMappingURL=terminal-close.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",