@warlock.js/core 5.31.0 → 5.33.0

package/esm/dev-server/module-loader.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"module-loader.mjs","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/module-loader.ts"],"sourcesContent":["import { pathToFileURL } from \"node:url\";\nimport ts from \"typescript\";\nimport { importAppModule } from \"../loader/app-module-importer\";\nimport { registerGroupedTranslationKeys, registerLocaleDictionary } from \"../localization\";\nimport { router } from \"../router/router\";\nimport { devLogError, formatModuleNotFoundError } from \"./dev-logger\";\nimport { extractTranslationKeys } from \"./extract-translation-keys\";\nimport type { CleanupFunction, FileManager } from \"./file-manager\";\nimport { warnForLegacyLocales } from \"./legacy-locales-warning\";\nimport { getDevelopmentModelModuleRegistry } from \"./model-module-registry\";\nimport type { SpecialFileType, SpecialFilesCollector } from \"./special-files-collector\";\n\ndeclare global {\n  var __currentModuleFile: FileManager | undefined;\n}\n\n/**\n * Thrown when a special file (route/event/main/locale) fails to import or\n * register. Carries the file that failed and the original cause so a broken\n * module surfaces with its origin instead of vanishing into a 404.\n */\nexport class ModuleLoadError extends Error {\n  /** Stable Warlock error code; `warlock explain WL2001` prints the fix. */\n  public readonly code = \"WL2001\";\n\n  public constructor(\n    public readonly type: string,\n    public readonly file: FileManager,\n    public readonly cause: unknown,\n  ) {\n    const reason = cause instanceof Error ? cause.message : String(cause);\n    super(`Failed to load ${type}: ${file.relativePath} - ${reason}`);\n    this.name = \"ModuleLoadError\";\n  }\n}\n\n/**\n * The \"special\" file kinds that the dev server eagerly imports at boot.\n * Order matters: locales first (used by everything), events before main so\n * listeners are registered when main runs, routes after main so handlers are\n * bound, worker last so scheduled jobs and queue definitions see routes\n * already registered. Dev always loads worker files since dev runs every role.\n */\nconst SPECIAL_TYPES: readonly SpecialFileType[] = [\n  \"locale\",\n  \"event\",\n  \"main\",\n  \"route\",\n  \"worker\",\n] as const;\n\n/**\n * Loads application modules through the ESM loader hook. The hook stamps\n * `?v=N` on every import, so each reload is a fresh module without any\n * userland cache-busting plumbing.\n */\nexport class ModuleLoader {\n  private readonly loadedModules = new Map<string, unknown>();\n\n  public constructor(private readonly specialFilesCollector: SpecialFilesCollector) {\n    // Web creates its Vite bridge after Core's development orchestration has\n    // constructed ModuleLoader. Create the carrier now so a zero-model app can\n    // subscribe before a model is added later through HMR.\n    getDevelopmentModelModuleRegistry();\n  }\n\n  /**\n   * Eagerly load every special file at boot, in the canonical order so\n   * later phases (e.g. routes) see state earlier phases registered.\n   *\n   * A failing module no longer vanishes silently: each failure is collected\n   * (so one broken file doesn't hide the others) and, once every file has been\n   * attempted, an aggregate error is thrown. The boot callers\n   * (`DevelopmentServer.start`, the HTTP test bootstrap) already wrap this in a\n   * try/catch that logs and aborts the boot — so a broken route module aborts\n   * boot loudly rather than booting into a surface that 404s.\n   */\n  public async loadAll(\n    options: { onBeforeLoad?: (file: FileManager) => void | Promise<void> } = {},\n  ): Promise<void> {\n    const failures: ModuleLoadError[] = [];\n\n    for (const type of SPECIAL_TYPES) {\n      for (const file of this.specialFilesCollector.getFilesByType(type)) {\n        try {\n          await options.onBeforeLoad?.(file);\n          await this.loadModule(file, type);\n        } catch (error) {\n          failures.push(\n            error instanceof ModuleLoadError ? error : new ModuleLoadError(type, file, error),\n          );\n        }\n      }\n    }\n\n    if (failures.length > 0) {\n      throw new AggregateError(\n        failures,\n        `${failures.length} module(s) failed to load during boot:\\n` +\n          failures.map((failure) => `  - ${failure.message}`).join(\"\\n\"),\n      );\n    }\n  }\n\n  /**\n   * Import a file through the loader hook. For routes, scopes the import in\n   * `router.withSourceFile()` so the added routes carry their origin.\n   */\n  public async loadModule<T = unknown>(file: FileManager, type: string): Promise<T | undefined> {\n    if (file.relativePath.endsWith(\".env\")) return undefined;\n\n    if (type === \"locale\" && /\\/utils\\/locales\\.(ts|tsx)$/.test(file.relativePath)) {\n      warnForLegacyLocales(\n        this.specialFilesCollector.getFilesByType(\"locale\").map((locale) => locale.relativePath),\n      );\n    }\n\n    if (type === \"locale\" && file.relativePath.endsWith(\".json\")) {\n      const cleanup = registerLocaleDictionary({\n        sourceFile: file.relativePath,\n        source: file.source,\n        defaultNamespace: file.relativePath.split(\"/\")[2]!,\n      });\n      file.addCleanup(cleanup);\n      return undefined;\n    }\n\n    if (type === \"locale\") {\n      registerGroupedTranslationKeys(\n        file.relativePath,\n        extractTranslationKeys(\n          ts.createSourceFile(file.relativePath, file.source, ts.ScriptTarget.Latest),\n        ),\n      );\n    }\n\n    globalThis.__currentModuleFile = file;\n\n    try {\n      const fileUrl = pathToFileURL(file.absolutePath).href;\n\n      const load = async () => {\n        const module = (await importAppModule(fileUrl)) as Record<string, unknown>;\n        this.loadedModules.set(file.absolutePath, module);\n        this.registerCleanup(file, module);\n        if (type === \"model\") {\n          getDevelopmentModelModuleRegistry().publish(file.absolutePath, fileUrl, module);\n        }\n        return module as T;\n      };\n\n      return type === \"route\" ? await router.withSourceFile(file.relativePath, load) : await load();\n    } catch (error: any) {\n      if (error.code === \"ERR_MODULE_NOT_FOUND\") {\n        devLogError(formatModuleNotFoundError(error));\n      } else {\n        // Pass the error through so devLogError prints the stack. With dev\n        // source maps enabled, frames remap to the original `.ts` line/col\n        // (e.g. the actual call site of an undefined symbol) instead of\n        // vanishing — a one-line \"x is not defined\" is undebuggable.\n        devLogError(\n          `Failed to load ${type}: ${file.relativePath} - ${error?.message || error}`,\n          error,\n        );\n      }\n\n      // RETHROW after logging. Previously this returned undefined, so a route\n      // file that threw on import or registration disappeared with no boot\n      // error — the whole surface 404'd silently. Boot callers abort on the\n      // throw; the HMR batch-reload handler catches it, keeps the server\n      // alive, and shows it loudly.\n      throw error instanceof ModuleLoadError ? error : new ModuleLoadError(type, file, error);\n    } finally {\n      globalThis.__currentModuleFile = undefined;\n    }\n  }\n\n  /**\n   * Reload a previously-loaded special file. The version-bump that makes the\n   * import fresh is done by the caller (layer-executor) before invoking this.\n   * Routes are removed from the registry first so re-registration is clean.\n   */\n  public async reloadModule(file: FileManager): Promise<void> {\n    const moduleType = this.specialFilesCollector.getFileType(file.relativePath);\n    if (!moduleType) return;\n\n    this.runCleanup(file);\n\n    if (moduleType === \"route\") {\n      router.removeRoutesBySourceFile(file.relativePath);\n    }\n\n    this.loadedModules.delete(file.absolutePath);\n    await this.loadModule(file, moduleType);\n  }\n\n  /**\n   * Run every cleanup hook the file registered (or `$cleanup` on its exports)\n   * and reset the list. Called once per HMR reload.\n   */\n  public runCleanup(file: FileManager): void {\n    for (const hook of file.cleanup) {\n      try {\n        if (typeof hook === \"function\") {\n          hook();\n        } else if (\n          hook &&\n          typeof (hook as { unsubscribe?: () => void }).unsubscribe === \"function\"\n        ) {\n          (hook as { unsubscribe: () => void }).unsubscribe();\n        }\n      } catch {\n        // Cleanup errors shouldn't break HMR.\n      }\n    }\n    file.resetCleanup();\n  }\n\n  /**\n   * Clean up after a file whose source was deleted from disk.\n   */\n  public cleanupDeletedModule(file: FileManager): void {\n    this.loadedModules.delete(file.absolutePath);\n\n    if (file.type === \"model\") {\n      getDevelopmentModelModuleRegistry().remove(file.absolutePath);\n    }\n\n    if (file.type === \"route\") {\n      router.removeRoutesBySourceFile(file.relativePath);\n    }\n\n    this.runCleanup(file);\n  }\n\n  /**\n   * Scan a freshly-loaded module for cleanup handlers and register them on\n   * the FileManager so they run before the next reload. Priority: explicit\n   * `export function cleanup()` → `.$cleanup` on any exported value.\n   */\n  private registerCleanup(file: FileManager, module: Record<string, unknown>): void {\n    if (typeof module.cleanup === \"function\") {\n      file.addCleanup(module.cleanup as CleanupFunction);\n      return;\n    }\n\n    const cleanups: CleanupFunction[] = [];\n\n    for (const exportedValue of Object.values(module)) {\n      const cleanup = (exportedValue as { $cleanup?: unknown })?.$cleanup;\n      if (typeof cleanup === \"function\") {\n        cleanups.push(cleanup.bind(exportedValue) as CleanupFunction);\n      }\n    }\n\n    if (cleanups.length > 0) {\n      file.addCleanup(cleanups);\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"module-loader.mjs","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/module-loader.ts"],"sourcesContent":["import { pathToFileURL } from \"node:url\";\nimport { parseSourceFile } from \"../tooling/syntax/ast\";\nimport { importAppModule } from \"../loader/app-module-importer\";\nimport { registerGroupedTranslationKeys, registerLocaleDictionary } from \"../localization\";\nimport { router } from \"../router/router\";\nimport { devLogError, formatModuleNotFoundError } from \"./dev-logger\";\nimport { extractTranslationKeys } from \"./extract-translation-keys\";\nimport type { CleanupFunction, FileManager } from \"./file-manager\";\nimport { warnForLegacyLocales } from \"./legacy-locales-warning\";\nimport { getDevelopmentModelModuleRegistry } from \"./model-module-registry\";\nimport type { SpecialFileType, SpecialFilesCollector } from \"./special-files-collector\";\n\ndeclare global {\n  var __currentModuleFile: FileManager | undefined;\n}\n\n/**\n * Thrown when a special file (route/event/main/locale) fails to import or\n * register. Carries the file that failed and the original cause so a broken\n * module surfaces with its origin instead of vanishing into a 404.\n */\nexport class ModuleLoadError extends Error {\n  /** Stable Warlock error code; `warlock explain WL2001` prints the fix. */\n  public readonly code = \"WL2001\";\n\n  public constructor(\n    public readonly type: string,\n    public readonly file: FileManager,\n    public readonly cause: unknown,\n  ) {\n    const reason = cause instanceof Error ? cause.message : String(cause);\n    super(`Failed to load ${type}: ${file.relativePath} - ${reason}`);\n    this.name = \"ModuleLoadError\";\n  }\n}\n\n/**\n * The \"special\" file kinds that the dev server eagerly imports at boot.\n * Order matters: locales first (used by everything), events before main so\n * listeners are registered when main runs, routes after main so handlers are\n * bound, worker last so scheduled jobs and queue definitions see routes\n * already registered. Dev always loads worker files since dev runs every role.\n */\nconst SPECIAL_TYPES: readonly SpecialFileType[] = [\n  \"locale\",\n  \"event\",\n  \"main\",\n  \"route\",\n  \"worker\",\n] as const;\n\n/**\n * Loads application modules through the ESM loader hook. The hook stamps\n * `?v=N` on every import, so each reload is a fresh module without any\n * userland cache-busting plumbing.\n */\nexport class ModuleLoader {\n  private readonly loadedModules = new Map<string, unknown>();\n\n  public constructor(private readonly specialFilesCollector: SpecialFilesCollector) {\n    // Web creates its Vite bridge after Core's development orchestration has\n    // constructed ModuleLoader. Create the carrier now so a zero-model app can\n    // subscribe before a model is added later through HMR.\n    getDevelopmentModelModuleRegistry();\n  }\n\n  /**\n   * Eagerly load every special file at boot, in the canonical order so\n   * later phases (e.g. routes) see state earlier phases registered.\n   *\n   * A failing module no longer vanishes silently: each failure is collected\n   * (so one broken file doesn't hide the others) and, once every file has been\n   * attempted, an aggregate error is thrown. The boot callers\n   * (`DevelopmentServer.start`, the HTTP test bootstrap) already wrap this in a\n   * try/catch that logs and aborts the boot — so a broken route module aborts\n   * boot loudly rather than booting into a surface that 404s.\n   */\n  public async loadAll(\n    options: { onBeforeLoad?: (file: FileManager) => void | Promise<void> } = {},\n  ): Promise<void> {\n    const failures: ModuleLoadError[] = [];\n\n    for (const type of SPECIAL_TYPES) {\n      for (const file of this.specialFilesCollector.getFilesByType(type)) {\n        try {\n          await options.onBeforeLoad?.(file);\n          await this.loadModule(file, type);\n        } catch (error) {\n          failures.push(\n            error instanceof ModuleLoadError ? error : new ModuleLoadError(type, file, error),\n          );\n        }\n      }\n    }\n\n    if (failures.length > 0) {\n      throw new AggregateError(\n        failures,\n        `${failures.length} module(s) failed to load during boot:\\n` +\n          failures.map((failure) => `  - ${failure.message}`).join(\"\\n\"),\n      );\n    }\n  }\n\n  /**\n   * Import a file through the loader hook. For routes, scopes the import in\n   * `router.withSourceFile()` so the added routes carry their origin.\n   */\n  public async loadModule<T = unknown>(file: FileManager, type: string): Promise<T | undefined> {\n    if (file.relativePath.endsWith(\".env\")) return undefined;\n\n    if (type === \"locale\" && /\\/utils\\/locales\\.(ts|tsx)$/.test(file.relativePath)) {\n      warnForLegacyLocales(\n        this.specialFilesCollector.getFilesByType(\"locale\").map((locale) => locale.relativePath),\n      );\n    }\n\n    if (type === \"locale\" && file.relativePath.endsWith(\".json\")) {\n      const cleanup = registerLocaleDictionary({\n        sourceFile: file.relativePath,\n        source: file.source,\n        defaultNamespace: file.relativePath.split(\"/\")[2]!,\n      });\n      file.addCleanup(cleanup);\n      return undefined;\n    }\n\n    if (type === \"locale\") {\n      registerGroupedTranslationKeys(\n        file.relativePath,\n        extractTranslationKeys(parseSourceFile(file.relativePath, file.source)),\n      );\n    }\n\n    globalThis.__currentModuleFile = file;\n\n    try {\n      const fileUrl = pathToFileURL(file.absolutePath).href;\n\n      const load = async () => {\n        const module = (await importAppModule(fileUrl)) as Record<string, unknown>;\n        this.loadedModules.set(file.absolutePath, module);\n        this.registerCleanup(file, module);\n        if (type === \"model\") {\n          getDevelopmentModelModuleRegistry().publish(file.absolutePath, fileUrl, module);\n        }\n        return module as T;\n      };\n\n      return type === \"route\" ? await router.withSourceFile(file.relativePath, load) : await load();\n    } catch (error: any) {\n      if (error.code === \"ERR_MODULE_NOT_FOUND\") {\n        devLogError(formatModuleNotFoundError(error));\n      } else {\n        // Pass the error through so devLogError prints the stack. With dev\n        // source maps enabled, frames remap to the original `.ts` line/col\n        // (e.g. the actual call site of an undefined symbol) instead of\n        // vanishing — a one-line \"x is not defined\" is undebuggable.\n        devLogError(\n          `Failed to load ${type}: ${file.relativePath} - ${error?.message || error}`,\n          error,\n        );\n      }\n\n      // RETHROW after logging. Previously this returned undefined, so a route\n      // file that threw on import or registration disappeared with no boot\n      // error — the whole surface 404'd silently. Boot callers abort on the\n      // throw; the HMR batch-reload handler catches it, keeps the server\n      // alive, and shows it loudly.\n      throw error instanceof ModuleLoadError ? error : new ModuleLoadError(type, file, error);\n    } finally {\n      globalThis.__currentModuleFile = undefined;\n    }\n  }\n\n  /**\n   * Reload a previously-loaded special file. The version-bump that makes the\n   * import fresh is done by the caller (layer-executor) before invoking this.\n   * Routes are removed from the registry first so re-registration is clean.\n   */\n  public async reloadModule(file: FileManager): Promise<void> {\n    const moduleType = this.specialFilesCollector.getFileType(file.relativePath);\n    if (!moduleType) return;\n\n    this.runCleanup(file);\n\n    if (moduleType === \"route\") {\n      router.removeRoutesBySourceFile(file.relativePath);\n    }\n\n    this.loadedModules.delete(file.absolutePath);\n    await this.loadModule(file, moduleType);\n  }\n\n  /**\n   * Run every cleanup hook the file registered (or `$cleanup` on its exports)\n   * and reset the list. Called once per HMR reload.\n   */\n  public runCleanup(file: FileManager): void {\n    for (const hook of file.cleanup) {\n      try {\n        if (typeof hook === \"function\") {\n          hook();\n        } else if (\n          hook &&\n          typeof (hook as { unsubscribe?: () => void }).unsubscribe === \"function\"\n        ) {\n          (hook as { unsubscribe: () => void }).unsubscribe();\n        }\n      } catch {\n        // Cleanup errors shouldn't break HMR.\n      }\n    }\n    file.resetCleanup();\n  }\n\n  /**\n   * Clean up after a file whose source was deleted from disk.\n   */\n  public cleanupDeletedModule(file: FileManager): void {\n    this.loadedModules.delete(file.absolutePath);\n\n    if (file.type === \"model\") {\n      getDevelopmentModelModuleRegistry().remove(file.absolutePath);\n    }\n\n    if (file.type === \"route\") {\n      router.removeRoutesBySourceFile(file.relativePath);\n    }\n\n    this.runCleanup(file);\n  }\n\n  /**\n   * Scan a freshly-loaded module for cleanup handlers and register them on\n   * the FileManager so they run before the next reload. Priority: explicit\n   * `export function cleanup()` → `.$cleanup` on any exported value.\n   */\n  private registerCleanup(file: FileManager, module: Record<string, unknown>): void {\n    if (typeof module.cleanup === \"function\") {\n      file.addCleanup(module.cleanup as CleanupFunction);\n      return;\n    }\n\n    const cleanups: CleanupFunction[] = [];\n\n    for (const exportedValue of Object.values(module)) {\n      const cleanup = (exportedValue as { $cleanup?: unknown })?.$cleanup;\n      if (typeof cleanup === \"function\") {\n        cleanups.push(cleanup.bind(exportedValue) as CleanupFunction);\n      }\n    }\n\n    if (cleanups.length > 0) {\n      file.addCleanup(cleanups);\n    }\n  }\n}\n"],"mappings":"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"}

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

