@forgecharts/sdk 1.1.27 → 1.1.29

package/dist/tools/barDivergenceCheck.d.ts

@@ -0,0 +1,120 @@
+/**
+ * First-Divergence Bar Comparison Tool
+ *
+ * Compares OHLCV bars from multiple data sources (provider REST, database,
+ * aggregated from 1m, SDK engine) and reports the **first** mismatch found.
+ *
+ * Usage:
+ *
+ *   import { compareSources, checkAllSources, formatReport } from '@forgecharts/sdk/tools/barDivergenceCheck';
+ *
+ *   const report = compareSources(
+ *     { source: 'provider',   bars: providerBars   },
+ *     { source: 'database',   bars: databaseBars   },
+ *     '1h',
+ *     'BINANCE:BTCUSDT',
+ *     from,
+ *     to,
+ *   );
+ *
+ *   if (report.diverged) console.log(formatReport(report));
+ *
+ * All bar arrays are expected to contain Unix **second** timestamps in the
+ * `time` field (matching the CandleBar.time convention).  Use `from`/`to`
+ * as Unix seconds to scope the comparison window.
+ */
+/** Identifies which pipeline stage produced a bar array. */
+export type BarSource = 'provider' | 'database' | 'aggregated' | 'sdk';
+/** Minimal OHLCV shape accepted by the divergence checker. */
+export interface OhlcvBar {
+    /** Unix seconds (same as CandleBar.time). */
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+/** A labelled set of bars from one pipeline source. */
+export interface SourceBars {
+    source: BarSource;
+    bars: readonly OhlcvBar[];
+}
+/** A single field-level difference between two bars at the same timestamp. */
+export interface FieldDiff {
+    field: 'open' | 'high' | 'low' | 'close' | 'volume';
+    valueA: number;
+    valueB: number;
+    /** valueA − valueB */
+    delta: number;
+}
+/** Full description of a single mismatched candle. */
+export interface BarMismatch {
+    /** Unix seconds — the candle open time where divergence was first detected. */
+    time: number;
+    /** Canonical candle-open boundary in milliseconds for the given timeframe. */
+    bucketStartMs: number;
+    sourceA: BarSource;
+    sourceB: BarSource;
+    /** OHLCV field deltas — empty when the only problem is a missing bar. */
+    differences: FieldDiff[];
+    /**
+     * True when the two bars carry the same `time` but their canonical
+     * `bucketStart` values differ — indicates a misaligned timestamp on one side.
+     */
+    bucketMismatch: boolean;
+    /** Human-readable diagnostic notes. */
+    notes: string[];
+}
+/** Summary of a pairwise source comparison. */
+export interface DivergenceReport {
+    symbol: string;
+    timeframe: string;
+    /** Unix seconds — inclusive window start. */
+    from: number;
+    /** Unix seconds — inclusive window end. */
+    to: number;
+    diverged: boolean;
+    /** The first mismatch found, or null when the sources are identical. */
+    firstMismatch: BarMismatch | null;
+    totalMismatches: number;
+    /** Number of bars from source A inside [from, to]. */
+    sourceACount: number;
+    /** Number of bars from source B inside [from, to]. */
+    sourceBCount: number;
+}
+/**
+ * Compare all timestamps from both sources inside [from, to] and return the
+ * first mismatch found, scanning oldest-first.
+ *
+ * Mismatch criteria (any one triggers a report):
+ *   1. Bar present in one source but absent in the other.
+ *   2. OHLCV field values differ by more than floating-point epsilon.
+ *   3. Canonical `getBucketStart` for the bar's time differs between sources
+ *      (indicates one source has a misaligned timestamp).
+ *
+ * @param a          Source A bars.
+ * @param b          Source B bars.
+ * @param timeframe  Canonical timeframe label (e.g. `'1h'`, `'1w'`).
+ * @param symbol     Symbol string — stored in the report for identification.
+ * @param from       Window start, Unix seconds (inclusive).
+ * @param to         Window end, Unix seconds (inclusive).
+ */
+export declare function compareSources(a: SourceBars, b: SourceBars, timeframe: string, symbol: string, from: number, to: number): DivergenceReport;
+/**
+ * Run all pairwise comparisons across every combination of the provided sources.
+ *
+ * For N sources this produces N*(N-1)/2 reports.  Use `formatReport` to render
+ * each one for console output.
+ */
+export declare function checkAllSources(sources: SourceBars[], symbol: string, timeframe: string, from: number, to: number): DivergenceReport[];
+/**
+ * Render a `DivergenceReport` as a multi-line human-readable string suitable
+ * for console output or log files.
+ *
+ * @example
+ * const report = compareSources(a, b, '1h', 'BINANCE:BTCUSDT', from, to);
+ * console.log(formatReport(report));
+ */
+export declare function formatReport(report: DivergenceReport): string;
+//# sourceMappingURL=barDivergenceCheck.d.ts.map

package/dist/tools/barDivergenceCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"barDivergenceCheck.d.ts","sourceRoot":"","sources":["../../src/tools/barDivergenceCheck.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAMH,4DAA4D;AAC5D,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,KAAK,CAAC;AAEvE,8DAA8D;AAC9D,MAAM,WAAW,QAAQ;IACvB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,uDAAuD;AACvD,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;CAC3B;AAED,8EAA8E;AAC9E,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,SAAS,CAAC;IACnB,OAAO,EAAE,SAAS,CAAC;IACnB,yEAAyE;IACzE,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,uCAAuC;IACvC,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,CAAC;IAClB,wEAAwE;IACxE,aAAa,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,YAAY,EAAE,MAAM,CAAC;CACtB;AAwBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,gBAAgB,CAmGlB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,UAAU,EAAE,EACrB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,gBAAgB,EAAE,CAQpB;AAID;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CA6B7D"}

package/dist/trading/TradingOverlayStore.d.ts

@@ -0,0 +1,86 @@
+/**
+ * TradingOverlayStore
+ *
+ * Shared, mode-agnostic store for trade overlay state.
+ * Used by both unmanaged mode (externally supplied data) and managed mode
+ * (internally generated data from the managed trading service).
+ *
+ * Supports:
+ *   - Full replace  (setOrders / setPositions)
+ *   - Incremental   (upsertOrder / upsertPosition / pushExecution)
+ *   - Remove by id  (removeOrder / removePosition)
+ *
+ * Subscribers are notified via callbacks registered with onChange().
+ * The store is intentionally free of React/DOM dependencies so it can be
+ * consumed from any rendering layer (canvas, React, etc.).
+ *
+ * @example
+ * ```ts
+ * const store = new TradingOverlayStore();
+ *
+ * // Subscribe to changes (e.g. trigger a canvas repaint)
+ * store.onChange(() => chart.markDirty());
+ *
+ * // Feed data
+ * store.setOrders([...]);
+ * store.upsertOrder({ id: 'o1', role: 'entry', side: 'buy', ... });
+ * store.removeOrder('o1');
+ * ```
+ */
+import type { ChartOrder, ChartPosition, ExecutionFill } from './tradingTypes';
+type ChangeListener = () => void;
+export declare class TradingOverlayStore {
+    private _orders;
+    private _positions;
+    private _fills;
+    private _listeners;
+    /**
+     * Register a callback that fires whenever any state changes.
+     * Returns an unsubscribe function.
+     */
+    onChange(listener: ChangeListener): () => void;
+    private _notify;
+    /** Replace the entire order set. */
+    setOrders(orders: ChartOrder[]): void;
+    /**
+     * Insert or replace a single order.
+     * Matching is done by `order.id`.
+     */
+    upsertOrder(order: ChartOrder): void;
+    /** Remove an order by id. Silent no-op if not found. */
+    removeOrder(orderId: string): void;
+    /** Returns a snapshot of all orders as an array (insertion order). */
+    getOrders(): ChartOrder[];
+    /** Returns orders that share the given `groupId`. */
+    getOrdersByGroup(groupId: string): ChartOrder[];
+    /** Replace the entire position set. */
+    setPositions(positions: ChartPosition[]): void;
+    /**
+     * Insert or replace a single position.
+     * Matching is done by `position.id`.
+     */
+    upsertPosition(position: ChartPosition): void;
+    /** Remove a position by id. Silent no-op if not found. */
+    removePosition(positionId: string): void;
+    /** Returns a snapshot of all positions as an array (insertion order). */
+    getPositions(): ChartPosition[];
+    /**
+     * Append an execution fill to the fill log.
+     * Fills are append-only — they are never updated or removed.
+     */
+    pushExecution(fill: ExecutionFill): void;
+    /** Returns all fills in insertion (chronological) order. */
+    getFills(): readonly ExecutionFill[];
+    /** Returns fills associated with a specific order id. */
+    getFillsByOrder(orderId: string): ExecutionFill[];
+    /** Wipes all overlay state (orders, positions, fills). */
+    clear(): void;
+    /** Returns the full overlay state as a plain object — useful for debug / serialisation. */
+    snapshot(): {
+        orders: ChartOrder[];
+        positions: ChartPosition[];
+        fills: readonly ExecutionFill[];
+    };
+}
+export {};
+//# sourceMappingURL=TradingOverlayStore.d.ts.map

package/dist/trading/TradingOverlayStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TradingOverlayStore.d.ts","sourceRoot":"","sources":["../../src/trading/TradingOverlayStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/E,KAAK,cAAc,GAAG,MAAM,IAAI,CAAC;AAEjC,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAoC;IACnD,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,MAAM,CAA4B;IAE1C,OAAO,CAAC,UAAU,CAAwB;IAI1C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,IAAI;IAO9C,OAAO,CAAC,OAAO;IAMf,oCAAoC;IACpC,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;IAMrC;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAKpC,wDAAwD;IACxD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIlC,sEAAsE;IACtE,SAAS,IAAI,UAAU,EAAE;IAIzB,qDAAqD;IACrD,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE;IAM/C,uCAAuC;IACvC,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,IAAI;IAM9C;;;OAGG;IACH,cAAc,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAK7C,0DAA0D;IAC1D,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIxC,yEAAyE;IACzE,YAAY,IAAI,aAAa,EAAE;IAM/B;;;OAGG;IACH,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAKxC,4DAA4D;IAC5D,QAAQ,IAAI,SAAS,aAAa,EAAE;IAIpC,yDAAyD;IACzD,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE;IAMjD,0DAA0D;IAC1D,KAAK,IAAI,IAAI;IASb,2FAA2F;IAC3F,QAAQ,IAAI;QAAE,MAAM,EAAE,UAAU,EAAE,CAAC;QAAC,SAAS,EAAE,aAAa,EAAE,CAAC;QAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAA;KAAE;CAOlG"}

package/dist/trading/UnmanagedIngestion.d.ts

@@ -0,0 +1,91 @@
+/**
+ * UnmanagedIngestion
+ *
+ * External candle data ingestion for unmanaged mode.
+ *
+ * In unmanaged mode the client owns their data pipeline. They pass
+ * normalised candle data to us; this layer validates the license gate,
+ * delegates to the existing CandleEngine for bucket management, and
+ * notifies callers via callbacks mirroring the CandleEngine contract.
+ *
+ * Critical constraint: the default RapidAPI-backed datafeed is completely
+ * untouched. UnmanagedIngestion is an additive, opt-in path.
+ *
+ * Candle rules (matches CandleEngine behaviour):
+ *   same timeMs   → update current candle
+ *   newer timeMs  → append / new bucket
+ *   older timeMs  → silently ignored (logged in debug mode)
+ *
+ * @example
+ * ```ts
+ * const ingestion = new UnmanagedIngestion('1m', {
+ *   onBarUpdated: (bar) => series.update(bar),
+ *   onResync:     (bars) => series.setData(bars),
+ * });
+ *
+ * // Feed a full history snapshot first
+ * ingestion.setHistory(historicalBars);
+ *
+ * // Then stream live ticks
+ * ingestion.pushCandle(latestBar);
+ * ```
+ */
+import type { CandleBar, UpdateResult, GapInfo } from '../engine/CandleEngine';
+import type { CandleInput } from './tradingTypes';
+import type { Timeframe } from '@forgecharts/types';
+export interface UnmanagedIngestionOptions {
+    /** Enable debug logging on the underlying CandleEngine. */
+    debug?: boolean;
+    /**
+     * Fired after every bar mutation (update or append from a live push).
+     * Corresponds to CandleEngine.onBarUpdated.
+     */
+    onBarUpdated?: (bar: CandleBar, result: UpdateResult) => void;
+    /**
+     * Fired when the full bar array changes (after setHistory or gap backfill).
+     * The chart adapter should call `series.setData(bars)`.
+     */
+    onResync?: (bars: readonly CandleBar[]) => void;
+    /** Fired when a candle bucket closes. */
+    onBarClosed?: (bar: CandleBar) => void;
+    /** Fired when the engine detects skipped buckets in the live stream. */
+    onGapDetected?: (info: GapInfo) => void;
+}
+export declare class UnmanagedIngestion {
+    private readonly _engine;
+    private readonly _opts;
+    private _timeframe;
+    constructor(timeframe: Timeframe, opts?: UnmanagedIngestionOptions);
+    private _assertUnmanaged;
+    /**
+     * Load a full historical bar snapshot.
+     * Replaces the engine's bar array and triggers `onResync` so the chart
+     * series is fully redrawn.
+     *
+     * Call this once at startup (or on symbol/interval change) before
+     * streaming live candles via `pushCandle`.
+     *
+     * @throws If the active license is not in unmanaged mode.
+     */
+    setHistory(bars: CandleInput[]): void;
+    /**
+     * Push a single live candle tick.
+     *
+     * Behaviour follows CandleEngine rules:
+     *   - same bucket  → updates existing bar (OHLCV merging)
+     *   - new bucket   → appends a new bar (previous bar is finalised)
+     *   - older bucket → silently ignored; debug-logged when `debug: true`
+     *
+     * @throws If the active license is not in unmanaged mode.
+     */
+    pushCandle(bar: CandleInput): UpdateResult;
+    /** Returns the current bar array (chronological, ascending). */
+    getBars(): readonly CandleBar[];
+    /** Returns the latest candle, or null if no data has been loaded. */
+    getLatestBar(): CandleBar | null;
+    /** Changes the active timeframe and clears all bar data. */
+    setTimeframe(timeframe: Timeframe): void;
+    /** Clears all bars (e.g. on symbol change before calling setHistory again). */
+    reset(): void;
+}
+//# sourceMappingURL=UnmanagedIngestion.d.ts.map

package/dist/trading/UnmanagedIngestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnmanagedIngestion.d.ts","sourceRoot":"","sources":["../../src/trading/UnmanagedIngestion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAE/E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,WAAW,yBAAyB;IACxC,2DAA2D;IAC3D,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAE9D;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,KAAK,IAAI,CAAC;IAEhD,yCAAyC;IACzC,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,IAAI,CAAC;IAEvC,wEAAwE;IACxE,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACzC;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAClD,OAAO,CAAC,UAAU,CAAY;gBAElB,SAAS,EAAE,SAAS,EAAE,IAAI,GAAE,yBAA8B;IAgBtE,OAAO,CAAC,gBAAgB;IAWxB;;;;;;;;;OASG;IACH,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,IAAI;IAYrC;;;;;;;;;OASG;IACH,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY;IAO1C,gEAAgE;IAChE,OAAO,IAAI,SAAS,SAAS,EAAE;IAI/B,qEAAqE;IACrE,YAAY,IAAI,SAAS,GAAG,IAAI;IAKhC,4DAA4D;IAC5D,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAMxC,+EAA+E;IAC/E,KAAK,IAAI,IAAI;CAGd"}

package/dist/trading/__tests__/ManagedTradingController.test.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ManagedTradingController — unit tests
+ *
+ * Covers:
+ *   - Cannot initialize (registerProvider) in unmanaged mode
+ *   - Can initialize in managed mode
+ *   - isReady() reflects provider registration state
+ *   - placeOrder() throws without a provider
+ *   - placeOrder() with a mock provider: writes optimistic overlay entry,
+ *     updates with provider id on success, rolls back on failure
+ *   - cancelOrder() updates overlay status to 'cancelled'
+ *   - modifyOrder() patches price / qty / label in overlay
+ *   - placeBracketOrder() creates 3 orders with the same groupId in the overlay
+ *   - reportFill() pushes to overlay + updates order status
+ *   - All methods blocked in unmanaged mode
+ */
+export {};
+//# sourceMappingURL=ManagedTradingController.test.d.ts.map

package/dist/trading/__tests__/ManagedTradingController.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManagedTradingController.test.d.ts","sourceRoot":"","sources":["../../../src/trading/__tests__/ManagedTradingController.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}

