backtest-kit 1.1.8 → 1.1.9

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { memoize, makeExtendable, singleshot, getErrorMessage, not, trycatch, retry, Subject, randomString, errorData, ToolRegistry, sleep, str, queued } from 'functools-kit';
+import { memoize, makeExtendable, singleshot, getErrorMessage, not, trycatch, retry, Subject, randomString, errorData, ToolRegistry, isObject, sleep, resolveDocuments, str, queued } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -45,11 +45,16 @@ const connectionServices$1 = {
     exchangeConnectionService: Symbol('exchangeConnectionService'),
     strategyConnectionService: Symbol('strategyConnectionService'),
     frameConnectionService: Symbol('frameConnectionService'),
+    sizingConnectionService: Symbol('sizingConnectionService'),
+    riskConnectionService: Symbol('riskConnectionService'),
 };
 const schemaServices$1 = {
     exchangeSchemaService: Symbol('exchangeSchemaService'),
     strategySchemaService: Symbol('strategySchemaService'),
     frameSchemaService: Symbol('frameSchemaService'),
+    walkerSchemaService: Symbol('walkerSchemaService'),
+    sizingSchemaService: Symbol('sizingSchemaService'),
+    riskSchemaService: Symbol('riskSchemaService'),
 };
 const globalServices$1 = {
     exchangeGlobalService: Symbol('exchangeGlobalService'),
@@ -57,24 +62,34 @@ const globalServices$1 = {
     frameGlobalService: Symbol('frameGlobalService'),
     liveGlobalService: Symbol('liveGlobalService'),
     backtestGlobalService: Symbol('backtestGlobalService'),
+    walkerGlobalService: Symbol('walkerGlobalService'),
+    sizingGlobalService: Symbol('sizingGlobalService'),
+    riskGlobalService: Symbol('riskGlobalService'),
 };
 const logicPrivateServices$1 = {
     backtestLogicPrivateService: Symbol('backtestLogicPrivateService'),
     liveLogicPrivateService: Symbol('liveLogicPrivateService'),
+    walkerLogicPrivateService: Symbol('walkerLogicPrivateService'),
 };
 const logicPublicServices$1 = {
     backtestLogicPublicService: Symbol('backtestLogicPublicService'),
     liveLogicPublicService: Symbol('liveLogicPublicService'),
+    walkerLogicPublicService: Symbol('walkerLogicPublicService'),
 };
 const markdownServices$1 = {
     backtestMarkdownService: Symbol('backtestMarkdownService'),
     liveMarkdownService: Symbol('liveMarkdownService'),
     performanceMarkdownService: Symbol('performanceMarkdownService'),
+    walkerMarkdownService: Symbol('walkerMarkdownService'),
+    heatMarkdownService: Symbol('heatMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
     strategyValidationService: Symbol('strategyValidationService'),
     frameValidationService: Symbol('frameValidationService'),
+    walkerValidationService: Symbol('walkerValidationService'),
+    sizingValidationService: Symbol('sizingValidationService'),
+    riskValidationService: Symbol('riskValidationService'),
 };
 const TYPES = {
     ...baseServices$1,
@@ -1101,6 +1116,102 @@ class PersistSignalUtils {
  * ```
  */
 const PersistSignalAdaper = new PersistSignalUtils();
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
+const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
+const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
+/**
+ * Utility class for managing risk active positions persistence.
+ *
+ * Features:
+ * - Memoized storage instances per risk profile
+ * - Custom adapter support
+ * - Atomic read/write operations for RiskData
+ * - Crash-safe position state management
+ *
+ * Used by ClientRisk for live mode persistence of active positions.
+ */
+class PersistRiskUtils {
+    constructor() {
+        this.PersistRiskFactory = PersistBase;
+        this.getRiskStorage = memoize(([riskName]) => `${riskName}`, (riskName) => Reflect.construct(this.PersistRiskFactory, [
+            riskName,
+            `./logs/data/risk/`,
+        ]));
+        /**
+         * Reads persisted active positions for a risk profile.
+         *
+         * Called by ClientRisk.waitForInit() to restore state.
+         * Returns empty Map if no positions exist.
+         *
+         * @param riskName - Risk profile identifier
+         * @returns Promise resolving to Map of active positions
+         */
+        this.readPositionData = async (riskName) => {
+            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            const isInitial = !this.getRiskStorage.has(riskName);
+            const stateStorage = this.getRiskStorage(riskName);
+            await stateStorage.waitForInit(isInitial);
+            const RISK_STORAGE_KEY = "positions";
+            if (await stateStorage.hasValue(RISK_STORAGE_KEY)) {
+                return await stateStorage.readValue(RISK_STORAGE_KEY);
+            }
+            return [];
+        };
+        /**
+         * Writes active positions to disk with atomic file writes.
+         *
+         * Called by ClientRisk after addSignal/removeSignal to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
+         *
+         * @param positions - Map of active positions
+         * @param riskName - Risk profile identifier
+         * @returns Promise that resolves when write is complete
+         */
+        this.writePositionData = async (riskRow, riskName) => {
+            backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            const isInitial = !this.getRiskStorage.has(riskName);
+            const stateStorage = this.getRiskStorage(riskName);
+            await stateStorage.waitForInit(isInitial);
+            const RISK_STORAGE_KEY = "positions";
+            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
+     * ```
+     */
+    usePersistRiskAdapter(Ctor) {
+        backtest$1.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        this.PersistRiskFactory = Ctor;
+    }
+}
+/**
+ * Global singleton instance of PersistRiskUtils.
+ * Used by ClientRisk for active positions persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
+ *
+ * // Read positions
+ * const positions = await PersistRiskAdapter.readPositionData("my-risk");
+ *
+ * // Write positions
+ * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
+ * ```
+ */
+const PersistRiskAdapter = new PersistRiskUtils();
 
 /**
  * Global signal emitter for all trading events (live + backtest).
@@ -1123,10 +1234,20 @@ const signalBacktestEmitter = new Subject();
  */
 const errorEmitter = new Subject();
 /**
- * Done emitter for background execution completion.
- * Emits when background tasks complete (Live.background, Backtest.background).
+ * Done emitter for live background execution completion.
+ * Emits when live background tasks complete (Live.background).
+ */
+const doneLiveSubject = new Subject();
+/**
+ * Done emitter for backtest background execution completion.
+ * Emits when backtest background tasks complete (Backtest.background).
+ */
+const doneBacktestSubject = new Subject();
+/**
+ * Done emitter for walker background execution completion.
+ * Emits when walker background tasks complete (Walker.background).
  */
-const doneEmitter = new Subject();
+const doneWalkerSubject = new Subject();
 /**
  * Progress emitter for backtest execution progress.
  * Emits progress updates during backtest execution.
@@ -1137,6 +1258,37 @@ const progressEmitter = new Subject();
  * Emits performance metrics for profiling and bottleneck detection.
  */
 const performanceEmitter = new Subject();
+/**
+ * Walker emitter for strategy comparison progress.
+ * Emits progress updates during walker execution (each strategy completion).
+ */
+const walkerEmitter = new Subject();
+/**
+ * Walker complete emitter for strategy comparison completion.
+ * Emits when all strategies have been tested and final results are available.
+ */
+const walkerCompleteSubject = new Subject();
+/**
+ * Validation emitter for risk validation errors.
+ * Emits when risk validation functions throw errors during signal checking.
+ */
+const validationSubject = new Subject();
+
+var emitters = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    doneBacktestSubject: doneBacktestSubject,
+    doneLiveSubject: doneLiveSubject,
+    doneWalkerSubject: doneWalkerSubject,
+    errorEmitter: errorEmitter,
+    performanceEmitter: performanceEmitter,
+    progressEmitter: progressEmitter,
+    signalBacktestEmitter: signalBacktestEmitter,
+    signalEmitter: signalEmitter,
+    signalLiveEmitter: signalLiveEmitter,
+    validationSubject: validationSubject,
+    walkerCompleteSubject: walkerCompleteSubject,
+    walkerEmitter: walkerEmitter
+});
 
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
@@ -1203,13 +1355,23 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         }
         self._lastSignalTimestamp = currentTime;
     }
