gloomberb 0.13.3 → 0.14.0

package/src/components/chart/composite/format.ts

@@ -1,4 +1,4 @@
-import { formatMarketPriceWithCurrency } from "../../../market-data/market/format";
+import { formatMarketPriceWithCurrency, type MarketFormatOptions } from "../../../market-data/market/format";
 import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
 import type { CompositeAxisDomain } from "./types";
 
@@ -10,6 +10,8 @@ const CURRENCY_SYMBOLS: Record<string, string> = {
   CNY: "¥",
 };
 
+const CURRENCY_CODES = new Set(Intl.supportedValuesOf("currency"));
+
 const HOUR_MS = 60 * 60 * 1_000;
 const INTRADAY_SPAN_MAX_MS = 36 * HOUR_MS;
 
@@ -28,7 +30,7 @@ function compactNumber(value: number): string {
 
 function unitCurrencyCode(unit: string): string | null {
   const currency = unit.trim().toUpperCase().split(/[\s/]/)[0] ?? "";
-  return CURRENCY_SYMBOLS[currency] ? currency : null;
+  return CURRENCY_CODES.has(currency) ? currency : null;
 }
 
 function currencyPrefix(unit: string): string {
@@ -36,16 +38,65 @@ function currencyPrefix(unit: string): string {
   return currency ? CURRENCY_SYMBOLS[currency] ?? "" : "";
 }
 
-function formatFullCurrencyValue(value: number, unit: string): string | null {
+function formatFullCurrencyValue(
+  value: number,
+  unit: string,
+  assetCategory?: string,
+  options: MarketFormatOptions = {},
+): string | null {
   const currency = unitCurrencyCode(unit);
-  return currency ? formatMarketPriceWithCurrency(value, currency) : null;
+  return currency ? formatMarketPriceWithCurrency(value, currency, { ...options, assetCategory }) : null;
+}
+
+/** An axis can serve several price series. Keep the most precise value the
+ * shared formatter produces, rather than inheriting the first asset's rounding. */
+function formatAxisPriceValue(value: number, domain: CompositeAxisDomain, options: MarketFormatOptions = {}): string {
+  const categories = domain.priceAssetCategories?.length ? domain.priceAssetCategories : [undefined];
+  return categories.reduce<string>((best, category) => {
+    const formatted = formatFullCurrencyValue(value, domain.unit, category, options) ?? "";
+    return formatted.length > best.length ? formatted : best;
+  }, "");
+}
+
+const AXIS_TICK_COUNT = 3;
+
+function axisTickValue(domain: CompositeAxisDomain, ratio: number): number {
+  return domain.scale === "log"
+    ? Math.exp(Math.log(domain.max) + (Math.log(domain.min) - Math.log(domain.max)) * ratio)
+    : domain.max + (domain.min - domain.max) * ratio;
+}
+
+/** The narrowest distance between neighbouring ticks. A log axis bunches its
+ * lowest ticks together, so the tightest pair is what every label has to stay
+ * legible against. */
+function narrowestAxisTickGap(domain: CompositeAxisDomain): number | null {
+  const values = Array.from(
+    { length: AXIS_TICK_COUNT },
+    (_, index) => axisTickValue(domain, index / (AXIS_TICK_COUNT - 1)),
+  );
+  const gap = Math.min(...values.slice(1).map((value, index) => Math.abs(value - values[index]!)));
+  return Number.isFinite(gap) && gap > 0 ? gap : null;
+}
+
+/** What compactNumber's final digit is worth. Ticks nearer to each other than
+ * this render as the same label. */
+function compactResolution(value: number): number {
+  const absolute = Math.abs(value);
+  for (const divisor of [1e12, 1e9, 1e6, 1e3]) {
+    if (absolute >= divisor) return absolute >= divisor * 10 ? divisor : divisor / 10;
+  }
+  if (absolute >= 100) return 1;
+  if (absolute >= 10) return 0.1;
+  if (absolute >= 1) return 0.01;
+  // Sub-unit values keep three significant digits.
+  return absolute > 0 ? 10 ** (Math.floor(Math.log10(absolute)) - 2) : 0;
 }
 
 export function formatCompositeSeriesValue(value: number, series: ResolvedSeries): string {
-  return formatChartLegendValue(value, series.unit, series.unitGroup);
+  return formatChartLegendValue(value, series.unit, series.unitGroup, series.priceAssetCategory);
 }
 
-export function formatChartLegendValue(value: number, unit: string, unitGroup = ""): string {
+export function formatChartLegendValue(value: number, unit: string, unitGroup = "", assetCategory?: string): string {
   const trimmed = unit.trim();
   const group = unitGroup.toLowerCase();
   const compact = compactNumber(value);
@@ -54,7 +105,16 @@ export function formatChartLegendValue(value: number, unit: string, unitGroup =
   }
   if (group.includes("ratio") || trimmed.toLowerCase() === "x") return `${compact}x`;
   if (group.startsWith("derived-unit:")) return `${compact} ${trimmed}`;
-  const fullPrice = formatFullCurrencyValue(value, trimmed);
+  if (group.split(":")[0] === "currency-total") {
+    const scale = ([[1e12, "T"], [1e9, "B"], [1e6, "M"], [1e3, "K"]] as const)
+      .find(([divisor]) => Math.abs(value) >= divisor);
+    if (scale) {
+      const amount = `${Number((value / scale[0]).toFixed(2))}${scale[1]}`;
+      const prefix = currencyPrefix(trimmed);
+      return prefix ? `${prefix}${amount}` : `${amount} ${trimmed}`.trim();
+    }
+  }
+  const fullPrice = formatFullCurrencyValue(value, trimmed, assetCategory);
   if (fullPrice) return fullPrice;
   return trimmed && trimmed.length <= 6 ? `${compact}${trimmed.startsWith("/") ? "" : " "}${trimmed}` : compact;
 }
@@ -67,13 +127,27 @@ export function formatCompositeAxisValue(value: number, domain: CompositeAxisDom
   // Derived dimensions are included in the legend value. Axis labels stay
   // numeric so a narrow gutter cannot truncate USD/JPY into a false USD label.
   if (group.startsWith("derived-unit:")) return compact;
+  // Compact labels suit a wide view, but a zoomed one can hold several ticks
+  // inside a single rounding step and print one repeated price down the gutter.
+  // Where that happens the axis spends the digits needed to tell them apart,
+  // shared across every tick so the column reads as one scale.
+  const gap = narrowestAxisTickGap(domain);
+  if (gap !== null && gap < compactResolution(value)) {
+    const resolved = formatAxisPriceValue(value, domain, {
+      fixedFractionDigits: Math.max(0, Math.ceil(-Math.log10(gap))),
+    });
+    if (resolved) return resolved;
+  }
   return `${currencyPrefix(domain.unit)}${compact}`;
 }
 
 export function formatCompositeCursorValue(value: number, domain: CompositeAxisDomain): string {
   const group = domain.unitGroup.toLowerCase();
   if (group.startsWith("derived-unit:")) return compactNumber(value);
-  const fullPrice = formatFullCurrencyValue(value, domain.unit);
+  if (group.split(":")[0] === "currency-total") {
+    return formatChartLegendValue(value, domain.unit, domain.unitGroup);
+  }
+  const fullPrice = formatAxisPriceValue(value, domain);
   if (fullPrice) return fullPrice;
   return formatCompositeAxisValue(value, domain);
 }
@@ -88,9 +162,7 @@ export function compositeAxisTicks(
   const tickCount = Math.max(2, Math.floor(count));
   return Array.from({ length: tickCount }, (_, index) => {
     const ratio = index / (tickCount - 1);
-    const value = domain.scale === "log"
-      ? Math.exp(Math.log(domain.max) + (Math.log(domain.min) - Math.log(domain.max)) * ratio)
-      : domain.max + (domain.min - domain.max) * ratio;
+    const value = axisTickValue(domain, ratio);
     return { ratio, value, label: format(value, domain) };
   });
 }
@@ -139,7 +211,8 @@ export function formatCompositePointDetails(point: TimeSeriesPoint | null | unde
   const availableAt = validUtcTimestamp(point.availableAt);
 
   if (periodLabel) details.push(periodLabel);
-  if (observedAt) {
+  const labelIncludesObservedDate = ["Quarter", "Year", "TTM"].some((period) => periodLabel === `${period} ended ${observedAt}`);
+  if (observedAt && !labelIncludesObservedDate) {
     const isFiscalPeriod = periodLabel && periodLabel.toLowerCase() !== "current";
     details.push(`${isFiscalPeriod ? "Period ended" : "Observed"} ${observedAt}`);
   }

package/src/components/chart/composite/fx-precision.test.ts

@@ -0,0 +1,92 @@
+import { expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import { loadChartPaneModel } from "../../../plugins/builtin/chart-composer/headless";
+import { buildPriceChartPreset } from "../../../plugins/builtin/chart-composer/presets";
+import { formatMarketPriceWithCurrency } from "../../../market-data/market/format";
+import { applyResolvedSeriesTransform } from "../../../time-series/transforms";
+import type { HeadlessPaneContext } from "../../../types/headless";
+import { formatCompositeCursorValue, formatCompositeSeriesValue } from "./format";
+import { applyCompositeChartCursor, buildCompositeChartScene, resolveCompositeCursorDate } from "./scene";
+import { reuseResolvedSeriesIdentity } from "./panel-series";
+
+const cases = [
+  ["EURUSD=X", "USD", "CURRENCY", 1.1602274179458618, "$1.160227"],
+  ["USDEUR=X", "EUR", "CURRENCY", 0.8618999719619751, "€0.8619"],
+  ["JPY=X", "JPY", "CURRENCY", 153.5540008544922, "¥153.554001"],
+  ["JPYUSD=X", "USD", "CURRENCY", 0.00651236716657877, "$0.006512"],
+  ["AAPL", "USD", "EQUITY", 259.7499, "$259.75"],
+  // A real provider quote, not a hand-rounded one: crypto display precision has
+  // to survive the float tail rather than spend eight decimals on it.
+  ["BTC-USD", "USD", "CRYPTOCURRENCY", 109_556.1640625, "$109,556.16"],
+  ["ETH-USD", "USD", "CRYPTOCURRENCY", 3_421.8843212, "$3,421.88"],
+  ["SHIB-USD", "USD", "CRYPTOCURRENCY", 0.00000526, "$0.00000526"],
+] as const;
+
+async function priceModel(symbol: string, currency: string, instrumentType: string, value: number) {
+  const step = Math.min(0.0001, value / 10);
+  const points = [0, 1, 2].map((offset) => ({ date: new Date(Date.UTC(2026, 8, 9 + offset)), close: value + (offset - 2) * step }));
+  const spec = buildPriceChartPreset(symbol);
+  spec.viewport = { ...spec.viewport, range: "1M", resolution: "1d", dateWindow: { start: "2026-09-09", end: "2026-09-11" } };
+  spec.studies = [{ id: "sma", kind: "sma", inputSeriesIds: [spec.series[0]!.id], parameters: { period: 2 }, panelId: "main", axis: "left" }];
+  const provider = createTestDataProvider({
+    getQuote: async () => ({ symbol, currency, instrumentType, price: value, change: 0, changePercent: 0, lastUpdated: Date.parse("2026-09-11T21:00Z"), stale: true }),
+    getTickerFinancials: async () => ({ annualStatements: [], quarterlyStatements: [], priceHistory: points }),
+    getPriceHistory: async () => points,
+    getPriceHistoryForResolution: async () => points,
+    getDetailedPriceHistory: async () => points,
+  });
+  const model = await loadChartPaneModel(spec, {
+    marketData: provider, config: createDefaultConfig("/tmp/fx-precision-unused"),
+    apiClient: {} as HeadlessPaneContext["apiClient"], signal: new AbortController().signal,
+  });
+  return { model, points };
+}
+
+for (const [symbol, currency, category, value, expected] of cases) {
+  test(`${symbol} keeps its price basis through export, legend, pointer cursor and price study`, async () => {
+    const { model, points } = await priceModel(symbol, currency, category, value);
+    const series = model.chart.series.find((entry) => entry.id === model.spec.series[0]!.id)!;
+    expect(series.points.map((point) => point.value)).toEqual(points.map((point) => point.close));
+    const exported = JSON.parse(JSON.stringify(model)).series.find((entry: { id: string }) => entry.id === series.id);
+    expect(exported.points.at(-1).value).toBe(value);
+    expect(exported.unit).toBe(series.unit);
+    expect(formatCompositeSeriesValue(value, series)).toBe(expected);
+    expect(formatCompositeSeriesValue(value, exported)).toBe(expected);
+
+    const scene = buildCompositeChartScene(model.chart.series, model.spec.panels, { width: 101, height: 20 })!;
+    const panel = scene.panels.find((entry) => entry.series.some((item) => item.source.id === series.id))!;
+    const projected = panel.series.find((entry) => entry.source.id === series.id)!.points.at(-1)!;
+    const cursorDate = resolveCompositeCursorDate(scene, projected.xRatio * (scene.width - 1))!;
+    const cursor = applyCompositeChartCursor(scene, cursorDate).cursorValues.find((entry) => entry.seriesId === series.id)!;
+    expect(cursor.value).toBe(value);
+    expect(formatCompositeCursorValue(cursor.value!, panel.axes[series.axis]!)).toBe(expected);
+    const average = model.chart.series.find((entry) => entry.id === "sma")!;
+    const averageValue = average.points.at(-1)!.value!;
+    expect(formatCompositeSeriesValue(averageValue, average)).toBe(formatMarketPriceWithCurrency(averageValue, currency, { assetCategory: category }));
+  });
+}
+
+test("shared price axes retain FX cursor precision in either order and metadata recovery updates identical points", async () => {
+  const fx = (await priceModel("EURUSD=X", "USD", "CURRENCY", 1.1602274179458618)).model.chart.series[0]!;
+  const equity = (await priceModel("AAPL", "USD", "EQUITY", 259.7499)).model.chart.series[0]!;
+  for (const entries of [[equity, fx], [fx, equity]]) {
+    const scene = buildCompositeChartScene(entries, [{ id: "main" }], { width: 101, height: 20 })!;
+    expect(formatCompositeCursorValue(1.1602274179458618, scene.panels[0]!.axes.left!)).toBe("$1.160227");
+  }
+  const untyped = { ...fx, priceAssetCategory: undefined };
+  const recovered = reuseResolvedSeriesIdentity(untyped, fx);
+  expect(formatCompositeSeriesValue(1.1602274179458618, untyped)).toBe("$1.16");
+  expect(formatCompositeSeriesValue(1.1602274179458618, recovered)).toBe("$1.160227");
+  expect(recovered.points).toBe(untyped.points);
+});
+
+test("FX metadata does not turn normalized returns or ratios into currency prices", async () => {
+  const fx = (await priceModel("EURUSD=X", "USD", "CURRENCY", 1.1602274179458618)).model.chart.series[0]!;
+  const percent = applyResolvedSeriesTransform(fx, "percent");
+  const latest = percent.points.at(-1)!;
+  expect(latest.value).toBeCloseTo((fx.points.at(-1)!.value! / fx.points[0]!.value! - 1) * 100, 10);
+  expect(latest.rawValue).toBe(fx.points.at(-1)!.value);
+  expect(formatCompositeSeriesValue(latest.value!, percent)).toEndWith("%");
+  expect(formatCompositeSeriesValue(1.25, { ...fx, unit: "x", unitGroup: "ratio" })).toBe("1.25x");
+});

package/src/components/chart/composite/interactions.test.ts

@@ -80,6 +80,19 @@ function frameFor(
 }
 
 describe("composite chart interactions", () => {
+  test("default navigation retains dated edge gaps without extending to wholly unavailable series", () => {
+    const data = series([1, 2, 3, 10]);
+    data.points[0]!.value = null;
+    data.points[3]!.value = Number.NaN;
+    const unavailable = series([-100, 100]);
+    unavailable.points.forEach((point) => { point.value = null; });
+    const frame = buildCompositeNavigationFrame([data, unavailable], [data])!;
+    expect(frame.dataStart).toBe(viewport(1, 10).start.getTime());
+    expect(frame.dataEnd).toBe(viewport(1, 10).end.getTime());
+    expect(buildCompositeNavigationFrame([unavailable], [unavailable])).toBeNull();
+    expect(panCompositeViewport(frame, viewport(2, 3), -100 * DAY_MS).end).toEqual(viewport(1, 10).end);
+  });
+
   test("zooms around the right edge and clamps zoom-out to the loaded data", () => {
     const frame = frameFor(series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]));
     const full = viewport(1, 11);

package/src/components/chart/composite/interactions.ts

@@ -84,8 +84,10 @@ function dataExtent(series: readonly ResolvedSeries[]): { start: number; end: nu
   let start = Number.POSITIVE_INFINITY;
   let end = Number.NEGATIVE_INFINITY;
   for (const entry of series) {
+    // A drawable series owns its dated gaps too. Trimming these dates here
+    // overrides the scene's gap-aware bounds in the mounted chart.
+    if (!entry.points.some((point) => hasRenderableValue(point) && Number.isFinite(point.date.getTime()))) continue;
     for (const point of entry.points) {
-      if (!hasRenderableValue(point)) continue;
       const timestamp = point.date.getTime();
       if (!Number.isFinite(timestamp)) continue;
       if (timestamp < start) start = timestamp;

package/src/components/chart/composite/panel-series.ts

@@ -28,6 +28,7 @@ function sameSeriesMeta(left: ResolvedSeries, right: ResolvedSeries): boolean {
     && left.color === right.color
     && left.unit === right.unit
     && left.unitGroup === right.unitGroup
+    && left.priceAssetCategory === right.priceAssetCategory
     && left.nativeFrequency === right.nativeFrequency
     && left.timestampMode === right.timestampMode
     && left.dataShape === right.dataShape
@@ -38,6 +39,7 @@ function sameSeriesMeta(left: ResolvedSeries, right: ResolvedSeries): boolean {
     && left.interpolation === right.interpolation
     && left.warning === right.warning
     && left.hidden === right.hidden
+    && left.observationKind === right.observationKind
     && left.timeBasis?.kind === right.timeBasis?.kind
     && left.timeBasis?.timeZone === right.timeBasis?.timeZone
     && left.timeBasis?.cadenceMs === right.timeBasis?.cadenceMs;

package/src/components/chart/composite/price-axis-labels.test.ts

@@ -17,5 +17,13 @@ describe("buildCursorPriceAxisOverlay", () => {
 
     expect(overlay.labelText).toBe("$214.03");
     expect(overlay.topPercent).toBeCloseTo((cursorPixelY / (height * cellHeightPx - 1)) * 100, 5);
+
+    // An extreme value or a narrow pane must not present a partial amount or
+    // lose its trailing currency. The full value remains in the chart legend.
+    for (const cursorLabel of ["$90.01B", "-123.46M CAD", "$1,234,567.89"]) {
+      expect(buildCursorPriceAxisOverlay({
+        axisWidth: 4, axisSectionWidth: 5, height, cursorPixelY, cursorLabel, cellHeightPx,
+      }).labelText).toBe("…");
+    }
   });
 });

package/src/components/chart/composite/price-axis-labels.tsx

@@ -5,7 +5,9 @@ import { colors } from "../../../theme/colors";
 function formatAxisCell(label: string | null, width: number): string {
   if (width <= 0) return "";
   if (!label) return " ".repeat(width);
-  return label.length >= width ? label.slice(0, width) : label.padStart(width);
+  // A clipped numeric prefix can change both magnitude and currency. If a
+  // constrained chart cannot fit the complete label, show no partial value.
+  return ([...label].length > width ? "…" : label).padStart(width);
 }
 
 interface PriceAxisMarker {

package/src/components/chart/composite/price-series.ts

@@ -7,6 +7,7 @@ import type {
   TimeSeriesPoint,
 } from "../../../time-series/types";
 import type { PricePoint } from "../../../types/financials";
+import { pricePointValues, priceHistoryIntegrityNotice } from "../../../utils/price-history-integrity";
 
 export interface PricePointsToResolvedSeriesOptions {
   id: string;
@@ -24,23 +25,29 @@ export interface PricePointsToResolvedSeriesOptions {
   timeBasis?: ResolvedSeriesMarketTimeBasis;
 }
 
-function finiteOrNull(value: number | null | undefined): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
+// A chart re-resolves its series on every quote tick to append one live
+// point; the history points behind it never change identity, so their
+// resolved form is kept per point and provider.
+const resolvedPoints = new WeakMap<PricePoint, { providerId: string | undefined; resolved: TimeSeriesPoint | null }>();
 
 function normalizePricePoint(point: PricePoint, providerId?: string): TimeSeriesPoint | null {
+  const cached = resolvedPoints.get(point);
+  if (cached && cached.providerId === providerId) return cached.resolved;
+  const resolved = normalizePricePointUncached(point, providerId);
+  resolvedPoints.set(point, { providerId, resolved });
+  return resolved;
+}
+
+function normalizePricePointUncached(point: PricePoint, providerId?: string): TimeSeriesPoint | null {
   const date = point.date instanceof Date ? new Date(point.date) : new Date(point.date as unknown as string | number);
   if (!Number.isFinite(date.getTime())) return null;
+  const { integrity, ...values } = pricePointValues(point);
   return {
     date,
     observedAt: date,
-    value: finiteOrNull(point.close),
-    open: finiteOrNull(point.open),
-    high: finiteOrNull(point.high),
-    low: finiteOrNull(point.low),
-    close: finiteOrNull(point.close),
-    volume: finiteOrNull(point.volume),
-    provenance: providerId ? { providerId, quality: "reported" } : undefined,
+    value: values.close,
+    ...values,
+    provenance: providerId || integrity ? { providerId, quality: "reported", ...(integrity ? { priceHistoryIntegrity: integrity } : {}) } : undefined,
   };
 }
 
@@ -71,6 +78,6 @@ export function pricePointsToResolvedSeries(
     interpolation: "none",
     timeBasis: options.timeBasis,
     points: [...byTimestamp.values()].sort((left, right) => left.date.getTime() - right.date.getTime()),
-    warning: options.warning,
+    warning: [options.warning, priceHistoryIntegrityNotice([...byTimestamp.values()].filter((point) => point.provenance?.priceHistoryIntegrity).length)].filter(Boolean).join(" ") || undefined,
   };
 }

package/src/components/chart/composite/renderers.test.ts

@@ -115,13 +115,13 @@ describe("composite chart renderers", () => {
     expect(Math.max(...greenXs)).toBeLessThan(Math.min(...orangeXs));
   });
 
-  test("groups offset annual and quarterly fiscal closes into stable cohort lanes", () => {
+  test("groups explicit period-end labels and legacy fiscal labels into the same stable cohort lanes", () => {
     const cases = [
       {
         frequency: "annual" as const,
         first: [
-          { date: "2024-01-28", periodLabel: "FY2024" },
-          { date: "2025-01-26", periodLabel: "FY2025" },
+          { date: "2024-01-28", periodLabel: "Year ended 2024-01-28" },
+          { date: "2025-01-26", periodLabel: "Year ended 2025-01-26" },
         ],
         second: [
           { date: "2023-12-31", periodLabel: "FY2023" },
@@ -131,8 +131,8 @@ describe("composite chart renderers", () => {
       {
         frequency: "quarterly" as const,
         first: [
-          { date: "2024-01-28", periodLabel: "2024 Q1" },
-          { date: "2024-04-28", periodLabel: "2024 Q2" },
+          { date: "2024-01-28", periodLabel: "Quarter ended 2024-01-28" },
+          { date: "2024-04-28", periodLabel: "Quarter ended 2024-04-28" },
         ],
         second: [
           { date: "2023-12-31", periodLabel: "2023 Q4" },

package/src/components/chart/composite/scene-market-cursor.test.ts

@@ -0,0 +1,148 @@
+import { expect, test } from "bun:test";
+import { CHART_SPEC_VERSION, type ChartSpec, type ResolvedSeries, type TimeSeriesPoint } from "../../../time-series/types";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { resolveChartSpecData } from "../../../time-series/resolve";
+import { applyCompositeChartCursor, buildCompositeChartScene, resolveAdjacentCompositeCursorDate, resolveCompositeCursorDate } from "./scene";
+import { countMeasureBars } from "./tools";
+import { pricePointIntegrity } from "../../../utils/price-history-integrity";
+import { reuseResolvedSeriesIdentity } from "./panel-series";
+
+function market(id: string, zone: string, dates: string[], values: number[]): ResolvedSeries {
+  return {
+    id, label: id, color: "#ffffff", unit: "%", unitGroup: "percent", nativeFrequency: "daily",
+    dataShape: "scalar", style: "line", transform: "percent", axis: "left", panelId: "main", interpolation: "none",
+    timeBasis: { kind: "market", timeZone: zone, cadenceMs: 86_400_000 },
+    points: dates.map((date, index) => ({ date: new Date(date), value: values[index]! })),
+  };
+}
+const asx = () => market("ASX", "Australia/Sydney", ["2026-01-07T23:00:00Z", "2026-01-08T23:00:00Z"], [0, 10]);
+const us = () => market("US", "America/New_York", ["2026-01-08T14:30:00Z", "2026-01-09T14:30:00Z"], [0, 20]);
+
+test("every cross-market endpoint remains inspectable by pointer and keyboard in either series order", () => {
+  for (const entries of [[asx(), us()], [us(), asx()]]) {
+    const scene = buildCompositeChartScene(entries, [{ id: "main" }], { width: 101, height: 20 })!;
+    expect(scene.timeScale.kind === "market" && scene.timeScale.anchorSeriesId).toBe(entries[0]!.id);
+    const sortedDates = entries.flatMap(entry => entry.points.map(point => point.date.toISOString())).sort();
+    expect(scene.dates.map(date => date.toISOString())).toEqual(sortedDates);
+    for (const entry of scene.panels[0]!.series) for (const projected of entry.points) {
+      const requested = new Date(projected.timestamp);
+      const pointerDate = resolveCompositeCursorDate(scene, projected.xRatio * (scene.width - 1));
+      expect(pointerDate?.getTime()).toBe(requested.getTime());
+      const inspected = applyCompositeChartCursor(scene, requested);
+      expect(inspected.cursorDate?.getTime()).toBe(requested.getTime());
+      expect(inspected.cursorValues.find(value => value.seriesId === entry.source.id)?.value).toBe(projected.value);
+    }
+    const last = resolveAdjacentCompositeCursorDate(scene, null, -1)!;
+    expect(last.toISOString()).toBe("2026-01-09T14:30:00.000Z");
+    expect(applyCompositeChartCursor(scene, last).cursorValues.find(value => value.seriesId === "US")?.value).toBe(20);
+    let cursor = resolveAdjacentCompositeCursorDate(scene, null, 1)!;
+    const traversed = [cursor.toISOString()];
+    for (let index = 1; index < scene.dates.length; index++) {
+      cursor = resolveAdjacentCompositeCursorDate(scene, cursor, 1)!;
+      traversed.push(cursor.toISOString());
+    }
+    expect(traversed).toEqual(sortedDates);
+    // Cursor observations are not a count of the primary market's bars.
+    if (scene.timeScale.kind === "market") {
+      expect(countMeasureBars(scene.timeScale.anchors.map(anchor => new Date(anchor.timestamp)), scene.startTime, scene.endTime)).toBe(2);
+    }
+  }
+});
+
+test("new market cursor slots neither expose unpublished filings nor add nonmarket source dates", () => {
+  const published: TimeSeriesPoint = { date: new Date("2025-12-31"), value: 500, availableAt: new Date("2026-01-08T20:00:00Z") };
+  const notYetPublished: TimeSeriesPoint = { date: new Date("2026-01-01"), value: 900, availableAt: new Date("2026-01-10T20:00:00Z") };
+  const filing: ResolvedSeries = { ...asx(), id: "filing", timeBasis: undefined, transform: "raw", style: "columns", points: [published, notYetPublished] };
+  const scene = buildCompositeChartScene([asx(), us(), filing], [{ id: "main" }], {
+    width: 101, height: 20, clipToViewport: true,
+    viewport: { start: new Date("2026-01-07T23:00:00Z"), end: new Date("2026-01-09T14:30:00Z") },
+  })!;
+  expect(scene.dates.map(date => date.toISOString())).toEqual([
+    "2026-01-07T23:00:00.000Z", "2026-01-08T14:30:00.000Z", "2026-01-08T23:00:00.000Z", "2026-01-09T14:30:00.000Z",
+  ]);
+  expect(applyCompositeChartCursor(scene, new Date("2026-01-08T14:30:00Z")).cursorValues.find(value => value.seriesId === "filing")?.value).toBeNull();
+  const publishedCursor = applyCompositeChartCursor(scene, new Date("2026-01-08T23:00:00Z"));
+  expect(publishedCursor.cursorValues.find(value => value.seriesId === "filing")?.value).toBe(500);
+  const projected = scene.panels[0]!.series.find(entry => entry.source.id === "filing")!.points;
+  expect(projected).toHaveLength(1);
+  expect(projected[0]!.point).toBe(published);
+  expect(projected[0]!.xRatio).toBe(scene.panels[0]!.series.find(entry => entry.source.id === "ASX")!.points.at(-1)!.xRatio);
+});
+
+test("only finite visible market observations add cursor stops while a hidden primary preserves geometry", () => {
+  const primary = asx();
+  const secondary = us();
+  secondary.points.push({ date: new Date("2026-01-09T14:15:00Z"), value: null });
+  secondary.points.push({ date: new Date("2026-01-10T14:30:00Z"), value: 30 });
+  const scene = buildCompositeChartScene([secondary], [{ id: "main" }], {
+    width: 101, height: 20, timelineSeries: [primary, secondary], clipToViewport: true,
+    viewport: { start: primary.points[0]!.date, end: new Date("2026-01-09T14:30:00Z") },
+  })!;
+  expect(scene.timeScale.kind === "market" && scene.timeScale.anchorSeriesId).toBe("ASX");
+  expect(scene.dates.map(date => date.toISOString())).toEqual([
+    "2026-01-07T23:00:00.000Z", "2026-01-08T14:30:00.000Z", "2026-01-08T23:00:00.000Z", "2026-01-09T14:30:00.000Z",
+  ]);
+});
+
+test("resolved crypto weekend observations and their studies keep exact timestamps beside an equity market", async () => {
+  const history: Record<string, Array<{ date: Date; close: number }>> = {
+    "BTC-USD": ["2026-01-09", "2026-01-10", "2026-01-11"].map((date, index) => ({ date: new Date(date), close: 100 + index * 10 })),
+    SPY: [{ date: new Date("2026-01-09T14:30:00Z"), close: 50 }],
+  };
+  const getHistory = async (symbol: string) => history[symbol] ?? [];
+  const spec: ChartSpec = {
+    version: CHART_SPEC_VERSION,
+    viewport: { range: "1M", resolution: "1d", dateWindow: { start: "2026-01-09", end: "2026-01-11" } },
+    panels: [{ id: "main" }],
+    series: [["BTC-USD", "CCC"], ["SPY", "NYSE"]].map(([symbol, exchange]) => ({
+      id: symbol!, source: { kind: "security", instrument: { symbol: symbol!, exchange }, fieldId: "market.close" },
+      style: "line", transform: "raw", axis: "left", panelId: "main", interpolation: "none",
+    })),
+    studies: [{ id: "sma", kind: "sma", inputSeriesIds: ["BTC-USD"], parameters: { period: 2 }, panelId: "main", axis: "left" }],
+  };
+  const result = await resolveChartSpecData(spec, {
+    now: new Date("2026-01-12"),
+    dataProvider: createTestDataProvider({
+      getQuote: async symbol => ({ symbol, currency: "USD", instrumentType: symbol === "BTC-USD" ? "CRYPTOCURRENCY" : "ETF", price: history[symbol]!.at(-1)!.close, change: 0, changePercent: 0 }),
+      getTickerFinancials: async symbol => ({ annualStatements: [], quarterlyStatements: [], priceHistory: history[symbol] ?? [] }),
+      getDetailedPriceHistory: getHistory, getPriceHistory: getHistory, getPriceHistoryForResolution: getHistory,
+    }),
+    loadFredSeries: async () => ({ data: { observations: [], info: null }, fetchedAt: 0, stale: false, source: "network" as const }),
+  });
+  const crypto = result.series.find(entry => entry.id === "BTC-USD")!;
+  const average = result.series.find(entry => entry.id === "sma")!;
+  expect(crypto.timeBasis).toBeUndefined();
+  // Retaining a previous render's identical points must not discard newly
+  // established observation semantics at the identity-reuse boundary.
+  const reusedCrypto = reuseResolvedSeriesIdentity({ ...crypto, observationKind: undefined }, crypto);
+  const scene = buildCompositeChartScene(result.series.map(entry => entry.id === crypto.id ? reusedCrypto : entry), spec.panels, { width: 101, height: 20 })!;
+  const projected = scene.panels[0]!.series.find(entry => entry.source.id === "BTC-USD")!.points;
+  expect(projected.map(point => new Date(point.timestamp).toISOString())).toEqual(history["BTC-USD"]!.map(point => point.date.toISOString()));
+  for (const point of projected) {
+    expect(resolveCompositeCursorDate(scene, point.xRatio * (scene.width - 1))?.getTime()).toBe(point.timestamp);
+    expect(applyCompositeChartCursor(scene, new Date(point.timestamp)).cursorValues.find(value => value.seriesId === "BTC-USD")?.value).toBe(point.value);
+  }
+  expect(crypto.observationKind).toBe("market");
+  expect(average.observationKind).toBe("market");
+  expect(scene.panels[0]!.series.find(entry => entry.source.id === "sma")!.points.map(point => point.value)).toEqual([105, 115]);
+  const onlyCrypto = buildCompositeChartScene([crypto, average], spec.panels, { width: 101, height: 20 })!;
+  expect(onlyCrypto.timeScale.kind).toBe("calendar");
+  expect(onlyCrypto.dates.map(date => date.toISOString())).toEqual(history["BTC-USD"]!.map(point => point.date.toISOString()));
+});
+
+
+test("a quarantined crypto observation stays selectable beside an exchange session", () => {
+  const crypto = { ...asx(), id: "BTC", observationKind: "market" as const, timeBasis: undefined };
+  const invalidDate = new Date("2026-01-09T00:00:00Z");
+  const integrity = pricePointIntegrity({ date: invalidDate, open: 120, high: 110, low: 90, close: 100 })!;
+  crypto.points = [
+    { date: new Date("2026-01-08"), value: 100 },
+    { date: invalidDate, value: null, provenance: { priceHistoryIntegrity: integrity } },
+  ];
+  const scene = buildCompositeChartScene([us(), crypto], [{ id: "main" }], { width: 101, height: 20 })!;
+  expect(scene.dates.some(date => date.getTime() === invalidDate.getTime())).toBe(true);
+  const selected = applyCompositeChartCursor(scene, invalidDate);
+  expect(selected.cursorDate?.getTime()).toBe(invalidDate.getTime());
+  expect(selected.cursorValues.find(value => value.seriesId === "BTC")?.value).toBeNull();
+  expect(selected.cursorValues.find(value => value.seriesId === "BTC")?.point?.provenance?.priceHistoryIntegrity).toEqual(integrity);
+});