gloomberb 0.2.0 → 0.3.2

package/src/market-data/hooks.tsx

@@ -0,0 +1,234 @@
+import { useEffect, useMemo, useSyncExternalStore } from "react";
+import type { NewsItem, SecFilingItem } from "../types/data-provider";
+import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
+import type { TickerRecord } from "../types/ticker";
+import type { ChartRequest, InstrumentRef, NewsRequest, OptionsRequest, SecFilingsRequest } from "./request-types";
+import { instrumentFromTicker } from "./request-types";
+import {
+  getSharedMarketDataCoordinator,
+  resolveEntryValue,
+} from "./coordinator";
+import type { QueryEntry } from "./result-types";
+
+function useCoordinatorVersion(): number {
+  const coordinator = getSharedMarketDataCoordinator();
+  return useSyncExternalStore(
+    coordinator?.subscribe.bind(coordinator) ?? (() => () => {}),
+    () => coordinator?.getVersion() ?? 0,
+    () => 0,
+  );
+}
+
+function useCoordinatorSelector<T>(selector: (coordinator: NonNullable<ReturnType<typeof getSharedMarketDataCoordinator>>) => T, fallback: T): T {
+  const coordinator = getSharedMarketDataCoordinator();
+  useCoordinatorVersion();
+  return coordinator ? selector(coordinator) : fallback;
+}
+
+function stableCurrencyList(currencies: Array<string | null | undefined>): string[] {
+  return [...new Set(
+    currencies
+      .map((currency) => currency?.trim().toUpperCase() ?? "")
+      .filter(Boolean),
+  )].sort((left, right) => left.localeCompare(right));
+}
+
+export function useTickerInstrument(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): InstrumentRef | null {
+  return useMemo(() => instrumentFromTicker(ticker, symbol ?? null), [symbol, ticker]);
+}
+
+export function useTickerFinancials(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): TickerFinancials | null {
+  const instrument = useTickerInstrument(symbol, ticker);
+  const financials = useCoordinatorSelector(
+    (coordinator) => (instrument ? coordinator.getTickerFinancialsSync(instrument) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !instrument) return;
+    void coordinator.loadSnapshot(instrument);
+  }, [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol]);
+
+  return financials;
+}
+
+export function useTickerFinancialsMap(tickers: TickerRecord[]): Map<string, TickerFinancials> {
+  return useCoordinatorSelector((coordinator) => {
+    const result = new Map<string, TickerFinancials>();
+    for (const ticker of tickers) {
+      const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+      if (!instrument) continue;
+      const financials = coordinator.getTickerFinancialsSync(instrument);
+      if (financials) {
+        result.set(ticker.metadata.ticker, financials);
+      }
+    }
+    return result;
+  }, new Map<string, TickerFinancials>());
+}
+
+export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): QueryEntry<Quote> | null {
+  const instrument = useTickerInstrument(symbol, ticker);
+  const entry = useCoordinatorSelector(
+    (coordinator) => (instrument ? coordinator.getQuoteEntry(instrument) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !instrument) return;
+    void coordinator.loadQuote(instrument);
+  }, [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol]);
+
+  return entry;
+}
+
+export function useChartQuery(request: ChartRequest | null | undefined): QueryEntry<PricePoint[]> | null {
+  const key = request ? [
+    request.instrument.symbol,
+    request.instrument.exchange ?? "",
+    request.range,
+    request.granularity ?? "daily",
+    request.startDate?.toISOString() ?? "",
+    request.endDate?.toISOString() ?? "",
+    request.barSize ?? "",
+  ].join("|") : null;
+  const entry = useCoordinatorSelector(
+    (coordinator) => (request ? coordinator.getChartEntry(request) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !request) return;
+    void coordinator.loadChart(request);
+  }, [key]);
+
+  return entry;
+}
+
+export function useNewsQuery(request: NewsRequest | null | undefined): QueryEntry<NewsItem[]> | null {
+  const key = request ? `${request.instrument.symbol}|${request.instrument.exchange ?? ""}|${request.count ?? 50}` : null;
+  const entry = useCoordinatorSelector(
+    (coordinator) => (request ? coordinator.getNewsEntry(request) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !request) return;
+    void coordinator.loadNews(request);
+  }, [key]);
+
+  return entry;
+}
+
+export function useOptionsQuery(request: OptionsRequest | null | undefined): QueryEntry<OptionsChain> | null {
+  const key = request ? `${request.instrument.symbol}|${request.instrument.exchange ?? ""}|${request.expirationDate ?? "default"}` : null;
+  const entry = useCoordinatorSelector(
+    (coordinator) => (request ? coordinator.getOptionsEntry(request) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !request) return;
+    void coordinator.loadOptions(request);
+  }, [key]);
+
+  return entry;
+}
+
+export function useSecFilingsQuery(request: SecFilingsRequest | null | undefined): QueryEntry<SecFilingItem[]> | null {
+  const key = request ? `${request.instrument.symbol}|${request.instrument.exchange ?? ""}|${request.count ?? 50}` : null;
+  const entry = useCoordinatorSelector(
+    (coordinator) => (request ? coordinator.getSecFilingsEntry(request) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !request) return;
+    void coordinator.loadSecFilings(request);
+  }, [key]);
+
+  return entry;
+}
+
+export function useSecFilingContent(filing: SecFilingItem | null | undefined): QueryEntry<string | null> | null {
+  const key = filing?.accessionNumber ?? null;
+  const entry = useCoordinatorSelector(
+    (coordinator) => (filing ? coordinator.getSecContentEntry(filing.accessionNumber) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !filing) return;
+    void coordinator.loadSecFilingContent(filing);
+  }, [key]);
+
+  return entry;
+}
+
+export function useArticleSummary(url: string | null | undefined): QueryEntry<string | null> | null {
+  const entry = useCoordinatorSelector(
+    (coordinator) => (url ? coordinator.getArticleSummaryEntry(url) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !url) return;
+    void coordinator.loadArticleSummary(url);
+  }, [url]);
+
+  return entry;
+}
+
+export function useFxRate(currency: string | null | undefined): QueryEntry<number> | null {
+  const entry = useCoordinatorSelector(
+    (coordinator) => (currency ? coordinator.getFxEntry(currency) : null),
+    null,
+  );
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !currency) return;
+    void coordinator.loadFxRate(currency);
+  }, [currency]);
+
+  return entry;
+}
+
+export function useFxRatesMap(currencies: Array<string | null | undefined>): Map<string, number> {
+  const normalizedCurrencies = useMemo(() => stableCurrencyList(currencies), [currencies]);
+  const entries = useCoordinatorSelector((coordinator) => (
+    normalizedCurrencies.map((currency) => [currency, coordinator.getFxEntry(currency)] as const)
+  ), [] as Array<readonly [string, QueryEntry<number>]>);
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator) return;
+    for (const currency of normalizedCurrencies) {
+      void coordinator.loadFxRate(currency);
+    }
+  }, [normalizedCurrencies.join("|")]);
+
+  return useMemo(() => {
+    const rates = new Map<string, number>();
+    rates.set("USD", 1);
+    for (const [currency, entry] of entries) {
+      const rate = resolveEntryValue(entry);
+      if (rate != null) {
+        rates.set(currency, rate);
+      }
+    }
+    return rates;
+  }, [entries]);
+}
+
+export function useResolvedEntryValue<T>(entry: QueryEntry<T> | null | undefined): T | null {
+  return useMemo(() => (entry ? resolveEntryValue(entry) : null), [entry]);
+}

