@reefclaw/connect 0.1.10 → 0.1.12

package/assets/plugin/shadow/shadow-tracker.js

@@ -1,151 +0,0 @@
-// Shadow Tracker — compares paper fills against live exchange estimates.
-// Listens for fill events from the simulator, fetches real order book,
-// computes what the live fill would have been, logs the comparison.
-import { EventEmitter } from 'node:events';
-import { logger } from '../logger.js';
-import { priceToBps } from '../simulator/types.js';
-import { computeBookAwareFillPrice } from '../simulator/realistic-fills.js';
-import { createEmptyShadowMetrics, DEFAULT_SHADOW_CONFIG } from './types.js';
-const TAG = 'shadow-tracker';
-/** Maximum recent comparisons to keep in memory. */
-const MAX_RECENT_COMPARISONS = 100;
-/**
- * ShadowTracker hooks into the ExchangeSimulator to compute
- * shadow estimates for every paper fill.
- *
- * Events emitted:
- * - 'shadowComparison': ShadowComparison — after each fill comparison
- */
-export class ShadowTracker extends EventEmitter {
-    privateApi;
-    simulator;
-    metrics;
-    config;
-    recentComparisons = [];
-    active = false;
-    constructor(privateApi, simulator, config, existingMetrics) {
-        super();
-        this.privateApi = privateApi;
-        this.simulator = simulator;
-        this.config = config ?? DEFAULT_SHADOW_CONFIG;
-        this.metrics = existingMetrics ?? createEmptyShadowMetrics();
-    }
-    /** Start listening for simulator fill events. */
-    start() {
-        if (this.active)
-            return;
-        this.active = true;
-        this.simulator.on('fill', this.onFill);
-        logger.info(TAG, `Shadow tracker started (${this.metrics.totalShadowTrades} prior comparisons)`);
-    }
-    /** Stop listening. */
-    stop() {
-        if (!this.active)
-            return;
-        this.active = false;
-        this.simulator.off('fill', this.onFill);
-        logger.info(TAG, 'Shadow tracker stopped');
-    }
-    /** Get current shadow metrics. */
-    getMetrics() {
-        return { ...this.metrics };
-    }
-    /** Get recent comparisons. */
-    getRecentComparisons() {
-        return [...this.recentComparisons];
-    }
-    /** Check if shadow mode criteria are met for mode upgrade. */
-    isReadyForUpgrade() {
-        const reasons = [];
-        if (this.metrics.totalShadowTrades < this.config.minTrades) {
-            reasons.push(`Need ${this.config.minTrades} shadow trades, have ${this.metrics.totalShadowTrades}`);
-        }
-        if (this.metrics.tradingDays < this.config.minDays) {
-            reasons.push(`Need ${this.config.minDays} trading days, have ${this.metrics.tradingDays}`);
-        }
-        if (this.metrics.avgDeltaBps > this.config.maxAvgDeltaBps) {
-            reasons.push(`Avg delta ${this.metrics.avgDeltaBps.toFixed(2)}bps exceeds max ${this.config.maxAvgDeltaBps}bps`);
-        }
-        return { ready: reasons.length === 0, reasons };
-    }
-    // Arrow function to preserve `this` binding when used as event listener
-    onFill = (fillData) => {
-        // Only compare market order fills (limit orders fill at limit price, no comparison needed)
-        if (fillData.type !== 'market')
-            return;
-        // Fire and forget — shadow comparison is async but doesn't block the fill
-        this.computeShadowComparison(fillData).catch(err => {
-            logger.warn(TAG, `Shadow comparison failed: ${err instanceof Error ? err.message : String(err)}`);
-        });
-    };
-    async computeShadowComparison(fillData) {
-        // Fetch fresh order book from the exchange (authenticated path)
-        const liveBook = await this.privateApi.fetchOrderBook(fillData.symbol, 20);
-        let shadowPrice;
-        let bookDepthUsed = 0;
-        let bookDepthAvailable = false;
-        if (liveBook && liveBook.asks.length > 0 && liveBook.bids.length > 0) {
-            // Walk the live book to compute shadow VWAP
-            const { vwap, levelsConsumed } = computeBookAwareFillPrice(fillData.side, fillData.amount, liveBook);
-            shadowPrice = vwap;
-            bookDepthUsed = levelsConsumed;
-            bookDepthAvailable = true;
-        }
-        else {
-            // No live book available — use paper fill as shadow estimate
-            shadowPrice = fillData.fillPrice;
-            logger.warn(TAG, `No live order book for ${fillData.symbol} — shadow estimate equals paper`);
-        }
-        // Compute shadow fee (same taker rate as paper for fair comparison)
-        const simConfig = this.simulator.getSimulationConfig();
-        const shadowFee = fillData.amount * shadowPrice * simConfig.fees.takerRate;
-        // Delta: positive = live would be worse (pay more for buy, receive less for sell)
-        const deltaBps = priceToBps(shadowPrice, fillData.fillPrice);
-        const comparison = {
-            orderId: fillData.orderId,
-            symbol: fillData.symbol,
-            side: fillData.side,
-            type: fillData.type,
-            amount: fillData.amount,
-            paperFillPrice: fillData.fillPrice,
-            shadowEstimatePrice: shadowPrice,
-            deltaBps,
-            paperFee: fillData.fee,
-            shadowEstimateFee: shadowFee,
-            bookDepthUsed,
-            bookDepthAvailable,
-            timestamp: new Date().toISOString(),
-        };
-        // Update metrics
-        this.updateMetrics(comparison);
-        // Store recent comparison (match webapp slice pattern — slice instead of shift)
-        this.recentComparisons = [
-            ...this.recentComparisons.slice(-(MAX_RECENT_COMPARISONS - 1)),
-            comparison,
-        ];
-        // Emit event for skill/bridge pipeline
-        this.emit('shadowComparison', comparison);
-        logger.info(TAG, `Shadow comparison: ${fillData.side} ${fillData.amount} ${fillData.symbol}` +
-            ` | Paper: ${fillData.fillPrice.toFixed(2)} | Shadow: ${shadowPrice.toFixed(2)}` +
-            ` | Delta: ${deltaBps.toFixed(2)}bps` +
-            ` | Book: ${bookDepthAvailable ? `${bookDepthUsed} levels` : 'unavailable'}`);
-    }
-    updateMetrics(comparison) {
-        const m = this.metrics;
-        m.totalShadowTrades++;
-        const absDelta = Math.abs(comparison.deltaBps);
-        m.totalDeltaBpsSum += absDelta;
-        m.avgDeltaBps = m.totalDeltaBpsSum / m.totalShadowTrades;
-        if (absDelta > m.worstDeltaBps) {
-            m.worstDeltaBps = absDelta;
-        }
-        m.paperTotalFees += comparison.paperFee;
-        m.shadowTotalFees += comparison.shadowEstimateFee;
-        // Track trading days
-        const today = comparison.timestamp.slice(0, 10);
-        if (today !== m.lastTradeDate) {
-            m.tradingDays++;
-            m.lastTradeDate = today;
-        }
-    }
-}

