@oxidezap/baileyrs 0.0.31 → 0.0.35

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;
@@ -520,7 +584,7 @@ class ProtoCompatibilityRuntime {
         }
         if (hasOwn(object, 'toJSON'))
             delete object.toJSON;
-        Object.setPrototypeOf(object, this.constructors[schemaId].prototype);
+        Object.setPrototypeOf(object, this.constructorFor(schemaId).prototype);
         return object;
     }
     projectForEncode(schemaId, 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];

package/lib/Socket/communities.d.ts

@@ -20,7 +20,7 @@ export declare const makeCommunityMethods: (ctx: SocketContext, groups?: {
     groupRevokeInvite: (jid: string) => Promise<string | undefined>;
     groupAcceptInvite: (code: string) => Promise<string | undefined>;
     groupRevokeInviteV4: (groupJid: string, invitedJid: string) => Promise<boolean>;
-    groupAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("whatsapp-rust-bridge/proto-types").proto.Message.IGroupInviteMessage) => Promise<any>;
+    groupAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("@oxidezap/whatsapp-rust-bridge/proto-types").proto.Message.IGroupInviteMessage) => Promise<any>;
     groupGetInviteInfo: (code: string) => Promise<GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
     groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
@@ -49,7 +49,7 @@ export declare const makeCommunityMethods: (ctx: SocketContext, groups?: {
     communityRevokeInvite: (jid: string) => Promise<string | undefined>;
     communityAcceptInvite: (code: string) => Promise<string | undefined>;
     communityRevokeInviteV4: (communityJid: string, invitedJid: string) => Promise<boolean>;
-    communityAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("whatsapp-rust-bridge/proto-types").proto.Message.IGroupInviteMessage) => Promise<any>;
+    communityAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("@oxidezap/whatsapp-rust-bridge/proto-types").proto.Message.IGroupInviteMessage) => Promise<any>;
     communityGetInviteInfo: (code: string) => Promise<GroupMetadata>;
     communityToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
     communitySettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;

package/lib/Socket/contacts.d.ts

@@ -12,6 +12,6 @@ export type OnWhatsAppResult = {
 export declare const makeContactMethods: (ctx: SocketContext) => {
     onWhatsApp: (...phoneNumber: string[]) => Promise<OnWhatsAppResult[] | undefined>;
     profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number) => Promise<string | undefined>;
-    fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("whatsapp-rust-bridge").UserInfoResult>>;
+    fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("@oxidezap/whatsapp-rust-bridge").UserInfoResult>>;
 };
 //# sourceMappingURL=contacts.d.ts.map

package/lib/Socket/events.d.ts

@@ -6,7 +6,7 @@
  * mapped type so TS forces a handler per variant — a missing handler
  * is a compile error.
  */
