gloomberb 0.17.2 → 0.17.3

package/src/market-data/market/freshness.ts

@@ -1,4 +1,4 @@
-import type { MarketState } from "../../types/financials";
+import type { MarketState, QuoteIndexSession } from "../../types/financials";
 import { canonicalExchange, EXCHANGE_TIME_ZONES, isUsListingExchange } from "../../utils/exchanges";
 import { hasPublishedApacCalendar, isPublishedApacClosure } from "../published-apac-sessions";
 import { hasPublishedCnCalendar, isPublishedCnClosure } from "../published-cn-sessions";
@@ -675,3 +675,27 @@ function isTimestampStaleForExchangeSessionUnsafe(
   }
   return false;
 }
+
+function readSessionWindow(value: unknown): { start: number; end: number } | null {
+  const { start, end } = (value ?? {}) as { start?: unknown; end?: unknown };
+  return typeof start === "number" && typeof end === "number" && Number.isFinite(start) && Number.isFinite(end) && end > start
+    ? { start, end }
+    : null;
+}
+
+/**
+ * The regular sessions an index quote carries, read without trusting the
+ * shape it arrived in: its zone, the session its day follows and the latest
+ * ones. Null when the zone or the current session is missing.
+ */
+export function readIndexSession(value: unknown): QuoteIndexSession | null {
+  const { timeZone, current, regular } = (value ?? {}) as { timeZone?: unknown; current?: unknown; regular?: unknown };
+  const now = readSessionWindow(current);
+  if (typeof timeZone !== "string" || !timeZone.includes("/") || !now) return null;
+  return {
+    timeZone,
+    current: now,
+    // The latest two: the one a print after the close belongs to, and the one before it.
+    regular: Array.isArray(regular) ? regular.flatMap((window) => readSessionWindow(window) ?? []).slice(-2) : [],
+  };
+}

package/src/market-data/quotes/regular-session-valuation.ts

@@ -1,4 +1,4 @@
-import type { Fundamentals, Quote, TickerFinancials } from "../../types/financials";
+import type { EnterpriseValueCheck, Fundamentals, Quote, TickerFinancials } from "../../types/financials";
 import { priceEarningsEps } from "../../utils/fundamentals";
 import { getRegularSessionDisplay } from "../market/status";
 
@@ -39,6 +39,33 @@ interface FigureMoves {
   enterpriseValue: number;
 }
 
