@warlock.js/core 4.0.174 → 4.1.2

package/esm/dev-server/files-orchestrator.mjs

@@ -0,0 +1,201 @@
+import { Path } from "./path.mjs";
+import { devLogDim, devLogSuccess } from "./dev-logger.mjs";
+import { warlockConfigManager } from "../warlock-config/warlock-config.manager.mjs";
+import { DependencyGraph } from "./dependency-graph.mjs";
+import "./flags.mjs";
+import { tsconfigManager } from "./tsconfig-manager.mjs";
+import { FileEventHandler } from "./file-event-handler.mjs";
+import { FileManager } from "./file-manager.mjs";
+import { ensureWarlockDirectory, getFilesFromDirectory } from "./utils.mjs";
+import { FileOperations } from "./file-operations.mjs";
+import { FilesWatcher } from "./files-watcher.mjs";
+import { EslintHealthChecker } from "./health-checker/checkers/eslint-health-checker.mjs";
+import { TypescriptHealthChecker } from "./health-checker/checkers/typescript-health-checker.mjs";
+import { FilesHealthcareManager } from "./health-checker/files-healthcare.manager.mjs";
+import { buildTranspileInit } from "./loader/build-transpile-init.mjs";
+import { registerLoader } from "./loader/register-loader.mjs";
+import { ManifestManager } from "./manifest-manager.mjs";
+import { ModuleLoader } from "./module-loader.mjs";
+import { packageJsonManager } from "./package-json-manager.mjs";
+import { SpecialFilesCollector } from "./special-files-collector.mjs";
+import { colors } from "@mongez/copper";
+import { init } from "es-module-lexer";
+
+//#region ../../@warlock.js/core/src/dev-server/files-orchestrator.ts
+/**
+* Register a cleanup callback that fires before the current module is
+* unloaded by HMR. Stack-inspects the caller so user code doesn't need to
+* thread the FileManager through.
+*/
+function onCleanup(callback) {
+	if (globalThis.__currentModuleFile) {
+		globalThis.__currentModuleFile.addCleanup(callback);
+		return;
+	}
+	const callerLine = (/* @__PURE__ */ new Error()).stack?.split("\n")[2];
+	const callerFile = (callerLine?.match(/\((.+?):\d+:\d+\)/) || callerLine?.match(/at (.+?):\d+:\d+/))?.[1];
+	if (!callerFile) return;
+	filesOrchestrator.files.get(Path.toRelative(callerFile))?.addCleanup(callback);
+}
+/**
+* Top-level coordinator for the dev server's file system.
+*
+* Owns: file discovery, the dependency graph, the manifest, the special-files
+* index, the file watcher, and the lifecycle of the ESM loader hook (which
+* provides cache-busting via `?v=N` version tokens).
+*/
+var FilesOrchestrator = class {
+	constructor() {
+		this.filesWatcher = new FilesWatcher();
+		this.files = /* @__PURE__ */ new Map();
+		this.manifest = new ManifestManager(this.files);
+		this.dependencyGraph = new DependencyGraph();
+		this.healthCheckerManager = new FilesHealthcareManager(this.files);
+		this.specialFilesCollector = new SpecialFilesCollector();
+		this.moduleLoader = new ModuleLoader(this.specialFilesCollector);
+		this.loaderPort = null;
+		this.pendingFlushes = [];
+		this.isInitialized = false;
+		this.fileOperations = new FileOperations(this.files, this.dependencyGraph, this.manifest, this.specialFilesCollector);
+		this.eventHandler = new FileEventHandler(this.fileOperations, this.manifest, this.dependencyGraph, this.files);
+	}
+	async add(relativePath) {
+		return this.fileOperations.addFile(relativePath);
+	}
+	async load(relativePath, type = "other") {
+		const fileManager = await this.add(relativePath);
+		return this.moduleLoader.loadModule(fileManager, fileManager.type || type);
+	}
+	getDependencyGraph() {
+		return this.dependencyGraph;
+	}
+	getInvalidationChain(file) {
+		return this.dependencyGraph.getInvalidationChain(file);
+	}
+	getFiles() {
+		return this.files;
+	}
+	getHealthCheckerManager() {
+		return this.healthCheckerManager;
+	}
+	/**
+	* Initialise managers and register the ESM loader hook. Must be called
+	* before any user `src/` module is dynamically imported.
+	*/
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		await init;
+		await Promise.all([tsconfigManager.init(), packageJsonManager.init()]);
+		await ensureWarlockDirectory();
+		const devServerConfig = await warlockConfigManager.lazyGet("devServer");
+		const transpileInit = buildTranspileInit(tsconfigManager.tsconfig?.compilerOptions, devServerConfig?.transpileCacheDebug === true);
+		this.loaderPort = await registerLoader(transpileInit);
+		this.loaderPort.on("message", (msg) => {
+			if (msg.type === "sync-ack") this.pendingFlushes.shift()?.();
+		});
+	}
+	/**
+	* Tell the hook worker a file changed. The next `import()` of it will get
+	* a fresh `?v=N` URL → Node cache miss → fresh content.
+	*/
+	bumpVersion(absolutePath) {
+		this.loaderPort?.postMessage({
+			type: "bump",
+			absolutePath
+		});
+	}
+	/**
+	* Wait until the hook worker has processed every pending bump.
+	*
+	* `postMessage` is async — without this, a follow-up `import()` may
+	* resolve before the worker increments the counter and Node will return
+	* the cached old module.
+	*/
+	flushVersionBumps() {
+		if (!this.loaderPort) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.pendingFlushes.push(resolve);
+			this.loaderPort.postMessage({ type: "sync" });
+		});
+	}
+	/**
+	* Discover files on disk, reconcile against the manifest, build the dep
+	* graph, and persist the new manifest. Idempotent.
+	*/
+	async initializeAll() {
+		const [filesInFilesystem, manifestExists] = await Promise.all([this.getAllFilesFromFilesystem(), this.manifest.init()]);
+		if (!manifestExists) await this.processFiles(filesInFilesystem);
+		else await this.reconcileFiles(filesInFilesystem);
+		this.dependencyGraph.build(this.files);
+		this.fileOperations.updateFileDependents();
+		this.fileOperations.syncFilesToManifest();
+		await this.manifest.save();
+	}
+	async checkHealth(files) {
+		const filesToCheck = [...files.added, ...files.changed].map((file) => this.files.get(Path.toRelative(file))).filter((file) => !!file);
+		const filesToDelete = files.deleted.map((file) => this.files.get(Path.toRelative(file))).filter((file) => !!file);
+		await this.healthCheckerManager.onFileChanges(filesToCheck);
+		this.healthCheckerManager.removeFiles(filesToDelete);
+		this.healthCheckerManager.checkFiles(filesToCheck);
+	}
+	async startCheckingHealth(healthCheckers) {
+		devLogDim("Started File Health Checks in the background.");
+		const checkers = healthCheckers ?? [new TypescriptHealthChecker(), new EslintHealthChecker()];
+		await this.healthCheckerManager.setHealthCheckers(checkers).initialize();
+		await this.healthCheckerManager.validateAllFiles();
+	}
+	/**
+	* Glob the src directory, returning relative paths.
+	*/
+	async getAllFilesFromFilesystem() {
+		return (await getFilesFromDirectory()).map((absPath) => Path.toRelative(absPath));
+	}
+	/**
+	* Process every file from scratch — used when no manifest exists.
+	*/
+	async processFiles(filePaths) {
+		devLogDim(`processing ${filePaths.length} files...`);
+		await runInBatches(filePaths, 500, async (relativePath) => {
+			const fileManager = new FileManager(Path.toAbsolute(relativePath), this.files, this.fileOperations);
+			this.files.set(relativePath, fileManager);
+			await fileManager.process();
+		});
+		devLogSuccess(`processed ${filePaths.length} files`);
+	}
+	async reconcileFiles(filesInFilesystem) {
+		const filesInManifest = new Set(this.manifest.getAllFilePaths());
+		const filesInFilesystemSet = new Set(filesInFilesystem);
+		const newFiles = filesInFilesystem.filter((f) => !filesInManifest.has(f));
+		const deletedFiles = Array.from(filesInManifest).filter((f) => !filesInFilesystemSet.has(f));
+		const existingFiles = filesInFilesystem.filter((f) => filesInManifest.has(f));
+		if (newFiles.length > 0 || deletedFiles.length > 0) devLogDim(`reconciling: ${colors.green(newFiles.length)} new, ${colors.red(deletedFiles.length)} deleted, ${colors.blue(existingFiles.length)} existing`);
+		await this.processFiles(newFiles);
+		for (const relativePath of deletedFiles) {
+			this.manifest.removeFile(relativePath);
+			this.files.delete(relativePath);
+		}
+		await runInBatches(existingFiles, 500, async (relativePath) => {
+			const fileManager = new FileManager(Path.toAbsolute(relativePath), this.files, this.fileOperations);
+			this.files.set(relativePath, fileManager);
+			await fileManager.init(this.manifest.getFile(relativePath));
+		});
+	}
+	async watchFiles() {
+		devLogSuccess("watching for file changes");
+		this.filesWatcher.onFileChange((p) => this.eventHandler.handleFileChange(p));
+		this.filesWatcher.onFileAdd((p) => this.eventHandler.handleFileAdd(p));
+		this.filesWatcher.onFileDelete((p) => this.eventHandler.handleFileDelete(p));
+		const watchConfig = warlockConfigManager.get("devServer")?.watch;
+		await this.filesWatcher.watch(watchConfig);
+	}
+};
+async function runInBatches(items, size, fn) {
+	if (items.length === 0) return;
+	for (let i = 0; i < items.length; i += size) await Promise.all(items.slice(i, i + size).map(fn));
+}
+const filesOrchestrator = new FilesOrchestrator();
+
+//#endregion
+export { FilesOrchestrator, filesOrchestrator, onCleanup };
+//# sourceMappingURL=files-orchestrator.mjs.map

