discord-html-transcripts-fix 2.1.0 → 2.3.0

package/dist/generator/renderers/message.js

@@ -52,15 +52,8 @@ const FLAG_IS_CROSSPOST = 1 << 1;
 const FLAG_SUPPRESS_EMBEDS = 1 << 2;
 const FLAG_SUPPRESS_NOTIFICATIONS = 1 << 12;
 const FLAG_IS_VOICE_MESSAGE = 1 << 13;
-const FLAG_HAS_SNAPSHOT = 1 << 14;
 const ACTIVITY_TYPES = { 1: 'Join', 2: 'Spectate', 3: 'Listen', 5: 'Join Request' };
 
-function abbrCount(n) {
-    if (n < 1000) return String(n);
-    if (n < 1000000) return (n / 1000).toFixed(n < 10000 ? 1 : 0).replace(/\.0$/, '') + 'K';
-    return (n / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
-}
-
 function t(context, key, fallback) {
     const dict = context?.i18n?.[context?.lang] || context?.i18n?.en || {};
     return dict[key] || fallback || key;
@@ -71,7 +64,9 @@ async function DiscordMessage({ message, context }) {
         if (message.system)
             return (0, jsx_runtime_1.jsx)(systemMessage_1.default, { message: message, context: context });
 
-        const isCrossGuildReply = message.reference && message.reference.guildId !== message.guild?.id;
+        // Only replies count here: a forward from another server is not a
+        // cross-server reply and must not get the server tag.
+        const isCrossGuildReply = message.reference && !(0, utils_1.isForwardMessage)(message) && message.reference.guildId !== message.guild?.id;
 
         // Data-attrs for client-side filtering (keyword/author/role/date/has-*).
         const memberRoleIds = message.member?.roles?.cache
@@ -106,8 +101,18 @@ async function DiscordMessage({ message, context }) {
             partyId: message.activity.partyId,
         } : null;
 
-        // Forwarded message snapshots (messageSnapshots) — render before the empty body
-        const snapshots = Array.isArray(message.messageSnapshots) ? message.messageSnapshots : [];
+        // Forwarded message snapshots (messageSnapshots) — render before the empty body.
+        // discord.js exposes them as a Collection, never an array, so an Array.isArray
+        // check left every forward empty ("Message could not be loaded.").
+        const snapshots = toArray(message.messageSnapshots);
+        const isForward = (0, utils_1.isForwardMessage)(message);
+        // Discord hides who wrote a forwarded message (see renderSnapshots). Name the
+        // channel it was forwarded from instead — only from this server, so a
+        // transcript never reveals channel names of other servers the bot is in.
+        const forwardedFromChannel = isForward && message.reference?.guildId && message.reference.guildId === message.guild?.id
+            ? message.guild?.channels?.cache?.get(message.reference.channelId)
+            : null;
+        const forwardSource = forwardedFromChannel?.name ? '#' + forwardedFromChannel.name : null;
 
         const editedAtIso = message.editedAt instanceof Date ? message.editedAt.toISOString() : null;
         // Hover text for the "(edited)" marker — the ISO string stays in
@@ -197,7 +202,14 @@ async function DiscordMessage({ message, context }) {
                 ] }),
                 editedAtIso && (0, jsx_runtime_1.jsx)("span", { className: "dht-edit-marker", title: editedAtTitle || editedAtIso, "data-edit-iso": editedAtIso, "data-i18n": "edited", "data-i18n-params": JSON.stringify({ time: editedAtLabel || editedAtIso }), children: '(' + t(context, 'edited', 'edited') + ')' }),
                 Array.isArray(message.editHistory) && message.editHistory.length > 0 && renderEditHistory(message.editHistory, context),
-                snapshots.length > 0 && renderSnapshots(snapshots, context),
+                snapshots.length > 0
+                    ? renderSnapshots(snapshots, context, 0, forwardSource)
+                    // A forward whose snapshot is missing still says what it is
+                    // instead of rendering as an empty message.
+                    : isForward && (0, jsx_runtime_1.jsx)("div", { className: "dht-forwarded-wrap", children: (0, jsx_runtime_1.jsx)("div", { className: "dht-forwarded", "data-depth": 0, children: (0, jsx_runtime_1.jsxs)("div", { className: "dht-forwarded-head", children: [
+                        (0, jsx_runtime_1.jsx)("span", { className: "dht-forwarded-icon", children: '↪' }),
+                        (0, jsx_runtime_1.jsx)("em", { "data-i18n": "forwardUnavailable", children: t(context, 'forwardUnavailable', 'Forwarded message is unavailable') }),
+                    ] }) }) }),
                 message.content && ((0, jsx_runtime_1.jsx)(content_1.default, { content: message.content, context: Object.assign({}, context, { type: message.webhookId ? content_1.RenderType.WEBHOOK : content_1.RenderType.NORMAL }) })),
                 (0, jsx_runtime_1.jsx)(attachment_1.Attachments, { message: message, context: context }),
                 isVoice && renderVoiceIndicator(message, context),
@@ -210,10 +222,14 @@ async function DiscordMessage({ message, context }) {
                     slot: "reactions",
                     children: Array.from(message.reactions.cache.values()).map((reaction, id) => {
                         const total = reaction.count ?? 0;
-                        const burstCount = reaction.count_details?.burst || reaction.burst_count || 0;
+                        // discord.js names these countDetails and burstColors. The snake_case
+                        // reads only ever matched raw API JSON, so super reactions never
+                        // showed in production; raw shapes still work as a fallback.
+                        const burstCount = reaction.countDetails?.burst || reaction.count_details?.burst || reaction.burst_count || 0;
                         const burst = burstCount > 0;
-                        const burstColors = Array.isArray(reaction.burst_colors) && reaction.burst_colors.length
-                            ? reaction.burst_colors.filter((c) => typeof c === 'string' && /^#[0-9a-fA-F]{3,8}$/.test(c))
+                        const rawBurstColors = reaction.burstColors ?? reaction.burst_colors;
+                        const burstColors = Array.isArray(rawBurstColors) && rawBurstColors.length
+                            ? rawBurstColors.filter((c) => typeof c === 'string' && /^#[0-9a-fA-F]{3,8}$/.test(c))
                             : [];
                         const title = burst
                             ? `${total} reactions (${burstCount} super)`
@@ -224,7 +240,9 @@ async function DiscordMessage({ message, context }) {
                         return ((0, jsx_runtime_1.jsx)("discord-reaction", {
                             name: reaction.emoji?.name || ':unknown:',
                             emoji: (0, utils_1.parseDiscordEmoji)(reaction.emoji) || undefined,
-                            count: abbrCount(total),
+                            // <discord-reaction> declares `count` as a Number and renders
+                            // it as one: an abbreviated "1.5K" showed up as NaN.
+                            count: total,
                             title,
                             "data-burst": burst ? 'true' : undefined,
                             className: burst ? 'dht-reaction--burst' : undefined,
@@ -236,7 +254,7 @@ async function DiscordMessage({ message, context }) {
             ]
         }, message.id));
     } catch (err) {
-        console.warn('[discord-html-transcripts-fix] Render failed', message?.id, err?.message || err);
+        console.warn('[discord-html-transcripts-fix] Render failed', message?.id, err);
         const safeAuthor = (message?.author?.displayName || message?.author?.username) || 'Unknown';
         return ((0, jsx_runtime_1.jsx)("discord-message", { id: `m-${message?.id}`, children: (0, jsx_runtime_1.jsx)("span", { style: { opacity: 0.6 }, children: `[message from ${safeAuthor} failed to render]` }) }, message?.id));
     }
@@ -321,7 +339,8 @@ function renderVoiceIndicator(message, context) {
             if (typeof a.contentType === 'string' && a.contentType.startsWith('audio/')) { audio = a; break; }
         }
     }
-    const duration = audio?.duration_secs || audio?.durationSecs;
+    // discord.js exposes the raw `duration_secs` as `duration`.
+    const duration = audio?.duration || audio?.duration_secs || audio?.durationSecs;
     const waveformB64 = audio?.waveform;
     let waveformRects = null;
     let waveformWidth = 0;
@@ -360,18 +379,29 @@ function toArray(maybeColl) {
     return [];
 }
 
-function renderSnapshots(snapshots, context, depth = 0) {
+function renderSnapshots(snapshots, context, depth = 0, source = null) {
     const arr = toArray(snapshots);
     if (arr.length === 0 || depth >= 5) return null; // hard-cap at 5 levels
     return (0, jsx_runtime_1.jsx)("div", {
         className: "dht-forwarded-wrap",
         children: arr.map((snap, i) => {
             const m = snap.message || snap;
-            const author = m?.author?.displayName || m?.author?.username || 'Unknown';
+            // Discord deliberately hides who wrote a forwarded message, and the API
+            // snapshot has no author. discord.js still builds each snapshot in the
+            // source channel's message cache, so when the bot has the original
+            // cached, the snapshot IS the original — author included, even from
+            // another server. Only plain-object input, whose author the caller
+            // supplied on purpose, may name one.
+            const fromLibrary = (0, utils_1.isLibraryStructure)(m);
+            const author = fromLibrary ? null : (m?.author?.displayName || m?.author?.username || null);
+            const origin = author || source;
             const text = m?.content || '';
             const attachments = toArray(m?.attachments);
             const nested = toArray(m?.messageSnapshots);
             const embeds = toArray(m?.embeds);
+            // Raw component shapes are not what the component renderer is written
+            // for, so plain-object input keeps showing only what it showed before.
+            const components = fromLibrary ? toArray(m?.components) : [];
             const stickers = toArray(m?.stickers).map((s) => ({
                 id: s.id,
                 name: s.name,
@@ -381,11 +411,19 @@ function renderSnapshots(snapshots, context, depth = 0) {
             return (0, jsx_runtime_1.jsxs)("div", { className: "dht-forwarded", "data-depth": depth, children: [
                 (0, jsx_runtime_1.jsxs)("div", { className: "dht-forwarded-head", children: [
                     (0, jsx_runtime_1.jsx)("span", { className: "dht-forwarded-icon", children: '↪' }),
-                    (0, jsx_runtime_1.jsx)("span", { "data-i18n": "forwardedFrom", children: t(context, 'forwardedFrom', 'Forwarded from') }),
-                    (0, jsx_runtime_1.jsx)("strong", { children: ' ' + author }),
+                    // Without a known origin just say "Forwarded" rather than an
+                    // unlocalised "Forwarded from Unknown".
+                    origin
+                        ? (0, jsx_runtime_1.jsx)("span", { "data-i18n": "forwardedFrom", children: t(context, 'forwardedFrom', 'Forwarded from') })
+                        : (0, jsx_runtime_1.jsx)("span", { "data-i18n": "forwardedMessage", children: t(context, 'forwardedMessage', 'Forwarded') }),
+                    origin && (0, jsx_runtime_1.jsx)("strong", { children: ' ' + origin }),
                 ] }),
                 text && (0, jsx_runtime_1.jsx)("div", { className: "dht-forwarded-body", children: (0, jsx_runtime_1.jsx)(content_1.default, { content: text, context: Object.assign({}, context, { type: content_1.RenderType.NORMAL }) }) }),
-                attachments.length > 0 && (0, jsx_runtime_1.jsxs)("div", { className: "dht-forwarded-attachments", children: [
+                // discord.js attachments take the same path as a message's own, so
+                // saveImages and a custom resolveImageSrc archive forwarded images too
+                // instead of leaving them on Discord's expiring CDN links.
+                fromLibrary && attachments.length > 0 && (0, jsx_runtime_1.jsx)("div", { className: "dht-forwarded-media", children: (0, jsx_runtime_1.jsx)(attachment_1.Attachments, { message: m, context: context }) }),
+                !fromLibrary && attachments.length > 0 && (0, jsx_runtime_1.jsxs)("div", { className: "dht-forwarded-attachments", children: [
                     (0, jsx_runtime_1.jsxs)("strong", { children: ['📎 ', attachments.length, ' attachment', attachments.length !== 1 ? 's' : '', ':'] }),
                     (0, jsx_runtime_1.jsx)("ul", { children: attachments.map((a, ai) => {
                         const safeUrl = (0, utils_1.safeHref)(a.url);
@@ -397,7 +435,10 @@ function renderSnapshots(snapshots, context, depth = 0) {
                     }) })
                 ] }),
                 stickers.length > 0 && renderStickers(stickers),
-                embeds.length > 0 && (0, jsx_runtime_1.jsxs)("div", { className: "dht-forwarded-embeds", children: ['📑 ', embeds.length, ' embed', embeds.length !== 1 ? 's' : ''] }),
+                // Forwarded embeds and components render in full, like Discord shows them.
+                fromLibrary && embeds.length > 0 && (0, jsx_runtime_1.jsx)("div", { className: "dht-forwarded-media", children: embeds.map((embed, ei) => (0, jsx_runtime_1.jsx)(embed_1.DiscordEmbed, { embed: embed, context: Object.assign({}, context, { index: ei, message: m }) }, ei)) }),
+                !fromLibrary && embeds.length > 0 && (0, jsx_runtime_1.jsxs)("div", { className: "dht-forwarded-embeds", children: ['📑 ', embeds.length, ' embed', embeds.length !== 1 ? 's' : ''] }),
+                components.length > 0 && (0, jsx_runtime_1.jsx)("div", { className: "dht-forwarded-media", children: (0, jsx_runtime_1.jsx)("discord-attachments", { children: components.map((component, ci) => (0, jsx_runtime_1.jsx)(components_1.default, { id: ci, component: component, context: context }, ci)) }) }),
                 nested.length > 0 && renderSnapshots(nested, context, depth + 1),
             ] }, i);
         })
@@ -415,8 +456,7 @@ const FLAG_IS_COMPONENTS_V2 = 1 << 15;
 // Walks message.embeds and message.components to determine whether the message
 // carries media or V2 containers — used to drive the filter checkboxes
 // (data-has-image, data-has-attachment, data-has-embed, data-has-component-v2).
-function detectMediaFlags(message) {
-    const out = { hasImage: false, hasAttachment: false, hasEmbed: false, hasComponentV2: false };
+function detectMediaFlags(message, out = { hasImage: false, hasAttachment: false, hasEmbed: false, hasComponentV2: false }, depth = 0) {
 
     // Direct attachments
     if (message.attachments && typeof message.attachments.values === 'function') {
@@ -472,6 +512,14 @@ function detectMediaFlags(message) {
     };
     if (Array.isArray(message.components)) for (const c of message.components) walk(c);
 
+    // What a forward carries counts for the "has image/attachment/embed" filters too.
+    if (depth < 5) {
+        for (const snap of toArray(message.messageSnapshots)) {
+            const inner = snap?.message || snap;
+            if (inner) detectMediaFlags(inner, out, depth + 1);
+        }
+    }
+
     return out;
 }
 

package/dist/generator/renderers/reply.js

@@ -8,6 +8,7 @@ exports.default = MessageReply;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const discord_js_1 = require("discord.js");
 const content_1 = __importStar(require("./content"));
+const utils_1 = require("../../utils/utils");
 
 function t(context, key, fallback) {
     const dict = context?.i18n?.[context?.lang] || context?.i18n?.en || {};
@@ -15,7 +16,10 @@ function t(context, key, fallback) {
 }
 
 async function MessageReply({ message, context }) {
-    if (!message.reference) return null;
+    // A forward carries a message reference too (type Forward). It is rendered from
+    // its snapshots, not as a reply; treating it as one put a "Message could not be
+    // loaded." reply bar on every forwarded message.
+    if (!message.reference || (0, utils_1.isForwardMessage)(message)) return null;
 
     const isCrossGuild = message.reference.guildId !== message.guild?.id;
 
@@ -32,16 +36,22 @@ async function MessageReply({ message, context }) {
     if (!referencedMessage)
         return (0, jsx_runtime_1.jsx)("discord-reply", { slot: "reply", children: "Message could not be loaded." });
 
-    const isCrossPost = referencedMessage.reference && referencedMessage.reference.guildId !== message.guild?.id;
+    const isCrossPost = referencedMessage.reference && !(0, utils_1.isForwardMessage)(referencedMessage) && referencedMessage.reference.guildId !== message.guild?.id;
     const isCommand = !!referencedMessage.interaction;
     // Special-case: replying to a forwarded-only / Components-V2-only message has empty content
     const hasContent = !!referencedMessage.content;
-    const hasSnapshot = Array.isArray(referencedMessage.messageSnapshots) && referencedMessage.messageSnapshots.length > 0;
+    // messageSnapshots is a discord.js Collection (size), not an array (length).
+    // discord.js before 14.16 has none at all; the forward flag still says what it is.
+    const snapshotCount = referencedMessage.messageSnapshots?.size ?? referencedMessage.messageSnapshots?.length ?? 0;
+    const hasSnapshot = snapshotCount > 0 || (0, utils_1.isForwardMessage)(referencedMessage);
     const hasComponents = Array.isArray(referencedMessage.components) && referencedMessage.components.length > 0;
     const hasSticker = referencedMessage.stickers?.size > 0;
     const author = referencedMessage.member?.nickname ?? referencedMessage.author.displayName ?? referencedMessage.author.username;
     const avatar = referencedMessage.author.avatarURL?.({ size: 32 }) ?? undefined;
-    const roleColor = referencedMessage.member?.displayHexColor ?? undefined;
+    // displayHexColor is '#000000' for members without a colored role; passed on,
+    // that would paint the name black on the dark background.
+    const memberHex = referencedMessage.member?.displayHexColor;
+    const roleColor = memberHex && memberHex !== '#000000' ? memberHex : undefined;
     const op = referencedMessage.author.id === message?.channel?.ownerId && message?.channel?.isThread?.();
 
     return ((0, jsx_runtime_1.jsx)("discord-reply", {
@@ -50,7 +60,10 @@ async function MessageReply({ message, context }) {
         attachment: referencedMessage.attachments.size > 0,
         author: author,
         avatar: avatar,
-        roleColor: roleColor,
+        // Props become HTML attributes, whose names HTML lowercases: `roleColor`
+        // arrived as `rolecolor`, which the component does not observe, so reply
+        // authors never got their role color.
+        "role-color": roleColor,
         bot: !isCrossPost && referencedMessage.author.bot,
         verified: referencedMessage.author.flags?.has?.(discord_js_1.UserFlags.VerifiedBot),
         op: op,

package/dist/generator/renderers/systemMessage.js

@@ -6,6 +6,7 @@ exports.JoinMessage = JoinMessage;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const discord_js_1 = require("discord.js");
 const utils_1 = require("../../utils/utils");
+const content_1 = require("./content");
 
 function t(context, key, fallback) {
     const dict = context?.i18n?.[context?.lang] || context?.i18n?.en || {};
@@ -145,14 +146,19 @@ async function SystemMessage({ message, context }) {
             const matchedKeyword = fields.find((f) => /matched_keyword|keyword/i.test(f.name))?.value || '';
             const action = fields.find((f) => /action_type|action/i.test(f.name))?.value || '';
             const blocked = e?.description || '';
-            const channelId = fields.find((f) => /channel/i.test(f.name))?.value;
+            const channelField = fields.find((f) => /channel/i.test(f.name))?.value;
+            // A bare id in today's payloads; tolerate the <#id> mention form as well.
+            const channelId = channelField ? String(channelField).match(/\d{17,20}/)?.[0] ?? String(channelField) : null;
+            // The raw `<#id>` mention syntax used to be printed verbatim; name the
+            // channel when this server knows it.
+            const automodChannel = channelId ? message.guild?.channels?.cache?.get(channelId) : null;
             return ((0, jsx_runtime_1.jsxs)("discord-system-message", { id: `m-${message.id}`, timestamp: ts, type: "boost", children: [
                 (0, jsx_runtime_1.jsx)("span", { "data-i18n": "autoModBlocked", children: t(ctx, 'autoModBlocked', 'AutoMod blocked a message.') }),
                 ruleName && (0, jsx_runtime_1.jsxs)("span", { className: "dht-automod-rule", children: [' · Rule: ', (0, jsx_runtime_1.jsx)("strong", { children: ruleName })] }),
                 action && (0, jsx_runtime_1.jsxs)("span", { className: "dht-automod-rule", children: [' · Action: ', action] }),
                 matchedKeyword && (0, jsx_runtime_1.jsxs)("span", { className: "dht-automod-rule", children: [' · Matched: ', (0, jsx_runtime_1.jsx)("code", { children: matchedKeyword })] }),
                 blocked && (0, jsx_runtime_1.jsx)("blockquote", { className: "dht-automod-content", children: blocked }),
-                channelId && (0, jsx_runtime_1.jsxs)("span", { className: "dht-automod-rule", children: [' · In <#', channelId, '>'] }),
+                channelId && (0, jsx_runtime_1.jsxs)("span", { className: "dht-automod-rule", children: [' · In #', automodChannel?.name || channelId] }),
             ] }, message.id));
         }
         case discord_js_1.MessageType.StageStart:
@@ -213,8 +219,17 @@ async function SystemMessage({ message, context }) {
         case discord_js_1.MessageType.Reply:
             return undefined;
 
-        default:
-            return undefined;
+        // A type without its own wording here — Server Discovery notices, invite
+        // reminders, premium upsells, purchase notifications, or anything Discord adds
+        // later. Dropping it left a silent gap in the record; a neutral line keeps it,
+        // with whatever text Discord sent, and names the type on hover.
+        default: {
+            const typeName = typeof discord_js_1.MessageType[message.type] === 'string' ? discord_js_1.MessageType[message.type] : null;
+            return ((0, jsx_runtime_1.jsxs)("discord-system-message", { id: `m-${message.id}`, timestamp: ts, type: "alert", title: typeName ? `${typeName} (${message.type})` : `type ${message.type}`, "data-system-type": message.type, children: [
+                (0, jsx_runtime_1.jsx)("span", { "data-i18n": "systemMessage", children: t(ctx, 'systemMessage', 'System message') }),
+                message.content && (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [': ', (0, jsx_runtime_1.jsx)(content_1.default, { content: message.content, context: Object.assign({}, ctx, { type: content_1.RenderType.NORMAL }) })] }),
+            ] }, message.id));
+        }
     }
 }
 

package/dist/index.js

@@ -85,6 +85,13 @@ async function generateFromMessages(messages, channel, options = {}) {
         hydrate: options.hydrate ?? false,
         language: options.language ?? 'en',
         i18n: options.i18n ?? undefined,
+        // These four were missing from this hand-maintained list when they were
+        // introduced, so the public API silently dropped them and only the
+        // defaults ever applied. Anything the generator reads must be listed here.
+        dateFormat: options.dateFormat,
+        timeFormat: options.timeFormat,
+        inlineAssets: options.inlineAssets ?? false,
+        inlineAssetsTimeout: options.inlineAssetsTimeout,
         stream: options.returnType === 'stream' || options.stream === true,
         returnType: options.returnType,
     });

package/dist/static/client.js

@@ -75,9 +75,11 @@ const defaultDicts = {
         left: 'left.',
         autoModBlocked: 'AutoMod blocked a message.',
         serverAlert: 'Server safety alert.',
+        systemMessage: 'System message',
         pollEnded: 'A poll ended.',
         roleSubPurchased: 'subscribed to {role}!',
         forwardedFrom: 'Forwarded from',
+        forwardUnavailable: 'Forwarded message is unavailable',
         searchPlaceholder: 'Search transcript…',
         ofMatches: 'of',
         noMatches: 'no matches',
@@ -86,6 +88,9 @@ const defaultDicts = {
         statsMessages: '{n} messages',
         statsParticipants: '{n} participants',
         statsImages: '{n} images',
+        statsMessage: '{n} message',
+        statsParticipant: '{n} participant',
+        statsImage: '{n} image',
         crossServerReply: 'Message from another server',
         appBadge: 'APP',
         botBadge: 'BOT',
@@ -129,9 +134,11 @@ const defaultDicts = {
         left: 'hat den Channel verlassen.',
         autoModBlocked: 'AutoMod hat eine Nachricht blockiert.',
         serverAlert: 'Sicherheitswarnung.',
+        systemMessage: 'Systemnachricht',
         pollEnded: 'Eine Umfrage wurde beendet.',
         roleSubPurchased: 'hat {role} abonniert!',
         forwardedFrom: 'Weitergeleitet von',
+        forwardUnavailable: 'Weitergeleitete Nachricht ist nicht verfügbar',
         searchPlaceholder: 'Im Transcript suchen…',
         ofMatches: 'von',
         noMatches: 'keine Treffer',
@@ -140,6 +147,9 @@ const defaultDicts = {
         statsMessages: '{n} Nachrichten',
         statsParticipants: '{n} Teilnehmer',
         statsImages: '{n} Bilder',
+        statsMessage: '{n} Nachricht',
+        statsParticipant: '{n} Teilnehmer',
+        statsImage: '{n} Bild',
         crossServerReply: 'Nachricht von einem anderen Server',
         appBadge: 'APP',
         botBadge: 'BOT',

package/dist/types.d.ts

@@ -53,8 +53,9 @@ export type GenerateFromMessagesOptions<T extends ExportReturnType> = Partial<{
      */
     favicon: 'guild' | string;
     /**
-     * Whether to hydrate the html server-side
-     * @default false - the returned html will be hydrated client-side
+     * Adds the client-side script that reveals spoilers on click.
+     * The `<discord-*>` elements hydrate in the browser either way.
+     * @default false
      */
     hydrate: boolean;
     /**
@@ -71,15 +72,46 @@ export type GenerateFromMessagesOptions<T extends ExportReturnType> = Partial<{
         enabled?: boolean;
         template?: string;
     };
+    /**
+     * Embed the third-party assets the transcript would otherwise load from a CDN
+     * at view time — the `<discord-*>` web component runtime and the gg sans font
+     * (from jsDelivr) and the Twemoji SVGs (from cdnjs) — directly into the HTML.
+     *
+     * Without this the file needs internet access whenever it is *opened*: offline,
+     * behind a CDN-blocking network or after a CDN outage the transcript renders
+     * unstyled. It also means every viewer's IP reaches those CDNs, which may
+     * matter for GDPR-sensitive ticket archives.
+     *
+     * Costs roughly +890 kB per file and one download at generation time (cached
+     * per process, shared between concurrent exports). Discord's own CDN
+     * (cdn.discordapp.com, media.discordapp.net) is not a third-party CDN and stays
+     * in use: avatars always load from it, attachment images unless `saveImages` is
+     * set, and embed images, stickers and custom emoji.
+     *
+     * Never fails the export: if an asset cannot be fetched, the CDN reference is
+     * kept and a warning naming the cause is logged. Combined with a stream return
+     * type the document is buffered first, so streaming saves no memory then.
+     * @default false
+     */
+    inlineAssets: boolean;
+    /**
+     * Timeout in milliseconds for each download made by `inlineAssets`, including
+     * connection setup. A numeric string such as `'5000'` is accepted; anything
+     * that is not a positive whole number falls back to the default with a warning.
+     * @default 30000
+     */
+    inlineAssetsTimeout: number;
     /**
      * Date order used whenever a message timestamp is older than yesterday
-     * (e.g. `11/08/2026 07:16`).
+     * (e.g. `11/08/2026 07:16`). Matched case-insensitively; an unknown value falls
+     * back to the default with a one-time warning.
      * @default 'dd/mm/yyyy'
      */
     dateFormat: 'dd/mm/yyyy' | 'mm/dd/yyyy';
     /**
      * Clock format for message timestamps — `'24h'` renders `07:16`,
-     * `'12h'` renders `07:16 AM`.
+     * `'12h'` renders `07:16 AM`. Matched case-insensitively; an unknown value
+     * falls back to the default with a one-time warning.
      * @default '24h'
      */
     timeFormat: '24h' | '12h';

package/dist/utils/buildProfiles.js

@@ -4,6 +4,7 @@ exports.buildProfiles = buildProfiles;
 exports.buildExtendedContext = buildExtendedContext;
 exports.buildAllContext = buildAllContext;
 const discord_js_1 = require("discord.js");
+const utils_1 = require("./utils");
 
 /**
  * Backwards compatible: returns the profile dict used by <discord-mention> web components.
@@ -37,7 +38,8 @@ async function buildAllContext(messages, channel) {
         ? channel.guild
         : null;
 
-    const seenUserIds = new Set();
+    // id -> 'member' | 'bare': whether the entry was built from the guild member.
+    const userState = new Map();
     const seenRoleIds = new Set();
     const seenChannelIds = new Set();
 
@@ -73,12 +75,48 @@ async function buildAllContext(messages, channel) {
         };
     };
 
+    // Plain-object input may carry dates as strings; discord.js gives Dates.
+    const isoDate = (value) => {
+        const date = value instanceof Date ? value
+            : (typeof value === 'string' || typeof value === 'number') ? new Date(value) : null;
+        return date && !Number.isNaN(date.getTime()) ? date.toISOString() : null;
+    };
+
     const includeUser = (member, author) => {
-        if (!author) return;
-        const id = author.id;
-        if (seenUserIds.has(id)) return;
-        seenUserIds.add(id);
+        const id = author?.id;
+        if (!id) return;
+        // The first sighting must not decide: a user seen first without their
+        // member (a mention, a command, a forward) would otherwise keep a profile
+        // without nickname, roles and color for the whole transcript.
+        const state = userState.get(id);
+        if (state === 'member' || (state === 'bare' && !member)) return;
+        userState.set(id, member ? 'member' : 'bare');
+        try {
+            buildUser(id, member, author);
+            return;
+        }
+        catch (err) {
+            // One malformed user must not cost every other profile in the transcript.
+            console.warn(`[discord-html-transcripts-fix] could not build the profile of user ${id}${member ? ' from their guild member' : ''}:`, err);
+        }
+        // A broken member — discord.js' role getters throw when the @everyone role
+        // is not cached, for one — still leaves the user's own name and avatar.
+        if (member && !profiles[id]) {
+            try {
+                buildUser(id, null, author);
+            }
+            catch (err) {
+                console.warn(`[discord-html-transcripts-fix] could not build the profile of user ${id}:`, err);
+            }
+        }
+    };
 
+    // discord.js gives a method; a user serialised with toJSON() carries the URL itself.
+    const avatarOf = (subject, size) => typeof subject?.displayAvatarURL === 'function'
+        ? subject.displayAvatarURL({ size, forceStatic: true })
+        : (typeof subject?.displayAvatarURL === 'string' ? subject.displayAvatarURL : undefined);
+
+    const buildUser = (id, member, author) => {
         // Compute member roles first so we can derive the name color from the
         // highest *listed* role (top of the role list), matching how Discord
         // colors usernames. Falls back to displayHexColor (highest *colored*
@@ -103,9 +141,9 @@ async function buildAllContext(messages, channel) {
         // whose hash still carries the `a_` prefix). The static variant (.webp
         // or .png) always works, so render avatars as static in transcripts.
         // Avatars in a historical archive don't gain much from being animated.
-        profiles[id] = {
+        const profile = {
             author: member?.nickname ?? author.displayName ?? author.username,
-            avatar: member?.displayAvatarURL?.({ size: 64, forceStatic: true }) ?? author.displayAvatarURL?.({ size: 64, forceStatic: true }),
+            avatar: avatarOf(member, 64) ?? avatarOf(author, 64),
             roleColor: effectiveColor,
             roleIcon: member?.roles?.icon?.iconURL?.() ?? undefined,
             roleName: member?.roles?.hoist?.name ?? undefined,
@@ -125,19 +163,19 @@ async function buildAllContext(messages, channel) {
             }
         }
 
-        users[id] = {
+        const user = {
             id,
             username: author.username,
             displayName: member?.nickname || author.displayName || author.username,
             globalName: author.globalName || null,
-            avatar: member?.displayAvatarURL?.({ size: 128, forceStatic: true }) || author.displayAvatarURL?.({ size: 128, forceStatic: true }) || null,
+            avatar: avatarOf(member, 128) || avatarOf(author, 128) || null,
             bannerColor: effectiveColor,
             bot: !!author.bot,
             system: !!author.system,
             verifiedBot: flagNames.includes('VerifiedBot'),
             flags: flagNames,
-            joinedAt: member?.joinedAt ? member.joinedAt.toISOString() : null,
-            createdAt: author.createdAt ? author.createdAt.toISOString() : null,
+            joinedAt: isoDate(member?.joinedAt),
+            createdAt: isoDate(author.createdAt),
             roles: memberRoles.map((r) => ({
                 id: r.id,
                 name: r.name,
@@ -148,9 +186,12 @@ async function buildAllContext(messages, channel) {
                 ? { name: memberRoles[0].name, color: memberRoles[0].hexColor }
                 : null,
         };
+        // Both at once, so a failure above never leaves half an entry behind.
+        profiles[id] = profile;
+        users[id] = user;
     };
 
-    for (const message of messages) {
+    const collect = (message) => {
         if (message.author) includeUser(message.member, message.author);
         if (message.interaction?.user) {
             // FIX: try to find a member object for this user from later messages (interaction user may have authored their own messages elsewhere).
@@ -174,11 +215,28 @@ async function buildAllContext(messages, channel) {
                 for (const [cid] of message.mentions.channels) includeChannelFromGuild(cid);
             }
         }
-        // also include authors of forwarded snapshots
-        if (Array.isArray(message.messageSnapshots)) {
-            for (const snap of message.messageSnapshots) {
-                if (snap?.author) includeUser(null, snap.author);
-            }
+        // Authors of forwarded snapshots — from plain-object input only, exactly
+        // as the renderer names them. Discord hides who wrote a forward, and a
+        // discord.js snapshot of a message the bot has cached is that cached
+        // original, author included (see renderSnapshots).
+        // messageSnapshots is a discord.js Collection, not an array.
+        const snaps = message.messageSnapshots;
+        const snapList = !snaps ? [] : Array.isArray(snaps) ? snaps : typeof snaps.values === 'function' ? Array.from(snaps.values()) : [];
+        for (const snap of snapList) {
+            // Raw payloads nest the snapshot under `message`, like the renderer reads it.
+            const snapMessage = snap?.message || snap;
+            if (!snapMessage || (0, utils_1.isLibraryStructure)(snapMessage)) continue;
+            includeUser(null, snapMessage.author);
+        }
+    };
+
+    for (const message of messages) {
+        try {
+            collect(message);
+        }
+        catch (err) {
+            // A malformed message costs its own entries, not every profile.
+            console.warn('[discord-html-transcripts-fix] could not collect the profiles of message', message?.id, err);
         }
     }