@oxidezap/baileyrs 0.0.32 → 0.1.0

package/README.md

@@ -25,7 +25,7 @@ so existing integrations can migrate with minimal changes. See
 | Media encrypt/decrypt | Node.js crypto | Rust AES-256-CBC + HMAC |
 | Media upload/download | JS fetch + temp files | Rust with CDN failover, auth refresh, resumable upload |
 | Key management | JS auth state | Rust `PersistenceManager` |
-| Auto-reconnect | Manual `startSock()` loop | Built-in with fibonacci backoff |
+| Auto-reconnect | Manual `startSock()` loop | Transient drops retried in Rust (fibonacci backoff); terminal ones still yours |
 
 ## Documentation
 
@@ -51,9 +51,16 @@ import makeWASocket from '@oxidezap/baileyrs'
 ### Drop-in replacement for upstream Baileys
 
 baileyrs is API-compatible with [@whiskeysockets/baileys](https://github.com/WhiskeySockets/Baileys).
-Existing projects switch over by aliasing the package — **no source changes needed**
-(one exception: carrying an existing pairing across takes a one-line import swap,
-see [Migrating from Upstream Baileys](#migrating-from-upstream-baileys)):
+Existing projects switch over by aliasing the package — **the API and imports
+need no source changes**. Two things do:
+
+- Carrying an existing pairing across takes a one-line import swap, see
+  [Migrating from Upstream Baileys](#migrating-from-upstream-baileys).
+- If your `connection.update` handler was written for a version of baileyrs
+  before 0.1, see [Gotchas](#gotchas): a `close` now always means the socket
+  is finished, and you have to recreate it. Code written against upstream
+  Baileys already does the right thing.
+
 
 ```sh
 npm install @whiskeysockets/baileys@npm:@oxidezap/baileyrs
@@ -78,27 +85,57 @@ now resolves to baileyrs.
 import makeWASocket, { Boom, DisconnectReason, useMultiFileAuthState } from '@oxidezap/baileyrs'
 
 const { state } = await useMultiFileAuthState('auth_info')
-const sock = makeWASocket({ auth: state })
 
-sock.ev.on('connection.update', ({ connection, lastDisconnect }) => {
-    if (connection === 'close') {
-        const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode
-        if (statusCode === DisconnectReason.loggedOut) {
-            console.log('Logged out')
-        }
-        // Auto-reconnect is handled by the Rust engine — no need to call makeWASocket again
+// setTimeout caps at ~2^31-1 ms (~24.8 days) and fires immediately past that,
+// so a long ban has to be waited out in chunks.
+async function waitUntil(deadlineMs: number) {
+    for (let left = deadlineMs - Date.now(); left > 0; left = deadlineMs - Date.now()) {
+        await new Promise(resolve => setTimeout(resolve, Math.min(left, 2_147_483_647)))
     }
-    if (connection === 'open') {
-        console.log('Connected')
-    }
-})
+}
 
-sock.ev.on('messages.upsert', ({ messages }) => {
-    for (const msg of messages) {
-        console.log('received message', msg.key.id)
-    }
-})
+async function connectToWhatsApp() {
+    const sock = makeWASocket({ auth: state })
+
+    sock.ev.on('connection.update', ({ connection, lastDisconnect }) => {
+        if (connection === 'close') {
+            // `close` means this socket is finished — same as upstream Baileys.
+            // Transient drops never get here; the Rust engine retries those and
+            // reports `connecting`.
+            const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode
+            // See the reconnect table under Gotchas: a few terminal closes
+            // reject the replacement just as fast, so they are not worth
+            // retrying — or not yet. `Example/example.ts` has the full policy.
+            if (statusCode === DisconnectReason.loggedOut || statusCode === 405) {
+                console.log('Closed for good', statusCode)
+            } else if (statusCode === DisconnectReason.forbidden) {
+                // Temporary ban: `expire` is unix seconds. A missing or past
+                // expiry means the ban is over — reconnect like any other
+                // terminal close rather than staying offline forever.
+                const expire = (lastDisconnect?.error as Boom)?.data?.expire
+                console.log('Temporarily banned until', expire)
+                waitUntil(typeof expire === 'number' ? expire * 1000 : 0).then(connectToWhatsApp)
+            } else {
+                setTimeout(connectToWhatsApp, 5_000)
+            }
+        }
+        if (connection === 'open') {
+            console.log('Connected')
+        }
+    })
+
+    // Register every handler in here. A replacement socket is a new emitter,
+    // so anything attached outside stops firing after the first reconnect.
+    sock.ev.on('messages.upsert', ({ messages }) => {
+        for (const msg of messages) {
+            console.log('received message', msg.key.id)
+        }
+    })
+
+    return sock
+}
 
+const sock = await connectToWhatsApp()
 await sock.sendMessage('1234567890@s.whatsapp.net', { text: 'Hello!' })
 ```
 
@@ -156,9 +193,25 @@ preserved. No QR re-scan, no logged-out events.
 
 A few behaviors that differ from upstream — almost always to your advantage:
 
-- **Auto-reconnect is built in.** Don't call `makeWASocket()` again from
-  `connection.update`'s `'close'` branch. The Rust engine retries with
-  fibonacci backoff; opening a second socket leaks the first one.
+- **Auto-reconnect is built in, but `close` still means `close`.** The Rust
+  engine retries transient drops on a fibonacci backoff and reports them as
+  `connection: 'connecting'`, so the canonical upstream handler never fires
+  for those and you never end up with two sockets on one account. A
+  `connection: 'close'` is only emitted once the engine has given up — a
+  replaced session, an outdated build, a temporary ban, an unrecoverable
+  `<failure>` — and by then the socket has already released its resources.
+  Ignoring it leaves the bot permanently offline, so handle it the upstream
+  way and build a replacement — with three exceptions, because some of those
+  failures reject the replacement just as fast:
+
+  | `statusCode` | what to do |
+  | --- | --- |
+  | `DisconnectReason.loggedOut` (401) | stop; needs a fresh pairing |
+  | `405` | stop; the server rejected this build, and the next one too |
+  | `DisconnectReason.forbidden` (403) | wait until `lastDisconnect.error.data.expire` (unix seconds) — it is a temporary ban |
+  | anything else | reconnect, after a short delay |
+
+  `Example/example.ts` implements exactly this.
 - **No `getMessage` / `cachedGroupMetadata` polyfill required.** The Rust
   side caches group metadata and message keys natively. You can still pass
   them — they're respected as overrides — but they're optional.

package/lib/Bridge/adapt.d.ts

@@ -7,7 +7,7 @@
  * (table-driven dispatch, additional validation, schema-derived types,
  * etc.) without rippling through call sites.
  */
-import type { WhatsAppEvent } from 'whatsapp-rust-bridge';
+import type { WhatsAppEvent } from '@oxidezap/whatsapp-rust-bridge';
 import type { ILogger } from '../Utils/logger.js';
 import type { CanonicalEvent } from './types.js';
 import { adaptBridgeMessageWire } from './schema.js';

package/lib/Bridge/history-sync-wire.d.ts

@@ -1,4 +1,4 @@
-import { type HistorySyncWireBatch, type WhatsAppEvent } from 'whatsapp-rust-bridge';
+import { type HistorySyncWireBatch, type WhatsAppEvent } from '@oxidezap/whatsapp-rust-bridge';
 import type { ILogger } from '../Utils/logger.js';
 declare const HISTORY_SYNC_EVENT_TYPE: 'history_sync';
 export interface DecodedHistorySyncWireBatch {

package/lib/Bridge/history-sync-wire.js

@@ -1,5 +1,5 @@
-import { BinaryReader } from 'whatsapp-rust-bridge';
-import { proto as WAProto } from 'whatsapp-rust-bridge/proto-types';
+import { BinaryReader } from '@oxidezap/whatsapp-rust-bridge';
+import { proto as WAProto } from '@oxidezap/whatsapp-rust-bridge/proto-types';
 import { isConversationHistorySync } from '../Utils/process-history-message.js';
 import { createSparseArray } from '../Utils/sparse-array.js';
 const HISTORY_SYNC_EVENT_TYPE = 'history_sync';

package/lib/Bridge/schema.d.ts

@@ -22,7 +22,7 @@
  * `asNumber`, `asString`) at those leak points only — not boilerplate
  * everywhere.
  */
-import type { MessageWireInfo, WhatsAppEvent } from 'whatsapp-rust-bridge';
+import type { MessageWireInfo, WhatsAppEvent } from '@oxidezap/whatsapp-rust-bridge';
 import type { ILogger } from '../Utils/logger.js';
 import type { CanonicalEvent, CanonicalMessage } from './types.js';
 export type BridgeEventType = WhatsAppEvent['type'];

package/lib/Bridge/schema.js

@@ -718,8 +718,15 @@ const adaptIncomingCall = (data, logger) => {
     const action = isObject(data.action) ? data.action : undefined;
     if (!action)
         return null;
-    const actionType = parseCallActionType(action.type);
-    const callId = asString(action.call_id);
+    // The bridge `CallAction` union narrows variant-specific fields only on the
+    // matching variant, and its group-call variants (group updates, rekeys,
+    // waiting rooms) carry no `call_id` at all. `parseCallActionType` admits
+    // none of those, so a runtime read through the action's own shape is safe —
+    // and is the cheapest way around TS's inability to follow our
+    // string-normalized discriminator back into the bridge union.
+    const fields = action;
+    const actionType = parseCallActionType(fields.type);
+    const callId = asString(fields.call_id);
     if (!actionType || !callId) {
         logger?.debug({ data }, 'incoming_call adapter: missing action.type/call_id');
         return null;
@@ -727,15 +734,8 @@ const adaptIncomingCall = (data, logger) => {
     const canonicalAction = {
         type: actionType,
         callId,
-        callCreator: asJidAddressString(action.call_creator)
+        callCreator: asJidAddressString(fields.call_creator)
     };
-    // The bridge `CallAction` union narrows variant-specific fields only
-    // on the matching variant. We've already validated `action.type` via
-    // `parseCallActionType`, so a runtime cast through the action's own
-    // shape is safe — reading fields off `unknown` is the cheapest way
-    // around TS's inability to follow our string-normalized discriminator
-    // back into the bridge union.
-    const fields = action;
     if (actionType === 'offer') {
         canonicalAction.callerPn = asJidString(fields.caller_pn);
         canonicalAction.callerCountryCode = asString(fields.caller_country_code);

package/lib/Bridge/types.d.ts

@@ -13,7 +13,7 @@
  *   - All timestamps are unix seconds.
  *   - Optional fields use `?` (omitted) rather than `null`.
  */
-import type { proto } from 'whatsapp-rust-bridge/proto-types';
+import type { proto } from '@oxidezap/whatsapp-rust-bridge/proto-types';
 import type { Chat, Contact, LIDMapping, WAMessage } from '../Types/index.js';
 import type { BinaryNode, WAProto } from '../Types/index.js';
 export interface CanonicalConnected {

package/lib/Compatibility/group-metadata.d.ts

@@ -1,4 +1,4 @@
-import type { GroupMetadataResult } from 'whatsapp-rust-bridge';
+import type { GroupMetadataResult } from '@oxidezap/whatsapp-rust-bridge';
 import type { GroupMetadata } from '../Types/GroupMetadata.js';
 /**
  * Translate the bridge's protocol-neutral group DTO into the public Baileys

package/lib/Compatibility/legacy-store/codecs/basic.js

@@ -1,6 +1,6 @@
 // Basic value codecs for the Baileys legacy-store projection.
 import { Buffer } from 'node:buffer';
-import { proto } from 'whatsapp-rust-bridge/proto-types';
+import { proto } from '@oxidezap/whatsapp-rust-bridge/proto-types';
 import { AppState, JsonByteEncoding, LidMapping, NativeStore, TimeValue } from '../constants.js';
 import { bytesToNumbers, fromJsonBytes, toBytes, toJsonBytes } from '../common.js';
 import { parseLidMappingKey } from '../routing.js';

package/lib/Compatibility/legacy-store/codecs/signal.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { decodeSenderKeyRecordComponents, encodeSenderKeyRecordComponents, importLegacySessionRecordV1, projectLegacySessionRecordV1 } from 'whatsapp-rust-bridge';
+import { decodeSenderKeyRecordComponents, encodeSenderKeyRecordComponents, importLegacySessionRecordV1, projectLegacySessionRecordV1 } from '@oxidezap/whatsapp-rust-bridge';
 import { JsonByteEncoding, LegacySession, NativeStore, TimeValue } from '../constants.js';
 import { EMPTY_BYTES } from '../common.js';
 import { NATIVE_ONLY_PROJECTION } from '../types.js';
@@ -28,9 +28,18 @@ const integer = (value, label) => {
     }
     return value;
 };
+/**
+ * The two shapes order their states in opposite directions: the core keeps the
+ * current state at the front and prunes from the back, while the legacy record
+ * is read back-to-front — `getSenderKeyState()` takes the last entry and
+ * `addSenderKeyState` drops the first one on overflow. Both conversions below
+ * therefore reverse. Carrying an order through unchanged writes the record
+ * upside down: the old implementation would send under a stale key and evict
+ * the freshest state instead of the oldest.
+ */
 function senderKeyToLegacy(nativeBytes) {
     const record = decodeSenderKeyRecordComponents(nativeBytes);
-    const states = record.states.map(state => ({
+    const states = record.states.toReversed().map(state => ({
         senderKeyId: state.keyId,
         senderChainKey: {
             iteration: state.chainKey.iteration,
@@ -54,6 +63,8 @@ function senderKeyFromLegacy(value) {
     const parsed = JSON.parse(Buffer.from(value).toString(JsonByteEncoding.UTF8), BufferJSON.reviver);
     if (!Array.isArray(parsed))
         throw new TypeError('legacy sender-key record must contain an array');
+    // Indexed against the stored order so a validation error names the state the
+    // caller can find in the record; reversed afterwards. See `senderKeyToLegacy`.
     const record = {
         states: parsed.map((state, stateIndex) => ({
             keyId: integer(state.senderKeyId, `sender-key state ${stateIndex} id`),
@@ -71,6 +82,7 @@ function senderKeyFromLegacy(value) {
             }))
         }))
     };
+    record.states.reverse();
     return encodeSenderKeyRecordComponents(record);
 }
 const messageKeyIndex = (value) => {
@@ -91,13 +103,13 @@ function messageKeysFromLegacy(messageKeys) {
 function messageKeysToLegacy(messageKeys) {
     return Object.fromEntries(messageKeys.map(messageKey => [messageKey.index, toBase64(messageKey.seed)]));
 }
-function legacyEntryToCore(entry) {
+function legacyEntryToCore(entry, recordRegistrationId) {
     const ratchet = entry.currentRatchet;
     if (!entry._chains || typeof entry._chains !== 'object') {
         throw new TypeError('legacy session is missing its chain catalog');
     }
     return {
-        registrationId: entry.registrationId ?? TimeValue.UNKNOWN_SECONDS,
+        registrationId: entry.registrationId ?? recordRegistrationId ?? TimeValue.UNKNOWN_SECONDS,
         ratchet: {
             keyPair: {
                 public: fromBase64(ratchet.ephemeralKeyPair.pubKey, 'sender ratchet public key'),
@@ -145,7 +157,7 @@ function sessionFromLegacy(value, defaults) {
     const decoded = {
         sessions: Object.entries(record._sessions).map(([indexKey, entry]) => ({
             indexKey: fromBase64(indexKey, 'legacy session index key'),
-            session: legacyEntryToCore(entry)
+            session: legacyEntryToCore(entry, record.registrationId)
         }))
     };
     return importLegacySessionRecordV1(decoded, {

package/lib/Compatibility/legacy-store/device.js

@@ -1,6 +1,6 @@
 // Device credential projection for legacy Baileys authentication states.
 import { Buffer } from 'node:buffer';
-import { proto } from 'whatsapp-rust-bridge/proto-types';
+import { proto } from '@oxidezap/whatsapp-rust-bridge/proto-types';
 import { WA_DEFAULT_VERSION } from '../../Defaults/index.js';
 import { jidDecode, jidEncode } from '../../WABinary/jid-utils.js';
 import { DeviceRecordKey, JsonByteEncoding, SignalDomain, SignalKeyLength, TimeValue } from './constants.js';

package/lib/Compatibility/legacy-store/multi-file.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { proto } from 'whatsapp-rust-bridge/proto-types';
+import { proto } from '@oxidezap/whatsapp-rust-bridge/proto-types';
 import { BufferJSON } from '../../Utils/generics.js';
 import { JsonByteEncoding, LegacyMultiFile, LegacyStore } from './constants.js';
 const PATH_SEPARATOR = /[\\/]/g;

package/lib/Compatibility/legacy-store/native-projection.d.ts

@@ -1,4 +1,4 @@
-import type { JsStoreCallbacks } from 'whatsapp-rust-bridge';
+import type { JsStoreCallbacks } from '@oxidezap/whatsapp-rust-bridge';
 import type { SignalCreds, SignalKeyStore } from '../../Types/index.js';
 /**
  * Project a neutral native byte store as the public legacy key store. Values

package/lib/Compatibility/legacy-store/types.d.ts

@@ -1,4 +1,4 @@
-import type { JsStoreCallbacks } from 'whatsapp-rust-bridge';
+import type { JsStoreCallbacks } from '@oxidezap/whatsapp-rust-bridge';
 import type { RouteKind } from './constants.js';
 export type LegacyStoreLogger = {
     warn(obj: unknown, msg?: string): void;

package/lib/Compatibility/media-type.d.ts

@@ -1,4 +1,4 @@
-import type { MediaType as BridgeMediaType } from 'whatsapp-rust-bridge';
+import type { MediaType as BridgeMediaType } from '@oxidezap/whatsapp-rust-bridge';
 import type { MediaType } from '../Defaults/index.js';
 /**
  * Narrow upstream's semantic media names to the protocol-neutral modes the

package/lib/Compatibility/message-relay.d.ts

@@ -1,4 +1,4 @@
-import type { MessageRetransmissionInput } from 'whatsapp-rust-bridge';
+import type { MessageRetransmissionInput } from '@oxidezap/whatsapp-rust-bridge';
 import type { BinaryNode, MessageRelayOptions } from '../Types/index.js';
 type OwnRelayIdentity = {
     id?: string;

package/lib/Compatibility/proto-runtime.js

@@ -1,6 +1,6 @@
 import { Buffer } from 'node:buffer';
 import { createRequire } from 'node:module';
-import { BinaryReader } from 'whatsapp-rust-bridge';
+import { BinaryReader } from '@oxidezap/whatsapp-rust-bridge';
 import { PROTO_ENUM_SCHEMAS, PROTO_FIELD_FLAG, PROTO_FIELD_KIND, PROTO_MESSAGE_SCHEMAS } from '../WAProto/compatibility-schema.js';
 const INSTANCE_SCHEMA = Symbol('proto compatibility schema');
 const EMPTY_ARRAY = Object.freeze([]);
@@ -138,24 +138,62 @@ const lookupPath = (root, path) => {
     }
     return current;
 };
-const installPath = (root, path, value) => {
-    const segments = path.split('.');
-    const leaf = segments.pop();
-    if (!leaf)
-        throw new Error(`invalid protobuf path: ${path}`);
-    let current = root;
-    for (const segment of segments) {
-        const next = current[segment];
-        if (!isObject(next) && typeof next !== 'function')
-            current[segment] = {};
-        current = current[segment];
-    }
-    current[leaf] = value;
-};
 const isSourceCodec = (value) => (isObject(value) || typeof value === 'function') &&
     typeof value.encode === 'function' &&
     typeof value.decode === 'function';
-const schemaDepth = (path) => path.split('.').length;
+const buildSchemaTree = (messagePaths, enumPaths) => {
+    const roots = new Map();
+    const nodeFor = (path) => {
+        let level = roots;
+        let node;
+        for (const segment of path.split('.')) {
+            node = level.get(segment);
+            if (!node) {
+                node = { children: new Map() };
+                level.set(segment, node);
+            }
+            level = node.children;
+        }
+        if (!node)
+            throw new Error(`invalid protobuf path: ${path}`);
+        return node;
+    };
+    messagePaths.forEach((path, messageId) => {
+        nodeFor(path).messageId = messageId;
+    });
+    enumPaths.forEach((path, enumId) => {
+        nodeFor(path).enumId = enumId;
+    });
+    return roots;
+};
+/**
+ * Self-replacing getter, so only the first read pays. It stays enumerable,
+ * writable and configurable so the entry behaves exactly like the eagerly
+ * installed value it replaced.
+ *
+ * The replacement targets the *receiver*, not `target`: these descriptors are
+ * also copied onto the exported namespace, so writing back to `target` would
+ * leave the object actually being read still holding an accessor and rebuild on
+ * every access — 7.4% of process CPU when this was wrong.
+ */
+const defineLazyValue = (target, key, build) => {
+    const settle = (receiver, value) => {
+        const owner = (isObject(receiver) || typeof receiver === 'function' ? receiver : target);
+        Object.defineProperty(owner, key, { configurable: true, enumerable: true, value, writable: true });
+    };
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const value = build();
+            settle(this, value);
+            return value;
+        },
+        set(value) {
+            settle(this, value);
+        }
+    });
+};
 class ProtoCompatibilityRuntime {
     constructor(sourceNamespace) {
         this.namespace = { ...sourceNamespace };
@@ -171,15 +209,41 @@ class ProtoCompatibilityRuntime {
             const candidate = lookupPath(sourceNamespace, path);
             return isSourceCodec(candidate) ? candidate : undefined;
         });
-        this.constructors = PROTO_MESSAGE_SCHEMAS.map(([, fields], schemaId) => this.makeConstructor(schemaId, fields, this.sourceCodecs[schemaId]));
+        // Building all 498 eagerly cost ~4.6 MB of RSS in every importing process
+        // while a full connection touches under a dozen. `Array.from` rather than
+        // `new Array(n)` keeps the array packed, so `constructorFor`'s indexed read
+        // stays on the fast element kind.
+        this.constructors = Array.from({ length: PROTO_MESSAGE_SCHEMAS.length });
         this.unsupportedCodecs = Object.freeze(PROTO_MESSAGE_SCHEMAS.flatMap(([path], schemaId) => (this.sourceCodecs[schemaId] ? [] : [path])));
-        const messageIds = PROTO_MESSAGE_SCHEMAS.map((_, index) => index).toSorted((left, right) => schemaDepth(PROTO_MESSAGE_SCHEMAS[left][0]) - schemaDepth(PROTO_MESSAGE_SCHEMAS[right][0]));
-        for (const schemaId of messageIds) {
-            installPath(this.namespace, PROTO_MESSAGE_SCHEMAS[schemaId][0], this.constructors[schemaId]);
-        }
-        const enumIds = PROTO_ENUM_SCHEMAS.map((_, index) => index).toSorted((left, right) => schemaDepth(PROTO_ENUM_SCHEMAS[left][0]) - schemaDepth(PROTO_ENUM_SCHEMAS[right][0]));
-        for (const enumId of enumIds)
-            installPath(this.namespace, PROTO_ENUM_SCHEMAS[enumId][0], this.enums[enumId].publicValue);
+        const tree = buildSchemaTree(PROTO_MESSAGE_SCHEMAS.map(([path]) => path), PROTO_ENUM_SCHEMAS.map(([path]) => path));
+        for (const [name, node] of tree)
+            this.installNode(this.namespace, name, node);
+    }
+    /**
+     * Nested types are installed only once their container is read, so using a
+     * container does not build what is nested inside it.
+     */
+    installNode(target, name, node) {
+        defineLazyValue(target, name, () => {
+            // Build once: this getter is reachable from both this namespace and the
+            // exported copy, and a second build would reinstall accessors over
+            // entries a caller had already resolved.
+            if (node.value === undefined) {
+                const value = node.messageId !== undefined
+                    ? this.constructorFor(node.messageId)
+                    : node.enumId !== undefined
+                        ? this.enums[node.enumId].publicValue
+                        : {};
+                node.value = value;
+                for (const [childName, child] of node.children)
+                    this.installNode(value, childName, child);
+            }
+            return node.value;
+        });
+    }
+    constructorFor(schemaId) {
+        var _a;
+        return ((_a = this.constructors)[schemaId] ?? (_a[schemaId] = this.makeConstructor(schemaId, PROTO_MESSAGE_SCHEMAS[schemaId][1], this.sourceCodecs[schemaId])));
     }
     makeEnum(entries) {
         const publicValue = {};
@@ -312,7 +376,7 @@ class ProtoCompatibilityRuntime {
         }
     }
     fromObject(schemaId, input) {
-        const constructor = this.constructors[schemaId];
+        const constructor = this.constructorFor(schemaId);
         if (input instanceof constructor)
             return input;
         const data = input;
@@ -494,34 +558,44 @@ class ProtoCompatibilityRuntime {
         const reader = new LongBinaryReader(asUint8Array(input));
         return this.hydrate(schemaId, codec.decode(reader, length));
     }
+    /**
+     * A fresh instance rather than an in-place re-parent: the codec installs its
+     * own `toJSON` on what it returns, and deleting that normalizes the object
+     * into dictionary mode, where every later read is a megamorphic lookup.
+     */
     hydrate(schemaId, value) {
-        const object = isObject(value) ? value : {};
+        const source = isObject(value) ? value : {};
+        const instance = Object.create(this.constructorFor(schemaId).prototype);
         const messageFields = this.messageFieldsByName[schemaId];
-        for (const key in object) {
+        for (const key in source) {
+            const nested = source[key];
             const field = messageFields[key];
-            if (!field)
-                continue;
-            const nested = object[key];
-            if (field[3] & PROTO_FIELD_FLAG.repeated) {
-                if (Array.isArray(nested))
-                    for (const item of nested)
-                        if (isObject(item))
-                            this.hydrate(field[2], item);
+            if (!field) {
+                instance[key] = nested;
             }
-            else if (field[3] & PROTO_FIELD_FLAG.map) {
-                if (isObject(nested))
-                    for (const item of Object.values(nested))
+            else if (field[3] & PROTO_FIELD_FLAG.repeated) {
+                if (Array.isArray(nested)) {
+                    for (let index = 0; index < nested.length; index++) {
+                        const item = nested[index];
                         if (isObject(item))
-                            this.hydrate(field[2], item);
+                            nested[index] = this.hydrate(field[2], item);
+                    }
+                }
+                instance[key] = nested;
             }
-            else if (isObject(nested)) {
-                this.hydrate(field[2], nested);
+            else if (field[3] & PROTO_FIELD_FLAG.map && isObject(nested)) {
+                const entries = {};
+                for (const entry in nested) {
+                    const item = nested[entry];
+                    entries[entry] = isObject(item) ? this.hydrate(field[2], item) : item;
+                }
+                instance[key] = entries;
+            }
+            else {
+                instance[key] = isObject(nested) ? this.hydrate(field[2], nested) : nested;
             }
         }
-        if (hasOwn(object, 'toJSON'))
-            delete object.toJSON;
-        Object.setPrototypeOf(object, this.constructors[schemaId].prototype);
-        return object;
+        return instance;
     }
     projectForEncode(schemaId, value) {
         if (!isObject(value))

package/lib/Compatibility/socket-results.d.ts

@@ -1,4 +1,4 @@
-import type { BlocklistEntryResult, BusinessProfileResult, MembershipRequestResult, ParticipantChangeResult } from 'whatsapp-rust-bridge';
+import type { BlocklistEntryResult, BusinessProfileResult, MembershipRequestResult, ParticipantChangeResult } from '@oxidezap/whatsapp-rust-bridge';
 import type { BinaryNode, WABusinessProfile } from '../Types/index.js';
 export type ParticipantUpdateResult = {
     status: string;

package/lib/Compatibility/stanza-responses.d.ts

@@ -1,4 +1,4 @@
-import type { WasmWhatsAppClient } from 'whatsapp-rust-bridge';
+import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import type { BinaryNode } from '../Types/index.js';
 type StanzaResponseClient = Pick<WasmWhatsAppClient, 'acknowledgeStanza' | 'rejectStanza' | 'requestMessageRetry'>;
 export interface StanzaResponseContext {

package/lib/Compatibility/usync/adapter.d.ts

@@ -1,4 +1,4 @@
-import type { UsyncQuery as NativeUsyncQuery, UsyncResponse as NativeUsyncResponse } from 'whatsapp-rust-bridge';
+import type { UsyncQuery as NativeUsyncQuery, UsyncResponse as NativeUsyncResponse } from '@oxidezap/whatsapp-rust-bridge';
 import type { BinaryNode } from '../../Types/index.js';
 import { type USyncQuery, type USyncQueryResult } from '../../WAUSync/USyncQuery.js';
 export type RawUSyncQuery = (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;

package/lib/Compatibility/websocket-client.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { URL } from 'node:url';
-import type { WasmWhatsAppClient } from 'whatsapp-rust-bridge';
+import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import type { SocketConfig } from '../Types/index.js';
 type ReadyState = 0 | 1 | 2 | 3;
 type EventListener = Parameters<EventEmitter['on']>[1];
@@ -12,8 +12,13 @@ export declare class WebSocketClient extends EventEmitter {
     protected readonly socket: {
         readonly readyState: ReadyState;
     };
-    private closing;
-    private closed;
+    /**
+     * One value rather than a pair of booleans plus a promise that could
+     * disagree with them. `closing` carries the in-flight close so a second
+     * caller joins it instead of returning while the first `disconnect()` is
+     * still running — which is how teardown reached `free()` on a busy client.
+     */
+    private closeState;
     private readonly getClient;
     private listenerMutationDepth;
     constructor(url: string | URL, config: SocketConfig, getClient: () => WasmWhatsAppClient | undefined);
@@ -32,6 +37,22 @@ export declare class WebSocketClient extends EventEmitter {
     off(eventName: string | symbol, listener: EventListener): this;
     removeAllListeners(eventName?: string | symbol): this;
     connect(): void;
+    /**
+     * Idempotent, and a second caller joins the first rather than returning
+     * while it is still going.
+     *
+     * The early return used to be bare: `void ws.close(); await sock.end()` saw
+     * the flag, returned immediately, and let teardown reach `free()` with the
+     * original `disconnect()` still in flight — the wasm heap corruption
+     * `bridge-free-safety.test.ts` documents. Awaiting a *second* `disconnect()`
+     * does not join the first one.
+     *
+     * The state is stored before `disconnect()` is called, and the work is
+     * deferred by a microtask to make that ordering hold: an inline async body
+     * runs eagerly to its first `await`, so `disconnect()` would be invoked
+     * while the state still said `open`, and anything it reaches synchronously
+     * that calls back into `close()` would issue a second one.
+     */
     close(): Promise<void>;
     send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
     private get readyState();