gloomberb 0.10.4 → 0.11.0

package/src/capabilities/chart-series.ts

@@ -0,0 +1,318 @@
+import { debugLog } from "../utils/debug-log";
+import type {
+  CapabilitySeriesSource,
+  ChartSeriesSpec,
+  ChartViewportSpec,
+  ResolvedSeries,
+  SeriesStyle,
+  SeriesTimestampMode,
+  SeriesTransform,
+  TimeSeriesPoint,
+} from "../time-series/types";
+import type {
+  CapabilityInvoker,
+  CapabilitySchema,
+  ChartSeriesCatalogItem,
+  ChartSeriesCatalogRequest,
+  ChartSeriesResolveRequest,
+} from "./types";
+
+export const CHART_SERIES_CAPABILITY_KIND = "chart-series";
+export const MAX_CHART_SERIES_CATALOG_ITEMS = 32;
+export const MAX_CHART_SERIES_POINTS = 20_000;
+
+const CAPABILITY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+const SERIES_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~%:/-]{0,239}$/;
+const chartSeriesLog = debugLog.createLogger("chart-series");
+const ranges = new Set(["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"]);
+const resolutions = new Set(["auto", "1m", "5m", "15m", "30m", "45m", "1h", "1d", "1wk", "1mo"]);
+const periods = new Set(["auto", "daily", "weekly", "monthly", "quarterly", "annual", "ttm"]);
+const styles = new Set(["line", "area", "step", "columns", "points", "candles", "ohlc", "hlc"]);
+const transforms = new Set(["raw", "percent", "index100", "yoy", "qoq", "log"]);
+const shapes = new Set(["scalar", "ohlcv", "event", "band"]);
+const axes = new Set(["left", "right"]);
+const interpolations = new Set(["none", "step-after"]);
+
+export function isValidChartCapabilityId(value: string): boolean {
+  return CAPABILITY_ID_PATTERN.test(value);
+}
+
+export function isValidChartSeriesId(value: string): boolean {
+  return SERIES_ID_PATTERN.test(value);
+}
+
+function fail(path: string, message: string): never {
+  throw new Error(`Invalid chart series ${path}: ${message}`);
+}
+
+function object(value: unknown, path: string): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail(path, "expected an object.");
+  return value as Record<string, unknown>;
+}
+
+function onlyKeys(input: Record<string, unknown>, path: string, allowed: readonly string[]): void {
+  const extra = Object.keys(input).find((key) => !allowed.includes(key));
+  if (extra) fail(path, `unsupported field "${extra}".`);
+}
+
+function boundedString(value: unknown, path: string, max: number): string {
+  if (typeof value !== "string" || value.length === 0 || value.length > max) {
+    fail(path, `expected a non-empty string of at most ${max} characters.`);
+  }
+  return value;
+}
+
+function optionalString(value: unknown, path: string, max: number): string | undefined {
+  return value === undefined ? undefined : boundedString(value, path, max);
+}
+
+function enumValue<T extends string>(value: unknown, path: string, allowed: Set<string>): T {
+  if (typeof value !== "string" || !allowed.has(value)) fail(path, `unsupported value ${String(value)}.`);
+  return value as T;
+}
+
+function finiteNumber(value: unknown, path: string, nullable = false): number | null {
+  if (nullable && value === null) return null;
+  if (typeof value !== "number" || !Number.isFinite(value)) fail(path, "expected a finite number.");
+  return value;
+}
+
+function optionalNumber(value: unknown, path: string, nullable = false): number | null | undefined {
+  return value === undefined ? undefined : finiteNumber(value, path, nullable);
+}
+
+function dateValue(value: unknown, path: string): Date {
+  const date = value instanceof Date ? new Date(value) : new Date(value as string | number);
+  if (!Number.isFinite(date.getTime())) fail(path, "expected a valid date.");
+  return date;
+}
+
+function catalogRequest(value: unknown): ChartSeriesCatalogRequest {
+  const input = object(value, "catalog request");
+  onlyKeys(input, "catalog request", ["query", "limit"]);
+  const query = input.query === undefined ? undefined : optionalString(input.query, "catalog query", 200);
+  const limit = input.limit === undefined ? 8 : input.limit;
+  if (!Number.isInteger(limit) || (limit as number) < 1 || (limit as number) > MAX_CHART_SERIES_CATALOG_ITEMS) {
+    fail("catalog limit", `expected an integer from 1 to ${MAX_CHART_SERIES_CATALOG_ITEMS}.`);
+  }
+  return { ...(query !== undefined ? { query } : {}), limit: limit as number };
+}
+
+function viewport(value: unknown): ChartViewportSpec {
+  const input = object(value, "resolve viewport");
+  onlyKeys(input, "resolve viewport", ["range", "resolution", "dateWindow", "maxPoints"]);
+  const range = enumValue<ChartViewportSpec["range"]>(input.range, "viewport range", ranges);
+  const resolution = enumValue<ChartViewportSpec["resolution"]>(input.resolution, "viewport resolution", resolutions);
+  let dateWindow: ChartViewportSpec["dateWindow"];
+  if (input.dateWindow !== undefined) {
+    const window = object(input.dateWindow, "viewport date window");
+    onlyKeys(window, "viewport date window", ["start", "end"]);
+    const start = boundedString(window.start, "viewport start", 40);
+    const end = boundedString(window.end, "viewport end", 40);
+    const startTime = Date.parse(start);
+    const endTime = Date.parse(end);
+    if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime > endTime) {
+      fail("viewport date window", "expected valid ordered bounds.");
+    }
+    dateWindow = { start, end };
+  }
+  let maxPoints: number | undefined;
+  if (input.maxPoints !== undefined) {
+    if (!Number.isInteger(input.maxPoints) || (input.maxPoints as number) < 1 || (input.maxPoints as number) > 10_000) {
+      fail("viewport maxPoints", "expected an integer from 1 to 10000.");
+    }
+    maxPoints = input.maxPoints as number;
+  }
+  return { range, resolution, ...(dateWindow ? { dateWindow } : {}), ...(maxPoints ? { maxPoints } : {}) };
+}
+
+function resolveRequest(value: unknown): ChartSeriesResolveRequest {
+  const input = object(value, "resolve request");
+  onlyKeys(input, "resolve request", ["seriesId", "viewport"]);
+  const seriesId = boundedString(input.seriesId, "series ID", 240);
+  if (!isValidChartSeriesId(seriesId)) fail("series ID", "contains unsupported characters.");
+  return { seriesId, viewport: viewport(input.viewport) };
+}
+
+function catalogItem(value: unknown, index: number): ChartSeriesCatalogItem {
+  const item = object(value, `catalog item ${index}`);
+  onlyKeys(item, `catalog item ${index}`, ["seriesId", "label", "description", "detail", "style", "transform"]);
+  const seriesId = boundedString(item.seriesId, `catalog item ${index} series ID`, 240);
+  if (!isValidChartSeriesId(seriesId)) fail(`catalog item ${index} series ID`, "contains unsupported characters.");
+  return {
+    seriesId,
+    label: boundedString(item.label, `catalog item ${index} label`, 160),
+    ...(optionalString(item.description, `catalog item ${index} description`, 500) !== undefined
+      ? { description: item.description as string }
+      : {}),
+    ...(optionalString(item.detail, `catalog item ${index} detail`, 100) !== undefined
+      ? { detail: item.detail as string }
+      : {}),
+    ...(item.style !== undefined ? { style: enumValue<SeriesStyle>(item.style, `catalog item ${index} style`, styles) } : {}),
+    ...(item.transform !== undefined ? { transform: enumValue<SeriesTransform>(item.transform, `catalog item ${index} transform`, transforms) } : {}),
+  };
+}
+
+function catalogOutput(value: unknown): ChartSeriesCatalogItem[] {
+  if (!Array.isArray(value)) fail("catalog output", "expected an array.");
+  if (value.length > MAX_CHART_SERIES_CATALOG_ITEMS) {
+    fail("catalog output", `returned ${value.length} items; maximum is ${MAX_CHART_SERIES_CATALOG_ITEMS}.`);
+  }
+  return value.map(catalogItem);
+}
+
+function point(value: unknown, index: number): TimeSeriesPoint {
+  const input = object(value, `point ${index}`);
+  onlyKeys(input, `point ${index}`, [
+    "date", "observedAt", "availableAt", "value", "open", "high", "low", "close", "volume", "periodLabel", "provenance",
+  ]);
+  const provenance = input.provenance === undefined ? undefined : object(input.provenance, `point ${index} provenance`);
+  if (provenance) onlyKeys(provenance, `point ${index} provenance`, ["providerId", "quality"]);
+  const quality = provenance?.quality === undefined
+    ? undefined
+    : enumValue<"reported" | "derived" | "estimated">(
+        provenance.quality,
+        `point ${index} provenance quality`,
+        new Set(["reported", "derived", "estimated"]),
+      );
+  return {
+    date: dateValue(input.date, `point ${index} date`),
+    observedAt: dateValue(input.observedAt, `point ${index} observedAt`),
+    ...(input.availableAt !== undefined ? { availableAt: dateValue(input.availableAt, `point ${index} availableAt`) } : {}),
+    value: finiteNumber(input.value, `point ${index} value`, true),
+    ...(input.open !== undefined ? { open: optionalNumber(input.open, `point ${index} open`, true) } : {}),
+    ...(input.high !== undefined ? { high: optionalNumber(input.high, `point ${index} high`, true) } : {}),
+    ...(input.low !== undefined ? { low: optionalNumber(input.low, `point ${index} low`, true) } : {}),
+    ...(input.close !== undefined ? { close: optionalNumber(input.close, `point ${index} close`, true) } : {}),
+    ...(input.volume !== undefined ? { volume: optionalNumber(input.volume, `point ${index} volume`, true) } : {}),
+    ...(input.periodLabel !== undefined ? { periodLabel: boundedString(input.periodLabel, `point ${index} period label`, 120) } : {}),
+    ...(provenance ? {
+      provenance: {
+        ...(provenance.providerId !== undefined
+          ? { providerId: boundedString(provenance.providerId, `point ${index} provider ID`, 80) }
+          : {}),
+        ...(quality ? { quality } : {}),
+      },
+    } : {}),
+  };
+}
+
+function resolvedOutput(value: unknown): ResolvedSeries {
+  const input = object(value, "resolve output");
+  onlyKeys(input, "resolve output", [
+    "id", "label", "color", "unit", "unitGroup", "nativeFrequency", "timestampMode", "dataShape", "style", "transform",
+    "axis", "panelId", "interpolation", "timeBasis", "latestChangePercent", "points", "warning", "hidden",
+  ]);
+  if (!Array.isArray(input.points)) fail("resolve output points", "expected an array.");
+  if (input.points.length > MAX_CHART_SERIES_POINTS) {
+    fail("resolve output points", `returned ${input.points.length} points; maximum is ${MAX_CHART_SERIES_POINTS}.`);
+  }
+  const timeBasis = input.timeBasis === undefined ? undefined : object(input.timeBasis, "resolve output time basis");
+  if (timeBasis) onlyKeys(timeBasis, "resolve output time basis", ["kind", "timeZone", "cadenceMs"]);
+  const kind = timeBasis?.kind === undefined ? undefined : enumValue<"market">(timeBasis.kind, "time basis kind", new Set(["market"]));
+  const warning = optionalString(input.warning, "resolve output warning", 500);
+  return {
+    id: boundedString(input.id, "resolve output ID", 160),
+    label: boundedString(input.label, "resolve output label", 160),
+    color: boundedString(input.color, "resolve output color", 64),
+    unit: typeof input.unit === "string" && input.unit.length <= 64 ? input.unit : fail("resolve output unit", "expected a string of at most 64 characters."),
+    unitGroup: boundedString(input.unitGroup, "resolve output unit group", 64),
+    nativeFrequency: enumValue(input.nativeFrequency, "resolve output frequency", periods),
+    ...(input.timestampMode !== undefined
+      ? { timestampMode: enumValue<SeriesTimestampMode>(input.timestampMode, "resolve output timestamp mode", new Set(["available-at", "period-end"])) }
+      : {}),
+    dataShape: enumValue(input.dataShape, "resolve output data shape", shapes),
+    style: enumValue(input.style, "resolve output style", styles),
+    transform: enumValue(input.transform, "resolve output transform", transforms),
+    axis: enumValue(input.axis, "resolve output axis", axes),
+    panelId: boundedString(input.panelId, "resolve output panel ID", 80),
+    interpolation: enumValue(input.interpolation, "resolve output interpolation", interpolations),
+    ...(timeBasis ? {
+      timeBasis: {
+        kind: kind!,
+        timeZone: boundedString(timeBasis.timeZone, "time basis timezone", 80),
+        ...(timeBasis.cadenceMs !== undefined
+          ? { cadenceMs: finiteNumber(timeBasis.cadenceMs, "time basis cadence") as number }
+          : {}),
+      },
+    } : {}),
+    ...(input.latestChangePercent !== undefined
+      ? { latestChangePercent: finiteNumber(input.latestChangePercent, "resolve output latest change") as number }
+      : {}),
+    points: input.points.map(point),
+    ...(warning !== undefined ? { warning } : {}),
+    ...(input.hidden !== undefined
+      ? typeof input.hidden === "boolean" ? { hidden: input.hidden } : fail("resolve output hidden", "expected a boolean.")
+      : {}),
+  };
+}
+
+export const chartSeriesCatalogRequestSchema: CapabilitySchema<ChartSeriesCatalogRequest> = { parse: catalogRequest };
+export const chartSeriesCatalogOutputSchema: CapabilitySchema<ChartSeriesCatalogItem[]> = { parse: catalogOutput };
+export const chartSeriesResolveRequestSchema: CapabilitySchema<ChartSeriesResolveRequest> = { parse: resolveRequest };
+export const chartSeriesResolveOutputSchema: CapabilitySchema<ResolvedSeries> = { parse: resolvedOutput };
+
+export function chartSeriesCapabilityManifests(invoker: CapabilityInvoker) {
+  return invoker.capabilityManifests(CHART_SERIES_CAPABILITY_KIND);
+}
+
+export async function searchChartSeriesCapabilities(
+  invoker: CapabilityInvoker,
+  query: string,
+  limit = 8,
+  signal?: AbortSignal,
+): Promise<Array<ChartSeriesCatalogItem & { capabilityId: string; capabilityName: string }>> {
+  const manifests = chartSeriesCapabilityManifests(invoker);
+  const results = await Promise.allSettled(manifests.map(async (manifest) => {
+    const items = await invoker.invokeCapability<ChartSeriesCatalogItem[]>(
+      manifest.id,
+      query.trim() ? "search" : "catalog",
+      { query, limit },
+      { signal },
+    );
+    return items.map((item) => ({
+      ...item,
+      capabilityId: manifest.id,
+      capabilityName: manifest.name,
+    }));
+  }));
+  if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+  for (const [index, result] of results.entries()) {
+    if (result.status === "rejected") {
+      chartSeriesLog.warn("Chart series provider catalog failed", {
+        capabilityId: manifests[index]?.id,
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+      });
+    }
+  }
+  return results.flatMap((result) => result.status === "fulfilled" ? result.value : []).slice(0, limit);
+}
+
+export function chartSeriesSourceKey(
+  source: CapabilitySeriesSource,
+  viewport?: ChartViewportSpec,
+): string {
+  return JSON.stringify([
+    "chart-series",
+    source.capabilityId,
+    source.seriesId,
+    viewport ? {
+      range: viewport.range,
+      resolution: viewport.resolution,
+      dateWindow: viewport.dateWindow ?? null,
+      maxPoints: viewport.maxPoints ?? null,
+    } : null,
+  ]);
+}
+
+export function createChartSeriesResolver(invoker: CapabilityInvoker) {
+  return async (
+    source: CapabilitySeriesSource,
+    viewport: ChartViewportSpec,
+    _spec: ChartSeriesSpec,
+  ): Promise<ResolvedSeries> => invoker.invokeCapability<ResolvedSeries>(
+    source.capabilityId,
+    "resolve",
+    { seriesId: source.seriesId, viewport } satisfies ChartSeriesResolveRequest,
+  );
+}

