gloomberb 0.7.2 → 0.7.4

package/src/sources/yahoo-finance.test.ts

@@ -33,6 +33,43 @@ describe("YahooFinanceClient exchange aliases", () => {
     expect(history[0]?.close).toBe(200);
   });
 
+  test("maps IBKR option symbols to Yahoo option quote marks", async () => {
+    const provider = new YahooFinanceClient() as any;
+    provider.getOptionsChain = async (ticker: string, _exchange: string, expirationDate: number) => ({
+      underlyingSymbol: ticker,
+      expirationDates: [expirationDate],
+      calls: [{
+        contractSymbol: "AMD270917C00230000",
+        strike: 230,
+        currency: "USD",
+        lastPrice: 251,
+        change: 1.5,
+        percentChange: 0.6,
+        volume: 10,
+        openInterest: 20,
+        bid: 250.25,
+        ask: 254.5,
+        impliedVolatility: 0.4,
+        inTheMoney: false,
+        expiration: expirationDate,
+        lastTradeDate: 1_800_000_000,
+      }],
+      puts: [],
+    });
+
+    const quote = await provider.getQuote("AMD   270917C00230000");
+
+    expect(quote).toMatchObject({
+      symbol: "AMD   270917C00230000",
+      price: 252.375,
+      mark: 252.375,
+      bid: 250.25,
+      ask: 254.5,
+      providerId: "yahoo",
+    });
+    expect(quote.lastUpdated).toBe(1_800_000_000_000);
+  });
+
   test("preserves analyst rating price targets from upgrade history", async () => {
     const provider = new YahooFinanceClient() as any;
     let requestUrl = "";

package/src/sources/yahoo-finance.ts

@@ -7,6 +7,7 @@ import {
   type ManualChartResolution,
 } from "../components/chart/chart-resolution";
 import type { InstrumentSearchResult } from "../types/instrument";
+import { parseOptionSymbol } from "../utils/options";
 import { SecEdgarClient } from "./sec-edgar";
 
 // Exchange suffix mapping for Yahoo Finance ticker symbols
@@ -755,7 +756,7 @@ export class YahooFinanceClient implements DataProvider {
     const history: PricePoint[] = [];
     for (let i = 0; i < result.timestamp.length; i++) {
       const close = quote.close?.[i];
-      if (close == null || Number.isNaN(close)) continue;
+      if (close == null || !Number.isFinite(close) || close <= 0) continue;
       history.push({
         date: new Date((result.timestamp[i]!) * 1000),
         open: quote.open?.[i] ?? undefined,
@@ -1047,8 +1048,53 @@ export class YahooFinanceClient implements DataProvider {
     };
   }
 
+  private async getOptionQuote(ticker: string, context?: MarketDataRequestContext): Promise<Quote> {
+    const parsed = parseOptionSymbol(ticker);
+    if (!parsed) throw new Error(`Unsupported option symbol ${ticker}`);
+    const chain = await this.getOptionsChain(parsed.underlying, "", parsed.expTs, context);
+    const contracts = parsed.side === "C" ? chain.calls : chain.puts;
+    const contract = contracts.find((candidate) =>
+      Math.abs(candidate.strike - parsed.strike) < 0.001 &&
+      candidate.expiration === parsed.expTs
+    );
+    if (!contract) throw new Error(`No option contract for ${ticker}`);
+
+    const mark = contract.bid > 0 && contract.ask > 0
+      ? (contract.bid + contract.ask) / 2
+      : contract.bid > 0
+        ? contract.bid
+        : contract.ask > 0
+          ? contract.ask
+          : undefined;
+    return {
+      symbol: ticker,
+      providerId: this.id,
+      price: mark ?? contract.lastPrice,
+      currency: contract.currency || "USD",
+      change: contract.change,
+      changePercent: contract.percentChange,
+      volume: contract.volume,
+      bid: contract.bid,
+      ask: contract.ask,
+      mark,
+      name: contract.contractSymbol,
+      lastUpdated: contract.lastTradeDate > 0
+        ? contract.lastTradeDate * 1000
+        : Date.now(),
+      exchangeName: "OPTIONS",
+      fullExchangeName: "OPTIONS",
+      listingExchangeName: "OPTIONS",
+      listingExchangeFullName: "OPTIONS",
+      dataSource: "delayed",
+    };
+  }
+
   /** Fetch just a quote (lighter weight) */
-  async getQuote(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<Quote> {
+  async getQuote(ticker: string, exchange = "", context?: MarketDataRequestContext): Promise<Quote> {
+    if (parseOptionSymbol(ticker)) {
+      return this.getOptionQuote(ticker, context);
+    }
+
     const symbolsToTry = this.getSymbolsToTry(ticker, exchange);
     let lastError: any;
 

package/src/state/app-bootstrap.test.ts

@@ -408,8 +408,28 @@ describe("initializeAppState", () => {
       custom: {},
       tags: [],
     });
+    const hydrationSymbols = [
+      "AAPL",
+      ...Array.from({ length: 13 }, (_, index) => `T${String(index + 1).padStart(2, "0")}`),
+    ];
+    for (const symbol of hydrationSymbols.slice(1)) {
+      await tickerRepository.createTicker({
+        ticker: symbol,
+        exchange: "NASDAQ",
+        currency: "USD",
+        name: symbol,
+        portfolios: [],
+        watchlists: ["main"],
+        positions: [],
+        broker_contracts: [],
+        custom: {},
+        tags: [],
+      });
+    }
 
     const events: string[] = [];
+    const cachedTargetRequests: string[] = [];
+    const financialRefreshes: string[] = [];
 
     await initializeAppState({
       config: quoteOnlyConfig,
@@ -417,23 +437,26 @@ describe("initializeAppState", () => {
       dataProvider: {
         id: "test-provider",
         name: "Test Provider",
-        getCachedFinancialsForTargets: () => new Map([["AAPL", {
-          annualStatements: [],
-          quarterlyStatements: [],
-          priceHistory: [],
-          quote: {
-            symbol: "AAPL",
-            price: 200,
-            currency: "USD",
-            change: 1,
-            changePercent: 0.5,
-            marketCap: 2_000_000_000,
-            lastUpdated: Date.now(),
-          },
-          fundamentals: {
-            trailingPE: 25,
-          },
-        }]]),
+        getCachedFinancialsForTargets: (targets: Array<{ symbol: string }>) => {
+          cachedTargetRequests.push(...targets.map((target) => target.symbol));
+          return new Map(targets.map((target) => [target.symbol, {
+            annualStatements: [],
+            quarterlyStatements: [],
+            priceHistory: [],
+            quote: {
+              symbol: target.symbol,
+              price: 200,
+              currency: "USD",
+              change: 1,
+              changePercent: 0.5,
+              marketCap: 2_000_000_000,
+              lastUpdated: Date.now(),
+            },
+            fundamentals: {
+              trailingPE: 25,
+            },
+          }]));
+        },
       } as any,
       sessionSnapshot: {
         paneState: {
@@ -446,11 +469,11 @@ describe("initializeAppState", () => {
         activePanel: "left",
         statusBarVisible: true,
         openPaneIds: ["portfolio-list:main"],
-        hydrationTargets: [{
-          symbol: "AAPL",
+        hydrationTargets: hydrationSymbols.map((symbol) => ({
+          symbol,
           exchange: "NASDAQ",
           instrument: null,
-        }],
+        })),
         exchangeCurrencies: [],
         savedAt: Date.now(),
       },
@@ -458,13 +481,17 @@ describe("initializeAppState", () => {
       primeCachedFinancials: (entries) => {
         events.push(`prime:${entries.map((entry) => entry.ticker.metadata.ticker).join(",")}`);
       },
-      refreshTicker: () => {},
+      refreshTicker: (symbol) => { financialRefreshes.push(symbol); },
       refreshQuote: () => {},
       autoImportBrokerPositions: async () => {},
     });
 
-    expect(events).toContain("prime:AAPL");
-    expect(events.indexOf("prime:AAPL")).toBeLessThan(events.indexOf("SET_INITIALIZED"));
+    const primeEvent = events.find((event) => event.startsWith("prime:"));
+    expect(primeEvent).toContain("AAPL");
+    expect(primeEvent).toContain("T13");
+    expect(cachedTargetRequests).toContain("T13");
+    expect(financialRefreshes).not.toContain("T13");
+    expect(events.indexOf(primeEvent!)).toBeLessThan(events.indexOf("SET_INITIALIZED"));
 
     persistence.close();
   });

package/src/state/app-bootstrap.ts

@@ -37,11 +37,11 @@ interface RefreshPlanEntry {
 }
 
 const MAX_BACKGROUND_WARMUP_TICKERS = 12;
-const PORTFOLIO_FINANCIAL_COLUMN_IDS = new Set([
-  "market_cap",
+const PORTFOLIO_FULL_SNAPSHOT_COLUMN_IDS = new Set([
   "pe",
   "forward_pe",
   "dividend_yield",
+  "sparkline",
 ]);
 const startupLog = debugLog.createLogger("startup");
 
@@ -157,7 +157,7 @@ function buildRefreshPlan(
     const columnIds = Array.isArray(instance.settings?.columnIds)
       ? instance.settings.columnIds.filter((value): value is string => typeof value === "string")
       : [];
-    return columnIds.some((columnId) => PORTFOLIO_FINANCIAL_COLUMN_IDS.has(columnId))
+    return columnIds.some((columnId) => PORTFOLIO_FULL_SNAPSHOT_COLUMN_IDS.has(columnId))
       ? "financials"
       : "quote";
   };
@@ -216,26 +216,39 @@ function buildCachedFinancialTarget(ticker: TickerRecord): CachedFinancialsTarge
 async function resolveCachedFinancialPrimeEntries(
   refreshPlan: RefreshPlanEntry[],
   sessionSnapshot: AppSessionSnapshot | null | undefined,
+  tickerMap: Map<string, TickerRecord>,
   dataProvider: DataProvider,
 ): Promise<Array<{ ticker: TickerRecord; financials: TickerFinancials }>> {
   if (!dataProvider.getCachedFinancialsForTargets) return [];
 
-  const sessionTargetsBySymbol = new Map<string, CachedFinancialsTarget>();
+  const targetEntriesBySymbol = new Map<string, { ticker: TickerRecord; target: CachedFinancialsTarget }>();
   for (const target of sessionSnapshot?.hydrationTargets ?? []) {
-    sessionTargetsBySymbol.set(target.symbol.trim().toUpperCase(), target);
+    const symbol = target.symbol.trim().toUpperCase();
+    const ticker = tickerMap.get(symbol);
+    if (ticker) {
+      targetEntriesBySymbol.set(symbol, { ticker, target });
+    }
   }
 
-  const financialEntries = refreshPlan.filter((entry) => entry.mode === "financials");
-  if (financialEntries.length === 0) return [];
+  for (const entry of refreshPlan.filter((entry) => entry.mode === "financials")) {
+    const symbol = entry.ticker.metadata.ticker.trim().toUpperCase();
+    if (!targetEntriesBySymbol.has(symbol)) {
+      targetEntriesBySymbol.set(symbol, {
+        ticker: entry.ticker,
+        target: buildCachedFinancialTarget(entry.ticker),
+      });
+    }
+  }
 
+  const targetEntries = [...targetEntriesBySymbol.values()];
+  if (targetEntries.length === 0) return [];
   const cachedFinancials = await dataProvider.getCachedFinancialsForTargets(
-    financialEntries.map(({ ticker }) => (
-      sessionTargetsBySymbol.get(ticker.metadata.ticker.trim().toUpperCase()) ?? buildCachedFinancialTarget(ticker)
-    )),
+    targetEntries.map((entry) => entry.target),
+    { includeStaleQuotes: true },
   );
   const primedEntries: Array<{ ticker: TickerRecord; financials: TickerFinancials }> = [];
 
-  for (const entry of financialEntries) {
+  for (const entry of targetEntries) {
     const cached = cachedFinancials.get(entry.ticker.metadata.ticker.trim().toUpperCase());
     if (cached) {
       primedEntries.push({ ticker: entry.ticker, financials: cached });
@@ -347,8 +360,11 @@ export async function initializeAppState({
   if (primeCachedFinancials) {
     const cachedPrimeEntries = await measurePerfAsync(
       "startup.resolve-cached-financial-prime",
-      () => resolveCachedFinancialPrimeEntries(refreshPlan, sessionSnapshot, dataProvider),
-      { financialRefreshCount: refreshPlan.filter((entry) => entry.mode === "financials").length },
+      () => resolveCachedFinancialPrimeEntries(refreshPlan, sessionSnapshot, tickerMap, dataProvider),
+      {
+        financialRefreshCount: refreshPlan.filter((entry) => entry.mode === "financials").length,
+        sessionHydrationTargetCount: sessionSnapshot?.hydrationTargets.length ?? 0,
+      },
     );
     if (cachedPrimeEntries.length > 0) {
       measurePerf("startup.prime-cached-financials", () => {

package/src/state/app-context.test.ts

@@ -329,6 +329,64 @@ describe("pane state updates", () => {
 
     expect(next).toBe(initial);
   });
+
+  test("keeps pane runtime state scoped to each saved layout", () => {
+    let state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
+    const originalLayoutIndex = state.config.activeLayoutIndex;
+
+    state = appReducer(state, {
+      type: "UPDATE_PANE_STATE",
+      paneId: "ticker-detail:main",
+      patch: { activeTabId: "chart" },
+    });
+    state = appReducer(state, { type: "DUPLICATE_LAYOUT", index: originalLayoutIndex });
+    const duplicateLayoutIndex = state.config.activeLayoutIndex;
+
+    state = appReducer(state, {
+      type: "UPDATE_PANE_STATE",
+      paneId: "ticker-detail:main",
+      patch: { activeTabId: "financials" },
+    });
+
+    expect(state.config.layouts[duplicateLayoutIndex]?.paneState?.["ticker-detail:main"]?.activeTabId).toBe("financials");
+
+    state = appReducer(state, { type: "SWITCH_LAYOUT", index: originalLayoutIndex });
+    expect(state.paneState["ticker-detail:main"]?.activeTabId).toBe("chart");
+    expect(state.config.layouts[originalLayoutIndex]?.paneState?.["ticker-detail:main"]?.activeTabId).toBe("chart");
+
+    state = appReducer(state, { type: "SWITCH_LAYOUT", index: duplicateLayoutIndex });
+    expect(state.paneState["ticker-detail:main"]?.activeTabId).toBe("financials");
+  });
+
+  test("hydrates saved layout pane state before legacy session pane state", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    config.layouts[config.activeLayoutIndex] = {
+      ...config.layouts[config.activeLayoutIndex]!,
+      paneState: {
+        "ticker-detail:main": { activeTabId: "chart" },
+      },
+      focusedPaneId: "ticker-detail:main",
+      activePanel: "right",
+    };
+    const sessionSnapshot: AppSessionSnapshot = {
+      paneState: {
+        "ticker-detail:main": { activeTabId: "overview" },
+      },
+      focusedPaneId: "portfolio-list:main",
+      activePanel: "left",
+      statusBarVisible: true,
+      openPaneIds: ["portfolio-list:main", "ticker-detail:main"],
+      hydrationTargets: [],
+      exchangeCurrencies: ["USD"],
+      savedAt: Date.now(),
+    };
+
+    const state = createInitialState(config, sessionSnapshot);
+
+    expect(state.paneState["ticker-detail:main"]?.activeTabId).toBe("chart");
+    expect(state.focusedPaneId).toBe("ticker-detail:main");
+    expect(state.activePanel).toBe("right");
+  });
 });
 
 describe("quote merging", () => {
@@ -487,6 +545,61 @@ describe("quote merging", () => {
 });
 
 describe("layout focus fallback", () => {
+  test("switching to an old layout without focused metadata uses that layout's top floating pane", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const targetLayout = {
+      ...cloneLayout(config.layout),
+      dockRoot: null,
+      floating: [
+        { instanceId: "chat:main", x: 4, y: 2, width: 36, height: 10, zIndex: 70 },
+        { instanceId: "ticker-detail:main", x: 12, y: 4, width: 36, height: 10, zIndex: 95 },
+      ],
+    };
+    config.layouts = [
+      { name: "Current", layout: cloneLayout(config.layout), paneState: {} },
+      { name: "Floating", layout: cloneLayout(targetLayout), paneState: {} },
+    ];
+    config.activeLayoutIndex = 0;
+
+    let state = createInitialState(config);
+    state = appReducer(state, { type: "FOCUS_PANE", paneId: "chat:main" });
+    state = appReducer(state, { type: "SWITCH_LAYOUT", index: 1 });
+
+    const chatEntry = state.config.layout.floating.find((entry) => entry.instanceId === "chat:main");
+    const tickerEntry = state.config.layout.floating.find((entry) => entry.instanceId === "ticker-detail:main");
+    expect(state.focusedPaneId).toBe("ticker-detail:main");
+    expect((tickerEntry?.zIndex ?? 0) > (chatEntry?.zIndex ?? 0)).toBe(true);
+  });
+
+  test("switching layouts raises the saved focused floating pane above stale z-order", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const targetLayout = {
+      ...cloneLayout(config.layout),
+      dockRoot: null,
+      floating: [
+        { instanceId: "chat:main", x: 4, y: 2, width: 36, height: 10, zIndex: 70 },
+        { instanceId: "ticker-detail:main", x: 12, y: 4, width: 36, height: 10, zIndex: 95 },
+      ],
+    };
+    config.layouts = [
+      { name: "Current", layout: cloneLayout(config.layout), paneState: {} },
+      {
+        name: "Floating",
+        layout: cloneLayout(targetLayout),
+        paneState: {},
+        focusedPaneId: "chat:main",
+      },
+    ];
+    config.activeLayoutIndex = 0;
+
+    const state = appReducer(createInitialState(config), { type: "SWITCH_LAYOUT", index: 1 });
+
+    const chatEntry = state.config.layout.floating.find((entry) => entry.instanceId === "chat:main");
+    const tickerEntry = state.config.layout.floating.find((entry) => entry.instanceId === "ticker-detail:main");
+    expect(state.focusedPaneId).toBe("chat:main");
+    expect((chatEntry?.zIndex ?? 0) > (tickerEntry?.zIndex ?? 0)).toBe(true);
+  });
+
   test("starts with the top floating pane focused when no session pane is active", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     const layout = {

package/src/state/app-context.tsx

@@ -37,6 +37,7 @@ import {
   type PaneRuntimeState,
   resolveCollectionForPane,
   resolveTickerForPane,
+  syncConfigActiveLayoutState,
 } from "../core/state/app-state";
 import type { AppAction, AppState } from "../core/state/app-state";
 import { scheduleConfigSave } from "./config-save-scheduler";
@@ -50,6 +51,7 @@ export {
   getPaneState,
   resolveCollectionForPane,
   resolveFinancialsForPane,
+  syncConfigActiveLayoutState,
   resolveTickerFileForPane,
   resolveTickerForPane,
 } from "../core/state/app-state";
@@ -283,10 +285,12 @@ export function usePaneSettingValue<T>(
       ? (nextValue as (previousValue: T) => T)(currentValue)
       : nextValue;
     const layout = setPaneSetting(currentState.config.layout, scopedPaneId, key, resolved);
-    const layouts = currentState.config.layouts.map((savedLayout, index) => (
-      index === currentState.config.activeLayoutIndex ? { ...savedLayout, layout } : savedLayout
-    ));
-    const nextConfig = { ...currentState.config, layout, layouts };
+    const nextConfig = syncConfigActiveLayoutState(
+      { ...currentState.config, layout },
+      currentState.paneState,
+      currentState.focusedPaneId,
+      currentState.activePanel,
+    );
     dispatch({ type: "SET_CONFIG", config: nextConfig });
     scheduleConfigSave(nextConfig);
   }, [dispatch, fallback, key, scopedPaneId, stateRef]);

package/src/state/session-persistence.test.ts

@@ -24,7 +24,10 @@ function createTicker(symbol: string, exchange = "NASDAQ"): TickerRecord {
 describe("session persistence", () => {
   test("builds a working-set snapshot from runtime state", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
-    const tickers = new Map<string, TickerRecord>([["AAPL", createTicker("AAPL")]]);
+    const tickers = new Map<string, TickerRecord>([
+      ["AAPL", createTicker("AAPL")],
+      ["MSFT", createTicker("MSFT")],
+    ]);
     const financials = new Map<string, TickerFinancials>([["AAPL", {
       annualStatements: [],
       quarterlyStatements: [],
@@ -61,8 +64,7 @@ describe("session persistence", () => {
     });
 
     expect(snapshot.focusedPaneId).toBe("ticker-detail:main");
-    expect(snapshot.hydrationTargets).toHaveLength(1);
-    expect(snapshot.hydrationTargets[0]?.symbol).toBe("AAPL");
+    expect(snapshot.hydrationTargets.map((target) => target.symbol)).toEqual(["AAPL", "MSFT"]);
     expect(snapshot.exchangeCurrencies).toContain("JPY");
     expect(snapshot.paneState["portfolio-list:main"]).toEqual({
       cursorSymbol: "AAPL",

package/src/state/use-inline-tickers.ts

@@ -152,6 +152,9 @@ export function useInlineTickers(texts: readonly string[]): {
       return {
         symbol: ticker.metadata.ticker,
         exchange: ticker.metadata.exchange,
+        surface: "inline" as const,
+        visible: true,
+        weight: 40,
         context: instrument
           ? {
             brokerId: instrument.brokerId,

package/src/state/use-quote-streaming.ts

@@ -22,6 +22,7 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
     ?? target.context?.instrument?.localSymbol
     ?? target.context?.instrument?.symbol
     ?? "";
+  const weight = Number.isFinite(target.weight) ? String(target.weight) : "";
   return [
     target.symbol,
     target.exchange ?? "",
@@ -29,6 +30,10 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
     target.context?.brokerInstanceId ?? "",
     contractKey,
     target.route ?? "auto",
+    target.surface ?? "",
+    target.visible ? "visible" : "",
+    target.selected ? "selected" : "",
+    weight,
   ].join("|");
 }
 
@@ -68,6 +73,12 @@ export function useQuoteStreaming(targets: QuoteSubscriptionTarget[]): void {
         brokerInstanceId: target.context?.brokerInstanceId,
         instrument: target.context?.instrument ?? null,
       },
+      priority: {
+        surface: target.surface,
+        visible: target.visible,
+        selected: target.selected,
+        weight: target.weight,
+      },
     })));
     return () => {
       quoteStreamLog.info("unsubscribe", {

package/src/theme/colors.ts

@@ -73,21 +73,20 @@ export function syncTheme(id: string): void {
 
 export { blendHex } from "./color-utils";
 
-const COMPARISON_SERIES_COLORS = [
-  "#5bc0eb",
-  "#f6ae2d",
-  "#f26419",
-  "#6f2dbd",
-  "#00a896",
-  "#ef476f",
-  "#118ab2",
-  "#8ac926",
-  "#ff7f51",
-  "#4361ee",
-] as const;
-
 export function getComparisonSeriesColor(index: number): string {
-  return COMPARISON_SERIES_COLORS[((index % COMPARISON_SERIES_COLORS.length) + COMPARISON_SERIES_COLORS.length) % COMPARISON_SERIES_COLORS.length]!;
+  const seriesColors = [
+    colors.borderFocused,
+    colors.warning,
+    colors.positive,
+    colors.negative,
+    colors.textBright,
+    colors.neutral,
+    blendHex(colors.borderFocused, colors.positive, 0.45),
+    blendHex(colors.warning, colors.negative, 0.35),
+    blendHex(colors.textBright, colors.positive, 0.35),
+    blendHex(colors.borderFocused, colors.negative, 0.35),
+  ];
+  return seriesColors[((index % seriesColors.length) + seriesColors.length) % seriesColors.length]!;
 }
 
 /** Returns a hover background color derived from bg and selected */

package/src/types/config.ts

@@ -1,8 +1,8 @@
 import type { Portfolio, Watchlist } from "./ticker";
 
-export const CURRENT_CONFIG_VERSION = 15;
+export const CURRENT_CONFIG_VERSION = 16;
 
-export type DefaultChartRenderMode = "area" | "line" | "candles" | "ohlc";
+export type DefaultChartRenderMode = "area" | "line" | "candles" | "ohlc" | "hlc";
 export type ChartRendererPreference = "auto" | "kitty" | "braille";
 
 export interface ChartPreferences {
@@ -108,8 +108,12 @@ export interface LayoutConfig {
 }
 
 export interface SavedLayout {
+  id?: string;
   name: string;
   layout: LayoutConfig;
+  paneState?: Record<string, Record<string, unknown>>;
+  focusedPaneId?: string | null;
+  activePanel?: "left" | "right";
 }
 
 export interface AppConfig {
@@ -154,6 +158,7 @@ export const DEFAULT_COLUMNS: ColumnConfig[] = [
 
 export const DEFAULT_PORTFOLIO_COLUMN_IDS = [
   ...DEFAULT_COLUMNS.map((column) => column.id),
+  "sparkline",
   "shares",
   "avg_cost",
   "cost_basis",
@@ -585,8 +590,8 @@ export function createDefaultConfig(dataDir: string): AppConfig {
     watchlists: [{ id: "watchlist", name: "Watchlist" }],
     layout,
     layouts: [
-      { name: "Home", layout: cloneLayout(layout) },
-      { name: "Monitor", layout: cloneLayout(DEFAULT_MONITOR_LAYOUT) },
+      { name: "Home", layout: cloneLayout(layout), paneState: {} },
+      { name: "Monitor", layout: cloneLayout(DEFAULT_MONITOR_LAYOUT), paneState: {} },
     ],
     activeLayoutIndex: 0,
     brokerInstances: [],

package/src/types/data-provider.ts

@@ -90,6 +90,10 @@ export interface QuoteSubscriptionTarget {
   exchange?: string;
   context?: MarketDataRequestContext;
   route?: "auto" | "provider" | "broker";
+  surface?: "portfolio" | "watchlist" | "detail" | "monitor" | "inline" | "screener" | "unknown";
+  visible?: boolean;
+  selected?: boolean;
+  weight?: number;
 }
 
 export interface QuoteBatchResult {
@@ -111,7 +115,7 @@ export interface AssetDataProvider {
   readonly cachePolicy?: CachePolicyMap;
 
   canProvide?(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<boolean> | boolean;
-  getCachedFinancialsForTargets?(targets: CachedFinancialsTarget[], options?: { allowExpired?: boolean }): Map<string, TickerFinancials> | Promise<Map<string, TickerFinancials>>;
+  getCachedFinancialsForTargets?(targets: CachedFinancialsTarget[], options?: { allowExpired?: boolean; includeStaleQuotes?: boolean }): Map<string, TickerFinancials> | Promise<Map<string, TickerFinancials>>;
   getQuotesBatch?(targets: QuoteSubscriptionTarget[], options?: { forceRefresh?: boolean }): Promise<QuoteBatchResult[]>;
   getTickerFinancialsBatch?(targets: CachedFinancialsTarget[], options?: { forceRefresh?: boolean }): Promise<TickerFinancialsBatchResult[]>;
   getTickerFinancials(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<TickerFinancials>;

package/src/types/financials.ts

@@ -32,6 +32,7 @@ export interface Quote {
   volume?: number;
   name?: string;
   lastUpdated: number; // timestamp ms
+  receivedAt?: number; // local receipt timestamp ms for streamed/display freshness
   exchangeName?: string;
   fullExchangeName?: string;
   listingExchangeName?: string;

package/src/types/plugin.ts

@@ -110,6 +110,7 @@ export type PaneSettingField =
 
 export interface PaneSettingsDef {
   title?: string;
+  values?: Record<string, unknown>;
   fields: PaneSettingField[];
 }
 
@@ -406,6 +407,12 @@ export interface BrokerInstanceUpdateOptions {
   replaceConfig?: boolean;
 }
 
+export interface PinTickerOptions {
+  floating?: boolean;
+  paneType?: string;
+  forceNewPane?: boolean;
+}
+
 export interface GloomPluginContext {
   registerPane(pane: PaneDef): void;
   registerPaneTemplate(template: PaneTemplateDef): void;
@@ -448,7 +455,7 @@ export interface GloomPluginContext {
   createPaneFromTemplate(templateId: string, options?: PaneTemplateCreateOptions): void;
   hidePane(paneId: string): void;
   focusPane(paneId: string): void;
-  pinTicker(symbol: string, options?: { floating?: boolean; paneType?: string }): void;
+  pinTicker(symbol: string, options?: PinTickerOptions): void;
   navigateTicker(symbol: string, options?: { sourcePaneId?: string | null }): void;
   openPaneSettings(paneId?: string): void;