gloomberb 0.15.2 → 0.15.4

package/src/layout-marketplace/payload.test.ts

@@ -1,419 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { PaneRuntimeState } from "../core/state/app/types";
-import type { PaneDef } from "../types/plugin";
-import {
-  materializeMarketplaceLayout,
-  parseMarketplaceLayoutEntry,
-  parseMarketplaceLayoutList,
-  publishableMarketplaceLayout,
-  publishableMarketplacePane,
-} from "./payload";
-
-const component = () => null;
-const panes = new Map<string, PaneDef>([
-  ["twitter-feed", {
-    id: "twitter-feed",
-    name: "X Feed",
-    component,
-    defaultPosition: "right",
-  }],
-  ["prediction-markets", {
-    id: "prediction-markets",
-    name: "Prediction Markets",
-    component,
-    defaultPosition: "right",
-  }],
-  ["portfolio-list", {
-    id: "portfolio-list",
-    name: "Portfolio",
-    component,
-    defaultPosition: "left",
-    portableShare: {
-      private: { title: true, params: true, settings: true, state: true },
-    },
-  }],
-]);
-
-function portableFixture() {
-  const feedId = "twitter-feed:from:@private-user";
-  const predictionId = "prediction-markets:fed-search";
-  const portfolioId = "portfolio-list:private-account";
-  const layout = {
-    dockRoot: {
-      kind: "split" as const,
-      axis: "horizontal" as const,
-      ratio: 0.6,
-      first: { kind: "pane" as const, instanceId: feedId },
-      second: {
-        kind: "split" as const,
-        axis: "vertical" as const,
-        ratio: 0.5,
-        first: { kind: "pane" as const, instanceId: predictionId },
-        second: { kind: "pane" as const, instanceId: portfolioId },
-      },
-    },
-    instances: [
-      {
-        instanceId: feedId,
-        paneId: "twitter-feed",
-        title: "Semiconductor X Feed",
-        params: { query: "$NVDA OR $AMD", queryType: "Latest" },
-        settings: { dense: true, accessToken: "must-not-leave-device" },
-        binding: { kind: "none" as const },
-        placementMemory: { floating: { x: 1, y: 2, width: 20, height: 8 } },
-      },
-      {
-        instanceId: predictionId,
-        paneId: "prediction-markets",
-        params: { query: "fed", scope: "polymarket" },
-        binding: { kind: "follow" as const, sourceInstanceId: feedId },
-      },
-      {
-        instanceId: portfolioId,
-        paneId: "portfolio-list",
-        title: "Family account",
-        params: { collectionId: "family" },
-        settings: { visibleCollectionIds: ["family"] },
-        binding: { kind: "none" as const },
-      },
-    ],
-    floating: [],
-    detached: [],
-  };
-  const paneState: Record<string, PaneRuntimeState> = {
-    [feedId]: {
-      pluginState: {
-        "gloomberb-cloud": {
-          feeds: {
-            feeds: [{ id: "feed-1", query: "$NVDA OR $AMD", queryType: "Latest" }],
-          },
-          sessionToken: "must-not-leave-device",
-        },
-      },
-    },
-    [predictionId]: {
-      pluginState: {
-        "prediction-markets": {
-          venueScope: "polymarket",
-          searchQuery: "fed",
-          browseTab: "top",
-        },
-      },
-    },
-    [portfolioId]: {
-      collectionId: "family",
-      pluginState: { portfolio: { currentValue: 1_000_000 } },
-    },
-  };
-  return { layout, paneState };
-}
-
-function validEntry() {
-  const fixture = portableFixture();
-  const payload = publishableMarketplaceLayout(fixture.layout, fixture.paneState, panes);
-  return {
-    id: "0123456789abcdef0123456789abcdef",
-    name: "Social Desk",
-    ...payload,
-    author: { username: "analyst", displayName: "Analyst" },
-    publishedAt: "2026-08-26T00:00:00.000Z",
-  };
-}
-
-describe("layout marketplace payloads", () => {
-  test("projects one pane through the same privacy contract", () => {
-    const pane = publishableMarketplacePane({
-      instanceId: "twitter-feed:private-source",
-      paneId: "twitter-feed",
-      title: "Semiconductor X Feed",
-      params: { query: "$NVDA OR $AMD" },
-      settings: { dense: true, accessToken: "secret" },
-      binding: { kind: "follow", sourceInstanceId: "portfolio-list:private" },
-    }, {
-      pluginState: {
-        "gloomberb-cloud": {
-          feeds: { feeds: [{ query: "$NVDA OR $AMD" }] },
-          sessionToken: "secret",
-        },
-      },
-    }, panes, "NVDA");
-
-    expect(pane.layout.instances).toEqual([{
-      instanceId: "p1",
-      paneId: "twitter-feed",
-      title: "Semiconductor X Feed",
-      params: { query: "$NVDA OR $AMD" },
-      settings: { dense: true },
-      binding: { kind: "fixed", symbol: "NVDA" },
-    }]);
-    expect(pane.paneState.p1).toMatchObject({
-      pluginState: {
-        "gloomberb-cloud": {
-          feeds: { feeds: [{ query: "$NVDA OR $AMD" }] },
-        },
-      },
-    });
-    expect(JSON.stringify(pane)).not.toContain("private-source");
-    expect(JSON.stringify(pane)).not.toContain("secret");
-  });
-
-  test("drops cache-sized pane state instead of failing the share", () => {
-    const pane = publishableMarketplacePane({
-      instanceId: "news-top:main",
-      paneId: "prediction-markets",
-      binding: { kind: "none" },
-    }, {
-      sort: { columnId: "time", direction: "desc" },
-      "news-top:articles": Array.from({ length: 400 }, (_, index) => ({
-        id: `article-${index}`,
-        title: "x".repeat(200),
-        publishedAt: "2026-08-26T00:00:00.000Z",
-      })),
-    }, panes);
-
-    expect(pane.paneState.p1).toEqual({ sort: { columnId: "time", direction: "desc" } });
-  });
-
-  test("drops an oversized plugin-state key without taking the pane's open item with it", () => {
-    const pane = publishableMarketplacePane({
-      instanceId: "news-top:main",
-      paneId: "prediction-markets",
-      binding: { kind: "none" },
-    }, {
-      pluginState: {
-        news: {
-          "news-top:openArticleId": "article-7",
-          "news-top:articles": Array.from({ length: 400 }, (_, index) => ({
-            id: `article-${index}`,
-            title: "x".repeat(200),
-            publishedAt: "2026-08-26T00:00:00.000Z",
-          })),
-        },
-      },
-    }, panes);
-
-    expect(pane.paneState.p1).toEqual({
-      pluginState: { news: { "news-top:openArticleId": "article-7" } },
-    });
-  });
-
-  test("pins a fixed binding to its public listing key and leaves the broker contract behind", () => {
-    const listed = publishableMarketplacePane({
-      instanceId: "chart:1",
-      paneId: "twitter-feed",
-      binding: { kind: "fixed", symbol: "SHEL", listing: { exchange: "LSE", name: "Shell", currency: "GBp", type: "Common Stock" } },
-    }, {}, panes);
-    expect(listed.layout.instances[0]?.binding).toEqual({ kind: "fixed", symbol: "SHEL:XLON" });
-
-    const brokered = publishableMarketplacePane({
-      instanceId: "chart:2",
-      paneId: "twitter-feed",
-      binding: {
-        kind: "fixed",
-        symbol: "aapl",
-        instrument: { brokerId: "ibkr", brokerInstanceId: "ibkr:1", conId: 265598, symbol: "AAPL", exchange: "SMART" } as never,
-      },
-    }, {}, panes);
-    expect(brokered.layout.instances[0]?.binding).toEqual({ kind: "fixed", symbol: "AAPL" });
-    expect(JSON.stringify(brokered)).not.toContain("265598");
-  });
-
-  test("lets a pane pin what it resolved locally before it leaves the device", () => {
-    const prepared = publishableMarketplacePane({
-      instanceId: "chart:1",
-      paneId: "pinning",
-      settings: { symbol: "SHEL" },
-    }, {}, new Map([["pinning", {
-      id: "pinning",
-      name: "Pinning",
-      component,
-      defaultPosition: "right",
-      portableShare: {
-        prepare: (pane, { tickers }) => ({
-          ...pane,
-          settings: { ...pane.settings, exchange: tickers.get(String(pane.settings?.symbol))?.metadata.exchange },
-        }),
-      },
-    }]]), null, {
-      tickers: new Map([["SHEL", { metadata: { ticker: "SHEL", exchange: "LSE" } } as never]]),
-    });
-    expect(prepared.layout.instances[0]?.settings).toEqual({ symbol: "SHEL", exchange: "LSE" });
-  });
-
-  test("shares portable pane setup and state while redacting private data", () => {
-    const fixture = portableFixture();
-    const payload = publishableMarketplaceLayout(fixture.layout, fixture.paneState, panes);
-
-    expect(payload.schemaVersion).toBe(2);
-    expect(payload.layout.instances.map((instance) => instance.instanceId)).toEqual(["p1", "p2", "p3"]);
-    expect(payload.layout.instances[0]).toEqual({
-      instanceId: "p1",
-      paneId: "twitter-feed",
-      title: "Semiconductor X Feed",
-      params: { query: "$NVDA OR $AMD", queryType: "Latest" },
-      settings: { dense: true },
-      binding: { kind: "none" },
-    });
-    expect(payload.layout.instances[1]?.binding).toEqual({ kind: "follow", sourceInstanceId: "p1" });
-    expect(payload.layout.instances[2]).toEqual({
-      instanceId: "p3",
-      paneId: "portfolio-list",
-      binding: { kind: "none" },
-    });
-    expect(payload.paneState.p1).toMatchObject({
-      pluginState: {
-        "gloomberb-cloud": {
-          feeds: { feeds: [{ query: "$NVDA OR $AMD", queryType: "Latest" }] },
-        },
-      },
-    });
-    expect(payload.paneState.p2).toMatchObject({
-      pluginState: { "prediction-markets": { searchQuery: "fed" } },
-    });
-    expect(payload.paneState.p3).toBeUndefined();
-    expect(JSON.stringify(payload)).not.toContain("must-not-leave-device");
-    expect(JSON.stringify(payload)).not.toContain("family");
-    expect(JSON.stringify(payload)).not.toContain("private-user");
-    expect(JSON.stringify(payload)).not.toContain("placementMemory");
-  });
-
-  test("keeps the config of a pane whose plugin is not installed here", () => {
-    const payload = publishableMarketplaceLayout({
-      dockRoot: { kind: "pane", instanceId: "tv:1" },
-      instances: [{
-        instanceId: "tv:1",
-        paneId: "gloomberb-tv:screener",
-        title: "Movers",
-        params: { universe: "sp500" },
-        settings: { dense: true, apiKey: "leak" },
-      }],
-      floating: [],
-      detached: [],
-    }, { "tv:1": { cursorSymbol: "NVDA", password: "no" } }, panes);
-    expect(payload.layout.instances[0]).toEqual({
-      instanceId: "p1",
-      paneId: "gloomberb-tv:screener",
-      title: "Movers",
-      params: { universe: "sp500" },
-      settings: { dense: true },
-    });
-    expect(payload.paneState.p1).toEqual({ cursorSymbol: "NVDA" });
-    expect(JSON.stringify(payload)).not.toContain("leak");
-    expect(JSON.stringify(payload)).not.toContain("password");
-  });
-
-  test("keeps team-scoped collection references and drops personal ones", () => {
-    const layout = {
-      dockRoot: { kind: "pane" as const, instanceId: "pl:1" },
-      instances: [{
-        instanceId: "pl:1",
-        paneId: "portfolio-list",
-        params: { collectionId: "team:org-1:abc" },
-        settings: { collectionId: "team:org-1:abc", visibleCollectionIds: ["team:org-1:abc", "team:org-1:def"] },
-      }],
-      floating: [],
-      detached: [],
-    };
-    // The real portfolio pane marks the collection fields private by name.
-    const portfolioPanes = new Map<string, PaneDef>([["portfolio-list", {
-      id: "portfolio-list",
-      name: "Portfolio",
-      component,
-      defaultPosition: "left",
-      portableShare: {
-        private: {
-          params: ["collectionId"],
-          settings: ["collectionId", "visibleCollectionIds"],
-          state: ["collectionId", "collectionSorts"],
-        },
-      },
-    }]]);
-    const team = publishableMarketplaceLayout(layout, { "pl:1": { collectionId: "team:org-1:abc" } }, portfolioPanes);
-    expect(team.layout.instances[0]?.params).toEqual({ collectionId: "team:org-1:abc" });
-    expect(team.layout.instances[0]?.settings).toEqual({
-      collectionId: "team:org-1:abc",
-      visibleCollectionIds: ["team:org-1:abc", "team:org-1:def"],
-    });
-    expect(team.paneState.p1).toEqual({ collectionId: "team:org-1:abc" });
-
-    const personal = publishableMarketplaceLayout({
-      ...layout,
-      instances: [{ ...layout.instances[0]!, params: { collectionId: "main" }, settings: { collectionId: "broker:ibkr:x", visibleCollectionIds: ["team:org-1:abc", "main"] } }],
-    }, { "pl:1": { collectionId: "main" } }, portfolioPanes);
-    expect(personal.layout.instances[0]?.params).toBeUndefined();
-    expect(personal.layout.instances[0]?.settings).toBeUndefined();
-    expect(personal.paneState.p1).toBeUndefined();
-  });
-
-  test("round-trips a custom view spec through publish and materialize unchanged", () => {
-    const spec = JSON.stringify({
-      version: 1,
-      source: { kind: "inline", pane: "SCR", argument: "sp500", options: { limit: 50 } },
-      projection: { columns: [{ key: "symbol" }, { key: "change", transform: "percent" }], filters: [{ key: "change", op: "gt", value: 0.02 }], sort: { by: "change", direction: "desc" } },
-      presentation: { title: "Movers", symbolKey: "symbol" },
-    });
-    const viewPanes = new Map<string, PaneDef>([["custom-view", { id: "custom-view", name: "View", component, defaultPosition: "right" }]]);
-    const layout = {
-      dockRoot: { kind: "pane" as const, instanceId: "view:1" },
-      instances: [{ instanceId: "view:1", paneId: "custom-view", title: "Movers", settings: { spec } }],
-      floating: [],
-      detached: [],
-    };
-    const payload = publishableMarketplaceLayout(layout, {}, viewPanes);
-    expect(payload.layout.instances[0]?.settings).toEqual({ spec });
-    const materialized = materializeMarketplaceLayout(payload);
-    expect(materialized.layout.instances[0]?.settings).toEqual({ spec });
-    const shared = publishableMarketplacePane(layout.instances[0]!, {}, viewPanes);
-    expect(shared.layout.instances[0]?.settings).toEqual({ spec });
-  });
-
-  test("materializes independent pane ids and rewrites state and follow bindings", () => {
-    const entry = validEntry();
-    const materialized = materializeMarketplaceLayout(
-      entry,
-      (paneId, index) => `${paneId}:copy-${index + 1}`,
-    );
-
-    expect(materialized.layout.instances.map((instance) => instance.instanceId)).toEqual([
-      "twitter-feed:copy-1",
-      "prediction-markets:copy-2",
-      "portfolio-list:copy-3",
-    ]);
-    expect(materialized.layout.instances[1]?.binding).toEqual({
-      kind: "follow",
-      sourceInstanceId: "twitter-feed:copy-1",
-    });
-    expect(materialized.paneState["twitter-feed:copy-1"]).toEqual(entry.paneState.p1);
-    expect(materialized.paneState.p1).toBeUndefined();
-  });
-
-  test("accepts old structural entries and rejects malformed or private v2 responses", () => {
-    const entry = validEntry();
-    expect(parseMarketplaceLayoutList({ items: [entry] })).toEqual([entry]);
-
-    const legacy = {
-      ...entry,
-      schemaVersion: 1,
-      layout: {
-        dockRoot: { kind: "pane", instanceId: "legacy:query-is-visible" },
-        instances: [{ instanceId: "legacy:query-is-visible", paneId: "twitter-feed" }],
-        floating: [],
-        detached: [],
-      },
-    } as Record<string, unknown>;
-    delete legacy.paneState;
-    expect(parseMarketplaceLayoutEntry(legacy)).toMatchObject({ schemaVersion: 1, paneState: {} });
-
-    const privateResponse = structuredClone(entry);
-    privateResponse.layout.instances[0]!.settings = { sessionToken: "secret" };
-    expect(parseMarketplaceLayoutEntry(privateResponse)).toBeNull();
-
-    const rawIds = structuredClone(entry);
-    rawIds.layout.instances[0]!.instanceId = "twitter-feed:raw-query";
-    expect(parseMarketplaceLayoutEntry(rawIds)).toBeNull();
-
-    const dangling = structuredClone(entry);
-    dangling.layout.dockRoot = { kind: "pane", instanceId: "p99" };
-    expect(parseMarketplaceLayoutEntry(dangling)).toBeNull();
-  });
-});