package/src/market-data/query-store.ts

@@ -0,0 +1,28 @@
+import type { QueryEntry } from "./result-types";
+import { createIdleEntry } from "./result-types";
+
+export class QueryStore<T> {
+  private readonly entries = new Map<string, QueryEntry<T>>();
+
+  constructor(private readonly onChange: () => void) {}
+
+  get(key: string): QueryEntry<T> {
+    return this.entries.get(key) ?? createIdleEntry<T>();
+  }
+
+  set(key: string, entry: QueryEntry<T>): void {
+    this.entries.set(key, entry);
+    this.onChange();
+  }
+
+  update(key: string, updater: (current: QueryEntry<T>) => QueryEntry<T>): QueryEntry<T> {
+    const next = updater(this.get(key));
+    this.entries.set(key, next);
+    this.onChange();
+    return next;
+  }
+
+  values(): IterableIterator<QueryEntry<T>> {
+    return this.entries.values();
+  }
+}

package/src/market-data/request-types.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+import type { TickerRecord } from "../types/ticker";
+import { quoteSubscriptionTargetFromTicker } from "./request-types";
+
+function makeTicker(overrides: Partial<TickerRecord["metadata"]> = {}): TickerRecord {
+  return {
+    metadata: {
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Apple",
+      broker_contracts: [],
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+      ...overrides,
+    },
+  };
+}
+
+describe("quoteSubscriptionTargetFromTicker", () => {
+  test("preserves broker contract context for streaming targets", () => {
+    const ticker = makeTicker({
+      broker_contracts: [{
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-live",
+        conId: 265598,
+        symbol: "AAPL",
+        localSymbol: "AAPL",
+        exchange: "NASDAQ",
+        currency: "USD",
+        secType: "STK",
+      }],
+    });
+
+    expect(quoteSubscriptionTargetFromTicker(ticker, ticker.metadata.ticker)).toEqual({
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      route: "auto",
+      context: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-live",
+        instrument: ticker.metadata.broker_contracts?.[0],
+      },
+    });
+  });
+
+  test("still returns a valid unscoped target when no broker contract exists", () => {
+    const ticker = makeTicker();
+
+    expect(quoteSubscriptionTargetFromTicker(ticker, ticker.metadata.ticker)).toEqual({
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      route: "auto",
+      context: {
+        brokerId: undefined,
+        brokerInstanceId: undefined,
+        instrument: null,
+      },
+    });
+  });
+});

