@oxidezap/baileyrs 0.0.35 → 0.1.1

package/lib/Socket/bridge-client-owner.js

@@ -0,0 +1,135 @@
+/**
+ * Owns the bridge client's lifetime.
+ *
+ * The socket's startup is async and its teardown can start at any point during
+ * it — a `sock.end()` right after `makeWASocket()`, an `await using` scope
+ * exiting, or a terminal disconnect the dispatcher reports while `init()` is
+ * still building the client. That window used to be managed by hand across six
+ * closure variables and a scattering of `if (ended) return` checks, which is
+ * where every teardown bug in this file came from: startup dereferencing a
+ * handle teardown had already nulled, a client built after teardown with
+ * nobody left to free it, an `end()` that resolved for its second caller while
+ * the first was still flushing, and a re-entrant close releasing the same wasm
+ * handle twice.
+ *
+ * All of those are one question — *what phase is this client in?* — so it is
+ * one discriminated union rather than a set of booleans that can disagree:
+ *
+ * ```
+ *   starting ──adopt()──► running ──close()──► closing ──► closed
+ *      │                     │                    ▲
+ *      └──────close()────────┴──discard()─────────┘
+ * ```
+ *
+ * Two rules make the whole thing safe, and both are properties of the union
+ * rather than of any individual method:
+ *
+ *  - **The transition is synchronous and happens first.** `close()` publishes
+ *    `closing` — carrying the promise callers await — before any teardown work
+ *    starts, so re-entering it finds an in-flight close instead of starting a
+ *    second one. That is why the work is deferred by a microtask rather than
+ *    started inline: an async body would otherwise run eagerly to its first
+ *    `await`, i.e. before the state was stored.
+ *  - **`closing` still carries the client.** The socket's transport close
+ *    reads it back through `peek()` (`ws.close()` is `getClient()?.disconnect()`),
+ *    so dropping the handle at the start of teardown silently turns that into
+ *    a no-op and moves the disconnect after the auth-store flush. `isClosing()`
+ *    — not `peek()` — is the "should I still be doing work" signal.
+ */
+export const makeBridgeClientOwner = (opts) => {
+    const { logger, teardown, release } = opts;
+    let state = { phase: 'starting' };
+    /** Releases started outside `close()`, so `settled()` can join them. */
+    const pendingReleases = new Set();
+    const releaseQuietly = async (target) => {
+        try {
+            await release(target);
+        }
+        catch (err) {
+            logger.error({ err }, 'failed to release the bridge client');
+        }
+    };
+    /** `releaseQuietly`, but joinable through `settled()`. */
+    const trackRelease = (target) => {
+        const running = releaseQuietly(target).finally(() => pendingReleases.delete(running));
+        pendingReleases.add(running);
+        return running;
+    };
+    /** Drain releases started outside this close — see `runClose`. */
+    const drainReleases = async () => {
+        while (pendingReleases.size)
+            await Promise.all(pendingReleases);
+    };
+    const runClose = async (client, error, done) => {
+        try {
+            await teardown(client, error);
+        }
+        finally {
+            state = { phase: 'closed', done };
+            if (client)
+                await releaseQuietly(client);
+            // A `discard()` in flight when this close started put the client
+            // back in `starting`, so the capture above found none and teardown
+            // ran without it. Its release is still going: joining here keeps
+            // `close()` from settling while a client is being disconnected and
+            // freed, which is what the caller is told it can rely on.
+            await drainReleases();
+        }
+    };
+    return {
+        peek: () => (state.phase === 'running' || state.phase === 'closing' ? state.client : undefined),
+        adopt: candidate => {
+            if (state.phase !== 'starting') {
+                // Teardown has already been through here and found nothing, so
+                // this client would have no owner: nothing would free it and its
+                // read loop would reconnect forever against a disposed socket.
+                void trackRelease(candidate);
+                return false;
+            }
+            state = { phase: 'running', client: candidate };
+            return true;
+        },
+        isClosing: () => state.phase === 'closing' || state.phase === 'closed',
+        close: error => {
+            if (state.phase === 'closing' || state.phase === 'closed') {
+                logger.trace({ trace: error?.stack }, 'already closing; awaiting the in-flight teardown');
+                return state.done;
+            }
+            const client = state.phase === 'running' ? state.client : undefined;
+            // Deferred by a microtask so the `closing` state below is stored
+            // before any teardown work runs. Calling `runClose` inline would
+            // execute its body eagerly up to the first `await` — teardown starts
+            // by closing the transport — and anything reached synchronously that
+            // calls back into `close()` would find no in-flight close and start
+            // a second teardown, releasing the same wasm handle twice.
+            const done = Promise.resolve().then(() => runClose(client, error, done));
+            state = { phase: 'closing', client, done };
+            return done;
+        },
+        discard: async () => {
+            // `close()` owns the client from the moment it starts, and keeps it
+            // published for the whole of teardown — releasing it here as well
+            // would be two disconnect/free sequences on one handle. Join instead.
+            //
+            // Joining without adopting the failure: `close()` rejects when
+            // teardown rethrows the first auth-store flush error, and this is
+            // best-effort cleanup called from `init()`'s catch. Propagating it
+            // would make `initPromise` reject — which the socket documents as
+            // impossible, relies on for `getClient()`'s error message, and does
+            // not always await, so it could surface as an unhandled rejection.
+            if (state.phase === 'closing' || state.phase === 'closed') {
+                await state.done.catch(() => { });
+                return;
+            }
+            if (state.phase !== 'running')
+                return;
+            const { client } = state;
+            // Back to `starting`, not `closed`: a later `close()` must still run
+            // teardown for everything the socket owns beyond the client.
+            state = { phase: 'starting' };
+            await trackRelease(client);
+        },
+        settled: drainReleases
+    };
+};
+//# sourceMappingURL=bridge-client-owner.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

