@warlock.js/core 4.1.15 → 4.2.1

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

@@ -1,7 +1,7 @@
 import { MANIFEST_PATH } from "./flags.mjs";
 import { fileExistsAsync, getJsonFileAsync, putFileAsync } from "@warlock.js/fs";
 
-//#region ../../@warlock.js/core/src/dev-server/manifest-manager.ts
+//#region ../@warlock.js/core/src/dev-server/manifest-manager.ts
 var ManifestManager = class {
 	/**
 	* Constructor

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

@@ -1 +1 @@
-{"version":3,"file":"manifest-manager.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/manifest-manager.ts"],"sourcesContent":["import { fileExistsAsync, getJsonFileAsync, putFileAsync } from \"@warlock.js/fs\";\r\nimport { FileManager } from \"./file-manager\";\r\nimport type { FileManifest } from \"./types\";\r\nimport { MANIFEST_PATH } from \"./flags\";\r\n\r\n/**\r\n * Manifest structure with metadata and files\r\n */\r\nexport type Manifest = {\r\n  version: string;\r\n  lastBuildTime: number;\r\n  projectHash?: string;\r\n  stats: {\r\n    totalFiles: number;\r\n    totalDependencies: number;\r\n  };\r\n  files: Record<string, FileManifest>;\r\n};\r\n\r\nexport class ManifestManager {\r\n  /**\r\n   * Manifest data with metadata\r\n   */\r\n  private manifest: Manifest = {\r\n    version: \"1.0.0\",\r\n    lastBuildTime: Date.now(),\r\n    stats: {\r\n      totalFiles: 0,\r\n      totalDependencies: 0,\r\n    },\r\n    files: {},\r\n  };\r\n\r\n  /**\r\n   * Constructor\r\n   */\r\n  public constructor(private readonly files: Map<string, FileManager>) {}\r\n\r\n  /**\r\n   * Initialize manifest manager\r\n   * @returns true if manifest exists, false otherwise\r\n   */\r\n  public async init(): Promise<boolean> {\r\n    if (await fileExistsAsync(MANIFEST_PATH)) {\r\n      this.manifest = await getJsonFileAsync(MANIFEST_PATH);\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Save manifest to disk\r\n   */\r\n  public async save(): Promise<void> {\r\n    // Update stats before saving\r\n    this.manifest.stats.totalFiles = Object.keys(this.manifest.files).length;\r\n    this.manifest.stats.totalDependencies = this.calculateTotalDependencies();\r\n    this.manifest.lastBuildTime = Date.now();\r\n\r\n    await putFileAsync(MANIFEST_PATH, JSON.stringify(this.manifest, null, 2));\r\n  }\r\n\r\n  /**\r\n   * Get file manifest data\r\n   */\r\n  public getFile(filePath: string): FileManifest | undefined {\r\n    return this.manifest.files[filePath];\r\n  }\r\n\r\n  /**\r\n   * Check if file exists in manifest\r\n   */\r\n  public hasFile(filePath: string): boolean {\r\n    return filePath in this.manifest.files;\r\n  }\r\n\r\n  /**\r\n   * Set file manifest data\r\n   */\r\n  public setFile(filePath: string, fileManifest: FileManifest): void {\r\n    this.manifest.files[filePath] = fileManifest;\r\n  }\r\n\r\n  /**\r\n   * Remove file from manifest\r\n   */\r\n  public removeFile(filePath: string): void {\r\n    delete this.manifest.files[filePath];\r\n  }\r\n\r\n  /**\r\n   * Get all file paths in manifest\r\n   */\r\n  public getAllFilePaths(): string[] {\r\n    return Object.keys(this.manifest.files);\r\n  }\r\n\r\n  /**\r\n   * Get all file manifests\r\n   */\r\n  public getAllFiles(): Record<string, FileManifest> {\r\n    return this.manifest.files;\r\n  }\r\n\r\n  /**\r\n   * Get manifest metadata\r\n   */\r\n  public getMetadata() {\r\n    return {\r\n      version: this.manifest.version,\r\n      lastBuildTime: this.manifest.lastBuildTime,\r\n      projectHash: this.manifest.projectHash,\r\n      stats: this.manifest.stats,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Calculate total dependencies across all files\r\n   */\r\n  private calculateTotalDependencies(): number {\r\n    return Object.values(this.manifest.files).reduce(\r\n      (total, file) => total + (file.dependencies?.length || 0),\r\n      0,\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Clear all files from manifest\r\n   */\r\n  public clear(): void {\r\n    this.manifest.files = {};\r\n    this.manifest.stats = {\r\n      totalFiles: 0,\r\n      totalDependencies: 0,\r\n    };\r\n  }\r\n}\r\n"],"mappings":";;;;AAmBA,IAAa,kBAAb,MAA6B;;;;CAiB3B,AAAO,YAAY,AAAiB,OAAiC;EAAjC;kBAbP;GAC3B,SAAS;GACT,eAAe,KAAK,IAAI;GACxB,OAAO;IACL,YAAY;IACZ,mBAAmB;GACrB;GACA,OAAO,CAAC;EACV;CAKsE;;;;;CAMtE,MAAa,OAAyB;EACpC,IAAI,MAAM,gBAAgB,aAAa,GAAG;GACxC,KAAK,WAAW,MAAM,iBAAiB,aAAa;GACpD,OAAO;EACT,OACE,OAAO;CAEX;;;;CAKA,MAAa,OAAsB;EAEjC,KAAK,SAAS,MAAM,aAAa,OAAO,KAAK,KAAK,SAAS,KAAK,EAAE;EAClE,KAAK,SAAS,MAAM,oBAAoB,KAAK,2BAA2B;EACxE,KAAK,SAAS,gBAAgB,KAAK,IAAI;EAEvC,MAAM,aAAa,eAAe,KAAK,UAAU,KAAK,UAAU,MAAM,CAAC,CAAC;CAC1E;;;;CAKA,AAAO,QAAQ,UAA4C;EACzD,OAAO,KAAK,SAAS,MAAM;CAC7B;;;;CAKA,AAAO,QAAQ,UAA2B;EACxC,OAAO,YAAY,KAAK,SAAS;CACnC;;;;CAKA,AAAO,QAAQ,UAAkB,cAAkC;EACjE,KAAK,SAAS,MAAM,YAAY;CAClC;;;;CAKA,AAAO,WAAW,UAAwB;EACxC,OAAO,KAAK,SAAS,MAAM;CAC7B;;;;CAKA,AAAO,kBAA4B;EACjC,OAAO,OAAO,KAAK,KAAK,SAAS,KAAK;CACxC;;;;CAKA,AAAO,cAA4C;EACjD,OAAO,KAAK,SAAS;CACvB;;;;CAKA,AAAO,cAAc;EACnB,OAAO;GACL,SAAS,KAAK,SAAS;GACvB,eAAe,KAAK,SAAS;GAC7B,aAAa,KAAK,SAAS;GAC3B,OAAO,KAAK,SAAS;EACvB;CACF;;;;CAKA,AAAQ,6BAAqC;EAC3C,OAAO,OAAO,OAAO,KAAK,SAAS,KAAK,EAAE,QACvC,OAAO,SAAS,SAAS,KAAK,cAAc,UAAU,IACvD,CACF;CACF;;;;CAKA,AAAO,QAAc;EACnB,KAAK,SAAS,QAAQ,CAAC;EACvB,KAAK,SAAS,QAAQ;GACpB,YAAY;GACZ,mBAAmB;EACrB;CACF;AACF"}
+{"version":3,"file":"manifest-manager.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/manifest-manager.ts"],"sourcesContent":["import { fileExistsAsync, getJsonFileAsync, putFileAsync } from \"@warlock.js/fs\";\r\nimport { FileManager } from \"./file-manager\";\r\nimport type { FileManifest } from \"./types\";\r\nimport { MANIFEST_PATH } from \"./flags\";\r\n\r\n/**\r\n * Manifest structure with metadata and files\r\n */\r\nexport type Manifest = {\r\n  version: string;\r\n  lastBuildTime: number;\r\n  projectHash?: string;\r\n  stats: {\r\n    totalFiles: number;\r\n    totalDependencies: number;\r\n  };\r\n  files: Record<string, FileManifest>;\r\n};\r\n\r\nexport class ManifestManager {\r\n  /**\r\n   * Manifest data with metadata\r\n   */\r\n  private manifest: Manifest = {\r\n    version: \"1.0.0\",\r\n    lastBuildTime: Date.now(),\r\n    stats: {\r\n      totalFiles: 0,\r\n      totalDependencies: 0,\r\n    },\r\n    files: {},\r\n  };\r\n\r\n  /**\r\n   * Constructor\r\n   */\r\n  public constructor(private readonly files: Map<string, FileManager>) {}\r\n\r\n  /**\r\n   * Initialize manifest manager\r\n   * @returns true if manifest exists, false otherwise\r\n   */\r\n  public async init(): Promise<boolean> {\r\n    if (await fileExistsAsync(MANIFEST_PATH)) {\r\n      this.manifest = await getJsonFileAsync(MANIFEST_PATH);\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Save manifest to disk\r\n   */\r\n  public async save(): Promise<void> {\r\n    // Update stats before saving\r\n    this.manifest.stats.totalFiles = Object.keys(this.manifest.files).length;\r\n    this.manifest.stats.totalDependencies = this.calculateTotalDependencies();\r\n    this.manifest.lastBuildTime = Date.now();\r\n\r\n    await putFileAsync(MANIFEST_PATH, JSON.stringify(this.manifest, null, 2));\r\n  }\r\n\r\n  /**\r\n   * Get file manifest data\r\n   */\r\n  public getFile(filePath: string): FileManifest | undefined {\r\n    return this.manifest.files[filePath];\r\n  }\r\n\r\n  /**\r\n   * Check if file exists in manifest\r\n   */\r\n  public hasFile(filePath: string): boolean {\r\n    return filePath in this.manifest.files;\r\n  }\r\n\r\n  /**\r\n   * Set file manifest data\r\n   */\r\n  public setFile(filePath: string, fileManifest: FileManifest): void {\r\n    this.manifest.files[filePath] = fileManifest;\r\n  }\r\n\r\n  /**\r\n   * Remove file from manifest\r\n   */\r\n  public removeFile(filePath: string): void {\r\n    delete this.manifest.files[filePath];\r\n  }\r\n\r\n  /**\r\n   * Get all file paths in manifest\r\n   */\r\n  public getAllFilePaths(): string[] {\r\n    return Object.keys(this.manifest.files);\r\n  }\r\n\r\n  /**\r\n   * Get all file manifests\r\n   */\r\n  public getAllFiles(): Record<string, FileManifest> {\r\n    return this.manifest.files;\r\n  }\r\n\r\n  /**\r\n   * Get manifest metadata\r\n   */\r\n  public getMetadata() {\r\n    return {\r\n      version: this.manifest.version,\r\n      lastBuildTime: this.manifest.lastBuildTime,\r\n      projectHash: this.manifest.projectHash,\r\n      stats: this.manifest.stats,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Calculate total dependencies across all files\r\n   */\r\n  private calculateTotalDependencies(): number {\r\n    return Object.values(this.manifest.files).reduce(\r\n      (total, file) => total + (file.dependencies?.length || 0),\r\n      0,\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Clear all files from manifest\r\n   */\r\n  public clear(): void {\r\n    this.manifest.files = {};\r\n    this.manifest.stats = {\r\n      totalFiles: 0,\r\n      totalDependencies: 0,\r\n    };\r\n  }\r\n}\r\n"],"mappings":";;;;AAmBA,IAAa,kBAAb,MAA6B;;;;CAiB3B,AAAO,YAAY,AAAiB,OAAiC;EAAjC;kBAbP;GAC3B,SAAS;GACT,eAAe,KAAK,IAAI;GACxB,OAAO;IACL,YAAY;IACZ,mBAAmB;GACrB;GACA,OAAO,CAAC;EACV;CAKsE;;;;;CAMtE,MAAa,OAAyB;EACpC,IAAI,MAAM,gBAAgB,aAAa,GAAG;GACxC,KAAK,WAAW,MAAM,iBAAiB,aAAa;GACpD,OAAO;EACT,OACE,OAAO;CAEX;;;;CAKA,MAAa,OAAsB;EAEjC,KAAK,SAAS,MAAM,aAAa,OAAO,KAAK,KAAK,SAAS,KAAK,CAAC,CAAC;EAClE,KAAK,SAAS,MAAM,oBAAoB,KAAK,2BAA2B;EACxE,KAAK,SAAS,gBAAgB,KAAK,IAAI;EAEvC,MAAM,aAAa,eAAe,KAAK,UAAU,KAAK,UAAU,MAAM,CAAC,CAAC;CAC1E;;;;CAKA,AAAO,QAAQ,UAA4C;EACzD,OAAO,KAAK,SAAS,MAAM;CAC7B;;;;CAKA,AAAO,QAAQ,UAA2B;EACxC,OAAO,YAAY,KAAK,SAAS;CACnC;;;;CAKA,AAAO,QAAQ,UAAkB,cAAkC;EACjE,KAAK,SAAS,MAAM,YAAY;CAClC;;;;CAKA,AAAO,WAAW,UAAwB;EACxC,OAAO,KAAK,SAAS,MAAM;CAC7B;;;;CAKA,AAAO,kBAA4B;EACjC,OAAO,OAAO,KAAK,KAAK,SAAS,KAAK;CACxC;;;;CAKA,AAAO,cAA4C;EACjD,OAAO,KAAK,SAAS;CACvB;;;;CAKA,AAAO,cAAc;EACnB,OAAO;GACL,SAAS,KAAK,SAAS;GACvB,eAAe,KAAK,SAAS;GAC7B,aAAa,KAAK,SAAS;GAC3B,OAAO,KAAK,SAAS;EACvB;CACF;;;;CAKA,AAAQ,6BAAqC;EAC3C,OAAO,OAAO,OAAO,KAAK,SAAS,KAAK,CAAC,CAAC,QACvC,OAAO,SAAS,SAAS,KAAK,cAAc,UAAU,IACvD,CACF;CACF;;;;CAKA,AAAO,QAAc;EACnB,KAAK,SAAS,QAAQ,CAAC;EACvB,KAAK,SAAS,QAAQ;GACpB,YAAY;GACZ,mBAAmB;EACrB;CACF;AACF"}