package/src/market-data/coordinator/chart-session.test.ts

@@ -1,152 +0,0 @@
-import { afterEach, expect, setSystemTime, test } from "bun:test";
-import { MarketDataCoordinator } from "./index";
-import { createTestDataProvider } from "../../test-support/data-provider";
-import type { PriceHistoryResult, HistorySession } from "../../types/price-history";
-import type { ChartRequest } from "../request-types";
-
-const coordinators: MarketDataCoordinator[] = [];
-afterEach(() => { coordinators.splice(0).forEach(coordinator => coordinator.destroy()); setSystemTime(); });
-const at = (time: string) => Date.parse(time);
-const preopen = at("2026-09-22T12:42:12Z");
-const request: ChartRequest = { instrument: { symbol: "AAPL", exchange: "NASDAQ" }, bufferRange: "1M",
-  granularity: "resolution", resolution: "15m" };
-const sourceKey = "provider:gloomberb-cloud";
-const proof = (patch: Partial<HistorySession> = {}): HistorySession => ({ version: 1, kind: "regular", calendar: "us-equity",
-  timeZone: "America/New_York", symbol: "AAPL", exchange: "NASDAQ", interval: "15min", source: "yahoo",
-  timestampConvention: "bar-open", barAlignment: "session-open", observedAt: Date.now(), ...patch });
-function result(time = "2026-09-21T19:45:00Z", patch: Partial<PriceHistoryResult> = {}): PriceHistoryResult {
-  return { points: [{ date: new Date(time), close: 338.8900146484375, volume: 2218511 }],
-    resolution: "15m", session: proof(), sourceKey, ...patch };
-}
-function coordinator(load: (...args: any[]) => Promise<PriceHistoryResult>) {
-  const instance = new MarketDataCoordinator(createTestDataProvider({ id: "preferred-router",
-    getPriceHistoryForResolutionWithMetadata: load,
-    getPriceHistory: async () => { throw new Error("Unexpected legacy/default history traversal"); } }));
-  coordinators.push(instance);
-  return instance;
-}
-
-test("coordinator retains actual source/session/cadence and does not renew cache age during normalization", async () => {
-  setSystemTime(preopen);
-  let calls = 0;
-  const instance = coordinator(async () => { calls++; return result(); });
-  const first = await instance.loadChart(request);
-  expect(first.data?.[0]?.close).toBe(338.8900146484375);
-  expect(first.history).toMatchObject({ resolution: "15m", sourceKey, session: { observedAt: preopen, source: "yahoo" } });
-  expect(first.source).toBe(sourceKey);
-  setSystemTime(preopen + 9 * 60_000);
-  const cached = await instance.loadChart(request);
-  expect(calls).toBe(1);
-  expect(cached.fetchedAt).toBe(first.fetchedAt);
-  expect(cached.history).toEqual(first.history);
-  setSystemTime(preopen + 11 * 60_000);
-  await instance.loadChart(request);
-  expect(calls).toBe(2);
-});
-
-test("the first due completed bar invalidates cached prior-session history inside its ten-minute TTL", async () => {
-  const beforeDue = at("2026-09-22T13:44:00Z");
-  setSystemTime(beforeDue);
-  let calls = 0;
-  const instance = coordinator(async () => result(++calls === 1 ? "2026-09-21T19:59:00Z" : "2026-09-22T13:45:00Z",
-    { resolution: "1m", session: proof({ interval: "1min" }) }));
-  const minuteRequest = { ...request, resolution: "1m" as const };
-  expect((await instance.loadChart(minuteRequest)).data).toHaveLength(1);
-  setSystemTime(at("2026-09-22T13:46:00Z"));
-  const refreshed = await instance.loadChart(minuteRequest);
-  expect(calls).toBe(2);
-  expect(refreshed.data?.[0]?.date.toISOString()).toBe("2026-09-22T13:45:00.000Z");
-});
-
-test("a stale intraday bar invalidates coordinator cache before TTL without borrowing quote freshness", async () => {
-  setSystemTime(at("2026-09-22T14:01:00Z"));
-  let calls = 0;
-  const instance = coordinator(async () => result(++calls === 1 ? "2026-09-22T13:32:00Z" : "2026-09-22T14:02:00Z",
-    { resolution: "1m", session: proof({ interval: "1min" }) }));
-  const minuteRequest = { ...request, resolution: "1m" as const };
-  await instance.loadChart(minuteRequest);
-  setSystemTime(at("2026-09-22T14:03:00Z"));
-  expect((await instance.loadChart(minuteRequest)).data?.[0]?.date.toISOString()).toBe("2026-09-22T14:02:00.000Z");
-  expect(calls).toBe(2);
-});
-
-test("empty and failed refreshes preserve retained history's own source, acquisition time and cache age", async () => {
-  setSystemTime(preopen);
-  let calls = 0;
-  const instance = coordinator(async () => {
-    if (++calls === 1) return result();
-    if (calls === 2) return result(undefined, { points: [], sourceKey: "provider:other", session: proof({ source: "twelvedata" }) });
-    throw new Error("Controlled provider outage");
-  });
-  const first = await instance.loadChart(request);
-  setSystemTime(preopen + 60_000);
-  const empty = await instance.loadChart(request, { forceRefresh: true });
-  expect(empty.data).toBeNull();
-  expect(empty.lastGoodData).toEqual(first.data);
-  expect(empty.history).toEqual(first.history);
-  expect(empty.source).toBe(first.source);
-  expect(empty.fetchedAt).toBe(first.fetchedAt);
-  setSystemTime(preopen + 120_000);
-  const failed = await instance.loadChart(request, { forceRefresh: true });
-  expect(failed.lastGoodData).toEqual(first.data);
-  expect(failed.history).toEqual(first.history);
-  expect(failed.source).toBe(first.source);
-  expect(failed.fetchedAt).toBe(first.fetchedAt);
-  expect(failed.error?.message).toContain("outage");
-});
-
-test("pending failures cannot retain a loading seed after its next session becomes due", async () => {
-  setSystemTime(at("2026-09-22T13:44:00Z"));
-  let reject: (error: Error) => void = () => {};
-  let calls = 0;
-  const instance = coordinator(async () => ++calls === 1
-    ? result("2026-09-21T19:59:00Z", { resolution: "1m", session: proof({ interval: "1min" }) })
-    : new Promise<PriceHistoryResult>((_resolve, fail) => { reject = fail; }));
-  const narrow = { ...request, bufferRange: "1W" as const, resolution: "1m" as const };
-  const wider = { ...request, resolution: "1m" as const };
-  const first = await instance.loadChart(narrow);
-  const pending = instance.loadChart(wider);
-  const loading = instance.getChartEntry(wider);
-  expect(loading.data).toEqual(first.data);
-  expect(loading.history).toEqual(first.history);
-  expect(loading.fetchedAt).toBe(first.fetchedAt);
-  setSystemTime(at("2026-09-22T13:46:00Z"));
-  reject(new Error("Controlled provider outage"));
-  const failed = await pending;
-  expect(failed.lastGoodData).toBeNull();
-  expect(failed.data).toBeNull();
-  expect(failed.history).toBeUndefined();
-});
-
-test("source contracts never cross instrument scope and unknown sources keep conservative freshness", async () => {
-  setSystemTime(preopen);
-  const unproven = coordinator(async () => result(undefined, { session: undefined, sourceKey: "provider:extended" }));
-  expect((await unproven.loadChart(request)).data).toBeNull();
-  const mismatch = coordinator(async () => result(undefined, { session: proof({ symbol: "MSFT" }) }));
-  expect((await mismatch.loadChart(request)).data).toBeNull();
-  let release: (value: PriceHistoryResult) => void = () => {};
-  let calls = 0;
-  const instance = coordinator(async () => ++calls === 1 ? result() : new Promise(resolve => { release = resolve; }));
-  await instance.loadChart({ ...request, bufferRange: "1W" });
-  const other = { ...request, instrument: { ...request.instrument, brokerId: "ibkr", brokerInstanceId: "work" } };
-  const pending = instance.loadChart(other);
-  expect(instance.getChartEntry(other).data).toBeNull();
-  release(result());
-  await pending;
-});
-
-test("historical detail and source-declared daily periods keep their original cadence rules", async () => {
-  setSystemTime(preopen);
-  const historical = new MarketDataCoordinator(createTestDataProvider({
-    getDetailedPriceHistoryWithMetadata: async () => result("2026-09-11T13:30:00Z", { session: undefined }),
-    getPriceHistoryWithMetadata: async () => result("2024-01-01T00:00:00Z", { session: undefined, resolution: "1d" }),
-  }));
-  coordinators.push(historical);
-  const detailed = await historical.loadChart({ ...request, granularity: "detail", startDate: new Date("2026-09-10T00:00:00Z"),
-    endDate: new Date("2026-09-12T00:00:00Z"), barSize: "15m" });
-  expect(detailed.data).toHaveLength(1);
-  expect(detailed.history?.resolution).toBe("15m");
-  const daily = await historical.loadChart({ instrument: request.instrument, granularity: "range", bufferRange: "1M" });
-  expect(daily.data).toHaveLength(1);
-  expect(daily.history?.resolution).toBe("1d");
-});

