@oxidezap/baileyrs 0.1.0 → 0.1.1

package/lib/Socket/events.js

@@ -813,7 +813,7 @@ const dispatchCanonicalEvent = (canonical, dispatchCtx) => {
     }
     catch (err) {
         // One bad event must not poison the rest of the pipeline.
-        dispatchCtx.ctx.logger.error({ err, type: canonical.type }, 'dispatcher threw — dropping event');
+        dispatchCtx.ctx.reportUnexpectedError(err, `dispatching a '${canonical.type}' event`);
     }
 };
 /** Aggregate adjacent ordinary messages while preserving every side-effecting
@@ -852,7 +852,7 @@ const dispatchCanonicalBatch = (ctx, dispatchCtx, count, canonicalAt) => {
             }
         }
         catch (err) {
-            ctx.logger.error({ err, type: CANONICAL_MESSAGE_EVENT }, 'dispatcher threw — dropping event');
+            ctx.reportUnexpectedError(err, `dispatching a '${CANONICAL_MESSAGE_EVENT}' event`);
         }
     }
     if (pending)
@@ -884,7 +884,7 @@ export const makeEventHandlers = (ctx, callbacks) => {
             view = decodeMessageWireBatch(batch);
         }
         catch (err) {
-            ctx.logger.error({ err }, 'failed to decode the message wire batch');
+            ctx.reportUnexpectedError(err, 'decoding the message wire batch');
             return;
         }
         const { messageData, messageOffsets, infos } = view;
@@ -923,7 +923,7 @@ export const makeEventHandlers = (ctx, callbacks) => {
             receipts = decodeReceiptWireBatch(batch);
         }
         catch (err) {
-            ctx.logger.error({ err }, 'failed to decode receipt wire batch');
+            ctx.reportUnexpectedError(err, 'decoding the receipt wire batch');
             return;
         }
         // The decoded payload matches the single-event wire shape; the union's
@@ -937,7 +937,7 @@ export const makeEventHandlers = (ctx, callbacks) => {
             acks = decodeServerAckWireBatch(batch);
         }
         catch (err) {
-            ctx.logger.error({ err }, 'failed to decode server-ack wire batch');
+            ctx.reportUnexpectedError(err, 'decoding the server-ack wire batch');
             return;
         }
         for (const data of acks)

package/lib/Socket/index.d.ts

@@ -2,7 +2,7 @@ import { Buffer } from 'node:buffer';
 import { type UploadMediaResult } 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';
+import type { BinaryNode, AuthenticationCreds, ConnectionState, Contact, ReachoutTimelockState, SignalKeyStoreWithTransaction, UserFacingSocketConfig, WABusinessProfile, WAMessage, WAMessageKey } from '../Types/index.js';
 import type Long from 'long';
 import type { MediaDownloadOptions } from '../Utils/messages-media.js';
 import type { proto } from '../WAProto/runtime.js';
@@ -12,12 +12,33 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     updateBlockStatus: (jid: string, action: 'block' | 'unblock') => Promise<void>;
     fetchBlocklist: () => Promise<Array<string | undefined>>;
+    getCatalog: ({ jid, limit, cursor }: import("../index.js").GetCatalogOptions) => Promise<import("../index.js").CatalogPage>;
+    getCollections: (jid?: string, limit?: number) => Promise<import("../index.js").CollectionsPage>;
+    getOrderDetails: (orderId: string, tokenBase64: string, sellerJid?: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").OrderResult>;
+    updateBussinesProfile: (args: import("../Types/Bussines.js").UpdateBussinesProfileProps) => Promise<void>;
+    updateCoverPhoto: (photo: import("../index.js").WAMediaUpload) => Promise<never>;
+    removeCoverPhoto: (id: string) => Promise<void>;
+    productCreate: (create: import("../index.js").ProductCreate) => Promise<never>;
+    productUpdate: (productId: string, update: import("../index.js").ProductUpdate) => Promise<never>;
+    productDelete: (productIds: string[]) => Promise<never>;
     pinChat: (jid: string, pin: boolean) => Promise<void>;
     muteChat: (jid: string, muteUntil?: number | null) => Promise<void>;
     archiveChat: (jid: string, archive: boolean) => Promise<void>;
     starMessage: (jid: string, messageId: string, star: boolean) => Promise<void>;
     chatModify: (mod: import("../index.js").ChatModification, jid: string) => Promise<void>;
-    resyncAppState: (_collections?: readonly import("../index.js").WAPatchName[], _isInitialSync?: boolean) => Promise<void>;
+    addOrEditContact: (jid: string, contact: proto.SyncActionValue.IContactAction) => Promise<void>;
+    removeContact: (jid: string) => Promise<void>;
+    addLabel: (jid: string, labels: import("../Types/Label.js").LabelActionBody) => Promise<void>;
+    addChatLabel: (jid: string, labelId: string) => Promise<void>;
+    removeChatLabel: (jid: string, labelId: string) => Promise<void>;
+    addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean;
+    }[], star: boolean) => Promise<void>;
+    addOrEditQuickReply: (quickReply: import("../Types/Bussines.js").QuickReplyAction) => Promise<void>;
+    removeQuickReply: (timestamp: string) => 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("@oxidezap/whatsapp-rust-bridge").UserInfoResult>>;
@@ -74,6 +95,14 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     communityMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
     communityJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
     communityFetchAllParticipating: () => Promise<Record<string, import("../index.js").GroupMetadata>>;
+    waitForSocketOpen: () => Promise<void>;
+    upsertMessage: (msg: WAMessage, type: import("../index.js").MessageUpsertType) => Promise<void>;
+    onUnexpectedError: (err: Error, msg: string) => void;
+    resyncAppState: (collections?: readonly ('critical_block' | 'critical_unblock_low' | 'regular_high' | 'regular_low' | 'regular')[], isInitialSync?: boolean) => Promise<void>;
+    updateServerTimeOffset: (node: BinaryNode) => never;
+    sendUnifiedSession: () => Promise<never>;
+    appPatch: (patchCreate: import("../index.js").WAPatchCreate) => Promise<never>;
+    messageRetryManager: null;
     sendMessage: (jid: string, content: import("../index.js").AnyMessageContent, options?: Omit<import("../index.js").MessageGenerationOptions, 'waClient' | 'logger' | 'userJid' | 'mediaInNote'>) => Promise<WAMessage>;
     updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;
     relayMessage: (jid: string, message: proto.IMessage, options: import("../index.js").MessageRelayOptions) => Promise<string>;
@@ -81,12 +110,31 @@ 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("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
-    newsletterMetadata: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
+    newsletterCreate: (name: string, description?: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterMetadata: (type: 'invite' | 'jid', key: string) => Promise<import("../index.js").NewsletterMetadata | null>;
+    newsletterUpdate: (jid: string, updates: import("../index.js").NewsletterUpdate) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUpdateDescription: (jid: string, description: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUpdatePicture: (jid: string, content: import("../index.js").WAMediaUpload) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterRemovePicture: (jid: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterFollow: (jid: string) => Promise<import("../index.js").NewsletterMetadata>;
+    newsletterUnfollow: (jid: string) => Promise<void>;
     newsletterSubscribe: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
     newsletterUnsubscribe: (jid: string) => Promise<void>;
+    newsletterMute: (jid: string) => Promise<void>;
+    newsletterUnmute: (jid: string) => Promise<void>;
+    newsletterSubscribers: (jid: string) => Promise<{
+        subscribers: number;
+    }>;
     newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
-    newsletterMute: (jid: string, mute: boolean) => Promise<void>;
+    newsletterFetchMessages: (jid: string, count: number, since?: number, after?: number) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMessageResult[]>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    }>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
+    newsletterDemote: (jid: string, userJid: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
     uploadPreKeys: (count?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     digestKeyBundle: () => Promise<void>;
@@ -94,6 +142,30 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendPresence: (status: 'available' | 'unavailable') => Promise<void>;
     presenceSubscribe: (toJid: string) => Promise<void>;
     sendChatState: (jid: string, state: 'composing' | 'recording' | 'paused') => Promise<void>;
+    fetchPrivacySettings: (force?: boolean) => Promise<any>;
+    updatePrivacySetting: (category: string, value: string) => Promise<void>;
+    updateLastSeenPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../index.js").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../index.js").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../index.js").WAPrivacyGroupAddValue) => Promise<void>;
+    updateCallPrivacy: (value: import("../index.js").WAPrivacyCallValue) => Promise<void>;
+    updateMessagesPrivacy: (value: import("../index.js").WAPrivacyMessagesValue) => Promise<void>;
+    issuePrivacyTokens: (jids: string[], timestamp?: number) => Promise<void>;
+    refreshMediaConn: (forceGet?: boolean) => Promise<Omit<import("../index.js").MediaConnInfo, 'hosts'> & {
+        hosts: {
+            hostname: string;
+        }[];
+    }>;
+    getMediaHost: () => string;
+    getBotListV2: () => Promise<import("../index.js").BotListInfo[]>;
+    fetchNewChatMessageCap: () => Promise<import("../index.js").NewChatMessageCapInfo & {
+        remaining_quota?: number;
+    }>;
+    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
+    sendPeerDataOperationMessage: (_pdoMessage: unknown) => Promise<never>;
+    createCallLink: (_type: 'audio' | 'video', _event?: unknown, _timeoutMs?: number) => Promise<never>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
     setPushName: (name: string) => Promise<void>;
     updateProfileName: (name: string) => Promise<void>;
@@ -176,7 +248,14 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T | undefined>;
     query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
-    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode['attrs']) => Promise<{
+    /**
+     * `dsmMessage` is accepted so the signature matches upstream, and
+     * refused rather than ignored. Upstream uses it to encrypt a different
+     * plaintext for the caller's own other devices; the engine encrypts one
+     * payload for every recipient, so honouring it is not possible here and
+     * dropping it would send those devices the wrong message.
+     */
+    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode['attrs'], dsmMessage?: proto.IMessage) => Promise<{
         nodes: BinaryNode[];
         shouldIncludeDeviceIdentity: boolean;
     }>;
