@oxidezap/baileyrs 0.1.0 → 0.1.2

package/lib/Socket/internals.d.ts

@@ -0,0 +1,88 @@
+import type { BinaryNode, MessageUpsertType, WAMessage, WAPatchCreate } from '../Types/index.js';
+import type { ILogger } from '../Utils/logger.js';
+import type { SocketContext } from './types.js';
+/**
+ * The one place an unexpected failure is reported, shared by the socket's
+ * `onUnexpectedError` property and by the internal paths that raise them.
+ *
+ * `report` cannot throw. Some of its callers are bridge callbacks that borrow
+ * memory and are contractually forbidden from raising, so a consumer whose
+ * handler throws would cost the session its borrowed batches. A handler that
+ * fails is reported through the logger and the caller carries on.
+ *
+ * The return type says `void`, which an `async` handler also satisfies, so a
+ * handler that rejects rather than throws is contained the same way. Left
+ * loose it would surface as an unhandled rejection, which ends the process
+ * under `--unhandled-rejections=strict`.
+ */
+export declare const makeUnexpectedErrorReporter: (logger: ILogger) => {
+    report: (err: unknown, msg: string) => void;
+    handler: (err: unknown, msg: string) => void;
+};
+export declare const makeInternalMethods: (ctx: SocketContext) => {
+    /**
+     * `waitForSocket`, not `waitForConnected`: upstream waits for the socket
+     * to open, which is not the same as being logged in, and the bridge
+     * separates the two.
+     *
+     * A rejection means the socket did not open within one connect attempt,
+     * not that it never will: the engine reconnects on its own, and a caller
+     * that wants the next attempt waits again.
+     */
+    waitForSocketOpen: () => Promise<void>;
+    /**
+     * Publishes a message onto the event bus, which is this layer's own job.
+     * Buffered as upstream buffers it, so a replay of many messages
+     * consolidates into the batches a listener expects rather than one
+     * event per call.
+     *
+     * The push-name half of upstream's version is not reproduced: contact
+     * state belongs to the core, and writing it from here would make two
+     * writers for one value.
+     */
+    upsertMessage: (msg: WAMessage, type: MessageUpsertType) => Promise<void>;
+    /**
+     * The same reporter the socket's own failure paths use, rather than a
+     * second one that only a consumer could reach: a dispatcher that threw
+     * or a wire batch that would not decode arrives here. The socket
+     * redefines this as an accessor, so assigning to it replaces the
+     * handler those paths report through.
+     */
+    onUnexpectedError: (err: Error, msg: string) => void;
+    /**
+     * Resolves without forcing anything, and says so once.
+     *
+     * The engine syncs app state on connect and re-syncs every collection
+     * when the server raises the `syncd_app_state` dirty bit, so the state a
+     * caller wants current already is. There is no on-demand resync to
+     * delegate to, and rejecting would break a call whose intent is met.
+     */
+    resyncAppState: (collections?: readonly ('critical_block' | 'critical_unblock_low' | 'regular_high' | 'regular_low' | 'regular')[], isInitialSync?: boolean) => Promise<void>;
+    /**
+     * Refused: the offset is protocol state the core keeps from the stanzas
+     * it already reads. A second clock here would drift from the one that
+     * actually timestamps outgoing messages.
+     */
+    updateServerTimeOffset: (node: BinaryNode) => never;
+    /**
+     * Refused one layer down. The core's session instance is `pub(crate)`,
+     * and what exists returns a half-built stanza plus a sequence number, so
+     * exposing it would hand JavaScript the job of finishing and sequencing
+     * a lifecycle stanza.
+     */
+    sendUnifiedSession: () => Promise<never>;
+    /**
+     * Refused: the bridge exposes app-state actions typed per action and
+     * deliberately no generic. Accepting a raw patch here would mean
+     * building mutation indices and schema versions in TypeScript, beside
+     * the copy the core already maintains.
+     */
+    appPatch: (patchCreate: WAPatchCreate) => Promise<never>;
+    /**
+     * Null rather than absent, and rather than a shadow. Retry is the
+     * engine's, so there is no manager here to hand out, and saying so in
+     * the type is more useful than leaving the field missing.
+     */
+    messageRetryManager: null;
+};
+//# sourceMappingURL=internals.d.ts.map

package/lib/Socket/internals.js

