tradelab 1.0.1 → 1.1.0

package/dist/cjs/live.cjs

@@ -56,6 +56,7 @@ __export(index_exports, {
   createCandleAggregator: () => createCandleAggregator,
   createClock: () => createClock,
   createCoinbaseBroker: () => createCoinbaseBroker,
+  createDashboardServer: () => createDashboardServer,
   createEventBus: () => createEventBus,
   createInteractiveBrokersBroker: () => createInteractiveBrokersBroker,
   createJsonFileStorage: () => createJsonFileStorage,
@@ -435,10 +436,10 @@ var AlpacaBroker = class extends BrokerAdapter {
       ...extra
     };
   }
-  async _request(method, path2, { query = null, body = null, dataApi = false } = {}) {
+  async _request(method, path3, { query = null, body = null, dataApi = false } = {}) {
     if (!this.fetch) throw new Error("global fetch is unavailable");
     const base = dataApi ? this.dataUrl : this.baseUrl;
-    const url = withQuery(`${base}${path2}`, query || {});
+    const url = withQuery(`${base}${path3}`, query || {});
     const response = await this.fetch(url, {
       method,
       headers: this._headers(),
@@ -648,11 +649,11 @@ var BinanceBroker = class extends BrokerAdapter {
     const signature = import_node_crypto.default.createHmac("sha256", this.config.apiSecret || "").update(payload).digest("hex");
     return { ...base, signature };
   }
-  async _request(method, path2, { signed = false, params = {}, body = null } = {}) {
+  async _request(method, path3, { signed = false, params = {}, body = null } = {}) {
     if (!this.fetch) throw new Error("global fetch is unavailable");
     const finalParams = signed ? this._signedParams(params) : params;
     const qs = queryString(finalParams);
-    const url = new import_node_url2.URL(`${this.baseUrl}${path2}${qs ? `?${qs}` : ""}`);
+    const url = new import_node_url2.URL(`${this.baseUrl}${path3}${qs ? `?${qs}` : ""}`);
     const headers = {
       "content-type": "application/json"
     };
@@ -671,8 +672,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return payload;
   }
   async getServerTime() {
-    const path2 = this.config.futures ? "/fapi/v1/time" : "/api/v3/time";
-    const data = await this._request("GET", path2);
+    const path3 = this.config.futures ? "/fapi/v1/time" : "/api/v3/time";
+    const data = await this._request("GET", path3);
     return Number(data.serverTime || Date.now());
   }
   async getAccount() {
@@ -735,8 +736,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return payload;
   }
   async submitOrder(order) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    const response = await this._request("POST", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    const response = await this._request("POST", path3, {
       signed: true,
       params: this._orderPayload(order)
     });
@@ -757,8 +758,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return receipt;
   }
   async cancelOrder(orderId) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    await this._request("DELETE", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    await this._request("DELETE", path3, {
       signed: true,
       params: {
         orderId
@@ -767,8 +768,8 @@ var BinanceBroker = class extends BrokerAdapter {
     this.emit("order:canceled", { orderId: String(orderId) });
   }
   async modifyOrder(orderId, changes = {}) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    const response = await this._request("PUT", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    const response = await this._request("PUT", path3, {
       signed: true,
       params: {
         orderId,
@@ -793,8 +794,8 @@ var BinanceBroker = class extends BrokerAdapter {
     return receipt;
   }
   async getOpenOrders() {
-    const path2 = this.config.futures ? "/fapi/v1/openOrders" : "/api/v3/openOrders";
-    const rows = await this._request("GET", path2, { signed: true });
+    const path3 = this.config.futures ? "/fapi/v1/openOrders" : "/api/v3/openOrders";
+    const rows = await this._request("GET", path3, { signed: true });
     return rows.map((row) => ({
       orderId: String(row.orderId),
       clientOrderId: row.clientOrderId,
@@ -810,8 +811,8 @@ var BinanceBroker = class extends BrokerAdapter {
     }));
   }
   async getOrderStatus(orderId) {
-    const path2 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
-    const row = await this._request("GET", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/order" : "/api/v3/order";
+    const row = await this._request("GET", path3, {
       signed: true,
       params: { orderId }
     });
@@ -873,8 +874,8 @@ var BinanceBroker = class extends BrokerAdapter {
     };
   }
   async getHistoricalBars(symbol, interval, limit = 200) {
-    const path2 = this.config.futures ? "/fapi/v1/klines" : "/api/v3/klines";
-    const rows = await this._request("GET", path2, {
+    const path3 = this.config.futures ? "/fapi/v1/klines" : "/api/v3/klines";
+    const rows = await this._request("GET", path3, {
       params: { symbol, interval, limit }
     });
     const bars = rows.map((row) => ({
@@ -898,7 +899,7 @@ var import_node_url3 = require("node:url");
 function base64url(input) {
   return Buffer.from(input).toString("base64url");
 }
-function buildJwt({ key, secret, method, host, path: path2 }) {
+function buildJwt({ key, secret, method, host, path: path3 }) {
   const now = Math.floor(Date.now() / 1e3);
   const header = { alg: "HS256", typ: "JWT", kid: key };
   const payload = {
@@ -906,7 +907,7 @@ function buildJwt({ key, secret, method, host, path: path2 }) {
     sub: key,
     nbf: now - 5,
     exp: now + 120,
-    uri: `${method.toUpperCase()} ${host}${path2}`
+    uri: `${method.toUpperCase()} ${host}${path3}`
   };
   const encodedHeader = base64url(JSON.stringify(header));
   const encodedPayload = base64url(JSON.stringify(payload));
@@ -965,9 +966,9 @@ var CoinbaseBroker = class extends BrokerAdapter {
       path: target.pathname
     });
   }
-  async _request(method, path2, { query = {}, body = null } = {}) {
+  async _request(method, path3, { query = {}, body = null } = {}) {
     if (!this.fetch) throw new Error("global fetch is unavailable");
-    const url = new import_node_url3.URL(`${this.baseUrl}${path2}`);
+    const url = new import_node_url3.URL(`${this.baseUrl}${path3}`);
     for (const [key, value] of Object.entries(query || {})) {
       if (value === void 0 || value === null) continue;
       url.searchParams.set(key, String(value));
@@ -1726,6 +1727,7 @@ function dayKeyET(timeMs) {
   const pseudoEtTime = anchor.getTime() + hoursET * 60 * 60 * 1e3 + minutesETDay * 60 * 1e3;
   return dayKeyUTC(pseudoEtTime);
 }
+var MS_PER_YEAR = 365 * 24 * 60 * 60 * 1e3;
 
 // src/live/engine/candleAggregator.js
 function intervalToMs(interval) {
@@ -2549,9 +2551,9 @@ function asNumber2(value) {
 function formatIsoTime(time) {
   return Number.isFinite(time) ? new Date(time).toISOString() : "invalid-time";
 }
-function callSignalWithContext({ signal, context, index, bar, symbol }) {
+async function callSignalWithContextAsync({ signal, context, index, bar, symbol }) {
   try {
-    return signal(context);
+    return await signal(context);
   } catch (error) {
     const cause = error instanceof Error ? error.message : String(error);
     throw new Error(
@@ -3038,7 +3040,7 @@ var LiveEngine = class {
     }
     if (!this.openPosition && !this.pendingOrder) {
       const context = this._signalContext(bar);
-      const rawSignal = callSignalWithContext({
+      const rawSignal = await callSignalWithContextAsync({
         signal: this.options.signal,
         context,
         index: context.index,
@@ -3309,6 +3311,112 @@ var LiveOrchestrator = class {
 function createLiveOrchestrator(options) {
   return new LiveOrchestrator(options);
 }
+
+// src/live/dashboard/server.js
+var import_node_http = __toESM(require("node:http"), 1);
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_url4 = require("node:url");
+var import_meta = {};
+var FALLBACK_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>tradelab live</title>
+  </head>
+  <body>
+    <h1>tradelab live</h1>
+    <pre id="state"></pre>
+    <script>
+      fetch("/state")
+        .then((res) => res.json())
+        .then((state) => {
+          document.getElementById("state").textContent = JSON.stringify(state, null, 2);
+        });
+    </script>
+  </body>
+</html>`;
+function readDashboardHtml() {
+  if (import_meta.url) {
+    const here = import_node_path2.default.dirname((0, import_node_url4.fileURLToPath)(import_meta.url));
+    const htmlPath = import_node_path2.default.join(here, "..", "..", "..", "templates", "dashboard.html");
+    return (0, import_node_fs2.readFileSync)(htmlPath, "utf8");
+  }
+  try {
+    return (0, import_node_fs2.readFileSync)(import_node_path2.default.join(process.cwd(), "templates", "dashboard.html"), "utf8");
+  } catch {
+    return FALLBACK_HTML;
+  }
+}
+function createDashboardServer({ source, port = 4317, maxBuffer = 200 }) {
+  if (!source?.eventBus || typeof source.eventBus.onAny !== "function") {
+    throw new Error("dashboard source must expose an eventBus with onAny()");
+  }
+  const recent = [];
+  const clients = /* @__PURE__ */ new Set();
+  const unsubscribe = source.eventBus.onAny(({ event, payload }) => {
+    const msg = { event, payload, t: Date.now() };
+    recent.push(msg);
+    if (recent.length > maxBuffer) recent.shift();
+    const frame = `data: ${JSON.stringify(msg)}
+
+`;
+    for (const res of clients) res.write(frame);
+  });
+  const server = import_node_http.default.createServer((req, res) => {
+    const url = (req.url || "/").split("?")[0];
+    if (url === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(readDashboardHtml());
+      return;
+    }
+    if (url === "/state") {
+      const status = typeof source.getStatus === "function" ? source.getStatus() : {};
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(status));
+      return;
+    }
+    if (url === "/events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      res.flushHeaders();
+      for (const msg of recent) res.write(`data: ${JSON.stringify(msg)}
+
+`);
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("not found");
+  });
+  return {
+    start() {
+      return new Promise((resolve) => {
+        server.listen(port, () => {
+          const address = server.address();
+          const actualPort = typeof address === "object" && address ? address.port : port;
+          resolve(`http://localhost:${actualPort}`);
+        });
+      });
+    },
+    close() {
+      unsubscribe();
+      for (const res of clients) res.end();
+      clients.clear();
+      return new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) reject(error);
+          else resolve();
+        });
+      });
+    },
+    server
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AlpacaBroker,
@@ -3337,6 +3445,7 @@ function createLiveOrchestrator(options) {
   createCandleAggregator,
   createClock,
   createCoinbaseBroker,
+  createDashboardServer,
   createEventBus,
   createInteractiveBrokersBroker,
   createJsonFileStorage,

package/dist/cjs/ta.cjs

@@ -0,0 +1,339 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ta/index.js
+var index_exports = {};
+__export(index_exports, {
+  atr: () => atr,
+  bollinger: () => bollinger,
+  detectFVG: () => detectFVG,
+  donchian: () => donchian,
+  ema: () => ema,
+  keltner: () => keltner,
+  lastSwing: () => lastSwing,
+  macd: () => macd,
+  rsi: () => rsi,
+  stochastic: () => stochastic,
+  structureState: () => structureState,
+  supertrend: () => supertrend,
+  swingHigh: () => swingHigh,
+  swingLow: () => swingLow,
+  vwap: () => vwap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/indicators.js
+function ema(values, period = 14) {
+  if (!values?.length) return [];
+  const lookback = Math.max(1, period | 0);
+  const output = new Array(values.length);
+  let warmupSum = 0;
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (!Number.isFinite(value)) {
+      output[index] = index === 0 ? 0 : output[index - 1];
+      continue;
+    }
+    if (index < lookback) {
+      warmupSum += value;
+      output[index] = index === lookback - 1 ? warmupSum / lookback : value;
+      continue;
+    }
+    const smoothing = 2 / (lookback + 1);
+    output[index] = value * smoothing + output[index - 1] * (1 - smoothing);
+  }
+  return output;
+}
+function swingHigh(bars, index, left = 2, right = 2) {
+  if (index < left || index + right >= bars.length) return false;
+  const high = bars[index].high;
+  for (let cursor = index - left; cursor <= index + right; cursor += 1) {
+    if (cursor !== index && bars[cursor].high >= high) return false;
+  }
+  return true;
+}
+function swingLow(bars, index, left = 2, right = 2) {
+  if (index < left || index + right >= bars.length) return false;
+  const low = bars[index].low;
+  for (let cursor = index - left; cursor <= index + right; cursor += 1) {
+    if (cursor !== index && bars[cursor].low <= low) return false;
+  }
+  return true;
+}
+function detectFVG(bars, index) {
+  if (index < 2) return null;
+  const first = bars[index - 2];
+  const third = bars[index];
+  if (first.high < third.low) {
+    return {
+      type: "bull",
+      top: first.high,
+      bottom: third.low,
+      mid: (first.high + third.low) / 2
+    };
+  }
+  if (first.low > third.high) {
+    return {
+      type: "bear",
+      top: third.high,
+      bottom: first.low,
+      mid: (third.high + first.low) / 2
+    };
+  }
+  return null;
+}
+function lastSwing(bars, index, direction) {
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    if (direction === "up" && swingLow(bars, cursor)) {
+      return { idx: cursor, price: bars[cursor].low };
+    }
+    if (direction === "down" && swingHigh(bars, cursor)) {
+      return { idx: cursor, price: bars[cursor].high };
+    }
+  }
+  return null;
+}
+function structureState(bars, index) {
+  return {
+    lastLow: lastSwing(bars, index, "up"),
+    lastHigh: lastSwing(bars, index, "down")
+  };
+}
+function atr(bars, period = 14) {
+  if (!bars?.length || period <= 0) return [];
+  const trueRanges = new Array(bars.length);
+  for (let index = 0; index < bars.length; index += 1) {
+    if (index === 0) {
+      trueRanges[index] = bars[index].high - bars[index].low;
+      continue;
+    }
+    const high = bars[index].high;
+    const low = bars[index].low;
+    const previousClose = bars[index - 1].close;
+    trueRanges[index] = Math.max(
+      high - low,
+      Math.abs(high - previousClose),
+      Math.abs(low - previousClose)
+    );
+  }
+  const output = new Array(trueRanges.length);
+  let previousAtr;
+  for (let index = 0; index < trueRanges.length; index += 1) {
+    if (index < period) {
+      output[index] = void 0;
+      if (index === period - 1) {
+        let seed = 0;
+        for (let cursor = 0; cursor < period; cursor += 1) {
+          seed += trueRanges[cursor];
+        }
+        previousAtr = seed / period;
+        output[index] = previousAtr;
+      }
+      continue;
+    }
+    previousAtr = (previousAtr * (period - 1) + trueRanges[index]) / period;
+    output[index] = previousAtr;
+  }
+  return output;
+}
+
+// src/ta/oscillators.js
+function rsi(closes, period = 14) {
+  const out = new Array(closes.length).fill(void 0);
+  if (closes.length <= period) return out;
+  let gainSum = 0;
+  let lossSum = 0;
+  for (let i = 1; i <= period; i += 1) {
+    const change = closes[i] - closes[i - 1];
+    if (change >= 0) gainSum += change;
+    else lossSum -= change;
+  }
+  let avgGain = gainSum / period;
+  let avgLoss = lossSum / period;
+  out[period] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  for (let i = period + 1; i < closes.length; i += 1) {
+    const change = closes[i] - closes[i - 1];
+    const gain = change > 0 ? change : 0;
+    const loss = change < 0 ? -change : 0;
+    avgGain = (avgGain * (period - 1) + gain) / period;
+    avgLoss = (avgLoss * (period - 1) + loss) / period;
+    out[i] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  }
+  return out;
+}
+function macd(closes, fast = 12, slow = 26, signalPeriod = 9) {
+  const emaFast = ema(closes, fast);
+  const emaSlow = ema(closes, slow);
+  const macdLine = closes.map((_, i) => emaFast[i] - emaSlow[i]);
+  const signalLine = ema(macdLine, signalPeriod);
+  const histogram = macdLine.map((v, i) => v - signalLine[i]);
+  return { macd: macdLine, signal: signalLine, histogram };
+}
+function stochastic(bars, kPeriod = 14, dPeriod = 3) {
+  const k = new Array(bars.length).fill(void 0);
+  for (let i = kPeriod - 1; i < bars.length; i += 1) {
+    let hh = -Infinity;
+    let ll = Infinity;
+    for (let j = i - kPeriod + 1; j <= i; j += 1) {
+      if (bars[j].high > hh) hh = bars[j].high;
+      if (bars[j].low < ll) ll = bars[j].low;
+    }
+    const range = hh - ll;
+    k[i] = range === 0 ? 0 : (bars[i].close - ll) / range * 100;
+  }
+  const d = new Array(bars.length).fill(void 0);
+  for (let i = 0; i < bars.length; i += 1) {
+    if (i < kPeriod - 1 + dPeriod - 1) continue;
+    let sum = 0;
+    for (let j = i - dPeriod + 1; j <= i; j += 1) sum += k[j];
+    d[i] = sum / dPeriod;
+  }
+  return { k, d };
+}
+
+// src/ta/channels.js
+function rollingMean(values, period, i) {
+  let sum = 0;
+  for (let j = i - period + 1; j <= i; j += 1) sum += values[j];
+  return sum / period;
+}
+function bollinger(closes, period = 20, mult = 2) {
+  const middle = new Array(closes.length).fill(void 0);
+  const upper = new Array(closes.length).fill(void 0);
+  const lower = new Array(closes.length).fill(void 0);
+  for (let i = period - 1; i < closes.length; i += 1) {
+    const avg = rollingMean(closes, period, i);
+    let variance = 0;
+    for (let j = i - period + 1; j <= i; j += 1) variance += (closes[j] - avg) ** 2;
+    const sd = Math.sqrt(variance / period);
+    middle[i] = avg;
+    upper[i] = avg + mult * sd;
+    lower[i] = avg - mult * sd;
+  }
+  return { middle, upper, lower };
+}
+function donchian(bars, period = 20) {
+  const upper = new Array(bars.length).fill(void 0);
+  const lower = new Array(bars.length).fill(void 0);
+  const middle = new Array(bars.length).fill(void 0);
+  for (let i = period - 1; i < bars.length; i += 1) {
+    let hh = -Infinity;
+    let ll = Infinity;
+    for (let j = i - period + 1; j <= i; j += 1) {
+      if (bars[j].high > hh) hh = bars[j].high;
+      if (bars[j].low < ll) ll = bars[j].low;
+    }
+    upper[i] = hh;
+    lower[i] = ll;
+    middle[i] = (hh + ll) / 2;
+  }
+  return { upper, lower, middle };
+}
+function keltner(bars, emaPeriod = 20, atrPeriod = 14, mult = 2) {
+  const closes = bars.map((b) => b.close);
+  const mid = ema(closes, emaPeriod);
+  const range = atr(bars, atrPeriod);
+  const upper = new Array(bars.length).fill(void 0);
+  const lower = new Array(bars.length).fill(void 0);
+  const middle = new Array(bars.length).fill(void 0);
+  for (let i = 0; i < bars.length; i += 1) {
+    if (range[i] === void 0) continue;
+    middle[i] = mid[i];
+    upper[i] = mid[i] + mult * range[i];
+    lower[i] = mid[i] - mult * range[i];
+  }
+  return { upper, lower, middle };
+}
+
+// src/ta/trend.js
+function supertrend(bars, period = 10, mult = 3) {
+  const range = atr(bars, period);
+  const line = new Array(bars.length).fill(void 0);
+  const direction = new Array(bars.length).fill(void 0);
+  let prevUpper = Infinity;
+  let prevLower = -Infinity;
+  let prevDir = 1;
+  for (let i = 0; i < bars.length; i += 1) {
+    if (range[i] === void 0) continue;
+    const mid = (bars[i].high + bars[i].low) / 2;
+    const basicUpper = mid + mult * range[i];
+    const basicLower = mid - mult * range[i];
+    const close = bars[i].close;
+    const prevClose = i > 0 ? bars[i - 1].close : close;
+    const upper = basicUpper < prevUpper || prevClose > prevUpper ? basicUpper : prevUpper;
+    const lower = basicLower > prevLower || prevClose < prevLower ? basicLower : prevLower;
+    let dir = prevDir;
+    if (prevDir === 1 && close < lower) dir = -1;
+    else if (prevDir === -1 && close > upper) dir = 1;
+    line[i] = dir === 1 ? lower : upper;
+    direction[i] = dir;
+    prevUpper = upper;
+    prevLower = lower;
+    prevDir = dir;
+  }
+  return { line, direction };
+}
+function dayKeyUTC(timeMs) {
+  const d = new Date(timeMs);
+  return d.getUTCFullYear() * 1e4 + (d.getUTCMonth() + 1) * 100 + d.getUTCDate();
+}
+function vwap(bars) {
+  const out = new Array(bars.length).fill(void 0);
+  let currentDay = null;
+  let cumPV = 0;
+  let cumV = 0;
+  let cumTP = 0;
+  let count = 0;
+  for (let i = 0; i < bars.length; i += 1) {
+    const day = dayKeyUTC(bars[i].time);
+    if (day !== currentDay) {
+      currentDay = day;
+      cumPV = 0;
+      cumV = 0;
+      cumTP = 0;
+      count = 0;
+    }
+    const tp = (bars[i].high + bars[i].low + bars[i].close) / 3;
+    const vol = Number.isFinite(bars[i].volume) ? bars[i].volume : 0;
+    cumPV += tp * vol;
+    cumV += vol;
+    cumTP += tp;
+    count += 1;
+    out[i] = cumV > 0 ? cumPV / cumV : cumTP / count;
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  atr,
+  bollinger,
+  detectFVG,
+  donchian,
+  ema,
+  keltner,
+  lastSwing,
+  macd,
+  rsi,
+  stochastic,
+  structureState,
+  supertrend,
+  swingHigh,
+  swingLow,
+  vwap
+});

package/docs/api-reference.md

@@ -123,11 +123,57 @@ import { LiveEngine, PaperEngine } from "tradelab/live";
 - `parseWindowsCSV(csv)`
 - `inWindowsET(timeMs, windows)`
 
+## Technical analysis (`tradelab/ta`)
+
+TA exports are under a separate entrypoint:
+
+```js
+import { rsi, macd, bollinger, vwap, supertrend } from "tradelab/ta";
+```
+
+Every indicator returns a **full-length array aligned to the input** — warmup positions are `undefined` so values index 1:1 with candles. Oscillators accept a `number[]` of closes; range-based indicators accept `{ high, low, close }` candle arrays.
+
+### Oscillators
+
+| Export                                      | Input        | Returns                       | Description                                              |
+| ------------------------------------------- | ------------ | ----------------------------- | -------------------------------------------------------- |
+| `rsi(closes, period?)`                      | `number[]`   | `(number \| undefined)[]`     | Wilder's RSI; warmup positions are `undefined`           |
+| `macd(closes, fast?, slow?, signalPeriod?)` | `number[]`   | `{ macd, signal, histogram }` | MACD line, signal line, and histogram; all full-length   |
+| `stochastic(bars, kPeriod?, dPeriod?)`      | candle array | `{ k, d }`                    | Stochastic %K and %D; `k` and `d` are full-length arrays |
+
+### Bands & channels
+
+| Export                                         | Input        | Returns                    | Description                                                   |
+| ---------------------------------------------- | ------------ | -------------------------- | ------------------------------------------------------------- |
+| `bollinger(closes, period?, mult?)`            | `number[]`   | `{ middle, upper, lower }` | Bollinger Bands with SMA middle and stddev-scaled outer bands |
+| `donchian(bars, period?)`                      | candle array | `{ upper, lower, middle }` | Donchian channel: rolling highest-high / lowest-low           |
+| `keltner(bars, emaPeriod?, atrPeriod?, mult?)` | candle array | `{ upper, lower, middle }` | Keltner channel: EMA middle with ATR-scaled width             |
+
+### Trend & volume
+
+| Export                             | Input                                 | Returns                   | Description                                                                |
+| ---------------------------------- | ------------------------------------- | ------------------------- | -------------------------------------------------------------------------- |
+| `supertrend(bars, period?, mult?)` | candle array                          | `{ line, direction }`     | Supertrend support/resistance line; `direction` is `1` (up) or `-1` (down) |
+| `vwap(bars)`                       | candle array with `time` and `volume` | `(number \| undefined)[]` | Session VWAP, resets on each UTC calendar day                              |
+
+### Re-exported from main module
+
+| Export                                  | Description                        |
+| --------------------------------------- | ---------------------------------- |
+| `ema(values, period?)`                  | Exponential moving average         |
+| `atr(bars, period?)`                    | Average True Range                 |
+| `swingHigh(bars, index, left?, right?)` | Detect swing high at index         |
+| `swingLow(bars, index, left?, right?)`  | Detect swing low at index          |
+| `detectFVG(bars, index)`                | Detect Fair Value Gap at index     |
+| `lastSwing(bars, index, direction)`     | Find the last swing in a direction |
+| `structureState(bars, index)`           | Assess market structure state      |
+
 ## Types
 
 The package ships declarations in:
 
 - [../types/index.d.ts](../types/index.d.ts) for the main module
 - [../types/live.d.ts](../types/live.d.ts) for `tradelab/live`
+- [../types/ta.d.ts](../types/ta.d.ts) for `tradelab/ta`
 
 <small>[Back to main page](README.md)</small>