@@ -203,14 +282,6 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     waUploadToServer: (data: Uint8Array | Buffer, opts: {
         mediaType: MediaType;
     }) => Promise<UploadMediaResult>;
-    fetchPrivacySettings: (force?: boolean) => Promise<any>;
-    updatePrivacySetting: (category: string, value: string) => Promise<void>;
-    updateLastSeenPrivacy: (value: WAPrivacyValue) => Promise<void>;
-    updateOnlinePrivacy: (value: WAPrivacyOnlineValue) => Promise<void>;
-    updateProfilePicturePrivacy: (value: WAPrivacyValue) => Promise<void>;
-    updateStatusPrivacy: (value: WAPrivacyValue) => Promise<void>;
-    updateReadReceiptsPrivacy: (value: WAReadReceiptsValue) => Promise<void>;
-    updateGroupsAddPrivacy: (value: WAPrivacyGroupAddValue) => Promise<void>;
     updateDefaultDisappearingMode: (duration: number) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     /**

package/lib/Socket/index.js

@@ -21,6 +21,7 @@ import { makeNativeCryptoProvider } from '../Utils/native-crypto-provider.js';
 import { wrapLegacyStore } from '../Utils/wrap-legacy-store.js';
 import { assertNodeErrorFree } from '../WABinary/generic-utils.js';
 import { makeBlockingMethods } from './blocking.js';
+import { makeBusinessMethods } from './business.js';
 import { makeChatActionMethods } from './chat-actions.js';
 import { makeContactMethods } from './contacts.js';
 import { makeCommunityMethods } from './communities.js';
@@ -28,10 +29,13 @@ import { makeBridgeClientOwner } from './bridge-client-owner.js';
 import { makeTerminalCloseReporter } from './terminal-close-reporter.js';
 import { makeEventHandlers } from './events.js';
 import { makeGroupMethods } from './groups.js';
+import { makeInternalMethods, makeUnexpectedErrorReporter } from './internals.js';
 import { makeMessageMethods } from './messages.js';
 import { makeNewsletterMethods } from './newsletter.js';
 import { makePreKeyMethods } from './prekeys.js';
 import { makePresenceMethods } from './presence.js';
+import { makePrivacyMethods } from './privacy.js';
+import { makeServerQueryMethods } from './server-queries.js';
 import { makeProfileMethods } from './profile.js';
 import { mapReachoutTimelock } from './reachout.js';
 import { makeHttpClient, makeTransport } from './transport.js';
@@ -249,11 +253,18 @@ const makeWASocket = (config) => {
     let autoReconnectEnabled = true;
     /** Owns reporting the terminal close: once, after teardown, never not at all. */
     const terminalClose = makeTerminalCloseReporter({ logger });
