gloomberb 0.13.2 → 0.14.0

package/src/sources/provider-router/shell-history-cache.test.ts

@@ -0,0 +1,131 @@
+import { afterEach, expect, test } from "bun:test";
+import { AppPersistence } from "../../data/app-persistence";
+import type { BrokerAdapter } from "../../types/broker";
+import type { PricePoint } from "../../types/financials";
+import { AssetDataRouter } from "./index";
+import { cacheRouterResource } from "./cache";
+import { attachTestRegistry, brokerInstance, cleanupProviderRouterTestFiles, createTempDbPath, fallbackProvider, makeFinancials, makeQuote, setBrokerInstances } from "./test-support";
+
+afterEach(cleanupProviderRouterTestFiles);
+const policy = { staleMs: 60_000, expireMs: 600_000 };
+const bad = [{ date: new Date("1997-06-30"), close: 63.8935986328125 }, { date: new Date("2026-09-07"), close: 35.33 }];
+const good: PricePoint[] = [{ date: new Date("2005-07-25"), close: 17.47 }, { date: new Date("2026-09-07"), close: 35.33 }]
+  .map((point) => ({ ...point, historySource: { provider: "yahoo", symbol: "SHEL", exchange: "LSE", currency: "GBP", verifiedLineageStart: "2005-07-21" } }));
+const equal = (actual: unknown, expected: unknown) => expect(JSON.stringify(actual)).toBe(JSON.stringify(expected));
+
+test("saved Shell source caches recover across range, broader and detailed paths and a new router", async () => {
+  for (const [id, origin] of [["yahoo", "yahoo"], ["gloomberb-cloud", "yahoo"], ["gloomberb-cloud", "twelvedata"]] as const) for (const ticker of ["SHEL", "SHEL:XLON"]) {
+    const store = new AppPersistence(createTempDbPath("shell-lineage"));
+    // 242 cloud records included unrestricted Twelve provenance. They must not
+    // bypass the same recovery merely because a provider was already recorded.
+    const legacy = origin === "twelvedata" ? bad.map((point) => ({ ...point, historySource: {
+      provider: origin, symbol: "SHEL", exchange: "LSE", currency: "GBP",
+    } })) : bad;
+    const corrected = good.map((point) => ({ ...point, historySource: { ...point.historySource!, provider: origin } }));
+    try {
+      for (const [kind, variantKey] of [
+        ["price-history", "exchange=LSE;range=ALL;version=5;calendar=1;granularity=1;unit=GBP"],
+        ["price-history", "exchange=LSE;range=ALL;resolution=1wk;version=5;granularity=1;unit=GBP"],
+        ["price-history", "range=ALL;resolution=1wk;version=5;granularity=1;unit=GBP"],
+        ["detailed-price-history", "exchange=LSE;start=1996-01-01;end=2026-09-10;bar=1wk;version=5;unit=GBP"],
+      ]) store.resources.set({ namespace: "market", kind: kind!, entityKey: ticker, variantKey, sourceKey: `provider:${id}` }, legacy, { cachePolicy: policy });
+      let calls = 0;
+      const load = async () => { calls++; return corrected; };
+      const provider = { ...fallbackProvider, id, getPriceHistory: load, getPriceHistoryForResolution: load, getDetailedPriceHistory: load };
+      const read = async (router: AssetDataRouter) => {
+        equal(await router.getPriceHistory(ticker, "LSE", "ALL"), corrected);
+        equal(await router.getPriceHistoryForResolution(ticker, "LSE", "5Y", "1wk"), corrected);
+        equal(await router.getDetailedPriceHistory(ticker, "LSE", new Date("1996-01-01"), new Date("2026-09-10"), "1wk"), corrected);
+      };
+      await read(new AssetDataRouter(provider, [], store.resources));
+      expect(calls).toBe(3);
+      await read(new AssetDataRouter(provider, [], store.resources));
+      expect(calls).toBe(3);
+    } finally { store.close(); }
+  }
+});
+
+test("an unavailable or legacy provider response cannot revive poisoned cache; valid independent history still wins", async () => {
+  const store = new AppPersistence(createTempDbPath("shell-lineage-fallback"));
+  try {
+    const key = { namespace: "market", kind: "price-history", entityKey: "SHEL", variantKey: "exchange=LSE;range=ALL;resolution=1wk;version=5;unit=GBP" };
+    store.resources.set({ ...key, sourceKey: "provider:gloomberb-cloud" }, bad, { cachePolicy: policy });
+    for (const [index, load] of [async () => [], async () => bad, async () => { throw Error("controlled offline source"); }].entries()) {
+      const router = new AssetDataRouter({ ...fallbackProvider, id: "gloomberb-cloud", getPriceHistoryForResolution: load }, [], store.resources);
+      if (index === 0) expect(await router.getPriceHistoryForResolution("SHEL", "LSE", "ALL", "1wk")).toEqual([]);
+      else await expect(router.getPriceHistoryForResolution("SHEL", "LSE", "ALL", "1wk")).rejects.toThrow("No resolution-aware history provider");
+    }
+    const independent = bad;
+    store.resources.set({ ...key, sourceKey: "provider:independent" }, independent, { cachePolicy: policy });
+    const router = new AssetDataRouter({ ...fallbackProvider, id: "gloomberb-cloud", async getPriceHistoryForResolution() { return []; } },
+      [{ ...fallbackProvider, id: "independent", async getPriceHistoryForResolution() { throw Error("should reuse independent cache"); } }], store.resources);
+    equal(await router.getPriceHistoryForResolution("SHEL", "LSE", "ALL", "1wk"), independent);
+  } finally { store.close(); }
+});
+
+test("modern London, US and Amsterdam histories and broker history are not retired", async () => {
+  const store = new AppPersistence(createTempDbPath("shell-lineage-controls"));
+  try {
+    const modern = [bad[1]!];
+    for (const [ticker, exchange, points] of [["SHEL", "LSE", modern], ["SHEL", "NYSE", bad], ["SHELL", "AMS", bad]] as const) {
+      const unit = exchange === "LSE" ? ";unit=GBP" : "";
+      store.resources.set({ namespace: "market", kind: "price-history", entityKey: ticker,
+        variantKey: `exchange=${exchange};range=1Y;resolution=1wk;version=5${unit}`, sourceKey: "provider:yahoo" }, points, { cachePolicy: policy });
+      const router = new AssetDataRouter({ ...fallbackProvider, id: "yahoo", async getPriceHistoryForResolution() { throw Error("unchanged cache should be reused"); } }, [], store.resources);
+      equal(await router.getPriceHistoryForResolution(ticker, exchange, "1Y", "1wk"), points);
+    }
+    const broker: BrokerAdapter = { id: "ibkr", name: "IBKR", configSchema: [], async validate() { return true; }, async importPositions() { return []; } };
+    store.resources.set({ namespace: "market", kind: "price-history", entityKey: "SHEL", variantKey: "exchange=LSE;range=ALL;resolution=1wk;version=5;unit=GBP", sourceKey: "broker:ibkr:ibkr-work" }, bad, { cachePolicy: policy });
+    const router = new AssetDataRouter(fallbackProvider, [], store.resources);
+    attachTestRegistry(router, { brokers: [["ibkr", broker]] }); setBrokerInstances(router, [brokerInstance()]);
+    equal(await router.getPriceHistoryForResolution("SHEL", "LSE", "ALL", "1wk", { brokerId: "ibkr", brokerInstanceId: "ibkr-work" }), bad);
+  } finally { store.close(); }
+});
+
+test("legacy financial snapshots lose affected history while valid accounts and broker contributions survive", async () => {
+  for (const [id, origin] of [["yahoo", "yahoo"], ["gloomberb-cloud", "yahoo"], ["gloomberb-cloud", "twelvedata"]] as const) {
+    const store = new AppPersistence(createTempDbPath("shell-financial-history"));
+    try {
+      const legacy = origin === "twelvedata" ? bad.map((point) => ({ ...point, historySource: { provider: origin, symbol: "SHEL" as const, exchange: "LSE" as const, currency: "GBP" as const } })) : bad;
+      const financials = makeFinancials({ quote: makeQuote({ symbol: "SHEL", currency: "GBP", listingExchangeName: "LSE", providerId: id }),
+        profile: { description: "Recorded research fixture" }, annualStatements: [{ date: "2025-12-31", totalRevenue: 100 }], priceHistory: legacy });
+      cacheRouterResource(store.resources, "financials", "SHEL", "exchange=LSE", `provider:${id}`, financials, policy);
+      const provider = { ...fallbackProvider, id, async getTickerFinancials() { return financials; } };
+      const router = new AssetDataRouter(provider, [], store.resources);
+      const value = await router.getTickerFinancials("SHEL", "LSE");
+      expect(value.priceHistory).toEqual([]);
+      expect(value.annualStatements).toEqual(financials.annualStatements);
+      expect(value.profile).toEqual(financials.profile);
+      // An extended partial refresh merges its previous source record first;
+      // that branch must not resurrect the same stale snapshot history.
+      const extended = await router.getTickerFinancials("SHEL", "LSE", { statementHistory: "extended", cacheMode: "refresh" });
+      expect(extended.priceHistory).toEqual([]);
+      const broker: BrokerAdapter = { id: "ibkr", name: "IBKR", configSchema: [], async validate() { return true; }, async importPositions() { return []; } };
+      cacheRouterResource(store.resources, "financials", "SHEL", "exchange=LSE", "broker:ibkr:ibkr-work", { ...financials, quote: { ...financials.quote!, providerId: "ibkr" } }, policy);
+      attachTestRegistry(router, { brokers: [["ibkr", broker]] }); setBrokerInstances(router, [brokerInstance()]);
+      equal((await router.getTickerFinancials("SHEL", "LSE", { brokerId: "ibkr", brokerInstanceId: "ibkr-work" })).priceHistory, legacy);
+    } finally { store.close(); }
+  }
+});
+
+
+test("cadence-verified filtered caches recover missing disclosure only for requested long windows", async () => {
+  for (const origin of ["yahoo", "twelvedata"] as const) {
+    const store = new AppPersistence(createTempDbPath("shell-lineage-missing-provenance"));
+    const legacy = good.map(({ historySource, ...point }) => point);
+    const corrected = good.map((point) => ({ ...point, historySource: { ...point.historySource!, provider: origin } }));
+    try {
+      store.resources.set({ namespace: "market", kind: "price-history", entityKey: "SHEL",
+        variantKey: "exchange=LSE;range=ALL;resolution=1wk;version=5;granularity=1;unit=GBP", sourceKey: "provider:gloomberb-cloud" }, legacy, { cachePolicy: policy });
+      let calls = 0;
+      const provider = { ...fallbackProvider, id: "gloomberb-cloud", async getPriceHistoryForResolution() { calls++; return corrected; } };
+      const router = new AssetDataRouter(provider, [], store.resources);
+      equal(await router.getPriceHistoryForResolution("SHEL", "LSE", "1Y", "1wk"), [legacy[1]]);
+      expect(calls).toBe(0);
+      equal(await router.getPriceHistoryForResolution("SHEL", "LSE", "ALL", "1wk"), corrected);
+      expect(calls).toBe(1);
+      equal(await new AssetDataRouter(provider, [], store.resources).getPriceHistoryForResolution("SHEL", "LSE", "ALL", "1wk"), corrected);
+      expect(calls).toBe(1);
+    } finally { store.close(); }
+  }
+});

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

