@warlock.js/core 4.0.174 → 4.1.3

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

@@ -0,0 +1,68 @@
+import { register } from "node:module";
+import { putFileAsync } from "@warlock.js/fs";
+import path from "node:path";
+import { build } from "esbuild";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { MessageChannel } from "node:worker_threads";
+
+//#region ../../@warlock.js/core/src/dev-server/loader/register-loader.ts
+/**
+* Bundle, write, and register the ESM loader hook.
+*
+* **Why bundle?**
+* `module.register()` runs the hook file in a fresh Node.js worker thread that
+* has no tsx hook of its own. The hook source is TypeScript, so we must produce
+* a plain ESM bundle before registering. esbuild inline-bundles all three hook
+* modules (`hook-thread`, `resolve-hook`, `load-hook`, `version-registry`)
+* into a single `.mjs` file written to `.warlock/`. External npm packages
+* (`esbuild`, `node:*`) are kept external — the hook thread can resolve those
+* from `node_modules` normally.
+*
+* **Why a file and not a `data:` URL?**
+* Some Node versions have issues resolving `import.meta.url` inside `data:`
+* modules. A real file under `.warlock/` is simpler and debuggable.
+*
+* **Timing**
+* Called from `FilesOrchestrator.init()` before any user `src/` module is
+* dynamically imported. `module.register()` takes effect for all subsequent
+* `import()` calls, which is exactly the window we need.
+*
+* @param transpile - Transpile-cache config to ship into the hook worker,
+*   or `null` to keep the hook in tsx-passthrough mode.
+*
+* @returns The main-thread side of the MessageChannel. Callers post
+*   `{ type: "bump", absolutePath }` messages on it to invalidate modules.
+*
+* @example
+* const port = await registerLoader(transpileInit);
+* // Later, when a file changes:
+* port.postMessage({ type: "bump", absolutePath: "/abs/path/to/user.model.ts" });
+*/
+async function registerLoader(transpile) {
+	const { port1, port2 } = new MessageChannel();
+	const bundledCode = (await build({
+		entryPoints: [path.join(path.dirname(fileURLToPath(import.meta.url)), "hook-thread.ts")],
+		bundle: true,
+		format: "esm",
+		write: false,
+		platform: "node",
+		target: "node20",
+		packages: "external"
+	})).outputFiles[0].text;
+	const hookBundlePath = path.join(process.cwd(), ".warlock", "loader-hook.mjs");
+	await putFileAsync(hookBundlePath, bundledCode);
+	const srcRoot = path.join(process.cwd(), "src");
+	register(pathToFileURL(hookBundlePath).href, import.meta.url, {
+		data: {
+			port: port2,
+			srcRoot,
+			transpile
+		},
+		transferList: [port2]
+	});
+	return port1;
+}
+
+//#endregion
+export { registerLoader };
+//# sourceMappingURL=register-loader.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register-loader.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/register-loader.ts"],"sourcesContent":["import { putFileAsync } from \"@warlock.js/fs\";\nimport { build } from \"esbuild\";\nimport { register } from \"node:module\";\nimport path from \"node:path\";\nimport { fileURLToPath, pathToFileURL } from \"node:url\";\nimport { type MessagePort, MessageChannel } from \"node:worker_threads\";\nimport type { TranspileInit } from \"./load-hook.js\";\n\n/**\n * Bundle, write, and register the ESM loader hook.\n *\n * **Why bundle?**\n * `module.register()` runs the hook file in a fresh Node.js worker thread that\n * has no tsx hook of its own. The hook source is TypeScript, so we must produce\n * a plain ESM bundle before registering. esbuild inline-bundles all three hook\n * modules (`hook-thread`, `resolve-hook`, `load-hook`, `version-registry`)\n * into a single `.mjs` file written to `.warlock/`. External npm packages\n * (`esbuild`, `node:*`) are kept external — the hook thread can resolve those\n * from `node_modules` normally.\n *\n * **Why a file and not a `data:` URL?**\n * Some Node versions have issues resolving `import.meta.url` inside `data:`\n * modules. A real file under `.warlock/` is simpler and debuggable.\n *\n * **Timing**\n * Called from `FilesOrchestrator.init()` before any user `src/` module is\n * dynamically imported. `module.register()` takes effect for all subsequent\n * `import()` calls, which is exactly the window we need.\n *\n * @param transpile - Transpile-cache config to ship into the hook worker,\n *   or `null` to keep the hook in tsx-passthrough mode.\n *\n * @returns The main-thread side of the MessageChannel. Callers post\n *   `{ type: \"bump\", absolutePath }` messages on it to invalidate modules.\n *\n * @example\n * const port = await registerLoader(transpileInit);\n * // Later, when a file changes:\n * port.postMessage({ type: \"bump\", absolutePath: \"/abs/path/to/user.model.ts\" });\n */\nexport async function registerLoader(\n  transpile: TranspileInit,\n): Promise<MessagePort> {\n  const { port1, port2 } = new MessageChannel();\n\n  const hookThreadPath = path.join(path.dirname(fileURLToPath(import.meta.url)), \"hook-thread.ts\");\n\n  const bundleResult = await build({\n    entryPoints: [hookThreadPath],\n    bundle: true,\n    format: \"esm\",\n    write: false,\n    platform: \"node\",\n    target: \"node20\",\n    // Keep npm packages and Node built-ins external — the hook thread resolves\n    // them normally from node_modules at runtime.\n    packages: \"external\",\n  });\n\n  const bundledCode = bundleResult.outputFiles[0].text;\n  // Caller (filesOrchestrator.init) guarantees .warlock/ exists before this runs.\n  const hookBundlePath = path.join(process.cwd(), \".warlock\", \"loader-hook.mjs\");\n  await putFileAsync(hookBundlePath, bundledCode);\n\n  const srcRoot = path.join(process.cwd(), \"src\");\n\n  // No tsx registration: our hook owns resolution (own-resolver) and the\n  // transpile of every `.ts`/`.tsx` (esbuild, in the load hook). The chain\n  // is simply [our hook] → [Node default] for non-TS (npm/.js, node:).\n  // In this monorepo tsx is still the *launcher* (`tsx start.ts`) so its\n  // loader is present anyway, but it is never consulted for TypeScript —\n  // our hook short-circuits first. A released `node bin/warlock.js` has no\n  // tsx at all and relies entirely on this hook.\n\n  register(pathToFileURL(hookBundlePath).href, import.meta.url, {\n    data: { port: port2, srcRoot, transpile },\n    transferList: [port2],\n  });\n\n  return port1;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,eAAsB,eACpB,WACsB;CACtB,MAAM,EAAE,OAAO,UAAU,IAAI,eAAe;CAgB5C,MAAM,eAAc,MAZO,MAAM;EAC/B,aAAa,CAHQ,KAAK,KAAK,KAAK,QAAQ,cAAc,OAAO,KAAK,GAAG,CAAC,GAAG,gBAGlD,CAAC;EAC5B,QAAQ;EACR,QAAQ;EACR,OAAO;EACP,UAAU;EACV,QAAQ;EAGR,UAAU;CACZ,CAAC,GAEgC,YAAY,GAAG;CAEhD,MAAM,iBAAiB,KAAK,KAAK,QAAQ,IAAI,GAAG,YAAY,iBAAiB;CAC7E,MAAM,aAAa,gBAAgB,WAAW;CAE9C,MAAM,UAAU,KAAK,KAAK,QAAQ,IAAI,GAAG,KAAK;CAU9C,SAAS,cAAc,cAAc,EAAE,MAAM,OAAO,KAAK,KAAK;EAC5D,MAAM;GAAE,MAAM;GAAO;GAAS;EAAU;EACxC,cAAc,CAAC,KAAK;CACtB,CAAC;CAED,OAAO;AACT"}

