@warlock.js/core 4.0.174 → 4.1.2

package/esm/dev-server/parse-imports.mjs

@@ -0,0 +1,348 @@
+import { Path } from "./path.mjs";
+import { tsconfigManager } from "./tsconfig-manager.mjs";
+import { directoryExistsAsync, fileExistsAsync } from "@warlock.js/fs";
+import path from "node:path";
+import { parse } from "es-module-lexer";
+
+//#region ../../@warlock.js/core/src/dev-server/parse-imports.ts
+/**
+* Detect if a file contains only type definitions (no runtime code)
+*
+* A file is considered type-only if ALL its exports are:
+* - interface declarations
+* - type alias declarations
+* - export type { ... } statements
+* - export type { ... } from "..." statements
+*
+* Files with any of these are NOT type-only:
+* - export const/let/var
+* - export function
+* - export class
+* - export default (non-type)
+* - export { ... } (without type keyword)
+* - export * from (without type keyword)
+*
+* @param source - The source code to analyze
+* @returns true if the file exports only types
+*/
+function isTypeOnlyFile(source) {
+	const withoutStrings = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/'(?:[^'\\]|\\.)*'/g, "''").replace(/"(?:[^"\\]|\\.)*"/g, "\"\"").replace(/`(?:[^`\\]|\\.)*`/g, "``");
+	const typeOnlyPatterns = [
+		/export\s+type\s+\{[^}]*\}/g,
+		/export\s+type\s+\{[^}]*\}\s+from\s+['"]/g,
+		/export\s+interface\s+\w+/g,
+		/export\s+type\s+\w+\s*=/g
+	];
+	let remaining = withoutStrings;
+	for (const pattern of typeOnlyPatterns) remaining = remaining.replace(pattern, "");
+	for (const pattern of [
+		/export\s+(?:const|let|var)\s+\w+/g,
+		/export\s+function\s+\w+/g,
+		/export\s+async\s+function\s+\w+/g,
+		/export\s+class\s+\w+/g,
+		/export\s+enum\s+\w+/g,
+		/export\s+default\s+(?!type\s)/g,
+		/export\s+\{[^}]*\}(?!\s+from)/g,
+		/export\s+\{[^}]*\}\s+from\s+['"][^'"]+['"]/g,
+		/export\s+\*\s+from\s+['"][^'"]+['"]/g,
+		/export\s+\*\s+as\s+\w+/g
+	]) if (pattern.test(remaining)) {
+		pattern.lastIndex = 0;
+		if (pattern.source.includes("export\\s+\\{")) {
+			const matches = remaining.match(/export\s+\{([^}]*)\}(?:\s+from\s+['"][^'"]+['"])?/g);
+			if (matches) for (const match of matches) {
+				if (/^export\s+type\s+/.test(match)) continue;
+				const specifiersMatch = match.match(/export\s+\{([^}]*)\}/);
+				if (specifiersMatch) {
+					if (specifiersMatch[1].split(",").map((s) => s.trim()).filter(Boolean).some((item) => !item.startsWith("type "))) return false;
+				}
+			}
+			continue;
+		}
+		return false;
+	}
+	return typeOnlyPatterns.some((pattern) => {
+		pattern.lastIndex = 0;
+		return pattern.test(withoutStrings);
+	});
+}
+/**
+* Check if an import statement is a pure `import type` (the keyword sits
+* immediately after `import`, covering `import type { X }`, `import type Foo`,
+* and `import type * as Ns`).
+*/
+function isTypeOnlyImport(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("import type ") || !!trimmed.match(/^import\s+type\s+[\{\*]/);
+}
+/**
+* Decide whether an `import ... from "m"` statement contributes any runtime
+* binding. Returns false for pure `import type` and for destructured imports
+* where every specifier is prefixed with the `type` keyword.
+*/
+function hasRuntimeImports(line) {
+	const trimmed = line.trim();
+	if (isTypeOnlyImport(trimmed)) return false;
+	const specifiersMatch = trimmed.match(/import\s+(?:type\s+)?\{([^}]+)\}/);
+	if (!specifiersMatch) return true;
+	return !specifiersMatch[1].split(",").map((s) => s.trim()).filter(Boolean).every((item) => /^type\s+\w+/.test(item));
+}
+/**
+* Decide whether an `export ... from "m"` statement re-exports only types.
+* Covers `export type { X } from`, `export type * from`, and
+* `export { type X, type Y } from`.
+*/
+function isExportTypeOnlyStatement(line) {
+	const trimmed = line.trim();
+	if (/^export\s+type\s+/.test(trimmed)) return true;
+	const specifiersMatch = trimmed.match(/export\s+\{([^}]+)\}/);
+	if (!specifiersMatch) return false;
+	return specifiersMatch[1].split(",").map((s) => s.trim()).filter(Boolean).every((item) => /^type\s+\w+/.test(item));
+}
+/**
+* Extract import paths using regex (more reliable for TypeScript).
+* Each entry carries an `isTypeOnly` flag: true when every occurrence of the
+* path in the source is a type-only statement (no runtime binding).
+* A single runtime occurrence makes the path runtime.
+*/
+function extractImportPathsWithRegex(source) {
+	const imports = [];
+	const seenPaths = /* @__PURE__ */ new Map();
+	/**
+	* Record an import path with its type-only flag.
+	* If the same path appears in multiple statements, the edge is type-only
+	* iff every occurrence is type-only — a single runtime statement makes it runtime.
+	*/
+	const record = (importPath, originalLine, isTypeOnly) => {
+		if (!importPath) return;
+		const existingIndex = seenPaths.get(importPath);
+		if (existingIndex === void 0) {
+			seenPaths.set(importPath, imports.length);
+			imports.push({
+				path: importPath,
+				originalLine,
+				isTypeOnly
+			});
+			return;
+		}
+		if (!isTypeOnly) imports[existingIndex].isTypeOnly = false;
+	};
+	const importRegex = /import\s+(?:type\s+)?(\{[\s\S]*?\}|\*\s+as\s+\w+|\w+(?:\s*,\s*\{[\s\S]*?\})?)\s+from\s+['"]([^'"]+)['"]/g;
+	let match;
+	while ((match = importRegex.exec(source)) !== null) {
+		const fullMatch = match[0];
+		const importPath = match[2];
+		record(importPath, fullMatch, !hasRuntimeImports(fullMatch));
+	}
+	const sideEffectRegex = /import\s+['"]([^'"]+)['"]/g;
+	while ((match = sideEffectRegex.exec(source)) !== null) record(match[1], match[0], false);
+	const dynamicImportPattern = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+	while ((match = dynamicImportPattern.exec(source)) !== null) record(match[1], match[0], false);
+	const exportFromPattern = /export\s+(?:\{[^}]*\}|\*|\w+)\s+from\s+['"]([^'"]+)['"]/g;
+	while ((match = exportFromPattern.exec(source)) !== null) {
+		const fullMatch = match[0];
+		record(match[1], fullMatch, isExportTypeOnlyStatement(fullMatch));
+	}
+	return imports;
+}
+/**
+* Parse import/export statements in a TS/JS source file and return the
+* resolved dependency edges keyed by the original import path. Includes
+* type-only edges (flagged) so downstream consumers can distinguish runtime
+* cycles from type-only ones.
+*
+* @example
+* const importMap = await parseImports(source, "/abs/path/to/file.ts");
+* for (const [importPath, { absolutePath, isTypeOnly }] of importMap) {
+*   // ...
+* }
+*/
+async function parseImports(source, filePath) {
+	try {
+		if (filePath.endsWith(".d.ts")) return /* @__PURE__ */ new Map();
+		try {
+			const [imports] = await parse(source);
+			if (imports && imports.length > 0) return await resolveImports(imports, source, filePath);
+		} catch (lexerError) {}
+		const regexImports = extractImportPathsWithRegex(source);
+		const resolvedImports = /* @__PURE__ */ new Map();
+		for (const { path: importPath, isTypeOnly } of regexImports) {
+			if (isNodeBuiltin(importPath)) continue;
+			if (!importPath.startsWith(".") && !tsconfigManager.isAlias(importPath)) continue;
+			let resolvedPath = null;
+			if (tsconfigManager.isAlias(importPath)) resolvedPath = await resolveAliasImport(importPath);
+			else if (importPath.startsWith(".")) resolvedPath = await resolveRelativeImport(importPath, filePath);
+			if (resolvedPath) mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);
+		}
+		return resolvedImports;
+	} catch (error) {
+		console.error(`Error parsing imports for ${filePath}:`, error);
+		return /* @__PURE__ */ new Map();
+	}
+}
+/**
+* Merge a resolved import into the output map, preserving the type-only rule:
+* a path is type-only iff every statement that references it is type-only.
+*/
+function mergeResolvedImport(target, importPath, absolutePath, isTypeOnly) {
+	const existing = target.get(importPath);
+	if (!existing) {
+		target.set(importPath, {
+			absolutePath,
+			isTypeOnly
+		});
+		return;
+	}
+	if (!isTypeOnly) existing.isTypeOnly = false;
+}
+/**
+* Resolve imports from `es-module-lexer` output. For each specifier, slice the
+* raw statement (`ss..se`) and re-run the type-only heuristic so we can flag
+* the edge correctly — the lexer itself does not distinguish `import type`.
+*/
+async function resolveImports(imports, source, filePath) {
+	const resolvedImports = /* @__PURE__ */ new Map();
+	for (const imp of imports) {
+		const importPath = imp.n;
+		if (!importPath) continue;
+		if (isNodeBuiltin(importPath)) continue;
+		if (!importPath.startsWith(".") && !tsconfigManager.isAlias(importPath)) continue;
+		let resolvedPath = null;
+		if (tsconfigManager.isAlias(importPath)) resolvedPath = await resolveAliasImport(importPath);
+		else if (importPath.startsWith(".")) resolvedPath = await resolveRelativeImport(importPath, filePath);
+		if (!resolvedPath) continue;
+		const isTypeOnly = isLexerStatementTypeOnly(imp, source);
+		mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);
+	}
+	return resolvedImports;
+}
+/**
+* Classify a single lexer-reported statement as type-only or runtime.
+* Dynamic imports (`import(...)`) are always runtime. For static
+* imports/export-from we slice the raw source and apply the same heuristic
+* the regex fallback uses.
+*/
+function isLexerStatementTypeOnly(imp, source) {
+	const statementStart = imp.ss;
+	const statementEnd = imp.se;
+	if (typeof statementStart !== "number" || typeof statementEnd !== "number" || statementEnd <= statementStart) return false;
+	const statement = source.slice(statementStart, statementEnd);
+	const trimmed = statement.trim();
+	if (trimmed.startsWith("import(") || /^\bimport\s*\(/.test(trimmed)) return false;
+	if (trimmed.startsWith("export")) return isExportTypeOnlyStatement(statement);
+	return !hasRuntimeImports(statement);
+}
+/**
+* Resolve alias imports to actual file paths with extensions
+* Example: app/users/services/get-users.service -> /absolute/path/to/src/app/users/services/get-users.service.ts
+*/
+async function resolveAliasImport(importPath) {
+	const resolvedBase = tsconfigManager.resolveAliasToAbsolute(importPath);
+	if (!resolvedBase) return null;
+	return await tryResolveWithExtensions(resolvedBase);
+}
+/**
+* Resolve relative imports to actual file paths
+* Example: ./../services/get-user.service -> /absolute/path/to/services/get-user.service.ts
+*/
+async function resolveRelativeImport(importPath, currentFilePath) {
+	const dir = path.dirname(currentFilePath);
+	return await tryResolveWithExtensions(Path.normalize(path.resolve(dir, importPath)));
+}
+/**
+* Try to resolve a file path by checking different extensions
+* TypeScript/JavaScript files can be imported without extensions
+*
+* @TODO: For better performance, we need to check the files in files orchestrator
+* instead of using the file system as we will be fetching all project files anyway.
+*/
+const fileExistsCache = /* @__PURE__ */ new Map();
+/**
+* Clear the file exists cache
+* Should be called when new files are created to ensure fresh lookups
+*/
+function clearFileExistsCache() {
+	fileExistsCache.clear();
+}
+async function cachedFileExists(filePath) {
+	if (fileExistsCache.has(filePath)) return fileExistsCache.get(filePath);
+	const exists = await fileExistsAsync(filePath);
+	fileExistsCache.set(filePath, exists);
+	return exists;
+}
+async function tryResolveWithExtensions(basePath) {
+	const normalizedBase = Path.normalize(basePath);
+	const extensions = [
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".cjs"
+	];
+	const validExtensions = new Set(extensions);
+	const ext = path.extname(normalizedBase);
+	if (ext && validExtensions.has(ext)) {
+		if (await cachedFileExists(normalizedBase)) return normalizedBase;
+		return null;
+	}
+	const pathsToCheck = extensions.map((extension) => normalizedBase + extension);
+	const results = await Promise.all(pathsToCheck.map(async (p) => ({
+		path: p,
+		exists: await cachedFileExists(p)
+	})));
+	for (const result of results) if (result.exists) return result.path;
+	if (await directoryExistsAsync(normalizedBase)) {
+		const indexPaths = extensions.map((extension) => Path.join(normalizedBase, `index${extension}`));
+		const indexResults = await Promise.all(indexPaths.map(async (p) => ({
+			path: p,
+			exists: await cachedFileExists(p)
+		})));
+		for (const result of indexResults) if (result.exists) return result.path;
+	}
+	return null;
+}
+/**
+* Check if import is a Node.js built-in module
+*/
+function isNodeBuiltin(importPath) {
+	const builtins = [
+		"fs",
+		"path",
+		"http",
+		"https",
+		"crypto",
+		"stream",
+		"util",
+		"events",
+		"buffer",
+		"child_process",
+		"os",
+		"url",
+		"querystring",
+		"zlib",
+		"net",
+		"tls",
+		"dns",
+		"dgram",
+		"cluster",
+		"worker_threads",
+		"perf_hooks",
+		"async_hooks",
+		"timers",
+		"readline",
+		"repl",
+		"vm",
+		"assert",
+		"console",
+		"process",
+		"v8"
+	];
+	if (importPath.startsWith("node:")) return true;
+	const moduleName = importPath.split("/")[0];
+	return builtins.includes(moduleName);
+}
+
+//#endregion
+export { clearFileExistsCache, isTypeOnlyFile, parseImports };
+//# sourceMappingURL=parse-imports.mjs.map

package/esm/dev-server/parse-imports.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-imports.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/parse-imports.ts"],"sourcesContent":["import { fileExistsAsync, directoryExistsAsync } from \"@warlock.js/fs\";\r\nimport { ImportSpecifier, parse } from \"es-module-lexer\";\r\nimport path from \"node:path\";\r\nimport { Path } from \"./path\";\r\nimport { tsconfigManager } from \"./tsconfig-manager\";\r\n\r\n/**\r\n * Detect if a file contains only type definitions (no runtime code)\r\n *\r\n * A file is considered type-only if ALL its exports are:\r\n * - interface declarations\r\n * - type alias declarations\r\n * - export type { ... } statements\r\n * - export type { ... } from \"...\" statements\r\n *\r\n * Files with any of these are NOT type-only:\r\n * - export const/let/var\r\n * - export function\r\n * - export class\r\n * - export default (non-type)\r\n * - export { ... } (without type keyword)\r\n * - export * from (without type keyword)\r\n *\r\n * @param source - The source code to analyze\r\n * @returns true if the file exports only types\r\n */\r\nexport function isTypeOnlyFile(source: string): boolean {\r\n  // Remove comments to avoid false positives\r\n  const withoutComments = source\r\n    .replace(/\\/\\*[\\s\\S]*?\\*\\//g, \"\") // block comments\r\n    .replace(/\\/\\/.*$/gm, \"\"); // line comments\r\n\r\n  // Remove string literals to avoid false positives\r\n  const withoutStrings = withoutComments\r\n    .replace(/'(?:[^'\\\\]|\\\\.)*'/g, \"''\")\r\n    .replace(/\"(?:[^\"\\\\]|\\\\.)*\"/g, '\"\"')\r\n    .replace(/`(?:[^`\\\\]|\\\\.)*`/g, \"``\");\r\n\r\n  // Patterns for type-only exports (these are safe)\r\n  const typeOnlyPatterns = [\r\n    /export\\s+type\\s+\\{[^}]*\\}/g, // export type { Foo, Bar }\r\n    /export\\s+type\\s+\\{[^}]*\\}\\s+from\\s+['\"]/g, // export type { Foo } from \"...\"\r\n    /export\\s+interface\\s+\\w+/g, // export interface Foo\r\n    /export\\s+type\\s+\\w+\\s*=/g, // export type Foo =\r\n  ];\r\n\r\n  // Remove all type-only exports from consideration\r\n  let remaining = withoutStrings;\r\n  for (const pattern of typeOnlyPatterns) {\r\n    remaining = remaining.replace(pattern, \"\");\r\n  }\r\n\r\n  // Patterns for runtime exports (these make the file NOT type-only)\r\n  const runtimeExportPatterns = [\r\n    /export\\s+(?:const|let|var)\\s+\\w+/g, // export const/let/var foo\r\n    /export\\s+function\\s+\\w+/g, // export function foo\r\n    /export\\s+async\\s+function\\s+\\w+/g, // export async function foo\r\n    /export\\s+class\\s+\\w+/g, // export class Foo\r\n    /export\\s+enum\\s+\\w+/g, // export enum Foo (enums have runtime value)\r\n    /export\\s+default\\s+(?!type\\s)/g, // export default (not type)\r\n    /export\\s+\\{[^}]*\\}(?!\\s+from)/g, // export { foo } (local re-export without type)\r\n    /export\\s+\\{[^}]*\\}\\s+from\\s+['\"][^'\"]+['\"]/g, // export { foo } from (without type)\r\n    /export\\s+\\*\\s+from\\s+['\"][^'\"]+['\"]/g, // export * from (re-exports everything)\r\n    /export\\s+\\*\\s+as\\s+\\w+/g, // export * as namespace\r\n  ];\r\n\r\n  for (const pattern of runtimeExportPatterns) {\r\n    if (pattern.test(remaining)) {\r\n      // Reset regex lastIndex for subsequent tests\r\n      pattern.lastIndex = 0;\r\n\r\n      // Special case: check if export { } contains only type exports\r\n      if (pattern.source.includes(\"export\\\\s+\\\\{\")) {\r\n        const matches = remaining.match(/export\\s+\\{([^}]*)\\}(?:\\s+from\\s+['\"][^'\"]+['\"])?/g);\r\n        if (matches) {\r\n          for (const match of matches) {\r\n            // Skip if it's already a type export\r\n            if (/^export\\s+type\\s+/.test(match)) continue;\r\n\r\n            // Extract the specifiers\r\n            const specifiersMatch = match.match(/export\\s+\\{([^}]*)\\}/);\r\n            if (specifiersMatch) {\r\n              const specifiers = specifiersMatch[1];\r\n              const items = specifiers\r\n                .split(\",\")\r\n                .map((s) => s.trim())\r\n                .filter(Boolean);\r\n\r\n              // If any specifier is NOT prefixed with \"type \", this is a runtime export\r\n              const hasRuntimeSpecifier = items.some((item) => !item.startsWith(\"type \"));\r\n              if (hasRuntimeSpecifier) {\r\n                return false;\r\n              }\r\n            }\r\n          }\r\n        }\r\n        continue;\r\n      }\r\n\r\n      return false;\r\n    }\r\n  }\r\n\r\n  // If we get here, no runtime exports were found\r\n  // But we should also verify the file has at least some type exports\r\n  // (an empty file or file with only imports is not really \"type-only\")\r\n  const hasTypeExports = typeOnlyPatterns.some((pattern) => {\r\n    pattern.lastIndex = 0;\r\n    return pattern.test(withoutStrings);\r\n  });\r\n\r\n  return hasTypeExports;\r\n}\r\n\r\n/**\r\n * Check if an import statement is a pure `import type` (the keyword sits\r\n * immediately after `import`, covering `import type { X }`, `import type Foo`,\r\n * and `import type * as Ns`).\r\n */\r\nfunction isTypeOnlyImport(line: string): boolean {\r\n  const trimmed = line.trim();\r\n\r\n  return trimmed.startsWith(\"import type \") || !!trimmed.match(/^import\\s+type\\s+[\\{\\*]/);\r\n}\r\n\r\n/**\r\n * Decide whether an `import ... from \"m\"` statement contributes any runtime\r\n * binding. Returns false for pure `import type` and for destructured imports\r\n * where every specifier is prefixed with the `type` keyword.\r\n */\r\nfunction hasRuntimeImports(line: string): boolean {\r\n  const trimmed = line.trim();\r\n\r\n  if (isTypeOnlyImport(trimmed)) {\r\n    return false;\r\n  }\r\n\r\n  const specifiersMatch = trimmed.match(/import\\s+(?:type\\s+)?\\{([^}]+)\\}/);\r\n\r\n  if (!specifiersMatch) {\r\n    return true;\r\n  }\r\n\r\n  const items = specifiersMatch[1].split(\",\").map((s) => s.trim()).filter(Boolean);\r\n\r\n  return !items.every((item) => /^type\\s+\\w+/.test(item));\r\n}\r\n\r\n/**\r\n * Decide whether an `export ... from \"m\"` statement re-exports only types.\r\n * Covers `export type { X } from`, `export type * from`, and\r\n * `export { type X, type Y } from`.\r\n */\r\nfunction isExportTypeOnlyStatement(line: string): boolean {\r\n  const trimmed = line.trim();\r\n\r\n  if (/^export\\s+type\\s+/.test(trimmed)) {\r\n    return true;\r\n  }\r\n\r\n  const specifiersMatch = trimmed.match(/export\\s+\\{([^}]+)\\}/);\r\n\r\n  if (!specifiersMatch) {\r\n    return false;\r\n  }\r\n\r\n  const items = specifiersMatch[1].split(\",\").map((s) => s.trim()).filter(Boolean);\r\n\r\n  return items.every((item) => /^type\\s+\\w+/.test(item));\r\n}\r\n\r\n/**\r\n * Extract import paths using regex (more reliable for TypeScript).\r\n * Each entry carries an `isTypeOnly` flag: true when every occurrence of the\r\n * path in the source is a type-only statement (no runtime binding).\r\n * A single runtime occurrence makes the path runtime.\r\n */\r\nfunction extractImportPathsWithRegex(\r\n  source: string,\r\n): Array<{ path: string; originalLine: string; isTypeOnly: boolean }> {\r\n  const imports: Array<{ path: string; originalLine: string; isTypeOnly: boolean }> = [];\r\n  const seenPaths = new Map<string, number>();\r\n\r\n  /**\r\n   * Record an import path with its type-only flag.\r\n   * If the same path appears in multiple statements, the edge is type-only\r\n   * iff every occurrence is type-only — a single runtime statement makes it runtime.\r\n   */\r\n  const record = (importPath: string, originalLine: string, isTypeOnly: boolean): void => {\r\n    if (!importPath) {\r\n      return;\r\n    }\r\n\r\n    const existingIndex = seenPaths.get(importPath);\r\n\r\n    if (existingIndex === undefined) {\r\n      seenPaths.set(importPath, imports.length);\r\n      imports.push({ path: importPath, originalLine, isTypeOnly });\r\n\r\n      return;\r\n    }\r\n\r\n    if (!isTypeOnly) {\r\n      imports[existingIndex].isTypeOnly = false;\r\n    }\r\n  };\r\n\r\n  // Pattern 1: Standard ES module imports (handles multiline)\r\n  // Matches: import { ... } from \"path\", import Foo from \"path\", import Foo, { ... } from \"path\"\r\n  const importRegex =\r\n    /import\\s+(?:type\\s+)?(\\{[\\s\\S]*?\\}|\\*\\s+as\\s+\\w+|\\w+(?:\\s*,\\s*\\{[\\s\\S]*?\\})?)\\s+from\\s+['\"]([^'\"]+)['\"]/g;\r\n\r\n  let match;\r\n\r\n  while ((match = importRegex.exec(source)) !== null) {\r\n    const fullMatch = match[0];\r\n    const importPath = match[2];\r\n    const isTypeOnly = !hasRuntimeImports(fullMatch);\r\n\r\n    record(importPath, fullMatch, isTypeOnly);\r\n  }\r\n\r\n  // Pattern 1b: Side-effect imports - import \"path\" — always runtime\r\n  const sideEffectRegex = /import\\s+['\"]([^'\"]+)['\"]/g;\r\n\r\n  while ((match = sideEffectRegex.exec(source)) !== null) {\r\n    record(match[1], match[0], false);\r\n  }\r\n\r\n  // Pattern 2: Dynamic imports - import(\"path\") — always runtime\r\n  const dynamicImportPattern = /import\\s*\\(\\s*['\"]([^'\"]+)['\"]\\s*\\)/g;\r\n\r\n  while ((match = dynamicImportPattern.exec(source)) !== null) {\r\n    record(match[1], match[0], false);\r\n  }\r\n\r\n  // Pattern 3: Export from - export ... from \"path\"\r\n  const exportFromPattern = /export\\s+(?:\\{[^}]*\\}|\\*|\\w+)\\s+from\\s+['\"]([^'\"]+)['\"]/g;\r\n\r\n  while ((match = exportFromPattern.exec(source)) !== null) {\r\n    const fullMatch = match[0];\r\n\r\n    record(match[1], fullMatch, isExportTypeOnlyStatement(fullMatch));\r\n  }\r\n\r\n  return imports;\r\n}\r\n\r\n/**\r\n * Metadata for a single resolved import edge.\r\n * `isTypeOnly` is true iff every import/export statement that references this\r\n * path is type-only (pure `import type`, `export type`, or destructured lists\r\n * where every specifier carries the `type` keyword). A single runtime\r\n * occurrence flips the flag to false — that's what matters for cycle detection.\r\n */\r\nexport type ResolvedImport = {\r\n  absolutePath: string;\r\n  isTypeOnly: boolean;\r\n};\r\n\r\n/**\r\n * Parse import/export statements in a TS/JS source file and return the\r\n * resolved dependency edges keyed by the original import path. Includes\r\n * type-only edges (flagged) so downstream consumers can distinguish runtime\r\n * cycles from type-only ones.\r\n *\r\n * @example\r\n * const importMap = await parseImports(source, \"/abs/path/to/file.ts\");\r\n * for (const [importPath, { absolutePath, isTypeOnly }] of importMap) {\r\n *   // ...\r\n * }\r\n */\r\nexport async function parseImports(\r\n  source: string,\r\n  filePath: string,\r\n): Promise<Map<string, ResolvedImport>> {\r\n  try {\r\n    // Skip .d.ts files - they're type declarations, not runtime code\r\n    if (filePath.endsWith(\".d.ts\")) {\r\n      return new Map();\r\n    }\r\n\r\n    // Try es-module-lexer first (faster and more accurate for simple cases)\r\n    try {\r\n      const [imports] = await parse(source);\r\n\r\n      if (imports && imports.length > 0) {\r\n        return await resolveImports(imports as ImportSpecifier[], source, filePath);\r\n      }\r\n    } catch (lexerError) {\r\n      // es-module-lexer failed, fall back to regex-based extraction\r\n      // This is common with TypeScript files that have complex syntax\r\n    }\r\n\r\n    // Fallback: Use regex-based extraction (more forgiving with TypeScript)\r\n    const regexImports = extractImportPathsWithRegex(source);\r\n    const resolvedImports = new Map<string, ResolvedImport>();\r\n\r\n    for (const { path: importPath, isTypeOnly } of regexImports) {\r\n      if (isNodeBuiltin(importPath)) {\r\n        continue;\r\n      }\r\n\r\n      if (!importPath.startsWith(\".\") && !tsconfigManager.isAlias(importPath)) {\r\n        continue;\r\n      }\r\n\r\n      let resolvedPath: string | null = null;\r\n\r\n      if (tsconfigManager.isAlias(importPath)) {\r\n        resolvedPath = await resolveAliasImport(importPath);\r\n      } else if (importPath.startsWith(\".\")) {\r\n        resolvedPath = await resolveRelativeImport(importPath, filePath);\r\n      }\r\n\r\n      if (resolvedPath) {\r\n        mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);\r\n      }\r\n    }\r\n\r\n    return resolvedImports;\r\n  } catch (error) {\r\n    console.error(`Error parsing imports for ${filePath}:`, error);\r\n\r\n    return new Map();\r\n  }\r\n}\r\n\r\n/**\r\n * Merge a resolved import into the output map, preserving the type-only rule:\r\n * a path is type-only iff every statement that references it is type-only.\r\n */\r\nfunction mergeResolvedImport(\r\n  target: Map<string, ResolvedImport>,\r\n  importPath: string,\r\n  absolutePath: string,\r\n  isTypeOnly: boolean,\r\n): void {\r\n  const existing = target.get(importPath);\r\n\r\n  if (!existing) {\r\n    target.set(importPath, { absolutePath, isTypeOnly });\r\n\r\n    return;\r\n  }\r\n\r\n  if (!isTypeOnly) {\r\n    existing.isTypeOnly = false;\r\n  }\r\n}\r\n\r\n/**\r\n * Resolve imports from `es-module-lexer` output. For each specifier, slice the\r\n * raw statement (`ss..se`) and re-run the type-only heuristic so we can flag\r\n * the edge correctly — the lexer itself does not distinguish `import type`.\r\n */\r\nasync function resolveImports(\r\n  imports: ImportSpecifier[],\r\n  source: string,\r\n  filePath: string,\r\n): Promise<Map<string, ResolvedImport>> {\r\n  const resolvedImports = new Map<string, ResolvedImport>();\r\n\r\n  for (const imp of imports) {\r\n    const importPath = imp.n;\r\n\r\n    if (!importPath) {\r\n      continue;\r\n    }\r\n\r\n    if (isNodeBuiltin(importPath)) {\r\n      continue;\r\n    }\r\n\r\n    if (!importPath.startsWith(\".\") && !tsconfigManager.isAlias(importPath)) {\r\n      continue;\r\n    }\r\n\r\n    let resolvedPath: string | null = null;\r\n\r\n    if (tsconfigManager.isAlias(importPath)) {\r\n      resolvedPath = await resolveAliasImport(importPath);\r\n    } else if (importPath.startsWith(\".\")) {\r\n      resolvedPath = await resolveRelativeImport(importPath, filePath);\r\n    }\r\n\r\n    if (!resolvedPath) {\r\n      continue;\r\n    }\r\n\r\n    const isTypeOnly = isLexerStatementTypeOnly(imp, source);\r\n\r\n    mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);\r\n  }\r\n\r\n  return resolvedImports;\r\n}\r\n\r\n/**\r\n * Classify a single lexer-reported statement as type-only or runtime.\r\n * Dynamic imports (`import(...)`) are always runtime. For static\r\n * imports/export-from we slice the raw source and apply the same heuristic\r\n * the regex fallback uses.\r\n */\r\nfunction isLexerStatementTypeOnly(imp: ImportSpecifier, source: string): boolean {\r\n  // Dynamic imports always execute — they cannot be type-only.\r\n  // es-module-lexer reports dynamic with a.n === undefined typically, but\r\n  // we guard by checking the statement prefix too.\r\n  const statementStart = imp.ss;\r\n  const statementEnd = imp.se;\r\n\r\n  if (\r\n    typeof statementStart !== \"number\" ||\r\n    typeof statementEnd !== \"number\" ||\r\n    statementEnd <= statementStart\r\n  ) {\r\n    return false;\r\n  }\r\n\r\n  const statement = source.slice(statementStart, statementEnd);\r\n  const trimmed = statement.trim();\r\n\r\n  if (trimmed.startsWith(\"import(\") || /^\\bimport\\s*\\(/.test(trimmed)) {\r\n    return false;\r\n  }\r\n\r\n  if (trimmed.startsWith(\"export\")) {\r\n    return isExportTypeOnlyStatement(statement);\r\n  }\r\n\r\n  return !hasRuntimeImports(statement);\r\n}\r\n\r\n/**\r\n * Resolve alias imports to actual file paths with extensions\r\n * Example: app/users/services/get-users.service -> /absolute/path/to/src/app/users/services/get-users.service.ts\r\n */\r\nasync function resolveAliasImport(importPath: string): Promise<string | null> {\r\n  // Use tsconfig manager to resolve the alias to an absolute path\r\n  const resolvedBase = tsconfigManager.resolveAliasToAbsolute(importPath);\r\n\r\n  if (!resolvedBase) return null;\r\n\r\n  // Try to resolve with extensions\r\n  const resolvedPath = await tryResolveWithExtensions(resolvedBase);\r\n\r\n  return resolvedPath;\r\n}\r\n\r\n/**\r\n * Resolve relative imports to actual file paths\r\n * Example: ./../services/get-user.service -> /absolute/path/to/services/get-user.service.ts\r\n */\r\nasync function resolveRelativeImport(\r\n  importPath: string,\r\n  currentFilePath: string,\r\n): Promise<string | null> {\r\n  const dir = path.dirname(currentFilePath);\r\n  // Use path.resolve to handle .. and . properly, then normalize to forward slashes\r\n  const resolvedBase = Path.normalize(path.resolve(dir, importPath));\r\n\r\n  // Try to resolve with extensions\r\n  const resolvedPath = await tryResolveWithExtensions(resolvedBase);\r\n\r\n  return resolvedPath;\r\n}\r\n\r\n/**\r\n * Try to resolve a file path by checking different extensions\r\n * TypeScript/JavaScript files can be imported without extensions\r\n *\r\n * @TODO: For better performance, we need to check the files in files orchestrator\r\n * instead of using the file system as we will be fetching all project files anyway.\r\n */\r\n// Cache for file existence checks to avoid redundant filesystem calls\r\nconst fileExistsCache = new Map<string, boolean>();\r\n\r\n/**\r\n * Clear the file exists cache\r\n * Should be called when new files are created to ensure fresh lookups\r\n */\r\nexport function clearFileExistsCache(): void {\r\n  fileExistsCache.clear();\r\n}\r\n\r\nasync function cachedFileExists(filePath: string): Promise<boolean> {\r\n  if (fileExistsCache.has(filePath)) {\r\n    return fileExistsCache.get(filePath)!;\r\n  }\r\n  const exists = (await fileExistsAsync(filePath)) as boolean;\r\n  fileExistsCache.set(filePath, exists);\r\n  return exists;\r\n}\r\n\r\nasync function tryResolveWithExtensions(basePath: string): Promise<string | null> {\r\n  // Normalize the base path first (handle Windows paths)\r\n  const normalizedBase = Path.normalize(basePath);\r\n\r\n  // List of extensions to try, in order of preference\r\n  const extensions = [\".ts\", \".tsx\", \".js\", \".jsx\", \".mjs\", \".cjs\"];\r\n  const validExtensions = new Set(extensions);\r\n\r\n  // If the path already has a VALID code file extension, check if it exists\r\n  const ext = path.extname(normalizedBase);\r\n  if (ext && validExtensions.has(ext)) {\r\n    if (await cachedFileExists(normalizedBase)) {\r\n      return normalizedBase;\r\n    }\r\n    // If explicit extension doesn't exist, return null\r\n    return null;\r\n  }\r\n\r\n  // Try all extensions in parallel for better performance\r\n  const pathsToCheck = extensions.map((extension) => normalizedBase + extension);\r\n  const results = await Promise.all(\r\n    pathsToCheck.map(async (p) => ({ path: p, exists: await cachedFileExists(p) })),\r\n  );\r\n\r\n  // Return the first one that exists (in order of preference)\r\n  for (const result of results) {\r\n    if (result.exists) {\r\n      return result.path;\r\n    }\r\n  }\r\n\r\n  // Try index files in directory\r\n  if (await directoryExistsAsync(normalizedBase)) {\r\n    const indexPaths = extensions.map((extension) =>\r\n      Path.join(normalizedBase, `index${extension}`),\r\n    );\r\n    const indexResults = await Promise.all(\r\n      indexPaths.map(async (p) => ({ path: p, exists: await cachedFileExists(p) })),\r\n    );\r\n\r\n    for (const result of indexResults) {\r\n      if (result.exists) {\r\n        return result.path;\r\n      }\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Check if import is a Node.js built-in module\r\n */\r\nfunction isNodeBuiltin(importPath: string): boolean {\r\n  const builtins = [\r\n    \"fs\",\r\n    \"path\",\r\n    \"http\",\r\n    \"https\",\r\n    \"crypto\",\r\n    \"stream\",\r\n    \"util\",\r\n    \"events\",\r\n    \"buffer\",\r\n    \"child_process\",\r\n    \"os\",\r\n    \"url\",\r\n    \"querystring\",\r\n    \"zlib\",\r\n    \"net\",\r\n    \"tls\",\r\n    \"dns\",\r\n    \"dgram\",\r\n    \"cluster\",\r\n    \"worker_threads\",\r\n    \"perf_hooks\",\r\n    \"async_hooks\",\r\n    \"timers\",\r\n    \"readline\",\r\n    \"repl\",\r\n    \"vm\",\r\n    \"assert\",\r\n    \"console\",\r\n    \"process\",\r\n    \"v8\",\r\n  ];\r\n\r\n  // Check for node: prefix or direct builtin name\r\n  if (importPath.startsWith(\"node:\")) return true;\r\n\r\n  const moduleName = importPath.split(\"/\")[0];\r\n  return builtins.includes(moduleName);\r\n}\r\n"],"mappings":"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"}

