@archznn/xavva 2.4.0 → 2.6.0

package/src/services/BuildService.ts

@@ -30,6 +30,11 @@ export class BuildService {
 			this.cache.clearCache();
 		}
 
+		// Sempre limpa a pasta de build antes (target/ ou build/)
+		if (!incremental) {
+			await this.cleanBuildDirectory();
+		}
+
 		// Cache só é usado se --cache for passado ou em modo incremental
 		const useCache = this.projectConfig.cache || incremental;
 		
@@ -54,7 +59,8 @@ export class BuildService {
 			if (incremental) {
 				command.push("compile");
 			} else {
-				if (this.projectConfig.clean) command.push("clean");
+				// Sempre executa clean antes do build
+				command.push("clean");
 				// Use 'package' para gerar .war ou 'war:exploded' para pasta
 				if (this.projectConfig.war) {
 					command.push("package");
@@ -76,7 +82,8 @@ export class BuildService {
 			if (incremental) {
 				command.push("classes");
 			} else {
-				if (this.projectConfig.clean) command.push("clean");
+				// Sempre executa clean antes do build
+				command.push("clean");
 				command.push("war");
 				command.push("--parallel", "--build-cache");
 			}
@@ -123,25 +130,147 @@ export class BuildService {
 		}
 	}
 
+	/**
+	 * Limpa fisicamente o diretório de build (target/ ou build/)
+	 * Garante build limpo antes de cada execução
+	 */
+	private async cleanBuildDirectory(): Promise<void> {
+		const buildDir = this.projectConfig.buildTool === 'maven' 
+			? path.join(process.cwd(), 'target')
+			: path.join(process.cwd(), 'build');
+		
+		if (existsSync(buildDir)) {
+			try {
+				Logger.step(`Cleaning ${path.basename(buildDir)}/ directory...`);
+				await fs.rm(buildDir, { recursive: true, force: true });
+				Logger.debug(`Removed ${buildDir}`);
+			} catch (e) {
+				Logger.warn(`Could not fully remove ${buildDir}, continuing...`);
+			}
+		}
+	}
+
 	async syncExploded(srcDir: string, destDir: string): Promise<void> {
 		if (!existsSync(srcDir)) return;
 		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
 		await this.fastSync(srcDir, destDir);
 	}
 
-	async syncClasses(customSrc?: string): Promise<string | null> {
+	async syncClasses(changedFiles?: string[]): Promise<string | null> {
 		const appFolder = this.projectService.getInferredAppName();
 		const webappPath = path.join(this.tomcatConfig.path, "webapps", appFolder);
 		const targetLib = path.join(webappPath, "WEB-INF", "classes");
-		const sourceDir = customSrc || this.projectService.getClassesDir();
+		const sourceDir = this.projectService.getClassesDir();
 
 		if (!existsSync(sourceDir)) return null;
 		if (!existsSync(targetLib)) mkdirSync(targetLib, { recursive: true });
 
-		await this.fastSync(sourceDir, targetLib);
+		// Se temos uma lista específica de arquivos modificados, sincroniza apenas eles
+		if (changedFiles && changedFiles.length > 0) {
+			await this.syncSpecificFiles(changedFiles, sourceDir, targetLib);
+		} else {
+			// Caso contrário, sincroniza tudo (comportamento padrão)
+			await this.fastSync(sourceDir, targetLib);
+		}
+		
 		return appFolder;
 	}
 
+	/**
+	 * Sincroniza apenas arquivos específicos baseado nos arquivos .java modificados.
+	 * Converte .java para .class e sincroniza apenas os arquivos realmente modificados.
+	 */
+	private async syncSpecificFiles(changedFiles: string[], sourceDir: string, targetLib: string): Promise<void> {
+		const tasks: Promise<void>[] = [];
+		const syncedCount = { value: 0 };
+		
+		for (const javaFile of changedFiles) {
+			// Converte caminho do .java para caminho do .class
+			// Ex: src/main/java/com/example/Foo.java -> target/classes/com/example/Foo.class
+			const relativePath = this.javaToClassPath(javaFile);
+			if (!relativePath) continue;
+			
+			const sourcePath = path.join(sourceDir, relativePath);
+			const targetPath = path.join(targetLib, relativePath);
+			
+			if (!existsSync(sourcePath)) {
+				// Se o .class não existe, talvez seja um arquivo excluído ou inner class
+				// Neste caso, faz sync completo como fallback
+				continue;
+			}
+			
+			tasks.push((async () => {
+				const targetDir = path.dirname(targetPath);
+				if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
+				
+				const srcStat = statSync(sourcePath);
+				const destStat = existsSync(targetPath) ? statSync(targetPath) : null;
+				
+				if (!destStat || srcStat.mtimeMs > destStat.mtimeMs) {
+					await fs.copyFile(sourcePath, targetPath);
+					syncedCount.value++;
+				}
+			})());
+		}
+		
+		await Promise.all(tasks);
+		
+		// Se não conseguimos sincronizar nenhum arquivo específico, faz sync completo
+		if (syncedCount.value === 0) {
+			await this.fastSync(sourceDir, targetLib);
+		} else if (!this.projectConfig.quiet) {
+			Logger.info("sync", `${syncedCount.value} classe(s) sincronizada(s)`);
+		}
+	}
+	
+	/**
+	 * Converte caminho de arquivo .java para caminho relativo de .class
+	 */
+	private javaToClassPath(javaFile: string): string | null {
+		// Remove prefixos comuns de diretórios source
+		const parts = javaFile.split(/[/\\]/);
+		
+		// Encontra o índice após "java" ou "src/main/java" ou "src"
+		let startIndex = -1;
+		
+		for (let i = 0; i < parts.length; i++) {
+			if (parts[i] === "java" && i > 0 && (parts[i-1] === "main" || parts[i-1] === "test")) {
+				startIndex = i + 1;
+				break;
+			}
+		}
+		
+		// Se não encontrou padrão maven, tenta achar "src"
+		if (startIndex === -1) {
+			const srcIndex = parts.indexOf("src");
+			if (srcIndex !== -1 && srcIndex < parts.length - 1) {
+				// Pula "src" e possível "main/java"
+				if (parts[srcIndex + 1] === "main" && parts[srcIndex + 2] === "java") {
+					startIndex = srcIndex + 3;
+				} else {
+					startIndex = srcIndex + 1;
+				}
+			}
+		}
+		
+		// Se ainda não encontrou, assume que o caminho já é relativo ao package
+		if (startIndex === -1) {
+			startIndex = 0;
+		}
+		
+		// Pega o caminho relativo
+		const relativeParts = parts.slice(startIndex);
+		if (relativeParts.length === 0) return null;
+		
+		// Substitui extensão .java por .class
+		const fileName = relativeParts[relativeParts.length - 1];
+		if (!fileName || !fileName.endsWith(".java")) return null;
+		
+		relativeParts[relativeParts.length - 1] = fileName.replace(".java", ".class");
+		
+		return path.join(...relativeParts);
+	}
+
 	private async fastSync(src: string, dest: string) {
 		const entries = readdirSync(src, { withFileTypes: true });
 		

package/src/services/EmbeddedTomcatService.ts

@@ -10,6 +10,17 @@ import {
 import path from "path";
 import os from "os";
 import { spawn } from "child_process";
+import {
+	getPlatform,
+	isWindows,
+	getTomcatArchiveName,
+	getTomcatDownloadUrl,
+	getTomcatArchiveUrl,
+	getExtractCommand,
+	getPortCheckCommand,
+	getCatalinaScript,
+	hasCatalinaScript,
+} from "../utils/platform";
 
 export interface EmbeddedTomcatOptions {
 	version?: string;
@@ -35,20 +46,18 @@ export class EmbeddedTomcatService {
 	private isInstalled: boolean = false;
 
 	// Versões estáveis do Tomcat (atualizadas: 2026-03-04)
+	// URLs são construídas dinamicamente baseadas na plataforma
 	private static readonly VERSIONS: Record<
 		string,
-		{ url: string; sha512: string }
+		{ sha512: string }
 	> = {
 			"10.1.52": {
-				url: "https://dlcdn.apache.org/tomcat/tomcat-10/v10.1.52/bin/apache-tomcat-10.1.52-windows-x64.zip",
 				sha512: "",
 			},
 			"9.0.115": {
-				url: "https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.115/bin/apache-tomcat-9.0.115-windows-x64.zip",
 				sha512: "",
 			},
 			"11.0.18": {
-				url: "https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.18/bin/apache-tomcat-11.0.18-windows-x64.zip",
 				sha512: "",
 			},
 		};
@@ -61,14 +70,14 @@ export class EmbeddedTomcatService {
 		this.baseDir = path.join(os.homedir(), ".xavva", "tomcat");
 		this.tomcatHome = path.join(this.baseDir, this.version);
 
-		// Se a versão não está na lista, usa URL padrão
+		// Constrói URL de download baseada na plataforma
 		const versionInfo = EmbeddedTomcatService.VERSIONS[this.version];
 		if (versionInfo) {
-			this.downloadUrl = versionInfo.url;
+			// Usa URL primária (CDN Apache)
+			this.downloadUrl = getTomcatDownloadUrl(this.version);
 		} else {
-			// Tenta inferir URL baseado no padrão Apache
-			const majorVersion = this.version.split(".")[0];
-			this.downloadUrl = `https://archive.apache.org/dist/tomcat/tomcat-${majorVersion}/v${this.version}/bin/apache-tomcat-${this.version}-windows-x64.zip`;
+			// Tenta inferir URL baseado no padrão Apache (archive)
+			this.downloadUrl = getTomcatArchiveUrl(this.version);
 		}
 	}
 
@@ -76,8 +85,7 @@ export class EmbeddedTomcatService {
 	 * Verifica se o Tomcat já está instalado
 	 */
 	checkInstallation(): boolean {
-		const catalinaBat = path.join(this.tomcatHome, "bin", "catalina.bat");
-		this.isInstalled = existsSync(catalinaBat);
+		this.isInstalled = hasCatalinaScript(this.tomcatHome);
 		return this.isInstalled;
 	}
 
@@ -100,13 +108,8 @@ export class EmbeddedTomcatService {
 
 		for (const entry of entries) {
 			if (entry.isDirectory()) {
-				const catalinaBat = path.join(
-					baseDir,
-					entry.name,
-					"bin",
-					"catalina.bat",
-				);
-				if (existsSync(catalinaBat)) {
+				const tomcatPath = path.join(baseDir, entry.name);
+				if (hasCatalinaScript(tomcatPath)) {
 					versions.push(entry.name);
 				}
 			}
@@ -133,10 +136,8 @@ export class EmbeddedTomcatService {
 			mkdirSync(this.baseDir, { recursive: true });
 		}
 
-		const zipPath = path.join(
-			this.baseDir,
-			`apache-tomcat-${this.version}.zip`,
-		);
+		const archiveName = getTomcatArchiveName(this.version);
+		const zipPath = path.join(this.baseDir, archiveName);
 
 		try {
 			// Download
@@ -300,21 +301,24 @@ export class EmbeddedTomcatService {
 	 */
 	async isPortAvailable(): Promise<boolean> {
 		return new Promise((resolve) => {
-			const netstat = spawn("cmd", [
-				"/c",
-				`netstat -ano | findstr :${this.port}`,
-			]);
+			const cmd = getPortCheckCommand(this.port);
+			const checkProcess = spawn(cmd[0], cmd.slice(1));
 			let output = "";
 
-			netstat.stdout?.on("data", (data) => {
+			checkProcess.stdout?.on("data", (data) => {
+				output += data.toString();
+			});
+
+			checkProcess.stderr?.on("data", (data) => {
 				output += data.toString();
 			});
 
-			netstat.on("close", () => {
+			checkProcess.on("close", () => {
+				// Se houver output, a porta está em uso
 				resolve(output.trim().length === 0);
 			});
 
-			netstat.on("error", () => {
+			checkProcess.on("error", () => {
 				resolve(true); // Assume disponível se não conseguir verificar
 			});
 		});
@@ -382,18 +386,23 @@ export class EmbeddedTomcatService {
 	}
 
 	/**
-	 * Extrai arquivo ZIP usando PowerShell
+	 * Extrai arquivo de arquivos (ZIP ou tar.gz)
 	 */
 	private async extractZip(zipPath: string, destDir: string): Promise<void> {
 		const spinner = Logger.spinner("Extraindo arquivos...");
 
 		return new Promise((resolve, reject) => {
-			const ps = spawn("powershell", [
-				"-command",
-				`Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force`,
-			]);
+			const cmd = getExtractCommand(zipPath, destDir);
+			
+			if (!cmd) {
+				spinner(false);
+				reject(new Error(`Formato de arquivo não suportado: ${path.extname(zipPath)}`));
+				return;
+			}
+
+			const extractProcess = spawn(cmd[0], cmd.slice(1));
 
-			ps.on("close", (code) => {
+			extractProcess.on("close", (code) => {
 				if (code === 0) {
 					spinner(true);
 					resolve();
@@ -403,7 +412,7 @@ export class EmbeddedTomcatService {
 				}
 			});
 
-			ps.on("error", (err) => {
+			extractProcess.on("error", (err) => {
 				spinner(false);
 				reject(err);
 			});

package/src/services/LogAnalyzer.ts

@@ -77,7 +77,7 @@ export class LogAnalyzer {
         const isProject = this.projectPrefixes.some(p => trimmed.includes(p));
         
         if (isProject) {
-            return `    ${Logger.C.bold}${Logger.C.yellow}${trimmed}${Logger.C.reset}`;
+            return `    ${Logger.C.bold}${Logger.C.warning}${trimmed}${Logger.C.reset}`;
         } else {
             return `    ${Logger.C.dim}${trimmed}${Logger.C.reset}`;
         }
@@ -100,7 +100,7 @@ export class LogAnalyzer {
 
         let color = Logger.C.primary;
         let symbol = "●";
-        if (level === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        if (level === "WARN") { color = Logger.C.warning; symbol = "▲"; }
         else if (level === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         return `${color}${symbol} ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg}`;
@@ -113,7 +113,7 @@ export class LogAnalyzer {
         
         let color = Logger.C.dim;
         let symbol = "ℹ";
-        if (label === "WARNING") { color = Logger.C.yellow; symbol = "▲"; }
+        if (label === "WARNING") { color = Logger.C.warning; symbol = "▲"; }
         else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?|org\.glassfish)\.[a-zA-Z0-9.]+\s/, "").trim();
@@ -129,7 +129,7 @@ export class LogAnalyzer {
         
         let color = Logger.C.dim;
         let symbol = "ℹ";
-        if (label === "WARNING" || label === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        if (label === "WARNING" || label === "WARN") { color = Logger.C.warning; symbol = "▲"; }
         else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?)\.[a-zA-Z0-9.]+\s/, "").trim();

package/src/services/TomcatService.ts

@@ -5,6 +5,14 @@ import { ProjectService } from "./ProjectService";
 import { existsSync, mkdirSync, writeFileSync, statSync, promises as fs } from "fs";
 import path from "path";
 import os from "os";
+import {
+	getCatalinaPath,
+	getMemoryCommand,
+	getKillCommand,
+	getPortCheckCommand,
+	getJavaPath,
+	isWindows,
+} from "../utils/platform";
 
 export class TomcatService {
 	private activeConfig: TomcatConfig;
@@ -25,23 +33,55 @@ export class TomcatService {
 	async getMemoryUsage(): Promise<string> {
 		if (!this.pid) return "0 MB";
 		try {
-			const { stdout } = Bun.spawnSync(["powershell", "-command", `(Get-Process -Id ${this.pid}).WorkingSet64 / 1MB`]);
+			const cmd = getMemoryCommand(this.pid);
+			if (!cmd) return "N/A";
+			
+			const { stdout } = Bun.spawnSync(cmd);
 			const mem = await new Response(stdout).text();
-			return `${Math.round(parseFloat(mem))} MB`;
+			const memValue = parseFloat(mem.trim());
+			
+			if (isNaN(memValue)) return "N/A";
+			
+			// No Linux/macOS, ps retorna em KB, convertemos para MB
+			if (!isWindows()) {
+				return `${Math.round(memValue / 1024)} MB`;
+			}
+			
+			return `${Math.round(memValue)} MB`;
 		} catch (e) {
 			return "N/A";
 		}
 	}
 
 	async killConflict() {
-		const { stdout } = Bun.spawnSync(["cmd", "/c", `netstat -ano | findstr :${this.activeConfig.port}`]);
+		const cmd = getPortCheckCommand(this.activeConfig.port);
+		const { stdout } = Bun.spawnSync(cmd);
 		const output = await new Response(stdout).text();
 
 		if (output) {
-			const lines = output.trim().split('\n');
-			const pid = lines[0].trim().split(/\s+/).pop();
-			Logger.step(`Freeing port ${this.activeConfig.port}`);
-			Bun.spawnSync(["taskkill", "/F", "/PID", pid]);
+			// Extrai PID do output
+			let pid: string | undefined;
+			
+			if (isWindows()) {
+				// Windows: netstat output, última coluna é o PID
+				const lines = output.trim().split('\n');
+				pid = lines[0].trim().split(/\s+/).pop();
+			} else {
+				// Linux/Mac: tenta extrair PID de lsof, ss ou netstat
+				// lsof -i :port: formato tem PID na coluna 2
+				// ss -tlnp: tem pid=XXXX
+				// netstat -tlnp: tem /XXXX no final
+				const match = output.match(/\b(\d+)\b/) || // número isolado (lsof)
+							  output.match(/pid=(\d+)/) ||     // ss format
+							  output.match(/\/(\d+)/);         // netstat format
+				if (match) pid = match[1];
+			}
+			
+			if (pid) {
+				Logger.step(`Freeing port ${this.activeConfig.port}`);
+				const killCmd = getKillCommand(pid);
+				Bun.spawnSync(killCmd);
+			}
 		}
 	}
 
@@ -105,21 +145,54 @@ export class TomcatService {
 			
 			Logger.step("Downloading HotswapAgent v2.0.3 (Global)...");
 			const url = "https://github.com/HotswapProjects/HotswapAgent/releases/download/RELEASE-2.0.3/hotswap-agent-2.0.3.jar";
-			const response = await fetch(url);
-			if (!response.ok) throw new Error(`Status: ${response.status}`);
+			
+			Logger.debug(`URL: ${url}`);
+			Logger.debug(`Destino: ${agentPath}`);
+			
+			const response = await fetch(url, {
+				redirect: "follow",
+			});
+			
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			}
+			
+			const contentLength = response.headers.get("content-length");
+			Logger.debug(`Content-Length: ${contentLength || "unknown"}`);
 			
 			const buffer = await response.arrayBuffer();
+			Logger.debug(`Downloaded: ${buffer.byteLength} bytes`);
+			
+			if (buffer.byteLength < 1000) {
+				throw new Error(`Arquivo muito pequeno (${buffer.byteLength} bytes)`);
+			}
+			
 			writeFileSync(agentPath, Buffer.from(buffer));
+			
+			// Verifica se foi escrito corretamente
+			const stats = statSync(agentPath);
+			Logger.debug(`Escrito: ${stats.size} bytes`);
+			
 			Logger.success("HotswapAgent v2.0.3 installed globally!");
 			return agentPath;
-		} catch (e) {
-			Logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
+		} catch (e: any) {
+			Logger.warn(`Falha ao baixar HotswapAgent: ${e.message}`);
+			Logger.warn("Usando hot swap padrão da JVM.");
+			
+			// Limpa arquivo parcial se existir
+			if (existsSync(agentPath)) {
+				try {
+					await fs.unlink(agentPath);
+					Logger.debug("Arquivo parcial removido");
+				} catch {}
+			}
+			
 			return null;
 		}
 	}
 
 	async start(config: AppConfig, isWatching: boolean = false) {
-		const binPath = `${this.activeConfig.path}\\bin\\catalina.bat`;
+		const binPath = getCatalinaPath(this.activeConfig.path);
 		const args = (config.project.debug || isWatching) ? ["jpda", "run"] : ["run"];
 		
 		const catalinaOpts = [process.env.CATALINA_OPTS || ""];
@@ -134,7 +207,7 @@ export class TomcatService {
 					javaBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
 				}
 
-				const javaVer = Bun.spawnSync([javaBin, "-version"]);
+				const javaVer = Bun.spawnSync([getJavaPath(), "-version"]);
 				const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
 				
 				if (output.includes("dcevm") || output.includes("jbr") || output.includes("trava")) {

package/src/services/WatcherService.ts

@@ -9,6 +9,11 @@ export class WatcherService {
     private pendingFullBuild = false;
     private coolingFiles = new Set<string>();
     private debounceTimer?: Timer;
+    
+    // Rastreamento de arquivos modificados para build incremental inteligente
+    private modifiedFiles = new Set<string>();
+    private pendingFiles = new Set<string>(); // Arquivos modificados durante compilação
+    private hasPendingChanges = false;
 
     constructor(private config: AppConfig, private deployCmd: DeployCommand) {}
 
@@ -43,24 +48,57 @@ export class WatcherService {
             if (!isJava) return;
 
             Logger.watcher(filename, 'watch');
+            
+            // Se estiver compilando, acumula na fila de pendentes
+            if (this.isDeploying) {
+                this.pendingFiles.add(filename);
+                this.hasPendingChanges = true;
+                return;
+            }
+            
+            // Acumula arquivos modificados para o próximo build
+            this.modifiedFiles.add(filename);
+            
             clearTimeout(this.debounceTimer);
             
             this.debounceTimer = setTimeout(() => {
-                this.run(this.pendingFullBuild ? false : true);
+                const filesToCompile = [...this.modifiedFiles];
+                this.modifiedFiles.clear();
+                this.run(this.pendingFullBuild ? false : true, filesToCompile);
                 this.pendingFullBuild = false;
             }, WATCHER_DEBOUNCE_MS);
         });
     }
 
-    private async run(incremental = false) {
+    private async run(incremental = false, changedFiles?: string[]) {
         if (this.isDeploying) return;
         this.isDeploying = true;
+        
         try {
-            await this.deployCmd.execute(this.config, { watch: true, incremental });
+            // Passa os arquivos específicos que foram modificados
+            await this.deployCmd.execute(this.config, { 
+                watch: true, 
+                incremental,
+                changedFiles 
+            });
         } catch (e) {
             // Error handled by command
         } finally {
             this.isDeploying = false;
+            
+            // Se houve mudanças durante a compilação, processa imediatamente
+            if (this.hasPendingChanges) {
+                const pending = [...this.pendingFiles];
+                this.pendingFiles.clear();
+                this.hasPendingChanges = false;
+                
+                Logger.watcher(`Processing ${pending.length} pending change(s)...`, 'warn');
+                
+                // Pequeno delay para garantir que os arquivos foram salvos completamente
+                setTimeout(() => {
+                    this.run(true, pending);
+                }, 100);
+            }
         }
     }
 

package/src/types/config.ts

@@ -61,6 +61,7 @@ export interface CLIArguments {
     yes?: boolean;
     war?: boolean;
     cache?: boolean;
+    changedFiles?: string[];
 }
 
 export interface CommandContext {

package/src/utils/constants.ts

@@ -10,8 +10,8 @@ export const DEFAULT_DEBUG_PORT = 5005;
 
 // Timeouts (em milissegundos)
 export const TIMEOUT_SHUTDOWN_MS = 5000;
-export const WATCHER_DEBOUNCE_MS = 1000;
-export const WATCHER_COOLING_MS = 500;
+export const WATCHER_DEBOUNCE_MS = 1500;
+export const WATCHER_COOLING_MS = 1000;
 export const BROWSER_OPEN_DELAY_MS = 800;
 export const DEPLOY_HEALTH_CHECK_DELAY_MS = 1500;
 export const HOTSWAP_DELAY_MS = 500;