package/esm/dev-server/files-orchestrator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-orchestrator.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/files-orchestrator.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\r\nimport { init } from \"es-module-lexer\";\r\nimport type { MessagePort } from \"node:worker_threads\";\r\nimport { warlockConfigManager } from \"../warlock-config/warlock-config.manager\";\r\nimport { DependencyGraph } from \"./dependency-graph\";\r\nimport { devLogDim, devLogSuccess } from \"./dev-logger\";\r\nimport { FileEventHandler } from \"./file-event-handler\";\r\nimport { FileManager } from \"./file-manager\";\r\nimport { FileOperations } from \"./file-operations\";\r\nimport { FilesWatcher } from \"./files-watcher\";\r\nimport { FILE_PROCESSING_BATCH_SIZE } from \"./flags\";\r\nimport { EslintHealthChecker } from \"./health-checker/checkers/eslint-health-checker\";\r\nimport { TypescriptHealthChecker } from \"./health-checker/checkers/typescript-health-checker\";\r\nimport { FileHealthCheckerContract } from \"./health-checker/file-health-checker.contract\";\r\nimport { FilesHealthcareManager } from \"./health-checker/files-healthcare.manager\";\r\nimport { buildTranspileInit } from \"./loader/build-transpile-init.js\";\r\nimport { registerLoader } from \"./loader/register-loader.js\";\r\nimport { ManifestManager } from \"./manifest-manager\";\r\nimport { ModuleLoader } from \"./module-loader\";\r\nimport { packageJsonManager } from \"./package-json-manager\";\r\nimport { Path } from \"./path\";\r\nimport { SpecialFilesCollector } from \"./special-files-collector\";\r\nimport { tsconfigManager } from \"./tsconfig-manager\";\r\nimport { ensureWarlockDirectory, getFilesFromDirectory } from \"./utils\";\r\n\r\n/**\r\n * Register a cleanup callback that fires before the current module is\r\n * unloaded by HMR. Stack-inspects the caller so user code doesn't need to\r\n * thread the FileManager through.\r\n */\r\nexport function onCleanup(callback: () => any) {\r\n  if (globalThis.__currentModuleFile) {\r\n    globalThis.__currentModuleFile.addCleanup(callback);\r\n    return;\r\n  }\r\n\r\n  const stack = new Error().stack;\r\n  const callerLine = stack?.split(\"\\n\")[2];\r\n  const match = callerLine?.match(/\\((.+?):\\d+:\\d+\\)/) || callerLine?.match(/at (.+?):\\d+:\\d+/);\r\n  const callerFile = match?.[1];\r\n\r\n  if (!callerFile) return;\r\n  const fileManager = filesOrchestrator.files.get(Path.toRelative(callerFile));\r\n  fileManager?.addCleanup(callback);\r\n}\r\n\r\n/**\r\n * Top-level coordinator for the dev server's file system.\r\n *\r\n * Owns: file discovery, the dependency graph, the manifest, the special-files\r\n * index, the file watcher, and the lifecycle of the ESM loader hook (which\r\n * provides cache-busting via `?v=N` version tokens).\r\n */\r\nexport class FilesOrchestrator {\r\n  public readonly filesWatcher = new FilesWatcher();\r\n  public readonly files = new Map<string, FileManager>();\r\n  private readonly manifest = new ManifestManager(this.files);\r\n  private readonly dependencyGraph = new DependencyGraph();\r\n  private readonly healthCheckerManager = new FilesHealthcareManager(this.files);\r\n  public readonly specialFilesCollector = new SpecialFilesCollector();\r\n  public readonly moduleLoader = new ModuleLoader(this.specialFilesCollector);\r\n  public readonly fileOperations: FileOperations;\r\n  private readonly eventHandler: FileEventHandler;\r\n\r\n  /** Main-thread end of the MessageChannel to the loader hook worker. */\r\n  private loaderPort: MessagePort | null = null;\r\n\r\n  /** Resolve callbacks for pending `flushVersionBumps()` calls. */\r\n  private readonly pendingFlushes: Array<() => void> = [];\r\n\r\n  public isInitialized = false;\r\n\r\n  public constructor() {\r\n    this.fileOperations = new FileOperations(\r\n      this.files,\r\n      this.dependencyGraph,\r\n      this.manifest,\r\n      this.specialFilesCollector,\r\n    );\r\n\r\n    this.eventHandler = new FileEventHandler(\r\n      this.fileOperations,\r\n      this.manifest,\r\n      this.dependencyGraph,\r\n      this.files,\r\n    );\r\n  }\r\n\r\n  public async add(relativePath: string): Promise<FileManager> {\r\n    return this.fileOperations.addFile(relativePath);\r\n  }\r\n\r\n  public async load<T>(relativePath: string, type = \"other\") {\r\n    const fileManager = await this.add(relativePath);\r\n    return this.moduleLoader.loadModule<T>(fileManager, fileManager.type || type);\r\n  }\r\n\r\n  public getDependencyGraph(): DependencyGraph {\r\n    return this.dependencyGraph;\r\n  }\r\n\r\n  public getInvalidationChain(file: string): string[] {\r\n    return this.dependencyGraph.getInvalidationChain(file);\r\n  }\r\n\r\n  public getFiles(): Map<string, FileManager> {\r\n    return this.files;\r\n  }\r\n\r\n  public getHealthCheckerManager(): FilesHealthcareManager {\r\n    return this.healthCheckerManager;\r\n  }\r\n\r\n  /**\r\n   * Initialise managers and register the ESM loader hook. Must be called\r\n   * before any user `src/` module is dynamically imported.\r\n   */\r\n  public async init() {\r\n    if (this.isInitialized) return;\r\n    this.isInitialized = true;\r\n\r\n    await init;\r\n    await Promise.all([tsconfigManager.init(), packageJsonManager.init()]);\r\n\r\n    // The loader hook writes itself into .warlock/, so ensure the dir exists.\r\n    await ensureWarlockDirectory();\r\n\r\n    const devServerConfig = await warlockConfigManager.lazyGet(\"devServer\");\r\n    const transpileInit = buildTranspileInit(\r\n      tsconfigManager.tsconfig?.compilerOptions,\r\n      devServerConfig?.transpileCacheDebug === true,\r\n    );\r\n\r\n    this.loaderPort = await registerLoader(transpileInit);\r\n\r\n    this.loaderPort.on(\"message\", (msg: { type: string }) => {\r\n      if (msg.type === \"sync-ack\") {\r\n        this.pendingFlushes.shift()?.();\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Tell the hook worker a file changed. The next `import()` of it will get\r\n   * a fresh `?v=N` URL → Node cache miss → fresh content.\r\n   */\r\n  public bumpVersion(absolutePath: string): void {\r\n    this.loaderPort?.postMessage({ type: \"bump\", absolutePath });\r\n  }\r\n\r\n  /**\r\n   * Wait until the hook worker has processed every pending bump.\r\n   *\r\n   * `postMessage` is async — without this, a follow-up `import()` may\r\n   * resolve before the worker increments the counter and Node will return\r\n   * the cached old module.\r\n   */\r\n  public flushVersionBumps(): Promise<void> {\r\n    if (!this.loaderPort) return Promise.resolve();\r\n\r\n    return new Promise<void>((resolve) => {\r\n      this.pendingFlushes.push(resolve);\r\n      this.loaderPort!.postMessage({ type: \"sync\" });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Discover files on disk, reconcile against the manifest, build the dep\r\n   * graph, and persist the new manifest. Idempotent.\r\n   */\r\n  public async initializeAll() {\r\n    const [filesInFilesystem, manifestExists] = await Promise.all([\r\n      this.getAllFilesFromFilesystem(),\r\n      this.manifest.init(),\r\n    ]);\r\n\r\n    if (!manifestExists) {\r\n      await this.processFiles(filesInFilesystem);\r\n    } else {\r\n      await this.reconcileFiles(filesInFilesystem);\r\n    }\r\n\r\n    this.dependencyGraph.build(this.files);\r\n    this.fileOperations.updateFileDependents();\r\n    this.fileOperations.syncFilesToManifest();\r\n    await this.manifest.save();\r\n  }\r\n\r\n  public async checkHealth(files: { added: string[]; changed: string[]; deleted: string[] }) {\r\n    const filesToCheck = [...files.added, ...files.changed]\r\n      .map((file) => this.files.get(Path.toRelative(file)))\r\n      .filter((file): file is FileManager => !!file);\r\n\r\n    const filesToDelete = files.deleted\r\n      .map((file) => this.files.get(Path.toRelative(file)))\r\n      .filter((file): file is FileManager => !!file);\r\n\r\n    await this.healthCheckerManager.onFileChanges(filesToCheck);\r\n    this.healthCheckerManager.removeFiles(filesToDelete);\r\n    this.healthCheckerManager.checkFiles(filesToCheck);\r\n  }\r\n\r\n  public async startCheckingHealth(healthCheckers?: FileHealthCheckerContract[]): Promise<void> {\r\n    devLogDim(\"Started File Health Checks in the background.\");\r\n    const checkers = healthCheckers ?? [new TypescriptHealthChecker(), new EslintHealthChecker()];\r\n    await this.healthCheckerManager.setHealthCheckers(checkers).initialize();\r\n    await this.healthCheckerManager.validateAllFiles();\r\n  }\r\n\r\n  /**\r\n   * Glob the src directory, returning relative paths.\r\n   */\r\n  public async getAllFilesFromFilesystem(): Promise<string[]> {\r\n    const absolutePaths = await getFilesFromDirectory();\r\n    return absolutePaths.map((absPath) => Path.toRelative(absPath));\r\n  }\r\n\r\n  /**\r\n   * Process every file from scratch — used when no manifest exists.\r\n   */\r\n  private async processFiles(filePaths: string[]) {\r\n    devLogDim(`processing ${filePaths.length} files...`);\r\n    await runInBatches(filePaths, FILE_PROCESSING_BATCH_SIZE, async (relativePath) => {\r\n      const fileManager = new FileManager(\r\n        Path.toAbsolute(relativePath),\r\n        this.files,\r\n        this.fileOperations,\r\n      );\r\n      this.files.set(relativePath, fileManager);\r\n      await fileManager.process();\r\n    });\r\n    devLogSuccess(`processed ${filePaths.length} files`);\r\n  }\r\n\r\n  private async reconcileFiles(filesInFilesystem: string[]) {\r\n    const filesInManifest = new Set(this.manifest.getAllFilePaths());\r\n    const filesInFilesystemSet = new Set(filesInFilesystem);\r\n\r\n    const newFiles = filesInFilesystem.filter((f) => !filesInManifest.has(f));\r\n    const deletedFiles = Array.from(filesInManifest).filter((f) => !filesInFilesystemSet.has(f));\r\n    const existingFiles = filesInFilesystem.filter((f) => filesInManifest.has(f));\r\n\r\n    if (newFiles.length > 0 || deletedFiles.length > 0) {\r\n      devLogDim(\r\n        `reconciling: ${colors.green(newFiles.length)} new, ${colors.red(deletedFiles.length)} deleted, ${colors.blue(existingFiles.length)} existing`,\r\n      );\r\n    }\r\n\r\n    await this.processFiles(newFiles);\r\n\r\n    for (const relativePath of deletedFiles) {\r\n      this.manifest.removeFile(relativePath);\r\n      this.files.delete(relativePath);\r\n    }\r\n\r\n    await runInBatches(existingFiles, FILE_PROCESSING_BATCH_SIZE, async (relativePath) => {\r\n      const fileManager = new FileManager(\r\n        Path.toAbsolute(relativePath),\r\n        this.files,\r\n        this.fileOperations,\r\n      );\r\n      this.files.set(relativePath, fileManager);\r\n      await fileManager.init(this.manifest.getFile(relativePath));\r\n    });\r\n  }\r\n\r\n  public async watchFiles() {\r\n    devLogSuccess(\"watching for file changes\");\r\n\r\n    this.filesWatcher.onFileChange((p) => this.eventHandler.handleFileChange(p));\r\n    this.filesWatcher.onFileAdd((p) => this.eventHandler.handleFileAdd(p));\r\n    this.filesWatcher.onFileDelete((p) => this.eventHandler.handleFileDelete(p));\r\n\r\n    const watchConfig = warlockConfigManager.get(\"devServer\")?.watch;\r\n    await this.filesWatcher.watch(watchConfig);\r\n  }\r\n}\r\n\r\nasync function runInBatches<T>(\r\n  items: T[],\r\n  size: number,\r\n  fn: (item: T) => Promise<unknown>,\r\n): Promise<void> {\r\n  if (items.length === 0) return;\r\n  for (let i = 0; i < items.length; i += size) {\r\n    await Promise.all(items.slice(i, i + size).map(fn));\r\n  }\r\n}\r\n\r\nexport const filesOrchestrator = new FilesOrchestrator();\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,UAAU,UAAqB;CAC7C,IAAI,WAAW,qBAAqB;EAClC,WAAW,oBAAoB,WAAW,QAAQ;EAClD;CACF;CAGA,MAAM,8BADQ,IAAI,MAAM,GAAE,OACA,MAAM,IAAI,EAAE;CAEtC,MAAM,cADQ,YAAY,MAAM,mBAAmB,KAAK,YAAY,MAAM,kBAAkB,KACjE;CAE3B,IAAI,CAAC,YAAY;CAEjB,AADoB,kBAAkB,MAAM,IAAI,KAAK,WAAW,UAAU,CAChE,GAAG,WAAW,QAAQ;AAClC;;;;;;;;AASA,IAAa,oBAAb,MAA+B;CAmB7B,AAAO,cAAc;sBAlBU,IAAI,aAAa;+BACxB,IAAI,IAAyB;kBACzB,IAAI,gBAAgB,KAAK,KAAK;yBACvB,IAAI,gBAAgB;8BACf,IAAI,uBAAuB,KAAK,KAAK;+BACrC,IAAI,sBAAsB;sBACnC,IAAI,aAAa,KAAK,qBAAqB;oBAKjC;wBAGY,CAAC;uBAE/B;EAGrB,KAAK,iBAAiB,IAAI,eACxB,KAAK,OACL,KAAK,iBACL,KAAK,UACL,KAAK,qBACP;EAEA,KAAK,eAAe,IAAI,iBACtB,KAAK,gBACL,KAAK,UACL,KAAK,iBACL,KAAK,KACP;CACF;CAEA,MAAa,IAAI,cAA4C;EAC3D,OAAO,KAAK,eAAe,QAAQ,YAAY;CACjD;CAEA,MAAa,KAAQ,cAAsB,OAAO,SAAS;EACzD,MAAM,cAAc,MAAM,KAAK,IAAI,YAAY;EAC/C,OAAO,KAAK,aAAa,WAAc,aAAa,YAAY,QAAQ,IAAI;CAC9E;CAEA,AAAO,qBAAsC;EAC3C,OAAO,KAAK;CACd;CAEA,AAAO,qBAAqB,MAAwB;EAClD,OAAO,KAAK,gBAAgB,qBAAqB,IAAI;CACvD;CAEA,AAAO,WAAqC;EAC1C,OAAO,KAAK;CACd;CAEA,AAAO,0BAAkD;EACvD,OAAO,KAAK;CACd;;;;;CAMA,MAAa,OAAO;EAClB,IAAI,KAAK,eAAe;EACxB,KAAK,gBAAgB;EAErB,MAAM;EACN,MAAM,QAAQ,IAAI,CAAC,gBAAgB,KAAK,GAAG,mBAAmB,KAAK,CAAC,CAAC;EAGrE,MAAM,uBAAuB;EAE7B,MAAM,kBAAkB,MAAM,qBAAqB,QAAQ,WAAW;EACtE,MAAM,gBAAgB,mBACpB,gBAAgB,UAAU,iBAC1B,iBAAiB,wBAAwB,IAC3C;EAEA,KAAK,aAAa,MAAM,eAAe,aAAa;EAEpD,KAAK,WAAW,GAAG,YAAY,QAA0B;GACvD,IAAI,IAAI,SAAS,YACf,KAAK,eAAe,MAAM,IAAI;EAElC,CAAC;CACH;;;;;CAMA,AAAO,YAAY,cAA4B;EAC7C,KAAK,YAAY,YAAY;GAAE,MAAM;GAAQ;EAAa,CAAC;CAC7D;;;;;;;;CASA,AAAO,oBAAmC;EACxC,IAAI,CAAC,KAAK,YAAY,OAAO,QAAQ,QAAQ;EAE7C,OAAO,IAAI,SAAe,YAAY;GACpC,KAAK,eAAe,KAAK,OAAO;GAChC,KAAK,WAAY,YAAY,EAAE,MAAM,OAAO,CAAC;EAC/C,CAAC;CACH;;;;;CAMA,MAAa,gBAAgB;EAC3B,MAAM,CAAC,mBAAmB,kBAAkB,MAAM,QAAQ,IAAI,CAC5D,KAAK,0BAA0B,GAC/B,KAAK,SAAS,KAAK,CACrB,CAAC;EAED,IAAI,CAAC,gBACH,MAAM,KAAK,aAAa,iBAAiB;OAEzC,MAAM,KAAK,eAAe,iBAAiB;EAG7C,KAAK,gBAAgB,MAAM,KAAK,KAAK;EACrC,KAAK,eAAe,qBAAqB;EACzC,KAAK,eAAe,oBAAoB;EACxC,MAAM,KAAK,SAAS,KAAK;CAC3B;CAEA,MAAa,YAAY,OAAkE;EACzF,MAAM,eAAe,CAAC,GAAG,MAAM,OAAO,GAAG,MAAM,OAAO,EACnD,KAAK,SAAS,KAAK,MAAM,IAAI,KAAK,WAAW,IAAI,CAAC,CAAC,EACnD,QAAQ,SAA8B,CAAC,CAAC,IAAI;EAE/C,MAAM,gBAAgB,MAAM,QACzB,KAAK,SAAS,KAAK,MAAM,IAAI,KAAK,WAAW,IAAI,CAAC,CAAC,EACnD,QAAQ,SAA8B,CAAC,CAAC,IAAI;EAE/C,MAAM,KAAK,qBAAqB,cAAc,YAAY;EAC1D,KAAK,qBAAqB,YAAY,aAAa;EACnD,KAAK,qBAAqB,WAAW,YAAY;CACnD;CAEA,MAAa,oBAAoB,gBAA6D;EAC5F,UAAU,+CAA+C;EACzD,MAAM,WAAW,kBAAkB,CAAC,IAAI,wBAAwB,GAAG,IAAI,oBAAoB,CAAC;EAC5F,MAAM,KAAK,qBAAqB,kBAAkB,QAAQ,EAAE,WAAW;EACvE,MAAM,KAAK,qBAAqB,iBAAiB;CACnD;;;;CAKA,MAAa,4BAA+C;EAE1D,QAAO,MADqB,sBAAsB,GAC7B,KAAK,YAAY,KAAK,WAAW,OAAO,CAAC;CAChE;;;;CAKA,MAAc,aAAa,WAAqB;EAC9C,UAAU,cAAc,UAAU,OAAO,UAAU;EACnD,MAAM,aAAa,gBAAuC,OAAO,iBAAiB;GAChF,MAAM,cAAc,IAAI,YACtB,KAAK,WAAW,YAAY,GAC5B,KAAK,OACL,KAAK,cACP;GACA,KAAK,MAAM,IAAI,cAAc,WAAW;GACxC,MAAM,YAAY,QAAQ;EAC5B,CAAC;EACD,cAAc,aAAa,UAAU,OAAO,OAAO;CACrD;CAEA,MAAc,eAAe,mBAA6B;EACxD,MAAM,kBAAkB,IAAI,IAAI,KAAK,SAAS,gBAAgB,CAAC;EAC/D,MAAM,uBAAuB,IAAI,IAAI,iBAAiB;EAEtD,MAAM,WAAW,kBAAkB,QAAQ,MAAM,CAAC,gBAAgB,IAAI,CAAC,CAAC;EACxE,MAAM,eAAe,MAAM,KAAK,eAAe,EAAE,QAAQ,MAAM,CAAC,qBAAqB,IAAI,CAAC,CAAC;EAC3F,MAAM,gBAAgB,kBAAkB,QAAQ,MAAM,gBAAgB,IAAI,CAAC,CAAC;EAE5E,IAAI,SAAS,SAAS,KAAK,aAAa,SAAS,GAC/C,UACE,gBAAgB,OAAO,MAAM,SAAS,MAAM,EAAE,QAAQ,OAAO,IAAI,aAAa,MAAM,EAAE,YAAY,OAAO,KAAK,cAAc,MAAM,EAAE,UACtI;EAGF,MAAM,KAAK,aAAa,QAAQ;EAEhC,KAAK,MAAM,gBAAgB,cAAc;GACvC,KAAK,SAAS,WAAW,YAAY;GACrC,KAAK,MAAM,OAAO,YAAY;EAChC;EAEA,MAAM,aAAa,oBAA2C,OAAO,iBAAiB;GACpF,MAAM,cAAc,IAAI,YACtB,KAAK,WAAW,YAAY,GAC5B,KAAK,OACL,KAAK,cACP;GACA,KAAK,MAAM,IAAI,cAAc,WAAW;GACxC,MAAM,YAAY,KAAK,KAAK,SAAS,QAAQ,YAAY,CAAC;EAC5D,CAAC;CACH;CAEA,MAAa,aAAa;EACxB,cAAc,2BAA2B;EAEzC,KAAK,aAAa,cAAc,MAAM,KAAK,aAAa,iBAAiB,CAAC,CAAC;EAC3E,KAAK,aAAa,WAAW,MAAM,KAAK,aAAa,cAAc,CAAC,CAAC;EACrE,KAAK,aAAa,cAAc,MAAM,KAAK,aAAa,iBAAiB,CAAC,CAAC;EAE3E,MAAM,cAAc,qBAAqB,IAAI,WAAW,GAAG;EAC3D,MAAM,KAAK,aAAa,MAAM,WAAW;CAC3C;AACF;AAEA,eAAe,aACb,OACA,MACA,IACe;CACf,IAAI,MAAM,WAAW,GAAG;CACxB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,MACrC,MAAM,QAAQ,IAAI,MAAM,MAAM,GAAG,IAAI,IAAI,EAAE,IAAI,EAAE,CAAC;AAEtD;AAEA,MAAa,oBAAoB,IAAI,kBAAkB"}

