gloomberb 0.15.2 → 0.15.3

package/src/sources/reported-operating-results.test.ts

@@ -1,286 +0,0 @@
-import { expect, test } from "bun:test";
-import type { FinancialStatement, TickerFinancials } from "../types/financials";
-import { coalesceFinancialPeriodAliases, mergeFinancialStatementRows, statementFieldAvailability } from "../utils/financial-statements";
-import { normalizeStatementOperatingResult, operatingResultDisagrees, providerOperatingObservation, reportedOperatingCohort } from "../utils/operating-result";
-import { parseCompanyFactsFinancialStatements, SecEdgarClient } from "./sec-edgar";
-import { buildYahooStatements, parseYahooTimeseries } from "./yahoo-finance/financials";
-import { YahooFinanceClient } from "./yahoo-finance";
-import { mapCloudFinancials } from "./gloomberb-cloud/normalizers";
-import sec from "./fixtures/sec-operating-expenses.json";
-import yahoo from "./fixtures/shop-operating-provider.json";
-import liveSubmissions from "./fixtures/shop-submissions-20260922.json";
-import { canAggregateOperatingField } from "../utils/operating-result-aggregation";
-import { readFileSync } from "node:fs";
-
-const metrics = parseYahooTimeseries(yahoo.timeseries.result);
-const source = () => parseCompanyFactsFinancialStatements(sec.shop);
-const provider = (period: "annual" | "quarterly") => buildYahooStatements({ ...metrics,
-  // Controlled independent companion observations; the captured Yahoo request
-  // above contained only the directly compared operating trio.
-  [`${period}EBITDA`]: [{ asOfDate: period === "annual" ? "2025-12-31" : "2026-06-30", currency: "USD", periodType: period === "annual" ? "12M" : "3M", value: 17 }],
-  [`${period}TotalExpenses`]: [{ asOfDate: period === "annual" ? "2025-12-31" : "2026-06-30", currency: "USD", periodType: period === "annual" ? "12M" : "3M", value: 23 }],
-}, period, true)[0]!;
-const financials = (row: FinancialStatement): TickerFinancials => ({
-  quote: { symbol: "SHOP", currency: "USD", exchangeName: "NASDAQ", price: 100, change: 0, changePercent: 0 },
-  financialCurrency: "USD", annualStatements: [row], quarterlyStatements: [], priceHistory: [],
-});
-
-test("captured native provider and SEC rows keep direct trio and independent companions in both merge orders", () => {
-  for (const period of ["annual", "quarterly"] as const) {
-    const original = provider(period);
-    const direct = source()[period === "annual" ? "annualStatements" : "quarterlyStatements"][0]!;
-    for (const [primary, fallback] of [[original, direct], [direct, original]]) {
-      const merged = mergeFinancialStatementRows([primary!], [fallback!])[0]!;
-      expect(reportedOperatingCohort(merged, period)?.values).toEqual({
-        grossProfit: direct.grossProfit!, operatingExpense: direct.operatingExpense!, operatingIncome: direct.operatingIncome!,
-      });
-      expect(merged.operatingIncome).toBe(period === "annual" ? 1_468_000_000 : 488_000_000);
-      expect(merged.operatingExpense).toBe(period === "annual" ? 4_087_000_000 : 1_220_000_000);
-      expect(merged.ebitda).toBe(original.ebitda);
-      expect(merged.totalExpenses).toBe(original.totalExpenses);
-      expect(providerOperatingObservation(merged, "operatingIncome")?.value).toBe(original.operatingIncome);
-      if (original.ebitda !== undefined) expect(providerOperatingObservation(merged, "ebitda")?.value).toBe(original.ebitda);
-      expect(operatingResultDisagrees(merged)).toBe(true);
-      expect(statementFieldAvailability(merged, "operatingExpense")).toBe(direct.operatingResult!.reported!.filed);
-      expect(normalizeStatementOperatingResult(JSON.parse(JSON.stringify(merged)), period)).toEqual(merged);
-    }
-  }
-});
-
-test("native default supplementation changes only the qualified reported operating group, with unrelated controls", async () => {
-  const client = new YahooFinanceClient() as any;
-  let calls = 0;
-  client.secClient.getFinancialStatements = async () => { calls++; return source(); };
-  const original = financials(provider("annual"));
-  const merged = await client.supplementSecStatements("SHOP", "NASDAQ", original, false) as TickerFinancials;
-  expect(merged.annualStatements[0]!.operatingIncome).toBe(1_468_000_000);
-  expect(merged.annualStatements[0]!.ebitda).toBe(original.annualStatements[0]!.ebitda);
-  const toronto = { ...original, quote: { ...original.quote!, currency: "CAD", exchangeName: "TSX" } };
-  expect((await client.supplementSecStatements("SHOP", "TSX", toronto, false)).annualStatements).toEqual(toronto.annualStatements);
-  expect(calls).toBe(1);
-  const alias = await client.supplementSecStatements("SHOP", "XNAS", original, true) as TickerFinancials;
-  expect(alias.annualStatements[0]!.operatingIncome).toBe(1_468_000_000);
-  expect(alias.annualStatements[0]!.ebitda).toBe(original.annualStatements[0]!.ebitda);
-  const msft = parseCompanyFactsFinancialStatements(sec.msft).annualStatements[0]!;
-  expect(msft.operatingResult).toBeUndefined();
-  expect(mergeFinancialStatementRows([{ date: msft.date, currency: "USD", operatingIncome: 10 }], [msft])[0]!.operatingIncome).toBe(10);
-});
-
-test("owned operating rows cannot cross currency, neighboring period or conflicting top-line anchors", () => {
-  const direct = source().quarterlyStatements[0]!;
-  const original = provider("quarterly");
-  const foreign = { ...original, currency: "CAD" };
-  expect(mergeFinancialStatementRows([foreign], [direct])[0]!.operatingIncome).toBe(original.operatingIncome);
-  const neighboring: FinancialStatement = { date: "2026-06-29", currency: "USD", operatingIncome: original.operatingIncome };
-  const merged = mergeFinancialStatementRows([neighboring], [direct])[0]!;
-  expect(merged.date).toBe(neighboring.date);
-  expect(merged.operatingIncome).toBe(original.operatingIncome);
-  expect(merged.operatingExpense).toBeUndefined();
-  expect(merged.grossProfit).toBeUndefined();
-  expect(merged.operatingResult?.reported).toBeUndefined();
-  expect(mergeFinancialStatementRows([neighboring], [direct])).toHaveLength(2);
-  const matchingNeighbor = { ...direct, date: neighboring.date, operatingResult: undefined };
-  for (const [primary, fallback] of [[matchingNeighbor, direct], [direct, matchingNeighbor]] as const) {
-    expect(coalesceFinancialPeriodAliases([primary, fallback]).map(row => row.date)).toEqual([neighboring.date, direct.date]);
-    expect(mergeFinancialStatementRows([primary], [fallback]).map(row => row.date)).toEqual([neighboring.date, direct.date]);
-    expect(mergeFinancialStatementRows([primary], [fallback]).find(row => row.date === direct.date)?.operatingResult).toEqual(direct.operatingResult);
-  }
-  const anchored = structuredClone(direct);
-  anchored.operatingResult!.reported!.anchors = { totalRevenue: 3_583_000_000 };
-  const conflict = mergeFinancialStatementRows([{ ...original, totalRevenue: 1 }], [anchored])[0]!;
-  expect(conflict.operatingResult?.reported).toBeUndefined();
-  expect(conflict.operatingIncome).toBe(original.operatingIncome);
-});
-
-test("Cloud ownership is listing, period and numeric-value bound rather than accepting arbitrary metadata", () => {
-  const row = mergeFinancialStatementRows([provider("annual")], source().annualStatements)[0]!;
-  const input = financials(row);
-  expect(mapCloudFinancials(input as any, undefined, { symbol: "SHOP", exchange: "NASDAQ" }).annualStatements[0]!.operatingResult).toEqual(row.operatingResult);
-  expect(mapCloudFinancials({ ...input, quote: undefined } as any, undefined, { symbol: "SHOP", exchange: "TSX" }).annualStatements[0]!.operatingResult).toBeUndefined();
-  for (const mutate of [
-    (bad: FinancialStatement) => { bad.operatingResult!.reported!.cik = "0000789019"; },
-    (bad: FinancialStatement) => { bad.operatingResult!.reported!.period = "quarterly"; },
-    (bad: FinancialStatement) => { bad.operatingIncome = 7; },
-  ]) {
-    const bad = structuredClone(row); mutate(bad);
-    expect(mapCloudFinancials(financials(bad) as any, undefined, { symbol: "SHOP", exchange: "NASDAQ" }).annualStatements[0]!.operatingResult?.reported).toBeUndefined();
-  }
-  const bad = structuredClone(row);
-  (bad.operatingResult!.provider!.operatingIncome as any).sourceField = 42;
-  expect(normalizeStatementOperatingResult(bad).operatingResult?.provider?.operatingIncome).toBeUndefined();
-});
-
-test("companion provenance follows the actual numeric owner even when losing values happen to match", () => {
-  const direct = { ...source().annualStatements[0]!, ebitda: provider("annual").ebitda, totalExpenses: provider("annual").totalExpenses };
-  const merged = mergeFinancialStatementRows([direct], [provider("annual")])[0]!;
-  expect(merged.ebitda).toBe(direct.ebitda);
-  expect(merged.operatingResult?.provider?.ebitda).toBeUndefined();
-  expect(merged.operatingResult?.provider?.totalExpenses).toBeUndefined();
-  expect(merged.operatingResult?.provider?.operatingIncome).toBeDefined();
-});
-
-test("Yahoo ownership requires each observation's explicit currency and exact duration, including replacement points", () => {
-  for (const period of ["annual", "quarterly"] as const) {
-    const valid = { asOfDate: "2025-12-31", currency: "USD", periodType: period === "annual" ? "12M" : "3M", value: 100 };
-    for (const unqualified of [{ ...valid, currency: undefined }, { ...valid, periodType: undefined },
-      { ...valid, periodType: period === "annual" ? "3M" : "12M" }, { ...valid, value: undefined }]) {
-      const row = buildYahooStatements({ [`${period}OperatingIncome`]: [valid, unqualified] }, period, true)[0]!;
-      expect(row.operatingIncome).toBe(unqualified.value);
-      expect(providerOperatingObservation(row, "operatingIncome")).toBeUndefined();
-    }
-  }
-});
-
-function nativeFixtureClient() {
-  const client = new SecEdgarClient() as any;
-  const requests: string[] = [];
-  const state = { companyFactsFail: false, tableFail: false, submissionsFail: false, amendment: false,
-    annualFail: false, liveSubmissions: false, tableWait: undefined as Promise<void> | undefined };
-  client.loadLookup = async () => new Map([
-    ["SHOP", { cik: "0001594805", exchange: "Nasdaq" }],
-    ["MSFT", { cik: "0000789019", exchange: "Nasdaq" }],
-  ]);
-  client.fetchJson = async (url: string) => {
-    requests.push(url);
-    if (url.includes("companyfacts")) {
-      if (state.companyFactsFail) throw new Error("fixture companyfacts unavailable");
-      return url.includes("1594805") ? sec.shop : sec.msft;
-    }
-    if (state.submissionsFail) throw new Error("fixture submissions unavailable");
-    if (state.liveSubmissions) return liveSubmissions;
-    return { cik: "1594805", filings: { recent: {
-      accessionNumber: [...(state.amendment ? ["0001594805-26-000048"] : []), "0001594805-26-000047", "0001594805-26-000007"],
-      form: [...(state.amendment ? ["10-Q/A"] : []), "10-Q", "10-K"],
-      filingDate: [...(state.amendment ? ["2026-08-06"] : []), "2026-08-05", "2026-02-11"],
-      primaryDocument: [...(state.amendment ? ["shop-amendment.htm"] : []), "shop-20260630.htm", "shop-20251231.htm"],
-    } } };
-  };
-  client.fetchText = async (url: string) => {
-    requests.push(url);
-    if (state.tableWait) await state.tableWait;
-    if (state.tableFail) throw new Error("fixture source unavailable");
-    if (state.annualFail && url.includes("20251231")) throw new Error("fixture annual source unavailable");
-    return { body: readFileSync(new URL(`./fixtures/shop-${url.includes("20260630") ? "20260630" : "20251231"}-quarterly-summary.html`, import.meta.url), "utf8") };
-  };
-  return { client, requests, state };
-}
-
-test("native acquisition loads direct Q4 table cohorts with bounded, cached issuer-qualified documents", async () => {
-  const { client, requests } = nativeFixtureClient();
-  const first = await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  const q4 = first.quarterlyStatements.find((row: FinancialStatement) => row.date === "2025-12-31")!;
-  expect(q4.operatingIncome).toBe(631_000_000);
-  expect(q4.operatingExpense).toBe(1_062_000_000);
-  expect(q4.operatingResult.reported.origin.kind).toBe("filing-table");
-  expect(q4.operatingResult.reported.anchors).toEqual({ totalRevenue: 3_672_000_000, costOfRevenue: 1_979_000_000 });
-  expect(q4.ebitda).toBeUndefined();
-  expect(q4.totalExpenses).toBeUndefined();
-  expect(requests.filter(url => url.includes("submissions"))).toHaveLength(1);
-  expect(requests.filter(url => url.includes("Archives"))).toHaveLength(2);
-  await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  await client.getFinancialStatements("MSFT", { reportedOperatingResults: true });
-  expect(requests.filter(url => url.includes("Archives"))).toHaveLength(2);
-});
-
-test("native sources fail independently and total table refresh failure retains the original qualified snapshot", async () => {
-  for (const failure of ["tableFail", "submissionsFail"] as const) {
-    const { client, requests, state } = nativeFixtureClient();
-    await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-    const snapshot = client.shopOperatingTables;
-    snapshot.expiresAt = 0;
-    state[failure] = true;
-    const stale = await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-    expect(stale.quarterlyStatements.find((row: FinancialStatement) => row.date === "2025-12-31")?.operatingIncome).toBe(631_000_000);
-    expect(client.shopOperatingTables).toBe(snapshot);
-    expect(snapshot.expiresAt).toBe(0);
-    const requestCount = requests.filter(url => url.includes("submissions")).length;
-    await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-    expect(requests.filter(url => url.includes("submissions"))).toHaveLength(requestCount);
-    const cold = nativeFixtureClient();
-    cold.state[failure] = true;
-    const fallback = await cold.client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-    expect(fallback.annualStatements[0].operatingIncome).toBe(1_468_000_000);
-    expect(fallback.quarterlyStatements.find((row: FinancialStatement) => row.date === "2025-12-31")).toBeUndefined();
-  }
-  const tablesOnly = nativeFixtureClient();
-  tablesOnly.state.companyFactsFail = true;
-  const rows = await tablesOnly.client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  expect(rows.quarterlyStatements.find((row: FinancialStatement) => row.date === "2025-12-31")?.operatingIncome).toBe(631_000_000);
-  tablesOnly.client.shopOperatingTables = undefined;
-  tablesOnly.state.tableFail = true;
-  await expect(tablesOnly.client.getFinancialStatements("SHOP", { reportedOperatingResults: true })).rejects.toThrow("fixture companyfacts unavailable");
-});
-
-test("captured annual amendment does not discard the later Q2 filing's direct Q4 and compatible trailing quarters", async () => {
-  const { client, requests, state } = nativeFixtureClient();
-  state.liveSubmissions = true;
-  const first = await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  const q4 = first.quarterlyStatements.find((row: FinancialStatement) => row.date === "2025-12-31")!;
-  expect(q4.operatingIncome).toBe(631_000_000);
-  expect(q4.operatingExpense).toBe(1_062_000_000);
-  expect(q4.operatingResult.reported.accessionNumber).toBe("0001594805-26-000047");
-  expect(q4.operatingResult.reported.filed).toBe("2026-08-05");
-  const trailing = first.quarterlyStatements.filter((row: FinancialStatement) => row.date >= "2025-09-30");
-  expect(trailing).toHaveLength(4);
-  expect(canAggregateOperatingField(trailing, "operatingIncome")).toBe(true);
-  expect(canAggregateOperatingField(trailing, "operatingExpense")).toBe(true);
-  expect(trailing.reduce((sum: number, row: FinancialStatement) => sum + row.operatingIncome!, 0)).toBe(1_844_000_000);
-  expect(trailing.reduce((sum: number, row: FinancialStatement) => sum + row.operatingExpense!, 0)).toBe(4_494_000_000);
-  expect(requests.filter(url => url.includes("Archives"))).toHaveLength(1);
-  expect(requests.some(url => url.includes("000159480526000007"))).toBe(false);
-  expect(client.shopOperatingTables).toBeUndefined();
-  const partial = client.shopOperatingTablesPartial;
-  expect(partial.expiresAt - Date.now()).toBeGreaterThan(55_000);
-  expect(partial.expiresAt - Date.now()).toBeLessThanOrEqual(60_000);
-  const count = requests.length;
-  await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  expect(requests.length).toBe(count + 1); // companyfacts only; no repeated filings/documents
-  partial.expiresAt = client.shopOperatingTablesRetryAt = 0;
-  await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  expect(requests.filter(url => url.includes("submissions"))).toHaveLength(2);
-  expect(client.shopOperatingTablesPartial.cohorts).toHaveLength(partial.cohorts.length);
-});
-
-test("a later quarterly amendment preserves the annual sibling at its actual date without selecting the preceding Q", async () => {
-  const { client, requests, state } = nativeFixtureClient();
-  state.amendment = true;
-  const value = await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  const q4 = value.quarterlyStatements.find((row: FinancialStatement) => row.date === "2025-12-31")!;
-  expect(q4.operatingIncome).toBe(631_000_000);
-  expect(q4.operatingResult.reported.filed).toBe("2026-02-11");
-  expect(q4.operatingResult.reported.accessionNumber).toBe("0001594805-26-000007");
-  expect(requests.some(url => url.includes("Archives") && url.includes("20260630"))).toBe(false);
-  expect(client.shopOperatingTables).toBeUndefined();
-});
-
-test("partial refresh, total failure and recovery preserve snapshot expiry and source dates with bounded single-flight acquisition", async () => {
-  const { client, requests, state } = nativeFixtureClient();
-  await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  const complete = client.shopOperatingTables;
-  complete.expiresAt = 0;
-  state.annualFail = true;
-  let release!: () => void;
-  state.tableWait = new Promise<void>(resolve => { release = resolve; });
-  const pending = Promise.all([client.getFinancialStatements("SHOP", { reportedOperatingResults: true }),
-    client.getFinancialStatements("SHOP", { reportedOperatingResults: true })]);
-  release();
-  await pending;
-  expect(requests.filter(url => url.includes("submissions"))).toHaveLength(2);
-  expect(requests.filter(url => url.includes("Archives"))).toHaveLength(4);
-  expect(client.shopOperatingTables).toBe(complete);
-  expect(complete.expiresAt).toBe(0);
-  const partial = client.shopOperatingTablesPartial;
-  expect(partial.cohorts).toEqual(complete.cohorts);
-  partial.expiresAt = client.shopOperatingTablesRetryAt = 0;
-  state.tableFail = true;
-  await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  expect(client.shopOperatingTablesPartial).toBe(partial);
-  expect(partial.expiresAt).toBe(0);
-  expect(client.shopOperatingTables).toBe(complete);
-  client.shopOperatingTablesRetryAt = 0;
-  state.tableFail = state.annualFail = false;
-  await client.getFinancialStatements("SHOP", { reportedOperatingResults: true });
-  expect(client.shopOperatingTablesPartial).toBeUndefined();
-  expect(client.shopOperatingTables.expiresAt - Date.now()).toBeGreaterThan(5 * 60 * 60_000);
-  expect(client.shopOperatingTablesRetryAt).toBe(0);
-});

