zapo-js 1.6.2 → 1.7.0

package/dist/client/events/dirty.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDirtyBits = parseDirtyBits;
 exports.handleDirtyBits = handleDirtyBits;
+const privacy_1 = require("../events/privacy");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
 const account_sync_1 = require("../../transport/node/builders/account-sync");
-const privacy_1 = require("../../transport/node/builders/privacy");
 const usync_1 = require("../../transport/node/builders/usync");
 const helpers_1 = require("../../transport/node/helpers");
 const query_1 = require("../../transport/node/query");
@@ -223,19 +223,23 @@ async function syncAccountPictureDirtyBit(runtime) {
     }
     throw new Error(`account_sync.picture iq failed (${iqError.code}: ${iqError.text})`);
 }
+/**
+ * Catch-up path for a session that was offline while another device changed a
+ * setting. Runs the same refresh the live `account_sync` notification
+ * triggers: the whole category set plus the disallowed lists.
+ */
 async function syncAccountPrivacyDirtyBit(runtime) {
-    await runSyncQuery(runtime, {
-        queryContext: 'account_sync.privacy',
-        node: (0, privacy_1.buildGetPrivacySettingsIq)(),
-        logMessage: 'account_sync privacy synchronized'
-    });
+    await runtime.syncAccountPrivacy();
+    runtime.logger.debug('account_sync privacy synchronized');
 }