+    const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+    if (await not(self.params.risk.checkSignal({
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        currentPrice,
+        timestamp: currentTime,
+    }))) {
+        return null;
+    }
     const signal = await self.params.getSignal(self.params.execution.context.symbol);
     if (!signal) {
         return null;
     }
     const signalRow = {
         id: randomString(),
-        priceOpen: await self.params.exchange.getAveragePrice(self.params.execution.context.symbol),
+        priceOpen: currentPrice,
         ...signal,
         symbol: self.params.execution.context.symbol,
         exchangeName: self.params.method.context.exchangeName,
@@ -1239,7 +1401,7 @@ const GET_AVG_PRICE_FN = (candles) => {
         ? candles.reduce((acc, c) => acc + c.close, 0) / candles.length
         : sumPriceVolume / totalVolume;
 };
-const WAIT_FOR_INIT_FN = async (self) => {
+const WAIT_FOR_INIT_FN$1 = async (self) => {
     self.params.logger.debug("ClientStrategy waitForInit");
     if (self.params.execution.context.backtest) {
         return;
@@ -1298,7 +1460,7 @@ class ClientStrategy {
          *
          * @returns Promise that resolves when initialization is complete
          */
-        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN(this));
+        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN$1(this));
     }
     /**
      * Updates pending signal and persists to disk in live mode.
@@ -1348,6 +1510,11 @@ class ClientStrategy {
             const pendingSignal = await GET_SIGNAL_FN(this);
             await this.setPendingSignal(pendingSignal);
             if (this._pendingSignal) {
+                // Register signal with risk management
+                await this.params.risk.addSignal(this.params.execution.context.symbol, {
+                    strategyName: this.params.method.context.strategyName,
+                    riskName: this.params.riskName,
+                });
                 if (this.params.callbacks?.onOpen) {
                     this.params.callbacks.onOpen(this.params.execution.context.symbol, this._pendingSignal, this._pendingSignal.priceOpen, this.params.execution.context.backtest);
                 }
@@ -1356,6 +1523,7 @@ class ClientStrategy {
                     signal: this._pendingSignal,
                     strategyName: this.params.method.context.strategyName,
                     exchangeName: this.params.method.context.exchangeName,
+                    symbol: this.params.execution.context.symbol,
                     currentPrice: this._pendingSignal.priceOpen,
                 };
                 if (this.params.callbacks?.onTick) {
@@ -1372,6 +1540,7 @@ class ClientStrategy {
                 signal: null,
                 strategyName: this.params.method.context.strategyName,
                 exchangeName: this.params.method.context.exchangeName,
+                symbol: this.params.execution.context.symbol,
                 currentPrice,
             };
             if (this.params.callbacks?.onTick) {
@@ -1442,6 +1611,11 @@ class ClientStrategy {
             if (this.params.callbacks?.onClose) {
                 this.params.callbacks.onClose(this.params.execution.context.symbol, signal, averagePrice, this.params.execution.context.backtest);
             }
+            // Remove signal from risk management
+            await this.params.risk.removeSignal(this.params.execution.context.symbol, {
+                strategyName: this.params.method.context.strategyName,
+                riskName: this.params.riskName,
+            });
             await this.setPendingSignal(null);
             const result = {
                 action: "closed",
@@ -1452,6 +1626,7 @@ class ClientStrategy {
                 pnl: pnl,
                 strategyName: this.params.method.context.strategyName,
                 exchangeName: this.params.method.context.exchangeName,
+                symbol: this.params.execution.context.symbol,
             };
             if (this.params.callbacks?.onTick) {
                 this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
@@ -1467,6 +1642,7 @@ class ClientStrategy {
             currentPrice: averagePrice,
             strategyName: this.params.method.context.strategyName,
             exchangeName: this.params.method.context.exchangeName,
+            symbol: this.params.execution.context.symbol,
         };
         if (this.params.callbacks?.onTick) {
             this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
@@ -1557,6 +1733,11 @@ class ClientStrategy {
                 if (this.params.callbacks?.onClose) {
                     this.params.callbacks.onClose(this.params.execution.context.symbol, signal, averagePrice, this.params.execution.context.backtest);
                 }
+                // Remove signal from risk management
+                await this.params.risk.removeSignal(this.params.execution.context.symbol, {
+                    strategyName: this.params.method.context.strategyName,
+                    riskName: this.params.riskName,
+                });
                 await this.setPendingSignal(null);
                 const result = {
                     action: "closed",
@@ -1567,6 +1748,7 @@ class ClientStrategy {
                     pnl: pnl,
                     strategyName: this.params.method.context.strategyName,
                     exchangeName: this.params.method.context.exchangeName,
+                    symbol: this.params.execution.context.symbol,
                 };
                 if (this.params.callbacks?.onTick) {
                     this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
@@ -1593,6 +1775,11 @@ class ClientStrategy {
         if (this.params.callbacks?.onClose) {
             this.params.callbacks.onClose(this.params.execution.context.symbol, signal, lastPrice, this.params.execution.context.backtest);
         }
+        // Remove signal from risk management
+        await this.params.risk.removeSignal(this.params.execution.context.symbol, {
+            strategyName: this.params.method.context.strategyName,
+            riskName: this.params.riskName,
+        });
         await this.setPendingSignal(null);
         const result = {
             action: "closed",
@@ -1603,6 +1790,7 @@ class ClientStrategy {
             pnl: pnl,
             strategyName: this.params.method.context.strategyName,
             exchangeName: this.params.method.context.exchangeName,
+            symbol: this.params.execution.context.symbol,
         };
         if (this.params.callbacks?.onTick) {
             this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
@@ -1635,6 +1823,11 @@ class ClientStrategy {
     }
 }
 
+const NOOP_RISK = {
+    checkSignal: () => Promise.resolve(true),
+    addSignal: () => Promise.resolve(),
+    removeSignal: () => Promise.resolve(),
+};
 /**
  * Connection service routing strategy operations to correct ClientStrategy instance.
  *
@@ -1661,6 +1854,7 @@ class StrategyConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.executionContextService = inject(TYPES.executionContextService);
         this.strategySchemaService = inject(TYPES.strategySchemaService);
+        this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
         this.methodContextService = inject(TYPES.methodContextService);
         /**
@@ -1673,13 +1867,15 @@ class StrategyConnectionService {
          * @returns Configured ClientStrategy instance
          */
         this.getStrategy = memoize(([strategyName]) => `${strategyName}`, (strategyName) => {
-            const { getSignal, interval, callbacks } = this.strategySchemaService.get(strategyName);
+            const { riskName, getSignal, interval, callbacks } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 interval,
                 execution: this.executionContextService,
                 method: this.methodContextService,
                 logger: this.loggerService,
                 exchange: this.exchangeConnectionService,
+                risk: riskName ? this.riskConnectionService.getRisk(riskName) : NOOP_RISK,
+                riskName,
                 strategyName,
                 getSignal,
                 callbacks,
@@ -1906,104 +2102,581 @@ class FrameConnectionService {
 }
 
 /**
- * Global service for exchange operations with execution context injection.
+ * Calculates position size using fixed percentage risk method.
+ * Risk amount = accountBalance * riskPercentage
+ * Position size = riskAmount / |priceOpen - priceStopLoss|
  *
- * Wraps ExchangeConnectionService with ExecutionContextService to inject
- * symbol, when, and backtest parameters into the execution context.
+ * @param params - Calculation parameters
+ * @param schema - Fixed percentage schema
+ * @returns Calculated position size
+ */
+const calculateFixedPercentage = (params, schema) => {
+    const { accountBalance, priceOpen, priceStopLoss } = params;
+    const { riskPercentage } = schema;
+    const riskAmount = accountBalance * (riskPercentage / 100);
+    const stopDistance = Math.abs(priceOpen - priceStopLoss);
+    if (stopDistance === 0) {
+        throw new Error("Stop-loss distance cannot be zero");
+    }
+    return riskAmount / stopDistance;
+};
+/**
+ * Calculates position size using Kelly Criterion.
+ * Kelly % = (winRate * winLossRatio - (1 - winRate)) / winLossRatio
+ * Position size = accountBalance * kellyPercentage * kellyMultiplier / priceOpen
  *
- * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
+ * @param params - Calculation parameters
+ * @param schema - Kelly schema
+ * @returns Calculated position size
  */
-class ExchangeGlobalService {
+const calculateKellyCriterion = (params, schema) => {
+    const { accountBalance, priceOpen, winRate, winLossRatio } = params;
+    const { kellyMultiplier = 0.25 } = schema;
+    if (winRate <= 0 || winRate >= 1) {
+        throw new Error("winRate must be between 0 and 1");
+    }
+    if (winLossRatio <= 0) {
+        throw new Error("winLossRatio must be positive");
+    }
+    // Kelly formula: (W * R - L) / R
+    // W = win rate, L = loss rate (1 - W), R = win/loss ratio
+    const kellyPercentage = (winRate * winLossRatio - (1 - winRate)) / winLossRatio;
+    // Kelly can be negative (edge is negative) or very large
+    // Apply multiplier to reduce risk (common practice: 0.25 for quarter Kelly)
+    const adjustedKelly = Math.max(0, kellyPercentage) * kellyMultiplier;
+    return (accountBalance * adjustedKelly) / priceOpen;
+};
+/**
+ * Calculates position size using ATR-based method.
+ * Risk amount = accountBalance * riskPercentage
+ * Position size = riskAmount / (ATR * atrMultiplier)
+ *
+ * @param params - Calculation parameters
+ * @param schema - ATR schema
+ * @returns Calculated position size
+ */
+const calculateATRBased = (params, schema) => {
+    const { accountBalance, atr } = params;
+    const { riskPercentage, atrMultiplier = 2 } = schema;
+    if (atr <= 0) {
+        throw new Error("ATR must be positive");
+    }
+    const riskAmount = accountBalance * (riskPercentage / 100);
+    const stopDistance = atr * atrMultiplier;
+    return riskAmount / stopDistance;
+};
+/**
+ * Main calculation function routing to specific sizing method.
+ * Applies min/max constraints after calculation.
+ *
+ * @param params - Calculation parameters
+ * @param self - ClientSizing instance reference
+ * @returns Calculated and constrained position size
+ */
+const CALCULATE_FN = async (params, self) => {
+    self.params.logger.debug("ClientSizing calculate", {
+        symbol: params.symbol,
+        method: params.method,
+    });
+    const schema = self.params;
+    let quantity;
+    // Type-safe routing based on discriminated union using schema.method
+    if (schema.method === "fixed-percentage") {
+        if (params.method !== "fixed-percentage") {
+            throw new Error(`Params method mismatch: expected fixed-percentage, got ${params.method}`);
+        }
+        quantity = calculateFixedPercentage(params, schema);
+    }
+    else if (schema.method === "kelly-criterion") {
+        if (params.method !== "kelly-criterion") {
+            throw new Error(`Params method mismatch: expected kelly-criterion, got ${params.method}`);
+        }
+        quantity = calculateKellyCriterion(params, schema);
+    }
+    else if (schema.method === "atr-based") {
+        if (params.method !== "atr-based") {
+            throw new Error(`Params method mismatch: expected atr-based, got ${params.method}`);
+        }
+        quantity = calculateATRBased(params, schema);
+    }
+    else {
+        const _exhaustiveCheck = schema;
+        throw new Error(`ClientSizing calculate: unknown method ${_exhaustiveCheck.method}`);
+    }
+    // Apply max position percentage constraint
+    if (schema.maxPositionPercentage !== undefined) {
+        const maxByPercentage = (params.accountBalance * schema.maxPositionPercentage) /
+            100 /
+            params.priceOpen;
+        quantity = Math.min(quantity, maxByPercentage);
+    }
+    // Apply min/max absolute constraints
+    if (schema.minPositionSize !== undefined) {
+        quantity = Math.max(quantity, schema.minPositionSize);
+    }
+    if (schema.maxPositionSize !== undefined) {
+        quantity = Math.min(quantity, schema.maxPositionSize);
+    }
+    // Trigger callback if defined
+    if (schema.callbacks?.onCalculate) {
+        schema.callbacks.onCalculate(quantity, params);
+    }
+    return quantity;
+};
+/**
+ * Client implementation for position sizing calculation.
+ *
+ * Features:
+ * - Multiple sizing methods (fixed %, Kelly, ATR)
+ * - Min/max position constraints
+ * - Max position percentage limit
+ * - Callback support for validation and logging
+ *
+ * Used by strategy execution to determine optimal position sizes.
+ */
+class ClientSizing {
+    constructor(params) {
+        this.params = params;
+    }
+    /**
+     * Calculates position size based on configured method and constraints.
+     *
+     * @param params - Calculation parameters (symbol, balance, prices, etc.)
+     * @returns Promise resolving to calculated position size
+     * @throws Error if required parameters are missing or invalid
+     */
+    async calculate(params) {
+        return await CALCULATE_FN(params, this);
+    }
+    ;
+}
+
+/**
+ * Connection service routing sizing operations to correct ClientSizing instance.
+ *
+ * Routes sizing method calls to the appropriate sizing implementation
+ * based on the provided sizingName parameter. Uses memoization to cache
+ * ClientSizing instances for performance.
+ *
+ * Key features:
+ * - Explicit sizing routing via sizingName parameter
+ * - Memoized ClientSizing instances by sizingName
+ * - Position size calculation with risk management
+ *
+ * Note: sizingName is empty string for strategies without sizing configuration.
+ *
+ * @example
+ * ```typescript
+ * // Used internally by framework
+ * const quantity = await sizingConnectionService.calculate(
+ *   {
+ *     symbol: "BTCUSDT",
+ *     accountBalance: 10000,
+ *     priceOpen: 50000,
+ *     priceStopLoss: 49000,
+ *     method: "fixed-percentage"
+ *   },
+ *   { sizingName: "conservative" }
+ * );
+ * ```
+ */
+class SizingConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+        this.sizingSchemaService = inject(TYPES.sizingSchemaService);
         /**
-         * Fetches historical candles with execution context.
+         * Retrieves memoized ClientSizing instance for given sizing name.
          *
-         * @param symbol - Trading pair symbol
-         * @param interval - Candle interval (e.g., "1m", "1h")
-         * @param limit - Maximum number of candles to fetch
-         * @param when - Timestamp for context (used in backtest mode)
-         * @param backtest - Whether running in backtest mode
-         * @returns Promise resolving to array of candles
+         * Creates ClientSizing on first call, returns cached instance on subsequent calls.
+         * Cache key is sizingName string.
+         *
+         * @param sizingName - Name of registered sizing schema
+         * @returns Configured ClientSizing instance
          */
-        this.getCandles = async (symbol, interval, limit, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService getCandles", {
-                symbol,
-                interval,
-                limit,
-                when,
-                backtest,
-            });
-            return await ExecutionContextService.runInContext(async () => {
-                return await this.exchangeConnectionService.getCandles(symbol, interval, limit);
-            }, {
-                symbol,
-                when,
-                backtest,
+        this.getSizing = memoize(([sizingName]) => `${sizingName}`, (sizingName) => {
+            const schema = this.sizingSchemaService.get(sizingName);
+            return new ClientSizing({
+                ...schema,
+                logger: this.loggerService,
             });
-        };
+        });
         /**
-         * Fetches future candles (backtest mode only) with execution context.
+         * Calculates position size based on risk parameters and configured method.
          *
-         * @param symbol - Trading pair symbol
-         * @param interval - Candle interval
-         * @param limit - Maximum number of candles to fetch
-         * @param when - Timestamp for context
-         * @param backtest - Whether running in backtest mode (must be true)
-         * @returns Promise resolving to array of future candles
+         * Routes to appropriate ClientSizing instance based on provided context.
+         * Supports multiple sizing methods: fixed-percentage, kelly-criterion, atr-based.
+         *
+         * @param params - Calculation parameters (symbol, balance, prices, method-specific data)
+         * @param context - Execution context with sizing name
+         * @returns Promise resolving to calculated position size
          */
-        this.getNextCandles = async (symbol, interval, limit, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService getNextCandles", {
-                symbol,
-                interval,
-                limit,
-                when,
-                backtest,
-            });
-            return await ExecutionContextService.runInContext(async () => {
-                return await this.exchangeConnectionService.getNextCandles(symbol, interval, limit);
-            }, {
-                symbol,
-                when,
-                backtest,
+        this.calculate = async (params, context) => {
+            this.loggerService.log("sizingConnectionService calculate", {
+                symbol: params.symbol,
+                method: params.method,
+                context,
             });
+            return await this.getSizing(context.sizingName).calculate(params);
         };
+    }
+}
+
+/** Symbol indicating that positions need to be fetched from persistence */
+const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
+/** Key generator for active position map */
+const GET_KEY_FN = (strategyName, symbol) => `${strategyName}:${symbol}`;
+/** Wrapper to execute risk validation function with error handling */
+const DO_VALIDATION_FN = trycatch(async (validation, params) => {
+    await validation(params);
+    return true;
+}, {
+    defaultValue: false,
+    fallback: (error) => {
+        backtest$1.loggerService.warn("ClientRisk exception thrown", {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        });
+        validationSubject.next(error);
+    },
+});
+/**
+ * Initializes active positions by reading from persistence.
+ * Uses singleshot pattern to ensure it only runs once.
+ * This function is exported for use in tests or other modules.
+ */
+const WAIT_FOR_INIT_FN = async (self) => {
+    self.params.logger.debug("ClientRisk waitForInit");
+    const persistedPositions = await PersistRiskAdapter.readPositionData(self.params.riskName);
+    self._activePositions = new Map(persistedPositions);
+};
+/**
+ * ClientRisk implementation for portfolio-level risk management.
+ *
+ * Provides risk checking logic to prevent signals that violate configured limits:
+ * - Maximum concurrent positions (tracks across all strategies)
+ * - Custom validations with access to all active positions
+ *
+ * Multiple ClientStrategy instances share the same ClientRisk instance,
+ * allowing cross-strategy risk analysis.
+ *
+ * Used internally by strategy execution to validate signals before opening positions.
+ */
+class ClientRisk {
+    constructor(params) {
+        this.params = params;
         /**
-         * Calculates VWAP with execution context.
-         *
-         * @param symbol - Trading pair symbol
-         * @param when - Timestamp for context
-         * @param backtest - Whether running in backtest mode
-         * @returns Promise resolving to VWAP price
+         * Map of active positions tracked across all strategies.
+         * Key: `${strategyName}:${exchangeName}:${symbol}`
+         * Starts as POSITION_NEED_FETCH symbol, gets initialized on first use.
          */
-        this.getAveragePrice = async (symbol, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService getAveragePrice", {
-                symbol,
-                when,
-                backtest,
-            });
-            return await ExecutionContextService.runInContext(async () => {
-                return await this.exchangeConnectionService.getAveragePrice(symbol);
-            }, {
-                symbol,
-                when,
-                backtest,
-            });
-        };
+        this._activePositions = POSITION_NEED_FETCH;
         /**
-         * Formats price with execution context.
+         * Initializes active positions by loading from persistence.
+         * Uses singleshot pattern to ensure initialization happens exactly once.
+         * Skips persistence in backtest mode.
+         */
+        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN(this));
+        /**
+         * Checks if a signal should be allowed based on risk limits.
          *
-         * @param symbol - Trading pair symbol
-         * @param price - Price to format
-         * @param when - Timestamp for context
-         * @param backtest - Whether running in backtest mode
-         * @returns Promise resolving to formatted price string
+         * Executes custom validations with access to:
+         * - Passthrough params from ClientStrategy (symbol, strategyName, exchangeName, currentPrice, timestamp)
+         * - Active positions via this.activePositions getter
+         *
+         * Returns false immediately if any validation throws error.
+         * Triggers callbacks (onRejected, onAllowed) based on result.
+         *
+         * @param params - Risk check arguments (passthrough from ClientStrategy)
+         * @returns Promise resolving to true if allowed, false if rejected
          */
-        this.formatPrice = async (symbol, price, when, backtest) => {
-            this.loggerService.log("exchangeGlobalService formatPrice", {
-                symbol,
-                price,
+        this.checkSignal = async (params) => {
+            this.params.logger.debug("ClientRisk checkSignal", {
+                symbol: params.symbol,
+                strategyName: params.strategyName,
+            });
+            if (this._activePositions === POSITION_NEED_FETCH) {
+                await this.waitForInit();
+            }
+            const riskMap = this._activePositions;
+            const payload = {
+                ...params,
+                activePositionCount: riskMap.size,
+                activePositions: Array.from(riskMap.values()),
+            };
+            // Execute custom validations
+            let isValid = true;
+            if (this.params.validations) {
+                for (const validation of this.params.validations) {
+                    if (not(await DO_VALIDATION_FN(typeof validation === "function"
+                        ? validation
+                        : validation.validate, payload))) {
+                        isValid = false;
+                        break;
+                    }
+                }
+            }
+            if (!isValid) {
+                if (this.params.callbacks?.onRejected) {
+                    this.params.callbacks.onRejected(params.symbol, params);
+                }
+                return false;
+            }
+            // All checks passed
+            if (this.params.callbacks?.onAllowed) {
+                this.params.callbacks.onAllowed(params.symbol, params);
+            }
+            return true;
+        };
+    }
+    /**
+     * Persists current active positions to disk.
+     */
+    async _updatePositions() {
+        if (this._activePositions === POSITION_NEED_FETCH) {
+            await this.waitForInit();
+        }
+        await PersistRiskAdapter.writePositionData(Array.from(this._activePositions), this.params.riskName);
+    }
+    /**
+     * Registers a new opened signal.
+     * Called by StrategyConnectionService after signal is opened.
+     */
+    async addSignal(symbol, context) {
+        this.params.logger.debug("ClientRisk addSignal", {
+            symbol,
+            context,
+        });
+        if (this._activePositions === POSITION_NEED_FETCH) {
+            await this.waitForInit();
+        }
+        const key = GET_KEY_FN(context.strategyName, symbol);
+        const riskMap = this._activePositions;
+        riskMap.set(key, {
+            signal: null, // Signal details not needed for position tracking
+            strategyName: context.strategyName,
+            exchangeName: "",
+            openTimestamp: Date.now(),
+        });
+        await this._updatePositions();
+    }
+    /**
+     * Removes a closed signal.
+     * Called by StrategyConnectionService when signal is closed.
+     */
+    async removeSignal(symbol, context) {
+        this.params.logger.debug("ClientRisk removeSignal", {
+            symbol,
+            context,
+        });
+        if (this._activePositions === POSITION_NEED_FETCH) {
+            await this.waitForInit();
+        }
+        const key = GET_KEY_FN(context.strategyName, symbol);
+        const riskMap = this._activePositions;
+        riskMap.delete(key);
+        await this._updatePositions();
+    }
+}
+
+/**
+ * Connection service routing risk operations to correct ClientRisk instance.
+ *
+ * Routes risk checking calls to the appropriate risk implementation
+ * based on the provided riskName parameter. Uses memoization to cache
+ * ClientRisk instances for performance.
+ *
+ * Key features:
+ * - Explicit risk routing via riskName parameter
+ * - Memoized ClientRisk instances by riskName
+ * - Risk limit validation for signals
+ *
+ * Note: riskName is empty string for strategies without risk configuration.
+ *
+ * @example
+ * ```typescript
+ * // Used internally by framework
+ * const result = await riskConnectionService.checkSignal(
+ *   {
+ *     symbol: "BTCUSDT",
+ *     positionSize: 0.5,
+ *     currentPrice: 50000,
+ *     portfolioBalance: 100000,
+ *     currentDrawdown: 5,
+ *     currentPositions: 3,
+ *     dailyPnl: -2,
+ *     currentSymbolExposure: 8
+ *   },
+ *   { riskName: "conservative" }
+ * );
+ * ```
+ */
+class RiskConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.riskSchemaService = inject(TYPES.riskSchemaService);
+        /**
+         * Retrieves memoized ClientRisk instance for given risk name.
+         *
+         * Creates ClientRisk on first call, returns cached instance on subsequent calls.
+         * Cache key is riskName string.
+         *
+         * @param riskName - Name of registered risk schema
+         * @returns Configured ClientRisk instance
+         */
+        this.getRisk = memoize(([riskName]) => `${riskName}`, (riskName) => {
+            const schema = this.riskSchemaService.get(riskName);
+            return new ClientRisk({
+                ...schema,
+                logger: this.loggerService,
+            });
+        });
+        /**
+         * Checks if a signal should be allowed based on risk limits.
+         *
+         * Routes to appropriate ClientRisk instance based on provided context.
+         * Validates portfolio drawdown, symbol exposure, position count, and daily loss limits.
+         *
+         * @param params - Risk check arguments (portfolio state, position details)
+         * @param context - Execution context with risk name
+         * @returns Promise resolving to risk check result
+         */
+        this.checkSignal = async (params, context) => {
+            this.loggerService.log("riskConnectionService checkSignal", {
+                symbol: params.symbol,
+                context,
+            });
+            return await this.getRisk(context.riskName).checkSignal(params);
+        };
+        /**
+         * Registers an opened signal with the risk management system.
+         * Routes to appropriate ClientRisk instance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context information (strategyName, riskName)
+         */
+        this.addSignal = async (symbol, context) => {
+            this.loggerService.log("riskConnectionService addSignal", {
+                symbol,
+                context,
+            });
+            await this.getRisk(context.riskName).addSignal(symbol, context);
+        };
+        /**
+         * Removes a closed signal from the risk management system.
+         * Routes to appropriate ClientRisk instance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context information (strategyName, riskName)
+         */
+        this.removeSignal = async (symbol, context) => {
+            this.loggerService.log("riskConnectionService removeSignal", {
+                symbol,
+                context,
+            });
+            await this.getRisk(context.riskName).removeSignal(symbol, context);
+        };
+    }
+}
+
+/**
+ * Global service for exchange operations with execution context injection.
+ *
+ * Wraps ExchangeConnectionService with ExecutionContextService to inject
+ * symbol, when, and backtest parameters into the execution context.
+ *
+ * Used internally by BacktestLogicPrivateService and LiveLogicPrivateService.
+ */
+class ExchangeGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+        /**
+         * Fetches historical candles with execution context.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param limit - Maximum number of candles to fetch
+         * @param when - Timestamp for context (used in backtest mode)
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of candles
+         */
+        this.getCandles = async (symbol, interval, limit, when, backtest) => {
+            this.loggerService.log("exchangeGlobalService getCandles", {
+                symbol,
+                interval,
+                limit,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getCandles(symbol, interval, limit);
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
+        /**
+         * Fetches future candles (backtest mode only) with execution context.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
+         * @param limit - Maximum number of candles to fetch
+         * @param when - Timestamp for context
+         * @param backtest - Whether running in backtest mode (must be true)
+         * @returns Promise resolving to array of future candles
+         */
+        this.getNextCandles = async (symbol, interval, limit, when, backtest) => {
+            this.loggerService.log("exchangeGlobalService getNextCandles", {
+                symbol,
+                interval,
+                limit,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getNextCandles(symbol, interval, limit);
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
+        /**
+         * Calculates VWAP with execution context.
+         *
+         * @param symbol - Trading pair symbol
+         * @param when - Timestamp for context
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to VWAP price
+         */
+        this.getAveragePrice = async (symbol, when, backtest) => {
+            this.loggerService.log("exchangeGlobalService getAveragePrice", {
+                symbol,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getAveragePrice(symbol);
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
+        /**
+         * Formats price with execution context.
+         *
+         * @param symbol - Trading pair symbol
+         * @param price - Price to format
+         * @param when - Timestamp for context
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to formatted price string
+         */
+        this.formatPrice = async (symbol, price, when, backtest) => {
+            this.loggerService.log("exchangeGlobalService formatPrice", {
+                symbol,
+                price,
                 when,
                 backtest,
             });
@@ -2163,6 +2836,87 @@ class FrameGlobalService {
     }
 }
 
+/**
+ * Global service for sizing operations.
+ *
+ * Wraps SizingConnectionService for position size calculation.
+ * Used internally by strategy execution and public API.
+ */
+class SizingGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.sizingConnectionService = inject(TYPES.sizingConnectionService);
+        /**
+         * Calculates position size based on risk parameters.
+         *
+         * @param params - Calculation parameters (symbol, balance, prices, method-specific data)
+         * @param context - Execution context with sizing name
+         * @returns Promise resolving to calculated position size
+         */
+        this.calculate = async (params, context) => {
+            this.loggerService.log("sizingGlobalService calculate", {
+                symbol: params.symbol,
+                method: params.method,
+                context,
+            });
+            return await this.sizingConnectionService.calculate(params, context);
+        };
+    }
+}
+
+/**
+ * Global service for risk operations.
+ *
+ * Wraps RiskConnectionService for risk limit validation.
+ * Used internally by strategy execution and public API.
+ */
+class RiskGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.riskConnectionService = inject(TYPES.riskConnectionService);
+        /**
+         * Checks if a signal should be allowed based on risk limits.
+         *
+         * @param params - Risk check arguments (portfolio state, position details)
+         * @param context - Execution context with risk name
+         * @returns Promise resolving to risk check result
+         */
+        this.checkSignal = async (params, context) => {
+            this.loggerService.log("riskGlobalService checkSignal", {
+                symbol: params.symbol,
+                context,
+            });
+            return await this.riskConnectionService.checkSignal(params, context);
+        };
+        /**
+         * Registers an opened signal with the risk management system.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context information (strategyName, riskName)
+         */
+        this.addSignal = async (symbol, context) => {
+            this.loggerService.log("riskGlobalService addSignal", {
+                symbol,
+                context,
+            });
+            await this.riskConnectionService.addSignal(symbol, context);
+        };
+        /**
+         * Removes a closed signal from the risk management system.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context information (strategyName, riskName)
+         */
+        this.removeSignal = async (symbol, context) => {
+            this.loggerService.log("riskGlobalService removeSignal", {
+                symbol,
+                context,
+            });
+            await this.riskConnectionService.removeSignal(symbol, context);
+        };
+    }
+}
+
 /**
  * Service for managing exchange schema registry.
  *
@@ -2393,28 +3147,266 @@ class FrameSchemaService {
 }
 
 /**
- * Private service for backtest orchestration using async generators.
- *
- * Flow:
- * 1. Get timeframes from frame service
- * 2. Iterate through timeframes calling tick()
- * 3. When signal opens: fetch candles and call backtest()
- * 4. Skip timeframes until signal closes
- * 5. Yield closed result and continue
+ * Service for managing sizing schema registry.
  *
- * Memory efficient: streams results without array accumulation.
- * Supports early termination via break in consumer.
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Sizing schemas are registered via addSizing() and retrieved by name.
  */
-class BacktestLogicPrivateService {
+class SizingSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.strategyGlobalService = inject(TYPES.strategyGlobalService);
-        this.exchangeGlobalService = inject(TYPES.exchangeGlobalService);
-        this.frameGlobalService = inject(TYPES.frameGlobalService);
-        this.methodContextService = inject(TYPES.methodContextService);
+        this._registry = new ToolRegistry("sizingSchema");
+        /**
+         * Validates sizing schema structure for required properties.
+         *
+         * Performs shallow validation to ensure all required properties exist
+         * and have correct types before registration in the registry.
+         *
+         * @param sizingSchema - Sizing schema to validate
+         * @throws Error if sizingName is missing or not a string
+         * @throws Error if method is missing or not a valid sizing method
+         * @throws Error if required method-specific fields are missing
+         */
+        this.validateShallow = (sizingSchema) => {
+            this.loggerService.log(`sizingSchemaService validateShallow`, {
+                sizingSchema,
+            });
+            const sizingName = sizingSchema.sizingName;
+            const method = sizingSchema.method;
+            if (typeof sizingName !== "string") {
+                throw new Error(`sizing schema validation failed: missing sizingName`);
+            }
+            if (typeof method !== "string") {
+                throw new Error(`sizing schema validation failed: missing method for sizingName=${sizingName}`);
+            }
+            // Method-specific validation
+            if (sizingSchema.method === "fixed-percentage") {
+                if (typeof sizingSchema.riskPercentage !== "number") {
+                    throw new Error(`sizing schema validation failed: missing riskPercentage for fixed-percentage sizing (sizingName=${sizingName})`);
+                }
+            }
+            if (sizingSchema.method === "atr-based") {
+                if (typeof sizingSchema.riskPercentage !== "number") {
+                    throw new Error(`sizing schema validation failed: missing riskPercentage for atr-based sizing (sizingName=${sizingName})`);
+                }
+            }
+        };
     }
     /**
-     * Runs backtest for a symbol, streaming closed signals as async generator.
+     * Registers a new sizing schema.
+     *
+     * @param key - Unique sizing name
+     * @param value - Sizing schema configuration
+     * @throws Error if sizing name already exists
+     */
+    register(key, value) {
+        this.loggerService.log(`sizingSchemaService register`, { key });
+        this.validateShallow(value);
+        this._registry = this._registry.register(key, value);
+    }
+    /**
+     * Overrides an existing sizing schema with partial updates.
+     *
+     * @param key - Sizing name to override
+     * @param value - Partial schema updates
+     * @throws Error if sizing name doesn't exist
+     */
+    override(key, value) {
+        this.loggerService.log(`sizingSchemaService override`, { key });
+        this._registry = this._registry.override(key, value);
+        return this._registry.get(key);
+    }
+    /**
+     * Retrieves a sizing schema by name.
+     *
+     * @param key - Sizing name
+     * @returns Sizing schema configuration
+     * @throws Error if sizing name doesn't exist
+     */
+    get(key) {
+        this.loggerService.log(`sizingSchemaService get`, { key });
+        return this._registry.get(key);
+    }
+}
+
+/**
+ * Service for managing risk schema registry.
+ *
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Risk profiles are registered via addRisk() and retrieved by name.
+ */
+class RiskSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._registry = new ToolRegistry("riskSchema");
+        /**
+         * Registers a new risk schema.
+         *
+         * @param key - Unique risk profile name
+         * @param value - Risk schema configuration
+         * @throws Error if risk name already exists
+         */
+        this.register = (key, value) => {
+            this.loggerService.log(`riskSchemaService register`, { key });
+            this.validateShallow(value);
+            this._registry = this._registry.register(key, value);
+        };
+        /**
+         * Validates risk schema structure for required properties.
+         *
+         * Performs shallow validation to ensure all required properties exist
+         * and have correct types before registration in the registry.
+         *
+         * @param riskSchema - Risk schema to validate
+         * @throws Error if riskName is missing or not a string
+         */
+        this.validateShallow = (riskSchema) => {
+            this.loggerService.log(`riskSchemaService validateShallow`, {
+                riskSchema,
+            });
+            if (typeof riskSchema.riskName !== "string") {
+                throw new Error(`risk schema validation failed: missing riskName`);
+            }
+            if (riskSchema.validations && !Array.isArray(riskSchema.validations)) {
+                throw new Error(`risk schema validation failed: validations is not an array for riskName=${riskSchema.riskName}`);
+            }
+            if (riskSchema.validations &&
+                riskSchema.validations?.some((validation) => typeof validation !== "function" && !isObject(validation))) {
+                throw new Error(`risk schema validation failed: invalid validations for riskName=${riskSchema.riskName}`);
+            }
+        };
+        /**
+         * Overrides an existing risk schema with partial updates.
+         *
+         * @param key - Risk name to override
+         * @param value - Partial schema updates
+         * @returns Updated risk schema
+         * @throws Error if risk name doesn't exist
+         */
+        this.override = (key, value) => {
+            this.loggerService.log(`riskSchemaService override`, { key });
+            this._registry = this._registry.override(key, value);
+            return this._registry.get(key);
+        };
+        /**
+         * Retrieves a risk schema by name.
+         *
+         * @param key - Risk name
+         * @returns Risk schema configuration
+         * @throws Error if risk name doesn't exist
+         */
+        this.get = (key) => {
+            this.loggerService.log(`riskSchemaService get`, { key });
+            return this._registry.get(key);
+        };
+    }
+}
+
+/**
+ * Service for managing walker schema registry.
+ *
+ * Uses ToolRegistry from functools-kit for type-safe schema storage.
+ * Walkers are registered via addWalker() and retrieved by name.
+ */
+class WalkerSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._registry = new ToolRegistry("walkerSchema");
+        /**
+         * Registers a new walker schema.
+         *
+         * @param key - Unique walker name
+         * @param value - Walker schema configuration
+         * @throws Error if walker name already exists
+         */
+        this.register = (key, value) => {
+            this.loggerService.log(`walkerSchemaService register`, { key });
+            this.validateShallow(value);
+            this._registry = this._registry.register(key, value);
+        };
+        /**
+         * Validates walker schema structure for required properties.
+         *
+         * Performs shallow validation to ensure all required properties exist
+         * and have correct types before registration in the registry.
+         *
+         * @param walkerSchema - Walker schema to validate
+         * @throws Error if walkerName is missing or not a string
+         * @throws Error if exchangeName is missing or not a string
+         * @throws Error if frameName is missing or not a string
+         * @throws Error if strategies is missing or not an array
+         * @throws Error if strategies array is empty
+         */
+        this.validateShallow = (walkerSchema) => {
+            this.loggerService.log(`walkerSchemaService validateShallow`, {
+                walkerSchema,
+            });
+            if (typeof walkerSchema.walkerName !== "string") {
+                throw new Error(`walker schema validation failed: missing walkerName`);
+            }
+            if (typeof walkerSchema.exchangeName !== "string") {
+                throw new Error(`walker schema validation failed: missing exchangeName for walkerName=${walkerSchema.walkerName}`);
+            }
+            if (typeof walkerSchema.frameName !== "string") {
+                throw new Error(`walker schema validation failed: missing frameName for walkerName=${walkerSchema.walkerName}`);
+            }
+            if (!Array.isArray(walkerSchema.strategies)) {
+                throw new Error(`walker schema validation failed: strategies must be an array for walkerName=${walkerSchema.walkerName}`);
+            }
+            if (walkerSchema.strategies.length === 0) {
+                throw new Error(`walker schema validation failed: strategies array cannot be empty for walkerName=${walkerSchema.walkerName}`);
+            }
+        };
+        /**
+         * Overrides an existing walker schema with partial updates.
+         *
+         * @param key - Walker name to override
+         * @param value - Partial schema updates
+         * @returns Updated walker schema
+         * @throws Error if walker name doesn't exist
+         */
+        this.override = (key, value) => {
+            this.loggerService.log(`walkerSchemaService override`, { key });
+            this._registry = this._registry.override(key, value);
+            return this._registry.get(key);
+        };
+        /**
+         * Retrieves a walker schema by name.
+         *
+         * @param key - Walker name
+         * @returns Walker schema configuration
+         * @throws Error if walker name doesn't exist
+         */
+        this.get = (key) => {
+            this.loggerService.log(`walkerSchemaService get`, { key });
+            return this._registry.get(key);
+        };
+    }
+}
+
+/**
+ * Private service for backtest orchestration using async generators.
+ *
+ * Flow:
+ * 1. Get timeframes from frame service
+ * 2. Iterate through timeframes calling tick()
+ * 3. When signal opens: fetch candles and call backtest()
+ * 4. Skip timeframes until signal closes
+ * 5. Yield closed result and continue
+ *
+ * Memory efficient: streams results without array accumulation.
+ * Supports early termination via break in consumer.
+ */
+class BacktestLogicPrivateService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.strategyGlobalService = inject(TYPES.strategyGlobalService);
+        this.exchangeGlobalService = inject(TYPES.exchangeGlobalService);
+        this.frameGlobalService = inject(TYPES.frameGlobalService);
+        this.methodContextService = inject(TYPES.methodContextService);
+    }
+    /**
+     * Runs backtest for a symbol, streaming closed signals as async generator.
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @yields Closed signal results with PNL
@@ -2435,6 +3427,7 @@ class BacktestLogicPrivateService {
         const timeframes = await this.frameGlobalService.getTimeframe(symbol);
         const totalFrames = timeframes.length;
         let i = 0;
+        let previousEventTimestamp = null;
         while (i < timeframes.length) {
             const timeframeStartTime = performance.now();
             const when = timeframes[i];
@@ -2479,8 +3472,10 @@ class BacktestLogicPrivateService {
                 });
                 // Track signal processing duration
                 const signalEndTime = performance.now();
+                const currentTimestamp = Date.now();
                 await performanceEmitter.next({
-                    timestamp: Date.now(),
+                    timestamp: currentTimestamp,
+                    previousTimestamp: previousEventTimestamp,
                     metricType: "backtest_signal",
                     duration: signalEndTime - signalStartTime,
                     strategyName: this.methodContextService.context.strategyName,
@@ -2488,6 +3483,7 @@ class BacktestLogicPrivateService {
                     symbol,
                     backtest: true,
                 });
+                previousEventTimestamp = currentTimestamp;
                 // Пропускаем timeframes до closeTimestamp
                 while (i < timeframes.length &&
                     timeframes[i].getTime() < backtestResult.closeTimestamp) {
@@ -2497,8 +3493,10 @@ class BacktestLogicPrivateService {
             }
             // Track timeframe processing duration
             const timeframeEndTime = performance.now();
+            const currentTimestamp = Date.now();
             await performanceEmitter.next({
-                timestamp: Date.now(),
+                timestamp: currentTimestamp,
+                previousTimestamp: previousEventTimestamp,
                 metricType: "backtest_timeframe",
                 duration: timeframeEndTime - timeframeStartTime,
                 strategyName: this.methodContextService.context.strategyName,
@@ -2506,6 +3504,7 @@ class BacktestLogicPrivateService {
                 symbol,
                 backtest: true,
             });
+            previousEventTimestamp = currentTimestamp;
             i++;
         }
         // Emit final progress event (100%)
@@ -2521,8 +3520,10 @@ class BacktestLogicPrivateService {
         }
         // Track total backtest duration
         const backtestEndTime = performance.now();
+        const currentTimestamp = Date.now();
         await performanceEmitter.next({
-            timestamp: Date.now(),
+            timestamp: currentTimestamp,
+            previousTimestamp: previousEventTimestamp,
             metricType: "backtest_total",
             duration: backtestEndTime - backtestStartTime,
             strategyName: this.methodContextService.context.strategyName,
@@ -2530,6 +3531,7 @@ class BacktestLogicPrivateService {
             symbol,
             backtest: true,
         });
+        previousEventTimestamp = currentTimestamp;
     }
 }
 
@@ -2582,6 +3584,7 @@ class LiveLogicPrivateService {
         this.loggerService.log("liveLogicPrivateService run", {
             symbol,
         });
+        let previousEventTimestamp = null;
         while (true) {
             const tickStartTime = performance.now();
             const when = new Date();
@@ -2592,8 +3595,10 @@ class LiveLogicPrivateService {
             });
             // Track tick duration
             const tickEndTime = performance.now();
+            const currentTimestamp = Date.now();
             await performanceEmitter.next({
-                timestamp: Date.now(),
+                timestamp: currentTimestamp,
+                previousTimestamp: previousEventTimestamp,
                 metricType: "live_tick",
                 duration: tickEndTime - tickStartTime,
                 strategyName: this.methodContextService.context.strategyName,
@@ -2601,6 +3606,7 @@ class LiveLogicPrivateService {
                 symbol,
                 backtest: false,
             });
+            previousEventTimestamp = currentTimestamp;
             if (result.action === "active") {
                 await sleep(TICK_TTL);
                 continue;
@@ -2615,6 +3621,144 @@ class LiveLogicPrivateService {
     }
 }
 
+/**
+ * Private service for walker orchestration (strategy comparison).
+ *
+ * Flow:
+ * 1. Yields progress updates as each strategy completes
+ * 2. Tracks best metric in real-time
+ * 3. Returns final results with all strategies ranked
+ *
+ * Uses BacktestLogicPublicService internally for each strategy.
+ */
+class WalkerLogicPrivateService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.backtestLogicPublicService = inject(TYPES.backtestLogicPublicService);
+        this.backtestMarkdownService = inject(TYPES.backtestMarkdownService);
+        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
+    }
+    /**
+     * Runs walker comparison for a symbol.
+     *
+     * Executes backtest for each strategy sequentially.
+     * Yields WalkerContract after each strategy completes.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategies - List of strategy names to compare
+     * @param metric - Metric to use for comparison
+     * @param context - Walker context with exchangeName, frameName, walkerName
+     * @yields WalkerContract with progress after each strategy
+     *
+     * @example
+     * ```typescript
+     * for await (const progress of walkerLogic.run(
+     *   "BTCUSDT",
+     *   ["strategy-v1", "strategy-v2"],
+     *   "sharpeRatio",
+     *   {
+     *     exchangeName: "binance",
+     *     frameName: "1d-backtest",
+     *     walkerName: "my-optimizer"
+     *   }
+     * )) {
+     *   console.log("Progress:", progress.strategiesTested, "/", progress.totalStrategies);
+     * }
+     * ```
+     */
+    async *run(symbol, strategies, metric, context) {
+        this.loggerService.log("walkerLogicPrivateService run", {
+            symbol,
+            strategies,
+            metric,
+            context,
+        });
+        // Get walker schema for callbacks
+        const walkerSchema = this.walkerSchemaService.get(context.walkerName);
+        let strategiesTested = 0;
+        let bestMetric = null;
+        let bestStrategy = null;
+        // Run backtest for each strategy
+        for (const strategyName of strategies) {
+            // Call onStrategyStart callback if provided
+            if (walkerSchema.callbacks?.onStrategyStart) {
+                walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
+            }
+            this.loggerService.info("walkerLogicPrivateService testing strategy", {
+                strategyName,
+                symbol,
+            });
+            const iterator = this.backtestLogicPublicService.run(symbol, {
+                strategyName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+            });
+            await resolveDocuments(iterator);
+            this.loggerService.info("walkerLogicPrivateService backtest complete", {
+                strategyName,
+                symbol,
+            });
+            // Get statistics from BacktestMarkdownService
+            const stats = await this.backtestMarkdownService.getData(strategyName);
+            // Extract metric value
+            const value = stats[metric];
+            const metricValue = value !== null &&
+                value !== undefined &&
+                typeof value === "number" &&
+                !isNaN(value) &&
+                isFinite(value)
+                ? value
+                : null;
+            // Update best strategy if needed
+            const isBetter = bestMetric === null ||
+                (metricValue !== null && metricValue > bestMetric);
+            if (isBetter && metricValue !== null) {
+                bestMetric = metricValue;
+                bestStrategy = strategyName;
+            }
+            strategiesTested++;
+            const walkerContract = {
+                walkerName: context.walkerName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                symbol,
+                strategyName,
+                stats,
+                metricValue,
+                metric,
+                bestMetric,
+                bestStrategy,
+                strategiesTested,
+                totalStrategies: strategies.length,
+            };
+            // Call onStrategyComplete callback if provided
+            if (walkerSchema.callbacks?.onStrategyComplete) {
+                walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+            }
+            await walkerEmitter.next(walkerContract);
+            yield walkerContract;
+        }
+        const finalResults = {
+            walkerName: context.walkerName,
+            symbol,
+            exchangeName: context.exchangeName,
+            frameName: context.frameName,
+            metric,
+            totalStrategies: strategies.length,
+            bestStrategy,
+            bestMetric,
+            bestStats: bestStrategy !== null
+                ? await this.backtestMarkdownService.getData(bestStrategy)
+                : null,
+        };
+        // Call onComplete callback if provided with final best results
+        if (walkerSchema.callbacks?.onComplete) {
+            walkerSchema.callbacks.onComplete(finalResults);
+        }
+        await walkerCompleteSubject.next(finalResults);
+    }
+}
+
 /**
  * Public service for backtest orchestration with context management.
  *
@@ -2727,7 +3871,58 @@ class LiveLogicPublicService {
     }
 }
 
-const METHOD_NAME_RUN$1 = "liveGlobalService run";
+/**
+ * Public service for walker orchestration with context management.
+ *
+ * Wraps WalkerLogicPrivateService with MethodContextService to provide
+ * implicit context propagation for strategyName, exchangeName, frameName, and walkerName.
+ *
+ * @example
+ * ```typescript
+ * const walkerLogicPublicService = inject(TYPES.walkerLogicPublicService);
+ *
+ * const results = await walkerLogicPublicService.run("BTCUSDT", {
+ *   walkerName: "my-optimizer",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest",
+ *   strategies: ["strategy-v1", "strategy-v2"],
+ *   metric: "sharpeRatio",
+ * });
+ *
+ * console.log("Best strategy:", results.bestStrategy);
+ * ```
+ */
+class WalkerLogicPublicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.walkerLogicPrivateService = inject(TYPES.walkerLogicPrivateService);
+        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
+        /**
+         * Runs walker comparison for a symbol with context propagation.
+         *
+         * Executes backtests for all strategies.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Walker context with strategies and metric
+         */
+        this.run = (symbol, context) => {
+            this.loggerService.log("walkerLogicPublicService run", {
+                symbol,
+                context,
+            });
+            // Get walker schema
+            const walkerSchema = this.walkerSchemaService.get(context.walkerName);
+            // Run walker private service with strategies and metric from schema
+            return this.walkerLogicPrivateService.run(symbol, walkerSchema.strategies, walkerSchema.metric || "sharpeRatio", {
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                walkerName: context.walkerName,
+            });
+        };
+    }
+}
+
+const METHOD_NAME_RUN$2 = "liveGlobalService run";
 /**
  * Global service providing access to live trading functionality.
  *
@@ -2750,18 +3945,18 @@ class LiveGlobalService {
          * @returns Infinite async generator yielding opened and closed signals
          */
         this.run = (symbol, context) => {
-            this.loggerService.log(METHOD_NAME_RUN$1, {
+            this.loggerService.log(METHOD_NAME_RUN$2, {
                 symbol,
                 context,
             });
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
+            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$2);
+            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$2);
             return this.liveLogicPublicService.run(symbol, context);
         };
     }
 }
 
-const METHOD_NAME_RUN = "backtestGlobalService run";
+const METHOD_NAME_RUN$1 = "backtestGlobalService run";
 /**
  * Global service providing access to backtest functionality.
  *
@@ -2783,25 +3978,52 @@ class BacktestGlobalService {
          * @returns Async generator yielding closed signals with PNL
          */
         this.run = (symbol, context) => {
-            this.loggerService.log(METHOD_NAME_RUN, {
+            this.loggerService.log(METHOD_NAME_RUN$1, {
                 symbol,
                 context,
             });
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN);
-            this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN);
+            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
+            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
+            this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN$1);
             return this.backtestLogicPublicService.run(symbol, context);
         };
     }
 }
 
+const METHOD_NAME_RUN = "walkerGlobalService run";
+/**
+ * Global service providing access to walker functionality.
+ *
+ * Simple wrapper around WalkerLogicPublicService for dependency injection.
+ * Used by public API exports.
+ */
+class WalkerGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.walkerLogicPublicService = inject(TYPES.walkerLogicPublicService);
+        /**
+         * Runs walker comparison for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Walker context with strategies and metric
+         */
+        this.run = (symbol, context) => {
+            this.loggerService.log(METHOD_NAME_RUN, {
+                symbol,
+                context,
+            });
+            return this.walkerLogicPublicService.run(symbol, context);
+        };
+    }
+}
+
 /**
  * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
  *
  * @param value - Value to check
  * @returns true if value is unsafe, false otherwise
  */
-function isUnsafe$1(value) {
+function isUnsafe$3(value) {
     if (typeof value !== "number") {
         return true;
     }
@@ -2813,7 +4035,7 @@ function isUnsafe$1(value) {
     }
     return false;
 }
-const columns$1 = [
+const columns$2 = [
     {
         key: "signalId",
         label: "Signal ID",
@@ -2891,7 +4113,7 @@ const columns$1 = [
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     constructor() {
         /** Internal list of all closed signals for this strategy */
         this._signalList = [];
@@ -2960,14 +4182,14 @@ let ReportStorage$1 = class ReportStorage {
             totalSignals,
             winCount,
             lossCount,
-            winRate: isUnsafe$1(winRate) ? null : winRate,
-            avgPnl: isUnsafe$1(avgPnl) ? null : avgPnl,
-            totalPnl: isUnsafe$1(totalPnl) ? null : totalPnl,
-            stdDev: isUnsafe$1(stdDev) ? null : stdDev,
-            sharpeRatio: isUnsafe$1(sharpeRatio) ? null : sharpeRatio,
-            annualizedSharpeRatio: isUnsafe$1(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
-            certaintyRatio: isUnsafe$1(certaintyRatio) ? null : certaintyRatio,
-            expectedYearlyReturns: isUnsafe$1(expectedYearlyReturns) ? null : expectedYearlyReturns,
+            winRate: isUnsafe$3(winRate) ? null : winRate,
+            avgPnl: isUnsafe$3(avgPnl) ? null : avgPnl,
+            totalPnl: isUnsafe$3(totalPnl) ? null : totalPnl,
+            stdDev: isUnsafe$3(stdDev) ? null : stdDev,
+            sharpeRatio: isUnsafe$3(sharpeRatio) ? null : sharpeRatio,
+            annualizedSharpeRatio: isUnsafe$3(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
+            certaintyRatio: isUnsafe$3(certaintyRatio) ? null : certaintyRatio,
+            expectedYearlyReturns: isUnsafe$3(expectedYearlyReturns) ? null : expectedYearlyReturns,
         };
     }
     /**
@@ -2981,9 +4203,9 @@ let ReportStorage$1 = class ReportStorage {
         if (stats.totalSignals === 0) {
             return str.newline(`# Backtest Report: ${strategyName}`, "", "No signals closed yet.");
         }
-        const header = columns$1.map((col) => col.label);
-        const separator = columns$1.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => columns$1.map((col) => col.format(closedSignal)));
+        const header = columns$2.map((col) => col.label);
+        const separator = columns$2.map(() => "---");
+        const rows = this._signalList.map((closedSignal) => columns$2.map((col) => col.format(closedSignal)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
         return str.newline(`# Backtest Report: ${strategyName}`, "", table, "", `**Total signals:** ${stats.totalSignals}`, `**Closed signals:** ${stats.totalSignals}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
@@ -3044,7 +4266,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$1());
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -3191,7 +4413,7 @@ class BacktestMarkdownService {
  * @param value - Value to check
  * @returns true if value is unsafe, false otherwise
  */
-function isUnsafe(value) {
+function isUnsafe$2(value) {
     if (typeof value !== "number") {
         return true;
     }
@@ -3203,7 +4425,7 @@ function isUnsafe(value) {
     }
     return false;
 }
-const columns = [
+const columns$1 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -3282,7 +4504,7 @@ const MAX_EVENTS$1 = 250;
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
-class ReportStorage {
+let ReportStorage$1 = class ReportStorage {
     constructor() {
         /** Internal list of all tick events for this strategy */
         this._eventList = [];
@@ -3480,14 +4702,14 @@ class ReportStorage {
             totalClosed,
             winCount,
             lossCount,
-            winRate: isUnsafe(winRate) ? null : winRate,
-            avgPnl: isUnsafe(avgPnl) ? null : avgPnl,
-            totalPnl: isUnsafe(totalPnl) ? null : totalPnl,
-            stdDev: isUnsafe(stdDev) ? null : stdDev,
-            sharpeRatio: isUnsafe(sharpeRatio) ? null : sharpeRatio,
-            annualizedSharpeRatio: isUnsafe(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
-            certaintyRatio: isUnsafe(certaintyRatio) ? null : certaintyRatio,
-            expectedYearlyReturns: isUnsafe(expectedYearlyReturns) ? null : expectedYearlyReturns,
+            winRate: isUnsafe$2(winRate) ? null : winRate,
+            avgPnl: isUnsafe$2(avgPnl) ? null : avgPnl,
+            totalPnl: isUnsafe$2(totalPnl) ? null : totalPnl,
+            stdDev: isUnsafe$2(stdDev) ? null : stdDev,
+            sharpeRatio: isUnsafe$2(sharpeRatio) ? null : sharpeRatio,
+            annualizedSharpeRatio: isUnsafe$2(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
+            certaintyRatio: isUnsafe$2(certaintyRatio) ? null : certaintyRatio,
+            expectedYearlyReturns: isUnsafe$2(expectedYearlyReturns) ? null : expectedYearlyReturns,
         };
     }
     /**
@@ -3501,9 +4723,9 @@ class ReportStorage {
         if (stats.totalEvents === 0) {
             return str.newline(`# Live Trading Report: ${strategyName}`, "", "No events recorded yet.");
         }
-        const header = columns.map((col) => col.label);
-        const separator = columns.map(() => "---");
-        const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
+        const header = columns$1.map((col) => col.label);
+        const separator = columns$1.map(() => "---");
+        const rows = this._eventList.map((event) => columns$1.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
         return str.newline(`# Live Trading Report: ${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Closed signals:** ${stats.totalClosed}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
@@ -3528,7 +4750,7 @@ class ReportStorage {
             console.error(`Failed to save markdown report:`, error);
         }
     }
-}
+};
 /**
  * Service for generating and saving live trading markdown reports.
  *
@@ -3567,7 +4789,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage());
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$1());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -3783,9 +5005,26 @@ class PerformanceStorage {
             const variance = durations.reduce((sum, d) => sum + Math.pow(d - avgDuration, 2), 0) /
                 durations.length;
             const stdDev = Math.sqrt(variance);
-            metricStats[metricType] = {
-                metricType,
-                count: events.length,
+            // Calculate wait times between events
+            const waitTimes = [];
+            for (let i = 0; i < events.length; i++) {
+                if (events[i].previousTimestamp !== null) {
+                    const waitTime = events[i].timestamp - events[i].previousTimestamp;
+                    waitTimes.push(waitTime);
+                }
+            }
+            const sortedWaitTimes = waitTimes.sort((a, b) => a - b);
+            const avgWaitTime = sortedWaitTimes.length > 0
+                ? sortedWaitTimes.reduce((sum, w) => sum + w, 0) /
+                    sortedWaitTimes.length
+                : 0;
+            const minWaitTime = sortedWaitTimes.length > 0 ? sortedWaitTimes[0] : 0;
+            const maxWaitTime = sortedWaitTimes.length > 0
+                ? sortedWaitTimes[sortedWaitTimes.length - 1]
+                : 0;
+            metricStats[metricType] = {
+                metricType,
+                count: events.length,
                 totalDuration,
                 avgDuration,
                 minDuration: durations[0],
@@ -3794,6 +5033,9 @@ class PerformanceStorage {
                 median: percentile(durations, 50),
                 p95: percentile(durations, 95),
                 p99: percentile(durations, 99),
+                avgWaitTime,
+                minWaitTime,
+                maxWaitTime,
             };
         }
         const totalDuration = this._events.reduce((sum, e) => sum + e.duration, 0);
@@ -3830,6 +5072,9 @@ class PerformanceStorage {
             "Median (ms)",
             "P95 (ms)",
             "P99 (ms)",
+            "Avg Wait (ms)",
+            "Min Wait (ms)",
+            "Max Wait (ms)",
         ];
         const summarySeparator = summaryHeader.map(() => "---");
         const summaryRows = sortedMetrics.map((metric) => [
@@ -3843,6 +5088,9 @@ class PerformanceStorage {
             metric.median.toFixed(2),
             metric.p95.toFixed(2),
             metric.p99.toFixed(2),
+            metric.avgWaitTime.toFixed(2),
+            metric.minWaitTime.toFixed(2),
+            metric.maxWaitTime.toFixed(2),
         ]);
         const summaryTableData = [summaryHeader, summarySeparator, ...summaryRows];
         const summaryTable = str.newline(summaryTableData.map((row) => `| ${row.join(" | ")} |`));
@@ -3851,7 +5099,7 @@ class PerformanceStorage {
             const pct = (metric.totalDuration / stats.totalDuration) * 100;
             return `- **${metric.metricType}**: ${pct.toFixed(1)}% (${metric.totalDuration.toFixed(2)}ms total)`;
         });
-        return str.newline(`# Performance Report: ${strategyName}`, "", `**Total events:** ${stats.totalEvents}`, `**Total execution time:** ${stats.totalDuration.toFixed(2)}ms`, `**Number of metric types:** ${Object.keys(stats.metricStats).length}`, "", "## Time Distribution", "", str.newline(percentages), "", "## Detailed Metrics", "", summaryTable, "", "**Note:** All durations are in milliseconds. P95/P99 represent 95th and 99th percentile response times.");
+        return str.newline(`# Performance Report: ${strategyName}`, "", `**Total events:** ${stats.totalEvents}`, `**Total execution time:** ${stats.totalDuration.toFixed(2)}ms`, `**Number of metric types:** ${Object.keys(stats.metricStats).length}`, "", "## Time Distribution", "", str.newline(percentages), "", "## Detailed Metrics", "", summaryTable, "", "**Note:** All durations are in milliseconds. P95/P99 represent 95th and 99th percentile response times. Wait times show the interval between consecutive events of the same type.");
     }
     /**
      * Saves performance report to disk.
@@ -3886,101 +5134,896 @@ class PerformanceStorage {
  *
  * @example
  * ```typescript
- * import { listenPerformance } from "backtest-kit";
- *
- * // Subscribe to performance events
- * listenPerformance((event) => {
- *   console.log(`${event.metricType}: ${event.duration.toFixed(2)}ms`);
- * });
+ * import { listenPerformance } from "backtest-kit";
+ *
+ * // Subscribe to performance events
+ * listenPerformance((event) => {
+ *   console.log(`${event.metricType}: ${event.duration.toFixed(2)}ms`);
+ * });
+ *
+ * // After execution, generate report
+ * const stats = await Performance.getData("my-strategy");
+ * console.log("Bottlenecks:", stats.metricStats);
+ *
+ * // Save report to disk
+ * await Performance.dump("my-strategy");
+ * ```
+ */
+class PerformanceMarkdownService {
+    constructor() {
+        /** Logger service for debug output */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Memoized function to get or create PerformanceStorage for a strategy.
+         * Each strategy gets its own isolated storage instance.
+         */
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new PerformanceStorage());
+        /**
+         * Processes performance events and accumulates metrics.
+         * Should be called from performance tracking code.
+         *
+         * @param event - Performance event with timing data
+         */
+        this.track = async (event) => {
+            this.loggerService.log("performanceMarkdownService track", {
+                event,
+            });
+            const strategyName = event.strategyName || "global";
+            const storage = this.getStorage(strategyName);
+            storage.addEvent(event);
+        };
+        /**
+         * Gets aggregated performance statistics for a strategy.
+         *
+         * @param strategyName - Strategy name to get data for
+         * @returns Performance statistics with aggregated metrics
+         *
+         * @example
+         * ```typescript
+         * const stats = await performanceService.getData("my-strategy");
+         * console.log("Total time:", stats.totalDuration);
+         * console.log("Slowest operation:", Object.values(stats.metricStats)
+         *   .sort((a, b) => b.avgDuration - a.avgDuration)[0]);
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            this.loggerService.log("performanceMarkdownService getData", {
+                strategyName,
+            });
+            const storage = this.getStorage(strategyName);
+            return storage.getData(strategyName);
+        };
+        /**
+         * Generates markdown report with performance analysis.
+         *
+         * @param strategyName - Strategy name to generate report for
+         * @returns Markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await performanceService.getReport("my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (strategyName) => {
+            this.loggerService.log("performanceMarkdownService getReport", {
+                strategyName,
+            });
+            const storage = this.getStorage(strategyName);
+            return storage.getReport(strategyName);
+        };
+        /**
+         * Saves performance report to disk.
+         *
+         * @param strategyName - Strategy name to save report for
+         * @param path - Directory path to save report
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./logs/performance/my-strategy.md
+         * await performanceService.dump("my-strategy");
+         *
+         * // Save to custom path
+         * await performanceService.dump("my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (strategyName, path = "./logs/performance") => {
+            this.loggerService.log("performanceMarkdownService dump", {
+                strategyName,
+                path,
+            });
+            const storage = this.getStorage(strategyName);
+            await storage.dump(strategyName, path);
+        };
+        /**
+         * Clears accumulated performance data from storage.
+         *
+         * @param strategyName - Optional strategy name to clear specific strategy data
+         */
+        this.clear = async (strategyName) => {
+            this.loggerService.log("performanceMarkdownService clear", {
+                strategyName,
+            });
+            this.getStorage.clear(strategyName);
+        };
+        /**
+         * Initializes the service by subscribing to performance events.
+         * Uses singleshot to ensure initialization happens only once.
+         */
+        this.init = singleshot(async () => {
+            this.loggerService.log("performanceMarkdownService init");
+            performanceEmitter.subscribe(this.track);
+        });
+    }
+}
+
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ */
+function isUnsafe$1(value) {
+    if (value === null) {
+        return true;
+    }
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Formats a metric value for display.
+ * Returns "N/A" for unsafe values, otherwise formats with 2 decimal places.
+ */
+function formatMetric(value) {
+    if (isUnsafe$1(value)) {
+        return "N/A";
+    }
+    return value.toFixed(2);
+}
+/**
+ * Storage class for accumulating walker results.
+ * Maintains a list of all strategy results and provides methods to generate reports.
+ */
+class ReportStorage {
+    constructor(walkerName) {
+        this.walkerName = walkerName;
+        /** Walker metadata (set from first addResult call) */
+        this._totalStrategies = null;
+        this._bestStats = null;
+        this._bestMetric = null;
+        this._bestStrategy = null;
+    }
+    /**
+     * Adds a strategy result to the storage.
+     *
+     * @param data - Walker contract with strategy result
+     */
+    addResult(data) {
+        {
+            this._bestMetric = data.bestMetric;
+            this._bestStrategy = data.bestStrategy;
+            this._totalStrategies = data.totalStrategies;
+        }
+        // Update best stats only if this strategy is the current best
+        if (data.strategyName === data.bestStrategy) {
+            this._bestStats = data.stats;
+        }
+    }
+    /**
+     * Calculates walker results from strategy results.
+     * Returns null for any unsafe numeric values (NaN, Infinity, etc).
+     *
+     * @param symbol - Trading symbol
+     * @param metric - Metric being optimized
+     * @param context - Context with exchangeName and frameName
+     * @returns Walker results data
+     */
+    async getData(symbol, metric, context) {
+        if (this._totalStrategies === null) {
+            throw new Error("No walker data available - no results added yet");
+        }
+        return {
+            walkerName: this.walkerName,
+            symbol,
+            exchangeName: context.exchangeName,
+            frameName: context.frameName,
+            metric,
+            totalStrategies: this._totalStrategies,
+            bestStrategy: this._bestStrategy,
+            bestMetric: this._bestMetric,
+            bestStats: this._bestStats,
+        };
+    }
+    /**
+     * Generates markdown report with all strategy results (View).
+     *
+     * @param symbol - Trading symbol
+     * @param metric - Metric being optimized
+     * @param context - Context with exchangeName and frameName
+     * @returns Markdown formatted report with all results
+     */
+    async getReport(symbol, metric, context) {
+        const results = await this.getData(symbol, metric, context);
+        return str.newline(`# Walker Comparison Report: ${results.walkerName}`, "", `**Symbol:** ${results.symbol}`, `**Exchange:** ${results.exchangeName}`, `**Frame:** ${results.frameName}`, `**Optimization Metric:** ${results.metric}`, `**Strategies Tested:** ${results.totalStrategies}`, "", `## Best Strategy: ${results.bestStrategy}`, "", `**Best ${results.metric}:** ${formatMetric(results.bestMetric)}`, "**Note:** Higher values are better for all metrics except Standard Deviation (lower is better).");
+    }
+    /**
+     * Saves walker report to disk.
+     *
+     * @param symbol - Trading symbol
+     * @param metric - Metric being optimized
+     * @param context - Context with exchangeName and frameName
+     * @param path - Directory path to save report (default: "./logs/walker")
+     */
+    async dump(symbol, metric, context, path = "./logs/walker") {
+        const markdown = await this.getReport(symbol, metric, context);
+        try {
+            const dir = join(process.cwd(), path);
+            await mkdir(dir, { recursive: true });
+            const filename = `${this.walkerName}.md`;
+            const filepath = join(dir, filename);
+            await writeFile(filepath, markdown, "utf-8");
+            console.log(`Walker report saved: ${filepath}`);
+        }
+        catch (error) {
+            console.error(`Failed to save walker report:`, error);
+        }
+    }
+}
+/**
+ * Service for generating and saving walker markdown reports.
+ *
+ * Features:
+ * - Listens to walker events via tick callback
+ * - Accumulates strategy results per walker using memoized storage
+ * - Generates markdown tables with detailed strategy comparison
+ * - Saves reports to disk in logs/walker/{walkerName}.md
+ *
+ * @example
+ * ```typescript
+ * const service = new WalkerMarkdownService();
+ * const results = await service.getData("my-walker");
+ * await service.dump("my-walker");
+ * ```
+ */
+class WalkerMarkdownService {
+    constructor() {
+        /** Logger service for debug output */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Memoized function to get or create ReportStorage for a walker.
+         * Each walker gets its own isolated storage instance.
+         */
+        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage(walkerName));
+        /**
+         * Processes walker progress events and accumulates strategy results.
+         * Should be called from walkerEmitter.
+         *
+         * @param data - Walker contract from walker execution
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         * walkerEmitter.subscribe((data) => service.tick(data));
+         * ```
+         */
+        this.tick = async (data) => {
+            this.loggerService.log("walkerMarkdownService tick", {
+                data,
+            });
+            const storage = this.getStorage(data.walkerName);
+            storage.addResult(data);
+        };
+        /**
+         * Gets walker results data from all strategy results.
+         * Delegates to ReportStorage.getData().
+         *
+         * @param walkerName - Walker name to get data for
+         * @param symbol - Trading symbol
+         * @param metric - Metric being optimized
+         * @param context - Context with exchangeName and frameName
+         * @returns Walker results data object with all metrics
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         * const results = await service.getData("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
+         * console.log(results.bestStrategy, results.bestMetric);
+         * ```
+         */
+        this.getData = async (walkerName, symbol, metric, context) => {
+            this.loggerService.log("walkerMarkdownService getData", {
+                walkerName,
+                symbol,
+                metric,
+                context,
+            });
+            const storage = this.getStorage(walkerName);
+            return storage.getData(symbol, metric, context);
+        };
+        /**
+         * Generates markdown report with all strategy results for a walker.
+         * Delegates to ReportStorage.getReport().
+         *
+         * @param walkerName - Walker name to generate report for
+         * @param symbol - Trading symbol
+         * @param metric - Metric being optimized
+         * @param context - Context with exchangeName and frameName
+         * @returns Markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         * const markdown = await service.getReport("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (walkerName, symbol, metric, context) => {
+            this.loggerService.log("walkerMarkdownService getReport", {
+                walkerName,
+                symbol,
+                metric,
+                context,
+            });
+            const storage = this.getStorage(walkerName);
+            return storage.getReport(symbol, metric, context);
+        };
+        /**
+         * Saves walker report to disk.
+         * Creates directory if it doesn't exist.
+         * Delegates to ReportStorage.dump().
+         *
+         * @param walkerName - Walker name to save report for
+         * @param symbol - Trading symbol
+         * @param metric - Metric being optimized
+         * @param context - Context with exchangeName and frameName
+         * @param path - Directory path to save report (default: "./logs/walker")
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         *
+         * // Save to default path: ./logs/walker/my-walker.md
+         * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" });
+         *
+         * // Save to custom path: ./custom/path/my-walker.md
+         * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" }, "./custom/path");
+         * ```
+         */
+        this.dump = async (walkerName, symbol, metric, context, path = "./logs/walker") => {
+            this.loggerService.log("walkerMarkdownService dump", {
+                walkerName,
+                symbol,
+                metric,
+                context,
+                path,
+            });
+            const storage = this.getStorage(walkerName);
+            await storage.dump(symbol, metric, context, path);
+        };
+        /**
+         * Clears accumulated result data from storage.
+         * If walkerName is provided, clears only that walker's data.
+         * If walkerName is omitted, clears all walkers' data.
+         *
+         * @param walkerName - Optional walker name to clear specific walker data
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         *
+         * // Clear specific walker data
+         * await service.clear("my-walker");
+         *
+         * // Clear all walkers' data
+         * await service.clear();
+         * ```
+         */
+        this.clear = async (walkerName) => {
+            this.loggerService.log("walkerMarkdownService clear", {
+                walkerName,
+            });
+            this.getStorage.clear(walkerName);
+        };
+        /**
+         * Initializes the service by subscribing to walker events.
+         * Uses singleshot to ensure initialization happens only once.
+         * Automatically called on first use.
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         * await service.init(); // Subscribe to walker events
+         * ```
+         */
+        this.init = singleshot(async () => {
+            this.loggerService.log("walkerMarkdownService init");
+            walkerEmitter.subscribe(this.tick);
+        });
+    }
+}
+
+const HEATMAP_METHOD_NAME_GET_DATA = "HeatMarkdownService.getData";
+const HEATMAP_METHOD_NAME_GET_REPORT = "HeatMarkdownService.getReport";
+const HEATMAP_METHOD_NAME_DUMP = "HeatMarkdownService.dump";
+const HEATMAP_METHOD_NAME_CLEAR = "HeatMarkdownService.clear";
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ *
+ * @param value - Value to check
+ * @returns true if value is unsafe, false otherwise
+ */
+function isUnsafe(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
+const columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+    },
+    {
+        key: "totalPnl",
+        label: "Total PNL",
+        format: (data) => data.totalPnl !== null ? str(data.totalPnl, "%+.2f%%") : "N/A",
+    },
+    {
+        key: "sharpeRatio",
+        label: "Sharpe",
+        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio, "%.2f") : "N/A",
+    },
+    {
+        key: "profitFactor",
+        label: "PF",
+        format: (data) => data.profitFactor !== null ? str(data.profitFactor, "%.2f") : "N/A",
+    },
+    {
+        key: "expectancy",
+        label: "Expect",
+        format: (data) => data.expectancy !== null ? str(data.expectancy, "%+.2f%%") : "N/A",
+    },
+    {
+        key: "winRate",
+        label: "WR",
+        format: (data) => data.winRate !== null ? str(data.winRate, "%.1f%%") : "N/A",
+    },
+    {
+        key: "avgWin",
+        label: "Avg Win",
+        format: (data) => data.avgWin !== null ? str(data.avgWin, "%+.2f%%") : "N/A",
+    },
+    {
+        key: "avgLoss",
+        label: "Avg Loss",
+        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%+.2f%%") : "N/A",
+    },
+    {
+        key: "maxDrawdown",
+        label: "Max DD",
+        format: (data) => data.maxDrawdown !== null ? str(-data.maxDrawdown, "%.2f%%") : "N/A",
+    },
+    {
+        key: "maxWinStreak",
+        label: "W Streak",
+        format: (data) => data.maxWinStreak.toString(),
+    },
+    {
+        key: "maxLossStreak",
+        label: "L Streak",
+        format: (data) => data.maxLossStreak.toString(),
+    },
+    {
+        key: "totalTrades",
+        label: "Trades",
+        format: (data) => data.totalTrades.toString(),
+    },
+];
+/**
+ * Storage class for accumulating closed signals per strategy and generating heatmap.
+ * Maintains symbol-level statistics and provides portfolio-wide metrics.
+ */
+class HeatmapStorage {
+    constructor() {
+        /** Internal storage of closed signals per symbol */
+        this.symbolData = new Map();
+    }
+    /**
+     * Adds a closed signal to the storage.
+     *
+     * @param data - Closed signal data with PNL and symbol
+     */
+    addSignal(data) {
+        const { symbol } = data;
+        if (!this.symbolData.has(symbol)) {
+            this.symbolData.set(symbol, []);
+        }
+        this.symbolData.get(symbol).push(data);
+    }
+    /**
+     * Calculates statistics for a single symbol.
+     *
+     * @param symbol - Trading pair symbol
+     * @param signals - Array of closed signals for this symbol
+     * @returns Heatmap row with aggregated statistics
+     */
+    calculateSymbolStats(symbol, signals) {
+        const totalTrades = signals.length;
+        const winCount = signals.filter((s) => s.pnl.pnlPercentage > 0).length;
+        const lossCount = signals.filter((s) => s.pnl.pnlPercentage < 0).length;
+        // Calculate win rate
+        let winRate = null;
+        if (totalTrades > 0) {
+            winRate = (winCount / totalTrades) * 100;
+        }
+        // Calculate total PNL
+        let totalPnl = null;
+        if (signals.length > 0) {
+            totalPnl = signals.reduce((acc, s) => acc + s.pnl.pnlPercentage, 0);
+        }
+        // Calculate average PNL
+        let avgPnl = null;
+        if (signals.length > 0) {
+            avgPnl = totalPnl / signals.length;
+        }
+        // Calculate standard deviation
+        let stdDev = null;
+        if (signals.length > 1 && avgPnl !== null) {
+            const variance = signals.reduce((acc, s) => acc + Math.pow(s.pnl.pnlPercentage - avgPnl, 2), 0) / signals.length;
+            stdDev = Math.sqrt(variance);
+        }
+        // Calculate Sharpe Ratio
+        let sharpeRatio = null;
+        if (avgPnl !== null && stdDev !== null && stdDev !== 0) {
+            sharpeRatio = avgPnl / stdDev;
+        }
+        // Calculate Maximum Drawdown
+        let maxDrawdown = null;
+        if (signals.length > 0) {
+            let peak = 0;
+            let currentDrawdown = 0;
+            let maxDD = 0;
+            for (const signal of signals) {
+                peak += signal.pnl.pnlPercentage;
+                if (peak > 0) {
+                    currentDrawdown = 0;
+                }
+                else {
+                    currentDrawdown = Math.abs(peak);
+                    if (currentDrawdown > maxDD) {
+                        maxDD = currentDrawdown;
+                    }
+                }
+            }
+            maxDrawdown = maxDD;
+        }
+        // Calculate Profit Factor
+        let profitFactor = null;
+        if (winCount > 0 && lossCount > 0) {
+            const sumWins = signals
+                .filter((s) => s.pnl.pnlPercentage > 0)
+                .reduce((acc, s) => acc + s.pnl.pnlPercentage, 0);
+            const sumLosses = Math.abs(signals
+                .filter((s) => s.pnl.pnlPercentage < 0)
+                .reduce((acc, s) => acc + s.pnl.pnlPercentage, 0));
+            if (sumLosses > 0) {
+                profitFactor = sumWins / sumLosses;
+            }
+        }
+        // Calculate Average Win / Average Loss
+        let avgWin = null;
+        let avgLoss = null;
+        if (winCount > 0) {
+            avgWin =
+                signals
+                    .filter((s) => s.pnl.pnlPercentage > 0)
+                    .reduce((acc, s) => acc + s.pnl.pnlPercentage, 0) / winCount;
+        }
+        if (lossCount > 0) {
+            avgLoss =
+                signals
+                    .filter((s) => s.pnl.pnlPercentage < 0)
+                    .reduce((acc, s) => acc + s.pnl.pnlPercentage, 0) / lossCount;
+        }
+        // Calculate Win/Loss Streaks
+        let maxWinStreak = 0;
+        let maxLossStreak = 0;
+        let currentWinStreak = 0;
+        let currentLossStreak = 0;
+        for (const signal of signals) {
+            if (signal.pnl.pnlPercentage > 0) {
+                currentWinStreak++;
+                currentLossStreak = 0;
+                if (currentWinStreak > maxWinStreak) {
+                    maxWinStreak = currentWinStreak;
+                }
+            }
+            else if (signal.pnl.pnlPercentage < 0) {
+                currentLossStreak++;
+                currentWinStreak = 0;
+                if (currentLossStreak > maxLossStreak) {
+                    maxLossStreak = currentLossStreak;
+                }
+            }
+        }
+        // Calculate Expectancy
+        let expectancy = null;
+        if (winRate !== null && avgWin !== null && avgLoss !== null) {
+            const lossRate = 100 - winRate;
+            expectancy = (winRate / 100) * avgWin + (lossRate / 100) * avgLoss;
+        }
+        // Apply safe math checks
+        if (isUnsafe(winRate))
+            winRate = null;
+        if (isUnsafe(totalPnl))
+            totalPnl = null;
+        if (isUnsafe(avgPnl))
+            avgPnl = null;
+        if (isUnsafe(stdDev))
+            stdDev = null;
+        if (isUnsafe(sharpeRatio))
+            sharpeRatio = null;
+        if (isUnsafe(maxDrawdown))
+            maxDrawdown = null;
+        if (isUnsafe(profitFactor))
+            profitFactor = null;
+        if (isUnsafe(avgWin))
+            avgWin = null;
+        if (isUnsafe(avgLoss))
+            avgLoss = null;
+        if (isUnsafe(expectancy))
+            expectancy = null;
+        return {
+            symbol,
+            totalPnl,
+            sharpeRatio,
+            maxDrawdown,
+            totalTrades,
+            winCount,
+            lossCount,
+            winRate,
+            avgPnl,
+            stdDev,
+            profitFactor,
+            avgWin,
+            avgLoss,
+            maxWinStreak,
+            maxLossStreak,
+            expectancy,
+        };
+    }
+    /**
+     * Gets aggregated portfolio heatmap statistics (Controller).
+     *
+     * @returns Promise resolving to heatmap statistics with per-symbol and portfolio-wide metrics
+     */
+    async getData() {
+        const symbols = [];
+        // Calculate per-symbol statistics
+        for (const [symbol, signals] of this.symbolData.entries()) {
+            const row = this.calculateSymbolStats(symbol, signals);
+            symbols.push(row);
+        }
+        // Sort by Sharpe Ratio descending (best performers first, nulls last)
+        symbols.sort((a, b) => {
+            if (a.sharpeRatio === null && b.sharpeRatio === null)
+                return 0;
+            if (a.sharpeRatio === null)
+                return 1;
+            if (b.sharpeRatio === null)
+                return -1;
+            return b.sharpeRatio - a.sharpeRatio;
+        });
+        // Calculate portfolio-wide metrics
+        const totalSymbols = symbols.length;
+        let portfolioTotalPnl = null;
+        let portfolioTotalTrades = 0;
+        if (symbols.length > 0) {
+            portfolioTotalPnl = symbols.reduce((acc, s) => acc + (s.totalPnl || 0), 0);
+            portfolioTotalTrades = symbols.reduce((acc, s) => acc + s.totalTrades, 0);
+        }
+        // Calculate portfolio Sharpe Ratio (weighted by number of trades)
+        let portfolioSharpeRatio = null;
+        const validSharpes = symbols.filter((s) => s.sharpeRatio !== null);
+        if (validSharpes.length > 0 && portfolioTotalTrades > 0) {
+            const weightedSum = validSharpes.reduce((acc, s) => acc + s.sharpeRatio * s.totalTrades, 0);
+            portfolioSharpeRatio = weightedSum / portfolioTotalTrades;
+        }
+        // Apply safe math
+        if (isUnsafe(portfolioTotalPnl))
+            portfolioTotalPnl = null;
+        if (isUnsafe(portfolioSharpeRatio))
+            portfolioSharpeRatio = null;
+        return {
+            symbols,
+            totalSymbols,
+            portfolioTotalPnl,
+            portfolioSharpeRatio,
+            portfolioTotalTrades,
+        };
+    }
+    /**
+     * Generates markdown report with portfolio heatmap table (View).
+     *
+     * @param strategyName - Strategy name for report title
+     * @returns Promise resolving to markdown formatted report string
+     */
+    async getReport(strategyName) {
+        const data = await this.getData();
+        if (data.symbols.length === 0) {
+            return str.newline(`# Portfolio Heatmap: ${strategyName}`, "", "*No data available*");
+        }
+        const header = columns.map((col) => col.label);
+        const separator = columns.map(() => "---");
+        const rows = data.symbols.map((row) => columns.map((col) => col.format(row)));
+        const tableData = [header, separator, ...rows];
+        const table = str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
+        return str.newline(`# Portfolio Heatmap: ${strategyName}`, "", `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%+.2f%%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio, "%.2f") : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`, "", table);
+    }
+    /**
+     * Saves heatmap report to disk.
+     *
+     * @param strategyName - Strategy name for filename
+     * @param path - Directory path to save report (default: "./logs/heatmap")
+     */
+    async dump(strategyName, path = "./logs/heatmap") {
+        const markdown = await this.getReport(strategyName);
+        try {
+            const dir = join(process.cwd(), path);
+            await mkdir(dir, { recursive: true });
+            const filename = `${strategyName}.md`;
+            const filepath = join(dir, filename);
+            await writeFile(filepath, markdown, "utf-8");
+            console.log(`Heatmap report saved: ${filepath}`);
+        }
+        catch (error) {
+            console.error(`Failed to save heatmap report:`, error);
+        }
+    }
+}
+/**
+ * Portfolio Heatmap Markdown Service.
+ *
+ * Subscribes to signalEmitter and aggregates statistics across all symbols per strategy.
+ * Provides portfolio-wide metrics and per-symbol breakdowns.
+ *
+ * Features:
+ * - Real-time aggregation of closed signals
+ * - Per-symbol statistics (Total PNL, Sharpe Ratio, Max Drawdown, Trades)
+ * - Portfolio-wide aggregated metrics per strategy
+ * - Markdown table report generation
+ * - Safe math (handles NaN/Infinity gracefully)
+ * - Strategy-based navigation using memoized storage
+ *
+ * @example
+ * ```typescript
+ * const service = new HeatMarkdownService();
  *
- * // After execution, generate report
- * const stats = await Performance.getData("my-strategy");
- * console.log("Bottlenecks:", stats.metricStats);
+ * // Service automatically tracks all closed signals per strategy
+ * const stats = await service.getData("my-strategy");
+ * console.log(`Portfolio Total PNL: ${stats.portfolioTotalPnl}%`);
  *
- * // Save report to disk
- * await Performance.dump("my-strategy");
+ * // Generate and save report
+ * await service.dump("my-strategy", "./reports");
  * ```
  */
-class PerformanceMarkdownService {
+class HeatMarkdownService {
     constructor() {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create PerformanceStorage for a strategy.
-         * Each strategy gets its own isolated storage instance.
+         * Memoized function to get or create HeatmapStorage for a strategy.
+         * Each strategy gets its own isolated heatmap storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new PerformanceStorage());
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new HeatmapStorage());
         /**
-         * Processes performance events and accumulates metrics.
-         * Should be called from performance tracking code.
+         * Processes tick events and accumulates closed signals.
+         * Should be called from signal emitter subscription.
          *
-         * @param event - Performance event with timing data
+         * Only processes closed signals - opened signals are ignored.
+         *
+         * @param data - Tick result from strategy execution (closed signals only)
          */
-        this.track = async (event) => {
-            this.loggerService.log("performanceMarkdownService track", {
-                event,
+        this.tick = async (data) => {
+            this.loggerService.log("heatMarkdownService tick", {
+                data,
             });
-            const strategyName = event.strategyName || "global";
-            const storage = this.getStorage(strategyName);
-            storage.addEvent(event);
+            if (data.action !== "closed") {
+                return;
+            }
+            const storage = this.getStorage(data.strategyName);
+            storage.addSignal(data);
         };
         /**
-         * Gets aggregated performance statistics for a strategy.
+         * Gets aggregated portfolio heatmap statistics for a strategy.
          *
-         * @param strategyName - Strategy name to get data for
-         * @returns Performance statistics with aggregated metrics
+         * @param strategyName - Strategy name to get heatmap data for
+         * @returns Promise resolving to heatmap statistics with per-symbol and portfolio-wide metrics
          *
          * @example
          * ```typescript
-         * const stats = await performanceService.getData("my-strategy");
-         * console.log("Total time:", stats.totalDuration);
-         * console.log("Slowest operation:", Object.values(stats.metricStats)
-         *   .sort((a, b) => b.avgDuration - a.avgDuration)[0]);
+         * const service = new HeatMarkdownService();
+         * const stats = await service.getData("my-strategy");
+         *
+         * console.log(`Total symbols: ${stats.totalSymbols}`);
+         * console.log(`Portfolio PNL: ${stats.portfolioTotalPnl}%`);
+         *
+         * stats.symbols.forEach(row => {
+         *   console.log(`${row.symbol}: ${row.totalPnl}% (${row.totalTrades} trades)`);
+         * });
          * ```
          */
         this.getData = async (strategyName) => {
-            this.loggerService.log("performanceMarkdownService getData", {
+            this.loggerService.log(HEATMAP_METHOD_NAME_GET_DATA, {
                 strategyName,
             });
             const storage = this.getStorage(strategyName);
-            return storage.getData(strategyName);
+            return storage.getData();
         };
         /**
-         * Generates markdown report with performance analysis.
+         * Generates markdown report with portfolio heatmap table for a strategy.
          *
-         * @param strategyName - Strategy name to generate report for
-         * @returns Markdown formatted report string
+         * @param strategyName - Strategy name to generate heatmap report for
+         * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await performanceService.getReport("my-strategy");
+         * const service = new HeatMarkdownService();
+         * const markdown = await service.getReport("my-strategy");
          * console.log(markdown);
+         * // Output:
+         * // # Portfolio Heatmap: my-strategy
+         * //
+         * // **Total Symbols:** 5 | **Portfolio PNL:** +45.3% | **Portfolio Sharpe:** 1.85 | **Total Trades:** 120
+         * //
+         * // | Symbol | Total PNL | Sharpe | Max DD | Trades |
+         * // |--------|-----------|--------|--------|--------|
+         * // | BTCUSDT | +15.5% | 2.10 | -2.5% | 45 |
+         * // | ETHUSDT | +12.3% | 1.85 | -3.1% | 38 |
+         * // ...
          * ```
          */
         this.getReport = async (strategyName) => {
-            this.loggerService.log("performanceMarkdownService getReport", {
+            this.loggerService.log(HEATMAP_METHOD_NAME_GET_REPORT, {
                 strategyName,
             });
             const storage = this.getStorage(strategyName);
             return storage.getReport(strategyName);
         };
         /**
-         * Saves performance report to disk.
+         * Saves heatmap report to disk for a strategy.
          *
-         * @param strategyName - Strategy name to save report for
-         * @param path - Directory path to save report
+         * Creates directory if it doesn't exist.
+         * Default filename: {strategyName}.md
+         *
+         * @param strategyName - Strategy name to save heatmap report for
+         * @param path - Optional directory path to save report (default: "./logs/heatmap")
          *
          * @example
          * ```typescript
-         * // Save to default path: ./logs/performance/my-strategy.md
-         * await performanceService.dump("my-strategy");
+         * const service = new HeatMarkdownService();
          *
-         * // Save to custom path
-         * await performanceService.dump("my-strategy", "./custom/path");
+         * // Save to default path: ./logs/heatmap/my-strategy.md
+         * await service.dump("my-strategy");
+         *
+         * // Save to custom path: ./reports/my-strategy.md
+         * await service.dump("my-strategy", "./reports");
          * ```
          */
-        this.dump = async (strategyName, path = "./logs/performance") => {
-            this.loggerService.log("performanceMarkdownService dump", {
+        this.dump = async (strategyName, path = "./logs/heatmap") => {
+            this.loggerService.log(HEATMAP_METHOD_NAME_DUMP, {
                 strategyName,
                 path,
             });
@@ -3988,23 +6031,43 @@ class PerformanceMarkdownService {
             await storage.dump(strategyName, path);
         };
         /**
-         * Clears accumulated performance data from storage.
+         * Clears accumulated heatmap data from storage.
+         * If strategyName is provided, clears only that strategy's data.
+         * If strategyName is omitted, clears all strategies' data.
          *
          * @param strategyName - Optional strategy name to clear specific strategy data
+         *
+         * @example
+         * ```typescript
+         * const service = new HeatMarkdownService();
+         *
+         * // Clear specific strategy data
+         * await service.clear("my-strategy");
+         *
+         * // Clear all strategies' data
+         * await service.clear();
+         * ```
          */
         this.clear = async (strategyName) => {
-            this.loggerService.log("performanceMarkdownService clear", {
+            this.loggerService.log(HEATMAP_METHOD_NAME_CLEAR, {
                 strategyName,
             });
             this.getStorage.clear(strategyName);
         };
         /**
-         * Initializes the service by subscribing to performance events.
+         * Initializes the service by subscribing to signal events.
          * Uses singleshot to ensure initialization happens only once.
+         * Automatically called on first use.
+         *
+         * @example
+         * ```typescript
+         * const service = new HeatMarkdownService();
+         * await service.init(); // Subscribe to signal events
+         * ```
          */
         this.init = singleshot(async () => {
-            this.loggerService.log("performanceMarkdownService init");
-            performanceEmitter.subscribe(this.track);
+            this.loggerService.log("heatMarkdownService init");
+            signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -4082,6 +6145,12 @@ class StrategyValidationService {
          * Injected logger service instance
          */
         this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * @readonly
+         * Injected risk validation service instance
+         */
+        this.riskValidationService = inject(TYPES.riskValidationService);
         /**
          * @private
          * Map storing strategy schemas by strategy name
@@ -4103,9 +6172,10 @@ class StrategyValidationService {
             this._strategyMap.set(strategyName, strategySchema);
         };
         /**
-         * Validates the existence of a strategy
+         * Validates the existence of a strategy and its risk profile (if configured)
          * @public
          * @throws {Error} If strategyName is not found
+         * @throws {Error} If riskName is configured but not found
          * Memoized function to cache validation results
          */
         this.validate = memoize(([strategyName]) => strategyName, (strategyName, source) => {
@@ -4117,6 +6187,10 @@ class StrategyValidationService {
             if (!strategy) {
                 throw new Error(`strategy ${strategyName} not found source=${source}`);
             }
+            // Validate risk profile if configured
+            if (strategy.riskName) {
+                this.riskValidationService.validate(strategy.riskName, source);
+            }
             return true;
         });
         /**
@@ -4192,6 +6266,194 @@ class FrameValidationService {
     }
 }
 
+/**
+ * @class WalkerValidationService
+ * Service for managing and validating walker configurations
+ */
+class WalkerValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * Map storing walker schemas by walker name
+         */
+        this._walkerMap = new Map();
+        /**
+         * Adds a walker schema to the validation service
+         * @public
+         * @throws {Error} If walkerName already exists
+         */
+        this.addWalker = (walkerName, walkerSchema) => {
+            this.loggerService.log("walkerValidationService addWalker", {
+                walkerName,
+                walkerSchema,
+            });
+            if (this._walkerMap.has(walkerName)) {
+                throw new Error(`walker ${walkerName} already exist`);
+            }
+            this._walkerMap.set(walkerName, walkerSchema);
+        };
+        /**
+         * Validates the existence of a walker
+         * @public
+         * @throws {Error} If walkerName is not found
+         * Memoized function to cache validation results
+         */
+        this.validate = memoize(([walkerName]) => walkerName, (walkerName, source) => {
+            this.loggerService.log("walkerValidationService validate", {
+                walkerName,
+                source,
+            });
+            const walker = this._walkerMap.get(walkerName);
+            if (!walker) {
+                throw new Error(`walker ${walkerName} not found source=${source}`);
+            }
+            return true;
+        });
+        /**
+         * Returns a list of all registered walker schemas
+         * @public
+         * @returns Array of walker schemas with their configurations
+         */
+        this.list = async () => {
+            this.loggerService.log("walkerValidationService list");
+            return Array.from(this._walkerMap.values());
+        };
+    }
+}
+
+/**
+ * @class SizingValidationService
+ * Service for managing and validating sizing configurations
+ */
+class SizingValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * Map storing sizing schemas by sizing name
+         */
+        this._sizingMap = new Map();
+        /**
+         * Adds a sizing schema to the validation service
+         * @public
+         * @throws {Error} If sizingName already exists
+         */
+        this.addSizing = (sizingName, sizingSchema) => {
+            this.loggerService.log("sizingValidationService addSizing", {
+                sizingName,
+                sizingSchema,
+            });
+            if (this._sizingMap.has(sizingName)) {
+                throw new Error(`sizing ${sizingName} already exist`);
+            }
+            this._sizingMap.set(sizingName, sizingSchema);
+        };
+        /**
+         * Validates the existence of a sizing and optionally its method
+         * @public
+         * @throws {Error} If sizingName is not found
+         * @throws {Error} If method is provided and doesn't match sizing schema method
+         * Memoized function to cache validation results
+         */
+        this.validate = memoize(([sizingName, source, method]) => `${sizingName}:${source}:${method || ""}`, (sizingName, source, method) => {
+            this.loggerService.log("sizingValidationService validate", {
+                sizingName,
+                source,
+                method,
+            });
+            const sizing = this._sizingMap.get(sizingName);
+            if (!sizing) {
+                throw new Error(`sizing ${sizingName} not found source=${source}`);
+            }
+            if (method !== undefined && sizing.method !== method) {
+                throw new Error(`Sizing method mismatch: sizing "${sizingName}" is configured as "${sizing.method}" but "${method}" was requested at source=${source}`);
+            }
+            return true;
+        });
+        /**
+         * Returns a list of all registered sizing schemas
+         * @public
+         * @returns Array of sizing schemas with their configurations
+         */
+        this.list = async () => {
+            this.loggerService.log("sizingValidationService list");
+            return Array.from(this._sizingMap.values());
+        };
+    }
+}
+
+/**
+ * @class RiskValidationService
+ * Service for managing and validating risk configurations
+ */
+class RiskValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * @private
+         * Map storing risk schemas by risk name
+         */
+        this._riskMap = new Map();
+        /**
+         * Adds a risk schema to the validation service
+         * @public
+         * @throws {Error} If riskName already exists
+         */
+        this.addRisk = (riskName, riskSchema) => {
+            this.loggerService.log("riskValidationService addRisk", {
+                riskName,
+                riskSchema,
+            });
+            if (this._riskMap.has(riskName)) {
+                throw new Error(`risk ${riskName} already exist`);
+            }
+            this._riskMap.set(riskName, riskSchema);
+        };
+        /**
+         * Validates the existence of a risk profile
+         * @public
+         * @throws {Error} If riskName is not found
+         * Memoized function to cache validation results
+         */
+        this.validate = memoize(([riskName, source]) => `${riskName}:${source}`, (riskName, source) => {
+            this.loggerService.log("riskValidationService validate", {
+                riskName,
+                source,
+            });
+            const risk = this._riskMap.get(riskName);
+            if (!risk) {
+                throw new Error(`risk ${riskName} not found source=${source}`);
+            }
+            return true;
+        });
+        /**
+         * Returns a list of all registered risk schemas
+         * @public
+         * @returns Array of risk schemas with their configurations
+         */
+        this.list = async () => {
+            this.loggerService.log("riskValidationService list");
+            return Array.from(this._riskMap.values());
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -4203,11 +6465,16 @@ class FrameValidationService {
     provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
     provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
     provide(TYPES.frameConnectionService, () => new FrameConnectionService());
+    provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
+    provide(TYPES.riskConnectionService, () => new RiskConnectionService());
 }
 {
     provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
     provide(TYPES.strategySchemaService, () => new StrategySchemaService());
     provide(TYPES.frameSchemaService, () => new FrameSchemaService());
+    provide(TYPES.walkerSchemaService, () => new WalkerSchemaService());
+    provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
+    provide(TYPES.riskSchemaService, () => new RiskSchemaService());
 }
 {
     provide(TYPES.exchangeGlobalService, () => new ExchangeGlobalService());
@@ -4215,24 +6482,34 @@ class FrameValidationService {
     provide(TYPES.frameGlobalService, () => new FrameGlobalService());
     provide(TYPES.liveGlobalService, () => new LiveGlobalService());
     provide(TYPES.backtestGlobalService, () => new BacktestGlobalService());
+    provide(TYPES.walkerGlobalService, () => new WalkerGlobalService());
+    provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
+    provide(TYPES.riskGlobalService, () => new RiskGlobalService());
 }
 {
     provide(TYPES.backtestLogicPrivateService, () => new BacktestLogicPrivateService());
     provide(TYPES.liveLogicPrivateService, () => new LiveLogicPrivateService());
+    provide(TYPES.walkerLogicPrivateService, () => new WalkerLogicPrivateService());
 }
 {
     provide(TYPES.backtestLogicPublicService, () => new BacktestLogicPublicService());
     provide(TYPES.liveLogicPublicService, () => new LiveLogicPublicService());
+    provide(TYPES.walkerLogicPublicService, () => new WalkerLogicPublicService());
 }
 {
     provide(TYPES.backtestMarkdownService, () => new BacktestMarkdownService());
     provide(TYPES.liveMarkdownService, () => new LiveMarkdownService());
     provide(TYPES.performanceMarkdownService, () => new PerformanceMarkdownService());
+    provide(TYPES.walkerMarkdownService, () => new WalkerMarkdownService());
+    provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
     provide(TYPES.strategyValidationService, () => new StrategyValidationService());
     provide(TYPES.frameValidationService, () => new FrameValidationService());
+    provide(TYPES.walkerValidationService, () => new WalkerValidationService());
+    provide(TYPES.sizingValidationService, () => new SizingValidationService());
+    provide(TYPES.riskValidationService, () => new RiskValidationService());
 }
 
 const baseServices = {
@@ -4246,11 +6523,16 @@ const connectionServices = {
     exchangeConnectionService: inject(TYPES.exchangeConnectionService),
     strategyConnectionService: inject(TYPES.strategyConnectionService),
     frameConnectionService: inject(TYPES.frameConnectionService),
+    sizingConnectionService: inject(TYPES.sizingConnectionService),
+    riskConnectionService: inject(TYPES.riskConnectionService),
 };
 const schemaServices = {
     exchangeSchemaService: inject(TYPES.exchangeSchemaService),
     strategySchemaService: inject(TYPES.strategySchemaService),
     frameSchemaService: inject(TYPES.frameSchemaService),
+    walkerSchemaService: inject(TYPES.walkerSchemaService),
+    sizingSchemaService: inject(TYPES.sizingSchemaService),
+    riskSchemaService: inject(TYPES.riskSchemaService),
 };
 const globalServices = {
     exchangeGlobalService: inject(TYPES.exchangeGlobalService),
@@ -4258,24 +6540,34 @@ const globalServices = {
     frameGlobalService: inject(TYPES.frameGlobalService),
     liveGlobalService: inject(TYPES.liveGlobalService),
     backtestGlobalService: inject(TYPES.backtestGlobalService),
+    walkerGlobalService: inject(TYPES.walkerGlobalService),
+    sizingGlobalService: inject(TYPES.sizingGlobalService),
+    riskGlobalService: inject(TYPES.riskGlobalService),
 };
 const logicPrivateServices = {
     backtestLogicPrivateService: inject(TYPES.backtestLogicPrivateService),
     liveLogicPrivateService: inject(TYPES.liveLogicPrivateService),
+    walkerLogicPrivateService: inject(TYPES.walkerLogicPrivateService),
 };
 const logicPublicServices = {
     backtestLogicPublicService: inject(TYPES.backtestLogicPublicService),
     liveLogicPublicService: inject(TYPES.liveLogicPublicService),
+    walkerLogicPublicService: inject(TYPES.walkerLogicPublicService),
 };
 const markdownServices = {
     backtestMarkdownService: inject(TYPES.backtestMarkdownService),
     liveMarkdownService: inject(TYPES.liveMarkdownService),
     performanceMarkdownService: inject(TYPES.performanceMarkdownService),
+    walkerMarkdownService: inject(TYPES.walkerMarkdownService),
+    heatMarkdownService: inject(TYPES.heatMarkdownService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
     strategyValidationService: inject(TYPES.strategyValidationService),
     frameValidationService: inject(TYPES.frameValidationService),
+    walkerValidationService: inject(TYPES.walkerValidationService),
+    sizingValidationService: inject(TYPES.sizingValidationService),
+    riskValidationService: inject(TYPES.riskValidationService),
 };
 const backtest = {
     ...baseServices,
@@ -4315,6 +6607,9 @@ async function setLogger(logger) {
 const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
 const ADD_EXCHANGE_METHOD_NAME = "add.addExchange";
 const ADD_FRAME_METHOD_NAME = "add.addFrame";
+const ADD_WALKER_METHOD_NAME = "add.addWalker";
+const ADD_SIZING_METHOD_NAME = "add.addSizing";
+const ADD_RISK_METHOD_NAME = "add.addRisk";
 /**
  * Registers a trading strategy in the framework.
  *
@@ -4421,24 +6716,198 @@ function addExchange(exchangeSchema) {
  *   startDate: new Date("2024-01-01T00:00:00Z"),
  *   endDate: new Date("2024-01-02T00:00:00Z"),
  *   callbacks: {
- *     onTimeframe: (timeframe, startDate, endDate, interval) => {
- *       console.log(`Generated ${timeframe.length} timeframes`);
+ *     onTimeframe: (timeframe, startDate, endDate, interval) => {
+ *       console.log(`Generated ${timeframe.length} timeframes`);
+ *     },
+ *   },
+ * });
+ * ```
+ */
+function addFrame(frameSchema) {
+    backtest$1.loggerService.info(ADD_FRAME_METHOD_NAME, {
+        frameSchema,
+    });
+    backtest$1.frameValidationService.addFrame(frameSchema.frameName, frameSchema);
+    backtest$1.frameSchemaService.register(frameSchema.frameName, frameSchema);
+}
+/**
+ * Registers a walker for strategy comparison.
+ *
+ * The walker executes backtests for multiple strategies on the same
+ * historical data and compares their performance using a specified metric.
+ *
+ * @param walkerSchema - Walker configuration object
+ * @param walkerSchema.walkerName - Unique walker identifier
+ * @param walkerSchema.exchangeName - Exchange to use for all strategies
+ * @param walkerSchema.frameName - Timeframe to use for all strategies
+ * @param walkerSchema.strategies - Array of strategy names to compare
+ * @param walkerSchema.metric - Metric to optimize (default: "sharpeRatio")
+ * @param walkerSchema.callbacks - Optional lifecycle callbacks
+ *
+ * @example
+ * ```typescript
+ * addWalker({
+ *   walkerName: "llm-prompt-optimizer",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest",
+ *   strategies: [
+ *     "my-strategy-v1",
+ *     "my-strategy-v2",
+ *     "my-strategy-v3"
+ *   ],
+ *   metric: "sharpeRatio",
+ *   callbacks: {
+ *     onStrategyComplete: (strategyName, symbol, stats, metric) => {
+ *       console.log(`${strategyName}: ${metric}`);
+ *     },
+ *     onComplete: (results) => {
+ *       console.log(`Best strategy: ${results.bestStrategy}`);
+ *     }
+ *   }
+ * });
+ * ```
+ */
+function addWalker(walkerSchema) {
+    backtest$1.loggerService.info(ADD_WALKER_METHOD_NAME, {
+        walkerSchema,
+    });
+    backtest$1.walkerValidationService.addWalker(walkerSchema.walkerName, walkerSchema);
+    backtest$1.walkerSchemaService.register(walkerSchema.walkerName, walkerSchema);
+}
+/**
+ * Registers a position sizing configuration in the framework.
+ *
+ * The sizing configuration defines:
+ * - Position sizing method (fixed-percentage, kelly-criterion, atr-based)
+ * - Risk parameters (risk percentage, Kelly multiplier, ATR multiplier)
+ * - Position constraints (min/max size, max position percentage)
+ * - Callback for calculation events
+ *
+ * @param sizingSchema - Sizing configuration object (discriminated union)
+ * @param sizingSchema.sizingName - Unique sizing identifier
+ * @param sizingSchema.method - Sizing method ("fixed-percentage" | "kelly-criterion" | "atr-based")
+ * @param sizingSchema.riskPercentage - Risk percentage per trade (for fixed-percentage and atr-based)
+ * @param sizingSchema.kellyMultiplier - Kelly multiplier (for kelly-criterion, default: 0.25)
+ * @param sizingSchema.atrMultiplier - ATR multiplier (for atr-based, default: 2)
+ * @param sizingSchema.maxPositionPercentage - Optional max position size as % of account
+ * @param sizingSchema.minPositionSize - Optional minimum position size
+ * @param sizingSchema.maxPositionSize - Optional maximum position size
+ * @param sizingSchema.callbacks - Optional lifecycle callbacks
+ *
+ * @example
+ * ```typescript
+ * // Fixed percentage sizing
+ * addSizing({
+ *   sizingName: "conservative",
+ *   method: "fixed-percentage",
+ *   riskPercentage: 1,
+ *   maxPositionPercentage: 10,
+ * });
+ *
+ * // Kelly Criterion sizing
+ * addSizing({
+ *   sizingName: "kelly",
+ *   method: "kelly-criterion",
+ *   kellyMultiplier: 0.25,
+ *   maxPositionPercentage: 20,
+ * });
+ *
+ * // ATR-based sizing
+ * addSizing({
+ *   sizingName: "atr-dynamic",
+ *   method: "atr-based",
+ *   riskPercentage: 2,
+ *   atrMultiplier: 2,
+ *   callbacks: {
+ *     onCalculate: (quantity, params) => {
+ *       console.log(`Calculated size: ${quantity} for ${params.symbol}`);
+ *     },
+ *   },
+ * });
+ * ```
+ */
+function addSizing(sizingSchema) {
+    backtest$1.loggerService.info(ADD_SIZING_METHOD_NAME, {
+        sizingSchema,
+    });
+    backtest$1.sizingValidationService.addSizing(sizingSchema.sizingName, sizingSchema);
+    backtest$1.sizingSchemaService.register(sizingSchema.sizingName, sizingSchema);
+}
+/**
+ * Registers a risk management configuration in the framework.
+ *
+ * The risk configuration defines:
+ * - Maximum concurrent positions across all strategies
+ * - Custom validations for advanced risk logic (portfolio metrics, correlations, etc.)
+ * - Callbacks for rejected/allowed signals
+ *
+ * Multiple ClientStrategy instances share the same ClientRisk instance,
+ * enabling cross-strategy risk analysis. ClientRisk tracks all active positions
+ * and provides access to them via validation functions.
+ *
+ * @param riskSchema - Risk configuration object
+ * @param riskSchema.riskName - Unique risk profile identifier
+ * @param riskSchema.maxConcurrentPositions - Optional max number of open positions across all strategies
+ * @param riskSchema.validations - Optional custom validation functions with access to params and active positions
+ * @param riskSchema.callbacks - Optional lifecycle callbacks (onRejected, onAllowed)
+ *
+ * @example
+ * ```typescript
+ * // Basic risk limit
+ * addRisk({
+ *   riskName: "conservative",
+ *   maxConcurrentPositions: 5,
+ * });
+ *
+ * // With custom validations (access to signal data and portfolio state)
+ * addRisk({
+ *   riskName: "advanced",
+ *   maxConcurrentPositions: 10,
+ *   validations: [
+ *     {
+ *       validate: async ({ params }) => {
+ *         // params contains: symbol, strategyName, exchangeName, signal, currentPrice, timestamp
+ *         // Calculate portfolio metrics from external data source
+ *         const portfolio = await getPortfolioState();
+ *         if (portfolio.drawdown > 20) {
+ *           throw new Error("Portfolio drawdown exceeds 20%");
+ *         }
+ *       },
+ *       docDescription: "Prevents trading during high drawdown",
+ *     },
+ *     ({ params }) => {
+ *       // Access signal details
+ *       const positionValue = calculatePositionValue(params.signal, params.currentPrice);
+ *       if (positionValue > 10000) {
+ *         throw new Error("Position value exceeds $10,000 limit");
+ *       }
+ *     },
+ *   ],
+ *   callbacks: {
+ *     onRejected: (symbol, reason, limit, params) => {
+ *       console.log(`[RISK] Signal rejected for ${symbol}: ${reason}`);
+ *     },
+ *     onAllowed: (symbol, params) => {
+ *       console.log(`[RISK] Signal allowed for ${symbol}`);
  *     },
  *   },
  * });
  * ```
  */
-function addFrame(frameSchema) {
-    backtest$1.loggerService.info(ADD_FRAME_METHOD_NAME, {
-        frameSchema,
+function addRisk(riskSchema) {
+    backtest$1.loggerService.info(ADD_RISK_METHOD_NAME, {
+        riskSchema,
     });
-    backtest$1.frameValidationService.addFrame(frameSchema.frameName, frameSchema);
-    backtest$1.frameSchemaService.register(frameSchema.frameName, frameSchema);
+    backtest$1.riskValidationService.addRisk(riskSchema.riskName, riskSchema);
+    backtest$1.riskSchemaService.register(riskSchema.riskName, riskSchema);
 }
 
 const LIST_EXCHANGES_METHOD_NAME = "list.listExchanges";
 const LIST_STRATEGIES_METHOD_NAME = "list.listStrategies";
 const LIST_FRAMES_METHOD_NAME = "list.listFrames";
+const LIST_WALKERS_METHOD_NAME = "list.listWalkers";
+const LIST_SIZINGS_METHOD_NAME = "list.listSizings";
+const LIST_RISKS_METHOD_NAME = "list.listRisks";
 /**
  * Returns a list of all registered exchange schemas.
  *
@@ -4531,6 +7000,111 @@ async function listFrames() {
     backtest$1.loggerService.log(LIST_FRAMES_METHOD_NAME);
     return await backtest$1.frameValidationService.list();
 }
+/**
+ * Returns a list of all registered walker schemas.
+ *
+ * Retrieves all walkers that have been registered via addWalker().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of walker schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listWalkers, addWalker } from "backtest-kit";
+ *
+ * addWalker({
+ *   walkerName: "llm-prompt-optimizer",
+ *   note: "Compare LLM-based trading strategies",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest",
+ *   strategies: ["my-strategy-v1", "my-strategy-v2"],
+ *   metric: "sharpeRatio",
+ * });
+ *
+ * const walkers = listWalkers();
+ * console.log(walkers);
+ * // [{ walkerName: "llm-prompt-optimizer", note: "Compare LLM...", ... }]
+ * ```
+ */
+async function listWalkers() {
+    backtest$1.loggerService.log(LIST_WALKERS_METHOD_NAME);
+    return await backtest$1.walkerValidationService.list();
+}
+/**
+ * Returns a list of all registered sizing schemas.
+ *
+ * Retrieves all sizing configurations that have been registered via addSizing().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of sizing schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listSizings, addSizing } from "backtest-kit";
+ *
+ * addSizing({
+ *   sizingName: "conservative",
+ *   note: "Low risk fixed percentage sizing",
+ *   method: "fixed-percentage",
+ *   riskPercentage: 1,
+ *   maxPositionPercentage: 10,
+ * });
+ *
+ * addSizing({
+ *   sizingName: "kelly",
+ *   note: "Kelly Criterion with quarter multiplier",
+ *   method: "kelly-criterion",
+ *   kellyMultiplier: 0.25,
+ * });
+ *
+ * const sizings = listSizings();
+ * console.log(sizings);
+ * // [
+ * //   { sizingName: "conservative", method: "fixed-percentage", ... },
+ * //   { sizingName: "kelly", method: "kelly-criterion", ... }
+ * // ]
+ * ```
+ */
+async function listSizings() {
+    backtest$1.loggerService.log(LIST_SIZINGS_METHOD_NAME);
+    return await backtest$1.sizingValidationService.list();
+}
+/**
+ * Returns a list of all registered risk schemas.
+ *
+ * Retrieves all risk configurations that have been registered via addRisk().
+ * Useful for debugging, documentation, or building dynamic UIs.
+ *
+ * @returns Array of risk schemas with their configurations
+ *
+ * @example
+ * ```typescript
+ * import { listRisks, addRisk } from "backtest-kit";
+ *
+ * addRisk({
+ *   riskName: "conservative",
+ *   note: "Conservative risk management with tight position limits",
+ *   maxConcurrentPositions: 5,
+ * });
+ *
+ * addRisk({
+ *   riskName: "aggressive",
+ *   note: "Aggressive risk management with loose limits",
+ *   maxConcurrentPositions: 10,
+ * });
+ *
+ * const risks = listRisks();
+ * console.log(risks);
+ * // [
+ * //   { riskName: "conservative", maxConcurrentPositions: 5, ... },
+ * //   { riskName: "aggressive", maxConcurrentPositions: 10, ... }
+ * // ]
+ * ```
+ */
+async function listRisks() {
+    backtest$1.loggerService.log(LIST_RISKS_METHOD_NAME);
+    return await backtest$1.riskValidationService.list();
+}
 
 const LISTEN_SIGNAL_METHOD_NAME = "event.listenSignal";
 const LISTEN_SIGNAL_ONCE_METHOD_NAME = "event.listenSignalOnce";
@@ -4539,10 +7113,18 @@ const LISTEN_SIGNAL_LIVE_ONCE_METHOD_NAME = "event.listenSignalLiveOnce";
 const LISTEN_SIGNAL_BACKTEST_METHOD_NAME = "event.listenSignalBacktest";
 const LISTEN_SIGNAL_BACKTEST_ONCE_METHOD_NAME = "event.listenSignalBacktestOnce";
 const LISTEN_ERROR_METHOD_NAME = "event.listenError";
-const LISTEN_DONE_METHOD_NAME = "event.listenDone";
-const LISTEN_DONE_ONCE_METHOD_NAME = "event.listenDoneOnce";
+const LISTEN_DONE_LIVE_METHOD_NAME = "event.listenDoneLive";
+const LISTEN_DONE_LIVE_ONCE_METHOD_NAME = "event.listenDoneLiveOnce";
+const LISTEN_DONE_BACKTEST_METHOD_NAME = "event.listenDoneBacktest";
+const LISTEN_DONE_BACKTEST_ONCE_METHOD_NAME = "event.listenDoneBacktestOnce";
+const LISTEN_DONE_WALKER_METHOD_NAME = "event.listenDoneWalker";
+const LISTEN_DONE_WALKER_ONCE_METHOD_NAME = "event.listenDoneWalkerOnce";
 const LISTEN_PROGRESS_METHOD_NAME = "event.listenProgress";
 const LISTEN_PERFORMANCE_METHOD_NAME = "event.listenPerformance";
+const LISTEN_WALKER_METHOD_NAME = "event.listenWalker";
+const LISTEN_WALKER_ONCE_METHOD_NAME = "event.listenWalkerOnce";
+const LISTEN_WALKER_COMPLETE_METHOD_NAME = "event.listenWalkerComplete";
+const LISTEN_VALIDATION_METHOD_NAME = "event.listenValidation";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -4734,9 +7316,133 @@ function listenError(fn) {
     return errorEmitter.subscribe(queued(async (error) => fn(error)));
 }
 /**
- * Subscribes to background execution completion events with queued async processing.
+ * Subscribes to live background execution completion events with queued async processing.
+ *
+ * Emits when Live.background() completes execution.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle completion events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneLive, Live } from "backtest-kit";
+ *
+ * const unsubscribe = listenDoneLive((event) => {
+ *   console.log("Live completed:", event.strategyName, event.exchangeName, event.symbol);
+ * });
+ *
+ * Live.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenDoneLive(fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_LIVE_METHOD_NAME);
+    return doneLiveSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered live background execution completion events with one-time execution.
+ *
+ * Emits when Live.background() completes execution.
+ * Executes callback once and automatically unsubscribes.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneLiveOnce, Live } from "backtest-kit";
+ *
+ * // Wait for first live completion
+ * listenDoneLiveOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => console.log("BTCUSDT live completed:", event.strategyName)
+ * );
+ *
+ * Live.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance"
+ * });
+ * ```
+ */
+function listenDoneLiveOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_LIVE_ONCE_METHOD_NAME);
+    return doneLiveSubject.filter(filterFn).once(fn);
+}
+/**
+ * Subscribes to backtest background execution completion events with queued async processing.
+ *
+ * Emits when Backtest.background() completes execution.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle completion events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneBacktest, Backtest } from "backtest-kit";
+ *
+ * const unsubscribe = listenDoneBacktest((event) => {
+ *   console.log("Backtest completed:", event.strategyName, event.exchangeName, event.symbol);
+ * });
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenDoneBacktest(fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_BACKTEST_METHOD_NAME);
+    return doneBacktestSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered backtest background execution completion events with one-time execution.
+ *
+ * Emits when Backtest.background() completes execution.
+ * Executes callback once and automatically unsubscribes.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneBacktestOnce, Backtest } from "backtest-kit";
+ *
+ * // Wait for first backtest completion
+ * listenDoneBacktestOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => console.log("BTCUSDT backtest completed:", event.strategyName)
+ * );
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ * ```
+ */
+function listenDoneBacktestOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_BACKTEST_ONCE_METHOD_NAME);
+    return doneBacktestSubject.filter(filterFn).once(fn);
+}
+/**
+ * Subscribes to walker background execution completion events with queued async processing.
  *
- * Emits when Live.background() or Backtest.background() completes execution.
+ * Emits when Walker.background() completes execution.
  * Events are processed sequentially in order received, even if callback is async.
  * Uses queued wrapper to prevent concurrent execution of the callback.
  *
@@ -4745,33 +7451,162 @@ function listenError(fn) {
  *
  * @example
  * ```typescript
- * import { listenDone, Live } from "backtest-kit";
+ * import { listenDoneWalker, Walker } from "backtest-kit";
+ *
+ * const unsubscribe = listenDoneWalker((event) => {
+ *   console.log("Walker completed:", event.strategyName, event.exchangeName, event.symbol);
+ * });
+ *
+ * Walker.background("BTCUSDT", {
+ *   walkerName: "my-walker"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenDoneWalker(fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_WALKER_METHOD_NAME);
+    return doneWalkerSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered walker background execution completion events with one-time execution.
+ *
+ * Emits when Walker.background() completes execution.
+ * Executes callback once and automatically unsubscribes.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenDoneWalkerOnce, Walker } from "backtest-kit";
+ *
+ * // Wait for first walker completion
+ * listenDoneWalkerOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => console.log("BTCUSDT walker completed:", event.strategyName)
+ * );
+ *
+ * Walker.background("BTCUSDT", {
+ *   walkerName: "my-walker"
+ * });
+ * ```
+ */
+function listenDoneWalkerOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_DONE_WALKER_ONCE_METHOD_NAME);
+    return doneWalkerSubject.filter(filterFn).once(fn);
+}
+/**
+ * Subscribes to backtest progress events with queued async processing.
+ *
+ * Emits during Backtest.background() execution to track progress.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle progress events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenProgress, Backtest } from "backtest-kit";
+ *
+ * const unsubscribe = listenProgress((event) => {
+ *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
+ *   console.log(`${event.processedFrames} / ${event.totalFrames} frames`);
+ *   console.log(`Strategy: ${event.strategyName}, Symbol: ${event.symbol}`);
+ * });
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenProgress(fn) {
+    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
+    return progressEmitter.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to performance metric events with queued async processing.
+ *
+ * Emits during strategy execution to track timing metrics for operations.
+ * Useful for profiling and identifying performance bottlenecks.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle performance events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenPerformance, Backtest } from "backtest-kit";
+ *
+ * const unsubscribe = listenPerformance((event) => {
+ *   console.log(`${event.metricType}: ${event.duration.toFixed(2)}ms`);
+ *   if (event.duration > 100) {
+ *     console.warn("Slow operation detected:", event.metricType);
+ *   }
+ * });
+ *
+ * Backtest.background("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenPerformance(fn) {
+    backtest$1.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
+    return performanceEmitter.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to walker progress events with queued async processing.
+ *
+ * Emits during Walker.run() execution after each strategy completes.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle walker progress events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenWalker, Walker } from "backtest-kit";
  *
- * const unsubscribe = listenDone((event) => {
- *   console.log("Completed:", event.strategyName, event.exchangeName, event.symbol);
- *   if (event.backtest) {
- *     console.log("Backtest mode completed");
- *   }
+ * const unsubscribe = listenWalker((event) => {
+ *   console.log(`Progress: ${event.strategiesTested} / ${event.totalStrategies}`);
+ *   console.log(`Best strategy: ${event.bestStrategy} (${event.bestMetric})`);
+ *   console.log(`Current strategy: ${event.strategyName} (${event.metricValue})`);
  * });
  *
- * Live.background("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "binance"
+ * Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker",
+ *   exchangeName: "binance",
+ *   frameName: "1d-backtest"
  * });
  *
  * // Later: stop listening
  * unsubscribe();
  * ```
  */
-function listenDone(fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_METHOD_NAME);
-    return doneEmitter.subscribe(queued(async (event) => fn(event)));
+function listenWalker(fn) {
+    backtest$1.loggerService.log(LISTEN_WALKER_METHOD_NAME);
+    return walkerEmitter.subscribe(queued(async (event) => fn(event)));
 }
 /**
- * Subscribes to filtered background execution completion events with one-time execution.
+ * Subscribes to filtered walker progress events with one-time execution.
  *
- * Emits when Live.background() or Backtest.background() completes execution.
- * Executes callback once and automatically unsubscribes.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific walker conditions.
  *
  * @param filterFn - Predicate to filter which events trigger the callback
  * @param fn - Callback function to handle the filtered event (called only once)
@@ -4779,47 +7614,60 @@ function listenDone(fn) {
  *
  * @example
  * ```typescript
- * import { listenDoneOnce, Backtest } from "backtest-kit";
+ * import { listenWalkerOnce, Walker } from "backtest-kit";
  *
- * // Wait for first backtest completion
- * listenDoneOnce(
- *   (event) => event.backtest && event.symbol === "BTCUSDT",
- *   (event) => console.log("BTCUSDT backtest completed:", event.strategyName)
+ * // Wait for walker to complete all strategies
+ * listenWalkerOnce(
+ *   (event) => event.strategiesTested === event.totalStrategies,
+ *   (event) => {
+ *     console.log("Walker completed!");
+ *     console.log("Best strategy:", event.bestStrategy, event.bestMetric);
+ *   }
  * );
  *
- * Backtest.background("BTCUSDT", {
- *   strategyName: "my-strategy",
+ * // Wait for specific strategy to be tested
+ * const cancel = listenWalkerOnce(
+ *   (event) => event.strategyName === "my-strategy-v2",
+ *   (event) => console.log("Strategy v2 tested:", event.metricValue)
+ * );
+ *
+ * Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker",
  *   exchangeName: "binance",
  *   frameName: "1d-backtest"
  * });
+ *
+ * // Cancel if needed before event fires
+ * cancel();
  * ```
  */
-function listenDoneOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_DONE_ONCE_METHOD_NAME);
-    return doneEmitter.filter(filterFn).once(fn);
+function listenWalkerOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_WALKER_ONCE_METHOD_NAME);
+    return walkerEmitter.filter(filterFn).once(fn);
 }
 /**
- * Subscribes to backtest progress events with queued async processing.
+ * Subscribes to walker completion events with queued async processing.
  *
- * Emits during Backtest.background() execution to track progress.
+ * Emits when Walker.run() completes testing all strategies.
  * Events are processed sequentially in order received, even if callback is async.
  * Uses queued wrapper to prevent concurrent execution of the callback.
  *
- * @param fn - Callback function to handle progress events
+ * @param fn - Callback function to handle walker completion event
  * @returns Unsubscribe function to stop listening to events
  *
  * @example
  * ```typescript
- * import { listenProgress, Backtest } from "backtest-kit";
+ * import { listenWalkerComplete, Walker } from "backtest-kit";
  *
- * const unsubscribe = listenProgress((event) => {
- *   console.log(`Progress: ${(event.progress * 100).toFixed(2)}%`);
- *   console.log(`${event.processedFrames} / ${event.totalFrames} frames`);
- *   console.log(`Strategy: ${event.strategyName}, Symbol: ${event.symbol}`);
+ * const unsubscribe = listenWalkerComplete((results) => {
+ *   console.log(`Walker ${results.walkerName} completed!`);
+ *   console.log(`Best strategy: ${results.bestStrategy}`);
+ *   console.log(`Best ${results.metric}: ${results.bestMetric}`);
+ *   console.log(`Tested ${results.totalStrategies} strategies`);
  * });
  *
- * Backtest.background("BTCUSDT", {
- *   strategyName: "my-strategy",
+ * Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker",
  *   exchangeName: "binance",
  *   frameName: "1d-backtest"
  * });
@@ -4828,45 +7676,37 @@ function listenDoneOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenProgress(fn) {
-    backtest$1.loggerService.log(LISTEN_PROGRESS_METHOD_NAME);
-    return progressEmitter.subscribe(queued(async (event) => fn(event)));
+function listenWalkerComplete(fn) {
+    backtest$1.loggerService.log(LISTEN_WALKER_COMPLETE_METHOD_NAME);
+    return walkerCompleteSubject.subscribe(queued(async (event) => fn(event)));
 }
 /**
- * Subscribes to performance metric events with queued async processing.
+ * Subscribes to risk validation errors with queued async processing.
  *
- * Emits during strategy execution to track timing metrics for operations.
- * Useful for profiling and identifying performance bottlenecks.
+ * Emits when risk validation functions throw errors during signal checking.
+ * Useful for debugging and monitoring risk validation failures.
  * Events are processed sequentially in order received, even if callback is async.
  * Uses queued wrapper to prevent concurrent execution of the callback.
  *
- * @param fn - Callback function to handle performance events
+ * @param fn - Callback function to handle validation errors
  * @returns Unsubscribe function to stop listening to events
  *
  * @example
  * ```typescript
- * import { listenPerformance, Backtest } from "backtest-kit";
- *
- * const unsubscribe = listenPerformance((event) => {
- *   console.log(`${event.metricType}: ${event.duration.toFixed(2)}ms`);
- *   if (event.duration > 100) {
- *     console.warn("Slow operation detected:", event.metricType);
- *   }
- * });
+ * import { listenValidation } from "./function/event";
  *
- * Backtest.background("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "binance",
- *   frameName: "1d-backtest"
+ * const unsubscribe = listenValidation((error) => {
+ *   console.error("Risk validation error:", error.message);
+ *   // Log to monitoring service for debugging
  * });
  *
  * // Later: stop listening
  * unsubscribe();
  * ```
  */
-function listenPerformance(fn) {
-    backtest$1.loggerService.log(LISTEN_PERFORMANCE_METHOD_NAME);
-    return performanceEmitter.subscribe(queued(async (event) => fn(event)));
+function listenValidation(fn) {
+    backtest$1.loggerService.log(LISTEN_VALIDATION_METHOD_NAME);
+    return validationSubject.subscribe(queued(async (error) => fn(error)));
 }
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
@@ -5082,7 +7922,7 @@ class BacktestUtils {
                         break;
                     }
                 }
-                await doneEmitter.next({
+                await doneBacktestSubject.next({
                     exchangeName: context.exchangeName,
                     strategyName: context.strategyName,
                     backtest: true,
@@ -5262,7 +8102,7 @@ class LiveUtils {
                         break;
                     }
                 }
-                await doneEmitter.next({
+                await doneLiveSubject.next({
                     exchangeName: context.exchangeName,
                     strategyName: context.strategyName,
                     backtest: false,
@@ -5479,4 +8319,458 @@ class Performance {
     }
 }
 
-export { Backtest, ExecutionContextService, Live, MethodContextService, Performance, PersistBase, PersistSignalAdaper, addExchange, addFrame, addStrategy, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listStrategies, listenDone, listenDoneOnce, listenError, listenPerformance, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, setLogger };
+const WALKER_METHOD_NAME_RUN = "WalkerUtils.run";
+const WALKER_METHOD_NAME_BACKGROUND = "WalkerUtils.background";
+const WALKER_METHOD_NAME_GET_DATA = "WalkerUtils.getData";
+const WALKER_METHOD_NAME_GET_REPORT = "WalkerUtils.getReport";
+const WALKER_METHOD_NAME_DUMP = "WalkerUtils.dump";
+/**
+ * Utility class for walker operations.
+ *
+ * Provides simplified access to walkerGlobalService.run() with logging.
+ * Automatically pulls exchangeName and frameName from walker schema.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Walker } from "./classes/Walker";
+ *
+ * for await (const result of Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker"
+ * })) {
+ *   console.log("Progress:", result.strategiesTested, "/", result.totalStrategies);
+ *   console.log("Best strategy:", result.bestStrategy, result.bestMetric);
+ * }
+ * ```
+ */
+class WalkerUtils {
+    constructor() {
+        /**
+         * Runs walker comparison for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with walker name
+         * @returns Async generator yielding progress updates after each strategy
+         */
+        this.run = (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_RUN, {
+                symbol,
+                context,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_RUN);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+            backtest$1.exchangeValidationService.validate(walkerSchema.exchangeName, WALKER_METHOD_NAME_RUN);
+            backtest$1.frameValidationService.validate(walkerSchema.frameName, WALKER_METHOD_NAME_RUN);
+            for (const strategyName of walkerSchema.strategies) {
+                backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
+            }
+            backtest$1.walkerMarkdownService.clear(context.walkerName);
+            // Clear backtest data for all strategies
+            for (const strategyName of walkerSchema.strategies) {
+                backtest$1.backtestMarkdownService.clear(strategyName);
+                backtest$1.strategyGlobalService.clear(strategyName);
+            }
+            return backtest$1.walkerGlobalService.run(symbol, {
+                walkerName: context.walkerName,
+                exchangeName: walkerSchema.exchangeName,
+                frameName: walkerSchema.frameName,
+            });
+        };
+        /**
+         * Runs walker comparison in background without yielding results.
+         *
+         * Consumes all walker progress updates internally without exposing them.
+         * Useful for running walker comparison for side effects only (callbacks, logging).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with walker name
+         * @returns Cancellation closure
+         *
+         * @example
+         * ```typescript
+         * // Run walker silently, only callbacks will fire
+         * await Walker.background("BTCUSDT", {
+         *   walkerName: "my-walker"
+         * });
+         * console.log("Walker comparison completed");
+         * ```
+         */
+        this.background = (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_BACKGROUND, {
+                symbol,
+                context,
+            });
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+            let isStopped = false;
+            const task = async () => {
+                for await (const _ of this.run(symbol, context)) {
+                    if (isStopped) {
+                        break;
+                    }
+                }
+                await doneWalkerSubject.next({
+                    exchangeName: walkerSchema.exchangeName,
+                    strategyName: context.walkerName,
+                    backtest: true,
+                    symbol,
+                });
+            };
+            task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
+            return () => {
+                isStopped = true;
+            };
+        };
+        /**
+         * Gets walker results data from all strategy comparisons.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to get data for
+         * @returns Promise resolving to walker results data object
+         *
+         * @example
+         * ```typescript
+         * const results = await Walker.getData("BTCUSDT", "my-walker");
+         * console.log(results.bestStrategy, results.bestMetric);
+         * ```
+         */
+        this.getData = async (symbol, walkerName) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_DATA, {
+                symbol,
+                walkerName,
+            });
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            return await backtest$1.walkerMarkdownService.getData(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+                exchangeName: walkerSchema.exchangeName,
+                frameName: walkerSchema.frameName,
+            });
+        };
+        /**
+         * Generates markdown report with all strategy comparisons for a walker.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Walker.getReport("BTCUSDT", "my-walker");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, walkerName) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
+                symbol,
+                walkerName,
+            });
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+                exchangeName: walkerSchema.exchangeName,
+                frameName: walkerSchema.frameName,
+            });
+        };
+        /**
+         * Saves walker report to disk.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to save report for
+         * @param path - Optional directory path to save report (default: "./logs/walker")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./logs/walker/my-walker.md
+         * await Walker.dump("BTCUSDT", "my-walker");
+         *
+         * // Save to custom path: ./custom/path/my-walker.md
+         * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, walkerName, path) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
+                symbol,
+                walkerName,
+                path,
+            });
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+                exchangeName: walkerSchema.exchangeName,
+                frameName: walkerSchema.frameName,
+            }, path);
+        };
+    }
+}
+/**
+ * Singleton instance of WalkerUtils for convenient walker operations.
+ *
+ * @example
+ * ```typescript
+ * import { Walker } from "./classes/Walker";
+ *
+ * for await (const result of Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker"
+ * })) {
+ *   console.log("Progress:", result.strategiesTested, "/", result.totalStrategies);
+ *   console.log("Best so far:", result.bestStrategy, result.bestMetric);
+ * }
+ * ```
+ */
+const Walker = new WalkerUtils();
+
+const HEAT_METHOD_NAME_GET_DATA = "HeatUtils.getData";
+const HEAT_METHOD_NAME_GET_REPORT = "HeatUtils.getReport";
+const HEAT_METHOD_NAME_DUMP = "HeatUtils.dump";
+/**
+ * Utility class for portfolio heatmap operations.
+ *
+ * Provides simplified access to heatMarkdownService with logging.
+ * Automatically aggregates statistics across all symbols per strategy.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Heat } from "backtest-kit";
+ *
+ * // Get raw heatmap data for a strategy
+ * const stats = await Heat.getData("my-strategy");
+ * console.log(`Portfolio PNL: ${stats.portfolioTotalPnl}%`);
+ *
+ * // Generate markdown report
+ * const markdown = await Heat.getReport("my-strategy");
+ * console.log(markdown);
+ *
+ * // Save to disk
+ * await Heat.dump("my-strategy", "./reports");
+ * ```
+ */
+class HeatUtils {
+    constructor() {
+        /**
+         * Gets aggregated portfolio heatmap statistics for a strategy.
+         *
+         * Returns per-symbol breakdown and portfolio-wide metrics.
+         * Data is automatically collected from all closed signals for the strategy.
+         *
+         * @param strategyName - Strategy name to get heatmap data for
+         * @returns Promise resolving to heatmap statistics object
+         *
+         * @example
+         * ```typescript
+         * const stats = await Heat.getData("my-strategy");
+         *
+         * console.log(`Total symbols: ${stats.totalSymbols}`);
+         * console.log(`Portfolio Total PNL: ${stats.portfolioTotalPnl}%`);
+         * console.log(`Portfolio Sharpe Ratio: ${stats.portfolioSharpeRatio}`);
+         *
+         * // Iterate through per-symbol statistics
+         * stats.symbols.forEach(row => {
+         *   console.log(`${row.symbol}: ${row.totalPnl}% (${row.totalTrades} trades)`);
+         * });
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName });
+            return await backtest$1.heatMarkdownService.getData(strategyName);
+        };
+        /**
+         * Generates markdown report with portfolio heatmap table for a strategy.
+         *
+         * Table includes: Symbol, Total PNL, Sharpe Ratio, Max Drawdown, Trades.
+         * Symbols are sorted by Total PNL descending.
+         *
+         * @param strategyName - Strategy name to generate heatmap report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Heat.getReport("my-strategy");
+         * console.log(markdown);
+         * // Output:
+         * // # Portfolio Heatmap: my-strategy
+         * //
+         * // **Total Symbols:** 5 | **Portfolio PNL:** +45.3% | **Portfolio Sharpe:** 1.85 | **Total Trades:** 120
+         * //
+         * // | Symbol | Total PNL | Sharpe | Max DD | Trades |
+         * // |--------|-----------|--------|--------|--------|
+         * // | BTCUSDT | +15.5% | 2.10 | -2.5% | 45 |
+         * // | ETHUSDT | +12.3% | 1.85 | -3.1% | 38 |
+         * // ...
+         * ```
+         */
+        this.getReport = async (strategyName) => {
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
+            return await backtest$1.heatMarkdownService.getReport(strategyName);
+        };
+        /**
+         * Saves heatmap report to disk for a strategy.
+         *
+         * Creates directory if it doesn't exist.
+         * Default filename: {strategyName}.md
+         *
+         * @param strategyName - Strategy name to save heatmap report for
+         * @param path - Optional directory path to save report (default: "./logs/heatmap")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./logs/heatmap/my-strategy.md
+         * await Heat.dump("my-strategy");
+         *
+         * // Save to custom path: ./reports/my-strategy.md
+         * await Heat.dump("my-strategy", "./reports");
+         * ```
+         */
+        this.dump = async (strategyName, path) => {
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
+            await backtest$1.heatMarkdownService.dump(strategyName, path);
+        };
+    }
+}
+/**
+ * Singleton instance of HeatUtils for convenient heatmap operations.
+ *
+ * @example
+ * ```typescript
+ * import { Heat } from "backtest-kit";
+ *
+ * // Strategy-specific heatmap
+ * const stats = await Heat.getData("my-strategy");
+ * console.log(`Portfolio PNL: ${stats.portfolioTotalPnl}%`);
+ * console.log(`Total Symbols: ${stats.totalSymbols}`);
+ *
+ * // Per-symbol breakdown
+ * stats.symbols.forEach(row => {
+ *   console.log(`${row.symbol}:`);
+ *   console.log(`  Total PNL: ${row.totalPnl}%`);
+ *   console.log(`  Sharpe Ratio: ${row.sharpeRatio}`);
+ *   console.log(`  Max Drawdown: ${row.maxDrawdown}%`);
+ *   console.log(`  Trades: ${row.totalTrades}`);
+ * });
+ *
+ * // Generate and save report
+ * await Heat.dump("my-strategy", "./reports");
+ * ```
+ */
+const Heat = new HeatUtils();
+
+const POSITION_SIZE_METHOD_NAME_FIXED = "PositionSize.fixedPercentage";
+const POSITION_SIZE_METHOD_NAME_KELLY = "PositionSize.kellyCriterion";
+const POSITION_SIZE_METHOD_NAME_ATR = "PositionSize.atrBased";
+/**
+ * Utility class for position sizing calculations.
+ *
+ * Provides static methods for each sizing method with validation.
+ * Each method validates that the sizing schema matches the requested method.
+ *
+ * @example
+ * ```typescript
+ * import { PositionSize } from "./classes/PositionSize";
+ *
+ * // Fixed percentage sizing
+ * const quantity = await PositionSize.fixedPercentage(
+ *   "BTCUSDT",
+ *   10000,
+ *   50000,
+ *   49000,
+ *   { sizingName: "conservative" }
+ * );
+ *
+ * // Kelly Criterion sizing
+ * const quantity = await PositionSize.kellyCriterion(
+ *   "BTCUSDT",
+ *   10000,
+ *   50000,
+ *   0.55,
+ *   1.5,
+ *   { sizingName: "kelly" }
+ * );
+ *
+ * // ATR-based sizing
+ * const quantity = await PositionSize.atrBased(
+ *   "BTCUSDT",
+ *   10000,
+ *   50000,
+ *   500,
+ *   { sizingName: "atr-dynamic" }
+ * );
+ * ```
+ */
+class PositionSizeUtils {
+}
+/**
+ * Calculates position size using fixed percentage risk method.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param accountBalance - Current account balance
+ * @param priceOpen - Planned entry price
+ * @param priceStopLoss - Stop-loss price
+ * @param context - Execution context with sizing name
+ * @returns Promise resolving to calculated position size
+ * @throws Error if sizing schema method is not "fixed-percentage"
+ */
+PositionSizeUtils.fixedPercentage = async (symbol, accountBalance, priceOpen, priceStopLoss, context) => {
+    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_FIXED, {
+        context,
+        symbol,
+    });
+    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_FIXED, "fixed-percentage");
+    return await backtest$1.sizingGlobalService.calculate({
+        symbol,
+        accountBalance,
+        priceOpen,
+        priceStopLoss,
+        method: "fixed-percentage",
+    }, context);
+};
+/**
+ * Calculates position size using Kelly Criterion method.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param accountBalance - Current account balance
+ * @param priceOpen - Planned entry price
+ * @param winRate - Win rate (0-1)
+ * @param winLossRatio - Average win/loss ratio
+ * @param context - Execution context with sizing name
+ * @returns Promise resolving to calculated position size
+ * @throws Error if sizing schema method is not "kelly-criterion"
+ */
+PositionSizeUtils.kellyCriterion = async (symbol, accountBalance, priceOpen, winRate, winLossRatio, context) => {
+    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_KELLY, {
+        context,
+        symbol,
+    });
+    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_KELLY, "kelly-criterion");
+    return await backtest$1.sizingGlobalService.calculate({
+        symbol,
+        accountBalance,
+        priceOpen,
+        winRate,
+        winLossRatio,
+        method: "kelly-criterion",
+    }, context);
+};
+/**
+ * Calculates position size using ATR-based method.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param accountBalance - Current account balance
+ * @param priceOpen - Planned entry price
+ * @param atr - Current ATR value
+ * @param context - Execution context with sizing name
+ * @returns Promise resolving to calculated position size
+ * @throws Error if sizing schema method is not "atr-based"
+ */
+PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, context) => {
+    backtest$1.loggerService.info(POSITION_SIZE_METHOD_NAME_ATR, {
+        context,
+        symbol,
+    });
+    backtest$1.sizingValidationService.validate(context.sizingName, POSITION_SIZE_METHOD_NAME_ATR, "atr-based");
+    return await backtest$1.sizingGlobalService.calculate({
+        symbol,
+        accountBalance,
+        priceOpen,
+        atr,
+        method: "atr-based",
+    }, context);
+};
+const PositionSize = PositionSizeUtils;
+
+export { Backtest, ExecutionContextService, Heat, Live, MethodContextService, Performance, PersistBase, PersistRiskAdapter, PersistSignalAdaper, PositionSize, Walker, addExchange, addFrame, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listRisks, listSizings, listStrategies, listWalkers, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenPerformance, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, setLogger };