@@ -0,0 +1,71 @@
+import { afterEach, expect, test } from "bun:test";
+import { AppPersistence } from "../../data/app-persistence";
+import type { MarketDataRequestContext } from "../../types/data-provider";
+import { AssetDataRouter } from "./index";
+import { cleanupProviderRouterTestFiles, createTempDbPath, fallbackProvider, makeFinancials, makeQuote } from "./test-support";
+
+const rows = Array.from({ length: 19 }, (_, index) => ({ date: `${2007 + index}-12-31`, currency: "USD", totalRevenue: 100 + index, operatingIncome: 40, inventory: 5 }));
+const financials = (extended: boolean, status: "available" | "retryable-failure" = "available", symbol = "MSFT", exchange = "NASDAQ") => makeFinancials({
+ quote: makeQuote({ symbol, listingExchangeName: exchange }), profile: { description: "Microsoft Corporation" }, annualStatements: extended ? rows : rows.slice(-5),
+ ...(extended ? { statementHistory: { mode: "extended" as const, source: "sec" as const, status, fetchedAt: new Date().toISOString() } } : {}),
+});
+afterEach(cleanupProviderRouterTestFiles);
+
+test("extended requests bypass a default deep cache and reuse the whole extended source for later counts", async () => {
+ const persistence = new AppPersistence(createTempDbPath("extended"));
+ const calls: Array<MarketDataRequestContext | undefined> = [];
+ const provider = { ...fallbackProvider, async getTickerFinancials(_symbol: string, _exchange?: string, context?: MarketDataRequestContext) { calls.push(context); return financials(context?.statementHistory === "extended", "available", _symbol, _exchange); } };
+ const router = new AssetDataRouter(provider, [], persistence.resources);
+ try {
+  expect((await router.getTickerFinancials("MSFT", "NASDAQ")).annualStatements).toHaveLength(5);
+  expect((await router.getTickerFinancials("MSFT", "NASDAQ", { statementHistory: "extended" })).annualStatements).toHaveLength(19);
+  const second = new AssetDataRouter(provider, [], persistence.resources);
+  expect((await second.getTickerFinancials("MSFT", "NASDAQ", { statementHistory: "extended" })).annualStatements).toHaveLength(19);
+  expect((await second.getTickerFinancials("MSFT", "NASDAQ")).annualStatements).toHaveLength(5);
+  expect(calls.map(c => c?.statementHistory)).toEqual([undefined, "extended"]);
+ } finally { persistence.close(); }
+});
+
+test("failed extension keeps usable rows and retries instead of caching a shallow answer for statement TTL", async () => {
+ const persistence = new AppPersistence(createTempDbPath("extended-retry"));
+ let calls = 0;
+ const provider = { ...fallbackProvider, async getTickerFinancials() { calls++; return financials(true, calls === 1 ? "retryable-failure" : "available"); } };
+ const router = new AssetDataRouter(provider, [], persistence.resources);
+ try {
+  expect((await router.getTickerFinancials("MSFT", "NASDAQ", { statementHistory: "extended" })).annualStatements).toHaveLength(19);
+  expect((await router.getTickerFinancials("MSFT", "NASDAQ", { statementHistory: "extended" })).statementHistory?.status).toBe("available");
+  expect(calls).toBe(2);
+ } finally { persistence.close(); }
+});
+
+test("mixed batches retain extended intent through the single route instead of default batch cache", async () => {
+ let batches = 0;
+ const contexts: Array<MarketDataRequestContext | undefined> = [];
+ const router = new AssetDataRouter({ ...fallbackProvider,
+  async getTickerFinancialsBatch(targets) { batches++; return targets.map(target => ({ target, financials: financials(false, "available", target.symbol, target.exchange) })); },
+  async getTickerFinancials(_symbol, _exchange, context) { contexts.push(context); return financials(context?.statementHistory === "extended", "available", _symbol, _exchange); },
+ });
+ const result = await router.getTickerFinancialsBatch([{ symbol: "MSFT", exchange: "NASDAQ", statementHistory: "extended" }, { symbol: "V", exchange: "NYSE" }]);
+ expect(result.map(item => item.financials?.annualStatements.length)).toEqual([19, 5]);
+ expect(contexts[0]?.statementHistory).toBe("extended");
+ expect(batches).toBe(1);
+});
+
+test("a failed refresh preserves the previous extended rows across repeated retries", async () => {
+ const persistence = new AppPersistence(createTempDbPath("extended-last-good"));
+ let failed = false;
+ const provider = { ...fallbackProvider, async getTickerFinancials() {
+  const value = financials(true, failed ? "retryable-failure" : "available");
+  return failed ? { ...value, annualStatements: value.annualStatements.slice(-4) } : value;
+ } };
+ const router = new AssetDataRouter(provider, [], persistence.resources);
+ try {
+  await router.getTickerFinancials("MSFT", "NASDAQ", { statementHistory: "extended" });
+  failed = true;
+  for (let attempt = 0; attempt < 2; attempt++) {
+   const value = await router.getTickerFinancials("MSFT", "NASDAQ", { statementHistory: "extended", cacheMode: "refresh" });
+   expect(value.annualStatements).toHaveLength(19);
+   expect(value.statementHistory?.status).toBe("retryable-failure");
+  }
+ } finally { persistence.close(); }
+});