package/esm/dev-server/files-watcher.d.mts

@@ -0,0 +1,69 @@
+//#region ../../@warlock.js/core/src/dev-server/files-watcher.d.ts
+type FileWatcherEvent = "change" | "delete" | "add" | "error" | "addDir" | "unlinkDir";
+type FileChangeCallback = (filePath: string) => void;
+type FileDeleteCallback = (filePath: string) => void;
+type FileAddCallback = (filePath: string) => void;
+type FileErrorCallback = (filePath: string, error: Error) => void;
+type FileAddDirCallback = (filePath: string) => void;
+type FileUnlinkDirCallback = (filePath: string) => void;
+type OnFileEventCallback = FileChangeCallback | FileDeleteCallback | FileAddCallback | FileErrorCallback | FileAddDirCallback | FileUnlinkDirCallback;
+/**
+ * Watch configuration options
+ */
+type WatchConfig = {
+  /**
+   * Glob patterns to include
+   */
+  include?: string[];
+  /**
+   * Glob patterns to exclude
+   */
+  exclude?: string[];
+};
+declare class FilesWatcher {
+  /**
+   * File watcher id
+   */
+  private id;
+  /**
+   * Watch for files changes
+   * @param config Optional watch configuration
+   */
+  watch(config?: WatchConfig): Promise<void>;
+  /**
+   * Trigger event immediately (no debouncing here)
+   * Debouncing is handled at the orchestrator level for batch processing
+   */
+  private triggerEvent;
+  /**
+   * On file change event
+   */
+  onFileChange(callback: FileChangeCallback): import("@mongez/events").EventSubscription;
+  /**
+   * On file delete event
+   */
+  onFileDelete(callback: FileDeleteCallback): import("@mongez/events").EventSubscription;
+  /**
+   * On file add event
+   */
+  onFileAdd(callback: FileAddCallback): import("@mongez/events").EventSubscription;
+  /**
+   * On file error event
+   */
+  onFileError(callback: FileErrorCallback): import("@mongez/events").EventSubscription;
+  /**
+   * On file add dir event
+   */
+  onDirectoryAdd(callback: FileAddDirCallback): import("@mongez/events").EventSubscription;
+  /**
+   * On file unlink dir event
+   */
+  onDirectoryRemove(callback: FileUnlinkDirCallback): import("@mongez/events").EventSubscription;
+  /**
+   * On file event
+   */
+  on(event: FileWatcherEvent, callback: OnFileEventCallback): import("@mongez/events").EventSubscription;
+}
+//#endregion
+export { FilesWatcher };
+//# sourceMappingURL=files-watcher.d.mts.map