package/esm/dev-server/module-loader.d.mts

@@ -1,7 +1,7 @@
 import { SpecialFilesCollector } from "./special-files-collector.mjs";
 import { FileManager } from "./file-manager.mjs";
 
-//#region ../../@warlock.js/core/src/dev-server/module-loader.d.ts
+//#region ../@warlock.js/core/src/dev-server/module-loader.d.ts
 declare global {
   var __currentModuleFile: FileManager | undefined;
 }

package/esm/dev-server/module-loader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"module-loader.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/module-loader.ts"],"mappings":";;;;QAMQ,MAAA;EAAA,IACF,mBAAA,EAAqB,WAAW;AAAA;;;;;;cAezB,YAAA;EAAA,iBAGkB,qBAAA;EAAA,iBAFZ,aAAA;cAEY,qBAAA,EAAuB,qBAAA;EAHzC;;;;EASE,OAAA,CAAA,GAAW,OAAA;EAahB;;;;EADK,UAAA,aAAA,CACX,IAAA,EAAM,WAAA,EACN,IAAA,WACC,OAAA,CAAQ,CAAA;EA4Da;;;;;EAlBX,YAAA,CAAa,IAAA,EAAM,WAAA,GAAc,OAAA;;;;;EAkBvC,UAAA,CAAW,IAAA,EAAM,WAAA;EA/DX;;;EAiFN,oBAAA,CAAqB,IAAA,EAAM,WAAA;EA/EhC;;;;;EAAA,QA8FM,eAAA;AAAA"}
+{"version":3,"file":"module-loader.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/module-loader.ts"],"mappings":";;;;QAMQ,MAAA;EAAA,IACF,mBAAA,EAAqB,WAAW;AAAA;;;;;;cAezB,YAAA;EAAA,iBAGkB,qBAAA;EAAA,iBAFZ,aAAA;cAEY,qBAAA,EAAuB,qBAAA;EAHzC;;;;EASE,OAAA,IAAW,OAAA;EAahB;;;;EADK,UAAA,cACX,IAAA,EAAM,WAAA,EACN,IAAA,WACC,OAAA,CAAQ,CAAA;EA4Da;;;;;EAlBX,YAAA,CAAa,IAAA,EAAM,WAAA,GAAc,OAAA;;;;;EAkBvC,UAAA,CAAW,IAAA,EAAM,WAAA;EA/DX;;;EAiFN,oBAAA,CAAqB,IAAA,EAAM,WAAA;EA/EhC;;;;;EAAA,QA8FM,eAAA;AAAA"}

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

@@ -2,7 +2,7 @@ import { router } from "../router/router.mjs";
 import { devLogError, formatModuleNotFoundError } from "./dev-logger.mjs";
 import { pathToFileURL } from "node:url";
 
