@livefolio/sdk 0.3.3 → 0.3.4

package/dist/index.js

@@ -96,6 +96,15 @@ function computeSma(bars, lookback) {
   }
   return result;
 }
+function smaInitialState(bars, lookback) {
+  if (bars.length < lookback) return null;
+  return { tail: bars.slice(-lookback).map((b) => b.value) };
+}
+function smaNext(prev, newRaw, lookback) {
+  const tail = [...prev.tail.slice(1), newRaw];
+  const sum = tail.reduce((a, b) => a + b, 0);
+  return { value: sum / lookback, state: { tail } };
+}
 
 // src/computations/ema.ts
 function computeEma(bars, lookback) {
@@ -112,6 +121,17 @@ function computeEma(bars, lookback) {
   }
   return result;
 }
+function emaInitialState(bars, lookback) {
+  if (bars.length < lookback) return null;
+  const series = computeEma(bars, lookback);
+  if (series.length === 0) return null;
+  return { ema: series[series.length - 1].value };
+}
+function emaNext(prev, newRaw, lookback) {
+  const multiplier = 2 / (lookback + 1);
+  const ema = newRaw * multiplier + prev.ema * (1 - multiplier);
+  return { value: ema, state: { ema } };
+}
 
 // src/computations/rsi.ts
 function computeRsi(bars, lookback) {
@@ -147,6 +167,34 @@ function computeRsi(bars, lookback) {
   }
   return result;
 }
+function rsiInitialState(bars, lookback) {
+  if (bars.length < lookback + 1) return null;
+  let avgGain = 0;
+  let avgLoss = 0;
+  for (let i = 1; i <= lookback; i++) {
+    const change = bars[i].value - bars[i - 1].value;
+    if (change > 0) avgGain += change;
+    else avgLoss += -change;
+  }
+  avgGain /= lookback;
+  avgLoss /= lookback;
+  let state = { avgGain, avgLoss, prev: bars[lookback].value };
+  for (let i = lookback + 1; i < bars.length; i++) {
+    const { state: next } = rsiNext(state, bars[i].value, lookback);
+    state = next;
+  }
+  return state;
+}
+function rsiNext(prev, newRaw, lookback) {
+  const change = newRaw - prev.prev;
+  const gain = change > 0 ? change : 0;
+  const loss = change < 0 ? -change : 0;
+  const avgGain = (prev.avgGain * (lookback - 1) + gain) / lookback;
+  const avgLoss = (prev.avgLoss * (lookback - 1) + loss) / lookback;
+  const rs = avgLoss === 0 ? 100 : avgGain / avgLoss;
+  const value = avgLoss === 0 ? 100 : 100 - 100 / (1 + rs);
+  return { value, state: { avgGain, avgLoss, prev: newRaw } };
+}
 
 // src/computations/returns.ts
 function computeReturns(bars, lookback, mode = "pct") {
@@ -160,6 +208,16 @@ function computeReturns(bars, lookback, mode = "pct") {
   }
   return result;
 }
+function returnInitialState(bars, lookback) {
+  if (bars.length < lookback + 1) return null;
+  return { tail: bars.slice(-(lookback + 1)).map((b) => b.value) };
+}
+function returnNext(prev, newRaw, lookback, mode = "pct") {
+  const tail = [...prev.tail.slice(1), newRaw];
+  const old = tail[0];
+  const value = mode === "abs" ? newRaw - old : (newRaw - old) / old;
+  return { value, state: { tail } };
+}
 
 // src/computations/volatility.ts
 function computeVolatility(bars, lookback) {
@@ -181,6 +239,18 @@ function computeVolatility(bars, lookback) {
   }
   return result;
 }
+function volatilityInitialState(bars, lookback) {
+  if (bars.length < lookback + 1) return null;
+  return { tail: bars.slice(-(lookback + 1)).map((b) => b.value) };
+}
+function volatilityNext(prev, newRaw, lookback) {
+  const tail = [...prev.tail.slice(1), newRaw];
+  const returns = [];
+  for (let i = 1; i < tail.length; i++) returns.push(tail[i] / tail[i - 1] - 1);
+  const mean = returns.reduce((s, r) => s + r, 0) / lookback;
+  const variance = returns.reduce((s, r) => s + (r - mean) ** 2, 0) / lookback;
+  return { value: Math.sqrt(variance), state: { tail } };
+}
 
 // src/computations/drawdown.ts
 function computeDrawdown(bars, lookback) {
@@ -195,6 +265,16 @@ function computeDrawdown(bars, lookback) {
   }
   return result;
 }