package/esm/dev-server/loader/transpile-cache.mjs

@@ -0,0 +1,57 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+//#region ../../@warlock.js/core/src/dev-server/loader/transpile-cache.ts
+/**
+* Persisted transpile cache.
+*
+* Keyed by a hash of *source content* plus a transform-options fingerprint.
+* Same source + same options → same key → same output, always. Changed
+* content → different key → fresh transpile. There is no path-keyed entry
+* anywhere, so the old "stack trace points at a mangled cache filename" bug
+* class is structurally impossible — the on-disk filename is opaque and the
+* source identity lives only inside the source map.
+*
+* This module is pure and hook-agnostic on purpose: it knows how to read,
+* write and evict cache entries given a key, nothing about the ESM loader,
+* `?v=N` versioning, or esbuild. Phase 2 wires it into the load hook.
+*
+* @example
+*   const fp = computeFingerprint({
+*     esbuildVersion: esbuild.version,
+*     cacheEpoch: CACHE_EPOCH,
+*     compilerOptions,
+*   });
+*   const key = cacheKey(sourceText, fp);
+*   const hit = cache.get(key);
+*   if (!hit) cache.put(key, { code, map });
+*/
+/**
+* Stable JSON stringify — object keys sorted recursively so semantically
+* equal option blobs always produce the same fingerprint regardless of key
+* insertion order.
+*/
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	return `{${Object.keys(value).sort().map((key) => {
+		const child = stableStringify(value[key]);
+		return `${JSON.stringify(key)}:${child}`;
+	}).join(",")}}`;
+}
+/**
+* Fold every output-affecting input into one short hex fingerprint that
+* becomes part of every cache key.
+*/
+function computeFingerprint(parts) {
+	const canonical = stableStringify({
+		esbuildVersion: parts.esbuildVersion,
+		cacheEpoch: parts.cacheEpoch,
+		compilerOptions: parts.compilerOptions
+	});
+	return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+}
+
+//#endregion
+export { computeFingerprint };
+//# sourceMappingURL=transpile-cache.mjs.map

