@oxidezap/baileyrs 0.1.0 → 0.1.1

package/lib/Socket/newsletter.d.ts

@@ -1,14 +1,69 @@
+import type { NewsletterMetadataResult } from '@oxidezap/whatsapp-rust-bridge';
+import type { NewsletterMetadata, NewsletterUpdate } from '../Types/Newsletter.js';
+import type { WAMediaUpload } from '../Types/index.js';
 import type { SocketContext } from './types.js';
 export declare const makeNewsletterMethods: (ctx: SocketContext) => {
-    newsletterCreate: (name: string, description?: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
-    newsletterMetadata: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
-    newsletterSubscribe: (jid: string) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMetadataResult>;
+    newsletterCreate: (name: string, description?: string) => Promise<NewsletterMetadata>;
+    /**
+     * `type` selects which lookup runs: the bridge has a method per key kind
+     * rather than one that inspects the key. Resolves to null when the
+     * newsletter does not exist, matching upstream.
+     */
+    newsletterMetadata: (type: 'invite' | 'jid', key: string) => Promise<NewsletterMetadata | null>;
+    /**
+     * `picture` is base64 of an already-generated image, and the empty string
+     * means remove, as upstream builds it. The core splits those into two
+     * methods, so the field is dispatched rather than forwarded.
+     */
+    newsletterUpdate: (jid: string, updates: NewsletterUpdate) => Promise<NewsletterMetadata>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<NewsletterMetadata>;
+    newsletterUpdateDescription: (jid: string, description: string) => Promise<NewsletterMetadata>;
+    newsletterUpdatePicture: (jid: string, content: WAMediaUpload) => Promise<NewsletterMetadata>;
+    newsletterRemovePicture: (jid: string) => Promise<NewsletterMetadata>;
+    newsletterFollow: (jid: string) => Promise<NewsletterMetadata>;
+    newsletterUnfollow: (jid: string) => Promise<void>;
+    /**
+     * The names this package used before it grew upstream's. Kept so existing
+     * callers do not break on a rename that buys them nothing, and returning
+     * the bridge result unmapped for the same reason: a caller reading `jid`
+     * or `subscriberCount` off it would find them renamed otherwise.
+     * `newsletterFollow` is the one that speaks upstream's shape.
+     */
+    newsletterSubscribe: (jid: string) => Promise<NewsletterMetadataResult>;
     newsletterUnsubscribe: (jid: string) => Promise<void>;
+    /**
+     * The follower-activity mute, which is the one a subscriber toggles. The
+     * core's other newsletter mute is for admin activity and is a different
+     * control, so the ambiguous alias is avoided here.
+     */
+    newsletterMute: (jid: string) => Promise<void>;
+    newsletterUnmute: (jid: string) => Promise<void>;
+    newsletterSubscribers: (jid: string) => Promise<{
+        subscribers: number;
+    }>;
     newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
     /**
-     * Mute or unmute a newsletter (channel) — silences its follower-activity
-     * notifications, the mute a subscriber toggles. `mute = true` silences.
+     * `since` and `after` have no equivalent: the core's query pages backward
+     * from a `before` cursor and carries no time filter. Mapping `after` onto
+     * `before` would page the opposite direction and return a plausible wrong
+     * answer, so a caller asking for either is told instead.
+     *
+     * Zero is not asking. `since: 0` is the epoch and `after: 0` is no cursor,
+     * which is what the unfiltered query already does, so the common
+     * `(jid, count, 0, 0)` call runs rather than being refused for nothing.
+     */
+    newsletterFetchMessages: (jid: string, count: number, since?: number, after?: number) => Promise<import("@oxidezap/whatsapp-rust-bridge").NewsletterMessageResult[]>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    }>;
+    /**
+     * The count rides on the admin-info result and the server omits it for an
+     * account that may not see it. Absent is reported as absent: `0` here would
+     * read as "no admins", which no newsletter can be.
      */
-    newsletterMute: (jid: string, mute: boolean) => Promise<void>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
+    newsletterDemote: (jid: string, userJid: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
 };
 //# sourceMappingURL=newsletter.d.ts.map

package/lib/Socket/newsletter.js

@@ -1,25 +1,143 @@
+import { Buffer } from 'node:buffer';
+import { bridgeNewsletterMetadataToBaileys } from '../Compatibility/newsletter-results.js';
+import { Boom } from '../Utils/boom.js';
+import { generateProfilePicture } from '../Utils/messages-media.js';
 export const makeNewsletterMethods = (ctx) => ({
     newsletterCreate: async (name, description) => {
-        return await (await ctx.getClient()).newsletterCreate(name, description);
+        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterCreate(name, description ?? null));
     },
-    newsletterMetadata: async (jid) => {
-        return await (await ctx.getClient()).newsletterMetadata(jid);
+    /**
+     * `type` selects which lookup runs: the bridge has a method per key kind
+     * rather than one that inspects the key. Resolves to null when the
+     * newsletter does not exist, matching upstream.
+     */
+    newsletterMetadata: async (type, key) => {
+        if (type !== 'invite' && type !== 'jid') {
+            throw new Boom(`newsletterMetadata: unknown key type '${type}'`, { statusCode: 400 });
+        }
+        const client = await ctx.getClient();
+        const result = type === 'invite' ? await client.newsletterMetadataByInvite(key) : await client.newsletterMetadata(key);
+        return result ? bridgeNewsletterMetadataToBaileys(result) : null;
+    },
+    /**
+     * `picture` is base64 of an already-generated image, and the empty string
+     * means remove, as upstream builds it. The core splits those into two
+     * methods, so the field is dispatched rather than forwarded.
+     */
+    newsletterUpdate: async (jid, updates) => {
+        const client = await ctx.getClient();
+        let result;
+        if (updates.name !== undefined || updates.description !== undefined) {
+            result = await client.newsletterUpdate(jid, updates.name ?? null, updates.description ?? null);
+        }
+        if (updates.picture === '') {
+            result = await client.newsletterRemovePicture(jid);
+        }
+        else if (updates.picture !== undefined) {
+            result = await client.newsletterSetPicture(jid, new Uint8Array(Buffer.from(updates.picture, 'base64')));
+        }
+        // Only when the delta asked for nothing: every write above already
+        // answers with the refreshed metadata, so reading it would be a round
+        // trip whose result is thrown away.
+        return bridgeNewsletterMetadataToBaileys(result ?? (await client.newsletterMetadata(jid)));
+    },
+    newsletterUpdateName: async (jid, name) => {
+        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterUpdate(jid, name, null));
+    },
+    newsletterUpdateDescription: async (jid, description) => {
+        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterUpdate(jid, null, description));
     },
+    newsletterUpdatePicture: async (jid, content) => {
+        const { img } = await generateProfilePicture(content);
+        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterSetPicture(jid, img));
+    },
+    newsletterRemovePicture: async (jid) => {
+        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterRemovePicture(jid));
+    },
+    newsletterFollow: async (jid) => {
+        return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterSubscribe(jid));
+    },
+    newsletterUnfollow: async (jid) => {
+        await (await ctx.getClient()).newsletterUnsubscribe(jid);
+    },
+    /**
+     * The names this package used before it grew upstream's. Kept so existing
+     * callers do not break on a rename that buys them nothing, and returning
+     * the bridge result unmapped for the same reason: a caller reading `jid`
+     * or `subscriberCount` off it would find them renamed otherwise.
+     * `newsletterFollow` is the one that speaks upstream's shape.
+     */
     newsletterSubscribe: async (jid) => {
         return await (await ctx.getClient()).newsletterSubscribe(jid);
     },
     newsletterUnsubscribe: async (jid) => {
         await (await ctx.getClient()).newsletterUnsubscribe(jid);
     },