package/assets/plugin/shadow/types.d.ts

@@ -1,42 +0,0 @@
-import type { TradingMode } from '../types.js';
-export type { TradingMode };
-/** A single shadow comparison record: paper fill vs live estimate. */
-export interface ShadowComparison {
-    orderId: string;
-    symbol: string;
-    side: 'buy' | 'sell';
-    type: 'market' | 'limit';
-    amount: number;
-    paperFillPrice: number;
-    shadowEstimatePrice: number;
-    deltaBps: number;
-    paperFee: number;
-    shadowEstimateFee: number;
-    bookDepthUsed: number;
-    bookDepthAvailable: boolean;
-    timestamp: string;
-}
-/** Aggregate shadow metrics across all shadow comparisons. */
-export interface ShadowMetrics {
-    totalShadowTrades: number;
-    avgDeltaBps: number;
-    worstDeltaBps: number;
-    totalDeltaBpsSum: number;
-    paperTotalFees: number;
-    shadowTotalFees: number;
-    startedAt: string;
-    tradingDays: number;
-    lastTradeDate: string;
-}
-/** Shadow mode configuration thresholds. */
-export interface ShadowConfig {
-    /** Minimum shadow trades before allowing mode upgrade (default: 50) */
-    minTrades: number;
-    /** Minimum days in shadow mode (default: 7) */
-    minDays: number;
-    /** Max acceptable average delta in bps (default: 5) */
-    maxAvgDeltaBps: number;
-}
-export declare const DEFAULT_SHADOW_CONFIG: ShadowConfig;
-/** Create empty shadow metrics. */
-export declare function createEmptyShadowMetrics(): ShadowMetrics;