package/esm/dev-server/path.mjs

@@ -0,0 +1,63 @@
+import path from "node:path";
+
+//#region ../../@warlock.js/core/src/dev-server/path.ts
+var Path = class {
+	/**
+	* Convert the given absolute path to a relative path
+	*/
+	static toRelative(absolutePath) {
+		return this.normalize(path.relative(process.cwd(), absolutePath));
+	}
+	/**
+	* Get relative path of the given path
+	*/
+	static relative(relativePath) {
+		return this.normalize(path.relative(process.cwd(), relativePath));
+	}
+	/**
+	* Get normalized absolute path of the given path
+	*/
+	static toNormalizedAbsolute(relativePath) {
+		return this.normalize(path.resolve(process.cwd(), relativePath));
+	}
+	/**
+	* Get absolute path of the given path
+	*/
+	static toAbsolute(relativePath) {
+		return this.normalize(path.resolve(process.cwd(), relativePath));
+	}
+	/**
+	* Normalize the given path (convert backslashes to forward slashes)
+	*/
+	static normalize(filePath) {
+		return filePath.replace(/\\/g, "/");
+	}
+	/**
+	* Join paths and normalize
+	*/
+	static join(...paths) {
+		return this.normalize(path.join(...paths));
+	}
+	/**
+	* Get directory name of a path
+	*/
+	static dirname(filePath) {
+		return this.normalize(path.dirname(filePath));
+	}
+	/**
+	* Get base name of a path
+	*/
+	static basename(filePath, ext) {
+		return path.basename(filePath, ext);
+	}
+	/**
+	* Get extension of a path
+	*/
+	static extname(filePath) {
+		return path.extname(filePath);
+	}
+};
+
+//#endregion
+export { Path };
+//# sourceMappingURL=path.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/path.ts"],"sourcesContent":["import path from \"node:path\";\n\nexport class Path {\n  /**\n   * Convert the given absolute path to a relative path\n   */\n  public static toRelative(absolutePath: string) {\n    return this.normalize(path.relative(process.cwd(), absolutePath));\n  }\n\n  /**\n   * Get relative path of the given path\n   */\n  public static relative(relativePath: string) {\n    return this.normalize(path.relative(process.cwd(), relativePath));\n  }\n\n  /**\n   * Get normalized absolute path of the given path\n   */\n  public static toNormalizedAbsolute(relativePath: string) {\n    return this.normalize(path.resolve(process.cwd(), relativePath));\n  }\n\n  /**\n   * Get absolute path of the given path\n   */\n  public static toAbsolute(relativePath: string) {\n    return this.normalize(path.resolve(process.cwd(), relativePath));\n  }\n\n  /**\n   * Normalize the given path (convert backslashes to forward slashes)\n   */\n  public static normalize(filePath: string) {\n    return filePath.replace(/\\\\/g, \"/\");\n  }\n\n  /**\n   * Join paths and normalize\n   */\n  public static join(...paths: string[]) {\n    return this.normalize(path.join(...paths));\n  }\n\n  /**\n   * Get directory name of a path\n   */\n  public static dirname(filePath: string) {\n    return this.normalize(path.dirname(filePath));\n  }\n\n  /**\n   * Get base name of a path\n   */\n  public static basename(filePath: string, ext?: string) {\n    return path.basename(filePath, ext);\n  }\n\n  /**\n   * Get extension of a path\n   */\n  public static extname(filePath: string) {\n    return path.extname(filePath);\n  }\n}\n"],"mappings":";;;AAEA,IAAa,OAAb,MAAkB;;;;CAIhB,OAAc,WAAW,cAAsB;EAC7C,OAAO,KAAK,UAAU,KAAK,SAAS,QAAQ,IAAI,GAAG,YAAY,CAAC;CAClE;;;;CAKA,OAAc,SAAS,cAAsB;EAC3C,OAAO,KAAK,UAAU,KAAK,SAAS,QAAQ,IAAI,GAAG,YAAY,CAAC;CAClE;;;;CAKA,OAAc,qBAAqB,cAAsB;EACvD,OAAO,KAAK,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,YAAY,CAAC;CACjE;;;;CAKA,OAAc,WAAW,cAAsB;EAC7C,OAAO,KAAK,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,YAAY,CAAC;CACjE;;;;CAKA,OAAc,UAAU,UAAkB;EACxC,OAAO,SAAS,QAAQ,OAAO,GAAG;CACpC;;;;CAKA,OAAc,KAAK,GAAG,OAAiB;EACrC,OAAO,KAAK,UAAU,KAAK,KAAK,GAAG,KAAK,CAAC;CAC3C;;;;CAKA,OAAc,QAAQ,UAAkB;EACtC,OAAO,KAAK,UAAU,KAAK,QAAQ,QAAQ,CAAC;CAC9C;;;;CAKA,OAAc,SAAS,UAAkB,KAAc;EACrD,OAAO,KAAK,SAAS,UAAU,GAAG;CACpC;;;;CAKA,OAAc,QAAQ,UAAkB;EACtC,OAAO,KAAK,QAAQ,QAAQ;CAC9B;AACF"}