package/src/market-data/request-types.ts

@@ -0,0 +1,70 @@
+import type { TimeRange } from "../components/chart/chart-types";
+import type { QuoteSubscriptionTarget } from "../types/data-provider";
+import type { BrokerContractRef } from "../types/instrument";
+import type { TickerRecord } from "../types/ticker";
+
+export interface InstrumentRef {
+  symbol: string;
+  exchange?: string;
+  brokerId?: string;
+  brokerInstanceId?: string;
+  instrument?: BrokerContractRef | null;
+}
+
+export type ChartGranularity = "daily" | "detail";
+
+export interface ChartRequest {
+  instrument: InstrumentRef;
+  range: TimeRange;
+  granularity?: ChartGranularity;
+  startDate?: Date;
+  endDate?: Date;
+  barSize?: string;
+}
+
+export interface NewsRequest {
+  instrument: InstrumentRef;
+  count?: number;
+}
+
+export interface OptionsRequest {
+  instrument: InstrumentRef;
+  expirationDate?: number;
+}
+
+export interface SecFilingsRequest {
+  instrument: InstrumentRef;
+  count?: number;
+}
+
+export function instrumentFromTicker(ticker: TickerRecord | null | undefined, fallbackSymbol?: string | null): InstrumentRef | null {
+  const symbol = ticker?.metadata.ticker ?? fallbackSymbol ?? null;
+  if (!symbol) return null;
+  const instrument = ticker?.metadata.broker_contracts?.[0] ?? null;
+  return {
+    symbol,
+    exchange: ticker?.metadata.exchange ?? "",
+    brokerId: instrument?.brokerId,
+    brokerInstanceId: instrument?.brokerInstanceId,
+    instrument,
+  };
+}
+
+export function quoteSubscriptionTargetFromTicker(
+  ticker: TickerRecord | null | undefined,
+  fallbackSymbol?: string | null,
+  route: QuoteSubscriptionTarget["route"] = "auto",
+): QuoteSubscriptionTarget | null {
+  const instrument = instrumentFromTicker(ticker, fallbackSymbol);
+  if (!instrument) return null;
+  return {
+    symbol: instrument.symbol,
+    exchange: instrument.exchange,
+    route,
+    context: {
+      brokerId: instrument.brokerId,
+      brokerInstanceId: instrument.brokerInstanceId,
+      instrument: instrument.instrument ?? null,
+    },
+  };
+}

