@warlock.js/core 4.0.174 → 4.1.3

package/esm/dev-server/file-event-handler.mjs

@@ -0,0 +1,98 @@
+import { Path } from "./path.mjs";
+import { devLogSuccess } from "./dev-logger.mjs";
+import "./flags.mjs";
+import { clearFileExistsCache } from "./parse-imports.mjs";
+import { debounce } from "@mongez/reinforcements";
+import events from "@mongez/events";
+
+//#region ../../@warlock.js/core/src/dev-server/file-event-handler.ts
+/**
+* Receives raw watcher events and processes them in a single debounced batch.
+* Order within a batch: adds → changes → deletes, so changes can reference
+* newly-added files and deletes fire last.
+*/
+var FileEventHandler = class {
+	constructor(fileOperations, manifest, dependencyGraph, files) {
+		this.fileOperations = fileOperations;
+		this.manifest = manifest;
+		this.dependencyGraph = dependencyGraph;
+		this.files = files;
+		this.pendingChanges = /* @__PURE__ */ new Set();
+		this.pendingAdds = /* @__PURE__ */ new Set();
+		this.pendingDeletes = /* @__PURE__ */ new Set();
+		this.processPendingEvents = debounce(() => this.processBatch(), 150);
+	}
+	handleFileChange(absolutePath) {
+		this.pendingChanges.add(Path.toRelative(absolutePath));
+		this.processPendingEvents();
+	}
+	handleFileAdd(absolutePath) {
+		this.pendingAdds.add(Path.toRelative(absolutePath));
+		this.processPendingEvents();
+	}
+	handleFileDelete(absolutePath) {
+		this.pendingDeletes.add(Path.toRelative(absolutePath));
+		this.processPendingEvents();
+	}
+	async processBatch() {
+		const changes = Array.from(this.pendingChanges);
+		const adds = Array.from(this.pendingAdds);
+		const deletes = Array.from(this.pendingDeletes);
+		this.pendingChanges.clear();
+		this.pendingAdds.clear();
+		this.pendingDeletes.clear();
+		if (changes.length === 0 && adds.length === 0 && deletes.length === 0) return;
+		const codeChanges = changes.filter((p) => !isExternalPath(p));
+		const codeAdds = adds.filter((p) => !isExternalPath(p));
+		if (codeAdds.length + codeChanges.length > 1) {
+			await new Promise((resolve) => setTimeout(resolve, 500));
+			clearFileExistsCache();
+		}
+		await this.processBatchAdds(codeAdds);
+		await this.processBatchChanges(codeChanges);
+		await this.processBatchDeletes(deletes);
+		this.fileOperations.updateFileDependents();
+		this.fileOperations.syncFilesToManifest();
+		await this.manifest.save();
+		events.trigger("dev-server:batch-complete", {
+			added: adds,
+			changed: changes,
+			deleted: deletes
+		});
+	}
+	async processBatchChanges(relativePaths) {
+		await runInBatches(relativePaths, 500, (path) => this.fileOperations.updateFile(path));
+	}
+	async processBatchAdds(relativePaths) {
+		await runInBatches(relativePaths, 500, async (path) => {
+			try {
+				await this.fileOperations.addFile(path);
+				devLogSuccess(`Added file: ${path}`);
+			} catch (error) {
+				console.error(`Failed to add file ${path}:`, error);
+			}
+		});
+	}
+	async processBatchDeletes(relativePaths) {
+		for (const relativePath of relativePaths) {
+			await this.fileOperations.deleteFile(relativePath);
+			devLogSuccess(`Deleted file: ${relativePath}`);
+		}
+	}
+};
+function isEnvFile(path) {
+	const basename = path.split("/").pop() || path;
+	return basename === ".env" || basename.startsWith(".env.");
+}
+/** Paths watched but never added to the dependency graph. */
+function isExternalPath(path) {
+	return isEnvFile(path) || path === "warlock.config.ts";
+}
+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));
+}
+
+//#endregion
+export { FileEventHandler };
+//# sourceMappingURL=file-event-handler.mjs.map

package/esm/dev-server/file-event-handler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-event-handler.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/file-event-handler.ts"],"sourcesContent":["import events from \"@mongez/events\";\r\nimport { debounce } from \"@mongez/reinforcements\";\r\nimport type { DependencyGraph } from \"./dependency-graph\";\r\nimport { devLogSuccess } from \"./dev-logger\";\r\nimport type { FileManager } from \"./file-manager\";\r\nimport type { FileOperations } from \"./file-operations\";\r\nimport { FILE_PROCESSING_BATCH_SIZE } from \"./flags\";\r\nimport type { ManifestManager } from \"./manifest-manager\";\r\nimport { clearFileExistsCache } from \"./parse-imports\";\r\nimport { Path } from \"./path\";\r\n\r\n/**\r\n * Receives raw watcher events and processes them in a single debounced batch.\r\n * Order within a batch: adds → changes → deletes, so changes can reference\r\n * newly-added files and deletes fire last.\r\n */\r\nexport class FileEventHandler {\r\n  private pendingChanges = new Set<string>();\r\n  private pendingAdds = new Set<string>();\r\n  private pendingDeletes = new Set<string>();\r\n\r\n  private readonly processPendingEvents = debounce(() => this.processBatch(), 150);\r\n\r\n  constructor(\r\n    private readonly fileOperations: FileOperations,\r\n    private readonly manifest: ManifestManager,\r\n    private readonly dependencyGraph: DependencyGraph,\r\n    private readonly files: Map<string, FileManager>,\r\n  ) {}\r\n\r\n  public handleFileChange(absolutePath: string): void {\r\n    this.pendingChanges.add(Path.toRelative(absolutePath));\r\n    this.processPendingEvents();\r\n  }\r\n\r\n  public handleFileAdd(absolutePath: string): void {\r\n    this.pendingAdds.add(Path.toRelative(absolutePath));\r\n    this.processPendingEvents();\r\n  }\r\n\r\n  public handleFileDelete(absolutePath: string): void {\r\n    this.pendingDeletes.add(Path.toRelative(absolutePath));\r\n    this.processPendingEvents();\r\n  }\r\n\r\n  private async processBatch(): Promise<void> {\r\n    const changes = Array.from(this.pendingChanges);\r\n    const adds = Array.from(this.pendingAdds);\r\n    const deletes = Array.from(this.pendingDeletes);\r\n\r\n    this.pendingChanges.clear();\r\n    this.pendingAdds.clear();\r\n    this.pendingDeletes.clear();\r\n\r\n    if (changes.length === 0 && adds.length === 0 && deletes.length === 0) return;\r\n\r\n    // Both .env files and warlock.config.ts live outside src/ — they should\r\n    // never enter the dep graph, only ride along in the batch event so the\r\n    // dev server can react (config reload / restart warning).\r\n    const codeChanges = changes.filter(p => !isExternalPath(p));\r\n    const codeAdds = adds.filter(p => !isExternalPath(p));\r\n\r\n    // Multi-file batches can race the filesystem on Windows.\r\n    if (codeAdds.length + codeChanges.length > 1) {\r\n      await new Promise(resolve => setTimeout(resolve, 500));\r\n      clearFileExistsCache();\r\n    }\r\n\r\n    await this.processBatchAdds(codeAdds);\r\n    await this.processBatchChanges(codeChanges);\r\n    await this.processBatchDeletes(deletes);\r\n\r\n    this.fileOperations.updateFileDependents();\r\n    this.fileOperations.syncFilesToManifest();\r\n    await this.manifest.save();\r\n\r\n    events.trigger(\"dev-server:batch-complete\", {\r\n      added: adds,\r\n      changed: changes,\r\n      deleted: deletes,\r\n    });\r\n  }\r\n\r\n  private async processBatchChanges(relativePaths: string[]): Promise<void> {\r\n    await runInBatches(relativePaths, FILE_PROCESSING_BATCH_SIZE, path =>\r\n      this.fileOperations.updateFile(path),\r\n    );\r\n  }\r\n\r\n  private async processBatchAdds(relativePaths: string[]): Promise<void> {\r\n    await runInBatches(relativePaths, FILE_PROCESSING_BATCH_SIZE, async path => {\r\n      try {\r\n        await this.fileOperations.addFile(path);\r\n        devLogSuccess(`Added file: ${path}`);\r\n      } catch (error) {\r\n        console.error(`Failed to add file ${path}:`, error);\r\n      }\r\n    });\r\n  }\r\n\r\n  private async processBatchDeletes(relativePaths: string[]): Promise<void> {\r\n    for (const relativePath of relativePaths) {\r\n      await this.fileOperations.deleteFile(relativePath);\r\n      devLogSuccess(`Deleted file: ${relativePath}`);\r\n    }\r\n  }\r\n}\r\n\r\nfunction isEnvFile(path: string): boolean {\r\n  const basename = path.split(\"/\").pop() || path;\r\n  return basename === \".env\" || basename.startsWith(\".env.\");\r\n}\r\n\r\n/** Paths watched but never added to the dependency graph. */\r\nfunction isExternalPath(path: string): boolean {\r\n  return isEnvFile(path) || path === \"warlock.config.ts\";\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"],"mappings":";;;;;;;;;;;;;AAgBA,IAAa,mBAAb,MAA8B;CAO5B,YACE,AAAiB,gBACjB,AAAiB,UACjB,AAAiB,iBACjB,AAAiB,OACjB;EAJiB;EACA;EACA;EACA;wCAVM,IAAI,IAAY;qCACnB,IAAI,IAAY;wCACb,IAAI,IAAY;8BAED,eAAe,KAAK,aAAa,GAAG,GAAG;CAO5E;CAEH,AAAO,iBAAiB,cAA4B;EAClD,KAAK,eAAe,IAAI,KAAK,WAAW,YAAY,CAAC;EACrD,KAAK,qBAAqB;CAC5B;CAEA,AAAO,cAAc,cAA4B;EAC/C,KAAK,YAAY,IAAI,KAAK,WAAW,YAAY,CAAC;EAClD,KAAK,qBAAqB;CAC5B;CAEA,AAAO,iBAAiB,cAA4B;EAClD,KAAK,eAAe,IAAI,KAAK,WAAW,YAAY,CAAC;EACrD,KAAK,qBAAqB;CAC5B;CAEA,MAAc,eAA8B;EAC1C,MAAM,UAAU,MAAM,KAAK,KAAK,cAAc;EAC9C,MAAM,OAAO,MAAM,KAAK,KAAK,WAAW;EACxC,MAAM,UAAU,MAAM,KAAK,KAAK,cAAc;EAE9C,KAAK,eAAe,MAAM;EAC1B,KAAK,YAAY,MAAM;EACvB,KAAK,eAAe,MAAM;EAE1B,IAAI,QAAQ,WAAW,KAAK,KAAK,WAAW,KAAK,QAAQ,WAAW,GAAG;EAKvE,MAAM,cAAc,QAAQ,QAAO,MAAK,CAAC,eAAe,CAAC,CAAC;EAC1D,MAAM,WAAW,KAAK,QAAO,MAAK,CAAC,eAAe,CAAC,CAAC;EAGpD,IAAI,SAAS,SAAS,YAAY,SAAS,GAAG;GAC5C,MAAM,IAAI,SAAQ,YAAW,WAAW,SAAS,GAAG,CAAC;GACrD,qBAAqB;EACvB;EAEA,MAAM,KAAK,iBAAiB,QAAQ;EACpC,MAAM,KAAK,oBAAoB,WAAW;EAC1C,MAAM,KAAK,oBAAoB,OAAO;EAEtC,KAAK,eAAe,qBAAqB;EACzC,KAAK,eAAe,oBAAoB;EACxC,MAAM,KAAK,SAAS,KAAK;EAEzB,OAAO,QAAQ,6BAA6B;GAC1C,OAAO;GACP,SAAS;GACT,SAAS;EACX,CAAC;CACH;CAEA,MAAc,oBAAoB,eAAwC;EACxE,MAAM,aAAa,qBAA2C,SAC5D,KAAK,eAAe,WAAW,IAAI,CACrC;CACF;CAEA,MAAc,iBAAiB,eAAwC;EACrE,MAAM,aAAa,oBAA2C,OAAM,SAAQ;GAC1E,IAAI;IACF,MAAM,KAAK,eAAe,QAAQ,IAAI;IACtC,cAAc,eAAe,MAAM;GACrC,SAAS,OAAO;IACd,QAAQ,MAAM,sBAAsB,KAAK,IAAI,KAAK;GACpD;EACF,CAAC;CACH;CAEA,MAAc,oBAAoB,eAAwC;EACxE,KAAK,MAAM,gBAAgB,eAAe;GACxC,MAAM,KAAK,eAAe,WAAW,YAAY;GACjD,cAAc,iBAAiB,cAAc;EAC/C;CACF;AACF;AAEA,SAAS,UAAU,MAAuB;CACxC,MAAM,WAAW,KAAK,MAAM,GAAG,EAAE,IAAI,KAAK;CAC1C,OAAO,aAAa,UAAU,SAAS,WAAW,OAAO;AAC3D;;AAGA,SAAS,eAAe,MAAuB;CAC7C,OAAO,UAAU,IAAI,KAAK,SAAS;AACrC;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"}

