gloomberb 0.15.2 → 0.15.3

package/src/plugins/builtin/shared/volatility/smile.test.ts

@@ -1,209 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { valueOption } from "../../options-calculator/model";
-import {
-  detectButterflyArbitrage, detectCalendarArbitrage, evaluateSmile,
-  fitVolatilitySmile, interpolateTotalVariance, sviTotalVariance,
-  type SmilePoint, type SviParameters,
-} from "./smile";
-
-const parameters: SviParameters = { a: 0.012, b: 0.08, rho: -0.55, m: 0.03, sigma: 0.12 };
-const years = 0.5;
-const knownSmile: SmilePoint[] = Array.from({ length: 17 }, (_, index) => {
-  const logMoneyness = -0.4 + index * 0.05;
-  return { logMoneyness, volatility: Math.sqrt(sviTotalVariance(parameters, logMoneyness) / years) };
-});
-
-describe("smile fitting", () => {
-  test("recovers a known skewed raw SVI smile and off-grid total variance", () => {
-    const original = structuredClone(knownSmile);
-    const fit = fitVolatilitySmile(knownSmile, years)!;
-    expect(fit.method).toBe("svi");
-    expect(fit.fallbackReason).toBeNull();
-    expect(fit.residual).toBeLessThan(1e-7);
-    for (const name of ["a", "b", "rho", "m", "sigma"] as const) {
-      expect(fit.parameters![name]).toBeCloseTo(parameters[name], 5);
-    }
-    for (const k of [-0.31, -0.015, 0.137, 0.29]) {
-      expect(evaluateSmile(fit, k)! ** 2 * years).toBeCloseTo(sviTotalVariance(parameters, k), 8);
-    }
-    expect(knownSmile).toEqual(original);
-  });
-
-  test("accepts valid negative a and positive skew without imposing arbitrage repair", () => {
-    const model: SviParameters = { a: -0.01, b: 0.2, rho: 0.4, m: -0.06, sigma: 0.15 };
-    const points = knownSmile.map(({ logMoneyness }) => ({
-      logMoneyness, volatility: Math.sqrt(sviTotalVariance(model, logMoneyness) / years),
-    }));
-    const fit = fitVolatilitySmile(points, years)!;
-    expect(fit.method).toBe("svi");
-    expect(fit.parameters!.a).toBeLessThan(0);
-    expect(fit.parameters!.rho).toBeGreaterThan(0);
-    expect(fit.residual).toBeLessThan(1e-7);
-  });
-
-  test("falls back on an exhausted optimizer or unacceptable SVI residual", () => {
-    const limited = fitVolatilitySmile(knownSmile, years, { maxIterations: 1 })!;
-    expect(limited.method).toBe("monotone-cubic");
-    expect(limited.fallbackReason).toContain("converge");
-    const jagged = knownSmile.map((point, index) => ({ ...point, volatility: point.volatility + (index % 2 ? 0.1 : 0) }));
-    const fit = fitVolatilitySmile(jagged, years, { maxResidual: 0.001 })!;
-    expect(fit.method).toBe("monotone-cubic");
-    expect(fit.fallbackReason).not.toBeNull();
-    expect(fit.residual).toBeLessThan(1e-12);
-    for (const point of jagged) expect(evaluateSmile(fit, point.logMoneyness)).toBeCloseTo(point.volatility, 12);
-  });
-
-  test("cubic fallback preserves monotonic intervals and extrema on uneven knots", () => {
-    const points = [
-      { logMoneyness: -0.6, volatility: 0.8 },
-      { logMoneyness: -0.02, volatility: 0.19 },
-      { logMoneyness: 0, volatility: 0.2 },
-      { logMoneyness: 0.8, volatility: 0.23 },
-    ];
-    const fit = fitVolatilitySmile(points, 0.1)!;
-    expect(fit.method).toBe("monotone-cubic");
-    for (let index = 1; index < points.length; index += 1) {
-      const left = points[index - 1]!;
-      const right = points[index]!;
-      let previous = left.volatility;
-      for (let step = 1; step <= 100; step += 1) {
-        const iv = evaluateSmile(fit, left.logMoneyness + (right.logMoneyness - left.logMoneyness) * step / 100)!;
-        expect(iv).toBeGreaterThanOrEqual(Math.min(left.volatility, right.volatility) - 1e-12);
-        expect(iv).toBeLessThanOrEqual(Math.max(left.volatility, right.volatility) + 1e-12);
-        expect((iv - previous) * Math.sign(right.volatility - left.volatility)).toBeGreaterThanOrEqual(-1e-12);
-        previous = iv;
-      }
-    }
-    expect(evaluateSmile(fit, -3)).toBe(0.8);
-    expect(evaluateSmile(fit, 3)).toBe(0.23);
-  });
-
-  test("rejects unusable data, reports dropped quotes and consolidates duplicate knots", () => {
-    expect(fitVolatilitySmile(knownSmile, 0)).toBeNull();
-    expect(fitVolatilitySmile(knownSmile, NaN)).toBeNull();
-    expect(fitVolatilitySmile([{ logMoneyness: 0, volatility: 0.2 }], years)).toBeNull();
-    const fit = fitVolatilitySmile([
-      { logMoneyness: 0.1, volatility: 0.4 },
-      { logMoneyness: 0, volatility: 0.2 },
-      { logMoneyness: 0, volatility: 0.4 },
-      { logMoneyness: NaN, volatility: 0.2 },
-      { logMoneyness: 0.2, volatility: -0.1 },
-      { logMoneyness: 0.3, volatility: Infinity },
-    ], years)!;
-    expect(fit.droppedPoints).toBe(3);
-    expect(fit.points).toHaveLength(2);
-    expect(evaluateSmile(fit, 0)).toBeCloseTo(Math.sqrt(0.1), 12);
-    expect(fit.residual).toBeGreaterThan(0);
-    expect(evaluateSmile(fit, NaN)).toBeNull();
-    const zero = fitVolatilitySmile([{ logMoneyness: 0, volatility: 0 }, { logMoneyness: 1, volatility: 0 }], years)!;
-    expect(evaluateSmile(zero, 0.5)).toBe(0);
-  });
-
-  test("rejects finite quotes whose total variance or cubic slopes overflow", () => {
-    const overflow = [{ logMoneyness: 0, volatility: 1e200 }, { logMoneyness: 1, volatility: 1e200 }];
-    expect(fitVolatilitySmile(overflow, years)).toBeNull();
-    const mixed = fitVolatilitySmile([...knownSmile, ...overflow], years)!;
-    expect(mixed.droppedPoints).toBe(2);
-    expect(mixed.residual).toBeFinite();
-    expect(fitVolatilitySmile([{ logMoneyness: 0, volatility: 1e154 }, { logMoneyness: 1e-8, volatility: 1e150 }], 1)).toBeNull();
-    expect(interpolateTotalVariance([{ years: 1, volatility: 1e200 }], 1)).toBeNull();
-    expect(interpolateTotalVariance([{ years: 1, volatility: 1e154 }], 10)).toBeNull();
-  });
-});
-
-describe("total variance interpolation", () => {
-  const tenors = [{ years: 0.25, volatility: 0.4 }, { years: 1, volatility: 0.2 }];
-
-  test("interpolates total variance rather than volatility and preserves exact tenors", () => {
-    const original = structuredClone(tenors);
-    const mid = interpolateTotalVariance(tenors.toReversed(), 0.5)!;
-    expect(mid.totalVariance).toBeCloseTo(0.04, 12);
-    expect(mid.volatility).toBeCloseTo(Math.sqrt(0.08), 12);
-    expect(mid.interpolated).toBe(true);
-    expect(mid.extrapolated).toBe(false);
-    expect(mid.sourceYears).toEqual([0.25, 1]);
-    expect(interpolateTotalVariance(tenors, 0.25)).toEqual({
-      years: 0.25, volatility: 0.4, totalVariance: 0.4 ** 2 * 0.25,
-      interpolated: false, extrapolated: false, sourceYears: [0.25, 0.25],
-    });
-    expect(tenors).toEqual(original);
-  });
-
-  test("uses explicitly marked flat IV extrapolation including expiry and a single tenor", () => {
-    for (const target of [0, 0.1, 1.5]) {
-      const result = interpolateTotalVariance(tenors, target)!;
-      const expectedVolatility = target < 0.25 ? 0.4 : 0.2;
-      expect(result.extrapolated).toBe(true);
-      expect(result.interpolated).toBe(false);
-      expect(result.volatility).toBe(expectedVolatility);
-      expect(result.totalVariance).toBeCloseTo(expectedVolatility ** 2 * target, 12);
-    }
-    expect(interpolateTotalVariance([tenors[0]!], 0.5)!.volatility).toBe(0.4);
-    expect(interpolateTotalVariance([], 1)).toBeNull();
-    expect(interpolateTotalVariance(tenors, -1)).toBeNull();
-    expect(interpolateTotalVariance(tenors, Infinity)).toBeNull();
-    expect(interpolateTotalVariance([{ years: NaN, volatility: 0.2 }], 1)).toBeNull();
-    expect(interpolateTotalVariance([{ years: 1, volatility: 0.2 }, { years: 1, volatility: 0.3 }], 1)).toBeNull();
-    expect(interpolateTotalVariance([{ years: 1, volatility: 0.2 }, { years: 1, volatility: 0.2 }], 2)!.volatility).toBe(0.2);
-  });
-});
-
-describe("arbitrage warnings", () => {
-  test("warns on decreasing variance, not decreasing IV, and never repairs calendar inputs", () => {
-    const valid = [{ years: 0.25, volatility: 0.4 }, { years: 1, volatility: 0.3 }];
-    expect(detectCalendarArbitrage(valid)).toEqual([]);
-    const bad = [{ years: 1, volatility: 0.1 }, { years: 0.25, volatility: 0.4 }];
-    const before = structuredClone(bad);
-    expect(detectCalendarArbitrage(bad)).toEqual([{
-      kind: "calendar", earlierYears: 0.25, laterYears: 1,
-      earlierVariance: 0.4 ** 2 * 0.25, laterVariance: 0.1 ** 2,
-    }]);
-    expect(bad).toEqual(before);
-    expect(interpolateTotalVariance(bad, 0.5)!.totalVariance).toBeCloseTo(0.03, 12);
-  });
-
-  test("uses convex strike slopes on irregular spacing without false flags on Black-Scholes calls", () => {
-    const strikes = [50, 80, 90, 95, 100, 102, 110, 130, 170];
-    const valid = strikes.map((strike) => ({ strike, callPrice: valueOption({
-      symbol: "", side: "call", spot: 100, strike, daysToExpiry: 180,
-      rate: 0.04, volatility: 0.25, dividendYield: 0.01, marketPrice: 0,
-    }).price }));
-    expect(detectButterflyArbitrage(valid.toReversed())).toEqual([]);
-    const irregular = [{ strike: 90, callPrice: 12 }, { strike: 100, callPrice: 7 }, { strike: 120, callPrice: 2 }];
-    expect(detectButterflyArbitrage(irregular)).toEqual([]);
-    const bad = [{ strike: 90, callPrice: 12 }, { strike: 100, callPrice: 11 }, { strike: 120, callPrice: 2 }];
-    const original = structuredClone(bad);
-    expect(detectButterflyArbitrage(bad)).toEqual([{
-      kind: "butterfly", strikes: [90, 100, 120], leftSlope: -0.1, rightSlope: -0.45,
-    }]);
-    expect(bad).toEqual(original);
-    expect(detectButterflyArbitrage(bad.slice(0, 2))).toEqual([]);
-  });
-
-  test("duplicate tenors cannot conceal a decreasing-variance pair", () => {
-    const points = [
-      { years: 0.25, volatility: 0.4 },
-      { years: 0.25, volatility: 0.1 },
-      { years: 1, volatility: 0.15 },
-    ];
-    const original = structuredClone(points);
-    const warnings = detectCalendarArbitrage(points);
-    expect(warnings).toHaveLength(1);
-    expect(warnings[0]!.earlierVariance).toBeCloseTo(0.04, 12);
-    expect(warnings[0]!.laterVariance).toBeCloseTo(0.0225, 12);
-    expect(detectCalendarArbitrage(points.toReversed())).toEqual(warnings);
-    expect(detectCalendarArbitrage(points.flatMap((point) => [point, point]))).toEqual(warnings);
-    expect(points).toEqual(original);
-  });
-
-  test("identical or conflicting duplicate strikes cannot conceal concavity", () => {
-    const points = [{ strike: 90, callPrice: 12 }, { strike: 100, callPrice: 11 }, { strike: 120, callPrice: 2 }];
-    const warnings = detectButterflyArbitrage(points);
-    expect(detectButterflyArbitrage([points[0]!, points[1]!, points[1]!, points[2]!])).toEqual(warnings);
-    const conflicting = [...points, { strike: 100, callPrice: 7 }, { strike: 90, callPrice: 13 }];
-    const original = structuredClone(conflicting);
-    expect(detectButterflyArbitrage(conflicting)).toEqual(warnings);
-    expect(detectButterflyArbitrage(conflicting.toReversed())).toEqual(warnings);
-    expect(conflicting).toEqual(original);
-  });
-});