+    /**
+     * The follower-activity mute, which is the one a subscriber toggles. The
+     * core's other newsletter mute is for admin activity and is a different
+     * control, so the ambiguous alias is avoided here.
+     */
+    newsletterMute: async (jid) => {
+        await (await ctx.getClient()).newsletterFollowerMute(jid, true);
+    },
+    newsletterUnmute: async (jid) => {
+        await (await ctx.getClient()).newsletterFollowerMute(jid, false);
+    },
+    newsletterSubscribers: async (jid) => {
+        const metadata = await (await ctx.getClient()).newsletterMetadata(jid);
+        return { subscribers: metadata.subscriberCount };
+    },
     newsletterReactMessage: async (jid, serverId, reaction) => {
         await (await ctx.getClient()).newsletterReactMessage(jid, serverId, reaction ?? null);
     },
     /**
-     * Mute or unmute a newsletter (channel) — silences its follower-activity
-     * notifications, the mute a subscriber toggles. `mute = true` silences.
+     * `since` and `after` have no equivalent: the core's query pages backward
+     * from a `before` cursor and carries no time filter. Mapping `after` onto
+     * `before` would page the opposite direction and return a plausible wrong
+     * answer, so a caller asking for either is told instead.
+     *
+     * Zero is not asking. `since: 0` is the epoch and `after: 0` is no cursor,
+     * which is what the unfiltered query already does, so the common
+     * `(jid, count, 0, 0)` call runs rather than being refused for nothing.
      */