package/dist/trading/__tests__/TradingOverlayStore.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TradingOverlayStore — unit tests
+ *
+ * Covers:
+ *   - Orders: set, upsert, remove, getByGroup
+ *   - Positions: set, upsert, remove
+ *   - Fills: push, getFills, getFillsByOrder
+ *   - clear() resets everything
+ *   - snapshot() reflects current state
+ *   - onChange subscriber fires on every mutation
+ *   - Both unmanaged and managed pathways can write into the same store
+ *   - groupId-based linked orders coexist correctly
+ *   - TP / SL / entry roles are stored verbatim
+ */
+export {};
+//# sourceMappingURL=TradingOverlayStore.test.d.ts.map

package/dist/trading/__tests__/TradingOverlayStore.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TradingOverlayStore.test.d.ts","sourceRoot":"","sources":["../../../src/trading/__tests__/TradingOverlayStore.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/trading/__tests__/UnmanagedIngestion.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * UnmanagedIngestion — unit tests
+ *
+ * Covers:
+ *   - setHistory loads bars in ascending order
+ *   - pushCandle appends a new bar
+ *   - pushCandle updates the current bar when same bucket
+ *   - getLatestBar returns correct data
+ *   - getBars() returns the full bar array
+ *   - setTimeframe clears bars and resets engine
+ *   - reset() wipes all bars
+ *   - Throws when called in managed mode
+ *   - onBarUpdated / onResync callbacks fire correctly
+ */
+export {};
+//# sourceMappingURL=UnmanagedIngestion.test.d.ts.map