package/src/market-data/result-types.ts

@@ -0,0 +1,56 @@
+export type ProviderStatus = "success" | "partial" | "empty" | "unsupported" | "retryable_error" | "fatal_error";
+
+export type ProviderReasonCode =
+  | "NO_DATA"
+  | "NOT_FOUND"
+  | "TIMEOUT"
+  | "UNSUPPORTED_RANGE"
+  | "BAD_MAPPING"
+  | "UPSTREAM_ERROR";
+
+export interface ProviderAttempt {
+  providerId: string;
+  status: ProviderStatus;
+  startedAt: number;
+  finishedAt: number;
+  latencyMs: number;
+  reasonCode?: ProviderReasonCode;
+  message?: string;
+}
+
+export interface ProviderResult<T> {
+  status: ProviderStatus;
+  data: T | null;
+  providerId: string;
+  latencyMs: number;
+  completeness: "full" | "partial";
+  reasonCode?: ProviderReasonCode;
+  asOf?: number;
+  staleAt?: number;
+}
+
+export type QueryPhase = "idle" | "loading" | "ready" | "refreshing" | "error";
+
+export interface QueryEntry<T> {
+  phase: QueryPhase;
+  data: T | null;
+  lastGoodData: T | null;
+  source: string | null;
+  fetchedAt: number | null;
+  staleAt: number | null;
+  error: { reasonCode: string; message: string } | null;
+  attempts: ProviderAttempt[];
+}
+
+export function createIdleEntry<T>(): QueryEntry<T> {
+  return {
+    phase: "idle",
+    data: null,
+    lastGoodData: null,
+    source: null,
+    fetchedAt: null,
+    staleAt: null,
+    error: null,
+    attempts: [],
+  };
+}

package/src/market-data/selectors.ts

