gloomberb 0.13.2 → 0.14.0

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);
+});

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

@@ -41,6 +41,63 @@ function series(overrides: Partial<ResolvedSeries> & Pick<ResolvedSeries, "id" |
 }
 
 describe("composite chart scene", () => {
+  test("default legend stays inside the viewport when the right buffer contains a newer observation", () => {
+    const margin = series({ id: "margin", unit: "%", unitGroup: "percent", points: [
+      point("2024-06-30", 44.64), point("2025-06-30", 45.62), point("2026-06-30", 46.78),
+    ] });
+    const options = { width: 100, height: 20, viewport: {
+      start: new Date("2016-01-01"), end: new Date("2025-12-31T23:59:59.999Z"),
+    } };
+    const scene = buildCompositeChartScene([margin], [{ id: "main" }], options)!;
+    // The navigation buffer remains available to draw and inspect explicitly.
+    expect(scene.panels[0]?.series[0]?.points.at(-1)?.value).toBe(46.78);
+    expect(scene.cursorValues[0]?.value).toBe(45.62);
+    const hovered = applyCompositeChartCursor(scene, new Date("2024-06-30"));
+    expect(hovered.cursorValues[0]?.value).toBe(44.64);
+    const cleared = applyCompositeChartCursor(hovered, null);
+    expect(cleared.cursorValues[0]?.value).toBe(45.62);
+    expect(cleared.panels).toBe(scene.panels);
+    const navigated = buildCompositeChartScene([margin], [{ id: "main" }], {
+      ...options, viewport: { start: new Date("2025-01-01"), end: new Date("2026-12-31") },
+    })!;
+    expect(navigated.cursorValues[0]?.value).toBe(46.78);
+    expect(margin.points).toHaveLength(3);
+  });
+
+  test("an empty default window cannot borrow a value from either side of its bounds", () => {
+    const options = { width: 100, height: 20, viewport: {
+      start: new Date("2016-01-01"), end: new Date("2025-12-31T23:59:59.999Z"),
+    } };
+    for (const date of ["2015-12-31", "2026-06-30"]) {
+      const scene = buildCompositeChartScene([series({ id: "outside", points: [point(date, 99)] })], [{ id: "main" }], options)!;
+      expect(scene.cursorValues.every((entry) => entry.value === null)).toBe(true);
+      const hovered = applyCompositeChartCursor(scene, new Date("2020-01-01"));
+      expect(applyCompositeChartCursor(hovered, null).cursorValues.every((entry) => entry.value === null)).toBe(true);
+    }
+  });
+
+  test("explicit research windows bound marks and hover while keeping source data available for navigation", () => {
+    const margin = series({ id: "margin", style: "columns", points: [
+      point("2025-06-30", 45.62), point("2026-06-30", 46.78),
+    ] });
+    const options = { width: 100, height: 20, clipToViewport: true, viewport: {
+      start: new Date("2016-01-01"), end: new Date("2025-12-31T23:59:59.999Z"),
+    } };
+    const scene = buildCompositeChartScene([margin], [{ id: "main" }], options)!;
+    expect(scene.panels[0]?.series[0]?.points.map((entry) => entry.value)).toEqual([45.62]);
+    expect(scene.dates.every((date) => date <= options.viewport.end)).toBe(true);
+    expect(applyCompositeChartCursor(scene, new Date("2026-06-30")).cursorValues[0]?.value).toBe(45.62);
+    const navigated = buildCompositeChartScene([margin], [{ id: "main" }], {
+      ...options, viewport: { start: new Date("2025-01-01"), end: new Date("2026-12-31") },
+    })!;
+    expect(navigated.panels[0]?.series[0]?.points.map((entry) => entry.value)).toEqual([45.62, 46.78]);
+    expect(margin.points).toHaveLength(2);
+    // Ordinary market charts retain their right offset and newest observation.
+    const ordinary = buildCompositeChartScene([margin], [{ id: "main" }], { width: 100, height: 20 })!;
+    expect(ordinary.panels[0]?.series[0]?.points.at(-1)?.value).toBe(46.78);
+    expect(ordinary.panels[0]?.series[0]?.points.at(-1)?.xRatio).toBeCloseTo(NEWEST_X_RATIO);
+  });
+
   test("keeps a panel and its height while its series has no observations in view", () => {
     const price = series({
       id: "price",
@@ -390,6 +447,87 @@ describe("composite chart scene", () => {
     expect(betweenDaily?.cursorValues.find((entry) => entry.seriesId === "quarterly")?.value).toBe(100);
   });
 
+  for (const style of ["line", "step"] as const) {
+    test(`${style} cursor stops at an explicit gap until a finite observation recovers`, () => {
+      const known = point("2026-09-01", 0.45);
+      const gap = { ...point("2026-09-02", 0), value: null, provenance: { quality: "derived" as const } };
+      const recovery = point("2026-09-04", 0);
+      const interrupted = series({
+        id: "interrupted", style, points: [known, gap, recovery],
+      });
+      const sparse = series({ id: "sparse", style, points: [known, recovery] });
+      const clock = series({
+        id: "clock", points: [1, 2, 3, 4, 5].map((day) => point(`2026-09-0${day}`, 100)),
+      });
+      const options = { width: 80, height: 10 };
+      const base = buildCompositeChartScene([interrupted, sparse, clock], [{ id: "main" }], options)!;
+      for (const [day, expected, expectedPoint] of [
+        [1, 0.45, known], [2, null, gap], [3, null, gap], [4, 0, recovery], [5, 0, recovery],
+      ] as const) {
+        const cursorDate = new Date(`2026-09-0${day}`);
+        const moved = applyCompositeChartCursor(base, cursorDate);
+        const rebuilt = buildCompositeChartScene([interrupted, sparse, clock], [{ id: "main" }], {
+          ...options, cursorDate,
+        })!;
+        for (const scene of [moved, rebuilt]) {
+          const inspected = scene.cursorValues.find((entry) => entry.seriesId === "interrupted");
+          expect(inspected?.value).toBe(expected);
+          expect(inspected?.point).toBe(expectedPoint);
+          expect(scene.cursorValues.find((entry) => entry.seriesId === "sparse")?.value).toBe(day < 4 ? 0.45 : 0);
+        }
+        expect(moved.panels).toBe(base.panels);
+      }
+    });
+  }
+
+  test("the idle and released cursor retain an explicit latest gap and its source date", () => {
+    const known = point("2026-09-01", 0.45);
+    const gap = { ...point("2026-09-02", 0), value: null };
+    const interrupted = series({ id: "ratio", style: "step", points: [known, gap] });
+    const clock = series({ id: "clock", points: [point("2026-09-01", 100), point("2026-09-03", 102)] });
+    const idle = buildCompositeChartScene([interrupted, clock], [{ id: "main" }], { width: 80, height: 10 })!;
+    expect(idle.cursorValues[0]?.value).toBeNull();
+    expect(idle.cursorValues[0]?.point).toBe(gap);
+    const inspected = applyCompositeChartCursor(idle, new Date("2026-09-03"));
+    expect(inspected.cursorValues[0]?.value).toBeNull();
+    expect(inspected.cursorValues[0]?.point).toBe(gap);
+    const released = applyCompositeChartCursor(inspected, null);
+    expect(released.cursorValues).toEqual(idle.cursorValues);
+  });
+
+  test("a missing latest market bar withholds the price marker until a finite close returns", () => {
+    const known = point("2026-09-01", 100);
+    const gap = { ...point("2026-09-02", 0), value: null };
+    const market = series({ id: "price", unitGroup: "price:USD", timeBasis: { kind: "market", timeZone: "America/New_York" }, points: [known, gap] });
+    const missing = buildCompositeChartScene([market], [{ id: "main" }], { width: 80, height: 10 })!;
+    expect(missing.panels[0]!.lastPrice).toBeUndefined();
+    expect(missing.cursorValues[0]!.value).toBeNull();
+    expect(missing.dates.map(date => date.toISOString().slice(0, 10))).toContain("2026-09-02");
+    const recovered = buildCompositeChartScene([{ ...market, points: [known, gap, point("2026-09-03", 0)] }], [{ id: "main" }], { width: 80, height: 10 })!;
+    expect(recovered.panels[0]!.lastPrice?.value).toBe(0);
+    expect(recovered.cursorValues[0]!.value).toBe(0);
+  });
+
+  test("a publication gap blocks a market cursor only once the missing observation is available", () => {
+    const known = { ...point("2024-09-30", 500), availableAt: new Date("2024-10-15") };
+    const gap = { ...point("2024-12-31", 0), value: null, availableAt: new Date("2025-01-06") };
+    const filing = series({ id: "filing", style: "step", points: [known, gap] });
+    const price = series({
+      id: "price", timeBasis: { kind: "market", timeZone: "UTC", cadenceMs: 24 * 60 * 60 * 1_000 },
+      points: [point("2025-01-03", 100), point("2025-01-06", 102), point("2025-01-07", 103)],
+    });
+    const scene = buildCompositeChartScene([price, filing], [{ id: "main" }], {
+      width: 80, height: 10, viewport: { start: new Date("2025-01-03"), end: new Date("2025-01-07") },
+    })!;
+    for (const [date, value, sourcePoint] of [
+      ["2025-01-03", 500, known], ["2025-01-06", null, gap], ["2025-01-07", null, gap],
+    ] as const) {
+      const inspected = applyCompositeChartCursor(scene, new Date(date)).cursorValues.find((entry) => entry.seriesId === "filing");
+      expect(inspected?.value).toBe(value);
+      expect(inspected?.point).toBe(sourcePoint);
+    }
+  });
+
   test("places a filing on its first eligible market slot without changing source timestamps", () => {
     const price = series({
       id: "price",
@@ -624,3 +762,31 @@ describe("composite chart scene", () => {
     expect(applyCompositeChartCursor(withCursor, new Date("2025-01-01T00:00:00.000Z"))).toBe(withCursor);
   });
 });
+
+test("a missing step observation before the viewport prevents carrying an older known level into it", () => {
+  const step = series({ id: "step", style: "step", interpolation: "step-after", points: [
+    point("2026-07-26", 4), { ...point("2026-08-01", 0), value: null }, point("2026-08-20", 5),
+  ] });
+  const scene = buildCompositeChartScene([step], [{ id: "main" }], {
+    width: 100, height: 20, viewport: { start: new Date("2026-08-10"), end: new Date("2026-09-10") },
+  });
+  const values = scene?.panels[0]?.series[0]?.points ?? [];
+  expect(values.length).toBeGreaterThan(0);
+  expect(values.every((point) => point.value === 5)).toBe(true);
+  expect(values[0]!.timestamp).toBe(new Date("2026-08-20").getTime());
+});
+
+test("opening step observations replace the older anchor before scaling and carrying levels", () => {
+  for (const value of [4, null]) {
+    const step = series({ id: "step", style: "step", interpolation: "step-after", points: [
+      point("2026-07-26", 999), { ...point("2026-08-10", 0), value }, point("2026-08-20", 5),
+    ] });
+    const scene = buildCompositeChartScene([step], [{ id: "main" }], {
+      width: 100, height: 20, viewport: { start: new Date("2026-08-10"), end: new Date("2026-09-10") },
+    });
+    const points = scene?.panels[0]?.series[0]?.points ?? [];
+    expect(points.length).toBeGreaterThan(0);
+    expect(points.every((point) => point.value !== 999)).toBe(true);
+    expect(points[0]!.timestamp).toBe(new Date(value === null ? "2026-08-20" : "2026-08-10").getTime());
+  }
+});

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

@@ -4,7 +4,7 @@ import type {
   ResolvedSeries,
   TimeSeriesPoint,
 } from "../../../time-series/types";
-import { effectiveTimeSeriesPointTime } from "../../../time-series/alignment";
+import { effectiveTimeSeriesPointTime, timeSeriesObservationKey } from "../../../time-series/alignment";
 import type {
   BuildCompositeChartSceneOptions,
   CompositeAxisDomain,
@@ -39,6 +39,10 @@ function pointTime(point: TimeSeriesPoint): number | null {
   return Number.isFinite(time) ? time : null;
 }
 
+function isMarketObservationSeries(series: ResolvedSeries): boolean {
+  return series.observationKind === "market" || series.timeBasis?.kind === "market";
+}
+
 function pointTimestampForScale(
   series: ResolvedSeries,
   point: TimeSeriesPoint,
@@ -46,7 +50,7 @@ function pointTimestampForScale(
 ): number | null {
   const timestamp = pointTime(point);
   if (timestamp === null) return null;
-  return timeScale?.kind === "market" && !series.timeBasis
+  return timeScale?.kind === "market" && !isMarketObservationSeries(series)
     ? effectiveTimeSeriesPointTime(point)
     : timestamp;
 }
@@ -75,20 +79,21 @@ function computeNormalizedSourcePoints(
   series: ResolvedSeries,
   timeScale?: CompositeTimeScale,
 ): NormalizedSourcePoint[] {
-  const bySourceTimestamp = new Map<number, NormalizedSourcePoint>();
+  const byObservation = new Map<string, NormalizedSourcePoint>();
   for (const point of series.points) {
     const sourceTimestamp = pointTime(point);
     const timestamp = pointTimestampForScale(series, point, timeScale);
     if (sourceTimestamp === null || timestamp === null || !Number.isFinite(timestamp)) continue;
-    bySourceTimestamp.set(sourceTimestamp, {
+    byObservation.set(timeSeriesObservationKey(point), {
       point,
       timestamp,
       value: resolveTimeSeriesPointValue(point),
     });
   }
-  return [...bySourceTimestamp.values()].sort((left, right) => (
+  return [...byObservation.values()].sort((left, right) => (
     left.timestamp - right.timestamp
     || left.point.date.getTime() - right.point.date.getTime()
+    || left.point.observedAt.getTime() - right.point.observedAt.getTime()
   ));
 }
 
@@ -96,7 +101,7 @@ function normalizedSourcePoints(
   series: ResolvedSeries,
   timeScale?: CompositeTimeScale,
 ): NormalizedSourcePoint[] {
-  const effectiveTimes = timeScale?.kind === "market" && !series.timeBasis;
+  const effectiveTimes = timeScale?.kind === "market" && !isMarketObservationSeries(series);
   const last = series.points[series.points.length - 1];
   const lastTimestamp = last ? pointTime(last) : null;
   const lastValue = last ? resolveTimeSeriesPointValue(last) : null;
@@ -154,18 +159,21 @@ function scopeSeriesToViewport(
   startTime: number,
   endTime: number,
   timeScale: CompositeTimeScale,
+  clipToViewport: boolean,
 ): ResolvedSeries | null {
   const points = normalizedSourcePoints(series, timeScale);
-  const placement = timeScale.kind === "market" && !series.timeBasis
+  const placement = timeScale.kind === "market" && !isMarketObservationSeries(series)
     ? "next-market-slot" as const
     : "timestamp" as const;
   const visible = points.filter(({ timestamp }) => {
     if (timestamp >= startTime && timestamp <= endTime) return true;
+    if (clipToViewport) return false;
     const projected = projectCompositeTimestamp(timeScale, timestamp, placement);
     return !!projected && projected.ratio >= 0 && projected.ratio <= 1;
   });
   if (series.interpolation === "step-after" || series.style === "step") {
-    const anchor = [...points].reverse().find(({ timestamp, value }) => timestamp < startTime && value !== null);
+    const anchor = points.some(({ timestamp }) => timestamp === startTime) ? undefined
+      : [...points].reverse().find(({ timestamp }) => timestamp < startTime);
     if (anchor && !visible.includes(anchor)) visible.unshift(anchor);
   }
   return visible.some(({ value }) => value !== null)
@@ -292,6 +300,7 @@ function buildAxisDomain(
     scale,
     unit: first.unit,
     unitGroup: first.unitGroup,
+    priceAssetCategories: [...new Set(axisSeries.flatMap((entry) => entry.priceAssetCategory ? [entry.priceAssetCategory] : []))],
     seriesIds: axisSeries.map((entry) => entry.id),
   };
 }
@@ -339,7 +348,7 @@ function projectSeries(
 ): CompositeProjectedPoint[] {
   const projected: CompositeProjectedPoint[] = [];
   let breakBefore = true;
-  const placement = timeScale.kind === "market" && !series.timeBasis
+  const placement = timeScale.kind === "market" && !isMarketObservationSeries(series)
     ? "next-market-slot" as const
     : "timestamp" as const;
   const stepSeries = series.interpolation === "step-after" || series.style === "step";
@@ -430,6 +439,9 @@ function attachLastPriceMarker(
   const projected = panel?.series.find((entry) => entry.source.id === primary.id);
   const domain = panel?.axes[primary.axis];
   if (!panel || !projected || !domain) return;
+  // A rejected or missing latest bar cannot make an older close current.
+  const latest = normalizedSourcePoints(primary).at(-1);
+  if (latest?.point.provenance?.priceHistoryIntegrity || latest?.value === null) return;
   const value = lastCloseOf(projected.points);
   if (value === null) return;
   const yRatio = projectCompositeValue(value, domain);
@@ -462,11 +474,10 @@ function nearestDate(dates: Date[], requested: Date): Date | null {
 
 function cursorPointForSeries(
   series: CompositePanelScene["series"][number],
-  cursorTime: number | null,
+  cursorTime: number,
 ): CompositeProjectedPoint | null {
   const points = series.points;
   if (points.length === 0) return null;
-  if (cursorTime === null) return points.at(-1) ?? null;
 
   let low = 0;
   let high = points.length;
@@ -481,17 +492,30 @@ function cursorPointForSeries(
 function buildCursorValues(
   panels: CompositePanelScene[],
   cursorDate: Date | null,
+  viewport: Pick<CompositeChartScene, "startTime" | "endTime" | "timeScale">,
 ): CompositeCursorValue[] {
-  const cursorTime = cursorDate?.getTime() ?? null;
+  const cursorTime = cursorDate?.getTime() ?? viewport.endTime;
   return panels.flatMap((panel) => panel.series.map((entry) => {
-    const projected = cursorPointForSeries(entry, cursorTime);
+    let projected = cursorPointForSeries(entry, cursorTime);
+    // Sparse observations can carry forward, but an explicitly unavailable
+    // observation ends that value at its date, including the idle legend.
+    const gap = normalizedSourcePoints(entry.source, viewport.timeScale).findLast(({ timestamp, point, value }) => (
+      timestamp <= cursorTime && (timestamp > (projected?.timestamp ?? Number.NEGATIVE_INFINITY)
+        || (timestamp === projected?.timestamp && point.observedAt > projected.point.observedAt))
+      && (point.provenance?.priceHistoryIntegrity || value === null)
+    ));
+    if (gap) projected = null;
+    // The drawn navigation buffer can include observations after the chosen
+    // end. An unarmed legend describes the active window, including when the
+    // pointer leaves; explicitly inspected cursor dates keep their own behavior.
+    if (!cursorDate && projected && projected.timestamp < viewport.startTime) projected = null;
     return {
       seriesId: entry.source.id,
       label: entry.source.label,
       color: entry.source.color,
       unit: entry.source.unit,
       value: projected?.value ?? null,
-      point: projected?.point ?? null,
+      point: projected?.point ?? gap?.point ?? null,
     };
   }));
 }
@@ -517,7 +541,7 @@ export function applyCompositeChartCursor(
     ...scene,
     cursorDate,
     cursorXRatio,
-    cursorValues: buildCursorValues(scene.panels, cursorDate),
+    cursorValues: buildCursorValues(scene.panels, cursorDate, scene),
   };
 }
 
@@ -529,7 +553,9 @@ export function buildCompositeChartScene(
   const dataSeries = series.filter((entry) => normalizedPoints(entry).length > 0);
   if (dataSeries.length === 0) return null;
 
-  const times = dataSeries.flatMap((entry) => normalizedPoints(entry).map((point) => point.timestamp));
+  // A known missing observation owns a date even though it has no drawable
+  // value. Retain it in the window and cursor timeline, including trailing gaps.
+  const times = dataSeries.flatMap((entry) => normalizedSourcePoints(entry).map((point) => point.timestamp));
   const uniqueTimes = [...new Set(times)].sort((left, right) => left - right);
   if (uniqueTimes.length === 0) return null;
   const firstTime = uniqueTimes[0]!;
@@ -549,13 +575,13 @@ export function buildCompositeChartScene(
   // The plot reaches past the viewport by the reserved right offset. Panned
   // back into history that space holds real observations, so navigation and
   // the cursor follow the drawn edge rather than the viewport end.
-  const plotEndTime = Math.max(endTime, unprojectCompositeTimestamp(timeScale, 1));
+  const plotEndTime = options.clipToViewport ? endTime : Math.max(endTime, unprojectCompositeTimestamp(timeScale, 1));
   // A step holds its level to the newest observation and no further: the space
   // reserved after it stays empty. With data still ahead of the window, the
   // level runs to the drawn edge instead.
   const stepTrailingTime = Math.min(plotEndTime, Math.max(lastTime, endTime));
   const scopedSeries = viewport
-    ? dataSeries.flatMap((entry) => scopeSeriesToViewport(entry, startTime, endTime, timeScale) ?? [])
+    ? dataSeries.flatMap((entry) => scopeSeriesToViewport(entry, startTime, endTime, timeScale, options.clipToViewport === true) ?? [])
     : dataSeries;
   // A range without observations still has a chart: keep the panels, axes and
   // grid and simply draw no points, instead of blanking the whole surface.
@@ -565,9 +591,19 @@ export function buildCompositeChartScene(
     : scopedSeries;
   const visibleTimes = uniqueTimes.filter((time) => time >= startTime && time <= plotEndTime);
   const marketTimes = timeScale.kind === "market"
-    ? timeScale.anchors
-      .map(({ timestamp }) => timestamp)
+    // The first market controls session spacing, but every plotted market
+    // observation must remain inspectable. Other exchanges can trade before
+    // or after its anchors. Nonmarket source dates stay excluded: filings
+    // retain their availability-based placement on eligible market slots.
+    ? [...new Set([
+      ...timeScale.anchors.map(({ timestamp }) => timestamp),
+      ...scopedSeries.filter(isMarketObservationSeries)
+        .flatMap((entry) => normalizedSourcePoints(entry)
+          .filter(({ value, point }) => value !== null || point.provenance?.priceHistoryIntegrity)
+          .map(({ timestamp }) => timestamp)),
+    ])]
       .filter((time) => time >= startTime && time <= plotEndTime)
+      .sort((left, right) => left - right)
     : [];
   const cursorTimes = timeScale.kind === "market" ? marketTimes : visibleTimes;
   const dates = (cursorTimes.length > 0
@@ -631,7 +667,7 @@ export function buildCompositeChartScene(
     panels: panelScenes,
     cursorDate,
     cursorXRatio,
-    cursorValues: buildCursorValues(panelScenes, cursorDate),
+    cursorValues: buildCursorValues(panelScenes, cursorDate, { startTime, endTime, timeScale }),
   };
 }