+/** The reply carries the full blocklist, not a delta. */
 async function syncAccountBlocklistDirtyBit(runtime) {
-    await runSyncQuery(runtime, {
+    const response = await runSyncQuery(runtime, {
         queryContext: 'account_sync.blocklist',
         node: (0, account_sync_1.buildAccountBlocklistSyncIq)(),
         logMessage: 'account_sync blocklist synchronized'
     });
+    runtime.emitBlocklist((0, privacy_1.parseBlocklist)(response));
 }
 async function syncGroupsDirtyBit(runtime) {
     await runSyncQuery(runtime, {
@@ -275,6 +279,7 @@ async function runSyncQuery(runtime, args) {
     (0, query_1.assertIqResult)(response, args.assertContext ?? args.queryContext);
     (0, usync_2.logUsyncProtocolErrors)((0, usync_1.parseUsyncResultEnvelope)(response), runtime.logger, args.queryContext);
     runtime.logger.debug(args.logMessage, args.contextData);
+    return response;
 }
 async function clearDirtyBits(runtime, dirtyBits) {
     try {

package/dist/client/events/offline.d.ts

@@ -0,0 +1,9 @@
+import type { WaOfflineThreadMetadataEvent } from '../types';
+import type { BinaryNode } from '../../transport/types';
+/**
+ * Parses the offline preview manifest out of an `<ib>` bulletin. Every child
+ * is optional: a bare node yields an empty `threads` list.
+ *
+ * @param node - the `<thread_metadata>` node, not the enclosing `<ib>`
+ */
+export declare function parseOfflineThreadMetadata(node: BinaryNode): WaOfflineThreadMetadataEvent;

package/dist/client/events/offline.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOfflineThreadMetadata = parseOfflineThreadMetadata;
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+const OFFLINE_THREAD_TAGS = Object.freeze({
+    ITEM: 'item',
+    WATERMARK: 'watermark',
+    STATUS_MSGS: 'status_msgs',
+    NOTIFICATIONS: 'notifications'
+});
+function parseThreadPreviews(node) {
+    const items = (0, helpers_1.getNodeChildrenByTag)(node, OFFLINE_THREAD_TAGS.ITEM);
+    const previews = [];
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        const jid = item.attrs.from;
+        const timestampSeconds = (0, primitives_1.parseOptionalInt)(item.attrs.t);
+        if (!jid || timestampSeconds === undefined || timestampSeconds < 0) {
+            continue;
+        }
+        previews.push({ jid, timestampSeconds });
+    }
+    return previews;
+}
+/** Keeps the highest `sts` per jid; non-positive means "no watermark", not "read at epoch". */
+function parseReadWatermarks(node) {
+    const watermarkNode = (0, helpers_1.findNodeChild)(node, OFFLINE_THREAD_TAGS.WATERMARK);
+    if (!watermarkNode) {
+        return undefined;
+    }
+    const highestByJid = new Map();
+    const items = (0, helpers_1.getNodeChildrenByTag)(watermarkNode, OFFLINE_THREAD_TAGS.ITEM);
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        const jid = item.attrs.from;
+        const readTimestampSeconds = (0, primitives_1.parseOptionalInt)(item.attrs.sts);
+        if (!jid || readTimestampSeconds === undefined || readTimestampSeconds <= 0) {
+            continue;
+        }
+        const current = highestByJid.get(jid);
+        if (current === undefined || readTimestampSeconds > current) {
+            highestByJid.set(jid, readTimestampSeconds);
+        }
+    }
+    if (highestByJid.size === 0) {
+        return undefined;
+    }
+    const watermarks = new Array(highestByJid.size);
+    let index = 0;
+    for (const [jid, readTimestampSeconds] of highestByJid) {
+        watermarks[index] = { jid, readTimestampSeconds };
+        index += 1;
+    }
+    return watermarks;
+}
+function parsePendingStatusMessages(node) {
+    const statusNode = (0, helpers_1.findNodeChild)(node, OFFLINE_THREAD_TAGS.STATUS_MSGS);
+    if (!statusNode) {
+        return undefined;
+    }
+    const items = (0, helpers_1.getNodeChildrenByTag)(statusNode, OFFLINE_THREAD_TAGS.ITEM);
+    const jids = [];
+    for (let index = 0; index < items.length; index += 1) {
+        const jid = items[index].attrs.from;
+        if (jid) {
+            jids.push(jid);
+        }
+    }
+    return {
+        count: (0, primitives_1.parseOptionalInt)(statusNode.attrs.count) ?? 0,
+        jids
+    };
+}
+function parsePendingNotifications(node) {
+    const notificationsNode = (0, helpers_1.findNodeChild)(node, OFFLINE_THREAD_TAGS.NOTIFICATIONS);
+    if (!notificationsNode) {
+        return undefined;
+    }
+    return { count: (0, primitives_1.parseOptionalInt)(notificationsNode.attrs.count) ?? 0 };
+}
+/**
+ * Parses the offline preview manifest out of an `<ib>` bulletin. Every child
+ * is optional: a bare node yields an empty `threads` list.
+ *
+ * @param node - the `<thread_metadata>` node, not the enclosing `<ib>`
+ */
+function parseOfflineThreadMetadata(node) {
+    return {
+        threads: parseThreadPreviews(node),
+        readWatermarks: parseReadWatermarks(node),
+        pendingStatusMessages: parsePendingStatusMessages(node),
+        pendingNotifications: parsePendingNotifications(node)
+    };
+}

package/dist/client/events/privacy.d.ts

@@ -0,0 +1,45 @@
+import { type WaPrivacyCategory, type WaPrivacySettingName, type WaPrivacySettingValueMap } from '../../protocol/privacy';
+import type { BinaryNode } from '../../transport/types';
+/**
+ * Snapshot of every privacy category the server reports. Categories the
+ * library does not model (or that came back as `error`) are absent instead
+ * of being surfaced with a placeholder value.
+ */
+export type WaPrivacySettings = {
+    readonly [K in WaPrivacySettingName]?: WaPrivacySettingValueMap[K];
+};
+/** Per-category deny-list (the JIDs excluded from a `contact_blacklist` setting). */
+export interface WaPrivacyDisallowedListResult {
+    readonly jids: readonly string[];
+    readonly dhash?: string;
+}
+/** Account-wide blocklist. The server always sends the full list, never a delta. */
+export interface WaBlocklistResult {
+    readonly jids: readonly string[];
+    readonly dhash?: string;
+}
+/** Parses the `<privacy>` payload of a privacy `get` IQ result. */
+export declare function parsePrivacySettings(result: BinaryNode): WaPrivacySettings;
+/**
+ * Reads the `dhash` the server echoes back on a privacy `set` result. It is a
+ * millisecond timestamp acting as the version stamp of that category's
+ * disallowed list, and is only present while the category sits on
+ * `contact_blacklist`.
+ */
+export declare function parsePrivacyCategoryDhash(result: BinaryNode, category: WaPrivacyCategory): string | null;
+/**
+ * Parses the `<privacy><list>` payload of a disallowed-list `get` IQ result,
+ * returning `null` when the reply carries no `<list>` at all. The server omits
+ * it to mean "nothing to update" - either the category is not on
+ * `contact_blacklist`, or the `dhash` the client sent still matches - which is
+ * different from an empty list, so a caller reacting to changes can skip it.
+ */
+export declare function parseDisallowedListUpdate(result: BinaryNode): WaPrivacyDisallowedListResult | null;
+/**
+ * Same read as {@link parseDisallowedListUpdate}, flattening the "nothing to
+ * update" reply into an empty list for callers that just want the current
+ * membership.
+ */
+export declare function parseDisallowedList(result: BinaryNode): WaPrivacyDisallowedListResult;
+/** Parses the `<list>` payload of a blocklist `get` IQ result. */
+export declare function parseBlocklist(result: BinaryNode): WaBlocklistResult;

package/dist/client/events/privacy.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrivacySettings = parsePrivacySettings;
+exports.parsePrivacyCategoryDhash = parsePrivacyCategoryDhash;
+exports.parseDisallowedListUpdate = parseDisallowedListUpdate;
+exports.parseDisallowedList = parseDisallowedList;
+exports.parseBlocklist = parseBlocklist;
+const nodes_1 = require("../../protocol/nodes");
+const privacy_1 = require("../../protocol/privacy");
+const helpers_1 = require("../../transport/node/helpers");
+/**
+ * Server categories the library intentionally drops: they are either
+ * region/product specific or not part of the modeled privacy surface.
+ */
+const IGNORED_SERVER_CATEGORIES = new Set([
+    'stickers',
+    'dependentaccountmessages',
+    'cover_photo',
+    'dependent_account_calling',
+    'groupcreation'
+]);
+const SETTING_VALUES = privacy_1.WA_PRIVACY_SETTING_VALUES;
+/** Parses the `<privacy>` payload of a privacy `get` IQ result. */
+function parsePrivacySettings(result) {
+    const privacyNode = (0, helpers_1.findNodeChild)(result, nodes_1.WA_NODE_TAGS.PRIVACY);
+    if (!privacyNode) {
+        return {};
+    }
+    const settings = {};
+    const categories = (0, helpers_1.getNodeChildrenByTag)(privacyNode, privacy_1.WA_PRIVACY_TAGS.CATEGORY);
+    for (let i = 0; i < categories.length; i += 1) {
+        const node = categories[i];
+        const name = node.attrs.name;
+        const value = node.attrs.value;
+        if (!name || !value) {
+            continue;
+        }
+        if (IGNORED_SERVER_CATEGORIES.has(name)) {
+            continue;
+        }
+        const settingName = privacy_1.WA_PRIVACY_CATEGORY_TO_SETTING[name];
+        if (!settingName) {
+            continue;
+        }
+        if (SETTING_VALUES[settingName]?.includes(value) !== true) {
+            continue;
+        }
+        settings[settingName] = value;
+    }
+    return settings;
+}
+/**
+ * Reads the `dhash` the server echoes back on a privacy `set` result. It is a
+ * millisecond timestamp acting as the version stamp of that category's
+ * disallowed list, and is only present while the category sits on
+ * `contact_blacklist`.
+ */
+function parsePrivacyCategoryDhash(result, category) {
+    const privacyNode = (0, helpers_1.findNodeChild)(result, nodes_1.WA_NODE_TAGS.PRIVACY);
+    if (!privacyNode) {
+        return null;
+    }
+    const categories = (0, helpers_1.getNodeChildrenByTag)(privacyNode, privacy_1.WA_PRIVACY_TAGS.CATEGORY);
+    for (let i = 0; i < categories.length; i += 1) {
+        const node = categories[i];
+        if (node.attrs.name !== category) {
+            continue;
+        }
+        return node.attrs.dhash ?? null;
+    }
+    return null;
+}
+/**
+ * Parses the `<privacy><list>` payload of a disallowed-list `get` IQ result,
+ * returning `null` when the reply carries no `<list>` at all. The server omits
+ * it to mean "nothing to update" - either the category is not on
+ * `contact_blacklist`, or the `dhash` the client sent still matches - which is
+ * different from an empty list, so a caller reacting to changes can skip it.
+ */
+function parseDisallowedListUpdate(result) {
+    const privacyNode = (0, helpers_1.findNodeChild)(result, nodes_1.WA_NODE_TAGS.PRIVACY);
+    if (!privacyNode) {
+        return null;
+    }
+    const listNode = (0, helpers_1.findNodeChild)(privacyNode, privacy_1.WA_PRIVACY_TAGS.LIST);
+    if (!listNode) {
+        return null;
+    }
+    const dhash = listNode.attrs.dhash;
+    const userNodes = (0, helpers_1.getNodeChildrenByTag)(listNode, privacy_1.WA_PRIVACY_TAGS.USER);
+    const jids = new Array(userNodes.length);
+    let jidsCount = 0;
+    for (let i = 0; i < userNodes.length; i += 1) {
+        const jid = userNodes[i].attrs.jid;
+        if (jid) {
+            jids[jidsCount] = jid;
+            jidsCount += 1;
+        }
+    }
+    jids.length = jidsCount;
+    return { jids, dhash };
+}
+/**
+ * Same read as {@link parseDisallowedListUpdate}, flattening the "nothing to
+ * update" reply into an empty list for callers that just want the current
+ * membership.
+ */
+function parseDisallowedList(result) {
+    return parseDisallowedListUpdate(result) ?? { jids: [] };
+}
+/** Parses the `<list>` payload of a blocklist `get` IQ result. */
+function parseBlocklist(result) {
+    const listNode = (0, helpers_1.findNodeChild)(result, nodes_1.WA_NODE_TAGS.LIST);
+    if (!listNode) {
+        return { jids: [] };
+    }
+    const dhash = listNode.attrs.dhash;
+    const itemNodes = (0, helpers_1.getNodeChildren)(listNode);
+    const jids = new Array(itemNodes.length);
+    let jidsCount = 0;
+    for (let i = 0; i < itemNodes.length; i += 1) {
+        const jid = itemNodes[i].attrs.jid;
+        if (jid) {
+            jids[jidsCount] = jid;
+            jidsCount += 1;
+        }
+    }
+    jids.length = jidsCount;
+    return { jids, dhash };
+}

package/dist/client/messaging/group-metadata.d.ts

@@ -4,12 +4,24 @@ import type { WaGroupMetadataStore } from '../../store/contracts/group-metadata.
 export type GroupMetadataQueryResult = {
     readonly participants: readonly string[];
     readonly ephemeral?: number;
+    readonly ephemeralTrigger?: number;
+};
+/** Disappearing-message settings a group reports, as sent on outgoing messages. */
+export type GroupEphemeralSettings = {
+    readonly expirationSeconds: number;
+    readonly trigger?: number;
 };
 export type GroupMetadataCache = {
     resolveParticipantUsers(groupJid: string): Promise<readonly string[]>;
     refreshParticipantUsers(groupJid: string): Promise<readonly string[]>;
     getEphemeral(groupJid: string): Promise<number | null>;
     resolveEphemeral(groupJid: string): Promise<number | null>;
+    /**
+     * Expiration plus the group's `disappearingMode` trigger in one read, or
+     * `null` when the group is not ephemeral. Refreshes a cold cache like
+     * {@link resolveEphemeral} does.
+     */
+    resolveEphemeralSettings(groupJid: string): Promise<GroupEphemeralSettings | null>;
     mutateFromGroupEvent(event: WaGroupEvent): Promise<void>;
 };
 export declare function createGroupMetadataCache(options: {

package/dist/client/messaging/group-metadata.js

@@ -42,6 +42,7 @@ function createGroupMetadataCache(options) {
             groupJid,
             participants,
             ephemeral: cached?.ephemeral,
+            ephemeralTrigger: cached?.ephemeralTrigger,
             updatedAtMs: Date.now()
         });
     };
@@ -124,6 +125,7 @@ function createGroupMetadataCache(options) {
             groupJid,
             participants,
             ephemeral: queried.ephemeral,
+            ephemeralTrigger: queried.ephemeralTrigger,
             updatedAtMs: Date.now()
         });
         return participants;
@@ -140,15 +142,22 @@ function createGroupMetadataCache(options) {
         const cached = await groupMetadataStore.getGroupMetadata(groupJid);
         return cached?.ephemeral ?? null;
     };
-    const resolveEphemeral = async (groupJid) => {
-        const cached = await groupMetadataStore.getGroupMetadata(groupJid);
-        if (cached) {
-            return cached.ephemeral ?? null;
+    const resolveEphemeralSettings = async (groupJid) => {
+        let cached = await groupMetadataStore.getGroupMetadata(groupJid);
+        if (!cached) {
+            await refreshParticipantUsers(groupJid);
+            cached = await groupMetadataStore.getGroupMetadata(groupJid);
+        }
+        const expirationSeconds = cached?.ephemeral;
+        if (expirationSeconds === undefined || expirationSeconds <= 0) {
+            return null;
         }
-        await refreshParticipantUsers(groupJid);
-        const refreshed = await groupMetadataStore.getGroupMetadata(groupJid);
-        return refreshed?.ephemeral ?? null;
+        return {
+            expirationSeconds,
+            ...(cached?.ephemeralTrigger !== undefined ? { trigger: cached.ephemeralTrigger } : {})
+        };
     };
+    const resolveEphemeral = async (groupJid) => (await resolveEphemeralSettings(groupJid))?.expirationSeconds ?? null;
     const applyGroupEvent = async (event) => {
         const groupJid = resolveGroupJidForGroupCacheEvent(event);
         if (!groupJid) {
@@ -164,13 +173,18 @@ function createGroupMetadataCache(options) {
                 return;
             }
             const nextEphemeral = event.expirationSeconds;
-            if (cached.ephemeral === nextEphemeral) {
+            const parsedTrigger = event.mode === undefined ? undefined : Number(event.mode);
+            const nextTrigger = parsedTrigger !== undefined && Number.isFinite(parsedTrigger)
+                ? parsedTrigger
+                : cached.ephemeralTrigger;
+            if (cached.ephemeral === nextEphemeral && cached.ephemeralTrigger === nextTrigger) {
                 return;
             }
             await groupMetadataStore.upsertGroupMetadata({
                 groupJid,
                 participants: cached.participants,
                 ephemeral: nextEphemeral,
+                ephemeralTrigger: nextTrigger,
                 updatedAtMs: Date.now()
             });
             return;
@@ -185,6 +199,7 @@ function createGroupMetadataCache(options) {
                 groupJid,
                 participants: participantUsers,
                 ephemeral: existing?.ephemeral,
+                ephemeralTrigger: existing?.ephemeralTrigger,
                 updatedAtMs: Date.now()
             });
             return;
@@ -237,6 +252,7 @@ function createGroupMetadataCache(options) {
         refreshParticipantUsers,
         getEphemeral,
         resolveEphemeral,
+        resolveEphemeralSettings,
         mutateFromGroupEvent
     };
 }

package/dist/client/messaging/link-preview.d.ts

@@ -4,6 +4,11 @@ import type { WaMediaConn } from '../../media/types';
 import type { WaLinkPreviewThumbnailFields } from '../../message/addons/link-preview/builder';
 import type { WaLinkPreviewFetcher, WaLinkPreviewOptions, WaLinkPreviewOverride, WaLinkPreviewResolved } from '../../message/addons/link-preview/types';
 import type { ServerClock } from '../../util/clock';
+/**
+ * Where the preview is published. `chat` uploads the HQ thumbnail encrypted;
+ * `newsletter` uploads it in the clear, since channel media is not encrypted.
+ */
+export type WaLinkPreviewSurface = 'chat' | 'newsletter';
 export interface ResolveLinkPreviewDeps {
     readonly logger: Logger;
     readonly mediaTransfer: WaMediaTransferClient;
@@ -11,6 +16,8 @@ export interface ResolveLinkPreviewDeps {
     readonly fetcher: WaLinkPreviewFetcher;
     readonly options: WaLinkPreviewOptions;
     readonly serverClock: ServerClock;
+    /** Defaults to `chat`. */
+    readonly surface?: WaLinkPreviewSurface;
 }
 export interface ResolvedLinkPreviewResult {
     readonly resolved: WaLinkPreviewResolved;

package/dist/client/messaging/link-preview.js

@@ -97,6 +97,9 @@ function buildInlineFields(thumbnail) {
     };
 }
 async function uploadHqFromBytes(deps, thumbnail) {
+    if (deps.surface === 'newsletter') {
+        return uploadPlaintextHq(deps, thumbnail.bytes, thumbnail);
+    }
     const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
     const encrypted = await WaMediaCrypto_1.WaMediaCrypto.encryptBytes('thumbnail-link', mediaKey, thumbnail.bytes, { sidecar: false });
     const directPath = await dispatchUpload(deps, encrypted.ciphertextHmac, encrypted.ciphertextHmac.byteLength, encrypted.fileEncSha256);
@@ -111,6 +114,9 @@ async function uploadHqFromBytes(deps, thumbnail) {
     };
 }
 async function uploadHqFromStream(deps, thumbnail) {
+    if (deps.surface === 'newsletter') {
+        return uploadPlaintextHq(deps, thumbnail.stream, thumbnail);
+    }
     const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
     const encrypted = await WaMediaCrypto_1.WaMediaCrypto.encryptToFile('thumbnail-link', mediaKey, thumbnail.stream, { sidecar: false, expectedFileSize: thumbnail.contentLength });
     let readStream;
@@ -137,6 +143,27 @@ async function uploadHqFromStream(deps, thumbnail) {
         await WaMediaCrypto_1.WaMediaCrypto.cleanupEncryptedFile(encrypted.filePath);
     }
 }
+/** Uploads the HQ thumbnail unencrypted, so no `mediaKey` / `thumbnailEncSha256`. */
+async function uploadPlaintextHq(deps, source, dimensions) {
+    const mediaConn = await deps.getMediaConn();
+    const upload = await (0, media_1.performPlaintextMediaUpload)({ mediaTransfer: deps.mediaTransfer, mediaConn, logger: deps.logger }, {
+        source,
+        path: constants_1.NEWSLETTER_MEDIA_UPLOAD_PATHS['thumbnail-link'],
+        mimetype: 'image/jpeg',
+        logLabel: 'uploading newsletter link preview thumbnail'
+    });
+    (0, media_1.assertMediaUploadStatus)(upload.status, 'newsletter thumbnail-link upload');
+    const parsed = (0, media_1.parseMediaUploadJsonBody)(upload.responseBytes, 'newsletter thumbnail-link upload');
+    if (!parsed.direct_path) {
+        throw new Error('newsletter thumbnail-link upload response missing direct_path');
+    }
+    return {
+        thumbnailDirectPath: parsed.direct_path,
+        thumbnailSha256: upload.fileSha256,
+        ...(dimensions.width !== undefined ? { thumbnailWidth: dimensions.width } : {}),
+        ...(dimensions.height !== undefined ? { thumbnailHeight: dimensions.height } : {})
+    };
+}
 async function dispatchUpload(deps, body, contentLength, fileEncSha256) {
     const mediaConn = await deps.getMediaConn();
     const host = (0, media_1.selectMediaUploadHost)(mediaConn);

package/dist/client/newsletter/content.d.ts

@@ -1,10 +1,11 @@
 import { type WaUploadMediaSource } from '../media';
+import type { ResolvedLinkPreviewResult } from '../messaging/link-preview';
 import type { Logger } from '../../infra/log/types';
 import { type NewsletterMediaKind } from '../../media/constants';
 import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
 import type { WaMediaConn } from '../../media/types';
 import { type WaSendContextInfo } from '../../message/context-info';
-import type { WaSendMessageContent } from '../../message/types';
+import type { WaSendMessageContent, WaSendTextMessage } from '../../message/types';
 export type WaNewsletterUploadMedia = WaUploadMediaSource;
 export interface WaNewsletterUploadInput {
     readonly mediaKind: NewsletterMediaKind;
@@ -38,5 +39,7 @@ export interface BuildNewsletterContentOptions {
     readonly logger: Logger;
     readonly mediaTransfer?: WaMediaTransferClient;
     readonly getMediaConn?: () => Promise<WaMediaConn>;
+    /** Must be bound to the `newsletter` surface (unencrypted thumbnail upload). */
+    readonly linkPreviewResolver?: (content: WaSendTextMessage) => Promise<ResolvedLinkPreviewResult | null>;
 }
 export declare function buildNewsletterMessageContent(options: BuildNewsletterContentOptions, content: WaSendMessageContent, ctx?: WaSendContextInfo | null): Promise<WaNewsletterBuiltContent>;

package/dist/client/newsletter/content.js

@@ -5,12 +5,14 @@ exports.buildNewsletterMessageContent = buildNewsletterMessageContent;
 const media_1 = require("../media");
 const constants_1 = require("../../media/constants");
 const sticker_pack_1 = require("../../media/sticker/sticker-pack");
+const builder_1 = require("../../message/addons/link-preview/builder");
 const context_info_1 = require("../../message/context-info");
 const content_1 = require("../../message/encode/content");
 const sticker_pack_2 = require("../../message/kinds/sticker-pack");
 const _proto_1 = require("../../proto");
 const message_1 = require("../../protocol/message");
 const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
 async function uploadNewsletterMedia(options, input) {
     const upload = await (0, media_1.performPlaintextMediaUpload)({
         mediaTransfer: options.mediaTransfer,
@@ -48,22 +50,41 @@ function resolveSendMediaKind(content) {
         return 'ptt';
     return content.type;
 }
+/** Enc media types a channel publish accepts; anything else ships as text. */
+const NEWSLETTER_MEDIA_TYPES = new Set([
+    message_1.WA_ENC_MEDIA_TYPES.AUDIO,
+    message_1.WA_ENC_MEDIA_TYPES.DOCUMENT,
+    message_1.WA_ENC_MEDIA_TYPES.GIF,
+    message_1.WA_ENC_MEDIA_TYPES.IMAGE,
+    message_1.WA_ENC_MEDIA_TYPES.PTT,
+    message_1.WA_ENC_MEDIA_TYPES.PTV,
+    message_1.WA_ENC_MEDIA_TYPES.STICKER,
+    message_1.WA_ENC_MEDIA_TYPES.STICKER_PACK,
+    message_1.WA_ENC_MEDIA_TYPES.URL,
+    message_1.WA_ENC_MEDIA_TYPES.VCARD,
+    message_1.WA_ENC_MEDIA_TYPES.VIDEO
+]);
+/**
+ * Resolves the `plaintext` node `mediatype`. Shares the encrypted send path's
+ * resolver so media without an upload still gets it - a link preview publishes
+ * as `url`, a contact card as `vcard`; without it the channel drops the card.
+ */
 function pickMediaTypeFromMessage(message) {
-    if (message.imageMessage)
-        return message_1.WA_ENC_MEDIA_TYPES.IMAGE;
-    if (message.videoMessage)
-        return message.videoMessage.gifPlayback ? message_1.WA_ENC_MEDIA_TYPES.GIF : message_1.WA_ENC_MEDIA_TYPES.VIDEO;
-    if (message.audioMessage)
-        return message.audioMessage.ptt ? message_1.WA_ENC_MEDIA_TYPES.PTT : message_1.WA_ENC_MEDIA_TYPES.AUDIO;
-    if (message.documentMessage)
-        return message_1.WA_ENC_MEDIA_TYPES.DOCUMENT;
-    if (message.stickerMessage)
-        return message_1.WA_ENC_MEDIA_TYPES.STICKER;
-    if (message.stickerPackMessage)
-        return message_1.WA_ENC_MEDIA_TYPES.STICKER_PACK;
-    if (message.ptvMessage)
-        return message_1.WA_ENC_MEDIA_TYPES.PTV;
-    return null;
+    const mediaType = (0, content_1.resolveEncMediaType)(message);
+    return mediaType !== null && NEWSLETTER_MEDIA_TYPES.has(mediaType) ? mediaType : null;
+}
+async function resolveTextLinkPreview(options, content) {
+    if (!options.linkPreviewResolver)
+        return null;
+    try {
+        return await options.linkPreviewResolver(content);
+    }
+    catch (error) {
+        options.logger.warn('link preview resolver failed, sending plain text', {
+            message: (0, primitives_1.toError)(error).message
+        });
+        return null;
+    }
 }
 function buildMediaProtoMessage(content, upload) {
     const common = {
@@ -149,11 +170,15 @@ async function buildNewsletterMessageContent(options, content, ctx) {
         };
     }
     if ((0, content_1.isSendTextMessage)(content)) {
-        const message = (0, context_info_1.applyContextInfo)({ extendedTextMessage: { text: content.text } }, ctx);
+        const preview = await resolveTextLinkPreview(options, content);
+        const message = (0, context_info_1.applyContextInfo)(preview !== null
+            ? (0, builder_1.buildExtendedTextWithPreview)(content.text, preview.resolved, preview.thumbnailFields)
+            : { extendedTextMessage: { text: content.text } }, ctx);
+        const mediaType = pickMediaTypeFromMessage(message);
         return {
-            kind: 'text',
+            kind: mediaType !== null ? 'media' : 'text',
             plaintext: _proto_1.proto.Message.encode(message).finish(),
-            mediaType: null,
+            mediaType,
             upload: null
         };
     }

package/dist/client/newsletter/messaging.d.ts

@@ -1,3 +1,4 @@
+import { type BuildNewsletterContentOptions } from '../newsletter/content';
 import { type WaNewsletterMexDeps } from '../newsletter/mex';
 import type { WaNewsletterMuteInput, WaNewsletterReactInput, WaNewsletterRevokeInput, WaNewsletterSendOptions, WaNewsletterSendResult, WaNewsletterViewReceiptInput, WaNewsletterVotePollInput } from '../newsletter/types';
 import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
@@ -10,6 +11,7 @@ export interface WaNewsletterMessagingDeps extends WaNewsletterMexDeps {
     readonly generateStanzaId: () => Promise<string>;
     readonly mediaTransfer?: WaMediaTransferClient;
     readonly getMediaConn?: () => Promise<WaMediaConn>;
+    readonly linkPreviewResolver?: BuildNewsletterContentOptions['linkPreviewResolver'];
 }
 /** Newsletter messaging operations (send, react, fetch, follow). */
 export interface WaNewsletterMessagingOps {

package/dist/client/newsletter/messaging.js

@@ -11,7 +11,8 @@ async function buildContent(deps, content, ctx) {
     return (0, content_1.buildNewsletterMessageContent)({
         logger: deps.logger,
         mediaTransfer: deps.mediaTransfer,
-        getMediaConn: deps.getMediaConn
+        getMediaConn: deps.getMediaConn,
+        linkPreviewResolver: deps.linkPreviewResolver
     }, content, ctx);
 }
 function toUploadSummary(built) {

package/dist/client/newsletter/mex.d.ts

@@ -1,13 +1,13 @@
+import type { WaAbPropName } from '../../abprops-spec';
 import type { Logger } from '../../infra/log/types';
 import type { WaMexOperationResponses, WaMexOperationVariables } from '../../mex';
-import type { AbPropName } from '../../protocol/abprops';
 import { type WaMexOpKey, type WaMexQuerySocket } from '../../transport/node/mex/client';
 import type { BinaryNode } from '../../transport/types';
 export type WaNewsletterTosKind = 'creation' | 'consumer' | 'admin_invite';
 export interface WaNewsletterMexDeps {
     readonly mexSocket: WaMexQuerySocket;
     readonly queryWithContext?: (context: string, node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
-    readonly getAbPropString?: (name: AbPropName) => string;
+    readonly getAbPropString?: (name: WaAbPropName) => string;
     readonly logger: Logger;
 }
 export declare function runMex<K extends WaMexOpKey>(deps: WaNewsletterMexDeps, opKey: K, variables: WaMexOperationVariables[K]): Promise<WaMexOperationResponses[K] | null>;