gloomberb 0.5.0 → 0.6.0

package/src/market-data/hooks.tsx

@@ -1,29 +1,49 @@
-import { useEffect, useMemo, useSyncExternalStore } from "react";
-import type { NewsItem, SecFilingItem } from "../types/data-provider";
+import { useCallback, useEffect, useMemo, useSyncExternalStore } from "react";
+import type { SecFilingItem } from "../types/data-provider";
 import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
-import type { ChartRequest, InstrumentRef, NewsRequest, OptionsRequest, SecFilingsRequest } from "./request-types";
+import type { ChartRequest, InstrumentRef, OptionsRequest, SecFilingsRequest } from "./request-types";
 import { instrumentFromTicker } from "./request-types";
 import {
   getSharedMarketDataCoordinator,
   resolveEntryValue,
 } from "./coordinator";
 import type { QueryEntry } from "./result-types";
-import { buildChartKey } from "./selectors";
-
-function useCoordinatorVersion(): number {
+import {
+  buildArticleSummaryKey,
+  buildChartKey,
+  buildFxKey,
+  buildOptionsKey,
+  buildQuoteKey,
+  buildSecContentKey,
+  buildSecFilingsKey,
+  buildSnapshotKey,
+} from "./selectors";
+
+const TICKER_FINANCIALS_LOAD_DELAY_MS = 250;
+
+function useCoordinatorKeysVersion(keys: readonly string[]): number {
   const coordinator = getSharedMarketDataCoordinator();
-  return useSyncExternalStore(
-    coordinator?.subscribe.bind(coordinator) ?? (() => () => {}),
-    () => coordinator?.getVersion() ?? 0,
-    () => 0,
+  const keyString = keys.join("\u001f");
+  const stableKeys = useMemo(
+    () => (keyString ? keyString.split("\u001f") : []),
+    [keyString],
   );
-}
-
-function useCoordinatorSelector<T>(selector: (coordinator: NonNullable<ReturnType<typeof getSharedMarketDataCoordinator>>) => T, fallback: T): T {
-  const coordinator = getSharedMarketDataCoordinator();
-  useCoordinatorVersion();
-  return coordinator ? selector(coordinator) : fallback;
+  const subscribe = useCallback((listener: () => void) => {
+    if (!coordinator) return () => {};
+    if (typeof coordinator.subscribeKeys === "function") {
+      return coordinator.subscribeKeys(stableKeys, listener);
+    }
+    return coordinator.subscribe(listener);
+  }, [coordinator, stableKeys]);
+  const getSnapshot = useCallback(() => {
+    if (!coordinator) return 0;
+    if (typeof coordinator.getKeysVersion === "function") {
+      return coordinator.getKeysVersion(stableKeys);
+    }
+    return coordinator.getVersion();
+  }, [coordinator, stableKeys]);
+  return useSyncExternalStore(subscribe, getSnapshot, () => 0);
 }
 
 function stableCurrencyList(currencies: Array<string | null | undefined>): string[] {
@@ -55,24 +75,52 @@ export function useTickerInstrument(symbol: string | null | undefined, ticker: T
 
 export function useTickerFinancials(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): TickerFinancials | null {
   const instrument = useTickerInstrument(symbol, ticker);
-  const financials = useCoordinatorSelector(
-    (coordinator) => (instrument ? coordinator.getTickerFinancialsSync(instrument) : null),
-    null,
-  );
+  const keys = useMemo(() => (
+    instrument
+      ? [
+        buildSnapshotKey(instrument),
+        buildQuoteKey(instrument),
+        buildChartKey({ instrument, bufferRange: "5Y", granularity: "range" }),
+      ]
+      : []
+  ), [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol]);
+  useCoordinatorKeysVersion(keys);
+  const coordinator = getSharedMarketDataCoordinator();
+  const financials = coordinator && instrument
+    ? coordinator.getTickerFinancialsSync(instrument)
+    : null;
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator || !instrument) return;
-    void coordinator.loadSnapshot(instrument);
+    const timeoutId = setTimeout(() => {
+      void coordinator.loadSnapshot(instrument);
+    }, TICKER_FINANCIALS_LOAD_DELAY_MS);
+    return () => clearTimeout(timeoutId);
   }, [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol]);
 
   return financials;
 }
 
+function buildTickerFinancialsKeys(tickers: TickerRecord[]): string[] {
+  const keys: string[] = [];
+  for (const ticker of tickers) {
+    const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+    if (!instrument) continue;
+    keys.push(
+      buildSnapshotKey(instrument),
+      buildQuoteKey(instrument),
+      buildChartKey({ instrument, bufferRange: "5Y", granularity: "range" }),
+    );
+  }
+  return keys;
+}
+
 export function useTickerFinancialsMap(tickers: TickerRecord[]): Map<string, TickerFinancials> {
   const coordinator = getSharedMarketDataCoordinator();
-  const version = useCoordinatorVersion();
   const tickerKey = buildTickerFinancialsMapKey(tickers);
+  const subscriptionKeys = useMemo(() => buildTickerFinancialsKeys(tickers), [tickerKey]);
+  const keysVersion = useCoordinatorKeysVersion(subscriptionKeys);
 
   return useMemo(() => {
     if (!coordinator) return new Map<string, TickerFinancials>();
@@ -86,15 +134,18 @@ export function useTickerFinancialsMap(tickers: TickerRecord[]): Map<string, Tic
       }
     }
     return result;
-  }, [coordinator, tickerKey, version]);
+  }, [coordinator, keysVersion, tickerKey, subscriptionKeys]);
 }
 
 export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): QueryEntry<Quote> | null {
   const instrument = useTickerInstrument(symbol, ticker);
-  const entry = useCoordinatorSelector(
-    (coordinator) => (instrument ? coordinator.getQuoteEntry(instrument) : null),
-    null,
+  const keys = useMemo(
+    () => (instrument ? [buildQuoteKey(instrument)] : []),
+    [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol],
   );
+  useCoordinatorKeysVersion(keys);
+  const coordinator = getSharedMarketDataCoordinator();
+  const entry = coordinator && instrument ? coordinator.getQuoteEntry(instrument) : null;
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
@@ -107,10 +158,9 @@ export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerR
 
 export function useChartQuery(request: ChartRequest | null | undefined): QueryEntry<PricePoint[]> | null {
   const key = request ? buildChartKey(request) : null;
-  const entry = useCoordinatorSelector(
-    (coordinator) => (request ? coordinator.getChartEntry(request) : null),
-    null,
-  );
+  useCoordinatorKeysVersion(key ? [key] : []);
+  const coordinator = getSharedMarketDataCoordinator();
+  const entry = coordinator && request ? coordinator.getChartEntry(request) : null;
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
@@ -127,9 +177,14 @@ export function useChartQueries(
 ): Map<string, QueryEntry<PricePoint[]>> {
   const requestKey = requests.map((request) => buildChartKey(request)).join(",");
   const debounceMs = Math.max(0, options.debounceMs ?? 0);
-  const entries = useCoordinatorSelector((coordinator) => (
-    requests.map((request) => [buildChartKey(request), coordinator.getChartEntry(request)] as const)
-  ), [] as Array<readonly [string, QueryEntry<PricePoint[]>]>);
+  const keys = useMemo(() => requests.map((request) => buildChartKey(request)), [requestKey]);
+  const keysVersion = useCoordinatorKeysVersion(keys);
+  const coordinator = getSharedMarketDataCoordinator();
+  const entries = useMemo(() => (
+    coordinator
+      ? requests.map((request) => [buildChartKey(request), coordinator.getChartEntry(request)] as const)
+      : [] as Array<readonly [string, QueryEntry<PricePoint[]>]>
+  ), [coordinator, keys, keysVersion, requestKey]);
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
@@ -150,60 +205,41 @@ export function useChartQueries(
   return useMemo(() => new Map(entries), [entries]);
 }
 
-export function useNewsQuery(request: NewsRequest | null | undefined): QueryEntry<NewsItem[]> | null {
-  const key = request ? `${request.instrument.symbol}|${request.instrument.exchange ?? ""}|${request.count ?? 50}` : null;
-  const entry = useCoordinatorSelector(
-    (coordinator) => (request ? coordinator.getNewsEntry(request) : null),
-    null,
-  );
-
-  useEffect(() => {
-    const coordinator = getSharedMarketDataCoordinator();
-    if (!coordinator || !request) return;
-    void coordinator.loadNews(request);
-  }, [key]);
-
-  return entry;
-}
-
 export function useOptionsQuery(request: OptionsRequest | null | undefined): QueryEntry<OptionsChain> | null {
-  const key = request ? `${request.instrument.symbol}|${request.instrument.exchange ?? ""}|${request.expirationDate ?? "default"}` : null;
-  const entry = useCoordinatorSelector(
-    (coordinator) => (request ? coordinator.getOptionsEntry(request) : null),
-    null,
-  );
+  const requestKey = request ? buildOptionsKey(request) : null;
+  useCoordinatorKeysVersion(requestKey ? [requestKey] : []);
+  const coordinator = getSharedMarketDataCoordinator();
+  const entry = coordinator && request ? coordinator.getOptionsEntry(request) : null;
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator || !request) return;
     void coordinator.loadOptions(request);
-  }, [key]);
+  }, [requestKey]);
 
   return entry;
 }
 
 export function useSecFilingsQuery(request: SecFilingsRequest | null | undefined): QueryEntry<SecFilingItem[]> | null {
-  const key = request ? `${request.instrument.symbol}|${request.instrument.exchange ?? ""}|${request.count ?? 50}` : null;
-  const entry = useCoordinatorSelector(
-    (coordinator) => (request ? coordinator.getSecFilingsEntry(request) : null),
-    null,
-  );
+  const requestKey = request ? buildSecFilingsKey(request) : null;
+  useCoordinatorKeysVersion(requestKey ? [requestKey] : []);
+  const coordinator = getSharedMarketDataCoordinator();
+  const entry = coordinator && request ? coordinator.getSecFilingsEntry(request) : null;
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator || !request) return;
     void coordinator.loadSecFilings(request);
