@oxidezap/baileyrs 0.1.3 → 0.2.0

package/lib/Compatibility/derived-stanza-nodes.d.ts

@@ -0,0 +1,28 @@
+import type { BinaryNode } from '../Types/index.js';
+/**
+ * The tag the engine refused, or `undefined` when the error is something else.
+ *
+ * Read off the message rather than off a field: the rejection names the tag
+ * inside its text (`extra stanza child <biz> conflicts with …`), and matching
+ * the sentence keeps this from firing on an unrelated invalid-argument — a
+ * malformed JID, an out-of-range enum — that a blanket retry would silently
+ * send twice.
+ */
+export declare const derivedNodeConflictTag: (error: unknown) => string | undefined;
+/** The caller's nodes without the one the engine derives, or `undefined` if none matched. */
+export declare const withoutDerivedNode: (nodes: readonly BinaryNode[], tag: string) => BinaryNode[] | undefined;
+/**
+ * Send, dropping whichever derived node the engine names, until it stops
+ * naming one.
+ *
+ * A loop rather than a single retry: a DM carrying an interactive payload
+ * derives both `<biz>` and `<bot>`, and the engine reports one conflicting tag
+ * per attempt — so a caller supplying both would have the first dropped and
+ * fail on the second. Each pass removes at least one node, and the caller's own
+ * list bounds the passes, so this cannot spin.
+ *
+ * Every attempt is refused before the engine encrypts or sends, which is what
+ * makes retrying safe here and nowhere else.
+ */
+export declare const sendDroppingDerivedNodes: <T>(nodes: readonly BinaryNode[], send: (nodes: BinaryNode[]) => Promise<T>, onDrop: (tag: string) => void) => Promise<T>;
+//# sourceMappingURL=derived-stanza-nodes.d.ts.map

package/lib/Compatibility/derived-stanza-nodes.js

@@ -0,0 +1,71 @@
+/**
+ * Upstream Baileys derives no stanza children of its own, so a caller that
+ * wants the `<biz>` on an interactive message has to attach it — which is what
+ * every payment recipe in that ecosystem tells them to do. The engine here
+ * derives it from the message content instead, and from
+ * `whatsapp-rust-bridge` 0.11.0 it refuses a caller node whose tag it already
+ * derives rather than sending both. Two of them on one `<message>` is what the
+ * client silently declines to render.
+ *
+ * That refusal is the correct behaviour and this is not an attempt to undo it.
+ * It only keeps the promise this library makes: Baileys code runs unchanged.
+ * A caller node the engine did not derive is left alone, because on a message
+ * that derives nothing the caller's node is the only one there is.
+ */
+/** The wire text the engine uses. Matched rather than parsed: it carries the tag. */
+const DERIVED_CONFLICT = 'conflicts with the one this send derives';
+/**
+ * The tag the engine refused, or `undefined` when the error is something else.
+ *
+ * Read off the message rather than off a field: the rejection names the tag
+ * inside its text (`extra stanza child <biz> conflicts with …`), and matching
+ * the sentence keeps this from firing on an unrelated invalid-argument — a
+ * malformed JID, an out-of-range enum — that a blanket retry would silently
+ * send twice.
+ */
+export const derivedNodeConflictTag = (error) => {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const { kind, reason, message } = error;
+    if (kind !== 'invalid-argument')
+        return undefined;
+    const text = typeof reason === 'string' ? reason : typeof message === 'string' ? message : '';
+    if (!text.includes(DERIVED_CONFLICT))
+        return undefined;
+    return /<([a-z-]+)>/u.exec(text)?.[1];
+};
+/** The caller's nodes without the one the engine derives, or `undefined` if none matched. */
+export const withoutDerivedNode = (nodes, tag) => {
+    const kept = nodes.filter(node => node.tag !== tag);
+    return kept.length === nodes.length ? undefined : kept;
+};
+/**
+ * Send, dropping whichever derived node the engine names, until it stops
+ * naming one.
+ *
+ * A loop rather than a single retry: a DM carrying an interactive payload
+ * derives both `<biz>` and `<bot>`, and the engine reports one conflicting tag
+ * per attempt — so a caller supplying both would have the first dropped and
+ * fail on the second. Each pass removes at least one node, and the caller's own
+ * list bounds the passes, so this cannot spin.
+ *
+ * Every attempt is refused before the engine encrypts or sends, which is what
+ * makes retrying safe here and nowhere else.
+ */
+export const sendDroppingDerivedNodes = async (nodes, send, onDrop) => {
+    let current = [...nodes];
+    for (let passes = nodes.length;; passes--) {
+        try {
+            return await send(current);
+        }
+        catch (error) {
+            const tag = passes > 0 ? derivedNodeConflictTag(error) : undefined;
+            const kept = tag === undefined ? undefined : withoutDerivedNode(current, tag);
+            if (tag === undefined || !kept)
+                throw error;
+            onDrop(tag);
+            current = kept;
+        }
+    }
+};
+//# sourceMappingURL=derived-stanza-nodes.js.map

