gloomberb 0.13.2 → 0.14.0

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

@@ -3,6 +3,7 @@ import { createDefaultConfig, createPaneInstance } from "../types/config";
 import type { TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
 import { buildAppSessionSnapshot, reconcileAppSessionSnapshot } from "../core/state/session-persistence";
+import { buildInstrumentKey } from "../market-data/selectors";
 
 function createTicker(symbol: string, exchange = "NASDAQ"): TickerRecord {
   return {
@@ -22,6 +23,51 @@ function createTicker(symbol: string, exchange = "NASDAQ"): TickerRecord {
 }
 
 describe("session persistence", () => {
+  test("saves portfolio and follower targets without selecting the first contract or resolving ambiguous lots", () => {
+    const config = createDefaultConfig("/tmp/session-contracts");
+    config.portfolios = ["a", "b", "manual", "unknown"].map((id) => ({ id, name: id }));
+    const contracts = [101, 202].map((conId) => ({ brokerId: "ibkr", brokerInstanceId: "same", symbol: "DUAL", conId }));
+    const ticker = createTicker("DUAL");
+    ticker.metadata.portfolios = config.portfolios.map(({ id }) => id);
+    ticker.metadata.broker_contracts = contracts;
+    ticker.metadata.positions = [
+      ...contracts.map((contract, index) => ({ portfolio: index ? "b" : "a", broker: "ibkr", brokerInstanceId: "same", brokerContractId: contract.conId, shares: 1 })),
+      { portfolio: "manual", broker: "manual", shares: 1 },
+      { portfolio: "unknown", broker: "ibkr", brokerInstanceId: "same", brokerContractId: 999, shares: 1 },
+    ];
+    config.layout.instances = config.portfolios.map(({ id }) => createPaneInstance("portfolio-list", { instanceId: id, params: { collectionId: id } }));
+    config.layout.instances.push(createPaneInstance("ticker-detail", { instanceId: "follow-b", binding: { kind: "follow", sourceInstanceId: "b" } }));
+    const state = { config, paneState: Object.fromEntries(config.portfolios.map(({ id }) => [id, { cursorSymbol: "DUAL", collectionId: id }])),
+      focusedPaneId: "b", activePanel: "left" as const, statusBarVisible: true, recentTickers: [], tickers: new Map([["DUAL", ticker]]), exchangeRates: new Map<string, number>() };
+    const snapshot = buildAppSessionSnapshot(state);
+    expect(snapshot.hydrationTargets.map(({ instrument }) => instrument?.conId ?? null)).toEqual([101, 202, null]);
+    expect(snapshot.hydrationTargets.map(buildInstrumentKey)).toHaveLength(3);
+    expect(ticker.metadata.broker_contracts).toEqual(contracts);
+    // A stale cursor does not change which collection supplies other rows.
+    state.paneState.b.cursorSymbol = "MISSING";
+    expect(buildAppSessionSnapshot(state).hydrationTargets.some(({ instrument }) => instrument?.conId === 202)).toBe(true);
+    expect(buildAppSessionSnapshot(state).hydrationTargets.some(({ symbol }) => symbol === "MISSING")).toBe(false);
+  });
+
+  test("fixed and followed legacy contracts keep full distinct identities in the saved working set", () => {
+    const config = createDefaultConfig("/tmp/session-fixed-contracts");
+    const ticker = createTicker("DUAL");
+    const contracts = ["202610", "202611"].map((lastTradeDateOrContractMonth) => ({ brokerId: "ibkr", brokerInstanceId: "same",
+      symbol: "DUAL", localSymbol: "DUAL", secType: "FUT", currency: "USD", lastTradeDateOrContractMonth }));
+    ticker.metadata.broker_contracts = contracts;
+    config.layout.instances = contracts.map((instrument, index) => createPaneInstance("ticker-detail", {
+      instanceId: `fixed:${index}`, binding: { kind: "fixed", symbol: "DUAL", instrument },
+    }));
+    config.layout.instances.push(createPaneInstance("ticker-detail", { instanceId: "follow", binding: { kind: "follow", sourceInstanceId: "fixed:1" } }));
+    const snapshot = buildAppSessionSnapshot({ config, paneState: {}, focusedPaneId: "follow", activePanel: "right", statusBarVisible: true,
+      recentTickers: ["DUAL"], tickers: new Map([["DUAL", ticker]]), exchangeRates: new Map() });
+    expect(snapshot.hydrationTargets.map(({ instrument }) => instrument?.lastTradeDateOrContractMonth)).toEqual(["202610", "202611"]);
+    expect(new Set(snapshot.hydrationTargets.map(buildInstrumentKey)).size).toBe(2);
+    config.layout.instances = [];
+    expect(buildAppSessionSnapshot({ config, paneState: {}, focusedPaneId: null, activePanel: "right", statusBarVisible: true,
+      recentTickers: ["DUAL"], tickers: new Map([["DUAL", ticker]]), exchangeRates: new Map() }).hydrationTargets).toEqual([]);
+  });
+
   test("builds a working-set snapshot from runtime state", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     const tickers = new Map<string, TickerRecord>([

package/src/sync/core-contributors.test.ts

@@ -350,7 +350,7 @@ describe("core sync contributors", () => {
     expect((payload as any).tickers[0].quote.price).toBe(150);
     expect((payload as any).tickers[0].quote.weekReferencePrice).toBe(125);
     expect((payload as any).tickers[0].quote.weekChangePercent).toBe(20);
-    expect((payload as any).analyticsByPortfolio.main.oneYearReturn).toBe(0.42);
+    expect((payload as any).analyticsByPortfolio.main.oneYearReturn).toBeNull();
 
     const saved: TickerRecord[] = [];
     const sanitizedTickerPayload = { tickers: (payload as any).tickers };
@@ -415,7 +415,7 @@ describe("core sync contributors", () => {
     expect(state.tickers.get("NVDA")?.metadata.positions).toHaveLength(1);
   });
 
-  test("syncs only public return and beta analytics", async () => {
+  test("does not publish current holdings performance as account return or unsupported basket beta", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-sync-test");
     config.baseCurrency = "USD";
     config.portfolios = [
@@ -501,10 +501,10 @@ describe("core sync contributors", () => {
 
     expect(payload.baseCurrency).toBe("USD");
     expect(payload.exchangeRates).toEqual({ USD: 1, JPY: 0.0067 });
-    expect(payload.analyticsByPortfolio.main.oneYearReturn).toBe(0.1);
-    expect(payload.analyticsByPortfolio.main.spyBeta).toBeCloseTo(1.5, 5);
-    expect(payload.analyticsByPortfolio["broker:ibkr:U123"].oneYearReturn).toBe(0.2);
-    expect(payload.analyticsByPortfolio["broker:ibkr:U123"].spyBeta).toBeCloseTo(3, 5);
+    expect(payload.analyticsByPortfolio.main.oneYearReturn).toBeNull();
+    expect(payload.analyticsByPortfolio.main.spyBeta).toBeNull();
+    expect(payload.analyticsByPortfolio["broker:ibkr:U123"].oneYearReturn).toBeNull();
+    expect(payload.analyticsByPortfolio["broker:ibkr:U123"].spyBeta).toBeNull();
     expect(payload.accountsByPortfolio).toEqual({
       "broker:ibkr:U123": {
         currency: "USD",
@@ -518,6 +518,35 @@ describe("core sync contributors", () => {
     expect(payload.analyticsByPortfolio.main).not.toHaveProperty("holdingsCount");
     expect(payload.analyticsByPortfolio.main).not.toHaveProperty("currency");
     expect(payload.analyticsByPortfolio.main).not.toHaveProperty("sourceLabel");
+
+    const mainTicker = state.tickers.get("7203.T")!;
+    mainTicker.metadata.currency = "USD";
+    mainTicker.metadata.positions[0]!.currency = "USD";
+    state.financials.get("7203.T")!.quote!.currency = "USD";
+    const supported = await coreCollectionsSyncContributor.collect({ state }) as any;
+    expect(supported.analyticsByPortfolio.main.spyBeta).toBeCloseTo(1.5, 5);
+    expect(supported.analyticsByPortfolio.main.oneYearReturn).toBeNull();
+
+    const cleanBenchmark = state.financials.get("SPY")!.priceHistory!;
+    const benchmarkEnd = cleanBenchmark.at(-1)!;
+    state.financials.get("SPY")!.priceHistory = [...cleanBenchmark.slice(0, -1), { ...benchmarkEnd, high: benchmarkEnd.close - 1 }];
+    setSyncedProfileAnalytics("main", { oneYearReturn: 0.25, spyBeta: 1.4 });
+    const invalidBenchmark = await coreCollectionsSyncContributor.collect({ state }) as any;
+    expect(invalidBenchmark.analyticsByPortfolio.main).toEqual({ oneYearReturn: 0.25, spyBeta: null });
+    state.financials.get("SPY")!.priceHistory = cleanBenchmark;
+    const cleanHolding = state.financials.get("7203.T")!.priceHistory!;
+    const holdingEnd = cleanHolding.at(-1)!;
+    state.financials.get("7203.T")!.priceHistory = [...cleanHolding.slice(0, -1), { ...holdingEnd, low: holdingEnd.close + 1 }];
+    const invalidHolding = await coreCollectionsSyncContributor.collect({ state }) as any;
+    expect(invalidHolding.analyticsByPortfolio.main).toEqual({ oneYearReturn: null, spyBeta: null });
+    state.financials.get("7203.T")!.priceHistory = cleanHolding;
+    setSyncedProfileAnalytics("main", null);
+    const corrected = await coreCollectionsSyncContributor.collect({ state }) as any;
+    expect(corrected.analyticsByPortfolio.main.spyBeta).toBeCloseTo(1.5, 5);
+
+    mainTicker.metadata.positions[0]!.side = "short";
+    const short = await coreCollectionsSyncContributor.collect({ state }) as any;
+    expect(short.analyticsByPortfolio.main.spyBeta).toBeNull();
   });
 
   test("redaction removes nested credential-shaped fields", () => {

package/src/sync/core-contributors.ts

@@ -9,8 +9,10 @@ import type { SyncContributor } from "./types";
 import { convertCurrency } from "../utils/format";
 import {
   computeDatedBeta,
-  computeDatedReturns,
+  resolveDatedReturns,
   computeWeightedPortfolioReturns,
+  syntheticAccountUnsupportedReason,
+  syntheticPositionUnsupportedReason,
   type WeightedReturnSeries,
 } from "../plugins/builtin/analytics/metrics";
 import {
@@ -373,50 +375,51 @@ function recentPriceHistory(history: PricePoint[], days: number): PricePoint[] {
   });
 }
 
-function oneYearReturnFromSeries(series: WeightedReturnSeries[]): number | null {
-  const returns = computeWeightedPortfolioReturns(series);
-  if (returns.length === 0) return null;
-  const cumulative = returns.reduce((acc, point) => (
-    Number.isFinite(point.value) ? acc * (1 + point.value) : acc
-  ), 1) - 1;
-  return Number.isFinite(cumulative) ? cumulative : null;
-}
-
 function collectAnalyticsByPortfolio(
   config: AppConfig,
   tickers: Map<string, TickerRecord>,
   financials: Map<string, TickerFinancials>,
   exchangeRates: Map<string, number>,
+  brokerAccounts: Record<string, BrokerAccount[]>,
 ) {
   const output: Record<string, Record<string, unknown>> = {};
-  const spyReturns = computeDatedReturns(recentPriceHistory(financials.get("SPY")?.priceHistory ?? [], 366));
+  const spySample = resolveDatedReturns(recentPriceHistory(financials.get("SPY")?.priceHistory ?? [], 366));
+  const spyReturns = spySample.returns;
   for (const portfolio of config.portfolios) {
-    let returnWeight = 0;
-    let weightedReturn = 0;
+    const account = portfolio.brokerInstanceId && portfolio.brokerAccountId
+      ? brokerAccounts[portfolio.brokerInstanceId]?.find((entry) => entry.accountId === portfolio.brokerAccountId)
+      : undefined;
+    let unsupported = !!syntheticAccountUnsupportedReason(account);
+    let invalidHistory = false;
     const datedReturnSeries: WeightedReturnSeries[] = [];
     for (const ticker of tickers.values()) {
       const tickerFinancials = financials.get(ticker.metadata.ticker);
       const portfolioPositions = ticker.metadata.positions.filter((position) => position.portfolio === portfolio.id);
-      if (portfolioPositions.length === 0 && !ticker.metadata.portfolios.includes(portfolio.id)) continue;
+      if (portfolioPositions.length === 0) continue;
+      unsupported ||= !!syntheticPositionUnsupportedReason(
+        ticker, tickerFinancials?.quote?.currency || ticker.metadata.currency || config.baseCurrency, portfolio.id,
+      );
       for (const position of portfolioPositions) {
+        if (position.shares === 0) continue;
         const value = positionValueBase(position, tickerFinancials, config.baseCurrency, exchangeRates);
-        if (value != null) {
-          const return1Y = tickerFinancials?.fundamentals?.return1Y;
-          if (typeof return1Y === "number" && Number.isFinite(return1Y)) {
-            returnWeight += value;
-            weightedReturn += return1Y * value;
-          }
-          const returns = computeDatedReturns(recentPriceHistory(tickerFinancials?.priceHistory ?? [], 366));
-          if (returns.length >= 10) datedReturnSeries.push({ weight: value, returns });
+        if (value == null || !Number.isFinite(value)) {
+          unsupported = true;
+          continue;
         }
+        const sample = resolveDatedReturns(recentPriceHistory(tickerFinancials?.priceHistory ?? [], 366));
+        invalidHistory ||= sample.integrity != null;
+        const returns = sample.returns;
+        if (returns.length >= 10) datedReturnSeries.push({ weight: value, returns });
+        else unsupported = true;
       }
     }
-    const portfolioReturns = computeWeightedPortfolioReturns(datedReturnSeries);
+    const portfolioReturns = unsupported ? [] : computeWeightedPortfolioReturns(datedReturnSeries);
     const previewAnalytics = getSyncedProfileAnalytics(portfolio.id);
     output[portfolio.id] = {
-      oneYearReturn: previewAnalytics?.oneYearReturn
-        ?? (returnWeight > 0 ? weightedReturn / returnWeight : oneYearReturnFromSeries(datedReturnSeries)),
-      spyBeta: previewAnalytics?.spyBeta
+      // A weighted history of today's holdings is not the investor's actual
+      // one-year account return. Only preserve an explicitly supplied preview.
+      oneYearReturn: invalidHistory ? null : previewAnalytics?.oneYearReturn ?? null,
+      spyBeta: invalidHistory || spySample.integrity ? null : previewAnalytics?.spyBeta
         ?? (
           portfolioReturns.length > 0 && spyReturns.length > 0
             ? computeDatedBeta(portfolioReturns, spyReturns)
@@ -482,7 +485,7 @@ function collectCoreCollectionsPayload(
     ),
     portfolios: config.portfolios.map(sanitizePortfolio),
     watchlists: config.watchlists.map(sanitizeWatchlist),
-    analyticsByPortfolio: collectAnalyticsByPortfolio(config, tickers, financials, exchangeRates),
+    analyticsByPortfolio: collectAnalyticsByPortfolio(config, tickers, financials, exchangeRates, brokerAccounts),
     accountsByPortfolio: collectAccountsByPortfolio(config, brokerAccounts),
     tickers: records,
   };

package/src/test-support/market-session.ts

@@ -0,0 +1,12 @@
+import { afterEach, beforeEach } from "bun:test";
+
+/** Price-only fixtures represent a regular session. Their identity/cache tests
+ * must not silently turn into pre/post-market freshness tests on the CI clock. */
+export function useRegularMarketSession(): void {
+  let originalNow: typeof Date.now;
+  beforeEach(() => {
+    originalNow = Date.now;
+    Date.now = () => Date.parse("2026-09-14T18:00:00Z");
+  });
+  afterEach(() => { Date.now = originalNow; });
+}

package/src/test-support/pane.tsx

@@ -0,0 +1,52 @@
+import type { Dispatch, ReactNode } from "react";
+import { AppContext, PaneInstanceProvider, type AppAction, type AppState } from "../state/app/context";
+import { PluginRenderProvider, type PluginRuntimeAccess } from "../plugins/runtime";
+import { cloneLayout, createDefaultConfig, type AppConfig, type PaneInstanceConfig } from "../types/config";
+import type { TickerRecord } from "../types/ticker";
+
+/** Provider wiring only: the suite retains ownership of its state and update timing. */
+export function TestPaneProvider({
+  state, dispatch = () => {}, paneId, pluginId, runtime, children,
+}: {
+  state: AppState;
+  dispatch?: Dispatch<AppAction>;
+  paneId: string;
+  pluginId: string;
+  runtime: PluginRuntimeAccess;
+  children: ReactNode;
+}) {
+  return (
+    <AppContext value={{ state, dispatch }}>
+      <PaneInstanceProvider paneId={paneId}>
+        <PluginRenderProvider pluginId={pluginId} runtime={runtime}>
+          {children}
+        </PluginRenderProvider>
+      </PaneInstanceProvider>
+    </AppContext>
+  );
+}
+
+export function createTestPaneConfig(dataDir: string, instance: PaneInstanceConfig): AppConfig {
+  const layout: AppConfig["layout"] = {
+    dockRoot: { kind: "pane", instanceId: instance.instanceId },
+    instances: [instance], floating: [], detached: [],
+  };
+  return {
+    ...createDefaultConfig(dataDir), layout,
+    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
+  };
+}
+
+export function createTestTicker(
+  symbol: string,
+  name = symbol,
+  overrides: Partial<TickerRecord["metadata"]> = {},
+): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol, exchange: "NASDAQ", currency: "USD", name,
+      portfolios: [], watchlists: [], positions: [], custom: {}, tags: [],
+      ...overrides,
+    },
+  };
+}

package/src/test-support/plugin-runtime.ts

@@ -15,6 +15,10 @@ export function createTestPluginRuntime(
     getMarketData: () => null,
     getConnectionHealth: () => connectionHealth,
     getCapability: () => null,
+    capabilityManifests: () => [],
+    invokeCapability: async () => {
+      throw new Error("This test plugin runtime registers no capabilities.");
+    },
     getBrokerAdapter: () => null,
     connectBrokerInstance: async () => {},
     updateBrokerInstance: async () => {},
@@ -31,6 +35,7 @@ export function createTestPluginRuntime(
     hidePane() {},
     focusPane() {},
     openPaneSettings() {},
+    sharePane() {},
     openPluginCommandWorkflow() {},
     notify() {},
     subscribeResumeState: () => () => {},

package/src/theme/color-utils.ts

@@ -1,27 +1,52 @@
+// These run per row and per badge on every render of any list, and the
+// inputs come from a palette of a few dozen colours. Each function keeps its
+// results by argument so the gamma math and hex parsing happen once per
+// distinct input rather than thousands of times per frame. The caches are
+// bounded so an unexpected stream of one-off colours cannot grow them.
+const CACHE_LIMIT = 4096;
+
+function remember<T>(cache: Map<string, T>, key: string, compute: () => T): T {
+  const cached = cache.get(key);
+  if (cached !== undefined) return cached;
+  const value = compute();
+  if (cache.size >= CACHE_LIMIT) cache.clear();
+  cache.set(key, value);
+  return value;
+}
+
+const blendCache = new Map<string, string>();
+const luminanceCache = new Map<string, number>();
+const contrastBlendCache = new Map<string, string>();
+const separationBlendCache = new Map<string, string>();
+
+function parseHex(hex: string): readonly [number, number, number] {
+  const h = hex.replace("#", "");
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)] as const;
+}
 
 export function blendHex(a: string, b: string, ratio: number): string {
-  const parse = (hex: string) => {
-    const h = hex.replace("#", "");
-    return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)] as const;
-  };
-  const [ar, ag, ab] = parse(a);
-  const [br, bg, bb] = parse(b);
-  const mix = (x: number, y: number) => Math.round(x + (y - x) * ratio).toString(16).padStart(2, "0");
-  return `#${mix(ar, br)}${mix(ag, bg)}${mix(ab, bb)}`;
+  return remember(blendCache, `${a}|${b}|${ratio}`, () => {
+    const [ar, ag, ab] = parseHex(a);
+    const [br, bg, bb] = parseHex(b);
+    const mix = (x: number, y: number) => Math.round(x + (y - x) * ratio).toString(16).padStart(2, "0");
+    return `#${mix(ar, br)}${mix(ag, bg)}${mix(ab, bb)}`;
+  });
 }
 
 export function relativeLuminance(hex: string): number {
-  const h = hex.replace("#", "");
-  const toLinear = (value: string) => {
-    const normalized = parseInt(value, 16) / 255;
-    return normalized <= 0.03928
-      ? normalized / 12.92
-      : Math.pow((normalized + 0.055) / 1.055, 2.4);
-  };
-  const r = toLinear(h.slice(0, 2));
-  const g = toLinear(h.slice(2, 4));
-  const b = toLinear(h.slice(4, 6));
-  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  return remember(luminanceCache, hex, () => {
+    const h = hex.replace("#", "");
+    const toLinear = (value: string) => {
+      const normalized = parseInt(value, 16) / 255;
+      return normalized <= 0.03928
+        ? normalized / 12.92
+        : Math.pow((normalized + 0.055) / 1.055, 2.4);
+    };
+    const r = toLinear(h.slice(0, 2));
+    const g = toLinear(h.slice(2, 4));
+    const b = toLinear(h.slice(4, 6));
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  });
 }
 
 export function contrastRatio(a: string, b: string): number {
@@ -31,18 +56,48 @@ export function contrastRatio(a: string, b: string): number {
 }
 
 const CONTRAST_BLEND_STEPS = [0, 0.08, 0.14, 0.2, 0.28, 0.36, 0.48, 0.62, 0.78, 1] as const;
+// Fine enough that a tint stops as soon as it is legible rather than
+// overshooting to the next coarse step and reading as a block of colour.
+const SEPARATION_BLEND_STEP = 0.02;
 
 export function blendForContrast(base: string, against: string, fallback: string, minContrast: number): string {
-  let candidate = base;
+  return remember(contrastBlendCache, `${base}|${against}|${fallback}|${minContrast}`, () => {
+    let candidate = base;
 
-  for (const ratio of CONTRAST_BLEND_STEPS) {
-    candidate = ratio === 0 ? base : blendHex(base, fallback, ratio);
-    if (contrastRatio(candidate, against) >= minContrast) {
-      return candidate;
+    for (const ratio of CONTRAST_BLEND_STEPS) {
+      candidate = ratio === 0 ? base : blendHex(base, fallback, ratio);
+      if (contrastRatio(candidate, against) >= minContrast) {
+        return candidate;
+      }
     }
-  }
 
-  return candidate;
+    return candidate;
+  });
+}
+
+/**
+ * A surface tint that carries the same weight in every palette. A fixed blend
+ * ratio cannot: how far it moves the eye depends entirely on where the accent
+ * sits relative to the background, so the same code reads as a clear band in
+ * one theme and as nothing at all in another. This walks `base` toward `tint`
+ * only as far as it takes to separate from `against`, and never past
+ * `maxRatio`, so a palette whose accent shares the background's luminance
+ * ends up tinted rather than flooded.
+ */
+export function blendForSeparation(
+  base: string,
+  tint: string,
+  against: string,
+  minContrast: number,
+  maxRatio: number,
+): string {
+  return remember(separationBlendCache, `${base}|${tint}|${against}|${minContrast}|${maxRatio}`, () => {
+    for (let ratio = SEPARATION_BLEND_STEP; ratio < maxRatio; ratio += SEPARATION_BLEND_STEP) {
+      const candidate = blendHex(base, tint, ratio);
+      if (contrastRatio(candidate, against) >= minContrast) return candidate;
+    }
+    return blendHex(base, tint, maxRatio);
+  });
 }
 
 export function blendForContrastOnSurfaces(
@@ -51,16 +106,18 @@ export function blendForContrastOnSurfaces(
   fallback: string,
   minContrast: number,
 ): string {
-  let candidate = base;
+  return remember(contrastBlendCache, `${base}|${surfaces.join(",")}|${fallback}|${minContrast}`, () => {
+    let candidate = base;
 
-  for (const ratio of CONTRAST_BLEND_STEPS) {
-    candidate = ratio === 0 ? base : blendHex(base, fallback, ratio);
-    if (surfaces.every((surface) => contrastRatio(candidate, surface) >= minContrast)) {
-      return candidate;
+    for (const ratio of CONTRAST_BLEND_STEPS) {
+      candidate = ratio === 0 ? base : blendHex(base, fallback, ratio);
+      if (surfaces.every((surface) => contrastRatio(candidate, surface) >= minContrast)) {
+        return candidate;
+      }
     }
-  }
 
-  return candidate;
+    return candidate;
+  });
 }
 
 export function higherContrast(a: string, b: string, against: string): string {

package/src/tickers/instrument-label.ts

@@ -0,0 +1,10 @@
+import type { BrokerContractRef } from "../types/instrument";
+
+/** Identifying contract terms belong in the existing title, never in a new toolbar. */
+export function tickerInstrumentLabel(symbol: string, contract?: BrokerContractRef | null): string {
+  if (!contract) return symbol;
+  const label = contract.localSymbol || symbol;
+  const terms = [contract.lastTradeDateOrContractMonth, contract.right,
+    contract.strike != null ? String(contract.strike) : undefined].filter(Boolean);
+  return terms.length ? [label, ...terms].join(" ") : label;
+}

package/src/tickers/list.test.ts

@@ -4,6 +4,7 @@ import { parseTickerListInput } from "./list";
 describe("parseTickerListInput", () => {
   test("normalizes, de-duplicates, and preserves order", () => {
     expect(parseTickerListInput(" msft, aapl,\nMSFT, nvda ")).toEqual(["MSFT", "AAPL", "NVDA"]);
+    expect(parseTickerListInput("AAPL TSM, SAP.DE\t7203.T AAPL")).toEqual(["AAPL", "TSM", "SAP.DE", "7203.T"]);
   });
 
   test("rejects empty ticker lists", () => {

package/src/tickers/list.ts

@@ -7,7 +7,7 @@ function normalizeTickerToken(value: string): string {
 
 export function parseTickerListInput(raw: string, maxTickers = MAX_TICKER_LIST_SIZE): string[] {
   const tokens = raw
-    .split(/[,\n]/)
+    .split(/[,\s]+/)
     .map(normalizeTickerToken)
     .filter(Boolean);
 

package/src/tickers/metadata.ts

@@ -10,10 +10,12 @@ const DEFAULT_TICKER_METADATA: Omit<TickerMetadata, "ticker" | "exchange" | "cur
 };
 
 function hydratePosition(raw: Record<string, unknown>): TickerPosition {
+  const avgCost = Object.hasOwn(raw, "avgCost") ? raw.avgCost : raw.avg_cost;
   return {
     portfolio: (raw.portfolio as string) ?? "",
     shares: (raw.shares as number) ?? 0,
-    avgCost: (raw.avgCost ?? raw.avg_cost) as number ?? 0,
+    avgCost: typeof avgCost === "number" && Number.isFinite(avgCost) ? avgCost : undefined,
+    priceBasis: raw.priceBasis === "per-unit" || raw.priceBasis === "percent-of-par" ? raw.priceBasis : undefined,
     currency: (raw.currency as string) ?? undefined,
     dateAcquired: (raw.dateAcquired ?? raw.date_acquired) as string | undefined,
     broker: (raw.broker as string) ?? "manual",
@@ -25,6 +27,7 @@ function hydratePosition(raw: Record<string, unknown>): TickerPosition {
     brokerInstanceId: (raw.brokerInstanceId ?? raw.broker_instance_id) as string | undefined,
     brokerAccountId: (raw.brokerAccountId ?? raw.broker_account_id) as string | undefined,
     brokerContractId: (raw.brokerContractId ?? raw.broker_contract_id) as number | undefined,
+    brokerContractIdentity: typeof raw.brokerContractIdentity === "string" ? raw.brokerContractIdentity : undefined,
   };
 }
 

package/src/tickers/open-target.test.ts

@@ -0,0 +1,86 @@
+import { expect, test } from "bun:test";
+import { JsonTickerRepository } from "../data/json-ticker-repository";
+import { createTestDataProvider } from "../test-support/data-provider";
+import { AmbiguousTickerError } from "./search";
+import { resolveTickerOpenTarget } from "./open-target";
+
+function repository() {
+  const values = new Map<string, string>();
+  return new JsonTickerRepository({
+    getItem: (key) => values.get(key) ?? null,
+    setItem: (key, value) => { values.set(key, value); },
+    removeItem: (key) => { values.delete(key); },
+  });
+}
+
+test("opening validated venue links hydrates their exact key without changing another listing's holdings", async () => {
+  for (const query of ["VOD:XLON", "VOD.L"]) {
+    for (const savedExchange of [null, "NASDAQ", "LSE"]) {
+      const tickerRepository = repository();
+      const saved = savedExchange ? await tickerRepository.createTicker({
+        ticker: "VOD", exchange: savedExchange, currency: savedExchange === "LSE" ? "GBP" : "USD", name: "Vodafone",
+        portfolios: ["retirement"], watchlists: [], positions: [{ portfolio: "retirement", shares: 10, avgCost: 20, broker: "manual", currency: "USD" }], custom: {}, tags: [],
+      }) : null;
+      const before = await tickerRepository.loadTicker("VOD");
+      const target = await resolveTickerOpenTarget({
+        query, tickerRepository, tickers: new Map(saved ? [["VOD", saved]] : []),
+        dataProvider: createTestDataProvider({ search: async () => [{ providerId: "cloud", symbol: "VOD", exchange: "LSE", currency: "GBp", name: "Vodafone Group", type: "EQUITY" }] }),
+      });
+      expect(target?.symbol).toBe(query);
+      expect(target?.ticker.metadata).toMatchObject({ ticker: query, exchange: "LSE", positions: [], portfolios: [] });
+      expect(await tickerRepository.loadTicker(query)).not.toBeNull();
+      expect(await tickerRepository.loadTicker("VOD")).toEqual(before);
+    }
+  }
+});
+
+test("opening an ordinary query keeps the provider ticker instead of persisting search text", async () => {
+  const tickerRepository = repository();
+  const target = await resolveTickerOpenTarget({
+    query: "brkb", tickerRepository, tickers: new Map(),
+    dataProvider: createTestDataProvider({ search: async () => [{ providerId: "cloud", symbol: "BRK.B", exchange: "NYSE", currency: "USD", name: "Berkshire Hathaway", type: "EQUITY" }] }),
+  });
+  expect(target?.symbol).toBe("BRK.B");
+  expect(await tickerRepository.loadTicker("BRKB")).toBeNull();
+});
+
+test("quote-only hydration verifies the returned symbol and listing before preserving a qualified key", async () => {
+  for (const query of ["VOD:XLON", "VOD.L"]) {
+    for (const [symbol, exchange, valid] of [
+      ["VOD", "NASDAQ", false],
+      ["BARC", "LSE", false],
+      ["VOD", undefined, false],
+      ["VOD.L", "NASDAQ", false],
+      ["VOD", "LSE", true],
+      ["VOD.L", "LSE", true],
+    ] as const) {
+      const tickerRepository = repository();
+      const target = await resolveTickerOpenTarget({
+        query, tickerRepository, tickers: new Map(),
+        dataProvider: createTestDataProvider({ getQuote: async () => ({
+          symbol, exchangeName: exchange, price: 1.25, currency: "GBP", lastUpdated: 1, change: 0, changePercent: 0,
+        }) }),
+      });
+      if (!valid) {
+        expect(target).toBeNull();
+        expect(await tickerRepository.loadAllTickers()).toEqual([]);
+      } else {
+        expect(target?.ticker.metadata).toMatchObject({ ticker: query, exchange: "LSE", currency: "GBP" });
+      }
+    }
+  }
+});
+
+
+test("ambiguous search cannot fall through to an unqualified quote and create a ticker", async () => {
+  const tickerRepository = repository();
+  let quoteCalls = 0;
+  await expect(resolveTickerOpenTarget({ query: "GLD", tickerRepository, tickers: new Map(),
+    dataProvider: createTestDataProvider({
+      search: async () => ["BYMA", "NYSE"].map((exchange) => ({ providerId: "cloud", symbol: "GLD", name: "SPDR", exchange, type: "ETF" })),
+      getQuote: async () => { quoteCalls++; return { symbol: "GLD", currency: "USD", price: 400, lastUpdated: 1, change: 0, changePercent: 0 }; },
+    }),
+  })).rejects.toBeInstanceOf(AmbiguousTickerError);
+  expect(quoteCalls).toBe(1);
+  expect(await tickerRepository.loadAllTickers()).toEqual([]);
+});