feat(events)!: move to bridge 0.10.0 and deliver the events it added

package.json

@@ -22,7 +22,7 @@
     "url": "https://github.com/oxidezap/baileyrs/issues"
   },
   "license": "MIT",
-  "author": "João Lucas <jlucaso@hotmail.com>",
+  "author": "Jo\u00e3o Lucas <jlucaso@hotmail.com>",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "exports": {
@@ -82,7 +82,7 @@
   },
   "dependencies": {
     "@hapi/boom": "^9.1.4",
-    "@oxidezap/whatsapp-rust-bridge": "0.7.2",
+    "@oxidezap/whatsapp-rust-bridge": "0.10.0",
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5"

scripts/compatibility/proto-runtime-audit.ts

@@ -51,10 +51,14 @@ const KNOWN_WIRE_GAPS = [
 	'BotMetadata.avatarMetadata',
 	'Message.AudioMessage.mediaKeyDomain',
 	'Message.DocumentMessage.mediaKeyDomain',
+	// Renamed rather than absent: WhatsApp schema 2.3000.1044659339 spells field
+	// 33 `faviconMmsMetadata`, which bridge 0.10.0 regenerated against, while
+	// baileys 7.0.0-rc13 still declares `faviconMMSMetadata`. The wire is
+	// identical; the gap closes when upstream regenerates its proto.
+	'Message.ExtendedTextMessage.faviconMMSMetadata',
 	'Message.ImageMessage.mediaKeyDomain',
 	'Message.MMSThumbnailMetadata.mediaKeyDomain',
 	'Message.MessageHistoryMetadata.oldestMessageTimestamp',
-	'Message.PaymentExtendedMetadata.messageParamsJson',
 	'Message.StickerMessage.mediaKeyDomain',
 	'Message.VideoMessage.mediaKeyDomain',
 	'Message.pollResultSnapshotMessageV3',

src/Bridge/primitives.ts

@@ -213,3 +213,7 @@ export const absoluteFromDuration = (seconds: number | undefined): number | unde
 
 /** `Date` holds ±8.64e15 ms, which is this many whole seconds. */
 const MAX_DATE_SECONDS = 8_640_000_000_000
+
+/** Wire collection names and the like: anything that is not a string is not one. */
+export const asStringArray = (x: unknown): string[] =>
+	Array.isArray(x) ? x.filter((item): item is string => typeof item === 'string') : []

src/Bridge/schema.ts

@@ -40,6 +40,7 @@ import type {
 import {
 	absoluteFromDuration,
 	asBoolOr,
+	asStringArray,
 	asDurationSeconds,
 	asInt64,
 	asJidAddressString,
@@ -352,6 +353,60 @@ const ADAPTERS = {
 		return { type: 'labelAssociation', labelId, chatJid, labeled: asBoolOr(extractAction(data)?.labeled, true) }
 	},
 
+	/**
+	 * The per-message half of `labels.association`, which used to have no path.
+	 * Same canonical event as the chat one, told apart by carrying a message.
+	 */
+	message_label_association_update: data => {
+		const labelId = asString(data?.label_id)
+		const chatJid = asJidString(data?.chat_jid)
+		const messageId = asString(data?.message_id)
+		if (!labelId || !chatJid || !messageId) {
+			return { type: 'noop', bridgeType: 'message_label_association_update' }
+		}
+		return {
+			type: 'labelAssociation',
+			labelId,
+			chatJid,
+			messageId,
+			labeled: asBoolOr(extractAction(data)?.labeled, true)
+		}
+	},
+
+	/**
+	 * What a degraded app-state sync left behind. The engine announces the
+	 * connection anyway, so without this a consumer is told a session with no
+	 * push name is healthy and has nothing to read that says otherwise.
+	 */
+	app_state_sync_failed: data => ({
+		type: 'appStateSyncFailed',
+		fatal: asStringArray(data?.fatal),
+		retryable: asStringArray(data?.retryable),
+		skipped: asStringArray(data?.skipped),
+		connected: asBoolOr(data?.connected, false)
+	}),
+
+	/**
+	 * The QR refs ran out. Upstream ends the socket with `timedOut` when its own
+	 * QR timer gives up (`Socket/socket.ts`), which is the same end state, so
+	 * this becomes the same terminal close rather than a new signal to learn.
+	 */
+	pairing_qr_codes_exhausted: () => ({ type: 'qrCodesExhausted' }),
+
+	// Acknowledged with no Baileys equivalent: upstream has no channel for a
+	// contact deletion (`contacts.update` only upserts), for the account-wide
+	// link-preview setting, for quick replies, for a call placed on the phone,
+	// or for a pairing-code rejection that arrives after the code was shown.
+	contact_removed: () => ({ type: 'noop', bridgeType: 'contact_removed' }),
+	disable_link_previews_update: () => ({ type: 'noop', bridgeType: 'disable_link_previews_update' }),
+	quick_reply_update: () => ({ type: 'noop', bridgeType: 'quick_reply_update' }),
+	call_log_sync: () => ({ type: 'noop', bridgeType: 'call_log_sync' }),
+	pairing_code_error: data => ({
+		type: 'noop',
+		bridgeType: 'pairing_code_error',
+		detail: asString(data?.error) ?? 'unknown'
+	}),
+
 	// ── Calls ──
 	incoming_call: (data, logger) => adaptIncomingCall(data, logger),
 	missed_call: data => {

src/Bridge/types.ts

@@ -432,10 +432,46 @@ export interface CanonicalLabelAssociation {
 	type: 'labelAssociation'
 	labelId: string
 	chatJid: string
-	/** `true` = label added to the chat, `false` = removed. */
+	/**
+	 * The message the label is on, for a per-message association.
+	 *
+	 * Absent means the label is on the chat itself. The two arrive on separate
+	 * bridge events and upstream carries both on `labels.association`, keyed by
+	 * the association's own `type`.
+	 */
+	messageId?: string
+	/** `true` = label added, `false` = removed. */
 	labeled: boolean
 }
 
+/**
+ * The server ran out of QR refs before anyone scanned one.
+ *
+ * Terminal: nothing else is coming on this socket, and the consumer builds a
+ * new one to be shown a fresh code.
+ */
+export interface CanonicalQrCodesExhausted {
+	type: 'qrCodesExhausted'
+}
+
+/**
+ * A batched app-state sync that did not leave every collection synced.
+ *
+ * Collections are named as they appear on the wire. `fatal` is the one a
+ * consumer usually has to act on: the server refused it and asking again gets
+ * the same answer. `connected` says whether the session was announced anyway,
+ * which is the difference between "degraded but usable" and "still retrying" —
+ * the engine connects on a degraded sync rather than withholding the session,
+ * so this event is the only thing that says what is missing from it.
+ */
+export interface CanonicalAppStateSyncFailed {
+	type: 'appStateSyncFailed'
+	fatal: string[]
+	retryable: string[]
+	skipped: string[]
+	connected: boolean
+}
+
 // ── Calls ──
 
 export type CanonicalCallActionType =
@@ -693,6 +729,8 @@ export type CanonicalEvent =
 	| CanonicalMarkChatAsReadUpdate
 	| CanonicalLabelEdit
 	| CanonicalLabelAssociation
+	| CanonicalAppStateSyncFailed
+	| CanonicalQrCodesExhausted
 	| CanonicalIncomingCall
 	| CanonicalUndecryptableMessage
 	| CanonicalLidMappingUpdate

src/Compatibility/encode-proto.ts

@@ -0,0 +1,30 @@
+import { encodeProto } from '@oxidezap/whatsapp-rust-bridge'
+import { repairProtoMessage } from './proto-runtime.ts'
+
+/**
+ * `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: string, message: unknown): Uint8Array => {
+	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)
+	}
+}