gloomberb 0.11.0 → 0.11.2

package/src/plugins/builtin/alerts/quotes.ts

@@ -1,5 +1,6 @@
 import type { DataProvider } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
+import { getActiveQuoteDisplay } from "../../../market-data/market/status";
 import type { AlertRule } from "./types";
 
 export function normalizeAlertSymbol(value: string | null | undefined): string {
@@ -17,12 +18,19 @@ export function createQuoteErrorMessage(
 export async function resolveAlertQuote(
   marketData: Pick<DataProvider, "getQuote">,
   symbol: string,
+  exchange = "",
 ): Promise<Quote> {
-  const quote = await marketData.getQuote(symbol, "");
-  if (!quote || typeof quote.price !== "number" || !Number.isFinite(quote.price)) {
+  const quote = await marketData.getQuote(symbol, exchange);
+  const display = getActiveQuoteDisplay(quote);
+  if (!display || !Number.isFinite(display.price)) {
     throw new Error(`No quote found for "${symbol}".`);
   }
-  return quote;
+  return {
+    ...quote,
+    price: display.price,
+    change: display.change,
+    changePercent: display.changePercent,
+  };
 }
 
 export function quoteAlertFields(

package/src/plugins/builtin/alerts/types.ts

@@ -6,6 +6,7 @@ export type AlertStatus = "active" | "triggered" | "expired";
 export interface AlertRule {
   id: string;
   symbol: string;
+  exchange?: string;
   condition: AlertCondition;
   targetPrice: number;
   createdAt: number;

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

@@ -5,6 +5,7 @@ import { EmptyState, Tabs } from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
 import { colors } from "../../../theme/colors";
+import { convertCurrency } from "../../../utils/format";
 import {
   getFocusedCollectionId,
   useAppSelector,
@@ -212,8 +213,14 @@ function PortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
       activePortfolio,
       brokerPerformance: brokerPerformance.performance,
       portfolioStats,
+      convertAccountValue: (value) => convertCurrency(
+        value,
+        accountState?.account.currency || baseCurrency,
+        baseCurrency,
+        effectiveExchangeRates,
+      ),
     }),
-    [accountState, activePortfolio, brokerPerformance.performance, portfolioStats],
+    [accountState, activePortfolio, baseCurrency, brokerPerformance.performance, effectiveExchangeRates, portfolioStats],
   );
 
   const riskRows = useMemo(
@@ -340,6 +347,9 @@ export const portfolioAnalyticsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 80, height: 30 },
+      portableShare: {
+        private: { params: true, settings: true, state: true },
+      },
     },
   ],
 

package/src/plugins/builtin/analytics/pane-model.ts

@@ -142,23 +142,25 @@ export function buildAnalyticsSummaryRows({
   accountState,
   brokerPerformance,
   portfolioStats,
+  convertAccountValue = (value) => value,
 }: {
   accountState: ResolvedPortfolioAccountState | null;
   activePortfolio: Portfolio | null;
   brokerPerformance: BrokerPortfolioPerformance | null;
   portfolioStats: PortfolioSummaryTotals;
+  convertAccountValue?: (value: number) => number;
 }): AnalyticsMetricRow[] {
   const rows: AnalyticsMetricRow[] = [];
   const account = accountState?.account;
-  const accountMetrics = resolvePortfolioAccountMetrics(portfolioStats, account);
+  const accountMetrics = resolvePortfolioAccountMetrics(portfolioStats, account, convertAccountValue);
   const accountFreshness = formatAccountFreshness(account);
-  const totalMarketValue = resolvePortfolioMarketValue(portfolioStats, account);
+  const totalMarketValue = resolvePortfolioMarketValue(portfolioStats, account, convertAccountValue);
 
   if (account?.netLiquidation != null) {
     rows.push({
       id: "net-liquidation",
       label: "Net Liq",
-      value: formatCompact(account.netLiquidation),
+      value: formatCompact(convertAccountValue(account.netLiquidation)),
       color: colors.text,
     });
   }
@@ -184,7 +186,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "cash",
       label: "Cash",
-      value: formatCompact(account.totalCashValue),
+      value: formatCompact(convertAccountValue(account.totalCashValue)),
       color: colors.text,
     });
   }

