@livefolio/sdk 0.2.13 → 0.3.0

package/dist/index.js

@@ -1,55 +1,1379 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.portfolio = exports.strategy = exports.market = exports.auth = void 0;
-exports.createLivefolioClient = createLivefolioClient;
-exports.auth = __importStar(require("./auth"));
-exports.market = __importStar(require("./market"));
-exports.strategy = __importStar(require("./strategy"));
-exports.portfolio = __importStar(require("./portfolio"));
-const auth_1 = require("./auth");
-const market_1 = require("./market");
-const strategy_1 = require("./strategy");
-const portfolio_1 = require("./portfolio");
-function createLivefolioClient(supabase) {
+// src/handles/ticker.ts
+var TickerHandle = class _TickerHandle {
+  symbol;
+  leverage;
+  _storage;
+  _resolvedId = null;
+  _resolving = null;
+  constructor(storage, symbol, leverage = 1) {
+    this._storage = storage;
+    this.symbol = symbol.toUpperCase();
+    this.leverage = leverage;
+  }
+  get id() {
+    if (this._resolvedId == null)
+      throw new Error("TickerHandle not yet resolved. Call resolve(), or access via an async method.");
+    return this._resolvedId;
+  }
+  async resolve() {
+    if (this._resolvedId != null) return { id: this._resolvedId };
+    if (!this._resolving) this._resolving = this._doResolve();
+    return this._resolving;
+  }
+  static fromResolved(storage, id, symbol, leverage) {
+    const handle = new _TickerHandle(storage, symbol, leverage);
+    handle._resolvedId = id;
+    return handle;
+  }
+  async _doResolve() {
+    const result = await this._storage.tickers.findOrCreate(this.symbol, this.leverage);
+    this._resolvedId = result.id;
+    return result;
+  }
+};
+
+// src/providers/mappings.ts
+var FRED_SERIES = {
+  T3M: "DGS3MO",
+  T6M: "DGS6MO",
+  T1Y: "DGS1",
+  T2Y: "DGS2",
+  T3Y: "DGS3",
+  T5Y: "DGS5",
+  T7Y: "DGS7",
+  T10Y: "DGS10",
+  T20Y: "DGS20",
+  T30Y: "DGS30"
+};
+var COMPUTED_TYPES = /* @__PURE__ */ new Set(["SMA", "EMA", "RSI", "Return", "Volatility", "Drawdown"]);
+var CALENDAR_TYPES = /* @__PURE__ */ new Set(["Month", "Day of Week", "Day of Month", "Day of Year"]);
+function getProviderInfo(type, tickerSymbol) {
+  if (type === "Price") return { provider: "yahoo", symbol: tickerSymbol };
+  if (type === "VIX") return { provider: "yahoo", symbol: "^VIX" };
+  if (type === "VIX3M") return { provider: "yahoo", symbol: "^VIX3M" };
+  if (type in FRED_SERIES) return { provider: "fred", seriesId: FRED_SERIES[type] };
+  if (COMPUTED_TYPES.has(type)) return { provider: "computed", dependsOn: "Price", symbol: tickerSymbol };
+  if (CALENDAR_TYPES.has(type)) return { provider: "calendar" };
+  return { provider: "none" };
+}
+
+// src/computations/sma.ts
+function computeSma(bars, lookback) {
+  if (bars.length < lookback) return [];
+  const result = [];
+  let sum = 0;
+  for (let i = 0; i < lookback; i++) sum += bars[i].value;
+  result.push({ date: bars[lookback - 1].date, value: sum / lookback });
+  for (let i = lookback; i < bars.length; i++) {
+    sum += bars[i].value - bars[i - lookback].value;
+    result.push({ date: bars[i].date, value: sum / lookback });
+  }
+  return result;
+}
+
+// src/computations/ema.ts
+function computeEma(bars, lookback) {
+  if (bars.length < lookback) return [];
+  const multiplier = 2 / (lookback + 1);
+  const result = [];
+  let sum = 0;
+  for (let i = 0; i < lookback; i++) sum += bars[i].value;
+  let ema = sum / lookback;
+  result.push({ date: bars[lookback - 1].date, value: ema });
+  for (let i = lookback; i < bars.length; i++) {
+    ema = bars[i].value * multiplier + ema * (1 - multiplier);
+    result.push({ date: bars[i].date, value: ema });
+  }
+  return result;
+}
+
+// src/computations/rsi.ts
+function computeRsi(bars, lookback) {
+  if (bars.length < lookback + 1) return [];
+  const changes = [];
+  for (let i = 1; i < bars.length; i++) {
+    changes.push(bars[i].value - bars[i - 1].value);
+  }
+  let avgGain = 0;
+  let avgLoss = 0;
+  for (let i = 0; i < lookback; i++) {
+    if (changes[i] > 0) avgGain += changes[i];
+    else avgLoss += Math.abs(changes[i]);
+  }
+  avgGain /= lookback;
+  avgLoss /= lookback;
+  const result = [];
+  const rs = avgLoss === 0 ? 100 : avgGain / avgLoss;
+  result.push({
+    date: bars[lookback].date,
+    value: avgLoss === 0 ? 100 : 100 - 100 / (1 + rs)
+  });
+  for (let i = lookback; i < changes.length; i++) {
+    const gain = changes[i] > 0 ? changes[i] : 0;
+    const loss = changes[i] < 0 ? Math.abs(changes[i]) : 0;
+    avgGain = (avgGain * (lookback - 1) + gain) / lookback;
+    avgLoss = (avgLoss * (lookback - 1) + loss) / lookback;
+    const smoothRs = avgLoss === 0 ? 100 : avgGain / avgLoss;
+    result.push({
+      date: bars[i + 1].date,
+      value: avgLoss === 0 ? 100 : 100 - 100 / (1 + smoothRs)
+    });
+  }
+  return result;
+}
+
+// src/computations/returns.ts
+function computeReturns(bars, lookback) {
+  if (bars.length <= lookback) return [];
+  const result = [];
+  for (let i = lookback; i < bars.length; i++) {
+    result.push({
+      date: bars[i].date,
+      value: (bars[i].value - bars[i - lookback].value) / bars[i - lookback].value
+    });
+  }
+  return result;
+}
+
+// src/computations/volatility.ts
+function computeVolatility(bars, lookback) {
+  if (bars.length < lookback + 1) return [];
+  const dailyReturns = [];
+  for (let i = 1; i < bars.length; i++) {
+    dailyReturns.push({
+      date: bars[i].date,
+      value: bars[i].value / bars[i - 1].value - 1
+    });
+  }
+  if (dailyReturns.length < lookback) return [];
+  const result = [];
+  for (let i = lookback - 1; i < dailyReturns.length; i++) {
+    const window = dailyReturns.slice(i - lookback + 1, i + 1);
+    const mean = window.reduce((s, r) => s + r.value, 0) / lookback;
+    const variance = window.reduce((s, r) => s + (r.value - mean) ** 2, 0) / lookback;
+    result.push({ date: dailyReturns[i].date, value: Math.sqrt(variance) });
+  }
+  return result;
+}
+
+// src/computations/drawdown.ts
+function computeDrawdown(bars, lookback) {
+  if (bars.length < lookback) return [];
+  const result = [];
+  for (let i = lookback - 1; i < bars.length; i++) {
+    let max = -Infinity;
+    for (let j = i - lookback + 1; j <= i; j++) {
+      if (bars[j].value > max) max = bars[j].value;
+    }
+    result.push({ date: bars[i].date, value: (bars[i].value - max) / max });
+  }
+  return result;
+}
+
+// src/computations/calendar.ts
+function dayOfYear(d) {
+  const start = new Date(d.getFullYear(), 0, 0);
+  const diff = d.getTime() - start.getTime();
+  return Math.floor(diff / (1e3 * 60 * 60 * 24));
+}
+function computeCalendar(bars, period) {
+  return bars.map((bar) => {
+    const [y, m, d] = bar.date.split("-").map(Number);
+    const date = new Date(y, m - 1, d);
+    let value;
+    switch (period) {
+      case "Month":
+        value = date.getMonth() + 1;
+        break;
+      case "Day of Week":
+        value = date.getDay();
+        break;
+      case "Day of Month":
+        value = date.getDate();
+        break;
+      case "Day of Year":
+        value = dayOfYear(date);
+        break;
+    }
+    return { date: bar.date, value };
+  });
+}
+
+// src/computations/index.ts
+var COMPUTATIONS = {
+  SMA: computeSma,
+  EMA: computeEma,
+  RSI: computeRsi,
+  Return: computeReturns,
+  Volatility: computeVolatility,
+  Drawdown: computeDrawdown
+};
+function getComputation(type) {
+  return COMPUTATIONS[type] ?? null;
+}
+
+// src/handles/indicator.ts
+var IndicatorHandle = class _IndicatorHandle {
+  type;
+  ticker;
+  lookback;
+  delay;
+  unit;
+  threshold;
+  _storage;
+  _market;
+  _resolvedId = null;
+  _resolving = null;
+  _cachedSeries = null;
+  _cachedAsOf = null;
+  _syncing = null;
+  constructor(storage, market, identity) {
+    this._storage = storage;
+    this._market = market;
+    this.type = identity.type;
+    this.ticker = identity.ticker;
+    this.lookback = identity.lookback;
+    this.delay = identity.delay;
+    this.unit = identity.unit;
+    this.threshold = identity.threshold;
+  }
+  get id() {
+    if (this._resolvedId == null)
+      throw new Error("IndicatorHandle not yet resolved. Call resolve(), or access via an async method.");
+    return this._resolvedId;
+  }
+  async resolve() {
+    if (this._resolvedId != null) return { id: this._resolvedId };
+    if (!this._resolving) this._resolving = this._doResolve();
+    return this._resolving;
+  }
+  static fromResolved(storage, market, id, identity) {
+    const handle = new _IndicatorHandle(storage, market, identity);
+    handle._resolvedId = id;
+    return handle;
+  }
+  async _doResolve() {
+    const tickerId = this.ticker ? (await this.ticker.resolve()).id : null;
+    const result = await this._storage.indicators.findOrCreate({
+      type: this.type,
+      tickerId,
+      lookback: this.lookback,
+      delay: this.delay,
+      unit: this.unit,
+      threshold: this.threshold
+    });
+    this._resolvedId = result.id;
+    return result;
+  }
+  // ── Freshness & Sync ───────────────────────────────────────────────
+  async _getLatestClosedTradingDay() {
+    const date = await this._storage.tradingDays.getLatestClosed();
+    if (!date) throw new Error("No closed trading days found");
+    return date;
+  }
+  async _getLatestSeriesDate(indicatorId) {
+    return this._storage.indicators.getLatestSeriesDate(indicatorId);
+  }
+  async _ensureFresh() {
+    const { id } = await this.resolve();
+    const latestClosed = await this._getLatestClosedTradingDay();
+    if (this._cachedAsOf === latestClosed) return;
+    const latestSeries = await this._getLatestSeriesDate(id);
+    if (latestSeries === latestClosed) {
+      this._cachedSeries = null;
+      this._cachedAsOf = latestClosed;
+      return;
+    }
+    if (!this._syncing) {
+      this._syncing = this._sync(latestSeries ?? void 0, latestClosed).finally(() => {
+        this._syncing = null;
+      });
+    }
+    await this._syncing;
+    this._cachedSeries = null;
+    this._cachedAsOf = latestClosed;
+  }
+  async _sync(fromDate, latestClosed) {
+    const tickerSymbol = this.ticker?.symbol ?? null;
+    const info = getProviderInfo(this.type, tickerSymbol);
+    let bars;
+    switch (info.provider) {
+      case "yahoo":
+        bars = await this._market.fetchBars(info.symbol, fromDate);
+        break;
+      case "fred":
+        bars = await this._market.fetchBars(info.seriesId, fromDate);
+        break;
+      case "computed": {
+        const priceHandle = new _IndicatorHandle(this._storage, this._market, {
+          type: "Price",
+          ticker: this.ticker,
+          lookback: 0,
+          delay: 0,
+          unit: null,
+          threshold: null
+        });
+        await priceHandle._ensureFresh();
+        const priceBars = await priceHandle._querySeriesFromDb();
+        const computeFn = getComputation(this.type);
+        if (!computeFn) throw new Error(`No computation found for type "${this.type}"`);
+        bars = computeFn(priceBars, this.lookback);
+        if (fromDate) {
+          bars = bars.filter((b) => b.date > fromDate);
+        }
+        break;
+      }
+      case "calendar": {
+        const allDays = await this._storage.tradingDays.getRange();
+        const dayBars = allDays.map((date) => ({ date, value: 0 }));
+        bars = computeCalendar(dayBars, this.type);
+        if (fromDate) {
+          bars = bars.filter((b) => b.date > fromDate);
+        }
+        break;
+      }
+      case "none":
+        return;
+    }
+    const leverage = this.ticker?.leverage ?? 1;
+    if (leverage !== 1 && info.provider !== "computed" && bars.length > 0) {
+      let anchor;
+      if (fromDate) {
+        const lastStored = await this._storage.indicators.getValue(this._resolvedId, fromDate);
+        anchor = lastStored ?? bars[0].value;
+      } else {
+        anchor = bars[0].value;
+      }
+      const leveraged = [{ date: bars[0].date, value: anchor }];
+      for (let i = 1; i < bars.length; i++) {
+        const dailyReturn = (bars[i].value - bars[i - 1].value) / bars[i - 1].value;
+        const prev = leveraged[i - 1].value;
+        leveraged.push({ date: bars[i].date, value: prev * (1 + leverage * dailyReturn) });
+      }
+      bars = leveraged;
+    }
+    bars = bars.filter((b) => b.date <= latestClosed);
+    if (bars.length > 0) {
+      await this._upsertSeries(bars);
+    }
+  }
+  async _upsertSeries(bars) {
+    const { id } = await this.resolve();
+    await this._storage.indicators.writeSeries(id, bars);
+  }
+  async _querySeriesFromDb(range) {
+    const { id } = await this.resolve();
+    return this._storage.indicators.getSeries(id, range);
+  }
+  // ── Public data access ─────────────────────────────────────────────
+  async series(range) {
+    if (this.type === "Threshold") {
+      return this._syntheticThresholdSeries(range);
+    }
+    await this._ensureFresh();
+    if (this._cachedSeries && !range) return this._cachedSeries;
+    const bars = await this._querySeriesFromDb(range);
+    if (!range) this._cachedSeries = bars;
+    return bars;
+  }
+  async _syntheticThresholdSeries(range) {
+    const v = this.threshold;
+    const dates = await this._storage.tradingDays.getRange(range);
+    return dates.map((date) => ({ date, value: v }));
+  }
+  async value(date) {
+    await this._ensureFresh();
+    const { id } = await this.resolve();
+    return this._storage.indicators.getValue(id, date);
+  }
+};
+
+// src/computations/signal.ts
+function computeBuffers(v2, tolerance, absolute) {
+  if (tolerance === 0) return { upper: v2, lower: v2 };
+  if (absolute) return { upper: v2 + tolerance, lower: v2 - tolerance };
+  return { upper: v2 * (1 + tolerance / 100), lower: v2 * (1 - tolerance / 100) };
+}
+function rawCompare(v1, v2, comparison) {
+  switch (comparison) {
+    case ">":
+      return v1 > v2 ? 1 : 0;
+    case "<":
+      return v1 < v2 ? 1 : 0;
+    case "=":
+      return v1 === v2 ? 1 : 0;
+  }
+}
+function evaluateSignal(series1, series2, comparison, tolerance, absolute, previousValue) {
+  const s2Map = /* @__PURE__ */ new Map();
+  for (const bar of series2) {
+    s2Map.set(bar.date, bar.value);
+  }
+  const result = [];
+  let prev = previousValue;
+  for (const bar1 of series1) {
+    const v2 = s2Map.get(bar1.date);
+    if (v2 === void 0) continue;
+    const v1 = bar1.value;
+    const { upper, lower } = computeBuffers(v2, tolerance, absolute);
+    let value;
+    if (tolerance === 0) {
+      value = rawCompare(v1, v2, comparison);
+    } else if (comparison === "=") {
+      value = v1 >= lower && v1 <= upper ? 1 : 0;
+    } else if (prev === void 0) {
+      value = rawCompare(v1, v2, comparison);
+    } else if (comparison === ">") {
+      if (prev === 1) {
+        value = v1 < lower ? 0 : 1;
+      } else {
+        value = v1 > upper ? 1 : 0;
+      }
+    } else {
+      if (prev === 1) {
+        value = v1 > upper ? 0 : 1;
+      } else {
+        value = v1 < lower ? 1 : 0;
+      }
+    }
+    result.push({ date: bar1.date, value });
+    prev = value;
+  }
+  return result;
+}
+
+// src/handles/signal.ts
+var ABSOLUTE_TOLERANCE_TYPES = /* @__PURE__ */ new Set([
+  "Return",
+  "Volatility",
+  "Drawdown",
+  "VIX",
+  "VIX3M",
+  "T3M",
+  "T6M",
+  "T1Y",
+  "T2Y",
+  "T3Y",
+  "T5Y",
+  "T7Y",
+  "T10Y",
+  "T20Y",
+  "T30Y"
+]);
+var SignalHandle = class _SignalHandle {
+  indicator1;
+  indicator2;
+  comparison;
+  tolerance;
+  _storage;
+  _market;
+  _resolvedId = null;
+  _resolving = null;
+  _cachedSeries = null;
+  _cachedAsOf = null;
+  _syncing = null;
+  constructor(storage, market, identity) {
+    this._storage = storage;
+    this._market = market;
+    this.indicator1 = identity.indicator1;
+    this.indicator2 = identity.indicator2;
+    this.comparison = identity.comparison;
+    this.tolerance = identity.tolerance;
+  }
+  get id() {
+    if (this._resolvedId == null)
+      throw new Error("SignalHandle not yet resolved. Call resolve(), or access via an async method.");
+    return this._resolvedId;
+  }
+  async resolve() {
+    if (this._resolvedId != null) return { id: this._resolvedId };
+    if (!this._resolving) this._resolving = this._doResolve();
+    return this._resolving;
+  }
+  static fromResolved(storage, market, id, identity) {
+    const handle = new _SignalHandle(storage, market, identity);
+    handle._resolvedId = id;
+    return handle;
+  }
+  async _doResolve() {
+    const [ind1, ind2] = await Promise.all([this.indicator1.resolve(), this.indicator2.resolve()]);
+    const result = await this._storage.signals.findOrCreate({
+      indicatorId1: ind1.id,
+      indicatorId2: ind2.id,
+      comparison: this.comparison,
+      tolerance: this.tolerance
+    });
+    this._resolvedId = result.id;
+    return result;
+  }
+  // ── Freshness & Sync ───────────────────────────────────────────────
+  async _getLatestClosedTradingDay() {
+    const date = await this._storage.tradingDays.getLatestClosed();
+    if (!date) throw new Error("No closed trading days found");
+    return date;
+  }
+  async _getLatestSignalSeriesDate(signalId) {
+    return this._storage.signals.getLatestSeriesDate(signalId);
+  }
+  async _getLastSignalValue(signalId) {
+    return this._storage.signals.getLastValue(signalId);
+  }
+  async _ensureFresh() {
+    const { id } = await this.resolve();
+    const latestClosed = await this._getLatestClosedTradingDay();
+    if (this._cachedAsOf === latestClosed) return;
+    await Promise.all([this.indicator1.series(), this.indicator2.series()]);
+    const latestSeries = await this._getLatestSignalSeriesDate(id);
+    if (latestSeries === latestClosed) {
+      this._cachedSeries = null;
+      this._cachedAsOf = latestClosed;
+      return;
+    }
+    if (!this._syncing) {
+      this._syncing = this._sync(latestSeries ?? void 0, latestClosed).finally(() => {
+        this._syncing = null;
+      });
+    }
+    await this._syncing;
+    this._cachedSeries = null;
+    this._cachedAsOf = latestClosed;
+  }
+  async _sync(fromDate, latestClosed) {
+    const { id } = await this.resolve();
+    const range = fromDate ? { from: fromDate } : void 0;
+    const [series1, series2] = await Promise.all([this.indicator1.series(range), this.indicator2.series(range)]);
+    const previousValue = fromDate ? await this._getLastSignalValue(id) ?? void 0 : void 0;
+    const absolute = ABSOLUTE_TOLERANCE_TYPES.has(this.indicator1.type);
+    const signalBars = evaluateSignal(series1, series2, this.comparison, this.tolerance, absolute, previousValue);
+    const bars = signalBars.filter((b) => b.date <= latestClosed);
+    if (bars.length > 0) {
+      await this._upsertSeries(bars);
+    }
+  }
+  async _upsertSeries(bars) {
+    const { id } = await this.resolve();
+    await this._storage.signals.writeSeries(id, bars);
+  }
+  async _querySeriesFromDb(range) {
+    const { id } = await this.resolve();
+    return this._storage.signals.getSeries(id, range);
+  }
+  // ── Public data access ─────────────────────────────────────────────
+  async series(range) {
+    await this._ensureFresh();
+    if (this._cachedSeries && !range) return this._cachedSeries;
+    const bars = await this._querySeriesFromDb(range);
+    if (!range) this._cachedSeries = bars;
+    return bars;
+  }
+  async value(date) {
+    await this._ensureFresh();
+    if (date) {
+      const series = await this._querySeriesFromDb({ from: date, to: date });
+      return series.length > 0 ? series[0].value : null;
+    }
+    const { id } = await this.resolve();
+    return this._storage.signals.getLastValue(id);
+  }
+};
+
+// src/handles/allocation.ts
+var AllocationHandle = class _AllocationHandle {
+  holdings;
+  _storage;
+  _resolvedId = null;
+  _resolving = null;
+  constructor(storage, holdings) {
+    const total = holdings.reduce((sum, [, weight]) => sum + weight, 0);
+    if (Math.abs(total - 1) > 1e-9) {
+      throw new Error(`Allocation weights must sum to 1, got ${total}`);
+    }
+    this._storage = storage;
+    this.holdings = holdings;
+  }
+  get id() {
+    if (this._resolvedId == null)
+      throw new Error("AllocationHandle not yet resolved. Call resolve(), or access via an async method.");
+    return this._resolvedId;
+  }
+  async resolve() {
+    if (this._resolvedId != null) return { id: this._resolvedId };
+    if (!this._resolving) this._resolving = this._doResolve();
+    return this._resolving;
+  }
+  static fromResolved(storage, id, holdings) {
+    const handle = new _AllocationHandle(storage, holdings);
+    handle._resolvedId = id;
+    return handle;
+  }
+  async _doResolve() {
+    await Promise.all(this.holdings.map(([ticker]) => ticker.resolve()));
+    const holdingsJson = {};
+    for (const [ticker, weight] of this.holdings) {
+      const key = ticker.leverage !== 1 ? `${ticker.symbol}?L=${ticker.leverage}` : ticker.symbol;
+      holdingsJson[key] = weight;
+    }
+    const result = await this._storage.allocations.findOrCreate(holdingsJson);
+    this._resolvedId = result.id;
+    return result;
+  }
+};
+
+// src/handles/strategy.ts
+import { customAlphabet } from "nanoid";
+
+// src/computations/strategy.ts
+function getPeriodKey(dateStr, freq) {
+  const d = /* @__PURE__ */ new Date(dateStr + "T00:00:00Z");
+  const y = d.getUTCFullYear();
+  const m = d.getUTCMonth();
+  switch (freq) {
+    case "Weekly": {
+      const thu = new Date(d);
+      thu.setUTCDate(thu.getUTCDate() + 3 - (thu.getUTCDay() + 6) % 7);
+      const yearStart = new Date(Date.UTC(thu.getUTCFullYear(), 0, 1));
+      const weekNo = Math.ceil(((thu.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+      return `${thu.getUTCFullYear()}-W${weekNo}`;
+    }
+    case "Monthly":
+      return `${y}-${m}`;
+    case "Bi-monthly":
+      return `${y}-${Math.floor(m / 2)}`;
+    case "Quarterly":
+      return `${y}-Q${Math.floor(m / 3)}`;
+    case "Every 4 Months":
+      return `${y}-${Math.floor(m / 4)}`;
+    case "Semiannually":
+      return `${y}-H${Math.floor(m / 6)}`;
+    case "Yearly":
+      return `${y}`;
+    default:
+      return `${y}-${m}`;
+  }
+}
+function computeRebalanceDates(tradingDays, freq, offset) {
+  if (freq === "Daily") return new Set(tradingDays);
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tradingDays.length; i++) {
+    const key = getPeriodKey(tradingDays[i], freq);
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(i);
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const indices of groups.values()) {
+    const lastIdx = indices[indices.length - 1];
+    const targetIdx = lastIdx - offset;
+    if (targetIdx >= 0 && targetIdx < tradingDays.length) {
+      result.add(tradingDays[targetIdx]);
+    }
+  }
+  return result;
+}
+function evaluateStrategy(signalSeries, rules, rebalanceDates, tradingDays) {
+  const result = /* @__PURE__ */ new Map();
+  let current;
+  for (const date of tradingDays) {
+    if (rebalanceDates.has(date)) {
+      for (const rule of rules) {
+        if (rule.signalIds.length === 0) {
+          current = rule.allocationIndex;
+          break;
+        }
+        const allTrue = rule.signalIds.every((id) => signalSeries.get(id)?.get(date) ?? false);
+        if (allTrue) {
+          current = rule.allocationIndex;
+          break;
+        }
+      }
+    }
+    if (current !== void 0) {
+      result.set(date, current);
+    }
+  }
+  return result;
+}
+
+// src/handles/portfolio.ts
+var PortfolioHandle = class {
+  holdings;
+  constructor(holdings) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [ticker, quantity] of holdings) {
+      const key = `${ticker.symbol}:${ticker.leverage}`;
+      if (seen.has(key)) {
+        throw new Error(`Duplicate ticker: ${ticker.symbol}`);
+      }
+      seen.add(key);
+      if (quantity < 0) {
+        throw new Error(`Quantity for ${ticker.symbol} is negative: ${quantity}`);
+      }
+    }
+    this.holdings = holdings;
+  }
+  _priceMap(prices) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [ticker, price] of prices) {
+      map.set(`${ticker.symbol}:${ticker.leverage}`, price);
+    }
+    return map;
+  }
+  _priceFor(ticker, priceMap) {
+    if (ticker.symbol === "CASHX") return 1;
+    const key = `${ticker.symbol}:${ticker.leverage}`;
+    const price = priceMap.get(key);
+    if (price == null) {
+      throw new Error(`Missing price for ${ticker.symbol}`);
+    }
+    return price;
+  }
+  value(prices) {
+    const priceMap = this._priceMap(prices);
+    let total = 0;
+    for (const [ticker, quantity] of this.holdings) {
+      total += quantity * this._priceFor(ticker, priceMap);
+    }
+    return total;
+  }
+  weights(prices) {
+    const total = this.value(prices);
+    if (total === 0) return [];
+    const priceMap = this._priceMap(prices);
+    const result = [];
+    for (const [ticker, quantity] of this.holdings) {
+      const dollarValue = quantity * this._priceFor(ticker, priceMap);
+      if (dollarValue === 0) continue;
+      result.push([ticker, dollarValue / total]);
+    }
+    return result;
+  }
+  trades(target, prices, date) {
+    const priceMap = this._priceMap(prices);
+    const totalValue = this.value(prices);
+    const currentDollars = /* @__PURE__ */ new Map();
+    for (const [ticker, quantity] of this.holdings) {
+      if (ticker.symbol === "CASHX") continue;
+      const price = this._priceFor(ticker, priceMap);
+      currentDollars.set(ticker.symbol, quantity * price);
+    }
+    const targetDollars = /* @__PURE__ */ new Map();
+    for (const [ticker, weight] of target.holdings) {
+      if (ticker.symbol === "CASHX") continue;
+      targetDollars.set(ticker.symbol, totalValue * weight);
+    }
+    const tickerBySymbol = /* @__PURE__ */ new Map();
+    for (const [ticker] of this.holdings) {
+      if (ticker.symbol !== "CASHX") tickerBySymbol.set(ticker.symbol, ticker);
+    }
+    for (const [ticker] of target.holdings) {
+      if (ticker.symbol === "CASHX") continue;
+      const existing = tickerBySymbol.get(ticker.symbol);
+      if (existing && existing.leverage !== ticker.leverage) {
+        throw new Error(`Conflicting leverage for ${ticker.symbol}`);
+      }
+      tickerBySymbol.set(ticker.symbol, ticker);
+    }
+    const allSymbols = /* @__PURE__ */ new Set([...currentDollars.keys(), ...targetDollars.keys()]);
+    const sells = [];
+    const buys = [];
+    for (const symbol of allSymbols) {
+      const current = currentDollars.get(symbol) ?? 0;
+      const target$ = targetDollars.get(symbol) ?? 0;
+      const delta = target$ - current;
+      const ticker = tickerBySymbol.get(symbol);
+      const price = this._priceFor(ticker, priceMap);
+      const quantity = Math.abs(delta) / price;
+      if (quantity < 1e-10) continue;
+      const trade = { date, symbol, quantity, price, action: delta > 0 ? "buy" : "sell" };
+      if (trade.action === "sell") {
+        sells.push(trade);
+      } else {
+        buys.push(trade);
+      }
+    }
+    return [...sells, ...buys];
+  }
+};
+
+// src/backtest/simulate.ts
+var EPSILON = 1e-8;
+function tkey(symbol, leverage) {
+  return `${symbol}:${leverage}`;
+}
+function runSimulation(bars, prices, rebalanceDates, portfolio) {
+  const positions = {};
+  const lastPrice = {};
+  let cash = 0;
+  for (const [ticker, quantity] of portfolio.holdings) {
+    if (ticker.symbol === "CASHX") {
+      cash = quantity;
+    } else {
+      positions[tkey(ticker.symbol, ticker.leverage)] = quantity;
+    }
+  }
+  const series = [];
+  const trades = [];
+  function valuationPrice(key, date) {
+    const live = prices[key]?.[date];
+    if (live != null) {
+      lastPrice[key] = live;
+      return live;
+    }
+    return lastPrice[key];
+  }
+  for (const bar of bars) {
+    const date = bar.date;
+    if (rebalanceDates.has(date)) {
+      let portfolioValue = cash;
+      for (const [key, shares] of Object.entries(positions)) {
+        const price = valuationPrice(key, date);
+        if (price != null) portfolioValue += shares * price;
+      }
+      const targetWeights = {};
+      for (const [ticker, weight] of bar.allocation.holdings) {
+        targetWeights[tkey(ticker.symbol, ticker.leverage)] = weight;
+      }
+      const allKeys = /* @__PURE__ */ new Set([...Object.keys(positions), ...Object.keys(targetWeights)]);
+      for (const key of allKeys) {
+        const price = prices[key]?.[date];
+        if (price == null || price <= 0) continue;
+        const currentShares = positions[key] ?? 0;
+        const targetValue = portfolioValue * (targetWeights[key] ?? 0);
+        const targetShares = targetValue / price;
+        const delta = targetShares - currentShares;
+        if (Math.abs(delta) <= EPSILON) continue;
+        if (Math.abs(targetShares) <= EPSILON) {
+          delete positions[key];
+        } else {
+          positions[key] = targetShares;
+        }
+        cash -= delta * price;
+        trades.push({
+          date,
+          symbol: key.split(":")[0],
+          quantity: Math.abs(delta),
+          price,
+          action: delta > 0 ? "buy" : "sell"
+        });
+      }
+      if (Math.abs(cash) <= EPSILON) cash = 0;
+    }
+    let value = cash;
+    for (const [key, shares] of Object.entries(positions)) {
+      const price = valuationPrice(key, date);
+      if (price != null) value += shares * price;
+    }
+    series.push({ date, value });
+  }
+  const finalHoldings = [];
+  const tickerByKey = /* @__PURE__ */ new Map();
+  for (const bar of bars) {
+    for (const [ticker] of bar.allocation.holdings) {
+      const key = tkey(ticker.symbol, ticker.leverage);
+      if (!tickerByKey.has(key)) {
+        tickerByKey.set(key, ticker);
+      }
+    }
+  }
+  for (const [ticker] of portfolio.holdings) {
+    const key = tkey(ticker.symbol, ticker.leverage);
+    if (!tickerByKey.has(key)) {
+      tickerByKey.set(key, ticker);
+    }
+  }
+  for (const [key, shares] of Object.entries(positions)) {
+    const ticker = tickerByKey.get(key);
+    if (ticker && Math.abs(shares) > EPSILON) {
+      finalHoldings.push([ticker, shares]);
+    }
+  }
+  const cashKey = tkey("CASHX", 1);
+  const cashTicker = tickerByKey.get(cashKey) ?? portfolio.holdings.find(([t]) => t.symbol === "CASHX")?.[0];
+  if (cashTicker && Math.abs(cash) > EPSILON) {
+    finalHoldings.push([cashTicker, cash]);
+  }
+  const finalPortfolio = new PortfolioHandle(finalHoldings);
+  return { series, trades, finalPortfolio };
+}
+
+// src/backtest/types.ts
+var SimulationHandle = class {
+  series;
+  trades;
+  startingPortfolio;
+  _portfolio;
+  _currentAllocation;
+  _lastClosePrices;
+  _lastLeveragedPrices;
+  _currentLeveragedPrices;
+  _lastDate;
+  constructor(series, trades, startingPortfolio, finalState) {
+    this.series = series;
+    this.trades = trades;
+    this.startingPortfolio = startingPortfolio;
+    if (finalState) {
+      this._portfolio = finalState.portfolio;
+      this._currentAllocation = finalState.allocation;
+      this._lastClosePrices = finalState.closePrices;
+      this._lastLeveragedPrices = new Map(Object.entries(finalState.leveragedPrices));
+      this._currentLeveragedPrices = new Map(Object.entries(finalState.leveragedPrices));
+      this._lastDate = series.at(-1)?.date ?? "";
+    } else {
+      this._portfolio = null;
+      this._currentAllocation = null;
+      this._lastClosePrices = {};
+      this._lastLeveragedPrices = /* @__PURE__ */ new Map();
+      this._currentLeveragedPrices = /* @__PURE__ */ new Map();
+      this._lastDate = "";
+    }
+  }
+  push(...prices) {
+    if (!this._portfolio || !this._currentAllocation) {
+      return { value: 0, holdings: [], weights: [], pendingTrades: [] };
+    }
+    for (const [ticker, realPrice] of prices) {
+      if (ticker.symbol === "CASHX") continue;
+      const lastClose = this._lastClosePrices[ticker.symbol];
+      if (lastClose == null) continue;
+      const realReturn = (realPrice - lastClose) / lastClose;
+      for (const [held] of this._portfolio.holdings) {
+        if (held.symbol !== ticker.symbol) continue;
+        if (held.symbol === "CASHX") continue;
+        const key = `${held.symbol}:${held.leverage}`;
+        const baseLeveragedPrice = this._lastLeveragedPrices.get(key);
+        if (baseLeveragedPrice == null) continue;
+        const leveragedReturn = held.leverage * realReturn;
+        this._currentLeveragedPrices.set(key, baseLeveragedPrice * (1 + leveragedReturn));
+      }
+    }
+    const priceArray = [];
+    for (const [held] of this._portfolio.holdings) {
+      if (held.symbol === "CASHX") continue;
+      const key = `${held.symbol}:${held.leverage}`;
+      const price = this._currentLeveragedPrices.get(key);
+      if (price != null) priceArray.push([held, price]);
+    }
     return {
-        supabase,
-        auth: (0, auth_1.createAuth)(supabase),
-        market: (0, market_1.createMarket)(supabase),
-        strategy: (0, strategy_1.createStrategy)(supabase),
-        portfolio: (0, portfolio_1.createPortfolio)(supabase),
+      value: this._portfolio.value(priceArray),
+      holdings: this._portfolio.holdings,
+      weights: this._portfolio.weights(priceArray),
+      pendingTrades: this._portfolio.trades(this._currentAllocation, priceArray, this._lastDate)
     };
+  }
+};
+
+// src/handles/strategy.ts
+var nanoid = customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 21);
+var StrategyHandle = class {
+  _linkId;
+  _name;
+  _freq;
+  _offset;
+  _rules;
+  _storage;
+  _market;
+  _resolvedId = null;
+  _resolvedLinkId = null;
+  _resolving = null;
+  _allocationMap = /* @__PURE__ */ new Map();
+  _cache = null;
+  _cachedAsOf = null;
+  _syncing = null;
+  constructor(storage, market, optionsOrLinkId) {
+    this._storage = storage;
+    this._market = market;
+    if (typeof optionsOrLinkId === "string") {
+      this._linkId = optionsOrLinkId;
+      this._name = null;
+      this._freq = "Daily";
+      this._offset = 0;
+      this._rules = [];
+    } else {
+      const opts = optionsOrLinkId;
+      if (opts.rules.length === 0) {
+        throw new Error("Strategy must have at least one rule");
+      }
+      const lastRule = opts.rules[opts.rules.length - 1];
+      if (lastRule.when && lastRule.when.length > 0) {
+        throw new Error("Last rule must be a fallback (no when clause)");
+      }
+      for (let i = 0; i < opts.rules.length - 1; i++) {
+        const rule = opts.rules[i];
+        if (rule.when !== void 0 && rule.when.length === 0) {
+          throw new Error(
+            `Rule ${i} has an empty when clause and will match unconditionally, making subsequent rules unreachable`
+          );
+        }
+      }
+      this._linkId = null;
+      this._name = opts.name;
+      this._freq = opts.freq ?? "Daily";
+      this._offset = opts.offset ?? 0;
+      this._rules = opts.rules;
+    }
+  }
+  get id() {
+    if (this._resolvedId == null) throw new Error("StrategyHandle not yet resolved. Call resolve() first.");
+    return this._resolvedId;
+  }
+  get link() {
+    if (this._resolvedLinkId == null) throw new Error("StrategyHandle not yet resolved. Call resolve() first.");
+    return this._resolvedLinkId;
+  }
+  get name() {
+    return this._name;
+  }
+  get freq() {
+    return this._freq;
+  }
+  get offset() {
+    return this._offset;
+  }
+  get rules() {
+    return this._rules;
+  }
+  async resolve() {
+    if (this._resolvedId != null) return { id: this._resolvedId };
+    if (!this._resolving) {
+      this._resolving = this._linkId !== null && this._name === null ? this._doResolveReference() : this._doResolveCreate();
+    }
+    return this._resolving;
+  }
+  async _doResolveCreate() {
+    const allSignals = /* @__PURE__ */ new Set();
+    const allAllocations = /* @__PURE__ */ new Set();
+    for (const rule of this._rules) {
+      if (rule.when) rule.when.forEach((s) => allSignals.add(s));
+      allAllocations.add(rule.hold);
+    }
+    await Promise.all([
+      ...Array.from(allSignals).map((s) => s.resolve()),
+      ...Array.from(allAllocations).map((a) => a.resolve())
+    ]);
+    const linkId = nanoid();
+    const result = await this._storage.strategies.create({
+      linkId,
+      name: this._name,
+      freq: this._freq,
+      offset: this._offset,
+      rules: this._rules.map((rule) => ({
+        signalIds: (rule.when ?? []).map((s) => s.id),
+        allocationId: rule.hold.id
+      }))
+    });
+    this._resolvedId = result.id;
+    this._resolvedLinkId = linkId;
+    for (const rule of this._rules) {
+      this._allocationMap.set(rule.hold.id, rule.hold);
+    }
+    return result;
+  }
+  async _doResolveReference() {
+    const ref = await this._storage.strategies.resolveReference(this._linkId);
+    this._resolvedId = ref.id;
+    this._resolvedLinkId = this._linkId;
+    this._name = ref.name;
+    this._freq = ref.freq;
+    this._offset = ref.offset;
+    const tickerMap = /* @__PURE__ */ new Map();
+    for (const t of ref.rules.tickers) {
+      tickerMap.set(t.id, TickerHandle.fromResolved(this._storage, t.id, t.symbol, t.leverage));
+    }
+    const indicatorMap = /* @__PURE__ */ new Map();
+    for (const ind of ref.rules.indicators) {
+      const ticker = ind.tickerId ? tickerMap.get(ind.tickerId) ?? null : null;
+      indicatorMap.set(
+        ind.id,
+        IndicatorHandle.fromResolved(this._storage, this._market, ind.id, {
+          type: ind.type,
+          ticker,
+          lookback: ind.lookback,
+          delay: ind.delay,
+          unit: ind.unit,
+          threshold: ind.threshold
+        })
+      );
+    }
+    const signalMap = /* @__PURE__ */ new Map();
+    for (const sig of ref.rules.signals) {
+      signalMap.set(
+        sig.id,
+        SignalHandle.fromResolved(this._storage, this._market, sig.id, {
+          indicator1: indicatorMap.get(sig.indicatorId1),
+          indicator2: indicatorMap.get(sig.indicatorId2),
+          comparison: sig.comparison,
+          tolerance: sig.tolerance
+        })
+      );
+    }
+    const allocationHandleMap = /* @__PURE__ */ new Map();
+    for (const alloc of ref.rules.allocations) {
+      const holdings = Object.entries(alloc.holdings).map(([key, weight]) => {
+        const match = key.match(/^(.+)\?L=(.+)$/);
+        const symbol = match ? match[1] : key;
+        const leverage = match ? Number(match[2]) : 1;
+        return [new TickerHandle(this._storage, symbol, leverage), weight];
+      });
+      const handle = AllocationHandle.fromResolved(this._storage, alloc.id, holdings);
+      allocationHandleMap.set(alloc.id, handle);
+      this._allocationMap.set(alloc.id, handle);
+    }
+    this._rules = ref.rules.definition.map((rule) => ({
+      when: rule.signalIds && rule.signalIds.length > 0 ? rule.signalIds.map((id) => signalMap.get(id)) : void 0,
+      hold: allocationHandleMap.get(rule.allocationId)
+    }));
+    return { id: ref.id };
+  }
+  async _getLatestClosedTradingDay() {
+    const date = await this._storage.tradingDays.getLatestClosed();
+    if (!date) throw new Error("No closed trading days found");
+    return date;
+  }
+  async _getLatestStrategySeriesDate() {
+    const { id } = await this.resolve();
+    return this._storage.strategies.getLatestSeriesDate(id);
+  }
+  async _ensureFresh() {
+    await this.resolve();
+    const latestClosed = await this._getLatestClosedTradingDay();
+    if (this._cachedAsOf === latestClosed) return;
+    const latestSeries = await this._getLatestStrategySeriesDate();
+    if (latestSeries === latestClosed) {
+      this._cache = null;
+      this._cachedAsOf = latestClosed;
+      return;
+    }
+    if (!this._syncing) {
+      this._syncing = this._sync(latestClosed).finally(() => {
+        this._syncing = null;
+      });
+    }
+    await this._syncing;
+    this._cache = null;
+    this._cachedAsOf = latestClosed;
+  }
+  async _sync(latestClosed) {
+    const { id } = await this.resolve();
+    const signalSeries = /* @__PURE__ */ new Map();
+    const allSignals = /* @__PURE__ */ new Set();
+    for (const rule of this._rules) {
+      if (rule.when) rule.when.forEach((s) => allSignals.add(s));
+    }
+    await Promise.all(
+      Array.from(allSignals).map(async (signal) => {
+        const bars = await signal.series();
+        const dateMap = /* @__PURE__ */ new Map();
+        for (const bar of bars) dateMap.set(bar.date, bar.value === 1);
+        signalSeries.set(signal.id, dateMap);
+      })
+    );
+    const tradingDays = await this._storage.tradingDays.getRange();
+    const rebalanceDates = computeRebalanceDates(tradingDays, this._freq, this._offset);
+    const allocations = [];
+    const allocIndexMap = /* @__PURE__ */ new Map();
+    const rulesInput = this._rules.map((rule) => {
+      let allocIdx = allocIndexMap.get(rule.hold.id);
+      if (allocIdx === void 0) {
+        allocIdx = allocations.length;
+        allocations.push(rule.hold);
+        allocIndexMap.set(rule.hold.id, allocIdx);
+      }
+      return {
+        signalIds: (rule.when ?? []).map((s) => s.id),
+        allocationIndex: allocIdx
+      };
+    });
+    const evalResult = evaluateStrategy(signalSeries, rulesInput, rebalanceDates, tradingDays);
+    const entries = Array.from(evalResult.entries()).filter(([date]) => date <= latestClosed).map(([date, allocIdx]) => ({
+      date,
+      allocationId: allocations[allocIdx].id
+    }));
+    if (entries.length > 0) {
+      await this._storage.strategies.writeSeries(id, entries);
+    }
+  }
+  async _querySeriesFromDb(range) {
+    const { id } = await this.resolve();
+    const entries = await this._storage.strategies.getSeries(id, range);
+    return entries.map((e) => ({
+      date: e.date,
+      allocation: this._allocationMap.get(e.allocationId)
+    }));
+  }
+  async series(range) {
+    await this._ensureFresh();
+    if (this._cache && !range) return this._cache;
+    const bars = await this._querySeriesFromDb(range);
+    if (!range) this._cache = bars;
+    return bars;
+  }
+  async value(date) {
+    await this._ensureFresh();
+    const bars = date ? await this._querySeriesFromDb({ from: date, to: date }) : await this._querySeriesFromDb();
+    if (bars.length === 0) return null;
+    return date ? bars[0].allocation : bars[bars.length - 1].allocation;
+  }
+  async simulate(options) {
+    const bars = await this.series({ from: options.from, to: options.to });
+    if (bars.length === 0) {
+      return new SimulationHandle([], [], options.portfolio);
+    }
+    const prices = await this._fetchPricesForTickers(bars, options.from, options.to);
+    const tradingDays = bars.map((b) => b.date);
+    const rebalanceDates = computeRebalanceDates(tradingDays, this._freq, this._offset);
+    rebalanceDates.add(bars[0].date);
+    const result = runSimulation(bars, prices, rebalanceDates, options.portfolio);
+    const lastBar = bars[bars.length - 1];
+    const lastDate = lastBar.date;
+    const lastAllocation = lastBar.allocation;
+    const leveragedPrices = {};
+    for (const [ticker, _weight] of lastAllocation.holdings) {
+      if (ticker.symbol === "CASHX") continue;
+      const key = `${ticker.symbol}:${ticker.leverage}`;
+      const price = prices[key]?.[lastDate];
+      if (price != null) leveragedPrices[key] = price;
+    }
+    const closePrices = {};
+    await this._fetchRawClosePrices(bars, lastDate, closePrices);
+    const finalState = {
+      portfolio: result.finalPortfolio,
+      allocation: lastAllocation,
+      closePrices,
+      leveragedPrices
+    };
+    return new SimulationHandle(result.series, result.trades, options.portfolio, finalState);
+  }
+  async _fetchPricesForTickers(bars, from, to) {
+    const tickerMap = /* @__PURE__ */ new Map();
+    for (const bar of bars) {
+      for (const [ticker] of bar.allocation.holdings) {
+        const key = `${ticker.symbol}:${ticker.leverage}`;
+        if (!tickerMap.has(key)) {
+          tickerMap.set(key, ticker);
+        }
+      }
+    }
+    const entries = await Promise.all(
+      Array.from(tickerMap.entries()).map(async ([key, ticker]) => {
+        const priceIndicator = new IndicatorHandle(this._storage, this._market, {
+          type: "Price",
+          ticker,
+          lookback: 0,
+          delay: 0,
+          unit: null,
+          threshold: null
+        });
+        const priceBars = await priceIndicator.series({ from, to });
+        const dateMap = {};
+        for (const bar of priceBars) {
+          dateMap[bar.date] = bar.value;
+        }
+        return [key, dateMap];
+      })
+    );
+    return Object.fromEntries(entries);
+  }
+  async _fetchRawClosePrices(bars, lastDate, closePrices) {
+    const symbols = /* @__PURE__ */ new Set();
+    for (const bar of bars) {
+      for (const [ticker] of bar.allocation.holdings) {
+        if (ticker.symbol !== "CASHX") symbols.add(ticker.symbol);
+      }
+    }
+    await Promise.all(
+      Array.from(symbols).map(async (symbol) => {
+        const rawTicker = new TickerHandle(this._storage, symbol, 1);
+        const priceIndicator = new IndicatorHandle(this._storage, this._market, {
+          type: "Price",
+          ticker: rawTicker,
+          lookback: 0,
+          delay: 0,
+          unit: null,
+          threshold: null
+        });
+        const priceBars = await priceIndicator.series({ from: lastDate, to: lastDate });
+        if (priceBars.length > 0) {
+          closePrices[symbol] = priceBars[0].value;
+        }
+      })
+    );
+  }
+};
+
+// src/client.ts
+function tickerBound(storage, market, type, ticker, lookback, opts) {
+  return new IndicatorHandle(storage, market, {
+    type,
+    ticker,
+    lookback,
+    delay: opts?.delay ?? 0,
+    unit: null,
+    threshold: null
+  });
+}
+function standalone(storage, market, type, opts) {
+  return new IndicatorHandle(storage, market, {
+    type,
+    ticker: null,
+    lookback: 0,
+    delay: opts?.delay ?? 0,
+    unit: null,
+    threshold: null
+  });
+}
+function createClient(options) {
+  const { storage, market } = options;
+  return {
+    ticker: (symbol, leverage) => new TickerHandle(storage, symbol, leverage),
+    sma: (ticker, lookback, opts) => tickerBound(storage, market, "SMA", ticker, lookback, opts),
+    ema: (ticker, lookback, opts) => tickerBound(storage, market, "EMA", ticker, lookback, opts),
+    price: (ticker, opts) => tickerBound(storage, market, "Price", ticker, 0, opts),
+    returns: (ticker, lookback, opts) => tickerBound(storage, market, "Return", ticker, lookback, opts),
+    volatility: (ticker, lookback, opts) => tickerBound(storage, market, "Volatility", ticker, lookback, opts),
+    drawdown: (ticker, lookback, opts) => tickerBound(storage, market, "Drawdown", ticker, lookback, opts),
+    rsi: (ticker, lookback, opts) => tickerBound(storage, market, "RSI", ticker, lookback, opts),
+    vix: (opts) => standalone(storage, market, "VIX", opts),
+    vix3m: (opts) => standalone(storage, market, "VIX3M", opts),
+    treasury: (tenor, opts) => standalone(storage, market, tenor, opts),
+    calendar: (period, opts) => standalone(storage, market, period, opts),
+    threshold: (value, unit) => new IndicatorHandle(storage, market, {
+      type: "Threshold",
+      ticker: null,
+      lookback: 0,
+      delay: 0,
+      unit: unit ?? null,
+      threshold: value
+    }),
+    gt: (ind1, ind2, tolerance) => new SignalHandle(storage, market, {
+      indicator1: ind1,
+      indicator2: ind2,
+      comparison: ">",
+      tolerance: tolerance ?? 0
+    }),
+    lt: (ind1, ind2, tolerance) => new SignalHandle(storage, market, {
+      indicator1: ind1,
+      indicator2: ind2,
+      comparison: "<",
+      tolerance: tolerance ?? 0
+    }),
+    eq: (ind1, ind2, tolerance) => new SignalHandle(storage, market, {
+      indicator1: ind1,
+      indicator2: ind2,
+      comparison: "=",
+      tolerance: tolerance ?? 0
+    }),
+    allocation: (...holdings) => new AllocationHandle(storage, holdings),
+    portfolio: (...holdings) => new PortfolioHandle(holdings),
+    strategy: (optionsOrLinkId) => new StrategyHandle(storage, market, optionsOrLinkId)
+  };
 }
+export {
+  AllocationHandle,
+  IndicatorHandle,
+  PortfolioHandle,
+  SignalHandle,
+  SimulationHandle,
+  StrategyHandle,
+  TickerHandle,
+  createClient
+};
 //# sourceMappingURL=index.js.map