xypriss 1.0.1 → 1.1.2

package/dist/esm/server/service/Reload/HotReloader.js

@@ -1,735 +0,0 @@
-import { spawn } from 'child_process';
-import { EventEmitter } from 'events';
-import { existsSync, promises } from 'fs';
-import { join } from 'path';
-import { DEFAULT_FW_CONFIG } from '../../const/FileWatcher.config.js';
-import { TypeScriptExecutor } from './exec/TypeScriptExecutor.js';
-import { Logger } from '../../utils/Logger.js';
-
-/**
- * Enhanced Hot Reloader with QuickDev Integration
- * Integrates with powerful Go-based QuickDev service with fallback to local implementation
- * Enables real hot reload by restarting the entire process
- */
-class HotReloader extends EventEmitter {
-    constructor(config = {}, FWConfig) {
-        super();
-        this.isRunning = false;
-        this.restartCount = 0;
-        this.lastRestart = 0;
-        this.isQuickDevAvailable = false;
-        this.useQuickDev = true; // Prefer QuickDev by default
-        this.config = {
-            enabled: true,
-            script: process.argv[1] || "index.js",
-            args: process.argv.slice(2),
-            env: { ...process.env },
-            cwd: process.cwd(),
-            restartDelay: 500,
-            maxRestarts: DEFAULT_FW_CONFIG.maxRestarts,
-            gracefulShutdownTimeout: 5000,
-            verbose: false,
-            typescript: {
-                enabled: true,
-                runner: "auto",
-                runnerArgs: [],
-                fallbackToNode: true,
-                autoDetectRunner: true,
-                enableRuntimeCompilation: true,
-            },
-            ...config,
-        };
-        this.FWConfig = FWConfig;
-        // Initialize logger
-        this.logger = new Logger({
-            enabled: true,
-            level: this.config.verbose ? "debug" : "info",
-            components: { fileWatcher: true },
-            types: {
-                hotReload: true,
-                startup: true,
-                warnings: true,
-                errors: true,
-            },
-        });
-        // Initialize TypeScript executor
-        this.tsExecutor = new TypeScriptExecutor({
-            verbose: this.config.verbose,
-            fallbackToNode: this.config.typescript?.fallbackToNode ?? true,
-            compilerOptions: this.config.typescript?.compilerOptions,
-        });
-        // Check for standalone executable
-        this.checkStandaloneExecutable();
-        // Check QuickDev availability (synchronous check first)
-        this.checkQuickDevAvailabilitySync();
-        // Then do async check for more thorough detection
-        this.checkQuickDevAvailability();
-    }
-    /**
-     * Check if QuickDev service is available (synchronous check)
-     */
-    checkQuickDevAvailabilitySync() {
-        try {
-            // Quick synchronous check using which/where command
-            const { execSync } = require("child_process");
-            const command = process.platform === "win32"
-                ? "where quickdev"
-                : "which quickdev";
-            execSync(command, { stdio: "pipe" });
-            this.isQuickDevAvailable = true;
-            this.logger.debug("fileWatcher", "QuickDev service detected (sync check)");
-        }
-        catch (error) {
-            this.isQuickDevAvailable = false;
-            this.logger.debug("fileWatcher", "QuickDev service not found (sync check)");
-        }
-    }
-    /**
-     * Check if QuickDev service is available (async verification)
-     */
-    async checkQuickDevAvailability() {
-        try {
-            // Check if quickdev is installed globally
-            const checkProcess = spawn("quickdev", ["--help"], {
-                stdio: "pipe",
-                shell: true,
-            });
-            checkProcess.on("close", (code) => {
-                // Only update if sync check didn't already detect it
-                if (!this.isQuickDevAvailable) {
-                    this.isQuickDevAvailable = code === 0;
-                }
-                if (this.isQuickDevAvailable) {
-                    this.logger.debug("fileWatcher", "QuickDev service detected and available");
-                }
-                else {
-                    this.logger.debug("fileWatcher", "QuickDev service not available, will use fallback");
-                }
-            });
-            checkProcess.on("error", () => {
-                // Only update if sync check didn't already detect it
-                if (!this.isQuickDevAvailable) {
-                    this.isQuickDevAvailable = false;
-                    this.logger.debug("fileWatcher", "QuickDev service not available, will use fallback");
-                }
-            });
-            // Timeout after 2 seconds
-            setTimeout(() => {
-                if (checkProcess.pid) {
-                    checkProcess.kill();
-                    // Only update if sync check didn't already detect it
-                    if (!this.isQuickDevAvailable) {
-                        this.isQuickDevAvailable = false;
-                    }
-                }
-            }, 2000);
-        }
-        catch (error) {
-            this.isQuickDevAvailable = false;
-            this.logger.debug("fileWatcher", "QuickDev service check failed, will use fallback");
-        }
-    }
-    /**
-     * Check for standalone TypeScript executable
-     */
-    checkStandaloneExecutable() {
-        const executablePaths = [
-            join(process.cwd(), "dist", "tsr", process.platform === "win32" ? "tsr.cjs" : "tsr"),
-            join(process.cwd(), "dist", "tsr", "tsr.cmd"), // Windows batch file
-            join(__dirname, "executable", "bin", process.platform === "win32" ? "tsr.exe" : "tsr"),
-        ];
-        for (const path of executablePaths) {
-            if (existsSync(path)) {
-                this.standaloneExecutablePath = path;
-                if (this.config.verbose) {
-                    console.log(`Found standalone TSR executable: ${path}`);
-                }
-                break;
-            }
-        }
-        if (!this.standaloneExecutablePath && this.config.verbose) {
-            console.log("No standalone TSR executable found, using TypeScript executor");
-        }
-    }
-    /**
-     * Create QuickDev configuration file
-     */
-    async createQuickDevConfig() {
-        const configPath = join(process.cwd(), "quickdev.config.json");
-        const quickdevConfig = {
-            script: this.config.script,
-            watch: this.FWConfig.fileWatcher?.watchPaths || ["src", "config"],
-            ignore: this.FWConfig.fileWatcher?.ignorePaths || [
-                "node_modules",
-                "dist",
-                "coverage",
-                ".git",
-                "build",
-            ],
-            extensions: this.FWConfig.fileWatcher?.extensions || [
-                ".ts",
-                ".js",
-                ".jsx",
-                ".tsx",
-            ],
-            gracefulShutdown: true,
-            gracefulShutdownTimeout: Math.floor(this.config.gracefulShutdownTimeout / 1000),
-            maxRestarts: this.config.maxRestarts,
-            resetRestartsAfter: 60000,
-            restartDelay: this.config.restartDelay,
-            batchChanges: true,
-            batchTimeout: 300,
-            enableHashing: true,
-            usePolling: false,
-            pollingInterval: 100,
-            followSymlinks: false,
-            watchDotFiles: false,
-            ignoreFile: ".quickdevignore",
-            parallelProcessing: true,
-            memoryLimit: 500,
-            maxFileSize: 10,
-            excludeEmptyFiles: true,
-            debounceMs: 250,
-            healthCheck: true,
-            healthCheckInterval: 30,
-            clearScreen: true,
-            typescriptRunner: this.config.typescript?.runner === "auto"
-                ? undefined
-                : this.config.typescript?.runner,
-            tsNodeFlags: this.config.typescript?.runnerArgs?.join(" "),
-        };
-        try {
-            await promises.writeFile(configPath, JSON.stringify(quickdevConfig, null, 2));
-            this.logger.debug("fileWatcher", `Created QuickDev config: ${configPath}`);
-            this.quickdevConfigPath = configPath;
-            return configPath;
-        }
-        catch (error) {
-            this.logger.warn("fileWatcher", "Failed to create QuickDev config file:", error);
-            throw error;
-        }
-    }
-    /**
-     * Start the hot reloader with QuickDev integration
-     */
-    async start() {
-        if (!this.config.enabled) {
-            this.logger.info("fileWatcher", "Hot reloader disabled");
-            return;
-        }
-        if (this.isRunning) {
-            this.logger.debug("fileWatcher", "Hot reloader already running");
-            return;
-        }
-        try {
-            this.logger.info("fileWatcher", "Starting hot reloader...");
-            // Wait for QuickDev availability check to complete
-            await new Promise((resolve) => setTimeout(resolve, 500));
-            if (this.useQuickDev && this.isQuickDevAvailable) {
-                await this.startQuickDev();
-            }
-            else {
-                await this.startChildProcess();
-            }
-            this.isRunning = true;
-            this.logger.info("fileWatcher", "Hot reloader started");
-        }
-        catch (error) {
-            this.logger.error("fileWatcher", "Failed to start hot reloader:", error.message);
-            // Try fallback if QuickDev fails
-            if (this.useQuickDev &&
-                this.isQuickDevAvailable &&
-                !this.childProcess) {
-                this.logger.info("fileWatcher", "QuickDev failed, trying fallback...");
-                this.isQuickDevAvailable = false;
-                await this.startChildProcess();
-                this.isRunning = true;
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    /**
-     * Start QuickDev service
-     */
-    async startQuickDev() {
-        try {
-            // Create configuration file
-            await this.createQuickDevConfig();
-            this.logger.debug("fileWatcher", "Starting QuickDev service...");
-            // Start QuickDev process
-            this.quickdevProcess = spawn("quickdev", ["-script", this.config.script], {
-                cwd: this.config.cwd,
-                env: this.config.env,
-                stdio: this.config.verbose ? "inherit" : "pipe",
-                shell: true,
-            });
-            return new Promise((resolve, reject) => {
-                let resolved = false;
-                // Set a timeout to prevent hanging
-                const timeout = setTimeout(() => {
-                    if (!resolved) {
-                        resolved = true;
-                        this.logger.warn("fileWatcher", "QuickDev startup timeout, assuming success");
-                        resolve();
-                    }
-                }, 5000); // 5 second timeout
-                this.quickdevProcess.on("spawn", () => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        this.logger.debug("fileWatcher", `QuickDev service started (PID: ${this.quickdevProcess?.pid})`);
-                        resolve();
-                    }
-                });
-                this.quickdevProcess.on("error", (error) => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        this.logger.error("fileWatcher", "QuickDev service error:", error.message);
-                        reject(error);
-                    }
-                });
-                this.quickdevProcess.on("exit", (code, signal) => {
-                    this.logger.debug("fileWatcher", `QuickDev service exited (code: ${code}, signal: ${signal})`);
-                    this.emit("process:exit", { code, signal });
-                    // If process exits immediately, it might be an error
-                    if (!resolved && code !== 0) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        reject(new Error(`QuickDev process exited with code ${code}`));
-                        return;
-                    }
-                    // Auto-restart on unexpected exit
-                    if (this.isRunning && code !== 0 && !signal) {
-                        this.logger.info("fileWatcher", "Unexpected exit, restarting...");
-                        setTimeout(() => this.restart(), this.config.restartDelay);
-                    }
-                });
-                // Also resolve if the process is spawned successfully (alternative check)
-                setTimeout(() => {
-                    if (!resolved &&
-                        this.quickdevProcess &&
-                        this.quickdevProcess.pid) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        this.logger.debug("fileWatcher", `QuickDev service confirmed running (PID: ${this.quickdevProcess.pid})`);
-                        resolve();
-                    }
-                }, 1000); // Check after 1 second
-            });
-        }
-        catch (error) {
-            throw new Error(`Failed to start QuickDev service: ${error}`);
-        }
-    }
-    /**
-     * Stop the hot reloader
-     */
-    async stop() {
-        if (!this.isRunning)
-            return;
-        try {
-            this.logger.debug("fileWatcher", "Stopping hot reloader...");
-            if (this.quickdevProcess) {
-                await this.stopQuickDev();
-            }
-            if (this.childProcess) {
-                await this.stopChildProcess();
-            }
-            this.isRunning = false;
-            this.logger.debug("fileWatcher", "Hot reloader stopped");
-        }
-        catch (error) {
-            this.logger.error("fileWatcher", "Error stopping hot reloader:", error.message);
-        }
-    }
-    /**
-     * Stop QuickDev service gracefully
-     */
-    async stopQuickDev() {
-        if (!this.quickdevProcess)
-            return;
-        return new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                if (this.quickdevProcess) {
-                    this.logger.debug("fileWatcher", "Force killing QuickDev service...");
-                    this.quickdevProcess.kill("SIGKILL");
-                }
-                resolve();
-            }, this.config.gracefulShutdownTimeout);
-            this.quickdevProcess.on("exit", () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            // Try graceful shutdown first
-            this.logger.debug("fileWatcher", "Sending SIGTERM to QuickDev service...");
-            this.quickdevProcess.kill("SIGTERM");
-        });
-    }
-    /**
-     * Restart the child process (hot reload)
-     */
-    async restart() {
-        if (!this.isRunning) {
-            this.logger.info("fileWatcher", "Hot reloader not running, starting...");
-            await this.start();
-            return;
-        }
-        // Check restart limits
-        const now = Date.now();
-        if (now - this.lastRestart < this.config.restartDelay) {
-            this.logger.debug("fileWatcher", "Restart too soon, waiting...");
-            return;
-        }
-        if (this.restartCount >= this.config.maxRestarts) {
-            this.logger.warn("fileWatcher", `Maximum restarts (${this.config.maxRestarts}) reached`);
-            return;
-        }
-        try {
-            this.logger.hotReload("fileWatcher", "Hot reloading process...");
-            const startTime = Date.now();
-            // Stop current process
-            if (this.quickdevProcess) {
-                await this.stopQuickDev();
-            }
-            if (this.childProcess) {
-                await this.stopChildProcess();
-            }
-            // Wait for restart delay
-            await new Promise((resolve) => setTimeout(resolve, this.config.restartDelay));
-            // Start new process
-            if (this.useQuickDev && this.isQuickDevAvailable) {
-                await this.startQuickDev();
-            }
-            else {
-                await this.startChildProcess();
-            }
-            const duration = Date.now() - startTime;
-            this.restartCount++;
-            this.lastRestart = now;
-            this.emit("restart:completed", {
-                duration,
-                restartCount: this.restartCount,
-            });
-            this.logger.hotReload("fileWatcher", `Process hot reloaded (${duration}ms)`);
-        }
-        catch (error) {
-            this.emit("restart:failed", { error: error.message });
-            this.logger.error("fileWatcher", "Hot reload failed:", error.message);
-        }
-    }
-    /**
-     * Check if the script is a TypeScript file
-     */
-    isTypeScriptFile(script) {
-        return script.endsWith(".ts") || script.endsWith(".tsx");
-    }
-    /**
-     * Get the appropriate runtime and arguments for the script using TypeScript executor
-     */
-    async getRuntimeConfig() {
-        const isTS = this.isTypeScriptFile(this.config.script);
-        const tsConfig = this.config.typescript;
-        // If TypeScript is disabled or not a TS file, use default behavior
-        if (!tsConfig?.enabled || !isTS) {
-            const runtime = process.execPath.includes("bun") ? "bun" : "node";
-            return {
-                runtime,
-                args: [this.config.script, ...this.config.args],
-            };
-        }
-        // Try standalone executable first (most reliable)
-        if (this.standaloneExecutablePath) {
-            this.logger.debug("fileWatcher", `Using standalone TSR executable: ${this.standaloneExecutablePath}`);
-            // For Windows .cmd files, use node to execute the .cjs file
-            if (this.standaloneExecutablePath.endsWith(".cmd")) {
-                const cjsPath = this.standaloneExecutablePath.replace(".cmd", ".cjs");
-                return {
-                    runtime: "node",
-                    args: [cjsPath, this.config.script, ...this.config.args],
-                };
-            }
-            else if (this.standaloneExecutablePath.endsWith(".cjs")) {
-                return {
-                    runtime: "node",
-                    args: [
-                        this.standaloneExecutablePath,
-                        this.config.script,
-                        ...this.config.args,
-                    ],
-                };
-            }
-            else {
-                // Unix executable
-                return {
-                    runtime: this.standaloneExecutablePath,
-                    args: [this.config.script, ...this.config.args],
-                };
-            }
-        }
-        try {
-            // Use the TypeScript executor to determine the best execution method
-            const result = await this.tsExecutor.executeTypeScript(this.config.script, this.config.args);
-            if (result.success) {
-                this.logger.debug("fileWatcher", `Using ${result.method}: ${result.runtime} ${result.args.join(" ")}`);
-                return {
-                    runtime: result.runtime,
-                    args: result.args,
-                };
-            }
-            else {
-                throw new Error(result.error || "TypeScript execution failed");
-            }
-        }
-        catch (error) {
-            this.logger.warn("fileWatcher", `TypeScript executor failed: ${error.message}`);
-            // Fallback to node if TypeScript executor fails
-            if (tsConfig.fallbackToNode) {
-                this.logger.warn("fileWatcher", "Falling back to node (may fail for TypeScript files)");
-                return {
-                    runtime: "node",
-                    args: [this.config.script, ...this.config.args],
-                };
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    /**
-     * Start child process
-     */
-    async startChildProcess() {
-        try {
-            const { runtime, args } = await this.getRuntimeConfig();
-            this.logger.debug("fileWatcher", `Starting process with: ${runtime} ${args.join(" ")}`);
-            return new Promise((resolve, reject) => {
-                let resolved = false;
-                this.childProcess = spawn(runtime, args, {
-                    cwd: this.config.cwd,
-                    env: {
-                        ...this.config.env,
-                        XyPriss_CHILD_PROCESS: "true", // Mark child processes
-                    },
-                    stdio: "inherit",
-                    detached: false,
-                });
-                // Set a timeout to prevent hanging
-                const timeout = setTimeout(() => {
-                    if (!resolved) {
-                        resolved = true;
-                        this.logger.warn("fileWatcher", "Child process startup timeout, assuming success");
-                        resolve();
-                    }
-                }, 5000); // 5 second timeout
-                this.childProcess.on("spawn", () => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        this.logger.debug("fileWatcher", `Child process started (PID: ${this.childProcess?.pid})`);
-                        resolve();
-                    }
-                });
-                this.childProcess.on("error", async (error) => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        // Handle TypeScript runner not found error
-                        if (error.message.includes("ENOENT") &&
-                            this.isTypeScriptFile(this.config.script)) {
-                            const tsConfig = this.config.typescript;
-                            if (tsConfig?.fallbackToNode) {
-                                this.logger.warn("fileWatcher", "TypeScript runner failed, falling back to node (this will likely fail for .ts files)");
-                                this.logger.warn("fileWatcher", "Install a TypeScript runner: npm install -g tsx");
-                                // Retry with node
-                                this.childProcess = spawn("node", [this.config.script, ...this.config.args], {
-                                    cwd: this.config.cwd,
-                                    env: {
-                                        ...this.config.env,
-                                        XyPriss_CHILD_PROCESS: "true", // Mark child processes
-                                    },
-                                    stdio: "inherit",
-                                    detached: false,
-                                });
-                                return;
-                            }
-                        }
-                        this.logger.error("fileWatcher", "Child process error:", error.message);
-                        // Provide helpful error messages for common issues
-                        if (error.message.includes("ENOENT")) {
-                            try {
-                                const { runtime: errorRuntime } = await this.getRuntimeConfig();
-                                this.logger.error("fileWatcher", `Runtime '${errorRuntime}' not found. Please install it:`);
-                                switch (errorRuntime) {
-                                    case "tsx":
-                                        this.logger.error("fileWatcher", "   npm install -g tsx");
-                                        break;
-                                    case "ts-node":
-                                        this.logger.error("fileWatcher", "   npm install -g ts-node");
-                                        break;
-                                    case "bun":
-                                        this.logger.error("fileWatcher", "   Visit: https://bun.sh/docs/installation");
-                                        break;
-                                    default:
-                                        this.logger.error("fileWatcher", `   Make sure '${errorRuntime}' is installed and available in PATH`);
-                                }
-                            }
-                            catch {
-                                this.logger.error("fileWatcher", "   Make sure the runtime is installed and available in PATH");
-                            }
-                        }
-                        reject(error);
-                    }
-                });
-                this.childProcess.on("exit", (code, signal) => {
-                    this.logger.debug("fileWatcher", `Child process exited (code: ${code}, signal: ${signal})`);
-                    this.emit("process:exit", { code, signal });
-                    // If process exits immediately, it might be an error
-                    if (!resolved && code !== 0) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        reject(new Error(`Child process exited with code ${code}`));
-                        return;
-                    }
-                    // Auto-restart on unexpected exit
-                    if (this.isRunning && code !== 0 && !signal) {
-                        this.logger.info("fileWatcher", "Unexpected exit, restarting...");
-                        setTimeout(() => this.restart(), this.config.restartDelay);
-                    }
-                });
-                // Also resolve if the process is spawned successfully (alternative check)
-                setTimeout(() => {
-                    if (!resolved &&
-                        this.childProcess &&
-                        this.childProcess.pid) {
-                        resolved = true;
-                        clearTimeout(timeout);
-                        this.logger.debug("fileWatcher", `Child process confirmed running (PID: ${this.childProcess.pid})`);
-                        resolve();
-                    }
-                }, 1000); // Check after 1 second
-            });
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    /**
-     * Stop child process gracefully
-     */
-    async stopChildProcess() {
-        if (!this.childProcess)
-            return;
-        return new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                if (this.childProcess) {
-                    // console.log('Force killing child process...');
-                    this.childProcess.kill("SIGKILL");
-                }
-                resolve();
-            }, this.config.gracefulShutdownTimeout);
-            this.childProcess.on("exit", () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            // Try graceful shutdown first
-            this.logger.debug("fileWatcher", "Sending SIGTERM to child process...");
-            this.childProcess.kill("SIGTERM");
-        });
-    }
-    /**
-     * Get hot reloader status
-     */
-    getStatus() {
-        let service = "none";
-        if (this.isRunning) {
-            if (this.quickdevProcess) {
-                service = "quickdev";
-            }
-            else if (this.childProcess) {
-                service = "local";
-            }
-        }
-        return {
-            isRunning: this.isRunning,
-            restartCount: this.restartCount,
-            lastRestart: this.lastRestart,
-            childPid: this.childProcess?.pid,
-            quickdevPid: this.quickdevProcess?.pid,
-            service,
-            isQuickDevAvailable: this.isQuickDevAvailable,
-            config: this.config,
-        };
-    }
-    /**
-     * Reset restart counter
-     */
-    resetRestartCount() {
-        this.restartCount = 0;
-        this.lastRestart = 0;
-        // console.log('Restart counter reset');
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(newConfig) {
-        this.config = { ...this.config, ...newConfig };
-        this.emit("config:updated", this.config);
-    }
-    /**
-     * Check if process is healthy
-     */
-    isHealthy() {
-        if (!this.isRunning)
-            return false;
-        if (this.quickdevProcess) {
-            return (!this.quickdevProcess.killed &&
-                this.restartCount < this.config.maxRestarts);
-        }
-        if (this.childProcess) {
-            return (!this.childProcess.killed &&
-                this.restartCount < this.config.maxRestarts);
-        }
-        return false;
-    }
-    /**
-     * Get QuickDev availability status
-     */
-    getQuickDevStatus() {
-        return {
-            available: this.isQuickDevAvailable,
-            inUse: this.isRunning && !!this.quickdevProcess,
-            pid: this.quickdevProcess?.pid,
-        };
-    }
-    /**
-     * Force use of local reloader (disable QuickDev)
-     */
-    async useLocalReloader() {
-        if (this.isRunning && this.quickdevProcess) {
-            await this.stop();
-        }
-        this.useQuickDev = false;
-        if (this.isRunning) {
-            await this.start();
-        }
-        this.logger.info("fileWatcher", "Forced to use local reloader");
-    }
-    /**
-     * Enable QuickDev if available
-     */
-    async enableQuickDev() {
-        this.useQuickDev = true;
-        if (this.isRunning &&
-            !this.quickdevProcess &&
-            this.isQuickDevAvailable) {
-            await this.restart();
-        }
-        this.logger.info("fileWatcher", "QuickDev enabled");
-    }
-}
-
-export { HotReloader, HotReloader as default };
-//# sourceMappingURL=HotReloader.js.map