package/esm/dev-server/loader/transpile-cache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpile-cache.mjs","names":[],"sources":["../../../../../../../@warlock.js/core/src/dev-server/loader/transpile-cache.ts"],"sourcesContent":["/**\n * Persisted transpile cache.\n *\n * Keyed by a hash of *source content* plus a transform-options fingerprint.\n * Same source + same options → same key → same output, always. Changed\n * content → different key → fresh transpile. There is no path-keyed entry\n * anywhere, so the old \"stack trace points at a mangled cache filename\" bug\n * class is structurally impossible — the on-disk filename is opaque and the\n * source identity lives only inside the source map.\n *\n * This module is pure and hook-agnostic on purpose: it knows how to read,\n * write and evict cache entries given a key, nothing about the ESM loader,\n * `?v=N` versioning, or esbuild. Phase 2 wires it into the load hook.\n *\n * @example\n *   const fp = computeFingerprint({\n *     esbuildVersion: esbuild.version,\n *     cacheEpoch: CACHE_EPOCH,\n *     compilerOptions,\n *   });\n *   const key = cacheKey(sourceText, fp);\n *   const hit = cache.get(key);\n *   if (!hit) cache.put(key, { code, map });\n */\n\nimport { createHash } from \"node:crypto\";\nimport {\n  mkdirSync,\n  readdirSync,\n  readFileSync,\n  renameSync,\n  rmSync,\n  statSync,\n  writeFileSync,\n} from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * A cached transpile result: the emitted JS and its source map (raw JSON\n * string, exactly as esbuild produced it). Either may be empty for code\n * that produced no map.\n */\nexport type TranspileEntry = {\n  code: string;\n  map: string;\n};\n\n/**\n * Inputs that change transpiled output for identical source text. Bumping\n * any of these must invalidate every entry — that is achieved structurally\n * by folding them into the key, not by sweeping the cache.\n */\nexport type FingerprintParts = {\n  /** `esbuild.version` — a transform-engine upgrade can change output. */\n  esbuildVersion: string;\n  /**\n   * Monotonic cache-format epoch owned by the framework. Bump it whenever\n   * the cache contract (entry shape, map handling, key derivation) changes\n   * so old entries are guaranteed to miss after a framework upgrade.\n   */\n  cacheEpoch: number;\n  /**\n   * The resolved tsconfig `compilerOptions` blob, hashed wholesale rather\n   * than cherry-picking fields — safer against tsconfig drift (a new option\n   * that affects output can't silently serve stale code).\n   */\n  compilerOptions: unknown;\n};\n\n/**\n * Current cache-format epoch. Bump on any change to {@link TranspileEntry}\n * shape, the storage layout, or how the loader consumes entries.\n */\nexport const CACHE_EPOCH = 1;\n\n/**\n * Stable JSON stringify — object keys sorted recursively so semantically\n * equal option blobs always produce the same fingerprint regardless of key\n * insertion order.\n */\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== \"object\") {\n    return JSON.stringify(value) ?? \"null\";\n  }\n\n  if (Array.isArray(value)) {\n    return `[${value.map(stableStringify).join(\",\")}]`;\n  }\n\n  const entries = Object.keys(value as Record<string, unknown>)\n    .sort()\n    .map(key => {\n      const child = stableStringify((value as Record<string, unknown>)[key]);\n      return `${JSON.stringify(key)}:${child}`;\n    });\n\n  return `{${entries.join(\",\")}}`;\n}\n\n/**\n * Fold every output-affecting input into one short hex fingerprint that\n * becomes part of every cache key.\n */\nexport function computeFingerprint(parts: FingerprintParts): string {\n  const canonical = stableStringify({\n    esbuildVersion: parts.esbuildVersion,\n    cacheEpoch: parts.cacheEpoch,\n    compilerOptions: parts.compilerOptions,\n  });\n\n  return createHash(\"sha256\").update(canonical).digest(\"hex\").slice(0, 16);\n}\n\n/**\n * Derive the cache key for a source file. The NUL separator makes\n * `sourceText` and `fingerprint` unambiguous (no concatenation collision).\n */\nexport function cacheKey(sourceText: string, fingerprint: string): string {\n  return createHash(\"sha256\")\n    .update(sourceText)\n    .update(\"\\0\")\n    .update(fingerprint)\n    .digest(\"hex\");\n}\n\n/** Options for {@link TranspileCache.gc}. */\nexport type GcOptions = {\n  /** Evict least-recently-modified entries once total size exceeds this. */\n  maxBytes?: number;\n  /** Evict entries whose mtime is older than this many milliseconds. */\n  maxAgeMs?: number;\n};\n\ntype CacheFileInfo = {\n  codePath: string;\n  mapPath: string;\n  size: number;\n  mtimeMs: number;\n};\n\n/**\n * Content-hash-addressed transpile cache stored on disk.\n *\n * Layout: `<cacheDir>/<first2-of-key>/<key>.js` plus a sibling `.js.map`.\n * Sharding by the first two hex chars keeps any single directory small on\n * large projects. GC metadata is derived from filesystem mtime so there is\n * no second source of truth (no sidecar index to keep consistent).\n */\nexport class TranspileCache {\n  public constructor(private readonly cacheDir: string) {}\n\n  private shardDir(key: string): string {\n    return path.join(this.cacheDir, key.slice(0, 2));\n  }\n\n  /**\n   * `label` is an optional human-readable prefix (e.g. a path slug). It is\n   * cosmetic only — the content `key` is still what makes the name unique,\n   * so the same `(key, label)` pair must be passed to `get` and `put`.\n   */\n  private fileName(key: string, label: string | undefined, ext: string): string {\n    return label ? `${label}.${key}${ext}` : `${key}${ext}`;\n  }\n\n  private codePath(key: string, label?: string): string {\n    return path.join(this.shardDir(key), this.fileName(key, label, \".js\"));\n  }\n\n  private mapPath(key: string, label?: string): string {\n    return path.join(this.shardDir(key), this.fileName(key, label, \".js.map\"));\n  }\n\n  /**\n   * Return the cached entry for `key`, or `null` on a miss. Synchronous on\n   * purpose: this sits on the module-load hot path and must not pay an\n   * event-loop hop per import.\n   */\n  public get(key: string, label?: string): TranspileEntry | null {\n    try {\n      const code = readFileSync(this.codePath(key, label), \"utf8\");\n      let map = \"\";\n      try {\n        map = readFileSync(this.mapPath(key, label), \"utf8\");\n      } catch {\n        // A code entry with no map is valid (e.g. map-less transform).\n      }\n      return { code, map };\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Store an entry for `key`. Written atomically (temp file + rename) so a\n   * concurrent {@link get} never observes a half-written module.\n   */\n  public put(key: string, entry: TranspileEntry, label?: string): void {\n    const shard = this.shardDir(key);\n    mkdirSync(shard, { recursive: true });\n\n    this.atomicWrite(this.codePath(key, label), entry.code);\n    if (entry.map) {\n      this.atomicWrite(this.mapPath(key, label), entry.map);\n    }\n  }\n\n  private atomicWrite(filePath: string, content: string): void {\n    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;\n    try {\n      writeFileSync(tempPath, content);\n      renameSync(tempPath, filePath);\n    } catch (error) {\n      try {\n        rmSync(tempPath, { force: true });\n      } catch {\n        // best effort — original error is the one that matters\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Opportunistic eviction. Cheap, runs at boot (not on the hot path).\n   * Removes age-expired entries first, then trims to the size budget by\n   * evicting least-recently-modified entries. Both bounds are optional;\n   * with neither set this is a no-op.\n   */\n  public gc(options: GcOptions = {}): void {\n    const { maxBytes, maxAgeMs } = options;\n    if (maxBytes === undefined && maxAgeMs === undefined) return;\n\n    const files = this.scan();\n    const now = Date.now();\n\n    let live = files;\n\n    if (maxAgeMs !== undefined) {\n      live = [];\n      for (const file of files) {\n        if (now - file.mtimeMs > maxAgeMs) {\n          this.evict(file);\n        } else {\n          live.push(file);\n        }\n      }\n    }\n\n    if (maxBytes !== undefined) {\n      let total = live.reduce((sum, file) => sum + file.size, 0);\n      if (total > maxBytes) {\n        // Oldest first — least-recently-modified is the eviction order.\n        live.sort((a, b) => a.mtimeMs - b.mtimeMs);\n        for (const file of live) {\n          if (total <= maxBytes) break;\n          total -= file.size;\n          this.evict(file);\n        }\n      }\n    }\n  }\n\n  private scan(): CacheFileInfo[] {\n    const result: CacheFileInfo[] = [];\n\n    let shards: string[];\n    try {\n      shards = readdirSync(this.cacheDir);\n    } catch {\n      return result;\n    }\n\n    for (const shard of shards) {\n      const shardPath = path.join(this.cacheDir, shard);\n      let entries: string[];\n      try {\n        entries = readdirSync(shardPath);\n      } catch {\n        continue;\n      }\n\n      for (const entry of entries) {\n        if (!entry.endsWith(\".js\")) continue;\n        const codePath = path.join(shardPath, entry);\n        try {\n          const stat = statSync(codePath);\n          const mapPath = `${codePath}.map`;\n          let mapSize = 0;\n          try {\n            mapSize = statSync(mapPath).size;\n          } catch {\n            // no map sidecar — fine\n          }\n          result.push({\n            codePath,\n            mapPath,\n            size: stat.size + mapSize,\n            mtimeMs: stat.mtimeMs,\n          });\n        } catch {\n          // entry vanished mid-scan — skip\n        }\n      }\n    }\n\n    return result;\n  }\n\n  private evict(file: CacheFileInfo): void {\n    try {\n      rmSync(file.codePath, { force: true });\n    } catch {\n      // best effort\n    }\n    try {\n      rmSync(file.mapPath, { force: true });\n    } catch {\n      // best effort\n    }\n  }\n\n  /** Remove the entire cache directory (used by `--fresh`). */\n  public clear(): void {\n    try {\n      rmSync(this.cacheDir, { recursive: true, force: true });\n    } catch {\n      // best effort\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,SAAS,gBAAgB,OAAwB;CAC/C,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC,OAAO,KAAK,UAAU,KAAK,KAAK;CAGlC,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,IAAI,MAAM,IAAI,eAAe,EAAE,KAAK,GAAG,EAAE;CAUlD,OAAO,IAPS,OAAO,KAAK,KAAgC,EACzD,KAAK,EACL,KAAI,QAAO;EACV,MAAM,QAAQ,gBAAiB,MAAkC,IAAI;EACrE,OAAO,GAAG,KAAK,UAAU,GAAG,EAAE,GAAG;CACnC,CAEe,EAAE,KAAK,GAAG,EAAE;AAC/B;;;;;AAMA,SAAgB,mBAAmB,OAAiC;CAClE,MAAM,YAAY,gBAAgB;EAChC,gBAAgB,MAAM;EACtB,YAAY,MAAM;EAClB,iBAAiB,MAAM;CACzB,CAAC;CAED,OAAO,WAAW,QAAQ,EAAE,OAAO,SAAS,EAAE,OAAO,KAAK,EAAE,MAAM,GAAG,EAAE;AACzE"}

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