package/src/capabilities/factories.ts

@@ -1,8 +1,17 @@
 import type { AssetDataProvider } from "../types/data-provider";
 import type { NewsDataProvider } from "../types/capability-route-source";
+import {
+  chartSeriesCatalogOutputSchema,
+  chartSeriesCatalogRequestSchema,
+  chartSeriesResolveOutputSchema,
+  chartSeriesResolveRequestSchema,
+  isValidChartCapabilityId,
+} from "./chart-series";
 import type {
   AssetDataCapability,
   CapabilityOperation,
+  ChartSeriesCapability,
+  ChartSeriesProvider,
   NewsCapability,
 } from "./types";
 
@@ -84,6 +93,43 @@ export function assetDataProvider(provider: AssetDataProvider): AssetDataCapabil
   };
 }
 
+export function chartSeriesProvider(options: {
+  id: string;
+  name: string;
+  priority?: number;
+  provider: ChartSeriesProvider;
+}): ChartSeriesCapability {
+  if (!isValidChartCapabilityId(options.id)) {
+    throw new Error(`Invalid chart series capability ID "${options.id}".`);
+  }
+  return {
+    id: options.id,
+    kind: "chart-series",
+    name: options.name,
+    priority: options.priority,
+    provider: options.provider,
+    operations: {
+      catalog: {
+        ...op((input: any, ctx) => options.provider.catalog?.({ ...input, signal: ctx.signal }) ?? [], "query"),
+        input: chartSeriesCatalogRequestSchema,
+        output: chartSeriesCatalogOutputSchema,
+      },
+      search: {
+        ...op((input: any, ctx) => options.provider.search?.({ ...input, signal: ctx.signal })
+          ?? options.provider.catalog?.({ ...input, signal: ctx.signal })
+          ?? [], "query"),
+        input: chartSeriesCatalogRequestSchema,
+        output: chartSeriesCatalogOutputSchema,
+      },
+      resolve: {
+        ...op((input: any, ctx) => options.provider.resolve({ ...input, signal: ctx.signal }), "query"),
+        input: chartSeriesResolveRequestSchema,
+        output: chartSeriesResolveOutputSchema,
+      },
+    },
+  };
+}
+
 export function newsProvider(options: {
   id: string;
   name: string;

package/src/capabilities/index.ts

@@ -2,3 +2,4 @@ export * from "./types";
 export * from "./registry";
 export * from "./factories";
 export * from "./service-capabilities";
+export * from "./chart-series";

package/src/capabilities/registry.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test";
+import { chartSeriesProvider } from "./factories";
 import { CapabilityRegistry } from "./registry";
+import { ConnectionHealthRegistry } from "../core/connection-health";
 import type { CapabilitySchema, PluginCapability } from "./types";
 
 interface IncrementInput {
@@ -82,6 +84,54 @@ describe("CapabilityRegistry", () => {
       .resolves.toBe(2);
   });
 
+  test("reports invokable provider operations through the connection boundary", async () => {
+    let clock = 10;
+    const health = new ConnectionHealthRegistry({ clock: () => clock });
+    health.registerSource({ id: "asset-data.test", name: "Test", kind: "asset-data" });
+    const registry = new CapabilityRegistry({ connectionHealth: health });
+    registry.register("plugin-a", testCapability({
+      id: "asset-data.test",
+      kind: "asset-data",
+      operations: {
+        read: {
+          kind: "read",
+          handler: async () => {
+            clock = 16;
+            return "ok";
+          },
+        },
+      },
+    }));
+
+    await expect(registry.invoke("asset-data.test", "read", {})).resolves.toBe("ok");
+    expect(health.getSnapshot().sources[0]).toMatchObject({
+      status: "connected",
+      lastOperation: "read",
+      lastLatencyMs: 6,
+    });
+  });
+
+  test("does not treat cached and static capability operations as network health", async () => {
+    const health = new ConnectionHealthRegistry();
+    health.registerSource({ id: "asset-data.test", name: "Test", kind: "asset-data" });
+    const registry = new CapabilityRegistry({ connectionHealth: health });
+    registry.register("plugin-a", testCapability({
+      id: "asset-data.test",
+      kind: "asset-data",
+      operations: Object.fromEntries([
+        "canProvide",
+        "getCachedFinancialsForTargets",
+        "getChartResolutionSupport",
+      ].map((id) => [id, { kind: "read", handler: () => true }])),
+    }));
+
+    await registry.invoke("asset-data.test", "canProvide", {});
+    await registry.invoke("asset-data.test", "getCachedFinancialsForTargets", {});
+    await registry.invoke("asset-data.test", "getChartResolutionSupport", {});
+
+    expect(health.getSnapshot().sources[0]).toMatchObject({ status: "idle", lastRequestAt: null });
+  });
+
   test("emits renderer-safe manifests only when requested", () => {
     const registry = new CapabilityRegistry();
     registry.register("plugin-a", testCapability());
@@ -139,6 +189,91 @@ describe("CapabilityRegistry", () => {
     expect(registry.list()).toEqual([]);
   });
 
+  test("registers, searches, resolves, disables, and disposes chart-series providers", async () => {
+    let enabled = true;
+    const registry = new CapabilityRegistry({ isPluginEnabled: () => enabled });
+    const dispose = registry.register("charts", chartSeriesProvider({
+      id: "charts.test",
+      name: "Test Charts",
+      provider: {
+        search: ({ query }) => [{ seriesId: "one", label: `Result ${query}` }],
+        resolve: ({ seriesId }) => ({
+          id: seriesId,
+          label: "Resolved",
+          color: "#fff",
+          unit: "value",
+          unitGroup: "value",
+          nativeFrequency: "daily",
+          dataShape: "scalar",
+          style: "line",
+          transform: "raw",
+          axis: "left",
+          panelId: "main",
+          interpolation: "none",
+          points: [{ date: new Date("2026-01-01"), observedAt: new Date("2026-01-01"), value: 1 }],
+        }),
+      },
+    }));
+
+    await expect(registry.invoke<any[]>("charts.test", "search", { query: "x" }))
+      .resolves.toEqual([{ seriesId: "one", label: "Result x" }]);
+    await expect(registry.invoke<any>("charts.test", "resolve", {
+      seriesId: "one",
+      viewport: { range: "1M", resolution: "auto" },
+    })).resolves.toMatchObject({ id: "one", points: [{ value: 1 }] });
+
+    enabled = false;
+    expect(registry.list("chart-series")).toEqual([]);
+    await expect(registry.invoke("charts.test", "search", {})).rejects.toThrow("not available");
+    enabled = true;
+    dispose();
+    await expect(registry.invoke("charts.test", "search", {})).rejects.toThrow("not available");
+  });
+
+  test("rejects unsafe chart-series requests and provider output before rendering", async () => {
+    const registry = new CapabilityRegistry();
+    registry.register("charts", chartSeriesProvider({
+      id: "charts.unsafe",
+      name: "Unsafe Charts",
+      provider: {
+        catalog: () => [{ seriesId: "ok", label: "x".repeat(161) }],
+        resolve: ({ seriesId }) => ({
+          id: seriesId,
+          label: "Unsafe",
+          color: "#ffffff",
+          unit: "value",
+          unitGroup: "value",
+          nativeFrequency: "daily",
+          dataShape: "scalar",
+          style: "line",
+          transform: "raw",
+          axis: "left",
+          panelId: "main",
+          interpolation: "none",
+          points: [{ date: new Date("invalid"), observedAt: new Date(), value: 1 }],
+        }),
+      },
+    }));
+
+    await expect(registry.invoke("charts.unsafe", "catalog", { query: "x".repeat(201), limit: 8 }, { renderer: true }))
+      .rejects.toThrow("catalog query");
+    await expect(registry.invoke("charts.unsafe", "catalog", { query: "x", limit: 8 }, { renderer: true }))
+      .rejects.toThrow("catalog item 0 label");
+    await expect(registry.invoke("charts.unsafe", "resolve", {
+      seriesId: "bad?query",
+      viewport: { range: "1M", resolution: "auto" },
+    }, { renderer: true })).rejects.toThrow("series ID");
+    await expect(registry.invoke("charts.unsafe", "resolve", {
+      seriesId: "safe-id",
+      parameters: {},
+      viewport: { range: "1M", resolution: "auto" },
+    }, { renderer: true })).rejects.toThrow('unsupported field "parameters"');
+    await expect(registry.invoke("charts.unsafe", "resolve", {
+      seriesId: "safe-id",
+      viewport: { range: "1M", resolution: "auto" },
+    }, { renderer: true })).rejects.toThrow("point 0 date");
+  });
+
   test("disposes subscriptions that finish after their capability is removed", async () => {
     const registry = new CapabilityRegistry();
     let finishSubscribe!: (dispose: () => void) => void;

package/src/capabilities/registry.ts

@@ -12,6 +12,15 @@ interface SubscriptionEntry {
   dispose: () => void;
 }
 
+const LOCAL_READ_OPERATIONS = new Set([
+  "canProvide",
+  "supports",
+  "getCachedFinancialsForTargets",
+  "getCachedNews",
+  "getChartResolutionSupport",
+  "getChartResolutionCapabilities",
+]);
+
 export class CapabilityRegistry {
   private readonly capabilities = new Map<string, RegisteredCapability>();
   private readonly subscriptions = new Map<string, SubscriptionEntry>();
@@ -57,8 +66,17 @@ export class CapabilityRegistry {
       ));
   }
 
-  manifests({ rendererOnly = false }: { rendererOnly?: boolean } = {}): CapabilityManifest[] {
-    return this.list().map(({ capability }) => {
+  manifests({
+    rendererOnly = false,
+    includeDisabled = false,
+  }: { rendererOnly?: boolean; includeDisabled?: boolean } = {}): CapabilityManifest[] {
+    const entries = includeDisabled
+      ? [...this.capabilities.values()].sort((left, right) => (
+          (left.capability.priority ?? 1000) - (right.capability.priority ?? 1000)
+          || left.capability.id.localeCompare(right.capability.id)
+        ))
+      : this.list();
+    return entries.map(({ capability }) => {
       const operations: CapabilityOperationManifest[] = Object.entries(capability.operations)
         .filter(([, operation]) => !rendererOnly || operation.rendererSafe === true)
         .map(([id, operation]) => ({
@@ -82,12 +100,21 @@ export class CapabilityRegistry {
     capabilityId: string,
     operationId: string,
     payload: unknown,
-    options: { renderer?: boolean } = {},
+    options: { renderer?: boolean; signal?: AbortSignal } = {},
   ): Promise<T> {
     const { capability, operation } = this.resolveOperation(capabilityId, operationId, options);
     if (!operation.handler) throw new Error(`Capability operation "${capabilityId}.${operationId}" is not invokable.`);
+    options.signal?.throwIfAborted();
     const input = (operation.input ?? recordSchema).parse(payload);
-    const result = await operation.handler(input, { capability, operationId });
+    const invoke = () => Promise.resolve(operation.handler!(input, {
+      capability,
+      operationId,
+      signal: options.signal,
+    }));
+    const health = this.options.connectionHealth;
+    const result = health?.hasSource(capabilityId) && !LOCAL_READ_OPERATIONS.has(operationId)
+      ? await health.track(capabilityId, operationId, invoke)
+      : await invoke();
     return (operation.output ? operation.output.parse(result) : result) as T;
   }
 

package/src/capabilities/types.ts

@@ -1,6 +1,13 @@
 import type { CachePolicyMap } from "../types/persistence";
+import type { ConnectionHealthRegistry } from "../core/connection-health";
 import type { AssetDataProvider } from "../types/data-provider";
 import type { NewsDataProvider } from "../types/capability-route-source";
+import type {
+  ChartViewportSpec,
+  ResolvedSeries,
+  SeriesStyle,
+  SeriesTransform,
+} from "../time-series/types";
 
 type CapabilityOperationKind = "read" | "query" | "action" | "stream";
 type CapabilitySideEffectLevel = "none" | "local-write" | "network-write" | "external-trade" | "external-side-effect";
@@ -8,6 +15,7 @@ type CapabilitySideEffectLevel = "none" | "local-write" | "network-write" | "ext
 type CapabilityKind =
   | "asset-data"
   | "news"
+  | "chart-series"
   | "plugin-service";
 
 export interface CapabilitySchema<T = unknown> {
@@ -17,6 +25,7 @@ export interface CapabilitySchema<T = unknown> {
 interface CapabilityHandlerContext {
   capability: PluginCapability;
   operationId: string;
+  signal?: AbortSignal;
 }
 
 type CapabilityStreamEmit<T = unknown> = (event: T) => void;
@@ -65,6 +74,38 @@ export interface NewsCapability extends PluginCapability {
   readonly provider: NewsDataProvider;
 }
 
+export interface ChartSeriesCatalogItem {
+  seriesId: string;
+  label: string;
+  description?: string;
+  detail?: string;
+  style?: SeriesStyle;
+  transform?: SeriesTransform;
+}
+
+export interface ChartSeriesCatalogRequest {
+  query?: string;
+  limit?: number;
+  signal?: AbortSignal;
+}
+
+export interface ChartSeriesResolveRequest {
+  seriesId: string;
+  viewport: ChartViewportSpec;
+  signal?: AbortSignal;
+}
+
+export interface ChartSeriesProvider {
+  catalog?(request: ChartSeriesCatalogRequest): Promise<ChartSeriesCatalogItem[]> | ChartSeriesCatalogItem[];
+  search?(request: ChartSeriesCatalogRequest): Promise<ChartSeriesCatalogItem[]> | ChartSeriesCatalogItem[];
+  resolve(request: ChartSeriesResolveRequest): Promise<ResolvedSeries> | ResolvedSeries;
+}
+
+export interface ChartSeriesCapability extends PluginCapability {
+  readonly kind: "chart-series";
+  readonly provider: ChartSeriesProvider;
+}
+
 export interface CapabilityOperationManifest {
   id: string;
   kind: CapabilityOperationKind;
@@ -92,6 +133,17 @@ export interface CapabilityManifest {
 export interface CapabilityRegistryOptions {
   isPluginEnabled?(pluginId: string): boolean;
   isCapabilityEnabled?(capability: PluginCapability, pluginId: string): boolean;
+  connectionHealth?: ConnectionHealthRegistry;
+}
+
+export interface CapabilityInvoker {
+  capabilityManifests(kind?: string): CapabilityManifest[];
+  invokeCapability<T = unknown>(
+    capabilityId: string,
+    operationId: string,
+    payload: unknown,
+    options?: { signal?: AbortSignal },
+  ): Promise<T>;
 }
 
 export interface RegisteredCapability {