@@ -22,5 +22,5 @@ var PackageJsonManager = class {
 const packageJsonManager = new PackageJsonManager();
 
 //#endregion
-export { packageJsonManager };
+export { PackageJsonManager, packageJsonManager };
 //# sourceMappingURL=package-json-manager.mjs.map

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

@@ -3,7 +3,7 @@ import { tsconfigManager } from "./tsconfig-manager.mjs";
 import path from "node:path";
 import { directoryExistsAsync, fileExistsAsync } from "@warlock.js/fs";
 import { parse } from "es-module-lexer";
-import ts from "typescript";
+import { parseSync } from "oxc-parser";
 
 //#region ../../packages/core/src/dev-server/parse-imports.ts
 /**
@@ -209,7 +209,7 @@ function isSameFile(first, second) {
 * line-based matches keep their lines). Only the regex fallback needs it; the
 * lexer already skips comments.
 *
-* Comment ranges come from a real TypeScript parse, never from scanning
+* Comment ranges come from an OXC parse, never from scanning
 * characters: only the parser can tell a regex literal (`/\/*$/`), a template
 * literal or JSX text (`<p>// not a comment</p>`) from a comment. A character
 * scanner read the `/*` in `p.replace(/\/*$/, "")` as a block comment and
@@ -219,48 +219,16 @@ function isSameFile(first, second) {
 * source is parsed as TSX.
 */
 function stripComments(source, filePath = "source.tsx") {
-	const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, false, scriptKindFor(filePath));
-	const ranges = [];
-	const seen = /* @__PURE__ */ new Set();
-	const collect = (node) => {
-		if (node.kind >= ts.SyntaxKind.FirstJSDocNode && node.kind <= ts.SyntaxKind.LastJSDocNode) return;
-		const children = node.getChildren(sourceFile);
-		if (children.length > 0) {
-			for (const child of children) collect(child);
-			return;
-		}
-		if (node.kind === ts.SyntaxKind.JsxText || node.kind === ts.SyntaxKind.JsxTextAllWhiteSpaces) return;
-		const tokenStart = node.getStart(sourceFile);
-		const trivia = [...ts.getTrailingCommentRanges(source, node.pos) ?? [], ...ts.getLeadingCommentRanges(source, node.pos) ?? []];
-		for (const range of trivia) if (range.end <= tokenStart && !seen.has(range.pos)) {
-			seen.add(range.pos);
-			ranges.push(range);
-		}
-	};
-	collect(sourceFile);
-	ranges.sort((first, second) => first.pos - second.pos);
+	const ranges = parseSync(filePath, source).comments;
 	let output = "";
 	let cursor = 0;
 	for (const range of ranges) {
-		output += source.slice(cursor, range.pos);
-		output += source.slice(range.pos, range.end).replace(/[^\n]/g, "");
+		output += source.slice(cursor, range.start);
+		output += source.slice(range.start, range.end).replace(/[^\n]/g, "");
 		cursor = range.end;
 	}
 	return output + source.slice(cursor);
 }