package/src/sources/sec-bank-revenue.test.ts

@@ -1,79 +0,0 @@
-import { expect, test } from "bun:test";
-import { parseCompanyFactsFinancialStatements } from "./sec-edgar";
-
-const bankConcept = "RevenuesNetOfInterestExpense";
-const fact = (rows: object[], unit = "USD") => ({ units: { [unit]: rows } });
-const quarter = { start: "2025-04-01", end: "2025-06-30", form: "10-Q", fp: "Q2", filed: "2025-08-05", accn: "0000019617-25-000615", val: 44_912_000_000 };
-const parseBank = (rows: object[], unit = "USD") => parseCompanyFactsFinancialStatements({ facts: { "us-gaap": { [bankConcept]: fact(rows, unit) } } });
-const revenueBy = (payload: object) => Object.fromEntries(parseCompanyFactsFinancialStatements(payload).quarterlyStatements
-  .map(row => [row.date, row.totalRevenue]));
-
-test("bank revenue fills quarters another tag leaves empty when both tags report the same amounts", () => {
-  // JPM tags total net revenue under both concepts; filings that carry both agree.
-  const q1 = { ...quarter, start: "2025-01-01", end: "2025-03-31", fp: "Q1", filed: "2025-05-01", accn: "0000019617-25-000400", val: 45_310_000_000 };
-  expect(revenueBy({ facts: { "us-gaap": {
-    Revenues: fact([q1]),
-    [bankConcept]: fact([q1, quarter]),
-  } } })).toEqual({ "2025-03-31": q1.val, "2025-06-30": quarter.val });
-});
-
-test("bank revenue stays out when a filing shows it measures something else than the filer's revenue tag", () => {
-  // AXP tags fee revenue alone under the contract-revenue concept. Mixing its
-  // total net revenue into empty periods would create false jumps.
-  const fee = { ...quarter, val: 6_047_000_000 };
-  const q3 = { ...quarter, start: "2025-07-01", end: "2025-09-30", fp: "Q3", accn: "0000004962-25-000900", val: 9_710_000_000 };
-  expect(revenueBy({ facts: { "us-gaap": {
-    RevenueFromContractWithCustomerExcludingAssessedTax: fact([fee]),
-    [bankConcept]: fact([{ ...quarter, val: 7_889_000_000 }, q3]),
-  } } })).toEqual({ "2025-06-30": fee.val });
-});
-
-test("a bank-revenue quarterly frame cannot admit YTD, missing, invalid or reversed duration", () => {
-  for (const duration of [
-    { start: "2025-01-01", end: "2025-06-30" },
-    { start: "2025-01-01", end: "2025-09-30" },
-    { start: undefined }, { start: "invalid" }, { start: "2025-02-30" },
-    { start: "2025-06-31", end: "2025-09-30" },
-    { start: "2025-07-01" }, { start: "2025-06-01" },
-  ]) {
-    const parsed = parseBank([{ ...quarter, ...duration, frame: "CY2025Q2" }]);
-    expect(parsed.quarterlyStatements).toEqual([]);
-  }
-  expect(parseBank([{ ...quarter, frame: "CY2025Q2", form: "8-K" }]).quarterlyStatements).toEqual([]);
-  expect(parseBank([quarter], "EUR").quarterlyStatements).toEqual([]);
-  // The new concept does not change the established frame policy for other tags.
-  const legacy = parseCompanyFactsFinancialStatements({ facts: { "us-gaap": {
-    Revenues: fact([{ ...quarter, start: "2025-01-01", frame: "CY2025Q2" }]),
-  } } });
-  expect(legacy.quarterlyStatements[0]?.totalRevenue).toBe(quarter.val);
-});
-
-test("direct bank revenue keeps zero and negative values, duration limits and existing annual rules", () => {
-  for (const [start, end, val] of [["2025-04-01", "2025-05-31", 0], ["2025-04-01", "2025-07-30", -2]] as const) {
-    const rows = parseBank([{ ...quarter, start, end, val, frame: "CY2025Q2" }]).quarterlyStatements;
-    expect(rows[0]?.totalRevenue).toBe(val);
-  }
-  for (const [start, end] of [["2025-04-01", "2025-05-30"], ["2025-04-01", "2025-07-31"]]) {
-    expect(parseBank([{ ...quarter, start, end, frame: "CY2025Q2" }]).quarterlyStatements).toEqual([]);
-  }
-  const annual = { ...quarter, start: "2025-01-01", end: "2025-12-31", form: "10-K", fp: "FY", filed: "2026-02-13" };
-  expect(parseBank([annual]).annualStatements[0]?.totalRevenue).toBe(annual.val);
-  expect(parseBank([{ ...annual, form: "10-Q" }]).annualStatements).toEqual([]);
-  expect(parseBank([{ ...annual, start: "2025-03-01" }]).annualStatements).toEqual([]);
-});
-
-test("bank revenue is a fallback; same-concept restatements retain their own disclosure dates", () => {
-  for (const tag of ["RevenueFromContractWithCustomerExcludingAssessedTax", "Revenues", "SalesRevenueNet"]) {
-    const result = parseCompanyFactsFinancialStatements({ facts: { "us-gaap": {
-      [tag]: fact([{ ...quarter, val: 100 }]),
-      [bankConcept]: fact([{ ...quarter, val: 200, filed: "2026-08-06" }]),
-    } } });
-    expect(result.quarterlyStatements[0]).toMatchObject({ totalRevenue: 100, fieldAvailability: { totalRevenue: "2025-08-05" } });
-  }
-  const repeat = { ...quarter, filed: "2026-08-06", frame: "CY2025Q2" };
-  expect(parseBank([quarter, repeat]).quarterlyStatements[0]?.fieldAvailability?.totalRevenue).toBe("2025-08-05");
-  const amended = { ...quarter, val: quarter.val + 1, filed: "2026-05-01", form: "10-Q/A" };
-  expect(parseBank([quarter, amended, { ...repeat, val: amended.val }]).quarterlyStatements[0]).toMatchObject({
-    totalRevenue: amended.val, fieldAvailability: { totalRevenue: "2026-05-01" },
-  });
-});