-import type { WhatsAppEvent, WhatsAppEventCallbacks } from 'whatsapp-rust-bridge';
+import type { WhatsAppEvent, WhatsAppEventCallbacks } from '@oxidezap/whatsapp-rust-bridge';
 import type { CanonicalEvent } from '../Bridge/index.js';
 import type { SocketContext } from './types.js';
 interface EventCallbacks {

package/lib/Socket/events.js

@@ -7,7 +7,7 @@
  * is a compile error.
  */
 import Long from 'long';
-import { BinaryReader, decodeMessageWireInfos, decodeReceiptWireBatch, decodeServerAckWireBatch } from 'whatsapp-rust-bridge';
+import { BinaryReader, decodeMessageWireBatch, decodeReceiptWireBatch, decodeServerAckWireBatch } from '@oxidezap/whatsapp-rust-bridge';
 import { adaptBridgeEvent, adaptBridgeMessageWire } from '../Bridge/index.js';
 import { decodeHistorySyncWireBatch } from '../Bridge/history-sync-wire.js';
 import { bridgeGroupMetadataToBaileys } from '../Compatibility/group-metadata.js';
@@ -25,7 +25,6 @@ import { mapReachoutTimelock } from './reachout.js';
 const CANONICAL_MESSAGE_EVENT = 'message';
 const MESSAGE_UPSERT_APPEND = 'append';
 const MESSAGE_UPSERT_NOTIFY = 'notify';
-const MESSAGE_WIRE_OFFSET_SENTINEL_COUNT = 1;
 /** Emit CB: pattern events on the ws EventEmitter for retrocompat. */
 const emitCBEvents = (ctx, node) => {
     const { ws } = ctx;
@@ -791,35 +790,30 @@ export const makeEventHandlers = (ctx, callbacks) => {
             dispatchCanonicalEvent(canonical, dispatchCtx);
     };
     const onMessageBatch = (batch) => {
-        if (batch.messageOffsets.length < MESSAGE_WIRE_OFFSET_SENTINEL_COUNT) {
-            ctx.logger.error('message wire batch is missing its leading offset');
-            return;
-        }
-        const messageCount = batch.messageOffsets.length - MESSAGE_WIRE_OFFSET_SENTINEL_COUNT;
-        let infos;
+        // The batch crosses as one buffer; the decoder validates its header and
+        // returns views over it, so payload count and metadata count agree by
+        // construction.
+        let view;
         try {
-            infos = decodeMessageWireInfos(batch);
+            view = decodeMessageWireBatch(batch);
         }
         catch (err) {
-            ctx.logger.error({ err }, 'failed to decode message wire metadata records');
-            return;
-        }
-        if (infos.length !== messageCount) {
-            ctx.logger.error({ infoCount: infos.length, messageCount }, 'message wire batch metadata count does not match its payload count');
+            ctx.logger.error({ err }, 'failed to decode the message wire batch');
             return;
         }
+        const { messageData, messageOffsets, infos } = view;
         // Decode through the runtime facade so each payload materializes as a
         // hydrated runtime instance: `WebMessageInfo.fromObject` then keeps the
         // message subtree via its instanceof short-circuit instead of walking
         // and reallocating the whole tree — the dominant per-message allocation
         // cost on the hot path. Lenient like the history-sync decoder: one
         // malformed payload is skipped, not fatal to the batch.
-        const messages = Array.from({ length: messageCount });
-        const reader = new BinaryReader(batch.messageData);
-        for (let index = 0; index < messageCount; index++) {
+        const messages = Array.from({ length: infos.length });
+        const reader = new BinaryReader(messageData);
+        for (let index = 0; index < infos.length; index++) {
             try {
-                const start = batch.messageOffsets[index];
-                const end = batch.messageOffsets[index + 1];
+                const start = messageOffsets[index];
+                const end = messageOffsets[index + 1];
                 reader.pos = start;
                 messages[index] = WAProto.Message.decode(reader, end - start);
             }
@@ -828,7 +822,7 @@ export const makeEventHandlers = (ctx, callbacks) => {
                 ctx.logger.warn({ err, index }, 'skipping malformed wire message');
             }
         }
-        dispatchCanonicalBatch(ctx, dispatchCtx, messageCount, index => adaptBridgeMessageWire(messages[index], infos[index], ctx.logger));
+        dispatchCanonicalBatch(ctx, dispatchCtx, infos.length, index => adaptBridgeMessageWire(messages[index], infos[index], ctx.logger));
     };
     const onHistorySyncBatch = (batch) => {
         const decoded = decodeHistorySyncWireBatch(batch, ctx.logger);

package/lib/Socket/index.d.ts

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { type UploadMediaResult, type WasmWhatsAppClient } from 'whatsapp-rust-bridge';
+import { type UploadMediaResult, type WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import { WebSocketClient } from '../Compatibility/websocket-client.js';
 import { type MediaType } from '../Defaults/index.js';
 import type { BinaryNode, AuthenticationCreds, ConnectionState, Contact, ReachoutTimelockState, SignalKeyStoreWithTransaction, UserFacingSocketConfig, WAPrivacyGroupAddValue, WAPrivacyOnlineValue, WAPrivacyValue, WABusinessProfile, WAReadReceiptsValue, WAMessage, WAMessageKey } from '../Types/index.js';
@@ -20,7 +20,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     resyncAppState: (_collections?: readonly import("../index.js").WAPatchName[], _isInitialSync?: boolean) => Promise<void>;
     onWhatsApp: (...phoneNumber: string[]) => Promise<import("./contacts.js").OnWhatsAppResult[] | undefined>;
     profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number) => Promise<string | undefined>;
-    fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("whatsapp-rust-bridge").UserInfoResult>>;
+    fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("@oxidezap/whatsapp-rust-bridge").UserInfoResult>>;
     groupMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<import("../index.js").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
@@ -81,9 +81,9 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../index.js").MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: WAMessageKey[], type: import("../index.js").MessageReceiptType) => Promise<void>;
     requestPlaceholderResend: (messageKey: WAMessageKey, msgData?: Partial<WAMessage>) => Promise<string | undefined>;
-    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>;
     newsletterMute: (jid: string, mute: boolean) => Promise<void>;

package/lib/Socket/index.js

@@ -1,6 +1,6 @@
 import { Buffer } from 'node:buffer';
 import { randomBytes } from 'node:crypto';
-import { createWhatsAppClient, encodeProto, initWasmEngine } from 'whatsapp-rust-bridge';
+import { createWhatsAppClient, encodeProto, initWasmEngine } from '@oxidezap/whatsapp-rust-bridge';
 import { normalizeSocketAuthenticationState } from '../Compatibility/internal/auth-state.js';
 import { makeMutex } from '../Compatibility/internal/make-mutex.js';
 import { isNativeMemoryStore } from '../Compatibility/internal/native-memory-store.js';

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';

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/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/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';

package/lib/Utils/messages.js

@@ -746,9 +746,12 @@ export const downloadContentFromMessage = async (mediaContent, type, opts = {})
         throw new Boom('downloadContentFromMessage: no bridge client available. ' +
             'Pass `opts.client = sock.waClient`, or call after `makeWASocket()` has initialized.', { statusCode: 500 });
     }
+    // `url` is seeded because the media guard downstream keys off its presence,
+    // and content addressed only by `directPath` (history-sync notifications
+    // carry no `url` field at all) would otherwise be rejected as non-media.
     const fakeMessage = {
         key: {},
-        message: { [`${type}Message`]: mediaContent }
+        message: { [`${type}Message`]: { url: null, ...mediaContent } }
     };
     return downloadMediaMessage(fakeMessage, 'stream', opts, {
         logger: opts.logger ?? activeBridgeLogger ?? noopLogger,

package/lib/Utils/process-history-message.js

@@ -10,9 +10,7 @@
  * are limited to swapping upstream imports for baileyrs equivalents and
  * keeping the WAProto namespace as our re-export.
  */
-import { pipeline } from 'node:stream/promises';
-import { promisify } from 'node:util';
-import { createInflate, inflate } from 'node:zlib';
+import { inflateZlib } from '@oxidezap/whatsapp-rust-bridge';
 import { proto } from '../WAProto/runtime.js';
 import { WAProto } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/jid-utils.js';
@@ -21,7 +19,6 @@ import { toNumber } from './generics.js';
 import { downloadContentFromMessage, normalizeMessageContent } from './messages.js';
 import { createSparseArray } from './sparse-array.js';
 const STUB = WAProto.WebMessageInfo.StubType;
-const inflatePromise = promisify(inflate);
 const extractPnFromMessages = (messages) => {
     for (let index = 0; index < messages.length; index++) {
         const msgItem = messages[index];
@@ -190,16 +187,15 @@ export const processHistoryMessage = (item, logger) => {
 /** Download, decrypt and inflate an external history-sync blob. */
 export const downloadHistory = async (msg, options) => {
     const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
-    const inflater = createInflate();
-    const chunks = [];
-    inflater.on('data', (chunk) => chunks.push(chunk));
-    await pipeline(stream, inflater);
-    return proto.HistorySync.decode(Buffer.concat(chunks));
+    const compressed = [];
+    for await (const chunk of stream)
+        compressed.push(chunk);
+    return proto.HistorySync.decode(inflateZlib(Buffer.concat(compressed)));
 };
 /** Resolve inline or external history-sync content and normalize its public payload. */
 export const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
     const historyMsg = msg.initialHistBootstrapInlinePayload
-        ? proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload))
+        ? proto.HistorySync.decode(inflateZlib(msg.initialHistBootstrapInlinePayload))
         : await downloadHistory(msg, options);
     return processHistoryMessage(historyMsg, logger);
 };

package/lib/Utils/process-message.js

@@ -1,6 +1,6 @@
 import { WAMessageStubType } from '../Types/index.js';
 import { proto } from '../WAProto/runtime.js';
-import { decryptEventResponsePayload, decryptPollVotePayload } from 'whatsapp-rust-bridge';
+import { decryptEventResponsePayload, decryptPollVotePayload } from '@oxidezap/whatsapp-rust-bridge';
 import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJidStatusBroadcast, jidDecode, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
 import { Boom } from './boom.js';
 import { getContentType, normalizeMessageContent } from './messages.js';

package/lib/WAProto/runtime.js

@@ -4,13 +4,16 @@
  * compatibility layer below translates constructor/object semantics while the
  * bridge remains the single protobuf codec shipped by this package.
  */
-import { proto as bridgeProto } from 'whatsapp-rust-bridge/proto-types';
+import { proto as bridgeProto } from '@oxidezap/whatsapp-rust-bridge/proto-types';
 import { createProtoCompatibilityFacade } from '../Compatibility/proto-runtime.js';
 const facade = createProtoCompatibilityFacade(bridgeProto);
 // Re-exporting the original namespace alias preserves its generated type
 // namespace for internal `proto.IMessage` references. The facade already
 // captured every neutral codec before these top-level values are replaced.
-Object.assign(bridgeProto, facade.proto);
+//
+// Descriptors, not values: the facade's entries are lazy getters, and
+// Object.assign would read — and therefore build — every one of them.
+Object.defineProperties(bridgeProto, Object.getOwnPropertyDescriptors(facade.proto));
 export { bridgeProto as proto };
 /** Internal audit signal; intentionally absent from the public package root. */
 export const unsupportedProtoCodecs = facade.unsupportedCodecs;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.0.31",
+  "version": "0.0.35",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",
@@ -75,10 +75,10 @@
   },
   "dependencies": {
     "@hapi/boom": "^9.1.4",
+    "@oxidezap/whatsapp-rust-bridge": "0.6.4",
     "long": "^5.3.2",
     "pino": "^10.3.1",
-    "protobufjs": "^7.6.5",
-    "whatsapp-rust-bridge": "0.6.0-alpha.41"
+    "protobufjs": "^7.6.5"
   },
   "devDependencies": {
     "@bufbuild/protobuf": "^2.13.0",