backtest-kit 9.0.2 → 9.0.4

package/build/index.cjs

@@ -1458,7 +1458,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);
         }
@@ -1468,9 +1468,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);
     }
 }
@@ -1495,12 +1496,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.
@@ -1530,15 +1531,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.
@@ -1547,15 +1549,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);
         };
     }
     /**
@@ -1849,7 +1852,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);
         }
@@ -1860,9 +1863,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);
     }
 }
@@ -1885,12 +1889,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.
@@ -1923,15 +1927,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.
@@ -1942,15 +1947,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);
         };
     }
     /**
@@ -2049,7 +2055,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);
         }
@@ -2060,9 +2066,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);
     }
 }
@@ -2085,12 +2092,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.
@@ -2143,15 +2150,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.
@@ -2162,15 +2170,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);
         };
     }
     /**
@@ -14156,57 +14165,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 };
 /**
@@ -14332,7 +14294,7 @@ const CALL_ALLOWED_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, par
  *
  * 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,
     });
@@ -14340,7 +14302,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);
 };
 /**
@@ -14369,7 +14331,7 @@ class ClientRisk {
          * Uses singleshot pattern to ensure initialization happens exactly once.
          * Skips persistence in backtest mode.
          */
-        this.waitForInit = functoolsKit.singleshot(async () => await WAIT_FOR_INIT_FN$3(this));
+        this.waitForInit = functoolsKit.singleshot(async (when) => await WAIT_FOR_INIT_FN$3(when, this));
         /**
          * Checks if a signal should be allowed based on risk limits.
          *
@@ -14391,11 +14353,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),
@@ -14498,14 +14464,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.
@@ -14520,8 +14486,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;
@@ -14537,7 +14504,7 @@ class ClientRisk {
                 minuteEstimatedTime: positionData.minuteEstimatedTime,
                 openTimestamp: positionData.openTimestamp,
             });
-            await this._updatePositions();
+            await this._updatePositions(new Date(timestamp));
         }
         finally {
             await RISK_LOCK.releaseLock();
@@ -14555,13 +14522,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();
@@ -14661,7 +14629,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.
          */
@@ -14683,7 +14651,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),
@@ -19674,8 +19642,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,
@@ -19690,7 +19658,7 @@ const INTERVAL_MINUTES$5 = {
 };
 const createEmitter = functoolsKit.memoize(([interval]) => `${interval}`, (interval) => {
     const tickSubject = new functoolsKit.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;
         functoolsKit.Source.fromInterval(EMITTER_CHECK_INTERVAL)
@@ -19717,6 +19685,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.
  *
@@ -27215,7 +27223,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);
     }
 };
 /**
@@ -27265,7 +27273,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);
     }
 };
 /**
@@ -27282,7 +27290,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,
@@ -27298,7 +27306,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),
@@ -27406,7 +27419,7 @@ class ClientPartial {
          * // Now profit()/loss() can be called
          * ```
          */
-        this.waitForInit = functoolsKit.singleshot(async (symbol, strategyName, exchangeName, backtest) => await WAIT_FOR_INIT_FN$1(symbol, strategyName, exchangeName, backtest, this));
+        this.waitForInit = functoolsKit.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.
@@ -27424,7 +27437,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;
         }
@@ -27439,7 +27452,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.
@@ -27564,7 +27582,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);
     }
 }
 
@@ -27689,6 +27707,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.
          *
@@ -27702,6 +27721,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),
@@ -27731,7 +27751,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);
         };
         /**
@@ -27758,7 +27778,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);
         };
         /**
@@ -27786,7 +27806,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);
@@ -28512,7 +28532,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;
 };
 /**
@@ -28527,7 +28547,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,
@@ -28543,7 +28563,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,
@@ -28648,7 +28673,7 @@ class ClientBreakeven {
          * // Now check() can be called
          * ```
          */
-        this.waitForInit = functoolsKit.singleshot(async (symbol, strategyName, exchangeName, backtest) => await WAIT_FOR_INIT_FN(symbol, strategyName, exchangeName, backtest, this));
+        this.waitForInit = functoolsKit.singleshot(async (symbol, strategyName, exchangeName, frameName, backtest) => await WAIT_FOR_INIT_FN(symbol, strategyName, exchangeName, frameName, backtest, this));
     }
     /**
      * Persists current breakeven state to disk.
@@ -28665,7 +28690,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;
         }
@@ -28679,7 +28704,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.
@@ -28770,7 +28800,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);
     }
 }
 
@@ -28859,6 +28889,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.
          *
@@ -28872,6 +28903,7 @@ class BreakevenConnectionService {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
+                time: this.timeMetaService,
                 backtest,
                 onBreakeven: CREATE_COMMIT_BREAKEVEN_FN(this),
             });
@@ -28898,7 +28930,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);
         };
         /**
@@ -28927,7 +28959,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);
@@ -36540,6 +36572,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 functoolsKit.sleep(SECOND_DELAY);
+            continue;
+        }
+        if (!exchangeList.length) {
+            backtest.loggerService.debug(WAIT_FOR_READY_METHOD_NAME, {
+                reason: "no exchanges registered",
+                attempt: i + 1,
+            });
+            await functoolsKit.sleep(SECOND_DELAY);
+            continue;
+        }
+        if (!strategyList.length) {
+            backtest.loggerService.debug(WAIT_FOR_READY_METHOD_NAME, {
+                reason: "no strategies registered",
+                attempt: i + 1,
+            });
+            await functoolsKit.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";
@@ -63825,5 +63931,6 @@ exports.validatePendingSignal = validatePendingSignal;
 exports.validateScheduledSignal = validateScheduledSignal;
 exports.validateSignal = validateSignal;
 exports.waitForCandle = waitForCandle;
+exports.waitForReady = waitForReady;
 exports.warmCandles = warmCandles;
 exports.writeMemory = writeMemory;