@backtest-kit/ui 5.5.3 → 5.6.2

package/build/index.cjs

@@ -20,10 +20,10 @@ const CC_WWWROOT_HOST = process.env.CC_WWWROOT_HOST || "0.0.0.0";
 const CC_WWWROOT_PORT = parseInt(process.env.CC_WWWROOT_PORT) || 60050;
 const CC_ENABLE_MOCK = !!parseInt(process.env.CC_ENABLE_MOCK) || false;
 
-const router$7 = Router({
+const router$9 = Router({
     params: true,
 });
-router$7.get("/api/v1/health/health_check", async (req, res) => {
+router$9.get("/api/v1/health/health_check", async (req, res) => {
     const [cpuLoad] = os.loadavg();
     return await micro.send(res, 200, {
         uptime: process.uptime(),
@@ -62,6 +62,8 @@ const connectionServices$1 = {
 };
 const metaServices$1 = {
     symbolMetaService: Symbol("symbolMetaService"),
+    backtestMetaService: Symbol("backtestMetaService"),
+    liveMetaService: Symbol("liveMetaService"),
 };
 const mockServices$1 = {
     notificationMockService: Symbol("notificationMockService"),
@@ -69,6 +71,7 @@ const mockServices$1 = {
     exchangeMockService: Symbol("exchangeMockService"),
     logMockService: Symbol("logMockService"),
     statusMockService: Symbol("statusMockService"),
+    markdownMockService: Symbol("markdownMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
@@ -76,6 +79,7 @@ const viewServices$1 = {
     exchangeViewService: Symbol("exchangeViewService"),
     logViewService: Symbol("logViewService"),
     statusViewService: Symbol("statusViewService"),
+    markdownViewService: Symbol("markdownViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -435,6 +439,147 @@ class StatusMockService {
     }
 }
 
+const MOCK_DIR = "./mock/markdown";
+const makeReader = (fileName) => functoolsKit.singleshot(() => fs.readFile(path.join(MOCK_DIR, fileName), "utf-8"));
+const makeDataReader = (fileName) => functoolsKit.singleshot(async () => JSON.parse(await fs.readFile(path.join(MOCK_DIR, "data", fileName), "utf-8")));
+const readBacktest = makeReader("backtest.md");
+const readStrategy = makeReader("strategy.md");
+const readLive = makeReader("live.md");
+const readBreakeven = makeReader("breakeven.md");
+const readRisk = makeReader("risk.md");
+const readPartial = makeReader("partial.md");
+const readHighestProfit = makeReader("highest_profit.md");
+const readSchedule = makeReader("schedule.md");
+const readPerformance = makeReader("performance.md");
+const readSync = makeReader("sync.md");
+const readHeat = makeReader("heat.md");
+const readWalker = makeReader("walker.md");
+const readBacktestData = makeDataReader("backtest.json");
+const readStrategyData = makeDataReader("strategy.json");
+const readLiveData = makeDataReader("live.json");
+const readBreakevenData = makeDataReader("breakeven.json");
+const readRiskData = makeDataReader("risk.json");
+const readPartialData = makeDataReader("partial.json");
+const readHighestProfitData = makeDataReader("highest_profit.json");
+const readScheduleData = makeDataReader("schedule.json");
+const readPerformanceData = makeDataReader("performance.json");
+const readSyncData = makeDataReader("sync.json");
+const readHeatData = makeDataReader("heat.json");
+const readWalkerData = makeDataReader("walker.json");
+class MarkdownMockService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        // Strategy
+        this.getStrategyData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getStrategyData", { symbol, strategyName, exchangeName, frameName });
+            return readStrategyData();
+        };
+        this.getStrategyReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getStrategyReport", { symbol, strategyName, exchangeName, frameName });
+            return readStrategy();
+        };
+        // Backtest
+        this.getBacktestData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getBacktestData", { symbol, strategyName, exchangeName, frameName });
+            return readBacktestData();
+        };
+        this.getBacktestReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getBacktestReport", { symbol, strategyName, exchangeName, frameName });
+            return readBacktest();
+        };
+        // Live
+        this.getLiveData = async (symbol, strategyName, exchangeName) => {
+            this.loggerService.log("markdownMockService getLiveData", { symbol, strategyName, exchangeName });
+            return readLiveData();
+        };
+        this.getLiveReport = async (symbol, strategyName, exchangeName) => {
+            this.loggerService.log("markdownMockService getLiveReport", { symbol, strategyName, exchangeName });
+            return readLive();
+        };
+        // Breakeven
+        this.getBreakevenData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getBreakevenData", { symbol, strategyName, exchangeName, frameName });
+            return readBreakevenData();
+        };
+        this.getBreakevenReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getBreakevenReport", { symbol, strategyName, exchangeName, frameName });
+            return readBreakeven();
+        };
+        // Risk
+        this.getRiskData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getRiskData", { symbol, strategyName, exchangeName, frameName });
+            return readRiskData();
+        };
+        this.getRiskReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getRiskReport", { symbol, strategyName, exchangeName, frameName });
+            return readRisk();
+        };
+        // Partial
+        this.getPartialData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getPartialData", { symbol, strategyName, exchangeName, frameName });
+            return readPartialData();
+        };
+        this.getPartialReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getPartialReport", { symbol, strategyName, exchangeName, frameName });
+            return readPartial();
+        };
+        // HighestProfit
+        this.getHighestProfitData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getHighestProfitData", { symbol, strategyName, exchangeName, frameName });
+            return readHighestProfitData();
+        };
+        this.getHighestProfitReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getHighestProfitReport", { symbol, strategyName, exchangeName, frameName });
+            return readHighestProfit();
+        };
+        // Schedule
+        this.getScheduleData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getScheduleData", { symbol, strategyName, exchangeName, frameName });
+            return readScheduleData();
+        };
+        this.getScheduleReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getScheduleReport", { symbol, strategyName, exchangeName, frameName });
+            return readSchedule();
+        };
+        // Performance
+        this.getPerformanceData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getPerformanceData", { symbol, strategyName, exchangeName, frameName });
+            return readPerformanceData();
+        };
+        this.getPerformanceReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getPerformanceReport", { symbol, strategyName, exchangeName, frameName });
+            return readPerformance();
+        };
+        // Sync
+        this.getSyncData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getSyncData", { symbol, strategyName, exchangeName, frameName });
+            return readSyncData();
+        };
+        this.getSyncReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getSyncReport", { symbol, strategyName, exchangeName, frameName });
+            return readSync();
+        };
+        // Heat
+        this.getHeatData = async (strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getHeatData", { strategyName, exchangeName, frameName });
+            return readHeatData();
+        };
+        this.getHeatReport = async (strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownMockService getHeatReport", { strategyName, exchangeName, frameName });
+            return readHeat();
+        };
+        // Walker
+        this.getWalkerData = async (symbol, walkerName) => {
+            this.loggerService.log("markdownMockService getWalkerData", { symbol, walkerName });
+            return readWalkerData();
+        };
+        this.getWalkerReport = async (symbol, walkerName) => {
+            this.loggerService.log("markdownMockService getWalkerReport", { symbol, walkerName });
+            return readWalker();
+        };
+    }
+}
+
 const DEFAULT_LIMIT$1 = 25;
 const DEFAULT_OFFSET$1 = 0;
 const CREATE_FILTER_LIST_FN$1 = (filterData) => Object.keys(filterData).map((key) => (row) => new RegExp(filterData[key], "i").test(row[key]));