-    newsletterMute: async (jid, mute) => {
-        await (await ctx.getClient()).newsletterMute(jid, mute);
+    newsletterFetchMessages: async (jid, count, since, after) => {
+        if (since) {
+            throw new Boom('newsletterFetchMessages: `since` is not supported, the message query carries no time filter', {
+                statusCode: 400
+            });
+        }
+        if (after) {
+            throw new Boom('newsletterFetchMessages: `after` is not supported, the message query pages backward from a `before` cursor', { statusCode: 400 });
+        }
+        return await (await ctx.getClient()).newsletterMessages(jid, count, null);
+    },
+    subscribeNewsletterUpdates: async (jid) => {
+        const duration = await (await ctx.getClient()).newsletterSubscribeLiveUpdates(jid);
+        return { duration: String(duration) };
+    },
+    /**
+     * The count rides on the admin-info result and the server omits it for an
+     * account that may not see it. Absent is reported as absent: `0` here would
+     * read as "no admins", which no newsletter can be.
+     */
+    newsletterAdminCount: async (jid) => {
+        const info = await (await ctx.getClient()).newsletterAdminInfo(jid);
+        if (info.adminCount === undefined) {
+            throw new Boom('newsletterAdminCount: the server did not return an admin count for this newsletter', {
+                statusCode: 404
+            });
+        }
+        return info.adminCount;
+    },
+    newsletterChangeOwner: async (jid, newOwnerJid) => {
+        await (await ctx.getClient()).newsletterChangeOwner(jid, newOwnerJid);
+    },
+    newsletterDemote: async (jid, userJid) => {
+        await (await ctx.getClient()).newsletterDemoteAdmin(jid, userJid);
+    },
+    newsletterDelete: async (jid) => {
+        await (await ctx.getClient()).newsletterDelete(jid);
     }
 });
 //# sourceMappingURL=newsletter.js.map

package/lib/Socket/privacy.d.ts