package/src/plugins/builtin/short-interest/client.test.ts

@@ -1,55 +0,0 @@
-import { afterAll, afterEach, expect, spyOn, test } from "bun:test";
-import { YahooHttpClient } from "../../../sources/yahoo-finance/http";
-import { ApiRequestError } from "../../../api-client/errors";
-import { fetchShortInterest, loadShortInterest } from "./client";
-
-const yahoo = spyOn(YahooHttpClient.prototype, "fetchJsonWithCrumb");
-afterEach(() => yahoo.mockReset());
-afterAll(() => yahoo.mockRestore());
-const fallback = { getCloudShortInterest: async () => { throw new Error("Controlled history unavailable"); } };
-const record = (shares = 20_000_000, ratio = 2.3, percent?: number) => ({
-  quoteSummary: { result: [{ defaultKeyStatistics: {
-    dateShortInterest: "2026-08-31", sharesShort: { raw: shares }, shortRatio: { raw: ratio },
-    sharesShortPreviousMonthDate: "2026-08-14", sharesShortPriorMonth: { raw: 10_000_000 },
-    floatShares: { raw: 100_000_000 },
-    ...(percent === undefined ? {} : { shortPercentOfFloat: { raw: percent } }),
-  } }] },
-});
-
-test("fallback preserves reported settlement metrics without inventing dated denominators", async () => {
-  yahoo.mockResolvedValue(record(20_000_000, 2.3, .25));
-  const rows = await fetchShortInterest("TEST", fallback);
-  expect(rows.map(row => row.settlementDate.toISOString())).toEqual(["2026-08-14T00:00:00.000Z", "2026-08-31T00:00:00.000Z"]);
-  expect(rows[0]).toMatchObject({ sharesShort: 10_000_000, shortRatio: null, averageDailyVolume: null, shortPercentFloat: null });
-  expect(rows[1]).toMatchObject({ sharesShort: 20_000_000, shortRatio: 2.3, averageDailyVolume: null, shortPercentFloat: 25 });
-});
-
-test("missing percent stays unknown even when an undated float is supplied", async () => {
-  yahoo.mockResolvedValue(record());
-  const rows = await fetchShortInterest("TEST", fallback);
-  expect(rows.map(row => row.shortPercentFloat)).toEqual([null, null]);
-  expect(rows.map(row => row.averageDailyVolume)).toEqual([null, null]);
-});
-
-test("reported zero and percentages above 100 remain source data", async () => {
-  yahoo.mockResolvedValue(record(0, 0, 0));
-  expect((await fetchShortInterest("TEST", fallback))[1]).toMatchObject({ sharesShort: 0, shortRatio: 0, averageDailyVolume: null, shortPercentFloat: 0 });
-  yahoo.mockResolvedValue(record(150_000_000, 2, 1.5));
-  expect((await fetchShortInterest("TEST", fallback))[1]!.shortPercentFloat).toBe(150);
-});
-
-test("FINRA average daily volume remains independent of its reported days-to-cover ratio", async () => {
-  const rows = await fetchShortInterest("TEST", { getCloudShortInterest: async () => ({ status: "success", data: {
-    symbol: "TEST", issueName: null, points: [{ settlementDate: "2026-08-31", sharesShort: 20_000_000,
-      averageDailyVolume: 8_800_000, daysToCover: 2.3, previousSharesShort: null, changePercent: null, revised: false }],
-  } }) });
-  expect(rows[0]).toMatchObject({ averageDailyVolume: 8_800_000, shortRatio: 2.3, shortPercentFloat: null });
-  expect(yahoo).not.toHaveBeenCalled();
-});
-
-test("the Yahoo fallback reports its source and whether Cloud wanted a session", async () => {
-  yahoo.mockResolvedValue(record());
-  const denied = { getCloudShortInterest: async () => { throw new ApiRequestError("Unauthorized", 401); } };
-  expect(await loadShortInterest("TEST", denied)).toMatchObject({ source: "yahoo", cloudSessionRequired: true });
-  expect(await loadShortInterest("TEST", fallback)).toMatchObject({ source: "yahoo", cloudSessionRequired: false });
-});