package/esm/dev-server/files-watcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-watcher.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/files-watcher.ts"],"mappings":";KAOK,gBAAA;AAAA,KAEA,kBAAA,IAAsB,QAAgB;AAAA,KACtC,kBAAA,IAAsB,QAAgB;AAAA,KACtC,eAAA,IAAmB,QAAgB;AAAA,KACnC,iBAAA,IAAqB,QAAA,UAAkB,KAAA,EAAO,KAAK;AAAA,KACnD,kBAAA,IAAsB,QAAgB;AAAA,KACtC,qBAAA,IAAyB,QAAgB;AAAA,KACzC,mBAAA,GACD,kBAAA,GACA,kBAAA,GACA,eAAA,GACA,iBAAA,GACA,kBAAA,GACA,qBAAA;;;AAZuC;KAiB/B,WAAA;EAhBW;;;EAoBrB,OAAA;EAnBG;;;EAuBH,OAAO;AAAA;AAAA,cAsBI,YAAA;EA5CS;;;EAAA,QAgDZ,EAAA;EAhDyC;;;AAAK;EAsDzC,KAAA,CAAM,MAAA,GAAS,WAAA,GAAW,OAAA;EArDlB;;;AAAoB;EAApB,QA8Gb,YAAA;EA7GgB;;;EAoHjB,YAAA,CAAa,QAAA,EAAU,kBAAA,4BAAkB,iBAAA;EAnH7C;;;EA0HI,YAAA,CAAa,QAAA,EAAU,kBAAA,4BAAkB,iBAAA;EAxH9C;;;EA+HK,SAAA,CAAU,QAAA,EAAU,eAAA,4BAAe,iBAAA;EA3HxC;;;EAkIK,WAAA,CAAY,QAAA,EAAU,iBAAA,4BAAiB,iBAAA;EAtI5C;;;EA6IK,cAAA,CAAe,QAAA,EAAU,kBAAA,4BAAkB,iBAAA;EAzIhD;;AAAqB;EAgJhB,iBAAA,CAAkB,QAAA,EAAU,qBAAA,4BAAqB,iBAAA;EA3InC;;;EAkJd,EAAA,CAAG,KAAA,EAAO,gBAAA,EAAkB,QAAA,EAAU,mBAAA,4BAAmB,iBAAA;AAAA"}

