backtest-kit 9.0.1 → 9.0.2

package/build/index.cjs

@@ -3581,7 +3581,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);
     }
     /**
@@ -3646,7 +3646,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
@@ -3739,19 +3739,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.
@@ -3915,7 +3916,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);
     }
 }
@@ -3943,7 +3944,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.
@@ -3990,21 +3991,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);
         };
     }
     /**
@@ -4118,7 +4120,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);
     }
     /**
@@ -4151,7 +4153,7 @@ class PersistStateDummyInstance {
      * No-op write (discards state).
      * @returns Promise that resolves immediately
      */
-    async writeStateData(_data) { }
+    async writeStateData(_data, _when) { }
     /**
      * No-op dispose.
      */
@@ -4216,18 +4218,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).
@@ -4337,7 +4340,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);
     }
     /**
@@ -4370,7 +4373,7 @@ class PersistSessionDummyInstance {
      * No-op write (discards session data).
      * @returns Promise that resolves immediately
      */
-    async writeSessionData(_data) { }
+    async writeSessionData(_data, _when) { }
     /**
      * No-op dispose.
      */
@@ -4438,19 +4441,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).
@@ -48520,7 +48524,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.
@@ -48657,7 +48661,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.
@@ -49312,7 +49316,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;
         });
     }
@@ -50121,7 +50125,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. */
@@ -50905,7 +50909,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,

package/build/index.mjs

@@ -3561,7 +3561,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 +3626,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 +3719,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 +3896,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 +3924,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 +3971,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 +4100,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 +4133,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 +4198,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 +4320,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 +4353,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 +4421,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).
@@ -48500,7 +48504,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 +48641,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 +49296,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 +50105,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 +50889,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "9.0.1",
+  "version": "9.0.2",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",

package/types.d.ts

@@ -14964,11 +14964,12 @@ interface IPersistMemoryInstance {
     /**
      * Write a memory entry.
      *
-     * @param data - Entry data to persist
+     * @param data - Entry data to persist (already carries `data.when`)
      * @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
      */
-    writeMemoryData(data: MemoryData, memoryId: string): Promise<void>;
+    writeMemoryData(data: MemoryData, memoryId: string, when: Date): Promise<void>;
     /**
      * Soft-delete a memory entry. File stays on disk; subsequent reads return null.
      *
@@ -15049,7 +15050,7 @@ declare class PersistMemoryInstance implements IPersistMemoryInstance {
      * @param memoryId - Memory entry identifier
      * @returns Promise that resolves when write is complete
      */
-    writeMemoryData(data: MemoryData, memoryId: string): Promise<void>;
+    writeMemoryData(data: MemoryData, memoryId: string, _when: Date): Promise<void>;
     /**
      * Soft-deletes a memory entry by writing `removed: true` flag.
      *
@@ -15142,13 +15143,14 @@ declare 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
      */
-    writeMemoryData: (data: MemoryData, signalId: string, bucketName: string, memoryId: string) => Promise<void>;
+    writeMemoryData: (data: MemoryData, signalId: string, bucketName: string, memoryId: string, when: Date) => Promise<void>;
     /**
      * Soft-deletes a memory entry for the given context.
      * Lazily initializes the instance on first access.
@@ -15241,10 +15243,11 @@ interface IPersistRecentInstance {
     /**
      * Write the latest recent signal for this context.
      *
-     * @param signalRow - Recent signal data to persist
+     * @param signalRow - Recent signal data to persist (already carries `signalRow.timestamp`)
+     * @param when - Logical timestamp this signal belongs to (duplicates `signalRow.timestamp` for API consistency)
      * @returns Promise that resolves when write is complete
      */
-    writeRecentData(signalRow: IPublicSignalRow): Promise<void>;
+    writeRecentData(signalRow: IPublicSignalRow, when: Date): Promise<void>;
 }
 /**
  * Default file-based implementation of IPersistRecentInstance.
@@ -15299,7 +15302,7 @@ declare class PersistRecentInstance implements IPersistRecentInstance {
      * @param signalRow - Recent signal data to persist
      * @returns Promise that resolves when write is complete
      */
-    writeRecentData(signalRow: IPublicSignalRow): Promise<void>;
+    writeRecentData(signalRow: IPublicSignalRow, _when: Date): Promise<void>;
 }
 /**
  * Constructor type for IPersistRecentInstance.
@@ -15362,15 +15365,16 @@ declare 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
      */
-    writeRecentData: (signalRow: IPublicSignalRow, symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<void>;
+    writeRecentData: (signalRow: IPublicSignalRow, symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, when: Date) => Promise<void>;
     /**
      * Clears the memoized instance cache.
      * Call when process.cwd() changes between strategy iterations.
@@ -15424,10 +15428,11 @@ interface IPersistStateInstance {
     /**
      * Write state for this context.
      *
-     * @param data - State data to persist
+     * @param data - State data to persist (already carries `data.when`)
+     * @param when - Logical timestamp this value belongs to (duplicates `data.when` for API consistency)
      * @returns Promise that resolves when write is complete
      */
-    writeStateData(data: StateData): Promise<void>;
+    writeStateData(data: StateData, when: Date): Promise<void>;
     /**
      * Release any resources held by this instance.
      * Default implementations may treat this as a no-op.
@@ -15481,7 +15486,7 @@ declare class PersistStateInstance implements IPersistStateInstance {
      * @param data - State data to persist
      * @returns Promise that resolves when write is complete
      */
-    writeStateData(data: StateData): Promise<void>;
+    writeStateData(data: StateData, _when: Date): Promise<void>;
     /**
      * No-op for the default file-based implementation.
      * Resource cleanup (memo cache invalidation) is handled by PersistStateUtils.dispose().
@@ -15545,12 +15550,13 @@ declare 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
      */
-    writeStateData: (data: StateData, signalId: string, bucketName: string) => Promise<void>;
+    writeStateData: (data: StateData, signalId: string, bucketName: string, when: Date) => Promise<void>;
     /**
      * Switches to PersistStateDummyInstance (all operations are no-ops).
      */
@@ -15612,10 +15618,11 @@ interface IPersistSessionInstance {
     /**
      * Write session data for this context.
      *
-     * @param data - Session data to persist
+     * @param data - Session data to persist (already carries `data.when`)
+     * @param when - Logical timestamp this value belongs to (duplicates `data.when` for API consistency)
      * @returns Promise that resolves when write is complete
      */
-    writeSessionData(data: SessionData): Promise<void>;
+    writeSessionData(data: SessionData, when: Date): Promise<void>;
     /**
      * Release any resources held by this instance.
      * Default implementations may treat this as a no-op.
@@ -15671,7 +15678,7 @@ declare class PersistSessionInstance implements IPersistSessionInstance {
      * @param data - Session data to persist
      * @returns Promise that resolves when write is complete
      */
-    writeSessionData(data: SessionData): Promise<void>;
+    writeSessionData(data: SessionData, _when: Date): Promise<void>;
     /**
      * No-op for the default file-based implementation.
      * Resource cleanup (memo cache invalidation) is handled by PersistSessionUtils.dispose().
@@ -15738,13 +15745,14 @@ declare 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
      */
-    writeSessionData: (data: SessionData, strategyName: string, exchangeName: string, frameName: string) => Promise<void>;
+    writeSessionData: (data: SessionData, strategyName: string, exchangeName: string, frameName: string, when: Date) => Promise<void>;
     /**
      * Switches to PersistSessionDummyInstance (all operations are no-ops).
      */