zapo-js 1.6.2 → 1.7.0

package/dist/esm/client/coordinators/WaRetryCoordinator.js

@@ -11,7 +11,9 @@ import { WaRetryReplayService } from '../../retry/replay.js';
 import { generatePreKeyPair } from '../../signal/registration/keygen.js';
 import { buildAckNode } from '../../transport/node/builders/global.js';
 import { buildRetryReceiptNode } from '../../transport/node/builders/retry.js';
+import { findNodeChild } from '../../transport/node/helpers.js';
 import { uint8Equal } from '../../util/bytes.js';
+import { tryAsNumber } from '../../util/coercion.js';
 import { setBoundedMapEntry } from '../../util/collections.js';
 import { toError } from '../../util/primitives.js';
 const RETRY_CLEANUP_INTERVAL_MS = 30000;
@@ -23,8 +25,10 @@ const DECRYPT_FAILURE_QUEUE_MAX_CONCURRENCY = 8;
 const PLACEHOLDER_RESEND_RETRY_THRESHOLD = 3;
 const PLACEHOLDER_RESEND_BATCH_SIZE = 32;
 const PLACEHOLDER_RESEND_DEBOUNCE_MS = 200;
-const PLACEHOLDER_RESEND_MAX_AGE_SECONDS = 30 * 24 * 60 * 60;
+const PLACEHOLDER_RESEND_FALLBACK_MAX_AGE_DAYS = 14;
 const PLACEHOLDER_RESEND_IN_FLIGHT_MAX = 256;