package/esm/dev-server/files-watcher.mjs

@@ -0,0 +1,129 @@
+import { rootPath, srcPath } from "../utils/paths.mjs";
+import "../utils/index.mjs";
+import { Path } from "./path.mjs";
+import { warlockConfigManager } from "../warlock-config/warlock-config.manager.mjs";
+import { Random } from "@mongez/reinforcements";
+import events from "@mongez/events";
+import chokidar from "chokidar";
+
+//#region ../../@warlock.js/core/src/dev-server/files-watcher.ts
+/**
+* Default patterns to exclude from watching
+*/
+const DEFAULT_EXCLUDE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.warlock/**",
+	"**/.git/**"
+];
+/**
+* All .env file variants to watch
+*/
+const ENV_FILES = [
+	".env",
+	".env.local",
+	".env.development",
+	".env.development.local",
+	".env.test",
+	".env.test.local",
+	".env.production",
+	".env.production.local"
+];
+var FilesWatcher = class {
+	constructor() {
+		this.id = Random.string();
+	}
+	/**
+	* Watch for files changes
+	* @param config Optional watch configuration
+	*/
+	async watch(config) {
+		const userWatchConfig = (await warlockConfigManager.lazyGet("devServer"))?.watch;
+		const basePaths = [
+			...ENV_FILES.map((file) => rootPath(file)),
+			rootPath("warlock.config.ts"),
+			srcPath()
+		];
+		const additionalPaths = userWatchConfig?.include || config?.include || [];
+		const paths = [...basePaths, ...additionalPaths].map((path) => Path.normalize(path));
+		const ignored = [
+			...DEFAULT_EXCLUDE,
+			...userWatchConfig?.exclude || [],
+			...config?.exclude || []
+		];
+		const watcher = chokidar.watch(paths, {
+			ignoreInitial: true,
+			ignored,
+			persistent: true,
+			usePolling: false,
+			interval: 100,
+			binaryInterval: 300,
+			awaitWriteFinish: {
+				stabilityThreshold: 100,
+				pollInterval: 50
+			},
+			depth: 99
+		});
+		watcher.on("add", (filePath) => this.triggerEvent("add", filePath));
+		watcher.on("change", (filePath) => this.triggerEvent("change", filePath));
+		watcher.on("unlink", (filePath) => this.triggerEvent("delete", filePath));
+		watcher.on("addDir", (filePath) => this.triggerEvent("addDir", filePath));
+		watcher.on("unlinkDir", (filePath) => this.triggerEvent("unlinkDir", filePath));
+		process.on("SIGINT", async () => {
+			await watcher.close();
+		});
+	}
+	/**
+	* Trigger event immediately (no debouncing here)
+	* Debouncing is handled at the orchestrator level for batch processing
+	*/
+	triggerEvent(event, filePath, error) {
+		events.trigger(`file-watcher.${this.id}.${event}`, Path.normalize(filePath), error);
+	}
+	/**
+	* On file change event
+	*/
+	onFileChange(callback) {
+		return this.on("change", callback);
+	}
+	/**
+	* On file delete event
+	*/
+	onFileDelete(callback) {
+		return this.on("delete", callback);
+	}
+	/**
+	* On file add event
+	*/
+	onFileAdd(callback) {
+		return this.on("add", callback);
+	}
+	/**
+	* On file error event
+	*/
+	onFileError(callback) {
+		return this.on("error", callback);
+	}
+	/**
+	* On file add dir event
+	*/
+	onDirectoryAdd(callback) {
+		return this.on("addDir", callback);
+	}
+	/**
+	* On file unlink dir event
+	*/
+	onDirectoryRemove(callback) {
+		return this.on("unlinkDir", callback);
+	}
+	/**
+	* On file event
+	*/
+	on(event, callback) {
+		return events.subscribe(`file-watcher.${this.id}.${event}`, callback);
+	}
+};
+
+//#endregion
+export { FilesWatcher };
+//# sourceMappingURL=files-watcher.mjs.map