package/src/sources/sec-edgar-shares.fixture.json

@@ -1,188 +0,0 @@
-{
-  "cik": 1321655,
-  "entityName": "Palantir Technologies Inc.",
-  "facts": {
-    "us-gaap": {
-      "WeightedAverageNumberOfSharesOutstandingBasic": {
-        "units": {
-          "shares": [
-            {
-              "start": "2023-01-01",
-              "end": "2023-12-31",
-              "val": 2147446000,
-              "accn": "0001321655-24-000022",
-              "fy": 2023,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2024-02-20"
-            },
-            {
-              "start": "2023-01-01",
-              "end": "2023-12-31",
-              "val": 2147446000,
-              "accn": "0001321655-25-000022",
-              "fy": 2024,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2025-02-18"
-            },
-            {
-              "start": "2023-01-01",
-              "end": "2023-12-31",
-              "val": 2147446000,
-              "accn": "0001321655-26-000011",
-              "fy": 2025,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2026-02-17",
-              "frame": "CY2023"
-            },
-            {
-              "start": "2024-01-01",
-              "end": "2024-12-31",
-              "val": 2250163000,
-              "accn": "0001321655-25-000022",
-              "fy": 2024,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2025-02-18"
-            },
-            {
-              "start": "2024-01-01",
-              "end": "2024-12-31",
-              "val": 2250163000,
-              "accn": "0001321655-26-000011",
-              "fy": 2025,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2026-02-17",
-              "frame": "CY2024"
-            },
-            {
-              "start": "2025-01-01",
-              "end": "2025-12-31",
-              "val": 2369612000,
-              "accn": "0001321655-26-000011",
-              "fy": 2025,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2026-02-17",
-              "frame": "CY2025"
-            },
-            {
-              "start": "2026-01-01",
-              "end": "2026-06-30",
-              "val": 2396861000,
-              "accn": "0001321655-26-000041",
-              "fy": 2026,
-              "fp": "Q2",
-              "form": "10-Q",
-              "filed": "2026-08-04"
-            },
-            {
-              "start": "2026-04-01",
-              "end": "2026-06-30",
-              "val": 2399820000,
-              "accn": "0001321655-26-000041",
-              "fy": 2026,
-              "fp": "Q2",
-              "form": "10-Q",
-              "filed": "2026-08-04",
-              "frame": "CY2026Q2"
-            }
-          ]
-        }
-      },
-      "WeightedAverageNumberOfDilutedSharesOutstanding": {
-        "units": {
-          "shares": [
-            {
-              "start": "2023-01-01",
-              "end": "2023-12-31",
-              "val": 2297927000,
-              "accn": "0001321655-24-000022",
-              "fy": 2023,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2024-02-20"
-            },
-            {
-              "start": "2023-01-01",
-              "end": "2023-12-31",
-              "val": 2297927000,
-              "accn": "0001321655-25-000022",
-              "fy": 2024,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2025-02-18"
-            },
-            {
-              "start": "2023-01-01",
-              "end": "2023-12-31",
-              "val": 2297927000,
-              "accn": "0001321655-26-000011",
-              "fy": 2025,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2026-02-17",
-              "frame": "CY2023"
-            },
-            {
-              "start": "2024-01-01",
-              "end": "2024-12-31",
-              "val": 2450818000,
-              "accn": "0001321655-25-000022",
-              "fy": 2024,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2025-02-18"
-            },
-            {
-              "start": "2024-01-01",
-              "end": "2024-12-31",
-              "val": 2450818000,
-              "accn": "0001321655-26-000011",
-              "fy": 2025,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2026-02-17",
-              "frame": "CY2024"
-            },
-            {
-              "start": "2025-01-01",
-              "end": "2025-12-31",
-              "val": 2565197000,
-              "accn": "0001321655-26-000011",
-              "fy": 2025,
-              "fp": "FY",
-              "form": "10-K",
-              "filed": "2026-02-17",
-              "frame": "CY2025"
-            },
-            {
-              "start": "2026-01-01",
-              "end": "2026-06-30",
-              "val": 2569826000,
-              "accn": "0001321655-26-000041",
-              "fy": 2026,
-              "fp": "Q2",
-              "form": "10-Q",
-              "filed": "2026-08-04"
-            },
-            {
-              "start": "2026-04-01",
-              "end": "2026-06-30",
-              "val": 2568694000,
-              "accn": "0001321655-26-000041",
-              "fy": 2026,
-              "fp": "Q2",
-              "form": "10-Q",
-              "filed": "2026-08-04",
-              "frame": "CY2026Q2"
-            }
-          ]
-        }
-      }
-    }
-  }
-}

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