package/lib/Compatibility/encode-proto.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `encodeProto`, with the two inputs the bridge codec stopped accepting put back.
+ *
+ * From 0.8.0 the codec refuses an empty string where the schema declares a
+ * 64-bit integer, and an unpaired surrogate in a text field. Both were written
+ * before — as `0` and as U+FFFD — and upstream Baileys still encodes both, so a
+ * message that used to reach the server would now throw in the caller's face.
+ * This is where that is absorbed, so the strict contract stays true of the
+ * bridge and the tolerant one stays true of this library.
+ *
+ * Repair on failure rather than check on write: the ordinary encode is exactly
+ * the call it was before, with no scan of any field, and the repair runs only
+ * for a message that was already going to throw. `encodeProto` returns finished
+ * bytes rather than a lazy writer, so one try/catch covers it.
+ */
+export declare const encodeProtoCompat: (path: string, message: unknown) => Uint8Array;
+//# sourceMappingURL=encode-proto.d.ts.map

package/lib/Compatibility/encode-proto.js

@@ -0,0 +1,32 @@
+import { encodeProto } from '@oxidezap/whatsapp-rust-bridge';
+import { repairProtoMessage } from './proto-runtime.js';
+/**
+ * `encodeProto`, with the two inputs the bridge codec stopped accepting put back.
+ *
+ * From 0.8.0 the codec refuses an empty string where the schema declares a
+ * 64-bit integer, and an unpaired surrogate in a text field. Both were written
+ * before — as `0` and as U+FFFD — and upstream Baileys still encodes both, so a
+ * message that used to reach the server would now throw in the caller's face.
+ * This is where that is absorbed, so the strict contract stays true of the
+ * bridge and the tolerant one stays true of this library.
+ *
+ * Repair on failure rather than check on write: the ordinary encode is exactly
+ * the call it was before, with no scan of any field, and the repair runs only
+ * for a message that was already going to throw. `encodeProto` returns finished
+ * bytes rather than a lazy writer, so one try/catch covers it.
+ */
+export const encodeProtoCompat = (path, message) => {
+    try {
+        return encodeProto(path, message);
+    }
+    catch (error) {
+        const repaired = repairProtoMessage(path, message);
+        // Reference equality: nothing was coerced, so the failure is something this
+        // does not explain — an unmodelled type, a number no int64 can hold — and
+        // it has to keep propagating rather than be retried into a second throw.
+        if (repaired === message)
+            throw error;
+        return encodeProto(path, repaired);
+    }
+};
+//# sourceMappingURL=encode-proto.js.map

package/lib/Compatibility/proto-runtime.d.ts

@@ -1,4 +1,14 @@
 type DynamicObject = Record<PropertyKey, unknown>;
+/**
+ * Repairs a message for a codec addressed by type name rather than schema index.
+ *
+ * The send path calls the neutral `encodeProto` directly instead of going
+ * through this facade's constructors, so it cannot reach the repair the way
+ * `proto.Message.encode` does. Same coercion, same copy-on-write contract:
+ * reference equality still means "nothing to fix", so a caller can tell a
+ * repair from a failure it does not understand.
+ */
+export declare const repairProtoMessage: (path: string, message: unknown) => unknown;
 export interface ProtoCompatibilityFacade {
     proto: DynamicObject;
     unsupportedCodecs: readonly string[];

package/lib/Compatibility/proto-runtime.js

@@ -46,33 +46,71 @@ const appendBytes = (writer, bytes) => {
     }
     return appendable;
 };