@@ -0,0 +1,166 @@
+import type { MarketDataRequestContext } from "../types/data-provider";
+import type { Quote, TickerFinancials } from "../types/financials";
+import type { InstrumentRef, NewsRequest, OptionsRequest, SecFilingsRequest, ChartRequest } from "./request-types";
+import type { QueryEntry } from "./result-types";
+import { hasLikelyQuoteUnitMismatch } from "../utils/currency-units";
+import { normalizePriceHistory } from "../utils/price-history";
+
+export function buildInstrumentKey(instrument: InstrumentRef): string {
+  const contractKey = instrument.instrument?.conId
+    ?? instrument.instrument?.localSymbol
+    ?? instrument.instrument?.symbol
+    ?? "";
+  return [
+    instrument.symbol.trim().toUpperCase(),
+    (instrument.exchange ?? "").trim().toUpperCase(),
+    instrument.brokerId ?? "",
+    instrument.brokerInstanceId ?? "",
+    contractKey,
+  ].join("|");
+}
+
+export function toMarketDataContext(instrument: InstrumentRef): MarketDataRequestContext {
+  return {
+    brokerId: instrument.brokerId,
+    brokerInstanceId: instrument.brokerInstanceId,
+    instrument: instrument.instrument ?? null,
+  };
+}
+
+export function buildQuoteKey(instrument: InstrumentRef): string {
+  return `quote:${buildInstrumentKey(instrument)}`;
+}
+
+export function buildSnapshotKey(instrument: InstrumentRef): string {
+  return `snapshot:${buildInstrumentKey(instrument)}`;
+}
+
+export function buildProfileKey(instrument: InstrumentRef): string {
+  return `profile:${buildInstrumentKey(instrument)}`;
+}
+
+export function buildFundamentalsKey(instrument: InstrumentRef): string {
+  return `fundamentals:${buildInstrumentKey(instrument)}`;
+}
+
+export function buildStatementsKey(instrument: InstrumentRef): string {
+  return `statements:${buildInstrumentKey(instrument)}`;
+}
+
+export function buildChartKey(request: ChartRequest): string {
+  return [
+    "chart",
+    buildInstrumentKey(request.instrument),
+    request.range,
+    request.granularity ?? "daily",
+    request.startDate ? request.startDate.toISOString() : "",
+    request.endDate ? request.endDate.toISOString() : "",
+    request.barSize ?? "",
+  ].join(":");
+}
+
+export function buildNewsKey(request: NewsRequest): string {
+  return `news:${buildInstrumentKey(request.instrument)}:${request.count ?? 50}`;
+}
+
+export function buildOptionsKey(request: OptionsRequest): string {
+  return `options:${buildInstrumentKey(request.instrument)}:${request.expirationDate ?? "default"}`;
+}
+
+export function buildSecFilingsKey(request: SecFilingsRequest): string {
+  return `sec:${buildInstrumentKey(request.instrument)}:${request.count ?? 50}`;
+}
+
+export function buildSecContentKey(accessionNumber: string): string {
+  return `sec-content:${accessionNumber}`;
+}
+
+export function buildArticleSummaryKey(url: string): string {
+  return `article-summary:${url.trim()}`;
+}
+
+export function buildFxKey(currency: string): string {
+  return `fx:${currency.trim().toUpperCase()}`;
+}
+
+export function resolveEntryData<T>(entry: QueryEntry<T> | null | undefined): T | null {
+  if (!entry) return null;
+  return entry.data ?? entry.lastGoodData ?? null;
+}
+
+export function hasLikelyPriceUnitMismatch(
+  left: Quote | null | undefined,
+  right: Quote | null | undefined,
+): boolean {
+  return hasLikelyQuoteUnitMismatch(left, right);
+}
+
+function mergeDefinedQuoteFields(
+  preferred: Quote | null | undefined,
+  fallback: Quote | null | undefined,
+): Quote | undefined {
+  const mergedEntries: Array<[string, unknown]> = [];
+  for (const source of [fallback, preferred]) {
+    if (!source) continue;
+    for (const [key, value] of Object.entries(source)) {
+      if (value !== undefined) {
+        mergedEntries.push([key, value]);
+      }
+    }
+  }
+  if (mergedEntries.length === 0) return undefined;
+  return Object.fromEntries(mergedEntries) as Quote;
+}
+
+function projectExtendedHoursQuote(
+  snapshotQuote: Quote | null | undefined,
+  liveQuote: Quote | null | undefined,
+): Quote | undefined {
+  const merged = mergeDefinedQuoteFields(liveQuote, snapshotQuote);
+  if (!merged) return undefined;
+  if (!snapshotQuote || !liveQuote) return merged;
+
+  const snapshotState = snapshotQuote.marketState;
+  if (snapshotState !== "PRE" && snapshotState !== "POST") return merged;
+  if (liveQuote.marketState === "PRE" || liveQuote.marketState === "POST") return merged;
+
+  if (snapshotState === "PRE") {
+    return {
+      ...merged,
+      marketState: "PRE",
+      preMarketPrice: liveQuote.price,
+      preMarketChange: liveQuote.change,
+      preMarketChangePercent: liveQuote.changePercent,
+    };
+  }
+
+  return {
+    ...merged,
+    marketState: "POST",
+    postMarketPrice: liveQuote.price,
+    postMarketChange: liveQuote.change,
+    postMarketChangePercent: liveQuote.changePercent,
+  };
+}
+
+export function buildTickerFinancialsSnapshot(
+  snapshotEntry: QueryEntry<TickerFinancials>,
+  quoteEntry?: QueryEntry<TickerFinancials["quote"]>,
+  chartEntry?: QueryEntry<TickerFinancials["priceHistory"]>,
+): TickerFinancials | null {
+  const snapshot = resolveEntryData(snapshotEntry);
+  const quote = resolveEntryData(quoteEntry);
+  const priceHistory = resolveEntryData(chartEntry);
+  if (!snapshot && !quote && !priceHistory) return null;
+  const resolvedQuote = snapshot?.quote && quote && hasLikelyPriceUnitMismatch(snapshot.quote, quote)
+    ? snapshot.quote
+    : (projectExtendedHoursQuote(snapshot?.quote, quote) ?? snapshot?.quote);
+  return {
+    quote: resolvedQuote,
+    fundamentals: snapshot?.fundamentals,
+    profile: snapshot?.profile,
+    annualStatements: snapshot?.annualStatements ?? [],
+    quarterlyStatements: snapshot?.quarterlyStatements ?? [],
+    priceHistory: normalizePriceHistory(priceHistory ?? snapshot?.priceHistory ?? []),
+  };
+}

