gloomberb 0.17.2 → 0.17.3

package/src/plugins/builtin/ticker-detail/quote-monitor/card.tsx

@@ -1,5 +1,5 @@
 import type { ReactNode } from "react";
-import { useMemo } from "react";
+import { useMemo, useRef } from "react";
 import { Box, Text, TextAttributes, useUiCapabilities } from "../../../../ui";
 import type { PricePoint, Quote, TickerFinancials } from "../../../../types/financials";
 import type { TickerRecord } from "../../../../types/ticker";
@@ -22,7 +22,7 @@ import { t } from "../../../../i18n";
 import { isQuoteStaleForCurrentSession } from "../../../../market-data/quotes/freshness";
 import { formatQuoteNavAsOf } from "../../../../market-data/quotes/time";
 import { useQuoteFlashDirection } from "../../../../components/quote-flash";
-import { appendLiveQuotePoint } from "../../../../time-series/chart-data";
+import { followLiveSparklinePrice } from "../../../../components/price-sparkline/model";
 import {
   PriceAreaSparklineBackground,
   PriceSparkline,
@@ -145,8 +145,13 @@ export function QuoteMonitorCard({
     : cachedFinancials?.priceHistory;
   const assetCategory = quote?.instrumentType ?? ticker?.metadata.assetCategory;
   // Completed bars end at the prior close; the live price closes the line and the stated range.
-  const priceHistory = useMemo(() => barHistory && appendLiveQuotePoint(barHistory, quote, { assetCategory }),
-    [assetCategory, barHistory, quote]);
+  const sparklineRef = useRef<PricePoint[] | undefined>(undefined);
+  const priceHistory = useMemo(() => {
+    if (!barHistory) return undefined;
+    const next = followLiveSparklinePrice(barHistory, quote, { assetCategory, period: chartPeriod, previous: sparklineRef.current });
+    sparklineRef.current = next;
+    return next;
+  }, [assetCategory, barHistory, chartPeriod, quote]);
   const flashFinancials = useMemo<TickerFinancials | null>(
     () => quote ? { quote, annualStatements: [], quarterlyStatements: [], priceHistory: [] } : null,
     [quote],

package/src/plugins/builtin/vol-surface/pane.tsx

@@ -21,6 +21,8 @@ import { useAutoRefresh } from "../../../react/auto-refresh";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { CLOUD_QUOTE_DELAY_MINUTES } from "../../../api-client/plan-access";
 import { useLiveSessionRefresh } from "../shared/volatility/live-session";
+import { getSharedMarketDataCoordinator } from "../../../market-data/coordinator";
+import { hasFreshReadyEntry } from "../../../market-data/coordinator/entries";
 import { createSurfaceDependencies, loadVolatilitySurface, withReusedYieldCurve, type SurfaceLoadRequest } from "./client";
 import { stableSurfaceSheet, SURFACE_LIVE_RELOAD_MS, surfaceFreshnessLabel, type SurfaceSheetAxes } from "./live";
 import { loadStoredSurface, loadSurfaceDates } from "../iv-history/client";
@@ -120,8 +122,20 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   // never collapses to the first few expiries while the rest reload.
   const [live, setLive] = useState<{ key: string; snapshot: SurfaceSnapshot; at: number } | null>(null);
   const liveController = useRef<AbortController | null>(null);
+  const settledRef = useRef<SurfaceSnapshot | null | undefined>(null);
   const liveDependencies = useMemo(() => withReusedYieldCurve(createSurfaceDependencies()), []);
   const reloadLive = useCallback(async () => {
+    const coordinator = getSharedMarketDataCoordinator();
+    const instrument = target?.instrument;
+    const chainInstrument = { symbol: target?.effectiveTicker ?? symbol!, exchange: target?.effectiveExchange ?? "",
+      brokerId: instrument?.brokerId, brokerInstanceId: instrument?.brokerInstanceId, instrument };
+    const shown = settledRef.current;
+    const expiries = shown?.expiries.map((entry) => entry.expiration) ?? [];
+    const freshChain = coordinator != null && expiries.length > 0 && expiries.every((expiration) => {
+      const entry = coordinator.getOptionsEntry({ instrument: chainInstrument, expirationDate: expiration });
+      return hasFreshReadyEntry(entry, SURFACE_LIVE_RELOAD_MS);
+    });
+    if (freshChain) return;
     liveController.current?.abort();
     const abort = new AbortController();
     liveController.current = abort;
@@ -129,10 +143,11 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
       // Each expiry is fitted as its chain arrives, never all together at the end.
       onSnapshot: () => {} }, liveDependencies);
     if (!abort.signal.aborted) setLive({ key: requestKey, snapshot, at: Date.now() });
-  }, [surfaceRequest, liveDependencies]);
+  }, [surfaceRequest, liveDependencies, symbol, target]);
   useEffect(() => () => liveController.current?.abort(), [reloadLive]);
   const liveReload = live?.key === requestKey && (resource.updatedAt == null || live.at > resource.updatedAt) ? live.snapshot : null;
   const settledSnapshot = liveReload ?? resource.data;