@@ -0,0 +1,71 @@
+import { FileManifest } from "./types.mjs";
+import { FileManager } from "./file-manager.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/manifest-manager.d.ts
+declare class ManifestManager {
+  private readonly files;
+  /**
+   * Manifest data with metadata
+   */
+  private manifest;
+  /**
+   * Constructor
+   */
+  constructor(files: Map<string, FileManager>);
+  /**
+   * Initialize manifest manager
+   * @returns true if manifest exists, false otherwise
+   */
+  init(): Promise<boolean>;
+  /**
+   * Save manifest to disk
+   */
+  save(): Promise<void>;
+  /**
+   * Get file manifest data
+   */
+  getFile(filePath: string): FileManifest | undefined;
+  /**
+   * Check if file exists in manifest
+   */
+  hasFile(filePath: string): boolean;
+  /**
+   * Set file manifest data
+   */
+  setFile(filePath: string, fileManifest: FileManifest): void;
+  /**
+   * Remove file from manifest
+   */
+  removeFile(filePath: string): void;
+  /**
+   * Get all file paths in manifest
+   */
+  getAllFilePaths(): string[];
+  /**
+   * Get all file manifests
+   */
+  getAllFiles(): Record<string, FileManifest>;
+  /**
+   * Get manifest metadata
+   */
+  getMetadata(): {
+    version: string;
+    lastBuildTime: number;
+    projectHash: string | undefined;
+    stats: {
+      totalFiles: number;
+      totalDependencies: number;
+    };
+  };
+  /**
+   * Calculate total dependencies across all files
+   */
+  private calculateTotalDependencies;
+  /**
+   * Clear all files from manifest
+   */
+  clear(): void;
+}
+//#endregion
+export { ManifestManager };
+//# sourceMappingURL=manifest-manager.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-manager.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/dev-server/manifest-manager.ts"],"mappings":";;;;cAmBa,eAAA;EAAA,iBAiByB,KAAA;EAAA;;;EAAA,QAb5B,QAAA;EAa+C;;;cAAnB,KAAA,EAAO,GAAA,SAAY,WAAA;EAkB1C;;;;EAZA,IAAA,CAAA,GAAQ,OAAA;EA+Bd;;;EAnBM,IAAA,CAAA,GAAQ,OAAA;EA0B0B;;;EAdxC,OAAA,CAAQ,QAAA,WAAmB,YAAA;EA4B3B;;;EArBA,OAAA,CAAQ,QAAA;EAmCR;;;EA5BA,OAAA,CAAQ,QAAA,UAAkB,YAAA,EAAc,YAAA;;;;EAOxC,UAAA,CAAW,QAAA;EA2CX;;AAAK;EApCL,eAAA,CAAA;;;;EAOA,WAAA,CAAA,GAAe,MAAA,SAAe,YAAA;;;;EAO9B,WAAA,CAAA;;;;;;;;;;;;UAYC,0BAAA;;;;EAUD,KAAA,CAAA;AAAA"}

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

