gloomberb 0.17.2 → 0.17.4

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/calendar-tab.tsx

@@ -165,7 +165,7 @@ export function CalendarAccountTab({ width, sessionMarker }: { width: number; se
       <EmptyState
         status="error"
         title={loadError}
-        actions={<Button label={t("Retry")} onPress={() => { void load(); }} />}
+        retry={{ onRetry: () => load(), pending: loading }}
       />
     );
   }

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/alerts/cli.ts

@@ -2,12 +2,14 @@ import { withConfigData, withMarketData } from "../../../cli/scoped-context";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
 import { requireArg, takeOption } from "../../../cli/commands/command-utils";
-import { EXCHANGE_OPTION, listingReadNotes, requireListingArg } from "../../../cli/listing-arg";
+import { EXCHANGE_OPTION, listingReadNotes, requireListingArg, type ListingArg } from "../../../cli/listing-arg";
 import { saveConfig } from "../../../data/config/store";
 import type { AppConfig } from "../../../types/config";
-import type { CliCommandDef } from "../../../types/plugin";
+import type { CliCommandContext, CliCommandDef } from "../../../types/plugin";
+import { getActiveQuoteDisplay } from "../../../market-data/market/status";
+import { settleWithin } from "../../../utils/async-deadline";
 import { cliStyles } from "../../../utils/cli-output";
-import { ambiguousNumberMessage, parsePastedNumber } from "../../../utils/decimal-comma";
+import { ambiguousNumberMessage, meantThousandsDot, parsePastedNumber, thousandsDotReadings, type ThousandsDotReadings } from "../../../utils/decimal-comma";
 import { newYorkToday } from "../earnings/board-model";
 import { createAlert, deserializeAlerts, rearmAlert, serializeAlerts } from "./alert-engine";
 import { ALERTS_KEY } from "./constants";
