gloomberb 0.9.7 → 0.9.8

package/src/sources/provider-router/financial-routes.ts

@@ -81,7 +81,9 @@ export class ProviderRouterFinancialRoutes {
       quarterlyStatements: base?.quarterlyStatements ?? [],
       priceHistory: base?.priceHistory ?? [],
     });
-    const cached = this.readCachedMergedFinancialsSelection(ticker, exchange, context, false);
+    const cached = this.readCachedMergedFinancialsSelection(ticker, exchange, context, false, {
+      includeSymbolProviderFallback: true,
+    });
     const forceRefresh = context?.cacheMode === "refresh";
     if (cached.value && !forceRefresh) {
       if (isOptionTicker && !cached.value.quote) {
@@ -128,8 +130,9 @@ export class ProviderRouterFinancialRoutes {
   async getQuote(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<Quote> {
     const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
     const variantKeys = this.deps.getTickerVariantCandidates(exchange);
+    const brokerSourceKeys = this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate));
     const sourceKeys = [
-      ...this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate)),
+      ...brokerSourceKeys,
       ...this.deps.getProviderSourceKeys(),
     ];
     const rawCached = selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, false);
@@ -138,12 +141,19 @@ export class ProviderRouterFinancialRoutes {
       : null;
     const forceRefresh = context?.cacheMode === "refresh";
     if (cached && !forceRefresh && !cached.stale) {
-      return cached.value;
+      if (!brokerSourceKeys.includes(cached.sourceKey)) return cached.value;
+      return this.mergeBrokerQuoteWithProviderReference(
+        cached.value,
+        await this.getProviderReferenceQuote(ticker, exchange, context),
+      );
     }
 
     const brokerQuote = await withBrokerTimeout(this.deps.primaryRoutes.fetchBrokerQuote(ticker, exchange, context));
     if (brokerQuote && !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(brokerQuote.value, exchange))) {
-      return brokerQuote.value;
+      return this.mergeBrokerQuoteWithProviderReference(
+        brokerQuote.value,
+        await this.getProviderReferenceQuote(ticker, exchange, context),
+      );
     }
 
     const providerQuote = await this.deps.primaryRoutes.fetchProviderQuote(ticker, exchange, context);
@@ -154,6 +164,45 @@ export class ProviderRouterFinancialRoutes {
     throw new Error(`No quote provider available for ${ticker}`);
   }
 