package/assets/plugin/shadow/types.js

@@ -1,20 +0,0 @@
-// Shadow mode types — tracking paper vs live fill comparison.
-export const DEFAULT_SHADOW_CONFIG = {
-    minTrades: 50,
-    minDays: 7,
-    maxAvgDeltaBps: 5,
-};
-/** Create empty shadow metrics. */
-export function createEmptyShadowMetrics() {
-    return {
-        totalShadowTrades: 0,
-        avgDeltaBps: 0,
-        worstDeltaBps: 0,
-        totalDeltaBpsSum: 0,
-        paperTotalFees: 0,
-        shadowTotalFees: 0,
-        startedAt: new Date().toISOString(),
-        tradingDays: 0,
-        lastTradeDate: '',
-    };
-}

package/assets/plugin/shared/indicators-extended.d.ts

@@ -1,52 +0,0 @@
-export interface OhlcvInput {
-    open: number;
-    high: number;
-    low: number;
-    close: number;
-    volume: number;
-}
-export interface MACDResult {
-    line: number;
-    signal: number;
-    histogram: number;
-    crossover: 'bullish' | 'bearish' | 'none';
-}
-export interface BollingerResult {
-    upper: number;
-    middle: number;
-    lower: number;
-    bandwidth: number;
-    percentB: number;
-}
-export interface StochRSIResult {
-    k: number;
-    d: number;
-}
-export interface IchimokuResult {
-    tenkan: number;
-    kijun: number;
-    senkouA: number;
-    senkouB: number;
-    chikou: number;
-    cloudPosition: 'above' | 'below' | 'inside';
-}
-export interface SupertrendResult {
-    value: number;
-    direction: 'bullish' | 'bearish';
-}
-export declare function computeMACD(closes: number[], fast?: number, slow?: number, signal?: number): MACDResult;
-export declare function computeBollingerBands(closes: number[], period?: number, stdDev?: number): BollingerResult;
-export declare function computeVWAP(bars: OhlcvInput[]): number;
-export declare function computeStochRSI(closes: number[], rsiPeriod?: number, stochPeriod?: number, kSmooth?: number, dSmooth?: number): StochRSIResult;
-export declare function computeADX(highs: number[], lows: number[], closes: number[], period?: number): {
-    adx: number;
-    plusDI: number;
-    minusDI: number;
-};
-export declare function computeIchimoku(highs: number[], lows: number[], closes: number[], tenkanPeriod?: number, kijunPeriod?: number, senkouBPeriod?: number): IchimokuResult;
-export declare function computeOBV(closes: number[], volumes: number[]): {
-    obv: number;
-    slope: 'rising' | 'falling' | 'flat';
-};
-export declare function computeSupertrend(highs: number[], lows: number[], closes: number[], period?: number, multiplier?: number): SupertrendResult;
-export declare function computeWilliamsR(highs: number[], lows: number[], closes: number[], period?: number): number;