package/lib/Socket/events.d.ts

@@ -20,6 +20,37 @@ interface EventCallbacks {
     onDirtyState?: (event: Extract<CanonicalEvent, {
         type: 'dirtyState';
     }>) => void;
+    /**
+     * The engine has stopped reconnecting: this client is dead weight only
+     * `free()` can reclaim.
+     *
+     * Owns publishing the `close` too — `publish()` must be called, and the
+     * point of handing it over is that the socket can finish tearing down
+     * first. Upstream does the same, emitting its close only after `ws.close()`
+     * and the end handlers (`Socket/socket.ts`). A consumer answering `close`
+     * with a replacement socket on the same auth folder would otherwise race
+     * the old one's store flush and `free()`.
+     */
+    onTerminalClose?: (error: Error, publish: () => void) => void;
+    /**
+     * Hand back a cleanup for anything the dispatcher armed that outlives a
+     * single event — today the history-sync pause timer. The socket registers
+     * it as an end handler, so a plain `sock.end()` or an `await using` scope
+     * exiting cancels it too: only the terminal-close path goes through
+     * `emitClose`, and a timer surviving disposal fires
+     * `messaging-history.status: paused` from a socket that is already gone.
+     *
+     * Called once, during `makeEventHandlers`.
+     */
+    onCleanup?: (cleanup: () => void) => void;
+    /**
+     * Whether `sock.setAutoReconnect(true)` is in effect. A plain drop is only
+     * transient while the engine still intends to retry: with auto-reconnect
+     * off, the run loop dispatches `Disconnected` and then breaks for good
+     * (`client/lifecycle.rs` tests the flag *after* the dispatch), so the same
+     * event becomes terminal. Absent callback means the default, enabled.
+     */
+    isAutoReconnectEnabled?: () => boolean;
 }
 /**
  * Create typed single and batch handlers for the bridge. The bridge only uses