package/dist/trading/__tests__/UnmanagedIngestion.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnmanagedIngestion.test.d.ts","sourceRoot":"","sources":["../../../src/trading/__tests__/UnmanagedIngestion.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/trading/managed/ManagedTradingController.d.ts

@@ -0,0 +1,110 @@
+/**
+ * ManagedTradingController
+ *
+ * The single managed-mode entry point for order routing.
+ *
+ * Responsibilities:
+ *  1. Enforce license/capability gates before any action.
+ *  2. Delegate execution to the registered IExecutionProvider.
+ *  3. Write results (orders, fills, positions) into the shared TradingOverlayStore
+ *     so managed and unmanaged modes share one visual layer.
+ *
+ * STUB STATUS
+ * ──────────────────────────────────────────────────────────────────────────────
+ * All execution methods are implemented as stubs that:
+ *   a) enforce license gates (will throw today if called without managed mode)
+ *   b) throw NotImplementedError when no provider is registered
+ *   c) are annotated with TODO markers for the implementation phase
+ *
+ * To implement a real provider, create a class implementing IExecutionProvider
+ * and call:
+ *   controller.registerProvider(new MyBrokerProvider(...));
+ *
+ * The controller will then delegate to it automatically.
+ * ──────────────────────────────────────────────────────────────────────────────
+ */
+import type { TradingOverlayStore } from '../TradingOverlayStore';
+import type { ExecutionFill } from '../tradingTypes';
+import type { IExecutionProvider, PlaceOrderInput, ModifyOrderInput, PlaceBracketOrderInput, OrderAck, BracketOrderAck } from './managedTypes';
+export declare class ManagedTradingController {
+    private _provider;
+    private readonly _store;
+    constructor(store: TradingOverlayStore);
+    /**
+     * Register the execution provider that will handle order routing.
+     *
+     * Call this before any order placement methods.  Only one provider may be
+     * active at a time — calling this again replaces the previous provider.
+     *
+     * @example
+     * ```ts
+     * import { RithmicProvider } from '@forgecharts/rithmic';
+     * controller.registerProvider(new RithmicProvider(credentials));
+     * ```
+     */
+    registerProvider(provider: IExecutionProvider): void;
+    /** Returns the id of the currently registered provider, or null if none. */
+    getProviderId(): string | null;
+    /** True when a provider is registered and managed trading is licensed. */
+    isReady(): boolean;
+    /**
+     * Place a single order via the registered execution provider.
+     *
+     * On success:
+     *   - Upserts a ChartOrder into the overlay store (status: 'pending' → 'open').
+     *   - Returns the provider acknowledgement.
+     *
+     * @throws If not in managed mode, orderEntry feature is off, or no provider.
+     *
+     * TODO: After provider.placeOrder resolves, subscribe to order status updates
+     *       (provider event stream) and call _store.upsertOrder() as status changes.
+     */
+    placeOrder(input: PlaceOrderInput): Promise<OrderAck>;
+    /**
+     * Cancel a working order by its provider-assigned id.
+     *
+     * On success:
+     *   - Updates the order status in the overlay store to 'cancelled'.
+     *
+     * @throws If not in managed mode, orderEntry feature is off, or no provider.
+     *
+     * TODO: Remove the overlay entry after a configurable delay (so the line
+     *       visually fades out rather than disappearing instantly).
+     */
+    cancelOrder(orderId: string): Promise<void>;
+    /**
+     * Modify a working order in place.
+     *
+     * On success:
+     *   - Updates the ChartOrder price/qty in the overlay store.
+     *
+     * @throws If not in managed mode, orderEntry feature is off, or no provider.
+     *
+     * TODO: Validate that the modified price is within instrument tick constraints
+     *       before forwarding to the provider.
+     */
+    modifyOrder(orderId: string, updates: ModifyOrderInput): Promise<OrderAck>;
+    /**
+     * Place a bracket order: entry + stop-loss + optional take-profit.
+     *
+     * On success:
+     *   - Upserts all bracket legs as ChartOrders sharing the same groupId.
+     *   - Returns acknowledgements for each leg.
+     *
+     * @throws If not in managed mode, bracketOrders feature is off, or no provider.
+     *
+     * TODO: Expose drag handles for each bracket leg in the chart overlay so
+     *       users can adjust prices before confirming.
+     */
+    placeBracketOrder(input: PlaceBracketOrderInput): Promise<BracketOrderAck>;
+    /**
+     * Report an execution fill received from the provider's event stream.
+     *
+     * Writes the fill into the overlay store and updates the parent order status.
+     * Called by the provider adapter whenever a fill notification arrives.
+     *
+     * TODO: Also update the related ChartPosition (create new or update qty/avgPrice).
+     */
+    reportFill(fill: ExecutionFill): void;
+}
+//# sourceMappingURL=ManagedTradingController.d.ts.map