-/** The parse dialect for a file: JSX only where the extension allows it. */
-function scriptKindFor(filePath) {
-	switch (path.extname(filePath).toLowerCase()) {
-		case ".ts":
-		case ".mts":
-		case ".cts": return ts.ScriptKind.TS;
-		case ".js":
-		case ".mjs":
-		case ".cjs": return ts.ScriptKind.JS;
-		case ".jsx": return ts.ScriptKind.JSX;
-		default: return ts.ScriptKind.TSX;
-	}
-}
 /**
 * 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.
@@ -434,5 +402,5 @@ function isNodeBuiltin(importPath) {
 }
 
 //#endregion
-export { clearFileExistsCache, isTypeOnlyFile, parseImports };
+export { clearFileExistsCache, isTypeOnlyFile, parseImports, stripComments };
 //# sourceMappingURL=parse-imports.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-imports.mjs","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/parse-imports.ts"],"sourcesContent":["import { fileExistsAsync, directoryExistsAsync } from \"@warlock.js/fs\";\nimport { type ImportSpecifier, parse } from \"es-module-lexer\";\nimport path from \"node:path\";\nimport ts from \"typescript\";\nimport { Path } from \"../utils/normalized-path\";\nimport { tsconfigManager } from \"./tsconfig-manager\";\n\n/**\n * Detect if a file contains only type definitions (no runtime code)\n *\n * A file is considered type-only if ALL its exports are:\n * - interface declarations\n * - type alias declarations\n * - export type { ... } statements\n * - export type { ... } from \"...\" statements\n *\n * Files with any of these are NOT type-only:\n * - export const/let/var\n * - export function\n * - export class\n * - export default (non-type)\n * - export { ... } (without type keyword)\n * - export * from (without type keyword)\n *\n * @param source - The source code to analyze\n * @returns true if the file exports only types\n */\nexport function isTypeOnlyFile(source: string): boolean {\n  // Remove comments to avoid false positives\n  const withoutComments = source\n    .replace(/\\/\\*[\\s\\S]*?\\*\\//g, \"\") // block comments\n    .replace(/\\/\\/.*$/gm, \"\"); // line comments\n\n  // Remove string literals to avoid false positives\n  const withoutStrings = withoutComments\n    .replace(/'(?:[^'\\\\]|\\\\.)*'/g, \"''\")\n    .replace(/\"(?:[^\"\\\\]|\\\\.)*\"/g, '\"\"')\n    .replace(/`(?:[^`\\\\]|\\\\.)*`/g, \"``\");\n\n  // Patterns for type-only exports (these are safe)\n  const typeOnlyPatterns = [\n    /export\\s+type\\s+\\{[^}]*\\}/g, // export type { Foo, Bar }\n    /export\\s+type\\s+\\{[^}]*\\}\\s+from\\s+['\"]/g, // export type { Foo } from \"...\"\n    /export\\s+interface\\s+\\w+/g, // export interface Foo\n    /export\\s+type\\s+\\w+\\s*=/g, // export type Foo =\n  ];\n\n  // Remove all type-only exports from consideration\n  let remaining = withoutStrings;\n  for (const pattern of typeOnlyPatterns) {\n    remaining = remaining.replace(pattern, \"\");\n  }\n\n  // Patterns for runtime exports (these make the file NOT type-only)\n  const runtimeExportPatterns = [\n    /export\\s+(?:const|let|var)\\s+\\w+/g, // export const/let/var foo\n    /export\\s+function\\s+\\w+/g, // export function foo\n    /export\\s+async\\s+function\\s+\\w+/g, // export async function foo\n    /export\\s+class\\s+\\w+/g, // export class Foo\n    /export\\s+enum\\s+\\w+/g, // export enum Foo (enums have runtime value)\n    /export\\s+default\\s+(?!type\\s)/g, // export default (not type)\n    /export\\s+\\{[^}]*\\}(?!\\s+from)/g, // export { foo } (local re-export without type)\n    /export\\s+\\{[^}]*\\}\\s+from\\s+['\"][^'\"]+['\"]/g, // export { foo } from (without type)\n    /export\\s+\\*\\s+from\\s+['\"][^'\"]+['\"]/g, // export * from (re-exports everything)\n    /export\\s+\\*\\s+as\\s+\\w+/g, // export * as namespace\n  ];\n\n  for (const pattern of runtimeExportPatterns) {\n    if (pattern.test(remaining)) {\n      // Reset regex lastIndex for subsequent tests\n      pattern.lastIndex = 0;\n\n      // Special case: check if export { } contains only type exports\n      if (pattern.source.includes(\"export\\\\s+\\\\{\")) {\n        const matches = remaining.match(/export\\s+\\{([^}]*)\\}(?:\\s+from\\s+['\"][^'\"]+['\"])?/g);\n        if (matches) {\n          for (const match of matches) {\n            // Skip if it's already a type export\n            if (/^export\\s+type\\s+/.test(match)) continue;\n\n            // Extract the specifiers\n            const specifiersMatch = match.match(/export\\s+\\{([^}]*)\\}/);\n            if (specifiersMatch) {\n              // Capture group 1 exists whenever the pattern matched. `?? \"\"`\n              // yields an empty specifier list, which `some()` below reads as\n              // \"no runtime specifier\" — the same answer an empty `{}` gives.\n              const specifiers = specifiersMatch[1] ?? \"\";\n              const items = specifiers\n                .split(\",\")\n                .map((s) => s.trim())\n                .filter(Boolean);\n\n              // If any specifier is NOT prefixed with \"type \", this is a runtime export\n              const hasRuntimeSpecifier = items.some((item) => !item.startsWith(\"type \"));\n              if (hasRuntimeSpecifier) {\n                return false;\n              }\n            }\n          }\n        }\n        continue;\n      }\n\n      return false;\n    }\n  }\n\n  // If we get here, no runtime exports were found\n  // But we should also verify the file has at least some type exports\n  // (an empty file or file with only imports is not really \"type-only\")\n  const hasTypeExports = typeOnlyPatterns.some((pattern) => {\n    pattern.lastIndex = 0;\n    return pattern.test(withoutStrings);\n  });\n\n  return hasTypeExports;\n}\n\n/**\n * Check if an import statement is a pure `import type` (the keyword sits\n * immediately after `import`, covering `import type { X }`, `import type Foo`,\n * and `import type * as Ns`).\n */\nfunction isTypeOnlyImport(line: string): boolean {\n  const trimmed = line.trim();\n\n  return trimmed.startsWith(\"import type \") || !!trimmed.match(/^import\\s+type\\s+[{*]/);\n}\n\n/**\n * Decide whether an `import ... from \"m\"` statement contributes any runtime\n * binding. Returns false for pure `import type` and for destructured imports\n * where every specifier is prefixed with the `type` keyword.\n */\nfunction hasRuntimeImports(line: string): boolean {\n  const trimmed = line.trim();\n\n  if (isTypeOnlyImport(trimmed)) {\n    return false;\n  }\n\n  const specifiersMatch = trimmed.match(/import\\s+(?:type\\s+)?\\{([^}]+)\\}/);\n\n  if (!specifiersMatch) {\n    return true;\n  }\n\n  const items = (specifiersMatch[1] ?? \"\")\n    .split(\",\")\n    .map((s) => s.trim())\n    .filter(Boolean);\n\n  return !items.every((item) => /^type\\s+\\w+/.test(item));\n}\n\n/**\n * Decide whether an `export ... from \"m\"` statement re-exports only types.\n * Covers `export type { X } from`, `export type * from`, and\n * `export { type X, type Y } from`.\n */\nfunction isExportTypeOnlyStatement(line: string): boolean {\n  const trimmed = line.trim();\n\n  if (/^export\\s+type\\s+/.test(trimmed)) {\n    return true;\n  }\n\n  const specifiersMatch = trimmed.match(/export\\s+\\{([^}]+)\\}/);\n\n  if (!specifiersMatch) {\n    return false;\n  }\n\n  const items = (specifiersMatch[1] ?? \"\")\n    .split(\",\")\n    .map((s) => s.trim())\n    .filter(Boolean);\n\n  return items.every((item) => /^type\\s+\\w+/.test(item));\n}\n\n/**\n * Extract import paths using regex (more reliable for TypeScript).\n * Each entry carries an `isTypeOnly` flag: true when every occurrence of the\n * path in the source is a type-only statement (no runtime binding).\n * A single runtime occurrence makes the path runtime.\n */\nfunction extractImportPathsWithRegex(\n  source: string,\n): Array<{ path: string; originalLine: string; isTypeOnly: boolean }> {\n  const imports: Array<{ path: string; originalLine: string; isTypeOnly: boolean }> = [];\n  const seenPaths = new Map<string, number>();\n\n  /**\n   * Record an import path with its type-only flag.\n   * If the same path appears in multiple statements, the edge is type-only\n   * iff every occurrence is type-only — a single runtime statement makes it runtime.\n   */\n  const record = (importPath: string, originalLine: string, isTypeOnly: boolean): void => {\n    if (!importPath) {\n      return;\n    }\n\n    const existingIndex = seenPaths.get(importPath);\n\n    if (existingIndex === undefined) {\n      seenPaths.set(importPath, imports.length);\n      imports.push({ path: importPath, originalLine, isTypeOnly });\n\n      return;\n    }\n\n    if (!isTypeOnly) {\n      const existing = imports[existingIndex];\n\n      // `existingIndex` came from findIndex on this same array, so it is in\n      // range; the compiler does not carry that here.\n      if (existing) existing.isTypeOnly = false;\n    }\n  };\n\n  // Pattern 1: Standard ES module imports (handles multiline)\n  // Matches: import { ... } from \"path\", import Foo from \"path\", import Foo, { ... } from \"path\"\n  const importRegex =\n    /import\\s+(?:type\\s+)?(\\{[\\s\\S]*?\\}|\\*\\s+as\\s+\\w+|\\w+(?:\\s*,\\s*\\{[\\s\\S]*?\\})?)\\s+from\\s+['\"]([^'\"]+)['\"]/g;\n\n  let match;\n\n  while ((match = importRegex.exec(source)) !== null) {\n    const fullMatch = match[0];\n    const importPath = match[2];\n\n    // Each pattern here captures its path in a group, so a match always carries\n    // one. Skipping rather than recording keeps a malformed match out of the\n    // dependency graph entirely — recording `undefined` would add an import\n    // edge to a module named \"undefined\", which the dev server would then\n    // watch, fail to resolve, and report against the wrong file.\n    if (importPath === undefined) continue;\n\n    const isTypeOnly = !hasRuntimeImports(fullMatch);\n\n    record(importPath, fullMatch, isTypeOnly);\n  }\n\n  // Pattern 1b: Side-effect imports - import \"path\" — always runtime\n  const sideEffectRegex = /import\\s+['\"]([^'\"]+)['\"]/g;\n\n  while ((match = sideEffectRegex.exec(source)) !== null) {\n    const sideEffectPath = match[1];\n\n    if (sideEffectPath === undefined) continue;\n\n    record(sideEffectPath, match[0], false);\n  }\n\n  // Pattern 2: Dynamic imports - import(\"path\") — always runtime\n  const dynamicImportPattern = /import\\s*\\(\\s*['\"]([^'\"]+)['\"]\\s*\\)/g;\n\n  while ((match = dynamicImportPattern.exec(source)) !== null) {\n    const dynamicPath = match[1];\n\n    if (dynamicPath === undefined) continue;\n\n    record(dynamicPath, match[0], false);\n  }\n\n  // Pattern 3: Export from - export ... from \"path\"\n  // A pure `export type { A } from` / `export type * from` re-export is matched\n  // and then skipped: it is erased at compile time, so it is no dependency\n  // edge. That keeps this fallback in line with the lexer path, which never\n  // reports the form, so the graph no longer depends on which path ran.\n  // `export { type A } from` (reported by the lexer) stays a type-only edge.\n  const exportFromPattern =\n    /export\\s+(?:type\\s+)?(?:\\{[^}]*\\}|\\*(?:\\s+as\\s+\\w+)?|\\w+)\\s+from\\s+['\"]([^'\"]+)['\"]/g;\n\n  while ((match = exportFromPattern.exec(source)) !== null) {\n    const fullMatch = match[0];\n    const exportPath = match[1];\n\n    if (exportPath === undefined) continue;\n\n    if (/^export\\s+type\\s/.test(fullMatch)) continue;\n\n    record(exportPath, fullMatch, isExportTypeOnlyStatement(fullMatch));\n  }\n\n  return imports;\n}\n\n/**\n * Metadata for a single resolved import edge.\n * `isTypeOnly` is true iff every import/export statement that references this\n * path is type-only (pure `import type`, `export type`, or destructured lists\n * where every specifier carries the `type` keyword). A single runtime\n * occurrence flips the flag to false — that's what matters for cycle detection.\n */\nexport type ResolvedImport = {\n  absolutePath: string;\n  isTypeOnly: boolean;\n};\n\n/**\n * Parse import/export statements in a TS/JS source file and return the\n * resolved dependency edges keyed by the original import path. Includes\n * type-only edges (flagged) so downstream consumers can distinguish runtime\n * cycles from type-only ones.\n *\n * @example\n * const importMap = await parseImports(source, \"/abs/path/to/file.ts\");\n * for (const [importPath, { absolutePath, isTypeOnly }] of importMap) {\n *   // ...\n * }\n */\nexport async function parseImports(\n  source: string,\n  filePath: string,\n): Promise<Map<string, ResolvedImport>> {\n  try {\n    // Skip .d.ts files - they're type declarations, not runtime code\n    if (filePath.endsWith(\".d.ts\")) {\n      return new Map();\n    }\n\n    // es-module-lexer first: it reads the real statements and skips comments.\n    try {\n      const [imports] = await parse(source);\n\n      if (imports && imports.length > 0) {\n        return await resolveImports(imports as ImportSpecifier[], source, filePath);\n      }\n    } catch {\n      // The lexer rejects some TypeScript syntax; the regex below covers it.\n    }\n\n    // Fallback: regex extraction, for files the lexer rejects and for files\n    // where it finds nothing (it does not report `export type { A } from`).\n    // It runs over the source without comments: scanning them turned a doc\n    // comment such as `(await import(\"./query-testing\"))` in a file with no\n    // imports into a self edge and a false \"circular dependency\".\n    const regexImports = extractImportPathsWithRegex(stripComments(source, filePath));\n    const resolvedImports = new Map<string, ResolvedImport>();\n\n    for (const { path: importPath, isTypeOnly } of regexImports) {\n      if (isNodeBuiltin(importPath)) {\n        continue;\n      }\n\n      if (!importPath.startsWith(\".\") && !tsconfigManager.isAlias(importPath)) {\n        continue;\n      }\n\n      let resolvedPath: string | null = null;\n\n      if (tsconfigManager.isAlias(importPath)) {\n        resolvedPath = await resolveAliasImport(importPath);\n      } else if (importPath.startsWith(\".\")) {\n        resolvedPath = await resolveRelativeImport(importPath, filePath);\n      }\n\n      if (resolvedPath && !isSameFile(resolvedPath, filePath)) {\n        mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);\n      }\n    }\n\n    return resolvedImports;\n  } catch (error) {\n    console.error(`Error parsing imports for ${filePath}:`, error);\n\n    return new Map();\n  }\n}\n\n/** True when both paths name the same file (case-insensitively on Windows). */\nfunction isSameFile(first: string, second: string): boolean {\n  const normalize = (filePath: string) => {\n    const resolved = Path.normalize(path.resolve(filePath));\n    return process.platform === \"win32\" ? resolved.toLowerCase() : resolved;\n  };\n\n  return normalize(first) === normalize(second);\n}\n\n/**\n * Remove `//` and `/* *\\/` comments, keeping every newline in place (so\n * line-based matches keep their lines). Only the regex fallback needs it; the\n * lexer already skips comments.\n *\n * Comment ranges come from a real TypeScript parse, never from scanning\n * characters: only the parser can tell a regex literal (`/\\/*$/`), a template\n * literal or JSX text (`<p>// not a comment</p>`) from a comment. A character\n * scanner read the `/*` in `p.replace(/\\/*$/, \"\")` as a block comment and\n * erased every import after it.\n *\n * `filePath` picks the dialect (`.tsx`/`.jsx` parse JSX); without it the\n * source is parsed as TSX.\n */\nexport function stripComments(source: string, filePath = \"source.tsx\"): string {\n  const sourceFile = ts.createSourceFile(\n    filePath,\n    source,\n    ts.ScriptTarget.Latest,\n    false,\n    scriptKindFor(filePath),\n  );\n  const ranges: ts.CommentRange[] = [];\n  const seen = new Set<number>();\n\n  const collect = (node: ts.Node): void => {\n    // A JSDoc node is itself a comment, already reported as trivia of the\n    // token that follows it; its inner tokens are not code.\n    if (node.kind >= ts.SyntaxKind.FirstJSDocNode && node.kind <= ts.SyntaxKind.LastJSDocNode) {\n      return;\n    }\n\n    const children = node.getChildren(sourceFile);\n\n    if (children.length > 0) {\n      for (const child of children) collect(child);\n\n      return;\n    }\n\n    // JSX text has no trivia: its content starts at `pos` and may contain `//`.\n    if (node.kind === ts.SyntaxKind.JsxText || node.kind === ts.SyntaxKind.JsxTextAllWhiteSpaces) {\n      return;\n    }\n\n    const tokenStart = node.getStart(sourceFile);\n\n    // Trivia before a token holds trailing comments of the previous line\n    // (`a; // x`) and leading comments of this one; collect both.\n    const trivia = [\n      ...(ts.getTrailingCommentRanges(source, node.pos) ?? []),\n      ...(ts.getLeadingCommentRanges(source, node.pos) ?? []),\n    ];\n\n    for (const range of trivia) {\n      if (range.end <= tokenStart && !seen.has(range.pos)) {\n        seen.add(range.pos);\n        ranges.push(range);\n      }\n    }\n  };\n\n  collect(sourceFile);\n  ranges.sort((first, second) => first.pos - second.pos);\n\n  let output = \"\";\n  let cursor = 0;\n\n  for (const range of ranges) {\n    output += source.slice(cursor, range.pos);\n    output += source.slice(range.pos, range.end).replace(/[^\\n]/g, \"\");\n    cursor = range.end;\n  }\n\n  return output + source.slice(cursor);\n}\n\n/** The parse dialect for a file: JSX only where the extension allows it. */\nfunction scriptKindFor(filePath: string): ts.ScriptKind {\n  const extension = path.extname(filePath).toLowerCase();\n\n  switch (extension) {\n    case \".ts\":\n    case \".mts\":\n    case \".cts\":\n      return ts.ScriptKind.TS;\n    case \".js\":\n    case \".mjs\":\n    case \".cjs\":\n      return ts.ScriptKind.JS;\n    case \".jsx\":\n      return ts.ScriptKind.JSX;\n    default:\n      return ts.ScriptKind.TSX;\n  }\n}\n\n/**\n * Merge a resolved import into the output map, preserving the type-only rule:\n * a path is type-only iff every statement that references it is type-only.\n */\nfunction mergeResolvedImport(\n  target: Map<string, ResolvedImport>,\n  importPath: string,\n  absolutePath: string,\n  isTypeOnly: boolean,\n): void {\n  const existing = target.get(importPath);\n\n  if (!existing) {\n    target.set(importPath, { absolutePath, isTypeOnly });\n\n    return;\n  }\n\n  if (!isTypeOnly) {\n    existing.isTypeOnly = false;\n  }\n}\n\n/**\n * Resolve imports from `es-module-lexer` output. For each specifier, slice the\n * raw statement (`ss..se`) and re-run the type-only heuristic so we can flag\n * the edge correctly — the lexer itself does not distinguish `import type`.\n */\nasync function resolveImports(\n  imports: ImportSpecifier[],\n  source: string,\n  filePath: string,\n): Promise<Map<string, ResolvedImport>> {\n  const resolvedImports = new Map<string, ResolvedImport>();\n\n  for (const imp of imports) {\n    const importPath = imp.n;\n\n    if (!importPath) {\n      continue;\n    }\n\n    if (isNodeBuiltin(importPath)) {\n      continue;\n    }\n\n    if (!importPath.startsWith(\".\") && !tsconfigManager.isAlias(importPath)) {\n      continue;\n    }\n\n    let resolvedPath: string | null = null;\n\n    if (tsconfigManager.isAlias(importPath)) {\n      resolvedPath = await resolveAliasImport(importPath);\n    } else if (importPath.startsWith(\".\")) {\n      resolvedPath = await resolveRelativeImport(importPath, filePath);\n    }\n\n    // A file importing itself is no dependency edge, and as one it reads as\n    // a one-file \"cycle\".\n    if (!resolvedPath || isSameFile(resolvedPath, filePath)) {\n      continue;\n    }\n\n    const isTypeOnly = isLexerStatementTypeOnly(imp, source);\n\n    mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);\n  }\n\n  return resolvedImports;\n}\n\n/**\n * Classify a single lexer-reported statement as type-only or runtime.\n * Dynamic imports (`import(...)`) are always runtime. For static\n * imports/export-from we slice the raw source and apply the same heuristic\n * the regex fallback uses.\n */\nfunction isLexerStatementTypeOnly(imp: ImportSpecifier, source: string): boolean {\n  // Dynamic imports always execute — they cannot be type-only.\n  // es-module-lexer reports dynamic with a.n === undefined typically, but\n  // we guard by checking the statement prefix too.\n  const statementStart = imp.ss;\n  const statementEnd = imp.se;\n\n  if (\n    typeof statementStart !== \"number\" ||\n    typeof statementEnd !== \"number\" ||\n    statementEnd <= statementStart\n  ) {\n    return false;\n  }\n\n  const statement = source.slice(statementStart, statementEnd);\n  const trimmed = statement.trim();\n\n  if (trimmed.startsWith(\"import(\") || /^\\bimport\\s*\\(/.test(trimmed)) {\n    return false;\n  }\n\n  if (trimmed.startsWith(\"export\")) {\n    return isExportTypeOnlyStatement(statement);\n  }\n\n  return !hasRuntimeImports(statement);\n}\n\n/**\n * Resolve alias imports to actual file paths with extensions\n * Example: app/users/services/get-users.service -> /absolute/path/to/src/app/users/services/get-users.service.ts\n */\nasync function resolveAliasImport(importPath: string): Promise<string | null> {\n  // Use tsconfig manager to resolve the alias to an absolute path\n  const resolvedBase = tsconfigManager.resolveAliasToAbsolute(importPath);\n\n  if (!resolvedBase) return null;\n\n  // Try to resolve with extensions\n  const resolvedPath = await tryResolveWithExtensions(resolvedBase);\n\n  return resolvedPath;\n}\n\n/**\n * Resolve relative imports to actual file paths\n * Example: ./../services/get-user.service -> /absolute/path/to/services/get-user.service.ts\n */\nasync function resolveRelativeImport(\n  importPath: string,\n  currentFilePath: string,\n): Promise<string | null> {\n  const dir = path.dirname(currentFilePath);\n  // Use path.resolve to handle .. and . properly, then normalize to forward slashes\n  const resolvedBase = Path.normalize(path.resolve(dir, importPath));\n\n  // Try to resolve with extensions\n  const resolvedPath = await tryResolveWithExtensions(resolvedBase);\n\n  return resolvedPath;\n}\n\n/**\n * Try to resolve a file path by checking different extensions\n * TypeScript/JavaScript files can be imported without extensions\n *\n * @TODO: For better performance, we need to check the files in files orchestrator\n * instead of using the file system as we will be fetching all project files anyway.\n */\n// Cache for file existence checks to avoid redundant filesystem calls\nconst fileExistsCache = new Map<string, boolean>();\n\n/**\n * Clear the file exists cache\n * Should be called when new files are created to ensure fresh lookups\n */\nexport function clearFileExistsCache(): void {\n  fileExistsCache.clear();\n}\n\nasync function cachedFileExists(filePath: string): Promise<boolean> {\n  if (fileExistsCache.has(filePath)) {\n    return fileExistsCache.get(filePath)!;\n  }\n  const exists = (await fileExistsAsync(filePath)) as boolean;\n\n  // Cache ONLY positive results. A negative (\"does not exist\") answer is the\n  // exact case that flips moments later: the \"add a new controller/route\" flow\n  // references a file, then creates it. Caching that negative for the whole\n  // process lifetime (it was cleared only on a multi-file watcher batch) left\n  // a routes.ts import unresolvable after its target was created — the dep\n  // edge never formed and the route module import failed, so the new API route\n  // 404'd until an unrelated multi-file batch cleared the cache. That is\n  // finding 60721e35 (\"backend route HMR needs a second edit\"). A file that\n  // exists does not stop existing mid-resolve, so caching the hit is safe;\n  // re-probing a still-missing path costs only a handful of stat calls.\n  if (exists) {\n    fileExistsCache.set(filePath, exists);\n  }\n\n  return exists;\n}\n\nasync function tryResolveWithExtensions(basePath: string): Promise<string | null> {\n  // Normalize the base path first (handle Windows paths)\n  const normalizedBase = Path.normalize(basePath);\n\n  // List of extensions to try, in order of preference\n  const extensions = [\".ts\", \".tsx\", \".js\", \".jsx\", \".mjs\", \".cjs\"];\n  const validExtensions = new Set(extensions);\n\n  // If the path already has a VALID code file extension, check if it exists\n  const ext = path.extname(normalizedBase);\n  if (ext && validExtensions.has(ext)) {\n    // NodeNext style: `./x.js` is written, `x.ts`/`x.tsx` is on disk. The\n    // loader rewrites it the same way (own-resolver `probeFile`), and a\n    // co-located source wins over the literal .js.\n    if ([\".js\", \".jsx\", \".mjs\", \".cjs\"].includes(ext)) {\n      const stem = normalizedBase.slice(0, -ext.length);\n      for (const sourceExt of [\".ts\", \".tsx\"]) {\n        if (await cachedFileExists(stem + sourceExt)) {\n          return stem + sourceExt;\n        }\n      }\n    }\n    if (await cachedFileExists(normalizedBase)) {\n      return normalizedBase;\n    }\n    // If explicit extension doesn't exist, return null\n    return null;\n  }\n\n  // Try all extensions in parallel for better performance\n  const pathsToCheck = extensions.map((extension) => normalizedBase + extension);\n  const results = await Promise.all(\n    pathsToCheck.map(async (p) => ({ path: p, exists: await cachedFileExists(p) })),\n  );\n\n  // Return the first one that exists (in order of preference)\n  for (const result of results) {\n    if (result.exists) {\n      return result.path;\n    }\n  }\n\n  // Try index files in directory\n  if (await directoryExistsAsync(normalizedBase)) {\n    const indexPaths = extensions.map((extension) =>\n      Path.join(normalizedBase, `index${extension}`),\n    );\n    const indexResults = await Promise.all(\n      indexPaths.map(async (p) => ({ path: p, exists: await cachedFileExists(p) })),\n    );\n\n    for (const result of indexResults) {\n      if (result.exists) {\n        return result.path;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Check if import is a Node.js built-in module\n */\nfunction isNodeBuiltin(importPath: string): boolean {\n  const builtins = [\n    \"fs\",\n    \"path\",\n    \"http\",\n    \"https\",\n    \"crypto\",\n    \"stream\",\n    \"util\",\n    \"events\",\n    \"buffer\",\n    \"child_process\",\n    \"os\",\n    \"url\",\n    \"querystring\",\n    \"zlib\",\n    \"net\",\n    \"tls\",\n    \"dns\",\n    \"dgram\",\n    \"cluster\",\n    \"worker_threads\",\n    \"perf_hooks\",\n    \"async_hooks\",\n    \"timers\",\n    \"readline\",\n    \"repl\",\n    \"vm\",\n    \"assert\",\n    \"console\",\n    \"process\",\n    \"v8\",\n  ];\n\n  // Check for node: prefix or direct builtin name\n  if (importPath.startsWith(\"node:\")) return true;\n\n  // `split` always yields a first element. Falling back to the whole path\n  // keeps the builtin check answering about a real name rather than undefined.\n  const moduleName = importPath.split(\"/\")[0] ?? importPath;\n\n  return builtins.includes(moduleName);\n}\n"],"mappings":"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"}
+{"version":3,"file":"parse-imports.mjs","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/parse-imports.ts"],"sourcesContent":["import { fileExistsAsync, directoryExistsAsync } from \"@warlock.js/fs\";\nimport { type ImportSpecifier, parse } from \"es-module-lexer\";\nimport path from \"node:path\";\nimport { parseSync } from \"oxc-parser\";\nimport { Path } from \"../utils/normalized-path\";\nimport { tsconfigManager } from \"./tsconfig-manager\";\n\n/**\n * Detect if a file contains only type definitions (no runtime code)\n *\n * A file is considered type-only if ALL its exports are:\n * - interface declarations\n * - type alias declarations\n * - export type { ... } statements\n * - export type { ... } from \"...\" statements\n *\n * Files with any of these are NOT type-only:\n * - export const/let/var\n * - export function\n * - export class\n * - export default (non-type)\n * - export { ... } (without type keyword)\n * - export * from (without type keyword)\n *\n * @param source - The source code to analyze\n * @returns true if the file exports only types\n */\nexport function isTypeOnlyFile(source: string): boolean {\n  // Remove comments to avoid false positives\n  const withoutComments = source\n    .replace(/\\/\\*[\\s\\S]*?\\*\\//g, \"\") // block comments\n    .replace(/\\/\\/.*$/gm, \"\"); // line comments\n\n  // Remove string literals to avoid false positives\n  const withoutStrings = withoutComments\n    .replace(/'(?:[^'\\\\]|\\\\.)*'/g, \"''\")\n    .replace(/\"(?:[^\"\\\\]|\\\\.)*\"/g, '\"\"')\n    .replace(/`(?:[^`\\\\]|\\\\.)*`/g, \"``\");\n\n  // Patterns for type-only exports (these are safe)\n  const typeOnlyPatterns = [\n    /export\\s+type\\s+\\{[^}]*\\}/g, // export type { Foo, Bar }\n    /export\\s+type\\s+\\{[^}]*\\}\\s+from\\s+['\"]/g, // export type { Foo } from \"...\"\n    /export\\s+interface\\s+\\w+/g, // export interface Foo\n    /export\\s+type\\s+\\w+\\s*=/g, // export type Foo =\n  ];\n\n  // Remove all type-only exports from consideration\n  let remaining = withoutStrings;\n  for (const pattern of typeOnlyPatterns) {\n    remaining = remaining.replace(pattern, \"\");\n  }\n\n  // Patterns for runtime exports (these make the file NOT type-only)\n  const runtimeExportPatterns = [\n    /export\\s+(?:const|let|var)\\s+\\w+/g, // export const/let/var foo\n    /export\\s+function\\s+\\w+/g, // export function foo\n    /export\\s+async\\s+function\\s+\\w+/g, // export async function foo\n    /export\\s+class\\s+\\w+/g, // export class Foo\n    /export\\s+enum\\s+\\w+/g, // export enum Foo (enums have runtime value)\n    /export\\s+default\\s+(?!type\\s)/g, // export default (not type)\n    /export\\s+\\{[^}]*\\}(?!\\s+from)/g, // export { foo } (local re-export without type)\n    /export\\s+\\{[^}]*\\}\\s+from\\s+['\"][^'\"]+['\"]/g, // export { foo } from (without type)\n    /export\\s+\\*\\s+from\\s+['\"][^'\"]+['\"]/g, // export * from (re-exports everything)\n    /export\\s+\\*\\s+as\\s+\\w+/g, // export * as namespace\n  ];\n\n  for (const pattern of runtimeExportPatterns) {\n    if (pattern.test(remaining)) {\n      // Reset regex lastIndex for subsequent tests\n      pattern.lastIndex = 0;\n\n      // Special case: check if export { } contains only type exports\n      if (pattern.source.includes(\"export\\\\s+\\\\{\")) {\n        const matches = remaining.match(/export\\s+\\{([^}]*)\\}(?:\\s+from\\s+['\"][^'\"]+['\"])?/g);\n        if (matches) {\n          for (const match of matches) {\n            // Skip if it's already a type export\n            if (/^export\\s+type\\s+/.test(match)) continue;\n\n            // Extract the specifiers\n            const specifiersMatch = match.match(/export\\s+\\{([^}]*)\\}/);\n            if (specifiersMatch) {\n              // Capture group 1 exists whenever the pattern matched. `?? \"\"`\n              // yields an empty specifier list, which `some()` below reads as\n              // \"no runtime specifier\" — the same answer an empty `{}` gives.\n              const specifiers = specifiersMatch[1] ?? \"\";\n              const items = specifiers\n                .split(\",\")\n                .map((s) => s.trim())\n                .filter(Boolean);\n\n              // If any specifier is NOT prefixed with \"type \", this is a runtime export\n              const hasRuntimeSpecifier = items.some((item) => !item.startsWith(\"type \"));\n              if (hasRuntimeSpecifier) {\n                return false;\n              }\n            }\n          }\n        }\n        continue;\n      }\n\n      return false;\n    }\n  }\n\n  // If we get here, no runtime exports were found\n  // But we should also verify the file has at least some type exports\n  // (an empty file or file with only imports is not really \"type-only\")\n  const hasTypeExports = typeOnlyPatterns.some((pattern) => {\n    pattern.lastIndex = 0;\n    return pattern.test(withoutStrings);\n  });\n\n  return hasTypeExports;\n}\n\n/**\n * Check if an import statement is a pure `import type` (the keyword sits\n * immediately after `import`, covering `import type { X }`, `import type Foo`,\n * and `import type * as Ns`).\n */\nfunction isTypeOnlyImport(line: string): boolean {\n  const trimmed = line.trim();\n\n  return trimmed.startsWith(\"import type \") || !!trimmed.match(/^import\\s+type\\s+[{*]/);\n}\n\n/**\n * Decide whether an `import ... from \"m\"` statement contributes any runtime\n * binding. Returns false for pure `import type` and for destructured imports\n * where every specifier is prefixed with the `type` keyword.\n */\nfunction hasRuntimeImports(line: string): boolean {\n  const trimmed = line.trim();\n\n  if (isTypeOnlyImport(trimmed)) {\n    return false;\n  }\n\n  const specifiersMatch = trimmed.match(/import\\s+(?:type\\s+)?\\{([^}]+)\\}/);\n\n  if (!specifiersMatch) {\n    return true;\n  }\n\n  const items = (specifiersMatch[1] ?? \"\")\n    .split(\",\")\n    .map((s) => s.trim())\n    .filter(Boolean);\n\n  return !items.every((item) => /^type\\s+\\w+/.test(item));\n}\n\n/**\n * Decide whether an `export ... from \"m\"` statement re-exports only types.\n * Covers `export type { X } from`, `export type * from`, and\n * `export { type X, type Y } from`.\n */\nfunction isExportTypeOnlyStatement(line: string): boolean {\n  const trimmed = line.trim();\n\n  if (/^export\\s+type\\s+/.test(trimmed)) {\n    return true;\n  }\n\n  const specifiersMatch = trimmed.match(/export\\s+\\{([^}]+)\\}/);\n\n  if (!specifiersMatch) {\n    return false;\n  }\n\n  const items = (specifiersMatch[1] ?? \"\")\n    .split(\",\")\n    .map((s) => s.trim())\n    .filter(Boolean);\n\n  return items.every((item) => /^type\\s+\\w+/.test(item));\n}\n\n/**\n * Extract import paths using regex (more reliable for TypeScript).\n * Each entry carries an `isTypeOnly` flag: true when every occurrence of the\n * path in the source is a type-only statement (no runtime binding).\n * A single runtime occurrence makes the path runtime.\n */\nfunction extractImportPathsWithRegex(\n  source: string,\n): Array<{ path: string; originalLine: string; isTypeOnly: boolean }> {\n  const imports: Array<{ path: string; originalLine: string; isTypeOnly: boolean }> = [];\n  const seenPaths = new Map<string, number>();\n\n  /**\n   * Record an import path with its type-only flag.\n   * If the same path appears in multiple statements, the edge is type-only\n   * iff every occurrence is type-only — a single runtime statement makes it runtime.\n   */\n  const record = (importPath: string, originalLine: string, isTypeOnly: boolean): void => {\n    if (!importPath) {\n      return;\n    }\n\n    const existingIndex = seenPaths.get(importPath);\n\n    if (existingIndex === undefined) {\n      seenPaths.set(importPath, imports.length);\n      imports.push({ path: importPath, originalLine, isTypeOnly });\n\n      return;\n    }\n\n    if (!isTypeOnly) {\n      const existing = imports[existingIndex];\n\n      // `existingIndex` came from findIndex on this same array, so it is in\n      // range; the compiler does not carry that here.\n      if (existing) existing.isTypeOnly = false;\n    }\n  };\n\n  // Pattern 1: Standard ES module imports (handles multiline)\n  // Matches: import { ... } from \"path\", import Foo from \"path\", import Foo, { ... } from \"path\"\n  const importRegex =\n    /import\\s+(?:type\\s+)?(\\{[\\s\\S]*?\\}|\\*\\s+as\\s+\\w+|\\w+(?:\\s*,\\s*\\{[\\s\\S]*?\\})?)\\s+from\\s+['\"]([^'\"]+)['\"]/g;\n\n  let match;\n\n  while ((match = importRegex.exec(source)) !== null) {\n    const fullMatch = match[0];\n    const importPath = match[2];\n\n    // Each pattern here captures its path in a group, so a match always carries\n    // one. Skipping rather than recording keeps a malformed match out of the\n    // dependency graph entirely — recording `undefined` would add an import\n    // edge to a module named \"undefined\", which the dev server would then\n    // watch, fail to resolve, and report against the wrong file.\n    if (importPath === undefined) continue;\n\n    const isTypeOnly = !hasRuntimeImports(fullMatch);\n\n    record(importPath, fullMatch, isTypeOnly);\n  }\n\n  // Pattern 1b: Side-effect imports - import \"path\" — always runtime\n  const sideEffectRegex = /import\\s+['\"]([^'\"]+)['\"]/g;\n\n  while ((match = sideEffectRegex.exec(source)) !== null) {\n    const sideEffectPath = match[1];\n\n    if (sideEffectPath === undefined) continue;\n\n    record(sideEffectPath, match[0], false);\n  }\n\n  // Pattern 2: Dynamic imports - import(\"path\") — always runtime\n  const dynamicImportPattern = /import\\s*\\(\\s*['\"]([^'\"]+)['\"]\\s*\\)/g;\n\n  while ((match = dynamicImportPattern.exec(source)) !== null) {\n    const dynamicPath = match[1];\n\n    if (dynamicPath === undefined) continue;\n\n    record(dynamicPath, match[0], false);\n  }\n\n  // Pattern 3: Export from - export ... from \"path\"\n  // A pure `export type { A } from` / `export type * from` re-export is matched\n  // and then skipped: it is erased at compile time, so it is no dependency\n  // edge. That keeps this fallback in line with the lexer path, which never\n  // reports the form, so the graph no longer depends on which path ran.\n  // `export { type A } from` (reported by the lexer) stays a type-only edge.\n  const exportFromPattern =\n    /export\\s+(?:type\\s+)?(?:\\{[^}]*\\}|\\*(?:\\s+as\\s+\\w+)?|\\w+)\\s+from\\s+['\"]([^'\"]+)['\"]/g;\n\n  while ((match = exportFromPattern.exec(source)) !== null) {\n    const fullMatch = match[0];\n    const exportPath = match[1];\n\n    if (exportPath === undefined) continue;\n\n    if (/^export\\s+type\\s/.test(fullMatch)) continue;\n\n    record(exportPath, fullMatch, isExportTypeOnlyStatement(fullMatch));\n  }\n\n  return imports;\n}\n\n/**\n * Metadata for a single resolved import edge.\n * `isTypeOnly` is true iff every import/export statement that references this\n * path is type-only (pure `import type`, `export type`, or destructured lists\n * where every specifier carries the `type` keyword). A single runtime\n * occurrence flips the flag to false — that's what matters for cycle detection.\n */\nexport type ResolvedImport = {\n  absolutePath: string;\n  isTypeOnly: boolean;\n};\n\n/**\n * Parse import/export statements in a TS/JS source file and return the\n * resolved dependency edges keyed by the original import path. Includes\n * type-only edges (flagged) so downstream consumers can distinguish runtime\n * cycles from type-only ones.\n *\n * @example\n * const importMap = await parseImports(source, \"/abs/path/to/file.ts\");\n * for (const [importPath, { absolutePath, isTypeOnly }] of importMap) {\n *   // ...\n * }\n */\nexport async function parseImports(\n  source: string,\n  filePath: string,\n): Promise<Map<string, ResolvedImport>> {\n  try {\n    // Skip .d.ts files - they're type declarations, not runtime code\n    if (filePath.endsWith(\".d.ts\")) {\n      return new Map();\n    }\n\n    // es-module-lexer first: it reads the real statements and skips comments.\n    try {\n      const [imports] = await parse(source);\n\n      if (imports && imports.length > 0) {\n        return await resolveImports(imports as ImportSpecifier[], source, filePath);\n      }\n    } catch {\n      // The lexer rejects some TypeScript syntax; the regex below covers it.\n    }\n\n    // Fallback: regex extraction, for files the lexer rejects and for files\n    // where it finds nothing (it does not report `export type { A } from`).\n    // It runs over the source without comments: scanning them turned a doc\n    // comment such as `(await import(\"./query-testing\"))` in a file with no\n    // imports into a self edge and a false \"circular dependency\".\n    const regexImports = extractImportPathsWithRegex(stripComments(source, filePath));\n    const resolvedImports = new Map<string, ResolvedImport>();\n\n    for (const { path: importPath, isTypeOnly } of regexImports) {\n      if (isNodeBuiltin(importPath)) {\n        continue;\n      }\n\n      if (!importPath.startsWith(\".\") && !tsconfigManager.isAlias(importPath)) {\n        continue;\n      }\n\n      let resolvedPath: string | null = null;\n\n      if (tsconfigManager.isAlias(importPath)) {\n        resolvedPath = await resolveAliasImport(importPath);\n      } else if (importPath.startsWith(\".\")) {\n        resolvedPath = await resolveRelativeImport(importPath, filePath);\n      }\n\n      if (resolvedPath && !isSameFile(resolvedPath, filePath)) {\n        mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);\n      }\n    }\n\n    return resolvedImports;\n  } catch (error) {\n    console.error(`Error parsing imports for ${filePath}:`, error);\n\n    return new Map();\n  }\n}\n\n/** True when both paths name the same file (case-insensitively on Windows). */\nfunction isSameFile(first: string, second: string): boolean {\n  const normalize = (filePath: string) => {\n    const resolved = Path.normalize(path.resolve(filePath));\n    return process.platform === \"win32\" ? resolved.toLowerCase() : resolved;\n  };\n\n  return normalize(first) === normalize(second);\n}\n\n/**\n * Remove `//` and `/* *\\/` comments, keeping every newline in place (so\n * line-based matches keep their lines). Only the regex fallback needs it; the\n * lexer already skips comments.\n *\n * Comment ranges come from an OXC parse, never from scanning\n * characters: only the parser can tell a regex literal (`/\\/*$/`), a template\n * literal or JSX text (`<p>// not a comment</p>`) from a comment. A character\n * scanner read the `/*` in `p.replace(/\\/*$/, \"\")` as a block comment and\n * erased every import after it.\n *\n * `filePath` picks the dialect (`.tsx`/`.jsx` parse JSX); without it the\n * source is parsed as TSX.\n */\nexport function stripComments(source: string, filePath = \"source.tsx\"): string {\n  const ranges = parseSync(filePath, source).comments;\n\n  let output = \"\";\n  let cursor = 0;\n\n  for (const range of ranges) {\n    output += source.slice(cursor, range.start);\n    output += source.slice(range.start, range.end).replace(/[^\\n]/g, \"\");\n    cursor = range.end;\n  }\n\n  return output + source.slice(cursor);\n}\n\n/**\n * Merge a resolved import into the output map, preserving the type-only rule:\n * a path is type-only iff every statement that references it is type-only.\n */\nfunction mergeResolvedImport(\n  target: Map<string, ResolvedImport>,\n  importPath: string,\n  absolutePath: string,\n  isTypeOnly: boolean,\n): void {\n  const existing = target.get(importPath);\n\n  if (!existing) {\n    target.set(importPath, { absolutePath, isTypeOnly });\n\n    return;\n  }\n\n  if (!isTypeOnly) {\n    existing.isTypeOnly = false;\n  }\n}\n\n/**\n * Resolve imports from `es-module-lexer` output. For each specifier, slice the\n * raw statement (`ss..se`) and re-run the type-only heuristic so we can flag\n * the edge correctly — the lexer itself does not distinguish `import type`.\n */\nasync function resolveImports(\n  imports: ImportSpecifier[],\n  source: string,\n  filePath: string,\n): Promise<Map<string, ResolvedImport>> {\n  const resolvedImports = new Map<string, ResolvedImport>();\n\n  for (const imp of imports) {\n    const importPath = imp.n;\n\n    if (!importPath) {\n      continue;\n    }\n\n    if (isNodeBuiltin(importPath)) {\n      continue;\n    }\n\n    if (!importPath.startsWith(\".\") && !tsconfigManager.isAlias(importPath)) {\n      continue;\n    }\n\n    let resolvedPath: string | null = null;\n\n    if (tsconfigManager.isAlias(importPath)) {\n      resolvedPath = await resolveAliasImport(importPath);\n    } else if (importPath.startsWith(\".\")) {\n      resolvedPath = await resolveRelativeImport(importPath, filePath);\n    }\n\n    // A file importing itself is no dependency edge, and as one it reads as\n    // a one-file \"cycle\".\n    if (!resolvedPath || isSameFile(resolvedPath, filePath)) {\n      continue;\n    }\n\n    const isTypeOnly = isLexerStatementTypeOnly(imp, source);\n\n    mergeResolvedImport(resolvedImports, importPath, resolvedPath, isTypeOnly);\n  }\n\n  return resolvedImports;\n}\n\n/**\n * Classify a single lexer-reported statement as type-only or runtime.\n * Dynamic imports (`import(...)`) are always runtime. For static\n * imports/export-from we slice the raw source and apply the same heuristic\n * the regex fallback uses.\n */\nfunction isLexerStatementTypeOnly(imp: ImportSpecifier, source: string): boolean {\n  // Dynamic imports always execute — they cannot be type-only.\n  // es-module-lexer reports dynamic with a.n === undefined typically, but\n  // we guard by checking the statement prefix too.\n  const statementStart = imp.ss;\n  const statementEnd = imp.se;\n\n  if (\n    typeof statementStart !== \"number\" ||\n    typeof statementEnd !== \"number\" ||\n    statementEnd <= statementStart\n  ) {\n    return false;\n  }\n\n  const statement = source.slice(statementStart, statementEnd);\n  const trimmed = statement.trim();\n\n  if (trimmed.startsWith(\"import(\") || /^\\bimport\\s*\\(/.test(trimmed)) {\n    return false;\n  }\n\n  if (trimmed.startsWith(\"export\")) {\n    return isExportTypeOnlyStatement(statement);\n  }\n\n  return !hasRuntimeImports(statement);\n}\n\n/**\n * Resolve alias imports to actual file paths with extensions\n * Example: app/users/services/get-users.service -> /absolute/path/to/src/app/users/services/get-users.service.ts\n */\nasync function resolveAliasImport(importPath: string): Promise<string | null> {\n  // Use tsconfig manager to resolve the alias to an absolute path\n  const resolvedBase = tsconfigManager.resolveAliasToAbsolute(importPath);\n\n  if (!resolvedBase) return null;\n\n  // Try to resolve with extensions\n  const resolvedPath = await tryResolveWithExtensions(resolvedBase);\n\n  return resolvedPath;\n}\n\n/**\n * Resolve relative imports to actual file paths\n * Example: ./../services/get-user.service -> /absolute/path/to/services/get-user.service.ts\n */\nasync function resolveRelativeImport(\n  importPath: string,\n  currentFilePath: string,\n): Promise<string | null> {\n  const dir = path.dirname(currentFilePath);\n  // Use path.resolve to handle .. and . properly, then normalize to forward slashes\n  const resolvedBase = Path.normalize(path.resolve(dir, importPath));\n\n  // Try to resolve with extensions\n  const resolvedPath = await tryResolveWithExtensions(resolvedBase);\n\n  return resolvedPath;\n}\n\n/**\n * Try to resolve a file path by checking different extensions\n * TypeScript/JavaScript files can be imported without extensions\n *\n * @TODO: For better performance, we need to check the files in files orchestrator\n * instead of using the file system as we will be fetching all project files anyway.\n */\n// Cache for file existence checks to avoid redundant filesystem calls\nconst fileExistsCache = new Map<string, boolean>();\n\n/**\n * Clear the file exists cache\n * Should be called when new files are created to ensure fresh lookups\n */\nexport function clearFileExistsCache(): void {\n  fileExistsCache.clear();\n}\n\nasync function cachedFileExists(filePath: string): Promise<boolean> {\n  if (fileExistsCache.has(filePath)) {\n    return fileExistsCache.get(filePath)!;\n  }\n  const exists = (await fileExistsAsync(filePath)) as boolean;\n\n  // Cache ONLY positive results. A negative (\"does not exist\") answer is the\n  // exact case that flips moments later: the \"add a new controller/route\" flow\n  // references a file, then creates it. Caching that negative for the whole\n  // process lifetime (it was cleared only on a multi-file watcher batch) left\n  // a routes.ts import unresolvable after its target was created — the dep\n  // edge never formed and the route module import failed, so the new API route\n  // 404'd until an unrelated multi-file batch cleared the cache. That is\n  // finding 60721e35 (\"backend route HMR needs a second edit\"). A file that\n  // exists does not stop existing mid-resolve, so caching the hit is safe;\n  // re-probing a still-missing path costs only a handful of stat calls.\n  if (exists) {\n    fileExistsCache.set(filePath, exists);\n  }\n\n  return exists;\n}\n\nasync function tryResolveWithExtensions(basePath: string): Promise<string | null> {\n  // Normalize the base path first (handle Windows paths)\n  const normalizedBase = Path.normalize(basePath);\n\n  // List of extensions to try, in order of preference\n  const extensions = [\".ts\", \".tsx\", \".js\", \".jsx\", \".mjs\", \".cjs\"];\n  const validExtensions = new Set(extensions);\n\n  // If the path already has a VALID code file extension, check if it exists\n  const ext = path.extname(normalizedBase);\n  if (ext && validExtensions.has(ext)) {\n    // NodeNext style: `./x.js` is written, `x.ts`/`x.tsx` is on disk. The\n    // loader rewrites it the same way (own-resolver `probeFile`), and a\n    // co-located source wins over the literal .js.\n    if ([\".js\", \".jsx\", \".mjs\", \".cjs\"].includes(ext)) {\n      const stem = normalizedBase.slice(0, -ext.length);\n      for (const sourceExt of [\".ts\", \".tsx\"]) {\n        if (await cachedFileExists(stem + sourceExt)) {\n          return stem + sourceExt;\n        }\n      }\n    }\n    if (await cachedFileExists(normalizedBase)) {\n      return normalizedBase;\n    }\n    // If explicit extension doesn't exist, return null\n    return null;\n  }\n\n  // Try all extensions in parallel for better performance\n  const pathsToCheck = extensions.map((extension) => normalizedBase + extension);\n  const results = await Promise.all(\n    pathsToCheck.map(async (p) => ({ path: p, exists: await cachedFileExists(p) })),\n  );\n\n  // Return the first one that exists (in order of preference)\n  for (const result of results) {\n    if (result.exists) {\n      return result.path;\n    }\n  }\n\n  // Try index files in directory\n  if (await directoryExistsAsync(normalizedBase)) {\n    const indexPaths = extensions.map((extension) =>\n      Path.join(normalizedBase, `index${extension}`),\n    );\n    const indexResults = await Promise.all(\n      indexPaths.map(async (p) => ({ path: p, exists: await cachedFileExists(p) })),\n    );\n\n    for (const result of indexResults) {\n      if (result.exists) {\n        return result.path;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Check if import is a Node.js built-in module\n */\nfunction isNodeBuiltin(importPath: string): boolean {\n  const builtins = [\n    \"fs\",\n    \"path\",\n    \"http\",\n    \"https\",\n    \"crypto\",\n    \"stream\",\n    \"util\",\n    \"events\",\n    \"buffer\",\n    \"child_process\",\n    \"os\",\n    \"url\",\n    \"querystring\",\n    \"zlib\",\n    \"net\",\n    \"tls\",\n    \"dns\",\n    \"dgram\",\n    \"cluster\",\n    \"worker_threads\",\n    \"perf_hooks\",\n    \"async_hooks\",\n    \"timers\",\n    \"readline\",\n    \"repl\",\n    \"vm\",\n    \"assert\",\n    \"console\",\n    \"process\",\n    \"v8\",\n  ];\n\n  // Check for node: prefix or direct builtin name\n  if (importPath.startsWith(\"node:\")) return true;\n\n  // `split` always yields a first element. Falling back to the whole path\n  // keeps the builtin check answering about a real name rather than undefined.\n  const moduleName = importPath.split(\"/\")[0] ?? importPath;\n\n  return builtins.includes(moduleName);\n}\n"],"mappings":"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"}

