@oxidezap/baileyrs 0.2.1 → 0.2.3

package/lib/Bridge/schema.js

@@ -179,10 +179,6 @@ const ADAPTERS = {
         };
     },
     // ── Contacts ──
-    push_name_update: data => {
-        const jid = asJidString(data?.jid);
-        return jid ? { type: 'pushNameUpdate', jid, newPushName: asString(data?.new_push_name) } : null;
-    },
     contact_update: data => adaptContactUpdate(data),
     contact_updated: data => adaptContactUpdate(data),
     picture_update: data => {
@@ -456,6 +452,7 @@ const ADAPTERS = {
     },
     // ── Acknowledged but no Baileys equivalent (noop) ──
     self_push_name_updated: () => ({ type: 'noop', bridgeType: 'self_push_name_updated' }),
+    client_expiration_changed: () => ({ type: 'noop', bridgeType: 'client_expiration_changed' }),
     offline_sync_completed: data => ({
         type: 'offlineSyncCompleted',
         count: asNumber(data?.count) ?? 0

package/lib/Bridge/types.d.ts

@@ -173,11 +173,6 @@ export interface CanonicalReceipt {
      */
     receiptType?: 'delivered' | 'sent' | 'sender' | 'retry' | 'enc-rekey-retry' | 'read' | 'read-self' | 'played' | 'played-self' | 'inactive' | 'peer-msg' | 'history-sync' | 'server-error' | 'other';
 }
-export interface CanonicalPushNameUpdate {
-    type: 'pushNameUpdate';
-    jid: string;
-    newPushName?: string;
-}
 export interface CanonicalContactUpdate {
     type: 'contactUpdate';
     jid: string;
@@ -713,5 +708,5 @@ export interface CanonicalServerAck {
     timestamp?: number;
     error?: string;
 }
-export type CanonicalEvent = CanonicalConnected | CanonicalDisconnected | CanonicalQR | CanonicalPairSuccess | CanonicalPairError | CanonicalLoggedOut | CanonicalConnectFailure | CanonicalStreamError | CanonicalStreamReplaced | CanonicalClientOutdated | CanonicalTemporaryBan | CanonicalQrScannedWithoutMultidevice | CanonicalMessage | CanonicalReceipt | CanonicalPushNameUpdate | CanonicalContactUpdate | CanonicalPictureUpdate | CanonicalPresence | CanonicalChatPresence | CanonicalGroupUpdate | CanonicalArchiveUpdate | CanonicalPinUpdate | CanonicalMuteUpdate | CanonicalStarUpdate | CanonicalMarkChatAsReadUpdate | CanonicalLabelEdit | CanonicalLabelAssociation | CanonicalAppStateSyncFailed | CanonicalQrCodesExhausted | CanonicalSettingUpdate | CanonicalIncomingCall | CanonicalUndecryptableMessage | CanonicalLidMappingUpdate | CanonicalNewsletterLiveUpdate | CanonicalChatDelete | CanonicalChatClear | CanonicalMessageDelete | CanonicalDisappearingModeChanged | CanonicalHistorySync | CanonicalOfflineSyncCompleted | CanonicalDirtyState | CanonicalRawNode | CanonicalNotification | CanonicalMexNotification | CanonicalServerAck | CanonicalNoop;
+export type CanonicalEvent = CanonicalConnected | CanonicalDisconnected | CanonicalQR | CanonicalPairSuccess | CanonicalPairError | CanonicalLoggedOut | CanonicalConnectFailure | CanonicalStreamError | CanonicalStreamReplaced | CanonicalClientOutdated | CanonicalTemporaryBan | CanonicalQrScannedWithoutMultidevice | CanonicalMessage | CanonicalReceipt | CanonicalContactUpdate | CanonicalPictureUpdate | CanonicalPresence | CanonicalChatPresence | CanonicalGroupUpdate | CanonicalArchiveUpdate | CanonicalPinUpdate | CanonicalMuteUpdate | CanonicalStarUpdate | CanonicalMarkChatAsReadUpdate | CanonicalLabelEdit | CanonicalLabelAssociation | CanonicalAppStateSyncFailed | CanonicalQrCodesExhausted | CanonicalSettingUpdate | CanonicalIncomingCall | CanonicalUndecryptableMessage | CanonicalLidMappingUpdate | CanonicalNewsletterLiveUpdate | CanonicalChatDelete | CanonicalChatClear | CanonicalMessageDelete | CanonicalDisappearingModeChanged | CanonicalHistorySync | CanonicalOfflineSyncCompleted | CanonicalDirtyState | CanonicalRawNode | CanonicalNotification | CanonicalMexNotification | CanonicalServerAck | CanonicalNoop;
 //# sourceMappingURL=types.d.ts.map

package/lib/Compatibility/all-encryptions-failed.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The rejection Baileys code expects, or the original error untouched.
+ *
+ * Narrow on purpose: only the engine's own `no-recipient-device` is rewritten,
+ * so every other failure still reaches the caller with the shape the bridge
+ * gave it.
+ */
+export declare const asAllEncryptionsFailed: (error: unknown) => unknown;
+/** Run a send, translating only that one rejection. */
+export declare const sendReportingUpstreamFailure: <T>(send: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=all-encryptions-failed.d.ts.map

package/lib/Compatibility/all-encryptions-failed.js

@@ -0,0 +1,49 @@
+import { Boom } from '../Utils/boom.js';
+/**
+ * A send that produced no ciphertext for its recipient.
+ *
+ * Upstream Baileys drops a device it cannot encrypt for and, when that leaves
+ * nothing, throws `Boom('All encryptions failed', { statusCode: 500 })`
+ * (`Socket/messages-send.ts`, in `createParticipantNodes`). The engine reached
+ * the same conclusion later: until `whatsapp-rust-bridge` 0.13.0 it returned a
+ * message id for a send that was never transmitted, and it now rejects with
+ * `no-recipient-device` instead.
+ *
+ * Same condition, different spelling, so it is translated here rather than
+ * left for the caller: Baileys code that branches on `statusCode === 500` or
+ * matches the message keeps working, and `attempted` rides along as extra
+ * data upstream has no way to carry.
+ */
+const NO_RECIPIENT_DEVICE = 'no-recipient-device';
+/** How many recipient devices the engine tried, when it said. */
+const attemptedFrom = (error) => {
+    const { attempted } = error;
+    return typeof attempted === 'number' ? attempted : undefined;
+};
+/**
+ * The rejection Baileys code expects, or the original error untouched.
+ *
+ * Narrow on purpose: only the engine's own `no-recipient-device` is rewritten,
+ * so every other failure still reaches the caller with the shape the bridge
+ * gave it.
+ */
+export const asAllEncryptionsFailed = (error) => {
+    if (typeof error !== 'object' || error === null)
+        return error;
+    if (error.kind !== NO_RECIPIENT_DEVICE)
+        return error;
+    return new Boom('All encryptions failed', {
+        statusCode: 500,
+        data: { attempted: attemptedFrom(error) }
+    });
+};
+/** Run a send, translating only that one rejection. */
+export const sendReportingUpstreamFailure = async (send) => {
+    try {
+        return await send();
+    }
+    catch (error) {
+        throw asAllEncryptionsFailed(error);
+    }
+};
+//# sourceMappingURL=all-encryptions-failed.js.map

package/lib/Socket/bridge-error-boundary.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Recreate a bridge rejection at the JS boundary so its stack names the caller.
+ *
+ * The engine constructs its errors inside wasm, in a microtask continuation
+ * that runs after the server response arrives. V8 captures the stack at
+ * construction, so what reaches the consumer is glue plus `wasm://` frames
+ * and never the code that made the call. Recreating the error inside a catch
+ * the caller is awaiting fixes that: V8's async stack walk names the awaiting
+ * frames, so a bot sees `at async itsOwnCommand` instead of function indices.
+ *
+ * What survives translation, and how:
+ *
+ *  - The engine sets its payload (`kind`, `serverCode`, `serverText`,
+ *    `errorType`, `backoffSeconds`, and whatever it adds next) and `name`
+ *    (`WhatsAppError`) as own enumerable properties, while `message` and
+ *    `stack` are own non-enumerable ones. `Object.assign` therefore copies
+ *    exactly the payload and the name, never touches the fresh stack, and
+ *    cannot invent a key the rejection did not carry.
+ *  - The original error becomes `cause`, so the wasm-side stack stays
+ *    reachable for whoever wants the engine's half of the story.
+ *  - Anything that is not the bridge's shape (an `Error` carrying a string
+ *    `kind`) passes through with the same identity it arrived with.
+ *
+ * The wrap happens once per client: `getClient()`/`getClientSync()` hand out
+ * a `Proxy` whose method wrappers are built on first access and cached, so
+ * the happy path pays one property trap and one extra promise layer, and the
+ * error path pays for everything else.
+ */
+import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
+/** Rebuild a bridge rejection here; return anything else untouched. */
+export declare const withCallerStack: (error: unknown) => unknown;
+/**
+ * The client the socket hands out. Methods bind to the raw client (wasm
+ * bindings need their own `this`), sync returns pass through untouched, and
+ * promise returns reject through `withCallerStack`.
+ */
+export declare const wrapBridgeClient: (client: WasmWhatsAppClient) => WasmWhatsAppClient;
+//# sourceMappingURL=bridge-error-boundary.d.ts.map

package/lib/Socket/bridge-error-boundary.js

@@ -0,0 +1,80 @@
+/**
+ * Recreate a bridge rejection at the JS boundary so its stack names the caller.
+ *
+ * The engine constructs its errors inside wasm, in a microtask continuation
+ * that runs after the server response arrives. V8 captures the stack at
+ * construction, so what reaches the consumer is glue plus `wasm://` frames
+ * and never the code that made the call. Recreating the error inside a catch
+ * the caller is awaiting fixes that: V8's async stack walk names the awaiting
+ * frames, so a bot sees `at async itsOwnCommand` instead of function indices.
+ *
+ * What survives translation, and how:
+ *
+ *  - The engine sets its payload (`kind`, `serverCode`, `serverText`,
+ *    `errorType`, `backoffSeconds`, and whatever it adds next) and `name`
+ *    (`WhatsAppError`) as own enumerable properties, while `message` and
+ *    `stack` are own non-enumerable ones. `Object.assign` therefore copies
+ *    exactly the payload and the name, never touches the fresh stack, and
+ *    cannot invent a key the rejection did not carry.
+ *  - The original error becomes `cause`, so the wasm-side stack stays
+ *    reachable for whoever wants the engine's half of the story.
+ *  - Anything that is not the bridge's shape (an `Error` carrying a string
+ *    `kind`) passes through with the same identity it arrived with.
+ *
+ * The wrap happens once per client: `getClient()`/`getClientSync()` hand out
+ * a `Proxy` whose method wrappers are built on first access and cached, so
+ * the happy path pays one property trap and one extra promise layer, and the
+ * error path pays for everything else.
+ */
+/**
+ * The bridge's rejection shape: a real `Error` the glue named `WhatsAppError`,
+ * carrying a string `kind`. The name check keeps consumer-owned errors that
+ * also discriminate on `kind` (a custom store or cache thrown through a
+ * bridge call) crossing by identity instead of being rebuilt.
+ */
+const isBridgeRejection = (error) => error instanceof Error && error.name === 'WhatsAppError' && typeof error.kind === 'string';
+/** Rebuild a bridge rejection here; return anything else untouched. */
+export const withCallerStack = (error) => {
+    if (!isBridgeRejection(error))
+        return error;
+    return Object.assign(new Error(error.message, { cause: error }), error);
+};
+const rethrowWithCallerStack = async (call) => {
+    try {
+        return await call;
+    }
+    catch (error) {
+        throw withCallerStack(error);
+    }
+};
+const wrappedClients = new WeakMap();
+/**
+ * The client the socket hands out. Methods bind to the raw client (wasm
+ * bindings need their own `this`), sync returns pass through untouched, and
+ * promise returns reject through `withCallerStack`.
+ */
+export const wrapBridgeClient = (client) => {
+    const memo = wrappedClients.get(client);
+    if (memo)
+        return memo;
+    const methods = new Map();
+    const wrapped = new Proxy(client, {
+        get(target, prop) {
+            const hit = methods.get(prop);
+            if (hit !== undefined)
+                return hit;
+            const value = Reflect.get(target, prop);
+            if (typeof value !== 'function')
+                return value;
+            const method = (...args) => {
+                const out = value.apply(target, args);
+                return out instanceof Promise ? rethrowWithCallerStack(out) : out;
+            };
+            methods.set(prop, method);
+            return method;
+        }
+    });
+    wrappedClients.set(client, wrapped);
+    return wrapped;
+};
+//# sourceMappingURL=bridge-error-boundary.js.map

package/lib/Socket/events.js

@@ -17,7 +17,7 @@ import { LabelAssociationType } from '../Types/LabelAssociation.js';
 import { Boom } from '../Utils/boom.js';
 import { toNumber } from '../Utils/generics.js';
 import { CONVERSATION_HISTORY_SYNC_TYPES } from '../Utils/process-history-message.js';
-import { isJidGroup } from '../WABinary/jid-utils.js';
+import { isJidBroadcast, isJidGroup } from '../WABinary/jid-utils.js';
 import { buildGroupCreateStubMessage, buildGroupJoinRequestEvents, buildGroupNotificationChatUpdates, buildGroupNotificationDomainEvent, buildGroupNotificationStubMessages } from '../Compatibility/group-notifications.js';
 import { emitMessageUpsert } from '../Compatibility/message-upsert.js';
 import { extractMessageCappingPayload } from './message-capping.js';
@@ -99,6 +99,20 @@ const messageUpsertMetadata = (message) => ({
     requestId: message.unavailableRequestId
 });
 const hasMessageSideEffects = (message) => message.messageProto.reactionMessage != null || message.messageProto.protocolMessage != null;
+// Mirror upstream `messages-recv.ts`: every inbound envelope that carries a
+// push name surfaces it as `contacts.update` with `notify`. This is also what
+// replaces the bridge's dedicated `push_name_update` event, gone in 0.14.0.
+const emitInboundPushName = (ctx, evt) => {
+    if (!evt.pushName || evt.isFromMe)
+        return;
+    const id = evt.senderJid ?? evt.chatJid;
+    // A broadcast envelope resolves to the pseudo-contact (the canonical layer
+    // drops the participant for non-groups); naming `status@broadcast` after
+    // whoever posted last would corrupt it, so stay silent instead.
+    if (isJidBroadcast(id))
+        return;
+    ctx.ev.emit('contacts.update', [{ id, notify: evt.pushName }]);
+};
 const hasSameUpsertMetadata = (left, right) => left.type === right.type && left.requestId === right.requestId;
 const clearHistorySyncPausedTimeout = (state) => {
     if (state.pausedTimeout)
@@ -315,6 +329,7 @@ const DISPATCHERS = {
     message: (evt, { ctx }) => {
         if (ctx.fullConfig.shouldIgnoreJid?.(evt.chatJid))
             return;
+        emitInboundPushName(ctx, evt);
         // Note: `emitOwnEvents=false` is NOT applied here. Upstream Baileys
         // uses that flag to suppress the local echo when `sendMessage()`
         // succeeds, not to drop inbound `fromMe` messages from other linked
@@ -422,6 +437,13 @@ const DISPATCHERS = {
         // can request a resend (PLACEHOLDER_MESSAGE_RESEND PDO). Logging
         // happens at debug — upstream considers this routine.
         ctx.logger.debug({ id: evt.id, chat: evt.chatJid, isUnavailable: evt.isUnavailable, fail: evt.decryptFailMode }, 'undecryptable message received');
+        // The name is envelope metadata, independent of whether the failure
+        // may be surfaced, so it goes out even for `hide`. The stub below
+        // predates `shouldIgnoreJid` and stays unguarded; the push name
+        // emission is new, so it honors the predicate like the other two
+        // call sites do.
+        if (!ctx.fullConfig.shouldIgnoreJid?.(evt.chatJid))
+            emitInboundPushName(ctx, evt);
         // `decrypt_fail_mode === 'hide'` means the server told us to
         // silently drop — match that by NOT emitting an upsert.
         if (evt.decryptFailMode === 'hide')
@@ -445,7 +467,6 @@ const DISPATCHERS = {
         ctx.ev.emit('messages.upsert', { messages: [stubMsg], type: 'notify' });
     },
     // ── Contacts ──
-    pushNameUpdate: (evt, { ctx }) => ctx.ev.emit('contacts.update', [{ id: evt.jid, notify: evt.newPushName }]),
     contactUpdate: (evt, { ctx }) => {
         // Promote ContactAction fields into upstream's `Partial<Contact>`
         // shape so consumers (sidebar UIs, contact pickers) see real names
@@ -869,6 +890,11 @@ const dispatchCanonicalBatch = (ctx, dispatchCtx, count, canonicalAt) => {
         if (ctx.fullConfig.shouldIgnoreJid?.(canonical.chatJid))
             continue;
         try {
+            // This branch bypasses the single-message dispatcher, so the push
+            // name has to be surfaced here too. Inside the try: a throwing
+            // consumer listener skips this message only, like the containment
+            // in dispatchCanonicalEvent.
+            emitInboundPushName(ctx, canonical);
             const metadata = messageUpsertMetadata(canonical);
             const message = canonicalMessageToWAMessage(canonical);
             if (pending && hasSameUpsertMetadata(pending, metadata)) {

package/lib/Socket/index.js

@@ -28,6 +28,7 @@ import { makeChatActionMethods } from './chat-actions.js';
 import { makeContactMethods } from './contacts.js';
 import { makeCommunityMethods } from './communities.js';
 import { makeBridgeClientOwner } from './bridge-client-owner.js';
+import { wrapBridgeClient } from './bridge-error-boundary.js';
 import { makeTerminalCloseReporter } from './terminal-close-reporter.js';
 import { makeEventHandlers } from './events.js';
 import { makeGroupMethods } from './groups.js';
@@ -224,7 +225,7 @@ const makeWASocket = (config) => {
             // Unregister before freeing: `free()` is swallowed, so ordering it
             // last would leave the module-level pointer aimed at a client that is
             // already gone if anything between them threw.
-            _unregisterActiveBridgeClient(client);
+            _unregisterActiveBridgeClient(wrapBridgeClient(client));
             try {
                 client.free();
             }
@@ -298,7 +299,7 @@ const makeWASocket = (config) => {
             if (initialized) {
                 const ready = owner.peek();
                 if (ready)
-                    return Promise.resolve(ready);
+                    return Promise.resolve(wrapBridgeClient(ready));
             }
             return initPromise.then(() => {
                 // Rechecked after the await: a close landing while startup was
@@ -319,7 +320,7 @@ const makeWASocket = (config) => {
                 const built = owner.peek();
                 if (!built)
                     throw new Boom('Client not initialized', { statusCode: 500 });
-                return built;
+                return wrapBridgeClient(built);
             });
         },
         getClientSync: () => {
@@ -330,7 +331,7 @@ const makeWASocket = (config) => {
             const built = owner.peek();
             if (!built)
                 throw new Boom('Client not initialized', { statusCode: 500 });
-            return built;
+            return wrapBridgeClient(built);
         }
     };
     // The native repository delegates Signal state directly to the core and does
@@ -459,8 +460,10 @@ const makeWASocket = (config) => {
         if (!owner.adopt(created))
             return owner.settled();
         // Fallback for standalone helpers like `downloadContentFromMessage`
-        // that carry no socket reference.
-        _registerActiveBridgeClient(created, logger);
+        // that carry no socket reference. Registered wrapped so those helpers
+        // reject with a caller stack too; the memoized wrap keeps the
+        // unregister identity check working.
+        _registerActiveBridgeClient(wrapBridgeClient(created), logger);
         // Replay a preference set before the client existed. `setAutoReconnect`
         // forwards through `client?.`, so `makeWASocket(cfg).setAutoReconnect(false)`
         // — the idiomatic first line — used to move only the JS mirror and leave
@@ -757,7 +760,8 @@ const makeWASocket = (config) => {
             };
         },
         get waClient() {
-            return owner.peek();
+            const live = owner.peek();
+            return live && wrapBridgeClient(live);
         },
         get isConnected() {
             return owner.peek()?.isConnected() ?? false;

package/lib/Socket/messages.js

@@ -1,3 +1,4 @@
+import { sendReportingUpstreamFailure } from '../Compatibility/all-encryptions-failed.js';
 import { sendDroppingDerivedNodes } from '../Compatibility/derived-stanza-nodes.js';
 import { encodeProtoCompat } from '../Compatibility/encode-proto.js';
 import { planMessageRelay } from '../Compatibility/message-relay.js';
@@ -69,14 +70,10 @@ export const makeMessageMethods = (ctx) => ({
                 return fullMsg;
             }
         }
-        let msgId;
         const msgBytes = encodeProtoCompat('Message', msg);
-        if (jid === 'status@broadcast' && options?.statusJidList?.length) {
-            msgId = await client.sendStatusMessageBytes(msgBytes, options.statusJidList);
-        }
-        else {
-            msgId = await client.sendMessageBytes(jid, msgBytes);
-        }
+        const msgId = await sendReportingUpstreamFailure(() => jid === 'status@broadcast' && options?.statusJidList?.length
+            ? client.sendStatusMessageBytes(msgBytes, options.statusJidList)
+            : client.sendMessageBytes(jid, msgBytes));
         fullMsg.key.id = msgId || fullMsg.key.id;
         // Local echo of the message we just sent. Suppressed when
         // `emitOwnEvents=false` so callers that explicitly opted out of seeing
@@ -150,9 +147,9 @@ export const makeMessageMethods = (ctx) => ({
         // either way.
         const drop = (tag) => ctx.logger.debug({ jid, messageId: plan.messageId, tag }, 'dropped an additionalNodes entry the engine derives from the message');
         if (plan.kind === 'status') {
-            return sendDroppingDerivedNodes(plan.nodes, nodes => client.sendStatusMessageBytesWithOptions(bytes, plan.recipients, plan.messageId, nodes, plan.refreshDevices), drop);
+            return sendReportingUpstreamFailure(() => sendDroppingDerivedNodes(plan.nodes, nodes => client.sendStatusMessageBytesWithOptions(bytes, plan.recipients, plan.messageId, nodes, plan.refreshDevices), drop));
         }
-        return sendDroppingDerivedNodes(plan.nodes, nodes => client.relayMessageBytesWithOptions(jid, bytes, plan.messageId, nodes, plan.refreshGroupMetadata, plan.refreshDevices), drop);
+        return sendReportingUpstreamFailure(() => sendDroppingDerivedNodes(plan.nodes, nodes => client.relayMessageBytesWithOptions(jid, bytes, plan.messageId, nodes, plan.refreshGroupMetadata, plan.refreshDevices), drop));
     },
     readMessages: async (keys) => {
         const receiptKeys = receiptMessageKeys(keys);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",
@@ -82,7 +82,7 @@
   },
   "dependencies": {
     "@hapi/boom": "^9.1.4",
-    "@oxidezap/whatsapp-rust-bridge": "0.12.0",
+    "@oxidezap/whatsapp-rust-bridge": "0.14.0",
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5"