@backtest-kit/ui 5.5.3 → 5.6.0

package/build/index.mjs

@@ -6,7 +6,7 @@ import finalhandler from 'finalhandler';
 import serveHandler from 'serve-handler';
 import os from 'os';
 import { createActivator } from 'di-kit';
-import { alignToInterval, Exchange, Notification, Storage, Log, Live, lib } from 'backtest-kit';
+import { alignToInterval, Exchange, Notification, Storage, Log, Live, Backtest, Breakeven, Risk, Partial, HighestProfit, Schedule, Performance, Sync, Heat, Walker, lib } from 'backtest-kit';
 import fs, { readdir, readFile } from 'fs/promises';
 import path, { join, dirname } from 'path';
 import { createRequire } from 'module';
@@ -17,10 +17,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(),
@@ -59,6 +59,8 @@ const connectionServices$1 = {
 };
 const metaServices$1 = {
     symbolMetaService: Symbol("symbolMetaService"),
+    backtestMetaService: Symbol("backtestMetaService"),
+    liveMetaService: Symbol("liveMetaService"),
 };
 const mockServices$1 = {
     notificationMockService: Symbol("notificationMockService"),
@@ -66,6 +68,7 @@ const mockServices$1 = {
     exchangeMockService: Symbol("exchangeMockService"),
     logMockService: Symbol("logMockService"),
     statusMockService: Symbol("statusMockService"),
+    markdownMockService: Symbol("markdownMockService"),
 };
 const viewServices$1 = {
     notificationViewService: Symbol("notificationViewService"),
@@ -73,6 +76,7 @@ const viewServices$1 = {
     exchangeViewService: Symbol("exchangeViewService"),
     logViewService: Symbol("logViewService"),
     statusViewService: Symbol("statusViewService"),
+    markdownViewService: Symbol("markdownViewService"),
 };
 const TYPES = {
     ...baseServices$1,
@@ -432,6 +436,136 @@ class StatusMockService {
     }
 }
 
+const MOCK_DIR = "./mock/markdown";
+const makeReader = (fileName) => singleshot(() => fs.readFile(path.join(MOCK_DIR, fileName), "utf-8"));
+const makeDataReader = (fileName) => singleshot(async () => JSON.parse(await fs.readFile(path.join(MOCK_DIR, "data", fileName), "utf-8")));
+const readBacktest = makeReader("backtest.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 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);
+        // 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]));
@@ -778,6 +912,178 @@ class StatusViewService {
     }
 }
 
+class MarkdownViewService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.markdownMockService = inject(TYPES.markdownMockService);
+        // 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Walker.getReport(symbol, { walkerName });
+        };
+    }
+}
+
 const symbol_list = [
     {
         icon: "/icon/btc.png",
@@ -919,6 +1225,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 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 Live.list();
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
     provide(TYPES.exchangeService, () => new ExchangeService());
@@ -928,7 +1269,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());
@@ -936,6 +1279,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());
@@ -943,6 +1287,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 = {
@@ -954,7 +1299,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),
@@ -962,6 +1309,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),
@@ -969,6 +1317,7 @@ const viewServices = {
     exchangeViewService: inject(TYPES.exchangeViewService),
     logViewService: inject(TYPES.logViewService),
     statusViewService: inject(TYPES.statusViewService),
+    markdownViewService: inject(TYPES.markdownViewService),
 };
 const ioc = {
     ...baseServices,
@@ -979,11 +1328,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;
@@ -1011,7 +1360,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;
@@ -1045,7 +1394,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;
@@ -1073,7 +1422,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;
@@ -1102,7 +1451,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;
@@ -1131,7 +1480,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;
@@ -1160,7 +1509,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;
@@ -1188,7 +1537,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;
@@ -1217,7 +1566,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;
@@ -1245,7 +1594,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;
@@ -1274,7 +1623,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;
@@ -1302,7 +1651,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;
@@ -1331,7 +1680,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;
@@ -1359,7 +1708,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;
@@ -1389,11 +1738,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;
@@ -1421,7 +1770,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;
@@ -1454,7 +1803,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;
@@ -1483,7 +1832,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;
@@ -1511,7 +1860,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;
@@ -1540,7 +1889,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;
@@ -1569,7 +1918,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;
@@ -1598,7 +1947,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;
@@ -1626,7 +1975,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;
@@ -1655,7 +2004,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;
@@ -1683,7 +2032,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;
@@ -1712,7 +2061,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;
@@ -1741,7 +2090,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;
@@ -1769,7 +2118,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;
@@ -1806,7 +2155,7 @@ function getModulesPath() {
     return join(basePath, "../../../");
 }
 
-const router$4 = Router({
+const router$6 = Router({
     params: true,
 });
 // getModulesPath
@@ -1823,7 +2172,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)) {
@@ -1839,7 +2188,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)) {
@@ -1855,7 +2204,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)) {
@@ -1871,7 +2220,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)) {
@@ -1888,10 +2237,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;
@@ -1919,7 +2268,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;
@@ -1947,7 +2296,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;
@@ -1976,6 +2325,630 @@ router$3.post("/api/v1/dict/symbol/one", async (req, res) => {
     }
 });
 
+const router$4 = Router({
+    params: true,
+});
+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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
+
+const router$3 = Router({
+    params: true,
+});
+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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
+
 const router$2 = Router({
     params: true,
 });
@@ -2007,6 +2980,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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: 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: errorData(error) });
+        return await micro.send(res, 200, { status: "error", error: getErrorMessage(error) });
+    }
+});
 
 const require = createRequire(import.meta.url);
 function getPublicPath() {
@@ -2019,20 +3020,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));
 });