package/src/plugins/builtin/broker-manager/index.tsx

@@ -307,6 +307,9 @@ export const brokerManagerModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 92, height: 24 },
+      portableShare: {
+        private: { title: true, params: true, settings: true, state: true },
+      },
     },
   ],
   paneTemplates: [

package/src/plugins/builtin/buildout/model/index.ts

@@ -122,7 +122,7 @@ export async function loadBuildoutData(token: string | null) {
 }
 
 export async function getBuildoutProToken() {
-  if (!apiClient.getSessionToken()) return null;
+  if (!apiClient.isSignedIn()) return null;
 
   const session = await apiClient.getSession().catch(() => null);
   if (!session) return null;

package/src/plugins/builtin/buildout/pane/index.tsx

@@ -4,6 +4,7 @@ import {
   DataTableStackView,
   EmptyState,
   Spinner,
+  useTableLoadMore,
   usePaneFooter,
   type DataTableKeyEvent,
   type PaneHint,
@@ -245,24 +246,22 @@ export function BuildoutPane({ focused, width, height }: PaneProps) {
     return true;
   }, [canFavorite, toggleFavorite]);
 
-  const loadMoreActiveRows = useCallback(() => {
-    if (state.status !== "ready") return;
-    const scrollBox = tableScrollRef.current;
-    if (!scrollBox?.viewport) return;
-    const page = activeBuildoutPage(state, activeTab, selectedList);
-    if (!page || page.loadingMore || !page.hasMore || page.error) return;
-    const visibleBottom = scrollBox.scrollTop + scrollBox.viewport.height;
-    const remaining = page.items.length - visibleBottom;
-    if (remaining > LOAD_MORE_THRESHOLD) return;
-
-    if (activeTab === "companies" && selectedList) {
-      void loadCompanies(selectedList, page.offset, true);
-    } else if (activeTab === "sites") {
-      void loadSites(page.offset, true);
-    } else if (activeTab === "intel") {
-      void loadIntel(page.offset, true);
-    }
-  }, [activeTab, loadCompanies, loadIntel, loadSites, selectedList, state]);
+  const activePage = state.status === "ready" ? activeBuildoutPage(state, activeTab, selectedList) : null;
+  const loadMoreActiveRows = useTableLoadMore(
+    tableScrollRef,
+    !!activePage && !activePage.loadingMore && !!activePage.hasMore && !activePage.error,
+    () => {
+      if (!activePage) return;
+      if (activeTab === "companies" && selectedList) {
+        void loadCompanies(selectedList, activePage.offset, true);
+      } else if (activeTab === "sites") {
+        void loadSites(activePage.offset, true);
+      } else if (activeTab === "intel") {
+        void loadIntel(activePage.offset, true);
+      }
+    },
+    LOAD_MORE_THRESHOLD,
+  );
 
   const handleRootKeyDown = useCallback((event: DataTableKeyEvent) => {
     if (event.name === "u" && state.status === "ready" && state.access !== "pro") {

package/src/plugins/builtin/cds/client.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudCdsResponse } from "../../../api-client";
+import type { InstrumentSearchResult } from "../../../types/instrument";
+import { loadCdsActivity } from "./client";
+
+function result(symbol: string, name: string): InstrumentSearchResult {
+  return { providerId: "gloomberb-cloud", symbol, name, exchange: "NYSE", type: "STK" };
+}
+
+const EMPTY_CDS: CloudCdsResponse = { source: "DTCC PPD", asOf: null, trades: [] };
+
+/** Records what the loader searched for and what it then asked the backend. */
+function spy(searchResults: InstrumentSearchResult[] | Error = []) {
+  const searched: string[] = [];
+  const requested: Array<string | undefined> = [];
+  return {
+    searched,
+    requested,
+    fetchCds: async (params: { issuer?: string }) => {
+      requested.push(params.issuer);
+      return EMPTY_CDS;
+    },
+    searchInstruments: async (query: string) => {
+      searched.push(query);
+      if (searchResults instanceof Error) throw searchResults;
+      return searchResults;
+    },
+  };
+}
+
+describe("loadCdsActivity", () => {
+  test("expands a bare ticker through search before requesting CDS", async () => {
+    // A near-miss is returned first, so first-result-wins would send the wrong name.
+    const calls = spy([result("ORCL.MX", "Oracle de Mexico"), result("ORCL", "Oracle Corporation")]);
+
+    const activity = await loadCdsActivity("ORCL", calls.fetchCds, calls.searchInstruments);
+
+    expect(calls.searched).toEqual(["ORCL"]);
+    expect(calls.requested).toEqual(["Oracle Corporation"]);
+    // The pane body reads this back, so ORCL must not survive resolution.
+    expect(activity.issuer).toBe("Oracle Corporation");
+  });
+
+  test("falls back to the first result when no symbol matches exactly", async () => {
+    const calls = spy([result("AVGO", "Broadcom Inc."), result("AVGOP", "Broadcom Preferred")]);
+
+    await loadCdsActivity("BRCM", calls.fetchCds, calls.searchInstruments);
+
+    expect(calls.requested).toEqual(["Broadcom Inc."]);
+  });
+
+  test("sends a company name straight through without searching", async () => {
+    const calls = spy([result("ORCL", "Oracle Corporation")]);
+
+    const activity = await loadCdsActivity("Tencent Holdings Limited", calls.fetchCds, calls.searchInstruments);
+
+    expect(calls.searched).toEqual([]);
+    expect(calls.requested).toEqual(["Tencent Holdings Limited"]);
+    expect(activity.issuer).toBe("Tencent Holdings Limited");
+  });
+
+  test("keeps the raw ticker when search is empty or fails", async () => {
+    const empty = spy([]);
+    await loadCdsActivity("ORCL", empty.fetchCds, empty.searchInstruments);
+    expect(empty.requested).toEqual(["ORCL"]);
+
+    // A search outage must not also take out the CDS request.
+    const broken = spy(new Error("search unavailable"));
+    const activity = await loadCdsActivity("ORCL", broken.fetchCds, broken.searchInstruments);
+    expect(broken.requested).toEqual(["ORCL"]);
+    expect(activity.issuer).toBe("ORCL");
+  });
+
+  test("market-wide load searches nothing and sends no issuer", async () => {
+    const calls = spy([result("ORCL", "Oracle Corporation")]);
+
+    const activity = await loadCdsActivity(null, calls.fetchCds, calls.searchInstruments);
+
+    expect(calls.searched).toEqual([]);
+    expect(calls.requested).toEqual([undefined]);
+    expect(activity.issuer).toBeNull();
+  });
+});

package/src/plugins/builtin/cds/client.ts

@@ -0,0 +1,67 @@
+import { apiClient, type CloudCdsResponse } from "../../../api-client";
+import type { InstrumentSearchResult } from "../../../types/instrument";
+import { normalizeCdsTrades, type CdsTrade } from "./model";
+
+/** One trading week of public dissemination is what "recent activity" means here. */
+const CDS_HISTORY_DAYS = 5;
+const CDS_TRADE_LIMIT = 500;
+
+export interface CdsActivity {
+  source: string;
+  asOf: string | null;
+  /** The issuer name actually sent, after any symbol lookup. */
+  issuer: string | null;
+  trades: CdsTrade[];
+}
+
+export type CdsActivityLoader = (issuer: string | null) => Promise<CdsActivity>;
+
+type CdsFetch = (params: { issuer?: string; days?: number; limit?: number }) => Promise<CloudCdsResponse>;
+type InstrumentSearch = (query: string, limit?: number) => Promise<InstrumentSearchResult[]>;
+
+/**
+ * A bare ticker with normal symbol punctuation and no spaces. Anything longer or
+ * containing a space is already a company name and is sent to the backend as-is.
+ */
+const TICKER_LIKE = /^[A-Za-z0-9][A-Za-z0-9.^:-]{0,11}$/;
+
+/**
+ * The backend matches DTCC issuer names, so a ticker has to become a company
+ * name first. An untracked symbol has no local metadata to expand it, and its
+ * quote name never arrives for a fixed binding, so the shared instrument search
+ * is the only reliable expansion. A search outage falls back to the raw input
+ * rather than taking the CDS request down with it.
+ */
+export async function resolveIssuerName(
+  issuer: string,
+  searchInstruments: InstrumentSearch,
+): Promise<string> {
+  if (!TICKER_LIKE.test(issuer)) return issuer;
+  try {
+    const results = await searchInstruments(issuer);
+    const symbol = issuer.toUpperCase();
+    const match = results.find((result) => result.symbol.toUpperCase() === symbol) ?? results[0];
+    return match?.name?.trim() || issuer;
+  } catch {
+    return issuer;
+  }
+}
+
+export async function loadCdsActivity(
+  issuer: string | null,
+  fetchCds: CdsFetch = (params) => apiClient.getCloudCds(params),
+  searchInstruments: InstrumentSearch = (query, limit) => apiClient.searchInstruments(query, limit),
+): Promise<CdsActivity> {
+  const resolved = issuer ? await resolveIssuerName(issuer, searchInstruments) : null;
+  const response = await fetchCds({
+    ...(resolved ? { issuer: resolved } : {}),
+    days: CDS_HISTORY_DAYS,
+    limit: CDS_TRADE_LIMIT,
+  });
+  return {
+    source: response.source,
+    asOf: response.asOf,
+    issuer: resolved,
+    trades: normalizeCdsTrades(response.trades ?? []),
+  };
+}

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

@@ -0,0 +1,41 @@
+import type { PaneTemplateCreateOptions } from "../../../types/plugin";
+import type { PluginModule } from "../plugin-module";
+import { CDS_PANE_ID } from "./model";
+import { CdsPane } from "./pane";
+
+/** Only an explicit argument binds a ticker; bare `CDS` stays market-wide. */
+function explicitSymbol(options?: PaneTemplateCreateOptions): string | null {
+  const raw = options?.symbol ?? options?.ticker?.metadata.ticker ?? options?.arg;
+  return raw?.trim().toUpperCase() || null;
+}
+
+export const cdsModule: PluginModule = {
+  panes: [{
+    id: CDS_PANE_ID,
+    name: "Single-Name CDS",
+    icon: "D",
+    component: CdsPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 92, height: 22 },
+  }],
+  paneTemplates: [{
+    id: "cds-pane",
+    paneId: CDS_PANE_ID,
+    label: "Single-Name CDS",
+    description: "Single-name corporate CDS trade activity from DTCC public dissemination.",
+    keywords: ["cds", "credit", "default", "swap", "single name", "issuer", "dtcc", "protection"],
+    shortcut: { prefix: "CDS", argPlaceholder: "ticker", argKind: "ticker", argOptional: true },
+    createInstance: (_context, options) => {
+      const symbol = explicitSymbol(options);
+      return symbol
+        ? {
+          instanceId: `${CDS_PANE_ID}:${symbol}`,
+          title: `CDS ${symbol}`,
+          binding: { kind: "fixed", symbol },
+          placement: "floating",
+        }
+        : { instanceId: `${CDS_PANE_ID}:market`, title: "CDS", placement: "floating" };
+    },
+  }],
+};

package/src/plugins/builtin/cds/model.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudCdsTradePayload } from "../../../api-client";
+import {
+  formatNotional,
+  issuerGroupKey,
+  normalizeCdsTrades,
+  resolveIssuerQuery,
+  spreadToBasisPoints,
+  summarizeIssuers,
+  tradesForIssuer,
+} from "./model";
+
+function payload(overrides: Partial<CloudCdsTradePayload> = {}): CloudCdsTradePayload {
+  return {
+    disseminationId: "1",
+    originalDisseminationId: null,
+    actionType: "NEWT",
+    eventTimestamp: "2026-08-25T14:30:00Z",
+    executionTimestamp: "2026-08-25T14:30:00Z",
+    effectiveDate: null,
+    expirationDate: null,
+    maturityDate: "2031-06-20",
+    issuerName: "Oracle Corporation",
+    underlierId: null,
+    underlierIdSource: null,
+    upi: null,
+    upiFisn: null,
+    upiUnderlierName: null,
+    notionalAmount: 5_000_000,
+    notionalCapped: false,
+    notionalCurrency: "USD",
+    // Raw DTCC decimals: 0.01 is a 100bp coupon.
+    fixedRate: 0.01,
+    reportedSpread: null,
+    spreadNotation: null,
+    upfrontAmount: null,
+    upfrontCurrency: null,
+    ...overrides,
+  };
+}
+
+describe("CDS spread units", () => {
+  test("converts reported spreads to basis points by notation", () => {
+    // Notation code "3" is what the raw DTCC feed carries for a decimal spread.
+    expect(spreadToBasisPoints(0.00256, "3")).toBeCloseTo(25.6, 6);
+    expect(spreadToBasisPoints(0.00256, "Decimal")).toBeCloseTo(25.6, 6);
+    // Unlabelled raw values are decimals too, not percent.
+    expect(spreadToBasisPoints(0.00256, null)).toBeCloseTo(25.6, 6);
+    expect(spreadToBasisPoints(25.6, "BPS")).toBe(25.6);
+    expect(spreadToBasisPoints(25.6, "Basis points")).toBe(25.6);
+    expect(spreadToBasisPoints(0.256, "Percentage")).toBeCloseTo(25.6, 6);
+    expect(spreadToBasisPoints(null, "3")).toBeNull();
+  });
+});
+
+describe("normalizeCdsTrades", () => {
+  test("keeps the reported spread only, and falls back through issuer names", () => {
+    const [withSpread, withoutName] = normalizeCdsTrades([
+      payload({ reportedSpread: 0.00256, spreadNotation: "3", fixedRate: 0.05 }),
+      payload({ disseminationId: "2", issuerName: null, upiUnderlierName: "ACME INC" }),
+    ]);
+    expect(withSpread!.spreadBp).toBeCloseTo(25.6, 6);
+    expect(withSpread!.couponBp).toBeCloseTo(500, 6);
+    // A missing spread is never back-solved from coupon or upfront.
+    expect(withoutName!.spreadBp).toBeNull();
+    expect(withoutName!.couponBp).toBeCloseTo(100, 6);
+    expect(withoutName!.issuer).toBe("ACME INC");
+  });
+
+  test("dates a trade by execution time so a late correction is not a new print", () => {
+    const [corrected, noExecution, unusableExecution] = normalizeCdsTrades([
+      payload({
+        actionType: "CORR",
+        originalDisseminationId: "9",
+        executionTimestamp: "2026-08-18T09:15:00Z",
+        eventTimestamp: "2026-08-25T14:30:00Z",
+      }),
+      payload({ disseminationId: "2", executionTimestamp: null }),
+      payload({ disseminationId: "3", executionTimestamp: "not-a-date" }),
+    ]);
+    expect(corrected!.eventAt).toBe(Date.parse("2026-08-18T09:15:00Z"));
+    expect(noExecution!.eventAt).toBe(Date.parse("2026-08-25T14:30:00Z"));
+    expect(unusableExecution!.eventAt).toBe(Date.parse("2026-08-25T14:30:00Z"));
+  });
+
+  test("drops reports with an unusable timestamp instead of dating them to 1970", () => {
+    expect(normalizeCdsTrades([
+      payload({ executionTimestamp: null, eventTimestamp: "not-a-date" }),
+    ])).toHaveLength(0);
+  });
+
+  test("marks capped notionals so a floor is not read as the trade size", () => {
+    expect(formatNotional({ notional: 5_000_000, notionalCapped: true })).toBe("5M+");
+    expect(formatNotional({ notional: 5_000_000, notionalCapped: false })).toBe("5M");
+    expect(formatNotional({ notional: null, notionalCapped: false })).toBe("--");
+  });
+});
+
+describe("summarizeIssuers", () => {
+  const trades = normalizeCdsTrades([
+    payload({ disseminationId: "a", executionTimestamp: "2026-08-25T10:00:00Z", reportedSpread: 0.009, spreadNotation: "3" }),
+    payload({ disseminationId: "b", executionTimestamp: "2026-08-25T14:00:00Z", reportedSpread: null }),
+    payload({ disseminationId: "c", executionTimestamp: "2026-08-25T12:00:00Z", reportedSpread: 0.011, spreadNotation: "3" }),
+    payload({ disseminationId: "d", executionTimestamp: "2026-08-25T09:00:00Z", issuerName: "Ford Motor Company" }),
+  ]);
+
+  test("groups by issuer with count, last trade, and the newest available spread", () => {
+    const summaries = summarizeIssuers(trades);
+    const oracle = summaries.find((row) => row.issuer === "Oracle Corporation")!;
+    expect(oracle.trades).toBe(3);
+    expect(oracle.lastTradeAt).toBe(Date.parse("2026-08-25T14:00:00Z"));
+    // The newest print carried no spread, so the last quoted level survives.
+    expect(oracle.latestSpreadBp).toBeCloseTo(110, 6);
+    expect(summaries.find((row) => row.issuer === "Ford Motor Company")!.latestSpreadBp).toBeNull();
+  });
+});
+
+describe("generic obligation names", () => {
+  // Verbatim `UPI Underlier Name` values seen dominating the live market view.
+  const GENERIC = [
+    "SR NT",
+    "SR NT 144A",
+    "NT",
+    "SR GTD NT 144A",
+    "No name obtainable",
+    "MEDIUM TERM NOTES EUR 2.3750 S.10/CALL",
+    "MEDIUM TERM NOTES EUR 0.6250 S.001STLA/CALL",
+    "GLOBAL BD",
+  ];
+
+  function unnamed(id: string, upiUnderlierName: string | null) {
+    return payload({ disseminationId: id, issuerName: null, upiUnderlierName });
+  }
+
+  test("drops records whose only name is a generic obligation label", () => {
+    const rows = normalizeCdsTrades([
+      ...GENERIC.map((name, index) => unnamed(`g${index}`, name)),
+      unnamed("empty", ""),
+      unnamed("missing", null),
+    ]);
+    expect(rows).toEqual([]);
+  });
+
+  test("accepts UPI underlier names that identify an issuer", () => {
+    const rows = normalizeCdsTrades([
+      unnamed("t", "Tencent Holdings Limited"),
+      unnamed("d", "DT.BANK MTN 17/20"),
+    ]);
+    expect(rows.map((row) => row.issuer)).toEqual(["Tencent Holdings Limited", "DT.BANK MTN 17/20"]);
+  });
+
+  test("keeps a reported issuer name and never falls back to an underlier id", () => {
+    const rows = normalizeCdsTrades([
+      payload({ disseminationId: "b", issuerName: "Broadcom Inc", upiUnderlierName: "SR NT 144A" }),
+      payload({ disseminationId: "x", issuerName: null, upiUnderlierName: null, underlierId: "US11135FAX50" }),
+    ]);
+    expect(rows.map((row) => row.issuer)).toEqual(["Broadcom Inc"]);
+  });
+
+  test("leaves the summary to real issuers when fake ones outnumber them", () => {
+    const summaries = summarizeIssuers(normalizeCdsTrades([
+      ...GENERIC.map((name, index) => unnamed(`g${index}`, name)),
+      payload({ disseminationId: "b", issuerName: "Broadcom Inc", upiUnderlierName: "SR GTD NT 144A" }),
+      payload({ disseminationId: "o", issuerName: "Oracle Corporation", upiUnderlierName: "SR NT" }),
+    ]));
+    expect(summaries.map((row) => row.issuer).sort()).toEqual(["Broadcom Inc", "Oracle Corporation"]);
+  });
+});
+
+describe("issuer aliases", () => {
+  // Spellings the deployed backend actually returns for one reference entity,
+  // deliberately in an order where the best one is not the first seen.
+  const ORACLE = ["ORACLE CORPORATION", "Oracle Cop", "Oracle Corporation"];
+  const BOEING = ["THE BOEING COMPANY", "Boeing Co/The", "The Boeing Company"];
+
+  const aliasTrades = normalizeCdsTrades([
+    ...ORACLE.map((issuerName, index) => payload({
+      disseminationId: `o${index}`,
+      issuerName,
+      executionTimestamp: `2026-08-25T1${index}:00:00Z`,
+      reportedSpread: 0.009,
+      spreadNotation: "3",
+    })),
+    ...BOEING.map((issuerName, index) => payload({
+      disseminationId: `b${index}`,
+      issuerName,
+      executionTimestamp: `2026-08-25T0${index}:00:00Z`,
+    })),
+  ]);
+
+  test("collapses case, punctuation, and legal-suffix aliases onto one key", () => {
+    expect(new Set(ORACLE.map(issuerGroupKey))).toEqual(new Set(["oracle"]));
+    expect(new Set(BOEING.map(issuerGroupKey))).toEqual(new Set(["boeing"]));
+  });
+
+  test("keeps meaningful words that distinguish real entities", () => {
+    expect(issuerGroupKey("Oracle Holdings Corp")).not.toBe(issuerGroupKey("Oracle Corporation"));
+    expect(issuerGroupKey("Boeing Capital Group")).not.toBe(issuerGroupKey("The Boeing Company"));
+    expect(issuerGroupKey("Acme 2031 Ltd")).not.toBe(issuerGroupKey("Acme 2026 Ltd"));
+    // A name that is only noise keeps its own row instead of an empty key.
+    expect(issuerGroupKey("The Company")).toBe("the company");
+  });
+
+  test("counts every alias in one row and displays the best spelling", () => {
+    const summaries = summarizeIssuers(aliasTrades);
+    expect(summaries).toHaveLength(2);
+
+    const oracle = summaries.find((row) => row.key === "oracle")!;
+    expect(oracle.trades).toBe(3);
+    expect(oracle.issuer).toBe("Oracle Corporation");
+
+    const boeing = summaries.find((row) => row.key === "boeing")!;
+    expect(boeing.trades).toBe(3);
+    expect(boeing.issuer).toBe("The Boeing Company");
+  });
+
+  test("drills down on the key so aliases open together", () => {
+    expect(tradesForIssuer(aliasTrades, "oracle").map((row) => row.issuer)).toEqual(ORACLE);
+    expect(tradesForIssuer(aliasTrades, "boeing").map((row) => row.issuer)).toEqual(BOEING);
+  });
+});
+
+describe("resolveIssuerQuery", () => {
+  const ticker = { metadata: { ticker: "ORCL", name: "Oracle Corporation" } } as never;
+
+  test("prefers tracked metadata and otherwise hands the loader a bare symbol", () => {
+    expect(resolveIssuerQuery("ORCL", ticker)).toBe("Oracle Corporation");
+    // Untracked: the loader expands this through instrument search.
+    expect(resolveIssuerQuery("orcl", null)).toBe("ORCL");
+    expect(resolveIssuerQuery(null, null)).toBeNull();
+  });
+});