package/src/plugins/builtin/short-interest/headless.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { CloudDataApi } from "../../../api-client/data";
-import type { CloudMarketResponse, CloudShortInterestPayload } from "../../../api-client/types";
-import { createTestDataProvider } from "../../../test-support/data-provider";
-import { createDefaultConfig } from "../../../types/config";
-import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
-import { fetchShortInterest } from "./client";
-import { createShortInterestHeadless } from "./headless";
-
-const records = [
-  {
-    settlementDate: new Date("2026-08-15T00:00:00.000Z"),
-    sharesShort: 12_000_000,
-    shortRatio: 2.5,
-    averageDailyVolume: 4_800_000,
-    shortPercentFloat: 3.2,
-  },
-  {
-    settlementDate: new Date("2026-08-31T00:00:00.000Z"),
-    sharesShort: 15_000_000,
-    shortRatio: 3,
-    averageDailyVolume: 5_000_000,
-    shortPercentFloat: 4.1,
-  },
-];
-
-function context(): HeadlessPaneContext {
-  return {
-    marketData: createTestDataProvider(),
-    apiClient: {} as HeadlessPaneContext["apiClient"],
-    config: createDefaultConfig("/tmp/gloomberb-headless-short-interest"),
-    signal: new AbortController().signal,
-  };
-}
-
-function args(overrides: Partial<HeadlessPaneLoadArgs["options"]> = {}): HeadlessPaneLoadArgs {
-  return {
-    rawArgument: "AMD",
-    argument: "AMD",
-    symbols: ["AMD"],
-    options: { order: "newest", limit: 24, ...overrides },
-  };
-}
-
-describe("short interest client", () => {
-  test("uses the served market route for FINRA history", async () => {
-    const paths: string[] = [];
-    const dataApi = new CloudDataApi(async <T>(path: string): Promise<T> => {
-      paths.push(path);
-      return {
-        status: "success",
-        data: {
-          symbol: "AAPL",
-          issueName: "Apple Inc.",
-          points: [{
-            settlementDate: "2026-08-31",
-            sharesShort: 15_000_000,
-            previousSharesShort: 12_000_000,
-            averageDailyVolume: 5_000_000,
-            daysToCover: 3,
-            changePercent: 25,
-            revised: false,
-          }],
-        },
-      } as CloudMarketResponse<CloudShortInterestPayload> as T;
-    });
-
-    const result = await fetchShortInterest("aapl", dataApi);
-
-    expect(paths).toEqual(["/market/short-interest?symbol=AAPL"]);
-    expect(result[0]).toMatchObject({ sharesShort: 15_000_000, shortRatio: 3 });
-  });
-});
-
-describe("short interest headless model", () => {
-  test("projects raw settlement values and applies order and limit", async () => {
-    const headless = createShortInterestHeadless({
-      loadRecords: async () => records,
-    });
-
-    const newest = await headless.load(args({ limit: 1 }), context());
-    expect(newest.rows).toEqual([{
-      settlementDate: "2026-08-31",
-      sharesShort: 15_000_000,
-      daysToCover: 3,
-      averageDailyVolume: 5_000_000,
-      shortPercentFloat: 4.1,
-    }]);
-
-    const oldest = await headless.load(args({ order: "oldest", limit: 1 }), context());
-    expect(oldest.rows[0]).toMatchObject({
-      settlementDate: "2026-08-15",
-      sharesShort: 12_000_000,
-    });
-  });
-});