@@ -0,0 +1,107 @@
+import { MANIFEST_PATH } from "./flags.mjs";
+import { fileExistsAsync, getJsonFileAsync, putFileAsync } from "@warlock.js/fs";
+
+//#region ../../@warlock.js/core/src/dev-server/manifest-manager.ts
+var ManifestManager = class {
+	/**
+	* Constructor
+	*/
+	constructor(files) {
+		this.files = files;
+		this.manifest = {
+			version: "1.0.0",
+			lastBuildTime: Date.now(),
+			stats: {
+				totalFiles: 0,
+				totalDependencies: 0
+			},
+			files: {}
+		};
+	}
+	/**
+	* Initialize manifest manager
+	* @returns true if manifest exists, false otherwise
+	*/
+	async init() {
+		if (await fileExistsAsync(MANIFEST_PATH)) {
+			this.manifest = await getJsonFileAsync(MANIFEST_PATH);
+			return true;
+		} else return false;
+	}
+	/**
+	* Save manifest to disk
+	*/
+	async save() {
+		this.manifest.stats.totalFiles = Object.keys(this.manifest.files).length;
+		this.manifest.stats.totalDependencies = this.calculateTotalDependencies();
+		this.manifest.lastBuildTime = Date.now();
+		await putFileAsync(MANIFEST_PATH, JSON.stringify(this.manifest, null, 2));
+	}
+	/**
+	* Get file manifest data
+	*/
+	getFile(filePath) {
+		return this.manifest.files[filePath];
+	}
+	/**
+	* Check if file exists in manifest
+	*/
+	hasFile(filePath) {
+		return filePath in this.manifest.files;
+	}
+	/**
+	* Set file manifest data
+	*/
+	setFile(filePath, fileManifest) {
+		this.manifest.files[filePath] = fileManifest;
+	}
+	/**
+	* Remove file from manifest
+	*/
+	removeFile(filePath) {
+		delete this.manifest.files[filePath];
+	}
+	/**
+	* Get all file paths in manifest
+	*/
+	getAllFilePaths() {
+		return Object.keys(this.manifest.files);
+	}
+	/**
+	* Get all file manifests
+	*/
+	getAllFiles() {
+		return this.manifest.files;
+	}
+	/**
+	* Get manifest metadata
+	*/
+	getMetadata() {
+		return {
+			version: this.manifest.version,
+			lastBuildTime: this.manifest.lastBuildTime,
+			projectHash: this.manifest.projectHash,
+			stats: this.manifest.stats
+		};
+	}
+	/**
+	* Calculate total dependencies across all files
+	*/
+	calculateTotalDependencies() {
+		return Object.values(this.manifest.files).reduce((total, file) => total + (file.dependencies?.length || 0), 0);
+	}
+	/**
+	* Clear all files from manifest
+	*/
+	clear() {
+		this.manifest.files = {};
+		this.manifest.stats = {
+			totalFiles: 0,
+			totalDependencies: 0
+		};
+	}
+};
+
+//#endregion
+export { ManifestManager };
+//# sourceMappingURL=manifest-manager.mjs.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,51 @@
+import { SpecialFilesCollector } from "./special-files-collector.mjs";
+import { FileManager } from "./file-manager.mjs";
+
+//#region ../../@warlock.js/core/src/dev-server/module-loader.d.ts
+declare global {
+  var __currentModuleFile: FileManager | undefined;
+}
+/**
+ * Loads application modules through the ESM loader hook. The hook stamps
+ * `?v=N` on every import, so each reload is a fresh module without any
+ * userland cache-busting plumbing.
+ */
+declare class ModuleLoader {
+  private readonly specialFilesCollector;
+  private readonly loadedModules;
+  constructor(specialFilesCollector: SpecialFilesCollector);
+  /**
+   * Eagerly load every special file at boot, in the canonical order so
+   * later phases (e.g. routes) see state earlier phases registered.
+   */
+  loadAll(): Promise<void>;
+  /**
+   * Import a file through the loader hook. For routes, scopes the import in
+   * `router.withSourceFile()` so the added routes carry their origin.
+   */
+  loadModule<T = unknown>(file: FileManager, type: string): Promise<T | undefined>;
+  /**
+   * Reload a previously-loaded special file. The version-bump that makes the
+   * import fresh is done by the caller (layer-executor) before invoking this.
+   * Routes are removed from the registry first so re-registration is clean.
+   */
+  reloadModule(file: FileManager): Promise<void>;
+  /**
+   * Run every cleanup hook the file registered (or `$cleanup` on its exports)
+   * and reset the list. Called once per HMR reload.
+   */
+  runCleanup(file: FileManager): void;
+  /**
+   * Clean up after a file whose source was deleted from disk.
+   */
+  cleanupDeletedModule(file: FileManager): void;
+  /**
+   * Scan a freshly-loaded module for cleanup handlers and register them on
+   * the FileManager so they run before the next reload. Priority: explicit
+   * `export function cleanup()` → `.$cleanup` on any exported value.
+   */
+  private registerCleanup;
+}
+//#endregion
+export { ModuleLoader };
+//# sourceMappingURL=module-loader.d.mts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,111 @@
+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
+/**
+* The four "special" file kinds that the dev server eagerly imports at boot.
+* Order matters: locales first (used by everything), events before main so
+* listeners are registered when main runs, routes last so handlers are bound.
+*/
+const SPECIAL_TYPES = [
+	"locale",
+	"event",
+	"main",
+	"route"
+];
+/**
+* Loads application modules through the ESM loader hook. The hook stamps
+* `?v=N` on every import, so each reload is a fresh module without any
+* userland cache-busting plumbing.
+*/
+var ModuleLoader = class {
+	constructor(specialFilesCollector) {
+		this.specialFilesCollector = specialFilesCollector;
+		this.loadedModules = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Eagerly load every special file at boot, in the canonical order so
+	* later phases (e.g. routes) see state earlier phases registered.
+	*/
+	async loadAll() {
+		for (const type of SPECIAL_TYPES) for (const file of this.specialFilesCollector.getFilesByType(type)) await this.loadModule(file, type);
+	}
+	/**
+	* Import a file through the loader hook. For routes, scopes the import in
+	* `router.withSourceFile()` so the added routes carry their origin.
+	*/
+	async loadModule(file, type) {
+		if (file.relativePath.endsWith(".env")) return void 0;
+		globalThis.__currentModuleFile = file;
+		try {
+			const fileUrl = pathToFileURL(file.absolutePath).href;
+			const load = async () => {
+				const module = await import(fileUrl);
+				this.loadedModules.set(file.absolutePath, module);
+				this.registerCleanup(file, module);
+				return module;
+			};
+			return type === "route" ? await router.withSourceFile(file.relativePath, load) : await load();
+		} catch (error) {
+			if (error.code === "ERR_MODULE_NOT_FOUND") devLogError(formatModuleNotFoundError(error));
+			else devLogError(`Failed to load ${type}: ${file.relativePath} - ${error?.message || error}`, error);
+			return;
+		} finally {
+			globalThis.__currentModuleFile = void 0;
+		}
+	}
+	/**
+	* Reload a previously-loaded special file. The version-bump that makes the
+	* import fresh is done by the caller (layer-executor) before invoking this.
+	* Routes are removed from the registry first so re-registration is clean.
+	*/
+	async reloadModule(file) {
+		const moduleType = this.specialFilesCollector.getFileType(file.relativePath);
+		if (!moduleType) return;
+		this.runCleanup(file);
+		if (moduleType === "route") router.removeRoutesBySourceFile(file.relativePath);
+		this.loadedModules.delete(file.absolutePath);
+		await this.loadModule(file, moduleType);
+	}
+	/**
+	* Run every cleanup hook the file registered (or `$cleanup` on its exports)
+	* and reset the list. Called once per HMR reload.
+	*/
+	runCleanup(file) {
+		for (const hook of file.cleanup) try {
+			if (typeof hook === "function") hook();
+			else if (hook && typeof hook.unsubscribe === "function") hook.unsubscribe();
+		} catch {}
+		file.resetCleanup();
+	}
+	/**
+	* Clean up after a file whose source was deleted from disk.
+	*/
+	cleanupDeletedModule(file) {
+		this.loadedModules.delete(file.absolutePath);
+		if (file.type === "route") router.removeRoutesBySourceFile(file.relativePath);
+		this.runCleanup(file);
+	}
+	/**
+	* Scan a freshly-loaded module for cleanup handlers and register them on
+	* the FileManager so they run before the next reload. Priority: explicit
+	* `export function cleanup()` → `.$cleanup` on any exported value.
+	*/
+	registerCleanup(file, module) {
+		if (typeof module.cleanup === "function") {
+			file.addCleanup(module.cleanup);
+			return;
+		}
+		const cleanups = [];
+		for (const exportedValue of Object.values(module)) {
+			const cleanup = exportedValue?.$cleanup;
+			if (typeof cleanup === "function") cleanups.push(cleanup.bind(exportedValue));
+		}
+		if (cleanups.length > 0) file.addCleanup(cleanups);
+	}
+};
+
+//#endregion
+export { ModuleLoader };
+//# sourceMappingURL=module-loader.mjs.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,26 @@
+import { Path } from "./path.mjs";
+import { getJsonFileAsync } from "@warlock.js/fs";
+
+//#region ../../@warlock.js/core/src/dev-server/package-json-manager.ts
+var PackageJsonManager = class {
+	constructor() {
+		this.packageJson = {};
+	}
+	/**
+	* Initialize the package.json manager
+	*/
+	async init() {
+		this.packageJson = await getJsonFileAsync(Path.toAbsolute("package.json"));
+	}
+	/**
+	* Check if the given path is a package path
+	*/
+	isPathPackage(path) {
+		return Object.keys(this.packageJson.dependencies || {}).concat(Object.keys(this.packageJson.devDependencies || {})).some((packageName) => path.startsWith(packageName));
+	}
+};
+const packageJsonManager = new PackageJsonManager();
+
+//#endregion
+export { packageJsonManager };
+//# sourceMappingURL=package-json-manager.mjs.map

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

@@ -0,0 +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"}