@reefclaw/connect 0.1.18 → 0.1.20

package/assets/plugin/venues/hyperliquid/hl-private.d.ts

@@ -49,16 +49,33 @@ export declare class HyperliquidPrivateApi {
     getExchange(): any;
     loadMarkets(): Promise<boolean>;
     /** Positions for the MASTER account. `null` = fetch failed (state unknown);
-     *  `[]` = the exchange confirmed flat. */
+     *  `[]` = the exchange confirmed flat.
+     *
+     *  ★ Rows are normalized through `normalizeHlPosition` — ccxt leaves
+     *  `markPrice`/`contractSize`/`timestamp`/`datetime` UNDEFINED on this venue
+     *  (clearinghouseState carries no markPx) while `CcxtPosition` declares them
+     *  required, which crashed `get_risk_summary` and degraded every other
+     *  mark-reading consumer. See hl-position.ts for the doc-exact derivation.
+     *  A row that cannot be priced makes the WHOLE snapshot null (unknown) — never
+     *  a partial list, never a fabricated zero. */
     fetchPositions(symbol?: string): Promise<CcxtPosition[] | null>;
     /** Open orders INCLUDING trigger/TPSL legs. CCXT's HL `fetchOpenOrders`
      *  defaults to `frontendOpenOrders`, which is the only endpoint that returns
-     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints. */
+     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints.
+     *
+     *  ★ Rows are normalized through `normalizeHlOrder` (ccxt leaves cost/fee/
+     *  average/timeInForce undefined and leaks 'take profit market' past the
+     *  type union — see hl-order.ts); `info` + `clientOrderId` survive verbatim
+     *  (protective classification + bracket reconciliation read them). */
     fetchOpenOrders(symbol?: string): Promise<CcxtOrder[] | null>;
     fetchBalance(): Promise<CcxtBalance | null>;
     /** Per-order status — the liveness resolver's REST tier (Tier 2 of the
      *  3-tier rule). Weight 2. `null` = lookup FAILED (unknown), which callers
-     *  must treat as "do not act", NOT as "gone". */
+     *  must treat as "do not act", NOT as "gone".
+     *
+     *  Normalized like fetchOpenOrders. Unknown statuses collapse to 'open'
+     *  (= not confirmed terminal — the conservative direction for both the
+     *  liveness resolver and the entry poller); raw status stays in `info`. */
     fetchOrder(orderId: string, symbol?: string): Promise<CcxtOrder | null>;
     /** Own fills. WS is the authoritative ingress (plan + the audit-trail rule);
      *  this is the gap-fill/truth-check path. NOTE: only the 10,000 most recent

package/assets/plugin/venues/hyperliquid/hl-private.js

@@ -29,6 +29,8 @@ import { logger } from '../../logger.js';
 import { toCcxtSymbol } from '../symbols.js';
 import { assertNotLimited, noteError, noteSuccess, exchangeIpWeight, updateAddressBudget, } from './hl-rate-gate.js';
 import { isValidHlCloid } from './hl-cloid.js';
+import { normalizeHlPosition } from './hl-position.js';
+import { normalizeHlOrder } from './hl-order.js';
 // ccxt via CJS require — OpenClaw's ESM loader yields the wrong module shape
 // (same rationale as binance-private.ts / hl-public.ts).
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -124,7 +126,15 @@ export class HyperliquidPrivateApi {
     }
     // ---- Reads (null on failure — NEVER []) ----
     /** Positions for the MASTER account. `null` = fetch failed (state unknown);
-     *  `[]` = the exchange confirmed flat. */
+     *  `[]` = the exchange confirmed flat.
+     *
+     *  ★ Rows are normalized through `normalizeHlPosition` — ccxt leaves
+     *  `markPrice`/`contractSize`/`timestamp`/`datetime` UNDEFINED on this venue
+     *  (clearinghouseState carries no markPx) while `CcxtPosition` declares them
+     *  required, which crashed `get_risk_summary` and degraded every other
+     *  mark-reading consumer. See hl-position.ts for the doc-exact derivation.
+     *  A row that cannot be priced makes the WHOLE snapshot null (unknown) — never
+     *  a partial list, never a fabricated zero. */
     async fetchPositions(symbol) {
         try {
             assertNotLimited('clearinghouseState');
@@ -133,7 +143,19 @@ export class HyperliquidPrivateApi {
             noteSuccess('clearinghouseState');
             if (!Array.isArray(raw))
                 return null;
-            return raw.filter((p) => Math.abs(Number(p.contracts ?? 0)) > 0);
+            const out = [];
+            for (const p of raw) {
+                if (Math.abs(Number(p?.contracts ?? 0)) <= 0)
+                    continue; // flat row — information, not failure
+                const normalized = normalizeHlPosition(p);
+                if (!normalized) {
+                    logger.error(TAG, `fetchPositions: unparseable position row for ${String(p?.symbol ?? 'unknown symbol')} ` +
+                        '— returning null (snapshot UNTRUSTED; a dropped row would read as "flat")');
+                    return null;
+                }
+                out.push(normalized);
+            }
+            return out;
         }
         catch (err) {
             noteError(err, 'fetchPositions');
@@ -143,14 +165,19 @@ export class HyperliquidPrivateApi {
     }
     /** Open orders INCLUDING trigger/TPSL legs. CCXT's HL `fetchOpenOrders`
      *  defaults to `frontendOpenOrders`, which is the only endpoint that returns
-     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints. */
+     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints.
+     *
+     *  ★ Rows are normalized through `normalizeHlOrder` (ccxt leaves cost/fee/
+     *  average/timeInForce undefined and leaks 'take profit market' past the
+     *  type union — see hl-order.ts); `info` + `clientOrderId` survive verbatim
+     *  (protective classification + bracket reconciliation read them). */
     async fetchOpenOrders(symbol) {
         try {
             assertNotLimited('frontendOpenOrders');
             const s = symbol ? toCcxtSymbol('hyperliquid', symbol) : undefined;
             const raw = await this.exchange.fetchOpenOrders(s);
             noteSuccess('frontendOpenOrders');
-            return Array.isArray(raw) ? raw : null;
+            return Array.isArray(raw) ? raw.map((o) => normalizeHlOrder(o)) : null;
         }
         catch (err) {
             noteError(err, 'fetchOpenOrders');
@@ -173,14 +200,18 @@ export class HyperliquidPrivateApi {
     }
     /** Per-order status — the liveness resolver's REST tier (Tier 2 of the
      *  3-tier rule). Weight 2. `null` = lookup FAILED (unknown), which callers
-     *  must treat as "do not act", NOT as "gone". */
+     *  must treat as "do not act", NOT as "gone".
+     *
+     *  Normalized like fetchOpenOrders. Unknown statuses collapse to 'open'
+     *  (= not confirmed terminal — the conservative direction for both the
+     *  liveness resolver and the entry poller); raw status stays in `info`. */
     async fetchOrder(orderId, symbol) {
         try {
             assertNotLimited('orderStatus');
             const s = symbol ? toCcxtSymbol('hyperliquid', symbol) : undefined;
             const raw = await this.exchange.fetchOrder(orderId, s);
             noteSuccess('orderStatus');
-            return raw ?? null;
+            return raw ? normalizeHlOrder(raw) : null;
         }
         catch (err) {
             noteError(err, 'fetchOrder');

package/dist/cli.js

@@ -7,10 +7,14 @@
 // message from reefclaw.com/onboarding to their agent (paste-to-agent stays the
 // primary connect path). The bridge reads that config from openclaw.json and
 // connects within seconds.
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { installPlugin } from './plugin.js';
 import { installBridge } from './bridge.js';
 import { installSkill } from './skill.js';
 import { enableConnectorSupervisor } from './supervisor-config.js';
+import { tuneGatewayMemory } from './gateway-tuning.js';
 import { checkGateway, checkBinanceRegion } from './validate.js';
 import { readConfig, writeConfig, mergeReefClawConfig, gatewayAuthDowngradeNeeded, openClawInstalled, openClawConfigPath, readGatewayPort, } from './openclaw.js';
 import { run, which } from './exec.js';
@@ -92,21 +96,35 @@ function wireConfig(pre) {
 /** The gateway only loads plugins at startup — a plugin registered while it
  *  runs stays invisible until restart (the bridge would log "No trading tools
  *  found" forever). Best-effort: a user without a managed gateway just gets
- *  the manual hint. */
+ *  the manual hint.
+ *
+ *  Fallback: on systemd-user installs `openclaw gateway restart` can fail
+ *  while `systemctl --user restart` works (observed live 2026-07-24 — the
+ *  installer printed "could not restart automatically" and the new plugin
+ *  never loaded until a manual systemctl restart). Try the unit directly
+ *  before giving up. */
 function restartGateway() {
     step('Restarting the OpenClaw gateway to load the plugin');
-    if (!which('openclaw')) {
-        info('openclaw CLI not on PATH — restart your gateway manually to load the trading tools.');
-        return;
-    }
-    const r = run('openclaw', ['gateway', 'restart'], { timeoutMs: 120_000 });
-    if (r.ok) {
-        ok('gateway restarted');
+    if (which('openclaw')) {
+        const r = run('openclaw', ['gateway', 'restart'], { timeoutMs: 120_000 });
+        if (r.ok) {
+            ok('gateway restarted');
+            return;
+        }
     }
     else {
-        warn('could not restart the gateway automatically.');
-        info('Restart it yourself (e.g. `openclaw gateway restart`) so the trading tools load.');
+        info('openclaw CLI not on PATH — trying the systemd user service directly.');
+    }
+    if (process.platform === 'linux' &&
+        existsSync(join(homedir(), '.config', 'systemd', 'user', 'openclaw-gateway.service'))) {
+        const s = run('systemctl', ['--user', 'restart', 'openclaw-gateway'], { timeoutMs: 120_000 });
+        if (s.ok) {
+            ok('gateway restarted (systemd user service)');
+            return;
+        }
     }
+    warn('could not restart the gateway automatically.');
+    info('Restart it yourself (e.g. `openclaw gateway restart`) so the trading tools load.');
 }
 function nextSteps() {
     banner(green('✓ ReefClaw is installed.'));
@@ -135,6 +153,9 @@ async function main() {
     // launchd/Task-Scheduler, works in containers. The gateway restart below is
     // therefore also what STARTS the connector.
     const supervised = enableConnectorSupervisor();
+    // Size the gateway heap cap to this box BEFORE the restart below picks it up.
+    // Re-runs after a VPS resize; leaves operator-authored overrides untouched.
+    tuneGatewayMemory();
     if (plugin.registered)
         restartGateway();
     await checkGateway(readGatewayPort(merged));

package/dist/gateway-tuning.js

@@ -0,0 +1,112 @@
+// Box-size-aware gateway memory tuning (systemd-user installs only).
+//
+// Writes a NODE_OPTIONS heap cap + cgroup MemoryHigh override for the
+// openclaw-gateway user service, sized to the box's total RAM. Two field-proven
+// operating points (2026-07-22 / 2026-07-24 incidents):
+//   - ~2 GB box: uncapped node children balloon into the kernel OOM killer
+//     (heartbeats die at ~10 min) → cap 320 MB, MemoryHigh 1500M.
+//   - ~4 GB box: a STALE 320 MB cap left over from before a resize makes the
+//     gateway V8-OOM mid-heartbeat every ~15 min ("FATAL ERROR: Reached heap
+//     limit") with 2.5 GB free → cap 1536 MB, MemoryHigh 3000M.
+// The second incident is why this module re-runs on every install/update and
+// OVERWRITES a stale ReefClaw-authored override: resizing the droplet does not
+// raise the cap by itself. Files we did not author are never touched.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir, totalmem } from 'node:os';
+import { join } from 'node:path';
+import { run } from './exec.js';
+import { step, ok, info, warn } from './ui.js';
+const GiB = 1024 * 1024 * 1024;
+/** First line of every override we write — the ownership marker that makes the
+ *  file safe to overwrite on the next run. Operator-authored files without it
+ *  are left alone. */
+export const REEFCLAW_TUNING_MARKER = '# ReefClaw gateway memory tuning';
+/** Pick the tuning for a box, or null when the box is large enough that node's
+ *  defaults are fine and no override should be written. Pure — unit-testable. */
+export function computeHeapTuning(totalBytes) {
+    if (totalBytes <= 2.75 * GiB) {
+        // 1-2 GB class: survival mode. Node children must GC hard instead of
+        // ballooning into the kernel OOM killer.
+        return { maxOldSpaceMb: 320, memoryHigh: '1500M' };
+    }
+    if (totalBytes <= 6 * GiB) {
+        // 4 GB class (the recommended floor): room to breathe, still backstopped
+        // below the kernel OOM threshold.
+        return { maxOldSpaceMb: 1536, memoryHigh: '3000M' };
+    }
+    // 8 GB+: node's own defaults are appropriate; do not constrain.
+    return null;
+}
+/** Render the override file content for a tuning. */
+export function renderTuningConf(tuning, totalBytes) {
+    const totalGb = (totalBytes / GiB).toFixed(1);
+    return (`${REEFCLAW_TUNING_MARKER} — written by @reefclaw/connect for a ${totalGb} GB box.\n` +
+        `# Re-running the installer after a VPS resize regenerates this file with the\n` +
+        `# right cap (a stale small-box cap V8-OOMs the gateway mid-heartbeat).\n` +
+        `# Delete this file and its marker line to manage these values yourself.\n` +
+        `[Service]\n` +
+        `Environment=NODE_OPTIONS=--max-old-space-size=${tuning.maxOldSpaceMb}\n` +
+        `MemoryHigh=${tuning.memoryHigh}\n`);
+}
+/** True when the existing override file is ours to overwrite (absent, or
+ *  carries a ReefClaw marker — including the pre-installer hand-written
+ *  variants whose first line starts with "# ReefClaw"). Pure. */
+export function canReplaceOverride(existingContent) {
+    if (existingContent === null)
+        return true;
+    return existingContent.trimStart().startsWith('# ReefClaw');
+}
+/** Best-effort: returns true when the override is in place (written now or
+ *  already correct), false when skipped. Never throws — resource tuning must
+ *  not fail an install. */
+export function tuneGatewayMemory() {
+    if (process.platform !== 'linux')
+        return false;
+    const unitPath = join(homedir(), '.config', 'systemd', 'user', 'openclaw-gateway.service');
+    if (!existsSync(unitPath)) {
+        // Container / non-systemd install (e.g. the connector-supervisor path) —
+        // there is no unit to override.
+        return false;
+    }
+    step('Tuning gateway memory for this box');
+    try {
+        const tuning = computeHeapTuning(totalmem());
+        const dropInDir = `${unitPath}.d`;
+        // Historical name kept for continuity with the hand-written mitigation
+        // files already in the field (same file = systemd merge rules stay simple).
+        const confPath = join(dropInDir, 'small-box.conf');
+        const existing = existsSync(confPath) ? readFileSync(confPath, 'utf-8') : null;
+        if (!canReplaceOverride(existing)) {
+            info(`found an operator-managed override at ${confPath} — leaving it untouched.`);
+            return false;
+        }
+        if (tuning === null) {
+            if (existing !== null) {
+                info('box has ample RAM — existing ReefClaw override left as-is (delete it to use node defaults).');
+            }
+            else {
+                ok('box has ample RAM — no memory override needed');
+            }
+            return false;
+        }
+        const content = renderTuningConf(tuning, totalmem());
+        if (existing === content) {
+            ok(`gateway memory override already current (heap ${tuning.maxOldSpaceMb} MB, MemoryHigh ${tuning.memoryHigh})`);
+            return true;
+        }
+        mkdirSync(dropInDir, { recursive: true });
+        writeFileSync(confPath, content, 'utf-8');
+        // Reload so the values apply on the next service (re)start — the gateway
+        // restart later in the install flow picks them up.
+        const reload = run('systemctl', ['--user', 'daemon-reload'], { timeoutMs: 30_000 });
+        if (!reload.ok) {
+            warn('wrote the memory override but `systemctl --user daemon-reload` failed — it applies after the next reload/restart.');
+        }
+        ok(`gateway heap cap set to ${tuning.maxOldSpaceMb} MB (MemoryHigh ${tuning.memoryHigh}) for this box size`);
+        return true;
+    }
+    catch (err) {
+        warn(`could not tune gateway memory: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/connect",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
   "type": "module",
   "bin": {

package/assets/shared/signals/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/shared/signals/indicators-extended.js

@@ -1,284 +0,0 @@
-// 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;
-}