gloomberb 0.12.0 → 0.13.2

package/src/time-series/resolve.ts

@@ -384,10 +384,16 @@ export function seedChartResolutionResult(
     if (resolved?.points.length) series.push(resolved);
   });
   if (series.length === 0) return null;
+  // Studies ride along with the seed. Without them the chart briefly drops to
+  // base series alone whenever it falls back here, and every panel a study
+  // owns loses its rows until the first real resolve lands.
+  const seeded = spec.studies.length > 0
+    ? [...series, ...resolveStudies(series, spec.studies).series]
+    : series;
   return {
-    series,
-    legendSeries: series,
-    bufferedSeries: series,
+    series: seeded,
+    legendSeries: seeded,
+    bufferedSeries: seeded,
     loading: false,
     errors: [],
     warnings: [],
@@ -805,13 +811,6 @@ function prepareBaseSeriesForStudies(
   );
 }
 
-function rawCalculationSeries(series: ResolvedSeries, bounds: DateBounds): ResolvedSeries {
-  if (bounds.start !== null && bounds.end !== null) {
-    return clipSeriesToWindow(series, new Date(bounds.start), new Date(bounds.end));
-  }
-  return { ...series, points: filterPoints(series.points, bounds) };
-}
-
 function scalarBaseline(series: ResolvedSeries, bounds: DateBounds): number | null {
   const points = filterPoints(series.points, bounds);
   for (const point of points) {
@@ -1148,15 +1147,14 @@ export async function resolveChartSpecData(
     ? requestVisibleBounds
     : followLatestMarketObservation(initialVisibleBounds, rawSeries);
   const resolution = initialResolution;
-  const studyBounds = bounds.end !== null
-      && initialCalculationBounds.end !== null
-      && bounds.end > initialCalculationBounds.end
-    ? { ...initialCalculationBounds, end: bounds.end }
-    : initialCalculationBounds;
   const baseSeries = rawSeries
     .filter((entry) => visibleSeriesIds.has(entry.id))
     .map((entry) => prepareBaseSeriesForStudies(entry, bounds, false, requestVisibleBounds));
-  const calculationSeries = rawSeries.map((entry) => rawCalculationSeries(entry, studyBounds));
+  // Studies run over the same loaded history their base series carries. Clipping
+  // them to the requested window instead left a study with no observations
+  // wherever the accumulated buffer had already been panned past, so a study's
+  // panel emptied out mid-pan and only refilled once the next fetch landed.
+  const calculationSeries = rawSeries;
   let resolved = baseSeries;
 
   // Study outputs are appended by the pure engine before the final viewport clip.

package/src/types/config.ts

@@ -120,6 +120,8 @@ export type OnboardingStage =
   | "welcome"
   | "portfolio"
   | "add-ticker"
+  | "research"
+  | "verify"
   | "account"
   | "upgrade"
   | "ready";

package/src/plugins/broker-sync/broker-sync.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildBrokerProfileConfig, validateBrokerProfileValues } from "../../brokers/profile-form";
-import { normalizeRobinhoodSnapshot, normalizeSimpleFinSnapshot } from "./normalize";
-import { loadPublicPortfolio } from "./public";
-import { requireRobinhoodPositionTools } from "./robinhood-native";
-import { decodeSimpleFinSetupToken } from "./simplefin-native";
-import { simpleFinBroker } from "./simplefin";
-
-describe("broker position normalization", () => {
-  test("normalizes nested Robinhood accounts and positions without duplicate records", () => {
-    const snapshot = normalizeRobinhoodSnapshot(
-      { accounts: [{ account_number: "RH-1", account_type: "ROTH_IRA", currency: "USD" }] },
-      [{ result: { positions: [{
-        accountNumber: "RH-1",
-        instrument: { symbol: "hood", name: "Robinhood Markets" },
-        quantity: "2.5",
-        total_cost: "100",
-        market_value: "125",
-      }] } }],
-    );
-
-    expect(snapshot.accounts).toEqual([expect.objectContaining({
-      accountId: "RH-1",
-      name: "Roth Ira",
-    })]);
-    expect(snapshot.positions).toEqual([expect.objectContaining({
-      accountId: "RH-1",
-      ticker: "HOOD",
-      shares: 2.5,
-      avgCost: 40,
-      markPrice: 50,
-      marketValue: 125,
-    })]);
-  });
-
-  test("normalizes only SimpleFIN accounts that contain investment holdings", () => {
-    const snapshot = normalizeSimpleFinSnapshot({ accounts: [
-      { id: "cash", conn_id: "bank", name: "Checking", currency: "USD", holdings: [] },
-      {
-        id: "invest",
-        conn_id: "broker",
-        name: "Roth IRA",
-        currency: "USD",
-        balance: "750",
-        holdings: [{ symbol: "VTI", shares: "3", cost_basis: "600", market_value: "750" }],
-      },
-    ] });
-
-    expect(snapshot.accounts).toHaveLength(1);
-    expect(snapshot.accounts[0]?.accountId).toBe("broker:invest");
-    expect(snapshot.positions[0]).toEqual(expect.objectContaining({
-      ticker: "VTI",
-      shares: 3,
-      avgCost: 200,
-      markPrice: 250,
-    }));
-  });
-
-  test("stores shorts as absolute shares and weighted-averages merged short lots", () => {
-    const snapshot = normalizeRobinhoodSnapshot(
-      { accounts: [{ account_number: "RH-1", account_type: "INDIVIDUAL" }] },
-      [{ result: { positions: [
-        {
-          accountNumber: "RH-1",
-          instrument: { symbol: "TSLA" },
-          quantity: "-10",
-          average_cost: "100",
-          market_value: "-800",
-        },
-        {
-          accountNumber: "RH-1",
-          instrument: { symbol: "TSLA" },
-          quantity: "-5",
-          average_cost: "110",
-          market_value: "-400",
-        },
-      ] } }],
-    );
-
-    expect(snapshot.positions).toEqual([expect.objectContaining({
-      ticker: "TSLA",
-      shares: 15,
-      avgCost: 1550 / 15,
-      side: "short",
-    })]);
-  });
-});
-
-describe("broker authentication boundaries", () => {
-  test("Public sync uses one token request and read-only portfolio requests", async () => {
-    const calls: Array<{ url: string; method: string }> = [];
-    const fetchImpl = (async (input: string | URL | Request, init?: RequestInit) => {
-      const url = String(input);
-      calls.push({ url, method: init?.method ?? "GET" });
-      if (url.endsWith("/personal/access-tokens")) {
-        return Response.json({ accessToken: "temporary-token" });
-      }
-      if (url.endsWith("/trading/account")) {
-        return Response.json({ accounts: [{ accountId: "PUB-1", accountType: "BROKERAGE" }] });
-      }
-      return Response.json({
-        accountId: "PUB-1",
-        accountType: "BROKERAGE",
-        totalAccountValue: "110",
-        buyingPower: { buyingPower: "10" },
-        positions: [{
-          instrument: { symbol: "AAPL", name: "Apple", type: "EQUITY" },
-          quantity: "1",
-          currentValue: "100",
-          lastPrice: { lastPrice: "100" },
-          costBasis: { unitCost: "80", gainValue: "20" },
-        }],
-      });
-    }) as typeof fetch;
-
-    const snapshot = await loadPublicPortfolio("public-secret", fetchImpl);
-
-    expect(calls.map(({ method }) => method)).toEqual(["POST", "GET", "GET"]);
-    expect(calls.every(({ url }) => url.startsWith("https://api.public.com/"))).toBe(true);
-    expect(snapshot.positions[0]).toEqual(expect.objectContaining({
-      ticker: "AAPL",
-      assetCategory: "STK",
-      avgCost: 80,
-    }));
-  });
-
-  test("Robinhood accepts only the two position-sync tools", () => {
-    const selected = requireRobinhoodPositionTools([
-      { name: "get_accounts", annotations: { readOnlyHint: true } },
-      { name: "get_equity_positions", annotations: { readOnlyHint: true } },
-      { name: "place_equity_order", annotations: { readOnlyHint: false } },
-    ]);
-    expect([...selected.keys()]).toEqual(["get_accounts", "get_equity_positions"]);
-    expect(() => requireRobinhoodPositionTools([
-      { name: "get_accounts", annotations: { readOnlyHint: true } },
-      { name: "get_equity_positions", annotations: { readOnlyHint: false } },
-    ])).toThrow("read-only get_equity_positions");
-  });
-
-  test("aggregates identical same-account lots instead of keeping only the last row", () => {
-    const snapshot = normalizeRobinhoodSnapshot(
-      { accounts: [{ account_number: "RH-1", currency: "USD" }] },
-      { positions: [
-        {
-          accountNumber: "RH-1",
-          instrument: { symbol: "HOOD" },
-          quantity: "2",
-          total_cost: "80",
-          market_value: "100",
-        },
-        {
-          accountNumber: "RH-1",
-          instrument: { symbol: "HOOD" },
-          quantity: "3",
-          total_cost: "150",
-          market_value: "150",
-        },
-      ] },
-    );
-
-    expect(snapshot.positions).toEqual([expect.objectContaining({
-      ticker: "HOOD",
-      shares: 5,
-      avgCost: 46,
-      marketValue: 250,
-    })]);
-  });
-
-  test("SimpleFIN accepts URL-safe setup tokens and rejects non-HTTPS claims", () => {
-    const claimUrl = "https://bridge.simplefin.org/simplefin/claim/demo";
-    const token = Buffer.from(claimUrl).toString("base64url");
-    expect(decodeSimpleFinSetupToken(token)).toBe(claimUrl);
-    expect(() => decodeSimpleFinSetupToken(Buffer.from("http://localhost/claim").toString("base64")))
-      .toThrow("not valid");
-  });
-
-  test("SimpleFIN keeps a claimed access URL when a user edits the profile", () => {
-    const previous = {
-      id: "simplefin-main",
-      brokerType: "simplefin",
-      label: "SimpleFIN",
-      enabled: true,
-      config: { setupToken: "", accessUrl: "https://user:password@example.com/simplefin" },
-    };
-    expect(validateBrokerProfileValues(simpleFinBroker, { setupToken: "" }, previous)).toBeNull();
-    expect(buildBrokerProfileConfig(simpleFinBroker, { setupToken: "" }, previous)).toEqual(previous.config);
-  });
-});

package/src/plugins/broker-sync/native-loader.ts

@@ -1,10 +0,0 @@
-export type RobinhoodNativeModule = typeof import("./robinhood-native");
-export type SimpleFinNativeModule = typeof import("./simplefin-native");
-
-export function loadRobinhoodNativeModule(): Promise<RobinhoodNativeModule> {
-  return import("./robinhood-native");
-}
-
-export function loadSimpleFinNativeModule(): Promise<SimpleFinNativeModule> {
-  return import("./simplefin-native");
-}

package/src/plugins/broker-sync/normalize.ts

@@ -1,308 +0,0 @@
-import type { BrokerPosition } from "../../types/broker";
-import type { BrokerAccount } from "../../types/trading";
-
-export interface BrokerPortfolioSnapshot {
-  accounts: BrokerAccount[];
-  positions: BrokerPosition[];
-}
-
-type UnknownRecord = Record<string, unknown>;
-
-function record(value: unknown): UnknownRecord | null {
-  return value !== null && typeof value === "object" && !Array.isArray(value)
-    ? value as UnknownRecord
-    : null;
-}
-
-function text(...values: unknown[]): string {
-  for (const value of values) {
-    if (typeof value === "string" && value.trim()) return value.trim();
-    if (typeof value === "number" && Number.isFinite(value)) return String(value);
-  }
-  return "";
-}
-
-function numberValue(...values: unknown[]): number | undefined {
-  for (const value of values) {
-    const parsed = typeof value === "number"
-      ? value
-      : typeof value === "string"
-        ? Number(value.replaceAll(",", ""))
-        : Number.NaN;
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-function nested(source: UnknownRecord, key: string): UnknownRecord {
-  return record(source[key]) ?? {};
-}
-
-function allRecords(value: unknown, output: UnknownRecord[] = [], seen = new Set<object>()): UnknownRecord[] {
-  if (value === null || typeof value !== "object" || seen.has(value)) return output;
-  seen.add(value);
-  if (Array.isArray(value)) {
-    for (const item of value) allRecords(item, output, seen);
-    return output;
-  }
-  const item = value as UnknownRecord;
-  output.push(item);
-  for (const child of Object.values(item)) allRecords(child, output, seen);
-  return output;
-}
-
-function accountId(source: UnknownRecord): string {
-  return text(
-    source.accountId,
-    source.account_id,
-    source.accountNumber,
-    source.account_number,
-    source.brokerageAccountId,
-    source.brokerage_account_id,
-  );
-}
-
-function titleCase(value: string): string {
-  return value.toLowerCase().replace(/(^|[_\s-])([a-z])/g, (_match, prefix: string, letter: string) => (
-    `${prefix === "_" ? " " : prefix}${letter.toUpperCase()}`
-  ));
-}
-
-function uniqueSnapshot(accounts: BrokerAccount[], positions: BrokerPosition[]): BrokerPortfolioSnapshot {
-  const uniqueAccounts = [...new Map(accounts.map((account) => [account.accountId, account])).values()];
-  const knownAccounts = new Set(uniqueAccounts.map((account) => account.accountId));
-  for (const position of positions) {
-    if (!position.accountId || knownAccounts.has(position.accountId)) continue;
-    knownAccounts.add(position.accountId);
-    uniqueAccounts.push({
-      accountId: position.accountId,
-      name: position.accountId,
-      currency: position.currency,
-    });
-  }
-  return { accounts: uniqueAccounts, positions: mergeIdenticalPositions(positions.map(withCanonicalShares)) };
-}
-
-function withCanonicalShares(position: BrokerPosition): BrokerPosition {
-  const side = position.side ?? (position.shares < 0 ? "short" : "long");
-  const shares = Math.abs(position.shares);
-  if (shares === position.shares && side === position.side) return position;
-  return { ...position, shares, side };
-}
-
-function mergeIdenticalPositions(positions: BrokerPosition[]): BrokerPosition[] {
-  const merged = new Map<string, BrokerPosition>();
-  for (const position of positions) {
-    const key = [
-      position.accountId ?? "",
-      position.ticker,
-      position.assetCategory ?? "",
-      position.exchange ?? "",
-      position.brokerContract?.conId ?? "",
-    ].join(":");
-    const existing = merged.get(key);
-    if (!existing) {
-      merged.set(key, position);
-      continue;
-    }
-    const shares = existing.shares + position.shares;
-    const existingCost = (existing.avgCost ?? 0) * existing.shares;
-    const nextCost = (position.avgCost ?? 0) * position.shares;
-    merged.set(key, {
-      ...existing,
-      shares,
-      avgCost: shares !== 0 ? (existingCost + nextCost) / shares : existing.avgCost,
-      marketValue: sumOptional(existing.marketValue, position.marketValue),
-      unrealizedPnl: sumOptional(existing.unrealizedPnl, position.unrealizedPnl),
-    });
-  }
-  return [...merged.values()];
-}
-
-function sumOptional(left?: number, right?: number): number | undefined {
-  if (left == null && right == null) return undefined;
-  return (left ?? 0) + (right ?? 0);
-}
-
-export function normalizeRobinhoodSnapshot(accountsPayload: unknown, positionsPayload: unknown): BrokerPortfolioSnapshot {
-  const accounts = allRecords(accountsPayload).flatMap((item): BrokerAccount[] => {
-    const id = accountId(item);
-    if (!id) return [];
-    const type = text(item.accountType, item.account_type, item.type);
-    const currency = text(item.currency, item.baseCurrency, item.base_currency, "USD").toUpperCase();
-    return [{
-      accountId: id,
-      name: text(item.name, item.accountName, item.account_name, type && titleCase(type), id),
-      currency,
-      netLiquidation: numberValue(item.totalValue, item.total_value, item.portfolioValue, item.portfolio_value),
-      buyingPower: numberValue(item.buyingPower, item.buying_power),
-    }];
-  });
-
-  const positions = allRecords(positionsPayload).flatMap((item): BrokerPosition[] => {
-    const instrument = nested(item, "instrument");
-    const account = nested(item, "account");
-    const costBasis = record(item.costBasis) ?? record(item.cost_basis) ?? {};
-    const lastPrice = record(item.lastPrice) ?? record(item.last_price) ?? {};
-    const symbol = text(item.symbol, item.ticker, instrument.symbol).toUpperCase();
-    const shares = numberValue(item.quantity, item.shares, item.qty);
-    if (!symbol || shares == null || shares === 0) return [];
-    const totalCost = numberValue(
-      item.totalCost,
-      item.total_cost,
-      typeof item.costBasis === "object" ? undefined : item.costBasis,
-      typeof item.cost_basis === "object" ? undefined : item.cost_basis,
-      costBasis.totalCost,
-      costBasis.total_cost,
-    );
-    const avgCost = numberValue(
-      item.averageCost,
-      item.average_cost,
-      item.averageBuyPrice,
-      item.average_buy_price,
-      item.costBasisPerShare,
-      item.cost_basis_per_share,
-      costBasis.unitCost,
-      costBasis.unit_cost,
-      totalCost != null ? totalCost / Math.abs(shares) : undefined,
-    );
-    const marketValue = numberValue(item.marketValue, item.market_value, item.currentValue, item.current_value);
-    const markPrice = numberValue(
-      item.markPrice,
-      item.mark_price,
-      item.price,
-      item.lastPrice,
-      item.last_price,
-      lastPrice.lastPrice,
-      lastPrice.last_price,
-      lastPrice.price,
-      marketValue != null ? marketValue / Math.abs(shares) : undefined,
-    );
-    return [{
-      ticker: symbol,
-      exchange: text(item.exchange, instrument.exchange, "SMART").toUpperCase(),
-      shares,
-      avgCost,
-      currency: text(item.currency, instrument.currency, "USD").toUpperCase(),
-      accountId: accountId(item) || accountId(account) || undefined,
-      name: text(item.name, item.description, instrument.name, symbol),
-      assetCategory: "STK",
-      markPrice,
-      marketValue,
-      unrealizedPnl: numberValue(item.unrealizedPnl, item.unrealized_pnl, item.unrealizedGain, item.unrealized_gain),
-      side: shares < 0 ? "short" : "long",
-    }];
-  });
-
-  return uniqueSnapshot(accounts, positions);
-}
-
-export function normalizePublicSnapshot(accountsPayload: unknown, portfolioPayloads: unknown[]): BrokerPortfolioSnapshot {
-  const accountRecords = record(accountsPayload)?.accounts;
-  const accounts = (Array.isArray(accountRecords) ? accountRecords : []).flatMap((value): BrokerAccount[] => {
-    const item = record(value);
-    if (!item) return [];
-    const id = accountId(item);
-    if (!id) return [];
-    const type = text(item.accountType, item.account_type);
-    return [{ accountId: id, name: type ? `Public ${titleCase(type)}` : `Public ${id}`, currency: "USD" }];
-  });
-
-  const positions: BrokerPosition[] = [];
-  for (const value of portfolioPayloads) {
-    const portfolio = record(value);
-    if (!portfolio) continue;
-    const id = accountId(portfolio);
-    const knownAccount = accounts.find((account) => account.accountId === id);
-    if (knownAccount) {
-      knownAccount.netLiquidation = numberValue(portfolio.totalAccountValue, portfolio.total_account_value);
-      knownAccount.totalCashValue = numberValue(portfolio.cash);
-      knownAccount.buyingPower = numberValue(nested(portfolio, "buyingPower").buyingPower);
-    }
-    const rawPositions = Array.isArray(portfolio.positions) ? portfolio.positions : [];
-    for (const rawPosition of rawPositions) {
-      const item = record(rawPosition);
-      if (!item) continue;
-      const instrument = nested(item, "instrument");
-      const lastPrice = nested(item, "lastPrice");
-      const costBasis = nested(item, "costBasis");
-      const symbol = text(instrument.symbol, item.symbol).toUpperCase();
-      const shares = numberValue(item.quantity);
-      if (!symbol || shares == null || shares === 0) continue;
-      positions.push({
-        ticker: symbol,
-        exchange: "SMART",
-        shares,
-        avgCost: numberValue(costBasis.unitCost, costBasis.unit_cost),
-        currency: "USD",
-        accountId: id || undefined,
-        name: text(instrument.name, symbol),
-        assetCategory: text(instrument.type, "STK").toUpperCase() === "EQUITY" ? "STK" : text(instrument.type, "STK").toUpperCase(),
-        markPrice: numberValue(lastPrice.lastPrice, lastPrice.last_price),
-        marketValue: numberValue(item.currentValue, item.current_value),
-        unrealizedPnl: numberValue(costBasis.gainValue, costBasis.gain_value),
-        percentOfNav: numberValue(item.percentOfPortfolio, item.percent_of_portfolio),
-        dateAcquired: text(item.openedAt, item.opened_at) || undefined,
-        side: shares < 0 ? "short" : "long",
-      });
-    }
-  }
-  return uniqueSnapshot(accounts, positions);
-}
-
-export function normalizeSimpleFinSnapshot(payload: unknown): BrokerPortfolioSnapshot {
-  const root = record(payload);
-  const rawAccounts = Array.isArray(root?.accounts) ? root.accounts : [];
-  const accounts: BrokerAccount[] = [];
-  const positions: BrokerPosition[] = [];
-  for (const rawAccount of rawAccounts) {
-    const account = record(rawAccount);
-    if (!account) continue;
-    const id = text(account.id);
-    const holdings = Array.isArray(account.holdings) ? account.holdings : [];
-    if (!id || holdings.length === 0) continue;
-    const currency = text(account.currency, "USD").toUpperCase();
-    accounts.push({
-      accountId: `${text(account.conn_id)}:${id}`,
-      name: text(account.name, id),
-      currency,
-      netLiquidation: numberValue(account.balance),
-      updatedAt: (numberValue(account["balance-date"]) ?? 0) * 1000 || undefined,
-    });
-    const normalizedAccountId = accounts.at(-1)!.accountId;
-    for (const rawHolding of holdings) {
-      const holding = record(rawHolding);
-      if (!holding) continue;
-      const symbol = text(holding.symbol, holding.ticker, holding.code).toUpperCase();
-      const shares = numberValue(holding.shares, holding.quantity, holding.units);
-      const marketValue = numberValue(holding.market_value, holding.marketValue, holding.value);
-      if (!symbol || shares == null || shares === 0) continue;
-      const costBasis = numberValue(holding.cost_basis, holding.costBasis);
-      const avgCost = numberValue(
-        holding.purchase_price,
-        holding.average_price,
-        holding.average_cost,
-        costBasis != null ? costBasis / Math.abs(shares) : undefined,
-      );
-      positions.push({
-        ticker: symbol,
-        exchange: text(holding.exchange, "SMART").toUpperCase(),
-        shares,
-        avgCost,
-        currency: text(holding.currency, currency).toUpperCase(),
-        accountId: normalizedAccountId,
-        name: text(holding.description, holding.name, symbol),
-        assetCategory: text(holding.type, holding.asset_type, "STK").toUpperCase(),
-        markPrice: numberValue(
-          holding.price,
-          holding.current_price,
-          holding.market_price,
-          marketValue != null ? marketValue / Math.abs(shares) : undefined,
-        ),
-        marketValue,
-        side: shares < 0 ? "short" : "long",
-      });
-    }
-  }
-  return uniqueSnapshot(accounts, positions);
-}