+    /**
+     * Held in a reporter rather than captured, because `sock.onUnexpectedError`
+     * is an assignable property: a consumer that replaces it has to be the one
+     * the socket's own failure paths reach afterwards.
+     */
+    const unexpectedErrors = makeUnexpectedErrorReporter(logger);
     const ctx = {
         ev,
         logger,
         fullConfig,
         ws,
+        reportUnexpectedError: unexpectedErrors.report,
         getUser: () => user,
         getMe: () => {
             const me = auth.creds.me;
@@ -783,7 +794,17 @@ const makeWASocket = (config) => {
         sendRawMessage: async (data) => {
             return (await ctx.getClient()).sendRawMessage(data instanceof Uint8Array ? data : new Uint8Array(data));
         },
-        createParticipantNodes: async (jids, message, extraAttrs) => {
+        /**
+         * `dsmMessage` is accepted so the signature matches upstream, and
+         * refused rather than ignored. Upstream uses it to encrypt a different
+         * plaintext for the caller's own other devices; the engine encrypts one
+         * payload for every recipient, so honouring it is not possible here and
+         * dropping it would send those devices the wrong message.
+         */
+        createParticipantNodes: async (jids, message, extraAttrs, dsmMessage) => {
+            if (dsmMessage) {
+                throw new Boom('createParticipantNodes: dsmMessage is not supported, the engine encrypts one payload for every recipient and cannot substitute a different one for your own devices', { statusCode: 501 });
+            }
             const bytes = encodeProto('Message', message);
             return (await ctx.getClient()).createParticipantNodesBytes(jids, bytes, extraAttrs ?? {});
         },
@@ -826,31 +847,7 @@ const makeWASocket = (config) => {
             const bytes = data instanceof Uint8Array && !Buffer.isBuffer(data) ? data : new Uint8Array(data);
             return (await ctx.getClient()).uploadMedia(bytes, toBridgeMediaType(opts.mediaType));
         },
-        fetchPrivacySettings: async (force) => {
-            void force;
-            return (await ctx.getClient()).fetchPrivacySettings();
-        },
-        updatePrivacySetting: async (category, value) => {
-            await (await ctx.getClient()).updatePrivacySetting(category, value);
-        },
-        updateLastSeenPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('last', value);
-        },
-        updateOnlinePrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('online', value);
-        },
-        updateProfilePicturePrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('profile', value);
-        },
-        updateStatusPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('status', value);
-        },
-        updateReadReceiptsPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('readreceipts', value);
-        },
-        updateGroupsAddPrivacy: async (value) => {
-            await (await ctx.getClient()).updatePrivacySetting('groupadd', value);
-        },
+        ...makePrivacyMethods(ctx),
         updateDefaultDisappearingMode: async (duration) => {
             await (await ctx.getClient()).updateDefaultDisappearingMode(duration);
         },
