gloomberb 0.18.2 → 0.18.4

package/src/components/ui/data-table/opentui/index.tsx

@@ -5,6 +5,7 @@ import { useThemeColors } from "../../../../theme/theme-context";
 import { usePaneInstance } from "../../../../state/app/context";
 import { useViewport } from "../../../../react/input";
 import { measurePerf } from "../../../../utils/perf-marks";
+import { displayWidth } from "../../../../utils/format";
 import { useDoubleClickActivation } from "../../../use-double-click-activation";
 import { useScrollBoxScrollActivity } from "../../../table-view-shared";
 import { EmptyState } from "../../status";
@@ -31,6 +32,7 @@ import {
   cutColumnText,
   resolveDataTableColumnClips,
   resolveDataTableVisibleWindow,
+  resolveMoreColumnsHint,
   reuseDataTableColumnClips,
   type DataTableColumnClip,
 } from "./model";
@@ -378,6 +380,27 @@ export function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>
     () => tableColumnStarts(displayColumns, columnGap),
     [columnGap, displayColumns],
   );
+  // Columns out of view past the right edge: the header row ends in "more →" there, a press on it scrolls to
+  // them, and the rows leave its cells blank, so a narrow pane says it has more than it shows. The header's
+  // scroll box is as wide as the body's viewport (measuredViewportWidth), so the header row has a blank cell
+  // past it, over the body's vertical scrollbar; the hint is laid over the row, not inside the scroll box,
+  // and takes that cell first.
+  const besideHeader = Math.max(0, Math.min(1, (scrollRef.current?.width ?? 0) - measuredViewportWidth));
+  const moreColumns = horizontalScrollbarVisible ? resolveMoreColumnsHint({
+    columns: displayColumns.map((column) => ({
+      width: column.width,
+      align: column.align,
+      label: sortColumnId === column.id ? `${column.label}${column.label ? " " : ""}▲` : column.label,
+    })),
+    columnGap,
+    columnStarts,
+    frozenFirstColumn: freezeFirstColumn,
+    besideHeader,
+    horizontalPadding,
+    scrollLeft,
+    viewportWidth: measuredViewportWidth,
+  }) : null;
+  const moreColumnsReserve = moreColumns?.reserve ?? 0;
   // A scroll step that cuts the columns as the last one did keeps the same
   // array, so the memoized rows skip the render.
   const columnClipsRef = useRef<readonly (DataTableColumnClip | null)[] | null>(null);
@@ -387,12 +410,13 @@ export function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>
       columnStarts,
       frozenFirstColumn: freezeFirstColumn,
       horizontalPadding,
+      rightReserve: moreColumnsReserve,
       scrollLeft,
       // A table that cannot scroll sideways fits its own columns; one it cut could never be scrolled to.
       viewportWidth: showHorizontalScrollbar ? measuredViewportWidth : 0,
       widths: displayColumns.map((column) => column.width),
     })),
-    [columnGap, columnStarts, displayColumns, freezeFirstColumn, horizontalPadding, measuredViewportWidth, scrollLeft, showHorizontalScrollbar],
+    [columnGap, columnStarts, displayColumns, freezeFirstColumn, horizontalPadding, measuredViewportWidth, moreColumnsReserve, scrollLeft, showHorizontalScrollbar],
   );
   const reportVisibleRange = useVisibleRangeEmitter({
     itemCount: items.length,
@@ -454,6 +478,17 @@ export function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>
     scrollRef: headerScrollRef,
     onHorizontalScroll: syncBodyScroll,
   });
