@oxidezap/baileyrs 0.2.2 → 0.2.4

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/message-relay.d.ts

@@ -1,9 +1,16 @@
 import type { MessageRetransmissionInput } from '@oxidezap/whatsapp-rust-bridge';
 import type { BinaryNode, MessageRelayOptions } from '../Types/index.js';
-type OwnRelayIdentity = {
+export declare const EMPTY_RELAY_NODES: BinaryNode[];
+export type OwnRelayIdentity = {
     id?: string;
     lid?: string;
 } | undefined;
+/**
+ * The one place that decides between the caller's id and a generated one.
+ * Every send path resolves through here, so `messageId` means the same thing
+ * on `sendMessage` and on `relayMessage`.
+ */
+export declare const resolveMessageId: (own: OwnRelayIdentity, messageId?: string) => string;
 export type MessageRelayPlan = {
     kind: 'message';
     messageId: string;
@@ -22,5 +29,4 @@ export type MessageRelayPlan = {
     input: MessageRetransmissionInput;
 };
 export declare const planMessageRelay: (jid: string, options: MessageRelayOptions, own: OwnRelayIdentity) => MessageRelayPlan;
-export {};
 //# sourceMappingURL=message-relay.d.ts.map

package/lib/Compatibility/message-relay.js

@@ -1,7 +1,13 @@
 import { Boom } from '../Utils/boom.js';
 import { generateMessageIDV2 } from '../Utils/generics.js';
 import { areJidsSameUser, isJidBroadcast, isJidGroup, isJidNewsletter } from '../WABinary/index.js';
-const EMPTY_RELAY_NODES = [];
+export const EMPTY_RELAY_NODES = [];
+/**
+ * The one place that decides between the caller's id and a generated one.
+ * Every send path resolves through here, so `messageId` means the same thing
+ * on `sendMessage` and on `relayMessage`.
+ */
+export const resolveMessageId = (own, messageId) => messageId || generateMessageIDV2(own?.id);
 const assertSupportedAttributes = (attributes) => {
     if (!attributes)
         return;
@@ -24,7 +30,7 @@ export const planMessageRelay = (jid, options, own) => {
             statusCode: 400
         });
     }
-    const id = messageId || generateMessageIDV2(own?.id);
+    const id = resolveMessageId(own, messageId);
     const refreshGroupMetadata = useCachedGroupMetadata === false;
     if (participant) {
         const requesterIsOwnDevice = isDirectConversation(jid) && isOwnDevice(participant.jid, own);

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,7 +1,7 @@
 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';
+import { EMPTY_RELAY_NODES, planMessageRelay, resolveMessageId } from '../Compatibility/message-relay.js';
 import { receiptMessageKeys } from '../Compatibility/message-keys.js';
 import { MESSAGE_RECEIPT_TYPES, WAProto } from '../Types/index.js';
 import { assertArgumentDomain } from '../Utils/argument-domain.js';
@@ -52,6 +52,12 @@ export const makeMessageMethods = (ctx) => ({
         if (contentType === 'protocolMessage') {
             const protoMsg = msg.protocolMessage;
             if (protoMsg?.type === WAProto.Message.ProtocolMessage.Type.REVOKE && protoMsg?.key?.id) {
+                if (options?.messageId) {
+                    // The core has no revoke variant that takes a stanza id, so
+                    // the option cannot be honoured here. Saying so beats the
+                    // silent drop this option used to get on every path.
+                    ctx.logger.warn({ jid, messageId: options.messageId }, 'messageId option cannot be honoured for a revoke: the core assigns the stanza id itself');
+                }
                 // Group revokes need the original sender's participant JID —
                 // without it the server rejects the revoke. The bridge
                 // signature is `revokeMessage(jid, message_id, participant?)`.
@@ -65,15 +71,26 @@ export const makeMessageMethods = (ctx) => ({
                 protoMsg?.key?.id &&
                 protoMsg?.editedMessage) {
                 const editBytes = WAProto.Message.encode(protoMsg.editedMessage).finish();
-                const newMsgId = await client.editMessageBytes(jid, protoMsg.key.id, editBytes);
+                // Edit-path counterpart of `options.messageId` on a plain send, and
+                // deliberately not `resolveMessageId`: the engine treats any supplied
+                // stanza id as borrowed and binds no id-keyed state to it, so an edit
+                // nobody asked to pin would silently lose its retry-cache entry and
+                // outbound secret. Absent stays absent. `||` and not `??` because an
+                // empty id means unspecified everywhere else in this API.
+                const editStanzaId = options?.messageId || undefined;
+                const newMsgId = await client.editMessageBytes(jid, protoMsg.key.id, editBytes, editStanzaId);
                 fullMsg.key.id = newMsgId || fullMsg.key.id;
                 return fullMsg;
             }
         }
         const msgBytes = encodeProtoCompat('Message', msg);
+        // The with-options sends are the same core send as the plain ones, with
+        // the stanza id supplied by the caller instead of drawn by the engine.
+        // The id resolves through the same place `relayMessage` resolves it.
+        const messageId = resolveMessageId(ctx.getUser(), options?.messageId);
         const msgId = await sendReportingUpstreamFailure(() => jid === 'status@broadcast' && options?.statusJidList?.length
-            ? client.sendStatusMessageBytes(msgBytes, options.statusJidList)
-            : client.sendMessageBytes(jid, msgBytes));
+            ? client.sendStatusMessageBytesWithOptions(msgBytes, options.statusJidList, messageId, EMPTY_RELAY_NODES, false)
+            : client.relayMessageBytesWithOptions(jid, msgBytes, messageId, EMPTY_RELAY_NODES, false, false));
         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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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.13.0",
+    "@oxidezap/whatsapp-rust-bridge": "0.15.0",
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5"