@@ -891,11 +888,14 @@ const makeWASocket = (config) => {
         ...makeContactMethods(ctx),
         ...makeProfileMethods(ctx),
         ...makeChatActionMethods(ctx),
+        ...makeInternalMethods(ctx),
         ...usyncMethods,
         ...makeStanzaResponseMethods(ctx),
         ...makePresenceMethods(ctx),
         ...makeBlockingMethods(ctx),
         ...makeNewsletterMethods(ctx),
+        ...makeBusinessMethods(ctx),
+        ...makeServerQueryMethods(ctx),
         downloadMedia: async (message, type, options = {}) => {
             return downloadMediaMessage(message, type, options, {
                 logger,
@@ -904,6 +904,16 @@ const makeWASocket = (config) => {
             });
         }
     };
+    // Assigning replaces the handler the socket itself reports through, rather
+    // than shadowing it with a second one only a consumer could reach.
+    Object.defineProperty(sock, 'onUnexpectedError', {
+        get: () => unexpectedErrors.handler,
+        set: (handler) => {
+            unexpectedErrors.handler = handler;
+        },
+        enumerable: true,
+        configurable: true
+    });
     return sock;
 };
 export default makeWASocket;

package/lib/Socket/internals.d.ts

@@ -0,0 +1,88 @@
+import type { BinaryNode, MessageUpsertType, WAMessage, WAPatchCreate } from '../Types/index.js';
+import type { ILogger } from '../Utils/logger.js';
+import type { SocketContext } from './types.js';
+/**
+ * The one place an unexpected failure is reported, shared by the socket's
+ * `onUnexpectedError` property and by the internal paths that raise them.
+ *
+ * `report` cannot throw. Some of its callers are bridge callbacks that borrow
+ * memory and are contractually forbidden from raising, so a consumer whose
+ * handler throws would cost the session its borrowed batches. A handler that
+ * fails is reported through the logger and the caller carries on.
+ *
+ * The return type says `void`, which an `async` handler also satisfies, so a
+ * handler that rejects rather than throws is contained the same way. Left
+ * loose it would surface as an unhandled rejection, which ends the process
+ * under `--unhandled-rejections=strict`.
+ */
+export declare const makeUnexpectedErrorReporter: (logger: ILogger) => {
+    report: (err: unknown, msg: string) => void;
+    handler: (err: unknown, msg: string) => void;
+};
+export declare const makeInternalMethods: (ctx: SocketContext) => {
+    /**
+     * `waitForSocket`, not `waitForConnected`: upstream waits for the socket
+     * to open, which is not the same as being logged in, and the bridge
+     * separates the two.
+     *
+     * A rejection means the socket did not open within one connect attempt,
+     * not that it never will: the engine reconnects on its own, and a caller
+     * that wants the next attempt waits again.
+     */
+    waitForSocketOpen: () => Promise<void>;
+    /**
+     * Publishes a message onto the event bus, which is this layer's own job.
+     * Buffered as upstream buffers it, so a replay of many messages
+     * consolidates into the batches a listener expects rather than one
+     * event per call.
+     *
+     * The push-name half of upstream's version is not reproduced: contact
+     * state belongs to the core, and writing it from here would make two
+     * writers for one value.
+     */
+    upsertMessage: (msg: WAMessage, type: MessageUpsertType) => Promise<void>;
+    /**
+     * The same reporter the socket's own failure paths use, rather than a
+     * second one that only a consumer could reach: a dispatcher that threw
+     * or a wire batch that would not decode arrives here. The socket
+     * redefines this as an accessor, so assigning to it replaces the
+     * handler those paths report through.
+     */
+    onUnexpectedError: (err: Error, msg: string) => void;
+    /**
+     * Resolves without forcing anything, and says so once.
+     *
+     * The engine syncs app state on connect and re-syncs every collection
+     * when the server raises the `syncd_app_state` dirty bit, so the state a
+     * caller wants current already is. There is no on-demand resync to
+     * delegate to, and rejecting would break a call whose intent is met.
+     */
+    resyncAppState: (collections?: readonly ('critical_block' | 'critical_unblock_low' | 'regular_high' | 'regular_low' | 'regular')[], isInitialSync?: boolean) => Promise<void>;
+    /**
+     * Refused: the offset is protocol state the core keeps from the stanzas
+     * it already reads. A second clock here would drift from the one that
+     * actually timestamps outgoing messages.
+     */
+    updateServerTimeOffset: (node: BinaryNode) => never;
+    /**
+     * Refused one layer down. The core's session instance is `pub(crate)`,
+     * and what exists returns a half-built stanza plus a sequence number, so
+     * exposing it would hand JavaScript the job of finishing and sequencing
+     * a lifecycle stanza.
+     */
+    sendUnifiedSession: () => Promise<never>;
+    /**
+     * Refused: the bridge exposes app-state actions typed per action and
+     * deliberately no generic. Accepting a raw patch here would mean
+     * building mutation indices and schema versions in TypeScript, beside
+     * the copy the core already maintains.
+     */
+    appPatch: (patchCreate: WAPatchCreate) => Promise<never>;
+    /**
+     * Null rather than absent, and rather than a shadow. Retry is the
+     * engine's, so there is no manager here to hand out, and saying so in
+     * the type is more useful than leaving the field missing.
+     */
+    messageRetryManager: null;
+};
+//# sourceMappingURL=internals.d.ts.map