@@ -0,0 +1,145 @@
+import { Boom } from '../Utils/boom.js';
+/**
+ * The one place an unexpected failure is reported, shared by the socket's
+ * `onUnexpectedError` property and by the internal paths that raise them.
+ *
+ * `report` cannot throw. Some of its callers are bridge callbacks that borrow
+ * memory and are contractually forbidden from raising, so a consumer whose
+ * handler throws would cost the session its borrowed batches. A handler that
+ * fails is reported through the logger and the caller carries on.
+ *
+ * The return type says `void`, which an `async` handler also satisfies, so a
+ * handler that rejects rather than throws is contained the same way. Left
+ * loose it would surface as an unhandled rejection, which ends the process
+ * under `--unhandled-rejections=strict`.
+ */
+export const makeUnexpectedErrorReporter = (logger) => {
+    const logUnexpected = (err, msg) => logger.error({ err }, `unexpected error in '${msg}'`);
+    const logHandlerFailure = (err, msg, reportingError) => {
+        logger.error({ err: reportingError }, 'the onUnexpectedError handler threw');
+        logUnexpected(err, msg);
+    };
+    let handler = logUnexpected;
+    return {
+        report: (err, msg) => {
+            try {
+                const settled = handler(err, msg);
+                if (settled instanceof Promise) {
+                    settled.catch(reportingError => logHandlerFailure(err, msg, reportingError));
+                }
+            }
+            catch (reportingError) {
+                logHandlerFailure(err, msg, reportingError);
+            }
+        },
+        get handler() {
+            return handler;
+        },
+        set handler(next) {
+            handler = next;
+        }
+    };
+};
+/**
+ * Upstream has no timeout on `waitForSocketOpen`; the bridge requires one, so
+ * one has to be chosen.
+ *
+ * It is the core's own transport connect ceiling, not `connectTimeoutMs`. That
+ * config reaches neither the transport nor the core, so a value below the
+ * ceiling would reject a wait while the attempt behind it was still running and
+ * about to succeed. A value above it would sit past the point the attempt was
+ * already abandoned.
+ */
+const TRANSPORT_CONNECT_TIMEOUT_MS = 20000;
+export const makeInternalMethods = (ctx) => {
+    /** Warned once per socket rather than per call, as with the other no-ops. */
+    let warnedAboutResync = false;
+    return {
+        /**
+         * `waitForSocket`, not `waitForConnected`: upstream waits for the socket
+         * to open, which is not the same as being logged in, and the bridge
+         * separates the two.
+         *
+         * A rejection means the socket did not open within one connect attempt,
+         * not that it never will: the engine reconnects on its own, and a caller
+         * that wants the next attempt waits again.
+         */
+        waitForSocketOpen: async () => {
+            await (await ctx.getClient()).waitForSocket(TRANSPORT_CONNECT_TIMEOUT_MS);
+        },
+        /**
+         * Publishes a message onto the event bus, which is this layer's own job.
+         * Buffered as upstream buffers it, so a replay of many messages
+         * consolidates into the batches a listener expects rather than one
+         * event per call.
+         *
+         * The push-name half of upstream's version is not reproduced: contact
+         * state belongs to the core, and writing it from here would make two
+         * writers for one value.
+         */
+        upsertMessage: ctx.ev.createBufferedFunction(async (msg, type) => {
+            ctx.ev.emit('messages.upsert', { messages: [msg], type });
+        }),
+        /**
+         * The same reporter the socket's own failure paths use, rather than a
+         * second one that only a consumer could reach: a dispatcher that threw
+         * or a wire batch that would not decode arrives here. The socket
+         * redefines this as an accessor, so assigning to it replaces the
+         * handler those paths report through.
+         */
+        onUnexpectedError: (err, msg) => {
+            ctx.reportUnexpectedError(err, msg);
+        },
+        /**
+         * Resolves without forcing anything, and says so once.
+         *
+         * The engine syncs app state on connect and re-syncs every collection
+         * when the server raises the `syncd_app_state` dirty bit, so the state a
+         * caller wants current already is. There is no on-demand resync to
+         * delegate to, and rejecting would break a call whose intent is met.
+         */
+        resyncAppState: async (collections, isInitialSync) => {
+            void collections;
+            void isInitialSync;
+            if (!warnedAboutResync) {
+                warnedAboutResync = true;
+                ctx.logger.warn('resyncAppState is a no-op: the engine syncs app state on connect and again whenever the server marks it dirty');
+            }
+        },
+        /**
+         * Refused: the offset is protocol state the core keeps from the stanzas
+         * it already reads. A second clock here would drift from the one that
+         * actually timestamps outgoing messages.
+         */
+        updateServerTimeOffset: (node) => {
+            void node;
+            throw new Boom('updateServerTimeOffset is not supported: the engine tracks the server clock offset itself, and a second one here would diverge from the one it stamps messages with', { statusCode: 501 });
+        },
+        /**
+         * Refused one layer down. The core's session instance is `pub(crate)`,
+         * and what exists returns a half-built stanza plus a sequence number, so
+         * exposing it would hand JavaScript the job of finishing and sequencing
+         * a lifecycle stanza.
+         */
+        sendUnifiedSession: async () => {
+            throw new Boom('sendUnifiedSession is not supported: it is connection lifecycle machinery the engine owns, not a consumer operation', { statusCode: 501 });
+        },
+        /**
+         * Refused: the bridge exposes app-state actions typed per action and
+         * deliberately no generic. Accepting a raw patch here would mean
+         * building mutation indices and schema versions in TypeScript, beside
+         * the copy the core already maintains.
+         */
+        appPatch: async (patchCreate) => {
+            void patchCreate;
+            throw new Boom('appPatch is not supported: use the typed chatModify variants, which is the only app-state surface this package can offer without a second implementation of the patch format', { statusCode: 501 });
+        },
+        /**
+         * Null rather than absent, and rather than a shadow. Retry is the
+         * engine's, so there is no manager here to hand out, and saying so in
+         * the type is more useful than leaving the field missing.
+         */
+        messageRetryManager: null
+    };
+};
+//# sourceMappingURL=internals.js.map