+function drawdownInitialState(bars, lookback) {
+  if (bars.length < lookback) return null;
+  return { tail: bars.slice(-lookback).map((b) => b.value) };
+}
+function drawdownNext(prev, newRaw, _lookback) {
+  const tail = [...prev.tail.slice(1), newRaw];
+  let max = -Infinity;
+  for (const v of tail) if (v > max) max = v;
+  return { value: (newRaw - max) / max, state: { tail } };
+}
 
 // src/computations/calendar.ts
 function dayOfYear(d) {
@@ -237,6 +317,28 @@ var COMPUTATIONS = {
 function getComputation(type) {
   return COMPUTATIONS[type] ?? null;
 }
+var NEXT = {
+  SMA: smaNext,
+  EMA: emaNext,
+  RSI: rsiNext,
+  Return: ((prev, newRaw, lookback) => returnNext(prev, newRaw, lookback, "pct")),
+  Volatility: volatilityNext,
+  Drawdown: drawdownNext
+};
+var SEED = {
+  SMA: smaInitialState,
+  EMA: emaInitialState,
+  RSI: rsiInitialState,
+  Return: returnInitialState,
+  Volatility: volatilityInitialState,
+  Drawdown: drawdownInitialState
+};
+function getNextComputation(type) {
+  return NEXT[type];
+}
+function getInitialStateFn(type) {
+  return SEED[type];
+}
 
 // src/handles/indicator.ts
 var FRED_SYMBOL_TO_TYPE = {
@@ -349,6 +451,34 @@ var IndicatorHandle = class _IndicatorHandle {
   async _sync(fromDate, latestClosed) {
     const tickerSymbol = this.ticker?.symbol ?? null;
     const info = getProviderInfo(this.type, tickerSymbol);
+    if (info.provider === "none") return;
+    let horizon = latestClosed;
+    if (this.delay > 0) {
+      const tradingDays = await this._storage.tradingDays.getRange();
+      const idx = tradingDays.indexOf(latestClosed);
+      if (idx < this.delay) return;
+      horizon = tradingDays[idx - this.delay];
+    }
+    const nextFn = getNextComputation(this.type);
+    const seedFn = getInitialStateFn(this.type);
+    const { id } = await this.resolve();
+    const checkpoint = nextFn ? await this._storage.indicators.getLatestBar(id) : null;
+    if (fromDate && nextFn && seedFn && checkpoint && checkpoint.metadata != null && checkpoint.date < horizon) {
+      const rawBars = await this._fetchRawBarsForIncremental(info, checkpoint.date, horizon);
+      if (rawBars.length === 0) return;
+      const newBars = [];
+      let state = checkpoint.metadata;
+      for (const raw of rawBars) {
+        if (raw.date <= checkpoint.date) continue;
+        if (raw.date > horizon) break;
+        const step = this.type === "Return" && info.provider === "computed" && info.rateSeries ? returnNext(state, raw.value, this.lookback, "abs") : nextFn(state, raw.value, this.lookback);
+        newBars.push({ date: raw.date, value: step.value });
+        state = step.state;
+      }
+      if (newBars.length === 0) return;
+      await this._storage.indicators.writeSeries(id, newBars, { metadata: state });
+      return;
+    }
     let bars;
     switch (info.provider) {
       case "yahoo":
@@ -375,43 +505,73 @@ var IndicatorHandle = class _IndicatorHandle {
           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);
-        }
+        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);
-        }
+        if (fromDate) bars = bars.filter((b) => b.date > fromDate);
         break;
       }
-      case "none":
-        return;
     }
     if (info.provider !== "computed") {
       bars = await this._applyLeverage(bars, fromDate);
     }
-    let horizon = latestClosed;
-    if (this.delay > 0) {
-      const tradingDays = await this._storage.tradingDays.getRange();
-      const idx = tradingDays.indexOf(latestClosed);
-      if (idx < this.delay) {
-        return;
+    bars = bars.filter((b) => b.date <= horizon);
+    if (bars.length === 0) return;
+    let metadata = void 0;
+    if (seedFn) {
+      if (info.provider === "computed") {
+        const priceHandle = new _IndicatorHandle(this._storage, this._market, {
+          type: "Price",
+          ticker: this.ticker,
+          lookback: 0,
+          delay: 0,
+          unit: null,
+          threshold: null
+        });
+        const priceBars = (await priceHandle._querySeriesFromDb()).filter((b) => b.date <= horizon);
+        metadata = seedFn(priceBars, this.lookback) ?? void 0;
+      } else {
+        metadata = seedFn(bars, this.lookback) ?? void 0;
       }
-      horizon = tradingDays[idx - this.delay];
     }
-    bars = bars.filter((b) => b.date <= horizon);
-    if (bars.length > 0) {
-      await this._upsertSeries(bars);
+    await this._upsertSeries(bars, metadata);
+  }
+  async _fetchRawBarsForIncremental(info, sinceDate, horizon) {
+    if (info.provider === "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();
+      return (await priceHandle._querySeriesFromDb({ from: sinceDate })).filter(
+        (b) => b.date > sinceDate && b.date <= horizon
+      );
+    }
+    if (info.provider === "yahoo" || info.provider === "fred") {
+      const symbol = info.provider === "yahoo" ? info.symbol : info.seriesId;
+      const bars = await this._market.fetchBars(symbol, sinceDate);
+      return bars.filter((b) => b.date > sinceDate && b.date <= horizon);
     }
+    if (info.provider === "calendar") {
+      const allDays = await this._storage.tradingDays.getRange();
+      const dayBars = allDays.map((date) => ({ date, value: 0 }));
+      return computeCalendar(dayBars, this.type).filter(
+        (b) => b.date > sinceDate && b.date <= horizon
+      );
+    }
+    return [];
   }
-  async _upsertSeries(bars) {
+  async _upsertSeries(bars, metadata) {
     const { id } = await this.resolve();
-    await this._storage.indicators.writeSeries(id, bars);
+    await this._storage.indicators.writeSeries(id, bars, metadata !== void 0 ? { metadata } : void 0);
   }
   async _querySeriesFromDb(range) {
     const { id } = await this.resolve();
@@ -476,6 +636,22 @@ var IndicatorHandle = class _IndicatorHandle {
       return computed.find((b) => b.date === date)?.value ?? null;
     }
     if (info.provider === "computed") {
+      const nextFn = getNextComputation(this.type);
+      if (nextFn) {
+        const { id } = await this.resolve();
+        const checkpoint = await this._storage.indicators.getLatestBar(id);
+        if (checkpoint && checkpoint.metadata != null) {
+          const tradingDays = await this._storage.tradingDays.getRange();
+          const ckIdx = tradingDays.indexOf(checkpoint.date);
+          const tgtIdx = tradingDays.indexOf(date);
+          if (ckIdx >= 0 && tgtIdx === ckIdx + 1) {
+            const rawBar = await this._resolveRawBarAt(info.symbol, date, overrides);
+            if (rawBar === null) return null;
+            const step = this.type === "Return" && info.rateSeries ? returnNext(checkpoint.metadata, rawBar, this.lookback, "abs") : nextFn(checkpoint.metadata, rawBar, this.lookback);
+            return step.value;
+          }
+        }
+      }
       let calendarDays;
       if (this.type === "RSI") {
         calendarDays = Math.max(this.lookback * 10, 90);
@@ -554,6 +730,18 @@ var IndicatorHandle = class _IndicatorHandle {
     }
     return bars;
   }
+  /**
+   * Resolve the single raw (unleveraged) value for `symbol` at `date`.
+   * Returns the override directly when present; otherwise delegates to
+   * `_resolveRawBars` with a one-day window and picks the matching bar.
+   */
+  async _resolveRawBarAt(symbol, date, overrides) {
+    const override = overrides?.[symbol];
+    if (override !== void 0) return override;
+    const bars = await this._resolveRawBars(symbol, date, date, overrides);
+    const hit = bars.find((b) => b.date === date);
+    return hit?.value ?? null;
+  }
   /**
    * Resolve raw (unleveraged) bars for a market symbol from storage. Maps:
    *   - `^VIX`   → the VIX indicator's stored series
@@ -786,13 +974,16 @@ var SignalHandle = class _SignalHandle {
     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;
     }
+    const isFastPath = await this._isSingleBarFastPath(latestSeries ?? void 0, latestClosed);
+    if (!isFastPath) {
+      await Promise.all([this.indicator1.series(), this.indicator2.series()]);
+    }
     if (!this._syncing) {
       this._syncing = this._sync(latestSeries ?? void 0, latestClosed).catch((err) => {
         console.warn("[sdk] signal sync failed, using stored data:", err);
@@ -804,17 +995,61 @@ var SignalHandle = class _SignalHandle {
     this._cachedSeries = null;
     this._cachedAsOf = latestClosed;
   }
+  async _isSingleBarFastPath(fromDate, latestClosed) {
+    if (!fromDate) return false;
+    const tradingDays = await this._storage.tradingDays.getRange();
+    const fromIdx = tradingDays.indexOf(fromDate);
+    const closedIdx = tradingDays.indexOf(latestClosed);
+    return fromIdx >= 0 && closedIdx === fromIdx + 1;
+  }
   async _sync(fromDate, latestClosed) {
     const { id } = await this.resolve();
+    const absolute = ABSOLUTE_TOLERANCE_TYPES.has(this.indicator1.type);
+    if (fromDate) {
+      const tradingDays = await this._storage.tradingDays.getRange();
+      const fromIdx = tradingDays.indexOf(fromDate);
+      const closedIdx = tradingDays.indexOf(latestClosed);
+      if (fromIdx >= 0 && closedIdx === fromIdx + 1) {
+        const newDate = tradingDays[closedIdx];
+        const [v1, v2] = await Promise.all([
+          this.indicator1.computeAt(newDate, void 0),
+          this.indicator2.computeAt(newDate, void 0)
+        ]);
+        if (v1 === null || v2 === null) return;
+        const prev = await this._getLastSignalValue(id) ?? void 0;
+        const value = this._evaluateOneBar(v1, v2, absolute, prev);
+        await this._upsertSeries([{ date: newDate, value }]);
+        return;
+      }
+    }
     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);
+    if (bars.length > 0) await this._upsertSeries(bars);
+  }
+  _evaluateOneBar(v1, v2, absolute, prev) {
+    if (this.tolerance === 0) {
+      switch (this.comparison) {
+        case ">":
+          return v1 > v2 ? 1 : 0;
+        case "<":
+          return v1 < v2 ? 1 : 0;
+        case "=":
+          return v1 === v2 ? 1 : 0;
+      }
+    }
+    const upper = absolute ? v2 + this.tolerance : v2 * (1 + this.tolerance / 100);
+    const lower = absolute ? v2 - this.tolerance : v2 * (1 - this.tolerance / 100);
+    if (this.comparison === "=") return v1 >= lower && v1 <= upper ? 1 : 0;
+    if (prev === void 0) {
+      return this.comparison === ">" ? v1 > v2 ? 1 : 0 : v1 < v2 ? 1 : 0;
     }
+    if (this.comparison === ">") {
+      return prev === 1 ? v1 < lower ? 0 : 1 : v1 > upper ? 1 : 0;
+    }
+    return prev === 1 ? v1 > upper ? 0 : 1 : v1 < lower ? 1 : 0;
   }
   async _upsertSeries(bars) {
     const { id } = await this.resolve();
@@ -956,6 +1191,9 @@ var AllocationHandle = class _AllocationHandle {
     handle._resolvedId = id;
     return handle;
   }
+  toJSON() {
+    return this.holdings.map(([ticker, weight]) => ({ symbol: ticker.symbol, leverage: ticker.leverage, weight })).sort((a, b) => a.symbol.localeCompare(b.symbol) || a.leverage - b.leverage);
+  }
   async _doResolve() {
     await Promise.all(this.holdings.map(([ticker]) => ticker.resolve()));
     const holdingsJson = {};
@@ -1461,6 +1699,22 @@ var StrategyHandle = class {
   get rules() {
     return this._rules;
   }
+  marketSymbols() {
+    const set = /* @__PURE__ */ new Set();
+    for (const rule of this._rules) {
+      for (const [ticker] of rule.hold.holdings) {
+        if (ticker.symbol !== "CASHX") set.add(ticker.symbol);
+      }
+      for (const signal of rule.when ?? []) {
+        for (const ind of [signal.indicator1, signal.indicator2]) {
+          if (ind.ticker !== null && ind.ticker.symbol !== "CASHX") set.add(ind.ticker.symbol);
+          if (ind.type === "VIX") set.add("^VIX");
+          if (ind.type === "VIX3M") set.add("^VIX3M");
+        }
+      }
+    }
+    return Array.from(set).sort();
+  }
   async resolve() {
     if (this._resolvedId != null) return { id: this._resolvedId };
     if (!this._resolving) {
@@ -1600,14 +1854,87 @@ var StrategyHandle = class {
    * map) we take the read-only preview path: historical signal bars come
    * straight from storage, today's bar is computed in-memory via
    * `signal.computeAt(date, overrides, prevBool)`, and nothing is written.
+   *
+   * Incremental path: when a strategy checkpoint exists (`getLatestSeriesDate`
+   * returns non-null), only the window (lastDate, limitDate] is processed.
+   * The current allocation is carried forward from `getLatestAllocationId`.
+   * Bootstrap: when no checkpoint exists, falls back to `_evaluateCold` which
+   * runs the full-history evaluation.
    */
   async _evaluate(limitDate, overrides) {
+    const { id } = await this.resolve();
+    const lastDate = await this._storage.strategies.getLatestSeriesDate(id);
+    const tradingDays = await this._storage.tradingDays.getRange();
+    const limitIdx = tradingDays.indexOf(limitDate);
+    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
+      };
+    });
+    if (lastDate === null) {
+      return this._evaluateCold(limitDate, overrides, rulesInput, allocations, tradingDays);
+    }
+    const lastAllocId = await this._storage.strategies.getLatestAllocationId(id);
+    const incrementalStartIdx = tradingDays.indexOf(lastDate) + 1;
+    const incrementalDays = tradingDays.slice(incrementalStartIdx, limitIdx + 1);
+    const isOverrideRefresh = incrementalDays.length === 0 && overrides !== void 0 && limitDate === lastDate;
+    const newDays = isOverrideRefresh ? [limitDate] : incrementalDays;
+    const startIdx = isOverrideRefresh ? limitIdx : incrementalStartIdx;
+    if (newDays.length === 0) return { allocations, entries: [] };
     const allSignals = /* @__PURE__ */ new Set();
-    for (const rule of this._rules) {
-      if (rule.when) rule.when.forEach((s) => allSignals.add(s));
+    for (const rule of this._rules) if (rule.when) rule.when.forEach((s) => allSignals.add(s));
+    const signalSeries = /* @__PURE__ */ new Map();
+    await Promise.all(
+      Array.from(allSignals).map(async (signal) => {
+        const bars = overrides === void 0 ? await signal.series({ from: newDays[0], to: limitDate }) : await this._storage.signals.getSeries(signal.id, { from: newDays[0], to: limitDate });
+        const dateMap = /* @__PURE__ */ new Map();
+        for (const bar of bars) dateMap.set(bar.date, bar.value === 1);
+        if (overrides !== void 0) {
+          const prevDateIdx = startIdx - 1 >= 0 ? tradingDays[startIdx - 1] : void 0;
+          const prevBool = prevDateIdx !== void 0 ? await signal.value(prevDateIdx) === 1 : null;
+          const todayValue = await signal.computeAt(limitDate, overrides, prevBool);
+          if (todayValue !== null) dateMap.set(limitDate, todayValue);
+        }
+        signalSeries.set(signal.id, dateMap);
+      })
+    );
+    const rebalanceDates = computeRebalanceDates(tradingDays, this._freq, this._offset);
+    const entries = [];
+    let current = lastAllocId !== null ? allocIndexMap.get(lastAllocId) ?? void 0 : void 0;
+    for (const date of newDays) {
+      if (rebalanceDates.has(date)) {
+        for (const rule of rulesInput) {
+          if (rule.signalIds.length === 0) {
+            current = rule.allocationIndex;
+            break;
+          }
+          const allTrue = rule.signalIds.every((sid) => signalSeries.get(sid)?.get(date) ?? false);
+          if (allTrue) {
+            current = rule.allocationIndex;
+            break;
+          }
+        }
+      }
+      if (current !== void 0) {
+        entries.push({ date, allocationId: allocations[current].id });
+      }
     }
+    return { allocations, entries };
+  }
+  // Renamed body of the old _evaluate — used only for first-ever evaluate (bootstrap).
+  async _evaluateCold(limitDate, overrides, rulesInput, allocations, tradingDays) {
+    const allSignals = /* @__PURE__ */ new Set();
+    for (const rule of this._rules) if (rule.when) rule.when.forEach((s) => allSignals.add(s));
     const signalSeries = /* @__PURE__ */ new Map();
-    const tradingDays = await this._storage.tradingDays.getRange();
     if (overrides === void 0) {
       await Promise.all(
         Array.from(allSignals).map(async (signal) => {
@@ -1635,20 +1962,6 @@ var StrategyHandle = class {
       );
     }
     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 <= limitDate).map(([date, allocIdx]) => ({ date, allocationId: allocations[allocIdx].id }));
     return { allocations, entries };
@@ -1749,11 +2062,30 @@ var StrategyHandle = class {
     const { allocations, entries } = await this._evaluate(date, overrides);
     const allocById = /* @__PURE__ */ new Map();
     for (const a of allocations) allocById.set(a.id, a);
-    for (const [id, a] of this._allocationMap) if (!allocById.has(id)) allocById.set(id, a);
-    let bars = entries.map((e) => ({
+    for (const [id2, a] of this._allocationMap) if (!allocById.has(id2)) allocById.set(id2, a);
+    const { id } = await this.resolve();
+    const lastDate = await this._storage.strategies.getLatestSeriesDate(id);
+    let storedBars = [];
+    if (lastDate !== null && entries.length > 0 && entries[0].date > (tradingDays[0] ?? "")) {
+      const storedEntries = await this._storage.strategies.getSeries(id, { to: lastDate });
+      storedBars = storedEntries.map((e) => ({
+        date: e.date,
+        allocation: allocById.get(e.allocationId) ?? this._allocationMap.get(e.allocationId)
+      }));
+    } else if (lastDate !== null && entries.length === 0) {
+      const storedEntries = await this._storage.strategies.getSeries(id);
+      storedBars = storedEntries.map((e) => ({
+        date: e.date,
+        allocation: allocById.get(e.allocationId) ?? this._allocationMap.get(e.allocationId)
+      }));
+    }
+    const newBars = entries.map((e) => ({
       date: e.date,
       allocation: allocById.get(e.allocationId)
     }));
+    const newDates = new Set(newBars.map((b) => b.date));
+    let bars = [...storedBars.filter((b) => !newDates.has(b.date)), ...newBars];
+    bars.sort((a, b) => a.date.localeCompare(b.date));
     if (range) {
       bars = bars.filter(
         (b) => (range.from === void 0 || b.date >= range.from) && (range.to === void 0 || b.date <= range.to)
@@ -1949,6 +2281,21 @@ function createClient(options) {
     strategy: (optionsOrLinkId) => new StrategyHandle(storage, market, optionsOrLinkId)
   };
 }
+
+// src/handles/allocation-equality.ts
+function allocationsEqual(a, b) {
+  if (a === null && b === null) return true;
+  if (a === null || b === null) return false;
+  const aj = a.toJSON();
+  const bj = b.toJSON();
+  if (aj.length !== bj.length) return false;
+  for (let i = 0; i < aj.length; i++) {
+    if (aj[i].symbol !== bj[i].symbol) return false;
+    if (aj[i].leverage !== bj[i].leverage) return false;
+    if (Math.abs(aj[i].weight - bj[i].weight) > 1e-9) return false;
+  }
+  return true;
+}
 export {
   AllocationHandle,
   IndicatorHandle,
@@ -1957,6 +2304,8 @@ export {
   SimulationHandle,
   StrategyHandle,
   TickerHandle,
+  allocationsEqual,
+  computeRebalanceDates,
   createClient
 };
 //# sourceMappingURL=index.js.map