@forgecharts/sdk 1.1.27 → 1.1.28

package/src/api/DrawingManager.ts

@@ -1,188 +0,0 @@
-import type { Drawing, OHLCV } from '@forgecharts/types';
-import type { CoordTransform } from '../core/CoordTransform';
-import { HANDLE_HALF, HANDLE_FILL, HANDLE_STROKE } from './drawingUtils';
-
-let _counter = 0;
-function nextId(): string {
-  return `drawing_${(++_counter).toString().padStart(4, '0')}`;
-}
-
-// ─── Lines menu ───────────────────────────────────────────────────────────────
-import { renderTrendline }    from './drawing tools/lines menu/trendline';
-import { renderRay }          from './drawing tools/lines menu/ray';
-import { renderInfoLine }     from './drawing tools/lines menu/infoLine';
-import { renderExtendedLine } from './drawing tools/lines menu/extendedLine';
-import { renderTrendAngle }   from './drawing tools/lines menu/trendAngle';
-import { renderHorizontal }   from './drawing tools/lines menu/horizontal';
-import { renderVertical }     from './drawing tools/lines menu/vertical';
-import { renderHorizontalRay } from './drawing tools/lines menu/horizontalRay';
-import { renderCrossLine }    from './drawing tools/lines menu/crossLine';
-// Channels
-import { renderParallelChannel }  from './drawing tools/lines menu/parallelChannel';
-import { renderRegressionTrend }  from './drawing tools/lines menu/regressionTrend';
-import { renderFlatTopBottom }    from './drawing tools/lines menu/flatTopBottom';
-import { renderDisjointChannel }  from './drawing tools/lines menu/disjointChannel';
-// Pitchforks
-import { renderPitchfork }                from './drawing tools/lines menu/pitchfork';
-import { renderSchiffPitchfork }          from './drawing tools/lines menu/schiffPitchfork';
-import { renderModifiedSchiffPitchfork }  from './drawing tools/lines menu/modifiedSchiffPitchfork';
-import { renderInsidePitchfork }          from './drawing tools/lines menu/insidePitchfork';
-
-// ─── Shapes menu ─────────────────────────────────────────────────────────────
-import { renderRectangle } from './drawing tools/shapes menu/rectangle';
-import { renderText }      from './drawing tools/shapes menu/text';
-
-// ─── Fib & Gann menu ─────────────────────────────────────────────────────────
-import { renderFibRetracement } from './drawing tools/fib gann menu/fibRetracement';
-
-// ─── Internal dispatch ────────────────────────────────────────────────────────
-
-function _renderOne(ctx: CanvasRenderingContext2D, d: Drawing, t: CoordTransform, interval = '1h', candles: readonly OHLCV[] = []): void {
-  switch (d.type) {
-    // ── Lines menu ────────────────────────────────────────────────────────
-    case 'trendline':      renderTrendline(ctx, d, t);            break;
-    case 'ray':            renderRay(ctx, d, t);                  break;
-    case 'infoLine':       renderInfoLine(ctx, d, t, interval);   break;
-    case 'extendedLine':   renderExtendedLine(ctx, d, t);         break;
-    case 'trendAngle':     renderTrendAngle(ctx, d, t);           break;
-    case 'horizontal':     renderHorizontal(ctx, d, t);           break;
-    case 'vertical':       renderVertical(ctx, d, t);             break;
-    case 'horizontalRay':  renderHorizontalRay(ctx, d, t);        break;
-    case 'crossLine':      renderCrossLine(ctx, d, t);            break;
-    // Channels
-    case 'parallelChannel':  renderParallelChannel(ctx, d, t);   break;
-    case 'regressionTrend':  renderRegressionTrend(ctx, d, t, candles); break;
-    case 'flatTopBottom':    renderFlatTopBottom(ctx, d, t);      break;
-    case 'disjointChannel':  renderDisjointChannel(ctx, d, t);   break;
-    // Pitchforks
-    case 'pitchfork':               renderPitchfork(ctx, d, t);               break;
-    case 'schiffPitchfork':         renderSchiffPitchfork(ctx, d, t);         break;
-    case 'modifiedSchiffPitchfork': renderModifiedSchiffPitchfork(ctx, d, t); break;
-    case 'insidePitchfork':         renderInsidePitchfork(ctx, d, t);         break;
-    // ── Shapes menu ───────────────────────────────────────────────────────
-    case 'rectangle':      renderRectangle(ctx, d, t);            break;
-    case 'text':           renderText(ctx, d, t);                 break;
-    // ── Fib & Gann menu ───────────────────────────────────────────────────
-    case 'fibRetracement': renderFibRetracement(ctx, d, t);       break;
-  }
-}
-
-function _renderHandles(ctx: CanvasRenderingContext2D, d: Drawing, t: CoordTransform): void {
-  ctx.save();
-  ctx.setLineDash([]);
-  ctx.lineWidth = 1.5;
-  for (const p of d.points) {
-    const px = t.timeToX(p.time);
-    const py = t.priceToY(p.price);
-    ctx.fillStyle = HANDLE_FILL;
-    ctx.strokeStyle = HANDLE_STROKE;
-    ctx.beginPath();
-    ctx.rect(px - HANDLE_HALF, py - HANDLE_HALF, HANDLE_HALF * 2, HANDLE_HALF * 2);
-    ctx.fill();
-    ctx.stroke();
-  }
-  ctx.restore();
-}
-
-// ─── Public API ────────────────────────────────────────────────────────────────
-
-export class DrawingManager {
-  private readonly _map = new Map<string, Drawing>();
-
-  // ─── CRUD ──────────────────────────────────────────────────────────────────
-
-  add(drawing: Omit<Drawing, 'id'>): string {
-    const id = nextId();
-    this._map.set(id, { ...drawing, id });
-    return id;
-  }
-
-  remove(id: string): boolean {
-    return this._map.delete(id);
-  }
-
-  update(
-    id: string,
-    patches: Partial<Pick<Drawing, 'points' | 'color' | 'text' | 'visible' | 'lineWidth' | 'fillColor' | 'fillOpacity' | 'deviationMultiplier'>>,
-  ): boolean {
-    const d = this._map.get(id);
-    if (!d) return false;
-    this._map.set(id, { ...d, ...patches });
-    return true;
-  }
-
-  get(id: string): Drawing | undefined {
-    return this._map.get(id);
-  }
-
-  has(id: string): boolean {
-    return this._map.has(id);
-  }
-
-  all(): readonly Drawing[] {
-    return [...this._map.values()];
-  }
-
-  clear(): void {
-    this._map.clear();
-  }
-
-  // ─── Rendering ─────────────────────────────────────────────────────────────
-
-  render(
-    ctx: CanvasRenderingContext2D,
-    transform: CoordTransform,
-    selectedId: string | null = null,
-    interval = '1h',
-    candles: readonly OHLCV[] = [],
-  ): void {
-    ctx.save();
-    for (const d of this._map.values()) {
-      if (d.visible === false) continue;
-      ctx.strokeStyle = d.color ?? '#2196f3';
-      ctx.lineWidth = d.lineWidth ?? 1.5;
-      ctx.setLineDash([]);
-      ctx.globalAlpha = 1;
-      _renderOne(ctx, d, transform, interval, candles);
-      if (d.id === selectedId) {
-        // Heavier highlight pass
-        ctx.save();
-        ctx.strokeStyle = d.color ?? '#2196f3';
-        ctx.lineWidth = (d.lineWidth ?? 1.5) + 1;
-        ctx.globalAlpha = 0.4;
-        _renderOne(ctx, d, transform, interval, candles);
-        ctx.restore();
-        _renderHandles(ctx, d, transform);
-      }
-    }
-    ctx.restore();
-  }
-
-  renderPreview(
-    ctx: CanvasRenderingContext2D,
-    transform: CoordTransform,
-    draft: Omit<Drawing, 'id'>,
-    interval = '1h',
-    candles: readonly OHLCV[] = [],
-  ): void {
-    const d = { id: '__preview__', ...draft } as Drawing;
-    ctx.save();
-    ctx.globalAlpha = 0.65;
-    ctx.setLineDash([6, 4]);
-    ctx.strokeStyle = d.color ?? '#2196f3';
-    ctx.lineWidth = d.lineWidth ?? 1.5;
-    _renderOne(ctx, d, transform, interval, candles);
-    ctx.restore();
-  }
-
-  /** Returns anchor pixel positions — used by InteractionManager for handle hit-testing. */
-  static anchorPixels(
-    d: Drawing,
-    transform: CoordTransform,
-  ): Array<{ x: number; y: number }> {
-    return d.points.map((p) => ({
-      x: transform.timeToX(p.time),
-      y: transform.priceToY(p.price),
-    }));
-  }
-}

