@forgecharts/sdk 1.1.23 → 1.1.28

package/dist/trading/managed/ManagedTradingController.js

@@ -0,0 +1,247 @@
+/**
+ * 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 { assertCanPlaceOrders, assertCanUseBrackets, assertCanUseManagedTrading, } from './managedCapabilities';
+// ── Internal helpers ──────────────────────────────────────────────────────────
+function notImplemented(method) {
+    throw new Error(`[ForgeCharts:ManagedTrading] ${method} — no execution provider is registered. ` +
+        'Call controller.registerProvider(provider) before using managed trading methods.');
+}
+function makeId() {
+    return `order_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+// ── Controller ────────────────────────────────────────────────────────────────
+export class ManagedTradingController {
+    _provider = null;
+    _store;
+    constructor(store) {
+        this._store = store;
+    }
+    // ── Provider registration ─────────────────────────────────────────────────
+    /**
+     * 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) {
+        assertCanUseManagedTrading();
+        this._provider = provider;
+    }
+    /** Returns the id of the currently registered provider, or null if none. */
+    getProviderId() {
+        return this._provider?.providerId ?? null;
+    }
+    /** True when a provider is registered and managed trading is licensed. */
+    isReady() {
+        return this._provider !== null;
+    }
+    // ── Order placement ───────────────────────────────────────────────────────
+    /**
+     * 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.
+     */
+    async placeOrder(input) {
+        assertCanPlaceOrders();
+        if (!this._provider)
+            notImplemented('placeOrder');
+        // Create an optimistic overlay entry immediately
+        const clientId = makeId();
+        const overlayOrder = {
+            id: clientId,
+            role: input.type === 'stop_market' || input.type === 'stop_limit' ? 'stop' : 'entry',
+            side: input.side,
+            status: 'pending',
+            price: input.limitPrice ?? input.stopPrice ?? 0,
+            qty: input.qty,
+            timestamp: Date.now(),
+            ...(input.groupId !== undefined ? { groupId: input.groupId } : {}),
+            ...(input.label !== undefined ? { label: input.label } : {}),
+            ...(input.meta !== undefined ? { meta: input.meta } : {}),
+        };
+        this._store.upsertOrder(overlayOrder);
+        try {
+            // TODO: provider.placeOrder should also start streaming status updates
+            const ack = await this._provider.placeOrder(input);
+            // Update overlay with provider-assigned id
+            this._store.upsertOrder({ ...overlayOrder, id: ack.orderId, status: 'open' });
+            // Remove the optimistic entry now the real id is known
+            if (ack.orderId !== clientId)
+                this._store.removeOrder(clientId);
+            return ack;
+        }
+        catch (err) {
+            // Roll back optimistic entry on placement failure
+            this._store.upsertOrder({ ...overlayOrder, status: 'rejected' });
+            throw err;
+        }
+    }
+    /**
+     * 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).
+     */
+    async cancelOrder(orderId) {
+        assertCanPlaceOrders();
+        if (!this._provider)
+            notImplemented('cancelOrder');
+        await this._provider.cancelOrder(orderId);
+        // Reflect cancellation in overlay
+        const existing = this._store.getOrders().find(o => o.id === orderId);
+        if (existing) {
+            this._store.upsertOrder({ ...existing, status: 'cancelled' });
+        }
+    }
+    /**
+     * 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.
+     */
+    async modifyOrder(orderId, updates) {
+        assertCanPlaceOrders();
+        if (!this._provider)
+            notImplemented('modifyOrder');
+        const ack = await this._provider.modifyOrder(orderId, updates);
+        // Reflect modifications in overlay
+        const existing = this._store.getOrders().find(o => o.id === orderId);
+        if (existing) {
+            this._store.upsertOrder({
+                ...existing,
+                ...(updates.limitPrice !== undefined ? { price: updates.limitPrice } : {}),
+                ...(updates.qty !== undefined ? { qty: updates.qty } : {}),
+                ...(updates.label !== undefined ? { label: updates.label } : {}),
+            });
+        }
+        return ack;
+    }
+    /**
+     * 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.
+     */
+    async placeBracketOrder(input) {
+        assertCanUseBrackets();
+        if (!this._provider)
+            notImplemented('placeBracketOrder');
+        const groupId = input.entry.groupId ?? makeId();
+        const ack = await this._provider.placeBracketOrder({
+            ...input,
+            entry: { ...input.entry, groupId },
+        });
+        // Upsert all bracket legs into the overlay store
+        this._store.upsertOrder({
+            id: ack.entry.orderId,
+            role: 'entry',
+            side: input.entry.side,
+            status: 'open',
+            price: input.entry.limitPrice ?? input.entry.stopPrice ?? 0,
+            qty: input.entry.qty,
+            groupId,
+            label: input.entry.label ?? 'Entry',
+            timestamp: ack.entry.timestamp,
+        });
+        this._store.upsertOrder({
+            id: ack.stopLoss.orderId,
+            role: 'stop_loss',
+            side: input.entry.side === 'buy' ? 'sell' : 'buy',
+            status: 'open',
+            price: input.stopLossPrice,
+            qty: input.entry.qty,
+            groupId,
+            label: 'Stop Loss',
+            timestamp: ack.stopLoss.timestamp,
+        });
+        if (ack.takeProfit && input.takeProfitPrice !== undefined) {
+            this._store.upsertOrder({
+                id: ack.takeProfit.orderId,
+                role: 'take_profit',
+                side: input.entry.side === 'buy' ? 'sell' : 'buy',
+                status: 'open',
+                price: input.takeProfitPrice,
+                qty: input.entry.qty,
+                groupId,
+                label: 'Take Profit',
+                timestamp: ack.takeProfit.timestamp,
+            });
+        }
+        return ack;
+    }
+    // ── Fill reporting ─────────────────────────────────────────────────────────
+    /**
+     * 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) {
+        assertCanUseManagedTrading();
+        this._store.pushExecution(fill);
+        // Update parent order status if fill is total
+        if (fill.orderId) {
+            const order = this._store.getOrders().find(o => o.id === fill.orderId);
+            if (order) {
+                // TODO: track partially-filled qty; use 'partial' when qty > fill.qty
+                this._store.upsertOrder({ ...order, status: 'filled' });
+            }
+        }
+        // TODO: upsert ChartPosition based on fill side/qty/price
+    }
+}
+//# sourceMappingURL=ManagedTradingController.js.map

package/dist/trading/managed/ManagedTradingController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManagedTradingController.js","sourceRoot":"","sources":["../../../src/trading/managed/ManagedTradingController.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAYH,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAE/B,iFAAiF;AAEjF,SAAS,cAAc,CAAC,MAAc;IACpC,MAAM,IAAI,KAAK,CACb,gCAAgC,MAAM,0CAA0C;QAChF,kFAAkF,CACnF,CAAC;AACJ,CAAC;AAED,SAAS,MAAM;IACb,OAAO,SAAS,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;AACzE,CAAC;AAED,iFAAiF;AAEjF,MAAM,OAAO,wBAAwB;IAE3B,SAAS,GAA8B,IAAI,CAAC;IACnC,MAAM,CAAsB;IAE7C,YAAY,KAA0B;QACpC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,6EAA6E;IAE7E;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,QAA4B;QAC3C,0BAA0B,EAAE,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;IAED,4EAA4E;IAC5E,aAAa;QACX,OAAO,IAAI,CAAC,SAAS,EAAE,UAAU,IAAI,IAAI,CAAC;IAC5C,CAAC;IAED,0EAA0E;IAC1E,OAAO;QACL,OAAO,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC;IACjC,CAAC;IAED,6EAA6E;IAE7E;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,UAAU,CAAC,KAAsB;QACrC,oBAAoB,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,cAAc,CAAC,YAAY,CAAC,CAAC;QAElD,iDAAiD;QACjD,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC;QAC1B,MAAM,YAAY,GAAe;YAC/B,EAAE,EAAS,QAAQ;YACnB,IAAI,EAAO,KAAK,CAAC,IAAI,KAAK,aAAa,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO;YACzF,IAAI,EAAO,KAAK,CAAC,IAAI;YACrB,MAAM,EAAK,SAAS;YACpB,KAAK,EAAM,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,SAAS,IAAI,CAAC;YACnD,GAAG,EAAQ,KAAK,CAAC,GAAG;YACpB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClE,GAAG,CAAC,KAAK,CAAC,KAAK,KAAO,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAI,KAAK,CAAC,KAAK,EAAI,CAAC,CAAC,CAAC,EAAE,CAAC;YAClE,GAAG,CAAC,KAAK,CAAC,IAAI,KAAQ,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAK,KAAK,CAAC,IAAI,EAAK,CAAC,CAAC,CAAC,EAAE,CAAC;SACnE,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;QAEtC,IAAI,CAAC;YACH,uEAAuE;YACvE,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YAEnD,2CAA2C;YAC3C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,GAAG,YAAY,EAAE,EAAE,EAAE,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;YAC9E,uDAAuD;YACvD,IAAI,GAAG,CAAC,OAAO,KAAK,QAAQ;gBAAE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;YAEhE,OAAO,GAAG,CAAC;QACb,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,kDAAkD;YAClD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,GAAG,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;YACjE,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,WAAW,CAAC,OAAe;QAC/B,oBAAoB,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,cAAc,CAAC,aAAa,CAAC,CAAC;QAEnD,MAAM,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAE1C,kCAAkC;QAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC;QACrE,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,WAAW,CAAC,OAAe,EAAE,OAAyB;QAC1D,oBAAoB,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,cAAc,CAAC,aAAa,CAAC,CAAC;QAEnD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAE/D,mCAAmC;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC;QACrE,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;gBACtB,GAAG,QAAQ;gBACX,GAAG,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1E,GAAG,CAAC,OAAO,CAAC,GAAG,KAAY,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAI,OAAO,CAAC,GAAG,EAAS,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1E,GAAG,CAAC,OAAO,CAAC,KAAK,KAAU,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAO,CAAC,CAAC,CAAC,EAAE,CAAC;aAC3E,CAAC,CAAC;QACL,CAAC;QAED,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,iBAAiB,CAAC,KAA6B;QACnD,oBAAoB,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,cAAc,CAAC,mBAAmB,CAAC,CAAC;QAEzD,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,IAAI,MAAM,EAAE,CAAC;QAEhD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;YACjD,GAAG,KAAK;YACR,KAAK,EAAE,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE;SACnC,CAAC,CAAC;QAEH,iDAAiD;QACjD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;YACtB,EAAE,EAAQ,GAAG,CAAC,KAAK,CAAC,OAAO;YAC3B,IAAI,EAAM,OAAO;YACjB,IAAI,EAAM,KAAK,CAAC,KAAK,CAAC,IAAI;YAC1B,MAAM,EAAI,MAAM;YAChB,KAAK,EAAK,KAAK,CAAC,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC;YAC9D,GAAG,EAAO,KAAK,CAAC,KAAK,CAAC,GAAG;YACzB,OAAO;YACP,KAAK,EAAK,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,OAAO;YACtC,SAAS,EAAE,GAAG,CAAC,KAAK,CAAC,SAAS;SAC/B,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;YACtB,EAAE,EAAQ,GAAG,CAAC,QAAQ,CAAC,OAAO;YAC9B,IAAI,EAAM,WAAW;YACrB,IAAI,EAAM,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK;YACrD,MAAM,EAAI,MAAM;YAChB,KAAK,EAAK,KAAK,CAAC,aAAa;YAC7B,GAAG,EAAO,KAAK,CAAC,KAAK,CAAC,GAAG;YACzB,OAAO;YACP,KAAK,EAAK,WAAW;YACrB,SAAS,EAAE,GAAG,CAAC,QAAQ,CAAC,SAAS;SAClC,CAAC,CAAC;QAEH,IAAI,GAAG,CAAC,UAAU,IAAI,KAAK,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;YAC1D,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;gBACtB,EAAE,EAAQ,GAAG,CAAC,UAAU,CAAC,OAAO;gBAChC,IAAI,EAAM,aAAa;gBACvB,IAAI,EAAM,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK;gBACrD,MAAM,EAAI,MAAM;gBAChB,KAAK,EAAK,KAAK,CAAC,eAAe;gBAC/B,GAAG,EAAO,KAAK,CAAC,KAAK,CAAC,GAAG;gBACzB,OAAO;gBACP,KAAK,EAAK,aAAa;gBACvB,SAAS,EAAE,GAAG,CAAC,UAAU,CAAC,SAAS;aACpC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,GAAG,CAAC;IACb,CAAC;IAED,8EAA8E;IAE9E;;;;;;;OAOG;IACH,UAAU,CAAC,IAAmB;QAC5B,0BAA0B,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAEhC,8CAA8C;QAC9C,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC;YACvE,IAAI,KAAK,EAAE,CAAC;gBACV,sEAAsE;gBACtE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;QAED,0DAA0D;IAC5D,CAAC;CACF"}

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/managedCapabilities.js

@@ -0,0 +1,79 @@
+/**
+ * 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
+ */
+import { ChartRuntimeResolver } from '../../licensing/ChartRuntimeResolver';
+const resolver = () => ChartRuntimeResolver.getInstance();
+// ── Guard helpers (throw on failure) ─────────────────────────────────────────
+/**
+ * Asserts that the active license is in managed mode.
+ * @throws {Error} with a clear message if mode is unmanaged.
+ */
+export function assertManagedMode() {
+    if (!resolver().isManagedMode()) {
+        throw new Error('[ForgeCharts] This feature requires a managed-mode license. ' +
+            'The current license is in unmanaged mode (or no license is installed). ' +
+            'Install a managed license via LicenseManager.validateLicense().');
+    }
+}
+/**
+ * Asserts that the license permits order placement (orderEntry feature).
+ * Implicitly checks managed mode first.
+ */
+export function assertCanPlaceOrders() {
+    assertManagedMode();
+    if (!resolver().canUseOrderEntry()) {
+        throw new Error('[ForgeCharts] Order entry is not enabled on the active license. ' +
+            'Contact your license provider to enable the orderEntry feature.');
+    }
+}
+/**
+ * Asserts that the license permits bracket / OCO orders.
+ * Implicitly checks managed mode and order entry first.
+ */
+export function assertCanUseBrackets() {
+    assertCanPlaceOrders();
+    if (!resolver().canUseBracketOrders()) {
+        throw new Error('[ForgeCharts] Bracket orders are not enabled on the active license. ' +
+            'Contact your license provider to enable the bracketOrders feature.');
+    }
+}
+/**
+ * Asserts that the license permits drag-to-price order placement.
+ * Implicitly checks managed mode and order entry first.
+ */
+export function assertCanUseDraggableOrders() {
+    assertCanPlaceOrders();
+    if (!resolver().canUseDraggableOrders()) {
+        throw new Error('[ForgeCharts] Draggable orders are not enabled on the active license. ' +
+            'Contact your license provider to enable the draggableOrders feature.');
+    }
+}
+/**
+ * Asserts that the license permits the managed trading service hooks.
+ * Implicitly checks managed mode first.
+ */
+export function assertCanUseManagedTrading() {
+    assertManagedMode();
+    if (!resolver().canUseManagedTrading()) {
+        throw new Error('[ForgeCharts] Managed trading is not enabled on the active license. ' +
+            'Contact your license provider to enable the managedTrading feature.');
+    }
+}
+// ── Boolean helpers (for conditional rendering, no throw) ────────────────────
+export const isManagedCapable = () => resolver().isManagedMode();
+export const canPlaceOrders = () => resolver().isManagedMode() && resolver().canUseOrderEntry();
+export const canPlaceBrackets = () => canPlaceOrders() && resolver().canUseBracketOrders();
+export const canUseDraggable = () => canPlaceOrders() && resolver().canUseDraggableOrders();
+export const canUseManagedTradingHook = () => resolver().isManagedMode() && resolver().canUseManagedTrading();
+//# sourceMappingURL=managedCapabilities.js.map