package/assets/plugin/shared/indicators-extended.js

@@ -1,291 +0,0 @@
-// ⚠️ GENERATED FILE — DO NOT EDIT.
-// Canonical source of truth: shared/src/shared/indicators-extended.ts
-// Regenerate: node scripts/sync-shared-code.mjs  (enforced by shared-code-sync.test.ts)
-//
-// This copy exists because this package builds with tsc and deploys as a
-// self-contained tree that strips workspace deps, so it cannot import
-// @reefclaw/shared runtime code across the deploy boundary.
-// Extended indicator computations for Phase 13 — Expanded Indicators.
-// Wraps technicalindicators library + custom implementations.
-// All functions take OHLCV arrays (oldest first) and return latest values.
-import { computeATRSeries, computeRSI, mean, computeStd } from './indicators.js';
-// ─── MACD (12, 26, 9) ──────────────────────────────────────────────────
-export function computeMACD(closes, fast = 12, slow = 26, signal = 9) {
-    if (closes.length < slow + signal) {
-        return { line: 0, signal: 0, histogram: 0, crossover: 'none' };
-    }
-    // Compute full EMA series (both aligned to start at index `slow - 1`)
-    const emaFastSeries = emaSeries(closes, fast);
-    const emaSlowSeries = emaSeries(closes, slow);
-    // Align: fast series starts earlier, so take the tail matching slow series length
-    const offset = emaFastSeries.length - emaSlowSeries.length;
-    const macdLine = [];
-    for (let i = 0; i < emaSlowSeries.length; i++) {
-        macdLine.push(emaFastSeries[i + offset] - emaSlowSeries[i]);
-    }
-    // Signal line = EMA of MACD line
-    const signalSeries = emaSeries(macdLine, signal);
-    const sigOffset = macdLine.length - signalSeries.length;
-    const currentLine = macdLine[macdLine.length - 1];
-    const currentSignal = signalSeries[signalSeries.length - 1];
-    const prevLine = macdLine.length >= 2 ? macdLine[macdLine.length - 2] : currentLine;
-    const prevSignalIdx = signalSeries.length >= 2 ? signalSeries.length - 2 : signalSeries.length - 1;
-    const prevSignal = signalSeries[prevSignalIdx];
-    let crossover = 'none';
-    if (prevLine <= prevSignal && currentLine > currentSignal)
-        crossover = 'bullish';
-    else if (prevLine >= prevSignal && currentLine < currentSignal)
-        crossover = 'bearish';
-    return {
-        line: currentLine,
-        signal: currentSignal,
-        histogram: currentLine - currentSignal,
-        crossover,
-    };
-}
-// ─── Bollinger Bands (20, 2σ) ───────────────────────────────────────────
-export function computeBollingerBands(closes, period = 20, stdDev = 2) {
-    if (closes.length < period) {
-        const p = closes[closes.length - 1] ?? 0;
-        return { upper: p, middle: p, lower: p, bandwidth: 0, percentB: 0.5 };
-    }
-    const slice = closes.slice(-period);
-    const middle = mean(slice);
-    const std = computeStd(slice);
-    const upper = middle + stdDev * std;
-    const lower = middle - stdDev * std;
-    const bandwidth = middle > 0 ? ((upper - lower) / middle) * 100 : 0;
-    const price = closes[closes.length - 1];
-    const percentB = upper !== lower ? (price - lower) / (upper - lower) : 0.5;
-    return { upper, middle, lower, bandwidth, percentB };
-}
-// ─── VWAP ───────────────────────────────────────────────────────────────
-export function computeVWAP(bars) {
-    if (bars.length === 0)
-        return 0;
-    let cumVolume = 0;
-    let cumTPxVol = 0;
-    for (const bar of bars) {
-        const tp = (bar.high + bar.low + bar.close) / 3;
-        cumVolume += bar.volume;
-        cumTPxVol += tp * bar.volume;
-    }
-    return cumVolume > 0 ? cumTPxVol / cumVolume : bars[bars.length - 1].close;
-}
-// ─── Stochastic RSI (14, 14, 3, 3) ─────────────────────────────────────
-export function computeStochRSI(closes, rsiPeriod = 14, stochPeriod = 14, kSmooth = 3, dSmooth = 3) {
-    if (closes.length < rsiPeriod + stochPeriod + dSmooth) {
-        return { k: 50, d: 50 };
-    }
-    // Compute RSI series
-    const rsiValues = [];
-    for (let i = rsiPeriod + 1; i <= closes.length; i++) {
-        rsiValues.push(computeRSI(closes.slice(0, i), rsiPeriod));
-    }
-    if (rsiValues.length < stochPeriod)
-        return { k: 50, d: 50 };
-    // Stochastic of RSI
-    const rawK = [];
-    for (let i = stochPeriod - 1; i < rsiValues.length; i++) {
-        const window = rsiValues.slice(i - stochPeriod + 1, i + 1);
-        const min = Math.min(...window);
-        const max = Math.max(...window);
-        rawK.push(max !== min ? ((rsiValues[i] - min) / (max - min)) * 100 : 50);
-    }
-    // %K = SMA of raw stochastic
-    const kValues = sma(rawK, kSmooth);
-    // %D = SMA of %K
-    const dValues = sma(kValues, dSmooth);
-    return {
-        k: Math.round(kValues[kValues.length - 1] ?? 50),
-        d: Math.round(dValues[dValues.length - 1] ?? 50),
-    };
-}
-// ─── ADX (14) ───────────────────────────────────────────────────────────
-export function computeADX(highs, lows, closes, period = 14) {
-    if (highs.length < period * 2 + 1) {
-        return { adx: 0, plusDI: 0, minusDI: 0 };
-    }
-    const plusDM = [];
-    const minusDM = [];
-    const tr = [];
-    for (let i = 1; i < highs.length; i++) {
-        const upMove = highs[i] - highs[i - 1];
-        const downMove = lows[i - 1] - lows[i];
-        plusDM.push(upMove > downMove && upMove > 0 ? upMove : 0);
-        minusDM.push(downMove > upMove && downMove > 0 ? downMove : 0);
-        tr.push(Math.max(highs[i] - lows[i], Math.abs(highs[i] - closes[i - 1]), Math.abs(lows[i] - closes[i - 1])));
-    }
-    // Smooth with Wilder's smoothing (equivalent to EMA with alpha=1/period)
-    const smoothPlusDM = wilderSmooth(plusDM, period);
-    const smoothMinusDM = wilderSmooth(minusDM, period);
-    const smoothTR = wilderSmooth(tr, period);
-    // +DI and -DI series
-    const plusDISeries = [];
-    const minusDISeries = [];
-    for (let i = 0; i < smoothTR.length; i++) {
-        plusDISeries.push(smoothTR[i] > 0 ? (smoothPlusDM[i] / smoothTR[i]) * 100 : 0);
-        minusDISeries.push(smoothTR[i] > 0 ? (smoothMinusDM[i] / smoothTR[i]) * 100 : 0);
-    }
-    // DX series
-    const dxSeries = [];
-    for (let i = 0; i < plusDISeries.length; i++) {
-        const sum = plusDISeries[i] + minusDISeries[i];
-        dxSeries.push(sum > 0 ? (Math.abs(plusDISeries[i] - minusDISeries[i]) / sum) * 100 : 0);
-    }
-    // ADX = Wilder smooth of DX
-    const adxSeries = wilderSmooth(dxSeries, period);
-    return {
-        adx: Math.round(adxSeries[adxSeries.length - 1] ?? 0),
-        plusDI: Math.round(plusDISeries[plusDISeries.length - 1] ?? 0),
-        minusDI: Math.round(minusDISeries[minusDISeries.length - 1] ?? 0),
-    };
-}
-// ─── Ichimoku Cloud ─────────────────────────────────────────────────────
-export function computeIchimoku(highs, lows, closes, tenkanPeriod = 9, kijunPeriod = 26, senkouBPeriod = 52) {
-    const n = highs.length;
-    if (n < senkouBPeriod) {
-        const p = closes[n - 1] ?? 0;
-        return { tenkan: p, kijun: p, senkouA: p, senkouB: p, chikou: p, cloudPosition: 'inside' };
-    }
-    const midpoint = (arr, period, end) => {
-        const slice = arr.slice(Math.max(0, end - period + 1), end + 1);
-        return (Math.max(...slice) + Math.min(...slice)) / 2;
-    };
-    const tenkan = midpoint(highs.concat().map((h, i) => Math.max(h, lows[i])), tenkanPeriod, n - 1);
-    const kijun = midpoint(highs.concat().map((h, i) => Math.max(h, lows[i])), kijunPeriod, n - 1);
-    // Recalculate properly using highs and lows separately
-    const tenkanH = Math.max(...highs.slice(-tenkanPeriod));
-    const tenkanL = Math.min(...lows.slice(-tenkanPeriod));
-    const tenkanVal = (tenkanH + tenkanL) / 2;
-    const kijunH = Math.max(...highs.slice(-kijunPeriod));
-    const kijunL = Math.min(...lows.slice(-kijunPeriod));
-    const kijunVal = (kijunH + kijunL) / 2;
-    const senkouA = (tenkanVal + kijunVal) / 2;
-    const senkouBH = Math.max(...highs.slice(-senkouBPeriod));
-    const senkouBL = Math.min(...lows.slice(-senkouBPeriod));
-    const senkouB = (senkouBH + senkouBL) / 2;
-    const chikou = closes[n - 1]; // Current close (projected back 26 periods)
-    const price = closes[n - 1];
-    const cloudTop = Math.max(senkouA, senkouB);
-    const cloudBottom = Math.min(senkouA, senkouB);
-    const cloudPosition = price > cloudTop ? 'above' : price < cloudBottom ? 'below' : 'inside';
-    return { tenkan: tenkanVal, kijun: kijunVal, senkouA, senkouB, chikou, cloudPosition };
-}
-// ─── OBV (On-Balance Volume) ────────────────────────────────────────────
-export function computeOBV(closes, volumes) {
-    if (closes.length < 2)
-        return { obv: 0, slope: 'flat' };
-    let obv = 0;
-    const obvSeries = [0];
-    for (let i = 1; i < closes.length; i++) {
-        if (closes[i] > closes[i - 1])
-            obv += volumes[i];
-        else if (closes[i] < closes[i - 1])
-            obv -= volumes[i];
-        obvSeries.push(obv);
-    }
-    // Slope over last 10 bars
-    const lookback = Math.min(10, obvSeries.length);
-    const recent = obvSeries.slice(-lookback);
-    const first = recent[0];
-    const last = recent[recent.length - 1];
-    const threshold = Math.abs(first) * 0.01; // 1% threshold
-    const slope = last - first > threshold ? 'rising' : last - first < -threshold ? 'falling' : 'flat';
-    return { obv, slope };
-}
-// ─── Supertrend (10, 3) ─────────────────────────────────────────────────
-export function computeSupertrend(highs, lows, closes, period = 10, multiplier = 3) {
-    const atrSeries = computeATRSeries(highs, lows, closes, period);
-    if (atrSeries.length === 0) {
-        return { value: closes[closes.length - 1] ?? 0, direction: 'bullish' };
-    }
-    // ATR series starts at index 1 (needs previous close for TR)
-    // Align: atrSeries[i] corresponds to bar index i+1
-    let upperBand = 0;
-    let lowerBand = 0;
-    let supertrend = 0;
-    let direction = 'bullish';
-    for (let i = 0; i < atrSeries.length; i++) {
-        const barIdx = i + 1; // offset for TR calculation
-        const hl2 = (highs[barIdx] + lows[barIdx]) / 2;
-        const atr = atrSeries[i];
-        const basicUpper = hl2 + multiplier * atr;
-        const basicLower = hl2 - multiplier * atr;
-        upperBand = i > 0 && basicUpper < upperBand && closes[barIdx - 1] > upperBand ? upperBand : basicUpper;
-        lowerBand = i > 0 && basicLower > lowerBand && closes[barIdx - 1] < lowerBand ? lowerBand : basicLower;
-        if (i === 0) {
-            supertrend = closes[barIdx] > upperBand ? lowerBand : upperBand;
-            direction = closes[barIdx] > upperBand ? 'bullish' : 'bearish';
-        }
-        else {
-            if (direction === 'bullish') {
-                if (closes[barIdx] < lowerBand) {
-                    direction = 'bearish';
-                    supertrend = upperBand;
-                }
-                else {
-                    supertrend = lowerBand;
-                }
-            }
-            else {
-                if (closes[barIdx] > upperBand) {
-                    direction = 'bullish';
-                    supertrend = lowerBand;
-                }
-                else {
-                    supertrend = upperBand;
-                }
-            }
-        }
-    }
-    return { value: supertrend, direction };
-}
-// ─── Williams %R (14) ───────────────────────────────────────────────────
-export function computeWilliamsR(highs, lows, closes, period = 14) {
-    if (highs.length < period)
-        return -50;
-    const recentHighs = highs.slice(-period);
-    const recentLows = lows.slice(-period);
-    const hh = Math.max(...recentHighs);
-    const ll = Math.min(...recentLows);
-    const close = closes[closes.length - 1];
-    return hh !== ll ? ((hh - close) / (hh - ll)) * -100 : -50;
-}
-// ─── Helper: EMA series ─────────────────────────────────────────────────
-function emaSeries(data, period) {
-    if (data.length === 0)
-        return [];
-    if (data.length < period)
-        return [data[data.length - 1]];
-    const k = 2 / (period + 1);
-    const result = [];
-    let ema = mean(data.slice(0, period));
-    result.push(ema);
-    for (let i = period; i < data.length; i++) {
-        ema = data[i] * k + ema * (1 - k);
-        result.push(ema);
-    }
-    return result;
-}
-// ─── Helper: SMA series ─────────────────────────────────────────────────
-function sma(data, period) {
-    if (data.length < period)
-        return data.length > 0 ? [mean(data)] : [];
-    const result = [];
-    for (let i = period - 1; i < data.length; i++) {
-        result.push(mean(data.slice(i - period + 1, i + 1)));
-    }
-    return result;
-}
-// ─── Helper: Wilder's smoothing ─────────────────────────────────────────
-function wilderSmooth(data, period) {
-    if (data.length < period)
-        return [];
-    const result = [];
-    result.push(mean(data.slice(0, period)));
-    for (let i = period; i < data.length; i++) {
-        result.push((result[result.length - 1] * (period - 1) + data[i]) / period);
-    }
-    return result;
-}

package/assets/plugin/shared/indicators.d.ts

@@ -1,15 +0,0 @@
-export declare function computeEMA(data: number[], period: number): number;
-export declare function computeATR(highs: number[], lows: number[], closes: number[], period: number): number;
-export declare function computeATRSeries(highs: number[], lows: number[], closes: number[], period: number): number[];
-export declare function computeRSI(closes: number[], period: number): number;
-export declare function linearSlope(y: number[], x?: number[]): number;
-export declare function computeStd(data: number[]): number;
-export declare function mean(data: number[]): number;
-/** Find swing highs and lows from OHLCV bars (simple pivot-point method). */
-export declare function findSwingPoints(bars: {
-    high: number;
-    low: number;
-}[], lookback?: number): {
-    highs: number[];
-    lows: number[];
-};