-//#region ../../@warlock.js/core/src/dev-server/module-loader.ts
+//#region ../@warlock.js/core/src/dev-server/module-loader.ts
 /**
 * The four "special" file kinds that the dev server eagerly imports at boot.
 * Order matters: locales first (used by everything), events before main so

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

@@ -1 +1 @@
-{"version":3,"file":"module-loader.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/module-loader.ts"],"sourcesContent":["import { pathToFileURL } from \"node:url\";\r\nimport { router } from \"../router/router\";\r\nimport { devLogError, formatModuleNotFoundError } from \"./dev-logger\";\r\nimport type { CleanupFunction, FileManager } from \"./file-manager\";\r\nimport type { SpecialFileType, SpecialFilesCollector } from \"./special-files-collector\";\r\n\r\ndeclare global {\r\n  var __currentModuleFile: FileManager | undefined;\r\n}\r\n\r\n/**\r\n * The four \"special\" file kinds that the dev server eagerly imports at boot.\r\n * Order matters: locales first (used by everything), events before main so\r\n * listeners are registered when main runs, routes last so handlers are bound.\r\n */\r\nconst SPECIAL_TYPES: readonly SpecialFileType[] = [\"locale\", \"event\", \"main\", \"route\"] as const;\r\n\r\n/**\r\n * Loads application modules through the ESM loader hook. The hook stamps\r\n * `?v=N` on every import, so each reload is a fresh module without any\r\n * userland cache-busting plumbing.\r\n */\r\nexport class ModuleLoader {\r\n  private readonly loadedModules = new Map<string, unknown>();\r\n\r\n  constructor(private readonly specialFilesCollector: SpecialFilesCollector) {}\r\n\r\n  /**\r\n   * Eagerly load every special file at boot, in the canonical order so\r\n   * later phases (e.g. routes) see state earlier phases registered.\r\n   */\r\n  public async loadAll(): Promise<void> {\r\n    for (const type of SPECIAL_TYPES) {\r\n      for (const file of this.specialFilesCollector.getFilesByType(type)) {\r\n        await this.loadModule(file, type);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Import a file through the loader hook. For routes, scopes the import in\r\n   * `router.withSourceFile()` so the added routes carry their origin.\r\n   */\r\n  public async loadModule<T = unknown>(\r\n    file: FileManager,\r\n    type: string,\r\n  ): Promise<T | undefined> {\r\n    if (file.relativePath.endsWith(\".env\")) return undefined;\r\n\r\n    globalThis.__currentModuleFile = file;\r\n\r\n    try {\r\n      const fileUrl = pathToFileURL(file.absolutePath).href;\r\n\r\n      const load = async () => {\r\n        const module = (await import(fileUrl)) as Record<string, unknown>;\r\n        this.loadedModules.set(file.absolutePath, module);\r\n        this.registerCleanup(file, module);\r\n        return module as T;\r\n      };\r\n\r\n      return type === \"route\"\r\n        ? await router.withSourceFile(file.relativePath, load)\r\n        : await load();\r\n    } catch (error: any) {\r\n      if (error.code === \"ERR_MODULE_NOT_FOUND\") {\r\n        devLogError(formatModuleNotFoundError(error));\r\n      } else {\r\n        // Pass the error through so devLogError prints the stack. With dev\r\n        // source maps enabled, frames remap to the original `.ts` line/col\r\n        // (e.g. the actual call site of an undefined symbol) instead of\r\n        // vanishing — a one-line \"x is not defined\" is undebuggable.\r\n        devLogError(\r\n          `Failed to load ${type}: ${file.relativePath} - ${error?.message || error}`,\r\n          error,\r\n        );\r\n      }\r\n      return undefined;\r\n    } finally {\r\n      globalThis.__currentModuleFile = undefined;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reload a previously-loaded special file. The version-bump that makes the\r\n   * import fresh is done by the caller (layer-executor) before invoking this.\r\n   * Routes are removed from the registry first so re-registration is clean.\r\n   */\r\n  public async reloadModule(file: FileManager): Promise<void> {\r\n    const moduleType = this.specialFilesCollector.getFileType(file.relativePath);\r\n    if (!moduleType) return;\r\n\r\n    this.runCleanup(file);\r\n\r\n    if (moduleType === \"route\") {\r\n      router.removeRoutesBySourceFile(file.relativePath);\r\n    }\r\n\r\n    this.loadedModules.delete(file.absolutePath);\r\n    await this.loadModule(file, moduleType);\r\n  }\r\n\r\n  /**\r\n   * Run every cleanup hook the file registered (or `$cleanup` on its exports)\r\n   * and reset the list. Called once per HMR reload.\r\n   */\r\n  public runCleanup(file: FileManager): void {\r\n    for (const hook of file.cleanup) {\r\n      try {\r\n        if (typeof hook === \"function\") {\r\n          hook();\r\n        } else if (hook && typeof (hook as { unsubscribe?: () => void }).unsubscribe === \"function\") {\r\n          (hook as { unsubscribe: () => void }).unsubscribe();\r\n        }\r\n      } catch {\r\n        // Cleanup errors shouldn't break HMR.\r\n      }\r\n    }\r\n    file.resetCleanup();\r\n  }\r\n\r\n  /**\r\n   * Clean up after a file whose source was deleted from disk.\r\n   */\r\n  public cleanupDeletedModule(file: FileManager): void {\r\n    this.loadedModules.delete(file.absolutePath);\r\n\r\n    if (file.type === \"route\") {\r\n      router.removeRoutesBySourceFile(file.relativePath);\r\n    }\r\n\r\n    this.runCleanup(file);\r\n  }\r\n\r\n  /**\r\n   * Scan a freshly-loaded module for cleanup handlers and register them on\r\n   * the FileManager so they run before the next reload. Priority: explicit\r\n   * `export function cleanup()` → `.$cleanup` on any exported value.\r\n   */\r\n  private registerCleanup(file: FileManager, module: Record<string, unknown>): void {\r\n    if (typeof module.cleanup === \"function\") {\r\n      file.addCleanup(module.cleanup as CleanupFunction);\r\n      return;\r\n    }\r\n\r\n    const cleanups: CleanupFunction[] = [];\r\n\r\n    for (const exportedValue of Object.values(module)) {\r\n      const cleanup = (exportedValue as { $cleanup?: unknown })?.$cleanup;\r\n      if (typeof cleanup === \"function\") {\r\n        cleanups.push(cleanup.bind(exportedValue) as CleanupFunction);\r\n      }\r\n    }\r\n\r\n    if (cleanups.length > 0) {\r\n      file.addCleanup(cleanups);\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;AAeA,MAAM,gBAA4C;CAAC;CAAU;CAAS;CAAQ;AAAO;;;;;;AAOrF,IAAa,eAAb,MAA0B;CAGxB,YAAY,AAAiB,uBAA8C;EAA9C;uCAFI,IAAI,IAAqB;CAEkB;;;;;CAM5E,MAAa,UAAyB;EACpC,KAAK,MAAM,QAAQ,eACjB,KAAK,MAAM,QAAQ,KAAK,sBAAsB,eAAe,IAAI,GAC/D,MAAM,KAAK,WAAW,MAAM,IAAI;CAGtC;;;;;CAMA,MAAa,WACX,MACA,MACwB;EACxB,IAAI,KAAK,aAAa,SAAS,MAAM,GAAG,OAAO;EAE/C,WAAW,sBAAsB;EAEjC,IAAI;GACF,MAAM,UAAU,cAAc,KAAK,YAAY,EAAE;GAEjD,MAAM,OAAO,YAAY;IACvB,MAAM,SAAU,MAAM,OAAO;IAC7B,KAAK,cAAc,IAAI,KAAK,cAAc,MAAM;IAChD,KAAK,gBAAgB,MAAM,MAAM;IACjC,OAAO;GACT;GAEA,OAAO,SAAS,UACZ,MAAM,OAAO,eAAe,KAAK,cAAc,IAAI,IACnD,MAAM,KAAK;EACjB,SAAS,OAAY;GACnB,IAAI,MAAM,SAAS,wBACjB,YAAY,0BAA0B,KAAK,CAAC;QAM5C,YACE,kBAAkB,KAAK,IAAI,KAAK,aAAa,KAAK,OAAO,WAAW,SACpE,KACF;GAEF;EACF,UAAU;GACR,WAAW,sBAAsB;EACnC;CACF;;;;;;CAOA,MAAa,aAAa,MAAkC;EAC1D,MAAM,aAAa,KAAK,sBAAsB,YAAY,KAAK,YAAY;EAC3E,IAAI,CAAC,YAAY;EAEjB,KAAK,WAAW,IAAI;EAEpB,IAAI,eAAe,SACjB,OAAO,yBAAyB,KAAK,YAAY;EAGnD,KAAK,cAAc,OAAO,KAAK,YAAY;EAC3C,MAAM,KAAK,WAAW,MAAM,UAAU;CACxC;;;;;CAMA,AAAO,WAAW,MAAyB;EACzC,KAAK,MAAM,QAAQ,KAAK,SACtB,IAAI;GACF,IAAI,OAAO,SAAS,YAClB,KAAK;QACA,IAAI,QAAQ,OAAQ,KAAsC,gBAAgB,YAC/E,AAAC,KAAqC,YAAY;EAEtD,QAAQ,CAER;EAEF,KAAK,aAAa;CACpB;;;;CAKA,AAAO,qBAAqB,MAAyB;EACnD,KAAK,cAAc,OAAO,KAAK,YAAY;EAE3C,IAAI,KAAK,SAAS,SAChB,OAAO,yBAAyB,KAAK,YAAY;EAGnD,KAAK,WAAW,IAAI;CACtB;;;;;;CAOA,AAAQ,gBAAgB,MAAmB,QAAuC;EAChF,IAAI,OAAO,OAAO,YAAY,YAAY;GACxC,KAAK,WAAW,OAAO,OAA0B;GACjD;EACF;EAEA,MAAM,WAA8B,CAAC;EAErC,KAAK,MAAM,iBAAiB,OAAO,OAAO,MAAM,GAAG;GACjD,MAAM,UAAW,eAA0C;GAC3D,IAAI,OAAO,YAAY,YACrB,SAAS,KAAK,QAAQ,KAAK,aAAa,CAAoB;EAEhE;EAEA,IAAI,SAAS,SAAS,GACpB,KAAK,WAAW,QAAQ;CAE5B;AACF"}
+{"version":3,"file":"module-loader.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/module-loader.ts"],"sourcesContent":["import { pathToFileURL } from \"node:url\";\r\nimport { router } from \"../router/router\";\r\nimport { devLogError, formatModuleNotFoundError } from \"./dev-logger\";\r\nimport type { CleanupFunction, FileManager } from \"./file-manager\";\r\nimport type { SpecialFileType, SpecialFilesCollector } from \"./special-files-collector\";\r\n\r\ndeclare global {\r\n  var __currentModuleFile: FileManager | undefined;\r\n}\r\n\r\n/**\r\n * The four \"special\" file kinds that the dev server eagerly imports at boot.\r\n * Order matters: locales first (used by everything), events before main so\r\n * listeners are registered when main runs, routes last so handlers are bound.\r\n */\r\nconst SPECIAL_TYPES: readonly SpecialFileType[] = [\"locale\", \"event\", \"main\", \"route\"] as const;\r\n\r\n/**\r\n * Loads application modules through the ESM loader hook. The hook stamps\r\n * `?v=N` on every import, so each reload is a fresh module without any\r\n * userland cache-busting plumbing.\r\n */\r\nexport class ModuleLoader {\r\n  private readonly loadedModules = new Map<string, unknown>();\r\n\r\n  constructor(private readonly specialFilesCollector: SpecialFilesCollector) {}\r\n\r\n  /**\r\n   * Eagerly load every special file at boot, in the canonical order so\r\n   * later phases (e.g. routes) see state earlier phases registered.\r\n   */\r\n  public async loadAll(): Promise<void> {\r\n    for (const type of SPECIAL_TYPES) {\r\n      for (const file of this.specialFilesCollector.getFilesByType(type)) {\r\n        await this.loadModule(file, type);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Import a file through the loader hook. For routes, scopes the import in\r\n   * `router.withSourceFile()` so the added routes carry their origin.\r\n   */\r\n  public async loadModule<T = unknown>(\r\n    file: FileManager,\r\n    type: string,\r\n  ): Promise<T | undefined> {\r\n    if (file.relativePath.endsWith(\".env\")) return undefined;\r\n\r\n    globalThis.__currentModuleFile = file;\r\n\r\n    try {\r\n      const fileUrl = pathToFileURL(file.absolutePath).href;\r\n\r\n      const load = async () => {\r\n        const module = (await import(fileUrl)) as Record<string, unknown>;\r\n        this.loadedModules.set(file.absolutePath, module);\r\n        this.registerCleanup(file, module);\r\n        return module as T;\r\n      };\r\n\r\n      return type === \"route\"\r\n        ? await router.withSourceFile(file.relativePath, load)\r\n        : await load();\r\n    } catch (error: any) {\r\n      if (error.code === \"ERR_MODULE_NOT_FOUND\") {\r\n        devLogError(formatModuleNotFoundError(error));\r\n      } else {\r\n        // Pass the error through so devLogError prints the stack. With dev\r\n        // source maps enabled, frames remap to the original `.ts` line/col\r\n        // (e.g. the actual call site of an undefined symbol) instead of\r\n        // vanishing — a one-line \"x is not defined\" is undebuggable.\r\n        devLogError(\r\n          `Failed to load ${type}: ${file.relativePath} - ${error?.message || error}`,\r\n          error,\r\n        );\r\n      }\r\n      return undefined;\r\n    } finally {\r\n      globalThis.__currentModuleFile = undefined;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reload a previously-loaded special file. The version-bump that makes the\r\n   * import fresh is done by the caller (layer-executor) before invoking this.\r\n   * Routes are removed from the registry first so re-registration is clean.\r\n   */\r\n  public async reloadModule(file: FileManager): Promise<void> {\r\n    const moduleType = this.specialFilesCollector.getFileType(file.relativePath);\r\n    if (!moduleType) return;\r\n\r\n    this.runCleanup(file);\r\n\r\n    if (moduleType === \"route\") {\r\n      router.removeRoutesBySourceFile(file.relativePath);\r\n    }\r\n\r\n    this.loadedModules.delete(file.absolutePath);\r\n    await this.loadModule(file, moduleType);\r\n  }\r\n\r\n  /**\r\n   * Run every cleanup hook the file registered (or `$cleanup` on its exports)\r\n   * and reset the list. Called once per HMR reload.\r\n   */\r\n  public runCleanup(file: FileManager): void {\r\n    for (const hook of file.cleanup) {\r\n      try {\r\n        if (typeof hook === \"function\") {\r\n          hook();\r\n        } else if (hook && typeof (hook as { unsubscribe?: () => void }).unsubscribe === \"function\") {\r\n          (hook as { unsubscribe: () => void }).unsubscribe();\r\n        }\r\n      } catch {\r\n        // Cleanup errors shouldn't break HMR.\r\n      }\r\n    }\r\n    file.resetCleanup();\r\n  }\r\n\r\n  /**\r\n   * Clean up after a file whose source was deleted from disk.\r\n   */\r\n  public cleanupDeletedModule(file: FileManager): void {\r\n    this.loadedModules.delete(file.absolutePath);\r\n\r\n    if (file.type === \"route\") {\r\n      router.removeRoutesBySourceFile(file.relativePath);\r\n    }\r\n\r\n    this.runCleanup(file);\r\n  }\r\n\r\n  /**\r\n   * Scan a freshly-loaded module for cleanup handlers and register them on\r\n   * the FileManager so they run before the next reload. Priority: explicit\r\n   * `export function cleanup()` → `.$cleanup` on any exported value.\r\n   */\r\n  private registerCleanup(file: FileManager, module: Record<string, unknown>): void {\r\n    if (typeof module.cleanup === \"function\") {\r\n      file.addCleanup(module.cleanup as CleanupFunction);\r\n      return;\r\n    }\r\n\r\n    const cleanups: CleanupFunction[] = [];\r\n\r\n    for (const exportedValue of Object.values(module)) {\r\n      const cleanup = (exportedValue as { $cleanup?: unknown })?.$cleanup;\r\n      if (typeof cleanup === \"function\") {\r\n        cleanups.push(cleanup.bind(exportedValue) as CleanupFunction);\r\n      }\r\n    }\r\n\r\n    if (cleanups.length > 0) {\r\n      file.addCleanup(cleanups);\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;AAeA,MAAM,gBAA4C;CAAC;CAAU;CAAS;CAAQ;AAAO;;;;;;AAOrF,IAAa,eAAb,MAA0B;CAGxB,YAAY,AAAiB,uBAA8C;EAA9C;uCAFI,IAAI,IAAqB;CAEkB;;;;;CAM5E,MAAa,UAAyB;EACpC,KAAK,MAAM,QAAQ,eACjB,KAAK,MAAM,QAAQ,KAAK,sBAAsB,eAAe,IAAI,GAC/D,MAAM,KAAK,WAAW,MAAM,IAAI;CAGtC;;;;;CAMA,MAAa,WACX,MACA,MACwB;EACxB,IAAI,KAAK,aAAa,SAAS,MAAM,GAAG,OAAO;EAE/C,WAAW,sBAAsB;EAEjC,IAAI;GACF,MAAM,UAAU,cAAc,KAAK,YAAY,CAAC,CAAC;GAEjD,MAAM,OAAO,YAAY;IACvB,MAAM,SAAU,MAAM,OAAO;IAC7B,KAAK,cAAc,IAAI,KAAK,cAAc,MAAM;IAChD,KAAK,gBAAgB,MAAM,MAAM;IACjC,OAAO;GACT;GAEA,OAAO,SAAS,UACZ,MAAM,OAAO,eAAe,KAAK,cAAc,IAAI,IACnD,MAAM,KAAK;EACjB,SAAS,OAAY;GACnB,IAAI,MAAM,SAAS,wBACjB,YAAY,0BAA0B,KAAK,CAAC;QAM5C,YACE,kBAAkB,KAAK,IAAI,KAAK,aAAa,KAAK,OAAO,WAAW,SACpE,KACF;GAEF;EACF,UAAU;GACR,WAAW,sBAAsB;EACnC;CACF;;;;;;CAOA,MAAa,aAAa,MAAkC;EAC1D,MAAM,aAAa,KAAK,sBAAsB,YAAY,KAAK,YAAY;EAC3E,IAAI,CAAC,YAAY;EAEjB,KAAK,WAAW,IAAI;EAEpB,IAAI,eAAe,SACjB,OAAO,yBAAyB,KAAK,YAAY;EAGnD,KAAK,cAAc,OAAO,KAAK,YAAY;EAC3C,MAAM,KAAK,WAAW,MAAM,UAAU;CACxC;;;;;CAMA,AAAO,WAAW,MAAyB;EACzC,KAAK,MAAM,QAAQ,KAAK,SACtB,IAAI;GACF,IAAI,OAAO,SAAS,YAClB,KAAK;QACA,IAAI,QAAQ,OAAQ,KAAsC,gBAAgB,YAC/E,AAAC,KAAqC,YAAY;EAEtD,QAAQ,CAER;EAEF,KAAK,aAAa;CACpB;;;;CAKA,AAAO,qBAAqB,MAAyB;EACnD,KAAK,cAAc,OAAO,KAAK,YAAY;EAE3C,IAAI,KAAK,SAAS,SAChB,OAAO,yBAAyB,KAAK,YAAY;EAGnD,KAAK,WAAW,IAAI;CACtB;;;;;;CAOA,AAAQ,gBAAgB,MAAmB,QAAuC;EAChF,IAAI,OAAO,OAAO,YAAY,YAAY;GACxC,KAAK,WAAW,OAAO,OAA0B;GACjD;EACF;EAEA,MAAM,WAA8B,CAAC;EAErC,KAAK,MAAM,iBAAiB,OAAO,OAAO,MAAM,GAAG;GACjD,MAAM,UAAW,eAA0C;GAC3D,IAAI,OAAO,YAAY,YACrB,SAAS,KAAK,QAAQ,KAAK,aAAa,CAAoB;EAEhE;EAEA,IAAI,SAAS,SAAS,GACpB,KAAK,WAAW,QAAQ;CAE5B;AACF"}

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