package/dist/trading/managed/managedCapabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managedCapabilities.js","sourceRoot":"","sources":["../../../src/trading/managed/managedCapabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAE5E,MAAM,QAAQ,GAAG,GAAG,EAAE,CAAC,oBAAoB,CAAC,WAAW,EAAE,CAAC;AAE1D,gFAAgF;AAEhF;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,IAAI,CAAC,QAAQ,EAAE,CAAC,aAAa,EAAE,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,8DAA8D;YAC9D,yEAAyE;YACzE,iEAAiE,CAClE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB;IAClC,iBAAiB,EAAE,CAAC;IACpB,IAAI,CAAC,QAAQ,EAAE,CAAC,gBAAgB,EAAE,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CACb,kEAAkE;YAClE,iEAAiE,CAClE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB;IAClC,oBAAoB,EAAE,CAAC;IACvB,IAAI,CAAC,QAAQ,EAAE,CAAC,mBAAmB,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CACb,sEAAsE;YACtE,oEAAoE,CACrE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,2BAA2B;IACzC,oBAAoB,EAAE,CAAC;IACvB,IAAI,CAAC,QAAQ,EAAE,CAAC,qBAAqB,EAAE,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CACb,wEAAwE;YACxE,sEAAsE,CACvE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,0BAA0B;IACxC,iBAAiB,EAAE,CAAC;IACpB,IAAI,CAAC,QAAQ,EAAE,CAAC,oBAAoB,EAAE,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,sEAAsE;YACtE,qEAAqE,CACtE,CAAC;IACJ,CAAC;AACH,CAAC;AAED,gFAAgF;AAEhF,MAAM,CAAC,MAAM,gBAAgB,GAAW,GAAY,EAAE,CAAC,QAAQ,EAAE,CAAC,aAAa,EAAE,CAAC;AAClF,MAAM,CAAC,MAAM,cAAc,GAAa,GAAY,EAAE,CAAC,QAAQ,EAAE,CAAC,aAAa,EAAE,IAAI,QAAQ,EAAE,CAAC,gBAAgB,EAAE,CAAC;AACnH,MAAM,CAAC,MAAM,gBAAgB,GAAW,GAAY,EAAE,CAAC,cAAc,EAAE,IAAI,QAAQ,EAAE,CAAC,mBAAmB,EAAE,CAAC;AAC5G,MAAM,CAAC,MAAM,eAAe,GAAY,GAAY,EAAE,CAAC,cAAc,EAAE,IAAI,QAAQ,EAAE,CAAC,qBAAqB,EAAE,CAAC;AAC9G,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAY,EAAE,CAAC,QAAQ,EAAE,CAAC,aAAa,EAAE,IAAI,QAAQ,EAAE,CAAC,oBAAoB,EAAE,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"managedTypes.d.ts","sourceRoot":"","sources":["../../../src/trading/managed/managedTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD,+CAA+C;AAC/C,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAEhE,0BAA0B;AAC1B,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,GAAG,YAAY,CAAC;AAEjF;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IAEf,IAAI,EAAE,SAAS,CAAC;IAEhB,IAAI,EAAE,gBAAgB,CAAC;IAEvB,gDAAgD;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,GAAG,EAAE,MAAM,CAAC;IAEZ,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAG,MAAM,CAAC;IACpB,GAAG,CAAC,EAAS,MAAM,CAAC;IACpB,KAAK,CAAC,EAAO,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,+EAA+E;IAC/E,KAAK,EAAE,eAAe,CAAC;IAEvB,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAID;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAQ,QAAQ,CAAC;IACtB,QAAQ,EAAK,QAAQ,CAAC;IACtB,UAAU,CAAC,EAAE,QAAQ,CAAC;IACtB,6DAA6D;IAC7D,OAAO,EAAM,MAAM,CAAC;CACrB;AAID;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,qFAAqF;IACrF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEtD;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5C;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE3E;;;;OAIG;IACH,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAC5E"}