@@ -0,0 +1,25 @@
+import type { WAPrivacyCallValue, WAPrivacyGroupAddValue, WAPrivacyMessagesValue, WAPrivacyOnlineValue, WAPrivacyValue, WAReadReceiptsValue } from '../Types/index.js';
+import type { SocketContext } from './types.js';
+export declare const makePrivacyMethods: (ctx: SocketContext) => {
+    fetchPrivacySettings: (force?: boolean) => Promise<any>;
+    updatePrivacySetting: (category: string, value: string) => Promise<void>;
+    updateLastSeenPrivacy: (value: WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: WAPrivacyGroupAddValue) => Promise<void>;
+    updateCallPrivacy: (value: WAPrivacyCallValue) => Promise<void>;
+    updateMessagesPrivacy: (value: WAPrivacyMessagesValue) => Promise<void>;
+    /**
+     * Resolves without issuing anything. The engine already issues these
+     * tokens on every 1:1 send, rate limited by a sender bucket, so the
+     * caller's intent is met before they ask; a second manual issue would land
+     * outside that bucket and move the timestamp the limiter reads.
+     *
+     * Warned once rather than thrown: upstream callers await this inside a send
+     * workflow, and rejecting would abort a workflow that was going to succeed.
+     */
+    issuePrivacyTokens: (jids: string[], timestamp?: number) => Promise<void>;
+};
+//# sourceMappingURL=privacy.d.ts.map

package/lib/Socket/privacy.js

@@ -0,0 +1,54 @@
+export const makePrivacyMethods = (ctx) => {
+    /** Per socket, so a send loop calling this does not flood the log. */
+    let warnedAboutPrivacyTokens = false;
+    return {
+        fetchPrivacySettings: async (force) => {
+            void force;
+            return (await ctx.getClient()).fetchPrivacySettings();
+        },
+        updatePrivacySetting: async (category, value) => {
+            await (await ctx.getClient()).updatePrivacySetting(category, value);
+        },
+        updateLastSeenPrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('last', value);
+        },
+        updateOnlinePrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('online', value);
+        },
+        updateProfilePicturePrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('profile', value);
+        },
+        updateStatusPrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('status', value);
+        },
+        updateReadReceiptsPrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('readreceipts', value);
+        },
+        updateGroupsAddPrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('groupadd', value);
+        },
+        updateCallPrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('calladd', value);
+        },
+        updateMessagesPrivacy: async (value) => {
+            await (await ctx.getClient()).updatePrivacySetting('messages', value);
+        },
+        /**
+         * Resolves without issuing anything. The engine already issues these
+         * tokens on every 1:1 send, rate limited by a sender bucket, so the
+         * caller's intent is met before they ask; a second manual issue would land
+         * outside that bucket and move the timestamp the limiter reads.
+         *
+         * Warned once rather than thrown: upstream callers await this inside a send
+         * workflow, and rejecting would abort a workflow that was going to succeed.
+         */
+        issuePrivacyTokens: async (jids, timestamp) => {
+            void timestamp;
+            if (!warnedAboutPrivacyTokens) {
+                warnedAboutPrivacyTokens = true;
+                ctx.logger.warn({ count: jids.length }, 'issuePrivacyTokens is a no-op: the engine issues privacy tokens on every 1:1 send, so this call can be removed');
+            }
+        }
+    };
+};
+//# sourceMappingURL=privacy.js.map

package/lib/Socket/server-queries.d.ts

@@ -0,0 +1,38 @@
+import type { BotListInfo } from '../Types/Chat.js';
+import type { NewChatMessageCapInfo } from '../Types/State.js';
+import type { MediaConnInfo } from '../Types/Message.js';
+import type { SocketContext } from './types.js';
+export declare const makeServerQueryMethods: (ctx: SocketContext) => {
+    /**
+     * `maxContentLengthBytes` is absent by design: the core's hosts carry
+     * nothing but a hostname, so the field upstream declares has no source
+     * and is not invented here.
+     */
+    refreshMediaConn: (forceGet?: boolean) => Promise<Omit<MediaConnInfo, 'hosts'> & {
+        hosts: {
+            hostname: string;
+        }[];
+    }>;
+    /** Synchronous, as upstream has it, so it reads what the last refresh saw. */
+    getMediaHost: () => string;
+    getBotListV2: () => Promise<BotListInfo[]>;
+    fetchNewChatMessageCap: () => Promise<NewChatMessageCapInfo & {
+        remaining_quota?: number;
+    }>;
+    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
+    /**
+     * Refused rather than wired up. The core already fires a peer data
+     * request itself when a message fails to decrypt, with its own age
+     * policy, so a second one here would duplicate it. The request a
+     * consumer actually drives, asking for history, is `fetchMessageHistory`.
+     */
+    sendPeerDataOperationMessage: (_pdoMessage: unknown) => Promise<never>;
+    /**
+     * Refused one layer down, as a build decision. `create_call_link` exists
+     * in the core behind its voip feature, and the bridge pins the core with
+     * default features off, so it is not compiled into the wasm artifact at
+     * all. Reaching it would pull the webrtc stack into the bundle.
+     */
+    createCallLink: (_type: 'audio' | 'video', _event?: unknown, _timeoutMs?: number) => Promise<never>;
+};
+//# sourceMappingURL=server-queries.d.ts.map