@@ -1,7 +1,7 @@
 import { Path } from "./path.mjs";
 import { getJsonFileAsync } from "@warlock.js/fs";
 
-//#region ../../@warlock.js/core/src/dev-server/package-json-manager.ts
+//#region ../@warlock.js/core/src/dev-server/package-json-manager.ts
 var PackageJsonManager = class {
 	constructor() {
 		this.packageJson = {};

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

@@ -1 +1 @@
-{"version":3,"file":"package-json-manager.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/package-json-manager.ts"],"sourcesContent":["import { getJsonFileAsync } from \"@warlock.js/fs\";\r\nimport { Path } from \"./path\";\r\n\r\nexport class PackageJsonManager {\r\n  /**\r\n   * Package.json data\r\n   */\r\n  public packageJson: any = {};\r\n\r\n  /**\r\n   * Initialize the package.json manager\r\n   */\r\n  public async init() {\r\n    this.packageJson = await getJsonFileAsync(Path.toAbsolute(\"package.json\"));\r\n  }\r\n\r\n  /**\r\n   * Check if the given path is a package path\r\n   */\r\n  public isPathPackage(path: string) {\r\n    const allPackages = Object.keys(this.packageJson.dependencies || {}).concat(\r\n      Object.keys(this.packageJson.devDependencies || {}),\r\n    );\r\n\r\n    return allPackages.some((packageName) => path.startsWith(packageName));\r\n  }\r\n}\r\n\r\nexport const packageJsonManager = new PackageJsonManager();\r\n"],"mappings":";;;;AAGA,IAAa,qBAAb,MAAgC;;qBAIJ,CAAC;;;;;CAK3B,MAAa,OAAO;EAClB,KAAK,cAAc,MAAM,iBAAiB,KAAK,WAAW,cAAc,CAAC;CAC3E;;;;CAKA,AAAO,cAAc,MAAc;EAKjC,OAJoB,OAAO,KAAK,KAAK,YAAY,gBAAgB,CAAC,CAAC,EAAE,OACnE,OAAO,KAAK,KAAK,YAAY,mBAAmB,CAAC,CAAC,CAGnC,EAAE,MAAM,gBAAgB,KAAK,WAAW,WAAW,CAAC;CACvE;AACF;AAEA,MAAa,qBAAqB,IAAI,mBAAmB"}
+{"version":3,"file":"package-json-manager.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/package-json-manager.ts"],"sourcesContent":["import { getJsonFileAsync } from \"@warlock.js/fs\";\r\nimport { Path } from \"./path\";\r\n\r\nexport class PackageJsonManager {\r\n  /**\r\n   * Package.json data\r\n   */\r\n  public packageJson: any = {};\r\n\r\n  /**\r\n   * Initialize the package.json manager\r\n   */\r\n  public async init() {\r\n    this.packageJson = await getJsonFileAsync(Path.toAbsolute(\"package.json\"));\r\n  }\r\n\r\n  /**\r\n   * Check if the given path is a package path\r\n   */\r\n  public isPathPackage(path: string) {\r\n    const allPackages = Object.keys(this.packageJson.dependencies || {}).concat(\r\n      Object.keys(this.packageJson.devDependencies || {}),\r\n    );\r\n\r\n    return allPackages.some((packageName) => path.startsWith(packageName));\r\n  }\r\n}\r\n\r\nexport const packageJsonManager = new PackageJsonManager();\r\n"],"mappings":";;;;AAGA,IAAa,qBAAb,MAAgC;;qBAIJ,CAAC;;;;;CAK3B,MAAa,OAAO;EAClB,KAAK,cAAc,MAAM,iBAAiB,KAAK,WAAW,cAAc,CAAC;CAC3E;;;;CAKA,AAAO,cAAc,MAAc;EAKjC,OAJoB,OAAO,KAAK,KAAK,YAAY,gBAAgB,CAAC,CAAC,CAAC,CAAC,OACnE,OAAO,KAAK,KAAK,YAAY,mBAAmB,CAAC,CAAC,CAGnC,CAAC,CAAC,MAAM,gBAAgB,KAAK,WAAW,WAAW,CAAC;CACvE;AACF;AAEA,MAAa,qBAAqB,IAAI,mBAAmB"}

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

@@ -4,7 +4,7 @@ import { directoryExistsAsync, fileExistsAsync } from "@warlock.js/fs";
 import path from "node:path";
 import { parse } from "es-module-lexer";
 
