gloomberb 0.10.4 → 0.11.0

package/src/plugins/prediction-markets/services/kalshi/adapter.ts

@@ -30,6 +30,7 @@ import type {
   KalshiEventResponse,
   KalshiEventsResponse,
   KalshiOrderbookResponse,
+  KalshiSeriesResponse,
   KalshiTradesResponse,
 } from "./types";
 
@@ -39,9 +40,16 @@ const KALSHI_EVENT_PAGE_LIMIT = 200;
 const DEFAULT_KALSHI_EVENT_MAX_PAGES = 3;
 const SEARCH_KALSHI_EVENT_MAX_PAGES = 3;
 
-function buildKalshiCatalogUrl(cursor?: string, category?: string): string {
+function kalshiSeriesTickerFromEvent(eventTicker: string | undefined): string | undefined {
+  const trimmed = eventTicker?.trim().toUpperCase();
+  if (!trimmed) return undefined;
+  const withoutDateSuffix = trimmed.replace(/-[0-9].*$/, "");
+  return withoutDateSuffix || trimmed;
+}
+
+function buildKalshiCatalogUrl(cursor?: string, category?: string, limit = KALSHI_EVENT_PAGE_LIMIT): string {
   const url = new URL("https://api.elections.kalshi.com/trade-api/v2/events");
-  url.searchParams.set("limit", String(KALSHI_EVENT_PAGE_LIMIT));
+  url.searchParams.set("limit", String(limit));
   url.searchParams.set("status", "open");
   url.searchParams.set("with_nested_markets", "true");
   if (category) url.searchParams.set("category", category);
@@ -51,13 +59,16 @@ function buildKalshiCatalogUrl(cursor?: string, category?: string): string {
 
 async function fetchKalshiCatalogEvents(
   maxPages = DEFAULT_KALSHI_EVENT_MAX_PAGES,
+  limit = KALSHI_EVENT_PAGE_LIMIT,
+  signal?: AbortSignal,
 ): Promise<KalshiEventRecord[]> {
   const events: KalshiEventRecord[] = [];
   let cursor: string | undefined;
 
   for (let page = 0; page < maxPages; page += 1) {
     const response = await fetchJson<KalshiEventsResponse>(
-      buildKalshiCatalogUrl(cursor),
+      buildKalshiCatalogUrl(cursor, undefined, limit),
+      signal,
     );
     events.push(...(response.events ?? []));
     cursor = response.cursor?.trim() || undefined;
@@ -70,16 +81,19 @@ async function fetchKalshiCatalogEvents(
 async function fetchKalshiCatalogEventsForCategory(
   categoryId: PredictionCategoryId,
   maxPages = DEFAULT_KALSHI_EVENT_MAX_PAGES,
+  limit = KALSHI_EVENT_PAGE_LIMIT,
+  signal?: AbortSignal,
 ): Promise<KalshiEventRecord[]> {
   const categories = getKalshiCategoryNames(categoryId);
-  if (categories.length === 0) return await fetchKalshiCatalogEvents(maxPages);
+  if (categories.length === 0) return await fetchKalshiCatalogEvents(maxPages, limit, signal);
 
   const deduped = new Map<string, KalshiEventRecord>();
   for (const category of categories) {
     let cursor: string | undefined;
     for (let page = 0; page < maxPages; page += 1) {
       const response = await fetchJson<KalshiEventsResponse>(
-        buildKalshiCatalogUrl(cursor, category),
+        buildKalshiCatalogUrl(cursor, category, limit),
+        signal,
       );
       for (const event of response.events ?? []) {
         const key = event.event_ticker ?? event.title;
@@ -96,20 +110,20 @@ async function fetchKalshiCatalogEventsForCategory(
 export async function loadKalshiCatalog(
   searchQuery = "",
   categoryId: PredictionCategoryId = "all",
+  options: { limit?: number; signal?: AbortSignal } = {},
 ): Promise<PredictionMarketSummary[]> {
   const normalizedQuery = searchQuery.trim().toLowerCase();
+  const requestedLimit = Math.max(1, Math.min(KALSHI_EVENT_PAGE_LIMIT, options.limit ?? KALSHI_EVENT_PAGE_LIMIT));
+  const pageLimit = Math.max(20, requestedLimit);
+  const maxPages = options.limit ? 1 : normalizedQuery ? SEARCH_KALSHI_EVENT_MAX_PAGES : DEFAULT_KALSHI_EVENT_MAX_PAGES;
   return await loadCachedPredictionResource(
     "catalog",
-    buildPredictionCatalogResourceKey("kalshi", categoryId, normalizedQuery),
+    `${buildPredictionCatalogResourceKey("kalshi", categoryId, normalizedQuery)}:${requestedLimit}`,
     async () => {
-      const maxPages = normalizedQuery
-        ? SEARCH_KALSHI_EVENT_MAX_PAGES
-        : DEFAULT_KALSHI_EVENT_MAX_PAGES;
-      const events =
-        categoryId === "all"
-          ? await fetchKalshiCatalogEvents(maxPages)
-          : await fetchKalshiCatalogEventsForCategory(categoryId, maxPages);
-      return normalizeKalshiCatalog(events, normalizedQuery, categoryId);
+      const events = categoryId === "all"
+        ? await fetchKalshiCatalogEvents(maxPages, pageLimit, options.signal)
+        : await fetchKalshiCatalogEventsForCategory(categoryId, maxPages, pageLimit, options.signal);
+      return normalizeKalshiCatalog(events, normalizedQuery, categoryId).slice(0, requestedLimit);
     },
     PREDICTION_CACHE_POLICIES.catalog,
   );
@@ -134,6 +148,23 @@ async function loadKalshiEvent(
   }
 }
 
+export async function resolveKalshiChartSummary(
+  eventTicker: string,
+  marketTicker: string,
+  signal?: AbortSignal,
+): Promise<PredictionMarketSummary> {
+  const response = await fetchJson<KalshiEventResponse>(
+    `https://api.elections.kalshi.com/trade-api/v2/events/${eventTicker}`,
+    signal,
+  );
+  const market = response.markets?.find((candidate) => candidate.ticker === marketTicker);
+  const summary = market ? normalizeKalshiMarket(market, response.event) : null;
+  if (!summary) {
+    throw new Error(`Kalshi market ${marketTicker} in event ${eventTicker} is no longer resolvable. Remove or replace this chart series.`);
+  }
+  return summary;
+}
+
 async function loadKalshiTrades(
   summary: PredictionMarketSummary,
 ): Promise<PredictionTrade[]> {
@@ -194,11 +225,15 @@ async function loadKalshiBook(
 export async function loadKalshiHistory(
   summary: PredictionMarketSummary,
   range: "1D" | "1W" | "1M" | "ALL",
+  options: { start?: Date; end?: Date; signal?: AbortSignal; strict?: boolean } = {},
 ): Promise<PredictionHistoryPoint[]> {
-  const event = await loadKalshiEvent(summary.eventTicker);
-  if (!event?.event?.series_ticker) return [];
+  const seriesTicker = summary.seriesTicker ?? (await loadKalshiEvent(summary.eventTicker))?.event?.series_ticker;
+  if (!seriesTicker) {
+    if (options.strict) throw new Error(`Kalshi event ${summary.eventTicker ?? "unknown"} no longer exposes chart history.`);
+    return [];
+  }
 
-  const now = Math.floor(Date.now() / 1000);
+  const now = Math.floor((options.end?.getTime() ?? Date.now()) / 1000);
   const rangeSeconds =
     range === "1D"
       ? 24 * 60 * 60
@@ -208,15 +243,16 @@ export async function loadKalshiHistory(
           ? 30 * 24 * 60 * 60
           : 365 * 24 * 60 * 60;
   const periodInterval = range === "1D" ? 60 : range === "1W" ? 60 : 1440;
-  const start = now - rangeSeconds;
+  const start = Math.floor((options.start?.getTime() ?? (now * 1000 - rangeSeconds * 1000)) / 1000);
 
   try {
     return await loadCachedPredictionResource(
       "history",
-      `${summary.key}:${range}`,
+      `${summary.key}:${range}:${start}:${now}`,
       async () => {
         const response = await fetchJson<KalshiCandlestickResponse>(
-          `https://api.elections.kalshi.com/trade-api/v2/series/${event.event.series_ticker}/markets/${summary.marketId}/candlesticks?start_ts=${start}&end_ts=${now}&period_interval=${periodInterval}`,
+          `https://api.elections.kalshi.com/trade-api/v2/series/${seriesTicker}/markets/${summary.marketId}/candlesticks?start_ts=${start}&end_ts=${now}&period_interval=${periodInterval}`,
+          options.signal,
         );
         return (response.candlesticks ?? [])
           .map((candle) => ({
@@ -234,11 +270,30 @@ export async function loadKalshiHistory(
       },
       PREDICTION_CACHE_POLICIES.history,
     );
-  } catch {
+  } catch (error) {
+    if (options.strict) throw error;
     return [];
   }
 }
 
+async function loadKalshiSeriesSettlement(
+  seriesTicker: string | undefined,
+): Promise<string | undefined> {
+  const ticker = seriesTicker?.trim();
+  if (!ticker) return undefined;
+  try {
+    const response = await fetchJson<KalshiSeriesResponse>(
+      `https://api.elections.kalshi.com/trade-api/v2/series/${encodeURIComponent(ticker)}`,
+    );
+    const names = (response.series?.settlement_sources ?? [])
+      .map((source) => source.name?.trim())
+      .filter((name): name is string => !!name);
+    return names.length > 0 ? names.join(", ") : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function loadKalshiDetail(
   summary: PredictionMarketSummary,
   range: "1D" | "1W" | "1M" | "ALL",
@@ -247,11 +302,14 @@ export async function loadKalshiDetail(
     "detail",
     buildPredictionDetailResourceKey(summary.key, range),
     async () => {
-      const [event, history, book, trades] = await Promise.all([
+      const seriesTicker = summary.seriesTicker
+        || kalshiSeriesTickerFromEvent(summary.eventTicker);
+      const [event, history, book, trades, resolutionSource] = await Promise.all([
         loadKalshiEvent(summary.eventTicker),
         loadKalshiHistory(summary, range),
         loadKalshiBook(summary),
         loadKalshiTrades(summary),
+        loadKalshiSeriesSettlement(seriesTicker),
       ]);
       const eventMeta = event?.event;
       const siblings: PredictionSiblingMarket[] = (event?.markets ?? [])
@@ -277,7 +335,8 @@ export async function loadKalshiDetail(
           ...summary,
           eventLabel: event?.event?.title ?? summary.eventLabel,
           category: event?.event?.category ?? summary.category,
-          seriesTicker: event?.event?.series_ticker ?? summary.seriesTicker,
+          seriesTicker: event?.event?.series_ticker ?? seriesTicker,
+          resolutionSource: resolutionSource ?? summary.resolutionSource,
           tags: summary.tags?.length
             ? summary.tags
             : event?.event?.category

package/src/plugins/prediction-markets/services/kalshi/normalize.ts

@@ -66,6 +66,7 @@ export function normalizeKalshiMarket(
     title?: string;
     category?: string;
     series_ticker?: string;
+    event_ticker?: string;
     sub_title?: string;
   },
 ): PredictionMarketSummary | null {
@@ -103,7 +104,7 @@ export function normalizeKalshiMarket(
     title: record.title,
     marketLabel,
     eventLabel: eventLabel || eventMeta?.title || record.title,
-    eventTicker: record.event_ticker,
+    eventTicker: record.event_ticker ?? eventMeta?.event_ticker,
     seriesTicker: eventMeta?.series_ticker,
     category,
     tags: category ? [category] : [],
@@ -161,6 +162,7 @@ function flattenKalshiEvents(
         title: event.title,
         category: event.category,
         series_ticker: event.series_ticker,
+        event_ticker: event.event_ticker,
         sub_title: event.sub_title,
       });
       if (!normalized) continue;

package/src/plugins/prediction-markets/services/kalshi/types.ts

@@ -74,6 +74,20 @@ export interface KalshiOrderbookResponse {
   };
 }
 
+export interface KalshiSettlementSource {
+  name?: string;
+  url?: string;
+}
+
+export interface KalshiSeriesResponse {
+  series?: {
+    ticker?: string;
+    title?: string;
+    category?: string;
+    settlement_sources?: KalshiSettlementSource[];
+  };
+}
+
 export interface KalshiCandlestickResponse {
   candlesticks?: Array<{
     end_period_ts: number;

package/src/plugins/prediction-markets/services/polymarket/adapter.ts

@@ -31,9 +31,9 @@ export { loadPolymarketDetail } from "./detail";
 const POLYMARKET_CATALOG_OFFSETS = [0, 200, 400];
 const POLYMARKET_CATEGORY_OFFSETS = [0, 200];
 
-function buildPolymarketCatalogUrl(offset: number, tagSlug?: string): string {
+function buildPolymarketCatalogUrl(offset: number, tagSlug?: string, limit = 200): string {
   const url = new URL("https://gamma-api.polymarket.com/events");
-  url.searchParams.set("limit", "200");
+  url.searchParams.set("limit", String(limit));
   url.searchParams.set("offset", String(offset));
   url.searchParams.set("active", "true");
   url.searchParams.set("closed", "false");
@@ -43,10 +43,10 @@ function buildPolymarketCatalogUrl(offset: number, tagSlug?: string): string {
   return url.toString();
 }
 
-function buildPolymarketSearchUrl(query: string): string {
+function buildPolymarketSearchUrl(query: string, limit = 40): string {
   const url = new URL("https://gamma-api.polymarket.com/public-search");
   url.searchParams.set("q", query);
-  url.searchParams.set("limit_per_type", "40");
+  url.searchParams.set("limit_per_type", String(limit));
   url.searchParams.set("search_profiles", "false");
   url.searchParams.set("search_tags", "false");
   url.searchParams.set("events_status", "open");
@@ -57,11 +57,14 @@ function buildPolymarketSearchUrl(query: string): string {
 async function loadPolymarketCatalogPages(
   offsets: number[],
   tagSlug?: string,
+  limit = 200,
+  signal?: AbortSignal,
 ): Promise<PolymarketEventRecord[]> {
   const results = await Promise.allSettled(
     offsets.map((offset) =>
       fetchJson<PolymarketEventRecord[]>(
-        buildPolymarketCatalogUrl(offset, tagSlug),
+        buildPolymarketCatalogUrl(offset, tagSlug, limit),
+        signal,
       ),
     ),
   );
@@ -78,21 +81,25 @@ async function loadPolymarketCatalogPages(
 export async function loadPolymarketCatalog(
   searchQuery = "",
   categoryId: PredictionCategoryId = "all",
+  options: { limit?: number; signal?: AbortSignal } = {},
 ): Promise<PredictionMarketSummary[]> {
   const normalizedQuery = searchQuery.trim().toLowerCase();
+  const requestedLimit = Math.max(1, Math.min(200, options.limit ?? 200));
+  const pageLimit = Math.max(20, requestedLimit);
   return await loadCachedPredictionResource(
     "catalog",
-    buildPredictionCatalogResourceKey("polymarket", categoryId, normalizedQuery),
+    `${buildPredictionCatalogResourceKey("polymarket", categoryId, normalizedQuery)}:${requestedLimit}`,
     async () => {
       if (normalizedQuery.length > 0) {
         const response = await fetchJson<PolymarketSearchResponse>(
-          buildPolymarketSearchUrl(normalizedQuery),
+          buildPolymarketSearchUrl(normalizedQuery, Math.min(40, pageLimit)),
+          options.signal,
         );
-        const searchEvents = response.events ?? [];
+        const searchEvents = (response.events ?? []).slice(0, requestedLimit);
         const hydratedEvents = (
           await Promise.all(
             [...new Set(searchEvents.map((event) => event.id).filter(Boolean))]
-              .map((eventId) => loadPolymarketEvent(eventId)),
+              .map((eventId) => loadPolymarketEvent(eventId, options.signal)),
           )
         ).filter((event): event is PolymarketEventRecord => event != null);
         const resolvedEvents = reconcilePolymarketSearchEvents(
@@ -103,7 +110,7 @@ export async function loadPolymarketCatalog(
           resolvedEvents,
           normalizedQuery,
           categoryId,
-        );
+        ).slice(0, requestedLimit);
       }
 
       if (categoryId !== "all") {
@@ -111,8 +118,10 @@ export async function loadPolymarketCatalog(
         const categoryPages = await Promise.all(
           tagSlugs.map((tagSlug) =>
             loadPolymarketCatalogPages(
-              POLYMARKET_CATEGORY_OFFSETS,
+              options.limit ? [0] : POLYMARKET_CATEGORY_OFFSETS,
               tagSlug,
+              pageLimit,
+              options.signal,
             ).catch(() => []),
           ),
         );
@@ -121,13 +130,16 @@ export async function loadPolymarketCatalog(
           "",
           categoryId,
         );
-        if (categorized.length > 0) return categorized;
+        if (categorized.length > 0) return categorized.slice(0, requestedLimit);
       }
 
       const pages = await loadPolymarketCatalogPages(
-        POLYMARKET_CATALOG_OFFSETS,
+        options.limit ? [0] : POLYMARKET_CATALOG_OFFSETS,
+        undefined,
+        pageLimit,
+        options.signal,
       );
-      return normalizePolymarketCatalog(pages, "", categoryId);
+      return normalizePolymarketCatalog(pages, "", categoryId).slice(0, requestedLimit);
     },
     PREDICTION_CACHE_POLICIES.catalog,
   );

package/src/plugins/prediction-markets/services/polymarket/detail.ts

@@ -36,8 +36,10 @@ import type {
 
 export async function loadPolymarketEvent(
   eventId: string | undefined,
+  signal?: AbortSignal,
 ): Promise<PolymarketEventRecord | null> {
   if (!eventId) return null;
+  signal?.throwIfAborted();
   try {
     return await loadCachedPredictionResource(
       "rules",
@@ -45,10 +47,12 @@ export async function loadPolymarketEvent(
       async () =>
         await fetchJson<PolymarketEventRecord>(
           `https://gamma-api.polymarket.com/events/${eventId}`,
+          signal,
         ),
       PREDICTION_CACHE_POLICIES.rules,
     );
-  } catch {
+  } catch (error) {
+    if (signal?.aborted) throw signal.reason ?? error;
     return null;
   }
 }
@@ -81,6 +85,25 @@ function findCanonicalPolymarketMarket(
   );
 }
 
+export async function resolvePolymarketChartSummary(
+  eventId: string,
+  marketId: string,
+  signal?: AbortSignal,
+): Promise<PredictionMarketSummary> {
+  const event = await fetchJson<PolymarketEventRecord>(
+    `https://gamma-api.polymarket.com/events/${eventId}`,
+    signal,
+  );
+  const market = event.markets?.find((candidate) => candidate.id === marketId);
+  const summary = market
+    ? normalizePolymarketMarket(hydratePolymarketMarket(market, event))
+    : null;
+  if (!summary) {
+    throw new Error(`Polymarket market ${marketId} in event ${eventId} is no longer resolvable. Remove or replace this chart series.`);
+  }
+  return summary;
+}
+
 async function resolvePolymarketSummary(
   summary: PredictionMarketSummary,
 ): Promise<{
@@ -121,12 +144,16 @@ async function resolvePolymarketSummary(
   };
 }
 
-async function loadPolymarketHistory(
+export async function loadPolymarketHistory(
   summary: PredictionMarketSummary,
   range: "1D" | "1W" | "1M" | "ALL",
+  options: { start?: Date; end?: Date; signal?: AbortSignal; strict?: boolean } = {},
 ): Promise<PredictionHistoryPoint[]> {
   const tokenId = summary.yesTokenId;
-  if (!tokenId) return [];
+  if (!tokenId) {
+    if (options.strict) throw new Error(`Polymarket market ${summary.marketId} no longer exposes a YES token for chart history.`);
+    return [];
+  }
   const interval =
     range === "1D"
       ? "1d"
@@ -137,14 +164,24 @@ async function loadPolymarketHistory(
           : "max";
   const fidelity =
     range === "1D" ? 15 : range === "1W" ? 60 : range === "1M" ? 240 : 1440;
+  const start = options.start ? Math.floor(options.start.getTime() / 1000) : null;
+  const end = options.end ? Math.floor(options.end.getTime() / 1000) : null;
+  const bounded = start !== null && end !== null && Number.isFinite(start) && Number.isFinite(end) && start <= end;
 
   return await loadCachedPredictionResource(
     "history",
-    `${summary.key}:${range}`,
+    `${summary.key}:${range}${bounded ? `:${start}:${end}` : ""}`,
     async () => {
-      const response = await fetchJson<PolymarketHistoryResponse>(
-        `https://clob.polymarket.com/prices-history?market=${tokenId}&interval=${interval}&fidelity=${fidelity}`,
-      );
+      const url = new URL("https://clob.polymarket.com/prices-history");
+      url.searchParams.set("market", tokenId);
+      url.searchParams.set("fidelity", String(fidelity));
+      if (bounded) {
+        url.searchParams.set("startTs", String(start));
+        url.searchParams.set("endTs", String(end));
+      } else {
+        url.searchParams.set("interval", interval);
+      }
+      const response = await fetchJson<PolymarketHistoryResponse>(url.toString(), options.signal);
       return (response.history ?? [])
         .map((point) => ({
           date: new Date(point.t * 1000),
@@ -204,19 +241,31 @@ async function loadPolymarketBook(
     "book",
     summary.key,
     async () => {
-      const [yesBook, noBook] = await Promise.all([
-        yesTokenId
-          ? fetchJson<PolymarketBookResponse>(
-              `https://clob.polymarket.com/book?token_id=${yesTokenId}`,
-            ).catch(() => null)
-          : Promise.resolve(null),
-        noTokenId
-          ? fetchJson<PolymarketBookResponse>(
-              `https://clob.polymarket.com/book?token_id=${noTokenId}`,
-            ).catch(() => null)
-          : Promise.resolve(null),
+      const loadSide = async (tokenId: string | null | undefined) => {
+        if (!tokenId) return { book: null, error: null as string | null };
+        try {
+          return {
+            book: await fetchJson<PolymarketBookResponse>(
+              `https://clob.polymarket.com/book?token_id=${tokenId}`,
+            ),
+            error: null as string | null,
+          };
+        } catch (error) {
+          // Keep the failure: an empty book and a failed book look identical downstream.
+          return {
+            book: null,
+            error: error instanceof Error ? error.message : String(error),
+          };
+        }
+      };
+      const [yesResult, noResult] = await Promise.all([
+        loadSide(yesTokenId),
+        loadSide(noTokenId),
       ]);
+      const yesBook = yesResult.book;
+      const noBook = noResult.book;
       return {
+        error: yesResult.error ?? noResult.error,
         yesBids: (yesBook?.bids ?? [])
           .map(normalizePolymarketBookLevel)
           .filter((level): level is PredictionBookLevel => level != null),

package/src/plugins/prediction-markets/test-helpers.tsx

@@ -522,7 +522,6 @@ export function GroupedDetailHarness({
           historyRange="1M"
           onDetailTabChange={() => {}}
           onHistoryRangeChange={() => {}}
-          onPreviewOrder={() => {}}
           onSelectMarket={() => {}}
           scrollRef={scrollRef}
           selectedRow={selectedRow!}

package/src/plugins/prediction-markets/types.ts

@@ -4,7 +4,7 @@ import type { PredictionCategoryId } from "./categories";
 export type PredictionVenue = "polymarket" | "kalshi";
 export type PredictionVenueScope = "all" | PredictionVenue;
 export type PredictionBrowseTab = "top" | "ending" | "new" | "watchlist";
-export type PredictionDetailTab = "overview" | "book" | "trades" | "rules";
+export type PredictionDetailTab = "overview" | "chart" | "book" | "trades" | "rules";
 export type PredictionHistoryRange = "1D" | "1W" | "1M" | "ALL";
 export type PredictionVolumeUnit = "usd" | "contracts";
 type PredictionSortDirection = "asc" | "desc";
@@ -99,6 +99,8 @@ export interface PredictionBookSnapshot {
   noBids: PredictionBookLevel[];
   noAsks: PredictionBookLevel[];
   lastTradePrice: number | null;
+  /** Set when the venue book request failed, so empty depth is never reported as "no depth". */
+  error?: string | null;
 }
 
 export interface PredictionTrade {
@@ -119,14 +121,6 @@ export interface PredictionMarketDetail {
   trades: PredictionTrade[];
 }
 
-export interface PredictionOrderPreviewIntent {
-  marketKey: string;
-  outcome: "yes" | "no";
-  side: "buy" | "sell";
-  price: number;
-  size: number;
-}
-
 export interface PredictionColumnDef extends ColumnConfig {
   description: string;
 }

package/src/plugins/registry/context.ts

@@ -1,10 +1,12 @@
 import type { AppPersistencePort, AppTickerRepositoryPort } from "../../core/app-service-ports";
+import type { ConnectionHealthRegistry } from "../../core/connection-health";
 import type { BrokerInstanceConfig, LayoutConfig } from "../../types/config";
 import type { DataProvider } from "../../types/data-provider";
 import type { TickerFinancials } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 import type { PluginCapability } from "../../capabilities";
 import type {
+  AppNotificationDelivery,
   AppNotificationRequest,
   BrokerInstanceUpdateOptions,
   GloomPluginContext,
@@ -29,6 +31,7 @@ export interface RegistryPluginContextOptions {
   contributions: RegistryContributions;
   enableCapabilityHandlers: boolean;
   marketData: DataProvider;
+  connectionHealth: ConnectionHealthRegistry;
   tickerRepository: AppTickerRepositoryPort;
   persistence: AppPersistencePort;
   getLayout: () => LayoutConfig;
@@ -69,7 +72,7 @@ export interface RegistryPluginContextOptions {
     on: <K extends keyof PluginEvents>(event: K, handler: (payload: PluginEvents[K]) => void) => () => void;
     emit: <K extends keyof PluginEvents>(event: K, payload: PluginEvents[K]) => void;
   };
-  notify: (notification: AppNotificationRequest) => void;
+  notify: (notification: AppNotificationRequest) => AppNotificationDelivery | void;
 }
 
 export function createRegistryPluginContext({
@@ -78,6 +81,7 @@ export function createRegistryPluginContext({
   contributions,
   enableCapabilityHandlers,
   marketData,
+  connectionHealth,
   tickerRepository,
   persistence,
   getLayout,
@@ -169,6 +173,7 @@ export function createRegistryPluginContext({
     getPaneDef: (paneId) => contributions.panesMap.get(paneId),
 
     marketData,
+    connectionHealth,
     tickerRepository,
     persistence: pluginPersistence,
     log,

package/src/plugins/registry/index.test.ts

@@ -145,6 +145,7 @@ describe("built-in composite plugin ownership", () => {
     expect(registry.getPluginPaneIds("application")).toEqual(expect.arrayContaining([
       "help",
       "changelog",
+      "connections",
     ]));
     expect(registry.getPluginPaneIds("macro")).toEqual(expect.arrayContaining([
       "econ-calendar",
@@ -155,6 +156,7 @@ describe("built-in composite plugin ownership", () => {
     expect(registry.getPaneTemplatePluginId("macro-tv-pane")).toBe("macro");
     expect(registry.getPanePluginId("analytics")).toBe("portfolio");
     expect(registry.getPanePluginId("help")).toBe("application");
+    expect(registry.getPanePluginId("connections")).toBe("application");
     expect(registry.getPanePluginId("macro-tv")).toBe("macro");
     expect(registry.getCommandPluginId("earnings-monitor-shortcut")).toBe("macro");
     expect(registry.getCommandPluginId("gridlock-all")).toBe("application");