backtest-kit 10.2.0 → 11.2.0

package/build/index.cjs

@@ -818,6 +818,13 @@ const beforeStartSubject = new functoolsKit.Subject();
  * Emits when the engine has completed processing a signal.
  */
 const afterEndSubject = new functoolsKit.Subject();
+/**
+ * Emitter for `@backtest-kit/cli`, which notifies the application
+ * that all modules have been initialized.
+ *
+ * Send entry absolute path to the consumer
+ */
+const entrySubject = new functoolsKit.BehaviorSubject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -829,6 +836,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     doneBacktestSubject: doneBacktestSubject,
     doneLiveSubject: doneLiveSubject,
     doneWalkerSubject: doneWalkerSubject,
+    entrySubject: entrySubject,
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
     highestProfitSubject: highestProfitSubject,
@@ -6584,7 +6592,7 @@ const INTERVAL_MINUTES$8 = {
  * Used to indicate that the actual pendingAt will be set upon activation.
  */
 const SCHEDULED_SIGNAL_PENDING_MOCK = 0;
-const TIMEOUT_SYMBOL = Symbol('timeout');
+const TIMEOUT_SYMBOL$1 = Symbol('timeout');
 /**
  * Calls onSignalSync callback for signal-open event.
  *
@@ -7006,7 +7014,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
     const signal = await Promise.race([
         self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
-        functoolsKit.sleep(timeoutMs).then(() => TIMEOUT_SYMBOL),
+        functoolsKit.sleep(timeoutMs).then(() => TIMEOUT_SYMBOL$1),
     ]);
     if (typeof signal === "symbol") {
         throw new Error(`Timeout for ${self.params.method.context.strategyName} symbol=${self.params.execution.context.symbol}`);
@@ -37581,8 +37589,9 @@ function getActionSchema(actionName) {
 }
 
 const WAIT_FOR_READY_METHOD_NAME = "init.waitForReady";
-const MAX_WAIT_SECONDS = 10;
+const MAX_WAIT_SECONDS = 45;
 const SECOND_DELAY = 1000;
+const TIMEOUT_SYMBOL = Symbol('timeout');
 /**
  * Blocks until the schema registries needed to start trading are populated.
  *
@@ -37620,6 +37629,18 @@ const SECOND_DELAY = 1000;
  */
 async function waitForReady(isBacktest = true) {
     backtest.loggerService.info(WAIT_FOR_READY_METHOD_NAME, { isBacktest });
+    if (entrySubject.data) {
+        return;
+    }
+    if (entrySubject.hasListeners) {
+        backtest.loggerService.debug(`${WAIT_FOR_READY_METHOD_NAME} waiting for entrySubject`);
+        const result = await Promise.race([
+            entrySubject.toPromise(),
+            functoolsKit.sleep(MAX_WAIT_SECONDS * SECOND_DELAY).then(() => TIMEOUT_SYMBOL)
+        ]);
+        typeof result === "symbol" && console.log("waitForReady timeout");
+        return;
+    }
     for (let i = 0; i !== MAX_WAIT_SECONDS; i++) {
         const [exchangeList, frameList, strategyList] = await Promise.all([
             backtest.exchangeValidationService.list(),
@@ -37650,6 +37671,9 @@ async function waitForReady(isBacktest = true) {
             await functoolsKit.sleep(SECOND_DELAY);
             continue;
         }
+        if (i === MAX_WAIT_SECONDS - 1) {
+            console.log("waitForReady timeout");
+        }
         break;
     }
 }
@@ -63835,6 +63859,34 @@ class CronUtils {
          * on successful settle.
          */
         this._firedOnce = new Set();
+        /**
+         * Last interval boundary already fired per periodic slot.
+         *
+         * Key shape (no `alignedMs` segment — one entry per logical slot, not per
+         * boundary; always carries the generation suffix `:g${generation}`, and the
+         * `:${symbol}` scope only in fan-out mode):
+         * - Periodic global: `${name}${genSuffix}`.
+         * - Periodic fan-out: `${name}:${symbol}${genSuffix}`.
+         *
+         * Value is the aligned-boundary epoch ms (`alignedMs`) most recently opened
+         * for that slot. `_tick` fires a periodic entry whenever the incoming tick's
+         * aligned boundary is **strictly greater** than the stored value, instead of
+         * requiring the tick to land *exactly* on the boundary. This fixes the
+         * dropped-boundary bug: when virtual time jumps over a boundary (e.g. a
+         * `5m`-driven loop skipping from 00:14 to 00:29 never lands on the `15m`
+         * 00:15 boundary), the old `ts === alignedMs` check silently lost the tick.
+         * With the watermark, the next tick whose `alignedMs` advanced past the
+         * stored value fires once for the newest crossed boundary (catch-up
+         * collapses multiple skipped boundaries into a single invocation at the
+         * latest one).
+         *
+         * Written synchronously in `_tick` at slot-open time (before the `await`),
+         * so a still-in-flight handler does not let a later tick re-open the same
+         * (or an already-passed) boundary. Fire-once entries never touch this map —
+         * they use `_firedOnce`. Pruned by `_clearBoundaryFor` on
+         * `register`/`unregister` and wiped by `dispose`.
+         */
+        this._lastBoundary = new Map();
         /**
          * Register a periodic cron entry.
          *
@@ -63880,6 +63932,7 @@ class CronUtils {
                 }
             }
             this._clearFiredOnceFor(entry.name);
+            this._clearBoundaryFor(entry.name);
             const generation = ++this._generationCounter;
             this._entries.set(entry.name, { entry, generation });
             return () => this.unregister(entry.name);
@@ -63896,6 +63949,7 @@ class CronUtils {
             LOGGER_SERVICE$1.info(CRON_METHOD_NAME_UNREGISTER, { name });
             this._entries.delete(name);
             this._clearFiredOnceFor(name);
+            this._clearBoundaryFor(name);
         };
         /**
          * Clear fire-once marks so that fire-once entries can fire again.
@@ -63972,11 +64026,24 @@ class CronUtils {
          *    - Slot key: `${name}:once` (+ scope) (+ gen).
          *    - `aligned` = the 1-minute-aligned `when` from step 0.
          * 5. **Periodic** (`entry.interval` set):
-         *    - Align `when` further to the entry's interval via {@link alignToInterval}.
-         *    - If `ts !== alignedMs`, the tick is mid-interval — skip.
-         *      (This is the "remainder === 0" boundary check from the spec;
-         *      since `ts` is already on the 1-minute boundary, the check is exact
-         *      for `1m` and consistent for higher intervals.)
+         *    - Align `when` to the entry's interval via {@link alignToInterval} to
+         *      get `alignedMs`, the boundary this tick belongs to.
+         *    - Compare against the slot's watermark in `_lastBoundary` (keyed by
+         *      `${name}` + scope + gen, without the `alignedMs` segment). If a
+         *      watermark exists and `alignedMs <= lastBoundary`, this boundary was
+         *      already fired — skip.
+         *    - This **watermark** check replaces the old exact `ts === alignedMs`
+         *      match. The exact match required virtual time to land *precisely* on
+         *      the boundary; when a tick jumped clean over a boundary (e.g. a `5m`
+         *      loop going 00:14 → 00:29 never touching the `15m` 00:15 boundary)
+         *      the boundary was silently lost. With the watermark, the first tick
+         *      whose `alignedMs` advanced past the stored value fires once, at the
+         *      newest crossed boundary (catch-up collapses several skipped
+         *      boundaries into a single invocation at the latest one).
+         *    - The watermark is advanced to `alignedMs` synchronously when the slot
+         *      is opened (before the `await`), so a concurrent tick on the same or
+         *      an already-passed boundary cannot open a duplicate slot while the
+         *      handler is still in flight.
          *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
          * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
          *    already exists, `await` the same promise. Otherwise invoke
@@ -64025,6 +64092,9 @@ class CronUtils {
                 let alignedMs;
                 let slotKey;
                 let firedKey;
+                // Periodic-only watermark key (no `alignedMs` segment); null for
+                // fire-once entries, which coordinate via `_firedOnce` instead.
+                let boundaryKey;
                 if (entry.interval === undefined) {
                     const onceKey = `${entry.name}${scope}${genSuffix}`;
                     if (this._firedOnce.has(onceKey)) {
@@ -64034,11 +64104,18 @@ class CronUtils {
                     alignedMs = ts;
                     slotKey = `${entry.name}:once${scope}${genSuffix}`;
                     firedKey = onceKey;
+                    boundaryKey = null;
                 }
                 else {
                     aligned = alignToInterval(when, entry.interval);
                     alignedMs = aligned.getTime();
-                    if (ts !== alignedMs) {
+                    boundaryKey = `${entry.name}${scope}${genSuffix}`;
+                    const lastBoundary = this._lastBoundary.get(boundaryKey);
+                    // Fire when the tick's aligned boundary has advanced past the last one
+                    // we fired for this slot. Using `>` instead of the old `ts === alignedMs`
+                    // means a virtual-time jump that skips clean over a boundary still
+                    // fires once, at the newest crossed boundary, rather than dropping it.
+                    if (lastBoundary !== undefined && alignedMs <= lastBoundary) {
                         continue;
                     }
                     slotKey = `${entry.name}:${alignedMs}${scope}${genSuffix}`;
@@ -64046,6 +64123,13 @@ class CronUtils {
                 }
                 let pending = this._inFlight.get(slotKey);
                 if (!pending) {
+                    // Advance the watermark synchronously at slot-open time, before the
+                    // await below. Otherwise a later tick on the same (or an already
+                    // crossed) boundary, arriving while this handler is still in flight,
+                    // would see the stale watermark and open a duplicate slot.
+                    if (boundaryKey !== null) {
+                        this._lastBoundary.set(boundaryKey, alignedMs);
+                    }
                     pending = this._runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest);
                     this._inFlight.set(slotKey, pending);
                 }
@@ -64137,7 +64221,10 @@ class CronUtils {
          * 3. Wipes `_firedOnce` — all fire-once marks are dropped, so any future
          *    re-registration of the same `name` fires again on the next matching
          *    tick.
-         * 4. Does **not** touch `_inFlight` — in-flight handlers continue to
+         * 4. Wipes `_lastBoundary` — all periodic watermarks are dropped, so a
+         *    re-registered periodic entry starts firing from its next crossed
+         *    boundary again.
+         * 5. Does **not** touch `_inFlight` — in-flight handlers continue to
          *    settle in the background and clear their own slots via `.finally()`.
          *    Their final `_firedOnce.add(firedKey)` writes carry old-generation
          *    keys and are harmless (lookup uses the post-dispose generation).
@@ -64156,8 +64243,29 @@ class CronUtils {
             this.disable();
             this._entries.clear();
             this._firedOnce.clear();
+            this._lastBoundary.clear();
         };
     }
+    /**
+     * Garbage-collect every `_lastBoundary` key that belongs to the entry `name`
+     * (any generation, global or fan-out).
+     *
+     * Called from `register`/`unregister` alongside `_clearFiredOnceFor`. Like
+     * that helper this is memory hygiene, not correctness — the generation suffix
+     * already isolates re-registrations, so a stale watermark from an old
+     * generation can never gate a new entry.
+     */
+    _clearBoundaryFor(name) {
+        if (!name) {
+            return;
+        }
+        const prefix = `${name}:`;
+        for (const key of this._lastBoundary.keys()) {
+            if (key === name || key.startsWith(prefix)) {
+                this._lastBoundary.delete(key);
+            }
+        }
+    }
     /**
      * Garbage-collect every `_firedOnce` key that belongs to the entry `name`
      * (any generation, global or fan-out).

package/build/index.mjs

@@ -1,7 +1,7 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
 import { singleton } from 'di-singleton';
-import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, errorData, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, Source, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, BehaviorSubject, waitForNext, singlerun } from 'functools-kit';
+import { Subject, BehaviorSubject, makeExtendable, singleshot, getErrorMessage, memoize, not, errorData, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, Source, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$2, compose, waitForNext, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
 import fs__default from 'fs/promises';
 import path, { join, dirname } from 'path';
@@ -798,6 +798,13 @@ const beforeStartSubject = new Subject();
  * Emits when the engine has completed processing a signal.
  */
 const afterEndSubject = new Subject();
+/**
+ * Emitter for `@backtest-kit/cli`, which notifies the application
+ * that all modules have been initialized.
+ *
+ * Send entry absolute path to the consumer
+ */
+const entrySubject = new BehaviorSubject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -809,6 +816,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     doneBacktestSubject: doneBacktestSubject,
     doneLiveSubject: doneLiveSubject,
     doneWalkerSubject: doneWalkerSubject,
+    entrySubject: entrySubject,
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
     highestProfitSubject: highestProfitSubject,
@@ -6564,7 +6572,7 @@ const INTERVAL_MINUTES$8 = {
  * Used to indicate that the actual pendingAt will be set upon activation.
  */
 const SCHEDULED_SIGNAL_PENDING_MOCK = 0;
-const TIMEOUT_SYMBOL = Symbol('timeout');
+const TIMEOUT_SYMBOL$1 = Symbol('timeout');
 /**
  * Calls onSignalSync callback for signal-open event.
  *
@@ -6986,7 +6994,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
     const signal = await Promise.race([
         self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
-        sleep(timeoutMs).then(() => TIMEOUT_SYMBOL),
+        sleep(timeoutMs).then(() => TIMEOUT_SYMBOL$1),
     ]);
     if (typeof signal === "symbol") {
         throw new Error(`Timeout for ${self.params.method.context.strategyName} symbol=${self.params.execution.context.symbol}`);
@@ -23252,7 +23260,7 @@ class MarkdownFileBase {
             timestamp: getContextTimestamp(),
         }) + "\n";
         const status = await this[WRITE_SAFE_SYMBOL$1](line);
-        if (status === TIMEOUT_SYMBOL$1) {
+        if (status === TIMEOUT_SYMBOL$2) {
             throw new Error(`Timeout writing to markdown ${this.markdownName}`);
         }
     }
@@ -23545,7 +23553,7 @@ class ReportBase {
             timestamp: getContextTimestamp(),
         }) + "\n";
         const status = await this[WRITE_SAFE_SYMBOL$1](line);
-        if (status === TIMEOUT_SYMBOL$1) {
+        if (status === TIMEOUT_SYMBOL$2) {
             throw new Error(`Timeout writing to report ${this.reportName}`);
         }
     }
@@ -37561,8 +37569,9 @@ function getActionSchema(actionName) {
 }
 
 const WAIT_FOR_READY_METHOD_NAME = "init.waitForReady";
-const MAX_WAIT_SECONDS = 10;
+const MAX_WAIT_SECONDS = 45;
 const SECOND_DELAY = 1000;
+const TIMEOUT_SYMBOL = Symbol('timeout');
 /**
  * Blocks until the schema registries needed to start trading are populated.
  *
@@ -37600,6 +37609,18 @@ const SECOND_DELAY = 1000;
  */
 async function waitForReady(isBacktest = true) {
     backtest.loggerService.info(WAIT_FOR_READY_METHOD_NAME, { isBacktest });
+    if (entrySubject.data) {
+        return;
+    }
+    if (entrySubject.hasListeners) {
+        backtest.loggerService.debug(`${WAIT_FOR_READY_METHOD_NAME} waiting for entrySubject`);
+        const result = await Promise.race([
+            entrySubject.toPromise(),
+            sleep(MAX_WAIT_SECONDS * SECOND_DELAY).then(() => TIMEOUT_SYMBOL)
+        ]);
+        typeof result === "symbol" && console.log("waitForReady timeout");
+        return;
+    }
     for (let i = 0; i !== MAX_WAIT_SECONDS; i++) {
         const [exchangeList, frameList, strategyList] = await Promise.all([
             backtest.exchangeValidationService.list(),
@@ -37630,6 +37651,9 @@ async function waitForReady(isBacktest = true) {
             await sleep(SECOND_DELAY);
             continue;
         }
+        if (i === MAX_WAIT_SECONDS - 1) {
+            console.log("waitForReady timeout");
+        }
         break;
     }
 }
@@ -55421,7 +55445,7 @@ class LogJsonlUtils {
             await this[WAIT_FOR_INIT_SYMBOL]();
             const line = JSON.stringify(entry) + "\n";
             const status = await this[WRITE_SAFE_SYMBOL](line);
-            if (status === TIMEOUT_SYMBOL$1) {
+            if (status === TIMEOUT_SYMBOL$2) {
                 throw new Error(`LogJsonlUtils timeout writing to file=${this._filePath}`);
             }
         };
@@ -63815,6 +63839,34 @@ class CronUtils {
          * on successful settle.
          */
         this._firedOnce = new Set();
+        /**
+         * Last interval boundary already fired per periodic slot.
+         *
+         * Key shape (no `alignedMs` segment — one entry per logical slot, not per
+         * boundary; always carries the generation suffix `:g${generation}`, and the
+         * `:${symbol}` scope only in fan-out mode):
+         * - Periodic global: `${name}${genSuffix}`.
+         * - Periodic fan-out: `${name}:${symbol}${genSuffix}`.
+         *
+         * Value is the aligned-boundary epoch ms (`alignedMs`) most recently opened
+         * for that slot. `_tick` fires a periodic entry whenever the incoming tick's
+         * aligned boundary is **strictly greater** than the stored value, instead of
+         * requiring the tick to land *exactly* on the boundary. This fixes the
+         * dropped-boundary bug: when virtual time jumps over a boundary (e.g. a
+         * `5m`-driven loop skipping from 00:14 to 00:29 never lands on the `15m`
+         * 00:15 boundary), the old `ts === alignedMs` check silently lost the tick.
+         * With the watermark, the next tick whose `alignedMs` advanced past the
+         * stored value fires once for the newest crossed boundary (catch-up
+         * collapses multiple skipped boundaries into a single invocation at the
+         * latest one).
+         *
+         * Written synchronously in `_tick` at slot-open time (before the `await`),
+         * so a still-in-flight handler does not let a later tick re-open the same
+         * (or an already-passed) boundary. Fire-once entries never touch this map —
+         * they use `_firedOnce`. Pruned by `_clearBoundaryFor` on
+         * `register`/`unregister` and wiped by `dispose`.
+         */
+        this._lastBoundary = new Map();
         /**
          * Register a periodic cron entry.
          *
@@ -63860,6 +63912,7 @@ class CronUtils {
                 }
             }
             this._clearFiredOnceFor(entry.name);
+            this._clearBoundaryFor(entry.name);
             const generation = ++this._generationCounter;
             this._entries.set(entry.name, { entry, generation });
             return () => this.unregister(entry.name);
@@ -63876,6 +63929,7 @@ class CronUtils {
             LOGGER_SERVICE$1.info(CRON_METHOD_NAME_UNREGISTER, { name });
             this._entries.delete(name);
             this._clearFiredOnceFor(name);
+            this._clearBoundaryFor(name);
         };
         /**
          * Clear fire-once marks so that fire-once entries can fire again.
@@ -63952,11 +64006,24 @@ class CronUtils {
          *    - Slot key: `${name}:once` (+ scope) (+ gen).
          *    - `aligned` = the 1-minute-aligned `when` from step 0.
          * 5. **Periodic** (`entry.interval` set):
-         *    - Align `when` further to the entry's interval via {@link alignToInterval}.
-         *    - If `ts !== alignedMs`, the tick is mid-interval — skip.
-         *      (This is the "remainder === 0" boundary check from the spec;
-         *      since `ts` is already on the 1-minute boundary, the check is exact
-         *      for `1m` and consistent for higher intervals.)
+         *    - Align `when` to the entry's interval via {@link alignToInterval} to
+         *      get `alignedMs`, the boundary this tick belongs to.
+         *    - Compare against the slot's watermark in `_lastBoundary` (keyed by
+         *      `${name}` + scope + gen, without the `alignedMs` segment). If a
+         *      watermark exists and `alignedMs <= lastBoundary`, this boundary was
+         *      already fired — skip.
+         *    - This **watermark** check replaces the old exact `ts === alignedMs`
+         *      match. The exact match required virtual time to land *precisely* on
+         *      the boundary; when a tick jumped clean over a boundary (e.g. a `5m`
+         *      loop going 00:14 → 00:29 never touching the `15m` 00:15 boundary)
+         *      the boundary was silently lost. With the watermark, the first tick
+         *      whose `alignedMs` advanced past the stored value fires once, at the
+         *      newest crossed boundary (catch-up collapses several skipped
+         *      boundaries into a single invocation at the latest one).
+         *    - The watermark is advanced to `alignedMs` synchronously when the slot
+         *      is opened (before the `await`), so a concurrent tick on the same or
+         *      an already-passed boundary cannot open a duplicate slot while the
+         *      handler is still in flight.
          *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
          * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
          *    already exists, `await` the same promise. Otherwise invoke
@@ -64005,6 +64072,9 @@ class CronUtils {
                 let alignedMs;
                 let slotKey;
                 let firedKey;
+                // Periodic-only watermark key (no `alignedMs` segment); null for
+                // fire-once entries, which coordinate via `_firedOnce` instead.
+                let boundaryKey;
                 if (entry.interval === undefined) {
                     const onceKey = `${entry.name}${scope}${genSuffix}`;
                     if (this._firedOnce.has(onceKey)) {
@@ -64014,11 +64084,18 @@ class CronUtils {
                     alignedMs = ts;
                     slotKey = `${entry.name}:once${scope}${genSuffix}`;
                     firedKey = onceKey;
+                    boundaryKey = null;
                 }
                 else {
                     aligned = alignToInterval(when, entry.interval);
                     alignedMs = aligned.getTime();
-                    if (ts !== alignedMs) {
+                    boundaryKey = `${entry.name}${scope}${genSuffix}`;
+                    const lastBoundary = this._lastBoundary.get(boundaryKey);
+                    // Fire when the tick's aligned boundary has advanced past the last one
+                    // we fired for this slot. Using `>` instead of the old `ts === alignedMs`
+                    // means a virtual-time jump that skips clean over a boundary still
+                    // fires once, at the newest crossed boundary, rather than dropping it.
+                    if (lastBoundary !== undefined && alignedMs <= lastBoundary) {
                         continue;
                     }
                     slotKey = `${entry.name}:${alignedMs}${scope}${genSuffix}`;
@@ -64026,6 +64103,13 @@ class CronUtils {
                 }
                 let pending = this._inFlight.get(slotKey);
                 if (!pending) {
+                    // Advance the watermark synchronously at slot-open time, before the
+                    // await below. Otherwise a later tick on the same (or an already
+                    // crossed) boundary, arriving while this handler is still in flight,
+                    // would see the stale watermark and open a duplicate slot.
+                    if (boundaryKey !== null) {
+                        this._lastBoundary.set(boundaryKey, alignedMs);
+                    }
                     pending = this._runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest);
                     this._inFlight.set(slotKey, pending);
                 }
@@ -64117,7 +64201,10 @@ class CronUtils {
          * 3. Wipes `_firedOnce` — all fire-once marks are dropped, so any future
          *    re-registration of the same `name` fires again on the next matching
          *    tick.
-         * 4. Does **not** touch `_inFlight` — in-flight handlers continue to
+         * 4. Wipes `_lastBoundary` — all periodic watermarks are dropped, so a
+         *    re-registered periodic entry starts firing from its next crossed
+         *    boundary again.
+         * 5. Does **not** touch `_inFlight` — in-flight handlers continue to
          *    settle in the background and clear their own slots via `.finally()`.
          *    Their final `_firedOnce.add(firedKey)` writes carry old-generation
          *    keys and are harmless (lookup uses the post-dispose generation).
@@ -64136,8 +64223,29 @@ class CronUtils {
             this.disable();
             this._entries.clear();
             this._firedOnce.clear();
+            this._lastBoundary.clear();
         };
     }
+    /**
+     * Garbage-collect every `_lastBoundary` key that belongs to the entry `name`
+     * (any generation, global or fan-out).
+     *
+     * Called from `register`/`unregister` alongside `_clearFiredOnceFor`. Like
+     * that helper this is memory hygiene, not correctness — the generation suffix
+     * already isolates re-registrations, so a stale watermark from an old
+     * generation can never gate a new entry.
+     */
+    _clearBoundaryFor(name) {
+        if (!name) {
+            return;
+        }
+        const prefix = `${name}:`;
+        for (const key of this._lastBoundary.keys()) {
+            if (key === name || key.startsWith(prefix)) {
+                this._lastBoundary.delete(key);
+            }
+        }
+    }
     /**
      * Garbage-collect every `_firedOnce` key that belongs to the entry `name`
      * (any generation, global or fan-out).

package/package.json

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

package/types.d.ts

@@ -1,6 +1,6 @@
 import * as di_scoped from 'di-scoped';
 import * as functools_kit from 'functools-kit';
-import { Subject } from 'functools-kit';
+import { Subject, BehaviorSubject } from 'functools-kit';
 import { WriteStream } from 'fs';
 
 /**
@@ -26322,6 +26322,44 @@ declare class CronUtils {
      * on successful settle.
      */
     private readonly _firedOnce;
+    /**
+     * Last interval boundary already fired per periodic slot.
+     *
+     * Key shape (no `alignedMs` segment — one entry per logical slot, not per
+     * boundary; always carries the generation suffix `:g${generation}`, and the
+     * `:${symbol}` scope only in fan-out mode):
+     * - Periodic global: `${name}${genSuffix}`.
+     * - Periodic fan-out: `${name}:${symbol}${genSuffix}`.
+     *
+     * Value is the aligned-boundary epoch ms (`alignedMs`) most recently opened
+     * for that slot. `_tick` fires a periodic entry whenever the incoming tick's
+     * aligned boundary is **strictly greater** than the stored value, instead of
+     * requiring the tick to land *exactly* on the boundary. This fixes the
+     * dropped-boundary bug: when virtual time jumps over a boundary (e.g. a
+     * `5m`-driven loop skipping from 00:14 to 00:29 never lands on the `15m`
+     * 00:15 boundary), the old `ts === alignedMs` check silently lost the tick.
+     * With the watermark, the next tick whose `alignedMs` advanced past the
+     * stored value fires once for the newest crossed boundary (catch-up
+     * collapses multiple skipped boundaries into a single invocation at the
+     * latest one).
+     *
+     * Written synchronously in `_tick` at slot-open time (before the `await`),
+     * so a still-in-flight handler does not let a later tick re-open the same
+     * (or an already-passed) boundary. Fire-once entries never touch this map —
+     * they use `_firedOnce`. Pruned by `_clearBoundaryFor` on
+     * `register`/`unregister` and wiped by `dispose`.
+     */
+    private readonly _lastBoundary;
+    /**
+     * Garbage-collect every `_lastBoundary` key that belongs to the entry `name`
+     * (any generation, global or fan-out).
+     *
+     * Called from `register`/`unregister` alongside `_clearFiredOnceFor`. Like
+     * that helper this is memory hygiene, not correctness — the generation suffix
+     * already isolates re-registrations, so a stale watermark from an old
+     * generation can never gate a new entry.
+     */
+    private _clearBoundaryFor;
     /**
      * Garbage-collect every `_firedOnce` key that belongs to the entry `name`
      * (any generation, global or fan-out).
@@ -26443,11 +26481,24 @@ declare class CronUtils {
      *    - Slot key: `${name}:once` (+ scope) (+ gen).
      *    - `aligned` = the 1-minute-aligned `when` from step 0.
      * 5. **Periodic** (`entry.interval` set):
-     *    - Align `when` further to the entry's interval via {@link alignToInterval}.
-     *    - If `ts !== alignedMs`, the tick is mid-interval — skip.
-     *      (This is the "remainder === 0" boundary check from the spec;
-     *      since `ts` is already on the 1-minute boundary, the check is exact
-     *      for `1m` and consistent for higher intervals.)
+     *    - Align `when` to the entry's interval via {@link alignToInterval} to
+     *      get `alignedMs`, the boundary this tick belongs to.
+     *    - Compare against the slot's watermark in `_lastBoundary` (keyed by
+     *      `${name}` + scope + gen, without the `alignedMs` segment). If a
+     *      watermark exists and `alignedMs <= lastBoundary`, this boundary was
+     *      already fired — skip.
+     *    - This **watermark** check replaces the old exact `ts === alignedMs`
+     *      match. The exact match required virtual time to land *precisely* on
+     *      the boundary; when a tick jumped clean over a boundary (e.g. a `5m`
+     *      loop going 00:14 → 00:29 never touching the `15m` 00:15 boundary)
+     *      the boundary was silently lost. With the watermark, the first tick
+     *      whose `alignedMs` advanced past the stored value fires once, at the
+     *      newest crossed boundary (catch-up collapses several skipped
+     *      boundaries into a single invocation at the latest one).
+     *    - The watermark is advanced to `alignedMs` synchronously when the slot
+     *      is opened (before the `await`), so a concurrent tick on the same or
+     *      an already-passed boundary cannot open a duplicate slot while the
+     *      handler is still in flight.
      *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
      * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
      *    already exists, `await` the same promise. Otherwise invoke
@@ -26541,7 +26592,10 @@ declare class CronUtils {
      * 3. Wipes `_firedOnce` — all fire-once marks are dropped, so any future
      *    re-registration of the same `name` fires again on the next matching
      *    tick.
-     * 4. Does **not** touch `_inFlight` — in-flight handlers continue to
+     * 4. Wipes `_lastBoundary` — all periodic watermarks are dropped, so a
+     *    re-registered periodic entry starts firing from its next crossed
+     *    boundary again.
+     * 5. Does **not** touch `_inFlight` — in-flight handlers continue to
      *    settle in the background and clear their own slots via `.finally()`.
      *    Their final `_firedOnce.add(firedKey)` writes carry old-generation
      *    keys and are harmless (lookup uses the post-dispose generation).
@@ -29091,6 +29145,13 @@ declare const beforeStartSubject: Subject<BeforeStartContract>;
  * Emits when the engine has completed processing a signal.
  */
 declare const afterEndSubject: Subject<AfterEndContract>;
+/**
+ * Emitter for `@backtest-kit/cli`, which notifies the application
+ * that all modules have been initialized.
+ *
+ * Send entry absolute path to the consumer
+ */
+declare const entrySubject: BehaviorSubject<string>;
 
 declare const emitters_activePingSubject: typeof activePingSubject;
 declare const emitters_afterEndSubject: typeof afterEndSubject;
@@ -29100,6 +29161,7 @@ declare const emitters_breakevenSubject: typeof breakevenSubject;
 declare const emitters_doneBacktestSubject: typeof doneBacktestSubject;
 declare const emitters_doneLiveSubject: typeof doneLiveSubject;
 declare const emitters_doneWalkerSubject: typeof doneWalkerSubject;
+declare const emitters_entrySubject: typeof entrySubject;
 declare const emitters_errorEmitter: typeof errorEmitter;
 declare const emitters_exitEmitter: typeof exitEmitter;
 declare const emitters_highestProfitSubject: typeof highestProfitSubject;
@@ -29124,7 +29186,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_activePingSubject as activePingSubject, emitters_afterEndSubject as afterEndSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_beforeStartSubject as beforeStartSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_idlePingSubject as idlePingSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_signalNotifySubject as signalNotifySubject, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_activePingSubject as activePingSubject, emitters_afterEndSubject as afterEndSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_beforeStartSubject as beforeStartSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_entrySubject as entrySubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_idlePingSubject as idlePingSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_signalNotifySubject as signalNotifySubject, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**