package/src/plugins/builtin/short-interest/pane.test.tsx

@@ -1,57 +0,0 @@
-import { afterEach, expect, spyOn, test } from "bun:test";
-import { act, useState } from "react";
-import { apiClient } from "../../../api-client";
-import { YahooHttpClient } from "../../../sources/yahoo-finance/http";
-import { testRender, settleFrame, emitKeypress, takeSavedTextFile } from "../../../renderers/opentui/test-utils";
-import { TestPaneProvider, createTestPaneConfig, createTestTicker } from "../../../test-support/pane";
-import { createInitialState } from "../../../state/app/context";
-import { exportPaneTable } from "../../../state/pane-table-export-registry";
-import { ShortInterestView } from "./pane";
-
-let setup: Awaited<ReturnType<typeof testRender>> | undefined;
-let restore: (() => void) | undefined;
-afterEach(async () => {
-  if (setup) await act(async () => setup!.renderer.destroy()); setup = undefined;
-  restore?.(); restore = undefined;
-});
-
-test("reported percentages fit at normal width and dated rows remain usable through narrow scroll and refresh", async () => {
-  let updated = false;
-  const cloud = spyOn(apiClient, "getCloudShortInterest").mockRejectedValue(new Error("Controlled history unavailable"));
-  const yahoo = spyOn(YahooHttpClient.prototype, "fetchJsonWithCrumb").mockImplementation(async () => ({ quoteSummary: { result: [{ defaultKeyStatistics: {
-    dateShortInterest: updated ? "2026-09-15" : "2026-08-31", sharesShort: { raw: 20_000_000 },
-    sharesShortPreviousMonthDate: "2026-08-14", sharesShortPriorMonth: { raw: 10_000_000 },
-    shortRatio: { raw: 2.3 }, shortPercentOfFloat: { raw: .25 }, floatShares: { raw: 100_000_000 },
-  } }] } }));
-  restore = () => { cloud.mockRestore(); yahoo.mockRestore(); };
-  const config = createTestPaneConfig("/tmp/short-interest-test-unused", { instanceId: "si", paneId: "short-interest" });
-  const state = createInitialState(config); state.focusedPaneId = "si";
-  state.paneState.si = { cursorSymbol: "TEST" }; state.tickers.set("TEST", createTestTicker("TEST", "Controlled issuer", { assetCategory: "STK" }));
-  let resize: (value: number) => void = () => {};
-  function Harness() {
-    const [width, setWidth] = useState(100); resize = setWidth;
-    return <TestPaneProvider state={state} paneId="si" pluginId="ticker-research" runtime={{}}>
-      <ShortInterestView focused width={width} height={23} />
-    </TestPaneProvider>;
-  }
-  await act(async () => { setup = await testRender(<Harness />, { width: 100, height: 23 }); });
-  await settleFrame(setup!, 10);
-  expect(setup!.captureCharFrame()).toContain("% FLOAT");
-  expect(setup!.captureCharFrame()).toContain("25.00%");
-  await exportPaneTable("si", "full.csv"); const full = takeSavedTextFile()!.text;
-  expect(full).toContain("2026-08-31,20M,2.30,'-,25.00%");
-  await act(async () => { resize(48); setup!.resize(48, 23); });
-  await settleFrame(setup!, 6);
-  for (let i = 0; i < 4; i++) await emitKeypress(setup!, { name: "right", ctrl: true });
-  await settleFrame(setup!, 6);
-  expect(setup!.captureCharFrame()).toContain("2026-08-31");
-  expect(setup!.captureCharFrame()).toContain("2026-08-14");
-  expect(setup!.captureCharFrame()).toContain("25.00%");
-  await exportPaneTable("si", "narrow.csv"); expect(takeSavedTextFile()!.text).toBe(full);
-  updated = true;
-  await emitKeypress(setup!, { name: "r" }); await settleFrame(setup!, 10);
-  expect(setup!.captureCharFrame()).toContain("2026-09-15");
-  expect(yahoo).toHaveBeenCalledTimes(2);
-  await emitKeypress(setup!, { name: "r", ctrl: true }); await settleFrame(setup!, 6);
-  expect(yahoo).toHaveBeenCalledTimes(2);
-});