package/lib/Socket/internals.js

@@ -0,0 +1,145 @@
+import { Boom } from '../Utils/boom.js';
+/**
+ * The one place an unexpected failure is reported, shared by the socket's
+ * `onUnexpectedError` property and by the internal paths that raise them.
+ *
+ * `report` cannot throw. Some of its callers are bridge callbacks that borrow
+ * memory and are contractually forbidden from raising, so a consumer whose
+ * handler throws would cost the session its borrowed batches. A handler that
+ * fails is reported through the logger and the caller carries on.
+ *
+ * The return type says `void`, which an `async` handler also satisfies, so a
+ * handler that rejects rather than throws is contained the same way. Left
+ * loose it would surface as an unhandled rejection, which ends the process
+ * under `--unhandled-rejections=strict`.
+ */
+export const makeUnexpectedErrorReporter = (logger) => {
+    const logUnexpected = (err, msg) => logger.error({ err }, `unexpected error in '${msg}'`);
+    const logHandlerFailure = (err, msg, reportingError) => {
+        logger.error({ err: reportingError }, 'the onUnexpectedError handler threw');
+        logUnexpected(err, msg);
+    };
+    let handler = logUnexpected;
+    return {
+        report: (err, msg) => {
+            try {
+                const settled = handler(err, msg);
+                if (settled instanceof Promise) {
+                    settled.catch(reportingError => logHandlerFailure(err, msg, reportingError));
+                }
+            }
+            catch (reportingError) {
+                logHandlerFailure(err, msg, reportingError);
+            }
+        },
+        get handler() {
+            return handler;
+        },
+        set handler(next) {
+            handler = next;
+        }
+    };
+};
+/**
+ * Upstream has no timeout on `waitForSocketOpen`; the bridge requires one, so
+ * one has to be chosen.
+ *
+ * It is the core's own transport connect ceiling, not `connectTimeoutMs`. That
+ * config reaches neither the transport nor the core, so a value below the
+ * ceiling would reject a wait while the attempt behind it was still running and
+ * about to succeed. A value above it would sit past the point the attempt was
+ * already abandoned.
+ */
+const TRANSPORT_CONNECT_TIMEOUT_MS = 20000;
+export const makeInternalMethods = (ctx) => {
+    /** Warned once per socket rather than per call, as with the other no-ops. */
+    let warnedAboutResync = false;
+    return {
+        /**
+         * `waitForSocket`, not `waitForConnected`: upstream waits for the socket
+         * to open, which is not the same as being logged in, and the bridge
+         * separates the two.
+         *
+         * A rejection means the socket did not open within one connect attempt,
+         * not that it never will: the engine reconnects on its own, and a caller
+         * that wants the next attempt waits again.
+         */
+        waitForSocketOpen: async () => {
+            await (await ctx.getClient()).waitForSocket(TRANSPORT_CONNECT_TIMEOUT_MS);
+        },
+        /**
+         * Publishes a message onto the event bus, which is this layer's own job.
+         * Buffered as upstream buffers it, so a replay of many messages
+         * consolidates into the batches a listener expects rather than one
+         * event per call.
+         *
+         * The push-name half of upstream's version is not reproduced: contact
+         * state belongs to the core, and writing it from here would make two
+         * writers for one value.
+         */
+        upsertMessage: ctx.ev.createBufferedFunction(async (msg, type) => {
+            ctx.ev.emit('messages.upsert', { messages: [msg], type });
+        }),
+        /**
+         * The same reporter the socket's own failure paths use, rather than a
+         * second one that only a consumer could reach: a dispatcher that threw
+         * or a wire batch that would not decode arrives here. The socket
+         * redefines this as an accessor, so assigning to it replaces the
+         * handler those paths report through.
+         */
+        onUnexpectedError: (err, msg) => {
+            ctx.reportUnexpectedError(err, msg);
+        },
+        /**
+         * Resolves without forcing anything, and says so once.
+         *
+         * The engine syncs app state on connect and re-syncs every collection
+         * when the server raises the `syncd_app_state` dirty bit, so the state a
+         * caller wants current already is. There is no on-demand resync to
+         * delegate to, and rejecting would break a call whose intent is met.
+         */
+        resyncAppState: async (collections, isInitialSync) => {
+            void collections;
+            void isInitialSync;
+            if (!warnedAboutResync) {
+                warnedAboutResync = true;
+                ctx.logger.warn('resyncAppState is a no-op: the engine syncs app state on connect and again whenever the server marks it dirty');
+            }
+        },
+        /**
+         * Refused: the offset is protocol state the core keeps from the stanzas
+         * it already reads. A second clock here would drift from the one that
+         * actually timestamps outgoing messages.
+         */
+        updateServerTimeOffset: (node) => {
+            void node;
+            throw new Boom('updateServerTimeOffset is not supported: the engine tracks the server clock offset itself, and a second one here would diverge from the one it stamps messages with', { statusCode: 501 });
+        },
+        /**
+         * Refused one layer down. The core's session instance is `pub(crate)`,
+         * and what exists returns a half-built stanza plus a sequence number, so
+         * exposing it would hand JavaScript the job of finishing and sequencing
+         * a lifecycle stanza.
+         */
+        sendUnifiedSession: async () => {
+            throw new Boom('sendUnifiedSession is not supported: it is connection lifecycle machinery the engine owns, not a consumer operation', { statusCode: 501 });
+        },
+        /**
+         * Refused: the bridge exposes app-state actions typed per action and
+         * deliberately no generic. Accepting a raw patch here would mean
+         * building mutation indices and schema versions in TypeScript, beside
+         * the copy the core already maintains.
+         */
+        appPatch: async (patchCreate) => {
+            void patchCreate;
+            throw new Boom('appPatch is not supported: use the typed chatModify variants, which is the only app-state surface this package can offer without a second implementation of the patch format', { statusCode: 501 });
+        },
+        /**
+         * Null rather than absent, and rather than a shadow. Retry is the
+         * engine's, so there is no manager here to hand out, and saying so in
+         * the type is more useful than leaving the field missing.
+         */
+        messageRetryManager: null
+    };
+};
+//# sourceMappingURL=internals.js.map