-  }, [key]);
+  }, [requestKey]);
 
   return entry;
 }
 
 export function useSecFilingContent(filing: SecFilingItem | null | undefined): QueryEntry<string | null> | null {
-  const key = filing?.accessionNumber ?? null;
-  const entry = useCoordinatorSelector(
-    (coordinator) => (filing ? coordinator.getSecContentEntry(filing.accessionNumber) : null),
-    null,
-  );
+  const key = filing ? buildSecContentKey(filing.accessionNumber) : null;
+  useCoordinatorKeysVersion(key ? [key] : []);
+  const coordinator = getSharedMarketDataCoordinator();
+  const entry = coordinator && filing ? coordinator.getSecContentEntry(filing.accessionNumber) : null;
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
@@ -215,10 +251,10 @@ export function useSecFilingContent(filing: SecFilingItem | null | undefined): Q
 }
 
 export function useArticleSummary(url: string | null | undefined): QueryEntry<string | null> | null {
-  const entry = useCoordinatorSelector(
-    (coordinator) => (url ? coordinator.getArticleSummaryEntry(url) : null),
-    null,
-  );
+  const key = url ? buildArticleSummaryKey(url) : null;
+  useCoordinatorKeysVersion(key ? [key] : []);
+  const coordinator = getSharedMarketDataCoordinator();
+  const entry = coordinator && url ? coordinator.getArticleSummaryEntry(url) : null;
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
@@ -229,33 +265,19 @@ export function useArticleSummary(url: string | null | undefined): QueryEntry<st
   return entry;
 }
 