-//#region ../../@warlock.js/core/src/dev-server/parse-imports.ts
+//#region ../@warlock.js/core/src/dev-server/parse-imports.ts
 /**
 * Detect if a file contains only type definitions (no runtime code)
 *

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

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

package/esm/dev-server/path.mjs

@@ -1,6 +1,6 @@
 import path from "node:path";
 
-//#region ../../@warlock.js/core/src/dev-server/path.ts
+//#region ../@warlock.js/core/src/dev-server/path.ts
 var Path = class {
 	/**
 	* Convert the given absolute path to a relative path

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

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

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

@@ -1,6 +1,6 @@
 import { FileManager } from "./file-manager.mjs";
 
-//#region ../../@warlock.js/core/src/dev-server/special-files-collector.d.ts
+//#region ../@warlock.js/core/src/dev-server/special-files-collector.d.ts
 type SpecialFileType = "config" | "main" | "route" | "event" | "locale";
 /**
  * Categorises files into the kinds the dev server treats specially

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

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

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

@@ -1,4 +1,4 @@
-//#region ../../@warlock.js/core/src/dev-server/special-files-collector.ts
+//#region ../@warlock.js/core/src/dev-server/special-files-collector.ts
 /**
 * Categorises files into the kinds the dev server treats specially
 * (config / main / route / event / locale) and exposes typed accessors.

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

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

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

@@ -2,7 +2,7 @@ import { Path } from "./path.mjs";
 import path from "node:path";
 import ts from "typescript";
 
-//#region ../../@warlock.js/core/src/dev-server/tsconfig-manager.ts
+//#region ../@warlock.js/core/src/dev-server/tsconfig-manager.ts
 var TSConfigManager = class {
 	constructor() {
 		this.aliases = {};

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

@@ -1 +1 @@
-{"version":3,"file":"tsconfig-manager.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/tsconfig-manager.ts"],"sourcesContent":["import path from \"node:path\";\nimport ts from \"typescript\";\nimport { Path } from \"./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    // use typescript to load the tsconfig.json file\n    const output = ts.readConfigFile(Path.toAbsolute(\"tsconfig.json\"), ts.sys.readFile);\n\n    this.tsconfig = output.config!;\n\n    this.aliases = output.config?.compilerOptions?.paths || {};\n\n    this.baseUrl = output.config?.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      // Remove /* from alias pattern for matching\n      const aliasPattern = alias.replace(\"/*\", \"\");\n\n      if (!path.startsWith(aliasPattern)) {\n        return false;\n      }\n\n      // Check if this is a real alias or just an external package mapping\n      const aliasTargets = this.aliases[alias];\n      if (!Array.isArray(aliasTargets) || aliasTargets.length === 0) {\n        return false;\n      }\n\n      // If the alias starts with @, it's likely an external package alias\n      // Example: \"@warlock.js/core\" -> \"@warlock.js/core\" (external package)\n      if (aliasPattern.startsWith(\"@\")) {\n        return false;\n      }\n\n      // Otherwise, it's a real path alias (including self-referencing ones like src/* -> src/*)\n      // Example: \"app/*\" -> \"src/app/*\" (real alias)\n      // Example: \"src/*\" -> \"src/*\" (self-referencing alias, still valid)\n      return true;\n    });\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      const aliasPattern = alias.replace(\"/*\", \"\");\n      return path.startsWith(aliasPattern);\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    // 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":";;;;;AAIA,IAAa,kBAAb,MAA6B;;iBAIgB,CAAC;iBAKnB;;CAOzB,AAAO,OAAO;EACZ,IAAI,KAAK,UAAU;EAGnB,MAAM,SAAS,GAAG,eAAe,KAAK,WAAW,eAAe,GAAG,GAAG,IAAI,QAAQ;EAElF,KAAK,WAAW,OAAO;EAEvB,KAAK,UAAU,OAAO,QAAQ,iBAAiB,SAAS,CAAC;EAEzD,KAAK,UAAU,OAAO,QAAQ,iBAAiB,WAAW;CAC5D;;;;;;;;CASA,AAAO,QAAQ,MAAc;EAC3B,IAAI,CAAC,KAAK,UACR,KAAK,KAAK;EAGZ,OAAO,OAAO,KAAK,KAAK,OAAO,EAAE,MAAM,UAAU;GAE/C,MAAM,eAAe,MAAM,QAAQ,MAAM,EAAE;GAE3C,IAAI,CAAC,KAAK,WAAW,YAAY,GAC/B,OAAO;GAIT,MAAM,eAAe,KAAK,QAAQ;GAClC,IAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,aAAa,WAAW,GAC1D,OAAO;GAKT,IAAI,aAAa,WAAW,GAAG,GAC7B,OAAO;GAMT,OAAO;EACT,CAAC;CACH;;;;CAKA,AAAO,iBAAiB,MAA6B;EAMnD,OALiB,OAAO,KAAK,KAAK,OAAO,EAAE,MAAM,UAAU;GACzD,MAAM,eAAe,MAAM,QAAQ,MAAM,EAAE;GAC3C,OAAO,KAAK,WAAW,YAAY;EACrC,CAEc,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;EAGnC,MAAM,eAAe,SAAS,QAAQ,MAAM,EAAE;EAC9C,MAAM,aAAa,cAAc,QAAQ,MAAM,EAAE;EAEjD,MAAM,eAAe,aAAa,UAAU,aAAa,MAAM,EAAE,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":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/tsconfig-manager.ts"],"sourcesContent":["import path from \"node:path\";\nimport ts from \"typescript\";\nimport { Path } from \"./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    // use typescript to load the tsconfig.json file\n    const output = ts.readConfigFile(Path.toAbsolute(\"tsconfig.json\"), ts.sys.readFile);\n\n    this.tsconfig = output.config!;\n\n    this.aliases = output.config?.compilerOptions?.paths || {};\n\n    this.baseUrl = output.config?.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      // Remove /* from alias pattern for matching\n      const aliasPattern = alias.replace(\"/*\", \"\");\n\n      if (!path.startsWith(aliasPattern)) {\n        return false;\n      }\n\n      // Check if this is a real alias or just an external package mapping\n      const aliasTargets = this.aliases[alias];\n      if (!Array.isArray(aliasTargets) || aliasTargets.length === 0) {\n        return false;\n      }\n\n      // If the alias starts with @, it's likely an external package alias\n      // Example: \"@warlock.js/core\" -> \"@warlock.js/core\" (external package)\n      if (aliasPattern.startsWith(\"@\")) {\n        return false;\n      }\n\n      // Otherwise, it's a real path alias (including self-referencing ones like src/* -> src/*)\n      // Example: \"app/*\" -> \"src/app/*\" (real alias)\n      // Example: \"src/*\" -> \"src/*\" (self-referencing alias, still valid)\n      return true;\n    });\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      const aliasPattern = alias.replace(\"/*\", \"\");\n      return path.startsWith(aliasPattern);\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    // 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":";;;;;AAIA,IAAa,kBAAb,MAA6B;;iBAIgB,CAAC;iBAKnB;;CAOzB,AAAO,OAAO;EACZ,IAAI,KAAK,UAAU;EAGnB,MAAM,SAAS,GAAG,eAAe,KAAK,WAAW,eAAe,GAAG,GAAG,IAAI,QAAQ;EAElF,KAAK,WAAW,OAAO;EAEvB,KAAK,UAAU,OAAO,QAAQ,iBAAiB,SAAS,CAAC;EAEzD,KAAK,UAAU,OAAO,QAAQ,iBAAiB,WAAW;CAC5D;;;;;;;;CASA,AAAO,QAAQ,MAAc;EAC3B,IAAI,CAAC,KAAK,UACR,KAAK,KAAK;EAGZ,OAAO,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,MAAM,UAAU;GAE/C,MAAM,eAAe,MAAM,QAAQ,MAAM,EAAE;GAE3C,IAAI,CAAC,KAAK,WAAW,YAAY,GAC/B,OAAO;GAIT,MAAM,eAAe,KAAK,QAAQ;GAClC,IAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,aAAa,WAAW,GAC1D,OAAO;GAKT,IAAI,aAAa,WAAW,GAAG,GAC7B,OAAO;GAMT,OAAO;EACT,CAAC;CACH;;;;CAKA,AAAO,iBAAiB,MAA6B;EAMnD,OALiB,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,MAAM,UAAU;GACzD,MAAM,eAAe,MAAM,QAAQ,MAAM,EAAE;GAC3C,OAAO,KAAK,WAAW,YAAY;EACrC,CAEc,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;EAGnC,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"}

package/esm/dev-server/types.d.mts

@@ -1,4 +1,4 @@
-//#region ../../@warlock.js/core/src/dev-server/types.d.ts
+//#region ../@warlock.js/core/src/dev-server/types.d.ts
 type FileType = "main" | "config" | "event" | "route" | "controller" | "service" | "model" | "other";
 type FileManifest = {
   absolutePath: string;

package/esm/dev-server/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/types.ts"],"mappings":";KAAY,QAAA;AAAA,KAUA,YAAA;EACV,YAAA;EACA,YAAA;EACA,YAAA;EACA,IAAA;EACA,YAAA;EALsB;;;;;;;EAatB,oBAAA;EACA,UAAA;EACA,IAAA,EAAM,QAAQ;AAAA;;;AAAA;AAWhB;;;;AAAqB;KAAT,SAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/types.ts"],"mappings":";KAAY,QAAA;AAAA,KAUA,YAAA;EACV,YAAA;EACA,YAAA;EACA,YAAA;EACA,IAAA;EACA,YAAA;EALsB;;;;;;;EAatB,oBAAA;EACA,UAAA;EACA,IAAA,EAAM,QAAQ;AAAA;;;AAAA;AAWhB;;;;AAAqB;KAAT,SAAA"}

package/esm/dev-server/utils.mjs

@@ -4,7 +4,7 @@ import { Path } from "./path.mjs";
 import { ensureDirectoryAsync } from "@warlock.js/fs";
 import glob from "fast-glob";
 
-//#region ../../@warlock.js/core/src/dev-server/utils.ts
+//#region ../@warlock.js/core/src/dev-server/utils.ts
 /**
 * Ensure the .warlock/ directory exists. Used by the loader-hook
 * registration which writes its bundled hook file into this directory.

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

@@ -1 +1 @@
-{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/utils.ts"],"sourcesContent":["import { ensureDirectoryAsync } from \"@warlock.js/fs\";\r\nimport glob from \"fast-glob\";\r\nimport { srcPath, warlockPath } from \"../utils\";\r\nimport { Path } from \"./path\";\r\n\r\n/**\r\n * Ensure the .warlock/ directory exists. Used by the loader-hook\r\n * registration which writes its bundled hook file into this directory.\r\n */\r\nexport async function ensureWarlockDirectory() {\r\n  await ensureDirectoryAsync(warlockPath());\r\n}\r\n\r\n/**\r\n * Glob the project's `src/` directory for `.ts`/`.tsx` files. Returns\r\n * normalised absolute paths.\r\n */\r\nexport async function getFilesFromDirectory(directoryPath = srcPath(), pattern = \"**/*.{ts,tsx}\") {\r\n  const files = await glob(`${Path.normalize(directoryPath)}/${pattern}`, { absolute: true });\r\n  return files.map(file => Path.normalize(file));\r\n}\r\n\r\nexport async function getCertainFilesFromDirectory(directoryPath: string, filesNames: string[]) {\r\n  const pattern = filesNames.length === 1 ? filesNames[0] : `(${filesNames.join(\"|\")})`;\r\n  return getFilesFromDirectory(directoryPath, pattern + \".{ts,tsx}\");\r\n}\r\n\r\nexport function areSetsEqual<T>(set1: Set<T>, set2: Set<T>): boolean {\r\n  if (set1.size !== set2.size) return false;\r\n  for (const item of set1) {\r\n    if (!set2.has(item)) return false;\r\n  }\r\n  return true;\r\n}\r\n"],"mappings":";;;;;;;;;;;AASA,eAAsB,yBAAyB;CAC7C,MAAM,qBAAqB,YAAY,CAAC;AAC1C;;;;;AAMA,eAAsB,sBAAsB,gBAAgB,QAAQ,GAAG,UAAU,iBAAiB;CAEhG,QAAO,MADa,KAAK,GAAG,KAAK,UAAU,aAAa,EAAE,GAAG,WAAW,EAAE,UAAU,KAAK,CAAC,GAC7E,KAAI,SAAQ,KAAK,UAAU,IAAI,CAAC;AAC/C;AAEA,eAAsB,6BAA6B,eAAuB,YAAsB;CAE9F,OAAO,sBAAsB,gBADb,WAAW,WAAW,IAAI,WAAW,KAAK,IAAI,WAAW,KAAK,GAAG,EAAE,MAC7B,WAAW;AACnE;AAEA,SAAgB,aAAgB,MAAc,MAAuB;CACnE,IAAI,KAAK,SAAS,KAAK,MAAM,OAAO;CACpC,KAAK,MAAM,QAAQ,MACjB,IAAI,CAAC,KAAK,IAAI,IAAI,GAAG,OAAO;CAE9B,OAAO;AACT"}
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/utils.ts"],"sourcesContent":["import { ensureDirectoryAsync } from \"@warlock.js/fs\";\r\nimport glob from \"fast-glob\";\r\nimport { srcPath, warlockPath } from \"../utils\";\r\nimport { Path } from \"./path\";\r\n\r\n/**\r\n * Ensure the .warlock/ directory exists. Used by the loader-hook\r\n * registration which writes its bundled hook file into this directory.\r\n */\r\nexport async function ensureWarlockDirectory() {\r\n  await ensureDirectoryAsync(warlockPath());\r\n}\r\n\r\n/**\r\n * Glob the project's `src/` directory for `.ts`/`.tsx` files. Returns\r\n * normalised absolute paths.\r\n */\r\nexport async function getFilesFromDirectory(directoryPath = srcPath(), pattern = \"**/*.{ts,tsx}\") {\r\n  const files = await glob(`${Path.normalize(directoryPath)}/${pattern}`, { absolute: true });\r\n  return files.map(file => Path.normalize(file));\r\n}\r\n\r\nexport async function getCertainFilesFromDirectory(directoryPath: string, filesNames: string[]) {\r\n  const pattern = filesNames.length === 1 ? filesNames[0] : `(${filesNames.join(\"|\")})`;\r\n  return getFilesFromDirectory(directoryPath, pattern + \".{ts,tsx}\");\r\n}\r\n\r\nexport function areSetsEqual<T>(set1: Set<T>, set2: Set<T>): boolean {\r\n  if (set1.size !== set2.size) return false;\r\n  for (const item of set1) {\r\n    if (!set2.has(item)) return false;\r\n  }\r\n  return true;\r\n}\r\n"],"mappings":";;;;;;;;;;;AASA,eAAsB,yBAAyB;CAC7C,MAAM,qBAAqB,YAAY,CAAC;AAC1C;;;;;AAMA,eAAsB,sBAAsB,gBAAgB,QAAQ,GAAG,UAAU,iBAAiB;CAEhG,QAAO,MADa,KAAK,GAAG,KAAK,UAAU,aAAa,EAAE,GAAG,WAAW,EAAE,UAAU,KAAK,CAAC,EAC9E,CAAC,KAAI,SAAQ,KAAK,UAAU,IAAI,CAAC;AAC/C;AAEA,eAAsB,6BAA6B,eAAuB,YAAsB;CAE9F,OAAO,sBAAsB,gBADb,WAAW,WAAW,IAAI,WAAW,KAAK,IAAI,WAAW,KAAK,GAAG,EAAE,MAC7B,WAAW;AACnE;AAEA,SAAgB,aAAgB,MAAc,MAAuB;CACnE,IAAI,KAAK,SAAS,KAAK,MAAM,OAAO;CACpC,KAAK,MAAM,QAAQ,MACjB,IAAI,CAAC,KAAK,IAAI,IAAI,GAAG,OAAO;CAE9B,OAAO;AACT"}

