gloomberb 0.7.0 → 0.7.2

package/src/renderers/electrobun/view/ui-host.tsx

@@ -886,13 +886,29 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
     );
     const horizontalScrollBarVisibleRef = useRef(horizontalScrollBarVisible);
     const verticalScrollBarVisibleRef = useRef(verticalScrollBarVisible);
+    const horizontalScrollChangeHandlersRef = useRef(new Set<() => void>());
+    const verticalScrollChangeHandlersRef = useRef(new Set<() => void>());
     const scrollFrameRef = useRef<number | null>(null);
     const lastWheelAtRef = useRef(0);
     const [scrollbarActive, markScrollbarActive] = useScrollbarActivity();
 
-    const getElement = () => elementRef.current;
+    const getElement = useCallback(() => elementRef.current, []);
     const toCellY = (pixels: number) => Math.max(0, Math.round(pixels / WEB_CELL_HEIGHT));
     const toCellX = (pixels: number) => Math.max(0, Math.round(pixels / WEB_CELL_WIDTH));
+    const emitHorizontalScrollChange = useCallback(() => {
+      for (const handler of horizontalScrollChangeHandlersRef.current) {
+        handler();
+      }
+    }, []);
+    const emitVerticalScrollChange = useCallback(() => {
+      for (const handler of verticalScrollChangeHandlersRef.current) {
+        handler();
+      }
+    }, []);
+    const emitScrollPositionChanges = useCallback(() => {
+      emitVerticalScrollChange();
+      emitHorizontalScrollChange();
+    }, [emitHorizontalScrollChange, emitVerticalScrollChange]);
     const horizontalScrollBar = useMemo(() => ({
       get visible() {
         return horizontalScrollBarVisibleRef.current;
@@ -902,6 +918,12 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
         horizontalScrollBarVisibleRef.current = normalized;
         setHorizontalScrollBarVisible(normalized);
       },
+      on(event: "change", handler: () => void) {
+        if (event === "change") horizontalScrollChangeHandlersRef.current.add(handler);
+      },
+      off(event: "change", handler: () => void) {
+        if (event === "change") horizontalScrollChangeHandlersRef.current.delete(handler);
+      },
     }), []);
     const verticalScrollBar = useMemo(() => ({
       get visible() {
@@ -912,6 +934,12 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
         verticalScrollBarVisibleRef.current = normalized;
         setVerticalScrollBarVisible(normalized);
       },
+      on(event: "change", handler: () => void) {
+        if (event === "change") verticalScrollChangeHandlersRef.current.add(handler);
+      },
+      off(event: "change", handler: () => void) {
+        if (event === "change") verticalScrollChangeHandlersRef.current.delete(handler);
+      },
     }), []);
 
     useEffect(() => {
@@ -938,14 +966,40 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
       },
       set scrollTop(value: number) {
         const element = getElement();
-        if (element) element.scrollTop = Math.max(0, value) * WEB_CELL_HEIGHT;
+        if (element) {
+          element.scrollTop = Math.max(0, value) * WEB_CELL_HEIGHT;
+          emitVerticalScrollChange();
+        }
+      },
+      get scrollTopPx() {
+        return Math.max(0, getElement()?.scrollTop ?? 0);
+      },
+      set scrollTopPx(value: number) {
+        const element = getElement();
+        if (element) {
+          element.scrollTop = Math.max(0, value);
+          emitVerticalScrollChange();
+        }
       },
       get scrollLeft() {
         return toCellX(getElement()?.scrollLeft ?? 0);
       },
       set scrollLeft(value: number) {
         const element = getElement();
-        if (element) element.scrollLeft = Math.max(0, value) * WEB_CELL_WIDTH;
+        if (element) {
+          element.scrollLeft = Math.max(0, value) * WEB_CELL_WIDTH;
+          emitHorizontalScrollChange();
+        }
+      },
+      get scrollLeftPx() {
+        return Math.max(0, getElement()?.scrollLeft ?? 0);
+      },
+      set scrollLeftPx(value: number) {
+        const element = getElement();
+        if (element) {
+          element.scrollLeft = Math.max(0, value);
+          emitHorizontalScrollChange();
+        }
       },
       get scrollHeight() {
         return toCellY(getElement()?.scrollHeight ?? 0);
@@ -953,6 +1007,12 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
       get scrollWidth() {
         return toCellX(getElement()?.scrollWidth ?? 0);
       },
+      get scrollHeightPx() {
+        return Math.max(0, getElement()?.scrollHeight ?? 0);
+      },
+      get scrollWidthPx() {
+        return Math.max(0, getElement()?.scrollWidth ?? 0);
+      },
       get viewport() {
         const element = getElement();
         return {
@@ -960,6 +1020,13 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
           height: toCellY(element?.clientHeight ?? 0),
         };
       },
+      get viewportPx() {
+        const element = getElement();
+        return {
+          width: Math.max(0, element?.clientWidth ?? 0),
+          height: Math.max(0, element?.clientHeight ?? 0),
+        };
+      },
       getBoundingClientRect() {
         const rect = getElement()?.getBoundingClientRect();
         return {
@@ -976,8 +1043,10 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
         if (!element) return;
         if (typeof target === "number") {
           element.scrollTop = Math.max(0, target) * WEB_CELL_HEIGHT;
+          emitVerticalScrollChange();
           if (typeof y === "number") {
             element.scrollLeft = Math.max(0, y) * WEB_CELL_WIDTH;
+            emitHorizontalScrollChange();
           }
           return;
         }
@@ -985,13 +1054,40 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
           left: Math.max(0, target.x ?? toCellX(element.scrollLeft)) * WEB_CELL_WIDTH,
           top: Math.max(0, target.y ?? toCellY(element.scrollTop)) * WEB_CELL_HEIGHT,
         });
+        emitScrollPositionChanges();
+      },
+      scrollToPixels(target: number | { x?: number; y?: number }, y?: number) {
+        const element = getElement();
+        if (!element) return;
+        if (typeof target === "number") {
+          element.scrollTop = Math.max(0, target);
+          emitVerticalScrollChange();
+          if (typeof y === "number") {
+            element.scrollLeft = Math.max(0, y);
+            emitHorizontalScrollChange();
+          }
+          return;
+        }
+        element.scrollTo({
+          left: Math.max(0, target.x ?? element.scrollLeft),
+          top: Math.max(0, target.y ?? element.scrollTop),
+        });
+        emitScrollPositionChanges();
       },
-    }), [horizontalScrollBar, verticalScrollBar]);
+    }), [
+      emitHorizontalScrollChange,
+      emitScrollPositionChanges,
+      emitVerticalScrollChange,
+      getElement,
+      horizontalScrollBar,
+      verticalScrollBar,
+    ]);
 
     const scrollable = props.scrollX === true || props.scrollY === true;
     const overflowX = props.scrollX === true ? "auto" : "hidden";
     const overflowY = props.scrollY === true ? "auto" : "hidden";
     const handleScroll = useCallback(() => {
+      emitScrollPositionChanges();
       markScrollbarActive();
       if (typeof props.onMouseScroll !== "function") return;
       if (Date.now() - lastWheelAtRef.current < 32) return;
@@ -1000,7 +1096,7 @@ const WebScrollBox = forwardRef<ScrollBoxRenderable, Record<string, unknown> & {
         scrollFrameRef.current = null;
         (props.onMouseScroll as () => void)();
       });
-    }, [markScrollbarActive, props.onMouseScroll]);
+    }, [emitScrollPositionChanges, markScrollbarActive, props.onMouseScroll]);
     const handleWheel = useCallback((event: ReactWheelEvent<HTMLDivElement>) => {
       markScrollbarActive();
       lastWheelAtRef.current = Date.now();

package/src/renderers/opentui/input-host.tsx

@@ -15,7 +15,7 @@ export function OpenTuiInputHostProvider({ children }: { children: ReactNode })
   const shortcutsRef = useRef<ShortcutEntry[]>([]);
   const dispatchShortcut = (event: KeyEventLike) => {
     const shortcuts = shortcutsRef.current;
-    for (const phase of ["normal", "after"] as const) {
+    for (const phase of ["before", "normal", "after"] as const) {
       if (phase === "after" && (event.defaultPrevented || event.propagationStopped)) return;
       for (const entry of shortcuts) {
         if (entry.phase !== phase || !entry.enabledRef.current) continue;

package/src/sources/gloomberb-cloud.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { createGloomberbCloudCapabilities, GloomberbCloudProvider } from "./gloomberb-cloud";
 import type { NewsCapability } from "../capabilities";
-import { apiClient, type AuthUser } from "../utils/api-client";
+import { apiClient, type AuthUser, type CloudNewsPayload } from "../utils/api-client";
 
 const verifiedUser: AuthUser = {
   id: "user-1",
@@ -21,8 +21,56 @@ const originalGetCloudHolders = apiClient.getCloudHolders.bind(apiClient);
 const originalGetCloudAnalystResearch = apiClient.getCloudAnalystResearch.bind(apiClient);
 const originalGetCloudCorporateActions = apiClient.getCloudCorporateActions.bind(apiClient);
 const originalGetCloudNews = apiClient.getCloudNews.bind(apiClient);
+const originalGetCloudNewsStory = apiClient.getCloudNewsStory.bind(apiClient);
 const originalSubscribeQuotes = apiClient.subscribeQuotes.bind(apiClient);
 
+function makeCloudNewsPayload(overrides: Partial<CloudNewsPayload> = {}): CloudNewsPayload {
+  return {
+    id: "story-1",
+    headline: "Apple raises guidance",
+    summary: "Apple lifted its outlook after stronger iPhone demand.",
+    topic: "guidance",
+    topics: ["guidance"],
+    category: "guidance",
+    sentiment: "positive",
+    sectors: ["information_technology"],
+    firstPublishedAt: "2026-04-01T10:00:00.000Z",
+    lastPublishedAt: "2026-04-01T10:05:00.000Z",
+    firstSeenAt: "2026-04-01T10:00:10.000Z",
+    lastSeenAt: "2026-04-01T10:05:10.000Z",
+    primaryUrl: "https://example.com/aapl-guidance",
+    primarySource: "example-wire",
+    scores: {
+      importance: 91,
+      urgency: 74,
+      marketImpact: 88,
+      novelty: 86,
+      confidence: 95,
+    },
+    flags: {
+      breaking: true,
+      developing: false,
+      stale: false,
+    },
+    variantCount: 1,
+    sourceCount: 1,
+    sources: ["example-wire"],
+    entities: [],
+    tickerLinks: [{
+      symbol: "AAPL",
+      exchange: "XNAS",
+      canonicalTicker: "AAPL:XNAS",
+      relationType: "direct",
+      displayTier: "primary",
+      confidence: 0.98,
+      relevanceScore: 95,
+      impactScore: 93,
+      sentiment: "positive",
+    }],
+    ...overrides,
+  };
+}
+
 afterEach(() => {
   apiClient.ensureVerifiedSession = originalEnsureVerifiedSession;
   apiClient.getCloudHistory = originalGetCloudHistory;
@@ -31,6 +79,7 @@ afterEach(() => {
   apiClient.getCloudAnalystResearch = originalGetCloudAnalystResearch;
   apiClient.getCloudCorporateActions = originalGetCloudCorporateActions;
   apiClient.getCloudNews = originalGetCloudNews;
+  apiClient.getCloudNewsStory = originalGetCloudNewsStory;
   apiClient.subscribeQuotes = originalSubscribeQuotes;
 });
 
@@ -496,4 +545,40 @@ describe("GloomberbCloudProvider", () => {
       confidence: 93,
     });
   });
+
+  test("fetches story detail with ordered source items", async () => {
+    let requestedStoryId = "";
+    apiClient.getCloudNewsStory = async (storyId) => {
+      requestedStoryId = storyId;
+      return makeCloudNewsPayload({
+        id: storyId,
+        items: [{
+          id: "item-2",
+          sourceKey: "wire-b",
+          sourceName: "Wire B",
+          title: "Follow-up",
+          summary: "More details emerged.",
+          url: "https://example.com/follow-up",
+          publishedAt: "2026-04-01T10:05:00.000Z",
+          hasArticleText: true,
+        }, {
+          id: "item-1",
+          sourceKey: "wire-a",
+          sourceName: "Wire A",
+          title: "Original",
+          summary: "The first report.",
+          url: "https://example.com/original",
+          publishedAt: "2026-04-01T10:00:00.000Z",
+          hasArticleText: false,
+        }],
+      });
+    };
+
+    const source = createGloomberbCloudCapabilities().find((capability) => capability.kind === "news") as NewsCapability;
+    const story = await source.provider.fetchNewsStory?.("story-1");
+
+    expect(requestedStoryId).toBe("story-1");
+    expect(story?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
+    expect(story?.items?.[0]?.publishedAt).toEqual(new Date("2026-04-01T10:05:00.000Z"));
+  });
 });

package/src/sources/gloomberb-cloud.ts

@@ -5,15 +5,24 @@ import {
   type ManualChartResolution,
 } from "../components/chart/chart-resolution";
 import { assetDataProvider, newsProvider, type PluginCapability } from "../capabilities";
-import type { AssetDataProvider, MarketDataRequestContext, NewsItem, QuoteSubscriptionTarget, SearchRequestContext, SecFilingItem } from "../types/data-provider";
+import type {
+  AssetDataProvider,
+  CachedFinancialsTarget,
+  MarketDataRequestContext,
+  NewsItem,
+  QuoteBatchResult,
+  QuoteSubscriptionTarget,
+  SearchRequestContext,
+  SecFilingItem,
+  TickerFinancialsBatchResult,
+} from "../types/data-provider";
 import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
 import {
   apiClient,
   type CloudAnalystResearchPayload,
-  type CloudCompanyProfile,
   type CloudCorporateActionsPayload,
-  type CloudFundamentals,
+  type CloudMarketBatchItem,
   type CloudHoldersPayload,
   type CloudMarketResponse,
   type CloudNewsPayload,
@@ -103,6 +112,34 @@ function mapPricePoint(point: CloudPricePointPayload, divisor = 1): PricePoint {
   };
 }
 
+function mapCloudFinancials(financials: TickerFinancials): TickerFinancials {
+  const quote = financials.quote ? mapQuote(financials.quote as CloudQuotePayload) : undefined;
+  const divisor = quote ? resolveCurrencyUnit(quote.currency).divisor : 1;
+  return {
+    quote,
+    quoteContributions: financials.quoteContributions,
+    profile: financials.profile,
+    fundamentals: financials.fundamentals,
+    annualStatements: financials.annualStatements ?? [],
+    quarterlyStatements: financials.quarterlyStatements ?? [],
+    priceHistory: (financials.priceHistory ?? []).map((point) =>
+      point.date instanceof Date
+        ? point
+        : mapPricePoint(point as unknown as CloudPricePointPayload, divisor)
+    ),
+  };
+}
+
+function mapBatchError<T>(
+  item: CloudMarketBatchItem<T>,
+  fallbackMessage: string,
+): Error {
+  if (isEmptyCloudStatus(item.status)) {
+    return createProviderMiss(item.reasonCode ?? fallbackMessage);
+  }
+  return new Error(item.reasonCode ?? fallbackMessage);
+}
+
 function normalizeStringArray(value: unknown): string[] {
   return Array.isArray(value)
     ? value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
@@ -358,27 +395,45 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async getTickerFinancials(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<TickerFinancials> {
     await requireVerifiedSession();
     return withCloudFallback(async () => {
-      const [quoteResponse, profileResponse, fundamentalsResponse, statementsResponse] = await Promise.all([
-        apiClient.getCloudQuote(ticker, exchange),
-        apiClient.getCloudProfile(ticker, exchange),
-        apiClient.getCloudFundamentals(ticker, exchange),
-        apiClient.getCloudStatements(ticker, exchange, "both"),
-      ]);
-      const quote = mapQuote(unwrapRequiredCloudResponse(quoteResponse, `Cloud quote is unavailable for ${ticker}`));
-      const profile = unwrapOptionalCloudResponse(profileResponse) as CloudCompanyProfile | null;
-      const fundamentals = unwrapOptionalCloudResponse(fundamentalsResponse) as CloudFundamentals | null;
-      const statements = unwrapOptionalCloudResponse(statementsResponse);
-      return {
-        quote,
-        profile: profile ?? undefined,
-        fundamentals: fundamentals ?? undefined,
-        annualStatements: statements?.annualStatements ?? [],
-        quarterlyStatements: statements?.quarterlyStatements ?? [],
-        priceHistory: [],
-      };
+      const response = await apiClient.getCloudFinancials(ticker, exchange);
+      return mapCloudFinancials(unwrapRequiredCloudResponse(response, `Cloud financials are unavailable for ${ticker}`));
     }, `Cloud financials are unavailable for ${ticker}`);
   }
 
+  async getTickerFinancialsBatch(
+    targets: CachedFinancialsTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<TickerFinancialsBatchResult[]> {
+    await requireVerifiedSession();
+    return withCloudFallback(async () => {
+      const response = await apiClient.getCloudFinancialsBatch(
+        targets.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange,
+        })),
+        options.forceRefresh ? "refresh" : "cache-first",
+      );
+      const payload = unwrapRequiredCloudResponse(response, "Cloud financials are unavailable");
+      return payload.items.map((item, index) => {
+        const target = targets[index] ?? {
+          symbol: item.symbol,
+          exchange: item.exchange,
+        };
+        if ((item.status === "success" || item.status === "partial") && item.data) {
+          return {
+            target,
+            financials: mapCloudFinancials(item.data),
+          };
+        }
+        return {
+          target,
+          financials: null,
+          error: mapBatchError(item, `Cloud financials are unavailable for ${target.symbol}`),
+        };
+      });
+    }, "Cloud financials are unavailable");
+  }
+
   async getQuote(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<Quote> {
     await requireVerifiedSession();
     return withCloudFallback(
@@ -390,6 +445,40 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     );
   }
 
+  async getQuotesBatch(
+    targets: QuoteSubscriptionTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<QuoteBatchResult[]> {
+    await requireVerifiedSession();
+    return withCloudFallback(async () => {
+      const response = await apiClient.getCloudQuotesBatch(
+        targets.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange,
+        })),
+        options.forceRefresh ? "refresh" : "cache-first",
+      );
+      const payload = unwrapRequiredCloudResponse(response, "Cloud quotes are unavailable");
+      return payload.items.map((item, index) => {
+        const target = targets[index] ?? {
+          symbol: item.symbol,
+          exchange: item.exchange,
+        };
+        if ((item.status === "success" || item.status === "partial") && item.data) {
+          return {
+            target,
+            quote: mapQuote(item.data),
+          };
+        }
+        return {
+          target,
+          quote: null,
+          error: mapBatchError(item, `Cloud quotes are unavailable for ${target.symbol}`),
+        };
+      });
+    }, "Cloud quotes are unavailable");
+  }
+
   async getExchangeRate(fromCurrency: string): Promise<number> {
     await requireVerifiedSession();
     const response = await apiClient.getCloudExchangeRate(fromCurrency);
@@ -575,6 +664,13 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
           );
           return response.items.map((item) => mapCloudNewsArticle(item, query.ticker));
         },
+        async fetchNewsStory(storyId: string): Promise<NewsArticle | null> {
+          const story = await withCloudFallback(
+            () => apiClient.getCloudNewsStory(storyId),
+            "Cloud news story is unavailable",
+          );
+          return mapCloudNewsArticle(story);
+        },
       },
     }),
   ];