package/esm/dev-server/files-watcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-watcher.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/files-watcher.ts"],"sourcesContent":["import events from \"@mongez/events\";\r\nimport { Random } from \"@mongez/reinforcements\";\r\nimport chokidar from \"chokidar\";\r\nimport { rootPath, srcPath } from \"../utils\";\r\nimport { warlockConfigManager } from \"../warlock-config/warlock-config.manager\";\r\nimport { Path } from \"./path\";\r\n\r\ntype FileWatcherEvent = \"change\" | \"delete\" | \"add\" | \"error\" | \"addDir\" | \"unlinkDir\";\r\n\r\ntype FileChangeCallback = (filePath: string) => void;\r\ntype FileDeleteCallback = (filePath: string) => void;\r\ntype FileAddCallback = (filePath: string) => void;\r\ntype FileErrorCallback = (filePath: string, error: Error) => void;\r\ntype FileAddDirCallback = (filePath: string) => void;\r\ntype FileUnlinkDirCallback = (filePath: string) => void;\r\ntype OnFileEventCallback =\r\n  | FileChangeCallback\r\n  | FileDeleteCallback\r\n  | FileAddCallback\r\n  | FileErrorCallback\r\n  | FileAddDirCallback\r\n  | FileUnlinkDirCallback;\r\n\r\n/**\r\n * Watch configuration options\r\n */\r\nexport type WatchConfig = {\r\n  /**\r\n   * Glob patterns to include\r\n   */\r\n  include?: string[];\r\n  /**\r\n   * Glob patterns to exclude\r\n   */\r\n  exclude?: string[];\r\n};\r\n\r\n/**\r\n * Default patterns to exclude from watching\r\n */\r\nconst DEFAULT_EXCLUDE = [\"**/node_modules/**\", \"**/dist/**\", \"**/.warlock/**\", \"**/.git/**\"];\r\n\r\n/**\r\n * All .env file variants to watch\r\n */\r\nconst ENV_FILES = [\r\n  \".env\",\r\n  \".env.local\",\r\n  \".env.development\",\r\n  \".env.development.local\",\r\n  \".env.test\",\r\n  \".env.test.local\",\r\n  \".env.production\",\r\n  \".env.production.local\",\r\n];\r\n\r\nexport class FilesWatcher {\r\n  /**\r\n   * File watcher id\r\n   */\r\n  private id = Random.string();\r\n\r\n  /**\r\n   * Watch for files changes\r\n   * @param config Optional watch configuration\r\n   */\r\n  public async watch(config?: WatchConfig) {\r\n    // Get user config from warlock.config.ts\r\n    const devServerConfig = await warlockConfigManager.lazyGet(\"devServer\");\r\n    const userWatchConfig = devServerConfig?.watch;\r\n\r\n    // Build paths to watch:\r\n    // 1. All .env variants that exist\r\n    // 2. warlock.config.ts (project-level settings; restart-required on change)\r\n    // 3. src directory\r\n    // 4. Any additional paths from user config\r\n    const envPaths = ENV_FILES.map((file) => rootPath(file));\r\n    const basePaths = [...envPaths, rootPath(\"warlock.config.ts\"), srcPath()];\r\n    const additionalPaths = userWatchConfig?.include || config?.include || [];\r\n\r\n    const paths = [...basePaths, ...additionalPaths].map((path) => Path.normalize(path));\r\n\r\n    // Merge default exclude with config exclude\r\n    const ignored = [\r\n      ...DEFAULT_EXCLUDE,\r\n      ...(userWatchConfig?.exclude || []),\r\n      ...(config?.exclude || []),\r\n    ];\r\n\r\n    const watcher = chokidar.watch(paths, {\r\n      ignoreInitial: true,\r\n      ignored,\r\n      persistent: true,\r\n      usePolling: false, // Try native first, will fallback if needed\r\n      interval: 100,\r\n      binaryInterval: 300,\r\n      awaitWriteFinish: {\r\n        stabilityThreshold: 100,\r\n        pollInterval: 50,\r\n      },\r\n      // On Windows, explicitly enable recursive watching\r\n      depth: 99,\r\n    });\r\n\r\n    watcher.on(\"add\", (filePath) => this.triggerEvent(\"add\", filePath));\r\n    watcher.on(\"change\", (filePath) => this.triggerEvent(\"change\", filePath));\r\n    watcher.on(\"unlink\", (filePath) => this.triggerEvent(\"delete\", filePath));\r\n    watcher.on(\"addDir\", (filePath) => this.triggerEvent(\"addDir\", filePath));\r\n    watcher.on(\"unlinkDir\", (filePath) => this.triggerEvent(\"unlinkDir\", filePath));\r\n    // watcher.on(\"error\", (error: Error, filePath: string) =>\r\n    //   this.triggerEvent(\"error\", filePath, error),\r\n    // );\r\n\r\n    // Cleanup on process exit\r\n    process.on(\"SIGINT\", async () => {\r\n      await watcher.close();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Trigger event immediately (no debouncing here)\r\n   * Debouncing is handled at the orchestrator level for batch processing\r\n   */\r\n  private triggerEvent(event: FileWatcherEvent, filePath: string, error?: Error) {\r\n    events.trigger(`file-watcher.${this.id}.${event}`, Path.normalize(filePath), error);\r\n  }\r\n\r\n  /**\r\n   * On file change event\r\n   */\r\n  public onFileChange(callback: FileChangeCallback) {\r\n    return this.on(\"change\", callback);\r\n  }\r\n\r\n  /**\r\n   * On file delete event\r\n   */\r\n  public onFileDelete(callback: FileDeleteCallback) {\r\n    return this.on(\"delete\", callback);\r\n  }\r\n\r\n  /**\r\n   * On file add event\r\n   */\r\n  public onFileAdd(callback: FileAddCallback) {\r\n    return this.on(\"add\", callback);\r\n  }\r\n\r\n  /**\r\n   * On file error event\r\n   */\r\n  public onFileError(callback: FileErrorCallback) {\r\n    return this.on(\"error\", callback);\r\n  }\r\n\r\n  /**\r\n   * On file add dir event\r\n   */\r\n  public onDirectoryAdd(callback: FileAddDirCallback) {\r\n    return this.on(\"addDir\", callback);\r\n  }\r\n\r\n  /**\r\n   * On file unlink dir event\r\n   */\r\n  public onDirectoryRemove(callback: FileUnlinkDirCallback) {\r\n    return this.on(\"unlinkDir\", callback);\r\n  }\r\n\r\n  /**\r\n   * On file event\r\n   */\r\n  public on(event: FileWatcherEvent, callback: OnFileEventCallback) {\r\n    return events.subscribe(`file-watcher.${this.id}.${event}`, callback);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;;AAwCA,MAAM,kBAAkB;CAAC;CAAsB;CAAc;CAAkB;AAAY;;;;AAK3F,MAAM,YAAY;CAChB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,IAAa,eAAb,MAA0B;;YAIX,OAAO,OAAO;;;;;;CAM3B,MAAa,MAAM,QAAsB;EAGvC,MAAM,mBAAkB,MADM,qBAAqB,QAAQ,WAAW,IAC7B;EAQzC,MAAM,YAAY;GAAC,GADF,UAAU,KAAK,SAAS,SAAS,IAAI,CACzB;GAAG,SAAS,mBAAmB;GAAG,QAAQ;EAAC;EACxE,MAAM,kBAAkB,iBAAiB,WAAW,QAAQ,WAAW,CAAC;EAExE,MAAM,QAAQ,CAAC,GAAG,WAAW,GAAG,eAAe,EAAE,KAAK,SAAS,KAAK,UAAU,IAAI,CAAC;EAGnF,MAAM,UAAU;GACd,GAAG;GACH,GAAI,iBAAiB,WAAW,CAAC;GACjC,GAAI,QAAQ,WAAW,CAAC;EAC1B;EAEA,MAAM,UAAU,SAAS,MAAM,OAAO;GACpC,eAAe;GACf;GACA,YAAY;GACZ,YAAY;GACZ,UAAU;GACV,gBAAgB;GAChB,kBAAkB;IAChB,oBAAoB;IACpB,cAAc;GAChB;GAEA,OAAO;EACT,CAAC;EAED,QAAQ,GAAG,QAAQ,aAAa,KAAK,aAAa,OAAO,QAAQ,CAAC;EAClE,QAAQ,GAAG,WAAW,aAAa,KAAK,aAAa,UAAU,QAAQ,CAAC;EACxE,QAAQ,GAAG,WAAW,aAAa,KAAK,aAAa,UAAU,QAAQ,CAAC;EACxE,QAAQ,GAAG,WAAW,aAAa,KAAK,aAAa,UAAU,QAAQ,CAAC;EACxE,QAAQ,GAAG,cAAc,aAAa,KAAK,aAAa,aAAa,QAAQ,CAAC;EAM9E,QAAQ,GAAG,UAAU,YAAY;GAC/B,MAAM,QAAQ,MAAM;EACtB,CAAC;CACH;;;;;CAMA,AAAQ,aAAa,OAAyB,UAAkB,OAAe;EAC7E,OAAO,QAAQ,gBAAgB,KAAK,GAAG,GAAG,SAAS,KAAK,UAAU,QAAQ,GAAG,KAAK;CACpF;;;;CAKA,AAAO,aAAa,UAA8B;EAChD,OAAO,KAAK,GAAG,UAAU,QAAQ;CACnC;;;;CAKA,AAAO,aAAa,UAA8B;EAChD,OAAO,KAAK,GAAG,UAAU,QAAQ;CACnC;;;;CAKA,AAAO,UAAU,UAA2B;EAC1C,OAAO,KAAK,GAAG,OAAO,QAAQ;CAChC;;;;CAKA,AAAO,YAAY,UAA6B;EAC9C,OAAO,KAAK,GAAG,SAAS,QAAQ;CAClC;;;;CAKA,AAAO,eAAe,UAA8B;EAClD,OAAO,KAAK,GAAG,UAAU,QAAQ;CACnC;;;;CAKA,AAAO,kBAAkB,UAAiC;EACxD,OAAO,KAAK,GAAG,aAAa,QAAQ;CACtC;;;;CAKA,AAAO,GAAG,OAAyB,UAA+B;EAChE,OAAO,OAAO,UAAU,gBAAgB,KAAK,GAAG,GAAG,SAAS,QAAQ;CACtE;AACF"}

