backtest-kit 9.0.2 → 9.0.4

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);
         };
     }
     /**
@@ -14136,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 };
 /**
@@ -14312,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,
     });
@@ -14320,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);
 };
 /**
@@ -14349,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.
          *
@@ -14371,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),
@@ -14478,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.
@@ -14500,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;
@@ -14517,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();
@@ -14535,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();
@@ -14641,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.
          */
@@ -14663,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),
@@ -19654,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,
@@ -19670,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)
@@ -19697,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.
  *
@@ -27195,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);
     }
 };
 /**
@@ -27245,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);
     }
 };
 /**
@@ -27262,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,
@@ -27278,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),
@@ -27386,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.
@@ -27404,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;
         }
@@ -27419,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.
@@ -27544,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);
     }
 }
 
@@ -27669,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.
          *
@@ -27682,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),
@@ -27711,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);
         };
         /**
@@ -27738,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);
         };
         /**
@@ -27766,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);
@@ -28492,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;
 };
 /**
@@ -28507,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,
@@ -28523,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,
@@ -28628,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.
@@ -28645,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;
         }
@@ -28659,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.
@@ -28750,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);
     }
 }
 
@@ -28839,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.
          *
@@ -28852,6 +28883,7 @@ class BreakevenConnectionService {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
+                time: this.timeMetaService,
                 backtest,
                 onBreakeven: CREATE_COMMIT_BREAKEVEN_FN(this),
             });
@@ -28878,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);
         };
         /**
@@ -28907,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);
@@ -36520,6 +36552,80 @@ function getActionSchema(actionName) {
     return backtest.actionSchemaService.get(actionName);
 }
 
+const WAIT_FOR_READY_METHOD_NAME = "init.waitForReady";
+const MAX_WAIT_SECONDS = 10;
+const SECOND_DELAY = 1000;
+/**
+ * Blocks until the schema registries needed to start trading are populated.
+ *
+ * Polls `exchangeValidationService`, `frameValidationService` and
+ * `strategyValidationService` once per second for up to `MAX_WAIT_SECONDS`
+ * seconds. The loop exits as soon as the required registries are non-empty
+ * for the given mode:
+ *
+ * - Backtest mode (`isBacktest = true`): exchange, frame and strategy schemas
+ *   must all be registered (frames define the historical window).
+ * - Live mode (`isBacktest = false`): only exchange and strategy schemas are
+ *   required — frames are unused.
+ *
+ * Useful at startup when schemas are registered asynchronously (lazy imports,
+ * remote config, plugin loading) and the caller wants to delay `Backtest`/
+ * `Live` invocation until everything is ready. If the timeout elapses without
+ * the registries filling in, the function returns silently — the caller is
+ * expected to surface a clearer error from the subsequent `Backtest`/`Live`
+ * call (e.g. "no strategy registered").
+ *
+ * @param isBacktest - Whether to additionally require a registered frame schema. Defaults to `true`.
+ * @returns Promise that resolves when the registries are ready or the timeout elapses.
+ *
+ * @example
+ * ```typescript
+ * import { waitForReady, Backtest } from "backtest-kit";
+ *
+ * import "./schemas/exchange";
+ * import "./schemas/strategy";
+ * import "./schemas/frame";
+ *
+ * await waitForReady();
+ * Backtest.background("BTCUSDT", { strategyName, exchangeName, frameName });
+ * ```
+ */
+async function waitForReady(isBacktest = true) {
+    backtest.loggerService.info(WAIT_FOR_READY_METHOD_NAME, { isBacktest });
+    for (let i = 0; i !== MAX_WAIT_SECONDS; i++) {
+        const [exchangeList, frameList, strategyList] = await Promise.all([
+            backtest.exchangeValidationService.list(),
+            backtest.frameValidationService.list(),
+            backtest.strategyValidationService.list(),
+        ]);
+        if (isBacktest && !frameList.length) {
+            backtest.loggerService.debug(WAIT_FOR_READY_METHOD_NAME, {
+                reason: "no frames registered",
+                attempt: i + 1,
+            });
+            await sleep(SECOND_DELAY);
+            continue;
+        }
+        if (!exchangeList.length) {
+            backtest.loggerService.debug(WAIT_FOR_READY_METHOD_NAME, {
+                reason: "no exchanges registered",
+                attempt: i + 1,
+            });
+            await sleep(SECOND_DELAY);
+            continue;
+        }
+        if (!strategyList.length) {
+            backtest.loggerService.debug(WAIT_FOR_READY_METHOD_NAME, {
+                reason: "no strategies registered",
+                attempt: i + 1,
+            });
+            await sleep(SECOND_DELAY);
+            continue;
+        }
+        break;
+    }
+}
+
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
 const GET_CLOSE_PRICE_METHOD_NAME = "exchange.getClosePrice";
@@ -63523,4 +63629,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };