@oxidezap/baileyrs 0.1.0 → 0.1.1

package/README.md

@@ -220,6 +220,76 @@ A few behaviors that differ from upstream — almost always to your advantage:
   `(err as Boom).output.statusCode` pattern works unchanged. If your
   `package.json` was pulling `@hapi/boom` only for baileys, you can drop
   the dependency.
+- **Your key store also holds bridge state, so "empty" is not "unpaired".**
+  See [Bridge state in your key store](#bridge-state-in-your-key-store) — this
+  one can break a boot path, so it has its own section.
+
+### Bridge state in your key store
+
+Upstream Baileys keeps engine state in `creds` (persisted by `saveCreds`) and
+puts only Signal key material in `keys`. baileyrs uses that same `keys` store
+as the persistence channel for the Rust core's own state as well: its device
+record, and the byte-level records the Signal namespaces are projected from.
+Those live under namespaces reserved with the **`bridge-` prefix**:
+
+| namespace | what it holds |
+| --- | --- |
+| `bridge-native-*` | the core's own encoding of a namespace that also has a Baileys projection (`bridge-native-session`, `bridge-native-prekey`, `bridge-native-device`, …) |
+| `bridge-*` | core records with no Baileys equivalent (`bridge-signed-prekey`, `bridge-sent-message`, `bridge-msg-secret`, `bridge-meta`, …) |
+
+No upstream Baileys namespace starts with `bridge-`, and none of your data is
+stored under one. Which of them you actually see depends on what the engine
+touches; `bridge-native-device` shows up first, because the core reads its
+device record while the socket is still `connecting` — **before any QR, before
+any pairing**.
+
+That last point is the one that bites. A store that counted rows to decide
+whether this was a first run reports a session that does not exist:
+
+```js
+// WRONG on baileyrs: bridge-native-device is already in the table before pairing,
+// so this never reports empty again — the bot skips its pairing flow and hangs.
+const isEmpty = () => !creds.registered && !creds.me?.id && countKeys() === 0
+
+// Right, on baileyrs and upstream alike: creds are the pairing record.
+const isEmpty = () => !creds.registered && !creds.me?.id
+```
+
+**A non-empty key store is not evidence of a session.** `creds.registered` and
+`creds.me?.id` are, and they are the only thing to check.
+
+When you need to present a store the way upstream would — counting rows,
+listing the Signal namespaces, exporting an upstream-shaped dump — filter the
+bridge rows out with the exported classifier rather than matching the prefix
+yourself. It is derived from the internal routing catalog, so a namespace added
+in a later release is covered without you changing anything:
+
+```ts
+// Aliased install? Import from '@whiskeysockets/baileys' instead; it resolves here.
+import { BRIDGE_INTERNAL_KEY_TYPES, isBridgeInternalKeyType } from '@oxidezap/baileyrs'
+
+isBridgeInternalKeyType('bridge-native-device') // true
+isBridgeInternalKeyType('pre-key')              // false
+
+// Every bridge-internal namespace, e.g. for a SQL `NOT IN (...)` clause. The
+// store also holds the Baileys namespaces the engine projects into it.
+BRIDGE_INTERNAL_KEY_TYPES
+```
+
+> **Do not drop these rows from a backup or a store-to-store move.** They are
+> effective state, not metadata. `bridge-signed-prekey`, `bridge-sender-key-devices`,
+> `bridge-base-key`, `bridge-sent-message`, `bridge-msg-secret`,
+> `bridge-mutation-mac` and `bridge-meta` have no Baileys projection at all, and
+> a Signal session that turned native-only lives under `bridge-native-session`
+> alone. Restoring only the non-bridge rows rolls those sessions back or loses
+> the state outright. Filter the bridge rows only where the destination is an
+> upstream-shaped view that cannot represent them; a full backup, or a move
+> between two baileyrs stores, carries every `bridge-` row across.
+
+This applies to stores you own — the upstream `{ creds, keys }` shape that
+baileyrs auto-wraps, including `useLegacyMultiFileAuthState`. It does not apply
+to `useMultiFileAuthState`, whose `keys` is a projection over the engine's own
+store; the `bridge-` namespaces never surface through it.
 
 ## Disclaimer
 

package/lib/Compatibility/legacy-store/namespaces.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Namespace prefix reserved for bridge-internal state. Every namespace the
+ * routing catalog writes back to a legacy key store starts with it, and no
+ * Baileys Signal namespace does, so the prefix is treated as reserved: a
+ * namespace added to the catalog later is classified without a code change.
+ */
+export declare const BRIDGE_INTERNAL_KEY_PREFIX = "bridge-";
+/**
+ * Every namespace `wrapLegacyStore` can write that is not a Signal key.
+ * Derived from the routing catalog so it cannot drift from what is written.
+ */
+export declare const BRIDGE_INTERNAL_KEY_TYPES: readonly string[];
+/**
+ * Whether a `SignalKeyStore` namespace holds bridge-internal state rather than
+ * Signal key material. Custom stores use it to skip those rows when they
+ * enumerate, count or migrate. Never throws: anything that is not a known
+ * namespace, including a non-string, is reported as not internal.
+ */
+export declare function isBridgeInternalKeyType(type: unknown): boolean;
+//# sourceMappingURL=namespaces.d.ts.map

package/lib/Compatibility/legacy-store/namespaces.js

@@ -0,0 +1,27 @@
+// Public classifier for the namespaces the bridge parks in a consumer's key store.
+import { StoreCatalog } from './constants.js';
+/**
+ * Namespace prefix reserved for bridge-internal state. Every namespace the
+ * routing catalog writes back to a legacy key store starts with it, and no
+ * Baileys Signal namespace does, so the prefix is treated as reserved: a
+ * namespace added to the catalog later is classified without a code change.
+ */
+export const BRIDGE_INTERNAL_KEY_PREFIX = 'bridge-';
+/**
+ * Every namespace `wrapLegacyStore` can write that is not a Signal key.
+ * Derived from the routing catalog so it cannot drift from what is written.
+ */
+export const BRIDGE_INTERNAL_KEY_TYPES = Object.freeze([...new Set(Object.values(StoreCatalog).map(route => route.nativeType))].toSorted());
+const internalTypes = new Set(BRIDGE_INTERNAL_KEY_TYPES);
+/**
+ * Whether a `SignalKeyStore` namespace holds bridge-internal state rather than
+ * Signal key material. Custom stores use it to skip those rows when they
+ * enumerate, count or migrate. Never throws: anything that is not a known
+ * namespace, including a non-string, is reported as not internal.
+ */
+export function isBridgeInternalKeyType(type) {
+    if (typeof type !== 'string' || type.length === 0)
+        return false;
+    return type.startsWith(BRIDGE_INTERNAL_KEY_PREFIX) || internalTypes.has(type);
+}
+//# sourceMappingURL=namespaces.js.map

package/lib/Compatibility/newsletter-results.d.ts

@@ -0,0 +1,15 @@
+import type { NewsletterMetadataResult } from '@oxidezap/whatsapp-rust-bridge';
+import type { NewsletterMetadata, NewsletterViewRole } from '../Types/Newsletter.js';
+/** Upstream's `NewsletterViewRole`, or undefined for a role it does not name. */
+export declare const bridgeNewsletterRoleToBaileys: (role: string | undefined) => NewsletterViewRole | undefined;
+/**
+ * Neutral newsletter metadata in upstream's shape.
+ *
+ * Four upstream fields have no source in the bridge result and stay absent
+ * rather than being invented: `owner` (the result carries the viewer's role,
+ * not the owner's jid), `mute_state` (the result's `state` is the newsletter's
+ * lifecycle, Active/Suspended, not a mute), `reaction_codes`, and
+ * `thread_metadata`.
+ */
+export declare const bridgeNewsletterMetadataToBaileys: (result: NewsletterMetadataResult) => NewsletterMetadata;
+//# sourceMappingURL=newsletter-results.d.ts.map

package/lib/Compatibility/newsletter-results.js

@@ -0,0 +1,38 @@
+/**
+ * The bridge spells these the way the core's enums are named, and upstream
+ * spells them in screaming case. Written out rather than upper-cased blindly so
+ * a variant the core adds later shows up as `undefined` instead of as a string
+ * nobody declared.
+ */
+const VERIFICATION = {
+    Verified: 'VERIFIED',
+    Unverified: 'UNVERIFIED'
+};
+const VIEW_ROLE = {
+    Owner: 'OWNER',
+    Admin: 'ADMIN',
+    Subscriber: 'SUBSCRIBER',
+    Guest: 'GUEST'
+};
+/** Upstream's `NewsletterViewRole`, or undefined for a role it does not name. */
+export const bridgeNewsletterRoleToBaileys = (role) => role === undefined ? undefined : VIEW_ROLE[role];
+/**
+ * Neutral newsletter metadata in upstream's shape.
+ *
+ * Four upstream fields have no source in the bridge result and stay absent
+ * rather than being invented: `owner` (the result carries the viewer's role,
+ * not the owner's jid), `mute_state` (the result's `state` is the newsletter's
+ * lifecycle, Active/Suspended, not a mute), `reaction_codes`, and
+ * `thread_metadata`.
+ */
+export const bridgeNewsletterMetadataToBaileys = (result) => ({
+    id: result.jid,
+    name: result.name,
+    ...(result.description !== undefined ? { description: result.description } : {}),
+    ...(result.inviteCode !== undefined ? { invite: result.inviteCode } : {}),
+    ...(result.creationTime !== undefined ? { creation_time: result.creationTime } : {}),
+    subscribers: result.subscriberCount,
+    ...(VERIFICATION[result.verification] !== undefined ? { verification: VERIFICATION[result.verification] } : {}),
+    ...(result.pictureUrl !== undefined ? { picture: { url: result.pictureUrl } } : {})
+});
+//# sourceMappingURL=newsletter-results.js.map

package/lib/Socket/business.d.ts

@@ -0,0 +1,29 @@
+import type { OrderResult } from '@oxidezap/whatsapp-rust-bridge';
+import type { CatalogPage, CollectionsPage, GetCatalogOptions, ProductCreate, ProductUpdate } from '../Types/Product.js';
+import type { UpdateBussinesProfileProps } from '../Types/Bussines.js';
+import type { WAMediaUpload } from '../Types/Message.js';
+import type { SocketContext } from './types.js';
+export declare const makeBusinessMethods: (ctx: SocketContext) => {
+    getCatalog: ({ jid, limit, cursor }: GetCatalogOptions) => Promise<CatalogPage>;
+    getCollections: (jid?: string, limit?: number) => Promise<CollectionsPage>;
+    /**
+     * `sellerJid` is not in upstream's signature because upstream reads orders
+     * over the legacy `fb:thrift_iq` route, which addresses the server. The
+     * route the real client uses is a MEX query keyed by the seller, so the JID
+     * is required here. It is on the order message the token came from.
+     */
+    getOrderDetails: (orderId: string, tokenBase64: string, sellerJid?: string) => Promise<OrderResult>;
+    updateBussinesProfile: (args: UpdateBussinesProfileProps) => Promise<void>;
+    /**
+     * Declared but not callable end to end. The core and the bridge take the
+     * `{fbid, meta_hmac, ts}` receipt of a cover photo upload, and this
+     * package's upload path cannot produce one: it requires a url and a
+     * direct path, which that endpoint does not return.
+     */
+    updateCoverPhoto: (photo: WAMediaUpload) => Promise<never>;
+    removeCoverPhoto: (id: string) => Promise<void>;
+    productCreate: (create: ProductCreate) => Promise<never>;
+    productUpdate: (productId: string, update: ProductUpdate) => Promise<never>;
+    productDelete: (productIds: string[]) => Promise<never>;
+};
+//# sourceMappingURL=business.d.ts.map

package/lib/Socket/business.js

@@ -0,0 +1,104 @@
+import { Boom } from '../Utils/boom.js';
+import { jidNormalizedUser } from '../WABinary/jid-utils.js';
+/**
+ * Product create, update and delete exist only in Baileys: the operations they
+ * send appear in no WhatsApp Web bundle. Declared so a migrating caller reads
+ * why instead of a bare TypeError, and rejecting because there is nothing to
+ * call.
+ */
+const noProductWriteRoute = (method, ...ignored) => {
+    void ignored;
+    throw new Boom(`${method} is not supported: the WhatsApp Web client has no product create, edit or delete operation, so there is nothing for this to call. Manage the catalog from the WhatsApp Business app.`, { statusCode: 501 });
+};
+/**
+ * Upstream types these as strings, so an empty one is reachable from an
+ * unfilled form. `Number('')` is midnight, which would quietly rewrite the
+ * schedule instead of being refused.
+ */
+const minutesPastMidnight = (value, which) => {
+    const minutes = Number(value);
+    if (value.trim() === '' || !Number.isInteger(minutes) || minutes < 0 || minutes > 1440) {
+        throw new Boom(`updateBussinesProfile: ${which} time '${value}' is not a count of minutes past midnight`, {
+            statusCode: 400
+        });
+    }
+    return minutes;
+};
+/**
+ * Both catalog reads take an optional jid and mean "mine" without one, as
+ * upstream does. `getMe` rather than `getUser`, because it reads through to the
+ * persisted credentials, which is the same place upstream reads from and is
+ * populated before the socket finishes its own initialisation.
+ */
+const catalogSubject = (method, ctx, jid) => {
+    const subject = jidNormalizedUser(jid || ctx.getMe()?.id);
+    if (!subject) {
+        throw new Boom(`${method}: no jid was given and there is no authenticated account, so there is no own catalog to read`, {
+            statusCode: 400
+        });
+    }
+    return subject;
+};
+export const makeBusinessMethods = (ctx) => ({
+    getCatalog: async ({ jid, limit, cursor }) => {
+        const subject = catalogSubject('getCatalog', ctx, jid);
+        return await (await ctx.getClient()).getCatalog(subject, { limit, after: cursor });
+    },
+    getCollections: async (jid, limit) => {
+        const subject = catalogSubject('getCollections', ctx, jid);
+        return await (await ctx.getClient()).getCollections(subject, { collectionLimit: limit });
+    },
+    /**
+     * `sellerJid` is not in upstream's signature because upstream reads orders
+     * over the legacy `fb:thrift_iq` route, which addresses the server. The
+     * route the real client uses is a MEX query keyed by the seller, so the JID
+     * is required here. It is on the order message the token came from.
+     */
+    getOrderDetails: async (orderId, tokenBase64, sellerJid) => {
+        if (!sellerJid) {
+            throw new Boom('getOrderDetails: a third argument with the seller jid is required, because orders are read through a query keyed by the business rather than the legacy server-addressed one', { statusCode: 400 });
+        }
+        return await (await ctx.getClient()).getOrder(sellerJid, orderId, tokenBase64);
+    },
+    updateBussinesProfile: async (args) => {
+        const update = {
+            address: args.address,
+            description: args.description,
+            email: args.email,
+            websites: args.websites,
+            ...(args.hours !== undefined
+                ? {
+                    businessHours: {
+                        timezone: args.hours.timezone,
+                        // Minutes past midnight as a number; upstream types the two
+                        // as strings and the core rejects them on the other modes.
+                        config: args.hours.days.map(day => ({
+                            dayOfWeek: day.day,
+                            mode: day.mode,
+                            openTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.openTimeInMinutes, 'open') : undefined,
+                            closeTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.closeTimeInMinutes, 'close') : undefined
+                        }))
+                    }
+                }
+                : {})
+        };
+        await (await ctx.getClient()).updateBusinessProfile(update);
+    },
+    /**
+     * Declared but not callable end to end. The core and the bridge take the
+     * `{fbid, meta_hmac, ts}` receipt of a cover photo upload, and this
+     * package's upload path cannot produce one: it requires a url and a
+     * direct path, which that endpoint does not return.
+     */
+    updateCoverPhoto: async (photo) => {
+        void photo;
+        throw new Boom('updateCoverPhoto is not available yet: the cover photo upload returns an {fbid, meta_hmac, ts} receipt that this package cannot obtain. removeCoverPhoto works.', { statusCode: 501 });
+    },
+    removeCoverPhoto: async (id) => {
+        await (await ctx.getClient()).removeBusinessCoverPhoto(id);
+    },
+    productCreate: async (create) => noProductWriteRoute('productCreate', create),
+    productUpdate: async (productId, update) => noProductWriteRoute('productUpdate', productId, update),
+    productDelete: async (productIds) => noProductWriteRoute('productDelete', productIds)
+});
+//# sourceMappingURL=business.js.map