package/esm/dev-server/flags.mjs

@@ -0,0 +1,9 @@
+import { warlockPath } from "../utils/paths.mjs";
+import "../utils/index.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/flags.ts
+const MANIFEST_PATH = warlockPath("manifest.json");
+
+//#endregion
+export { MANIFEST_PATH };
+//# sourceMappingURL=flags.mjs.map

package/esm/dev-server/flags.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/flags.ts"],"sourcesContent":["import { warlockPath } from \"../utils\";\n\nexport const MANIFEST_PATH = warlockPath(\"manifest.json\");\n\n/**\n * Number of files to process in parallel per batch\n * Adjust this value to optimize performance vs memory usage\n * - Lower values (10-20): More stable, less memory, slower\n * - Higher values (100-200): Faster, more memory, potential instability\n * - Recommended: 50 for most projects\n */\nexport const FILE_PROCESSING_BATCH_SIZE = 500;\n"],"mappings":";;;;AAEA,MAAa,gBAAgB,YAAY,eAAe"}

package/esm/dev-server/health-checker/checkers/base-health-checker.d.mts

@@ -0,0 +1,55 @@
+import { FileManager } from "../../file-manager.mjs";
+import { FileHealthResult } from "../file-health-result.mjs";
+import { FileHealthCheckerContract, HealthCheckerFilesStats } from "../file-health-checker.contract.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/health-checker/checkers/base-health-checker.d.ts
+type CheckerFile = {
+  file: FileManager;
+  healthResult: FileHealthResult;
+};
+declare abstract class BaseHealthChecker implements FileHealthCheckerContract {
+  /**
+   * List of checked files
+   */
+  protected files: Map<string, CheckerFile>;
+  /**
+   * Health checker name (unique identifier)
+   */
+  abstract name: string;
+  /**
+   * Path to worker file (without extension)
+   *
+   * If provided, the checker runs in a dedicated worker thread.
+   * If undefined, the checker runs in the main thread.
+   *
+   * @see FileHealthCheckerContract.workerPath
+   */
+  workerPath?: string;
+  /**
+   * Initialize the health checker
+   */
+  abstract initialize(): void;
+  /**
+   * Detect when files are changed
+   */
+  onFileChanges(files: FileManager[]): Promise<void>;
+  /**
+   * Remove the given file from the checker
+   */
+  removeFile(file: FileManager): BaseHealthChecker;
+  /**
+   * Validate the health of the file
+   */
+  check(file: FileManager): Promise<FileHealthResult>;
+  /**
+   * Validate the health of the file
+   */
+  abstract validate(file: FileManager, result: FileHealthResult): Promise<FileHealthResult>;
+  /**
+   * Get the stats of the health checker
+   */
+  stats(): Promise<HealthCheckerFilesStats>;
+}
+//#endregion
+export { BaseHealthChecker };
+//# sourceMappingURL=base-health-checker.d.mts.map

package/esm/dev-server/health-checker/checkers/base-health-checker.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-health-checker.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/core/src/dev-server/health-checker/checkers/base-health-checker.ts"],"mappings":";;;;;KAOK,WAAA;EACH,IAAA,EAAM,WAAA;EACN,YAAA,EAAc,gBAAgB;AAAA;AAAA,uBAGV,iBAAA,YAA6B,yBAAA;EAHnB;;;EAAA,UAOpB,KAAA,EAAO,GAAA,SAAY,WAAA;EAPf;;AAAgB;EAAhB,SAYE,IAAA;EATsB;;;;;;;;EAmB/B,UAAA;EAyBwC;;;EAAA,SApB/B,UAAA,CAAA;EAkC+D;;;EA7BlE,aAAA,CAAc,KAAA,EAAO,WAAA,KAAgB,OAAA;EA7BD;;;EAoC1C,UAAA,CAAW,IAAA,EAAM,WAAA,GAAc,iBAAA;EAhC5B;;;EAwCG,KAAA,CAAM,IAAA,EAAM,WAAA,GAAc,OAAA,CAAQ,gBAAA;EAzBxC;;;EAAA,SAuCS,QAAA,CAAS,IAAA,EAAM,WAAA,EAAa,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,gBAAA;EA7BpD;;;EAkCd,KAAA,CAAA,GAAS,OAAA,CAAQ,uBAAA;AAAA"}

package/esm/dev-server/health-checker/checkers/base-health-checker.mjs