package/esm/dev-server/special-files-collector.d.mts

@@ -0,0 +1,23 @@
+import { FileManager } from "./file-manager.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/special-files-collector.d.ts
+type SpecialFileType = "config" | "main" | "route" | "event" | "locale";
+/**
+ * Categorises files into the kinds the dev server treats specially
+ * (config / main / route / event / locale) and exposes typed accessors.
+ */
+declare class SpecialFilesCollector {
+  private readonly buckets;
+  collect(files: Map<string, FileManager>): void;
+  addFile(fileManager: FileManager): void;
+  removeFile(relativePath: string): void;
+  updateFile(fileManager: FileManager): void;
+  getFileType(relativePath: string): SpecialFileType | null;
+  getFilesByType(type: SpecialFileType): FileManager[];
+  getStats(): Record<SpecialFileType, number>;
+  clear(): void;
+  private categorise;
+}
+//#endregion
+export { SpecialFilesCollector };
+//# sourceMappingURL=special-files-collector.d.mts.map

package/esm/dev-server/special-files-collector.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"special-files-collector.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/special-files-collector.ts"],"mappings":";;;KAEY,eAAA;;AAAZ;;;cAMa,qBAAA;EAAA,iBACM,OAAA;EAQV,OAAA,CAAQ,KAAA,EAAO,GAAA,SAAY,WAAA;EAO3B,OAAA,CAAQ,WAAA,EAAa,WAAA;EAIrB,UAAA,CAAW,YAAA;EAIX,UAAA,CAAW,WAAA,EAAa,WAAA;EAKxB,WAAA,CAAY,YAAA,WAAuB,eAAA;EAUnC,cAAA,CAAe,IAAA,EAAM,eAAA,GAAkB,WAAA;EAUvC,QAAA,CAAA,GAAY,MAAA,CAAO,eAAA;EAUnB,KAAA,CAAA;EAAA,QAIC,UAAA;AAAA"}

package/esm/dev-server/special-files-collector.mjs

@@ -0,0 +1,67 @@
+//#region ../../@warlock.js/core/src/dev-server/special-files-collector.ts
+/**
+* Categorises files into the kinds the dev server treats specially
+* (config / main / route / event / locale) and exposes typed accessors.
+*/
+var SpecialFilesCollector = class {
+	constructor() {
+		this.buckets = {
+			config: /* @__PURE__ */ new Map(),
+			main: /* @__PURE__ */ new Map(),
+			route: /* @__PURE__ */ new Map(),
+			event: /* @__PURE__ */ new Map(),
+			locale: /* @__PURE__ */ new Map()
+		};
+	}
+	collect(files) {
+		for (const bucket of Object.values(this.buckets)) bucket.clear();
+		for (const [relativePath, fileManager] of files) this.categorise(relativePath, fileManager);
+	}
+	addFile(fileManager) {
+		this.categorise(fileManager.relativePath, fileManager);
+	}
+	removeFile(relativePath) {
+		for (const bucket of Object.values(this.buckets)) bucket.delete(relativePath);
+	}
+	updateFile(fileManager) {
+		this.removeFile(fileManager.relativePath);
+		this.categorise(fileManager.relativePath, fileManager);
+	}
+	getFileType(relativePath) {
+		for (const [type, bucket] of Object.entries(this.buckets)) if (bucket.has(relativePath)) return type;
+		return null;
+	}
+	getFilesByType(type) {
+		const files = Array.from(this.buckets[type].values());
+		if (type === "route") files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+		return files;
+	}
+	getStats() {
+		return {
+			config: this.buckets.config.size,
+			main: this.buckets.main.size,
+			route: this.buckets.route.size,
+			event: this.buckets.event.size,
+			locale: this.buckets.locale.size
+		};
+	}
+	clear() {
+		for (const bucket of Object.values(this.buckets)) bucket.clear();
+	}
+	categorise(relativePath, fileManager) {
+		if (isConfigFile(relativePath)) this.buckets.config.set(relativePath, fileManager);
+		else if (isMainFile(relativePath)) this.buckets.main.set(relativePath, fileManager);
+		else if (isRouteFile(relativePath)) this.buckets.route.set(relativePath, fileManager);
+		else if (isEventFile(relativePath)) this.buckets.event.set(relativePath, fileManager);
+		else if (isLocaleFile(relativePath)) this.buckets.locale.set(relativePath, fileManager);
+	}
+};
+const isConfigFile = (path) => /^src\/config\/.*\.(ts|tsx)$/.test(path);
+const isMainFile = (path) => /^src\/app\/[^/]+\/main\.(ts|tsx)$/.test(path) || path === "src/app/main.ts" || path === "src/app/main.tsx";
+const isRouteFile = (path) => /^src\/app\/[^/]+\/routes\.(ts|tsx)$/.test(path);
+const isEventFile = (path) => /^src\/app\/[^/]+\/events\/[^/]+\.(ts|tsx)$/.test(path);
+const isLocaleFile = (path) => /^src\/app\/[^/]+\/utils\/locales\.(ts|tsx)$/.test(path);
+
+//#endregion
+export { SpecialFilesCollector };
+//# sourceMappingURL=special-files-collector.mjs.map

package/esm/dev-server/special-files-collector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"special-files-collector.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/special-files-collector.ts"],"sourcesContent":["import { FileManager } from \"./file-manager\";\r\n\r\nexport type SpecialFileType = \"config\" | \"main\" | \"route\" | \"event\" | \"locale\";\r\n\r\n/**\r\n * Categorises files into the kinds the dev server treats specially\r\n * (config / main / route / event / locale) and exposes typed accessors.\r\n */\r\nexport class SpecialFilesCollector {\r\n  private readonly buckets: Record<SpecialFileType, Map<string, FileManager>> = {\r\n    config: new Map(),\r\n    main: new Map(),\r\n    route: new Map(),\r\n    event: new Map(),\r\n    locale: new Map(),\r\n  };\r\n\r\n  public collect(files: Map<string, FileManager>): void {\r\n    for (const bucket of Object.values(this.buckets)) bucket.clear();\r\n    for (const [relativePath, fileManager] of files) {\r\n      this.categorise(relativePath, fileManager);\r\n    }\r\n  }\r\n\r\n  public addFile(fileManager: FileManager): void {\r\n    this.categorise(fileManager.relativePath, fileManager);\r\n  }\r\n\r\n  public removeFile(relativePath: string): void {\r\n    for (const bucket of Object.values(this.buckets)) bucket.delete(relativePath);\r\n  }\r\n\r\n  public updateFile(fileManager: FileManager): void {\r\n    this.removeFile(fileManager.relativePath);\r\n    this.categorise(fileManager.relativePath, fileManager);\r\n  }\r\n\r\n  public getFileType(relativePath: string): SpecialFileType | null {\r\n    for (const [type, bucket] of Object.entries(this.buckets) as [\r\n      SpecialFileType,\r\n      Map<string, FileManager>,\r\n    ][]) {\r\n      if (bucket.has(relativePath)) return type;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  public getFilesByType(type: SpecialFileType): FileManager[] {\r\n    const files = Array.from(this.buckets[type].values());\r\n    // Routes are loaded sequentially in alphabetical order so registration\r\n    // is deterministic across runs.\r\n    if (type === \"route\") {\r\n      files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));\r\n    }\r\n    return files;\r\n  }\r\n\r\n  public getStats(): Record<SpecialFileType, number> {\r\n    return {\r\n      config: this.buckets.config.size,\r\n      main: this.buckets.main.size,\r\n      route: this.buckets.route.size,\r\n      event: this.buckets.event.size,\r\n      locale: this.buckets.locale.size,\r\n    };\r\n  }\r\n\r\n  public clear(): void {\r\n    for (const bucket of Object.values(this.buckets)) bucket.clear();\r\n  }\r\n\r\n  private categorise(relativePath: string, fileManager: FileManager): void {\r\n    if (isConfigFile(relativePath)) {\r\n      this.buckets.config.set(relativePath, fileManager);\r\n    } else if (isMainFile(relativePath)) {\r\n      this.buckets.main.set(relativePath, fileManager);\r\n    } else if (isRouteFile(relativePath)) {\r\n      this.buckets.route.set(relativePath, fileManager);\r\n    } else if (isEventFile(relativePath)) {\r\n      this.buckets.event.set(relativePath, fileManager);\r\n    } else if (isLocaleFile(relativePath)) {\r\n      this.buckets.locale.set(relativePath, fileManager);\r\n    }\r\n  }\r\n}\r\n\r\nconst isConfigFile = (path: string) => /^src\\/config\\/.*\\.(ts|tsx)$/.test(path);\r\nconst isMainFile = (path: string) =>\r\n  /^src\\/app\\/[^/]+\\/main\\.(ts|tsx)$/.test(path) ||\r\n  path === \"src/app/main.ts\" ||\r\n  path === \"src/app/main.tsx\";\r\nconst isRouteFile = (path: string) => /^src\\/app\\/[^/]+\\/routes\\.(ts|tsx)$/.test(path);\r\nconst isEventFile = (path: string) => /^src\\/app\\/[^/]+\\/events\\/[^/]+\\.(ts|tsx)$/.test(path);\r\nconst isLocaleFile = (path: string) => /^src\\/app\\/[^/]+\\/utils\\/locales\\.(ts|tsx)$/.test(path);\r\n"],"mappings":";;;;;AAQA,IAAa,wBAAb,MAAmC;;iBAC6C;GAC5E,wBAAQ,IAAI,IAAI;GAChB,sBAAM,IAAI,IAAI;GACd,uBAAO,IAAI,IAAI;GACf,uBAAO,IAAI,IAAI;GACf,wBAAQ,IAAI,IAAI;EAClB;;CAEA,AAAO,QAAQ,OAAuC;EACpD,KAAK,MAAM,UAAU,OAAO,OAAO,KAAK,OAAO,GAAG,OAAO,MAAM;EAC/D,KAAK,MAAM,CAAC,cAAc,gBAAgB,OACxC,KAAK,WAAW,cAAc,WAAW;CAE7C;CAEA,AAAO,QAAQ,aAAgC;EAC7C,KAAK,WAAW,YAAY,cAAc,WAAW;CACvD;CAEA,AAAO,WAAW,cAA4B;EAC5C,KAAK,MAAM,UAAU,OAAO,OAAO,KAAK,OAAO,GAAG,OAAO,OAAO,YAAY;CAC9E;CAEA,AAAO,WAAW,aAAgC;EAChD,KAAK,WAAW,YAAY,YAAY;EACxC,KAAK,WAAW,YAAY,cAAc,WAAW;CACvD;CAEA,AAAO,YAAY,cAA8C;EAC/D,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,KAAK,OAAO,GAItD,IAAI,OAAO,IAAI,YAAY,GAAG,OAAO;EAEvC,OAAO;CACT;CAEA,AAAO,eAAe,MAAsC;EAC1D,MAAM,QAAQ,MAAM,KAAK,KAAK,QAAQ,MAAM,OAAO,CAAC;EAGpD,IAAI,SAAS,SACX,MAAM,MAAM,GAAG,MAAM,EAAE,aAAa,cAAc,EAAE,YAAY,CAAC;EAEnE,OAAO;CACT;CAEA,AAAO,WAA4C;EACjD,OAAO;GACL,QAAQ,KAAK,QAAQ,OAAO;GAC5B,MAAM,KAAK,QAAQ,KAAK;GACxB,OAAO,KAAK,QAAQ,MAAM;GAC1B,OAAO,KAAK,QAAQ,MAAM;GAC1B,QAAQ,KAAK,QAAQ,OAAO;EAC9B;CACF;CAEA,AAAO,QAAc;EACnB,KAAK,MAAM,UAAU,OAAO,OAAO,KAAK,OAAO,GAAG,OAAO,MAAM;CACjE;CAEA,AAAQ,WAAW,cAAsB,aAAgC;EACvE,IAAI,aAAa,YAAY,GAC3B,KAAK,QAAQ,OAAO,IAAI,cAAc,WAAW;OAC5C,IAAI,WAAW,YAAY,GAChC,KAAK,QAAQ,KAAK,IAAI,cAAc,WAAW;OAC1C,IAAI,YAAY,YAAY,GACjC,KAAK,QAAQ,MAAM,IAAI,cAAc,WAAW;OAC3C,IAAI,YAAY,YAAY,GACjC,KAAK,QAAQ,MAAM,IAAI,cAAc,WAAW;OAC3C,IAAI,aAAa,YAAY,GAClC,KAAK,QAAQ,OAAO,IAAI,cAAc,WAAW;CAErD;AACF;AAEA,MAAM,gBAAgB,SAAiB,8BAA8B,KAAK,IAAI;AAC9E,MAAM,cAAc,SAClB,oCAAoC,KAAK,IAAI,KAC7C,SAAS,qBACT,SAAS;AACX,MAAM,eAAe,SAAiB,sCAAsC,KAAK,IAAI;AACrF,MAAM,eAAe,SAAiB,6CAA6C,KAAK,IAAI;AAC5F,MAAM,gBAAgB,SAAiB,8CAA8C,KAAK,IAAI"}