package/esm/dev-server/read-config-ast.mjs

@@ -1,38 +1,8 @@
+import { parseSourceFile } from "../tooling/syntax/ast.mjs";
 import { readFile } from "node:fs/promises";
-import ts from "typescript";
 
 //#region ../../packages/core/src/dev-server/read-config-ast.ts
-/**
-* Parse one config file into an AST.
-*
-* ## Why this is not `ts.createProgram`
-*
-* It was. The typings generator built a whole TypeScript **Program** for each
-* config file just to call `program.getSourceFile(path)` on it. A Warlock
-* config imports `@warlock.js/core`, which in this monorepo resolves to
-* TypeScript **source**, so every one of those Programs resolved and parsed the
-* entire dependency graph behind it.
-*
-* Measured on the reference app's six configs, 2026-08-24:
-*
-* ```
-* ts.createProgram      82,996.00 ms    2,908 source files per program
-* ts.createSourceFile        5.12 ms
-* ratio                 16,212x
-* ```
-*
-* And all of it was discarded. `getTypeChecker()` is never called anywhere in
-* the generator — every question it asks of the AST is syntactic
-* (`isImportDeclaration`, `isTypeAliasDeclaration`, `isVariableDeclaration`,
-* `isObjectLiteralExpression`). Resolving 2,908 files to answer a syntactic
-* question is 2,908 files of work thrown away.
-*
-* A previous pass had already noticed the cost and halved it, from two Programs
-* per file to one — an optimisation inside a premise that did not need to hold.
-*
-* **If a future change here needs a type checker, it needs a Program too, and
-* the cost comes back.** That is the one reason to reconsider this file.
-*/
+/** Parse config syntax without resolving or executing its dependency graph. */
 async function readConfigAst(filePath) {
 	let contents;
 	try {
@@ -40,7 +10,7 @@ async function readConfigAst(filePath) {
 	} catch {
 		return;
 	}
-	return ts.createSourceFile(filePath, contents, ts.ScriptTarget.ESNext, true);
+	return parseSourceFile(filePath, contents);
 }
 
 //#endregion

package/esm/dev-server/read-config-ast.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"read-config-ast.mjs","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/read-config-ast.ts"],"sourcesContent":["/**\n * Parse one config file into an AST.\n *\n * ## Why this is not `ts.createProgram`\n *\n * It was. The typings generator built a whole TypeScript **Program** for each\n * config file just to call `program.getSourceFile(path)` on it. A Warlock\n * config imports `@warlock.js/core`, which in this monorepo resolves to\n * TypeScript **source**, so every one of those Programs resolved and parsed the\n * entire dependency graph behind it.\n *\n * Measured on the reference app's six configs, 2026-08-24:\n *\n * ```\n * ts.createProgram      82,996.00 ms    2,908 source files per program\n * ts.createSourceFile        5.12 ms\n * ratio                 16,212x\n * ```\n *\n * And all of it was discarded. `getTypeChecker()` is never called anywhere in\n * the generator — every question it asks of the AST is syntactic\n * (`isImportDeclaration`, `isTypeAliasDeclaration`, `isVariableDeclaration`,\n * `isObjectLiteralExpression`). Resolving 2,908 files to answer a syntactic\n * question is 2,908 files of work thrown away.\n *\n * A previous pass had already noticed the cost and halved it, from two Programs\n * per file to one — an optimisation inside a premise that did not need to hold.\n *\n * **If a future change here needs a type checker, it needs a Program too, and\n * the cost comes back.** That is the one reason to reconsider this file.\n */\n\nimport { readFile } from \"node:fs/promises\";\nimport ts from \"typescript\";\n\nexport async function readConfigAst(filePath: string): Promise<ts.SourceFile | undefined> {\n  let contents: string;\n\n  try {\n    contents = await readFile(filePath, \"utf-8\");\n  } catch {\n    // Callers already treat a missing config as \"nothing to generate\"; a throw\n    // here would turn an absent optional file into a failed generation.\n    return undefined;\n  }\n\n  return ts.createSourceFile(\n    filePath,\n    contents,\n    ts.ScriptTarget.ESNext,\n    // The generator's visitors read `node.parent`, which the Program-backed\n    // source files provided for free.\n    /* setParentNodes */ true,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,eAAsB,cAAc,UAAsD;CACxF,IAAI;CAEJ,IAAI;EACF,WAAW,MAAM,SAAS,UAAU,OAAO;CAC7C,QAAQ;EAGN;CACF;CAEA,OAAO,GAAG,iBACR,UACA,UACA,GAAG,aAAa,QAGK,IACvB;AACF"}
+{"version":3,"file":"read-config-ast.mjs","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/read-config-ast.ts"],"sourcesContent":["import { readFile } from \"node:fs/promises\";\nimport { parseSourceFile, type SourceFile } from \"../tooling/syntax/ast\";\n\n/** Parse config syntax without resolving or executing its dependency graph. */\nexport async function readConfigAst(filePath: string): Promise<SourceFile | undefined> {\n  let contents: string;\n  try {\n    contents = await readFile(filePath, \"utf-8\");\n  } catch {\n    return undefined;\n  }\n  return parseSourceFile(filePath, contents);\n}\n"],"mappings":";;;;;AAIA,eAAsB,cAAc,UAAmD;CACrF,IAAI;CACJ,IAAI;EACF,WAAW,MAAM,SAAS,UAAU,OAAO;CAC7C,QAAQ;EACN;CACF;CACA,OAAO,gBAAgB,UAAU,QAAQ;AAC3C"}

