backtest-kit 9.0.1 → 9.0.3

package/build/index.mjs

@@ -1438,7 +1438,7 @@ class PersistRiskInstance {
      *
      * @returns Promise resolving to positions (empty array if none persisted)
      */
-    async readPositionData() {
+    async readPositionData(_when) {
         if (await this._storage.hasValue(PersistRiskInstance.STORAGE_KEY)) {
             return await this._storage.readValue(PersistRiskInstance.STORAGE_KEY);
         }
@@ -1448,9 +1448,10 @@ class PersistRiskInstance {
      * Writes the positions array using the fixed STORAGE_KEY.
      *
      * @param riskRow - Position entries to persist
+     * @param when - Logical timestamp (reserved for API consistency; not used)
      * @returns Promise that resolves when write is complete
      */
-    async writePositionData(riskRow) {
+    async writePositionData(riskRow, _when) {
         await this._storage.writeValue(PersistRiskInstance.STORAGE_KEY, riskRow);
     }
 }
@@ -1475,12 +1476,12 @@ class PersistRiskDummyInstance {
      * Always returns empty positions array.
      * @returns Promise resolving to []
      */
-    async readPositionData() { return []; }
+    async readPositionData(_when) { return []; }
     /**
      * No-op write (discards positions).
      * @returns Promise that resolves immediately
      */
-    async writePositionData(_riskRow) { }
+    async writePositionData(_riskRow, _when) { }
 }
 /**
  * Utility class for managing risk active positions persistence.
@@ -1510,15 +1511,16 @@ class PersistRiskUtils {
          *
          * @param riskName - Risk profile identifier
          * @param exchangeName - Exchange identifier
+         * @param when - Logical timestamp at which the read is happening (reserved for API consistency)
          * @returns Promise resolving to position entries (empty array if none)
          */
-        this.readPositionData = async (riskName, exchangeName) => {
+        this.readPositionData = async (riskName, exchangeName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
             await instance.waitForInit(isInitial);
-            return instance.readPositionData();
+            return instance.readPositionData(when);
         };
         /**
          * Writes active positions for the given risk context.
@@ -1527,15 +1529,16 @@ class PersistRiskUtils {
          * @param riskRow - Position entries to persist
          * @param riskName - Risk profile identifier
          * @param exchangeName - Exchange identifier
+         * @param when - Logical timestamp this write belongs to (reserved for API consistency)
          * @returns Promise that resolves when write is complete
          */
-        this.writePositionData = async (riskRow, riskName, exchangeName) => {
+        this.writePositionData = async (riskRow, riskName, exchangeName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
             await instance.waitForInit(isInitial);
-            return instance.writePositionData(riskRow);
+            return instance.writePositionData(riskRow, when);
         };
     }
     /**
@@ -1829,7 +1832,7 @@ class PersistPartialInstance {
      * @param signalId - Signal identifier
      * @returns Promise resolving to partial data record (empty object if not found)
      */
-    async readPartialData(signalId) {
+    async readPartialData(signalId, _when) {
         if (await this._storage.hasValue(signalId)) {
             return await this._storage.readValue(signalId);
         }
@@ -1840,9 +1843,10 @@ class PersistPartialInstance {
      *
      * @param data - Partial data record to persist
      * @param signalId - Signal identifier
+     * @param when - Logical timestamp (reserved for API consistency; not used)
      * @returns Promise that resolves when write is complete
      */
-    async writePartialData(data, signalId) {
+    async writePartialData(data, signalId, _when) {
         await this._storage.writeValue(signalId, data);
     }
 }
@@ -1865,12 +1869,12 @@ class PersistPartialDummyInstance {
      * Always returns empty partial data record.
      * @returns Promise resolving to {}
      */
-    async readPartialData(_signalId) { return {}; }
+    async readPartialData(_signalId, _when) { return {}; }
     /**
      * No-op write (discards partial data).
      * @returns Promise that resolves immediately
      */
-    async writePartialData(_data, _signalId) { }
+    async writePartialData(_data, _signalId, _when) { }
 }
 /**
  * Utility class for managing partial profit/loss levels persistence.
@@ -1903,15 +1907,16 @@ class PersistPartialUtils {
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
+         * @param when - Logical timestamp at which the read is happening (reserved for API consistency)
          * @returns Promise resolving to partial data record (empty object if none)
          */
-        this.readPartialData = async (symbol, strategyName, signalId, exchangeName) => {
+        this.readPartialData = async (symbol, strategyName, signalId, exchangeName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
             await instance.waitForInit(isInitial);
-            return instance.readPartialData(signalId);
+            return instance.readPartialData(signalId, when);
         };
         /**
          * Writes partial data for the given context and signalId.
@@ -1922,15 +1927,16 @@ class PersistPartialUtils {
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
+         * @param when - Logical timestamp this write belongs to (reserved for API consistency)
          * @returns Promise that resolves when write is complete
          */
-        this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName) => {
+        this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
             await instance.waitForInit(isInitial);
-            return instance.writePartialData(partialData, signalId);
+            return instance.writePartialData(partialData, signalId, when);
         };
     }
     /**
@@ -2029,7 +2035,7 @@ class PersistBreakevenInstance {
      * @param signalId - Signal identifier
      * @returns Promise resolving to breakeven data record (empty object if not found)
      */
-    async readBreakevenData(signalId) {
+    async readBreakevenData(signalId, _when) {
         if (await this._storage.hasValue(signalId)) {
             return await this._storage.readValue(signalId);
         }
@@ -2040,9 +2046,10 @@ class PersistBreakevenInstance {
      *
      * @param data - Breakeven data record to persist
      * @param signalId - Signal identifier
+     * @param when - Logical timestamp (reserved for API consistency; not used)
      * @returns Promise that resolves when write is complete
      */
-    async writeBreakevenData(data, signalId) {
+    async writeBreakevenData(data, signalId, _when) {
         await this._storage.writeValue(signalId, data);
     }
 }
@@ -2065,12 +2072,12 @@ class PersistBreakevenDummyInstance {
      * Always returns empty breakeven data record.
      * @returns Promise resolving to {}
      */
-    async readBreakevenData(_signalId) { return {}; }
+    async readBreakevenData(_signalId, _when) { return {}; }
     /**
      * No-op write (discards breakeven data).
      * @returns Promise that resolves immediately
      */
-    async writeBreakevenData(_data, _signalId) { }
+    async writeBreakevenData(_data, _signalId, _when) { }
 }
 /**
  * Persistence utility class for breakeven state management.
@@ -2123,15 +2130,16 @@ class PersistBreakevenUtils {
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
+         * @param when - Logical timestamp at which the read is happening (reserved for API consistency)
          * @returns Promise resolving to breakeven data record (empty object if none)
          */
-        this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName) => {
+        this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
             const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
             await instance.waitForInit(isInitial);
-            return instance.readBreakevenData(signalId);
+            return instance.readBreakevenData(signalId, when);
         };
         /**
          * Writes breakeven data for the given context and signalId.
@@ -2142,15 +2150,16 @@ class PersistBreakevenUtils {
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
+         * @param when - Logical timestamp this write belongs to (reserved for API consistency)
          * @returns Promise that resolves when write is complete
          */
-        this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName) => {
+        this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
             const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
             await instance.waitForInit(isInitial);
-            return instance.writeBreakevenData(breakevenData, signalId);
+            return instance.writeBreakevenData(breakevenData, signalId, when);
         };
     }
     /**
@@ -3561,7 +3570,7 @@ class PersistMemoryInstance {
      * @param memoryId - Memory entry identifier
      * @returns Promise that resolves when write is complete
      */
-    async writeMemoryData(data, memoryId) {
+    async writeMemoryData(data, memoryId, _when) {
         await this._storage.writeValue(memoryId, data);
     }
     /**
@@ -3626,7 +3635,7 @@ class PersistMemoryDummyInstance {
      * No-op write (discards entry).
      * @returns Promise that resolves immediately
      */
-    async writeMemoryData(_data, _memoryId) { }
+    async writeMemoryData(_data, _memoryId, _when) { }
     /**
      * No-op remove.
      * @returns Promise that resolves immediately
@@ -3719,19 +3728,20 @@ class PersistMemoryUtils {
          * Writes a memory entry for the given context.
          * Lazily initializes the instance on first access.
          *
-         * @param data - Entry data to persist
+         * @param data - Entry data to persist (already carries `data.when`)
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
          * @param memoryId - Memory entry identifier
+         * @param when - Logical timestamp this entry belongs to (duplicates `data.when` for API consistency)
          * @returns Promise that resolves when write is complete
          */
-        this.writeMemoryData = async (data, signalId, bucketName, memoryId) => {
+        this.writeMemoryData = async (data, signalId, bucketName, memoryId, when) => {
             LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
             await instance.waitForInit(isInitial);
-            return instance.writeMemoryData(data, memoryId);
+            return instance.writeMemoryData(data, memoryId, when);
         };
         /**
          * Soft-deletes a memory entry for the given context.
@@ -3895,7 +3905,7 @@ class PersistRecentInstance {
      * @param signalRow - Recent signal data to persist
      * @returns Promise that resolves when write is complete
      */
-    async writeRecentData(signalRow) {
+    async writeRecentData(signalRow, _when) {
         await this._storage.writeValue(this.symbol, signalRow);
     }
 }
@@ -3923,7 +3933,7 @@ class PersistRecentDummyInstance {
      * No-op write (discards recent signal).
      * @returns Promise that resolves immediately
      */
-    async writeRecentData(_signalRow) { }
+    async writeRecentData(_signalRow, _when) { }
 }
 /**
  * Utility class for managing recent signal persistence.
@@ -3970,21 +3980,22 @@ class PersistRecentUtils {
          * Writes the latest recent signal for the given context.
          * Lazily initializes the instance on first access.
          *
-         * @param signalRow - Recent signal data to persist
+         * @param signalRow - Recent signal data to persist (already carries `signalRow.timestamp`)
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier (may be empty)
          * @param backtest - True for backtest mode, false for live mode
+         * @param when - Logical timestamp this signal belongs to (duplicates `signalRow.timestamp` for API consistency)
          * @returns Promise that resolves when write is complete
          */
-        this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest, when) => {
             LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
             const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await instance.waitForInit(isInitial);
-            return instance.writeRecentData(signalRow);
+            return instance.writeRecentData(signalRow, when);
         };
     }
     /**
@@ -4098,7 +4109,7 @@ class PersistStateInstance {
      * @param data - State data to persist
      * @returns Promise that resolves when write is complete
      */
-    async writeStateData(data) {
+    async writeStateData(data, _when) {
         await this._storage.writeValue(this.bucketName, data);
     }
     /**
@@ -4131,7 +4142,7 @@ class PersistStateDummyInstance {
      * No-op write (discards state).
      * @returns Promise that resolves immediately
      */
-    async writeStateData(_data) { }
+    async writeStateData(_data, _when) { }
     /**
      * No-op dispose.
      */
@@ -4196,18 +4207,19 @@ class PersistStateUtils {
          * Writes state for the given context.
          * Lazily initializes the instance on first access.
          *
-         * @param data - State data to persist
+         * @param data - State data to persist (already carries `data.when`)
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
+         * @param when - Logical timestamp this value belongs to (duplicates `data.when` for API consistency)
          * @returns Promise that resolves when write is complete
          */
-        this.writeStateData = async (data, signalId, bucketName) => {
+        this.writeStateData = async (data, signalId, bucketName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
             const instance = this.getStateStorage(signalId, bucketName);
             await instance.waitForInit(isInitial);
-            return instance.writeStateData(data);
+            return instance.writeStateData(data, when);
         };
         /**
          * Switches to PersistStateDummyInstance (all operations are no-ops).
@@ -4317,7 +4329,7 @@ class PersistSessionInstance {
      * @param data - Session data to persist
      * @returns Promise that resolves when write is complete
      */
-    async writeSessionData(data) {
+    async writeSessionData(data, _when) {
         await this._storage.writeValue(this.frameName, data);
     }
     /**
@@ -4350,7 +4362,7 @@ class PersistSessionDummyInstance {
      * No-op write (discards session data).
      * @returns Promise that resolves immediately
      */
-    async writeSessionData(_data) { }
+    async writeSessionData(_data, _when) { }
     /**
      * No-op dispose.
      */
@@ -4418,19 +4430,20 @@ class PersistSessionUtils {
          * Writes session data for the given context.
          * Lazily initializes the instance on first access.
          *
-         * @param data - Session data to persist
+         * @param data - Session data to persist (already carries `data.when`)
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier
+         * @param when - Logical timestamp this value belongs to (duplicates `data.when` for API consistency)
          * @returns Promise that resolves when write is complete
          */
-        this.writeSessionData = async (data, strategyName, exchangeName, frameName) => {
+        this.writeSessionData = async (data, strategyName, exchangeName, frameName, when) => {
             LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
             const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
             await instance.waitForInit(isInitial);
-            return instance.writeSessionData(data);
+            return instance.writeSessionData(data, when);
         };
         /**
          * Switches to PersistSessionDummyInstance (all operations are no-ops).
@@ -14132,57 +14145,10 @@ const get = (object, path) => {
     return pathArrayFlat.reduce((obj, key) => obj && obj[key], object);
 };
 
-const MS_PER_MINUTE$6 = 60000;
-const INTERVAL_MINUTES$6 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
-    "2h": 120,
-    "4h": 240,
-    "6h": 360,
-    "8h": 480,
-    "1d": 1440,
-};
-/**
- * Aligns timestamp down to the nearest interval boundary.
- * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
- *
- * Candle timestamp convention:
- * - Candle timestamp = openTime (when candle opens)
- * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
- *
- * Adapter contract:
- * - Adapter must return candles with timestamp = openTime
- * - First returned candle.timestamp must equal aligned since
- * - Adapter must return exactly `limit` candles
- *
- * @param date - Date to align
- * @param interval - Candle interval (e.g., "1m", "15m", "1h")
- * @returns New Date aligned down to interval boundary
- */
-const alignToInterval = (date, interval) => {
-    const minutes = INTERVAL_MINUTES$6[interval];
-    if (minutes === undefined) {
-        throw new Error(`alignToInterval: unknown interval=${interval}`);
-    }
-    const intervalMs = minutes * MS_PER_MINUTE$6;
-    return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
-};
-
 /** Used to prevent race confition between concurent strategies */
 const RISK_LOCK = new Lock();
 /** Symbol indicating that positions need to be fetched from persistence */
 const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
-/** Get timestamp from execution context or fallback to aligned current time */
-const GET_CONTEXT_TIMESTAMP_FN = (self) => {
-    if (ExecutionContextService.hasContext()) {
-        return self.params.execution.context.when.getTime();
-    }
-    return alignToInterval(new Date(), "1m").getTime();
-};
 /** Zero PNL constant for scheduled signals (which don't have priceOpen or PNL yet) */
 const ZERO_PNL = { pnlPercentage: 0, priceOpen: 0, priceClose: 0, pnlCost: 0, pnlEntries: 0 };
 /**
@@ -14308,7 +14274,7 @@ const CALL_ALLOWED_CALLBACKS_FN = trycatch(async (self, symbol, params) => {
  *
  * In backtest mode, initializes with empty Map. In live mode, reads from persist storage.
  */
-const WAIT_FOR_INIT_FN$3 = async (self) => {
+const WAIT_FOR_INIT_FN$3 = async (when, self) => {
     self.params.logger.debug("ClientRisk waitForInit", {
         backtest: self.params.backtest,
     });
@@ -14316,7 +14282,7 @@ const WAIT_FOR_INIT_FN$3 = async (self) => {
         self._activePositions = new Map();
         return;
     }
-    const persistedPositions = await PersistRiskAdapter.readPositionData(self.params.riskName, self.params.exchangeName);
+    const persistedPositions = await PersistRiskAdapter.readPositionData(self.params.riskName, self.params.exchangeName, when);
     self._activePositions = new Map(persistedPositions);
 };
 /**
@@ -14345,7 +14311,7 @@ class ClientRisk {
          * Uses singleshot pattern to ensure initialization happens exactly once.
          * Skips persistence in backtest mode.
          */
-        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN$3(this));
+        this.waitForInit = singleshot(async (when) => await WAIT_FOR_INIT_FN$3(when, this));
         /**
          * Checks if a signal should be allowed based on risk limits.
          *
@@ -14367,11 +14333,15 @@ class ClientRisk {
             });
             await RISK_LOCK.acquireLock();
             try {
+                const timestamp = await this.params.time.getTimestamp(params.symbol, {
+                    strategyName: params.strategyName,
+                    exchangeName: params.exchangeName,
+                    frameName: params.frameName,
+                }, this.params.backtest);
                 if (this._activePositions === POSITION_NEED_FETCH) {
-                    await this.waitForInit();
+                    await this.waitForInit(new Date(timestamp));
                 }
                 const riskMap = this._activePositions;
-                const timestamp = GET_CONTEXT_TIMESTAMP_FN(this);
                 const payload = {
                     ...params,
                     currentSignal: TO_RISK_SIGNAL(params.currentSignal, params.currentPrice, timestamp),
@@ -14474,14 +14444,14 @@ class ClientRisk {
      * Persists current active positions to disk.
      * Skips in backtest mode.
      */
-    async _updatePositions() {
+    async _updatePositions(when) {
         if (this.params.backtest) {
             return;
         }
         if (this._activePositions === POSITION_NEED_FETCH) {
-            await this.waitForInit();
+            await this.waitForInit(when);
         }
-        await PersistRiskAdapter.writePositionData(Array.from(this._activePositions), this.params.riskName, this.params.exchangeName);
+        await PersistRiskAdapter.writePositionData(Array.from(this._activePositions), this.params.riskName, this.params.exchangeName, when);
     }
     /**
      * Registers a new opened signal.
@@ -14496,8 +14466,9 @@ class ClientRisk {
         });
         await RISK_LOCK.acquireLock();
         try {
+            const timestamp = await this.params.time.getTimestamp(symbol, context, this.params.backtest);
             if (this._activePositions === POSITION_NEED_FETCH) {
-                await this.waitForInit();
+                await this.waitForInit(new Date(timestamp));
             }
             const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
             const riskMap = this._activePositions;
@@ -14513,7 +14484,7 @@ class ClientRisk {
                 minuteEstimatedTime: positionData.minuteEstimatedTime,
                 openTimestamp: positionData.openTimestamp,
             });
-            await this._updatePositions();
+            await this._updatePositions(new Date(timestamp));
         }
         finally {
             await RISK_LOCK.releaseLock();
@@ -14531,13 +14502,14 @@ class ClientRisk {
         });
         await RISK_LOCK.acquireLock();
         try {
+            const timestamp = await this.params.time.getTimestamp(symbol, context, this.params.backtest);
             if (this._activePositions === POSITION_NEED_FETCH) {
-                await this.waitForInit();
+                await this.waitForInit(new Date(timestamp));
             }
             const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
             const riskMap = this._activePositions;
             riskMap.delete(key);
-            await this._updatePositions();
+            await this._updatePositions(new Date(timestamp));
         }
         finally {
             await RISK_LOCK.releaseLock();
@@ -14637,7 +14609,7 @@ class RiskConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.riskSchemaService = inject(TYPES.riskSchemaService);
-        this.executionContextService = inject(TYPES.executionContextService);
+        this.timeMetaService = inject(TYPES.timeMetaService);
         /**
          * Action core service injected from DI container.
          */
@@ -14659,7 +14631,7 @@ class RiskConnectionService {
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
-                execution: this.executionContextService,
+                time: this.timeMetaService,
                 backtest,
                 exchangeName,
                 onRejected: CREATE_COMMIT_REJECTION_FN(this, exchangeName, frameName),
@@ -19650,8 +19622,8 @@ class BacktestLogicPrivateService {
 }
 
 const EMITTER_CHECK_INTERVAL = 5000;
-const MS_PER_MINUTE$5 = 60000;
-const INTERVAL_MINUTES$5 = {
+const MS_PER_MINUTE$6 = 60000;
+const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -19666,7 +19638,7 @@ const INTERVAL_MINUTES$5 = {
 };
 const createEmitter = memoize(([interval]) => `${interval}`, (interval) => {
     const tickSubject = new Subject();
-    const intervalMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$5;
+    const intervalMs = INTERVAL_MINUTES$6[interval] * MS_PER_MINUTE$6;
     {
         let lastAligned = Math.floor(Date.now() / intervalMs) * intervalMs;
         Source.fromInterval(EMITTER_CHECK_INTERVAL)
@@ -19693,6 +19665,46 @@ const waitForCandle = async (interval) => {
     return emitter.toPromise();
 };
 
+const MS_PER_MINUTE$5 = 60000;
+const INTERVAL_MINUTES$5 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+    "1d": 1440,
+};
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param date - Date to align
+ * @param interval - Candle interval (e.g., "1m", "15m", "1h")
+ * @returns New Date aligned down to interval boundary
+ */
+const alignToInterval = (date, interval) => {
+    const minutes = INTERVAL_MINUTES$5[interval];
+    if (minutes === undefined) {
+        throw new Error(`alignToInterval: unknown interval=${interval}`);
+    }
+    const intervalMs = minutes * MS_PER_MINUTE$5;
+    return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
+};
+
 /**
  * Private service for live trading orchestration using async generators.
  *
@@ -27191,7 +27203,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, data.strategyName, data.exchangeName, self.params.signalId);
+        await self._persistState(symbol, data.strategyName, data.exchangeName, data.frameName, self.params.signalId);
     }
 };
 /**
@@ -27241,7 +27253,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, data.strategyName, data.exchangeName, self.params.signalId);
+        await self._persistState(symbol, data.strategyName, data.exchangeName, data.frameName, self.params.signalId);
     }
 };
 /**
@@ -27258,7 +27270,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
  * @param backtest - True if backtest mode, false if live mode
  * @param self - ClientPartial instance reference
  */
-const WAIT_FOR_INIT_FN$1 = async (symbol, strategyName, exchangeName, backtest, self) => {
+const WAIT_FOR_INIT_FN$1 = async (symbol, strategyName, exchangeName, frameName, backtest, self) => {
     self.params.logger.debug("ClientPartial waitForInit", {
         symbol,
         backtest,
@@ -27274,7 +27286,12 @@ const WAIT_FOR_INIT_FN$1 = async (symbol, strategyName, exchangeName, backtest,
         self.params.logger.debug("ClientPartial waitForInit: skipping persist read in backtest mode");
         return;
     }
-    const partialData = await PersistPartialAdapter.readPartialData(symbol, strategyName, self.params.signalId, exchangeName);
+    const timestamp = await self.params.time.getTimestamp(symbol, {
+        strategyName,
+        exchangeName,
+        frameName,
+    }, self.params.backtest);
+    const partialData = await PersistPartialAdapter.readPartialData(symbol, strategyName, self.params.signalId, exchangeName, new Date(timestamp));
     for (const [signalId, data] of Object.entries(partialData)) {
         const state = {
             profitLevels: new Set(data.profitLevels),
@@ -27382,7 +27399,7 @@ class ClientPartial {
          * // Now profit()/loss() can be called
          * ```
          */
-        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, backtest) => await WAIT_FOR_INIT_FN$1(symbol, strategyName, exchangeName, backtest, this));
+        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, frameName, backtest) => await WAIT_FOR_INIT_FN$1(symbol, strategyName, exchangeName, frameName, backtest, this));
     }
     /**
      * Persists current partial state to disk.
@@ -27400,7 +27417,7 @@ class ClientPartial {
      * @param signalId - Signal identifier
      * @returns Promise that resolves when persistence is complete
      */
-    async _persistState(symbol, strategyName, exchangeName, signalId) {
+    async _persistState(symbol, strategyName, exchangeName, frameName, signalId) {
         if (this.params.backtest) {
             return;
         }
@@ -27415,7 +27432,12 @@ class ClientPartial {
                 lossLevels: Array.from(state.lossLevels),
             };
         }
-        await PersistPartialAdapter.writePartialData(partialData, symbol, strategyName, signalId, exchangeName);
+        const timestamp = await this.params.time.getTimestamp(symbol, {
+            strategyName,
+            exchangeName,
+            frameName,
+        }, this.params.backtest);
+        await PersistPartialAdapter.writePartialData(partialData, symbol, strategyName, signalId, exchangeName, new Date(timestamp));
     }
     /**
      * Processes profit state and emits events for newly reached profit levels.
@@ -27540,7 +27562,7 @@ class ClientPartial {
             throw new Error(`Signal ID mismatch: expected ${this.params.signalId}, got ${data.id}`);
         }
         this._states.delete(data.id);
-        await this._persistState(symbol, data.strategyName, data.exchangeName, this.params.signalId);
+        await this._persistState(symbol, data.strategyName, data.exchangeName, data.frameName, this.params.signalId);
     }
 }
 
@@ -27665,6 +27687,7 @@ class PartialConnectionService {
          * Action core service injected from DI container.
          */
         this.actionCoreService = inject(TYPES.actionCoreService);
+        this.timeMetaService = inject(TYPES.timeMetaService);
         /**
          * Memoized factory function for ClientPartial instances.
          *
@@ -27678,6 +27701,7 @@ class PartialConnectionService {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
+                time: this.timeMetaService,
                 backtest,
                 onProfit: CREATE_COMMIT_PROFIT_FN(this),
                 onLoss: CREATE_COMMIT_LOSS_FN(this),
@@ -27707,7 +27731,7 @@ class PartialConnectionService {
                 when,
             });
             const partial = this.getPartial(data.id, backtest);
-            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
+            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
             return await partial.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
         };
         /**
@@ -27734,7 +27758,7 @@ class PartialConnectionService {
                 when,
             });
             const partial = this.getPartial(data.id, backtest);
-            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
+            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
             return await partial.loss(symbol, data, currentPrice, lossPercent, backtest, when);
         };
         /**
@@ -27762,7 +27786,7 @@ class PartialConnectionService {
                 backtest,
             });
             const partial = this.getPartial(data.id, backtest);
-            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
+            await partial.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
             await partial.clear(symbol, data, priceClose, backtest);
             const key = CREATE_KEY_FN$l(data.id, backtest);
             this.getPartial.clear(key);
@@ -28488,7 +28512,7 @@ const HANDLE_BREAKEVEN_FN = async (symbol, data, currentPrice, backtest, when, s
     // Emit event
     await self.params.onBreakeven(symbol, data.strategyName, data.exchangeName, data.frameName, data, currentPrice, backtest, when.getTime());
     // Persist state
-    await self._persistState(symbol, data.strategyName, data.exchangeName, self.params.signalId);
+    await self._persistState(symbol, data.strategyName, data.exchangeName, data.frameName, self.params.signalId);
     return true;
 };
 /**
@@ -28503,7 +28527,7 @@ const HANDLE_BREAKEVEN_FN = async (symbol, data, currentPrice, backtest, when, s
  * @param exchangeName - Exchange identifier
  * @param self - ClientBreakeven instance reference
  */
-const WAIT_FOR_INIT_FN = async (symbol, strategyName, exchangeName, backtest, self) => {
+const WAIT_FOR_INIT_FN = async (symbol, strategyName, exchangeName, frameName, backtest, self) => {
     self.params.logger.debug("ClientBreakeven waitForInit", {
         symbol,
         strategyName,
@@ -28519,7 +28543,12 @@ const WAIT_FOR_INIT_FN = async (symbol, strategyName, exchangeName, backtest, se
         self.params.logger.debug("ClientBreakeven waitForInit: skipping persist read in backtest mode");
         return;
     }
-    const breakevenData = await PersistBreakevenAdapter.readBreakevenData(symbol, strategyName, self.params.signalId, exchangeName);
+    const timestamp = await self.params.time.getTimestamp(symbol, {
+        strategyName,
+        exchangeName,
+        frameName,
+    }, self.params.backtest);
+    const breakevenData = await PersistBreakevenAdapter.readBreakevenData(symbol, strategyName, self.params.signalId, exchangeName, new Date(timestamp));
     for (const [signalId, data] of Object.entries(breakevenData)) {
         const state = {
             reached: data.reached,
@@ -28624,7 +28653,7 @@ class ClientBreakeven {
          * // Now check() can be called
          * ```
          */
-        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, backtest) => await WAIT_FOR_INIT_FN(symbol, strategyName, exchangeName, backtest, this));
+        this.waitForInit = singleshot(async (symbol, strategyName, exchangeName, frameName, backtest) => await WAIT_FOR_INIT_FN(symbol, strategyName, exchangeName, frameName, backtest, this));
     }
     /**
      * Persists current breakeven state to disk.
@@ -28641,7 +28670,7 @@ class ClientBreakeven {
      * @param signalId - Signal identifier
      * @returns Promise that resolves when persistence is complete
      */
-    async _persistState(symbol, strategyName, exchangeName, signalId) {
+    async _persistState(symbol, strategyName, exchangeName, frameName, signalId) {
         if (this.params.backtest) {
             return;
         }
@@ -28655,7 +28684,12 @@ class ClientBreakeven {
                 reached: state.reached,
             };
         }
-        await PersistBreakevenAdapter.writeBreakevenData(breakevenData, symbol, strategyName, signalId, exchangeName);
+        const timestamp = await this.params.time.getTimestamp(symbol, {
+            strategyName,
+            exchangeName,
+            frameName,
+        }, this.params.backtest);
+        await PersistBreakevenAdapter.writeBreakevenData(breakevenData, symbol, strategyName, signalId, exchangeName, new Date(timestamp));
     }
     /**
      * Checks if breakeven should be triggered and emits event if conditions met.
@@ -28746,7 +28780,7 @@ class ClientBreakeven {
             throw new Error(`Signal ID mismatch: expected ${this.params.signalId}, got ${data.id}`);
         }
         this._states.delete(data.id);
-        await this._persistState(symbol, data.strategyName, data.exchangeName, this.params.signalId);
+        await this._persistState(symbol, data.strategyName, data.exchangeName, data.frameName, this.params.signalId);
     }
 }
 
@@ -28835,6 +28869,7 @@ class BreakevenConnectionService {
          * Action core service injected from DI container.
          */
         this.actionCoreService = inject(TYPES.actionCoreService);
+        this.timeMetaService = inject(TYPES.timeMetaService);
         /**
          * Memoized factory function for ClientBreakeven instances.
          *
@@ -28848,6 +28883,7 @@ class BreakevenConnectionService {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
+                time: this.timeMetaService,
                 backtest,
                 onBreakeven: CREATE_COMMIT_BREAKEVEN_FN(this),
             });
@@ -28874,7 +28910,7 @@ class BreakevenConnectionService {
                 when,
             });
             const breakeven = this.getBreakeven(data.id, backtest);
-            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
+            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
             return await breakeven.check(symbol, data, currentPrice, backtest, when);
         };
         /**
@@ -28903,7 +28939,7 @@ class BreakevenConnectionService {
                 backtest,
             });
             const breakeven = this.getBreakeven(data.id, backtest);
-            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
+            await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, data.frameName, backtest);
             await breakeven.clear(symbol, data, priceClose, backtest);
             const key = CREATE_KEY_FN$i(data.id, backtest);
             this.getBreakeven.clear(key);
@@ -48500,7 +48536,7 @@ class RecentPersistBacktestUtils {
             backtest.loggerService.info(RECENT_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING, {
                 signalId: event.data.id,
             });
-            await PersistRecentAdapter.writeRecentData(event.data, event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest);
+            await PersistRecentAdapter.writeRecentData(event.data, event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest, new Date(event.data.timestamp));
         };
         /**
          * Retrieves the latest persisted signal for the given context.
@@ -48637,7 +48673,7 @@ class RecentPersistLiveUtils {
             backtest.loggerService.info(RECENT_PERSIST_LIVE_METHOD_NAME_HANDLE_ACTIVE_PING, {
                 signalId: event.data.id,
             });
-            await PersistRecentAdapter.writeRecentData(event.data, event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest);
+            await PersistRecentAdapter.writeRecentData(event.data, event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest, new Date(event.data.timestamp));
         };
         /**
          * Retrieves the latest persisted signal for the given context.
@@ -49292,7 +49328,7 @@ class StatePersistInstance {
             }
             this._when = when.getTime();
             const id = CREATE_KEY_FN$6(this.signalId, this.bucketName);
-            await PersistStateAdapter.writeStateData({ id, data: this._value, when: this._when }, this.signalId, this.bucketName);
+            await PersistStateAdapter.writeStateData({ id, data: this._value, when: this._when }, this.signalId, this.bucketName, when);
             return this._value;
         });
     }
@@ -50101,7 +50137,7 @@ class SessionPersistInstance {
             this._data = value;
             this._when = when.getTime();
             const id = CREATE_KEY_FN$5(this.symbol, this.strategyName, this.exchangeName, this.frameName, this.backtest);
-            await PersistSessionAdapter.writeSessionData({ id, data: value, when: this._when }, this.strategyName, this.exchangeName, this.frameName);
+            await PersistSessionAdapter.writeSessionData({ id, data: value, when: this._when }, this.strategyName, this.exchangeName, this.frameName, when);
         };
     }
     /** Releases resources held by this instance. */
@@ -50885,7 +50921,7 @@ class MemoryPersistInstance {
         });
         const priority = Date.now();
         const whenMs = when.getTime();
-        await PersistMemoryAdapter.writeMemoryData({ data: value, priority, removed: false, index, when: whenMs }, this.signalId, this.bucketName, memoryId);
+        await PersistMemoryAdapter.writeMemoryData({ data: value, priority, removed: false, index, when: whenMs }, this.signalId, this.bucketName, memoryId, when);
         this._index.upsert({
             id: memoryId,
             content: value,