@oxidezap/baileyrs 0.1.2 → 0.2.0

package/lib/Socket/groups.d.ts

@@ -1,14 +1,40 @@
 import { type GroupMetadata, type ParticipantAction, type WAMessageKey } from '../Types/index.js';
 import { proto } from '../WAProto/runtime.js';
 import type { SocketContext } from './types.js';
-type GroupSetting = 'announcement' | 'not_announcement' | 'locked' | 'unlocked';
+declare const GROUP_SETTING_ALIASES: {
+    readonly announcement: {
+        readonly setting: 'announce';
+        readonly value: true;
+    };
+    readonly not_announcement: {
+        readonly setting: 'announce';
+        readonly value: false;
+    };
+    readonly locked: {
+        readonly setting: 'locked';
+        readonly value: true;
+    };
+    readonly unlocked: {
+        readonly setting: 'locked';
+        readonly value: false;
+    };
+};
+/** The table is the definition: both the type and the accepted set come off it. */
+export type GroupSetting = keyof typeof GROUP_SETTING_ALIASES;
+export declare const GROUP_SETTINGS: readonly GroupSetting[];
+export declare const GROUP_REQUEST_ACTIONS: readonly ['approve', 'reject'];
+export type GroupRequestAction = (typeof GROUP_REQUEST_ACTIONS)[number];
+export declare const MEMBER_ADD_MODES: readonly ['admin_add', 'all_member_add'];
+export type MemberAddMode = (typeof MEMBER_ADD_MODES)[number];
+export declare const JOIN_APPROVAL_MODES: readonly ['on', 'off'];
+export type JoinApprovalMode = (typeof JOIN_APPROVAL_MODES)[number];
 export declare const makeGroupMethods: (ctx: SocketContext) => {
     groupMetadata: (jid: string) => Promise<GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
     groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
     groupRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     groupParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
@@ -19,8 +45,8 @@ export declare const makeGroupMethods: (ctx: SocketContext) => {
     groupGetInviteInfo: (code: string) => Promise<GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
     groupSettingUpdate: (jid: string, setting: GroupSetting) => Promise<void>;
-    groupMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    groupJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: MemberAddMode) => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: JoinApprovalMode) => Promise<void>;
     groupFetchAllParticipating: () => Promise<Record<string, GroupMetadata>>;
     updateMemberLabel: (jid: string, memberLabel: string) => Promise<string>;
 };

package/lib/Socket/groups.js

@@ -1,7 +1,8 @@
 import { bridgeInviteLinkToCode, bridgeMembershipRequestsToBaileys, bridgeMembershipRequestUpdatesToBaileys, bridgeParticipantChangesToBaileys } from '../Compatibility/socket-results.js';
 import { emitMessageUpsert } from '../Compatibility/message-upsert.js';