+/**
+ * The served EV check at the moved figures, so its note reads the EV and the
+ * market cap the rows show: the EV it describes is the moved one, and the
+ * computed EV moves with the cap. A withdrawn EV, shown nowhere, moves with
+ * the cap as the computed one does. The status stays the one Gloom Cloud
+ * judged.
+ */
+function movedEnterpriseValueCheck(
+  check: EnterpriseValueCheck | undefined,
+  served: number | undefined,
+  enterpriseValue: number | undefined,
+  movedCap: number | undefined,
+): EnterpriseValueCheck | undefined {
+  if (!check || movedCap == null || !Number.isFinite(movedCap) || !Number.isFinite(check.marketCap)) return check;
+  const shift = movedCap - check.marketCap;
+  if (shift === 0 && served === enterpriseValue) return check;
+  const source = check.status !== "withdrawn" && served === check.source && enterpriseValue != null
+    ? enterpriseValue
+    : check.source + shift;
+  return {
+    ...check,
+    source,
+    marketCap: movedCap,
+    ...(check.computed != null && Number.isFinite(check.computed) ? { computed: check.computed + shift } : {}),
+  };
+}
+
 function moveFigures(fundamentals: Fundamentals, currency: string | undefined, moves: FigureMoves): Fundamentals {
   const cap = fundamentals.marketCapCurrency === currency ? fundamentals.marketCap : undefined;
   const movedCap = cap != null ? scaledAmount(cap, moves.marketCap) : undefined;
@@ -47,8 +74,12 @@ function moveFigures(fundamentals: Fundamentals, currency: string | undefined, m
   const enterpriseValue = served != null && Number.isFinite(served) && served !== 0 && movedCap != null && Number.isFinite(movedCap)
     ? Math.round(served + movedCap * (1 - 1 / moves.enterpriseValue)) : served;
   const enterpriseValueRatio = positive(served) && positive(enterpriseValue) ? enterpriseValue / served : null;
+  const check = fundamentals.enterpriseValueCheck?.currency === currency
+    ? movedEnterpriseValueCheck(fundamentals.enterpriseValueCheck, served, enterpriseValue, movedCap)
+    : fundamentals.enterpriseValueCheck;
   return {
     ...fundamentals,
+    ...(check ? { enterpriseValueCheck: check } : {}),
     trailingPE: scaled(fundamentals.trailingPE, moves.trailingPE),
     forwardPE: scaled(fundamentals.forwardPE, moves.forwardPE),
     dividendYield: scaled(fundamentals.dividendYield, 1 / moves.dividendYield),

package/src/market-data/quotes/resolution.ts

@@ -532,6 +532,8 @@ export function resolveCanonicalQuote(
     overnightChange: priceProvider?.overnightChange,
     overnightChangePercent: priceProvider?.overnightChangePercent,
     overnightPriceKind: priceProvider?.overnightPriceKind,
+    // An index's regular sessions come with the print they date.
+    indexSession: priceProvider?.indexSession,
     bid: resolved.bid as Quote["bid"],
     ask: resolved.ask as Quote["ask"],
     bidSize: resolved.bidSize as Quote["bidSize"],

package/src/plugins/builtin/account-management/pane.tsx

@@ -1019,19 +1019,23 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
                 />
               </Box>
               <Box flexDirection="row" gap={1}>
-                <Button
-                  label={t("Change Password")}
-                  active={activeField === "passwordAction"}
-                  onPress={openPasswordDialog}
-                  disabled={!!busy}
-                />
-                <Button
-                  label={busy === "delete" ? t("Deleting...") : t("Delete Account")}
-                  variant="danger"
-                  active={activeField === "deleteAccountAction"}
-                  onPress={() => { void deleteAccount(); }}
-                  disabled={!!busy}
-                />
+                <Box ref={fieldNodeRef("passwordAction")} flexDirection="row">
+                  <Button
+                    label={t("Change Password")}
+                    active={activeField === "passwordAction"}
+                    onPress={openPasswordDialog}
+                    disabled={!!busy}
+                  />
+                </Box>
+                <Box ref={fieldNodeRef("deleteAccountAction")} flexDirection="row">
+                  <Button
+                    label={busy === "delete" ? t("Deleting...") : t("Delete Account")}
+                    variant="danger"
+                    active={activeField === "deleteAccountAction"}
+                    onPress={() => { void deleteAccount(); }}
+                    disabled={!!busy}
+                  />
+                </Box>
               </Box>
             </>
           ) : null}

package/src/plugins/builtin/attention/headless.ts

@@ -1,6 +1,6 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchAttention } from "./client";
-import { ATTENTION_TABS, attentionTab, attentionWindow, attentionRows, WINDOWS } from "./model";
+import { ATTENTION_TABS, attentionPreviewNote, attentionTab, attentionWindow, attentionRows, emptyAttention, WINDOWS } from "./model";
 export const attentionHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "free-text", optional: true, placeholder: "TICKER", description: "Optional listing-qualified ticker, such as 6758:JPX." },
   options: [{ key: "tab", type: "enum", values: ATTENTION_TABS.map(({ value }) => ({ value })), defaultValue: "ranking", description: "Rankings, abnormal attention, groups, history or evidence." },
@@ -11,25 +11,34 @@ export const attentionHeadless: HeadlessPaneDefinition<"bundle"> = {
   async load(args, ctx) {
     const argument = Array.isArray(args.argument) ? args.argument.join(" ") : args.argument;
     const tab = attentionTab(args.options.tab);
-    const data = await fetchAttention(attentionWindow(args.options.window), argument?.trim().toUpperCase() || undefined, ctx.apiClient);
+    const window = attentionWindow(args.options.window);
+    const asked = argument?.trim().toUpperCase() || undefined;
+    let data = await fetchAttention(window, asked, ctx.apiClient);
+    // The free preview picks its rows before it looks the ticker up, so one outside them comes back empty: show the preview's own rows and say they are not the ticker's.
+    const outside = !!asked && data.entitlement === "preview" && !data.rows.length && data.counts.rows > 0;
+    if (outside) data = await fetchAttention(window, undefined, ctx.apiClient);
+    const note = attentionPreviewNote(data, asked, outside);
+    const lock = note ? { errors: [note] } : {};
+    // A board that has published nothing yet says so, whatever the plan.
+    const empty = data.status === "ready" ? {} : { empty: emptyAttention(data) };
     const metadata = { asOf: data.asOf, stale: data.stale, complete: data.status === "ready" && !data.truncated,
       status: data.status, periodStart: data.periodStart, periodEnd: data.periodEnd, entitlement: data.entitlement,
       privacy: data.privacy, coverage: data.coverage, methodologyUrl: data.methodologyUrl, selectedListing: data.selectedListing ?? null, historyEvidence: data.historyEvidence ?? null, unit: "rounded researcher-hours" };
     // Published hour by hour, so not a feed, but the service says when publication has fallen behind.
     const freshness = { status: data.stale ? "stale" as const : "not-a-feed" as const, basis: "hourly publication" };
-    if (tab === "sectors" || tab === "countries") return { metadata, freshness, sections: [{ title: tab === "sectors" ? "Sector attention" : "Country attention",
-      columns: [{ key: "name", header: "Group" }, { key: "researchUnits", header: "Research hours" }, { key: "sharePct", header: "Share %" }, { key: "tickers", header: "Tickers" }], rows: data[tab].map((row) => ({ ...row })) }] };
-    if (tab === "history") return { metadata, freshness, sections: [{ title: "Published hourly history", columns: [{ key: "symbol", header: "Ticker" },
+    if (tab === "sectors" || tab === "countries") return { metadata, freshness, ...lock, sections: [{ title: tab === "sectors" ? "Sector attention" : "Country attention",
+      columns: [{ key: "name", header: "Group" }, { key: "researchUnits", header: "Research hours" }, { key: "sharePct", header: "Share %" }, { key: "tickers", header: "Tickers" }], rows: data[tab].map((row) => ({ ...row })), ...empty }] };
+    if (tab === "history") return { metadata, freshness, ...lock, sections: [{ title: "Published hourly history", columns: [{ key: "symbol", header: "Ticker" },
       { key: "bucketStart", header: "Hour (UTC)" }, { key: "researchUnits", header: "Research hours" }],
-      rows: data.history && data.selectedListing ? data.history.map((point) => ({ symbol: data.selectedListing!.symbol, ...point })) : data.rows.flatMap((row) => row.history.map((point) => ({ symbol: row.symbol, ...point }))) }] };
-    if (tab === "evidence") return { metadata, freshness, sections: [{ title: "Publication evidence", columns: [{ key: "symbol", header: "Ticker" },
+      rows: data.history && data.selectedListing ? data.history.map((point) => ({ symbol: data.selectedListing!.symbol, ...point })) : data.rows.flatMap((row) => row.history.map((point) => ({ symbol: row.symbol, ...point }))), ...empty }] };
+    if (tab === "evidence") return { metadata, freshness, ...lock, sections: [{ title: "Publication evidence", columns: [{ key: "symbol", header: "Ticker" },
       { key: "periodStart", header: "Period start" }, { key: "periodEnd", header: "Period end" }, { key: "asOf", header: "Published" },
       { key: "confidence", header: "Quality" }, { key: "marketAsOf", header: "Market as of" }],
-      rows: data.rows.map((row) => ({ symbol: row.symbol, ...row.evidence, baselinePeriods: row.baselinePeriods, marketAsOf: row.marketAsOf, news: row.news })) }] };
-    return { metadata, freshness, sections: [{ title: tab === "abnormal" ? "Abnormal attention" : "Research ranking", columns: [
+      rows: data.rows.map((row) => ({ symbol: row.symbol, ...row.evidence, baselinePeriods: row.baselinePeriods, marketAsOf: row.marketAsOf, news: row.news })), ...empty }] };
+    return { metadata, freshness, ...lock, sections: [{ title: tab === "abnormal" ? "Abnormal attention" : "Research ranking", columns: [
       { key: "rank", header: "Rank" }, { key: "symbol", header: "Ticker" }, { key: "name", header: "Name" }, { key: "researchUnits", header: "Research hours" },
       { key: "sharePct", header: "Share %" }, { key: "zScore", header: "Latest-hour Z-score" }, { key: "priceChangePct", header: "Price %" },
       { key: "relativeVolume", header: "Relative volume" }, { key: "sector", header: "Sector" }, { key: "country", header: "Country" },
-    ], rows: attentionRows(data.rows, tab, "", tab === "abnormal" ? "zScore" : "rank", tab === "abnormal" ? "desc" : "asc").map((row) => ({ ...row })) }] };
+    ], rows: attentionRows(data.rows, tab, "", tab === "abnormal" ? "zScore" : "rank", tab === "abnormal" ? "desc" : "asc").map((row) => ({ ...row })), ...empty }] };
   },
 };

package/src/plugins/builtin/attention/model.ts

@@ -1,5 +1,6 @@
 import type { AttentionPayload, AttentionPoint, AttentionRow, AttentionWindow } from "../../../api-client/attention";
 import type { DataTableColumn } from "../../../components";
+import { countOf, freePreviewNote, previewCantFilter } from "../shared/free-preview";
 export const ATTENTION_TABS = [{ value: "ranking", label: "Ranking" }, { value: "abnormal", label: "Abnormal" },
   { value: "sectors", label: "Sectors" }, { value: "countries", label: "Countries" }, { value: "history", label: "History" }, { value: "evidence", label: "Evidence" }] as const;
 export type AttentionTab = typeof ATTENTION_TABS[number]["value"];
@@ -44,6 +45,27 @@ export function rowCell(row: AttentionRow, column: string) {
 export const emptyAttention = (data: AttentionPayload | null | undefined) => data?.status === "disabled"
   ? "Research attention collection is not enabled yet." : "Waiting for privacy-qualified research activity.";
 
+/** How many tickers the free preview lists: the top of the board by research hours. */
+const PREVIEW_ROWS = 3;
+
+/**
+ * What the free preview of the board shows and what Pro adds, for the lock
+ * line of `fn ATTN`. The server picks the preview's rows before it looks a
+ * ticker up, so a ticker outside them comes back empty and `outside` says the
+ * rows are the board's, not the ticker's. Null when there is nothing to
+ * preview, which includes a board still collecting.
+ */
+export function attentionPreviewNote(data: AttentionPayload, asked: string | undefined, outside: boolean): string | null {
+  if (data.entitlement !== "preview" || !data.rows.length) return null;
+  const total = Math.max(data.counts.rows, data.rows.length);
+  const listed = total > data.rows.length ? `${data.rows.length} of ${total.toLocaleString("en-US")} tickers` : countOf(data.rows.length, "ticker");
+  const shows = asked && outside ? `the top ${listed}, not ${asked}: ${previewCantFilter(["ticker"])}`
+    : asked ? `${data.rows[0]!.symbol}, one of the top ${PREVIEW_ROWS} of ${total.toLocaleString("en-US")} tickers, for the latest hour`
+      : `the top ${listed}, for the latest hour`;
+  const hidden = total - PREVIEW_ROWS;
+  return freePreviewNote({ shows, adds: `${hidden > 0 ? `the other ${hidden.toLocaleString("en-US")} tickers and ` : ""}hourly history for any ticker` });
+}
+
 /** An unpublished hour is a gap, never a measured zero or an interpolated count. */
 export function historyPoints(history: readonly AttentionPoint[]) {
   const points = [...history].sort((a, b) => a.bucketStart.localeCompare(b.bucketStart));

package/src/plugins/builtin/bond-calculator/pane.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useMemo, useRef, useState } from "react";
 import { Box, ScrollBox } from "../../../ui";
 import { DataTableView, FieldGrid, KeyValueRow, Notice, QueryBar, Section, usePaneNoticeFooter, usePaneTabs, type GridField, type SelectControl } from "../../../components";
+import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { usePaneSettingValue, usePaneStateValue, useShortcut } from "../../../public/react";
 import { useAsyncResource } from "../../../react/async-resource";
 import { colors } from "../../../theme/colors";
@@ -70,6 +71,7 @@ export function BondCalculatorPane({ focused, width, height }: PaneProps) {
   }, [result, draft.quote, update]);
   const selectTab = useCallback((value: string) => { setActiveField(null); setTab(value); }, [setTab]);
   const { strip: tabStrip, rows: tabRows } = usePaneTabs({ tabs: TABS, activeValue: tab, onSelect: selectTab, focused: focused && !activeField, dense: true });
+  usePaneRefreshKey(() => { void load(); }, { focused });
   useShortcut((event) => {
     if (event.defaultPrevented || event.propagationStopped || event.ctrl || event.alt || event.meta || event.super) return;
     const consume = () => { event.preventDefault(); event.stopPropagation(); };
@@ -77,7 +79,6 @@ export function BondCalculatorPane({ focused, width, height }: PaneProps) {
     // Shifted letters are global chords (Shift+R refreshes everything).
     if (event.targetEditable || event.shift) return;
     if (event.name === "e") { consume(); setTab("valuation"); setActiveField("settlement"); }
-    else if (event.name === "r") { consume(); void load(); }
     else if ((event.name === "j" || event.name === "k") && tab === "valuation") {
       consume();
       const index = activeField ? FIELDS.indexOf(activeField) : -1;

package/src/plugins/builtin/changelog/index.tsx

@@ -3,6 +3,7 @@ import { Box, TextAttributes, type ScrollBoxRenderable } from "../../../ui";
 import { usePaneInstance } from "../../../state/app/context";
 import {
   DataTableStackView,
+  PaneLinkMenu,
   PaneStatusBody,
   useExternalLinkFooter,
   type DataTableCell,
@@ -66,14 +67,16 @@ function ChangelogDetail({
 }) {
   // The stack title already carries the version.
   return (
-    <DetailReader
-      ref={scrollRef}
-      resetScrollKey={release.id}
-      width={width}
-      meta={[formatShortDate(release.publishedAt, { fallback: "" })]}
-      body={release.body}
-      bodyFormat="markdown"
-    />
+    <PaneLinkMenu>
+      <DetailReader
+        ref={scrollRef}
+        resetScrollKey={release.id}
+        width={width}
+        meta={[formatShortDate(release.publishedAt, { fallback: "" })]}
+        body={release.body}
+        bodyFormat="markdown"
+      />
+    </PaneLinkMenu>
   );
 }
 

package/src/plugins/builtin/chart-composer/editor/desktop-view.tsx

@@ -79,6 +79,7 @@ export function DesktopSeriesEditorFields({ fields }: { fields: SeriesEditorFiel
             <Box flexDirection="row" width="100%" style={{ gap: 6 }}>
               <Box flexGrow={1} minWidth={0}>
                 <SelectField
+                  label={field.label}
                   value={field.value}
                   options={field.options}
                   width="100%"
@@ -89,6 +90,7 @@ export function DesktopSeriesEditorFields({ fields }: { fields: SeriesEditorFiel
             </Box>
           ) : (
             <SelectField
+              label={field.label}
               value={field.value}
               options={field.options}
               width="100%"

package/src/plugins/builtin/chat/attachments/desktop.tsx

@@ -8,6 +8,7 @@ import { useThemeColors } from "../../../../theme/theme-context";
 import { t, tf } from "../../../../i18n";
 import type { ChatAttachment } from "../../../../api-client";
 import type { ChatDraftAttachment } from "../controller/attachments";
+import { chatPlainText } from "../markdown";
 import {
   CHAT_IMAGE_TYPES,
   chatImageReviewNote,
@@ -355,7 +356,7 @@ export function DesktopChatAttachmentStrip({
 }
 
 function imageAlt(index: number, count: number, caption: string, author: string): string {
-  const text = caption.replace(/\s+/g, " ").trim();
+  const text = chatPlainText(caption).replace(/\s+/g, " ").trim();
   const position = count > 1 ? ` ${index + 1} of ${count}` : "";
   if (text) return `Image${position}: ${text.length > 120 ? `${text.slice(0, 117)}...` : text}`;
   return `Image${position} from @${author}`;

package/src/plugins/builtin/chat/attachments/model.ts

@@ -1,5 +1,6 @@
 import { ApiRequestError } from "../../../../api-client/errors";
 import type { ChatAttachment, ChatMessage } from "../../../../api-client";
+import { chatPlainText } from "../markdown";
 
 /** What the server takes: four images a message, each up to 5 MB, as PNG, JPEG, WebP or GIF. */
 export const MAX_CHAT_IMAGES = 4;
@@ -76,10 +77,11 @@ function chatImageCountLabel(count: number): string {
   return count > 1 ? `[${count} images]` : "[image]";
 }
 
-/** A message read as one line: its images as a placeholder in front of the text. */
+/** A message read as one line, without its markdown: its images as a placeholder in front of the text. */
 export function chatTextWithImages(content: string, imageCount = 0): string {
-  if (imageCount <= 0) return content;
-  const text = content.trim();
+  const plain = chatPlainText(content);
+  if (imageCount <= 0) return plain;
+  const text = plain.trim();
   const placeholder = chatImageCountLabel(imageCount);
   return text ? `${placeholder} ${text}` : placeholder;
 }

package/src/plugins/builtin/chat/content/footer.tsx

@@ -278,6 +278,11 @@ export function useChatFooter({
     if (replyToId) {
       menu.push({ id: "original-message", label: "Go to Original Message", onSelect: () => latest.current.jumpToMessage(replyToId) });
     }
+    // The message as its author wrote it, markdown and all; a selection copies what the row draws.
+    const messageText = composing ? "" : selectedMessage?.content ?? "";
+    if (messageText) {
+      menu.push({ id: "copy-message", label: "Copy Message Text", onSelect: () => { void rendererHost.copyText(messageText); } });
+    }
     if (needsProfileSetup) {
       menu.push({ id: "profile-setup", label: "Set Up Profile", onSelect: () => latest.current.openProfileSetup() });
     }
@@ -302,6 +307,7 @@ export function useChatFooter({
     notificationsEnabled,
     openTargetTitle,
     openTargets.length,
+    rendererHost,
     replyToId,
     selectedIdx,
     selectedMessage,

package/src/plugins/builtin/chat/content/open-targets.ts

@@ -1,6 +1,6 @@
 import type { InlineTickerCatalogEntry } from "../../../../state/hooks/inline-tickers";
 import type { ChatAttachment } from "../../../../api-client";
-import { tokenizeInlineContent } from "../../../../utils/inline-content-tokenizer";
+import { chatMessageTokens } from "../markdown";
 import { chatImageLabel } from "../attachments/model";
 import { wirePaneTarget, type ChatMessagePaneLink } from "../pane-links/model";
 import { chatPaneLinkPane, peekSharePreview } from "../pane-links/previews";
@@ -26,7 +26,8 @@ function paneLinkLabel(link: ChatMessagePaneLink): string {
  * What a message lets you open, in reading order: its chips (the panes its
  * share links and Wire link open), the ticker badges its text draws (a symbol
  * the catalog does not know stays plain text), its links, then its images.
- * `content` is the text the message draws, without the links its chips stand for.
+ * `content` is the text the message draws, without the links its chips stand
+ * for. Code is text, so nothing in it is offered.
  */
 export function chatMessageOpenTargets(
   content: string,
@@ -36,7 +37,14 @@ export function chatMessageOpenTargets(
 ): ChatOpenTarget[] {
   const targets: ChatOpenTarget[] = paneLinks.map((link) => ({ kind: "pane", link, label: paneLinkLabel(link) }));
   const seen = new Set<string>();
-  for (const token of tokenizeInlineContent(content)) {
+  // The link just listed: a label with marks in it ("[the **keys**](url)") is several tokens of one link.
+  let open: Extract<ChatOpenTarget, { kind: "link" }> | null = null;
+  for (const token of chatMessageTokens(content)) {
+    if (token.kind === "link" && open?.url === token.url) {
+      open.label += token.value;
+      continue;
+    }
+    open = null;
     if (token.kind === "ticker") {
       const entry = catalog[token.symbol];
       if (!entry || entry.status === "missing" || seen.has(`ticker:${token.symbol}`)) continue;
@@ -44,7 +52,8 @@ export function chatMessageOpenTargets(
       targets.push({ kind: "ticker", symbol: token.symbol });
     } else if (token.kind === "link" && !seen.has(`link:${token.url}`)) {
       seen.add(`link:${token.url}`);
-      targets.push({ kind: "link", url: token.url, label: token.value });
+      open = { kind: "link", url: token.url, label: token.value };
+      targets.push(open);
     }
   }
   attachments.forEach((attachment, index) => {

package/src/plugins/builtin/chat/content/transcript.tsx

@@ -10,6 +10,7 @@ import { DesktopChatMessage, desktopChatMessageWidth } from "../message/desktop"
 import { UserProfilePopover } from "../message/profile-popover";
 import { TerminalChatMessage } from "../message/terminal";
 import { NewMessagesJump } from "./new-messages";
+import { useWholeMessageCopy } from "./whole-message-copy";
 
 interface MutableRef<T> {
   current: T;
@@ -138,6 +139,7 @@ export function ChatTranscript({
   useLayoutEffect(() => {
     takeBackScrollPlace();
   }, [takeBackScrollPlace]);
+  useWholeMessageCopy(nativePaneChrome === true, messages);
   const reactionProps = {
     reactionsEnabled,
     currentUserId: user?.id ?? null,

package/src/plugins/builtin/chat/content/whole-message-copy.ts

@@ -0,0 +1,70 @@
+import { useEffect, useRef } from "react";
+import type { ChatMessage } from "../../../../api-client";
+
+const BODY_SELECTOR = "[data-gloom-role=chat-message-body]";
+const MESSAGE_ID_ATTRIBUTE = "data-gloom-chat-message-id";
+
+/** Whether the selection takes in every character the body draws, first to last. */
+function coversBody(range: Range, body: Element): boolean {
+  const walker = body.ownerDocument.createTreeWalker(body, 4 /* NodeFilter.SHOW_TEXT */);
+  let first: [Node, number] | null = null;
+  let last: [Node, number] | null = null;
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    const text = node.textContent ?? "";
+    const start = text.search(/\S/);
+    if (start < 0) continue;
+    first ??= [node, start];
+    last = [node, text.trimEnd().length];
+  }
+  if (!first || !last) return false;
+  try {
+    return range.comparePoint(first[0], first[1]) === 0 && range.comparePoint(last[0], last[1]) === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * What a copy of the selection puts on the clipboard when it takes in whole
+ * messages of this list: each as it was written, marks and all, one per line.
+ * Null when it takes in part of a message, which copies as drawn, or anything
+ * outside this list's messages.
+ */
+function wholeMessagesText(doc: Document, messages: readonly ChatMessage[]): string | null {
+  const selection = doc.getSelection();
+  if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return null;
+  const range = selection.getRangeAt(0);
+  const bodies = Array.from(doc.querySelectorAll(BODY_SELECTOR)).filter((body) => range.intersectsNode(body));
+  if (bodies.length === 0) return null;
+  const parts: string[] = [];
+  for (const body of bodies) {
+    const id = body.closest(`[${MESSAGE_ID_ATTRIBUTE}]`)?.getAttribute(MESSAGE_ID_ATTRIBUTE);
+    const message = id ? messages.find((candidate) => candidate.id === id) : undefined;
+    if (!message || !coversBody(range, body)) return null;
+    parts.push(message.content);
+  }
+  return parts.join("\n");
+}
+
+/**
+ * Desktop and web: copying whole messages copies what their authors wrote,
+ * markdown and share links included, not the text as drawn. Copying part of a
+ * message copies what it shows.
+ */
+export function useWholeMessageCopy(enabled: boolean, messages: readonly ChatMessage[]): void {
+  const messagesRef = useRef(messages);
+  messagesRef.current = messages;
+  useEffect(() => {
+    const doc = (globalThis as { document?: Document }).document;
+    if (!enabled || !doc) return;
+    const onCopy = (event: ClipboardEvent) => {
+      if (event.defaultPrevented || !event.clipboardData) return;
+      const text = wholeMessagesText(doc, messagesRef.current);
+      if (text === null) return;
+      event.clipboardData.setData("text/plain", text);
+      event.preventDefault();
+    };
+    doc.addEventListener("copy", onCopy);
+    return () => doc.removeEventListener("copy", onCopy);
+  }, [enabled]);
+}