package/esm/dev-server/file-manager.d.mts

@@ -0,0 +1,77 @@
+import { FileManifest, FileState, FileType } from "./types.mjs";
+import { FileOperations } from "./file-operations.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/file-manager.d.ts
+type CleanupFunction = () => void;
+/**
+ * FileManager — per-file metadata for the dependency graph.
+ *
+ * The loader hook transpiles and caches on-demand at import time, so this
+ * class never touches disk for anything beyond reading source to hash it
+ * and parse its imports. Its job is keeping the metadata that the
+ * orchestrator needs to invalidate dependents on change.
+ */
+declare class FileManager {
+  readonly absolutePath: string;
+  files: Map<string, FileManager>;
+  fileOperations: FileOperations;
+  relativePath: string;
+  lastModified: number;
+  hash: string;
+  source: string;
+  /** Files this file imports (relative paths). */
+  dependencies: Set<string>;
+  /**
+   * Subset of `dependencies` reached only through type-only imports — a single
+   * runtime occurrence makes the whole edge runtime.
+   */
+  typeOnlyDependencies: Set<string>;
+  /** Original specifier → resolved absolute path. */
+  importMap: Map<string, string>;
+  /** Files that import this file (relative paths). */
+  dependents: Set<string>;
+  type: FileType | undefined;
+  /** Cleanup hooks the loaded module registered for itself. */
+  cleanup: CleanupFunction[];
+  /** Whether the source has zero runtime imports/exports. */
+  isTypeOnlyFile: boolean;
+  state: FileState;
+  constructor(absolutePath: string, files: Map<string, FileManager>, fileOperations: FileOperations);
+  addCleanup(cleanup: CleanupFunction | CleanupFunction[]): void;
+  resetCleanup(): void;
+  /**
+   * Initial setup. Restores from manifest if the hash still matches,
+   * otherwise re-processes from disk.
+   */
+  init(fileManifest?: Partial<FileManifest>): Promise<void>;
+  /**
+   * Read source, hash, parse imports, emit ready. The only file-system
+   * touch happens here; transpilation is the loader hook's job.
+   *
+   * @param force - re-parse even when the hash matches.
+   * @returns true if the file was (re)parsed.
+   */
+  process({
+    force
+  }?: {
+    force?: boolean;
+  }): Promise<boolean>;
+  /**
+   * Parse the current source and refresh `importMap`, `dependencies`, and
+   * `typeOnlyDependencies`. A dependency is classified type-only iff every
+   * import/export statement that resolves to it is type-only — a single
+   * runtime reference makes the whole edge runtime.
+   */
+  protected rebuildImportMetadata(): Promise<void>;
+  /**
+   * Restore from a cached manifest entry. If the on-disk hash matches the
+   * manifest hash, dep-graph metadata is restored from the manifest without
+   * re-parsing. Otherwise the file is reprocessed.
+   */
+  protected initFromManifest(fileManifest: Partial<FileManifest>): Promise<void>;
+  protected detectFileType(): void;
+  toManifest(): FileManifest;
+}
+//#endregion
+export { FileManager };
+//# sourceMappingURL=file-manager.d.mts.map

package/esm/dev-server/file-manager.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-manager.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/file-manager.ts"],"mappings":";;;;KASY,eAAA;;AAAZ;;;;AAA2B;AAU3B;;cAAa,WAAA;EAAA,SAgCO,YAAA;EACT,KAAA,EAAO,GAAA,SAAY,WAAA;EACnB,cAAA,EAAgB,cAAA;EAjClB,YAAA;EACA,YAAA;EACA,IAAA;EACA,MAAA;EAiBM;EAdN,YAAA,EAAY,GAAA;EAsBL;;;;EAhBP,oBAAA,EAAoB,GAAA;EAwBkB;EArBtC,SAAA,EAAS,GAAA;EAmCiB;EAhC1B,UAAA,EAAU,GAAA;EAEV,IAAA,EAAM,QAAA;EAgDsD;EA7C5D,OAAA,EAAS,eAAA;EAsHuC;EAnHhD,cAAA;EAEA,KAAA,EAAO,SAAA;cAGI,YAAA,UACT,KAAA,EAAO,GAAA,SAAY,WAAA,GACnB,cAAA,EAAgB,cAAA;EAGlB,UAAA,CAAW,OAAA,EAAS,eAAA,GAAkB,eAAA;EAMtC,YAAA,CAAA;EAXW;;;;EAmBL,IAAA,CAAK,YAAA,GAAe,OAAA,CAAQ,YAAA,IAAgB,OAAA;EAjBhC;;;;;;;EAmCZ,OAAA,CAAA;IAAU;EAAA;IAAmB,KAAA;EAAA,IAAyB,OAAA;EArDnD;;;;;;EAAA,UA8FA,qBAAA,CAAA,GAAyB,OAAA;EAnFlC;;;;;EAAA,UAmHS,gBAAA,CAAiB,YAAA,EAAc,OAAA,CAAQ,YAAA,IAAgB,OAAA;EAAA,UA6B7D,cAAA,CAAA;EAsBH,UAAA,CAAA,GAAc,YAAA;AAAA"}

package/esm/dev-server/file-manager.mjs

@@ -0,0 +1,157 @@
+import { Path } from "./path.mjs";
+import { isTypeOnlyFile, parseImports } from "./parse-imports.mjs";
+import { DEV_SERVER_EVENTS } from "./events.mjs";
+import events from "@mongez/events";
+import { getFileAsync, lastModifiedAsync } from "@warlock.js/fs";
+import crypto from "crypto";
+
+//#region ../../@warlock.js/core/src/dev-server/file-manager.ts
+/**
+* FileManager — per-file metadata for the dependency graph.
+*
+* The loader hook transpiles and caches on-demand at import time, so this
+* class never touches disk for anything beyond reading source to hash it
+* and parse its imports. Its job is keeping the metadata that the
+* orchestrator needs to invalidate dependents on change.
+*/
+var FileManager = class {
+	constructor(absolutePath, files, fileOperations) {
+		this.absolutePath = absolutePath;
+		this.files = files;
+		this.fileOperations = fileOperations;
+		this.relativePath = "";
+		this.lastModified = 0;
+		this.hash = "";
+		this.source = "";
+		this.dependencies = /* @__PURE__ */ new Set();
+		this.typeOnlyDependencies = /* @__PURE__ */ new Set();
+		this.importMap = /* @__PURE__ */ new Map();
+		this.dependents = /* @__PURE__ */ new Set();
+		this.cleanup = [];
+		this.isTypeOnlyFile = false;
+		this.state = "idle";
+	}
+	addCleanup(cleanup) {
+		const next = Array.isArray(cleanup) ? cleanup : [cleanup];
+		this.cleanup.push(...next);
+		this.cleanup = [...new Set(this.cleanup)];
+	}
+	resetCleanup() {
+		this.cleanup = [];
+	}
+	/**
+	* Initial setup. Restores from manifest if the hash still matches,
+	* otherwise re-processes from disk.
+	*/
+	async init(fileManifest) {
+		this.relativePath = Path.toRelative(this.absolutePath);
+		this.detectFileType();
+		if (fileManifest) await this.initFromManifest(fileManifest);
+		else await this.process();
+	}
+	/**
+	* Read source, hash, parse imports, emit ready. The only file-system
+	* touch happens here; transpilation is the loader hook's job.
+	*
+	* @param force - re-parse even when the hash matches.
+	* @returns true if the file was (re)parsed.
+	*/
+	async process({ force = false } = {}) {
+		if (!this.relativePath) this.relativePath = Path.toRelative(this.absolutePath);
+		if (!this.type) this.detectFileType();
+		this.state = "loading";
+		let newSource;
+		try {
+			newSource = await getFileAsync(this.absolutePath);
+		} catch {
+			this.state = "deleted";
+			return false;
+		}
+		const newHash = crypto.createHash("sha256").update(newSource).digest("hex");
+		if (!force && newHash === this.hash) {
+			this.state = "ready";
+			return false;
+		}
+		this.source = newSource;
+		this.hash = newHash;
+		this.lastModified = (await lastModifiedAsync(this.absolutePath)).getTime();
+		await this.rebuildImportMetadata();
+		this.isTypeOnlyFile = isTypeOnlyFile(this.source);
+		this.state = "ready";
+		events.trigger(DEV_SERVER_EVENTS.FILE_READY, this);
+		return true;
+	}
+	/**
+	* Parse the current source and refresh `importMap`, `dependencies`, and
+	* `typeOnlyDependencies`. A dependency is classified type-only iff every
+	* import/export statement that resolves to it is type-only — a single
+	* runtime reference makes the whole edge runtime.
+	*/
+	async rebuildImportMetadata() {
+		const resolved = await parseImports(this.source, this.absolutePath);
+		this.importMap = /* @__PURE__ */ new Map();
+		this.dependencies = /* @__PURE__ */ new Set();
+		this.typeOnlyDependencies = /* @__PURE__ */ new Set();
+		const runtimePaths = /* @__PURE__ */ new Set();
+		for (const [originalPath, { absolutePath, isTypeOnly }] of resolved) {
+			this.importMap.set(originalPath, absolutePath);
+			const relativePath = Path.toRelative(absolutePath);
+			this.dependencies.add(relativePath);
+			if (!isTypeOnly) runtimePaths.add(relativePath);
+		}
+		for (const dependency of this.dependencies) if (!runtimePaths.has(dependency)) this.typeOnlyDependencies.add(dependency);
+	}
+	/**
+	* Restore from a cached manifest entry. If the on-disk hash matches the
+	* manifest hash, dep-graph metadata is restored from the manifest without
+	* re-parsing. Otherwise the file is reprocessed.
+	*/
+	async initFromManifest(fileManifest) {
+		this.type = fileManifest.type;
+		this.state = "loading";
+		try {
+			this.source = await getFileAsync(this.absolutePath);
+		} catch {
+			this.state = "deleted";
+			return;
+		}
+		if (crypto.createHash("sha256").update(this.source).digest("hex") !== fileManifest.hash) {
+			await this.process({ force: true });
+			return;
+		}
+		this.hash = fileManifest.hash;
+		this.lastModified = fileManifest.lastModified;
+		this.dependencies = new Set(fileManifest.dependencies || []);
+		this.typeOnlyDependencies = new Set(fileManifest.typeOnlyDependencies || []);
+		this.dependents = new Set(fileManifest.dependents || []);
+		this.state = "ready";
+		events.trigger(DEV_SERVER_EVENTS.FILE_READY, this);
+	}
+	detectFileType() {
+		const path = this.relativePath;
+		if (path.includes("main.ts") || path.includes("main.tsx")) this.type = "main";
+		else if (path.startsWith("src/config/")) this.type = "config";
+		else if (path.endsWith("routes.ts") || path.endsWith("routes.tsx")) this.type = "route";
+		else if (path.includes("/events/")) this.type = "event";
+		else if (path.includes("controller")) this.type = "controller";
+		else if (path.includes("service")) this.type = "service";
+		else if (path.endsWith(".model.ts")) this.type = "model";
+		else this.type = "other";
+	}
+	toManifest() {
+		return {
+			absolutePath: this.absolutePath,
+			relativePath: this.relativePath,
+			lastModified: this.lastModified,
+			hash: this.hash,
+			dependencies: Array.from(this.dependencies),
+			typeOnlyDependencies: Array.from(this.typeOnlyDependencies),
+			dependents: Array.from(this.dependents),
+			type: this.type
+		};
+	}
+};
+
+//#endregion
+export { FileManager };
+//# sourceMappingURL=file-manager.mjs.map

package/esm/dev-server/file-manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-manager.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/file-manager.ts"],"sourcesContent":["import events from \"@mongez/events\";\r\nimport { getFileAsync, lastModifiedAsync } from \"@warlock.js/fs\";\r\nimport crypto from \"crypto\";\r\nimport { DEV_SERVER_EVENTS } from \"./events\";\r\nimport { type FileOperations } from \"./file-operations\";\r\nimport { isTypeOnlyFile, parseImports } from \"./parse-imports\";\r\nimport { Path } from \"./path\";\r\nimport type { FileManifest, FileState, FileType } from \"./types\";\r\n\r\nexport type CleanupFunction = () => void;\r\n\r\n/**\r\n * FileManager — per-file metadata for the dependency graph.\r\n *\r\n * The loader hook transpiles and caches on-demand at import time, so this\r\n * class never touches disk for anything beyond reading source to hash it\r\n * and parse its imports. Its job is keeping the metadata that the\r\n * orchestrator needs to invalidate dependents on change.\r\n */\r\nexport class FileManager {\r\n  public relativePath = \"\";\r\n  public lastModified = 0;\r\n  public hash = \"\";\r\n  public source = \"\";\r\n\r\n  /** Files this file imports (relative paths). */\r\n  public dependencies = new Set<string>();\r\n\r\n  /**\r\n   * Subset of `dependencies` reached only through type-only imports — a single\r\n   * runtime occurrence makes the whole edge runtime.\r\n   */\r\n  public typeOnlyDependencies = new Set<string>();\r\n\r\n  /** Original specifier → resolved absolute path. */\r\n  public importMap = new Map<string, string>();\r\n\r\n  /** Files that import this file (relative paths). */\r\n  public dependents = new Set<string>();\r\n\r\n  public type: FileType | undefined;\r\n\r\n  /** Cleanup hooks the loaded module registered for itself. */\r\n  public cleanup: CleanupFunction[] = [];\r\n\r\n  /** Whether the source has zero runtime imports/exports. */\r\n  public isTypeOnlyFile = false;\r\n\r\n  public state: FileState = \"idle\";\r\n\r\n  public constructor(\r\n    public readonly absolutePath: string,\r\n    public files: Map<string, FileManager>,\r\n    public fileOperations: FileOperations,\r\n  ) {}\r\n\r\n  public addCleanup(cleanup: CleanupFunction | CleanupFunction[]) {\r\n    const next = Array.isArray(cleanup) ? cleanup : [cleanup];\r\n    this.cleanup.push(...next);\r\n    this.cleanup = [...new Set(this.cleanup)];\r\n  }\r\n\r\n  public resetCleanup() {\r\n    this.cleanup = [];\r\n  }\r\n\r\n  /**\r\n   * Initial setup. Restores from manifest if the hash still matches,\r\n   * otherwise re-processes from disk.\r\n   */\r\n  public async init(fileManifest?: Partial<FileManifest>): Promise<void> {\r\n    this.relativePath = Path.toRelative(this.absolutePath);\r\n    this.detectFileType();\r\n\r\n    if (fileManifest) {\r\n      await this.initFromManifest(fileManifest);\r\n    } else {\r\n      await this.process();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Read source, hash, parse imports, emit ready. The only file-system\r\n   * touch happens here; transpilation is the loader hook's job.\r\n   *\r\n   * @param force - re-parse even when the hash matches.\r\n   * @returns true if the file was (re)parsed.\r\n   */\r\n  public async process({ force = false }: { force?: boolean } = {}): Promise<boolean> {\r\n    if (!this.relativePath) this.relativePath = Path.toRelative(this.absolutePath);\r\n    if (!this.type) this.detectFileType();\r\n\r\n    this.state = \"loading\";\r\n\r\n    let newSource: string;\r\n\r\n    try {\r\n      newSource = await getFileAsync(this.absolutePath);\r\n    } catch {\r\n      this.state = \"deleted\";\r\n      return false;\r\n    }\r\n\r\n    const newHash = crypto.createHash(\"sha256\").update(newSource).digest(\"hex\");\r\n\r\n    if (!force && newHash === this.hash) {\r\n      this.state = \"ready\";\r\n      return false;\r\n    }\r\n\r\n    this.source = newSource;\r\n    this.hash = newHash;\r\n    this.lastModified = (await lastModifiedAsync(this.absolutePath)).getTime();\r\n\r\n    await this.rebuildImportMetadata();\r\n    this.isTypeOnlyFile = isTypeOnlyFile(this.source);\r\n\r\n    this.state = \"ready\";\r\n    events.trigger(DEV_SERVER_EVENTS.FILE_READY, this);\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Parse the current source and refresh `importMap`, `dependencies`, and\r\n   * `typeOnlyDependencies`. A dependency is classified type-only iff every\r\n   * import/export statement that resolves to it is type-only — a single\r\n   * runtime reference makes the whole edge runtime.\r\n   */\r\n  protected async rebuildImportMetadata(): Promise<void> {\r\n    const resolved = await parseImports(this.source, this.absolutePath);\r\n\r\n    this.importMap = new Map();\r\n    this.dependencies = new Set();\r\n    this.typeOnlyDependencies = new Set();\r\n\r\n    const runtimePaths = new Set<string>();\r\n\r\n    for (const [originalPath, { absolutePath, isTypeOnly }] of resolved) {\r\n      this.importMap.set(originalPath, absolutePath);\r\n\r\n      const relativePath = Path.toRelative(absolutePath);\r\n      this.dependencies.add(relativePath);\r\n\r\n      if (!isTypeOnly) {\r\n        runtimePaths.add(relativePath);\r\n      }\r\n    }\r\n\r\n    for (const dependency of this.dependencies) {\r\n      if (!runtimePaths.has(dependency)) {\r\n        this.typeOnlyDependencies.add(dependency);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Restore from a cached manifest entry. If the on-disk hash matches the\r\n   * manifest hash, dep-graph metadata is restored from the manifest without\r\n   * re-parsing. Otherwise the file is reprocessed.\r\n   */\r\n  protected async initFromManifest(fileManifest: Partial<FileManifest>): Promise<void> {\r\n    this.type = fileManifest.type;\r\n\r\n    this.state = \"loading\";\r\n\r\n    try {\r\n      this.source = await getFileAsync(this.absolutePath);\r\n    } catch {\r\n      this.state = \"deleted\";\r\n      return;\r\n    }\r\n\r\n    const currentHash = crypto.createHash(\"sha256\").update(this.source).digest(\"hex\");\r\n\r\n    if (currentHash !== fileManifest.hash) {\r\n      await this.process({ force: true });\r\n      return;\r\n    }\r\n\r\n    this.hash = fileManifest.hash!;\r\n    this.lastModified = fileManifest.lastModified!;\r\n    this.dependencies = new Set(fileManifest.dependencies || []);\r\n    this.typeOnlyDependencies = new Set(fileManifest.typeOnlyDependencies || []);\r\n    this.dependents = new Set(fileManifest.dependents || []);\r\n\r\n    this.state = \"ready\";\r\n    events.trigger(DEV_SERVER_EVENTS.FILE_READY, this);\r\n  }\r\n\r\n  protected detectFileType(): void {\r\n    const path = this.relativePath;\r\n\r\n    if (path.includes(\"main.ts\") || path.includes(\"main.tsx\")) {\r\n      this.type = \"main\";\r\n    } else if (path.startsWith(\"src/config/\")) {\r\n      this.type = \"config\";\r\n    } else if (path.endsWith(\"routes.ts\") || path.endsWith(\"routes.tsx\")) {\r\n      this.type = \"route\";\r\n    } else if (path.includes(\"/events/\")) {\r\n      this.type = \"event\";\r\n    } else if (path.includes(\"controller\")) {\r\n      this.type = \"controller\";\r\n    } else if (path.includes(\"service\")) {\r\n      this.type = \"service\";\r\n    } else if (path.endsWith(\".model.ts\")) {\r\n      this.type = \"model\";\r\n    } else {\r\n      this.type = \"other\";\r\n    }\r\n  }\r\n\r\n  public toManifest(): FileManifest {\r\n    return {\r\n      absolutePath: this.absolutePath,\r\n      relativePath: this.relativePath,\r\n      lastModified: this.lastModified,\r\n      hash: this.hash,\r\n      dependencies: Array.from(this.dependencies),\r\n      typeOnlyDependencies: Array.from(this.typeOnlyDependencies),\r\n      dependents: Array.from(this.dependents),\r\n      type: this.type!,\r\n    };\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/dev-server/file-operations.d.mts

@@ -0,0 +1,43 @@
+import { DependencyGraph } from "./dependency-graph.mjs";
+import { ManifestManager } from "./manifest-manager.mjs";
+import { SpecialFilesCollector } from "./special-files-collector.mjs";
+import { FileManager } from "./file-manager.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/file-operations.d.ts
+/**
+ * FileOperations — add/update/delete lifecycle for a single file.
+ *
+ * Coordinates the dependency graph, manifest, and special-files collector
+ * so the orchestrator and event handler can stay declarative.
+ */
+declare class FileOperations {
+  private readonly files;
+  private readonly dependencyGraph;
+  private readonly manifest;
+  private readonly specialFilesCollector;
+  constructor(files: Map<string, FileManager>, dependencyGraph: DependencyGraph, manifest: ManifestManager, specialFilesCollector: SpecialFilesCollector);
+  /**
+   * Register and process a new file. Recursively pulls in any
+   * not-yet-tracked dependencies so the dep graph is complete.
+   */
+  addFile(relativePath: string): Promise<FileManager>;
+  /**
+   * Reprocess a file after a change. Re-syncs the dep graph and special-files
+   * collector when its imports or path classification shift.
+   */
+  updateFile(relativePath: string): Promise<boolean>;
+  /**
+   * Remove a file. Notifies dependents so they surface broken-import errors.
+   */
+  deleteFile(relativePath: string): Promise<void>;
+  /**
+   * Re-process any file whose imports might now resolve to a freshly added
+   * file. Covers "import A from './b'" where b.ts only just got created.
+   */
+  private reloadFilesWaitingForDependency;
+  updateFileDependents(): void;
+  syncFilesToManifest(): void;
+}
+//#endregion
+export { FileOperations };
+//# sourceMappingURL=file-operations.d.mts.map

package/esm/dev-server/file-operations.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-operations.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/file-operations.ts"],"mappings":";;;;;;;;AAgBA;;;;cAAa,cAAA;EAAA,iBAEQ,KAAA;EAAA,iBACA,eAAA;EAAA,iBACA,QAAA;EAAA,iBACA,qBAAA;cAHA,KAAA,EAAO,GAAA,SAAY,WAAA,GACnB,eAAA,EAAiB,eAAA,EACjB,QAAA,EAAU,eAAA,EACV,qBAAA,EAAuB,qBAAA;EA2CK;;;;EApClC,OAAA,CAAQ,YAAA,WAAuB,OAAA,CAAQ,WAAA;EATjC;;;;EA6CN,UAAA,CAAW,YAAA,WAAuB,OAAA;EA9CT;;;EA6EzB,UAAA,CAAW,YAAA,WAAuB,OAAA;EA3ElB;;;;EAAA,QAoGf,+BAAA;EAoCP,oBAAA,CAAA;EAMA,mBAAA,CAAA;AAAA"}

package/esm/dev-server/file-operations.mjs

@@ -0,0 +1,113 @@
+import { Path } from "./path.mjs";
+import { parseImports } from "./parse-imports.mjs";
+import { DEV_SERVER_EVENTS } from "./events.mjs";
+import { FileManager } from "./file-manager.mjs";
+import { areSetsEqual } from "./utils.mjs";
+import events from "@mongez/events";
+
+//#region ../../@warlock.js/core/src/dev-server/file-operations.ts
+/**
+* FileOperations — add/update/delete lifecycle for a single file.
+*
+* Coordinates the dependency graph, manifest, and special-files collector
+* so the orchestrator and event handler can stay declarative.
+*/
+var FileOperations = class {
+	constructor(files, dependencyGraph, manifest, specialFilesCollector) {
+		this.files = files;
+		this.dependencyGraph = dependencyGraph;
+		this.manifest = manifest;
+		this.specialFilesCollector = specialFilesCollector;
+	}
+	/**
+	* Register and process a new file. Recursively pulls in any
+	* not-yet-tracked dependencies so the dep graph is complete.
+	*/
+	async addFile(relativePath) {
+		const existing = this.files.get(relativePath);
+		if (existing) return existing;
+		const fileManager = new FileManager(Path.toAbsolute(relativePath), this.files, this);
+		this.files.set(relativePath, fileManager);
+		await fileManager.process();
+		for (const depPath of fileManager.dependencies) if (!this.files.has(depPath)) try {
+			await this.addFile(depPath);
+		} catch {}
+		for (const dependency of fileManager.dependencies) this.dependencyGraph.addDependency(relativePath, dependency);
+		this.specialFilesCollector.addFile(fileManager);
+		await this.reloadFilesWaitingForDependency(relativePath);
+		return fileManager;
+	}
+	/**
+	* Reprocess a file after a change. Re-syncs the dep graph and special-files
+	* collector when its imports or path classification shift.
+	*/
+	async updateFile(relativePath) {
+		const fileManager = this.files.get(relativePath);
+		if (!fileManager) {
+			await this.addFile(relativePath);
+			return true;
+		}
+		const oldDependencies = new Set(fileManager.dependencies);
+		try {
+			if (!await fileManager.process()) return false;
+			if (!areSetsEqual(oldDependencies, fileManager.dependencies)) this.dependencyGraph.updateFile(relativePath, fileManager.dependencies, fileManager.typeOnlyDependencies);
+			this.specialFilesCollector.updateFile(fileManager);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Remove a file. Notifies dependents so they surface broken-import errors.
+	*/
+	async deleteFile(relativePath) {
+		if (!this.files.get(relativePath)) return;
+		const dependents = this.dependencyGraph.getDependents(relativePath);
+		this.dependencyGraph.removeFile(relativePath);
+		this.specialFilesCollector.removeFile(relativePath);
+		this.manifest.removeFile(relativePath);
+		for (const dependentPath of dependents) {
+			const dependentFile = this.files.get(dependentPath);
+			if (dependentFile) events.trigger(DEV_SERVER_EVENTS.FILE_READY, dependentFile);
+		}
+		setTimeout(() => this.files.delete(relativePath), 300);
+	}
+	/**
+	* Re-process any file whose imports might now resolve to a freshly added
+	* file. Covers "import A from './b'" where b.ts only just got created.
+	*/
+	async reloadFilesWaitingForDependency(newFilePath) {
+		const dependents = [];
+		for (const [existingPath, existingFile] of this.files) {
+			if (existingPath === newFilePath) continue;
+			if (existingFile.state !== "ready") continue;
+			try {
+				const importMap = await parseImports(existingFile.source, existingFile.absolutePath);
+				for (const [, resolved] of importMap) if (resolved && Path.toRelative(resolved.absolutePath) === newFilePath) {
+					dependents.push(existingPath);
+					break;
+				}
+			} catch {
+				continue;
+			}
+		}
+		for (const dependentPath of dependents) {
+			const dependentFile = this.files.get(dependentPath);
+			if (!dependentFile) continue;
+			try {
+				await dependentFile.process({ force: true });
+				this.dependencyGraph.updateFile(dependentPath, dependentFile.dependencies, dependentFile.typeOnlyDependencies);
+			} catch {}
+		}
+	}
+	updateFileDependents() {
+		for (const [relativePath, fileManager] of this.files) fileManager.dependents = this.dependencyGraph.getDependents(relativePath);
+	}
+	syncFilesToManifest() {
+		for (const [relativePath, fileManager] of this.files) this.manifest.setFile(relativePath, fileManager.toManifest());
+	}
+};
+
+//#endregion
+export { FileOperations };
+//# sourceMappingURL=file-operations.mjs.map

package/esm/dev-server/file-operations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-operations.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/file-operations.ts"],"sourcesContent":["import events from \"@mongez/events\";\r\nimport type { DependencyGraph } from \"./dependency-graph\";\r\nimport { DEV_SERVER_EVENTS } from \"./events\";\r\nimport { FileManager } from \"./file-manager\";\r\nimport type { ManifestManager } from \"./manifest-manager\";\r\nimport { parseImports } from \"./parse-imports\";\r\nimport { Path } from \"./path\";\r\nimport type { SpecialFilesCollector } from \"./special-files-collector\";\r\nimport { areSetsEqual } from \"./utils\";\r\n\r\n/**\r\n * FileOperations — add/update/delete lifecycle for a single file.\r\n *\r\n * Coordinates the dependency graph, manifest, and special-files collector\r\n * so the orchestrator and event handler can stay declarative.\r\n */\r\nexport class FileOperations {\r\n  public constructor(\r\n    private readonly files: Map<string, FileManager>,\r\n    private readonly dependencyGraph: DependencyGraph,\r\n    private readonly manifest: ManifestManager,\r\n    private readonly specialFilesCollector: SpecialFilesCollector,\r\n  ) {}\r\n\r\n  /**\r\n   * Register and process a new file. Recursively pulls in any\r\n   * not-yet-tracked dependencies so the dep graph is complete.\r\n   */\r\n  public async addFile(relativePath: string): Promise<FileManager> {\r\n    const existing = this.files.get(relativePath);\r\n    if (existing) return existing;\r\n\r\n    const fileManager = new FileManager(Path.toAbsolute(relativePath), this.files, this);\r\n\r\n    // Register before processing so recursive deps see us.\r\n    this.files.set(relativePath, fileManager);\r\n\r\n    await fileManager.process();\r\n\r\n    for (const depPath of fileManager.dependencies) {\r\n      if (!this.files.has(depPath)) {\r\n        try {\r\n          await this.addFile(depPath);\r\n        } catch {\r\n          // External or missing — let the importer surface it at load time.\r\n        }\r\n      }\r\n    }\r\n\r\n    for (const dependency of fileManager.dependencies) {\r\n      this.dependencyGraph.addDependency(relativePath, dependency);\r\n    }\r\n\r\n    this.specialFilesCollector.addFile(fileManager);\r\n\r\n    await this.reloadFilesWaitingForDependency(relativePath);\r\n\r\n    return fileManager;\r\n  }\r\n\r\n  /**\r\n   * Reprocess a file after a change. Re-syncs the dep graph and special-files\r\n   * collector when its imports or path classification shift.\r\n   */\r\n  public async updateFile(relativePath: string): Promise<boolean> {\r\n    const fileManager = this.files.get(relativePath);\r\n    if (!fileManager) {\r\n      await this.addFile(relativePath);\r\n      return true;\r\n    }\r\n\r\n    const oldDependencies = new Set(fileManager.dependencies);\r\n\r\n    try {\r\n      const hasChanged = await fileManager.process();\r\n      if (!hasChanged) return false;\r\n\r\n      if (!areSetsEqual(oldDependencies, fileManager.dependencies)) {\r\n        this.dependencyGraph.updateFile(\r\n          relativePath,\r\n          fileManager.dependencies,\r\n          fileManager.typeOnlyDependencies,\r\n        );\r\n      }\r\n\r\n      this.specialFilesCollector.updateFile(fileManager);\r\n      return true;\r\n    } catch {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove a file. Notifies dependents so they surface broken-import errors.\r\n   */\r\n  public async deleteFile(relativePath: string): Promise<void> {\r\n    const fileManager = this.files.get(relativePath);\r\n    if (!fileManager) return;\r\n\r\n    const dependents = this.dependencyGraph.getDependents(relativePath);\r\n\r\n    this.dependencyGraph.removeFile(relativePath);\r\n    this.specialFilesCollector.removeFile(relativePath);\r\n    this.manifest.removeFile(relativePath);\r\n\r\n    for (const dependentPath of dependents) {\r\n      const dependentFile = this.files.get(dependentPath);\r\n      if (dependentFile) {\r\n        events.trigger(DEV_SERVER_EVENTS.FILE_READY, dependentFile);\r\n      }\r\n    }\r\n\r\n    // Slight delay so in-flight reads still find the FileManager.\r\n    setTimeout(() => this.files.delete(relativePath), 300);\r\n  }\r\n\r\n  /**\r\n   * Re-process any file whose imports might now resolve to a freshly added\r\n   * file. Covers \"import A from './b'\" where b.ts only just got created.\r\n   */\r\n  private async reloadFilesWaitingForDependency(newFilePath: string): Promise<void> {\r\n    const dependents: string[] = [];\r\n\r\n    for (const [existingPath, existingFile] of this.files) {\r\n      if (existingPath === newFilePath) continue;\r\n      if (existingFile.state !== \"ready\") continue;\r\n\r\n      try {\r\n        const importMap = await parseImports(existingFile.source, existingFile.absolutePath);\r\n        for (const [, resolved] of importMap) {\r\n          if (resolved && Path.toRelative(resolved.absolutePath) === newFilePath) {\r\n            dependents.push(existingPath);\r\n            break;\r\n          }\r\n        }\r\n      } catch {\r\n        continue;\r\n      }\r\n    }\r\n\r\n    for (const dependentPath of dependents) {\r\n      const dependentFile = this.files.get(dependentPath);\r\n      if (!dependentFile) continue;\r\n      try {\r\n        await dependentFile.process({ force: true });\r\n        this.dependencyGraph.updateFile(\r\n          dependentPath,\r\n          dependentFile.dependencies,\r\n          dependentFile.typeOnlyDependencies,\r\n        );\r\n      } catch {\r\n        // File still has issues — ignore.\r\n      }\r\n    }\r\n  }\r\n\r\n  public updateFileDependents(): void {\r\n    for (const [relativePath, fileManager] of this.files) {\r\n      fileManager.dependents = this.dependencyGraph.getDependents(relativePath);\r\n    }\r\n  }\r\n\r\n  public syncFilesToManifest(): void {\r\n    for (const [relativePath, fileManager] of this.files) {\r\n      this.manifest.setFile(relativePath, fileManager.toManifest());\r\n    }\r\n  }\r\n}\r\n"],"mappings":"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"}

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

@@ -0,0 +1,89 @@
+import { DependencyGraph } from "./dependency-graph.mjs";
+import { SpecialFilesCollector } from "./special-files-collector.mjs";
+import { FileOperations } from "./file-operations.mjs";
+import { FileManager } from "./file-manager.mjs";
+import { FilesWatcher } from "./files-watcher.mjs";
+import { FileHealthCheckerContract } from "./health-checker/file-health-checker.contract.mjs";
+import { FilesHealthcareManager } from "./health-checker/files-healthcare.manager.mjs";
+import { ModuleLoader } from "./module-loader.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/files-orchestrator.d.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.
+ */
+declare function onCleanup(callback: () => any): void;
+/**
+ * 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).
+ */
+declare class FilesOrchestrator {
+  readonly filesWatcher: FilesWatcher;
+  readonly files: Map<string, FileManager>;
+  private readonly manifest;
+  private readonly dependencyGraph;
+  private readonly healthCheckerManager;
+  readonly specialFilesCollector: SpecialFilesCollector;
+  readonly moduleLoader: ModuleLoader;
+  readonly fileOperations: FileOperations;
+  private readonly eventHandler;
+  /** Main-thread end of the MessageChannel to the loader hook worker. */
+  private loaderPort;
+  /** Resolve callbacks for pending `flushVersionBumps()` calls. */
+  private readonly pendingFlushes;
+  isInitialized: boolean;
+  constructor();
+  add(relativePath: string): Promise<FileManager>;
+  load<T>(relativePath: string, type?: string): Promise<T | undefined>;
+  getDependencyGraph(): DependencyGraph;
+  getInvalidationChain(file: string): string[];
+  getFiles(): Map<string, FileManager>;
+  getHealthCheckerManager(): FilesHealthcareManager;
+  /**
+   * Initialise managers and register the ESM loader hook. Must be called
+   * before any user `src/` module is dynamically imported.
+   */
+  init(): Promise<void>;
+  /**
+   * 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: string): void;
+  /**
+   * 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(): Promise<void>;
+  /**
+   * Discover files on disk, reconcile against the manifest, build the dep
+   * graph, and persist the new manifest. Idempotent.
+   */
+  initializeAll(): Promise<void>;
+  checkHealth(files: {
+    added: string[];
+    changed: string[];
+    deleted: string[];
+  }): Promise<void>;
+  startCheckingHealth(healthCheckers?: FileHealthCheckerContract[]): Promise<void>;
+  /**
+   * Glob the src directory, returning relative paths.
+   */
+  getAllFilesFromFilesystem(): Promise<string[]>;
+  /**
+   * Process every file from scratch — used when no manifest exists.
+   */
+  private processFiles;
+  private reconcileFiles;
+  watchFiles(): Promise<void>;
+}
+declare const filesOrchestrator: FilesOrchestrator;
+//#endregion
+export { FilesOrchestrator, filesOrchestrator, onCleanup };
+//# sourceMappingURL=files-orchestrator.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"files-orchestrator.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/files-orchestrator.ts"],"mappings":";;;;;;;;;;;;AA8BA;;;iBAAgB,SAAA,CAAU,QAAmB;AAAA;AAuB7C;;;;;;AAvB6C,cAuBhC,iBAAA;EAAA,SACK,YAAA,EAAY,YAAA;EAAA,SACZ,KAAA,EAAK,GAAA,SAAA,WAAA;EAAA,iBACJ,QAAA;EAAA,iBACA,eAAA;EAAA,iBACA,oBAAA;EAAA,SACD,qBAAA,EAAqB,qBAAA;EAAA,SACrB,YAAA,EAAY,YAAA;EAAA,SACZ,cAAA,EAAgB,cAAA;EAAA,iBACf,YAAA;EA+CiB;EAAA,QA5C1B,UAAA;EA4FoB;EAAA,iBAzFX,cAAA;EAEV,aAAA;;EAkBM,GAAA,CAAI,YAAA,WAAuB,OAAA,CAAQ,WAAA;EAInC,IAAA,GAAA,CAAQ,YAAA,UAAsB,IAAA,YAAc,OAAA,CAAA,CAAA;EAKlD,kBAAA,CAAA,GAAsB,eAAA;EAItB,oBAAA,CAAqB,IAAA;EAIrB,QAAA,CAAA,GAAY,GAAA,SAAY,WAAA;EAIxB,uBAAA,CAAA,GAA2B,sBAAA;EAvDN;;;;EA+Df,IAAA,CAAA,GAAI,OAAA;EA5DA;;;;EAyFV,WAAA,CAAY,YAAA;EAtFS;;;;;;;EAiGrB,iBAAA,CAAA,GAAqB,OAAA;EArEf;;;;EAkFA,aAAA,CAAA,GAAa,OAAA;EAkBb,WAAA,CAAY,KAAA;IAAS,KAAA;IAAiB,OAAA;IAAmB,OAAA;EAAA,IAAmB,OAAA;EAc5E,mBAAA,CAAoB,cAAA,GAAiB,yBAAA,KAA8B,OAAA;EAzGnD;;;EAmHhB,yBAAA,CAAA,GAA6B,OAAA;EA3GvB;;;EAAA,QAmHL,YAAA;EAAA,QAcA,cAAA;EAgCD,UAAA,CAAA,GAAU,OAAA;AAAA;AAAA,cAuBZ,iBAAA,EAAiB,iBAA0B"}