package/lib/Socket/server-queries.js

@@ -0,0 +1,121 @@
+import { Boom } from '../Utils/boom.js';
+/**
+ * Every section, flattened and deduplicated, rather than only the section the
+ * server types `all`.
+ *
+ * Upstream reads that one section, and the core deliberately refused to: the
+ * real client walks every section and uses the type only for layout, so a bot
+ * that appears solely under a category is dropped by the narrower reading. A
+ * caller iterating this list handles the extra entries; one that silently lost
+ * a bot has no way to notice.
+ */
+const flattenBotList = (list) => {
+    const seen = new Set();
+    const bots = [];
+    for (const section of list.sections) {
+        for (const bot of section.bots) {
+            if (seen.has(bot.jid))
+                continue;
+            seen.add(bot.jid);
+            bots.push({ jid: bot.jid, personaId: bot.personaId });
+        }
+    }
+    return bots;
+};
+/**
+ * Upstream names these in snake case and types the three timestamps as
+ * strings. Every field is optional because the server omits whatever does not
+ * apply to the account's tier, and an absent quota stays absent: `0` here means
+ * the quota is spent.
+ */
+const toCapInfo = (result) => ({
+    ...(result.totalQuota !== undefined ? { total_quota: result.totalQuota } : {}),
+    ...(result.usedQuota !== undefined ? { used_quota: result.usedQuota } : {}),
+    ...(result.remainingQuota !== undefined ? { remaining_quota: result.remainingQuota } : {}),
+    ...(result.cycleStartTimestamp !== undefined ? { cycle_start_timestamp: String(result.cycleStartTimestamp) } : {}),
+    ...(result.cycleEndTimestamp !== undefined ? { cycle_end_timestamp: String(result.cycleEndTimestamp) } : {}),
+    ...(result.serverSentTimestamp !== undefined ? { server_sent_timestamp: String(result.serverSentTimestamp) } : {}),
+    ...(result.oteStatus !== undefined ? { ote_status: result.oteStatus } : {}),
+    ...(result.mvStatus !== undefined ? { mv_status: result.mvStatus } : {}),
+    ...(result.cappingStatus !== undefined
+        ? { capping_status: result.cappingStatus }
+        : {})
+});
+export const makeServerQueryMethods = (ctx) => {
+    /** Last host seen, so the synchronous accessor upstream exposes can answer. */
+    let mediaHost = '';
+    /**
+     * When the credentials were obtained, not when they were last handed out.
+     * The engine serves a live connection from its cache and gives no signal
+     * for which calls were actual fetches, so the stamp is kept only while the
+     * connection it describes is still live: past its own ttl, on a forced
+     * call, or on rotated credentials, whatever comes back is a fetch.
+     *
+     * A caller renewing on `fetchDate + ttl` needs both halves of that. Always
+     * restamping would push its deadline forward forever; never restamping
+     * would leave it renewing against a moment that has already passed.
+     */
+    let fetched;
+    const isLive = (held) => Date.now() - held.at.getTime() < held.ttl * 1000;
+    return {
+        /**
+         * `maxContentLengthBytes` is absent by design: the core's hosts carry
+         * nothing but a hostname, so the field upstream declares has no source
+         * and is not invented here.
+         */
+        refreshMediaConn: async (forceGet = false) => {
+            // Forced on the first call, as upstream's first call is: the engine may
+            // already hold a connection acquired by an upload, and stamping that
+            // one as fetched now would report it fresher than it is.
+            const held = fetched;
+            const conn = await (await ctx.getClient()).getMediaConn(forceGet || !held);
+            mediaHost = conn.hosts[0]?.hostname ?? mediaHost;
+            const isFetch = forceGet || !held || held.auth !== conn.auth || !isLive(held);
+            fetched = isFetch ? { auth: conn.auth, ttl: conn.ttl, at: new Date() } : held;
+            // A copy: the stored instant decides when the next call restamps, and a
+            // consumer holding the same Date could move it.
+            return { auth: conn.auth, ttl: conn.ttl, hosts: conn.hosts, fetchDate: new Date(fetched.at) };
+        },
+        /** Synchronous, as upstream has it, so it reads what the last refresh saw. */
+        getMediaHost: () => mediaHost,
+        getBotListV2: async () => {
+            return flattenBotList(await (await ctx.getClient()).getBotList());
+        },
+        fetchNewChatMessageCap: async () => {
+            return toCapInfo(await (await ctx.getClient()).fetchNewChatMessageCappingInfo());
+        },
+        cleanDirtyBits: async (type, fromTimestamp) => {
+            let timestamp = null;
+            if (fromTimestamp !== undefined) {
+                // A blank string is not a timestamp, and `Number('')` is the epoch,
+                // so without this a caller meaning "no timestamp" would ask the
+                // server to clean from the beginning of time.
+                const blank = typeof fromTimestamp === 'string' && fromTimestamp.trim() === '';
+                timestamp = typeof fromTimestamp === 'string' ? Number(fromTimestamp) : fromTimestamp;
+                if (blank || !Number.isFinite(timestamp)) {
+                    throw new Boom(`cleanDirtyBits: fromTimestamp '${fromTimestamp}' is not a number`, { statusCode: 400 });
+                }
+            }
+            await (await ctx.getClient()).cleanDirtyBits(type, timestamp);
+        },
+        /**
+         * Refused rather than wired up. The core already fires a peer data
+         * request itself when a message fails to decrypt, with its own age
+         * policy, so a second one here would duplicate it. The request a
+         * consumer actually drives, asking for history, is `fetchMessageHistory`.
+         */
+        sendPeerDataOperationMessage: async (_pdoMessage) => {
+            throw new Boom('sendPeerDataOperationMessage is not supported: use fetchMessageHistory to request history, and note the engine issues its own peer data request when a message fails to decrypt', { statusCode: 501 });
+        },
+        /**
+         * Refused one layer down, as a build decision. `create_call_link` exists
+         * in the core behind its voip feature, and the bridge pins the core with
+         * default features off, so it is not compiled into the wasm artifact at
+         * all. Reaching it would pull the webrtc stack into the bundle.
+         */
+        createCallLink: async (_type, _event, _timeoutMs) => {
+            throw new Boom('createCallLink is not available: the call-link operation sits behind the core voip feature, which is not compiled into the wasm bridge', { statusCode: 501 });
+        }
+    };
+};
+//# sourceMappingURL=server-queries.js.map