@@ -781,6 +926,193 @@ class StatusViewService {
     }
 }
 
+class MarkdownViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.markdownMockService = inject(TYPES.markdownMockService);
+        // Strategy
+        this.getStrategyData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getStrategyData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getStrategyData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Strategy.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getStrategyReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getStrategyReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getStrategyReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Strategy.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // Backtest
+        this.getBacktestData = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownViewService getBacktestData", { symbol, strategyName, exchangeName, frameName });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getBacktestData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Backtest.getData(symbol, { strategyName, exchangeName, frameName });
+        };
+        this.getBacktestReport = async (symbol, strategyName, exchangeName, frameName) => {
+            this.loggerService.log("markdownViewService getBacktestReport", { symbol, strategyName, exchangeName, frameName });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getBacktestReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Backtest.getReport(symbol, { strategyName, exchangeName, frameName });
+        };
+        // Live
+        this.getLiveData = async (symbol, strategyName, exchangeName) => {
+            this.loggerService.log("markdownViewService getLiveData", { symbol, strategyName, exchangeName });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getLiveData(symbol, strategyName, exchangeName);
+            }
+            return await backtestKit.Live.getData(symbol, { strategyName, exchangeName });
+        };
+        this.getLiveReport = async (symbol, strategyName, exchangeName) => {
+            this.loggerService.log("markdownViewService getLiveReport", { symbol, strategyName, exchangeName });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getLiveReport(symbol, strategyName, exchangeName);
+            }
+            return await backtestKit.Live.getReport(symbol, { strategyName, exchangeName });
+        };
+        // Breakeven
+        this.getBreakevenData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getBreakevenData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getBreakevenData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Breakeven.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getBreakevenReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getBreakevenReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getBreakevenReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Breakeven.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // Risk
+        this.getRiskData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getRiskData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getRiskData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Risk.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getRiskReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getRiskReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getRiskReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Risk.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // Partial
+        this.getPartialData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getPartialData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getPartialData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Partial.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getPartialReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getPartialReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getPartialReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Partial.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // HighestProfit
+        this.getHighestProfitData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getHighestProfitData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getHighestProfitData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.HighestProfit.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getHighestProfitReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getHighestProfitReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getHighestProfitReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.HighestProfit.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // Schedule
+        this.getScheduleData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getScheduleData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getScheduleData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Schedule.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getScheduleReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getScheduleReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getScheduleReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Schedule.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // Performance
+        this.getPerformanceData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getPerformanceData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getPerformanceData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Performance.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getPerformanceReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getPerformanceReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getPerformanceReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Performance.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // Sync
+        this.getSyncData = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getSyncData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getSyncData(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Sync.getData(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getSyncReport = async (symbol, strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getSyncReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getSyncReport(symbol, strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Sync.getReport(symbol, { strategyName, exchangeName, frameName }, backtest);
+        };
+        // Heat
+        this.getHeatData = async (strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getHeatData", { strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getHeatData(strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Heat.getData({ strategyName, exchangeName, frameName }, backtest);
+        };
+        this.getHeatReport = async (strategyName, exchangeName, frameName, backtest = false) => {
+            this.loggerService.log("markdownViewService getHeatReport", { strategyName, exchangeName, frameName, backtest });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getHeatReport(strategyName, exchangeName, frameName);
+            }
+            return await backtestKit.Heat.getReport({ strategyName, exchangeName, frameName }, backtest);
+        };
+        // Walker
+        this.getWalkerData = async (symbol, walkerName) => {
+            this.loggerService.log("markdownViewService getWalkerData", { symbol, walkerName });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getWalkerData(symbol, walkerName);
+            }
+            return await backtestKit.Walker.getData(symbol, { walkerName });
+        };
+        this.getWalkerReport = async (symbol, walkerName) => {
+            this.loggerService.log("markdownViewService getWalkerReport", { symbol, walkerName });
+            if (CC_ENABLE_MOCK) {
+                return await this.markdownMockService.getWalkerReport(symbol, walkerName);
+            }
+            return await backtestKit.Walker.getReport(symbol, { walkerName });
+        };
+    }
+}
+
 const symbol_list = [
     {
         icon: "/icon/btc.png",
@@ -922,6 +1254,41 @@ class PriceConnectionService {
     }
 }
 
+const BACKTEST_LIST = [
+    { id: "mock-backtest-1", symbol: "BTCUSDT", strategyName: "mock-strategy", exchangeName: "binance", frameName: "1m", status: "done" },
+    { id: "mock-backtest-2", symbol: "ETHUSDT", strategyName: "mock-strategy", exchangeName: "binance", frameName: "1m", status: "running" },
+    { id: "mock-backtest-3", symbol: "BNBUSDT", strategyName: "mock-strategy", exchangeName: "binance", frameName: "1m", status: "idle" },
+];
+class BacktestMetaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.list = async () => {
+            this.loggerService.log("backtestMetaService list");
+            if (CC_ENABLE_MOCK) {
+                return BACKTEST_LIST;
+            }
+            return await backtestKit.Backtest.list();
+        };
+    }
+}
+
+const LIVE_LIST = [
+    { id: "mock-live-1", symbol: "BTCUSDT", strategyName: "mock-strategy", exchangeName: "binance", status: "running" },
+    { id: "mock-live-2", symbol: "ETHUSDT", strategyName: "mock-strategy", exchangeName: "binance", status: "idle" },
+];
+class LiveMetaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.list = async () => {
+            this.loggerService.log("liveMetaService list");
+            if (CC_ENABLE_MOCK) {
+                return LIVE_LIST;
+            }
+            return await backtestKit.Live.list();
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
     provide(TYPES.exchangeService, () => new ExchangeService());
@@ -931,7 +1298,9 @@ class PriceConnectionService {
     provide(TYPES.priceConnectionService, () => new PriceConnectionService());
 }
 {
+    provide(TYPES.liveMetaService, () => new LiveMetaService());
     provide(TYPES.symbolMetaService, () => new SymbolMetaService());
+    provide(TYPES.backtestMetaService, () => new BacktestMetaService());
 }
 {
     provide(TYPES.notificationMockService, () => new NotificationMockService());
@@ -939,6 +1308,7 @@ class PriceConnectionService {
     provide(TYPES.exchangeMockService, () => new ExchangeMockService());
     provide(TYPES.logMockService, () => new LogMockService());
     provide(TYPES.statusMockService, () => new StatusMockService());
+    provide(TYPES.markdownMockService, () => new MarkdownMockService());
 }
 {
     provide(TYPES.notificationViewService, () => new NotificationViewService());
@@ -946,6 +1316,7 @@ class PriceConnectionService {
     provide(TYPES.exchangeViewService, () => new ExchangeViewService());
     provide(TYPES.logViewService, () => new LogViewService());
     provide(TYPES.statusViewService, () => new StatusViewService());
+    provide(TYPES.markdownViewService, () => new MarkdownViewService());
 }
 
 const baseServices = {
@@ -957,7 +1328,9 @@ const connectionServices = {
     priceConnectionService: inject(TYPES.priceConnectionService),
 };
 const metaServices = {
+    liveMetaService: inject(TYPES.liveMetaService),
     symbolMetaService: inject(TYPES.symbolMetaService),
+    backtestMetaService: inject(TYPES.backtestMetaService),
 };
 const mockServices = {
     notificationMockService: inject(TYPES.notificationMockService),
@@ -965,6 +1338,7 @@ const mockServices = {
     exchangeMockService: inject(TYPES.exchangeMockService),
     logMockService: inject(TYPES.logMockService),
     statusMockService: inject(TYPES.statusMockService),
+    markdownMockService: inject(TYPES.markdownMockService),
 };
 const viewServices = {
     notificationViewService: inject(TYPES.notificationViewService),
@@ -972,6 +1346,7 @@ const viewServices = {
     exchangeViewService: inject(TYPES.exchangeViewService),
     logViewService: inject(TYPES.logViewService),
     statusViewService: inject(TYPES.statusViewService),
+    markdownViewService: inject(TYPES.markdownViewService),
 };
 const ioc = {
     ...baseServices,
@@ -982,11 +1357,11 @@ const ioc = {
 };
 init();
 
-const router$6 = Router({
+const router$8 = Router({
     params: true,
 });
 // ExchangeMockService endpoints
-router$6.post("/api/v1/mock/candles_signal", async (req, res) => {
+router$8.post("/api/v1/mock/candles_signal", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1014,7 +1389,7 @@ router$6.post("/api/v1/mock/candles_signal", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/candles_point", async (req, res) => {
+router$8.post("/api/v1/mock/candles_point", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
@@ -1048,7 +1423,7 @@ router$6.post("/api/v1/mock/candles_point", async (req, res) => {
     }
 });
 // NotificationMockService endpoints
-router$6.post("/api/v1/mock/notification_list", async (req, res) => {
+router$8.post("/api/v1/mock/notification_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1076,7 +1451,7 @@ router$6.post("/api/v1/mock/notification_list", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/notification_one/:id", async (req, res) => {
+router$8.post("/api/v1/mock/notification_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1105,7 +1480,7 @@ router$6.post("/api/v1/mock/notification_one/:id", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/notification_filter", async (req, res) => {
+router$8.post("/api/v1/mock/notification_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -1134,7 +1509,7 @@ router$6.post("/api/v1/mock/notification_filter", async (req, res) => {
     }
 });
 // StorageMockService endpoints
-router$6.post("/api/v1/mock/storage_one/:id", async (req, res) => {
+router$8.post("/api/v1/mock/storage_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1163,7 +1538,7 @@ router$6.post("/api/v1/mock/storage_one/:id", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/storage_list/live", async (req, res) => {
+router$8.post("/api/v1/mock/storage_list/live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1191,7 +1566,7 @@ router$6.post("/api/v1/mock/storage_list/live", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/storage_list/backtest", async (req, res) => {
+router$8.post("/api/v1/mock/storage_list/backtest", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1220,7 +1595,7 @@ router$6.post("/api/v1/mock/storage_list/backtest", async (req, res) => {
     }
 });
 // LogMockService endpoints
-router$6.post("/api/v1/mock/log_list", async (req, res) => {
+router$8.post("/api/v1/mock/log_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1248,7 +1623,7 @@ router$6.post("/api/v1/mock/log_list", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/log_one/:id", async (req, res) => {
+router$8.post("/api/v1/mock/log_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1277,7 +1652,7 @@ router$6.post("/api/v1/mock/log_one/:id", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/log_filter", async (req, res) => {
+router$8.post("/api/v1/mock/log_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -1305,7 +1680,7 @@ router$6.post("/api/v1/mock/log_filter", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/candles_live", async (req, res) => {
+router$8.post("/api/v1/mock/candles_live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1334,7 +1709,7 @@ router$6.post("/api/v1/mock/candles_live", async (req, res) => {
     }
 });
 // StatusMockService endpoints
-router$6.post("/api/v1/mock/status_list", async (req, res) => {
+router$8.post("/api/v1/mock/status_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1362,7 +1737,7 @@ router$6.post("/api/v1/mock/status_list", async (req, res) => {
         });
     }
 });
-router$6.post("/api/v1/mock/status_one/:id", async (req, res) => {
+router$8.post("/api/v1/mock/status_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1392,11 +1767,11 @@ router$6.post("/api/v1/mock/status_one/:id", async (req, res) => {
     }
 });
 
-const router$5 = Router({
+const router$7 = Router({
     params: true,
 });
 // ExchangeViewService endpoints
-router$5.post("/api/v1/view/candles_signal", async (req, res) => {
+router$7.post("/api/v1/view/candles_signal", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1424,7 +1799,7 @@ router$5.post("/api/v1/view/candles_signal", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/candles_point", async (req, res) => {
+router$7.post("/api/v1/view/candles_point", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { currentTime, interval, requestId, serviceName, symbol, exchangeName } = request;
@@ -1457,7 +1832,7 @@ router$5.post("/api/v1/view/candles_point", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/candles_live", async (req, res) => {
+router$7.post("/api/v1/view/candles_live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { signalId, interval, requestId, serviceName } = request;
@@ -1486,7 +1861,7 @@ router$5.post("/api/v1/view/candles_live", async (req, res) => {
     }
 });
 // NotificationViewService endpoints
-router$5.post("/api/v1/view/notification_list", async (req, res) => {
+router$7.post("/api/v1/view/notification_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1514,7 +1889,7 @@ router$5.post("/api/v1/view/notification_list", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/notification_one/:id", async (req, res) => {
+router$7.post("/api/v1/view/notification_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1543,7 +1918,7 @@ router$5.post("/api/v1/view/notification_one/:id", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/notification_filter", async (req, res) => {
+router$7.post("/api/v1/view/notification_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -1572,7 +1947,7 @@ router$5.post("/api/v1/view/notification_filter", async (req, res) => {
     }
 });
 // StorageViewService endpoints
-router$5.post("/api/v1/view/storage_one/:id", async (req, res) => {
+router$7.post("/api/v1/view/storage_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1601,7 +1976,7 @@ router$5.post("/api/v1/view/storage_one/:id", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/storage_list/live", async (req, res) => {
+router$7.post("/api/v1/view/storage_list/live", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1629,7 +2004,7 @@ router$5.post("/api/v1/view/storage_list/live", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/storage_list/backtest", async (req, res) => {
+router$7.post("/api/v1/view/storage_list/backtest", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1658,7 +2033,7 @@ router$5.post("/api/v1/view/storage_list/backtest", async (req, res) => {
     }
 });
 // LogViewService endpoints
-router$5.post("/api/v1/view/log_list", async (req, res) => {
+router$7.post("/api/v1/view/log_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1686,7 +2061,7 @@ router$5.post("/api/v1/view/log_list", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/log_one/:id", async (req, res) => {
+router$7.post("/api/v1/view/log_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1715,7 +2090,7 @@ router$5.post("/api/v1/view/log_one/:id", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/log_filter", async (req, res) => {
+router$7.post("/api/v1/view/log_filter", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, filterData, limit, offset } = request;
@@ -1744,7 +2119,7 @@ router$5.post("/api/v1/view/log_filter", async (req, res) => {
     }
 });
 // StatusViewService endpoints
-router$5.post("/api/v1/view/status_list", async (req, res) => {
+router$7.post("/api/v1/view/status_list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1772,7 +2147,7 @@ router$5.post("/api/v1/view/status_list", async (req, res) => {
         });
     }
 });
-router$5.post("/api/v1/view/status_one/:id", async (req, res) => {
+router$7.post("/api/v1/view/status_one/:id", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1809,7 +2184,7 @@ function getModulesPath() {
     return path.join(basePath, "../../../");
 }
 
-const router$4 = Router({
+const router$6 = Router({
     params: true,
 });
 // getModulesPath
@@ -1826,7 +2201,7 @@ const ASSET_32 = CC_ENABLE_MOCK
 const cache128 = new Map();
 const cache32 = new Map();
 const cacheSvg = new Map();
-router$4.get("/icon/128/:filename", async (req, res) => {
+router$6.get("/icon/128/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cache128.has(filename)) {
@@ -1842,7 +2217,7 @@ router$4.get("/icon/128/:filename", async (req, res) => {
     }
     return await micro.send(res, 404, "File not found (128)");
 });
-router$4.get("/icon/32/:filename", async (req, res) => {
+router$6.get("/icon/32/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cache32.has(filename)) {
@@ -1858,7 +2233,7 @@ router$4.get("/icon/32/:filename", async (req, res) => {
     }
     return await micro.send(res, 404, "File not found (32)");
 });
-router$4.get("/icon/svg/:filename", async (req, res) => {
+router$6.get("/icon/svg/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cacheSvg.has(filename)) {
@@ -1874,7 +2249,7 @@ router$4.get("/icon/svg/:filename", async (req, res) => {
     }
     return await micro.send(res, 404, "File not found (svg)");
 });
-router$4.get("/icon/:filename", async (req, res) => {
+router$6.get("/icon/:filename", async (req, res) => {
     const filename = req.params.filename;
     // Check cache first
     if (cache32.has(filename)) {
@@ -1891,10 +2266,10 @@ router$4.get("/icon/:filename", async (req, res) => {
     return await micro.send(res, 404, "File not found (root)");
 });
 
-const router$3 = Router({
+const router$5 = Router({
     params: true,
 });
-router$3.post("/api/v1/dict/symbol/list", async (req, res) => {
+router$5.post("/api/v1/dict/symbol/list", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1922,7 +2297,7 @@ router$3.post("/api/v1/dict/symbol/list", async (req, res) => {
         });
     }
 });
-router$3.post("/api/v1/dict/symbol/map", async (req, res) => {
+router$5.post("/api/v1/dict/symbol/map", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName } = request;
@@ -1950,7 +2325,7 @@ router$3.post("/api/v1/dict/symbol/map", async (req, res) => {
         });
     }
 });
-router$3.post("/api/v1/dict/symbol/one", async (req, res) => {
+router$5.post("/api/v1/dict/symbol/one", async (req, res) => {
     try {
         const request = await micro.json(req);
         const { requestId, serviceName, id } = request;
@@ -1979,6 +2354,686 @@ router$3.post("/api/v1/dict/symbol/one", async (req, res) => {
     }
 });
 
+const router$4 = Router({
+    params: true,
+});
+router$4.post("/api/v1/markdown_mock/strategy_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getStrategyData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/strategy_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getStrategyReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/strategy_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/backtest_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getBacktestData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/backtest_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/backtest_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/backtest_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getBacktestReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/backtest_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/backtest_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/live_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
+        const data = await ioc.markdownMockService.getLiveData(symbol, strategyName, exchangeName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/live_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/live_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/live_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
+        const data = await ioc.markdownMockService.getLiveReport(symbol, strategyName, exchangeName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/live_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/live_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/breakeven_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getBreakevenData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/breakeven_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/breakeven_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/breakeven_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getBreakevenReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/breakeven_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/breakeven_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/risk_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getRiskData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/risk_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/risk_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/risk_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getRiskReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/risk_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/risk_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/partial_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getPartialData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/partial_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/partial_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/partial_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getPartialReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/partial_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/partial_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/highest_profit_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getHighestProfitData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/highest_profit_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/highest_profit_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/highest_profit_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getHighestProfitReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/highest_profit_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/highest_profit_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/schedule_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getScheduleData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/schedule_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/schedule_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/schedule_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getScheduleReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/schedule_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/schedule_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/performance_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getPerformanceData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/performance_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/performance_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/performance_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getPerformanceReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/performance_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/performance_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/sync_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getSyncData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/sync_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/sync_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/sync_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getSyncReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/sync_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/sync_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/heat_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getHeatData(strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/heat_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/heat_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/heat_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownMockService.getHeatReport(strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/heat_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/heat_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/walker_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, walkerName } = request;
+        const data = await ioc.markdownMockService.getWalkerData(symbol, walkerName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/walker_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/walker_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$4.post("/api/v1/markdown_mock/walker_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, walkerName } = request;
+        const data = await ioc.markdownMockService.getWalkerReport(symbol, walkerName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_mock/walker_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_mock/walker_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+
+const router$3 = Router({
+    params: true,
+});
+router$3.post("/api/v1/markdown_view/strategy_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getStrategyData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/strategy_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getStrategyReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/strategy_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/backtest_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownViewService.getBacktestData(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/backtest_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/backtest_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/backtest_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName } = request;
+        const data = await ioc.markdownViewService.getBacktestReport(symbol, strategyName, exchangeName, frameName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/backtest_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/backtest_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/live_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
+        const data = await ioc.markdownViewService.getLiveData(symbol, strategyName, exchangeName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/live_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/live_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/live_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName } = request;
+        const data = await ioc.markdownViewService.getLiveReport(symbol, strategyName, exchangeName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/live_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/live_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/breakeven_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getBreakevenData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/breakeven_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/breakeven_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/breakeven_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getBreakevenReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/breakeven_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/breakeven_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/risk_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getRiskData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/risk_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/risk_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/risk_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getRiskReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/risk_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/risk_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/partial_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getPartialData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/partial_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/partial_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/partial_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getPartialReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/partial_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/partial_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/highest_profit_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getHighestProfitData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/highest_profit_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/highest_profit_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/highest_profit_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getHighestProfitReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/highest_profit_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/highest_profit_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/schedule_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getScheduleData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/schedule_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/schedule_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/schedule_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getScheduleReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/schedule_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/schedule_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/performance_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getPerformanceData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/performance_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/performance_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/performance_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getPerformanceReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/performance_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/performance_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/sync_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getSyncData(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/sync_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/sync_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/sync_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getSyncReport(symbol, strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/sync_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/sync_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/heat_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getHeatData(strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/heat_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/heat_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/heat_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, strategyName, exchangeName, frameName, backtest } = request;
+        const data = await ioc.markdownViewService.getHeatReport(strategyName, exchangeName, frameName, backtest);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/heat_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/heat_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/walker_data", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, walkerName } = request;
+        const data = await ioc.markdownViewService.getWalkerData(symbol, walkerName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/walker_data ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/walker_data error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$3.post("/api/v1/markdown_view/walker_report", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName, symbol, walkerName } = request;
+        const data = await ioc.markdownViewService.getWalkerReport(symbol, walkerName);
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/markdown_view/walker_report ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/markdown_view/walker_report error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+
 const router$2 = Router({
     params: true,
 });
@@ -2010,6 +3065,34 @@ router$2.post("/api/v1/global/signal_pending_price", async (req, res) => {
         });
     }
 });
+router$2.post("/api/v1/global/backtest_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.backtestMetaService.list();
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/global/backtest_list ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/global/backtest_list error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
+router$2.post("/api/v1/global/live_list", async (req, res) => {
+    try {
+        const request = await micro.json(req);
+        const { requestId, serviceName } = request;
+        const data = await ioc.liveMetaService.list();
+        const result = { data, status: "ok", error: "", requestId, serviceName };
+        ioc.loggerService.log("/api/v1/global/live_list ok", { request, result: omit(result, "data") });
+        return await micro.send(res, 200, result);
+    }
+    catch (error) {
+        ioc.loggerService.log("/api/v1/global/live_list error", { error: functoolsKit.errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: functoolsKit.getErrorMessage(error) });
+    }
+});
 
 const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 function getPublicPath() {
@@ -2022,20 +3105,26 @@ const router = Router({
     params: true,
 });
 router.all("/api/v1/health/*", (req, res) => {
-    return router$7(req, res, finalhandler(req, res));
+    return router$9(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/mock/*", (req, res) => {
-    return router$6(req, res, finalhandler(req, res));
+    return router$8(req, res, finalhandler(req, res));
 });
 router.all("/api/v1/view/*", (req, res) => {
-    return router$5(req, res, finalhandler(req, res));
+    return router$7(req, res, finalhandler(req, res));
 });
-router.all("/icon/*", (req, res) => {
+router.all("/api/v1/markdown_mock/*", (req, res) => {
     return router$4(req, res, finalhandler(req, res));
 });
-router.all("/api/v1/dict/*", (req, res) => {
+router.all("/api/v1/markdown_view/*", (req, res) => {
     return router$3(req, res, finalhandler(req, res));
 });
+router.all("/icon/*", (req, res) => {
+    return router$6(req, res, finalhandler(req, res));
+});
+router.all("/api/v1/dict/*", (req, res) => {
+    return router$5(req, res, finalhandler(req, res));
+});
 router.all("/api/v1/global/*", (req, res) => {
     return router$2(req, res, finalhandler(req, res));
 });