package/esm/encryption/encrypt.d.mts

@@ -1,4 +1,4 @@
-//#region ../../@warlock.js/core/src/encryption/encrypt.d.ts
+//#region ../@warlock.js/core/src/encryption/encrypt.d.ts
 /**
  * Encrypts a plaintext string using AES-256-GCM (or the configured algorithm).
  * Returns a combined string in the format `iv:ciphertext:authTag`.

package/esm/encryption/encrypt.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"encrypt.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/encryption/encrypt.ts"],"mappings":";;AAoDA;;;;AAAyC;AAiCzC;;;;iBAjCgB,OAAA,CAAQ,SAAiB;;;;;;;;;;;iBAiCzB,OAAA,CAAQ,UAAkB"}
+{"version":3,"file":"encrypt.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/encryption/encrypt.ts"],"mappings":";;AAoDA;;;;AAAyC;AAiCzC;;;;iBAjCgB,OAAA,CAAQ,SAAiB;;;;;;;;;;;iBAiCzB,OAAA,CAAQ,UAAkB"}

package/esm/encryption/encrypt.mjs

@@ -2,7 +2,7 @@ import { config } from "../config/config-getter.mjs";
 import "../config/index.mjs";
 import crypto from "crypto";
 
-//#region ../../@warlock.js/core/src/encryption/encrypt.ts
+//#region ../@warlock.js/core/src/encryption/encrypt.ts
 /**
 * Default encryption algorithm.
 */

package/esm/encryption/encrypt.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"encrypt.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/encryption/encrypt.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport { config } from \"../config\";\nimport { EncryptionConfigurations } from \"./types\";\n\n/**\n * Default encryption algorithm.\n */\nconst DEFAULT_ALGORITHM = \"aes-256-gcm\";\n\n/**\n * Get the encryption key from config, validated as a 32-byte hex string.\n */\nfunction getEncryptionKey(): Buffer {\n  const key = config.key<EncryptionConfigurations[\"key\"]>(\"encryption.key\");\n\n  if (!key) {\n    throw new Error(\n      \"Missing encryption key. Set 'encryption.key' in your config (64 hex characters = 32 bytes).\",\n    );\n  }\n\n  const buffer = Buffer.from(key, \"hex\");\n\n  if (buffer.length !== 32) {\n    throw new Error(\n      `Encryption key must be exactly 32 bytes (64 hex characters). Got ${buffer.length} bytes for key ${key}.`,\n    );\n  }\n\n  return buffer;\n}\n\n/**\n * Get the configured encryption algorithm, defaults to aes-256-gcm.\n */\nfunction getAlgorithm(): string {\n  return config.key<EncryptionConfigurations[\"algorithm\"]>(\n    \"encryption.algorithm\",\n    DEFAULT_ALGORITHM,\n  )!;\n}\n\n/**\n * Encrypts a plaintext string using AES-256-GCM (or the configured algorithm).\n * Returns a combined string in the format `iv:ciphertext:authTag`.\n *\n * @example\n * import { encrypt } from \"@warlock.js/core\";\n *\n * const encrypted = encrypt(\"sk-proj-12345\");\n * // => \"a1b2c3...:d4e5f6...:g7h8i9...\"\n */\nexport function encrypt(plainText: string): string {\n  if (!plainText) return plainText;\n\n  const keyBuffer = getEncryptionKey();\n  const algorithm = getAlgorithm();\n\n  try {\n    // IV must be unique per encryption. 16 bytes is standard for AES.\n    const iv = crypto.randomBytes(16);\n    const cipher = crypto.createCipheriv(algorithm, keyBuffer, iv);\n\n    let encrypted = cipher.update(plainText, \"utf8\", \"hex\");\n    encrypted += cipher.final(\"hex\");\n\n    // Auth tag validates ciphertext integrity (tamper detection)\n    const authTag = (cipher as crypto.CipherGCM).getAuthTag().toString(\"hex\");\n\n    return `${iv.toString(\"hex\")}:${encrypted}:${authTag}`;\n  } catch (error) {\n    throw new Error(`Encryption failed: ${(error as Error).message}`);\n  }\n}\n\n/**\n * Decrypts a string previously encrypted with {@link encrypt}.\n * Expects the format `iv:ciphertext:authTag`.\n *\n * @example\n * import { decrypt } from \"@warlock.js/core\";\n *\n * const original = decrypt(encryptedString);\n * // => \"sk-proj-12345\"\n */\nexport function decrypt(cipherText: string): string {\n  if (!cipherText) return cipherText;\n\n  const keyBuffer = getEncryptionKey();\n  const algorithm = getAlgorithm();\n\n  try {\n    const parts = cipherText.split(\":\");\n\n    if (parts.length !== 3) {\n      throw new Error(\"Invalid encrypted format. Expected iv:ciphertext:authTag\");\n    }\n\n    const [ivHex, encryptedHex, authTagHex] = parts;\n\n    const decipher = crypto.createDecipheriv(algorithm, keyBuffer, Buffer.from(ivHex, \"hex\"));\n\n    (decipher as crypto.DecipherGCM).setAuthTag(Buffer.from(authTagHex, \"hex\"));\n\n    let decrypted = decipher.update(encryptedHex, \"hex\", \"utf8\");\n    // .final() throws if auth tag is invalid (data tampered)\n    decrypted += decipher.final(\"utf8\");\n\n    return decrypted;\n  } catch (error) {\n    throw new Error(`Decryption failed: ${(error as Error).message}`);\n  }\n}\n"],"mappings":";;;;;;;;AAOA,MAAM,oBAAoB;;;;AAK1B,SAAS,mBAA2B;CAClC,MAAM,MAAM,OAAO,IAAqC,gBAAgB;CAExE,IAAI,CAAC,KACH,MAAM,IAAI,MACR,6FACF;CAGF,MAAM,SAAS,OAAO,KAAK,KAAK,KAAK;CAErC,IAAI,OAAO,WAAW,IACpB,MAAM,IAAI,MACR,oEAAoE,OAAO,OAAO,iBAAiB,IAAI,EACzG;CAGF,OAAO;AACT;;;;AAKA,SAAS,eAAuB;CAC9B,OAAO,OAAO,IACZ,wBACA,iBACF;AACF;;;;;;;;;;;AAYA,SAAgB,QAAQ,WAA2B;CACjD,IAAI,CAAC,WAAW,OAAO;CAEvB,MAAM,YAAY,iBAAiB;CACnC,MAAM,YAAY,aAAa;CAE/B,IAAI;EAEF,MAAM,KAAK,OAAO,YAAY,EAAE;EAChC,MAAM,SAAS,OAAO,eAAe,WAAW,WAAW,EAAE;EAE7D,IAAI,YAAY,OAAO,OAAO,WAAW,QAAQ,KAAK;EACtD,aAAa,OAAO,MAAM,KAAK;EAG/B,MAAM,UAAW,OAA4B,WAAW,EAAE,SAAS,KAAK;EAExE,OAAO,GAAG,GAAG,SAAS,KAAK,EAAE,GAAG,UAAU,GAAG;CAC/C,SAAS,OAAO;EACd,MAAM,IAAI,MAAM,sBAAuB,MAAgB,SAAS;CAClE;AACF;;;;;;;;;;;AAYA,SAAgB,QAAQ,YAA4B;CAClD,IAAI,CAAC,YAAY,OAAO;CAExB,MAAM,YAAY,iBAAiB;CACnC,MAAM,YAAY,aAAa;CAE/B,IAAI;EACF,MAAM,QAAQ,WAAW,MAAM,GAAG;EAElC,IAAI,MAAM,WAAW,GACnB,MAAM,IAAI,MAAM,0DAA0D;EAG5E,MAAM,CAAC,OAAO,cAAc,cAAc;EAE1C,MAAM,WAAW,OAAO,iBAAiB,WAAW,WAAW,OAAO,KAAK,OAAO,KAAK,CAAC;EAExF,AAAC,SAAgC,WAAW,OAAO,KAAK,YAAY,KAAK,CAAC;EAE1E,IAAI,YAAY,SAAS,OAAO,cAAc,OAAO,MAAM;EAE3D,aAAa,SAAS,MAAM,MAAM;EAElC,OAAO;CACT,SAAS,OAAO;EACd,MAAM,IAAI,MAAM,sBAAuB,MAAgB,SAAS;CAClE;AACF"}
+{"version":3,"file":"encrypt.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/encryption/encrypt.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport { config } from \"../config\";\nimport { EncryptionConfigurations } from \"./types\";\n\n/**\n * Default encryption algorithm.\n */\nconst DEFAULT_ALGORITHM = \"aes-256-gcm\";\n\n/**\n * Get the encryption key from config, validated as a 32-byte hex string.\n */\nfunction getEncryptionKey(): Buffer {\n  const key = config.key<EncryptionConfigurations[\"key\"]>(\"encryption.key\");\n\n  if (!key) {\n    throw new Error(\n      \"Missing encryption key. Set 'encryption.key' in your config (64 hex characters = 32 bytes).\",\n    );\n  }\n\n  const buffer = Buffer.from(key, \"hex\");\n\n  if (buffer.length !== 32) {\n    throw new Error(\n      `Encryption key must be exactly 32 bytes (64 hex characters). Got ${buffer.length} bytes for key ${key}.`,\n    );\n  }\n\n  return buffer;\n}\n\n/**\n * Get the configured encryption algorithm, defaults to aes-256-gcm.\n */\nfunction getAlgorithm(): string {\n  return config.key<EncryptionConfigurations[\"algorithm\"]>(\n    \"encryption.algorithm\",\n    DEFAULT_ALGORITHM,\n  )!;\n}\n\n/**\n * Encrypts a plaintext string using AES-256-GCM (or the configured algorithm).\n * Returns a combined string in the format `iv:ciphertext:authTag`.\n *\n * @example\n * import { encrypt } from \"@warlock.js/core\";\n *\n * const encrypted = encrypt(\"sk-proj-12345\");\n * // => \"a1b2c3...:d4e5f6...:g7h8i9...\"\n */\nexport function encrypt(plainText: string): string {\n  if (!plainText) return plainText;\n\n  const keyBuffer = getEncryptionKey();\n  const algorithm = getAlgorithm();\n\n  try {\n    // IV must be unique per encryption. 16 bytes is standard for AES.\n    const iv = crypto.randomBytes(16);\n    const cipher = crypto.createCipheriv(algorithm, keyBuffer, iv);\n\n    let encrypted = cipher.update(plainText, \"utf8\", \"hex\");\n    encrypted += cipher.final(\"hex\");\n\n    // Auth tag validates ciphertext integrity (tamper detection)\n    const authTag = (cipher as crypto.CipherGCM).getAuthTag().toString(\"hex\");\n\n    return `${iv.toString(\"hex\")}:${encrypted}:${authTag}`;\n  } catch (error) {\n    throw new Error(`Encryption failed: ${(error as Error).message}`);\n  }\n}\n\n/**\n * Decrypts a string previously encrypted with {@link encrypt}.\n * Expects the format `iv:ciphertext:authTag`.\n *\n * @example\n * import { decrypt } from \"@warlock.js/core\";\n *\n * const original = decrypt(encryptedString);\n * // => \"sk-proj-12345\"\n */\nexport function decrypt(cipherText: string): string {\n  if (!cipherText) return cipherText;\n\n  const keyBuffer = getEncryptionKey();\n  const algorithm = getAlgorithm();\n\n  try {\n    const parts = cipherText.split(\":\");\n\n    if (parts.length !== 3) {\n      throw new Error(\"Invalid encrypted format. Expected iv:ciphertext:authTag\");\n    }\n\n    const [ivHex, encryptedHex, authTagHex] = parts;\n\n    const decipher = crypto.createDecipheriv(algorithm, keyBuffer, Buffer.from(ivHex, \"hex\"));\n\n    (decipher as crypto.DecipherGCM).setAuthTag(Buffer.from(authTagHex, \"hex\"));\n\n    let decrypted = decipher.update(encryptedHex, \"hex\", \"utf8\");\n    // .final() throws if auth tag is invalid (data tampered)\n    decrypted += decipher.final(\"utf8\");\n\n    return decrypted;\n  } catch (error) {\n    throw new Error(`Decryption failed: ${(error as Error).message}`);\n  }\n}\n"],"mappings":";;;;;;;;AAOA,MAAM,oBAAoB;;;;AAK1B,SAAS,mBAA2B;CAClC,MAAM,MAAM,OAAO,IAAqC,gBAAgB;CAExE,IAAI,CAAC,KACH,MAAM,IAAI,MACR,6FACF;CAGF,MAAM,SAAS,OAAO,KAAK,KAAK,KAAK;CAErC,IAAI,OAAO,WAAW,IACpB,MAAM,IAAI,MACR,oEAAoE,OAAO,OAAO,iBAAiB,IAAI,EACzG;CAGF,OAAO;AACT;;;;AAKA,SAAS,eAAuB;CAC9B,OAAO,OAAO,IACZ,wBACA,iBACF;AACF;;;;;;;;;;;AAYA,SAAgB,QAAQ,WAA2B;CACjD,IAAI,CAAC,WAAW,OAAO;CAEvB,MAAM,YAAY,iBAAiB;CACnC,MAAM,YAAY,aAAa;CAE/B,IAAI;EAEF,MAAM,KAAK,OAAO,YAAY,EAAE;EAChC,MAAM,SAAS,OAAO,eAAe,WAAW,WAAW,EAAE;EAE7D,IAAI,YAAY,OAAO,OAAO,WAAW,QAAQ,KAAK;EACtD,aAAa,OAAO,MAAM,KAAK;EAG/B,MAAM,UAAW,OAA4B,WAAW,CAAC,CAAC,SAAS,KAAK;EAExE,OAAO,GAAG,GAAG,SAAS,KAAK,EAAE,GAAG,UAAU,GAAG;CAC/C,SAAS,OAAO;EACd,MAAM,IAAI,MAAM,sBAAuB,MAAgB,SAAS;CAClE;AACF;;;;;;;;;;;AAYA,SAAgB,QAAQ,YAA4B;CAClD,IAAI,CAAC,YAAY,OAAO;CAExB,MAAM,YAAY,iBAAiB;CACnC,MAAM,YAAY,aAAa;CAE/B,IAAI;EACF,MAAM,QAAQ,WAAW,MAAM,GAAG;EAElC,IAAI,MAAM,WAAW,GACnB,MAAM,IAAI,MAAM,0DAA0D;EAG5E,MAAM,CAAC,OAAO,cAAc,cAAc;EAE1C,MAAM,WAAW,OAAO,iBAAiB,WAAW,WAAW,OAAO,KAAK,OAAO,KAAK,CAAC;EAExF,AAAC,SAAgC,WAAW,OAAO,KAAK,YAAY,KAAK,CAAC;EAE1E,IAAI,YAAY,SAAS,OAAO,cAAc,OAAO,MAAM;EAE3D,aAAa,SAAS,MAAM,MAAM;EAElC,OAAO;CACT,SAAS,OAAO;EACd,MAAM,IAAI,MAAM,sBAAuB,MAAgB,SAAS;CAClE;AACF"}