package/src/market-data/coordinator/events.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createManualFrameDriver, DataFrameScheduler } from "../frame-scheduler";
-import { MarketDataCoordinatorEvents } from "./events";
-
-function createEvents(minIntervalMs = 100) {
-  const clock = createManualFrameDriver(minIntervalMs);
-  const frames = new DataFrameScheduler(clock.driver);
-  return { clock, events: new MarketDataCoordinatorEvents(frames) };
-}
-
-describe("MarketDataCoordinatorEvents", () => {
-  test("coalesces a frame's bumps into one notification", () => {
-    const { clock, events } = createEvents();
-    const calls: number[] = [];
-    events.subscribeKeys(["quote:AMD"], () => {
-      calls.push(events.getKeysVersion(["quote:AMD"]));
-    });
-
-    events.bump("quote:AMD");
-    events.bump("quote:AMD");
-    expect(calls).toEqual([]);
-
-    clock.advance(0);
-    expect(calls).toEqual([1]);
-  });
-
-  test("delivers bumps made while notifying on the next frame, not the same one", () => {
-    const { clock, events } = createEvents();
-    const order: string[] = [];
-    events.subscribeKeys(["quote:AMD"], () => {
-      order.push("AMD");
-      events.bump("quote:NVDA");
-    });
-    events.subscribeKeys(["quote:NVDA"], () => {
-      order.push("NVDA");
-    });
-
-    events.bump("quote:AMD");
-    clock.advance(0);
-    expect(order).toEqual(["AMD"]);
-
-    clock.advance(99);
-    expect(order).toEqual(["AMD"]);
-    clock.advance(1);
-    expect(order).toEqual(["AMD", "NVDA"]);
-  });
-
-  test("a burst of ticks notifies at most once per frame interval", () => {
-    const { clock, events } = createEvents();
-    const calls: number[] = [];
-    events.subscribeKeys(["quote:AMD"], () => {
-      calls.push(events.getKeysVersion(["quote:AMD"]));
-    });
-
-    events.bump("quote:AMD");
-    clock.advance(0);
-    expect(calls).toEqual([1]);
-
-    for (let tick = 0; tick < 5; tick += 1) {
-      events.bump("quote:AMD");
-      clock.advance(10);
-    }
-    expect(calls).toEqual([1]);
-
-    clock.advance(50);
-    expect(calls).toEqual([1, 2]);
-  });
-});