gloomberb 0.16.2 → 0.16.4

package/src/plugins/builtin/earnings-calls/data.ts

@@ -5,6 +5,8 @@ import {
   type CloudEarningsTranscriptPayload,
 } from "../../../api-client";
 import { ApiRequestError } from "../../../api-client/errors";
+import { listingAbroad, type IssuerListingParams, type ListingAbroad } from "../../../api-client/paths";
+import { areDifferentCompanies } from "../../../sources/sec-registrant";
 import type { HeadlessPaneApiClient, PluginPersistence } from "../../../types/plugin";
 
 type EarningsCallsApiClient = Pick<
@@ -16,7 +18,8 @@ const LIST_KIND = "calls";
 const TRANSCRIPT_KIND = "transcript";
 const CACHE_SOURCE = "earnings-calls";
 const CACHE_SCHEMA_VERSION = 1;
-const LIST_CACHE_SCHEMA_VERSION = 2;
+// Version 3: a listing abroad is keyed by its venue and company, not its symbol alone.
+const LIST_CACHE_SCHEMA_VERSION = 3;
 
 /** The call list changes as new transcripts publish. */
 const LIST_CACHE_POLICY = {
@@ -94,19 +97,36 @@ function listOffset(value: number | undefined): number {
   return value !== undefined && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
 }
 
-function listKey(ticker: string | null, limit: number, offset: number): string {
-  return offset > 0 ? JSON.stringify([ticker, limit, offset]) : JSON.stringify([ticker, limit]);
+/** A listing abroad is its venue and company, so it never shares an entry with a US company of the same symbol. */
+function listKey(ticker: string | null, abroad: ListingAbroad | null, limit: number, offset: number): string {
+  const identity = abroad ? [abroad.symbol, abroad.exchange, abroad.name ?? null] : ticker;
+  return offset > 0 ? JSON.stringify([identity, limit, offset]) : JSON.stringify([identity, limit]);
 }
 
+/**
+ * A server that predates venue-aware lookups ignores the venue and lists the
+ * calls of the US company with the same symbol: AI in Paris would show C3.ai.
+ * Those calls are another company's, so they are dropped, and without the
+ * listing's company they cannot be told apart.
+ */
+function listingCalls(calls: CloudEarningsCallPayload[], abroad: ListingAbroad | null): CloudEarningsCallPayload[] {
+  if (!abroad) return calls;
+  const name = abroad.name;
+  return name ? calls.filter((call) => !areDifferentCompanies(name, call.companyName)) : [];
+}
+
+type EarningsCallsLoadOptions = IssuerListingParams & { force?: boolean; limit?: number; offset?: number };
+
 export async function loadEarningsCallsWithClient(
   client: EarningsCallsApiClient,
   ticker: string | null,
-  options?: { force?: boolean; limit?: number; offset?: number },
+  options?: EarningsCallsLoadOptions,
 ): Promise<EarningsCallsResult> {
   const normalizedTicker = ticker?.trim().toUpperCase() || null;
+  const abroad = normalizedTicker ? listingAbroad(normalizedTicker, options?.exchange, options?.name) : null;
   const limit = listLimit(options?.limit);
   const offset = listOffset(options?.offset);
-  const key = listKey(normalizedTicker, limit, offset);
+  const key = listKey(normalizedTicker, abroad, limit, offset);
   const force = options?.force ?? false;
   // Only the first page is worth keeping. A later page is an artefact of how
   // far somebody scrolled, over a shelf that reorders as transcripts publish,
@@ -131,11 +151,12 @@ export async function loadEarningsCallsWithClient(
   const request = client
     .getCloudEarningsCalls({
       ticker: normalizedTicker ?? undefined,
+      ...(abroad ? { exchange: abroad.exchange, ...(abroad.name ? { name: abroad.name } : {}) } : {}),
       limit,
       ...(offset > 0 ? { offset } : {}),
     })
     .then((payload) => {
-      const calls = payload.calls ?? [];
+      const calls = listingCalls(payload.calls ?? [], abroad);
       const value = { calls, pending: payload.pending === true, unknownTicker: payload.unknownTicker === true };
       // A list with calls still being produced changes by the minute, so it
       // is not worth keeping; a list of finished transcripts is.
@@ -190,7 +211,7 @@ export async function loadEarningsCallsWithClient(
 
 export function loadEarningsCalls(
   ticker: string | null,
-  options?: { force?: boolean; limit?: number; offset?: number },
+  options?: EarningsCallsLoadOptions,
 ): Promise<EarningsCallsResult> {
   return loadEarningsCallsWithClient(apiClient, ticker, options);
 }

package/src/plugins/builtin/earnings-calls/headless.ts

@@ -8,6 +8,7 @@ import type {
   HeadlessPaneLoadArgs,
   HeadlessRowsResult,
 } from "../../../types/plugin";
+import { resolveHeadlessIssuerListing } from "../shared/headless-market-data";
 import {
   callStatusLabel,
   isPendingTranscript,
@@ -57,10 +58,10 @@ export interface EarningsCallsHeadlessDependencies {
 }
 
 const defaultDependencies: EarningsCallsHeadlessDependencies = {
-  loadCalls: (ticker, limit, context) => loadEarningsCallsWithClient(
+  loadCalls: async (ticker, limit, context) => loadEarningsCallsWithClient(
     context.apiClient,
     ticker,
-    { limit },
+    { limit, ...(ticker ? await resolveHeadlessIssuerListing(context, ticker) : {}) },
   ),
   loadTranscript: (callId, context) => loadTranscriptWithClient(context.apiClient, callId),
 };

package/src/plugins/builtin/earnings-calls/pane.tsx

@@ -33,6 +33,7 @@ import { nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
 import { usePluginPaneState } from "../../runtime";
 import { ProWall, SignInWall } from "../cloud/auth-actions";
 import { usePlanAccess } from "../../../api-client/plan-access";
+import { listingAbroad } from "../../../api-client/paths";
 import { useBoundTicker as useSymbolBinding } from "../shared/ticker-request";
 import {
   callStatusLabel,
@@ -177,7 +178,7 @@ interface EarningsCallsViewProps {
 }
 
 export function EarningsCallsPane({ focused, width, height }: EarningsCallsViewProps) {
-  const { symbol, exchange } = useSymbolBinding();
+  const { symbol, exchange, ticker: boundTicker } = useSymbolBinding();
   const access = usePlanAccess();
 
   const [calls, setCalls] = useState<CloudEarningsCallPayload[]>([]);
@@ -227,6 +228,10 @@ export function EarningsCallsPane({ focused, width, height }: EarningsCallsViewP
   const [listPending, setListPending] = useState(false);
 
   const ticker = symbol ? symbol.toUpperCase() : null;
+  // A listing abroad asks for its own calls by venue and company, never a US namesake's.
+  const abroad = ticker ? listingAbroad(ticker, exchange, boundTicker?.metadata.name) : null;
+  const listingVenue = abroad?.exchange;
+  const listingName = abroad?.name;
 
   const fetchCalls = useCallback(
     (force: boolean) => {
@@ -234,7 +239,7 @@ export function EarningsCallsPane({ focused, width, height }: EarningsCallsViewP
       const request = ++listRequestVersion.current;
       setListStatus((current) => (current === "loaded" ? current : "loading"));
       setLoadingMore(false);
-      loadEarningsCalls(ticker, { force, limit: CALL_PAGE_SIZE })
+      loadEarningsCalls(ticker, { force, limit: CALL_PAGE_SIZE, exchange: listingVenue, name: listingName })
         .then((result) => {
           if (request !== listRequestVersion.current) return;
           setCalls(result.calls);
@@ -261,7 +266,7 @@ export function EarningsCallsPane({ focused, width, height }: EarningsCallsViewP
           setListStatus("error");
         });
     },
-    [ticker, access.emailVerified, access.hasProAccess],
+    [ticker, listingVenue, listingName, access.emailVerified, access.hasProAccess],
   );
 
   // Scrolling to the end of the shelf asks the server for the next page. A
@@ -271,7 +276,7 @@ export function EarningsCallsPane({ focused, width, height }: EarningsCallsViewP
     if (!access.emailVerified || !access.hasProAccess) return;
     const request = listRequestVersion.current;
     setLoadingMore(true);
-    loadEarningsCalls(ticker, { limit: CALL_PAGE_SIZE, offset: nextOffset })
+    loadEarningsCalls(ticker, { limit: CALL_PAGE_SIZE, offset: nextOffset, exchange: listingVenue, name: listingName })
       .then((result) => {
         if (request !== listRequestVersion.current) return;
         setCalls((current) => appendNewCalls(current, result.calls));
@@ -289,7 +294,7 @@ export function EarningsCallsPane({ focused, width, height }: EarningsCallsViewP
           status: statusOf(error),
         });
       });
-  }, [ticker, nextOffset, access.emailVerified, access.hasProAccess]);
+  }, [ticker, listingVenue, listingName, nextOffset, access.emailVerified, access.hasProAccess]);
 
   const loadMoreFromScroll = useTableLoadMore(
     tableScrollRef,

package/src/plugins/builtin/econ/calendar-model.ts

@@ -62,41 +62,66 @@ export function impactIndicator(impact: EconImpact): { text: string; color: stri
   }
 }
 
-function dateKey(d: Date): string {
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+/** The UTC day of an instant, so a release sits under the same day on every machine. */
+export function dateKey(d: Date): string {
+  return d.toISOString().slice(0, 10);
 }
 
 /**
- * Rows are grouped by local day, so the time beside them is local too. The
- * payload's `time` is the UTC clock time and would put a 23:00 UTC release
- * under the next local day at "23:00".
+ * The release's UTC clock time. Rows group by UTC day and the column header
+ * names the zone, as `gloomberb econ` prints it; local time would move a 23:00
+ * UTC release under another day and read differently on every machine.
  */
 export function timeLabel(d: Date): string {
-  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+  return d.toISOString().slice(11, 16);
+}
+
+/** The zone the calendar's times and days are in, for the column header. */
+export const CALENDAR_TIME_ZONE_LABEL = "UTC";
+
+/** "Fri Oct 9", the UTC day the calendar groups an instant under. */
+export function shortDayLabel(d: Date): string {
+  return `${DAY_NAMES[d.getUTCDay()]!} ${MONTH_NAMES[d.getUTCMonth()]!} ${d.getUTCDate()}`;
 }
 
 export function dayLabel(d: Date, today: Date): string {
   const dk = dateKey(d);
   const todayKey = dateKey(today);
-  const yesterday = new Date(today);
-  yesterday.setDate(yesterday.getDate() - 1);
-  const tomorrow = new Date(today);
-  tomorrow.setDate(tomorrow.getDate() + 1);
+  const dayMs = 24 * 60 * 60 * 1000;
+  const yesterday = dateKey(new Date(today.getTime() - dayMs));
+  const tomorrow = dateKey(new Date(today.getTime() + dayMs));
 
-  const dayName = DAY_NAMES[d.getDay()]!;
-  const monthName = MONTH_NAMES[d.getMonth()]!;
-  const dateNum = d.getDate();
-  const suffix = `${dayName} ${monthName} ${dateNum}`;
+  const suffix = shortDayLabel(d);
 
   if (dk === todayKey) return `TODAY · ${suffix}`;
-  if (dk === dateKey(tomorrow)) return `TOMORROW · ${suffix}`;
-  if (dk === dateKey(yesterday)) return `YESTERDAY · ${suffix}`;
+  if (dk === tomorrow) return `TOMORROW · ${suffix}`;
+  if (dk === yesterday) return `YESTERDAY · ${suffix}`;
   return suffix;
 }
 
+/**
+ * The calendar runs two weeks ahead. One that lists nothing a week past the
+ * start of the window (today, or a later first day asked for) stops short,
+ * as a feed that ends with its own week does, and says where it stops rather
+ * than reading as a quiet week.
+ */
+const MIN_DAYS_LISTED_AHEAD = 7;
+
+/**
+ * When the calendar stops short of a week past `windowStart`, the time of its
+ * last event; null when it reaches that far or lists nothing.
+ */
+export function shortCalendarEnd(events: readonly EconEvent[], windowStart: number): Date | null {
+  let last: Date | null = null;
+  for (const event of events) {
+    if (!last || event.date.getTime() > last.getTime()) last = event.date;
+  }
+  return last && last.getTime() < windowStart + MIN_DAYS_LISTED_AHEAD * 86_400_000 ? last : null;
+}
+
 /**
  * Events (already in time order; `eventIdx` indexes them) under a header per
- * local day, with NOW before the first event still to come. When that event is
+ * UTC day, with NOW before the first event still to come. When that event is
  * on a later day, NOW sits above that day's header, since the present is still
  * on the earlier day.
  */

package/src/plugins/builtin/econ/detail-view.tsx

@@ -29,7 +29,7 @@ import { Box, Text } from "../../../ui";
 import { displayWidth } from "../../../utils/format";
 import { useOpenTickerChoice } from "../shared/ticker-choice";
 import { resolveFredMapping, projectFredHistory, fredHistoryUnits } from "./fred-series-map";
-import { actualColor, timeLabel } from "./calendar-model";
+import { actualColor, CALENDAR_TIME_ZONE_LABEL, timeLabel } from "./calendar-model";
 import type { EconEvent } from "./types";
 
 interface EconDetailViewProps {
@@ -195,7 +195,7 @@ export function EconDetailView({ event, width, height, focused }: EconDetailView
     ...(event.actual ? [{ id: "actual", label: "Actual", value: event.actual, color: actualColor(event.actual, event.forecast) }] : []),
     ...(event.forecast ? [{ id: "forecast", label: "Forecast", value: event.forecast }] : []),
     ...(event.prior ? [{ id: "prior", label: "Prior", value: event.prior }] : []),
-    { id: "time", label: "Release", value: timeLabel(event.date) },
+    { id: "time", label: "Release", value: `${timeLabel(event.date)} ${CALENDAR_TIME_ZONE_LABEL}` },
   ];
 
   const projected = useMemo(

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

@@ -24,6 +24,8 @@ import {
   attachEconCalendarPersistence,
   actualColor,
   calendarDisplayRows,
+  CALENDAR_TIME_ZONE_LABEL,
+  dateKey,
   dayLabel,
   formatCountdown,
   formatStaleness,
@@ -33,6 +35,8 @@ import {
   matchesCountry,
   matchesImpact,
   resetEconCalendarPersistence,
+  shortCalendarEnd,
+  shortDayLabel,
   timeLabel,
   type CountryFilter,
   type DisplayRow,
@@ -42,6 +46,8 @@ import {
 } from "./calendar-model";
 import { usePaneStatusFooter } from "../../../components/layout/pane/status-footer";
 import { handleRefreshKey } from "../../../components/data-table/table-pane";
+import { tableColumnWidth } from "../../../components/ui/table-layout";
+import { useRemoteUiNode } from "../../../remote/semantic-tree";
 
 const IMPACT_LABELS: Record<ImpactFilter, string> = {
   all: "All",
@@ -100,17 +106,28 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   // Day headers and the NOW marker between the past and the upcoming events.
   const today = new Date(now);
   const rows = calendarDisplayRows(filtered, now);
+  // Rows group by UTC day, so today starts at UTC midnight.
+  const todayStart = Math.floor(now / 86_400_000) * 86_400_000;
+  // A calendar that stops short of a week ahead says where it stops.
+  const listedEnd = shortCalendarEnd(events, todayStart);
+  const listedAfter = listedEnd ? `No events listed after ${shortDayLabel(listedEnd)}` : null;
 
   // Map from eventIdx to flat row index (for scroll tracking)
   const eventIdxToRowIdx = new Map<number, number>();
   let nowRowIdx = -1;
   let nextUpcomingEventIdx = -1;
   let nextUpcomingTime = Number.POSITIVE_INFINITY;
+  // The first row of today or later, with the day header and NOW band above it.
+  let todayRowIdx = -1;
   for (let r = 0; r < rows.length; r++) {
     const row = rows[r]!;
     if (row.kind === "event") {
       eventIdxToRowIdx.set(row.eventIdx, r);
       const eventTime = row.event.date.getTime();
+      if (todayRowIdx < 0 && eventTime >= todayStart) {
+        todayRowIdx = r;
+        while (todayRowIdx > 0 && rows[todayRowIdx - 1]!.kind !== "event") todayRowIdx -= 1;
+      }
       if (eventTime > now && eventTime < nextUpcomingTime) {
         nextUpcomingEventIdx = row.eventIdx;
         nextUpcomingTime = eventTime;
@@ -125,51 +142,63 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   const selectedIdx = rememberedIdx >= 0 ? rememberedIdx
     : nextUpcomingEventIdx >= 0 ? nextUpcomingEventIdx : Math.max(0, filtered.length - 1);
 
-  // On initial load, scroll to NOW and select the first upcoming event
-  const initialScrollDone = useRef(false);
+  // The present at the top of the table: NOW a few rows down for context, but
+  // never above today, so a Saturday opens on NOW and Monday rather than on
+  // Friday's last releases. Asked for on open, on a filter change and on a
+  // forced reload; it holds until the user scrolls or moves the selection.
+  const presentRowIdx = nowRowIdx >= 0 ? Math.max(0, todayRowIdx, nowRowIdx - 3) : -1;
+  const [presentRequest, setPresentRequest] = useState(1);
+  const [presentAnchor, setPresentAnchor] = useState<{ index: number; version: number } | null>(null);
+  const servedPresentRequest = useRef(0);
   useEffect(() => {
-    if (initialScrollDone.current || filtered.length === 0) return;
-    if (nextUpcomingEventIdx >= 0) {
+    if (servedPresentRequest.current === presentRequest || filtered.length === 0) return;
+    // On open the selection moves to the next release as well.
+    if (servedPresentRequest.current === 0 && nextUpcomingEventIdx >= 0) {
       setSelectedKey(filtered[nextUpcomingEventIdx]?.id ?? null);
     }
-    const sb = scrollRef.current;
-    if (sb?.viewport && nowRowIdx >= 0) {
-      // Position NOW a few rows from the top so you can see context
-      const scrollTarget = Math.max(0, nowRowIdx - 3);
-      sb.scrollTo(scrollTarget);
-    }
-    initialScrollDone.current = true;
-  }, [filtered.length]);
+    servedPresentRequest.current = presentRequest;
+    setPresentAnchor(presentRowIdx >= 0 ? { index: presentRowIdx, version: presentRequest } : null);
+  }, [filtered.length, presentRequest]);
+  const returnToPresent = useCallback(() => setPresentRequest((request) => request + 1), []);
+  const leavePresent = useCallback(() => setPresentAnchor(null), []);
 
   const selectImpactFilter = useCallback((value: ImpactFilter) => {
     setImpactFilter(value);
     setSelectedKey(null);
-  }, [setImpactFilter, setSelectedKey]);
+    returnToPresent();
+  }, [returnToPresent, setImpactFilter, setSelectedKey]);
   const selectCountryFilter = useCallback((value: CountryFilter) => {
     setCountryFilter(value);
     setSelectedKey(null);
-  }, [setCountryFilter, setSelectedKey]);
+    returnToPresent();
+  }, [returnToPresent, setCountryFilter, setSelectedKey]);
   const cycleImpactFilter = useCallback((step: 1 | -1) => {
     setImpactFilter((prev) => FILTER_CYCLE[(FILTER_CYCLE.indexOf(prev) + step + FILTER_CYCLE.length) % FILTER_CYCLE.length]!);
     setSelectedKey(null);
-  }, [setImpactFilter, setSelectedKey]);
+    returnToPresent();
+  }, [returnToPresent, setImpactFilter, setSelectedKey]);
   const cycleCountryFilter = useCallback((step: 1 | -1) => {
     setCountryFilter((prev) => COUNTRY_CYCLE[(COUNTRY_CYCLE.indexOf(prev) + step + COUNTRY_CYCLE.length) % COUNTRY_CYCLE.length]!);
     setSelectedKey(null);
-  }, [setCountryFilter, setSelectedKey]);
+    returnToPresent();
+  }, [returnToPresent, setCountryFilter, setSelectedKey]);
 
   // A forced reload goes back to the present once it answers.
   const forcedResult = calendar.data?.forced ? calendar.data : null;
   useEffect(() => {
-    if (forcedResult) setSelectedKey(null);
-  }, [forcedResult, setSelectedKey]);
+    if (!forcedResult) return;
+    setSelectedKey(null);
+    returnToPresent();
+  }, [forcedResult, returnToPresent, setSelectedKey]);
 
   const handleRootKeyDown = useCallback((event: DataTableKeyEvent) => (
     handleRefreshKey(event, () => void calendar.reload(), { stopPropagation: true })
   ), [calendar.reload]);
 
   const columns = useMemo<EconCalendarColumn[]>(() => {
-    const timeWidth = 6;
+    // The header names the zone, so the column is as wide as the header needs.
+    const timeLabelText = `TIME (${CALENDAR_TIME_ZONE_LABEL})`;
+    const timeWidth = tableColumnWidth({ width: 6, label: timeLabelText });
     const impactWidth = 4;
     const flagWidth = 3;
     const actualWidth = 9;
@@ -183,7 +212,7 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
     const eventWidth = Math.max(minEventWidth, width - 3 - columnCount - fixedWidth);
 
     return [
-      { id: "time", label: "TIME", width: timeWidth, align: "left" },
+      { id: "time", label: timeLabelText, width: timeWidth, align: "left" },
       { id: "impact", label: "IMP", width: impactWidth, align: "left" },
       { id: "country", label: "CTY", width: flagWidth, align: "left" },
       { id: "event", label: "EVENT", width: eventWidth, align: "left" },
@@ -209,11 +238,21 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   const nextText = nextEvent && nextCountdown ? `next ${nextEvent.event} ${nextCountdown}` : null;
   // The cached first paint is being replaced; its age only counts once a load has answered.
   const showStale = stale && (!loading || calendar.updatedAt !== null);
+  // An empty list says it in its empty state instead.
+  const listedAfterStatus = listedAfter && !detailEvent && filtered.length > 0 ? listedAfter : null;
   const calendarStatus = useMemo<PaneFooterSegment[]>(() => [
     ...(nextText && !detailEvent ? [{ id: "next", parts: [{ text: nextText, tone: "muted" as const }] }] : []),
+    ...(listedAfterStatus ? [{ id: "listed-after", parts: [{ text: listedAfterStatus, tone: "warning" as const }] }] : []),
     ...(showStale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
     ...(staleness ? [{ id: "updated", parts: [{ text: staleness, tone: "muted" as const }] }] : []),
-  ], [detailEvent, nextText, showStale, staleness]);
+  ], [detailEvent, listedAfterStatus, nextText, showStale, staleness]);
+  // A report of the pane (`gloomberb fn ECO`) says it too.
+  const listedThrough = listedEnd ? dateKey(listedEnd) : null;
+  useRemoteUiNode(listedAfter && listedThrough ? {
+    role: "report-notice",
+    label: "Listed through",
+    getMetadata: () => ({ text: listedAfter, key: "listedThrough", value: listedThrough }),
+  } : null);
   usePaneStatusFooter({
     registrationId: "econ-calendar",
     loading,
@@ -336,9 +375,16 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
         kind: "index",
         selectedIndex: eventIdxToRowIdx.get(selectedIdx) ?? selectedIdx,
         onChange: (_index, row) => {
+          leavePresent();
           if (row.kind === "event") setSelectedKey(row.event.id);
         },
       }}
+      scrollToIndex={presentAnchor?.index}
+      scrollToIndexAlign={presentAnchor ? "start" : "nearest"}
+      scrollToIndexVersion={presentAnchor?.version ?? 0}
+      onBodyScrollActivity={(source) => {
+        if (source === "user") leavePresent();
+      }}
       columns={columns}
       items={rows}
       isNavigable={(row) => row.kind === "event"}
@@ -351,7 +397,7 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
       renderSectionHeader={renderSectionHeader}
       renderCell={renderCell}
       selectedTextOverridesCellColor
-      emptyStateTitle={loading ? "Loading economic events..." : "No events"}
+      emptyStateTitle={loading ? "Loading economic events..." : listedAfter ?? "No events"}
       emptyStateHint={emptyStateHint}
       showHorizontalScrollbar={false}
     />

package/src/plugins/builtin/econ-statistics/headless.ts

@@ -49,11 +49,19 @@ function detailEntries(view: StatViewModel): HeadlessPaneEntry[] {
       value: view.low,
       formatted: `${format(view.low.value)} ${view.low.date}`,
     },
-    { label: "As of", value: view.latest.date },
+    // FRED dates a monthly reading at the month's first day; the text says which period it is.
+    { label: "Period", value: view.latest.date, formatted: view.reading },
     { label: "Source", value: `FRED ${view.stat.seriesId}` },
   ];
 }
 
+/** The window the %ile column counts over, in words. */
+const PERCENTILE_WINDOW: Record<StatRangeId, string> = {
+  "5Y": "the last 5 years",
+  "20Y": "the last 20 years",
+  ALL: "the full history",
+};
+
 export function projectStatsHeadlessBundle(
   bundle: StatsBundle,
   range: StatRangeId,
@@ -86,7 +94,7 @@ export function projectStatsHeadlessBundle(
           align: "right" as const,
           format: (value: unknown) => formatNumber(Number(value), 0),
         },
-        { key: "asOf", header: "As of" },
+        { key: "asOf", header: "Period", format: (_value: unknown, row: Record<string, unknown>) => String(row.reading) },
       ],
       rows: categoryViews.map((view) => ({
         id: view.stat.id,
@@ -97,6 +105,7 @@ export function projectStatsHeadlessBundle(
         formattedPrevious: view.previous ? view.stat.formatValue(view.previous.value) : "-",
         percentile: view.percentile,
         asOf: view.latest.date,
+        reading: view.reading,
         stale: view.observationStale || view.cacheStale,
         fetchedAt: view.fetchedAt,
         cacheStale: view.cacheStale,
@@ -112,6 +121,7 @@ export function projectStatsHeadlessBundle(
       ...(selected ? [{ title: selected.stat.label, entries: detailEntries(selected) }] : []),
     ],
     errors: bundle.errors,
+    notes: [`%ile is the share of past readings at or below the latest one, over ${PERCENTILE_WINDOW[range]}.`],
     metadata: {
       fetchedAt: bundle.fetchedAt,
       fetchedAtComplete: bundle.fetchedAtComplete,

package/src/plugins/builtin/econ-statistics/pane.tsx

@@ -148,7 +148,7 @@ export function EconStatisticsPane({ focused, width, height }: PaneProps) {
   const footerInfo = useMemo<PaneFooterSegment[]>(() => {
     if (!selected) return [];
     const info: PaneFooterSegment[] = [
-      { id: "as-of", parts: [{ text: `as of ${selected.latest.date}`, tone: "muted" }] },
+      { id: "as-of", parts: [{ text: `reading for ${selected.reading}`, tone: "muted" }] },
     ];
     // The cached first paint is being replaced; its age only counts once that load fails.
     const seeding = resource.loading && resource.updatedAt === null && !selected.refreshError;

package/src/plugins/builtin/econ-statistics/view.ts

@@ -19,6 +19,8 @@ export interface StatViewModel {
   latest: StatPoint;
   /** The latest print's period at the series' own cadence: "Sep 21", "Aug", "Q2". */
   period: string;
+  /** What the latest print is a reading of, in full: "Aug 2026", "Q2 2026", "week ending 2026-10-03", "2026-10-09". */
+  reading: string;
   /** The print before this one, for the direction of the last move. */
   previous: StatPoint | null;
   yearAgo: StatPoint | null;
@@ -60,6 +62,20 @@ function formatStatPeriod(date: string, perYear: number): string {
   return `${name} ${Number(date.slice(8, 10))}`;
 }
 
+/**
+ * What the latest reading is a reading of. FRED dates a monthly or quarterly print at the start of
+ * its period, so 2026-08-01 is August 2026, not the first of the month; a weekly print is dated by
+ * the week's last day, a daily one by its day.
+ */
+function formatStatReading(date: string, perYear: number): string {
+  const month = Number(date.slice(5, 7));
+  const name = MONTHS[month - 1];
+  if (!name) return date;
+  if (perYear <= 4) return `Q${Math.ceil(month / 3)} ${date.slice(0, 4)}`;
+  if (perYear <= 12) return `${name} ${date.slice(0, 4)}`;
+  return perYear <= 52 ? `week ending ${date}` : date;
+}
+
 function extreme(points: readonly StatPoint[], pick: "high" | "low"): StatPoint {
   let best = points[0]!;
   for (const point of points) {
@@ -99,6 +115,7 @@ export function projectStat(
     range,
     latest,
     period: formatStatPeriod(latest.date, perYear),
+    reading: formatStatReading(latest.date, perYear),
     previous,
     yearAgo,
     changeOnPrevious: previous ? latest.value - previous.value : null,

package/src/plugins/builtin/executives/data.ts

@@ -4,7 +4,9 @@ import {
   type CloudProxyStatementPayload,
 } from "../../../api-client";
 import { ApiRequestError, isPermanentClientError } from "../../../api-client/errors";
+import type { IssuerListingParams } from "../../../api-client/paths";
 import type { PluginPersistence } from "../../../types/plugin";
+import { secListingKey } from "../../../utils/sec";
 
 /**
  * Executive compensation comes from Gloom Cloud's open proxy-statement
@@ -101,21 +103,30 @@ function loadCached<T>(
   return request.promise;
 }
 
+interface ProxyLoadOptions {
+  force?: boolean;
+  /** The listing's venue and company, for a listing outside the US. */
+  listing?: IssuerListingParams;
+}
+
 export async function loadProxyStatements(
   ticker: string,
-  options?: { force?: boolean },
+  options?: ProxyLoadOptions,
 ): Promise<ProxyResult<CloudProxyStatementListPayload>> {
-  const key = ticker.toUpperCase();
+  const symbol = ticker.toUpperCase();
+  // SAN in Paris is not SAN in New York: a listing abroad is cached under its venue.
+  const key = secListingKey(symbol, options?.listing?.exchange);
   return loadCached(LIST_KIND, key, activeListFetches, LIST_CACHE_POLICY, options?.force ?? false,
-    () => apiClient.getProxyStatements(key));
+    () => apiClient.getProxyStatements(symbol, options?.listing));
 }
 
 export async function loadProxyStatement(
   ticker: string,
   year: number,
-  options?: { force?: boolean },
+  options?: ProxyLoadOptions,
 ): Promise<ProxyResult<CloudProxyStatementPayload>> {
-  const key = `${ticker.toUpperCase()}:${year}`;
+  const symbol = ticker.toUpperCase();
+  const key = `${secListingKey(symbol, options?.listing?.exchange)}:${year}`;
   return loadCached(STATEMENT_KIND, key, activeStatementFetches, STATEMENT_CACHE_POLICY, options?.force ?? false,
-    () => apiClient.getProxyStatement(ticker.toUpperCase(), year));
+    () => apiClient.getProxyStatement(symbol, year, options?.listing));
 }