package/src/api/EventBus.ts

@@ -1,53 +0,0 @@
-import type { ChartEventMap } from '@forgecharts/types';
-
-type Handler<T> = (payload: T) => void;
-
-/**
- * EventBus — internal typed pub/sub used by TChart.
- *
- * All event keys are constrained to `keyof ChartEventMap`, giving
- * full type inference on payload shapes at every call site.
- */
-export class EventBus {
-  private readonly _listeners = new Map<
-    keyof ChartEventMap,
-    Set<Handler<unknown>>
-  >();
-
-  on<K extends keyof ChartEventMap>(event: K, handler: Handler<ChartEventMap[K]>): void {
-    if (!this._listeners.has(event)) {
-      this._listeners.set(event, new Set());
-    }
-    this._listeners.get(event)!.add(handler as Handler<unknown>);
-  }
-
-  off<K extends keyof ChartEventMap>(event: K, handler: Handler<ChartEventMap[K]>): void {
-    this._listeners.get(event)?.delete(handler as Handler<unknown>);
-  }
-
-  once<K extends keyof ChartEventMap>(event: K, handler: Handler<ChartEventMap[K]>): void {
-    const wrapper = (payload: ChartEventMap[K]): void => {
-      handler(payload);
-      this.off(event, wrapper);
-    };
-    this.on(event, wrapper);
-  }
-
-  emit<K extends keyof ChartEventMap>(event: K, payload: ChartEventMap[K]): void {
-    const handlers = this._listeners.get(event);
-    if (!handlers) return;
-    for (const h of handlers) {
-      try {
-        (h as Handler<ChartEventMap[K]>)(payload);
-      } catch (err) {
-        // Prevent one bad handler from breaking the others
-        console.error(`[ForgeCharts] Unhandled error in "${event}" listener`, err);
-      }
-    }
-  }
-
-  /** Removes all listeners — called on chart destruction. */
-  clear(): void {
-    this._listeners.clear();
-  }
-}

