gloomberb 0.18.3 → 0.18.4

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/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"),
   };
 }
 

package/src/data/config/layout.ts

@@ -19,6 +19,7 @@ import {
   normalizePaneId,
   removeUnreachablePaneInstances,
 } from "../../types/config";
+import { compactFloatingZ } from "../../layout/pane-manager/floating";
 import {
   migrateChartPaneSettings,
   type LegacyChartMigrationContext,
@@ -237,7 +238,7 @@ function getDefaultFollowSourceInstanceId(layout: LayoutConfig): string | null {
 
 function sanitizeFloatingEntries(value: unknown, validInstanceIds: Set<string>): LayoutConfig["floating"] {
   if (!Array.isArray(value)) return [];
-  return value
+  const entries = value
     .filter((entry): entry is LayoutConfig["floating"][number] =>
       !!entry
       && typeof entry === "object"
@@ -256,6 +257,8 @@ function sanitizeFloatingEntries(value: unknown, validInstanceIds: Set<string>):
       height: Math.max(1, Math.round(entry.height)),
       zIndex: typeof entry.zIndex === "number" ? Math.round(entry.zIndex) : entry.zIndex,
     }));
+  // A stack raised past the shell's menus and previews in an older session is renumbered in the same order.
+  return compactFloatingZ(entries);
 }
 
 function sanitizeDetachedEntries(value: unknown, validInstanceIds: Set<string>): LayoutConfig["detached"] {

package/src/data/config/store/node.ts

@@ -15,6 +15,7 @@ import {
 } from "./normalize";
 
 const configLog = debugLog.createLogger("config");
+const IN_MEMORY_DATA_DIR = ":memory:";
 
 /**
  * The config.json for a data directory: the file inside it, except that the
@@ -130,6 +131,9 @@ async function writeConfigFile(configPath: string, contents: string): Promise<vo
  * and the next one still runs.
  */
 export async function saveConfig(config: AppConfig): Promise<void> {
+  // `:memory:` is the data directory of a config kept in memory (tests, as for
+  // SQLite): there is no file, and writing one would land under the working directory.
+  if (config.dataDir === IN_MEMORY_DATA_DIR) return;
   const configPath = configFileFor(config.dataDir);
   // Written as it was when called, however the caller's object changes while
   // earlier saves are still running.

package/src/data/config/store/normalize.ts

@@ -44,7 +44,7 @@ function sanitizeTheme(value: unknown, fallback: string): string {
   if (typeof value !== "string") return fallback;
   if (!themes[value] && !reportedUnknownThemes.has(value)) {
     reportedUnknownThemes.add(value);
-    configLog.warn(`Unknown theme "${value}" in config; showing ${DEFAULT_THEME}. gloomberb config themes lists the ids.`);
+    configLog.warn(`Unknown theme "${value}" in config; showing ${DEFAULT_THEME}. gloom config themes lists the ids.`);
   }
   return value;
 }
@@ -93,6 +93,7 @@ export function normalizeLoadedConfig(
     brokerInstances: sanitizeBrokerInstances(candidate.brokerInstances),
     disabledPlugins,
     seededPlugins: sanitizeUniqueStringList(candidate.seededPlugins),
+    ...sanitizePluginSeedFailure(candidate.pluginSeedFailure),
     ...(candidate.portfolioCurrenciesAdopted === true ? { portfolioCurrenciesAdopted: true } : {}),
     ...(candidate.presentationMode === true ? { presentationMode: true } : {}),
     ...(typeof candidate.timezone === "string" && candidate.timezone.trim() ? { timezone: candidate.timezone.trim() } : {}),
@@ -160,6 +161,7 @@ export function normalizeConfigForSave(config: AppConfig): AppConfig {
     // Older apps read the retired group ids, so a group that is all off is saved as one.
     disabledPlugins: encodeBuiltinDisabledPluginIds(sanitizeUniqueStringList(config.disabledPlugins)),
     seededPlugins: sanitizeUniqueStringList(config.seededPlugins),
+    ...sanitizePluginSeedFailure(config.pluginSeedFailure),
     disabledSources: sanitizeUniqueStringList(config.disabledSources),
     pluginConfig: sanitizePluginConfig(config.pluginConfig),
     chartPreferences: sanitizeChartPreferences(config.chartPreferences, defaults.chartPreferences),
@@ -317,6 +319,13 @@ function sanitizeUniqueStringList(value: unknown): string[] {
   return [...new Set(sanitizeStringArray(value, []))];
 }
 
+/** The last failed plugin seed as saved, or nothing when it is absent or unreadable. */
+function sanitizePluginSeedFailure(value: unknown): Pick<AppConfig, "pluginSeedFailure"> {
+  if (!isRecord(value)) return {};
+  const plugins = sanitizeUniqueStringList(value.plugins).sort();
+  return plugins.length > 0 ? { pluginSeedFailure: { plugins, gitMissing: value.gitMissing === true } } : {};
+}
+
 function isPluginConfigMap(value: unknown): value is Record<string, Record<string, unknown>> {
   if (!isRecord(value)) return false;
   return Object.values(value).every((entry) => isRecord(entry));
@@ -363,10 +372,11 @@ function sanitizePortfolios(value: unknown, fallback: Portfolio[]): Portfolio[]
     .map(sanitizePortfolioAllocation);
 }
 
-/** Cash, target weights and the import source the portfolio commands write; a malformed one is dropped. */
+/** Cash, target weights, the import source and a fixed currency the portfolio commands write; a malformed one is dropped. */
 function sanitizePortfolioAllocation(entry: Portfolio): Portfolio {
-  const { cash, targetWeights, importedFrom, ...portfolio } = entry;
+  const { cash, targetWeights, importedFrom, fixedCurrency, ...portfolio } = entry;
   const next: Portfolio = { ...portfolio };
+  if (fixedCurrency === true) next.fixedCurrency = true;
   if (isRecord(importedFrom) && importedFrom.kind === "13f"
     && [importedFrom.cik, importedFrom.name, importedFrom.period, importedFrom.filed].every((value) => typeof value === "string" && value)) {
     next.importedFrom = { kind: "13f", cik: importedFrom.cik, name: importedFrom.name, period: importedFrom.period, filed: importedFrom.filed };

package/src/data/config/store/portfolio-as-of-column.ts

@@ -3,8 +3,8 @@ import { isRecord } from "../../../utils/guards";
 const PORTFOLIO_PANE_ID = "portfolio-list";
 
 /**
- * The portfolio pane's default columns before AS OF UTC took AGE's place
- * (GLO-575). Frozen here: the current default may change again, and only a
+ * The portfolio pane's default columns before AS OF UTC took AGE's place.
+ * Frozen here: the current default may change again, and only a
  * list still equal to this one was never chosen by the user.
  */
 const PREVIOUS_DEFAULT_COLUMN_IDS: readonly string[] = [

package/src/data/json-storage.ts

@@ -52,4 +52,6 @@ export const BROWSER_STORAGE_KEYS = {
   session: "gloomberb.web.session.v1",
   /** Broker account snapshots; other caches stay in memory. */
   resources: "gloomberb.web.resources.v1",
+  /** The layout the page draws before its script loads (renderers/dom/boot-frame.ts). */
+  bootFrame: "gloomberb.web.boot-frame.v1",
 } as const;

package/src/data/saved-copies.ts

@@ -0,0 +1,84 @@
+/**
+ * Answers a CLI command gave from a copy saved earlier because refreshing it
+ * failed: offline, a refused proxy, a service error. A command answers once,
+ * so the line it ends with says "couldn't refresh; saved <time>" instead of
+ * reading as live or delayed, but only when what it shows came from such a
+ * copy: a saved copy of something else it loaded on the way (a fallback for a
+ * pane it does not print) says nothing about the data on screen.
+ *
+ * The copy served is marked, by a symbol property that object spreads carry
+ * along and JSON never writes, and the command's output is searched for the
+ * marks. Nothing is marked outside `collectSavedCopies`: the app and its panes
+ * keep running for hours and say how current their data is in their own
+ * footers.
+ */
+const SAVED_AT = Symbol("gloomberb.savedCopyAt");
+
+let collecting = 0;
+let marked = 0;
+
+type Marked = { [SAVED_AT]?: number };
+
+function mark<T>(value: T, savedAt: number): T {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  marked += 1;
+  return { ...value, [SAVED_AT]: savedAt };
+}
+
+/**
+ * The value a command answers with when it came from a copy saved at
+ * `savedAt` (ms) after its refresh failed: a marked copy while a command runs,
+ * the value itself otherwise. An array's items are marked one by one, since
+ * a report shows its rows rather than the array that held them.
+ */
+export function servedFromSavedCopy<T>(value: T, savedAt: number): T {
+  if (collecting === 0 || !Number.isFinite(savedAt) || !value || typeof value !== "object") return value;
+  return (Array.isArray(value) ? value.map((item) => mark(item, savedAt)) : mark(value, savedAt)) as T;
+}
+
+/**
+ * The saved-copy mark of `value`, to spread into what is drawn from it (a
+ * report row built from a quote's fields), or nothing when it has none.
+ */
+export function savedCopyMark(value: unknown): object {
+  const savedAt = value && typeof value === "object" ? (value as Marked)[SAVED_AT] : undefined;
+  return typeof savedAt === "number" ? { [SAVED_AT]: savedAt } : {};
+}
+
+/** How far into a command's output the marks are looked for, so a large report is not walked whole. */
+const MAX_DEPTH = 6;
+const MAX_NODES = 50_000;
+
+/**
+ * When the oldest saved copy among `shown` (what a command prints, or the
+ * data its closing line is drawn from) was saved, or null when none of it
+ * came from one. The oldest, since that is how old what is shown can be.
+ */
+export function savedCopyShownAt(shown: unknown): number | null {
+  if (collecting === 0 || marked === 0) return null;
+  let oldest: number | null = null;
+  let budget = MAX_NODES;
+  const seen = new Set<object>();
+  const visit = (node: unknown, depth: number) => {
+    if (!node || typeof node !== "object" || seen.has(node) || budget-- <= 0) return;
+    seen.add(node);
+    const savedAt = (node as Marked)[SAVED_AT];
+    if (typeof savedAt === "number") oldest = oldest == null ? savedAt : Math.min(oldest, savedAt);
+    if (depth >= MAX_DEPTH) return;
+    for (const child of Array.isArray(node) ? node : Object.values(node)) visit(child, depth + 1);
+  };
+  visit(shown, 0);
+  return oldest;
+}
+
+/** Runs one command, marking the saved copies it answers from. */
+export async function collectSavedCopies<T>(run: () => Promise<T>): Promise<T> {
+  if (collecting === 0) marked = 0;
+  collecting += 1;
+  try {
+    return await run();
+  } finally {
+    collecting -= 1;
+    if (collecting === 0) marked = 0;
+  }
+}