package/lib/Socket/chat-actions.d.ts

@@ -1,4 +1,7 @@
-import type { ChatModification, WAPatchName } from '../Types/index.js';
+import type { proto } from '../WAProto/runtime.js';
+import type { QuickReplyAction } from '../Types/Bussines.js';
+import type { LabelActionBody } from '../Types/Label.js';
+import type { ChatModification } from '../Types/index.js';
 import type { SocketContext } from './types.js';
 export declare const makeChatActionMethods: (ctx: SocketContext) => {
     pinChat: (jid: string, pin: boolean) => Promise<void>;
@@ -9,17 +12,23 @@ export declare const makeChatActionMethods: (ctx: SocketContext) => {
      * Compatibility wrapper for original Baileys chatModify API.
      * Routes to the appropriate bridge method based on the modification type.
      *
-     * Fully supported: archive, pin, mute, star, markRead, delete, deleteForMe, pushNameSetting, contact, clear
-     * Not yet in bridge (app-state patches): disableLinkPreviews, labels, quickReply
+     * Every variant either runs or throws. A variant that resolved without
+     * doing anything told the caller their chat was labelled when nothing was
+     * synced, and no signature or type catches that.
      */
     chatModify: (mod: ChatModification, jid: string) => Promise<void>;
-    /**
-     * Force re-sync of app state collections.
-     *
-     * In the Rust bridge architecture, app state is managed internally by the engine
-     * and synced automatically on connect. This method is a no-op provided for API
-     * compatibility with upstream Baileys.
-     */
-    resyncAppState: (_collections?: readonly WAPatchName[], _isInitialSync?: boolean) => Promise<void>;
+    addOrEditContact: (jid: string, contact: proto.SyncActionValue.IContactAction) => Promise<void>;
+    removeContact: (jid: string) => Promise<void>;
+    addLabel: (jid: string, labels: LabelActionBody) => Promise<void>;
+    addChatLabel: (jid: string, labelId: string) => Promise<void>;
+    removeChatLabel: (jid: string, labelId: string) => Promise<void>;
+    addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean;
+    }[], star: boolean) => Promise<void>;
+    addOrEditQuickReply: (quickReply: QuickReplyAction) => Promise<void>;
+    removeQuickReply: (timestamp: string) => Promise<void>;
 };
 //# sourceMappingURL=chat-actions.d.ts.map