package/esm/encryption/hash.d.mts

@@ -1,4 +1,4 @@
-//#region ../../@warlock.js/core/src/encryption/hash.d.ts
+//#region ../@warlock.js/core/src/encryption/hash.d.ts
 /**
  * Creates a deterministic HMAC-SHA256 hash of the given string.
  *

package/esm/encryption/hash.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/encryption/hash.ts"],"mappings":";;AAmBA;;;;AAA0C;;;;;;;;;;iBAA1B,QAAA,CAAS,SAAiB"}
+{"version":3,"file":"hash.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/encryption/hash.ts"],"mappings":";;AAmBA;;;;AAA0C;;;;;;;;;;iBAA1B,QAAA,CAAS,SAAiB"}

package/esm/encryption/hash.mjs

@@ -2,7 +2,7 @@ import { config } from "../config/config-getter.mjs";
 import "../config/index.mjs";
 import crypto from "crypto";
 
-//#region ../../@warlock.js/core/src/encryption/hash.ts
+//#region ../@warlock.js/core/src/encryption/hash.ts
 /**
 * Creates a deterministic HMAC-SHA256 hash of the given string.
 *

package/esm/encryption/hash.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"hash.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/encryption/hash.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport { config } from \"../config\";\nimport { EncryptionConfigurations } from \"./types\";\n\n/**\n * Creates a deterministic HMAC-SHA256 hash of the given string.\n *\n * Useful for creating searchable, unique fingerprints of sensitive data\n * (e.g., an API key) without storing the plaintext.\n *\n * Uses a dedicated HMAC key from config. Falls back to the encryption key\n * if no separate HMAC key is configured.\n *\n * @example\n * import { hmacHash } from \"@warlock.js/core\";\n *\n * const fingerprint = hmacHash(\"sk-proj-12345\");\n * // Store `fingerprint` in DB for lookups, store encrypted value separately\n */\nexport function hmacHash(plainText: string): string {\n  if (!plainText) return plainText;\n\n  const hmacKey =\n    config.key<EncryptionConfigurations[\"hmacKey\"]>(\"encryption.hmacKey\") ||\n    config.key<EncryptionConfigurations[\"key\"]>(\"encryption.key\");\n\n  if (!hmacKey) {\n    throw new Error(\n      \"Missing HMAC key. Set 'encryption.hmacKey' (or 'encryption.key') in your config.\",\n    );\n  }\n\n  const keyBuffer = Buffer.from(hmacKey, \"hex\");\n\n  return crypto.createHmac(\"sha256\", keyBuffer).update(plainText).digest(\"hex\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,SAAS,WAA2B;CAClD,IAAI,CAAC,WAAW,OAAO;CAEvB,MAAM,UACJ,OAAO,IAAyC,oBAAoB,KACpE,OAAO,IAAqC,gBAAgB;CAE9D,IAAI,CAAC,SACH,MAAM,IAAI,MACR,kFACF;CAGF,MAAM,YAAY,OAAO,KAAK,SAAS,KAAK;CAE5C,OAAO,OAAO,WAAW,UAAU,SAAS,EAAE,OAAO,SAAS,EAAE,OAAO,KAAK;AAC9E"}
+{"version":3,"file":"hash.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/encryption/hash.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport { config } from \"../config\";\nimport { EncryptionConfigurations } from \"./types\";\n\n/**\n * Creates a deterministic HMAC-SHA256 hash of the given string.\n *\n * Useful for creating searchable, unique fingerprints of sensitive data\n * (e.g., an API key) without storing the plaintext.\n *\n * Uses a dedicated HMAC key from config. Falls back to the encryption key\n * if no separate HMAC key is configured.\n *\n * @example\n * import { hmacHash } from \"@warlock.js/core\";\n *\n * const fingerprint = hmacHash(\"sk-proj-12345\");\n * // Store `fingerprint` in DB for lookups, store encrypted value separately\n */\nexport function hmacHash(plainText: string): string {\n  if (!plainText) return plainText;\n\n  const hmacKey =\n    config.key<EncryptionConfigurations[\"hmacKey\"]>(\"encryption.hmacKey\") ||\n    config.key<EncryptionConfigurations[\"key\"]>(\"encryption.key\");\n\n  if (!hmacKey) {\n    throw new Error(\n      \"Missing HMAC key. Set 'encryption.hmacKey' (or 'encryption.key') in your config.\",\n    );\n  }\n\n  const keyBuffer = Buffer.from(hmacKey, \"hex\");\n\n  return crypto.createHmac(\"sha256\", keyBuffer).update(plainText).digest(\"hex\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,SAAS,WAA2B;CAClD,IAAI,CAAC,WAAW,OAAO;CAEvB,MAAM,UACJ,OAAO,IAAyC,oBAAoB,KACpE,OAAO,IAAqC,gBAAgB;CAE9D,IAAI,CAAC,SACH,MAAM,IAAI,MACR,kFACF;CAGF,MAAM,YAAY,OAAO,KAAK,SAAS,KAAK;CAE5C,OAAO,OAAO,WAAW,UAAU,SAAS,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,KAAK;AAC9E"}

package/esm/encryption/password.d.mts

@@ -1,4 +1,4 @@
-//#region ../../@warlock.js/core/src/encryption/password.d.ts
+//#region ../@warlock.js/core/src/encryption/password.d.ts
 /**
  * Hashes a password using bcrypt (async — does not block the event loop).
  *

package/esm/encryption/password.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"password.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/encryption/password.ts"],"mappings":";;AA6DA;;;;AAA6D;AAqB7D;;;;;;iBArBsB,YAAA,CAAa,QAAA,WAAmB,OAAO;;AAwBnD;;;;;;;iBAHY,cAAA,CACpB,aAAA,UACA,cAAA,WACC,OAAO"}
+{"version":3,"file":"password.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/encryption/password.ts"],"mappings":";;AA6DA;;;;AAA6D;AAqB7D;;;;;;iBArBsB,YAAA,CAAa,QAAA,WAAmB,OAAO;;AAwBnD;;;;;;;iBAHY,cAAA,CACpB,aAAA,UACA,cAAA,WACC,OAAO"}

package/esm/encryption/password.mjs

@@ -1,7 +1,7 @@
 import { config } from "../config/config-getter.mjs";
 import "../config/index.mjs";
 
-//#region ../../@warlock.js/core/src/encryption/password.ts
+//#region ../@warlock.js/core/src/encryption/password.ts
 /**
 * Default bcrypt salt rounds.
 */

package/esm/encryption/password.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"password.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/encryption/password.ts"],"sourcesContent":["import { config } from \"../config\";\r\nimport { EncryptionPasswordConfigurations } from \"./types\";\r\n\r\n/**\r\n * Default bcrypt salt rounds.\r\n */\r\nconst DEFAULT_SALT_ROUNDS = 12;\r\n\r\n// ============================================================\r\n// Lazy-loaded bcryptjs SDK Types\r\n// ============================================================\r\n\r\n/**\r\n * Cached bcryptjs module (loaded once, reused)\r\n */\r\nlet Bcryptjs: typeof import(\"bcryptjs\");\r\n\r\nlet isModuleExists: boolean | null = null;\r\n\r\n/**\r\n * Installation instructions for bcryptjs package\r\n */\r\nconst BCRYPTJS_INSTALL_INSTRUCTIONS = `\r\nPassword encryption requires the bcryptjs package.\r\nInstall it with:\r\n\r\n  yarn add bcryptjs\r\n\r\nOr with your preferred package manager:\r\n\r\n  npm install bcryptjs\r\n  pnpm add bcryptjs\r\n  yarn add bcryptjs\r\n`.trim();\r\n\r\n/**\r\n * Load bcryptjs module\r\n */\r\nasync function loadBcryptjs() {\r\n  try {\r\n    Bcryptjs = await import(\"bcryptjs\");\r\n    isModuleExists = true;\r\n  } catch {\r\n    isModuleExists = false;\r\n  }\r\n}\r\n\r\nloadBcryptjs();\r\n\r\n/**\r\n * Hashes a password using bcrypt (async — does not block the event loop).\r\n *\r\n * Salt rounds are read from \\`encryption.password.saltRounds\\` config,\r\n * defaulting to 12.\r\n *\r\n * @example\r\n * import { hashPassword } from \"@warlock.js/core\";\r\n *\r\n * const hashed = await hashPassword(\"user-password-123\");\r\n * // Store \\`hashed\\` in the database\r\n */\r\nexport async function hashPassword(password: string): Promise<string> {\r\n  if (!isModuleExists) {\r\n    throw new Error(BCRYPTJS_INSTALL_INSTRUCTIONS);\r\n  }\r\n\r\n  const saltRounds = config.key<EncryptionPasswordConfigurations[\"salt\"]>(\r\n    \"encryption.password.salt\",\r\n    DEFAULT_SALT_ROUNDS,\r\n  )!;\r\n\r\n  return Bcryptjs.hash(String(password), saltRounds);\r\n}\r\n\r\n/**\r\n * Verifies a plain password against a bcrypt hash (async — does not block the event loop).\r\n *\r\n * @example\r\n * import { verifyPassword } from \"@warlock.js/core\";\r\n *\r\n * const isValid = await verifyPassword(\"user-password-123\", storedHash);\r\n */\r\nexport async function verifyPassword(\r\n  plainPassword: string,\r\n  hashedPassword: string,\r\n): Promise<boolean> {\r\n  if (!isModuleExists) {\r\n    throw new Error(BCRYPTJS_INSTALL_INSTRUCTIONS);\r\n  }\r\n\r\n  return Bcryptjs.compare(String(plainPassword), String(hashedPassword));\r\n}\r\n"],"mappings":";;;;;;;AAMA,MAAM,sBAAsB;;;;AAS5B,IAAI;AAEJ,IAAI,iBAAiC;;;;AAKrC,MAAM,gCAAgC;;;;;;;;;;;EAWpC,KAAK;;;;AAKP,eAAe,eAAe;CAC5B,IAAI;EACF,WAAW,MAAM,OAAO;EACxB,iBAAiB;CACnB,QAAQ;EACN,iBAAiB;CACnB;AACF;AAEA,aAAa;;;;;;;;;;;;;AAcb,eAAsB,aAAa,UAAmC;CACpE,IAAI,CAAC,gBACH,MAAM,IAAI,MAAM,6BAA6B;CAG/C,MAAM,aAAa,OAAO,IACxB,4BACA,mBACF;CAEA,OAAO,SAAS,KAAK,OAAO,QAAQ,GAAG,UAAU;AACnD;;;;;;;;;AAUA,eAAsB,eACpB,eACA,gBACkB;CAClB,IAAI,CAAC,gBACH,MAAM,IAAI,MAAM,6BAA6B;CAG/C,OAAO,SAAS,QAAQ,OAAO,aAAa,GAAG,OAAO,cAAc,CAAC;AACvE"}
+{"version":3,"file":"password.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/encryption/password.ts"],"sourcesContent":["import { config } from \"../config\";\r\nimport { EncryptionPasswordConfigurations } from \"./types\";\r\n\r\n/**\r\n * Default bcrypt salt rounds.\r\n */\r\nconst DEFAULT_SALT_ROUNDS = 12;\r\n\r\n// ============================================================\r\n// Lazy-loaded bcryptjs SDK Types\r\n// ============================================================\r\n\r\n/**\r\n * Cached bcryptjs module (loaded once, reused)\r\n */\r\nlet Bcryptjs: typeof import(\"bcryptjs\");\r\n\r\nlet isModuleExists: boolean | null = null;\r\n\r\n/**\r\n * Installation instructions for bcryptjs package\r\n */\r\nconst BCRYPTJS_INSTALL_INSTRUCTIONS = `\r\nPassword encryption requires the bcryptjs package.\r\nInstall it with:\r\n\r\n  yarn add bcryptjs\r\n\r\nOr with your preferred package manager:\r\n\r\n  npm install bcryptjs\r\n  pnpm add bcryptjs\r\n  yarn add bcryptjs\r\n`.trim();\r\n\r\n/**\r\n * Load bcryptjs module\r\n */\r\nasync function loadBcryptjs() {\r\n  try {\r\n    Bcryptjs = await import(\"bcryptjs\");\r\n    isModuleExists = true;\r\n  } catch {\r\n    isModuleExists = false;\r\n  }\r\n}\r\n\r\nloadBcryptjs();\r\n\r\n/**\r\n * Hashes a password using bcrypt (async — does not block the event loop).\r\n *\r\n * Salt rounds are read from \\`encryption.password.saltRounds\\` config,\r\n * defaulting to 12.\r\n *\r\n * @example\r\n * import { hashPassword } from \"@warlock.js/core\";\r\n *\r\n * const hashed = await hashPassword(\"user-password-123\");\r\n * // Store \\`hashed\\` in the database\r\n */\r\nexport async function hashPassword(password: string): Promise<string> {\r\n  if (!isModuleExists) {\r\n    throw new Error(BCRYPTJS_INSTALL_INSTRUCTIONS);\r\n  }\r\n\r\n  const saltRounds = config.key<EncryptionPasswordConfigurations[\"salt\"]>(\r\n    \"encryption.password.salt\",\r\n    DEFAULT_SALT_ROUNDS,\r\n  )!;\r\n\r\n  return Bcryptjs.hash(String(password), saltRounds);\r\n}\r\n\r\n/**\r\n * Verifies a plain password against a bcrypt hash (async — does not block the event loop).\r\n *\r\n * @example\r\n * import { verifyPassword } from \"@warlock.js/core\";\r\n *\r\n * const isValid = await verifyPassword(\"user-password-123\", storedHash);\r\n */\r\nexport async function verifyPassword(\r\n  plainPassword: string,\r\n  hashedPassword: string,\r\n): Promise<boolean> {\r\n  if (!isModuleExists) {\r\n    throw new Error(BCRYPTJS_INSTALL_INSTRUCTIONS);\r\n  }\r\n\r\n  return Bcryptjs.compare(String(plainPassword), String(hashedPassword));\r\n}\r\n"],"mappings":";;;;;;;AAMA,MAAM,sBAAsB;;;;AAS5B,IAAI;AAEJ,IAAI,iBAAiC;;;;AAKrC,MAAM,gCAAgC;;;;;;;;;;;EAWpC,KAAK;;;;AAKP,eAAe,eAAe;CAC5B,IAAI;EACF,WAAW,MAAM,OAAO;EACxB,iBAAiB;CACnB,QAAQ;EACN,iBAAiB;CACnB;AACF;AAEA,aAAa;;;;;;;;;;;;;AAcb,eAAsB,aAAa,UAAmC;CACpE,IAAI,CAAC,gBACH,MAAM,IAAI,MAAM,6BAA6B;CAG/C,MAAM,aAAa,OAAO,IACxB,4BACA,mBACF;CAEA,OAAO,SAAS,KAAK,OAAO,QAAQ,GAAG,UAAU;AACnD;;;;;;;;;AAUA,eAAsB,eACpB,eACA,gBACkB;CAClB,IAAI,CAAC,gBACH,MAAM,IAAI,MAAM,6BAA6B;CAG/C,OAAO,SAAS,QAAQ,OAAO,aAAa,GAAG,OAAO,cAAc,CAAC;AACvE"}

package/esm/encryption/types.d.mts

@@ -1,4 +1,4 @@
-//#region ../../@warlock.js/core/src/encryption/types.d.ts
+//#region ../@warlock.js/core/src/encryption/types.d.ts
 /**
  * Configuration for the encryption module.
  *

package/esm/encryption/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/encryption/types.ts"],"mappings":";;AAmBA;;;;;;;;;;AAyB6C;AAG7C;;;;AAKM;;;KAjCM,wBAAA;;;;;;EAMV,GAAA;;;;;EAMA,SAAA;;;;;;;EAQA,OAAA;;;;EAKA,QAAA,GAAW,gCAAgC;AAAA;AAAA,KAGjC,gCAAA;;;;;EAKV,IAAI;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../@warlock.js/core/src/encryption/types.ts"],"mappings":";;AAmBA;;;;;;;;;;AAyB6C;AAG7C;;;;AAKM;;;KAjCM,wBAAA;;;;;;EAMV,GAAA;;;;;EAMA,SAAA;;;;;;;EAQA,OAAA;;;;EAKA,QAAA,GAAW,gCAAgC;AAAA;AAAA,KAGjC,gCAAA;;;;;EAKV,IAAI;AAAA"}

package/esm/http/config.d.mts

@@ -1,6 +1,6 @@
 import { HttpConfigurations } from "./types.mjs";
 
-//#region ../../@warlock.js/core/src/http/config.d.ts
+//#region ../@warlock.js/core/src/http/config.d.ts
 /**
  * Default http configurations
  */