@@ -0,0 +1,65 @@
+import { FileHealthResult } from "../file-health-result.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/health-checker/checkers/base-health-checker.ts
+var BaseHealthChecker = class {
+	constructor() {
+		this.files = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Detect when files are changed
+	*/
+	async onFileChanges(files) {}
+	/**
+	* Remove the given file from the checker
+	*/
+	removeFile(file) {
+		this.files.delete(file.relativePath);
+		return this;
+	}
+	/**
+	* Validate the health of the file
+	*/
+	async check(file) {
+		const result = new FileHealthResult();
+		this.files.set(file.relativePath, {
+			file,
+			healthResult: result
+		});
+		return await this.validate(file, result);
+	}
+	/**
+	* Get the stats of the health checker
+	*/
+	async stats() {
+		const result = {
+			name: this.name,
+			files: {
+				healthy: 0,
+				defective: 0
+			},
+			warnings: {
+				total: 0,
+				totalFiles: 0
+			},
+			errors: {
+				total: 0,
+				totalFiles: 0
+			}
+		};
+		for (const file of this.files.values()) {
+			const stats = file.healthResult.getStats();
+			const isHealthy = stats.state === "healthy";
+			result.files.healthy += isHealthy ? 1 : 0;
+			result.files.defective += !isHealthy ? 1 : 0;
+			result.warnings.total += stats.warnings;
+			result.warnings.totalFiles += stats.warnings > 0 ? 1 : 0;
+			result.errors.total += stats.errors;
+			result.errors.totalFiles += stats.errors > 0 ? 1 : 0;
+		}
+		return result;
+	}
+};
+
+//#endregion
+export { BaseHealthChecker };
+//# sourceMappingURL=base-health-checker.mjs.map

package/esm/dev-server/health-checker/checkers/base-health-checker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-health-checker.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/dev-server/health-checker/checkers/base-health-checker.ts"],"sourcesContent":["import type { FileManager } from \"../../file-manager\";\nimport type {\n  FileHealthCheckerContract,\n  HealthCheckerFilesStats,\n} from \"../file-health-checker.contract\";\nimport { FileHealthResult } from \"../file-health-result\";\n\ntype CheckerFile = {\n  file: FileManager;\n  healthResult: FileHealthResult;\n};\n\nexport abstract class BaseHealthChecker implements FileHealthCheckerContract {\n  /**\n   * List of checked files\n   */\n  protected files: Map<string, CheckerFile> = new Map();\n\n  /**\n   * Health checker name (unique identifier)\n   */\n  public abstract name: string;\n\n  /**\n   * Path to worker file (without extension)\n   *\n   * If provided, the checker runs in a dedicated worker thread.\n   * If undefined, the checker runs in the main thread.\n   *\n   * @see FileHealthCheckerContract.workerPath\n   */\n  public workerPath?: string;\n\n  /**\n   * Initialize the health checker\n   */\n  public abstract initialize(): void;\n\n  /**\n   * Detect when files are changed\n   */\n  public async onFileChanges(files: FileManager[]): Promise<void> {\n    //\n  }\n\n  /**\n   * Remove the given file from the checker\n   */\n  public removeFile(file: FileManager): BaseHealthChecker {\n    this.files.delete(file.relativePath);\n    return this;\n  }\n\n  /**\n   * Validate the health of the file\n   */\n  public async check(file: FileManager): Promise<FileHealthResult> {\n    const result = new FileHealthResult();\n\n    this.files.set(file.relativePath, {\n      file,\n      healthResult: result,\n    });\n\n    return await this.validate(file, result);\n  }\n\n  /**\n   * Validate the health of the file\n   */\n  public abstract validate(file: FileManager, result: FileHealthResult): Promise<FileHealthResult>;\n\n  /**\n   * Get the stats of the health checker\n   */\n  public async stats(): Promise<HealthCheckerFilesStats> {\n    const result: HealthCheckerFilesStats = {\n      name: this.name,\n      files: {\n        healthy: 0,\n        defective: 0,\n      },\n      warnings: {\n        total: 0,\n        totalFiles: 0,\n      },\n      errors: {\n        total: 0,\n        totalFiles: 0,\n      },\n    };\n\n    for (const file of this.files.values()) {\n      const healthResult = file.healthResult;\n      const stats = healthResult.getStats();\n      const isHealthy = stats.state === \"healthy\";\n      result.files.healthy += isHealthy ? 1 : 0;\n      result.files.defective += !isHealthy ? 1 : 0;\n      result.warnings.total += stats.warnings;\n      result.warnings.totalFiles += stats.warnings > 0 ? 1 : 0;\n      result.errors.total += stats.errors;\n      result.errors.totalFiles += stats.errors > 0 ? 1 : 0;\n    }\n\n    return result;\n  }\n}\n"],"mappings":";;;AAYA,IAAsB,oBAAtB,MAA6E;;+BAI/B,IAAI,IAAI;;;;;CAyBpD,MAAa,cAAc,OAAqC,CAEhE;;;;CAKA,AAAO,WAAW,MAAsC;EACtD,KAAK,MAAM,OAAO,KAAK,YAAY;EACnC,OAAO;CACT;;;;CAKA,MAAa,MAAM,MAA8C;EAC/D,MAAM,SAAS,IAAI,iBAAiB;EAEpC,KAAK,MAAM,IAAI,KAAK,cAAc;GAChC;GACA,cAAc;EAChB,CAAC;EAED,OAAO,MAAM,KAAK,SAAS,MAAM,MAAM;CACzC;;;;CAUA,MAAa,QAA0C;EACrD,MAAM,SAAkC;GACtC,MAAM,KAAK;GACX,OAAO;IACL,SAAS;IACT,WAAW;GACb;GACA,UAAU;IACR,OAAO;IACP,YAAY;GACd;GACA,QAAQ;IACN,OAAO;IACP,YAAY;GACd;EACF;EAEA,KAAK,MAAM,QAAQ,KAAK,MAAM,OAAO,GAAG;GAEtC,MAAM,QADe,KAAK,aACC,SAAS;GACpC,MAAM,YAAY,MAAM,UAAU;GAClC,OAAO,MAAM,WAAW,YAAY,IAAI;GACxC,OAAO,MAAM,aAAa,CAAC,YAAY,IAAI;GAC3C,OAAO,SAAS,SAAS,MAAM;GAC/B,OAAO,SAAS,cAAc,MAAM,WAAW,IAAI,IAAI;GACvD,OAAO,OAAO,SAAS,MAAM;GAC7B,OAAO,OAAO,cAAc,MAAM,SAAS,IAAI,IAAI;EACrD;EAEA,OAAO;CACT;AACF"}

package/esm/dev-server/health-checker/checkers/eslint-health-checker.d.mts

@@ -0,0 +1,44 @@
+import { FileManager } from "../../file-manager.mjs";
+import { FileHealthResult } from "../file-health-result.mjs";
+import { FileHealthCheckerContract } from "../file-health-checker.contract.mjs";
+import { BaseHealthChecker } from "./base-health-checker.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/health-checker/checkers/eslint-health-checker.d.ts
+declare class EslintHealthChecker extends BaseHealthChecker implements FileHealthCheckerContract {
+  /**
+   * ESLint instance (using new ESLint v9 API with flat config)
+   */
+  private eslint;
+  /**
+   * Health checker name
+   */
+  name: string;
+  /**
+   * Path to dedicated worker file for ESLint checking
+   * Runs in a separate thread to avoid blocking the main dev server
+   */
+  workerPath: string;
+  /**
+   * Whether checker is initialized
+   */
+  private initialized;
+  /**
+   * Check if file is a lintable file
+   */
+  private isLintableFile;
+  /**
+   * Initialize the health checker
+   */
+  initialize(): EslintHealthChecker;
+  /**
+   * Display health check results in a pretty format
+   */
+  private displayResults;
+  /**
+   * Validate the health of the file
+   */
+  validate(file: FileManager, result: FileHealthResult): Promise<FileHealthResult>;
+}
+//#endregion
+export { EslintHealthChecker };
+//# sourceMappingURL=eslint-health-checker.d.mts.map

package/esm/dev-server/health-checker/checkers/eslint-health-checker.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint-health-checker.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/core/src/dev-server/health-checker/checkers/eslint-health-checker.ts"],"mappings":";;;;;;cASa,mBAAA,SAA4B,iBAAA,YAA6B,yBAAA;;AAAtE;;UAIU,MAAA;EA+Ba;;;EA1Bd,IAAA;EA2K6D;;;;EArK7D,UAAA;EAfgC;;;EAAA,QAoB/B,WAAA;EALD;;;EAAA,QAUC,cAAA;EAUa;;;EAAd,UAAA,CAAA,GAAc,mBAAA;EAiJC;;;EAAA,QA5Gd,cAAA;EA4GoE;;AAAgB;EAA/E,QAAA,CAAS,IAAA,EAAM,WAAA,EAAa,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,gBAAA;AAAA"}