package/src/sources/provider-router/statement-history.ts

@@ -0,0 +1,15 @@
+import type { MarketDataRequestContext } from "../../types/data-provider";
+import type { TickerFinancials } from "../../types/financials";
+
+export function financialHistoryVariants(variants: string[], context?: MarketDataRequestContext): string[] {
+  return context?.statementHistory === "extended"
+    ? variants.map((variant) => `${variant};history=extended:v1`)
+    : variants;
+}
+
+/** A nominal row count never certifies that the extended source was attempted. */
+export function hasReusableExtendedHistory(value: TickerFinancials | null | undefined): boolean {
+  const attempt = value?.statementHistory;
+  return !!attempt && attempt.status !== "retryable-failure"
+    && Date.now() - Date.parse(attempt.fetchedAt) < 6 * 60 * 60_000;
+}

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

@@ -0,0 +1,126 @@
+import { expect, test } from "bun:test";
+import type { IncomeStatementSource } from "../../types/financials";
+import { AppPersistence } from "../../data/app-persistence";
+import { parseCompanyFactsFinancialStatements } from "../sec-edgar";
+import { deriveQuarterlyStatements } from "../../time-series/fundamentals";
+import { computeTTM } from "../../plugins/builtin/ticker-detail/financials/aggregation";
+import { mergeFinancialStatementRows } from "../../utils/financial-statements";
+import { redactWithdrawnStatement, withdrawKnownProviderStatements } from "../../utils/statement-observations";
+import { AssetDataRouter } from "./index";
+import { cacheRouterResource, listCachedResources } from "./cache";
+import { fallbackProvider, makeFinancials, makeQuote } from "./test-support";
+import fixture from "./fixtures/quarterly-source-disagreements.json";
+
+const target = { symbol: "BAC", exchange: "NYSE" };
+const policy = { staleMs: 60_000, expireMs: 600_000 };
+const q4 = <T extends { date: string }>(rows: T[]) => rows.find(row => row.date === "2025-12-31")!;
+const captured = (symbol: "BAC" | "O" = "BAC") => makeFinancials({ ...fixture.issuers[symbol].financials,
+  quote: makeQuote({ symbol, listingExchangeName: "NYSE", currency: "USD", providerId: "gloomberb-cloud" }),
+  profile: { description: "Recorded issuer" },
+});
+
+test("recorded quarter conflicts survive both sparse merge orders and JSON without erasing corroborated O income", () => {
+  for (const symbol of ["BAC", "O"] as const) {
+    const raw = captured(symbol);
+    const value = withdrawKnownProviderStatements(raw, { ...target, symbol }, "provider:gloomberb-cloud");
+    expect(q4(value.quarterlyStatements).totalRevenue).toBeUndefined();
+    if (symbol === "BAC") {
+      for (const field of ["netIncome", "netIncomeCommonStockholders", "pretaxIncome", "taxProvision"] as const) expect(q4(value.quarterlyStatements)[field]).toBeUndefined();
+    } else {
+      expect(q4(value.quarterlyStatements).netIncome).toBe(296_085_000);
+      expect(q4(value.quarterlyStatements).taxProvision).toBe(21_800_000);
+    }
+    for (const primary of [true, false]) {
+      const rows = mergeFinancialStatementRows(primary ? value.quarterlyStatements : raw.quarterlyStatements, primary ? raw.quarterlyStatements : value.quarterlyStatements);
+      expect(q4(JSON.parse(JSON.stringify(rows))).totalRevenue).toBeUndefined();
+      expect(computeTTM(rows)?.totalRevenue).toBeUndefined();
+    }
+    expect(withdrawKnownProviderStatements(value, { ...target, symbol }, "provider:gloomberb-cloud")).toBe(value);
+  }
+});
+
+test("actual SEC projection cannot recreate the known mixed-revision BAC quarter, but reported corrections restore it", () => {
+  const parsed = parseCompanyFactsFinancialStatements(fixture.issuers.BAC.companyfacts);
+  const derived = deriveQuarterlyStatements(parsed.quarterlyStatements, parsed.annualStatements);
+  const gap = q4(derived);
+  expect(gap.totalRevenue).toBeUndefined(); expect(gap.netIncome).toBeUndefined(); expect(gap.netIncomeCommonStockholders).toBeUndefined();
+  expect(gap.withdrawnObservations?.length).toBe(3);
+  const neighbor = { date: "2025-12-30", currency: "USD", totalAssets: 500, availableAt: "2026-06-01" };
+  for (const rows of [[...parsed.quarterlyStatements, neighbor], mergeFinancialStatementRows([neighbor], parsed.quarterlyStatements)]) {
+    const withNeighbor = deriveQuarterlyStatements(rows, parsed.annualStatements);
+    expect(q4(withNeighbor).totalRevenue).toBeUndefined();
+    expect(q4(withNeighbor).withdrawnObservations?.length).toBe(3);
+    expect(withNeighbor.find(row => row.date === neighbor.date)?.withdrawnObservations).toBeUndefined();
+  }
+  const corrected = { date: "2025-12-31", currency: "USD", totalRevenue: 28_367_000_000, netIncome: 7_647_000_000, netIncomeCommonStockholders: 7_319_000_000 };
+  const restored = q4(mergeFinancialStatementRows(derived, [corrected]));
+  expect(restored).toMatchObject(corrected); expect(restored.withdrawnObservations).toBeUndefined();
+  expect(q4(deriveQuarterlyStatements([...parsed.quarterlyStatements.filter(row => row.date !== corrected.date), corrected], parsed.annualStatements))).toMatchObject(corrected);
+});
+
+test("fresh, legacy cached and batch-only statement observations are withdrawn and a later correction is cached without a refresh loop", async () => {
+  const store = new AppPersistence(":memory:");
+  try {
+    let value = captured();
+    const provider = { ...fallbackProvider, id: "gloomberb-cloud", getTickerFinancials: async () => value,
+      getTickerFinancialsBatch: async (targets: typeof target[]) => targets.map(target => ({ target, financials: value })),
+    };
+    const router = new AssetDataRouter(provider, [], store.resources);
+    cacheRouterResource(store.resources, "financials", target.symbol, "exchange=NYSE", "provider:gloomberb-cloud", value, policy);
+    expect(q4(router.getCachedFinancialsForTargets([target]).get("BAC")!.quarterlyStatements).totalRevenue).toBeUndefined();
+    cacheRouterResource(store.resources, "financials", "contract:12345", "exchange=NYSE", "provider:gloomberb-cloud", value, policy);
+    expect(q4(listCachedResources<typeof value>(store.resources, "financials", "contract:12345", ["exchange=NYSE"], ["provider:gloomberb-cloud"], true)[0]!.value.quarterlyStatements).totalRevenue).toBeUndefined();
+    expect(q4((await router.getTickerFinancials("BAC", "NYSE", { cacheMode: "refresh" })).quarterlyStatements).netIncome).toBeUndefined();
+    expect(q4((await router.getTickerFinancialsBatch([target], { forceRefresh: true }))[0]!.financials!.quarterlyStatements).taxProvision).toBeUndefined();
+    const clean = withdrawKnownProviderStatements(value, target, "provider:gloomberb-cloud");
+    cacheRouterResource(store.resources, "financials", "BAC", "exchange=NYSE", "provider:gloomberb-cloud", clean, policy);
+    expect(listCachedResources(store.resources, "financials", "BAC", ["exchange=NYSE"], ["provider:gloomberb-cloud"], true)[0]!.stale).toBe(false);
+    value = { ...value, quarterlyStatements: value.quarterlyStatements.map(row => row.date === "2025-12-31" ? { ...row,
+      totalRevenue: 28_367_000_000, netIncome: 7_647_000_000, netIncomeCommonStockholders: 7_319_000_000,
+      pretaxIncome: 9_622_000_000, taxProvision: 1_975_000_000 } : row) };
+    const corrected = await router.getTickerFinancials("BAC", "NYSE", { cacheMode: "refresh" });
+    expect(q4(corrected.quarterlyStatements).totalRevenue).toBe(28_367_000_000);
+    expect(q4(corrected.quarterlyStatements).withdrawnObservations).toBeUndefined();
+  } finally { store.close(); }
+});
+
+test("withdrawals require source, listing, reporting currency and quarter; malformed metadata cannot erase other observations", () => {
+  const raw = captured();
+  for (const [value, request, source] of [
+    [raw, { ...target, exchange: "LSE" }, "provider:yahoo"],
+    [raw, { ...target, symbol: "OTHER" }, "provider:yahoo"],
+    [raw, target, "broker:account"],
+    [{ ...raw, quoteMetadata: { symbol: "JPM", listingExchangeName: "NYSE" } }, target, "provider:yahoo"],
+    [{ ...raw, quarterlyStatements: raw.quarterlyStatements.map(row => ({ ...row, currency: "GBP" })) }, target, "provider:yahoo"],
+  ] as const) expect(withdrawKnownProviderStatements(value, request, source)).toBe(value);
+  const row = q4(raw.quarterlyStatements);
+  for (const metadata of ["bac-2025q4-revenue", ["unknown"], [null], {}]) {
+    expect(redactWithdrawnStatement({ ...row, withdrawnObservations: metadata as any }).totalRevenue).toBe(row.totalRevenue);
+  }
+  expect(redactWithdrawnStatement({ ...row, date: "2024-12-31", withdrawnObservations: ["bac-2025q4-revenue"] }).totalRevenue).toBe(row.totalRevenue);
+});
+
+test("direct SEC income that matches a rejected vendor number stays stable through repeated withdrawals and cache reads", () => {
+  const evidence: IncomeStatementSource = { source: "sec", concept: "NetIncomeLoss", basis: "parent", unit: "USD",
+    startDate: "2025-10-01", endDate: "2025-12-31", filed: "2026-02-25", accessionNumber: "controlled-direct-fact" };
+  const raw = captured();
+  raw.quarterlyStatements = raw.quarterlyStatements.map(row => row.date === evidence.endDate
+    ? { ...row, fieldSources: { netIncome: evidence } } : row);
+  const cleaned = withdrawKnownProviderStatements(raw, target, "provider:gloomberb-cloud");
+  const row = q4(cleaned.quarterlyStatements);
+  expect(row.netIncome).toBe(7_528_000_000);
+  expect(row.fieldSources?.netIncome).toEqual(evidence);
+  expect(row.withdrawnObservations).toEqual(["bac-2025q4-revenue", "bac-2025q4-common-income", "bac-2025q4-pretax", "bac-2025q4-tax"]);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const repeated = withdrawKnownProviderStatements(cleaned, target, "provider:gloomberb-cloud");
+    expect(repeated).toBe(cleaned);
+    expect(q4(repeated.quarterlyStatements)).toBe(row);
+  }
+  const store = new AppPersistence(":memory:");
+  try {
+    cacheRouterResource(store.resources, "financials", "BAC", "exchange=NYSE", "provider:gloomberb-cloud", cleaned, policy);
+    const record = listCachedResources<typeof cleaned>(store.resources, "financials", "BAC", ["exchange=NYSE"], ["provider:gloomberb-cloud"], true)[0]!;
+    expect(record.stale).toBe(false);
+    expect(q4(record.value.quarterlyStatements).fieldSources?.netIncome).toEqual(evidence);
+  } finally { store.close(); }
+});

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

@@ -69,7 +69,7 @@ export class ProviderRouterStreamingRoutes {
         targetCount: providerTargets.length,
       });
       unsubscribers.push(streamingProvider.subscribeQuotes(providerTargets, (target, quote) => {
-        if (isProviderQuoteUsableForCurrentSession(quote, target.exchange)) {
+        if (isProviderQuoteUsableForCurrentSession(quote, target.exchange, target.symbol)) {
           onQuote(target, quote);
         }
       }));