+  settledRef.current = settledSnapshot;
   // Stored close surfaces and IV rank come from the Cloud IV history of the underlying.
   const underlying = (target?.effectiveTicker ?? symbol ?? "").toUpperCase();
   const datesLoader = useCallback(async () => (await loadSurfaceDates(underlying)).dates, [underlying]);

package/src/plugins/builtin/volatility/chart-model.ts

@@ -141,7 +141,7 @@ export function volatilityHistorySeries(fred: FredChartInput, colors: Volatility
       const value = values.get(date);
       return { date: new Date(date), observedAt: new Date(date), value: value != null && Number.isFinite(value) ? value : null };
     }), { id, label, color, calendarSpaced: true }),
-    unit: unitGroup === "volatility" ? "%" : "", unitGroup, panelId,
+    unit: unitGroup === "volatility" ? "index" : "", unitGroup, panelId,
   });
   const first = dates[0], last = dates.at(-1);
   return [

package/src/plugins/builtin/volatility/charts.tsx

@@ -26,7 +26,7 @@ export function VolatilityHistoryChart({ fred, width, height, focused = false }:
   return <CompositeChart series={series} legendSeries={legendSeries} panels={HISTORY_PANELS} width={width} height={height}
     focused={focused} navigable={false} showLegend showTimeAxis remoteKind="vix-history"
     formatValue={(value, entry) => entry.unitGroup === "ratio" ? value.toFixed(2) : formatCompositeSeriesValue(value, entry)}
-    formatAxisValue={(value, domain) => domain.unitGroup === "ratio" ? value.toFixed(2) : `${value.toFixed(0)}%`}
+    formatAxisValue={(value, domain) => domain.unitGroup === "ratio" ? value.toFixed(2) : value.toFixed(0)}
     colors={{ background: palette.bgColor, grid: palette.gridColor, crosshair: palette.crosshairColor, text: colors.text,
       textDim: palette.axisColor, negative: colors.negative }} />;
 }

package/src/renderers/dom/styles.css

@@ -81,6 +81,12 @@ button, [data-gloom-interactive="true"] { cursor: pointer; }
 [data-titlebar-overlay="true"] * {
   cursor: inherit;
 }
+/* A row of text grows with the text size and the title bar does not: at the
+   largest sizes the top bar's buttons and prompt would stand out of it. */
+[data-gloom-role="app-header"][data-titlebar-overlay="true"] button,
+[data-gloom-role="app-header"][data-titlebar-overlay="true"] [role="button"] {
+  max-height: __TITLEBAR_OVERLAY_HEIGHT_PX__px;
+}
 [data-titlebar-overlay="true"] button,
 [data-titlebar-overlay="true"] input,
 [data-titlebar-overlay="true"] textarea,

package/src/sources/gloomberb-cloud/normalizers.ts

@@ -222,6 +222,7 @@ export function mapPricePoint(
     volume: point.volume,
     ...(point.partial === true ? { partial: true } : {}),
     ...(point.filled === true ? { filled: true } : {}),
+    ...(point.unsettled === true ? { unsettled: true } : {}),
   };
 }
 