-export function useFxRate(currency: string | null | undefined): QueryEntry<number> | null {
-  const entry = useCoordinatorSelector(
-    (coordinator) => (currency ? coordinator.getFxEntry(currency) : null),
-    null,
-  );
-
-  useEffect(() => {
-    const coordinator = getSharedMarketDataCoordinator();
-    if (!coordinator || !currency) return;
-    void coordinator.loadFxRate(currency);
-  }, [currency]);
-
-  return entry;
-}
-
 export function useFxRatesMap(currencies: Array<string | null | undefined>): Map<string, number> {
   const coordinator = getSharedMarketDataCoordinator();
-  const version = useCoordinatorVersion();
   const normalizedCurrencyKey = stableCurrencyList(currencies).join("|");
   const normalizedCurrencies = useMemo(
     () => (normalizedCurrencyKey ? normalizedCurrencyKey.split("|") : []),
     [normalizedCurrencyKey],
   );
+  const keys = useMemo(() => normalizedCurrencies.map(buildFxKey), [normalizedCurrencies]);
+  const keysVersion = useCoordinatorKeysVersion(keys);
   const entries = useMemo(() => {
     if (!coordinator) return [] as Array<readonly [string, QueryEntry<number>]>;
     return normalizedCurrencies.map((currency) => [currency, coordinator.getFxEntry(currency)] as const);
-  }, [coordinator, normalizedCurrencies, version]);
+  }, [coordinator, keys, keysVersion, normalizedCurrencies]);
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();

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

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

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