+const PLACEHOLDER_RESEND_TIMEOUT_MS = 120000;
+const DAY_SECONDS = 24 * 60 * 60;
 const PLACEHOLDER_RESEND_SKIP_SUBTYPES = new Set([
     'bot_unavailable_fanout',
     'hosted_unavailable_fanout',
@@ -47,6 +51,30 @@ function getRemoteRetryReasonLogFields(reason) {
         remoteRetryReasonName: getRetryReasonName(reason) ?? 'missing_in_retry_receipt'
     };
 }
+/**
+ * Returns the placeholder subtype the primary never resends (bot fanout, hosted
+ * account, consumed view-once), or `null` when the message is recoverable.
+ */
+function resolvePlaceholderResendSkipSubtype(node) {
+    const subtype = node.attrs.subtype;
+    if (typeof subtype === 'string' && PLACEHOLDER_RESEND_SKIP_SUBTYPES.has(subtype)) {
+        return subtype;
+    }
+    const unavailable = findNodeChild(node, 'unavailable');
+    if (!unavailable) {
+        return null;
+    }
+    if (findNodeChild(node, 'bot')) {
+        return 'bot_unavailable_fanout';
+    }
+    if (unavailable.attrs.hosted === 'true') {
+        return 'hosted_unavailable_fanout';
+    }
+    if (unavailable.attrs.type === 'view_once') {
+        return 'view_once_unavailable_fanout';
+    }
+    return null;
+}
 export class WaRetryCoordinator {
     constructor(options) {
         this.nextRetryCleanupAtMs = 0;
@@ -765,6 +793,42 @@ export class WaRetryCoordinator {
         const meJid = credentials?.meJid;
         return !!meJid && parseSignalAddressFromJid(meJid).user === senderUser;
     }
+    /**
+     * Queues a `PLACEHOLDER_MESSAGE_RESEND` peer request for a message the server
+     * delivered as `<unavailable/>` (no `<enc>` to decrypt, so no retry receipt).
+     * Returns `false` when the placeholder is unrecoverable, too old, or this
+     * session is the primary. The payload surfaces later as a `message` event.
+     */
+    onUnavailableMessage(context) {
+        return this.enqueuePlaceholderResend(context);
+    }
+    getPlaceholderResendMaxAgeSeconds() {
+        const days = tryAsNumber(this.deps.getAbPropNumber?.('placeholder_message_resend_maximum_days_limit'));
+        return ((days !== null && days > 0 ? days : PLACEHOLDER_RESEND_FALLBACK_MAX_AGE_DAYS) *
+            DAY_SECONDS);
+    }
+    /**
+     * Builds the message key the primary indexes the message under: the chat is
+     * the `from`, or the `recipient` for a self-sent 1:1, always without the
+     * `:device` segment. The participant rides along only for an incoming
+     * group/broadcast message. Asking with the raw device-addressed `from`
+     * matches nothing and the resend comes back empty.
+     */
+    buildPlaceholderResendKey(context) {
+        const fromMe = this.isSenderFromOwnAccount(context);
+        const isGroupOrBroadcast = isGroupOrBroadcastJid(context.from);
+        const chatJid = fromMe && !isGroupOrBroadcast
+            ? (context.messageNode.attrs.recipient ?? context.from)
+            : context.from;
+        return {
+            remoteJid: toUserJid(chatJid),
+            id: context.stanzaId,
+            fromMe,
+            ...(!fromMe && isGroupOrBroadcast && context.participant
+                ? { participant: toUserJid(context.participant) }
+                : {})
+        };
+    }
     enqueuePlaceholderResend(context) {
         if (!this.deps.peerDataOperation || !this.deps.emitIncomingMessage) {
             return false;
@@ -772,14 +836,18 @@ export class WaRetryCoordinator {
         if (this.deps.isMobilePrimary?.()) {
             return false;
         }
-        const subtype = context.messageNode.attrs.subtype;
-        if (typeof subtype === 'string' && PLACEHOLDER_RESEND_SKIP_SUBTYPES.has(subtype)) {
+        const skipSubtype = resolvePlaceholderResendSkipSubtype(context.messageNode);
+        if (skipSubtype !== null) {
+            this.deps.logger.trace('placeholder resend skipped: unrecoverable placeholder', {
+                id: context.stanzaId,
+                subtype: skipSubtype
+            });
             return false;
         }
         const timestampSeconds = context.t ? Number(context.t) : Date.now() / 1000;
         if (Number.isFinite(timestampSeconds)) {
             const ageSeconds = Date.now() / 1000 - timestampSeconds;
-            if (ageSeconds > PLACEHOLDER_RESEND_MAX_AGE_SECONDS) {
+            if (ageSeconds > this.getPlaceholderResendMaxAgeSeconds()) {
                 return false;
             }
         }
@@ -794,12 +862,7 @@ export class WaRetryCoordinator {
             return false;
         }
         this.placeholderInFlight.add(context.stanzaId);
-        this.placeholderQueue.push({
-            remoteJid: context.from,
-            id: context.stanzaId,
-            fromMe: this.isSenderFromOwnAccount(context),
-            participant: context.participant
-        });
+        this.placeholderQueue.push(this.buildPlaceholderResendKey(context));
         if (this.placeholderTimer === null) {
             this.placeholderTimer = setTimeout(() => {
                 this.placeholderTimer = null;
@@ -828,7 +891,7 @@ export class WaRetryCoordinator {
                             participant: item.participant
                         }
                     }))
-                });
+                }, { timeoutMs: PLACEHOLDER_RESEND_TIMEOUT_MS });
                 const meJid = this.deps.getCurrentCredentials()?.meJid;
                 for (const result of results) {
                     const bytes = result.placeholderMessageResendResponse?.webMessageInfoBytes;

package/dist/esm/client/events/dirty.js

@@ -1,7 +1,7 @@
+import { parseBlocklist } from '../events/privacy.js';
 import { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_IQ_TYPES, WA_NODE_TAGS, WA_SUPPORTED_DIRTY_TYPES } from '../../protocol/constants.js';
 import { toUserJid } from '../../protocol/jid.js';
 import { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildClearDirtyBitsIq, buildListParticipatingGroupsIq, buildNewsletterMetadataSyncIq } from '../../transport/node/builders/account-sync.js';
-import { buildGetPrivacySettingsIq } from '../../transport/node/builders/privacy.js';
 import { parseUsyncResultEnvelope } from '../../transport/node/builders/usync.js';
 import { getNodeChildrenTags } from '../../transport/node/helpers.js';
 import { assertIqResult, parseIqError } from '../../transport/node/query.js';
@@ -219,19 +219,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: 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: buildAccountBlocklistSyncIq(),
         logMessage: 'account_sync blocklist synchronized'
     });
+    runtime.emitBlocklist(parseBlocklist(response));
 }
 async function syncGroupsDirtyBit(runtime) {
     await runSyncQuery(runtime, {
@@ -271,6 +275,7 @@ async function runSyncQuery(runtime, args) {
     assertIqResult(response, args.assertContext ?? args.queryContext);
     logUsyncProtocolErrors(parseUsyncResultEnvelope(response), runtime.logger, args.queryContext);
     runtime.logger.debug(args.logMessage, args.contextData);
+    return response;
 }
 async function clearDirtyBits(runtime, dirtyBits) {
     try {

package/dist/esm/client/events/offline.js

@@ -0,0 +1,92 @@
+import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+const OFFLINE_THREAD_TAGS = Object.freeze({
+    ITEM: 'item',
+    WATERMARK: 'watermark',
+    STATUS_MSGS: 'status_msgs',
+    NOTIFICATIONS: 'notifications'
+});
+function parseThreadPreviews(node) {
+    const items = 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 = 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 = findNodeChild(node, OFFLINE_THREAD_TAGS.WATERMARK);
+    if (!watermarkNode) {
+        return undefined;
+    }
+    const highestByJid = new Map();
+    const items = 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 = 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 = findNodeChild(node, OFFLINE_THREAD_TAGS.STATUS_MSGS);
+    if (!statusNode) {
+        return undefined;
+    }
+    const items = 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: parseOptionalInt(statusNode.attrs.count) ?? 0,
+        jids
+    };
+}
+function parsePendingNotifications(node) {
+    const notificationsNode = findNodeChild(node, OFFLINE_THREAD_TAGS.NOTIFICATIONS);
+    if (!notificationsNode) {
+        return undefined;
+    }
+    return { count: 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>`
+ */
+export function parseOfflineThreadMetadata(node) {
+    return {
+        threads: parseThreadPreviews(node),
+        readWatermarks: parseReadWatermarks(node),
+        pendingStatusMessages: parsePendingStatusMessages(node),
+        pendingNotifications: parsePendingNotifications(node)
+    };
+}

package/dist/esm/client/events/privacy.js

@@ -0,0 +1,123 @@
+import { WA_NODE_TAGS } from '../../protocol/nodes.js';
+import { WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_SETTING_VALUES, WA_PRIVACY_TAGS } from '../../protocol/privacy.js';
+import { findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+/**
+ * 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 = WA_PRIVACY_SETTING_VALUES;
+/** Parses the `<privacy>` payload of a privacy `get` IQ result. */
+export function parsePrivacySettings(result) {
+    const privacyNode = findNodeChild(result, WA_NODE_TAGS.PRIVACY);
+    if (!privacyNode) {
+        return {};
+    }
+    const settings = {};
+    const categories = getNodeChildrenByTag(privacyNode, 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 = 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`.
+ */
+export function parsePrivacyCategoryDhash(result, category) {
+    const privacyNode = findNodeChild(result, WA_NODE_TAGS.PRIVACY);
+    if (!privacyNode) {
+        return null;
+    }
+    const categories = getNodeChildrenByTag(privacyNode, 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.
+ */
+export function parseDisallowedListUpdate(result) {
+    const privacyNode = findNodeChild(result, WA_NODE_TAGS.PRIVACY);
+    if (!privacyNode) {
+        return null;
+    }
+    const listNode = findNodeChild(privacyNode, WA_PRIVACY_TAGS.LIST);
+    if (!listNode) {
+        return null;
+    }
+    const dhash = listNode.attrs.dhash;
+    const userNodes = getNodeChildrenByTag(listNode, 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.
+ */
+export function parseDisallowedList(result) {
+    return parseDisallowedListUpdate(result) ?? { jids: [] };
+}
+/** Parses the `<list>` payload of a blocklist `get` IQ result. */
+export function parseBlocklist(result) {
+    const listNode = findNodeChild(result, WA_NODE_TAGS.LIST);
+    if (!listNode) {
+        return { jids: [] };
+    }
+    const dhash = listNode.attrs.dhash;
+    const itemNodes = 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/esm/client/messaging/group-metadata.js

@@ -39,6 +39,7 @@ export function createGroupMetadataCache(options) {
             groupJid,
             participants,
             ephemeral: cached?.ephemeral,
+            ephemeralTrigger: cached?.ephemeralTrigger,
             updatedAtMs: Date.now()
         });
     };
@@ -121,6 +122,7 @@ export function createGroupMetadataCache(options) {
             groupJid,
             participants,
             ephemeral: queried.ephemeral,
+            ephemeralTrigger: queried.ephemeralTrigger,
             updatedAtMs: Date.now()
         });
         return participants;
@@ -137,15 +139,22 @@ export 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;
-        }
-        await refreshParticipantUsers(groupJid);
-        const refreshed = await groupMetadataStore.getGroupMetadata(groupJid);
-        return refreshed?.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;
+        }
+        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) {
@@ -161,13 +170,18 @@ export 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;
@@ -182,6 +196,7 @@ export function createGroupMetadataCache(options) {
                 groupJid,
                 participants: participantUsers,
                 ephemeral: existing?.ephemeral,
+                ephemeralTrigger: existing?.ephemeralTrigger,
                 updatedAtMs: Date.now()
             });
             return;
@@ -234,6 +249,7 @@ export function createGroupMetadataCache(options) {
         refreshParticipantUsers,
         getEphemeral,
         resolveEphemeral,
+        resolveEphemeralSettings,
         mutateFromGroupEvent
     };
 }

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

@@ -1,6 +1,6 @@
 import { createReadStream } from 'node:fs';
-import { assertMediaUploadStatus, buildMediaUploadUrl, parseMediaUploadJsonBody, selectMediaUploadHost } from '../media.js';
-import { MEDIA_UPLOAD_PATHS } from '../../media/constants.js';
+import { assertMediaUploadStatus, buildMediaUploadUrl, parseMediaUploadJsonBody, performPlaintextMediaUpload, selectMediaUploadHost } from '../media.js';
+import { MEDIA_UPLOAD_PATHS, NEWSLETTER_MEDIA_UPLOAD_PATHS } from '../../media/constants.js';
 import { WaMediaCrypto } from '../../media/crypto/WaMediaCrypto.js';
 import { findFirstLink } from '../../message/addons/link-preview/detect.js';
 import { proto } from '../../proto.js';
@@ -94,6 +94,9 @@ function buildInlineFields(thumbnail) {
     };
 }
 async function uploadHqFromBytes(deps, thumbnail) {
+    if (deps.surface === 'newsletter') {
+        return uploadPlaintextHq(deps, thumbnail.bytes, thumbnail);
+    }
     const mediaKey = await WaMediaCrypto.generateMediaKey();
     const encrypted = await WaMediaCrypto.encryptBytes('thumbnail-link', mediaKey, thumbnail.bytes, { sidecar: false });
     const directPath = await dispatchUpload(deps, encrypted.ciphertextHmac, encrypted.ciphertextHmac.byteLength, encrypted.fileEncSha256);
@@ -108,6 +111,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.generateMediaKey();
     const encrypted = await WaMediaCrypto.encryptToFile('thumbnail-link', mediaKey, thumbnail.stream, { sidecar: false, expectedFileSize: thumbnail.contentLength });
     let readStream;
@@ -134,6 +140,27 @@ async function uploadHqFromStream(deps, thumbnail) {
         await 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 performPlaintextMediaUpload({ mediaTransfer: deps.mediaTransfer, mediaConn, logger: deps.logger }, {
+        source,
+        path: NEWSLETTER_MEDIA_UPLOAD_PATHS['thumbnail-link'],
+        mimetype: 'image/jpeg',
+        logLabel: 'uploading newsletter link preview thumbnail'
+    });
+    assertMediaUploadStatus(upload.status, 'newsletter thumbnail-link upload');
+    const parsed = 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 = selectMediaUploadHost(mediaConn);

package/dist/esm/client/newsletter/content.js

@@ -1,12 +1,14 @@
 import { assertMediaUploadStatus, parseMediaUploadJsonBody, performPlaintextMediaUpload } from '../media.js';
 import { NEWSLETTER_MEDIA_UPLOAD_PATHS } from '../../media/constants.js';
 import { createStickerPackZipStream } from '../../media/sticker/sticker-pack.js';
+import { buildExtendedTextWithPreview } from '../../message/addons/link-preview/builder.js';
 import { applyContextInfo } from '../../message/context-info.js';
-import { isSendEventMessage, isSendEventResponseMessage, isSendKeepMessage, isSendMediaMessage, isSendPinMessage, isSendPollMessage, isSendPollVoteMessage, isSendReactionMessage, isSendRevokeMessage, isSendTextMessage, resolveMessageTypeAttr, unwrapMessage } from '../../message/encode/content.js';
+import { isSendEventMessage, isSendEventResponseMessage, isSendKeepMessage, isSendMediaMessage, isSendPinMessage, isSendPollMessage, isSendPollVoteMessage, isSendReactionMessage, isSendRevokeMessage, isSendTextMessage, resolveEncMediaType, resolveMessageTypeAttr, unwrapMessage } from '../../message/encode/content.js';
 import { toStickerPackProtoStickers, toStickerPackZipEntries, validateStickerPackInput } from '../../message/kinds/sticker-pack.js';
 import { proto } from '../../proto.js';
 import { WA_ENC_MEDIA_TYPES } from '../../protocol/message.js';
 import { base64ToBytes } from '../../util/bytes.js';
+import { toError } from '../../util/primitives.js';
 export async function uploadNewsletterMedia(options, input) {
     const upload = await performPlaintextMediaUpload({
         mediaTransfer: options.mediaTransfer,
@@ -44,22 +46,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([
+    WA_ENC_MEDIA_TYPES.AUDIO,
+    WA_ENC_MEDIA_TYPES.DOCUMENT,
+    WA_ENC_MEDIA_TYPES.GIF,
+    WA_ENC_MEDIA_TYPES.IMAGE,
+    WA_ENC_MEDIA_TYPES.PTT,
+    WA_ENC_MEDIA_TYPES.PTV,
+    WA_ENC_MEDIA_TYPES.STICKER,
+    WA_ENC_MEDIA_TYPES.STICKER_PACK,
+    WA_ENC_MEDIA_TYPES.URL,
+    WA_ENC_MEDIA_TYPES.VCARD,
+    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 WA_ENC_MEDIA_TYPES.IMAGE;
-    if (message.videoMessage)
-        return message.videoMessage.gifPlayback ? WA_ENC_MEDIA_TYPES.GIF : WA_ENC_MEDIA_TYPES.VIDEO;
-    if (message.audioMessage)
-        return message.audioMessage.ptt ? WA_ENC_MEDIA_TYPES.PTT : WA_ENC_MEDIA_TYPES.AUDIO;
-    if (message.documentMessage)
-        return WA_ENC_MEDIA_TYPES.DOCUMENT;
-    if (message.stickerMessage)
-        return WA_ENC_MEDIA_TYPES.STICKER;
-    if (message.stickerPackMessage)
-        return WA_ENC_MEDIA_TYPES.STICKER_PACK;
-    if (message.ptvMessage)
-        return WA_ENC_MEDIA_TYPES.PTV;
-    return null;
+    const mediaType = 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: toError(error).message
+        });
+        return null;
+    }
 }
 function buildMediaProtoMessage(content, upload) {
     const common = {
@@ -145,11 +166,15 @@ export async function buildNewsletterMessageContent(options, content, ctx) {
         };
     }
     if (isSendTextMessage(content)) {
-        const message = applyContextInfo({ extendedTextMessage: { text: content.text } }, ctx);
+        const preview = await resolveTextLinkPreview(options, content);
+        const message = applyContextInfo(preview !== null
+            ? 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.Message.encode(message).finish(),
-            mediaType: null,
+            mediaType,
             upload: null
         };
     }

package/dist/esm/client/newsletter/messaging.js

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

package/dist/esm/client/persistence/WriteBehindPersistence.js

@@ -9,7 +9,8 @@ function mergeThread(previous, incoming) {
         pinned: incoming.pinned ?? previous.pinned,
         muteEndMs: incoming.muteEndMs ?? previous.muteEndMs,
         markedAsUnread: incoming.markedAsUnread ?? previous.markedAsUnread,
-        ephemeralExpiration: incoming.ephemeralExpiration ?? previous.ephemeralExpiration
+        ephemeralExpiration: incoming.ephemeralExpiration ?? previous.ephemeralExpiration,
+        ephemeralSettingTimestamp: incoming.ephemeralSettingTimestamp ?? previous.ephemeralSettingTimestamp
     };
 }
 function mergeContact(previous, incoming) {