package/lib/Socket/messages.d.ts

@@ -1,20 +1,6 @@
-import type { AnyMessageContent, MessageGenerationOptions, MessageReceiptType, MessageRelayOptions, WAMessage, WAMessageContent, WAMessageKey } from '../Types/index.js';
+import type { AnyMessageContent, MessageGenerationOptions, MessageReceiptType, MessageRelayOptions, WAMessage, WAMessageKey } from '../Types/index.js';
 import { WAProto } from '../Types/index.js';
 import type { SocketContext } from './types.js';
-/**
- * Drop `messageContextInfo` before handing the proto to the Rust bridge so the
- * bridge can fill in its own `messageSecret` / `reportingTokenVersion`.
- *
- * Exception: pin messages need `messageAddOnDurationInSecs` (86400 / 604800 /
- * 2592000 to pin, 0 to unpin). The bridge does not set this field, so we save
- * it across the delete and restore it on a fresh contextInfo.
- *
- * Mutates `msg` in place.
- *
- * `contentType` is a parameter so the send path can hand over the type it has
- * already resolved rather than have it scanned out of `msg` a second time.
- */
-export declare function stripContextInfoForBridge(msg: WAMessageContent, contentType?: keyof WAProto.IMessage | undefined): void;
 export declare const makeMessageMethods: (ctx: SocketContext) => {
     sendMessage: (jid: string, content: AnyMessageContent, options?: Omit<MessageGenerationOptions, 'waClient' | 'logger' | 'userJid' | 'mediaInNote'>) => Promise<WAMessage>;
     updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;

package/lib/Socket/messages.js

@@ -13,26 +13,6 @@ function getMediaContent(content) {
         content?.documentMessage ||
         content?.stickerMessage);
 }