package/src/api/IndicatorDAG.ts

@@ -1,389 +0,0 @@
-/**
- * IndicatorDAG — Directed Acyclic Graph for indicator computation.
- *
- * Allows indicators to be chained: e.g. EMA can consume SMA's output instead
- * of raw OHLCV prices. Circular dependencies are rejected at registration time.
- * Results are cached and recomputed only when inputs actually change.
- *
- * Incremental fast-path: when a single bar is appended, SMA and EMA extend
- * their result by exactly one point in O(1) time.
- *
- * @example
- * ```ts
- * const dag = new IndicatorDAG();
- * dag.addNode('sma1', { type: 'sma', params: { period: 20 } });
- * dag.addNode('ema1', { type: 'ema', params: { period: 10 }, sourceId: 'sma1' });
- *
- * dag.execute(bars);                        // SMA first, then EMA(SMA)
- * const result = dag.getResult('ema1');     // { kind: 'series', points: [...] }
- * ```
- */
-
-import type { OHLCV, IndicatorConfig, PriceField } from '@forgecharts/types';
-import type { IndicatorPoint, MACDPoint } from '../core/IndicatorEngine';
-import {
-  extractField,
-  computeSMAFromSeries,
-  computeEMAFromSeries,
-  computeWMAFromSeries,
-  computeRSI,
-  computeMACD,
-  computeVolume,
-} from '../core/IndicatorEngine';
-import { TScriptIndicator } from '../tscript/TScriptIndicator';
-
-// ─── Public result type ────────────────────────────────────────────────────────
-
-/** Computed output of a single DAG node. */
-export type DAGResult =
-  | { readonly kind: 'series'; readonly points: readonly IndicatorPoint[] }
-  | { readonly kind: 'macd';   readonly points: readonly MACDPoint[]      };
-
-// ─── Internal ─────────────────────────────────────────────────────────────────
-
-type Node = {
-  id:           string;
-  config:       IndicatorConfig;
-  result:       DAGResult | null;
-  /** `bars.length` at the last successful execution. */
-  lastBarsLen:  number;
-  /** Source `IndicatorPoint[]` length at the last successful execution. */
-  lastInputLen: number;
-  /** Close price of the last bar at the last successful execution — detects forming-bar live ticks. */
-  lastBarClose: number;
-  dirty:        boolean;
-  /** Compiled TScript instance (only for type === 'script'). */
-  scriptRuntime?: TScriptIndicator;
-};
-
-function _configEqual(a: IndicatorConfig, b: IndicatorConfig): boolean {
-  return (
-    a.type        === b.type        &&
-    a.sourceId    === b.sourceId    &&
-    a.sourceField === b.sourceField &&
-    JSON.stringify(a.params) === JSON.stringify(b.params)
-  );
-}
-
-// ─── IndicatorDAG ─────────────────────────────────────────────────────────────
-
-export class IndicatorDAG {
-  private readonly _nodes = new Map<string, Node>();
-
-  // ─── Registration ───────────────────────────────────────────────────────────
-
-  /**
-   * Registers a node for `id`.
-   * If the node already exists its config is updated if changed.
-   * Throws `'[IndicatorDAG] Circular dependency detected'` if adding `id`
-   * would form a cycle.
-   */
-  addNode(id: string, config: IndicatorConfig): void {
-    const existing = this._nodes.get(id);
-    if (existing) {
-      if (!_configEqual(existing.config, config)) {
-        existing.config  = config;
-        existing.dirty   = true;
-        existing.result  = null;
-        this._markDependentsDirty(id);
-      }
-      return;
-    }
-
-    this._nodes.set(id, {
-      id,
-      config,
-      result:       null,
-      lastBarsLen:  -1,
-      lastInputLen: -1,
-      lastBarClose: NaN,
-      dirty:        true,
-    });
-
-    // Validate immediately — undo and rethrow if a cycle is formed.
-    try {
-      this._topoSort();
-    } catch (e) {
-      this._nodes.delete(id);
-      throw e;
-    }
-  }
-
-  /** Removes `id` and marks any indicators that depended on it as dirty. */
-  removeNode(id: string): void {
-    this._nodes.delete(id);
-    this._markDependentsDirty(id);
-  }
-
-  /**
-   * Syncs the DAG to exactly the provided indicator list.
-   * Adds new nodes, removes obsolete ones, updates changed configs.
-   * Throws if the resulting graph contains a cycle.
-   */
-  sync(
-    indicators: ReadonlyArray<{ readonly id: string; readonly config: IndicatorConfig }>,
-  ): void {
-    const incoming = new Set(indicators.map((i) => i.id));
-
-    // Remove nodes no longer present.
-    for (const id of [...this._nodes.keys()]) {
-      if (!incoming.has(id)) {
-        this._nodes.delete(id);
-        this._markDependentsDirty(id);
-      }
-    }
-
-    // Add or refresh nodes.
-    for (const { id, config } of indicators) {
-      const node = this._nodes.get(id);
-      if (!node) {
-        this._nodes.set(id, {
-          id,
-          config,
-          result:       null,
-          lastBarsLen:  -1,
-          lastInputLen: -1,
-          lastBarClose: NaN,
-          dirty:        true,
-        });
-      } else if (!_configEqual(node.config, config)) {
-        node.config  = config;
-        node.dirty   = true;
-        node.result  = null;
-        this._markDependentsDirty(id);
-      }
-    }
-
-    // Validate the whole graph (after all additions) — throws on cycle.
-    this._topoSort();
-  }
-
-  // ─── Execution ──────────────────────────────────────────────────────────────
-
-  /**
-   * Runs all dirty nodes in topological order.
-   *
-   * When the OHLCV array grew by exactly one bar since a node's last run and
-   * its input series also grew by one, SMA and EMA use an O(1) incremental
-   * append path. All other types fall back to a full recompute.
-   *
-   * @returns `true` if any node was executed.
-   */
-  execute(bars: readonly OHLCV[]): boolean {
-    const order = this._topoSort();
-    let executed = false;
-
-    for (const id of order) {
-      const node = this._nodes.get(id)!;
-      if (!this._needsRun(node, bars)) continue;
-
-      executed = true;
-      const input = this._resolveSource(node, bars);
-
-      const canIncremental =
-        node.result !== null &&
-        node.result.kind === 'series' &&
-        node.result.points.length > 0 &&
-        input.length === node.lastInputLen + 1 &&
-        bars.length  === node.lastBarsLen  + 1;
-
-      node.result = canIncremental
-        ? this._appendOne(node, input, node.result!.points as readonly IndicatorPoint[], bars)
-        : this._computeFull(node, input, bars);
-
-      node.dirty        = false;
-      node.lastBarsLen  = bars.length;
-      node.lastInputLen = input.length;
-      node.lastBarClose = bars.length > 0 ? bars[bars.length - 1]!.close : NaN;
-    }
-
-    return executed;
-  }
-
-  /** Forces every node to recompute on the next `execute()` call. */
-  invalidateAll(): void {
-    for (const node of this._nodes.values()) {
-      node.dirty = true;
-    }
-  }
-
-  isDirty(): boolean {
-    return [...this._nodes.values()].some((n) => n.dirty);
-  }
-
-  // ─── Results ────────────────────────────────────────────────────────────────
-
-  getResult(id: string): DAGResult | null {
-    return this._nodes.get(id)?.result ?? null;
-  }
-
-  getAllResults(): ReadonlyMap<string, DAGResult> {
-    const out = new Map<string, DAGResult>();
-    for (const [id, node] of this._nodes) {
-      if (node.result !== null) out.set(id, node.result);
-    }
-    return out;
-  }
-
-  // ─── Topological sort (Kahn's algorithm) ────────────────────────────────────
-
-  /**
-   * Returns node ids in topological execution order.
-   * Throws `'[IndicatorDAG] Circular dependency detected'` when a cycle exists.
-   */
-  private _topoSort(): string[] {
-    const inDeg = new Map<string, number>();
-    const adj   = new Map<string, string[]>(); // sourceId → dependent ids
-
-    for (const node of this._nodes.values()) {
-      if (!inDeg.has(node.id)) inDeg.set(node.id, 0);
-      const src = node.config.sourceId;
-      if (src !== undefined && this._nodes.has(src)) {
-        if (!adj.has(src)) adj.set(src, []);
-        adj.get(src)!.push(node.id);
-        inDeg.set(node.id, (inDeg.get(node.id) ?? 0) + 1);
-      }
-    }
-
-    const queue = [...this._nodes.keys()].filter((id) => (inDeg.get(id) ?? 0) === 0);
-    const order: string[] = [];
-
-    while (queue.length > 0) {
-      const curr = queue.shift()!;
-      order.push(curr);
-      for (const dep of adj.get(curr) ?? []) {
-        const d = (inDeg.get(dep) ?? 0) - 1;
-        inDeg.set(dep, d);
-        if (d === 0) queue.push(dep);
-      }
-    }
-
-    if (order.length !== this._nodes.size) {
-      throw new Error('[IndicatorDAG] Circular dependency detected');
-    }
-    return order;
-  }
-
-  // ─── Private helpers ────────────────────────────────────────────────────────
-
-  private _needsRun(node: Node, bars: readonly OHLCV[]): boolean {
-    if (node.dirty || node.result === null) return true;
-    if (bars.length !== node.lastBarsLen)   return true;
-    // Rerun when the forming bar's close has changed (live WS tick updating in-place).
-    if (bars.length > 0 && bars[bars.length - 1]!.close !== node.lastBarClose) return true;
-    // Rerun if the source indicator has newer data.
-    const srcId = node.config.sourceId;
-    if (srcId !== undefined) {
-      const src = this._nodes.get(srcId);
-      if (src && src.lastBarsLen !== node.lastBarsLen) return true;
-    }
-    return false;
-  }
-
-  /** Returns the ordered input series for `node` — either from a source indicator or raw price field. */
-  private _resolveSource(node: Node, bars: readonly OHLCV[]): readonly IndicatorPoint[] {
-    const srcId = node.config.sourceId;
-    if (srcId !== undefined) {
-      const src = this._nodes.get(srcId);
-      if (src?.result?.kind === 'series') return src.result.points;
-      // Source is missing, MACD, or not yet computed — fall through to raw bars.
-    }
-    const field: PriceField = node.config.sourceField ?? 'close';
-    return bars.map((b) => ({ time: b.time, value: extractField(b, field) }));
-  }
-
-  /** Full recompute of a node's result. */
-  private _computeFull(
-    node:  Node,
-    input: readonly IndicatorPoint[],
-    bars:  readonly OHLCV[],
-  ): DAGResult {
-    const p = (node.config.params ?? {}) as Record<string, number>;
-    switch (node.config.type) {
-      case 'sma':
-        return { kind: 'series', points: computeSMAFromSeries(input, p['period'] ?? 20) };
-      case 'ema':
-        return { kind: 'series', points: computeEMAFromSeries(input, p['period'] ?? 20) };
-      case 'wma':
-        return { kind: 'series', points: computeWMAFromSeries(input, p['period'] ?? 20) };
-      case 'rsi':
-        return { kind: 'series', points: computeRSI(bars, p['period'] ?? 14) };
-      case 'volume':
-        return { kind: 'series', points: computeVolume(bars) };
-      case 'macd':
-        return {
-          kind:   'macd',
-          points: computeMACD(bars, p['fast'] ?? 12, p['slow'] ?? 26, p['signal'] ?? 9),
-        };
-      case 'bbands': {
-        // Bollinger Bands — represented as three series; store middle band as primary.
-        const period = p['period'] ?? 20;
-        const sma    = computeSMAFromSeries(input, period);
-        return { kind: 'series', points: sma }; // renderer handles bbands specially
-      }
-      case 'script': {
-        const src = node.config.script;
-        if (!src) return { kind: 'series', points: [] };
-        // Compile once, reuse across bars.
-        if (!node.scriptRuntime) {
-          node.scriptRuntime = new TScriptIndicator(src);
-        }
-        const plots = node.scriptRuntime.run(bars);
-        // First plot() call becomes the primary series.
-        return { kind: 'series', points: plots[0] ?? [] };
-      }
-      default:
-        // Identity passthrough for unknown / future types.
-        return { kind: 'series', points: [...input] };
-    }
-  }
-
-  /**
-   * O(1) append of a single new point.
-   * Only called when `canIncremental` is true (input grew by exactly one element).
-   * Falls back to `_computeFull` for types that have no O(1) path.
-   */
-  private _appendOne(
-    node:  Node,
-    input: readonly IndicatorPoint[],
-    prev:  readonly IndicatorPoint[],
-    bars:  readonly OHLCV[],
-  ): DAGResult {
-    const p    = (node.config.params ?? {}) as Record<string, number>;
-    const last = input[input.length - 1]!;
-
-    switch (node.config.type) {
-      case 'sma': {
-        const period = p['period'] ?? 20;
-        if (input.length < period || prev.length === 0) {
-          return this._computeFull(node, input, bars);
-        }
-        // O(1): newSMA = (prevSMA * period - outgoing + incoming) / period
-        const prevSMA   = prev[prev.length - 1]!.value;
-        const outgoing  = input[input.length - 1 - period]?.value ?? 0;
-        const newValue  = (prevSMA * period - outgoing + last.value) / period;
-        return { kind: 'series', points: [...prev, { time: last.time, value: newValue }] };
-      }
-      case 'ema': {
-        const period  = p['period'] ?? 20;
-        const k       = 2 / (period + 1);
-        const prevEMA = prev[prev.length - 1]!.value;
-        const newValue = last.value * k + prevEMA * (1 - k);
-        return { kind: 'series', points: [...prev, { time: last.time, value: newValue }] };
-      }
-      default:
-        return this._computeFull(node, input, bars);
-    }
-  }
-
-  /** Recursively marks all indicators that depend on `sourceId` as dirty. */
-  private _markDependentsDirty(sourceId: string): void {
-    for (const node of this._nodes.values()) {
-      if (node.config.sourceId === sourceId && !node.dirty) {
-        node.dirty  = true;
-        node.result = null;
-        this._markDependentsDirty(node.id);
-      }
-    }
-  }
-}