package/lib/Socket/types.d.ts

@@ -23,6 +23,12 @@ export interface SocketContext {
     getClientSync: () => WasmWhatsAppClient;
     /** Raw stanza EventEmitter for CB: pattern compat */
     ws: EventEmitter;
+    /**
+     * Where a failure goes when it has nowhere else to go: a dispatcher that
+     * threw, a wire batch that would not decode. Also what the socket exposes
+     * as `onUnexpectedError`, so the two are one reporter rather than two.
+     */
+    reportUnexpectedError: (err: unknown, msg: string) => void;
 }
 /** Convert a bridge Jid struct to a string */
 export declare const jidStr: (jid: {

package/lib/Types/Product.d.ts

@@ -1,4 +1,13 @@
+import type { CatalogResult as CatalogPageResult, CollectionsResult } from '@oxidezap/whatsapp-rust-bridge';
 import type { WAMediaUpload } from './Message.js';
+/**
+ * What `getCatalog` returns, under a name of its own. The `CatalogResult`
+ * below is the raw catalog envelope and is a different shape, so a consumer
+ * typing the call has one name to reach for and it is this one.
+ */
+export type CatalogPage = CatalogPageResult;
+/** As `CatalogPage`, for `getCollections`. */
+export type CollectionsPage = CollectionsResult;
 export type CatalogResult = {
     data: {
         paging: {

package/lib/Utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './auth-utils.js';
 export * from './crypto.js';
 export * from './generics.js';
 export * from './messages.js';
+export { getUrlInfo, type URLGenerationOptions } from './link-preview.js';
 export * from './messages-media.js';
 export * from './process-history-message.js';
 export * from './process-message.js';

package/lib/Utils/index.js

@@ -3,6 +3,9 @@ export * from './auth-utils.js';
 export * from './crypto.js';
 export * from './generics.js';
 export * from './messages.js';
+// Named rather than `*`: the underscore hooks in that file exist for the tests
+// and would otherwise become released API.
+export { getUrlInfo } from './link-preview.js';
 export * from './messages-media.js';
 export * from './process-history-message.js';
 export * from './process-message.js';

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,60 @@
+import type { WAUrlInfo } from '../Types/Message.js';
+import type { ILogger } from './logger.js';
+/**
+ * The first link in a piece of text, or undefined when there is none. Exported
+ * under an underscore so the extraction can be tested without a network.
+ *
+ * Trailing prose punctuation is dropped: a link at the end of a sentence
+ * carries the full stop with it, and `https://example.com.` is not what the
+ * writer meant. A closing bracket goes the same way, which costs the rare url
+ * that genuinely ends in one and saves the common case of a link in
+ * parentheses.
+ */
+export declare const _firstLink: (text: string) => string | undefined;
+export type URLGenerationOptions = {
+    thumbnailWidth: number;
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number;
+        proxyUrl?: string;
+        headers?: HeadersInit;
+    };
+    uploadImage?: (encFilePath: string, opts: {
+        fileEncSha256B64: string;
+        mediaType: string;
+    }) => Promise<unknown>;
+    logger?: ILogger;
+};
+/**
+ * Fetched here rather than through `getHttpStream`, which forwards neither the
+ * timeout nor the proxy and validates no destination. The credentials in
+ * `headers` are for the page, so they are sent to the thumbnail only when it
+ * is the same origin; another host advertised by that page must not receive
+ * them.
+ */
+/** Exported under an underscore so the destination guard can be driven directly. */
+export declare const _getCompressedJpegThumbnail: (url: string, pageUrl: string, { thumbnailWidth, fetchOpts }: URLGenerationOptions) => Promise<{
+    buffer: any;
+    original: {
+        width: any;
+        height: any;
+    };
+}>;
+/**
+ * Reads the first URL out of a piece of text and fetches what a link preview
+ * needs. Nothing here is protocol: it is an HTTP fetch, an OpenGraph parse and
+ * a thumbnail, which is why it belongs in this layer rather than the engine.
+ *
+ * Resolves to undefined for the two cases that mean "no preview": text with no
+ * link in it, and a page with no title. Everything else throws, including a
+ * timeout, because a swallowed failure is indistinguishable from a page that
+ * genuinely had nothing, and a caller retrying the first would give up on the
+ * second.
+ *
+ * The metadata parse comes from `link-preview-js`, an optional peer dependency
+ * this package already declares and had no reader for, so nothing new is
+ * pulled in: a consumer who does not want link previews does not install it
+ * and never calls this.
+ */
+export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>;
+//# sourceMappingURL=link-preview.d.ts.map