-/**
- * Drop `messageContextInfo` before handing the proto to the Rust bridge so the
- * bridge can fill in its own `messageSecret` / `reportingTokenVersion`.
- *
- * Exception: pin messages need `messageAddOnDurationInSecs` (86400 / 604800 /
- * 2592000 to pin, 0 to unpin). The bridge does not set this field, so we save
- * it across the delete and restore it on a fresh contextInfo.
- *
- * Mutates `msg` in place.
- *
- * `contentType` is a parameter so the send path can hand over the type it has
- * already resolved rather than have it scanned out of `msg` a second time.
- */
-export function stripContextInfoForBridge(msg, contentType = getContentType(msg)) {
-    const pinAddOnDuration = contentType === 'pinInChatMessage' ? msg.messageContextInfo?.messageAddOnDurationInSecs : undefined;
-    delete msg.messageContextInfo;
-    if (pinAddOnDuration !== undefined && pinAddOnDuration !== null) {
-        msg.messageContextInfo = { messageAddOnDurationInSecs: pinAddOnDuration };
-    }
-}
 const normalizedUserJids = new WeakMap();
 const getNormalizedUserJid = (ctx) => {
     const userId = ctx.getUser()?.id;
@@ -87,7 +67,6 @@ export const makeMessageMethods = (ctx) => ({
                 return fullMsg;
             }
         }
-        stripContextInfoForBridge(msg, contentType);
         let msgId;
         const msgBytes = encodeProto('Message', msg);
         if (jid === 'status@broadcast' && options?.statusJidList?.length) {
@@ -155,7 +134,9 @@ export const makeMessageMethods = (ctx) => ({
             messageId: plan.messageId,
             extraNodes: plan.kind === 'retransmission' ? 0 : plan.nodes.length
         }, 'relayMessage compatibility plan');
-        stripContextInfoForBridge(message);
+        // The message goes to the bridge as the caller built it: the core settles
+        // messageSecret / reportingTokenVersion itself, reusing a caller-set secret
+        // rather than replacing it, so nothing here has to be dropped.
         const bytes = encodeProto('Message', message);
         if (plan.kind === 'retransmission') {
             await client.retransmitMessageBytes(jid, bytes, plan.input);