package/src/sources/provider-router.test.ts

@@ -195,6 +195,128 @@ describe("AssetDataRouter", () => {
     expect(holders.holders[0]?.name).toBe("Vanguard Group Inc");
   });
 
+  test("falls back to later analyst providers when rating targets are missing", async () => {
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "cloud",
+          symbol,
+          ratings: [{ date: "2026-05-01", firm: "Cloud Firm", action: "Raises", current: "Buy", prior: "Buy" }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "yahoo",
+          symbol,
+          ratings: [{
+            date: "2026-05-01",
+            firm: "Yahoo Firm",
+            action: "Raises",
+            current: "Buy",
+            prior: "Buy",
+            currentPriceTarget: 680,
+            priorPriceTarget: 595,
+          }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+
+    const router = new AssetDataRouter(yahooProvider, [cloudProvider]);
+    const research = await router.getAnalystResearch("AAPL", "NASDAQ");
+
+    expect(research.providerId).toBe("yahoo");
+    expect(research.ratings[0]?.currentPriceTarget).toBe(680);
+    expect(research.ratings[0]?.priorPriceTarget).toBe(595);
+  });
+
+  test("prefers cached analyst records with rating targets", async () => {
+    const dbPath = createTempDbPath("cached-analyst-targets");
+    const persistence = new AppPersistence(dbPath);
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "cloud",
+          symbol,
+          ratings: [{ date: "2026-05-01", firm: "Cloud Firm", action: "Raises", current: "Buy", prior: "Buy" }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getAnalystResearch(symbol) {
+        return {
+          providerId: "yahoo",
+          symbol,
+          ratings: [{
+            date: "2026-05-01",
+            firm: "Yahoo Firm",
+            action: "Raises",
+            current: "Buy",
+            prior: "Buy",
+            currentPriceTarget: 680,
+            priorPriceTarget: 595,
+          }],
+          recommendations: [],
+          earningsEstimates: [],
+          revenueEstimates: [],
+        };
+      },
+    };
+    const unavailableProvider = (id: string, priority: number): DataProvider => ({
+      ...fallbackProvider,
+      id,
+      name: id,
+      priority,
+      async getAnalystResearch() {
+        throw new Error(`${id} should not be fetched`);
+      },
+    });
+
+    try {
+      const seedRouter = new AssetDataRouter(yahooProvider, [cloudProvider], persistence.resources);
+      await seedRouter.getAnalystResearch("AAPL", "NASDAQ");
+
+      const cachedRouter = new AssetDataRouter(
+        unavailableProvider("yahoo", 1000),
+        [unavailableProvider("cloud", 100)],
+        persistence.resources,
+      );
+      const research = await cachedRouter.getAnalystResearch("AAPL", "NASDAQ");
+
+      expect(research.providerId).toBe("yahoo");
+      expect(research.ratings[0]?.currentPriceTarget).toBe(680);
+      expect(research.ratings[0]?.priorPriceTarget).toBe(595);
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("prefers broker quotes over fallback quotes", async () => {
     const router = new AssetDataRouter(fallbackProvider);
     const broker: BrokerAdapter = {