package/src/market-data/trace.ts

@@ -0,0 +1,7 @@
+import { debugLog } from "../utils/debug-log";
+
+const marketDataLog = debugLog.createLogger("market-data");
+
+export function traceMarketData(event: string, payload: Record<string, unknown>): void {
+  marketDataLog.info(event, payload);
+}

package/src/pane-settings.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+import { cloneLayout, createDefaultConfig, createPaneInstance, DEFAULT_PORTFOLIO_COLUMN_IDS, type LayoutConfig } from "./types/config";
+import { deletePaneSetting, getPaneSettingValue, setPaneSetting } from "./pane-settings";
+
+describe("pane settings helpers", () => {
+  test("seeds built-in default panes with persisted settings", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-pane-settings");
+    const portfolioPane = config.layout.instances.find((instance) => instance.instanceId === "portfolio-list:main");
+    const detailPane = config.layout.instances.find((instance) => instance.instanceId === "ticker-detail:main");
+
+    expect(portfolioPane?.settings).toMatchObject({
+      collectionScope: "all",
+      hideTabs: false,
+      lockedCollectionId: "main",
+    });
+    expect(portfolioPane?.settings?.columnIds).toEqual(DEFAULT_PORTFOLIO_COLUMN_IDS);
+    expect(detailPane?.settings).toEqual({
+      hideTabs: false,
+      lockedTabId: "overview",
+    });
+  });
+
+  test("cloneLayout deep-clones pane settings", () => {
+    const layout = cloneLayout(createDefaultConfig("/tmp/gloomberb-pane-settings").layout);
+    const cloned = cloneLayout(layout);
+    const clonedPortfolioSettings = cloned.instances.find((instance) => instance.instanceId === "portfolio-list:main")?.settings;
+    const originalPortfolioSettings = layout.instances.find((instance) => instance.instanceId === "portfolio-list:main")?.settings;
+
+    expect(clonedPortfolioSettings).toBeDefined();
+    expect(clonedPortfolioSettings).not.toBe(originalPortfolioSettings);
+
+    (clonedPortfolioSettings?.columnIds as string[]).push("change");
+    expect(originalPortfolioSettings?.columnIds).toEqual(DEFAULT_PORTFOLIO_COLUMN_IDS);
+  });
+
+  test("setPaneSetting and deletePaneSetting update pane-scoped settings immutably", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-pane-settings");
+    const extraPane = createPaneInstance("quote-monitor", {
+      instanceId: "quote-monitor:test",
+      binding: { kind: "fixed", symbol: "AAPL" },
+      settings: { symbol: "AAPL" },
+    });
+    const layout: LayoutConfig = {
+      ...config.layout,
+      instances: [...config.layout.instances, extraPane],
+    };
+
+    const updated = setPaneSetting(layout, "quote-monitor:test", "symbol", "MSFT");
+    expect(getPaneSettingValue(updated.instances.find((instance) => instance.instanceId === "quote-monitor:test"), "symbol", "")).toBe("MSFT");
+    expect(getPaneSettingValue(layout.instances.find((instance) => instance.instanceId === "quote-monitor:test"), "symbol", "")).toBe("AAPL");
+
+    const cleared = deletePaneSetting(updated, "quote-monitor:test", "symbol");
+    expect(getPaneSettingValue(cleared.instances.find((instance) => instance.instanceId === "quote-monitor:test"), "symbol", null)).toBeNull();
+  });
+});