package/dist/trading/managed/ManagedTradingController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManagedTradingController.d.ts","sourceRoot":"","sources":["../../../src/trading/managed/ManagedTradingController.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAc,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,QAAQ,EACR,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAsBxB,qBAAa,wBAAwB;IAEnC,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAEjC,KAAK,EAAE,mBAAmB;IAMtC;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAKpD,4EAA4E;IAC5E,aAAa,IAAI,MAAM,GAAG,IAAI;IAI9B,0EAA0E;IAC1E,OAAO,IAAI,OAAO;IAMlB;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAqC3D;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAajD;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAoBhF;;;;;;;;;;;OAWG;IACG,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC;IAuDhF;;;;;;;OAOG;IACH,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;CAetC"}

package/dist/trading/managed/managedCapabilities.d.ts

@@ -0,0 +1,45 @@
+/**
+ * managedCapabilities.ts
+ *
+ * Feature-gate helpers specific to managed trading.
+ * Thin wrappers around ChartRuntimeResolver that produce clear, actionable
+ * error messages when a managed method is called without a suitable license.
+ *
+ * Usage (inside a managed trading method):
+ *
+ *   assertManagedMode();              // throws if not in managed mode
+ *   assertCanPlaceOrders();           // throws if orderEntry flag is off
+ *   assertCanUseBrackets();           // throws if bracketOrders flag is off
+ *   assertCanUseDraggableOrders();    // throws if draggableOrders flag is off
+ */
+/**
+ * Asserts that the active license is in managed mode.
+ * @throws {Error} with a clear message if mode is unmanaged.
+ */
+export declare function assertManagedMode(): void;
+/**
+ * Asserts that the license permits order placement (orderEntry feature).
+ * Implicitly checks managed mode first.
+ */
+export declare function assertCanPlaceOrders(): void;
+/**
+ * Asserts that the license permits bracket / OCO orders.
+ * Implicitly checks managed mode and order entry first.
+ */
+export declare function assertCanUseBrackets(): void;
+/**
+ * Asserts that the license permits drag-to-price order placement.
+ * Implicitly checks managed mode and order entry first.
+ */
+export declare function assertCanUseDraggableOrders(): void;
+/**
+ * Asserts that the license permits the managed trading service hooks.
+ * Implicitly checks managed mode first.
+ */
+export declare function assertCanUseManagedTrading(): void;
+export declare const isManagedCapable: () => boolean;
+export declare const canPlaceOrders: () => boolean;
+export declare const canPlaceBrackets: () => boolean;
+export declare const canUseDraggable: () => boolean;
+export declare const canUseManagedTradingHook: () => boolean;
+//# sourceMappingURL=managedCapabilities.d.ts.map