@@ -43,20 +45,28 @@ const DAYS_RULE = `--days takes a whole number of days from 1 to ${MAX_LEAD_DAYS
 
 /** What `alerts add` was asked for, before any listing or date is looked up. */
 export type AlertAddRequest =
-  | { kind: "price"; symbol: string; condition: AlertCondition; price: number }
+  | {
+    kind: "price"; symbol: string; condition: AlertCondition; price: number;
+    /** A price typed as 81.000, which the last price may show was 81000 with a dot between thousands. */
+    thousandsDot?: ThousandsDotReadings & { text: string };
+  }
   | { kind: "earnings"; symbol: string; leadDays: number }
   | { kind: "macro"; event: MacroAlertEvent; leadDays: number };
 
 const CONDITIONS: readonly AlertCondition[] = ["above", "below", "crosses"];
 
+/** The first word of a price typed with a space between thousands and no quotes (`81 000`): one to three digits. */
+const LEADING_GROUP = /^[+-]?\d{1,3}$/;
+
 /**
  * Reads `alerts add` arguments: `<symbol> above 250`, `<symbol> earnings`, or
  * `CPI` / `FOMC`, with `--days` (already taken out of `args`, `null` when the
- * flag came without a value) for the event forms only. Throws a message that
- * names what the command takes.
+ * flag came without a value) for the event forms only, and `--exchange`, which
+ * a command to type again keeps. Throws a message that names what the command
+ * takes.
  */
-export function parseAlertAddArgs(args: readonly string[], days: string | null | undefined): AlertAddRequest {
-  const [first, second, third] = args;
+export function parseAlertAddArgs(args: readonly string[], days: string | null | undefined, exchange?: string | null): AlertAddRequest {
+  const [first, second, third, ...rest] = args;
   if (!first) throw new Error(ADD_USAGE);
   const leadDays = () => {
     const parsed = days === null ? null : parseLeadDays(days);
@@ -83,11 +93,57 @@ export function parseAlertAddArgs(args: readonly string[], days: string | null |
   }
   if (days !== undefined) throw new Error("--days is for earnings and CPI or FOMC alerts, not price alerts.");
   if (third === undefined) throw new Error(ADD_USAGE);
+  const retype = (price: number) => retypeCommand(first, condition, price, exchange);
+  // `81 000` without quotes arrives as 81 and a stray 000; neither reading is taken for granted.
+  const spaced = rest.length > 0 && LEADING_GROUP.test(third) ? parsePastedNumber([third, ...rest].join(" ")) : null;
+  if (spaced?.kind === "number") {
+    const typed = Number(third);
+    throw new Error(`${[third, ...rest].join(" ")} could be ${spaced.value} (thousands) or ${typed} and a stray ${rest.join(" ")}; type ${retype(spaced.value)} or ${retype(typed)}`);
+  }
   // A price pasted from a sheet (1.350,5, 1,350.5, 1 350,5) reads as it is written; `1,350` could be either, so it asks.
   const pasted = parsePastedNumber(third);
   if (pasted.kind === "ambiguous") throw new Error(ambiguousNumberMessage(third, pasted));
   if (pasted.kind === "invalid") throw new Error("Alert price must be a finite number.");
-  return { kind: "price", symbol: first, condition, price: pasted.value };
+  if (rest.length > 0) throw new Error(`A price alert takes one price, not "${rest.join(" ")}" after ${third}; type ${retype(pasted.value)}`);
+  const thousandsDot = thousandsDotReadings(third);
+  return { kind: "price", symbol: first, condition, price: pasted.value, ...(thousandsDot ? { thousandsDot: { ...thousandsDot, text: third.trim() } } : {}) };
+}
+
+/** `alerts add` as typed, with another price: what an error tells someone to type. */
+function retypeCommand(symbol: string, condition: AlertCondition, price: number, exchange: string | null | undefined): string {
+  return `gloomberb alerts add ${symbol} ${condition} ${price}${exchange ? ` --exchange ${exchange}` : ""}`;
+}
+
+const LAST_PRICE_TIMEOUT_MS = 10_000;
+
+/**
+ * The listing's last price, as the alert will check it, for telling 81.000
+ * typed for 81000 from 81; null when there is none, and the price is then
+ * read as written.
+ */
+async function lastPrice(listing: ListingArg, ctx: Pick<CliCommandContext, "initMarketData">): Promise<number | null> {
+  const quote = await settleWithin(
+    withMarketData(ctx, (market) => market.dataProvider.getQuote(listing.key.toUpperCase(), listing.exchange)),
+    LAST_PRICE_TIMEOUT_MS,
+  );
+  const price = quote ? getActiveQuoteDisplay(quote)?.price ?? quote.price : null;
+  return price != null && Number.isFinite(price) && price !== 0 ? price : null;
+}
+
+/**
+ * Asks which price `81.000` meant when the last price shows it was a dot
+ * between thousands: both readings, and the command to type for each.
+ */
+export function thousandsDotMessage(
+  request: Extract<AlertAddRequest, { kind: "price" }>,
+  listing: string,
+  last: number | null,
+  exchange?: string | null,
+): string | null {
+  const dot = request.thousandsDot;
+  if (!dot || !meantThousandsDot(dot, last)) return null;
+  const retype = (price: number) => retypeCommand(request.symbol, request.condition, price, exchange);
+  return `${dot.text} could be ${dot.thousands} (thousands) or ${dot.decimal} (decimal point), and ${listing.toUpperCase()} last traded at ${Number(last!.toFixed(2))}; type ${retype(dot.thousands)} or ${retype(dot.decimal)}`;
 }
 
 /** One row of `alerts list`: a price alert as stored, or an event alert with its next date. */
@@ -222,13 +278,17 @@ export const alertsCliCommand: CliCommandDef = {
 
     const parseAdd = (): AlertAddRequest => {
       try {
-        return parseAlertAddArgs(args.slice(1), days);
+        return parseAlertAddArgs(args.slice(1), days, exchangeOption);
       } catch (error) {
         return ctx.fail(error instanceof Error ? error.message : String(error));
       }
     };
     const request = action === "add" ? parseAdd() : null;
     const priceListing = request?.kind === "price" ? await requireListingArg(request.symbol, exchangeOption, ctx) : null;
+    if (request?.kind === "price" && request.thousandsDot && priceListing) {
+      const question = thousandsDotMessage(request, priceListing.key, await lastPrice(priceListing, ctx), exchangeOption);
+      if (question) ctx.fail(question);
+    }
     // What a typed listing was read as (7203:TSE as 7203:JPX), said beside what was added.
     let read = priceListing ? listingReadNotes(priceListing) : [];
     let newEventRule: EventAlertRule | null = null;
@@ -309,7 +369,8 @@ export const alertsCliCommand: CliCommandDef = {
         const alert = createAlert(symbol, condition, price, priceListing?.exchange);
         await save({ alerts: [...alerts, alert] });
         ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert }, ...(read.length > 0 ? { warnings: read } : {}) }, {
-          text: (data) => `Added alert ${data.alert.id}: ${symbol} ${condition} ${price}.${dryRunNote(data.dryRun)}`,
+          // No full stop after the price, which would read as part of it (below 81.).
+          text: (data) => `Added alert ${data.alert.id}: ${symbol} ${condition} ${price}${dryRunNote(data.dryRun)}`,
         });
         return;
       }

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/awards/headless.ts

@@ -1,6 +1,7 @@
 import type { AwardFilter, AwardRow, AwardType } from "../../../api-client/awards";
 import { notATickerSymbol } from "../../../sources/provider-errors";
 import type { HeadlessBundleSection, HeadlessPaneColumn, HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/headless";
+import { isoDateOption } from "../../../utils/calendar-date";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { fetchAward, fetchAwards } from "./client";
 import { AWARD_TABS, awardScope, awardsPreviewNote, awardTypeLabel, futureAwardDatesNote, money } from "./model";
@@ -85,7 +86,10 @@ export const awardsHeadless: HeadlessPaneDefinition<"bundle"> = {
   options: [
     { key: "tab", type: "enum", settingKey: "tab", defaultValue: "feed", values: [...AWARD_TABS.map(({ value }) => ({ value })), { value: "all" }], description: "Feed, company history, agencies, sectors, events, or all sections." },
     { key: "view", type: "enum", settingKey: "leaderView", defaultValue: "companies", values: [{ value: "companies" }, { value: "sectors" }], description: "Sectors tab: company leaders or sector totals." },
-    ...["jurisdiction", "currency", "source", "agency", "sector", "parentId", "from", "to", "query"].map((key) => ({ key, type: "string" as const, settingKey: key, description: `Filter by ${key}; dates use YYYY-MM-DD.` })),
+    ...FILTER_KEYS.map((key) => key === "from" || key === "to"
+      ? { key, type: "string" as const, settingKey: key, placeholder: "YYYY-MM-DD", description: `${key === "from" ? "Start" : "End"} of the date range. Dates use YYYY-MM-DD.`,
+        normalize: (value: string) => isoDateOption(value, key) }
+      : { key, type: "string" as const, settingKey: key, description: `Filter by ${key}.` }),
     { key: "type", type: "enum", settingKey: "awardType", defaultValue: "prime", values: [{ value: "prime" }, { value: "subaward" }, { value: "notice" }, { value: "modification" }], description: "Keep record types separate." },
     { key: "cursor", type: "string", description: "Continue after the previous response's nextCursor." },
     { key: "limit", type: "integer", minimum: 1, maximum: 200, defaultValue: 100, description: "Maximum feed rows in this response." },

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/catalysts/headless.ts

@@ -1,5 +1,6 @@
 import { CATALYST_TYPES } from "../../../api-client/catalysts";
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
+import { isoDateOption } from "../../../utils/calendar-date";
 import { fetchCatalystDetail, fetchCatalysts } from "./client";
 import { catalystCell, catalystChangeText, catalystDate, catalystQuery, catalystTickers } from "./model";
 
@@ -11,7 +12,10 @@ function definition(litigation: boolean): HeadlessPaneDefinition<"bundle"> {
     options: [
       { key: "tab", type: "enum", values: [{ value: "calendar" }, { value: "changes" }], defaultValue: "calendar", description: "Dated events or observed revisions." },
       { key: "type", type: "enum", values: CATALYST_TYPES.map((value) => ({ value })), description: "Event type." },
-      ...["agency", "country", "sector", "status", "search", "from", "to"].map((key) => ({ key, type: "string" as const, description: `Filter by ${key}. Dates use YYYY-MM-DD.` })),
+      ...["agency", "country", "sector", "status"].map((key) => ({ key, type: "string" as const, description: `Filter by ${key}.` })),
+      { key: "search", type: "string", description: "Filter by text." },
+      { key: "from", type: "string", placeholder: "YYYY-MM-DD", description: "Start of the calendar window. Dates use YYYY-MM-DD.", normalize: (value) => isoDateOption(value, "from") },
+      { key: "to", type: "string", placeholder: "YYYY-MM-DD", description: "End of the calendar window. Dates use YYYY-MM-DD.", normalize: (value) => isoDateOption(value, "to") },
       { key: "dateField", type: "enum", values: ["any", "announced", "effective", "deadline", "observed"].map((value) => ({ value })), defaultValue: "any", description: "Date field for the calendar window." },
       { key: "upcoming", type: "boolean", defaultValue: false, description: "Only future effective dates and deadlines." },
       { key: "offset", type: "integer", defaultValue: 0, description: "Zero-based event offset." },

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,