+  // "more →" steps right as Shift+Right does: half the viewport.
+  const scrollToMoreColumns = useCallback(() => {
+    const body = scrollRef.current;
+    const viewportWidth = body?.viewport?.width ?? 0;
+    if (!body || viewportWidth <= 0) return;
+    const maxLeft = Math.max(0, (body.scrollWidth ?? 0) - viewportWidth);
+    body.scrollLeft = Math.min(maxLeft, (body.scrollLeft ?? 0) + Math.max(1, Math.floor(viewportWidth / 2)));
+    syncHeaderScroll();
+    setScrollLeft(body.scrollLeft ?? 0);
+    nativeRenderer.requestRender();
+  }, [nativeRenderer, scrollRef, syncHeaderScroll]);
   const handleBodySizeChange = useCallback(() => {
     measureContentWidth();
     setScrollVersion((current) => current + 1);
@@ -616,7 +651,9 @@ export function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>
             const hasNextLabel = columnIndex < displayColumns.length - 1
               && tableColumnLeadGap(displayColumns, columnIndex + 1, columnGap) === 0;
             const label = column.label + indicator;
-            const labelText = " ".repeat(inset) + (clip
+            // A figure the right edge cuts is blank in every row (cutColumnText), so its label is too.
+            const figuresCut = clip !== null && column.align === "right" && clip.inset + clip.width < column.width;
+            const labelText = figuresCut ? " ".repeat(inset + Math.max(0, clip.width)) : " ".repeat(inset) + (clip
               // Cut on the right, the label's last cell is the edge.
               ? cutColumnText(label, column.align, column.width, clip, (text, width, cutRight) => (
                 fitTableHeaderText(text, width, column.align, hasNextLabel && !cutRight)
@@ -650,6 +687,28 @@ export function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>
           })}
         </Box>
       </ScrollBox>
+      {moreColumns ? (
+        <Box
+          position="absolute"
+          top={0}
+          left={moreColumns.left}
+          width={displayWidth(moreColumns.text)}
+          height={1}
+          zIndex={2}
+          backgroundColor={colors.panel}
+          hoverBackgroundColor={hoverBg(colors)}
+          cursor="pointer"
+          onMouseDown={(event: any) => {
+            event.preventDefault?.();
+            event.stopPropagation?.();
+            focusPane();
+            onTableMouseDown?.(event);
+            scrollToMoreColumns();
+          }}
+        >
+          <Text fg={colors.textDim}>{moreColumns.text}</Text>
+        </Box>
+      ) : null}
 
       <ScrollBox
         id={bodyScrollId}

package/src/components/ui/data-table/opentui/model.ts

@@ -1,4 +1,5 @@
 import { displayWidth } from "../../../../utils/format";
+import { tableColumnLeadGap } from "../../table-layout";
 
 /**
  * Where the viewport cuts a column: `inset` cells hidden on its left (past the
@@ -61,10 +62,113 @@ export function reuseDataTableColumnClips(
   return previous.length === next.length && next.every((clip, index) => sameClip(clip, previous[index] ?? null)) ? previous : next;
 }
 
+/**
+ * What a table's header says at its right edge while columns are out of view
+ * past it, longest first: the longest that fits beside the last column shown
+ * whole is drawn. With that column against the edge, the arrow takes the
+ * blank its label ends in. The hint never hides a column: with no blank to
+ * take, the horizontal scrollbar is the only sign.
+ */
+const MORE_COLUMNS_LABELS = ["more →", "more", "→"] as const;
+
+export interface MoreColumnsHint {
+  /** The cells the hint draws: its label, after a blank unless it takes the last column's own. */
+  text: string;
+  /** Where `text` starts, from the viewport's left edge. */
+  left: number;
+  /** Cells at the body's right edge the rows leave blank under the hint (`resolveDataTableColumnClips`). */
+  reserve: number;
+}
+
+interface HintColumn {
+  width: number;
+  align?: string;
+  /** The header label as drawn, with its sort mark. */
+  label: string;
+}
+
+/**
+ * Whether a column is out of view past the body's right edge at this scroll.
+ * A column the edge cuts counts when it shows nothing to read: figures cut on
+ * the right are blank (`cutColumnText`), and text shows less than its label.
+ * Text cut after its label ends in an ellipsis instead.
+ */
+function hasColumnsPastRightEdge(columns: readonly HintColumn[], starts: readonly number[], right: number): boolean {
+  return columns.some((column, index) => {
+    const start = starts[index] ?? 0;
+    if (start + column.width <= right) return false;
+    const shown = right - start;
+    return shown <= 0 || (column.align ?? "left") !== "left" || shown < displayWidth(column.label);
+  });
+}
+
+/**
+ * The "more →" hint at the header's right edge while columns are out of view
+ * past it, or null. The header's scroll box is as wide as the viewport, and
+ * `besideHeader` blank cells follow it on the header row (the cell over the
+ * body's vertical scrollbar); the hint, laid over the row, can reach them.
+ * The hint sits after a blank: a gap, cells past the last column shown whole,
+ * or that column's own trailing blank (a label shorter than its column keeps
+ * one, `fitTableHeaderText`), and only cut columns give it room. Never in a
+ * viewport too narrow to show a column beside it, or before it is measured.
+ */
+export function resolveMoreColumnsHint({
+  columns,
+  columnGap,
+  columnStarts,
+  besideHeader = 0,
+  frozenFirstColumn = false,
+  horizontalPadding,
+  scrollLeft,
+  viewportWidth,
+}: {
+  columns: readonly HintColumn[];
+  columnGap: number;
+  /** Where each column's content starts, from the first column (tableColumnStarts). */
+  columnStarts: readonly number[];
+  /** Blank cells right of the header's scroll box on the header row. */
+  besideHeader?: number;
+  frozenFirstColumn?: boolean;
+  horizontalPadding: number;
+  scrollLeft: number;
+  viewportWidth: number;
+}): MoreColumnsHint | null {
+  const longest = displayWidth(MORE_COLUMNS_LABELS[0]) + 1;
+  if (columns.length === 0 || viewportWidth < longest * 2) return null;
+  const right = scrollLeft + viewportWidth;
+  const starts = columns.map((_, index) => horizontalPadding + (columnStarts[index] ?? 0));
+  if (!hasColumnsPastRightEdge(columns, starts, right)) return null;
+  // The last column drawn whole (a frozen first column rides along with the scroll), and whether its label
+  // ends in a blank of its own.
+  let lastEnd = scrollLeft;
+  let lastPadded = false;
+  columns.forEach((column, index) => {
+    const start = (starts[index] ?? 0) + (frozenFirstColumn && index === 0 ? scrollLeft : 0);
+    const end = start + column.width;
+    if (end > right || end <= lastEnd) return;
+    lastEnd = end;
+    const next = columns[index + 1];
+    lastPadded = !!next && tableColumnLeadGap(columns, index + 1, columnGap) === 0 && displayWidth(column.label) < column.width;
+  });
+  const headerRight = right + Math.max(0, besideHeader);
+  const place = (label: string) => {
+    const labelStart = headerRight - displayWidth(label);
+    // The rows stop where the blank before the label starts, unless that blank is the last column's own.
+    const rowsEnd = labelStart === lastEnd && lastPadded ? lastEnd : labelStart - 1;
+    return { text: ` ${label}`, left: labelStart - 1 - scrollLeft, reserve: Math.max(0, right - rowsEnd), fits: rowsEnd >= lastEnd };
+  };
+  const fitted = MORE_COLUMNS_LABELS.map(place).find((candidate) => candidate.fits);
+  if (fitted) return { text: fitted.text, left: fitted.left, reserve: fitted.reserve };
+  // The last column ends at the header's edge: the arrow takes its label's trailing blank, the rows keep it.
+  if (lastPadded && headerRight === lastEnd) return { text: MORE_COLUMNS_LABELS[2], left: lastEnd - 1 - scrollLeft, reserve: 0 };
+  return null;
+}
+
 /**
  * Each column's clip at the current scroll, null for a column shown whole.
  * A frozen first column stays, and what slides under it counts as cut on the
- * left. Null for the whole table when every column is whole or nothing is
+ * left. `rightReserve` cells at the right edge show no column (under the
+ * "more →" hint, `resolveMoreColumnsHint`). Null for the whole table when every column is whole or nothing is
  * measured yet.
  */
 export function resolveDataTableColumnClips({
@@ -72,6 +176,7 @@ export function resolveDataTableColumnClips({
   columnStarts,
   frozenFirstColumn,
   horizontalPadding,
+  rightReserve = 0,
   scrollLeft,
   viewportWidth,
   widths,
@@ -81,13 +186,15 @@ export function resolveDataTableColumnClips({
   columnStarts: readonly number[];
   frozenFirstColumn: boolean;
   horizontalPadding: number;
+  /** Cells at the viewport's right edge that show no column. */
+  rightReserve?: number;
   scrollLeft: number;
   viewportWidth: number;
   /** Each column's drawn width. */
   widths: readonly number[];
 }): (DataTableColumnClip | null)[] | null {
   if (viewportWidth <= 0 || widths.length === 0) return null;
-  const right = scrollLeft + viewportWidth;
+  const right = scrollLeft + viewportWidth - Math.max(0, rightReserve);
   const left = frozenFirstColumn ? scrollLeft + horizontalPadding + (widths[0] ?? 0) + columnGap : scrollLeft;
   let cut = false;
   const clips = widths.map((width, index): DataTableColumnClip | null => {

package/src/components/ui/data-table/types.ts

@@ -178,7 +178,7 @@ export interface DataTableProps<
    */
   exportCsv?: () => string;
   /**
-   * A rendered-view report (`gloomberb fn`) reads every row, not only those
+   * A rendered-view report (`gloom fn`) reads every row, not only those
    * the viewport shows. For a bounded table a reader needs whole, such as an
    * option chain's strike window; leave it off for long or paged lists.
    */

package/src/components/ui/display.tsx

@@ -5,6 +5,7 @@ import { blendForContrast, higherContrast } from "../../theme/color-utils";
 import { useThemeColors } from "../../theme/theme-context";
 import { Box, Text, TextAttributes, useUiCapabilities } from "../../ui";
 import { truncateToDisplayWidth } from "../../utils/format";
+import { CountryFlagLead } from "./country-flag";
 import { usePaneLinkMenuEntry } from "./external-link";
 import { titleCase } from "./header-case";
 import { statToneColor, type StatTone } from "./stat-grid";
@@ -69,6 +70,8 @@ export interface KeyValueRowProps {
    * `PaneLinkMenu` the pane menu lists it as `link.label`, so the keyboard reaches what a click opens.
    */
   link?: { label: string; onOpen: () => void };
+  /** The country the value names (a code or a name): the desktop and the web lead the value with its flag. */
+  country?: string | null;
 }
 
 /**
@@ -120,7 +123,7 @@ export function KeyValueRow(props: KeyValueRowProps) {
  * width in characters, the value and detail taking the rest of the row and
  * clipped in CSS where they run out of it.
  */
-function NativeKeyValueRow({ label, value, detail, tone, color, width, labelWidth, emphasis = true, align = "left", link }: KeyValueRowProps) {
+function NativeKeyValueRow({ label, value, detail, tone, color, width, labelWidth, emphasis = true, align = "left", link, country }: KeyValueRowProps) {
   const colors = useThemeColors();
   usePaneLinkMenuEntry(link ? `key-value:${label}:${value}` : null, link?.label ?? "", () => link?.onOpen());
   const target = link ? {
@@ -136,6 +139,7 @@ function NativeKeyValueRow({ label, value, detail, tone, color, width, labelWidt
     <Box width={width === undefined ? undefined : "100%"} flexDirection="row" overflow="hidden" data-gloom-ui="key-value-row" {...target}>
       {/* At least the label width, in characters; a longer label keeps every character and moves its value along. */}
       <Text fg={colors.textDim} style={{ ...NATIVE_CLIP_STYLE, flex: "0 0 auto", minWidth: `${labelChars}ch`, paddingRight: "1ch", boxSizing: "border-box" }}>{t(label)}</Text>
+      {country ? <CountryFlagLead value={country} /> : null}
       <Text
         fg={color ?? statToneColor(tone, colors) ?? colors.text}
         attributes={emphasis ? TextAttributes.BOLD : undefined}

package/src/components/ui/index.ts

@@ -36,8 +36,10 @@ export { FieldGrid, GridFieldView, fieldGridColumns, fieldGridRows } from "./fie
 export type { FieldGridProps, GridField } from "./field-grid";
 export { StatGrid, statGridColumns, statGridRows } from "./stat-grid";
 export { ColumnGrid, ColumnGridPair } from "./column-grid";
-export type { ColumnGridCell, ColumnGridColumn, ColumnGridPairProps, ColumnGridProps } from "./column-grid";
+export type { ColumnGridCell, ColumnGridColumn, ColumnGridLink, ColumnGridPairProps, ColumnGridProps } from "./column-grid";
 export type { StatGridProps, StatItem } from "./stat-grid";
+export { COUNTRY_FLAG_CELLS, CountryFlag, CountryFlagLead, withCountryFlag, withFlagRoom } from "./country-flag";
+export type { CountryFlagProps } from "./country-flag";
 export { RatioBar } from "./ratio-bar";
 export type { RatioBarProps } from "./ratio-bar";
 export { RangeTrack } from "./range-track";

package/src/components/ui/logo-mark.tsx

@@ -28,8 +28,17 @@ export interface LogoMarkProps {
   /** What the logo stands for, such as a broker. Only its initial is drawn; the label beside it names it. */
   name: string;
   size?: LogoMarkSize;
+  /**
+   * Draws the logo on a white plate. Company and coin logos are made for a
+   * light page: a black mark on a clear field (XRP's) would vanish on a dark
+   * theme, while a logo that fills its square covers the plate.
+   */
+  plate?: boolean;
 }
 
+/** The page logos are drawn for, in every theme. */
+const LOGO_PLATE = "#ffffff";
+
 function initialOf(name: string): string {
   const letter = [...name.trim()].find((character) => /[\p{L}\p{N}]/u.test(character));
   return letter ? letter.toLocaleUpperCase() : "?";
@@ -40,7 +49,7 @@ function initialOf(name: string): string {
  * the desktop and the web. Decoration: hidden from assistive technology, so
  * the label beside it stays the name. The terminal draws nothing.
  */
-export function LogoMark({ src, name, size = "row" }: LogoMarkProps) {
+export function LogoMark({ src, name, size = "row", plate = false }: LogoMarkProps) {
   const desktop = useUiCapabilities().nativePaneChrome === true;
   const colors = useThemeColors();
   if (!desktop) return null;
@@ -52,7 +61,7 @@ export function LogoMark({ src, name, size = "row" }: LogoMarkProps) {
       objectFit="cover"
       aria-hidden="true"
       data-gloom-role="logo-mark"
-      style={{ width: tile.side, height: tile.side, flexShrink: 0, borderRadius: tile.radius }}
+      style={{ width: tile.side, height: tile.side, flexShrink: 0, borderRadius: tile.radius, ...(plate ? { background: LOGO_PLATE } : {}) }}
     >
       <Box width="100%" height="100%" alignItems="center" justifyContent="center" backgroundColor={colors.border}>
         <Text fg={colors.textBright} attributes={TextAttributes.BOLD} style={LETTER_STYLE[size]}>

package/src/components/ui/query-bar.tsx

@@ -144,7 +144,7 @@ export interface QueryBarProps {
   leading?: ReactNode;
   /**
    * The date the data is as of (`as of 2026-10-09`), shown where `meta` is
-   * when there is none. A `gloomberb shot` whose status line dates the data
+   * when there is none. A `gloom shot` whose status line dates the data
    * leaves it out, so the date is said once.
    */
   asOf?: string;

package/src/components/ui/row-notes.ts

@@ -0,0 +1,79 @@
+import { useCallback, useEffect, useState } from "react";
+
+/**
+ * What the last action on one row of a list came to, kept for that row
+ * (docs/pane-conventions.md, "Row messages"): the row's status cell shows
+ * its short state, its detail the full reason. The footer and toasts stay
+ * out of it.
+ *
+ * A note stands until the caller replaces or clears it (the next action on
+ * the row), or, given `signature`, until the row's own status moves past what
+ * it was when the note first showed: a later state is newer news than the
+ * note. A note on a row that is not listed waits for it; whether a note
+ * belongs in a toast instead (its row has left the list) is the caller's call.
+ */
+export interface RowNotes<Row, Note> {
+  /** The row's note while it stands, else null. */
+  noteFor(row: Row): Note | null;
+  /** Sets or clears one row's note, by the row's key. */
+  setNote(key: string, note: Note | null): void;
+  /** Clears every note: the list now shows other rows (another account, a reload). */
+  clearNotes(): void;
+}
+
+interface Kept<Note> {
+  note: Note;
+  /** The row's signature when the note first showed it. */
+  baseline?: string;
+}
+
+const NO_NOTES: ReadonlyMap<string, never> = new Map<string, never>();
+
+export function useRowNotes<Row, Note>(rows: readonly Row[], options: {
+  key: (row: Row) => string;
+  /**
+   * The parts of a row a real change moves (its state, its message), never a
+   * timestamp a poll restamps on every read. Without it a note stands until
+   * it is replaced or cleared.
+   */
+  signature?: (row: Row) => string;
+}): RowNotes<Row, Note> {
+  const { key, signature } = options;
+  const [notes, setNotes] = useState<ReadonlyMap<string, Kept<Note>>>(NO_NOTES);
+
+  const setNote = useCallback((rowKey: string, note: Note | null) => {
+    setNotes((current) => {
+      if (!note && !current.has(rowKey)) return current;
+      const next = new Map(current);
+      if (note) next.set(rowKey, { note });
+      else next.delete(rowKey);
+      return next;
+    });
+  }, []);
+  const clearNotes = useCallback(() => setNotes((current) => (current.size ? NO_NOTES : current)), []);
+
+  // A note takes its row as the list shows it once the note is up, and goes
+  // when that row moves on.
+  useEffect(() => {
+    if (!signature || notes.size === 0) return;
+    setNotes((current) => {
+      let next: Map<string, Kept<Note>> | null = null;
+      for (const [rowKey, kept] of current) {
+        const row = rows.find((entry) => key(entry) === rowKey);
+        if (!row) continue;
+        const now = signature(row);
+        if (kept.baseline === undefined) (next ??= new Map(current)).set(rowKey, { ...kept, baseline: now });
+        else if (kept.baseline !== now) (next ??= new Map(current)).delete(rowKey);
+      }
+      return next ?? current;
+    });
+  }, [key, notes, rows, signature]);
+
+  const noteFor = useCallback((row: Row): Note | null => {
+    const kept = notes.get(key(row));
+    if (!kept) return null;
+    return !signature || kept.baseline === undefined || kept.baseline === signature(row) ? kept.note : null;
+  }, [key, notes, signature]);
+
+  return { noteFor, setNote, clearNotes };
+}

package/src/components/ui/stat-grid.tsx

@@ -28,6 +28,13 @@ export interface StatItem {
   label: string;
   value: string;
   detail?: string;
+  /**
+   * Shorter forms of `detail`, longest first (an empty one shows none). The
+   * grid sizes its columns by the shortest, so a detail that grows with the
+   * data (a stamp outside regular hours) never takes a column from the band,
+   * and shows the longest form that fits the cell.
+   */
+  detailVariants?: readonly string[];
   tone?: StatTone;
   /** A domain colour (a price change, a series). Wins over `tone`. */
   color?: string;
@@ -55,9 +62,22 @@ function labelChars(items: StatItem[]): number {
   return Math.min(MAX_LABEL_CHARS, Math.max(4, ...items.map((item) => displayWidth(t(item.label)))));
 }
 
+/** The form of the detail the columns are sized by: the shortest. */
+function sizingDetail(item: StatItem): string | undefined {
+  return item.detailVariants?.length ? item.detailVariants[item.detailVariants.length - 1] : item.detail;
+}
+
+/** The longest form of a cell's detail that fits `room` cells, else its shortest. */
+function fittingStatDetail(item: Pick<StatItem, "detail" | "detailVariants">, room: number): string | undefined {
+  if (!item.detail || !item.detailVariants?.length) return item.detail;
+  const forms = [item.detail, ...item.detailVariants];
+  return forms.find((form) => displayWidth(form) <= room) ?? forms[forms.length - 1];
+}
+
 function naturalWidth(item: StatItem, labels: number): number {
   // A split bar takes the room the cell has left and is not counted here.
-  const detail = item.detail ? displayWidth(item.detail) + 2 : 0;
+  const sized = sizingDetail(item);
+  const detail = sized ? displayWidth(sized) + 2 : 0;
   return labels + 1 + displayWidth(item.value) + detail + CELL_GAP;
 }
 
@@ -132,9 +152,14 @@ export function StatGrid({ items, width, columns: columnsProp }: StatGridProps)
             const barRoom = valueWidth - displayWidth(value) - 1;
             const barCells = !item.split ? 0 : nativePaneChrome ? SPLIT_BAR_CELLS : barRoom >= 4 ? Math.min(SPLIT_BAR_CELLS, barRoom) : 0;
             const detailWidth = valueWidth - displayWidth(value) - (barCells ? barCells + 1 : 0) - 2;
-            const detail = !item.detail
+            // The desktop cell has no gap between cells: its label column, inset and gaps take the room
+            // (measured short, as a cell is wider than a character, so a form that fits is never clipped).
+            const shownDetail = fittingStatDetail(item, nativePaneChrome
+              ? width + (item.wide ? 0 : CELL_GAP) - labels - displayWidth(value) - (barCells ? barCells + 1 : 0) - 4
+              : detailWidth);
+            const detail = !shownDetail
               ? ""
-              : nativePaneChrome ? item.detail : detailWidth > 1 ? truncateToDisplayWidth(item.detail, detailWidth) : "";
+              : nativePaneChrome ? shownDetail : detailWidth > 1 ? truncateToDisplayWidth(shownDetail, detailWidth) : "";
             return (
               <Box
                 key={item.id ?? `${rowIndex}:${index}`}

package/src/components/ui/status.tsx

@@ -334,7 +334,9 @@ export function PaneStatusBody({
         <EmptyStateBody
           status={status}
           title={status === "error" ? errorTitle ?? (subject ? unavailableText(subject) : error!) : emptyTitle ?? t("Nothing to show yet.")}
-          message={status === "error" ? (errorTitle || subject ? error! : undefined) : emptyMessage}
+          message={status === "error"
+            ? ((errorTitle || subject) && error && error !== (errorTitle ?? unavailableText(subject!)) ? error : undefined)
+            : emptyMessage}
           actions={actions}
           retry={retry}
           feedback={feedback}

package/src/core/app-services.ts

@@ -26,6 +26,10 @@ export function createAppServices({ config, plugins, externalPlugins }: AppServi
           name: "News",
           provider: {
             fetchNews: async (query) => (await newsService.load(query)).articles,
+            fetchNewsPage: async (query) => {
+              const { articles, error, nextCursor } = await newsService.load(query);
+              return { articles, error, nextCursor };
+            },
             getCachedNews: (query) => newsService.getQueryState(query).articles,
           },
         }),

package/src/core/state/app/layout.ts

@@ -1,4 +1,4 @@
-import { getDockLeafLayouts, getDockedPaneIds } from "../../../layout/pane-manager";
+import { compactFloatingZ, getDockLeafLayouts, getDockedPaneIds } from "../../../layout/pane-manager";
 import { pinFollowingPane } from "../../../layout/pane-follow";
 import {
   cloneLayout,
@@ -509,7 +509,7 @@ export function moveHistoryIndex(
   return next;
 }
 
-/** If paneId is a floating pane, bump its zIndex to the top. */
+/** If paneId is a floating pane, bump its zIndex to the top, renumbering a stack that would climb past the shell's overlays. */
 export function bringFloatingToFront(layout: LayoutConfig, paneId: string): LayoutConfig {
   const entryIndex = layout.floating.findIndex((e) => e.instanceId === paneId);
   const entry = entryIndex >= 0 ? layout.floating[entryIndex] : undefined;
@@ -519,9 +519,9 @@ export function bringFloatingToFront(layout: LayoutConfig, paneId: string): Layo
   if ((entry.zIndex ?? 50) === maxZ && entryIndex === topEqualIndex) return layout; // already on top
   return {
     ...layout,
-    floating: layout.floating.map((e) =>
+    floating: compactFloatingZ(layout.floating.map((e) =>
       e.instanceId === paneId ? { ...e, zIndex: maxZ + 1 } : e,
-    ),
+    )),
   };
 }
 

package/src/data/cached-query.ts

@@ -1,4 +1,6 @@
+import type { QuoteIntradayBar } from "../types/financials";
 import { nextResponseSequence } from "./response-sequence";
+import { servedFromSavedCopy } from "./saved-copies";
 
 /** A value's age belongs to its source, not to the consumer that last read it. */
 export interface CachedValue<T> {
@@ -13,6 +15,10 @@ export interface CachedValue<T> {
   asOf?: number;
   /** How far a delayed source runs behind the market, in minutes; 0 for a real-time one. */
   delayMinutes?: number;
+  /** Exchange rates: the pair's bar the rate is the close of, when it is not a print. */
+  intradayBar?: QuoteIntradayBar;
+  /** Exchange rates: why a stale rate stands, as the data service states it. */
+  staleReason?: string;
   refreshError?: unknown;
 }
 
@@ -95,7 +101,8 @@ export class CachedQuery<T> implements CachedQueryHandle<T> {
         return accepted;
       }, (error: unknown) => {
         const fallback = this.usable(cached) ?? this.usable(this.options.read(true));
-        const retained = fallback ? { ...fallback, refreshError: error } : null;
+        // A command that shows it says it is the saved copy (`servedFromSavedCopy`).
+        const retained = fallback ? { ...fallback, value: servedFromSavedCopy(fallback.value, fallback.fetchedAt), refreshError: error } : null;
         if (generation === this.generation) this.publish({ result: retained, loading: false, error });
         if (retained) return retained;
         throw error;

package/src/data/config/chart-settings.ts

@@ -1,5 +1,6 @@
 import { logFailure } from "../../utils/log-failure";
-import { CHART_RESOLUTIONS, TIME_RANGES, type ChartResolution, type TimeRange } from "../../time-series/range";
+import { TIME_RANGES, type ChartResolution, type TimeRange } from "../../time-series/range";
+import { isChartResolution } from "../../time-series/resolution";
 import type { LayoutConfig, PaneBinding } from "../../types/config";
 import type {
   ChartPanelSpec,
@@ -19,7 +20,6 @@ import {
 import { recordOrNull } from "../../utils/guards";
 
 const CHART_RANGES = new Set<TimeRange>(TIME_RANGES);
-const CHART_RESOLUTION_SET = new Set<ChartResolution>(CHART_RESOLUTIONS);
 const PRICE_RENDER_MODES = new Set<SeriesStyle>(["area", "line", "candles", "ohlc", "hlc"]);
 const LEGACY_INDICATOR_IDS = new Set<LegacyChartIndicatorId>([
   "volume",
@@ -90,7 +90,7 @@ function range(value: unknown, fallback: TimeRange): TimeRange {
 }
 
 function resolution(value: unknown, fallback: ChartResolution): ChartResolution {
-  return CHART_RESOLUTION_SET.has(value as ChartResolution) ? value as ChartResolution : fallback;
+  return isChartResolution(value) ? value : fallback;
 }
 
 function makeSpec(

package/src/data/config/home.ts

@@ -16,7 +16,7 @@ import { isAbsolute, join } from "path";
  * On Linux a new install follows the XDG Base Directory spec instead (#1267):
  * config.json in `$XDG_CONFIG_HOME/gloomberb`, the data directory, plugins
  * and the terminal media pid file in `$XDG_DATA_HOME/gloomberb`, the plugin
- * cache in `$XDG_CACHE_HOME/gloomberb`. An existing `~/.gloomberb` keeps
+ * and native caches in `$XDG_CACHE_HOME/gloomberb`. An existing `~/.gloomberb` keeps
  * winning, so no install moves. Once an XDG config.json exists it wins over
  * a `~/.gloomberb` created later (an older version, a stray `mkdir`), so the
  * choice cannot flip and leave the data behind.
@@ -41,6 +41,11 @@ export interface GloomberbDirs {
   plugins: string;
   /** Host-owned scratch space for plugins: bundles, update state. */
   pluginCache: string;
+  /**
+   * The standalone binary's render library, copied out of the binary when the
+   * temp folder cannot hold or run it (see renderers/opentui/render-lib).
+   */
+  nativeCache: string;
 }
 
 function getUserHome(env: NodeJS.ProcessEnv): string {
@@ -74,6 +79,7 @@ function singleFolder(kind: "override" | "home", home: string): GloomberbDirs {
     data: home,
     plugins: join(home, "plugins"),
     pluginCache: join(home, "plugin-cache"),
+    nativeCache: join(home, "native-cache"),
   };
 }
 
@@ -85,12 +91,14 @@ function xdgBase(env: NodeJS.ProcessEnv, variable: string, fallback: string): st
 
 function xdgFolders(env: NodeJS.ProcessEnv): GloomberbDirs {
   const data = join(xdgBase(env, "XDG_DATA_HOME", join(".local", "share")), XDG_FOLDER);
+  const cache = join(xdgBase(env, "XDG_CACHE_HOME", ".cache"), XDG_FOLDER);
   return {
     kind: "xdg",
     configFile: join(xdgBase(env, "XDG_CONFIG_HOME", ".config"), XDG_FOLDER, "config.json"),
     data,
     plugins: join(data, "plugins"),
-    pluginCache: join(xdgBase(env, "XDG_CACHE_HOME", ".cache"), XDG_FOLDER, "plugin-cache"),
+    pluginCache: join(cache, "plugin-cache"),
+    nativeCache: join(cache, "native-cache"),
   };
 }