package/esm/dev-server/ready-block.mjs

@@ -58,5 +58,5 @@ function printReadyBlock(bootDurationMs) {
 }
 
 //#endregion
-export { printReadyBlock };
+export { collectReadyBlockFacts, printReadyBlock, renderReadyBlock };
 //# sourceMappingURL=ready-block.mjs.map

package/esm/dev-server/shortcuts.mjs

@@ -138,5 +138,5 @@ function raiseInterrupt() {
 const devServerShortcuts = new DevServerShortcuts();
 
 //#endregion
-export { devServerShortcuts };
+export { DevServerShortcuts, devServerShortcuts };
 //# sourceMappingURL=shortcuts.mjs.map

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

@@ -1,12 +1,11 @@
 import { FileManager } from "./file-manager.mjs";
-
 //#region ../../packages/core/src/dev-server/special-files-collector.d.ts
-type SpecialFileType = "config" | "main" | "route" | "event" | "locale" | "worker";
+export type SpecialFileType = "config" | "main" | "route" | "event" | "locale" | "worker";
 /**
  * Categorises files into the kinds the dev server treats specially
  * (config / main / route / event / locale / worker) and exposes typed accessors.
  */
-declare class SpecialFilesCollector {
+export declare class SpecialFilesCollector {
   private readonly buckets;
   collect(files: Map<string, FileManager>): void;
   addFile(fileManager: FileManager): void;
@@ -19,5 +18,4 @@ declare class SpecialFilesCollector {
   private categorise;
 }
 //#endregion
-export { SpecialFilesCollector };
 //# sourceMappingURL=special-files-collector.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"special-files-collector.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/special-files-collector.ts"],"mappings":";;;KAUY,eAAA;;AAAZ;;;cAMa,qBAAA;EAAA,iBACM,OAAA;EASV,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,IAAY,MAAA,CAAO,eAAA;EAWnB,KAAA;EAAA,QAIC,UAAA;AAAA"}
+{"version":3,"file":"special-files-collector.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/special-files-collector.ts"],"mappings":";;YAUY;;;;;qBAMC;mBACM;EASV,QAAQ,OAAO,YAAY;EAO3B,QAAQ,aAAa;EAIrB,WAAW;EAIX,WAAW,aAAa;EAKxB,YAAY,uBAAuB;EAUnC,eAAe,MAAM,kBAAkB;EAUvC,YAAY,OAAO;EAWnB;UAIC"}

package/esm/dev-server/supervisor.mjs

@@ -175,5 +175,5 @@ function releaseTerminal() {
 }
 
 //#endregion
-export { isDevWorker, superviseDevServer };
+export { WORKER_BOOTED_MESSAGE, WORKER_ENV_FLAG, isDevWorker, superviseDevServer };
 //# sourceMappingURL=supervisor.mjs.map

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

@@ -1,6 +1,6 @@
 import { Path } from "../utils/normalized-path.mjs";
 import path from "node:path";
-import fs from "node:fs";
+import fsSync from "node:fs";
 import { readTsconfig } from "get-tsconfig";
 
 //#region ../../packages/core/src/dev-server/tsconfig-manager.ts
@@ -12,7 +12,7 @@ var TSConfigManager = class {
 	init() {
 		if (this.tsconfig) return;
 		const configPath = Path.toAbsolute("tsconfig.json");
-		const parsed = fs.existsSync(configPath) ? readTsconfig(configPath, { typescriptVersion: false }).config : {};
+		const parsed = fsSync.existsSync(configPath) ? readTsconfig(configPath, { typescriptVersion: false }).config : {};
 		const compilerOptions = parsed.compilerOptions ?? {};
 		this.tsconfig = {
 			...parsed,
@@ -88,5 +88,5 @@ var TSConfigManager = class {
 const tsconfigManager = new TSConfigManager();
 
 //#endregion
-export { tsconfigManager };
+export { TSConfigManager, tsconfigManager };
 //# sourceMappingURL=tsconfig-manager.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"tsconfig-manager.mjs","names":[],"sources":["../../../../../../../../packages/core/src/dev-server/tsconfig-manager.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { readTsconfig } from \"get-tsconfig\";\nimport { Path } from \"../utils/normalized-path\";\n\nexport class TSConfigManager {\n  /**\n   * Aliases list (from tsconfig paths)\n   */\n  public aliases: Record<string, string[]> = {};\n\n  /**\n   * Base URL for resolving paths\n   */\n  public baseUrl: string = \".\";\n\n  /**\n   * TSConfig\n   */\n  public tsconfig: any;\n\n  public init() {\n    if (this.tsconfig) return;\n\n    // `ts.readConfigFile` does not follow `extends`; `readTsconfig` resolves the\n    // whole chain (paths, baseUrl, decorator flags) and keeps string enum values,\n    // which is what esbuild's `tsconfigRaw` expects.\n    const configPath = Path.toAbsolute(\"tsconfig.json\");\n    const parsed = fs.existsSync(configPath)\n      ? readTsconfig(configPath, { typescriptVersion: false }).config\n      : {};\n    const compilerOptions = parsed.compilerOptions ?? {};\n\n    this.tsconfig = { ...parsed, compilerOptions };\n\n    this.aliases = (compilerOptions.paths as Record<string, string[]> | undefined) || {};\n\n    this.baseUrl = compilerOptions.baseUrl || \".\";\n  }\n\n  /**\n   * Check if the given path is an alias\n   * This checks if it's a REAL path alias (not an external package alias)\n   *\n   * Real aliases map to local paths (e.g., app/* -> src/app/*, src/* -> src/*)\n   * External package aliases map to themselves with @ prefix (e.g., @warlock.js/core -> @warlock.js/core)\n   */\n  public isAlias(path: string) {\n    if (!this.tsconfig) {\n      this.init();\n    }\n\n    return Object.keys(this.aliases).some((alias) => {\n      if (!this.matchesAliasPattern(alias, path)) {\n        return false;\n      }\n\n      const aliasTargets = this.aliases[alias];\n      if (!Array.isArray(aliasTargets) || aliasTargets.length === 0) {\n        return false;\n      }\n\n      // A package mapped onto itself is an external package, not a local alias\n      // Example: \"@warlock.js/core\" -> \"@warlock.js/core\"\n      // (self-referencing local ones like src/* -> src/* are still aliases)\n      if (!alias.endsWith(\"/*\") && aliasTargets.every((target) => target === alias)) {\n        return false;\n      }\n\n      return true;\n    });\n  }\n\n  /**\n   * Check if an import path matches a tsconfig paths pattern\n   * (exact match, or `prefix/*` matching anything under `prefix/`)\n   */\n  private matchesAliasPattern(alias: string, importPath: string): boolean {\n    if (alias.endsWith(\"/*\")) {\n      return importPath.startsWith(alias.slice(0, -1));\n    }\n\n    return importPath === alias;\n  }\n\n  /**\n   * Get the alias key that matches the given import path\n   */\n  public getMatchingAlias(path: string): string | null {\n    const aliasKey = Object.keys(this.aliases).find((alias) =>\n      this.matchesAliasPattern(alias, path),\n    );\n\n    return aliasKey || null;\n  }\n\n  /**\n   * Resolve an alias import path to a relative path based on tsconfig paths\n   * Example: \"app/users/services/get-users.service\" -> \"src/app/users/services/get-users.service\"\n   *\n   * @param path - The import path with alias (e.g., \"app/users/services/get-users.service\")\n   * @returns The resolved relative path or null if alias not found\n   */\n  public resolveAliasPath(checkingPath: string): string | null {\n    // Find matching alias from tsconfig paths\n    const aliasKey = this.getMatchingAlias(checkingPath);\n\n    if (!aliasKey) return null;\n\n    const aliasTargets = this.aliases[aliasKey];\n    if (!Array.isArray(aliasTargets) || aliasTargets.length === 0) {\n      return null;\n    }\n\n    // Get the first target path (usually there's only one)\n    const targetPattern = aliasTargets[0];\n\n    if (targetPattern === undefined) {\n      return null;\n    }\n\n    // Replace alias pattern with target pattern\n    const aliasPattern = aliasKey.replace(\"/*\", \"\");\n    const targetBase = targetPattern.replace(\"/*\", \"\");\n    // Remove any leading slash so path.join does not drop the base\n    const relativePart = checkingPath.substring(aliasPattern.length).replace(/^[/\\\\]/, \"\");\n\n    // Join the target base with the relative part\n    const resolvedPath = path.join(targetBase, relativePart);\n\n    return Path.normalize(resolvedPath);\n  }\n\n  /**\n   * Resolve an alias import path to an absolute path\n   * Example: \"app/users/services/get-users.service\" -> \"/absolute/path/to/src/app/users/services/get-users.service\"\n   *\n   * @param path - The import path with alias\n   * @returns The resolved absolute path or null if alias not found\n   */\n  public resolveAliasToAbsolute(path: string): string | null {\n    const relativePath = this.resolveAliasPath(path);\n\n    if (!relativePath) return null;\n\n    return Path.normalize(Path.toAbsolute(relativePath));\n  }\n}\n\nexport const tsconfigManager = new TSConfigManager();\n"],"mappings":";;;;;;AAKA,IAAa,kBAAb,MAA6B;;iBAIgB,CAAC;iBAKnB;;CAOzB,AAAO,OAAO;EACZ,IAAI,KAAK,UAAU;EAKnB,MAAM,aAAa,KAAK,WAAW,eAAe;EAClD,MAAM,SAAS,GAAG,WAAW,UAAU,IACnC,aAAa,YAAY,EAAE,mBAAmB,MAAM,CAAC,CAAC,CAAC,SACvD,CAAC;EACL,MAAM,kBAAkB,OAAO,mBAAmB,CAAC;EAEnD,KAAK,WAAW;GAAE,GAAG;GAAQ;EAAgB;EAE7C,KAAK,UAAW,gBAAgB,SAAkD,CAAC;EAEnF,KAAK,UAAU,gBAAgB,WAAW;CAC5C;;;;;;;;CASA,AAAO,QAAQ,MAAc;EAC3B,IAAI,CAAC,KAAK,UACR,KAAK,KAAK;EAGZ,OAAO,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,MAAM,UAAU;GAC/C,IAAI,CAAC,KAAK,oBAAoB,OAAO,IAAI,GACvC,OAAO;GAGT,MAAM,eAAe,KAAK,QAAQ;GAClC,IAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,aAAa,WAAW,GAC1D,OAAO;GAMT,IAAI,CAAC,MAAM,SAAS,IAAI,KAAK,aAAa,OAAO,WAAW,WAAW,KAAK,GAC1E,OAAO;GAGT,OAAO;EACT,CAAC;CACH;;;;;CAMA,AAAQ,oBAAoB,OAAe,YAA6B;EACtE,IAAI,MAAM,SAAS,IAAI,GACrB,OAAO,WAAW,WAAW,MAAM,MAAM,GAAG,EAAE,CAAC;EAGjD,OAAO,eAAe;CACxB;;;;CAKA,AAAO,iBAAiB,MAA6B;EAKnD,OAJiB,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,MAAM,UAC/C,KAAK,oBAAoB,OAAO,IAAI,CAGxB,KAAK;CACrB;;;;;;;;CASA,AAAO,iBAAiB,cAAqC;EAE3D,MAAM,WAAW,KAAK,iBAAiB,YAAY;EAEnD,IAAI,CAAC,UAAU,OAAO;EAEtB,MAAM,eAAe,KAAK,QAAQ;EAClC,IAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,aAAa,WAAW,GAC1D,OAAO;EAIT,MAAM,gBAAgB,aAAa;EAEnC,IAAI,kBAAkB,QACpB,OAAO;EAIT,MAAM,eAAe,SAAS,QAAQ,MAAM,EAAE;EAC9C,MAAM,aAAa,cAAc,QAAQ,MAAM,EAAE;EAEjD,MAAM,eAAe,aAAa,UAAU,aAAa,MAAM,CAAC,CAAC,QAAQ,UAAU,EAAE;EAGrF,MAAM,eAAe,KAAK,KAAK,YAAY,YAAY;EAEvD,OAAO,KAAK,UAAU,YAAY;CACpC;;;;;;;;CASA,AAAO,uBAAuB,MAA6B;EACzD,MAAM,eAAe,KAAK,iBAAiB,IAAI;EAE/C,IAAI,CAAC,cAAc,OAAO;EAE1B,OAAO,KAAK,UAAU,KAAK,WAAW,YAAY,CAAC;CACrD;AACF;AAEA,MAAa,kBAAkB,IAAI,gBAAgB"}
+{"version":3,"file":"tsconfig-manager.mjs","names":["fs"],"sources":["../../../../../../../../packages/core/src/dev-server/tsconfig-manager.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { readTsconfig } from \"get-tsconfig\";\nimport { Path } from \"../utils/normalized-path\";\n\nexport class TSConfigManager {\n  /**\n   * Aliases list (from tsconfig paths)\n   */\n  public aliases: Record<string, string[]> = {};\n\n  /**\n   * Base URL for resolving paths\n   */\n  public baseUrl: string = \".\";\n\n  /**\n   * TSConfig\n   */\n  public tsconfig: any;\n\n  public init() {\n    if (this.tsconfig) return;\n\n    // `ts.readConfigFile` does not follow `extends`; `readTsconfig` resolves the\n    // whole chain (paths, baseUrl, decorator flags) and keeps string enum values,\n    // which is what esbuild's `tsconfigRaw` expects.\n    const configPath = Path.toAbsolute(\"tsconfig.json\");\n    const parsed = fs.existsSync(configPath)\n      ? readTsconfig(configPath, { typescriptVersion: false }).config\n      : {};\n    const compilerOptions = parsed.compilerOptions ?? {};\n\n    this.tsconfig = { ...parsed, compilerOptions };\n\n    this.aliases = (compilerOptions.paths as Record<string, string[]> | undefined) || {};\n\n    this.baseUrl = compilerOptions.baseUrl || \".\";\n  }\n\n  /**\n   * Check if the given path is an alias\n   * This checks if it's a REAL path alias (not an external package alias)\n   *\n   * Real aliases map to local paths (e.g., app/* -> src/app/*, src/* -> src/*)\n   * External package aliases map to themselves with @ prefix (e.g., @warlock.js/core -> @warlock.js/core)\n   */\n  public isAlias(path: string) {\n    if (!this.tsconfig) {\n      this.init();\n    }\n\n    return Object.keys(this.aliases).some((alias) => {\n      if (!this.matchesAliasPattern(alias, path)) {\n        return false;\n      }\n\n      const aliasTargets = this.aliases[alias];\n      if (!Array.isArray(aliasTargets) || aliasTargets.length === 0) {\n        return false;\n      }\n\n      // A package mapped onto itself is an external package, not a local alias\n      // Example: \"@warlock.js/core\" -> \"@warlock.js/core\"\n      // (self-referencing local ones like src/* -> src/* are still aliases)\n      if (!alias.endsWith(\"/*\") && aliasTargets.every((target) => target === alias)) {\n        return false;\n      }\n\n      return true;\n    });\n  }\n\n  /**\n   * Check if an import path matches a tsconfig paths pattern\n   * (exact match, or `prefix/*` matching anything under `prefix/`)\n   */\n  private matchesAliasPattern(alias: string, importPath: string): boolean {\n    if (alias.endsWith(\"/*\")) {\n      return importPath.startsWith(alias.slice(0, -1));\n    }\n\n    return importPath === alias;\n  }\n\n  /**\n   * Get the alias key that matches the given import path\n   */\n  public getMatchingAlias(path: string): string | null {\n    const aliasKey = Object.keys(this.aliases).find((alias) =>\n      this.matchesAliasPattern(alias, path),\n    );\n\n    return aliasKey || null;\n  }\n\n  /**\n   * Resolve an alias import path to a relative path based on tsconfig paths\n   * Example: \"app/users/services/get-users.service\" -> \"src/app/users/services/get-users.service\"\n   *\n   * @param path - The import path with alias (e.g., \"app/users/services/get-users.service\")\n   * @returns The resolved relative path or null if alias not found\n   */\n  public resolveAliasPath(checkingPath: string): string | null {\n    // Find matching alias from tsconfig paths\n    const aliasKey = this.getMatchingAlias(checkingPath);\n\n    if (!aliasKey) return null;\n\n    const aliasTargets = this.aliases[aliasKey];\n    if (!Array.isArray(aliasTargets) || aliasTargets.length === 0) {\n      return null;\n    }\n\n    // Get the first target path (usually there's only one)\n    const targetPattern = aliasTargets[0];\n\n    if (targetPattern === undefined) {\n      return null;\n    }\n\n    // Replace alias pattern with target pattern\n    const aliasPattern = aliasKey.replace(\"/*\", \"\");\n    const targetBase = targetPattern.replace(\"/*\", \"\");\n    // Remove any leading slash so path.join does not drop the base\n    const relativePart = checkingPath.substring(aliasPattern.length).replace(/^[/\\\\]/, \"\");\n\n    // Join the target base with the relative part\n    const resolvedPath = path.join(targetBase, relativePart);\n\n    return Path.normalize(resolvedPath);\n  }\n\n  /**\n   * Resolve an alias import path to an absolute path\n   * Example: \"app/users/services/get-users.service\" -> \"/absolute/path/to/src/app/users/services/get-users.service\"\n   *\n   * @param path - The import path with alias\n   * @returns The resolved absolute path or null if alias not found\n   */\n  public resolveAliasToAbsolute(path: string): string | null {\n    const relativePath = this.resolveAliasPath(path);\n\n    if (!relativePath) return null;\n\n    return Path.normalize(Path.toAbsolute(relativePath));\n  }\n}\n\nexport const tsconfigManager = new TSConfigManager();\n"],"mappings":";;;;;;AAKA,IAAa,kBAAb,MAA6B;;iBAIgB,CAAC;iBAKnB;;CAOzB,AAAO,OAAO;EACZ,IAAI,KAAK,UAAU;EAKnB,MAAM,aAAa,KAAK,WAAW,eAAe;EAClD,MAAM,SAASA,OAAG,WAAW,UAAU,IACnC,aAAa,YAAY,EAAE,mBAAmB,MAAM,CAAC,CAAC,CAAC,SACvD,CAAC;EACL,MAAM,kBAAkB,OAAO,mBAAmB,CAAC;EAEnD,KAAK,WAAW;GAAE,GAAG;GAAQ;EAAgB;EAE7C,KAAK,UAAW,gBAAgB,SAAkD,CAAC;EAEnF,KAAK,UAAU,gBAAgB,WAAW;CAC5C;;;;;;;;CASA,AAAO,QAAQ,MAAc;EAC3B,IAAI,CAAC,KAAK,UACR,KAAK,KAAK;EAGZ,OAAO,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,MAAM,UAAU;GAC/C,IAAI,CAAC,KAAK,oBAAoB,OAAO,IAAI,GACvC,OAAO;GAGT,MAAM,eAAe,KAAK,QAAQ;GAClC,IAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,aAAa,WAAW,GAC1D,OAAO;GAMT,IAAI,CAAC,MAAM,SAAS,IAAI,KAAK,aAAa,OAAO,WAAW,WAAW,KAAK,GAC1E,OAAO;GAGT,OAAO;EACT,CAAC;CACH;;;;;CAMA,AAAQ,oBAAoB,OAAe,YAA6B;EACtE,IAAI,MAAM,SAAS,IAAI,GACrB,OAAO,WAAW,WAAW,MAAM,MAAM,GAAG,EAAE,CAAC;EAGjD,OAAO,eAAe;CACxB;;;;CAKA,AAAO,iBAAiB,MAA6B;EAKnD,OAJiB,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,MAAM,UAC/C,KAAK,oBAAoB,OAAO,IAAI,CAGxB,KAAK;CACrB;;;;;;;;CASA,AAAO,iBAAiB,cAAqC;EAE3D,MAAM,WAAW,KAAK,iBAAiB,YAAY;EAEnD,IAAI,CAAC,UAAU,OAAO;EAEtB,MAAM,eAAe,KAAK,QAAQ;EAClC,IAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,aAAa,WAAW,GAC1D,OAAO;EAIT,MAAM,gBAAgB,aAAa;EAEnC,IAAI,kBAAkB,QACpB,OAAO;EAIT,MAAM,eAAe,SAAS,QAAQ,MAAM,EAAE;EAC9C,MAAM,aAAa,cAAc,QAAQ,MAAM,EAAE;EAEjD,MAAM,eAAe,aAAa,UAAU,aAAa,MAAM,CAAC,CAAC,QAAQ,UAAU,EAAE;EAGrF,MAAM,eAAe,KAAK,KAAK,YAAY,YAAY;EAEvD,OAAO,KAAK,UAAU,YAAY;CACpC;;;;;;;;CASA,AAAO,uBAAuB,MAA6B;EACzD,MAAM,eAAe,KAAK,iBAAiB,IAAI;EAE/C,IAAI,CAAC,cAAc,OAAO;EAE1B,OAAO,KAAK,UAAU,KAAK,WAAW,YAAY,CAAC;CACrD;AACF;AAEA,MAAa,kBAAkB,IAAI,gBAAgB"}