+  private async getProviderReferenceQuote(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+  ): Promise<Quote | null> {
+    const cached = this.readCachedProviderQuote(ticker, exchange, context);
+    if (cached) return cached;
+    const providerQuote = await this.deps.primaryRoutes.fetchProviderQuote(ticker, exchange, context);
+    return providerQuote?.value ?? null;
+  }
+
+  private readCachedProviderQuote(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+  ): Quote | null {
+    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
+    const entityKeys = [...new Set([entityKey, normalizeTicker(ticker)])];
+    const variantKeys = this.deps.getTickerVariantCandidates(exchange);
+    const sourceKeys = this.deps.getProviderSourceKeys();
+    for (const candidateEntityKey of entityKeys) {
+      const record = selectCachedResource<Quote>(this.deps.resources, "quote", candidateEntityKey, variantKeys, sourceKeys, false);
+      if (record && !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(record.value, exchange))) {
+        return record.value;
+      }
+    }
+    return null;
+  }
+
+  private mergeBrokerQuoteWithProviderReference(brokerQuote: Quote, providerQuote: Quote | null): Quote {
+    if (!providerQuote) return brokerQuote;
+    return resolveTickerFinancialsQuoteState({
+      quote: providerQuote,
+      annualStatements: [],
+      quarterlyStatements: [],
+      priceHistory: [],
+    }, brokerQuote)?.quote ?? brokerQuote;
+  }
+
   readCachedMergedFinancialsSelection(
     ticker: string,
     exchange?: string,
@@ -171,7 +220,8 @@ export class ProviderRouterFinancialRoutes {
       ? { ...brokerRecord, value: sanitizeCachedFinancials(brokerRecord.value, options) }
       : null;
     const providerSourceKeys = this.deps.getProviderSourceKeys();
-    const providerEntityKeys = options.includeSymbolProviderFallback
+    const includeSymbolProviderFallback = options.includeSymbolProviderFallback !== false;
+    const providerEntityKeys = includeSymbolProviderFallback
       ? [...new Set([entityKey, normalizeTicker(ticker)])]
       : [entityKey];
     const providerRecords = sortCachedRecords(

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

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import {
+  dropUnusableProviderQuote,
+  isProviderQuoteUsableForCurrentSession,
+} from "./financials";
+import { makeFinancials, makeQuote } from "./test-support";
+
+describe("provider-router financial quote usability", () => {
+  test("rejects active-session labels without active-session prices", () => {
+    expect(isProviderQuoteUsableForCurrentSession(makeQuote({
+      listingExchangeName: "NASDAQ",
+      marketState: "PRE",
+      lastUpdated: Date.now(),
+    }), "NASDAQ")).toBe(false);
+  });
+
+  test("rejects old active-session provider quotes", () => {
+    expect(isProviderQuoteUsableForCurrentSession(makeQuote({
+      listingExchangeName: "FWB2",
+      marketState: "REGULAR",
+      lastUpdated: Date.now() - 20 * 60_000,
+    }), "FWB2")).toBe(false);
+  });
+
+  test("rejects empty zero provider quotes", () => {
+    expect(isProviderQuoteUsableForCurrentSession(makeQuote({
+      price: 0,
+      change: 0,
+      changePercent: 0,
+      listingExchangeName: "SFB",
+      lastUpdated: Date.now(),
+    }), "SFB")).toBe(false);
+  });
+
+  test("strips unusable quotes while preserving non-quote financials", () => {
+    const value = dropUnusableProviderQuote(makeFinancials({
+      profile: { sector: "Industrials" },
+      quote: makeQuote({
+        price: 0,
+        change: 0,
+        changePercent: 0,
+        listingExchangeName: "SFB",
+      }),
+    }), "SFB");
+
+    expect(value.profile?.sector).toBe("Industrials");
+    expect(value.quote).toBeUndefined();
+  });
+});

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

@@ -77,6 +77,46 @@ export function quoteWithFreshnessExchange(quote: Quote, exchange?: string): Quo
   };
 }
 
+function finitePositiveNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+const ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS = 10 * 60_000;
+const ACTIVE_QUOTE_MARKET_STATES = new Set(["PRE", "REGULAR", "POST"]);
+
+function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
+  if (!ACTIVE_QUOTE_MARKET_STATES.has(quote.marketState ?? "")) return false;
+  if (!Number.isFinite(quote.lastUpdated)) return false;
+  return now - quote.lastUpdated > ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS;
+}
+
+export function isProviderQuoteUsableForCurrentSession(quote: Quote | null | undefined, exchange?: string): quote is Quote {
+  if (!quote) return false;
+  const normalized = quoteWithFreshnessExchange(quote, exchange);
+  if (isQuoteStaleForCurrentSession(normalized)) return false;
+  if (isActiveProviderQuoteTooOld(normalized)) return false;
+  return [
+    normalized.price,
+    normalized.preMarketPrice,
+    normalized.postMarketPrice,
+    normalized.bid,
+    normalized.ask,
+    normalized.mark,
+  ].some(finitePositiveNumber);
+}
+
+export function dropUnusableProviderQuote(value: TickerFinancials, exchange?: string): TickerFinancials {
+  if (!value.quote || isProviderQuoteUsableForCurrentSession(value.quote, exchange)) {
+    return value;
+  }
+
+  return {
+    ...value,
+    quote: undefined,
+    quoteContributions: undefined,
+  };
+}
+
 function sanitizeCachedQuote(
   quote: Quote,
   exchange: string | undefined,
@@ -216,13 +256,10 @@ export function mergeCachedFinancialRecords(
   value: TickerFinancials | null;
   stale: boolean;
 } {
-  const seenSources = new Set<string>();
   let merged: TickerFinancials | null = null;
   let stale = false;
 
   for (const record of records) {
-    if (seenSources.has(record.sourceKey)) continue;
-    seenSources.add(record.sourceKey);
     merged = mergeFinancials(merged, sanitizeCachedFinancials(record.value, options));
     stale = stale || record.stale === true;
   }

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

@@ -312,6 +312,61 @@ describe("AssetDataRouter", () => {
     expect(quote.price).toBe(123.45);
   });
 
+  test("reconciles broker quote price with provider day reference fields", async () => {
+    const router = new AssetDataRouter({
+      ...fallbackProvider,
+      id: "yahoo",
+      async getQuote() {
+        return {
+          symbol: "VICR",
+          providerId: "yahoo",
+          price: 299.74,
+          currency: "USD",
+          previousClose: 282.95,
+          change: 16.79,
+          changePercent: 5.93,
+          lastUpdated: Date.now(),
+        };
+      },
+    });
+    const broker: BrokerAdapter = {
+      id: "ibkr",
+      name: "IBKR",
+      configSchema: [],
+      async validate() {
+        return true;
+      },
+      async importPositions() {
+        return [];
+      },
+      async getQuote() {
+        return {
+          symbol: "VICR",
+          providerId: "ibkr",
+          price: 299.8,
+          currency: "USD",
+          previousClose: 380.1,
+          change: -80.3,
+          changePercent: -21.12,
+          lastUpdated: Date.now(),
+          dataSource: "live",
+        };
+      },
+    };
+
+    attachTestRegistry(router, { brokers: [["ibkr", broker]] });
+    setBrokerInstances(router, [brokerInstance()]);
+
+    const quote = await router.getQuote("VICR", "NASDAQ", { brokerId: "ibkr", brokerInstanceId: "ibkr-work" });
+    expect(quote.providerId).toBe("ibkr");
+    expect(quote.price).toBe(299.8);
+    expect(quote.previousClose).toBe(282.95);
+    expect(quote.change).toBeCloseTo(16.85, 5);
+    expect(quote.changePercent).toBeCloseTo(5.955, 3);
+    expect(quote.provenance?.price?.providerId).toBe("ibkr");
+    expect(quote.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
+  });
+
   test("prefers broker options chains for broker-context targets", async () => {
     const chain = {
       underlyingSymbol: "AAPL",
@@ -820,6 +875,48 @@ describe("AssetDataRouter", () => {
     unsubscribe();
   });
 
+  test("drops empty zero provider stream quotes", () => {
+    const providerTargets: QuoteSubscriptionTarget[] = [];
+    const seenQuotes: Array<{ symbol: string; price: number }> = [];
+    const streamingProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      subscribeQuotes(targets, onQuote) {
+        providerTargets.push(...targets);
+        onQuote(targets[0]!, {
+          symbol: "HEXA B",
+          price: 0,
+          currency: "SEK",
+          change: 0,
+          changePercent: 0,
+          lastUpdated: Date.now(),
+          listingExchangeName: "SFB",
+          dataSource: "delayed",
+        });
+        return () => {};
+      },
+    };
+
+    const router = new AssetDataRouter(fallbackProvider, [streamingProvider]);
+    const unsubscribe = router.subscribeQuotes([{
+      symbol: "HEXA B",
+      exchange: "SFB",
+      route: "provider",
+    }], (_target, quote) => {
+      seenQuotes.push({ symbol: quote.symbol, price: quote.price });
+    });
+
+    expect(providerTargets).toEqual([{
+      symbol: "HEXA B",
+      exchange: "SFB",
+      route: "provider",
+    }]);
+    expect(seenQuotes).toEqual([]);
+
+    unsubscribe();
+  });
+
   test("returns quote-only financials for option tickers when snapshots are unavailable", async () => {
     const router = new AssetDataRouter({
       ...fallbackProvider,
@@ -1308,6 +1405,56 @@ describe("AssetDataRouter", () => {
     expect(yahooCalls).toBe(1);
   });
 
+  test("fills unusable preferred provider financial quotes from a later provider", async () => {
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async getTickerFinancials() {
+        return makeFinancials({
+          profile: { sector: "Industrials" },
+          quote: makeQuote({
+            symbol: "HY9H",
+            price: 1295,
+            change: -95,
+            changePercent: -6.83,
+            lastUpdated: Date.now() - 20 * 60_000,
+            listingExchangeName: "FWB2",
+            marketState: "REGULAR",
+          }),
+        });
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getTickerFinancials() {
+        return makeFinancials({
+          quote: makeQuote({
+            symbol: "HY9H.F",
+            price: 1305,
+            change: -85,
+            changePercent: -6.12,
+            lastUpdated: Date.now(),
+            listingExchangeName: "FWB2",
+            marketState: "REGULAR",
+          }),
+        });
+      },
+    };
+
+    const router = new AssetDataRouter(yahooProvider, [cloudProvider]);
+    const merged = await router.getTickerFinancials("HY9H", "FWB2", { cacheMode: "refresh" });
+
+    expect(merged.profile?.sector).toBe("Industrials");
+    expect(merged.quote?.symbol).toBe("HY9H.F");
+    expect(merged.quote?.price).toBe(1305);
+    expect(merged.quote?.changePercent).toBe(-6.12);
+  });
+
   test("caches the preferred provider financial snapshot without merging fallback snapshots", async () => {
     const dbPath = createTempDbPath("cached-provider-financial-preferred");
     const persistence = new AppPersistence(dbPath);

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

@@ -1,14 +1,16 @@
 import type { MarketDataRequestContext } from "../../types/data-provider";
 import type { Quote, TickerFinancials } from "../../types/financials";
 import { normalizeTickerFinancialsPriceHistory } from "../../utils/price-history";
-import { isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshness";
 import { resolveTickerFinancialsQuoteState } from "../../market-data/quotes/resolution";
 import { shouldLogProviderError } from "../provider-errors";
 import {
+  dropUnusableProviderQuote,
   hasDetailedStatementRows,
   hasDeepStatementHistory,
   hasStatementRows,
+  isProviderQuoteUsableForCurrentSession,
   mergeMissingStatementArrays,
+  mergeFinancials,
 } from "./financials";
 import type { ProviderRouterCoreDeps, SourceResult } from "./route-types";
 
@@ -61,7 +63,8 @@ export class ProviderRouterPrimaryRoutes {
     for (const provider of this.options.providersInPriorityOrder()) {
       try {
         const rawValue = await provider.getTickerFinancials(ticker, exchange, context);
-        const value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(rawValue));
+        const resolvedValue = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(rawValue));
+        const value = resolvedValue ? dropUnusableProviderQuote(resolvedValue, exchange) : null;
         if (!value) continue;
         const sourceKey = this.options.providerSourceKey(provider);
         const cacheValue = primaryResult
@@ -84,6 +87,17 @@ export class ProviderRouterPrimaryRoutes {
           if (hasDetailedStatementRows(value) && hasDeepStatementHistory(value)) return primaryResult;
           continue;
         }
+        if (!primaryResult.value.quote && value.quote) {
+          primaryResult = {
+            sourceKey: primaryResult.sourceKey,
+            value: mergeFinancials(primaryResult.value, {
+              annualStatements: [],
+              quarterlyStatements: [],
+              priceHistory: [],
+              quote: value.quote,
+            }) ?? primaryResult.value,
+          };
+        }
         if (hasStatementRows(value)) {
           primaryResult = {
             sourceKey: primaryResult.sourceKey,
@@ -143,7 +157,7 @@ export class ProviderRouterPrimaryRoutes {
     for (const provider of this.options.providersInPriorityOrder()) {
       try {
         const quote = await provider.getQuote(ticker, exchange, context);
-        if (quote == null || isQuoteStaleForCurrentSession(quote)) continue;
+        if (!isProviderQuoteUsableForCurrentSession(quote, exchange)) continue;
         const sourceKey = this.options.providerSourceKey(provider);
         this.options.cacheResource(
           "quote",

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

@@ -1,6 +1,7 @@
 import type { DataProvider, MarketDataRequestContext, QuoteSubscriptionTarget } from "../../types/data-provider";
 import type { Quote } from "../../types/financials";
 import type { BrokerCandidate } from "./brokers";
+import { isProviderQuoteUsableForCurrentSession } from "./financials";
 
 export interface ProviderRouterStreamingDeps {
   providersInPriorityOrder(): DataProvider[];
@@ -67,7 +68,11 @@ export class ProviderRouterStreamingRoutes {
         providerId: streamingProvider.id,
         targetCount: providerTargets.length,
       });
-      unsubscribers.push(streamingProvider.subscribeQuotes(providerTargets, onQuote));
+      unsubscribers.push(streamingProvider.subscribeQuotes(providerTargets, (target, quote) => {
+        if (isProviderQuoteUsableForCurrentSession(quote, target.exchange)) {
+          onQuote(target, quote);
+        }
+      }));
     }
 
     if (unsubscribers.length === 0) {

package/src/sources/sec-edgar.test.ts

@@ -200,6 +200,47 @@ describe("parseCompanyFactsFinancialStatements", () => {
       },
     ]);
   });
+
+  test("merges statement values from all configured tags for a field", () => {
+    const fact = (tag: string, unit: string, rows: unknown[]) => ({
+      [tag]: {
+        units: {
+          [unit]: rows,
+        },
+      },
+    });
+    const quarterly = (end: string, val: number, frame: string) => ({
+      start: `${end.slice(0, 4)}-01-01`,
+      end,
+      val,
+      filed: end,
+      form: "10-Q",
+      fp: "Q1",
+      frame,
+    });
+
+    const statements = parseCompanyFactsFinancialStatements({
+      facts: {
+        "us-gaap": {
+          ...fact("RevenueFromContractWithCustomerExcludingAssessedTax", "USD", [
+            quarterly("2026-03-31", 200, "CY2026Q1"),
+          ]),
+          ...fact("Revenues", "USD", [
+            quarterly("2025-03-31", 100, "CY2025Q1"),
+          ]),
+          ...fact("GrossProfit", "USD", [
+            quarterly("2025-03-31", 60, "CY2025Q1"),
+            quarterly("2026-03-31", 120, "CY2026Q1"),
+          ]),
+        },
+      },
+    });
+
+    expect(statements.quarterlyStatements).toEqual([
+      { date: "2025-03-31", totalRevenue: 100, grossProfit: 60 },
+      { date: "2026-03-31", totalRevenue: 200, grossProfit: 120 },
+    ]);
+  });
 });
 
 describe("SecEdgarClient", () => {
@@ -403,6 +444,7 @@ describe("SecEdgarClient", () => {
 
     const client = new SecEdgarClient();
     const content = await client.getFilingContent({
+      form: "10-Q",
       filingUrl: "https://www.sec.gov/Archives/edgar/data/320193/index.htm",
       primaryDocumentUrl: "https://www.sec.gov/Archives/edgar/data/320193/primary-doc.htm",
     });

package/src/sources/sec-edgar.ts

@@ -451,7 +451,7 @@ function setCompanyFactValue(
   const selectionKey = `${date}:${String(field)}`;
   if (compareCompanyFactsEntries(entry, selectedFacts.get(selectionKey)) < 0) return;
   const row = rows.get(date) ?? { date };
-  (row as Record<string, unknown>)[field] = value;
+  (row as unknown as Record<string, unknown>)[field] = value;
   rows.set(date, row);
   selectedFacts.set(selectionKey, entry);
 }
@@ -506,7 +506,6 @@ export function parseCompanyFactsFinancialStatements(payload: unknown): SecCompa
       if (entries.length === 0) continue;
       fillCompanyFactsStatementRows(annualRows, annualSelectedFacts, entries, field, "annual");
       fillCompanyFactsStatementRows(quarterlyRows, quarterlySelectedFacts, entries, field, "quarterly");
-      break;
     }
   }
 

package/src/sources/yahoo-finance/mappers.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { extractExtendedHoursPrices } from "./mappers";
+import type { ChartResult } from "./types";
+
+describe("Yahoo mappers", () => {
+  test("derives premarket change from the prior regular close", () => {
+    const meta: NonNullable<ChartResult["meta"]> = {
+      regularMarketPrice: 39.47,
+      chartPreviousClose: 29,
+      currentTradingPeriod: {
+        pre: { start: 100, end: 200 },
+        regular: { start: 300, end: 400 },
+        post: { start: 500, end: 600 },
+      },
+    };
+
+    const result = extractExtendedHoursPrices(
+      meta,
+      [100, 200],
+      [39, 39.47],
+      "PRE",
+      38,
+    );
+
+    expect(result.preMarketPrice).toBe(39.47);
+    expect(result.preMarketChange).toBeCloseTo(1.47, 8);
+    expect(result.preMarketChangePercent).toBeCloseTo(3.8684210526, 8);
+  });
+});

package/src/sources/yahoo-finance/mappers.ts

@@ -286,13 +286,14 @@ export function extractExtendedHoursPrices(
   timestamps: number[],
   closes: (number | null)[],
   marketState: MarketState,
+  regularCloseOverride?: number,
 ): ExtendedHoursData {
   const ctp = meta.currentTradingPeriod;
   if (!ctp || !timestamps.length) return {};
 
   const regStart = ctp.regular?.start ?? 0;
   const regEnd = ctp.regular?.end ?? Infinity;
-  const regularClose = meta.regularMarketPrice ?? meta.chartPreviousClose;
+  const regularClose = regularCloseOverride ?? meta.regularMarketPrice ?? meta.chartPreviousClose;
 
   if (marketState === "PRE") {
     for (let i = timestamps.length - 1; i >= 0; i--) {

package/src/sources/yahoo-finance/requests.ts

@@ -65,6 +65,7 @@ export async function fetchYahooExtendedHoursData(
   http: YahooHttpClient,
   symbol: string,
   meta: NonNullable<ChartResult["meta"]>,
+  regularClose?: number,
 ): Promise<ExtendedHoursData> {
   const marketState = deriveMarketState(meta);
   if (marketState !== "PRE" && marketState !== "POST") return {};
@@ -80,7 +81,7 @@ export async function fetchYahooExtendedHoursData(
     const result = data.chart?.result?.[0];
     if (!result?.timestamp?.length) return {};
     const closes = result.indicators?.quote?.[0]?.close || [];
-    return extractExtendedHoursPrices(meta, result.timestamp, closes, marketState);
+    return extractExtendedHoursPrices(meta, result.timestamp, closes, marketState, regularClose);
   } catch {
     return {};
   }

package/src/sources/yahoo-finance/snapshots.ts

@@ -42,6 +42,7 @@ interface YahooSnapshotLoaders {
   fetchExtendedHoursData: (
     symbol: string,
     meta: NonNullable<ChartResult["meta"]>,
+    regularClose?: number,
   ) => Promise<ExtendedHoursData>;
   fetchQuoteSupplement: (
     symbol: string,
@@ -132,7 +133,12 @@ export async function loadYahooTickerFinancials(
   const changePct = prev ? (change / prev) * 100 : 0;
 
   const marketState = deriveMarketState(meta);
-  const extHours = await loaders.fetchExtendedHoursData(symbol, meta);
+  const extendedHoursBase = quoteSupplement.previousClose ?? prev;
+  const extHours = await loaders.fetchExtendedHoursData(
+    symbol,
+    meta,
+    extendedHoursBase == null ? undefined : extendedHoursBase * currencyDivisor,
+  );
   if (currencyDivisor !== 1) {
     normalizeExtendedHoursPrices(extHours, currencyDivisor);
   }
@@ -207,7 +213,12 @@ export async function loadYahooQuote(
   const change = prev != null ? price - prev : 0;
 
   const marketState = deriveMarketState(meta);
-  const extHours = await loaders.fetchExtendedHoursData(symbol, meta);
+  const extendedHoursBase = quoteSupplement.previousClose ?? prev;
+  const extHours = await loaders.fetchExtendedHoursData(
+    symbol,
+    meta,
+    extendedHoursBase == null ? undefined : extendedHoursBase * currencyDivisor,
+  );
   if (currencyDivisor !== 1) {
     normalizeExtendedHoursPrices(extHours, currencyDivisor);
   }

package/src/sources/yahoo-finance.ts

@@ -103,8 +103,12 @@ export class YahooFinanceClient implements DataProvider {
   }
 
   /** Fetch extended hours data using 1d intraday chart with pre/post market included */
-  private async fetchExtendedHoursData(symbol: string, meta: NonNullable<ChartResult["meta"]>) {
-    return fetchYahooExtendedHoursData(this.http, symbol, meta);
+  private async fetchExtendedHoursData(
+    symbol: string,
+    meta: NonNullable<ChartResult["meta"]>,
+    regularClose?: number,
+  ) {
+    return fetchYahooExtendedHoursData(this.http, symbol, meta, regularClose);
   }
 
   private async fetchTimeseries(symbol: string, types: string[], period1 = "2010-01-01") {

package/src/state/hooks/quote-streaming.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, test } from "bun:test";
-import { buildQuoteStreamSubscriptionKey } from "./quote-streaming";
+import {
+  buildQuoteStreamSubscriptionKey,
+  normalizeQuoteStreamSubscriptionTarget,
+} from "./quote-streaming";
 
 describe("buildQuoteStreamSubscriptionKey", () => {
   test("includes broker context so identical symbols can stream independently", () => {
@@ -28,4 +31,14 @@ describe("buildQuoteStreamSubscriptionKey", () => {
     expect(workKey).not.toBe(personalKey);
   });
 
+  test("keeps saved exchange aliases in stream targets", () => {
+    const target = normalizeQuoteStreamSubscriptionTarget({
+      symbol: "lpk",
+      exchange: "ibis",
+    });
+
+    expect(target?.symbol).toBe("LPK");
+    expect(target?.exchange).toBe("IBIS");
+    expect(buildQuoteStreamSubscriptionKey(target!)).toContain("LPK|IBIS");
+  });
 });