package/lib/Socket/chat-actions.js

@@ -1,89 +1,177 @@
-export const makeChatActionMethods = (ctx) => ({
-    pinChat: async (jid, pin) => {
-        await (await ctx.getClient()).pinChat(jid, pin);
-    },
-    muteChat: async (jid, muteUntil) => {
-        await (await ctx.getClient()).muteChat(jid, muteUntil);
-    },
-    archiveChat: async (jid, archive) => {
-        await (await ctx.getClient()).archiveChat(jid, archive);
-    },
-    starMessage: async (jid, messageId, star) => {
-        await (await ctx.getClient()).starMessage(jid, messageId, star);
-    },
-    /**
-     * Compatibility wrapper for original Baileys chatModify API.
-     * Routes to the appropriate bridge method based on the modification type.
-     *
-     * Fully supported: archive, pin, mute, star, markRead, delete, deleteForMe, pushNameSetting, contact, clear
-     * Not yet in bridge (app-state patches): disableLinkPreviews, labels, quickReply
-     */
-    chatModify: async (mod, jid) => {
-        const client = await ctx.getClient();
-        if ('archive' in mod) {
-            await client.archiveChat(jid, mod.archive);
-        }
-        else if ('pin' in mod) {
-            await client.pinChat(jid, mod.pin);
-        }
-        else if ('mute' in mod) {
-            await client.muteChat(jid, mod.mute);
-        }
-        else if ('star' in mod) {
-            for (const msg of mod.star.messages) {
-                await client.starMessage(jid, msg.id, mod.star.star);
+import { Boom } from '../Utils/boom.js';
+/**
+ * Refuse a field the mutation carries but the wire call cannot. Dropping it
+ * would report success for a change that never happened, which is the failure
+ * this whole path exists to stop.
+ */
+const rejectUnsupportedFields = (where, value, fields) => {
+    const present = fields.filter(field => value[field] != null);
+    if (present.length) {
+        throw new Boom(`${where}: ${present.join(', ')} cannot be set through this client`, {
+            statusCode: 400,
+            data: { fields: present }
+        });
+    }
+};
+export const makeChatActionMethods = (ctx) => {
+    const methods = {
+        pinChat: async (jid, pin) => {
+            await (await ctx.getClient()).pinChat(jid, pin);
+        },
+        muteChat: async (jid, muteUntil) => {
+            await (await ctx.getClient()).muteChat(jid, muteUntil);
+        },
+        archiveChat: async (jid, archive) => {
+            await (await ctx.getClient()).archiveChat(jid, archive);
+        },
+        starMessage: async (jid, messageId, star) => {
+            await (await ctx.getClient()).starMessage(jid, messageId, star);
+        },
+        /**
+         * Compatibility wrapper for original Baileys chatModify API.
+         * Routes to the appropriate bridge method based on the modification type.
+         *
+         * Every variant either runs or throws. A variant that resolved without
+         * doing anything told the caller their chat was labelled when nothing was
+         * synced, and no signature or type catches that.
+         */
+        chatModify: async (mod, jid) => {
+            const client = await ctx.getClient();
+            if ('archive' in mod) {
+                await client.archiveChat(jid, mod.archive);
             }
-        }
-        else if ('markRead' in mod) {
-            await client.markChatAsRead(jid, mod.markRead);
-        }
-        else if ('delete' in mod) {
-            await client.deleteChat(jid);
-        }
-        else if ('deleteForMe' in mod) {
-            await client.deleteMessageForMe(jid, mod.deleteForMe.key.id, !!mod.deleteForMe.key.fromMe);
-        }
-        else if ('pushNameSetting' in mod) {
-            await client.setPushName(mod.pushNameSetting);
-        }
-        else if ('contact' in mod) {
-            // Save/rename a contact (syncs the name to linked devices). `jid` is the
-            // contact's bare PN jid.
-            if (mod.contact) {
-                await client.saveContact(jid, mod.contact.fullName ?? undefined, mod.contact.firstName ?? undefined, mod.contact.saveOnPrimaryAddressbook ?? true);
+            else if ('pin' in mod) {
+                await client.pinChat(jid, mod.pin);
             }
-            else {
-                // `contact: null` = remove-contact in upstream Baileys; no
-                // bridge/core path yet — warn instead of silently dropping.
-                ctx.logger.warn({ jid }, 'chatModify: contact removal (contact: null) not yet supported by bridge');
+            else if ('mute' in mod) {
+                await client.muteChat(jid, mod.mute);
             }
-        }
-        else if ('clear' in mod) {
-            // Clear a chat's messages while keeping the chat. `lastMessages` (the
-            // message range) is ignored, same as the `delete` branch — the bridge
-            // clears the whole chat. deleteStarred/deleteMedia aren't part of the
-            // Baileys `clear` shape, so default both to false (keep starred + media).
-            if (mod.clear) {
-                await client.clearChat(jid, false, false);
+            else if ('star' in mod) {
+                for (const msg of mod.star.messages) {
+                    await client.starMessage(jid, msg.id, mod.star.star);
+                }
             }
+            else if ('markRead' in mod) {
+                await client.markChatAsRead(jid, mod.markRead);
+            }
+            else if ('delete' in mod) {
+                await client.deleteChat(jid);
+            }
+            else if ('deleteForMe' in mod) {
+                await client.deleteMessageForMe(jid, mod.deleteForMe.key.id, !!mod.deleteForMe.key.fromMe);
+            }
+            else if ('pushNameSetting' in mod) {
+                await client.setPushName(mod.pushNameSetting);
+            }
+            else if ('contact' in mod) {
+                // Save/rename a contact (syncs the name to linked devices). `jid` is the
+                // contact's bare PN jid.
+                if (mod.contact) {
+                    rejectUnsupportedFields('chatModify contact', mod.contact, ['lidJid', 'pnJid', 'username']);
+                    await client.saveContact(jid, mod.contact.fullName ?? undefined, mod.contact.firstName ?? undefined, mod.contact.saveOnPrimaryAddressbook ?? true);
+                }
+                else {
+                    // Its own method, not `saveContact` with empty fields: removal is
+                    // the one contact mutation the wire models as a `Remove`, and a
+                    // `Set` carrying empty values renames the contact to "".
+                    await client.removeContact(jid);
+                }
+            }
+            else if ('clear' in mod) {
+                // Clear a chat's messages while keeping the chat. `lastMessages` (the
+                // message range) is ignored, same as the `delete` branch — the bridge
+                // clears the whole chat. deleteStarred/deleteMedia aren't part of the
+                // Baileys `clear` shape, so default both to false (keep starred + media).
+                if (mod.clear) {
+                    await client.clearChat(jid, false, false);
+                }
+            }
+            else if ('disableLinkPreviews' in mod) {
+                await client.setLinkPreviewsDisabled(mod.disableLinkPreviews.isPreviewsDisabled ?? false);
+            }
+            else if ('addLabel' in mod) {
+                // One upstream variant, two wire actions: an edit carrying
+                // `deleted` is the delete, not a separate modification.
+                if (mod.addLabel.deleted) {
+                    await client.deleteLabel(mod.addLabel.id);
+                }
+                else {
+                    rejectUnsupportedFields('chatModify addLabel', mod.addLabel, ['predefinedId']);
+                    // The mutation replaces the whole label, so a missing field is
+                    // not "leave it alone", it is "set it to nothing". Upstream can
+                    // omit one because it builds the proto directly; this call
+                    // cannot, so both are required rather than defaulted.
+                    if (mod.addLabel.name === undefined || mod.addLabel.color === undefined) {
+                        throw new Boom('chatModify addLabel: name and color are both required, because the label mutation is a full replace and an omitted field would reset it', { statusCode: 400 });
+                    }
+                    await client.createLabel(mod.addLabel.id, mod.addLabel.name, mod.addLabel.color);
+                }
+            }
+            else if ('addChatLabel' in mod) {
+                await client.addChatLabel(mod.addChatLabel.labelId, jid);
+            }
+            else if ('removeChatLabel' in mod) {
+                await client.removeChatLabel(mod.removeChatLabel.labelId, jid);
+            }
+            else if ('addMessageLabel' in mod) {
+                await client.addMessageLabel(mod.addMessageLabel.labelId, jid, mod.addMessageLabel.messageId);
+            }
+            else if ('removeMessageLabel' in mod) {
+                await client.removeMessageLabel(mod.removeMessageLabel.labelId, jid, mod.removeMessageLabel.messageId);
+            }
+            else if ('quickReply' in mod) {
+                // Upstream's `timestamp` is the app-state index key, the same slot
+                // the core calls `id`. Deleting is the same upsert with `deleted`.
+                // `||`, not `??`: upstream treats an empty timestamp as absent and
+                // mints a key, and the core rejects an empty index outright.
+                const id = mod.quickReply.timestamp || String(Math.floor(Date.now() / 1000));
+                if (mod.quickReply.deleted) {
+                    await client.deleteQuickReply(id);
+                }
+                else {
+                    await client.setQuickReply(id, mod.quickReply.shortcut ?? '', mod.quickReply.message ?? '', mod.quickReply.keywords ?? [], mod.quickReply.count ?? 0);
+                }
+            }
+            else {
+                const variant = Object.keys(mod)[0] ?? '(empty)';
+                throw new Boom(`chatModify: unsupported modification '${variant}'`, { statusCode: 400, data: { variant, jid } });
+            }
+        },
+        // Upstream models all of these as sugar over `chatModify`, and so do we:
+        // one place decides which bridge call a modification becomes, so the
+        // method and the modification can never disagree.
+        addOrEditContact: async (jid, contact) => {
+            await methods.chatModify({ contact }, jid);
+        },
+        removeContact: async (jid) => {
+            await methods.chatModify({ contact: null }, jid);
+        },
+        addLabel: async (jid, labels) => {
+            await methods.chatModify({ addLabel: { ...labels } }, jid);
+        },
+        addChatLabel: async (jid, labelId) => {
+            await methods.chatModify({ addChatLabel: { labelId } }, jid);
+        },
+        removeChatLabel: async (jid, labelId) => {
+            await methods.chatModify({ removeChatLabel: { labelId } }, jid);
+        },
+        addMessageLabel: async (jid, messageId, labelId) => {
+            await methods.chatModify({ addMessageLabel: { labelId, messageId } }, jid);
+        },
+        removeMessageLabel: async (jid, messageId, labelId) => {
+            await methods.chatModify({ removeMessageLabel: { labelId, messageId } }, jid);
+        },
+        star: async (jid, messages, star) => {
+            await methods.chatModify({ star: { messages, star } }, jid);
+        },
+        // No jid: a quick reply is account-wide, keyed only by its index.
+        addOrEditQuickReply: async (quickReply) => {
+            await methods.chatModify({ quickReply }, '');
+        },
+        removeQuickReply: async (timestamp) => {
+            await methods.chatModify({ quickReply: { timestamp, deleted: true } }, '');
         }
-        else {
-            // App-state-patch variants not yet exposed by bridge:
-            // disableLinkPreviews, addLabel, addChatLabel,
-            // removeChatLabel, addMessageLabel, removeMessageLabel, quickReply
-            const variant = Object.keys(mod)[0];
-            ctx.logger.warn({ variant, jid }, 'chatModify: variant requires app-state patch support not yet available in bridge');
-        }
-    },
-    /**
-     * Force re-sync of app state collections.
-     *
-     * In the Rust bridge architecture, app state is managed internally by the engine
-     * and synced automatically on connect. This method is a no-op provided for API
-     * compatibility with upstream Baileys.
-     */
-    resyncAppState: async (_collections, _isInitialSync) => {
-        ctx.logger.info('resyncAppState: app state is synced automatically by the Rust bridge');
-    }
-});
+    };
+    return methods;
+};
 //# sourceMappingURL=chat-actions.js.map