@@ -47,18 +47,4 @@ describe("quoteSubscriptionTargetFromTicker", () => {
     });
   });
 
-  test("still returns a valid unscoped target when no broker contract exists", () => {
-    const ticker = makeTicker();
-
-    expect(quoteSubscriptionTargetFromTicker(ticker, ticker.metadata.ticker)).toEqual({
-      symbol: "AAPL",
-      exchange: "NASDAQ",
-      route: "auto",
-      context: {
-        brokerId: undefined,
-        brokerInstanceId: undefined,
-        instrument: null,
-      },
-    });
-  });
 });

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

@@ -1,3 +1,4 @@
+
 export type ProviderStatus = "success" | "partial" | "empty" | "unsupported" | "retryable_error" | "fatal_error";
 
 export type ProviderReasonCode =

package/src/news/aggregator.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect, beforeEach, mock } from "bun:test";
+import { NewsService } from "./aggregator";
+import { newsProvider, type NewsCapability } from "../capabilities";
+import type { MarketNewsItem } from "../types/news-source";
+
+function makeItem(overrides: Partial<MarketNewsItem> & { url: string }): MarketNewsItem {
+  return {
+    ...overrides,
+    id: overrides.url,
+    title: "Test headline",
+    url: overrides.url,
+    source: "Test",
+    publishedAt: overrides.publishedAt ?? new Date(),
+    topic: overrides.topic ?? "general",
+    topics: overrides.topics ?? [overrides.topic ?? "general"],
+    sectors: overrides.sectors ?? [],
+    categories: overrides.categories ?? [],
+    tickers: [],
+    scores: overrides.scores ?? {
+      importance: overrides.importance ?? 50,
+      urgency: overrides.isBreaking ? 80 : 0,
+      marketImpact: overrides.importance ?? 50,
+      novelty: 0,
+      confidence: 0,
+    },
+    importance: overrides.importance ?? 50,
+    isBreaking: overrides.isBreaking ?? false,
+    isDeveloping: overrides.isDeveloping ?? false,
+    summary: undefined,
+  };
+}
+
+function makeSource(id: string, items: MarketNewsItem[]): NewsCapability {
+  return newsProvider({
+    id,
+    name: id,
+    provider: {
+      fetchNews: mock(async () => items),
+    },
+  });
+}
+
+function makeCachedSource(id: string, cachedItems: MarketNewsItem[], fetchItems: MarketNewsItem[] = []): NewsCapability {
+  return newsProvider({
+    id,
+    name: id,
+    provider: {
+      getCachedNews: () => cachedItems,
+      fetchNews: mock(async () => fetchItems),
+    },
+  });
+}
+
+describe("NewsService", () => {
+  let agg: NewsService;
+
+  beforeEach(() => {
+    agg = new NewsService();
+  });
+
+  it("deduplicates by URL, keeping higher importance", async () => {
+    const low = makeItem({ url: "https://example.com/1", importance: 40 });
+    const high = makeItem({ url: "https://example.com/1", importance: 80 });
+
+    agg.register(makeSource("a", [low]));
+    agg.register(makeSource("b", [high]));
+    await agg.poll();
+
+    const stories = agg.getTopStories(10);
+    expect(stories).toHaveLength(1);
+    expect(stories[0]!.importance).toBe(80);
+  });
+
+  it("getTopStories returns items sorted by importance descending", async () => {
+    const items = [
+      makeItem({ url: "https://a.com/1", importance: 30 }),
+      makeItem({ url: "https://a.com/2", importance: 90 }),
+      makeItem({ url: "https://a.com/3", importance: 60 }),
+    ];
+    agg.register(makeSource("a", items));
+    await agg.poll();
+
+    const stories = agg.getTopStories(10);
+    expect(stories[0]!.importance).toBe(90);
+    expect(stories[1]!.importance).toBe(60);
+    expect(stories[2]!.importance).toBe(30);
+  });
+
+  it("getFirehose returns items sorted by publishedAt descending", async () => {
+    const now = Date.now();
+    const items = [
+      makeItem({ url: "https://b.com/1", publishedAt: new Date(now - 3000) }),
+      makeItem({ url: "https://b.com/2", publishedAt: new Date(now - 1000) }),
+      makeItem({ url: "https://b.com/3", publishedAt: new Date(now - 2000) }),
+    ];
+    agg.register(makeSource("b", items));
+    await agg.poll();
+
+    const firehose = agg.getFirehose(undefined, 10);
+    expect(firehose[0]!.url).toBe("https://b.com/2");
+    expect(firehose[1]!.url).toBe("https://b.com/3");
+    expect(firehose[2]!.url).toBe("https://b.com/1");
+  });
+
+  it("getFirehose filters to items after `since`", async () => {
+    const now = Date.now();
+    const cutoff = new Date(now - 2000);
+    const items = [
+      makeItem({ url: "https://c.com/old", publishedAt: new Date(now - 5000) }),
+      makeItem({ url: "https://c.com/new", publishedAt: new Date(now - 1000) }),
+    ];
+    agg.register(makeSource("c", items));
+    await agg.poll();
+
+    const firehose = agg.getFirehose(cutoff, 10);
+    expect(firehose).toHaveLength(1);
+    expect(firehose[0]!.url).toBe("https://c.com/new");
+  });
+
+  it("getBySector filters to items containing the sector in categories", async () => {
+    const items = [
+      makeItem({ url: "https://d.com/1", categories: ["tech", "earnings"] }),
+      makeItem({ url: "https://d.com/2", categories: ["energy"] }),
+      makeItem({ url: "https://d.com/3", categories: ["tech"] }),
+    ];
+    agg.register(makeSource("d", items));
+    await agg.poll();
+
+    const tech = agg.getBySector("tech", 10);
+    expect(tech).toHaveLength(2);
+    expect(tech.every((i) => i.categories.includes("tech"))).toBe(true);
+  });
+
+  it("getBreaking returns items that are isBreaking=true", async () => {
+    const items = [
+      makeItem({ url: "https://e.com/1", isBreaking: true }),
+      makeItem({ url: "https://e.com/2", isBreaking: false }),
+    ];
+    agg.register(makeSource("e", items));
+    await agg.poll();
+
+    const breaking = agg.getBreaking(10);
+    expect(breaking.some((i) => i.url === "https://e.com/1")).toBe(true);
+    expect(breaking.every((i) => i.url !== "https://e.com/2")).toBe(true);
+  });
+
+  it("getBreaking returns recent items with importance >= 70", async () => {
+    const now = Date.now();
+    const items = [
+      makeItem({ url: "https://f.com/recent-high", publishedAt: new Date(now - 30 * 60 * 1000), importance: 75, isBreaking: false }),
+      makeItem({ url: "https://f.com/recent-low", publishedAt: new Date(now - 30 * 60 * 1000), importance: 50, isBreaking: false }),
+      makeItem({ url: "https://f.com/old-high", publishedAt: new Date(now - 2 * 60 * 60 * 1000), importance: 90, isBreaking: false }),
+    ];
+    agg.register(makeSource("f", items));
+    await agg.poll();
+
+    const breaking = agg.getBreaking(10);
+    expect(breaking.some((i) => i.url === "https://f.com/recent-high")).toBe(true);
+    expect(breaking.every((i) => i.url !== "https://f.com/recent-low")).toBe(true);
+    expect(breaking.every((i) => i.url !== "https://f.com/old-high")).toBe(true);
+  });
+
+  it("retains at most 500 articles", async () => {
+    const items = Array.from({ length: 600 }, (_, i) =>
+      makeItem({
+        url: `https://g.com/${i}`,
+        publishedAt: new Date(Date.now() - i * 1000),
+      }),
+    );
+    agg.register(makeSource("g", items));
+    await agg.poll();
+
+    expect(agg.getFirehose(undefined, 1000)).toHaveLength(500);
+  });
+
+  it("subscribe callback fires on poll and getVersion increments", async () => {
+    let callCount = 0;
+    const unsub = agg.subscribe(() => { callCount++; });
+
+    const initialVersion = agg.getVersion();
+    agg.register(makeSource("h", []));
+    await agg.poll();
+
+    expect(callCount).toBe(1);
+    expect(agg.getVersion()).toBe(initialVersion + 1);
+
+    await agg.poll();
+    expect(callCount).toBe(2);
+    expect(agg.getVersion()).toBe(initialVersion + 2);
+
+    unsub();
+    await agg.poll();
+    expect(callCount).toBe(2); // unsubscribed, no more calls
+  });
+
+  it("watchQuery refreshes a query without a mounted pane", async () => {
+    const item = makeItem({ url: "https://watch.example.com/1", isBreaking: true });
+    const states: string[][] = [];
+
+    agg.register(makeSource("watch", [item]));
+    const dispose = agg.watchQuery(
+      { feed: "breaking", breaking: true, limit: 20 },
+      (state) => states.push(state.articles.map((article) => article.url)),
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(states).toContainEqual([item.url]);
+
+    const callCount = states.length;
+    dispose();
+    await agg.poll({ feed: "breaking", breaking: true, limit: 20 });
+    expect(states).toHaveLength(callCount);
+  });
+
+  it("seeds cached source items immediately on register", () => {
+    const cached = makeItem({ url: "https://cached.example.com/1", importance: 70 });
+    let callCount = 0;
+    agg.subscribe(() => { callCount++; });
+
+    const dispose = agg.register(makeCachedSource("cached", [cached]));
+
+    expect(agg.getFirehose(undefined, 10)).toHaveLength(1);
+    expect(agg.getFirehose(undefined, 10)[0]!.url).toBe(cached.url);
+    expect(callCount).toBe(1);
+
+    dispose();
+  });
+
+  it("register disposer removes the source", async () => {
+    const item = makeItem({ url: "https://dispose.example.com/1" });
+    const dispose = agg.register(makeSource("disposable", [item]));
+    dispose();
+
+    await agg.poll();
+
+    expect(agg.getFirehose(undefined, 10)).toHaveLength(0);
+  });
+
+  it("ticker queries continue past empty high-priority sources", async () => {
+    const empty = makeSource("empty", []);
+    const fallbackItem = makeItem({ url: "https://fallback.example.com/1", tickers: ["AAPL"] });
+    const fallback = makeSource("fallback", [fallbackItem]);
+    agg.register({
+      ...empty,
+      priority: 10,
+      provider: {
+        ...empty.provider,
+        supports: (query) => query.feed === "ticker" || query.scope === "ticker",
+      },
+    });
+    agg.register({
+      ...fallback,
+      priority: 100,
+      provider: {
+        ...fallback.provider,
+        supports: (query) => query.feed === "ticker" || query.scope === "ticker",
+      },
+    });
+
+    const state = await agg.load({ feed: "ticker", ticker: "AAPL", limit: 10 });
+
+    expect(state.articles).toHaveLength(1);
+    expect(state.articles[0]!.url).toBe(fallbackItem.url);
+    expect(state.sourceIds).toEqual(["fallback"]);
+  });
+});