gloomberb 0.11.0 → 0.11.2

package/src/market-data/coordinator/index.ts

@@ -386,7 +386,7 @@ export class MarketDataCoordinator {
         && typeof quote.lastUpdated === "number"
         && quote.lastUpdated < snapshot.quote.lastUpdated
       ) {
-        return quote;
+        return snapshot.quote;
       }
     }
     const cachedFinancials = snapshot ?? this.readCachedFinancialsForInstrument(instrument);

package/src/market-data/hooks.tsx

@@ -213,47 +213,6 @@ export function useQuoteEntries(
   }, [coordinator, instrumentKey, keysVersion]);
 }
 
-export function useChartQuery(
-  request: ChartRequest | null | undefined,
-  options: ChartQueryOptions = {},
-): QueryEntry<PricePoint[]> | null {
-  const key = request ? buildChartKey(request) : null;
-  useCoordinatorKeysVersion(key ? [key] : []);
-  const coordinator = getSharedMarketDataCoordinator();
-  const entry = coordinator && request ? coordinator.getChartEntry(request) : null;
-  const appActive = useAppActive();
-  const wasActiveRef = useRef(appActive);
-  const refreshIntervalMs = Math.max(0, options.refreshIntervalMs ?? 0);
-
-  useEffect(() => {
-    const coordinator = getSharedMarketDataCoordinator();
-    if (!coordinator || !request) {
-      wasActiveRef.current = appActive;
-      return;
-    }
-    if (!appActive) {
-      wasActiveRef.current = false;
-      return;
-    }
-
-    const forceRefresh = refreshIntervalMs > 0 && !wasActiveRef.current;
-    wasActiveRef.current = true;
-    void coordinator.loadChart(request, { forceRefresh }).catch(() => {});
-  }, [appActive, key, refreshIntervalMs]);
-
-  useEffect(() => {
-    const coordinator = getSharedMarketDataCoordinator();
-    if (!coordinator || !request || !appActive || refreshIntervalMs <= 0) return;
-
-    const interval = setInterval(() => {
-      void coordinator.loadChart(request, { forceRefresh: true }).catch(() => {});
-    }, refreshIntervalMs);
-    return () => clearInterval(interval);
-  }, [appActive, key, refreshIntervalMs]);
-
-  return entry;
-}
-
 export function useChartQueries(
   requests: readonly ChartRequest[],
   options: ChartQueryOptions = {},

package/src/market-data/market/format.test.ts

@@ -100,6 +100,13 @@ describe("formatMarketPriceWithCurrency", () => {
   test("preserves chart-style compact notation for large values", () => {
     expect(formatCompactMarketPriceWithCurrency(21_970, "JPY")).toBe("¥22.0K");
     expect(formatCompactMarketPriceWithCurrency(12_340, "HKD")).toBe("HK$12.3K");
+    expect(formatCompactMarketPriceWithCurrency(79_432.18, "USD", { assetCategory: "CRYPTO" })).toBe("$79.4K");
+  });
+
+  test("keeps full price precision for legend-style values", () => {
+    expect(formatMarketPriceWithCurrency(79_432.18, "USD", { assetCategory: "CRYPTO" })).toBe("$79,432.18");
+    expect(formatMarketPriceWithCurrency(79_432.18, "USD", { assetCategory: "STK" })).toBe("$79,432.18");
+    expect(formatMarketPriceWithCurrency(1.084567, "USD", { isCashBalance: true })).toBe("$1.084567");
   });
 
   test("formats position cost values with tighter equity precision", () => {

package/src/market-data/market/freshness.ts

@@ -5,6 +5,7 @@ const US_EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "
 const ALWAYS_OPEN_EXCHANGES = new Set(["CCC"]);
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 const OVERNIGHT_CLOSE_MAX_AGE_MS = 20 * 60 * 60 * 1000;
+const ALWAYS_OPEN_MAX_AGE_MS = 2 * 60 * 60 * 1000;
 const REGULAR_OPEN_MINUTES: Record<string, number> = {
   NASDAQ: 9 * 60 + 30,
   NYSE: 9 * 60 + 30,
@@ -174,11 +175,13 @@ function isTimestampStaleForExchangeSessionUnsafe(
   const canonical = canonicalExchange(exchange);
   if (!canonical || !Number.isFinite(timestampMs) || !Number.isFinite(now)) return false;
 
+  if (ALWAYS_OPEN_EXCHANGES.has(canonical)) {
+    return now - timestampMs > ALWAYS_OPEN_MAX_AGE_MS;
+  }
+
   const timestampDate = exchangeLocalDate(canonical, timestampMs);
   const currentDate = exchangeLocalDate(canonical, now);
   if (!timestampDate || !currentDate || timestampDate === currentDate) return false;
-
-  if (ALWAYS_OPEN_EXCHANGES.has(canonical)) return true;
   if (marketState === "REGULAR" && !isBeforeKnownRegularOpen(canonical, now)) return true;
 
   if (isUsExtendedHoursExchange(canonical)) {

package/src/market-data/quotes/freshness.test.ts

@@ -58,6 +58,22 @@ describe("quote freshness", () => {
     ).toBe(true);
   });
 
+  test("treats same-day crypto quotes older than two hours as stale", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "BTC-USD",
+          currency: "USD",
+          lastUpdated: Date.parse("2026-05-13T12:00:00Z"),
+          listingExchangeName: "CCC",
+          exchangeName: "CCC",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+  });
+
   test("treats old crypto quotes as stale on the 24/7 venue", () => {
     expect(
       isQuoteStaleForCurrentSession(

package/src/news/aggregator.test.ts

@@ -214,8 +214,8 @@ describe("NewsService", () => {
     expect(breaking.every((i) => i.url !== "https://f.com/old-high")).toBe(true);
   });
 
-  it("retains at most 500 articles", async () => {
-    const items = Array.from({ length: 600 }, (_, i) =>
+  it("retains at most 10000 articles", async () => {
+    const items = Array.from({ length: 10_100 }, (_, i) =>
       makeItem({
         url: `https://g.com/${i}`,
         publishedAt: new Date(Date.now() - i * 1000),
@@ -224,7 +224,7 @@ describe("NewsService", () => {
     agg.register(makeSource("g", items));
     await agg.poll();
 
-    expect(agg.getFirehose(undefined, 1000)).toHaveLength(500);
+    expect(agg.getFirehose(undefined, 20_000)).toHaveLength(10_000);
   });
 
   it("subscribe callback fires on poll and getVersion increments", async () => {
@@ -488,4 +488,93 @@ describe("NewsService", () => {
 
     expect(state.articles[0]?.items?.map((item) => item.id)).toEqual(["item-1"]);
   });
+
+  it("appends paged news instead of replacing the first page", async () => {
+    const first = makeItem({ url: "https://example.com/a", title: "First" });
+    const second = makeItem({ url: "https://example.com/b", title: "Second" });
+    const fetchNewsPage = mock(async (query: { cursor?: string }) => (
+      query.cursor === "page-2"
+        ? { articles: [second], nextCursor: null }
+        : { articles: [first], nextCursor: "page-2" }
+    ));
+    agg.register(newsProvider({
+      id: "cloud",
+      name: "cloud",
+      provider: {
+        fetchNews: async (query) => (await fetchNewsPage(query)).articles,
+        fetchNewsPage,
+      },
+    }));
+
+    const initial = await agg.load({ feed: "latest", limit: 50 });
+    expect(initial.articles.map((article) => article.url)).toEqual(["https://example.com/a"]);
+    expect(initial.nextCursor).toBe("page-2");
+
+    await agg.loadMore({ feed: "latest", limit: 50 });
+    const state = agg.getQueryState({ feed: "latest", limit: 50 });
+    expect(state.articles.map((article) => article.url)).toEqual([
+      "https://example.com/a",
+      "https://example.com/b",
+    ]);
+    expect(state.nextCursor).toBeNull();
+  });
+
+  it("keeps paged news past the query page size", async () => {
+    const first = makeItem({ url: "https://example.com/a", title: "First" });
+    const second = makeItem({ url: "https://example.com/b", title: "Second" });
+    const fetchNewsPage = mock(async (query: { cursor?: string }) => (
+      query.cursor === "page-2"
+        ? { articles: [second], nextCursor: "page-3" }
+        : { articles: [first], nextCursor: "page-2" }
+    ));
+    agg.register(newsProvider({
+      id: "cloud",
+      name: "cloud",
+      provider: {
+        fetchNews: async (query) => (await fetchNewsPage(query)).articles,
+        fetchNewsPage,
+      },
+    }));
+
+    await agg.load({ feed: "latest", limit: 1 });
+    await agg.loadMore({ feed: "latest", limit: 1 });
+    const state = agg.getQueryState({ feed: "latest", limit: 1 });
+    expect(state.articles.map((article) => article.url)).toEqual([
+      "https://example.com/a",
+      "https://example.com/b",
+    ]);
+    expect(state.nextCursor).toBe("page-3");
+  });
+
+  it("refresh keeps already paged news", async () => {
+    const first = makeItem({ url: "https://example.com/a", title: "First", publishedAt: new Date("2026-01-02") });
+    const second = makeItem({ url: "https://example.com/b", title: "Second", publishedAt: new Date("2026-01-01") });
+    const newer = makeItem({ url: "https://example.com/c", title: "Newer", publishedAt: new Date("2026-01-03") });
+    let head: "initial" | "refresh" = "initial";
+    const fetchNewsPage = mock(async (query: { cursor?: string }) => {
+      if (query.cursor === "page-2") return { articles: [second], nextCursor: "page-3" };
+      if (head === "refresh") return { articles: [newer, first], nextCursor: "page-2" };
+      head = "refresh";
+      return { articles: [first], nextCursor: "page-2" };
+    });
+    agg.register(newsProvider({
+      id: "cloud",
+      name: "cloud",
+      provider: {
+        fetchNews: async (query) => (await fetchNewsPage(query)).articles,
+        fetchNewsPage,
+      },
+    }));
+
+    await agg.load({ feed: "latest", limit: 1 });
+    await agg.loadMore({ feed: "latest", limit: 1 });
+    await agg.poll({ feed: "latest", limit: 1 });
+    const state = agg.getQueryState({ feed: "latest", limit: 1 });
+    expect(state.articles.map((article) => article.url)).toEqual([
+      "https://example.com/c",
+      "https://example.com/a",
+      "https://example.com/b",
+    ]);
+    expect(state.nextCursor).toBe("page-3");
+  });
 });

package/src/news/aggregator.ts

@@ -3,6 +3,7 @@ import type { ConnectionHealthRegistry } from "../core/connection-health";
 import type { NewsArticle, NewsQuery, NewsQueryState } from "./types";
 import {
   DEFAULT_GLOBAL_QUERY,
+  MAX_ARTICLES,
   buildNewsQueryKey,
   createIdleNewsQueryState,
   dedupeNewsArticles,
@@ -36,12 +37,14 @@ interface SourceFetchResult {
   articles: NewsArticle[];
   sourceIds: string[];
   failedSourceIds: string[];
+  nextCursor: string | null;
 }
 
 interface NewsQueryEntry {
   query: NewsQuery;
   state: NewsQueryState;
   inFlight: Promise<NewsQueryState> | null;
+  loadMoreInFlight: Promise<void> | null;
   refs: number;
   lastAccessedAt: number;
 }
@@ -169,6 +172,46 @@ export class NewsService {
     return this.refreshQuery(normalizeNewsQuery(query), true);
   }
 
+  async loadMore(query: NewsQuery): Promise<void> {
+    const normalized = normalizeNewsQuery(query);
+    const entry = this.queries.get(buildNewsQueryKey(normalized));
+    if (!entry || entry.loadMoreInFlight || !entry.state.nextCursor || entry.state.loadingMore) return;
+    if (entry.state.articles.length >= MAX_ARTICLES) {
+      entry.state = { ...entry.state, nextCursor: null };
+      this.notify();
+      return;
+    }
+
+    const request = (async () => {
+      entry.state = { ...entry.state, loadingMore: true };
+      this.notify();
+      try {
+        const result = await this.fetchFromSources({
+          ...normalized,
+          cursor: entry.state.nextCursor ?? undefined,
+        });
+        entry.state = {
+          ...entry.state,
+          loadingMore: false,
+          articles: filterNewsArticlesForQuery(
+            dedupeNewsArticles([...entry.state.articles, ...result.articles]),
+            normalized,
+          ),
+          nextCursor: result.nextCursor,
+        };
+        this.rebuildArticlePool();
+        this.notify();
+      } catch {
+        entry.state = { ...entry.state, loadingMore: false };
+        this.notify();
+      } finally {
+        entry.loadMoreInFlight = null;
+      }
+    })();
+    entry.loadMoreInFlight = request;
+    await request;
+  }
+
   async loadStory(storyId: string): Promise<NewsArticle | null> {
     const sources = this.enabledSources({ feed: "latest" })
       .filter((source) => !!source.provider.fetchNewsStory);
@@ -227,7 +270,14 @@ export class NewsService {
         if (result.sourceIds.length === 0 && result.failedSourceIds.length > 0) {
           throw new Error("News sources unavailable.");
         }
-        const articles = filterNewsArticlesForQuery(dedupeNewsArticles(result.articles), query);
+        if (entry.loadMoreInFlight) return entry.state;
+        const incoming = filterNewsArticlesForQuery(dedupeNewsArticles(result.articles), query);
+        const existing = entry.state.articles;
+        const incomingIds = new Set(incoming.map((article) => article.id));
+        const hasOlderPages = existing.some((article) => !incomingIds.has(article.id));
+        const articles = existing.length > 0
+          ? filterNewsArticlesForQuery(dedupeNewsArticles([...incoming, ...existing]), query)
+          : incoming;
         const state: NewsQueryState = {
           phase: "ready",
           articles,
@@ -238,6 +288,8 @@ export class NewsService {
             : null,
           updatedAt: this.now(),
           sourceIds: result.sourceIds,
+          nextCursor: hasOlderPages ? entry.state.nextCursor : result.nextCursor,
+          loadingMore: entry.state.loadingMore,
         };
         entry.state = state;
         entry.lastAccessedAt = this.now();
@@ -277,6 +329,7 @@ export class NewsService {
       query,
       state: createIdleNewsQueryState(),
       inFlight: null,
+      loadMoreInFlight: null,
       refs: 0,
       lastAccessedAt: now,
     };
@@ -313,10 +366,36 @@ export class NewsService {
 
   private async fetchFromSources(query: NewsQuery): Promise<SourceFetchResult> {
     const sources = this.enabledSources(query);
+    const pageSources = query.cursor
+      ? sources.filter((source) => !!source.provider.fetchNewsPage)
+      : sources;
     if (normalizeNewsFeed(query) === "ticker") {
-      return this.fetchTickerNews(query, sources);
+      return this.fetchTickerNews(query, pageSources);
     }
-    return this.fetchMergedNews(query, sources);
+    return this.fetchMergedNews(query, pageSources);
+  }
+
+  private async readSourcePage(
+    source: NewsCapability,
+    query: NewsQuery,
+  ): Promise<{ articles: NewsArticle[]; nextCursor: string | null }> {
+    if (source.provider.fetchNewsPage) {
+      const page = await this.trackSourceRequest(
+        source,
+        "fetchNewsPage",
+        () => source.provider.fetchNewsPage!(query),
+      );
+      return {
+        articles: page.articles.map((article) => markDetailCapableArticle(source, article)),
+        nextCursor: page.nextCursor ?? null,
+      };
+    }
+    const articles = (await this.trackSourceRequest(
+      source,
+      "fetchNews",
+      () => source.provider.fetchNews(query),
+    )).map((article) => markDetailCapableArticle(source, article));
+    return { articles, nextCursor: null };
   }
 
   private async fetchTickerNews(query: NewsQuery, sources: NewsCapability[]): Promise<SourceFetchResult> {
@@ -324,45 +403,44 @@ export class NewsService {
     const failedSourceIds: string[] = [];
     for (const source of sources) {
       try {
-        const articles = (await this.trackSourceRequest(
-          source,
-          "fetchNews",
-          () => source.provider.fetchNews(query),
-        )).map((article) => markDetailCapableArticle(source, article));
-        const result = { articles, sourceIds: [newsCapabilitySourceId(source)], failedSourceIds };
-        if (articles.length > 0) return result;
+        const page = await this.readSourcePage(source, query);
+        const result = {
+          articles: page.articles,
+          sourceIds: [newsCapabilitySourceId(source)],
+          failedSourceIds,
+          nextCursor: page.nextCursor,
+        };
+        if (page.articles.length > 0) return result;
         firstEmpty ??= result;
       } catch {
         failedSourceIds.push(newsCapabilitySourceId(source));
       }
     }
-    return firstEmpty ?? { articles: [], sourceIds: [], failedSourceIds };
+    return firstEmpty ?? { articles: [], sourceIds: [], failedSourceIds, nextCursor: null };
   }
 
   private async fetchMergedNews(query: NewsQuery, sources: NewsCapability[]): Promise<SourceFetchResult> {
     const settled = await Promise.allSettled(
       sources.map(async (source) => ({
         source,
-        articles: (await this.trackSourceRequest(
-          source,
-          "fetchNews",
-          () => source.provider.fetchNews(query),
-        )).map((article) => markDetailCapableArticle(source, article)),
+        page: await this.readSourcePage(source, query),
       })),
     );
     const articles: NewsArticle[] = [];
     const sourceIds: string[] = [];
     const failedSourceIds: string[] = [];
+    let nextCursor: string | null = null;
     settled.forEach((result, index) => {
       if (result.status !== "fulfilled") {
         const source = sources[index];
         if (source) failedSourceIds.push(newsCapabilitySourceId(source));
         return;
       }
-      articles.push(...result.value.articles);
+      articles.push(...result.value.page.articles);
       sourceIds.push(newsCapabilitySourceId(result.value.source));
+      nextCursor ??= result.value.page.nextCursor;
     });
-    return { articles, sourceIds, failedSourceIds };
+    return { articles, sourceIds, failedSourceIds, nextCursor };
   }
 
   private trackSourceRequest<T>(
@@ -393,6 +471,8 @@ export class NewsService {
         error: null,
         updatedAt: this.now(),
         sourceIds: [...new Set([...entry.state.sourceIds, newsCapabilitySourceId(source)])],
+        nextCursor: entry.state.nextCursor,
+        loadingMore: false,
       };
       changed = true;
     }

package/src/news/hooks.test.tsx

@@ -33,6 +33,8 @@ test("useNewsArticles watches once and unwatches on unmount", async () => {
     error: null,
     updatedAt: 1,
     sourceIds: [],
+    nextCursor: null,
+    loadingMore: false,
   };
   const service = {
     getQueryState: () => readyState,

package/src/news/hooks.ts

@@ -1,6 +1,8 @@
-import { useCallback, useSyncExternalStore } from "react";
+import { useCallback, useRef, useSyncExternalStore } from "react";
 import { buildNewsQueryKey, type NewsService } from "./aggregator";
 import type { NewsArticle, NewsQuery, NewsQueryState } from "./types";
+import { useTableLoadMore } from "../components/table-view-shared";
+import type { ScrollBoxRenderable } from "../ui";
 
 let sharedService: NewsService | null = null;
 
@@ -18,6 +20,8 @@ const IDLE_NEWS_QUERY_STATE: NewsQueryState = {
   error: null,
   updatedAt: null,
   sourceIds: [],
+  nextCursor: null,
+  loadingMore: false,
 };
 
 export function useNewsArticles(query: NewsQuery | null | undefined): NewsQueryState {
@@ -38,3 +42,25 @@ export function useNewsArticles(query: NewsQuery | null | undefined): NewsQueryS
 export function useLoadNewsStory(): (storyId: string) => Promise<NewsArticle | null> {
   return useCallback(async (storyId: string) => sharedService?.loadStory(storyId) ?? null, []);
 }
+
+export function useNewsLoadMore(query: NewsQuery | null | undefined): () => void {
+  const key = query ? buildNewsQueryKey(query) : null;
+  return useCallback(() => {
+    if (!query) return;
+    void sharedService?.loadMore(query);
+  }, [key]);
+}
+
+export function useNewsTableLoadMore(
+  query: NewsQuery | null | undefined,
+  state: Pick<NewsQueryState, "nextCursor" | "loadingMore">,
+) {
+  const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+  const loadMore = useNewsLoadMore(query);
+  const onBodyScrollActivity = useTableLoadMore(
+    scrollRef,
+    !!state.nextCursor && !state.loadingMore,
+    loadMore,
+  );
+  return { scrollRef, onBodyScrollActivity };
+}

package/src/news/news-model.ts

@@ -2,7 +2,7 @@ import { canonicalExchange, normalizeSymbol } from "../utils/exchanges";
 import type { NewsCapability } from "../capabilities";
 import type { NewsArticle, NewsFeed, NewsQuery, NewsQueryState } from "./types";
 
-const MAX_ARTICLES = 500;
+export const MAX_ARTICLES = 10_000;
 export const DEFAULT_GLOBAL_QUERY: NewsQuery = { feed: "latest", limit: MAX_ARTICLES };
 
 const FEEDS = new Set<NewsFeed>(["latest", "top", "breaking", "ticker", "sector", "topic"]);
@@ -86,6 +86,8 @@ export function createIdleNewsQueryState(): NewsQueryState {
     error: null,
     updatedAt: null,
     sourceIds: [],
+    nextCursor: null,
+    loadingMore: false,
   };
 }
 
@@ -204,5 +206,6 @@ export function filterNewsArticlesForQuery(items: NewsArticle[], query: NewsQuer
   if (query.breaking != null) {
     filtered = filtered.filter((item) => item.isBreaking === query.breaking);
   }
-  return filtered.slice(0, query.limit ?? MAX_ARTICLES);
+  // Page size is a fetch hint. Accumulated load-more results keep MAX_ARTICLES.
+  return filtered.slice(0, MAX_ARTICLES);
 }

package/src/news/types.ts

@@ -68,10 +68,17 @@ export interface NewsQuery {
 
 export type NewsQueryPhase = "idle" | "loading" | "ready" | "refreshing" | "error";
 
+export interface NewsPage {
+  articles: NewsArticle[];
+  nextCursor?: string | null;
+}
+
 export interface NewsQueryState {
   phase: NewsQueryPhase;
   articles: NewsArticle[];
   error: string | null;
   updatedAt: number | null;
   sourceIds: string[];
+  nextCursor: string | null;
+  loadingMore: boolean;
 }

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

@@ -55,6 +55,35 @@ describe("broker position normalization", () => {
       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", () => {
@@ -108,6 +137,35 @@ describe("broker authentication boundaries", () => {
     ])).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");

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

@@ -80,11 +80,48 @@ function uniqueSnapshot(accounts: BrokerAccount[], positions: BrokerPosition[]):
       currency: position.currency,
     });
   }
-  const uniquePositions = [...new Map(positions.map((position) => [
-    `${position.accountId ?? ""}:${position.ticker}:${position.assetCategory ?? ""}`,
-    position,
-  ])).values()];
-  return { accounts: uniqueAccounts, positions: uniquePositions };
+  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 {