+/**
+ * A UTF-16 code unit with no partner. There is no UTF-8 form for one, so the
+ * codec refuses it rather than letting `TextEncoder` substitute silently.
+ */
+const UNPAIRED_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/gu;
+/**
+ * Puts back what the codec used to do with an input it now refuses.
+ *
+ * Two cases, both measured against upstream Baileys, which still encodes both:
+ *
+ * - An empty string where the schema declares a 64-bit integer. Every one of the
+ *   134 send-path failures this addresses carried exactly `''`; a string that is
+ *   merely not a number — `'abc'`, `'1.5'` — is left to throw, because that was
+ *   never accepted and silently writing a value nobody sent is the worse answer.
+ * - An unpaired surrogate in a text field, replaced with U+FFFD. That is the
+ *   substitution `TextEncoder` used to make, so the bytes are unchanged from what
+ *   this library sent before.
+ *
+ * Returns `item` itself when it has nothing to do, so the caller can tell a
+ * repair from a failure it does not understand.
+ */
+const repairScalar = (kind, item) => {
+    if (typeof item !== 'string')
+        return item;
+    if (kind === PROTO_FIELD_KIND.signed64 || kind === PROTO_FIELD_KIND.unsigned64) {
+        return item === '' ? 0 : item;
+    }
+    if (kind !== PROTO_FIELD_KIND.string)
+        return item;
+    const replaced = item.replace(UNPAIRED_SURROGATE, '\uFFFD');
+    return replaced === item ? item : replaced;
+};
 const longFromWords = (low, high, unsigned) => LongRuntime.fromBits(low, high, unsigned);
 /**
- * The neutral codec normally returns safe JS numbers. The compatibility
- * facade supplies this reader so the same generated decoder materializes
- * protobuf 64-bit words directly as Long values, without a second decode or
- * an intermediate string/BigInt allocation.
+ * The neutral codec returns a JS number while a 64-bit value is exact as a
+ * double and a plain `{ low, high, unsigned }` past that. The compatibility
+ * facade supplies this reader so the same generated decoder materializes every
+ * 64-bit word as a long.js Long instead — uniformly, whatever the magnitude —
+ * without a second decode or an intermediate string/BigInt allocation.
+ *
+ * Uniformity is the point: upstream's types declare `Long` for these fields,
+ * so a consumer calling `.toNumber()` must not have that work only for values
+ * under 2^53. The neutral shape is structurally a Long minus its methods, and
+ * the methods are exactly what upstream code calls.
  */
 class LongBinaryReader extends BinaryReader {
-    uint64Number() {
+    uint64Value() {
         const [low, high] = this.varint64();
         return longFromWords(low, high, true);
     }
-    int64Number() {
+    int64Value() {
         const [low, high] = this.varint64();
         return longFromWords(low, high, false);
     }
-    sint64Number() {
+    sint64Value() {
         let [low, high] = this.varint64();
         const sign = -(low & 1);
         low = ((low >>> 1) | ((high & 1) << (WORD_BITS - 1))) ^ sign;
         high = (high >>> 1) ^ sign;
         return longFromWords(low, high, false);
     }
-    fixed64Number() {
+    fixed64Value() {
         return longFromWords(this.sfixed32(), this.sfixed32(), true);
     }
-    sfixed64Number() {
+    sfixed64Value() {
         return longFromWords(this.sfixed32(), this.sfixed32(), false);
     }
 }
@@ -194,6 +232,99 @@ const defineLazyValue = (target, key, build) => {
         }
     });
 };
+/**
+ * Type path to schema index, built on first use.
+ *
+ * Only the repair path needs it, and that path is only reached after an encode
+ * has already failed — so an importer that never sends a refused value never
+ * pays for the 498 entries.
+ */
+let schemaIdsByPath;
+const schemaIdFor = (path) => {
+    schemaIdsByPath ?? (schemaIdsByPath = new Map(PROTO_MESSAGE_SCHEMAS.map(([name], index) => [name, index])));
+    return schemaIdsByPath.get(path);
+};
+/**
+ * Coerces the two inputs the bridge codec stopped accepting back to what it
+ * used to write, and returns `value` itself when there was nothing to coerce.
+ *
+ * Reference equality is the signal: the caller only reaches here after an
+ * encode threw, and an unchanged result means the failure was something else
+ * — a genuinely invalid number, a missing codec — which must keep propagating.
+ *
+ * Copy-on-write throughout, like `projectForEncode`: a branch with nothing to
+ * fix is shared, not rebuilt.
+ */
+const repairMessage = (schemaId, value, ancestors) => {
+    if (!isObject(value))
+        return value;
+    const fields = PROTO_MESSAGE_SCHEMAS[schemaId]?.[1];
+    if (!fields)
+        return value;
+    // A message that contains itself, not one that is merely deep. A fixed depth
+    // cap was the earlier guard and it silently stopped repairing below it: 12
+    // nested `ephemeralMessage.message` wrappers is 24 levels, and an empty-string
+    // int64 under that many threw instead of being coerced. Recursive protobuf
+    // messages have no depth limit, so only an actual cycle can be refused.
+    const seen = ancestors ?? new Set();
+    if (seen.has(value))
+        return value;
+    seen.add(value);
+    let output;
+    for (const field of fields) {
+        if (!hasOwn(value, field[0]))
+            continue;
+        const current = value[field[0]];
+        if (current === null || current === undefined)
+            continue;
+        const repair = (item) => field[1] === PROTO_FIELD_KIND.message ? repairMessage(field[2], item, seen) : repairScalar(field[1], item);
+        let converted = current;
+        if (field[3] & PROTO_FIELD_FLAG.repeated) {
+            if (Array.isArray(current)) {
+                let items;
+                for (let index = 0; index < current.length; index++) {
+                    const item = repair(current[index]);
+                    if (item !== current[index])
+                        (items ?? (items = current.slice()))[index] = item;
+                }
+                converted = items ?? current;
+            }
+        }
+        else if (field[3] & PROTO_FIELD_FLAG.map) {
+            if (isObject(current)) {
+                let entries;
+                for (const key in current) {
+                    const item = repair(current[key]);
+                    if (item !== current[key])
+                        (entries ?? (entries = { ...current }))[key] = item;
+                }
+                converted = entries ?? current;
+            }
+        }
+        else {
+            converted = repair(current);
+        }
+        if (converted !== current)
+            (output ?? (output = { ...value }))[field[0]] = converted;
+    }
+    // The ancestor path, not everything ever visited: the same object reached
+    // twice in different branches is legitimate and must still be repaired.
+    seen.delete(value);
+    return output ?? value;
+};
+/**
+ * Repairs a message for a codec addressed by type name rather than schema index.
+ *
+ * The send path calls the neutral `encodeProto` directly instead of going
+ * through this facade's constructors, so it cannot reach the repair the way
+ * `proto.Message.encode` does. Same coercion, same copy-on-write contract:
+ * reference equality still means "nothing to fix", so a caller can tell a
+ * repair from a failure it does not understand.
+ */
+export const repairProtoMessage = (path, message) => {
+    const schemaId = schemaIdFor(path);
+    return schemaId === undefined ? message : repairMessage(schemaId, message);
+};
 class ProtoCompatibilityRuntime {
     constructor(sourceNamespace) {
         this.namespace = { ...sourceNamespace };
@@ -315,8 +446,42 @@ class ProtoCompatibilityRuntime {
         constructor.encode = (message, writer) => {
             if (!sourceCodec)
                 throw new Error(`protobuf codec unavailable for ${path}`);
-            const encoded = sourceCodec.encode(this.projectForEncode(schemaId, message));
-            return writer === undefined ? encoded : appendBytes(writer, encoded.finish());
+            const projected = this.projectForEncode(schemaId, message);
+            const encoded = sourceCodec.encode(projected);
+            // The bridge refuses two inputs it used to accept silently, and upstream
+            // Baileys still encodes both. Repairing on failure rather than checking
+            // every field on the way in is what keeps the ordinary encode free: a
+            // message the codec accepts never reaches the repair, and one that does
+            // not was already going to throw.
+            //
+            // The retry hangs off `finish` because the bridge's writer is lazy —
+            // `encode` queues the fields and `finish` is what writes them, so a
+            // refused value surfaces there. Re-encoding from the repaired message is
+            // safe for the same reason it would not be inside an overridden
+            // `string()`: that would have to resume after a tag and a length were
+            // already emitted, where this starts from a fresh writer.
+            const write = encoded.finish.bind(encoded);
+            const finish = () => {
+                try {
+                    return write();
+                }
+                catch (error) {
+                    const repaired = repairMessage(schemaId, projected);
+                    if (repaired === projected)
+                        throw error;
+                    return sourceCodec.encode(repaired).finish();
+                }
+            };
+            if (writer !== undefined)
+                return appendBytes(writer, finish());
+            // The codec's own writer is what comes back, with `finish` shadowed on
+            // the instance rather than replaced by a bare `{ finish }`. The published
+            // declaration types this return as a protobufjs `Writer`, and a caller
+            // that chains anything on it — `fork`, `join`, another field — has to
+            // find the rest of the surface still there. The writer is freshly made
+            // by this call, so shadowing one method on it touches nothing else.
+            encoded.finish = finish;
+            return encoded;
         };
         constructor.decode = (input, length) => {
             if (!sourceCodec)

package/lib/Socket/events.js

@@ -263,7 +263,7 @@ const DISPATCHERS = {
     // belongs on the bus: the QR the user was shown is spent, and `connecting`
     // clears it while telling the consumer a fresh one is coming.
     pairError: (evt, { ctx }) => {
-        ctx.logger.error({ err: evt.error }, 'pairing failed; the engine will retry');
+        ctx.logger.error({ err: evt.error, rejection: evt.rejection, backoff: evt.backoff }, 'pairing failed; the engine will retry');
         emitRetrying(ctx);
     },
     loggedOut: (evt, dispatchCtx) => emitClose(dispatchCtx, evt.reason ? `Logged out: ${evt.reason}` : 'Logged out', DisconnectReason.loggedOut),
@@ -592,13 +592,42 @@ const DISPATCHERS = {
         deleted: evt.deleted,
         predefinedId: evt.predefinedId
     }),
-    labelAssociation: (evt, { ctx }) => 
-    // Inbound sync only ever carries chat associations (the bridge event
-    // has a `chat_jid`); message-label associations are a separate path.
-    ctx.ev.emit('labels.association', {
-        association: { type: LabelAssociationType.Chat, chatId: evt.chatJid, labelId: evt.labelId },
+    labelAssociation: (evt, { ctx }) => ctx.ev.emit('labels.association', {
+        // The two halves arrive on separate bridge events and upstream tells
+        // them apart by the association's own type, so a message id is what
+        // decides which of the two shapes this is.
+        association: evt.messageId
+            ? {
+                type: LabelAssociationType.Message,
+                chatId: evt.chatJid,
+                messageId: evt.messageId,
+                labelId: evt.labelId
+            }
+            : { type: LabelAssociationType.Chat, chatId: evt.chatJid, labelId: evt.labelId },
         type: evt.labeled ? 'add' : 'remove'
     }),
+    appStateSyncFailed: (evt, { ctx }) => {
+        // Logged as well as published: a fatal collection is an operator's
+        // problem before it is a handler's, and `critical_block` carries the
+        // push name, so presence stays unavailable until it syncs.
+        if (evt.fatal.length) {
+            ctx.logger.warn({ fatal: evt.fatal, connected: evt.connected }, 'app state collections refused by the server');
+        }
+        ctx.ev.emit('app-state-sync.failed', {
+            fatal: evt.fatal,
+            retryable: evt.retryable,
+            skipped: evt.skipped,
+            connected: evt.connected
+        });
+    },
+    // Upstream ends the socket with `timedOut` when its own QR timer gives up
+    // (`Socket/socket.ts`), so the canonical reconnect handler already knows
+    // this state. Reporting anything else would make it learn a second one.
+    qrCodesExhausted: (_, dispatchCtx) => emitClose(dispatchCtx, 'QR refs attempts ended', DisconnectReason.timedOut),
+    // Straight onto upstream's own channel for this: `settings.update` already
+    // declares the `disableLinkPreviews` arm, and a consumer that reads it is
+    // reading the account-wide setting whichever device changed it.
+    settingUpdate: (evt, { ctx }) => ctx.ev.emit('settings.update', { setting: evt.setting, value: evt.value }),
     // ── Calls ──
     incomingCall: (evt, { ctx, callbacks }) => {
         callbacks?.onIncomingCall?.(evt);

package/lib/Socket/groups.js

@@ -2,7 +2,7 @@ import { bridgeInviteLinkToCode, bridgeMembershipRequestsToBaileys, bridgeMember
 import { emitMessageUpsert } from '../Compatibility/message-upsert.js';
 import { PARTICIPANT_ACTIONS, WAMessageStubType } from '../Types/index.js';
 import { assertArgumentDomain } from '../Utils/argument-domain.js';
-import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/generics.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 = {
@@ -15,7 +15,11 @@ 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'];
-const inviteExpirationNumber = (value) => typeof value === 'number' ? value : (value?.toNumber() ?? 0);
+// `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);

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';
@@ -806,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,
@@ -886,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),

package/lib/Socket/messages.js

@@ -1,4 +1,5 @@
-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 { MESSAGE_RECEIPT_TYPES, WAProto } from '../Types/index.js';
@@ -69,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);
         }
@@ -138,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);
@@ -229,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/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/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/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;