package/src/plugins/builtin/short-volume/model.test.ts

@@ -1,39 +0,0 @@
-import { expect, test } from "bun:test";
-import { ApiRequestError } from "../../../api-client/errors";
-import type { ShortVolumeObservation, ShortVolumePayload } from "../../../api-client/short-volume";
-import { fetchShortVolume, validateShortVolume } from "./client";
-import { exactQuantity, sortedVolumeHistory, volumeHistoryPoints } from "./model";
-
-function fixture(): ShortVolumePayload {
-  const row: ShortVolumeObservation = { date: "2026-09-21", shortVolume: "50.000001", shortExemptVolume: "0.000001", totalVolume: "100.000001",
-    ratioPercent: 50.00000049, markets: ["B", "Q", "N"], fetchedAt: "2026-09-22T00:00:00Z", sourceUrl: "https://cdn.finra.org/equity/regsho/daily/CNMSshvol20260921.txt", refreshFailed: false, unavailableReason: null };
-  return { version: 1, symbol: "AAPL", finraSymbol: "AAPL", scope: "nms", status: "partial", fetchedAt: "2026-09-22T00:00:00Z", asOf: row.date, sourceAsOf: row.date,
-    source: { name: "FINRA", url: row.sourceUrl, cadence: "Daily" }, history: [row], latest: { ...row, changePp: null, previousDate: null,
-      percentile: { value: null, rank: .5, sampleCount: 1, windowStart: "2025-09-21", windowEnd: row.date, historyStart: row.date, historyEnd: row.date, completeWindow: false, min: row.ratioPercent, max: row.ratioPercent, mean: row.ratioPercent } },
-    coverage: { windowStart: "2025-09-21", windowEnd: row.date, expectedFiles: 1, ingestedFiles: 1, missingFiles: 0, expectedMonths: 13, discoveredMonths: 1, completeWindow: false }, warnings: ["Limited history"] };
-}
-test("Cloud boundary preserves six-decimal shares and rejects ratio, precision and source identity corruption", () => {
-  const data=validateShortVolume(fixture(),"AAPL","nms");
-  expect(data.latest?.shortVolume).toBe("50.000001");
-  expect(exactQuantity("1234567890.000001")).toBe("1,234,567,890.000001");
-  const invalid=fixture(); invalid.history[0]!.shortVolume="50.0000001";
-  expect(()=>validateShortVolume(invalid,"AAPL","nms")).toThrow();
-  const ratio=fixture(); ratio.history[0]!.ratioPercent=55;
-  expect(()=>validateShortVolume(ratio,"AAPL","nms")).toThrow();
-  expect(()=>validateShortVolume(fixture(),"ABRpD","nms")).toThrow();
-  expect(()=>validateShortVolume(fixture(),"AAPL","otc")).toThrow();
-});
-test("missing files stay chart gaps and decimal share sorting does not round microshares", () => {
-  const data=fixture();
-  data.history=[{...data.history[0]!, date:"2026-07-01", shortVolume:"9007199254.000002"},{...data.history[0]!,shortVolume:"9007199254.000001"}];
-  expect(sortedVolumeHistory(data,{column:"shortVolume",direction:"desc"}).map(row=>row.date)).toEqual(["2026-07-01","2026-09-21"]);
-  expect(volumeHistoryPoints(data).map(row=>row.value)).toEqual([50.00000049,null,50.00000049]);
-  const pending=fixture(); pending.history[0]={...pending.history[0]!,shortVolume:null,shortExemptVolume:null,totalVolume:null,ratioPercent:null,fetchedAt:null,unavailableReason:"missing_file"};
-  pending.latest=null;pending.asOf=null;pending.status="unavailable";pending.coverage.ingestedFiles=0;pending.coverage.missingFiles=1;
-  expect(validateShortVolume(pending,"AAPL","nms").history[0]!.ratioPercent).toBeNull();
-});
-test("missing endpoint is recoverable while authorization failures remain distinct", async()=>{
-  await expect(fetchShortVolume("AAPL","nms",{getCloudShortVolume:async()=>{throw new ApiRequestError("missing",404);}})).rejects.toThrow("not available on this Gloom Cloud server yet");
-  const denied=new ApiRequestError("Forbidden",403);
-  await expect(fetchShortVolume("AAPL","nms",{getCloudShortVolume:async()=>{throw denied;}})).rejects.toBe(denied);
-});

