backtest-kit 2.3.1 → 2.3.3

package/README.md

@@ -9,6 +9,7 @@
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/tripolskypetr/backtest-kit)
 [![npm](https://img.shields.io/npm/v/backtest-kit.svg?style=flat-square)](https://npmjs.org/package/backtest-kit)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue)]()
+[![Build](https://github.com/tripolskypetr/backtest-kit/actions/workflows/webpack.yml/badge.svg)](https://github.com/tripolskypetr/backtest-kit/actions/workflows/webpack.yml)
 
 Build reliable trading systems: backtest on historical data, deploy live bots with recovery, and optimize strategies using LLMs like Ollama.
 
@@ -212,83 +213,113 @@ temporal time context to your strategies.
     <summary>
       The Math
     </summary>
-      
+
     For a candle with:
-    - `timestamp` = candle open time
+    - `timestamp` = candle open time (openTime)
     - `stepMs` = interval duration (e.g., 60000ms for "1m")
     - Candle close time = `timestamp + stepMs`
 
-    The candle is included if: `timestamp + stepMs < upperBoundary`
-
-    - `getCandles(symbol, interval, limit)` - Returns data in range `(when - limit*interval, when)`
-      - Fetches historical candles backwards from execution context time
-      - Only fully closed candles are included (candle must close before `when`)
-      - Lower bound: `candle.timestamp > sinceTimestamp` (exclusive)
-      - Upper bound: `candle.timestamp + stepMs < when` (exclusive)
-      - Example: `getCandles("BTCUSDT", "1m", 100)` returns 100 candles ending before current time
-
-    - `getNextCandles(symbol, interval, limit)` - Returns data in range `(when, when + limit*interval)`
-      - Fetches future candles forwards from execution context time (backtest only)
-      - Only fully closed candles are included
-      - Lower bound: `candle.timestamp > when` (exclusive)
-      - Upper bound: `candle.timestamp + stepMs < endTime` (exclusive)
+    **Alignment:** All timestamps are aligned down to interval boundary.
+    For example, for 15m interval: 00:17 → 00:15, 00:44 → 00:30
+
+    **Adapter contract:**
+    - First candle.timestamp must equal aligned `since`
+    - Adapter must return exactly `limit` candles
+    - Sequential timestamps: `since + i * stepMs` for i = 0..limit-1
+
+    **How `since` is calculated from `when`:**
+    - `when` = current execution context time (from AsyncLocalStorage)
+    - `alignedWhen` = `Math.floor(when / stepMs) * stepMs` (aligned down to interval boundary)
+    - `since` = `alignedWhen - limit * stepMs` (go back `limit` candles from aligned when)
+
+    **Boundary semantics (inclusive/exclusive):**
+    - `since` is always **inclusive** — first candle has `timestamp === since`
+    - Exactly `limit` candles are returned
+    - Last candle has `timestamp === since + (limit - 1) * stepMs` — **inclusive**
+    - For `getCandles`: `alignedWhen` is **exclusive** — candle at that timestamp is NOT included (it's a pending/incomplete candle)
+    - For `getRawCandles`: `eDate` is **exclusive** — candle at that timestamp is NOT included (it's a pending/incomplete candle)
+    - For `getNextCandles`: `alignedWhen` is **inclusive** — first candle starts at `alignedWhen` (it's the current candle for backtest, already closed in historical data)
+
+    - `getCandles(symbol, interval, limit)` - Returns exactly `limit` candles
+      - Aligns `when` down to interval boundary
+      - Calculates `since = alignedWhen - limit * stepMs`
+      - **since — inclusive**, first candle.timestamp === since
+      - **alignedWhen — exclusive**, candle at alignedWhen is NOT returned
+      - Range: `[since, alignedWhen)` — half-open interval
+      - Example: `getCandles("BTCUSDT", "1m", 100)` returns 100 candles ending before aligned when
+
+    - `getNextCandles(symbol, interval, limit)` - Returns exactly `limit` candles (backtest only)
+      - Aligns `when` down to interval boundary
+      - `since = alignedWhen` (starts from aligned when, going forward)
+      - **since — inclusive**, first candle.timestamp === since
+      - Range: `[alignedWhen, alignedWhen + limit * stepMs)` — half-open interval
       - Throws error in live mode to prevent look-ahead bias
-      - Example: `getNextCandles("BTCUSDT", "1m", 10)` returns next 10 candles after current time
+      - Example: `getNextCandles("BTCUSDT", "1m", 10)` returns next 10 candles starting from aligned when
 
     - `getRawCandles(symbol, interval, limit?, sDate?, eDate?)` - Flexible parameter combinations:
-      - `(limit)` - Returns data in range `(now - limit*interval, now)`
-      - `(limit, sDate)` - Returns data in range `(sDate, sDate + limit*interval)`
-      - `(limit, undefined, eDate)` - Returns data in range `(eDate - limit*interval, eDate)`
-      - `(undefined, sDate, eDate)` - Returns data in range `(sDate, eDate)`, limit calculated from range
-      - `(limit, sDate, eDate)` - Returns data in range `(sDate, eDate)`, limit used only for fetch size
-      - All combinations use: `candle.timestamp > sDate && candle.timestamp + stepMs < eDate`
-      - All combinations respect exclusive boundaries and look-ahead bias protection
+      - `(limit)` - since = alignedWhen - limit * stepMs, range `[since, alignedWhen)`
+      - `(limit, sDate)` - since = align(sDate), returns `limit` candles forward, range `[since, since + limit * stepMs)`
+      - `(limit, undefined, eDate)` - since = align(eDate) - limit * stepMs, **eDate — exclusive**, range `[since, eDate)`
+      - `(undefined, sDate, eDate)` - since = align(sDate), limit calculated from range, **sDate — inclusive, eDate — exclusive**, range `[sDate, eDate)`
+      - `(limit, sDate, eDate)` - since = align(sDate), returns `limit` candles, **sDate — inclusive**
+      - All combinations respect look-ahead bias protection (eDate/endTime <= when)
 
     **Persistent Cache:**
-    - Candle cache uses identical boundary semantics: `timestamp > sinceTimestamp && timestamp + stepMs < untilTimestamp`
-    - Cache and runtime filters are synchronized to prevent inconsistencies
-    - Cache returns only candles that match the requested time range exactly
+    - Cache lookup calculates expected timestamps: `since + i * stepMs` for i = 0..limit-1
+    - Returns all candles if found, null if any missing (cache miss)
+    - Cache and runtime use identical timestamp calculation logic
 
   </details>
 
-#### Boundary Semantics:
-
-All methods use **strict exclusive boundaries** - candles at exact boundary times are excluded. This prevents accidental inclusion of boundary conditions in backtest logic and ensures consistent behavior across cache and runtime.
+#### Candle Timestamp Convention:
 
 According to this `timestamp` of a candle in backtest-kit is exactly the `openTime`, not ~~`closeTime`~~
 
-**Key principle:** A candle is included only if it **fully closed** before the upper boundary.
+**Key principles:**
+- All timestamps are aligned down to interval boundary
+- First candle.timestamp must equal aligned `since`
+- Adapter must return exactly `limit` candles
+- Sequential timestamps: `since + i * stepMs`
 
-### 🔬 Technical Details: The `+ stepMs` Check
+### 🔬 Technical Details: Timestamp Alignment
 
-**Why check `candle.timestamp + stepMs < upperBoundary` instead of just `candle.timestamp < upperBoundary`?**
+**Why align timestamps to interval boundaries?**
 
-Because a candle's **timestamp is when it opens**, not when it closes:
+Because candle APIs return data starting from exact interval boundaries:
 
 ```typescript
-// 1-minute candle example:
-timestamp = 1000      // Candle opens at 1000ms
-stepMs = 60000        // Duration: 60 seconds
-// Candle closes at: 1000 + 60000 = 61000ms
-
-// Without + stepMs (WRONG):
-candle.timestamp < 61000
-1000 < 61000  // TRUE - includes candle that hasn't finished yet!
-
-// With + stepMs (CORRECT):
-candle.timestamp + stepMs < 61000
-1000 + 60000 < 61000
-61000 < 61000  // FALSE - correctly excludes unclosed candle
+// 15-minute interval example:
+when = 1704067920000       // 00:12:00
+step = 15                  // 15 minutes
+stepMs = 15 * 60000        // 900000ms
+
+// Alignment: round down to nearest interval boundary
+alignedWhen = Math.floor(when / stepMs) * stepMs
+// = Math.floor(1704067920000 / 900000) * 900000
+// = 1704067200000 (00:00:00)
+
+// Calculate since for 4 candles backwards:
+since = alignedWhen - 4 * stepMs
+// = 1704067200000 - 4 * 900000
+// = 1704063600000 (23:00:00 previous day)
+
+// Expected candles:
+// [0] timestamp = 1704063600000 (23:00)
+// [1] timestamp = 1704064500000 (23:15)
+// [2] timestamp = 1704065400000 (23:30)
+// [3] timestamp = 1704066300000 (23:45)
 ```
 
-**This check is applied consistently across:**
-- ✅ `getCandles()` filtering
-- ✅ `getNextCandles()` filtering
-- ✅ `getRawCandles()` filtering (all parameter combinations)
-- ✅ Cache read operations
-- ✅ Cache write operations
+**Pending candle exclusion:** The candle at `00:00:00` (alignedWhen) is NOT included in the result. At `when=00:12:00`, this candle covers the period `[00:00, 00:15)` and is still open (pending). Pending candles have incomplete OHLCV data that would distort technical indicators. Only fully closed candles are returned.
+
+**Validation is applied consistently across:**
+- ✅ `getCandles()` - validates first timestamp and count
+- ✅ `getNextCandles()` - validates first timestamp and count
+- ✅ `getRawCandles()` - validates first timestamp and count
+- ✅ Cache read - calculates exact expected timestamps
+- ✅ Cache write - stores validated candles
 
-**Result:** Zero chance of including incomplete or "forming" candles in your strategy logic.
+**Result:** Deterministic candle retrieval with exact timestamp matching.
 
 ### 💭 What this means:
 - `getCandles()` always returns data UP TO the current backtest timestamp using `async_hooks`