@@ -1,66 +0,0 @@
-import { expect, test } from "bun:test";
-import pltrShares from "./sec-edgar-shares.fixture.json";
-import { parseCompanyFactsFinancialStatements } from "./sec-edgar";
-
-const fact = (overrides: Record<string, unknown> = {}) => ({
-  start: "2023-01-01", end: "2023-12-31", val: 100,
-  form: "10-K", filed: "2024-02-01", accn: "0000789019-24-000001", ...overrides,
-});
-
-test("SEC native projection retains filed weighted-average shares and separates quarter from YTD", () => {
-  // Untouched SEC companyfacts observations captured 2026-09-16.
-  const result = parseCompanyFactsFinancialStatements(pltrShares);
-  expect(result.annualStatements.map(({ date, basicShares, dilutedShares }) => ({ date, basicShares, dilutedShares }))).toEqual([
-    { date: "2023-12-31", basicShares: 2_147_446_000, dilutedShares: 2_297_927_000 },
-    { date: "2024-12-31", basicShares: 2_250_163_000, dilutedShares: 2_450_818_000 },
-    { date: "2025-12-31", basicShares: 2_369_612_000, dilutedShares: 2_565_197_000 },
-  ]);
-  expect(result.quarterlyStatements).toHaveLength(1);
-  expect(result.quarterlyStatements[0]).toMatchObject({ date: "2026-06-30", basicShares: 2_399_820_000, dilutedShares: 2_568_694_000 });
-  expect(result.annualStatements[1]?.fieldAvailability).toEqual({ basicShares: "2025-02-18", dilutedShares: "2025-02-18" });
-});
-
-  test("keeps real zero share counts, rejects unavailable/wrong-unit facts and selects dated revisions", () => {
-    const result = parseCompanyFactsFinancialStatements({ cik: 789019, facts: { "us-gaap": {
-      WeightedAverageNumberOfSharesOutstandingBasic: { units: { shares: [
-        fact({ val: 0 }),
-        fact({ val: 40, end: "2022-12-31", start: "2022-01-01" }),
-        fact({ val: 44, end: "2022-12-31", start: "2022-01-01", filed: "2025-02-01" }),
-        fact({ val: Number.NaN, end: "2021-12-31", start: "2021-01-01" }),
-        fact({ val: Number.POSITIVE_INFINITY, end: "2020-12-31", start: "2020-01-01" }),
-        fact({ val: null, end: "2019-12-31", start: "2019-01-01" }),
-      ] } },
-      WeightedAverageNumberOfDilutedSharesOutstanding: { units: { USD: [fact({ val: 99 })] } },
-    } } })
-    expect(result.annualStatements).toHaveLength(2)
-    expect(result.annualStatements[0]).toMatchObject({ date: "2022-12-31", basicShares: 44, fieldAvailability: { basicShares: "2025-02-01" } })
-    expect(result.annualStatements[1]?.basicShares).toBe(0)
-    expect(result.annualStatements[1]?.dilutedShares).toBeUndefined()
-  })
-
-  test("adds raw share counts only on a verified current split basis without scaling old denominators", () => {
-    const priorAccn = "0000320193-19-000119", splitAccn = "0000320193-20-000096"
-    const before = fact({ start: "2017-10-01", end: "2018-09-29", val: 8, filed: "2019-10-31", accn: priorAccn })
-    const after = { ...before, val: 2, filed: "2020-10-30", accn: splitAccn }
-    const older = { ...before, start: "2016-09-25", end: "2017-09-30", val: 4 }
-    const disconnected = { ...older, start: "2015-09-27", end: "2016-09-24", filed: "2016-10-31", accn: "0000320193-16-000001" }
-    const eps = [before, after, older, disconnected]
-    const result = parseCompanyFactsFinancialStatements({ cik: 320193, facts: { "us-gaap": {
-      EarningsPerShareDiluted: { units: { "USD/shares": eps } },
-      NetIncomeLoss: { units: { USD: eps.map((row) => ({ ...row, val: 40 })) } },
-      StockholdersEquityNoteStockSplitConversionRatio1: { units: { pure: [{ end: "2020-08-28", val: 4, accn: splitAccn, filed: "2020-10-30", form: "10-K" }] } },
-      WeightedAverageNumberOfDilutedSharesOutstanding: { units: { shares: eps.map((row) => ({ ...row, val: row.accn === splitAccn ? 20 : 5 })) } },
-      WeightedAverageNumberOfSharesOutstandingBasic: { units: { shares: eps.map((row) => ({ ...row, val: row.accn === splitAccn ? 16 : 4 })) } },
-    } } })
-    expect(result.annualStatements.find((row) => row.date === after.end)).toMatchObject({ eps: 2, basicShares: 16, dilutedShares: 20 })
-    const scaledEps = result.annualStatements.find((row) => row.date === older.end)!
-    expect(scaledEps.eps).toBe(1)
-    expect(scaledEps.basicShares).toBeUndefined()
-    expect(scaledEps.dilutedShares).toBeUndefined()
-    expect(scaledEps.fieldAvailability?.dilutedShares).toBeUndefined()
-    const unresolved = result.annualStatements.find((row) => row.date === disconnected.end)!
-    expect(unresolved.epsBasis?.status).toBe("unresolved")
-    expect(unresolved.basicShares).toBeUndefined()
-    expect(unresolved.dilutedShares).toBeUndefined()
-  })
-