package/esm/dev-server/start-development-server.mjs

@@ -0,0 +1,63 @@
+import { devLogError, devServeLog } from "./dev-logger.mjs";
+import { DevelopmentServer } from "./development-server.mjs";
+import { colors } from "@mongez/copper";
+
+//#region ../../@warlock.js/core/src/dev-server/start-development-server.ts
+let handlersRegistered = false;
+/**
+* Start the development server.
+*
+* Boots the file orchestrator, loads app modules, starts late-phase
+* connectors, then wires graceful shutdown for SIGINT/SIGTERM (plus
+* SIGHUP on Windows where Ctrl+C in spawned children lands as SIGHUP).
+*
+* If startup throws, shuts down cleanly and exits 1 — dev should die
+* loudly rather than hang with a half-initialized state.
+*/
+async function startDevelopmentServer(options = {}) {
+	process.setSourceMapsEnabled(true);
+	const devServer = new DevelopmentServer(options);
+	registerShutdownHandlers(devServer);
+	try {
+		await devServer.start();
+	} catch (error) {
+		devLogError(`Failed to start Development Server: ${error.message}`);
+		await safeShutdown(devServer);
+		process.exit(1);
+	}
+	return devServer;
+}
+/**
+* Register signal handlers once per process. Guards against handler
+* accumulation if `startDevelopmentServer` is invoked more than once
+* (tests, programmatic restart).
+*/
+function registerShutdownHandlers(devServer) {
+	if (handlersRegistered) return;
+	handlersRegistered = true;
+	const onSignal = (signal) => async () => {
+		devServeLog(colors.yellow(`📡 Received ${signal}`));
+		const ok = await safeShutdown(devServer);
+		process.exit(ok ? 0 : 1);
+	};
+	process.on("SIGINT", onSignal("SIGINT"));
+	process.on("SIGTERM", onSignal("SIGTERM"));
+	if (process.platform === "win32") process.on("SIGHUP", onSignal("SIGHUP"));
+}
+/**
+* Shut down the dev server without swallowing async errors. Returns
+* whether shutdown completed cleanly so the caller picks the exit code.
+*/
+async function safeShutdown(devServer) {
+	try {
+		await devServer.shutdown();
+		return true;
+	} catch (error) {
+		devLogError(`Shutdown failed: ${error.message}`);
+		return false;
+	}
+}
+
+//#endregion
+export { startDevelopmentServer };
+//# sourceMappingURL=start-development-server.mjs.map