package/lib/Socket/messages.d.ts

@@ -1,20 +1,6 @@
-import type { AnyMessageContent, MessageGenerationOptions, MessageReceiptType, MessageRelayOptions, WAMessage, WAMessageContent, WAMessageKey } from '../Types/index.js';
+import type { AnyMessageContent, MessageGenerationOptions, MessageReceiptType, MessageRelayOptions, WAMessage, WAMessageKey } from '../Types/index.js';
 import { WAProto } from '../Types/index.js';
 import type { SocketContext } from './types.js';
-/**
- * Drop `messageContextInfo` before handing the proto to the Rust bridge so the
- * bridge can fill in its own `messageSecret` / `reportingTokenVersion`.
- *
- * Exception: pin messages need `messageAddOnDurationInSecs` (86400 / 604800 /
- * 2592000 to pin, 0 to unpin). The bridge does not set this field, so we save
- * it across the delete and restore it on a fresh contextInfo.
- *
- * Mutates `msg` in place.
- *
- * `contentType` is a parameter so the send path can hand over the type it has
- * already resolved rather than have it scanned out of `msg` a second time.
- */
-export declare function stripContextInfoForBridge(msg: WAMessageContent, contentType?: keyof WAProto.IMessage | undefined): void;
 export declare const makeMessageMethods: (ctx: SocketContext) => {
     sendMessage: (jid: string, content: AnyMessageContent, options?: Omit<MessageGenerationOptions, 'waClient' | 'logger' | 'userJid' | 'mediaInNote'>) => Promise<WAMessage>;
     updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;

package/lib/Socket/messages.js

@@ -13,26 +13,6 @@ function getMediaContent(content) {
         content?.documentMessage ||
         content?.stickerMessage);
 }
-/**
- * Drop `messageContextInfo` before handing the proto to the Rust bridge so the
- * bridge can fill in its own `messageSecret` / `reportingTokenVersion`.
- *
- * Exception: pin messages need `messageAddOnDurationInSecs` (86400 / 604800 /
- * 2592000 to pin, 0 to unpin). The bridge does not set this field, so we save
- * it across the delete and restore it on a fresh contextInfo.
- *
- * Mutates `msg` in place.
- *
- * `contentType` is a parameter so the send path can hand over the type it has
- * already resolved rather than have it scanned out of `msg` a second time.
- */
-export function stripContextInfoForBridge(msg, contentType = getContentType(msg)) {
-    const pinAddOnDuration = contentType === 'pinInChatMessage' ? msg.messageContextInfo?.messageAddOnDurationInSecs : undefined;
-    delete msg.messageContextInfo;
-    if (pinAddOnDuration !== undefined && pinAddOnDuration !== null) {
-        msg.messageContextInfo = { messageAddOnDurationInSecs: pinAddOnDuration };
-    }
-}
 const normalizedUserJids = new WeakMap();
 const getNormalizedUserJid = (ctx) => {
     const userId = ctx.getUser()?.id;
@@ -87,7 +67,6 @@ export const makeMessageMethods = (ctx) => ({
                 return fullMsg;
             }
         }
-        stripContextInfoForBridge(msg, contentType);
         let msgId;
         const msgBytes = encodeProto('Message', msg);
         if (jid === 'status@broadcast' && options?.statusJidList?.length) {
@@ -155,7 +134,9 @@ export const makeMessageMethods = (ctx) => ({
             messageId: plan.messageId,
             extraNodes: plan.kind === 'retransmission' ? 0 : plan.nodes.length
         }, 'relayMessage compatibility plan');
-        stripContextInfoForBridge(message);
+        // The message goes to the bridge as the caller built it: the core settles
+        // messageSecret / reportingTokenVersion itself, reusing a caller-set secret
+        // rather than replacing it, so nothing here has to be dropped.
         const bytes = encodeProto('Message', message);
         if (plan.kind === 'retransmission') {
             await client.retransmitMessageBytes(jid, bytes, plan.input);

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