-import { WAMessageStubType } from '../Types/index.js';
-import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/generics.js';
+import { PARTICIPANT_ACTIONS, WAMessageStubType } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
+import { generateMessageIDV2, toNumber, unixTimestampSeconds } from '../Utils/generics.js';
 import { proto } from '../WAProto/runtime.js';
 import { bridgeGroupMetadataToBaileys } from '../Compatibility/group-metadata.js';
 const GROUP_SETTING_ALIASES = {
@@ -10,14 +11,23 @@ const GROUP_SETTING_ALIASES = {
     locked: { setting: 'locked', value: true },
     unlocked: { setting: 'locked', value: false }
 };
-const inviteExpirationNumber = (value) => typeof value === 'number' ? value : (value?.toNumber() ?? 0);
+export const GROUP_SETTINGS = Object.keys(GROUP_SETTING_ALIASES);
+export const GROUP_REQUEST_ACTIONS = ['approve', 'reject'];
+export const MEMBER_ADD_MODES = ['admin_add', 'all_member_add'];
+export const JOIN_APPROVAL_MODES = ['on', 'off'];
+// `toNumber` rather than calling `.toNumber()`: a 64-bit field now crosses the
+// bridge as a plain `{ low, high, unsigned }` once the value is too wide to be
+// exact as a double, and that shape carries no methods. The helper reads both
+// forms, and reconstructs the high word instead of dropping it.
+const inviteExpirationNumber = (value) => toNumber(value);
 export const makeGroupMethods = (ctx) => {
     const groupMetadata = async (jid) => {
         const metadata = await (await ctx.getClient()).getGroupMetadata(jid);
         return bridgeGroupMetadataToBaileys(metadata);
     };
     const groupSettingUpdate = async (jid, setting) => {
-        const mapped = GROUP_SETTING_ALIASES[setting];
+        const checked = assertArgumentDomain('groupSettingUpdate', 'setting', setting, GROUP_SETTINGS);
+        const mapped = GROUP_SETTING_ALIASES[checked];
         await (await ctx.getClient()).groupSettingUpdate(jid, mapped.setting, mapped.value);
     };
     const groupAcceptInviteV4 = ctx.ev.createBufferedFunction(async (key, inviteMessage
@@ -71,9 +81,11 @@ export const makeGroupMethods = (ctx) => {
             return bridgeMembershipRequestsToBaileys(await (await ctx.getClient()).groupRequestParticipantsList(jid));
         },
         groupRequestParticipantsUpdate: async (jid, participants, action) => {
+            assertArgumentDomain('groupRequestParticipantsUpdate', 'action', action, GROUP_REQUEST_ACTIONS);
             return bridgeMembershipRequestUpdatesToBaileys(await (await ctx.getClient()).groupRequestParticipantsUpdate(jid, participants, action));
         },
         groupParticipantsUpdate: async (jid, participants, action) => {
+            assertArgumentDomain('groupParticipantsUpdate', 'action', action, PARTICIPANT_ACTIONS);
             return bridgeParticipantChangesToBaileys(await (await ctx.getClient()).groupParticipantsUpdate(jid, participants, action));
         },
         groupUpdateDescription: async (jid, description) => {
@@ -100,9 +112,13 @@ export const makeGroupMethods = (ctx) => {
         },
         groupSettingUpdate,
         groupMemberAddMode: async (jid, mode) => {
+            assertArgumentDomain('groupMemberAddMode', 'mode', mode, MEMBER_ADD_MODES);
             await (await ctx.getClient()).groupMemberAddMode(jid, mode);
         },
         groupJoinApprovalMode: async (jid, mode) => {
+            // Anything but 'on' used to mean off, so a typo turned approvals off
+            // and reported success.
+            assertArgumentDomain('groupJoinApprovalMode', 'mode', mode, JOIN_APPROVAL_MODES);
             await (await ctx.getClient()).groupSettingUpdate(jid, 'membership_approval', mode === 'on');
         },
         groupFetchAllParticipating: async () => {

package/lib/Socket/index.d.ts

@@ -2,15 +2,16 @@ 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, WABusinessProfile, WAMessage, WAMessageKey } from '../Types/index.js';
+import type { BinaryNode, AuthenticationCreds, ConnectionState, Contact, ReachoutTimelockState, SignalKeyStoreWithTransaction, UserFacingSocketConfig, WABusinessProfile, WAMessage, WAMessageKey, WAPresence } from '../Types/index.js';
 import type Long from 'long';
+import { type MediaDownloadType } from '../Utils/messages.js';
 import type { MediaDownloadOptions } from '../Utils/messages-media.js';
 import type { proto } from '../WAProto/runtime.js';
 /** Build the ws EventEmitter with auto-enable raw node forwarding */
 declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendMessageAck: (node: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
-    updateBlockStatus: (jid: string, action: 'block' | 'unblock') => Promise<void>;
+    updateBlockStatus: (jid: string, action: import("./blocking.js").BlockAction) => 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>;
@@ -40,14 +41,14 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     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>;
+    profilePictureUrl: (jid: string, type?: import("./contacts.js").ProfilePictureType, timeoutMs?: number) => Promise<string | undefined>;
     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>;
     groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
     groupRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: import("./groups.js").GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../index.js").ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
@@ -57,9 +58,9 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     groupAcceptInviteV4: (key: string | WAMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<any>;
     groupGetInviteInfo: (code: string) => Promise<import("../index.js").GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
-    groupMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    groupJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: import("./groups.js").GroupSetting) => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: import("./groups.js").MemberAddMode) => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: import("./groups.js").JoinApprovalMode) => Promise<void>;
     groupFetchAllParticipating: () => Promise<Record<string, import("../index.js").GroupMetadata>>;
     updateMemberLabel: (jid: string, memberLabel: string) => Promise<string>;
     communityMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
@@ -81,7 +82,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
         }[];
     }>;
     communityRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    communityRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    communityRequestParticipantsUpdate: (jid: string, participants: string[], action: import("./groups.js").GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     communityParticipantsUpdate: (jid: string, participants: string[], action: import("../index.js").ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     communityUpdateDescription: (jid: string, description?: string) => Promise<void>;
     communityInviteCode: (jid: string) => Promise<string | undefined>;
@@ -91,9 +92,9 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     communityAcceptInviteV4: (key: string | WAMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<any>;
     communityGetInviteInfo: (code: string) => Promise<import("../index.js").GroupMetadata>;
     communityToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    communitySettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
-    communityMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    communityJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    communitySettingUpdate: (jid: string, setting: import("./groups.js").GroupSetting) => Promise<void>;
+    communityMemberAddMode: (jid: string, mode: import("./groups.js").MemberAddMode) => Promise<void>;
+    communityJoinApprovalMode: (jid: string, mode: import("./groups.js").JoinApprovalMode) => Promise<void>;
     communityFetchAllParticipating: () => Promise<Record<string, import("../index.js").GroupMetadata>>;
     waitForSocketOpen: () => Promise<void>;
     upsertMessage: (msg: WAMessage, type: import("../index.js").MessageUpsertType) => Promise<void>;
@@ -111,7 +112,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     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("../index.js").NewsletterMetadata>;
-    newsletterMetadata: (type: 'invite' | 'jid', key: string) => Promise<import("../index.js").NewsletterMetadata | null>;
+    newsletterMetadata: (type: import("./newsletter.js").NewsletterKeyType, 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>;
@@ -139,9 +140,9 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     digestKeyBundle: () => Promise<void>;
     rotateSignedPreKey: () => Promise<void>;
-    sendPresence: (status: 'available' | 'unavailable') => Promise<void>;
+    sendPresence: (status: import("../index.js").WAPresenceStatus) => Promise<void>;
     presenceSubscribe: (toJid: string) => Promise<void>;
-    sendChatState: (jid: string, state: 'composing' | 'recording' | 'paused') => Promise<void>;
+    sendChatState: (jid: string, state: import("../index.js").WAChatState) => Promise<void>;
     fetchPrivacySettings: (force?: boolean) => Promise<any>;
     updatePrivacySetting: (category: string, value: string) => Promise<void>;
     updateLastSeenPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
@@ -163,7 +164,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     fetchNewChatMessageCap: () => Promise<import("../index.js").NewChatMessageCapInfo & {
         remaining_quota?: number;
     }>;
-    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
+    cleanDirtyBits: (type: import("./server-queries.js").DirtyBitType, 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>;
@@ -272,7 +273,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
      * caller hears about the protocol mistake instead of the bridge silently
      * sending nothing.
      */
-    sendPresenceUpdate: (type: 'available' | 'unavailable' | 'composing' | 'recording' | 'paused', toJid?: string) => Promise<void>;
+    sendPresenceUpdate: (type: WAPresence, toJid?: string) => Promise<void>;
     /**
      * Plaintext media upload helper, source-compatible with the upstream
      * Baileys `sock.waUploadToServer(buf, { mediaType })` shape so existing
@@ -303,7 +304,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     getBusinessProfile: (jid: string) => Promise<WABusinessProfile | void>;
     fetchMessageHistory: (count: number, oldestMsgKey: WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
     sendStatusMessage: (message: Record<string, unknown>, recipients: string[]) => Promise<string>;
-    downloadMedia: <T extends 'buffer' | 'stream'>(message: WAMessage, type: T, options?: MediaDownloadOptions) => Promise<T extends "buffer" ? Buffer<ArrayBufferLike> : import("node:stream").Readable>;
+    downloadMedia: <T extends MediaDownloadType>(message: WAMessage, type: T, options?: MediaDownloadOptions) => Promise<T extends "buffer" ? Buffer<ArrayBufferLike> : import("node:stream").Readable>;
 };
 export default makeWASocket;
 //# sourceMappingURL=index.d.ts.map

package/lib/Socket/index.js

@@ -1,6 +1,7 @@
 import { Buffer } from 'node:buffer';
 import { randomBytes } from 'node:crypto';
-import { createWhatsAppClient, encodeProto, initWasmEngine } from '@oxidezap/whatsapp-rust-bridge';
+import { createWhatsAppClient, initWasmEngine } from '@oxidezap/whatsapp-rust-bridge';
+import { encodeProtoCompat } from '../Compatibility/encode-proto.js';
 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';
@@ -12,11 +13,12 @@ import { makeStanzaResponseMethods } from '../Compatibility/stanza-responses.js'
 import { makeParticipatingRefreshHandler } from '../Compatibility/participating-refresh.js';
 import { makeTaggedMessageWaiter } from '../Compatibility/tagged-message-waiter.js';
 import { isRawNodeForwardingEnabled, WebSocketClient } from '../Compatibility/websocket-client.js';
-import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
-import { DisconnectReason } from '../Types/index.js';
+import { DEFAULT_CONNECTION_CONFIG, MEDIA_TYPES } from '../Defaults/index.js';
+import { DisconnectReason, WA_PRESENCES } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
 import { makeEventBuffer } from '../Utils/event-buffer.js';
-import { _registerActiveBridgeClient, _unregisterActiveBridgeClient, downloadMediaMessage } from '../Utils/messages.js';
+import { _registerActiveBridgeClient, _unregisterActiveBridgeClient, downloadMediaMessage, MEDIA_DOWNLOAD_TYPES } from '../Utils/messages.js';
 import { makeNativeCryptoProvider } from '../Utils/native-crypto-provider.js';
 import { wrapLegacyStore } from '../Utils/wrap-legacy-store.js';
 import { assertNodeErrorFree } from '../WABinary/generic-utils.js';
@@ -805,7 +807,7 @@ const makeWASocket = (config) => {
             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);
+            const bytes = encodeProtoCompat('Message', message);
             return (await ctx.getClient()).createParticipantNodesBytes(jids, bytes, extraAttrs ?? {});
         },
         signalRepository,
@@ -828,6 +830,9 @@ const makeWASocket = (config) => {
          * sending nothing.
          */
         sendPresenceUpdate: async (type, toJid) => {
+            // Ahead of the client: an off-union value used to fall through to the
+            // chat-state branch and be reported as a missing jid.
+            assertArgumentDomain('sendPresenceUpdate', 'type', type, WA_PRESENCES);
             const c = await ctx.getClient();
             if (type === 'available' || type === 'unavailable') {
                 return c.sendPresence(type);
@@ -844,6 +849,9 @@ const makeWASocket = (config) => {
          * keep working. Delegates to the bridge's encrypt + CDN-failover upload.
          */
         waUploadToServer: async (data, opts) => {
+            // The upstream set, which is wider than what the bridge uploads:
+            // `toBridgeMediaType` below still refuses the ones it cannot map.
+            assertArgumentDomain('waUploadToServer', 'mediaType', opts?.mediaType, MEDIA_TYPES);
             const bytes = data instanceof Uint8Array && !Buffer.isBuffer(data) ? data : new Uint8Array(data);
             return (await ctx.getClient()).uploadMedia(bytes, toBridgeMediaType(opts.mediaType));
         },
@@ -879,7 +887,7 @@ const makeWASocket = (config) => {
             return (await ctx.getClient()).fetchMessageHistory(count, oldestMsgKey.remoteJid || '', oldestMsgKey.id || '', oldestMsgKey.fromMe || false, typeof oldestMsgTimestamp === 'number' ? oldestMsgTimestamp : oldestMsgTimestamp.toNumber());
         },
         sendStatusMessage: async (message, recipients) => {
-            const bytes = encodeProto('Message', message);
+            const bytes = encodeProtoCompat('Message', message);
             return (await ctx.getClient()).sendStatusMessageBytes(bytes, recipients);
         },
         ...makeMessageMethods(ctx),
@@ -897,6 +905,10 @@ const makeWASocket = (config) => {
         ...makeBusinessMethods(ctx),
         ...makeServerQueryMethods(ctx),
         downloadMedia: async (message, type, options = {}) => {
+            // Checked here as well as in the helper: the client is awaited while
+            // the context below is built, and a check past that await reports a
+            // stack without the caller in it.
+            assertArgumentDomain('downloadMedia', 'type', type, MEDIA_DOWNLOAD_TYPES);
             return downloadMediaMessage(message, type, options, {
                 logger,
                 reuploadRequest: (m) => sock.updateMediaMessage(m),

package/lib/Socket/messages.js

@@ -1,7 +1,9 @@
-import { encodeProto } from '@oxidezap/whatsapp-rust-bridge';
+import { sendDroppingDerivedNodes } from '../Compatibility/derived-stanza-nodes.js';
+import { encodeProtoCompat } from '../Compatibility/encode-proto.js';
 import { planMessageRelay } from '../Compatibility/message-relay.js';
 import { receiptMessageKeys } from '../Compatibility/message-keys.js';
-import { WAProto } from '../Types/index.js';
+import { MESSAGE_RECEIPT_TYPES, WAProto } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
 import { generateWAMessage, getContentType, normalizeMessageContent } from '../Utils/messages.js';
 import { jidNormalizedUser } from '../WABinary/index.js';
@@ -68,7 +70,7 @@ export const makeMessageMethods = (ctx) => ({
             }
         }
         let msgId;
-        const msgBytes = encodeProto('Message', msg);
+        const msgBytes = encodeProtoCompat('Message', msg);
         if (jid === 'status@broadcast' && options?.statusJidList?.length) {
             msgId = await client.sendStatusMessageBytes(msgBytes, options.statusJidList);
         }
@@ -137,15 +139,20 @@ export const makeMessageMethods = (ctx) => ({
         // 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);
+        const bytes = encodeProtoCompat('Message', message);
         if (plan.kind === 'retransmission') {
             await client.retransmitMessageBytes(jid, bytes, plan.input);
             return plan.messageId;
         }
+        // Both sends go through the same retry: a caller node the engine derives
+        // is refused the same way whether the message is bound for a chat or for
+        // status, and the escape hatch — a node it does not derive — survives
+        // 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 client.sendStatusMessageBytesWithOptions(bytes, plan.recipients, plan.messageId, plan.nodes, plan.refreshDevices);
+            return sendDroppingDerivedNodes(plan.nodes, nodes => client.sendStatusMessageBytesWithOptions(bytes, plan.recipients, plan.messageId, nodes, plan.refreshDevices), drop);
         }
-        return client.relayMessageBytesWithOptions(jid, bytes, plan.messageId, plan.nodes, plan.refreshGroupMetadata, plan.refreshDevices);
+        return sendDroppingDerivedNodes(plan.nodes, nodes => client.relayMessageBytesWithOptions(jid, bytes, plan.messageId, nodes, plan.refreshGroupMetadata, plan.refreshDevices), drop);
     },
     readMessages: async (keys) => {
         const receiptKeys = receiptMessageKeys(keys);
@@ -161,6 +168,9 @@ export const makeMessageMethods = (ctx) => ({
      * Not supported: 'hist_sync', 'peer_msg' (logged as warning)
      */
     sendReceipt: async (jid, participant, messageIds, type) => {
+        // Ahead of the empty-list exit: the types this method handles elsewhere
+        // resolve without sending anything, so a typo looked like a no-op.
+        assertArgumentDomain('sendReceipt', 'type', type, MESSAGE_RECEIPT_TYPES);
         if (!messageIds.length)
             return;
         if (type === 'read' || type === 'read-self') {
@@ -193,6 +203,7 @@ export const makeMessageMethods = (ctx) => ({
      * Send receipts for multiple message keys, grouped by JID and participant.
      */
     sendReceipts: async (keys, type) => {
+        assertArgumentDomain('sendReceipts', 'type', type, MESSAGE_RECEIPT_TYPES);
         const client = await ctx.getClient();
         const receiptKeys = receiptMessageKeys(keys);
         if (type === 'read' || type === 'read-self') {
@@ -224,7 +235,7 @@ export const makeMessageMethods = (ctx) => ({
                 type: WAProto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE
             }
         };
-        const bytes = encodeProto('Message', message);
+        const bytes = encodeProtoCompat('Message', message);
         return (await ctx.getClient()).relayMessageBytes(messageKey.remoteJid, bytes, null);
     }
 });

package/lib/Socket/newsletter.d.ts

@@ -2,6 +2,8 @@ import type { NewsletterMetadataResult } from '@oxidezap/whatsapp-rust-bridge';
 import type { NewsletterMetadata, NewsletterUpdate } from '../Types/Newsletter.js';
 import type { WAMediaUpload } from '../Types/index.js';
 import type { SocketContext } from './types.js';
+export declare const NEWSLETTER_KEY_TYPES: readonly ['invite', 'jid'];
+export type NewsletterKeyType = (typeof NEWSLETTER_KEY_TYPES)[number];
 export declare const makeNewsletterMethods: (ctx: SocketContext) => {
     newsletterCreate: (name: string, description?: string) => Promise<NewsletterMetadata>;
     /**
@@ -9,7 +11,7 @@ export declare const makeNewsletterMethods: (ctx: SocketContext) => {
      * rather than one that inspects the key. Resolves to null when the
      * newsletter does not exist, matching upstream.
      */
-    newsletterMetadata: (type: 'invite' | 'jid', key: string) => Promise<NewsletterMetadata | null>;
+    newsletterMetadata: (type: NewsletterKeyType, key: string) => Promise<NewsletterMetadata | null>;
     /**
      * `picture` is base64 of an already-generated image, and the empty string
      * means remove, as upstream builds it. The core splits those into two

package/lib/Socket/newsletter.js

@@ -1,7 +1,9 @@
 import { Buffer } from 'node:buffer';
 import { bridgeNewsletterMetadataToBaileys } from '../Compatibility/newsletter-results.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
 import { generateProfilePicture } from '../Utils/messages-media.js';
+export const NEWSLETTER_KEY_TYPES = ['invite', 'jid'];
 export const makeNewsletterMethods = (ctx) => ({
     newsletterCreate: async (name, description) => {
         return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterCreate(name, description ?? null));
@@ -12,9 +14,7 @@ export const makeNewsletterMethods = (ctx) => ({
      * newsletter does not exist, matching upstream.
      */
     newsletterMetadata: async (type, key) => {
-        if (type !== 'invite' && type !== 'jid') {
-            throw new Boom(`newsletterMetadata: unknown key type '${type}'`, { statusCode: 400 });
-        }
+        assertArgumentDomain('newsletterMetadata', 'type', type, NEWSLETTER_KEY_TYPES);
         const client = await ctx.getClient();
         const result = type === 'invite' ? await client.newsletterMetadataByInvite(key) : await client.newsletterMetadata(key);
         return result ? bridgeNewsletterMetadataToBaileys(result) : null;

package/lib/Socket/presence.d.ts

@@ -1,7 +1,8 @@
+import { type WAChatState, type WAPresenceStatus } from '../Types/index.js';
 import type { SocketContext } from './types.js';
 export declare const makePresenceMethods: (ctx: SocketContext) => {
-    sendPresence: (status: 'available' | 'unavailable') => Promise<void>;
+    sendPresence: (status: WAPresenceStatus) => Promise<void>;
     presenceSubscribe: (toJid: string) => Promise<void>;
-    sendChatState: (jid: string, state: 'composing' | 'recording' | 'paused') => Promise<void>;
+    sendChatState: (jid: string, state: WAChatState) => Promise<void>;
 };
 //# sourceMappingURL=presence.d.ts.map

package/lib/Socket/presence.js

@@ -1,11 +1,15 @@
+import { WA_CHAT_STATES, WA_PRESENCE_STATUSES } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 export const makePresenceMethods = (ctx) => ({
     sendPresence: async (status) => {
+        assertArgumentDomain('sendPresence', 'status', status, WA_PRESENCE_STATUSES);
         await (await ctx.getClient()).sendPresence(status);
     },
     presenceSubscribe: async (toJid) => {
         await (await ctx.getClient()).presenceSubscribe(toJid);
     },
     sendChatState: async (jid, state) => {
+        assertArgumentDomain('sendChatState', 'state', state, WA_CHAT_STATES);
         await (await ctx.getClient()).sendChatState(jid, state);
     }
 });

package/lib/Socket/privacy.d.ts

@@ -1,7 +1,13 @@
-import type { WAPrivacyCallValue, WAPrivacyGroupAddValue, WAPrivacyMessagesValue, WAPrivacyOnlineValue, WAPrivacyValue, WAReadReceiptsValue } from '../Types/index.js';
+import { type WAPrivacyCallValue, type WAPrivacyGroupAddValue, type WAPrivacyMessagesValue, type WAPrivacyOnlineValue, type WAPrivacyValue, type WAReadReceiptsValue } from '../Types/index.js';
 import type { SocketContext } from './types.js';
 export declare const makePrivacyMethods: (ctx: SocketContext) => {
     fetchPrivacySettings: (force?: boolean) => Promise<any>;
+    /**
+     * The untyped escape hatch, left open on purpose: the bridge takes both
+     * halves as plain strings and the core's wire enums carry a fallback, so
+     * this is the way to reach a category or value the wrappers below do not
+     * name yet. The wrappers are the checked path.
+     */
     updatePrivacySetting: (category: string, value: string) => Promise<void>;
     updateLastSeenPrivacy: (value: WAPrivacyValue) => Promise<void>;
     updateOnlinePrivacy: (value: WAPrivacyOnlineValue) => Promise<void>;

package/lib/Socket/privacy.js

@@ -1,3 +1,5 @@
+import { WA_PRIVACY_CALL_VALUES, WA_PRIVACY_GROUP_ADD_VALUES, WA_PRIVACY_MESSAGES_VALUES, WA_PRIVACY_ONLINE_VALUES, WA_PRIVACY_VALUES, WA_READ_RECEIPTS_VALUES } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 export const makePrivacyMethods = (ctx) => {
     /** Per socket, so a send loop calling this does not flood the log. */
     let warnedAboutPrivacyTokens = false;
@@ -6,31 +8,45 @@ export const makePrivacyMethods = (ctx) => {
             void force;
             return (await ctx.getClient()).fetchPrivacySettings();
         },
+        /**
+         * The untyped escape hatch, left open on purpose: the bridge takes both
+         * halves as plain strings and the core's wire enums carry a fallback, so
+         * this is the way to reach a category or value the wrappers below do not
+         * name yet. The wrappers are the checked path.
+         */
         updatePrivacySetting: async (category, value) => {
             await (await ctx.getClient()).updatePrivacySetting(category, value);
         },
         updateLastSeenPrivacy: async (value) => {
+            assertArgumentDomain('updateLastSeenPrivacy', 'value', value, WA_PRIVACY_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('last', value);
         },
         updateOnlinePrivacy: async (value) => {
+            assertArgumentDomain('updateOnlinePrivacy', 'value', value, WA_PRIVACY_ONLINE_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('online', value);
         },
         updateProfilePicturePrivacy: async (value) => {
+            assertArgumentDomain('updateProfilePicturePrivacy', 'value', value, WA_PRIVACY_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('profile', value);
         },
         updateStatusPrivacy: async (value) => {
+            assertArgumentDomain('updateStatusPrivacy', 'value', value, WA_PRIVACY_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('status', value);
         },
         updateReadReceiptsPrivacy: async (value) => {
+            assertArgumentDomain('updateReadReceiptsPrivacy', 'value', value, WA_READ_RECEIPTS_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('readreceipts', value);
         },
         updateGroupsAddPrivacy: async (value) => {
+            assertArgumentDomain('updateGroupsAddPrivacy', 'value', value, WA_PRIVACY_GROUP_ADD_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('groupadd', value);
         },
         updateCallPrivacy: async (value) => {
+            assertArgumentDomain('updateCallPrivacy', 'value', value, WA_PRIVACY_CALL_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('calladd', value);
         },
         updateMessagesPrivacy: async (value) => {
+            assertArgumentDomain('updateMessagesPrivacy', 'value', value, WA_PRIVACY_MESSAGES_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('messages', value);
         },
         /**

package/lib/Socket/server-queries.d.ts

@@ -2,6 +2,8 @@ import type { BotListInfo } from '../Types/Chat.js';
 import type { NewChatMessageCapInfo } from '../Types/State.js';
 import type { MediaConnInfo } from '../Types/Message.js';
 import type { SocketContext } from './types.js';
+export declare const DIRTY_BIT_TYPES: readonly ['account_sync', 'groups'];
+export type DirtyBitType = (typeof DIRTY_BIT_TYPES)[number];
 export declare const makeServerQueryMethods: (ctx: SocketContext) => {
     /**
      * `maxContentLengthBytes` is absent by design: the core's hosts carry
@@ -19,7 +21,7 @@ export declare const makeServerQueryMethods: (ctx: SocketContext) => {
     fetchNewChatMessageCap: () => Promise<NewChatMessageCapInfo & {
         remaining_quota?: number;
     }>;
-    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
+    cleanDirtyBits: (type: DirtyBitType, fromTimestamp?: number | string) => Promise<void>;
     /**
      * Refused rather than wired up. The core already fires a peer data
      * request itself when a message fails to decrypt, with its own age

package/lib/Socket/server-queries.js

@@ -1,4 +1,6 @@
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
+export const DIRTY_BIT_TYPES = ['account_sync', 'groups'];
 /**
  * Every section, flattened and deduplicated, rather than only the section the
  * server types `all`.
@@ -85,6 +87,7 @@ export const makeServerQueryMethods = (ctx) => {
             return toCapInfo(await (await ctx.getClient()).fetchNewChatMessageCappingInfo());
         },
         cleanDirtyBits: async (type, fromTimestamp) => {
+            assertArgumentDomain('cleanDirtyBits', 'type', type, DIRTY_BIT_TYPES);
             let timestamp = null;
             if (fromTimestamp !== undefined) {
                 // A blank string is not a timestamp, and `Number('')` is the epoch,

package/lib/Types/Auth.d.ts

@@ -1,3 +1,4 @@
+import type Long from 'long';
 import type { Buffer } from 'node:buffer';
 import type { JsStoreCallbacks } from '@oxidezap/whatsapp-rust-bridge';
 import type { proto } from '../WAProto/runtime.js';
@@ -43,7 +44,9 @@ export type AccountSettings = {
     /** unarchive chats when a new message is received */
     unarchiveChats: boolean;
     /** the default mode to start new conversations with */
-    defaultDisappearingMode?: Pick<proto.IConversation, 'ephemeralExpiration' | 'ephemeralSettingTimestamp'>;
+    defaultDisappearingMode?: Pick<proto.IConversation, 'ephemeralExpiration'> & {
+        ephemeralSettingTimestamp?: number | Long | null;
+    };
 };
 /**
  * Authentication credentials.

package/lib/Types/Chat.d.ts

@@ -6,15 +6,33 @@ import type { LabelActionBody } from './Label.js';
 import type { ChatLabelAssociationActionBody } from './LabelAssociation.js';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation.js';
 import type { MinimalMessage, WAMessageKey } from './Message.js';
-/** privacy settings in WhatsApp Web */
-export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
-export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
-export type WAPrivacyGroupAddValue = 'all' | 'contacts' | 'contact_blacklist';
-export type WAReadReceiptsValue = 'all' | 'none';
-export type WAPrivacyCallValue = 'all' | 'known';
-export type WAPrivacyMessagesValue = 'all' | 'contacts';
+/**
+ * privacy settings in WhatsApp Web
+ *
+ * Each of these is a set first and a type second: the wrappers that take one
+ * check the value against the same array the type is derived from, so a value
+ * cannot be accepted by the compiler and refused at runtime, or the reverse.
+ */
+export declare const WA_PRIVACY_VALUES: readonly ['all', 'contacts', 'contact_blacklist', 'none'];
+export type WAPrivacyValue = (typeof WA_PRIVACY_VALUES)[number];
+export declare const WA_PRIVACY_ONLINE_VALUES: readonly ['all', 'match_last_seen'];
+export type WAPrivacyOnlineValue = (typeof WA_PRIVACY_ONLINE_VALUES)[number];
+export declare const WA_PRIVACY_GROUP_ADD_VALUES: readonly ['all', 'contacts', 'contact_blacklist'];
+export type WAPrivacyGroupAddValue = (typeof WA_PRIVACY_GROUP_ADD_VALUES)[number];
+export declare const WA_READ_RECEIPTS_VALUES: readonly ['all', 'none'];
+export type WAReadReceiptsValue = (typeof WA_READ_RECEIPTS_VALUES)[number];
+export declare const WA_PRIVACY_CALL_VALUES: readonly ['all', 'known'];
+export type WAPrivacyCallValue = (typeof WA_PRIVACY_CALL_VALUES)[number];
+export declare const WA_PRIVACY_MESSAGES_VALUES: readonly ['all', 'contacts'];
+export type WAPrivacyMessagesValue = (typeof WA_PRIVACY_MESSAGES_VALUES)[number];
+/** the two the account itself broadcasts, as opposed to the per-chat states */
+export declare const WA_PRESENCE_STATUSES: readonly ['unavailable', 'available'];
+export type WAPresenceStatus = (typeof WA_PRESENCE_STATUSES)[number];
+export declare const WA_CHAT_STATES: readonly ['composing', 'recording', 'paused'];
+export type WAChatState = (typeof WA_CHAT_STATES)[number];
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
-export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
+export declare const WA_PRESENCES: readonly ["unavailable", "available", "composing", "recording", "paused"];
+export type WAPresence = (typeof WA_PRESENCES)[number];
 export declare const ALL_WA_PATCH_NAMES: readonly ['critical_block', 'critical_unblock_low', 'regular_high', 'regular_low', 'regular'];
 export type WAPatchName = (typeof ALL_WA_PATCH_NAMES)[number];
 export interface PresenceData {