package/dist/trading/managed/managedCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managedCapabilities.d.ts","sourceRoot":"","sources":["../../../src/trading/managed/managedCapabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAQ3C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAQ3C;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAQlD;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAQjD;AAID,eAAO,MAAM,gBAAgB,QAAe,OAAqC,CAAC;AAClF,eAAO,MAAM,cAAc,QAAiB,OAAsE,CAAC;AACnH,eAAO,MAAM,gBAAgB,QAAe,OAA+D,CAAC;AAC5G,eAAO,MAAM,eAAe,QAAgB,OAAiE,CAAC;AAC9G,eAAO,MAAM,wBAAwB,QAAO,OAA0E,CAAC"}

package/dist/trading/managed/managedTypes.d.ts

@@ -0,0 +1,122 @@
+/**
+ * managedTypes.ts
+ *
+ * Input/output types specific to the managed trading flow.
+ * These are the shapes that callers pass into ManagedTradingController and
+ * that execution providers will eventually consume.
+ *
+ * Shared overlay types (ChartOrder, ChartPosition, ExecutionFill) are in
+ * ../tradingTypes — managed trading WRITES to those shapes, it does not
+ * define its own parallel set.
+ */
+import type { OrderSide } from '../tradingTypes';
+/** Time-in-force policy for managed orders. */
+export type TimeInForce = 'GTC' | 'IOC' | 'FOK' | 'GTD' | 'DAY';
+/** Managed order type. */
+export type ManagedOrderType = 'market' | 'limit' | 'stop_market' | 'stop_limit';
+/**
+ * Input to placeOrder().
+ * The controller normalises this into a ChartOrder for the overlay store.
+ */
+export interface PlaceOrderInput {
+    /** Symbol / instrument identifier (e.g. 'BTCUSDT', 'ES', 'AAPL'). */
+    symbol: string;
+    side: OrderSide;
+    type: ManagedOrderType;
+    /** Required for limit and stop-limit orders. */
+    limitPrice?: number;
+    /** Required for stop-market and stop-limit orders. */
+    stopPrice?: number;
+    qty: number;
+    timeInForce?: TimeInForce;
+    /**
+     * Group identifier for bracket legs.
+     * The SDK does not enforce OCO execution — the execution provider is responsible.
+     */
+    groupId?: string;
+    /** Human-readable label shown on the chart overlay. */
+    label?: string;
+    /** Arbitrary passthrough metadata forwarded to the execution provider. */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Input to modifyOrder().
+ * Only fields that are explicitly set will be forwarded to the provider.
+ */
+export interface ModifyOrderInput {
+    limitPrice?: number;
+    stopPrice?: number;
+    qty?: number;
+    label?: string;
+}
+/**
+ * Input to placeBracketOrder().
+ * Places an entry order plus linked stop-loss and/or take-profit in one call.
+ * All three legs share a `groupId` so they are visually associated on the chart.
+ */
+export interface PlaceBracketOrderInput {
+    /** The entry leg — type/side/price/qty. Provider may require limit or stop. */
+    entry: PlaceOrderInput;
+    /** Stop-loss price. Required field — brackets must have a risk leg. */
+    stopLossPrice: number;
+    /**
+     * Take-profit price.
+     * Optional — some workflows only manage downside.
+     */
+    takeProfitPrice?: number;
+}
+/**
+ * Returned by placeOrder() and placeBracketOrder() once acknowledged by the
+ * execution provider (even if not yet filled).
+ */
+export interface OrderAck {
+    /** Provider-assigned order id. */
+    orderId: string;
+    /** Optional provider-assigned client order id. */
+    clientOrderId?: string;
+    /** Timestamp (ms) when the ack was received from the provider. */
+    timestamp: number;
+}
+/** Returned by placeBracketOrder — one ack per submitted leg. */
+export interface BracketOrderAck {
+    entry: OrderAck;
+    stopLoss: OrderAck;
+    takeProfit?: OrderAck;
+    /** Shared group id linking all legs on the chart overlay. */
+    groupId: string;
+}
+/**
+ * IExecutionProvider
+ *
+ * The contract every broker / exchange adapter must implement.
+ * ManagedTradingController delegates all actual order routing to whichever
+ * provider is registered at runtime.
+ *
+ * Providers are NOT implemented here — this interface is the extension point.
+ */
+export interface IExecutionProvider {
+    /** Unique provider identifier (e.g. 'rithmic', 'binance', 'interactive-brokers'). */
+    readonly providerId: string;
+    /**
+     * Submit a new order to the venue.
+     * Must resolve with an OrderAck once the venue acknowledges.
+     */
+    placeOrder(input: PlaceOrderInput): Promise<OrderAck>;
+    /**
+     * Cancel a working order by its provider-assigned id.
+     * Must resolve once the cancellation is acknowledged.
+     */
+    cancelOrder(orderId: string): Promise<void>;
+    /**
+     * Modify a working order in place.
+     * Partial updates — only fields present in `updates` are changed.
+     */
+    modifyOrder(orderId: string, updates: ModifyOrderInput): Promise<OrderAck>;
+    /**
+     * Place a bracket order (entry + stop-loss + optional take-profit).
+     * Providers may implement this as a single atomic request or as multiple
+     * linked orders — the contract is the same from the controller's perspective.
+     */
+    placeBracketOrder(input: PlaceBracketOrderInput): Promise<BracketOrderAck>;
+}
+//# sourceMappingURL=managedTypes.d.ts.map