package/src/api/IndicatorRegistry.ts

@@ -1,47 +0,0 @@
-import type { IndicatorConfig, IndicatorInstance } from '@forgecharts/types';
-
-let _counter = 0;
-function nextId(): string {
-  return `indicator_${(++_counter).toString().padStart(4, '0')}`;
-}
-
-/**
- * IndicatorRegistry — tracks active indicator instances for a chart.
- * Rendering is a separate concern (handled by sub-pane renderers, out of SDK scope).
- */
-export class IndicatorRegistry {
-  private readonly _map = new Map<string, IndicatorInstance>();
-
-  /**
-   * Registers a new indicator and returns its opaque id.
-   */
-  add(config: IndicatorConfig): string {
-    const id = nextId();
-    this._map.set(id, { id, config });
-    return id;
-  }
-
-  /**
-   * Removes an indicator by id.
-   * @returns `true` if the indicator existed and was removed.
-   */
-  remove(id: string): boolean {
-    return this._map.delete(id);
-  }
-
-  get(id: string): IndicatorInstance | undefined {
-    return this._map.get(id);
-  }
-
-  has(id: string): boolean {
-    return this._map.has(id);
-  }
-
-  all(): readonly IndicatorInstance[] {
-    return [...this._map.values()];
-  }
-
-  clear(): void {
-    this._map.clear();
-  }
-}