@oxidezap/baileyrs 0.1.2 → 0.2.0

package/lib/Types/Chat.js

@@ -1,3 +1,21 @@
+/**
+ * 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 const WA_PRIVACY_VALUES = ['all', 'contacts', 'contact_blacklist', 'none'];
+export const WA_PRIVACY_ONLINE_VALUES = ['all', 'match_last_seen'];
+export const WA_PRIVACY_GROUP_ADD_VALUES = ['all', 'contacts', 'contact_blacklist'];
+export const WA_READ_RECEIPTS_VALUES = ['all', 'none'];
+export const WA_PRIVACY_CALL_VALUES = ['all', 'known'];
+export const WA_PRIVACY_MESSAGES_VALUES = ['all', 'contacts'];
+/** the two the account itself broadcasts, as opposed to the per-chat states */
+export const WA_PRESENCE_STATUSES = ['unavailable', 'available'];
+export const WA_CHAT_STATES = ['composing', 'recording', 'paused'];
+/** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
+export const WA_PRESENCES = [...WA_PRESENCE_STATUSES, ...WA_CHAT_STATES];
 export const ALL_WA_PATCH_NAMES = [
     'critical_block',
     'critical_unblock_low',

package/lib/Types/Events.d.ts

@@ -132,6 +132,23 @@ export type BaileysEventMap = {
         association: LabelAssociation;
         type: 'add' | 'remove';
     };
+    /**
+     * A batched app-state sync left collections unsynced. Not an upstream event:
+     * upstream never withholds a session on app state, so it has nothing to
+     * report here.
+     *
+     * The engine does the opposite of withholding — it announces a connection
+     * whose critical sync came back degraded, precisely so a session that works
+     * is usable — and this is what says which collections are missing from it.
+     * `connected` tells "degraded but usable" from a sync that ran before the
+     * connection was ready; `fatal` is the half a retry cannot fix.
+     */
+    'app-state-sync.failed': {
+        fatal: string[];
+        retryable: string[];
+        skipped: string[];
+        connected: boolean;
+    };
     /** Newsletter-related events */
     'newsletter.reaction': {
         id: string;

package/lib/Types/GroupMetadata.d.ts

@@ -5,7 +5,9 @@ export type GroupParticipant = Contact & {
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
 };
-export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote' | 'modify';
+export declare const PARTICIPANT_ACTIONS: readonly ['add', 'remove', 'promote', 'demote', 'modify'];
+/** Derived from the values, so the runtime check and the type cannot drift. */
+export type ParticipantAction = (typeof PARTICIPANT_ACTIONS)[number];
 export type RequestJoinAction = 'created' | 'revoked' | 'rejected';
 export type RequestJoinMethod = 'invite_link' | 'linked_group_join' | 'non_admin_add' | undefined;
 export interface GroupMetadata {

package/lib/Types/GroupMetadata.js

@@ -1,2 +1,2 @@
-export {};
+export const PARTICIPANT_ACTIONS = ['add', 'remove', 'promote', 'demote', 'modify'];
 //# sourceMappingURL=GroupMetadata.js.map

package/lib/Types/Message.d.ts

@@ -1,3 +1,4 @@
+import type Long from 'long';
 import type { Readable } from 'stream';
 import type { URL } from 'url';
 import type { MediaType as BridgeMediaType, UploadMediaResult, WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
@@ -8,8 +9,23 @@ import type { BinaryNode } from './BinaryNode.js';
 import type { GroupMetadata } from './GroupMetadata.js';
 import type { CacheStore } from './Socket.js';
 export { proto as WAProto };
-export type WAMessage = Omit<proto.IWebMessageInfo, 'messageStubParameters'> & {
+export type WAMessage = Omit<proto.IWebMessageInfo, 'messageStubParameters' | 'messageTimestamp'> & {
     key: WAMessageKey;
+    /**
+     * `number | Long`, as upstream declares it — not the neutral codec's `Int64`.
+     *
+     * From bridge 0.8.0 a 64-bit field is typed `number | { low, high, unsigned }`,
+     * a plain data shape carrying none of Long's methods. That is what the *codec*
+     * produces; it is not what this library hands out. The compatibility facade
+     * supplies a reader that materialises every 64-bit word as a long.js Long
+     * whatever its magnitude, and the published declaration has always said so, so
+     * a consumer calling `.toNumber()` is right to expect one.
+     *
+     * Declared here rather than left to flow through, because the neutral shape
+     * otherwise reaches every type derived from `WAMessage` and stops them being
+     * assignable to upstream's.
+     */
+    messageTimestamp?: number | Long | null;
     category?: string;
     retryCount?: number;
     messageStubParameters?: any;
@@ -51,7 +67,9 @@ export type MessageType = keyof proto.Message;
 export declare const WAMessageAddressingMode: typeof WAMessageAddressingModeType;
 export type WAMessageAddressingMode = WAMessageAddressingModeType;
 export type MessageWithContextInfo = 'imageMessage' | 'contactMessage' | 'locationMessage' | 'extendedTextMessage' | 'documentMessage' | 'audioMessage' | 'videoMessage' | 'call' | 'contactsArrayMessage' | 'liveLocationMessage' | 'templateMessage' | 'stickerMessage' | 'groupInviteMessage' | 'templateButtonReplyMessage' | 'productMessage' | 'listMessage' | 'orderMessage' | 'listResponseMessage' | 'buttonsMessage' | 'buttonsResponseMessage' | 'interactiveMessage' | 'interactiveResponseMessage' | 'pollCreationMessage' | 'requestPhoneNumberMessage' | 'messageHistoryBundle' | 'eventMessage' | 'newsletterAdminInviteMessage' | 'albumMessage' | 'stickerPackMessage' | 'pollResultSnapshotMessage' | 'messageHistoryNotice';
-export type MessageReceiptType = 'read' | 'read-self' | 'hist_sync' | 'peer_msg' | 'sender' | 'inactive' | 'played' | undefined;
+/** `undefined` is a member: it is how upstream spells a delivery receipt. */
+export declare const MESSAGE_RECEIPT_TYPES: readonly ['read', 'read-self', 'hist_sync', 'peer_msg', 'sender', 'inactive', 'played', undefined];
+export type MessageReceiptType = (typeof MESSAGE_RECEIPT_TYPES)[number];
 export type MediaConnInfo = {
     auth: string;
     ttl: number;

package/lib/Types/Message.js

@@ -7,4 +7,15 @@ export const WAMessageAddressingMode = Object.freeze({
     PN: 'pn',
     LID: 'lid'
 });
+/** `undefined` is a member: it is how upstream spells a delivery receipt. */
+export const MESSAGE_RECEIPT_TYPES = [
+    'read',
+    'read-self',
+    'hist_sync',
+    'peer_msg',
+    'sender',
+    'inactive',
+    'played',
+    undefined
+];
 //# sourceMappingURL=Message.js.map

package/lib/Utils/argument-domain.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Refuse a value outside a closed set, naming the method, the parameter, what
+ * arrived and everything that is accepted.
+ *
+ * Call it in the synchronous prefix of the public method, ahead of the first
+ * `await`. That is what puts the caller's own frame in the stack: a
+ * fire-and-forget call leaves no awaiting frame for V8 to stitch an async
+ * stack onto, and past the bridge boundary the rejection is built inside wasm
+ * and carries nothing but wasm frames.
+ *
+ * The domain is always the values that define the parameter's type, never a
+ * second list written beside it.
+ */
+export declare const assertArgumentDomain: <Value extends string | undefined>(method: string, parameter: string, value: unknown, domain: readonly Value[]) => Value;
+//# sourceMappingURL=argument-domain.d.ts.map

package/lib/Utils/argument-domain.js

@@ -0,0 +1,36 @@
+import { Boom } from './boom.js';
+/** Quoted when it is a string, bare otherwise, so `""` and `undefined` read apart. */
+const shown = (value) => {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    try {
+        return String(value);
+    }
+    catch {
+        // A null-prototype object, a revoked proxy, a trap that throws. `typeof`
+        // reads nothing off the value, so reporting it cannot fail on it.
+        return `[${typeof value}]`;
+    }
+};
+/**
+ * Refuse a value outside a closed set, naming the method, the parameter, what
+ * arrived and everything that is accepted.
+ *
+ * Call it in the synchronous prefix of the public method, ahead of the first
+ * `await`. That is what puts the caller's own frame in the stack: a
+ * fire-and-forget call leaves no awaiting frame for V8 to stitch an async
+ * stack onto, and past the bridge boundary the rejection is built inside wasm
+ * and carries nothing but wasm frames.
+ *
+ * The domain is always the values that define the parameter's type, never a
+ * second list written beside it.
+ */
+export const assertArgumentDomain = (method, parameter, value, domain) => {
+    if (domain.includes(value))
+        return value;
+    const error = new Boom(`${method}: ${JSON.stringify(parameter)} must be one of ${domain.map(shown).join(', ')}, received ${shown(value)}`, { statusCode: 400, data: { parameter, value, accepted: [...domain] } });
+    // Drop this frame: the method the consumer called is the useful top.
+    Error.captureStackTrace(error, assertArgumentDomain);
+    throw error;
+};
+//# sourceMappingURL=argument-domain.js.map

package/lib/Utils/event-buffer.js

@@ -143,7 +143,14 @@ const append = (data, historyCache, event, eventData, logger) => {
         case 'chats.upsert': {
             for (const chat of eventData) {
                 const id = chat.id || '';
-                let existing = data.chatUpserts[id] || data.historySets.chats[id];
+                // The history set is only consulted for a chat that *has* an id.
+                // Upstream guards the lookup with `id &&`, and this port had dropped
+                // it: an id-less chat then folded into whatever id-less entry a
+                // buffered history set happened to carry, summing their unread counts,
+                // where upstream releases it as its own `chats.upsert`. Found by the
+                // buffer differential once history rows started drawing from the same
+                // identity pool as live traffic.
+                let existing = data.chatUpserts[id] || (id ? data.historySets.chats[id] : undefined);
                 if (existing)
                     concatChats(existing, chat);
                 else {
@@ -185,14 +192,37 @@ const append = (data, historyCache, event, eventData, logger) => {
         case 'contacts.upsert': {
             for (const contact of eventData) {
                 const existing = data.contactUpserts[contact.id] || data.historySets.contacts[contact.id];
-                if (existing)
-                    Object.assign(existing, trimUndefined(contact));
-                else
-                    data.contactUpserts[contact.id] = contact;
+                // A `contacts.update` already buffered for this id arrived *before*
+                // this upsert, so it is folded in first and the upsert's own values
+                // win where the two carry the same field. Folding it last — which is
+                // what this did — let a stale name overwrite the one that came after
+                // it, and the buffer released the older of the two. Fields only the
+                // update carried still survive, which upstream drops.
                 const pending = data.contactUpdates[contact.id];
-                if (pending) {
-                    Object.assign(existing || contact, pending);
+                if (pending)
                     delete data.contactUpdates[contact.id];
+                if (existing) {
+                    if (pending)
+                        Object.assign(existing, pending);
+                    Object.assign(existing, trimUndefined(contact));
+                }
+                else {
+                    // Filling the gaps in `contact` rather than merging onto `pending`
+                    // and storing that: `pending` was grown from `{}` by the update
+                    // branch, and accumulating into it — or into a fresh literal —
+                    // measured about twice the cost of writing into the contact the
+                    // caller handed us, which arrives with a settled shape. An
+                    // explicitly-`undefined` field counts as absent, which is what
+                    // `trimUndefined` would decide and costs no second pass.
+                    if (pending) {
+                        const target = contact;
+                        const source = pending;
+                        for (const field in source) {
+                            if (target[field] === undefined)
+                                target[field] = source[field];
+                        }
+                    }
+                    data.contactUpserts[contact.id] = contact;
                 }
             }
             break;
@@ -326,17 +356,21 @@ const consolidateEvents = (data) => {
         if (Array.isArray(values) && values.length > 0)
             events[event] = values;
     };
+    // The order of these writes is the contract, not an implementation detail.
+    // A flush walks `Object.keys()` of this map, so insertion order decides both
+    // the key order a `process()` handler iterates and the order the individual
+    // events are re-dispatched to `.on()` listeners. Handlers that assume
+    // upstream's sequence — messages before the contacts they reference — see a
+    // different interleaving if these move. Keep them aligned with upstream's
+    // `consolidateEvents`.
     assignArray('chats.upsert', Object.values(data.chatUpserts));
     assignArray('chats.update', Object.values(data.chatUpdates));
     assignArray('chats.delete', [...data.chatDeletes]);
-    assignArray('contacts.upsert', Object.values(data.contactUpserts));
-    assignArray('contacts.update', Object.values(data.contactUpdates));
-    assignArray('messages.update', Object.values(data.messageUpdates));
-    assignArray('groups.update', Object.values(data.groupUpdates));
     const upserts = Object.values(data.messageUpserts);
     if (upserts.length) {
         events['messages.upsert'] = { messages: upserts.map(item => item.message), type: upserts[0].type };
     }
+    assignArray('messages.update', Object.values(data.messageUpdates));
     const deleted = Object.values(data.messageDeletes);
     if (deleted.length)
         events['messages.delete'] = { keys: deleted };
@@ -346,6 +380,9 @@ const consolidateEvents = (data) => {
     const receipts = Object.values(data.messageReceipts).flatMap(({ key, userReceipt }) => userReceipt.map(receipt => ({ key, receipt })));
     if (receipts.length)
         events['message-receipt.update'] = receipts;
+    assignArray('contacts.upsert', Object.values(data.contactUpserts));
+    assignArray('contacts.update', Object.values(data.contactUpdates));
+    assignArray('groups.update', Object.values(data.groupUpdates));
     return events;
 };
 /**

package/lib/Utils/messages.d.ts

@@ -55,6 +55,8 @@ export type DownloadMediaMessageContext = {
     /** Bridge client for media download. Falls back to the registered one. */
     waClient?: Pick<WasmWhatsAppClient, 'downloadMedia' | 'downloadMediaStream'>;
 };
+export declare const MEDIA_DOWNLOAD_TYPES: readonly ['buffer', 'stream'];
+export type MediaDownloadType = (typeof MEDIA_DOWNLOAD_TYPES)[number];
 /**
  * Downloads the given message. Throws an error if it's not a media message.
  *
@@ -68,7 +70,7 @@ export type DownloadMediaMessageContext = {
  * several sockets should pass `ctx` explicitly, because the registration points
  * at whichever client was created last.
  */
-export declare const downloadMediaMessage: <Type extends 'buffer' | 'stream'>(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer<ArrayBufferLike> : Readable>;
+export declare const downloadMediaMessage: <Type extends MediaDownloadType>(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer<ArrayBufferLike> : Readable>;
 export declare const _registerActiveBridgeClient: (client: WasmWhatsAppClient, logger?: ILogger) => void;
 /**
  * Drop the module-level pointer when `sock.end()` frees the client it points

package/lib/Utils/messages.js

@@ -6,6 +6,7 @@ import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT
 import { WAMessageStatus, WAProto } from '../Types/index.js';
 import { proto } from '../WAProto/runtime.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { assertArgumentDomain } from './argument-domain.js';
 import { Boom } from './boom.js';
 import { sha256 } from './crypto.js';
 import { getKeyAuthor, toNumber, unixTimestampSeconds } from './generics.js';
@@ -227,22 +228,45 @@ export const generateForwardMessageContent = (message, forceForward) => {
         throw new Boom('no content in message', { statusCode: 400 });
     }
     content = normalizeMessageContent(content);
-    // Shallow clone — only the inner message object gets modified (contextInfo)
+    // Shallow clone of the outer map — one entry on it is rewritten below.
     content = { ...content };
     let key = Object.keys(content)[0];
     let score = content?.[key]?.contextInfo?.forwardingScore || 0;
     score += message.key.fromMe && !forceForward ? 0 : 1;
+    const contextInfo = score > 0 ? { forwardingScore: score, isForwarded: true } : {};
+    // The nested message object is the *caller's*, reached through the shallow
+    // clone above, so writing `contextInfo` onto it wrote into their argument.
+    // And it replaces rather than merges: a caller who forwarded a quoted message
+    // found `stanzaId` and `participant` gone from their own object afterwards.
+    // Upstream leaves the argument untouched.
+    //
+    // Rebuilt rather than deep-copied, and only the one object being written.
+    // Upstream's copy is `proto.Message.decode(proto.Message.encode(content))` —
+    // a full serialise/parse round trip on a hot send path — which is not worth
+    // paying to fix an aliasing bug.
     if (key === 'conversation') {
-        content.extendedTextMessage = { text: content[key] };
+        // This object is created here, so nothing of the caller's is aliased and
+        // the `contextInfo` goes straight in. Same allocation count as before.
+        content.extendedTextMessage = { text: content[key], contextInfo };
         delete content.conversation;
         key = 'extendedTextMessage';
-    }
-    const key_ = content?.[key];
-    if (score > 0) {
-        key_.contextInfo = { forwardingScore: score, isForwarded: true };
+        return content;
+    }
+    const nested = content[key];
+    // A plain object is the only thing worth copying, and the only thing that can
+    // be the caller's to damage. Anything else — an absent slot on an empty
+    // message, a primitive, an array — keeps the original assignment, which
+    // throws for exactly the inputs it threw for before and that upstream throws
+    // for too. Spreading those instead invented a property named `"undefined"`
+    // where upstream raised a TypeError.
+    if (typeof nested === 'object' && nested !== null && !Array.isArray(nested)) {
+        // One shallow spread, of exactly the object being modified. This is the
+        // whole cost of the fix, and it is unavoidable: not writing into the
+        // caller's object means writing into a different one.
+        content[key] = { ...nested, contextInfo };
     }
     else {
-        key_.contextInfo = {};
+        nested.contextInfo = contextInfo;
     }
     return content;
 };
@@ -664,6 +688,7 @@ export const extractMessageContent = (content) => {
     }
     return content;
 };
+export const MEDIA_DOWNLOAD_TYPES = ['buffer', 'stream'];
 /**
  * Downloads the given message. Throws an error if it's not a media message.
  *
@@ -678,6 +703,9 @@ export const extractMessageContent = (content) => {
  * at whichever client was created last.
  */
 export const downloadMediaMessage = async (message, type, options, ctx) => {
+    // Anything but 'buffer' used to take the stream branch, so a typo returned
+    // a Readable to a caller holding it as a Buffer.
+    assertArgumentDomain('downloadMediaMessage', 'type', type, MEDIA_DOWNLOAD_TYPES);
     const waClient = ctx?.waClient ?? activeBridgeClient;
     if (!waClient) {
         throw new Boom('downloadMediaMessage: no bridge client available, and the download, its CDN failover and its decryption all happen in the engine. Pass `{ waClient: sock.waClient }`, use `sock.downloadMedia(message, type, options)`, or call after `makeWASocket()` has initialized.', { statusCode: 500 });

package/lib/Utils/process-history-message.d.ts

@@ -36,6 +36,15 @@ export declare const processHistoryMessage: (item: proto.IHistorySync, logger?:
 export declare const downloadHistory: (msg: proto.Message.IHistorySyncNotification, options: RequestInit) => Promise<proto.HistorySync>;
 /** Resolve inline or external history-sync content and normalize its public payload. */
 export declare const downloadAndProcessHistorySyncNotification: (msg: proto.Message.IHistorySyncNotification, options: RequestInit, logger?: ILogger) => Promise<ProcessedHistorySync>;
-/** Extract a history-sync notification through the same wrapper normalization as upstream. */
-export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification;
+/**
+ * Extract a history-sync notification through the same wrapper normalization as
+ * upstream.
+ *
+ * Returns `undefined` when the message carries none. It used to throw a Boom
+ * 400, which breaks the shape every caller writes against a drop-in API —
+ * `const h = getHistoryMsg(msg); if (!h) return` crashed instead of returning.
+ * "Absent" is the ordinary case here, not an error: any message that is not a
+ * history sync takes this path.
+ */
+export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification | undefined;
 //# sourceMappingURL=process-history-message.d.ts.map

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

@@ -14,7 +14,6 @@ import { inflateZlib } from '@oxidezap/whatsapp-rust-bridge';
 import { proto } from '../WAProto/runtime.js';
 import { WAProto } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/jid-utils.js';
-import { Boom } from './boom.js';
 import { toNumber } from './generics.js';
 import { downloadContentFromMessage, normalizeMessageContent } from './messages.js';
 import { createSparseArray } from './sparse-array.js';
@@ -199,13 +198,18 @@ export const downloadAndProcessHistorySyncNotification = async (msg, options, lo
         : await downloadHistory(msg, options);
     return processHistoryMessage(historyMsg, logger);
 };
-/** Extract a history-sync notification through the same wrapper normalization as upstream. */
+/**
+ * Extract a history-sync notification through the same wrapper normalization as
+ * upstream.
+ *
+ * Returns `undefined` when the message carries none. It used to throw a Boom
+ * 400, which breaks the shape every caller writes against a drop-in API —
+ * `const h = getHistoryMsg(msg); if (!h) return` crashed instead of returning.
+ * "Absent" is the ordinary case here, not an error: any message that is not a
+ * history sync takes this path.
+ */
 export const getHistoryMsg = (message) => {
     const normalizedContent = message ? normalizeMessageContent(message) : undefined;
-    const historySyncNotification = normalizedContent?.protocolMessage?.historySyncNotification;
-    if (!historySyncNotification) {
-        throw new Boom('Message does not contain a history sync notification', { statusCode: 400 });
-    }
-    return historySyncNotification;
+    return normalizedContent?.protocolMessage?.historySyncNotification ?? undefined;
 };
 //# sourceMappingURL=process-history-message.js.map

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,7 +1,44 @@
 import { mkdir, stat } from 'node:fs/promises';
+import { createDeviceProjection } from '../Compatibility/legacy-store/device.js';
 import { projectNativeStore } from '../Compatibility/legacy-store/native-projection.js';
 import { initAuthCreds } from './generics.js';
 import { useBridgeStore } from './use-bridge-store.js';
+/**
+ * The store namespace and keys the engine writes its own device under.
+ *
+ * `<folder>/device-device.bin` and `<folder>/device-account.bin` on disk.
+ */
+const DEVICE_STORE = 'device';
+const DEVICE_RECORDS = ['device', 'account'];
+/**
+ * Rebuild the credential mirror from the device the engine persisted.
+ *
+ * Without this the mirror is whatever `initAuthCreds()` just made up: every
+ * restart handed back `registered: false` and `me: undefined` for a session
+ * that was paired and working, because nothing on this path ever read the
+ * device back. The hydration itself already existed for `wrapLegacyStore`
+ * (`Compatibility/legacy-store/adapter.ts`), which only runs for callers that
+ * bring their own `{ creds, keys }`; a caller using this function goes straight
+ * to the bridge store and used to skip it entirely.
+ *
+ * A record that fails to decode is skipped rather than fatal: a mirror missing
+ * a field is worth less than a socket that will not start, and the engine reads
+ * its own device from the same bytes regardless of what this makes of them.
+ */
+const hydrateFromStore = async (store, creds) => {
+    const projection = createDeviceProjection(creds);
+    for (const record of DEVICE_RECORDS) {
+        const payload = await store.get(DEVICE_STORE, record);
+        if (!payload)
+            continue;
+        try {
+            projection.prepare(record, payload)();
+        }
+        catch {
+            /* a record we cannot read leaves that part of the mirror at its default */
+        }
+    }
+};
 /**
  * Creates a file-based authentication state for the Rust bridge.
  *
@@ -30,6 +67,14 @@ export const useMultiFileAuthState = async (folder) => {
     }
     const store = await useBridgeStore(folder);
     const creds = initAuthCreds();
+    // Before `projectNativeStore`, and that ordering is the whole point: the
+    // projection captures `signedIdentityKey.public` and `registrationId` off
+    // `creds` when it is called, and builds the Signal codecs around them.
+    // Hydrating afterwards would leave those codecs holding the identity of the
+    // throwaway `initAuthCreds()` rather than the device's, so a legacy session
+    // written through this store would be imported under the wrong local
+    // identity.
+    await hydrateFromStore(store, creds);
     const keys = projectNativeStore(store, creds);
     return {
         state: { creds, keys, store },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",
@@ -47,6 +47,7 @@
     "lib/**/*",
     "!lib/**/*.map",
     "!lib/**/__tests__/**",
+    "!lib/__fuzz__/**",
     "!lib/**/*.test.*",
     "!lib/**/*.test-e2e.*"
   ],
@@ -58,6 +59,7 @@
     "compat:audit:missing": "npm run build --silent && node scripts/compatibility/audit.ts --only-missing",
     "compat:audit:proto": "node scripts/compatibility/proto-runtime-audit.ts --details --strict",
     "compat:audit:wire": "node scripts/compatibility/wire-fidelity-audit.ts --details --strict",
+    "compat:audit:lifecycle": "node scripts/compatibility/lifecycle-contract-audit.ts --strict",
     "compat:audit:strict": "npm run build --silent && node scripts/compatibility/audit.ts --strict --only-missing",
     "compat:sync-waproto": "node scripts/compatibility/waproto-facade.ts --sync",
     "compat:check-waproto": "node scripts/compatibility/waproto-facade.ts --check",
@@ -70,13 +72,17 @@
     "prepack": "npm run build && node scripts/check-pack.ts",
     "prepare": "npm run build",
     "test": "node --test",
+    "fuzz": "node --test --test-timeout=600000 ./src/__fuzz__/**/*.test.ts",
+    "fuzz:deep": "FUZZ_MODE=deep node --expose-gc --test --test-timeout=1800000 ./src/__fuzz__/**/*.test.ts",
+    "fuzz:record": "FUZZ_RECORD=1 node --test --test-timeout=600000 ./src/__fuzz__/**/*.test.ts",
+    "fuzz:report": "node scripts/fuzz/report.ts",
     "test:compat-auditor": "node --test scripts/compatibility/__tests__/audit.test.ts",
     "typecheck:compat-auditor": "npm run build --silent && npm run compat:check-waproto --silent && npm run compat:layers --silent && tsc -p scripts/compatibility/tsconfig.json",
-    "test:e2e": "NODE_TLS_REJECT_UNAUTHORIZED=0 ADV_SECRET_KEY=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= node --expose-gc --test --test-concurrency=1 ./src/__tests__/e2e/*.test-e2e.ts"
+    "test:e2e": "NODE_TLS_REJECT_UNAUTHORIZED=0 ADV_SECRET_KEY=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= node --expose-gc --test --test-concurrency=1 ./src/__tests__/e2e/*.test-e2e.ts ./scripts/compatibility/__tests__/*.test-e2e.ts"
   },
   "dependencies": {
     "@hapi/boom": "^9.1.4",
-    "@oxidezap/whatsapp-rust-bridge": "0.7.0",
+    "@oxidezap/whatsapp-rust-bridge": "0.11.0",
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5"