package/dist/trading/managed/managedTypes.js

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ */
+export {};
+//# sourceMappingURL=managedTypes.js.map

package/dist/trading/managed/managedTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managedTypes.js","sourceRoot":"","sources":["../../../src/trading/managed/managedTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/trading/tradingTypes.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Shared trading overlay types used by both unmanaged and managed modes.
+ *
+ * These are the canonical data shapes the overlay engine, ingestion layer,
+ * and future managed trading service all operate on.
+ */
+/**
+ * Normalised candle data accepted by the unmanaged ingestion API.
+ * `time` may be Unix seconds or milliseconds — the engine auto-detects.
+ */
+export interface CandleInput {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+    /** True when the candle is confirmed closed (next candle has opened). */
+    isClosed?: boolean;
+}
+/** Visual role of the order line on the chart. */
+export type OrderRole = 'entry' | 'stop_loss' | 'take_profit' | 'limit' | 'stop' | 'other';
+/** Order side. */
+export type OrderSide = 'buy' | 'sell';
+/** Lifecycle status of the order. */
+export type OrderStatus = 'pending' | 'open' | 'filled' | 'partial' | 'cancelled' | 'rejected' | 'expired';
+export interface ChartOrder {
+    /** Unique order identifier — used as the primary key for upsert / remove. */
+    id: string;
+    /** Visual role — drives line colour and label. */
+    role: OrderRole;
+    side: OrderSide;
+    status: OrderStatus;
+    /** Limit / trigger price in the chart's native price unit. */
+    price: number;
+    /** Order quantity in the instrument's native lot / contract unit. */
+    qty: number;
+    /**
+     * Optional group identifier.
+     * Orders sharing a `groupId` are visually associated (e.g. bracket legs).
+     * The SDK does NOT manage execution rules — grouping is visual only.
+     */
+    groupId?: string;
+    /** Human-readable label shown next to the order line. */
+    label?: string;
+    /** ISO-8601 string or Unix timestamp (ms) when the order was placed. */
+    timestamp?: number | string;
+    /** Arbitrary client metadata — not used by the renderer. */
+    meta?: Record<string, unknown>;
+}
+export type PositionSide = 'long' | 'short';
+export type PositionStatus = 'open' | 'closed' | 'partial';
+export interface ChartPosition {
+    /** Unique position identifier. */
+    id: string;
+    side: PositionSide;
+    status: PositionStatus;
+    /** Average entry price. */
+    entryPrice: number;
+    /** Net open quantity (absolute value; sign is encoded in `side`). */
+    qty: number;
+    /** Current mark / last price (used to compute unrealized P&L). */
+    markPrice?: number;
+    /** Unrealized P&L in the account's currency. */
+    unrealizedPnl?: number;
+    /** Optional: link associated order ids (e.g. stop-loss, take-profit). */
+    linkedOrderIds?: string[];
+    /** Human-readable label. */
+    label?: string;
+    /** Arbitrary client metadata. */
+    meta?: Record<string, unknown>;
+}
+export type FillSide = 'buy' | 'sell';
+export interface ExecutionFill {
+    /** Unique fill / execution identifier. */
+    id: string;
+    /** ID of the parent order, if known. */
+    orderId?: string;
+    side: FillSide;
+    /** Execution price. */
+    price: number;
+    /** Filled quantity. */
+    qty: number;
+    /** Unix timestamp in milliseconds when the fill was reported. */
+    timestamp: number;
+    /** Arbitrary client metadata. */
+    meta?: Record<string, unknown>;
+}
+//# sourceMappingURL=tradingTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tradingTypes.d.ts","sourceRoot":"","sources":["../../src/trading/tradingTypes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAK,MAAM,CAAC;IAChB,IAAI,EAAK,MAAM,CAAC;IAChB,IAAI,EAAK,MAAM,CAAC;IAChB,GAAG,EAAM,MAAM,CAAC;IAChB,KAAK,EAAI,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAID,kDAAkD;AAClD,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3F,kBAAkB;AAClB,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC,qCAAqC;AACrC,MAAM,MAAM,WAAW,GACnB,SAAS,GACT,MAAM,GACN,QAAQ,GACR,SAAS,GACT,WAAW,GACX,UAAU,GACV,SAAS,CAAC;AAEd,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAC7E,EAAE,EAAE,MAAM,CAAC;IAEX,kDAAkD;IAClD,IAAI,EAAE,SAAS,CAAC;IAEhB,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,WAAW,CAAC;IAEpB,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IAEd,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IAEZ;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5B,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAID,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,CAAC;AAE5C,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,EAAE,EAAE,MAAM,CAAC;IAEX,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,cAAc,CAAC;IAEvB,2BAA2B;IAC3B,UAAU,EAAE,MAAM,CAAC;IAEnB,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IAEZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,gDAAgD;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,yEAAyE;IACzE,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAE1B,4BAA4B;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAID,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;AAEtC,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,EAAE,EAAE,MAAM,CAAC;IAEX,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,IAAI,EAAE,QAAQ,CAAC;IAEf,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IAEd,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IAEZ,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAElB,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC"}

package/dist/trading/tradingTypes.js

@@ -0,0 +1,8 @@
+/**
+ * Shared trading overlay types used by both unmanaged and managed modes.
+ *
+ * These are the canonical data shapes the overlay engine, ingestion layer,
+ * and future managed trading service all operate on.
+ */
+export {};
+//# sourceMappingURL=tradingTypes.js.map

package/dist/trading/tradingTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tradingTypes.js","sourceRoot":"","sources":["../../src/trading/tradingTypes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}