package/src/plugins/builtin/thirteenf/api.test.ts

@@ -1,149 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { MemoryPluginPersistence } from "../../../test-support/plugin-persistence";
-import { setHttpFetchTransport } from "../../../utils/http-transport";
-import {
-  attachThirteenFApiPersistence,
-  lookupThirteenFTickers,
-  mapForm,
-  resetThirteenFApiPersistence,
-  searchThirteenFFunds,
-} from "./api";
-import { buildPeriodReports } from "./model";
-
-afterEach(() => {
-  setHttpFetchTransport(null);
-  resetThirteenFApiPersistence();
-});
-
-describe("13F API", () => {
-  test("preserves amendment semantics when the source provides only the supported form_type alias", () => {
-    const base = {
-      cik: "1067983", period_of_report: "2026-06-30", accession_number: "original",
-      filed_as_of_date: "2026-08-14", form_type: "13F-HR", table_value_total: 100, table_entry_total: 1,
-    };
-    const original = mapForm(base)!;
-    const addition = mapForm({
-      ...base, accession_number: "addition", filed_as_of_date: "2026-08-20", form_type: "13F-HR/A",
-      amendment_type: "NEW HOLDINGS", table_value_total: 50,
-    })!;
-    expect(original.isAmendment).toBe(false);
-    expect(addition).toMatchObject({ submissionType: "13F-HR/A", isAmendment: true });
-    expect(buildPeriodReports([original, addition])[0]).toMatchObject({ complete: true, tableValueTotal: 150, tableEntryTotal: 2 });
-    const unknown = mapForm({ ...base, accession_number: "unknown", form_type: "13F-HR/A" })!;
-    expect(buildPeriodReports([unknown])[0]).toMatchObject({ complete: false, tableValueTotal: null });
-  });
-
-  test("uses the shared HTTP transport", async () => {
-    const urls: string[] = [];
-    setHttpFetchTransport(async (url) => {
-      urls.push(String(url));
-      return new Response(JSON.stringify([{ cik: "1067983", name: "BERKSHIRE HATHAWAY INC" }]), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    });
-
-    const funds = await searchThirteenFFunds("transport-smoke", 1);
-
-    expect(urls[0]).toContain("/cloud/sec/13f/funds");
-    expect(funds).toEqual([{ cik: "0001067983", name: "BERKSHIRE HATHAWAY INC" }]);
-  });
-
-  test("caches successful API responses by request URL", async () => {
-    attachThirteenFApiPersistence(new MemoryPluginPersistence());
-    let requestCount = 0;
-    setHttpFetchTransport(async () => {
-      requestCount += 1;
-      return new Response(JSON.stringify([{ cik: "1364742", name: "BlackRock Inc." }]), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    });
-
-    await searchThirteenFFunds("cache-smoke", 1);
-    await searchThirteenFFunds("cache-smoke", 1);
-
-    expect(requestCount).toBe(1);
-  });
-
-  test("treats nullable ticker lookup responses as empty results", async () => {
-    setHttpFetchTransport(async () => new Response("null", {
-      status: 200,
-      headers: { "Content-Type": "application/json" },
-    }));
-
-    await expect(lookupThirteenFTickers(["BAKER"])).resolves.toEqual([]);
-  });
-});
-
-test("a failed forced refresh retains the original retrieval date only for consumers that disclose it, and reopening retries", async () => {
-  const store = new MemoryPluginPersistence();
-  attachThirteenFApiPersistence(store);
-  let unavailable = false;
-  let calls = 0;
-  setHttpFetchTransport(async () => {
-    calls++;
-    return unavailable ? new Response("Unavailable", { status: 503 })
-      : Response.json([{ cik: "1067983", name: "Berkshire Hathaway" }]);
-  });
-  const expected = await searchThirteenFFunds("Berkshire", 1);
-  const key = "/funds?name=Berkshire&offset=0&limit=1";
-  const original = store.getResource("forms13f-api", key, { sourceKey: "forms13f" })!;
-  expect(original).not.toBeNull();
-  unavailable = true;
-  const warnings: string[] = [];
-  expect(await searchThirteenFFunds("Berkshire", 1, undefined, {
-    forceRefresh: true, onWarning: warning => warnings.push(warning),
-  })).toEqual(expected);
-  expect(warnings).toHaveLength(1);
-  expect(warnings[0]).toContain(new Date(original.fetchedAt).toISOString());
-  expect(warnings[0]).toContain("503");
-  expect(store.getResource("forms13f-api", key, { sourceKey: "forms13f" })).toEqual(original);
-  await expect(searchThirteenFFunds("Berkshire", 1)).rejects.toThrow("503");
-  unavailable = false;
-  const callsBeforeRecovery = calls;
-  expect(await searchThirteenFFunds("Berkshire", 1)).toEqual(expected);
-  expect(calls).toBe(callsBeforeRecovery + 1);
-  await searchThirteenFFunds("Berkshire", 1);
-  expect(calls).toBe(callsBeforeRecovery + 1);
-});
-
-test("stale but unexpired research refreshes, and a late request cannot overwrite newer cache", async () => {
-  const store = new MemoryPluginPersistence();
-  attachThirteenFApiPersistence(store);
-  const key = "/funds?name=Berkshire&offset=0&limit=1";
-  store.seedResource("forms13f-api", key, [{ cik: "1067983", name: "Old name" }], {
-    sourceKey: "forms13f", schemaVersion: 1, stale: true,
-  });
-  let release!: (response: Response) => void;
-  let calls = 0;
-  setHttpFetchTransport(async () => {
-    if (++calls === 1) return new Promise<Response>(resolve => { release = resolve; });
-    return Response.json([{ cik: "1067983", name: "Current name" }]);
-  });
-  const older = searchThirteenFFunds("Berkshire", 1);
-  for (let i = 0; i < 5 && !release; i++) await Promise.resolve();
-  await searchThirteenFFunds("Berkshire", 1, undefined, { forceRefresh: true });
-  release(Response.json([{ cik: "1067983", name: "Superseded name" }]));
-  await older;
-  expect(await searchThirteenFFunds("Berkshire", 1)).toEqual([{ cik: "0001067983", name: "Current name" }]);
-  expect(calls).toBe(2);
-});
-
-for (const status of [403, 404]) test(`authoritative public ${status} cannot retain a removed 13F response`, async () => {
-  const store = new MemoryPluginPersistence();
-  attachThirteenFApiPersistence(store);
-  let denied = false;
-  setHttpFetchTransport(async () => denied ? new Response("Removed", { status })
-    : Response.json([{ cik: "1067983", name: "Berkshire Hathaway" }]));
-  await searchThirteenFFunds("Berkshire", 1);
-  denied = true;
-  const warnings: string[] = [];
-  await expect(searchThirteenFFunds("Berkshire", 1, undefined, {
-    forceRefresh: true, onWarning: warning => warnings.push(warning),
-  })).rejects.toThrow(String(status));
-  expect(warnings).toEqual([]);
-  expect(store.getResource("forms13f-api", "/funds?name=Berkshire&offset=0&limit=1", {
-    sourceKey: "forms13f", allowExpired: true,
-  })).toBeNull();
-});