package/src/sources/provider-router/batches.ts

@@ -73,7 +73,7 @@ export class ProviderRouterBatchRoutes {
         : isProviderQuoteUsableForCurrentSession(rawCached.value, target.exchange, target.symbol, { recentAnswer: !rawCached.stale }))
         ? rawCached
         : null;
-      if (cached && !forceRefresh && !cached.stale) {
+      if (cached && !forceRefresh && !cached.stale && !options.revalidate) {
         if (brokerSourceKeys.includes(cached.sourceKey)) {
           misses.push({ index, target });
           return;
@@ -81,6 +81,7 @@ export class ProviderRouterBatchRoutes {
         results[index] = { target, quote: cached.value };
         return;
       }
+      // Revalidated, a fresh copy is still what the quote route answers when no source does.
       misses.push({ index, target });
     });
 

package/src/sources/provider-router/cache.ts

@@ -9,6 +9,8 @@ import { brokerContractIdentityKey } from "../../utils/instrument-identity";
 import { providerFinancialsMatchTarget, providerQuoteMatchesTarget } from "./financials";
 
 const MARKET_NAMESPACE = "market";
+/** Quotes and price histories are read on every tick; their eviction order is refreshed at most this often. */
+const HOT_READ_TOUCH_MS = 10 * 60_000;
 // A record written under another version is a miss: bump these instead of
 // repairing older records on read.
 export const FINANCIALS_SCHEMA_VERSION = 13;
@@ -174,6 +176,7 @@ export function listCachedResources<T>(
     sourceKeys,
     allowExpired,
     ...(SCHEMA_VERSIONS[kind] ? { schemaVersion: SCHEMA_VERSIONS[kind] } : {}),
+    ...(kind === "quote" || kind === "price-history" || kind === "price-history-recheck" ? { touchIntervalMs: HOT_READ_TOUCH_MS } : {}),
   }).filter((record) => {
     if (!record.sourceKey.startsWith("provider:") || entityKey.startsWith("contract:")
       || (kind !== "financials" && kind !== "quote")) return true;

package/src/sync/baseline.ts

@@ -3,6 +3,7 @@ import type { SyncBaselineStore } from "./types";
 
 const BASELINE_PLUGIN_ID = "core.sync";
 const BASELINE_KEY = "last-synced-payloads";
+const MEMOS_KEY = "contributor-memos";
 
 /**
  * Persists what this device last pushed so the next pull can tell "the cloud is
@@ -13,20 +14,24 @@ const BASELINE_KEY = "last-synced-payloads";
  * local state, never to discarding it.
  */
 export function createSyncBaselineStore(pluginState: AppPluginStateStorePort): SyncBaselineStore {
+  const load = (key: string) => {
+    try {
+      return pluginState.get<Record<string, unknown>>(BASELINE_PLUGIN_ID, key)?.value ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const save = (key: string, value: Record<string, unknown>) => {
+    try {
+      pluginState.set(BASELINE_PLUGIN_ID, key, value);
+    } catch {
+      // Ignored: a stale baseline or memo only makes the next pull more conservative.
+    }
+  };
   return {
-    load: () => {
-      try {
-        return pluginState.get<Record<string, unknown>>(BASELINE_PLUGIN_ID, BASELINE_KEY)?.value ?? null;
-      } catch {
-        return null;
-      }
-    },
-    save: (payloads) => {
-      try {
-        pluginState.set(BASELINE_PLUGIN_ID, BASELINE_KEY, payloads);
-      } catch {
-        // Ignored: a stale baseline only makes the next pull more conservative.
-      }
-    },
+    load: () => load(BASELINE_KEY),
+    save: (payloads) => save(BASELINE_KEY, payloads),
+    loadMemos: () => load(MEMOS_KEY),
+    saveMemos: (memos) => save(MEMOS_KEY, memos),
   };
 }

package/src/sync/controller.ts

@@ -5,6 +5,7 @@ import { stableStringify } from "../utils/hash";
 import { VERSION } from "../version";
 import {
   SYNC_SNAPSHOT_SCHEMA_VERSION,
+  SyncRevisionConflictError,
   type RegisteredSyncContributor,
   type RegisteredSyncTransport,
   type SyncBaselineStore,
@@ -35,6 +36,16 @@ interface SyncRuntime {
 
 const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
 const PUSH_DEBOUNCE_MS = 2500;
+/** How soon after a change contributors date it, so an edit made just before quitting still is. */
+const OBSERVE_DEBOUNCE_MS = 250;
+/** Pushes refused because another device wrote first, each followed by a fresh pull, before giving up until the next sync. */
+const MAX_CONFLICT_RETRIES = 3;
+
+/** What one pull left behind: the stored revision it merged with (0 for none) and that copy's content. */
+interface PullResult {
+  revision: number | null;
+  signature: string | null;
+}
 
 function nowIso(): string {
   return new Date().toISOString();
@@ -49,13 +60,17 @@ function resolveClientId(): string {
   return id;
 }
 
+/**
+ * The content of a snapshot as it reads once stored, so one assembled here
+ * (with fields left undefined) compares equal to the same one pulled back.
+ */
 function snapshotContentSignature(snapshot: SyncSnapshot): string {
-  return stableStringify(Object.fromEntries(
+  return stableStringify(JSON.parse(JSON.stringify(Object.fromEntries(
     Object.entries(snapshot.contributors).map(([id, contributor]) => [
       id,
       { schemaVersion: contributor.schemaVersion, payload: contributor.payload },
     ]),
-  ));
+  ))));
 }
 
 export class CloudSyncController {
@@ -64,6 +79,10 @@ export class CloudSyncController {
   private transports = new Map<string, RegisteredSyncTransport>();
   private listeners = new Set<() => void>();
   private pushTimer: ReturnType<typeof setTimeout> | null = null;
+  private observeTimer: ReturnType<typeof setTimeout> | null = null;
+  private observedSinceStart = false;
+  private memos: Record<string, unknown> | null = null;
+  private memosLoaded = false;
   private inFlight: Promise<void> | null = null;
   private syncQueued = false;
   private clientId: string | null = null;
@@ -141,6 +160,7 @@ export class CloudSyncController {
   schedulePush(reason: string): void {
     const runtime = this.runtime;
     if (!runtime) return;
+    this.scheduleObserve(runtime);
     const registration = runtime.getTransport();
     if (!registration?.transport.isAvailable()) {
       this.setStatus({
@@ -176,6 +196,7 @@ export class CloudSyncController {
   private async syncOnce(options: { reason?: string; force?: boolean }): Promise<void> {
     const runtime = this.runtime;
     if (!runtime) return;
+    this.observe(runtime);
     const registration = runtime.getTransport();
     if (!registration?.transport.isAvailable()) {
       this.setStatus({
@@ -187,53 +208,72 @@ export class CloudSyncController {
     }
     const transport = registration.transport;
 
-    // Always pull before push. Another device (TUI, browser, phone) may have
-    // written since this process last synced, and contributors already merge
-    // so local-only edits survive the apply.
-    if (!await this.runPull(runtime, transport)) return;
-    if (!this.isCurrent(runtime, transport)) return;
+    for (let attempt = 0; ; attempt += 1) {
+      // Always pull before push. Another device (TUI, browser, phone) may have
+      // written since this process last synced, and contributors already merge
+      // so local-only edits survive the apply.
+      const pulled = await this.runPull(runtime, transport);
+      if (!pulled || !this.isCurrent(runtime, transport)) return;
 
-    const snapshot = await this.assembleSnapshot(runtime);
-    if (!this.isCurrent(runtime, transport)) return;
-    const signature = snapshotContentSignature(snapshot);
-    if (!options.force && signature === this.lastSignature) return;
-
-    this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
-    try {
-      const result = await transport.pushSnapshot(snapshot, { baseRevision: this.status.revision });
-      if (!this.isCurrent(runtime, transport)) return;
-      this.lastSignature = signature;
-      this.appliedRevision = result.revision;
-      this.saveBaseline(runtime, snapshot);
-      this.setStatus({
-        phase: "synced",
-        transportId: transport.id,
-        revision: result.revision,
-        lastSyncAt: result.updatedAt,
-        error: null,
-      });
-    } catch (error) {
+      const snapshot = await this.assembleSnapshot(runtime);
       if (!this.isCurrent(runtime, transport)) return;
-      this.setStatus({
-        phase: "error",
-        transportId: transport.id,
-        error: error instanceof Error ? error.message : String(error),
-      });
+      const signature = snapshotContentSignature(snapshot);
+      if (!options.force && signature === this.lastSignature) return;
+      if (!options.force && signature === pulled.signature) {
+        // The cloud already holds exactly this: pushing it back would only
+        // bump the revision under another device's next push.
+        this.lastSignature = signature;
+        this.saveBaseline(runtime, snapshot);
+        return;
+      }
+
+      this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
+      try {
+        // The revision this snapshot was merged with. The cloud refuses the
+        // write if another device wrote since, instead of losing that write.
+        const result = await transport.pushSnapshot(snapshot, { baseRevision: pulled.revision });
+        if (!this.isCurrent(runtime, transport)) return;
+        this.lastSignature = signature;
+        this.appliedRevision = result.revision;
+        this.saveBaseline(runtime, snapshot);
+        this.setStatus({
+          phase: "synced",
+          transportId: transport.id,
+          revision: result.revision,
+          lastSyncAt: result.updatedAt,
+          error: null,
+        });
+        return;
+      } catch (error) {
+        if (!this.isCurrent(runtime, transport)) return;
+        if (error instanceof SyncRevisionConflictError && attempt < MAX_CONFLICT_RETRIES) {
+          // Pull whatever the other device wrote, even an older revision than
+          // this process last saw (an account switch, a restored snapshot).
+          this.appliedRevision = null;
+          continue;
+        }
+        this.setStatus({
+          phase: "error",
+          transportId: transport.id,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+      }
     }
   }
 
-  private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<boolean> {
+  private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<PullResult | null> {
     const baselineState = runtime.getState();
     this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
     try {
       const response = await transport.pullSnapshot();
-      if (!this.isCurrent(runtime, transport)) return false;
+      if (!this.isCurrent(runtime, transport)) return null;
 
       if (response.snapshot && this.shouldApplyPulledRevision(response.revision)) {
         this.assertSnapshotCompatible(response.snapshot, runtime.getContributors());
         this.pulledContributors = response.snapshot.contributors;
         for (const entry of runtime.getContributors()) {
-          if (!this.isCurrent(runtime, transport)) return false;
+          if (!this.isCurrent(runtime, transport)) return null;
           const contributorPayload = response.snapshot.contributors[entry.contributor.id];
           if (!contributorPayload || !entry.contributor.apply) continue;
           await entry.contributor.apply(contributorPayload.payload, {
@@ -245,12 +285,13 @@ export class CloudSyncController {
             isCurrent: () => this.isCurrent(runtime, transport),
             dispatch: runtime.dispatch,
             tickerRepository: runtime.tickerRepository,
+            memo: this.memoFor(runtime, entry.contributor.id),
           });
         }
         if (response.revision != null) this.appliedRevision = response.revision;
       }
 
-      if (!this.isCurrent(runtime, transport)) return false;
+      if (!this.isCurrent(runtime, transport)) return null;
       this.setStatus({
         phase: response.snapshot ? "synced" : "idle",
         transportId: transport.id,
@@ -259,15 +300,18 @@ export class CloudSyncController {
         lastSyncAt: response.updatedAt ?? this.status.lastSyncAt,
         error: null,
       });
-      return true;
+      return {
+        revision: response.snapshot ? response.revision : 0,
+        signature: response.snapshot ? snapshotContentSignature(response.snapshot) : null,
+      };
     } catch (error) {
-      if (!this.isCurrent(runtime, transport)) return false;
+      if (!this.isCurrent(runtime, transport)) return null;
       this.setStatus({
         phase: "error",
         transportId: transport.id,
         error: error instanceof Error ? error.message : String(error),
       });
-      return false;
+      return null;
     }
   }
 
@@ -302,7 +346,11 @@ export class CloudSyncController {
     // carried over instead of being deleted for every other device.
     const payloads: SyncSnapshot["contributors"] = { ...this.pulledContributors };
     for (const entry of contributors) {
-      const payload = await entry.contributor.collect({ state: runtime.getState() });
+      const payload = await entry.contributor.collect({
+        state: runtime.getState(),
+        baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
+        memo: this.memoFor(runtime, entry.contributor.id),
+      });
       payloads[entry.contributor.id] = {
         schemaVersion: entry.contributor.schemaVersion,
         updatedAt: createdAt,
@@ -327,6 +375,53 @@ export class CloudSyncController {
     return this.baseline;
   }
 
+  private scheduleObserve(runtime: SyncRuntime): void {
+    if (this.observeTimer) clearTimeout(this.observeTimer);
+    this.observeTimer = setTimeout(() => {
+      this.observeTimer = null;
+      if (this.runtime === runtime) this.observe(runtime);
+    }, OBSERVE_DEBOUNCE_MS);
+  }
+
+  /** Lets contributors date local edits as they happen, whether or not the cloud is reachable. */
+  private observe(runtime: SyncRuntime): void {
+    const launch = !this.observedSinceStart;
+    this.observedSinceStart = true;
+    for (const entry of runtime.getContributors()) {
+      if (!entry.contributor.observe) continue;
+      try {
+        entry.contributor.observe({
+          state: runtime.getState(),
+          baselinePayload: this.loadBaseline(runtime)?.[entry.contributor.id] ?? null,
+          memo: this.memoFor(runtime, entry.contributor.id),
+          launch,
+        });
+      } catch {
+        // A contributor that cannot date an edit leaves it undated, which only
+        // makes it lose a conflict it might have won.
+      }
+    }
+  }
+
+  private memoFor(runtime: SyncRuntime, contributorId: string) {
+    return {
+      get: () => this.loadMemos(runtime)[contributorId] ?? null,
+      set: (value: unknown) => {
+        const memos = { ...this.loadMemos(runtime), [contributorId]: value };
+        this.memos = memos;
+        runtime.baselineStore?.saveMemos?.(memos);
+      },
+    };
+  }
+
+  private loadMemos(runtime: SyncRuntime): Record<string, unknown> {
+    if (!this.memosLoaded) {
+      this.memosLoaded = true;
+      this.memos = runtime.baselineStore?.loadMemos?.() ?? null;
+    }
+    return this.memos ?? {};
+  }
+
   private saveBaseline(runtime: SyncRuntime, snapshot: SyncSnapshot): void {
     const payloads = Object.fromEntries(
       Object.entries(snapshot.contributors).map(([id, contributor]) => [id, contributor.payload]),
@@ -353,6 +448,11 @@ export class CloudSyncController {
   private resetOperations(): void {
     if (this.pushTimer) clearTimeout(this.pushTimer);
     this.pushTimer = null;
+    if (this.observeTimer) clearTimeout(this.observeTimer);
+    this.observeTimer = null;
+    this.observedSinceStart = false;
+    this.memos = null;
+    this.memosLoaded = false;
     this.inFlight = null;
     this.syncQueued = false;
     this.lastSignature = null;