@warlock.js/core 5.29.0 → 5.30.0

package/esm/vite/lower-stage3-decorators.mjs

@@ -1,6 +1,6 @@
 import { transform } from "esbuild";
 
-//#region ../core/src/vite/lower-stage3-decorators.ts
+//#region ../../packages/core/src/vite/lower-stage3-decorators.ts
 /**
 * Vite/Vitest plugin that lowers TC39 Stage-3 (native) decorators to plain JS
 * **before** the rest of the transform pipeline runs.

package/esm/vite/lower-stage3-decorators.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"lower-stage3-decorators.mjs","names":[],"sources":["../../../../../../../core/src/vite/lower-stage3-decorators.ts"],"sourcesContent":["import { transform } from \"esbuild\";\n\n/**\n * The Vite/Vitest plugin object returned by {@link lowerStage3Decorators}.\n *\n * Declared structurally so `@warlock.js/core` needn't take a `vite` dependency\n * just for one type — the shape is assignable to Vite's `PluginOption` wherever\n * it's placed in a config's `plugins` array.\n */\nexport interface DecoratorLoweringPlugin {\n  name: string;\n  enforce: \"pre\";\n  transform(code: string, id: string): Promise<{ code: string; map: string } | null>;\n}\n\n/**\n * Vite/Vitest plugin that lowers TC39 Stage-3 (native) decorators to plain JS\n * **before** the rest of the transform pipeline runs.\n *\n * Cascade models declare relations with native decorators (`@RegisterModel`,\n * `@BelongsTo`, `@HasMany`, …). Vitest's bundled rolldown-vite transforms `.ts`\n * with **oxc**, and Vite's SSR `moduleRunnerTransform` rewrites the decorator's\n * import reference into `@(0, __vite_ssr_import__.RegisterModel)()` — invalid\n * decorator syntax that throws \"SyntaxError: Invalid or unexpected token\" on\n * every model load. oxc can only lower *legacy* decorators, and legacy lowering\n * would mangle the Stage-3 `(value, context)` signature these decorators rely on\n * (they read `context.kind` / `context.metadata`).\n *\n * esbuild lowers Stage-3 decorators correctly while preserving their runtime\n * semantics — the same transform the production `tsx`/build path uses, so a file\n * lowered here behaves identically in dev, test, and prod. Running `enforce:\n * \"pre\"` hands oxc / the SSR rewrite already-lowered, decorator-free code. Files\n * with no decorator skip esbuild entirely, so the fast path is untouched.\n *\n * Keep it **first** in the `plugins` array so it runs ahead of `@mongez/vite`\n * and Vite's core transform.\n *\n * @example\n * ```ts\n * // vite.config.ts / vitest.config.ts\n * import { lowerStage3Decorators } from \"@warlock.js/core/vite\";\n * import { defineConfig } from \"vitest/config\";\n *\n * export default defineConfig({\n *   plugins: [lowerStage3Decorators(), mongezVite()],\n * });\n * ```\n */\nexport function lowerStage3Decorators(): DecoratorLoweringPlugin {\n  return {\n    name: \"warlock:lower-stage3-decorators\",\n    enforce: \"pre\",\n    async transform(code, id) {\n      const [filepath] = id.split(\"?\");\n\n      // `split` always yields a first element, so this holds. Returning `null`\n      // — the plugin's own \"not my file\" answer — rather than defaulting:\n      // `?? \"\"` would fail the `.tsx?` test and reach the same outcome by\n      // accident, and a transform plugin that guesses at a module id is how a\n      // file silently skips decorator lowering and fails at runtime instead.\n      if (filepath === undefined) return null;\n\n      if (!/\\.tsx?$/.test(filepath) || filepath.includes(\"/node_modules/\")) {\n        return null;\n      }\n\n      // Cheap gate: only files that actually carry a decorator pay esbuild's cost.\n      if (!/(^|\\n)\\s*@[A-Za-z_$]/.test(code)) {\n        return null;\n      }\n\n      const result = await transform(code, {\n        loader: filepath.endsWith(\".tsx\") ? \"tsx\" : \"ts\",\n        format: \"esm\",\n        target: \"es2022\",\n        sourcemap: true,\n        sourcefile: filepath,\n        // Force native (Stage-3) semantics regardless of any ambient tsconfig\n        // esbuild might otherwise honor.\n        tsconfigRaw: { compilerOptions: { experimentalDecorators: false } },\n      });\n\n      return { code: result.code, map: result.map };\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,wBAAiD;CAC/D,OAAO;EACL,MAAM;EACN,SAAS;EACT,MAAM,UAAU,MAAM,IAAI;GACxB,MAAM,CAAC,YAAY,GAAG,MAAM,GAAG;GAO/B,IAAI,aAAa,QAAW,OAAO;GAEnC,IAAI,CAAC,UAAU,KAAK,QAAQ,KAAK,SAAS,SAAS,gBAAgB,GACjE,OAAO;GAIT,IAAI,CAAC,uBAAuB,KAAK,IAAI,GACnC,OAAO;GAGT,MAAM,SAAS,MAAM,UAAU,MAAM;IACnC,QAAQ,SAAS,SAAS,MAAM,IAAI,QAAQ;IAC5C,QAAQ;IACR,QAAQ;IACR,WAAW;IACX,YAAY;IAGZ,aAAa,EAAE,iBAAiB,EAAE,wBAAwB,MAAM,EAAE;GACpE,CAAC;GAED,OAAO;IAAE,MAAM,OAAO;IAAM,KAAK,OAAO;GAAI;EAC9C;CACF;AACF"}
+{"version":3,"file":"lower-stage3-decorators.mjs","names":[],"sources":["../../../../../../../../packages/core/src/vite/lower-stage3-decorators.ts"],"sourcesContent":["import { transform } from \"esbuild\";\n\n/**\n * The Vite/Vitest plugin object returned by {@link lowerStage3Decorators}.\n *\n * Declared structurally so `@warlock.js/core` needn't take a `vite` dependency\n * just for one type — the shape is assignable to Vite's `PluginOption` wherever\n * it's placed in a config's `plugins` array.\n */\nexport interface DecoratorLoweringPlugin {\n  name: string;\n  enforce: \"pre\";\n  transform(code: string, id: string): Promise<{ code: string; map: string } | null>;\n}\n\n/**\n * Vite/Vitest plugin that lowers TC39 Stage-3 (native) decorators to plain JS\n * **before** the rest of the transform pipeline runs.\n *\n * Cascade models declare relations with native decorators (`@RegisterModel`,\n * `@BelongsTo`, `@HasMany`, …). Vitest's bundled rolldown-vite transforms `.ts`\n * with **oxc**, and Vite's SSR `moduleRunnerTransform` rewrites the decorator's\n * import reference into `@(0, __vite_ssr_import__.RegisterModel)()` — invalid\n * decorator syntax that throws \"SyntaxError: Invalid or unexpected token\" on\n * every model load. oxc can only lower *legacy* decorators, and legacy lowering\n * would mangle the Stage-3 `(value, context)` signature these decorators rely on\n * (they read `context.kind` / `context.metadata`).\n *\n * esbuild lowers Stage-3 decorators correctly while preserving their runtime\n * semantics — the same transform the production `tsx`/build path uses, so a file\n * lowered here behaves identically in dev, test, and prod. Running `enforce:\n * \"pre\"` hands oxc / the SSR rewrite already-lowered, decorator-free code. Files\n * with no decorator skip esbuild entirely, so the fast path is untouched.\n *\n * Keep it **first** in the `plugins` array so it runs ahead of `@mongez/vite`\n * and Vite's core transform.\n *\n * @example\n * ```ts\n * // vite.config.ts / vitest.config.ts\n * import { lowerStage3Decorators } from \"@warlock.js/core/vite\";\n * import { defineConfig } from \"vitest/config\";\n *\n * export default defineConfig({\n *   plugins: [lowerStage3Decorators(), mongezVite()],\n * });\n * ```\n */\nexport function lowerStage3Decorators(): DecoratorLoweringPlugin {\n  return {\n    name: \"warlock:lower-stage3-decorators\",\n    enforce: \"pre\",\n    async transform(code, id) {\n      const [filepath] = id.split(\"?\");\n\n      // `split` always yields a first element, so this holds. Returning `null`\n      // — the plugin's own \"not my file\" answer — rather than defaulting:\n      // `?? \"\"` would fail the `.tsx?` test and reach the same outcome by\n      // accident, and a transform plugin that guesses at a module id is how a\n      // file silently skips decorator lowering and fails at runtime instead.\n      if (filepath === undefined) return null;\n\n      if (!/\\.tsx?$/.test(filepath) || filepath.includes(\"/node_modules/\")) {\n        return null;\n      }\n\n      // Cheap gate: only files that actually carry a decorator pay esbuild's cost.\n      if (!/(^|\\n)\\s*@[A-Za-z_$]/.test(code)) {\n        return null;\n      }\n\n      const result = await transform(code, {\n        loader: filepath.endsWith(\".tsx\") ? \"tsx\" : \"ts\",\n        format: \"esm\",\n        target: \"es2022\",\n        sourcemap: true,\n        sourcefile: filepath,\n        // Force native (Stage-3) semantics regardless of any ambient tsconfig\n        // esbuild might otherwise honor.\n        tsconfigRaw: { compilerOptions: { experimentalDecorators: false } },\n      });\n\n      return { code: result.code, map: result.map };\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,wBAAiD;CAC/D,OAAO;EACL,MAAM;EACN,SAAS;EACT,MAAM,UAAU,MAAM,IAAI;GACxB,MAAM,CAAC,YAAY,GAAG,MAAM,GAAG;GAO/B,IAAI,aAAa,QAAW,OAAO;GAEnC,IAAI,CAAC,UAAU,KAAK,QAAQ,KAAK,SAAS,SAAS,gBAAgB,GACjE,OAAO;GAIT,IAAI,CAAC,uBAAuB,KAAK,IAAI,GACnC,OAAO;GAGT,MAAM,SAAS,MAAM,UAAU,MAAM;IACnC,QAAQ,SAAS,SAAS,MAAM,IAAI,QAAQ;IAC5C,QAAQ;IACR,QAAQ;IACR,WAAW;IACX,YAAY;IAGZ,aAAa,EAAE,iBAAiB,EAAE,wBAAwB,MAAM,EAAE;GACpE,CAAC;GAED,OAAO;IAAE,MAAM,OAAO;IAAM,KAAK,OAAO;GAAI;EAC9C;CACF;AACF"}

package/esm/warlock-config/bundle-config.mjs

@@ -0,0 +1,148 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { getTsconfig } from "get-tsconfig";
+import { pathToFileURL } from "node:url";
+
+//#region ../../packages/core/src/warlock-config/bundle-config.ts
+/**
+* Local source files the config bundle inlines. Everything else a config can
+* import (JSON, assets) is left to esbuild's own loaders.
+*/
+const LOCAL_SOURCE_FILTER = /\.(?:[cm]?[jt]sx?)$/;
+/**
+* Marks the nested `build.resolve()` the alias check makes, so the plugin's
+* own resolver does not intercept it again.
+*/
+const ALIAS_PROBE = Symbol("warlock-config-alias-probe");
+/**
+* Bundle `warlock.config.ts` and its LOCAL import graph into one ESM module.
+*
+* Used when the runtime cannot import the config as written: Node without
+* native TypeScript, or native TypeScript meeting what only a TS toolchain
+* resolves (an extensionless `./src/connectors/local` import, a tsconfig
+* `paths` alias such as `app/*`).
+*
+* - Relative, absolute and tsconfig-`paths` imports are inlined, so the whole
+*   local graph is transpiled and resolved the way TypeScript sees it.
+* - Every other bare specifier (`@warlock.js/*`, npm packages, `node:*`) stays
+*   an import, so the config shares the application's module instances:
+*   `BaseConnector`, the container and every registry keep one identity.
+* - `import.meta.url` / `dirname` / `filename` in each inlined module are
+*   replaced with that module's ORIGINAL location, so assets resolved relative
+*   to a connector's own folder keep working after inlining. Only real
+*   `import.meta` expressions are replaced: text in strings and comments is
+*   left alone. `import.meta.resolve()` is not rewritten; resolve from
+*   `import.meta.url` instead (`new URL("./asset", import.meta.url)`).
+* - A specifier that matches a tsconfig `paths` pattern is inlined only when it
+*   resolves to a file outside `node_modules`; a catch-all pattern such as
+*   `"*": ["./types/*"]` never pulls a package in.
+*
+* Returns the bundled source. The caller writes it beside the config (so the
+* external imports resolve from the project's `node_modules`) and imports it.
+*/
+async function bundleWarlockConfig(configPath) {
+	const { build } = await import("esbuild");
+	const projectRoot = path.dirname(configPath);
+	const tsconfig = getTsconfig(projectRoot);
+	const isPathAlias = createPathAliasMatcher(tsconfig?.config.compilerOptions?.paths);
+	const output = (await build({
+		entryPoints: [configPath],
+		absWorkingDir: projectRoot,
+		bundle: true,
+		write: false,
+		format: "esm",
+		platform: "node",
+		target: `node${process.versions.node.split(".")[0]}`,
+		tsconfig: tsconfig?.path,
+		logLevel: "silent",
+		plugins: [{
+			name: "warlock-config-local-graph",
+			setup(pluginBuild) {
+				pluginBuild.onResolve({ filter: /^[^./]/ }, async (args) => {
+					if (args.kind === "entry-point" || path.isAbsolute(args.path)) return void 0;
+					if (args.pluginData?.[ALIAS_PROBE]) return void 0;
+					if (!isPathAlias(args.path)) return {
+						path: args.path,
+						external: true
+					};
+					const resolved = await pluginBuild.resolve(args.path, {
+						kind: args.kind,
+						resolveDir: args.resolveDir,
+						importer: args.importer,
+						pluginData: { [ALIAS_PROBE]: true }
+					});
+					if (resolved.errors.length > 0 || resolved.external || isInNodeModules(resolved.path)) return {
+						path: args.path,
+						external: true
+					};
+					return { path: resolved.path };
+				});
+				pluginBuild.onLoad({ filter: LOCAL_SOURCE_FILTER }, async (args) => {
+					if (isInNodeModules(args.path)) return void 0;
+					const source = await readFile(args.path, "utf8");
+					const loader = loaderFor(args.path);
+					if (!source.includes("import.meta")) return {
+						contents: source,
+						loader,
+						resolveDir: path.dirname(args.path)
+					};
+					const { transform } = await import("esbuild");
+					return {
+						contents: (await transform(source, {
+							loader,
+							jsx: "preserve",
+							sourcefile: args.path,
+							tsconfigRaw: { compilerOptions: tsconfig?.config.compilerOptions },
+							define: {
+								"import.meta.url": JSON.stringify(pathToFileURL(args.path).href),
+								"import.meta.dirname": JSON.stringify(path.dirname(args.path)),
+								"import.meta.filename": JSON.stringify(args.path)
+							}
+						})).code,
+						loader: loader === "tsx" || loader === "jsx" ? "jsx" : "js",
+						resolveDir: path.dirname(args.path)
+					};
+				});
+			}
+		}]
+	})).outputFiles?.[0];
+	if (!output) throw new Error(`esbuild produced no output while bundling ${configPath}`);
+	return output.text;
+}
+/**
+* True when a bare specifier matches one of the tsconfig `paths` patterns.
+*
+* Only explicit `paths` count. `baseUrl` alone makes TypeScript (and
+* `get-tsconfig`'s `resolvePathAlias`) offer a candidate for EVERY bare
+* specifier, which would inline packages such as `@warlock.js/core` into the
+* bundle and split `BaseConnector` and the container into two identities.
+*/
+function createPathAliasMatcher(paths) {
+	const patterns = Object.keys(paths ?? {});
+	return (specifier) => patterns.some((pattern) => {
+		const star = pattern.indexOf("*");
+		if (star === -1) return specifier === pattern;
+		const prefix = pattern.slice(0, star);
+		const suffix = pattern.slice(star + 1);
+		return specifier.length >= prefix.length + suffix.length && specifier.startsWith(prefix) && specifier.endsWith(suffix);
+	});
+}
+/**
+* True when `filePath` lies inside a `node_modules` folder: a package, never
+* inlined into the config bundle.
+*/
+function isInNodeModules(filePath) {
+	return path.normalize(filePath).split(path.sep).includes("node_modules");
+}
+/**
+* The esbuild loader for a local source file, by extension.
+*/
+function loaderFor(filePath) {
+	const extension = path.extname(filePath).replace(/^\.[cm]?/, "");
+	if (extension === "tsx" || extension === "jsx" || extension === "ts") return extension;
+	return "js";
+}
+
+//#endregion
+export { bundleWarlockConfig };
+//# sourceMappingURL=bundle-config.mjs.map

package/esm/warlock-config/bundle-config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-config.mjs","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/bundle-config.ts"],"sourcesContent":["import type { TsconfigRaw } from \"esbuild\";\nimport { getTsconfig } from \"get-tsconfig\";\nimport { readFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\n\n/**\n * Local source files the config bundle inlines. Everything else a config can\n * import (JSON, assets) is left to esbuild's own loaders.\n */\nconst LOCAL_SOURCE_FILTER = /\\.(?:[cm]?[jt]sx?)$/;\n\n/**\n * Marks the nested `build.resolve()` the alias check makes, so the plugin's\n * own resolver does not intercept it again.\n */\nconst ALIAS_PROBE = Symbol(\"warlock-config-alias-probe\");\n\n/**\n * Bundle `warlock.config.ts` and its LOCAL import graph into one ESM module.\n *\n * Used when the runtime cannot import the config as written: Node without\n * native TypeScript, or native TypeScript meeting what only a TS toolchain\n * resolves (an extensionless `./src/connectors/local` import, a tsconfig\n * `paths` alias such as `app/*`).\n *\n * - Relative, absolute and tsconfig-`paths` imports are inlined, so the whole\n *   local graph is transpiled and resolved the way TypeScript sees it.\n * - Every other bare specifier (`@warlock.js/*`, npm packages, `node:*`) stays\n *   an import, so the config shares the application's module instances:\n *   `BaseConnector`, the container and every registry keep one identity.\n * - `import.meta.url` / `dirname` / `filename` in each inlined module are\n *   replaced with that module's ORIGINAL location, so assets resolved relative\n *   to a connector's own folder keep working after inlining. Only real\n *   `import.meta` expressions are replaced: text in strings and comments is\n *   left alone. `import.meta.resolve()` is not rewritten; resolve from\n *   `import.meta.url` instead (`new URL(\"./asset\", import.meta.url)`).\n * - A specifier that matches a tsconfig `paths` pattern is inlined only when it\n *   resolves to a file outside `node_modules`; a catch-all pattern such as\n *   `\"*\": [\"./types/*\"]` never pulls a package in.\n *\n * Returns the bundled source. The caller writes it beside the config (so the\n * external imports resolve from the project's `node_modules`) and imports it.\n */\nexport async function bundleWarlockConfig(configPath: string): Promise<string> {\n  const { build } = await import(\"esbuild\");\n  const projectRoot = path.dirname(configPath);\n  const tsconfig = getTsconfig(projectRoot);\n\n  const isPathAlias = createPathAliasMatcher(tsconfig?.config.compilerOptions?.paths);\n\n  const result = await build({\n    entryPoints: [configPath],\n    absWorkingDir: projectRoot,\n    bundle: true,\n    write: false,\n    format: \"esm\",\n    platform: \"node\",\n    target: `node${process.versions.node.split(\".\")[0]}`,\n    tsconfig: tsconfig?.path,\n    logLevel: \"silent\",\n    plugins: [\n      {\n        name: \"warlock-config-local-graph\",\n        setup(pluginBuild) {\n          // Keep packages external, but let tsconfig `paths` aliases through to\n          // esbuild's resolver: `app/connectors/local` is local code, not a package.\n          pluginBuild.onResolve({ filter: /^[^./]/ }, async (args) => {\n            if (args.kind === \"entry-point\" || path.isAbsolute(args.path)) return undefined;\n\n            if (args.pluginData?.[ALIAS_PROBE]) return undefined;\n\n            if (!isPathAlias(args.path)) return { path: args.path, external: true };\n\n            // A `paths` pattern can match package names too (a catch-all `\"*\"`\n            // does). Resolve it the way TypeScript would and inline it only\n            // when it lands on the project's own source.\n            const resolved = await pluginBuild.resolve(args.path, {\n              kind: args.kind,\n              resolveDir: args.resolveDir,\n              importer: args.importer,\n              pluginData: { [ALIAS_PROBE]: true },\n            });\n\n            if (resolved.errors.length > 0 || resolved.external || isInNodeModules(resolved.path)) {\n              return { path: args.path, external: true };\n            }\n\n            return { path: resolved.path };\n          });\n\n          pluginBuild.onLoad({ filter: LOCAL_SOURCE_FILTER }, async (args) => {\n            if (isInNodeModules(args.path)) return undefined;\n\n            const source = await readFile(args.path, \"utf8\");\n            const loader = loaderFor(args.path);\n\n            if (!source.includes(\"import.meta\")) {\n              return { contents: source, loader, resolveDir: path.dirname(args.path) };\n            }\n\n            // `define` replaces only real `import.meta.*` expressions; text in\n            // strings, templates and comments is untouched. JSX is preserved so\n            // the bundle compiles it with the project's own JSX settings.\n            const { transform } = await import(\"esbuild\");\n            const transformed = await transform(source, {\n              loader,\n              jsx: \"preserve\",\n              sourcefile: args.path,\n              tsconfigRaw: {\n                compilerOptions: tsconfig?.config.compilerOptions as TsconfigRaw[\"compilerOptions\"],\n              },\n              define: {\n                \"import.meta.url\": JSON.stringify(pathToFileURL(args.path).href),\n                \"import.meta.dirname\": JSON.stringify(path.dirname(args.path)),\n                \"import.meta.filename\": JSON.stringify(args.path),\n              },\n            });\n\n            return {\n              contents: transformed.code,\n              loader: loader === \"tsx\" || loader === \"jsx\" ? \"jsx\" : \"js\",\n              resolveDir: path.dirname(args.path),\n            };\n          });\n        },\n      },\n    ],\n  });\n\n  const output = result.outputFiles?.[0];\n\n  if (!output) {\n    throw new Error(`esbuild produced no output while bundling ${configPath}`);\n  }\n\n  return output.text;\n}\n\n/**\n * True when a bare specifier matches one of the tsconfig `paths` patterns.\n *\n * Only explicit `paths` count. `baseUrl` alone makes TypeScript (and\n * `get-tsconfig`'s `resolvePathAlias`) offer a candidate for EVERY bare\n * specifier, which would inline packages such as `@warlock.js/core` into the\n * bundle and split `BaseConnector` and the container into two identities.\n */\nfunction createPathAliasMatcher(paths: Record<string, string[]> | undefined) {\n  const patterns = Object.keys(paths ?? {});\n\n  return (specifier: string) =>\n    patterns.some((pattern) => {\n      const star = pattern.indexOf(\"*\");\n\n      if (star === -1) return specifier === pattern;\n\n      const prefix = pattern.slice(0, star);\n      const suffix = pattern.slice(star + 1);\n\n      return (\n        specifier.length >= prefix.length + suffix.length &&\n        specifier.startsWith(prefix) &&\n        specifier.endsWith(suffix)\n      );\n    });\n}\n\n/**\n * True when `filePath` lies inside a `node_modules` folder: a package, never\n * inlined into the config bundle.\n */\nfunction isInNodeModules(filePath: string): boolean {\n  return path.normalize(filePath).split(path.sep).includes(\"node_modules\");\n}\n\n/**\n * The esbuild loader for a local source file, by extension.\n */\nfunction loaderFor(filePath: string): \"ts\" | \"tsx\" | \"js\" | \"jsx\" {\n  const extension = path.extname(filePath).replace(/^\\.[cm]?/, \"\");\n\n  if (extension === \"tsx\" || extension === \"jsx\" || extension === \"ts\") return extension;\n\n  return \"js\";\n}\n"],"mappings":"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"}

package/esm/warlock-config/default-configurations.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/warlock-config/default-configurations.ts
+//#region ../../packages/core/src/warlock-config/default-configurations.ts
 const defaultWarlockConfigurations = { build: {
 	outdir: process.cwd() + "/dist",
 	outFile: "app.js",

package/esm/warlock-config/default-configurations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"default-configurations.mjs","names":[],"sources":["../../../../../../../core/src/warlock-config/default-configurations.ts"],"sourcesContent":["import { type WarlockConfig } from \"./types\";\n\nexport const defaultWarlockConfigurations: WarlockConfig = {\n  build: {\n    outdir: process.cwd() + \"/dist\",\n    outFile: \"app.js\",\n    routeRegistrationTimeoutMs: 30_000,\n    sourcemap: true,\n    minify: true,\n  },\n};\n"],"mappings":";AAEA,MAAa,+BAA8C,EACzD,OAAO;CACL,QAAQ,QAAQ,IAAI,IAAI;CACxB,SAAS;CACT,4BAA4B;CAC5B,WAAW;CACX,QAAQ;AACV,EACF"}
+{"version":3,"file":"default-configurations.mjs","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/default-configurations.ts"],"sourcesContent":["import { type WarlockConfig } from \"./types\";\n\nexport const defaultWarlockConfigurations: WarlockConfig = {\n  build: {\n    outdir: process.cwd() + \"/dist\",\n    outFile: \"app.js\",\n    routeRegistrationTimeoutMs: 30_000,\n    sourcemap: true,\n    minify: true,\n  },\n};\n"],"mappings":";AAEA,MAAa,+BAA8C,EACzD,OAAO;CACL,QAAQ,QAAQ,IAAI,IAAI;CACxB,SAAS;CACT,4BAA4B;CAC5B,WAAW;CACX,QAAQ;AACV,EACF"}

package/esm/warlock-config/define-config.d.mts

@@ -1,6 +1,6 @@
 import { WarlockConfig } from "./types.mjs";
 
-//#region ../core/src/warlock-config/define-config.d.ts
+//#region ../../packages/core/src/warlock-config/define-config.d.ts
 declare function defineConfig(options: WarlockConfig): WarlockConfig;
 //#endregion
 export { defineConfig };

package/esm/warlock-config/define-config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"define-config.d.mts","names":[],"sources":["../../../../../../../core/src/warlock-config/define-config.ts"],"mappings":";;;iBAKgB,YAAA,CAAa,OAAA,EAAS,aAAA,GAQsB,aAAa"}
+{"version":3,"file":"define-config.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/define-config.ts"],"mappings":";;;iBAKgB,YAAA,CAAa,OAAA,EAAS,aAAA,GAQsB,aAAa"}

package/esm/warlock-config/define-config.mjs

@@ -2,7 +2,7 @@ import { defaultWarlockConfigurations } from "./default-configurations.mjs";
 import { normalizeBuildConfig } from "./normalize-build-config.mjs";
 import { merge } from "@mongez/reinforcements";
 
-//#region ../core/src/warlock-config/define-config.ts
+//#region ../../packages/core/src/warlock-config/define-config.ts
 function defineConfig(options) {
 	return merge(defaultWarlockConfigurations, options.build ? {
 		...options,

package/esm/warlock-config/define-config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"define-config.mjs","names":[],"sources":["../../../../../../../core/src/warlock-config/define-config.ts"],"sourcesContent":["import { merge } from \"@mongez/reinforcements\";\nimport { defaultWarlockConfigurations } from \"./default-configurations\";\nimport { normalizeBuildConfig } from \"./normalize-build-config\";\nimport type { WarlockConfig } from \"./types\";\n\nexport function defineConfig(options: WarlockConfig) {\n  // Fold `build.outDirectory` into `build.outdir` BEFORE merging. Afterwards\n  // is too late: the defaults supply an `outdir`, so the alias could never\n  // tell \"the user set outdir\" from \"the default did\" and would be dropped.\n  const normalized: WarlockConfig = options.build\n    ? { ...options, build: normalizeBuildConfig(options.build) }\n    : options;\n\n  return merge(defaultWarlockConfigurations, normalized) as WarlockConfig;\n}\n"],"mappings":";;;;;AAKA,SAAgB,aAAa,SAAwB;CAQnD,OAAO,MAAM,8BAJqB,QAAQ,QACtC;EAAE,GAAG;EAAS,OAAO,qBAAqB,QAAQ,KAAK;CAAE,IACzD,OAEiD;AACvD"}
+{"version":3,"file":"define-config.mjs","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/define-config.ts"],"sourcesContent":["import { merge } from \"@mongez/reinforcements\";\nimport { defaultWarlockConfigurations } from \"./default-configurations\";\nimport { normalizeBuildConfig } from \"./normalize-build-config\";\nimport type { WarlockConfig } from \"./types\";\n\nexport function defineConfig(options: WarlockConfig) {\n  // Fold `build.outDirectory` into `build.outdir` BEFORE merging. Afterwards\n  // is too late: the defaults supply an `outdir`, so the alias could never\n  // tell \"the user set outdir\" from \"the default did\" and would be dropped.\n  const normalized: WarlockConfig = options.build\n    ? { ...options, build: normalizeBuildConfig(options.build) }\n    : options;\n\n  return merge(defaultWarlockConfigurations, normalized) as WarlockConfig;\n}\n"],"mappings":";;;;;AAKA,SAAgB,aAAa,SAAwB;CAQnD,OAAO,MAAM,8BAJqB,QAAQ,QACtC;EAAE,GAAG;EAAS,OAAO,qBAAqB,QAAQ,KAAK;CAAE,IACzD,OAEiD;AACvD"}

package/esm/warlock-config/index.d.mts

@@ -1,3 +1,3 @@
 import { WarlockConfig } from "./types.mjs";
 import { defineConfig } from "./define-config.mjs";
-import { WarlockConfigManager, isUnknownTsExtensionError, warlockConfigManager } from "./warlock-config.manager.mjs";
+import { WarlockConfigManager, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, warlockConfigManager } from "./warlock-config.manager.mjs";

package/esm/warlock-config/index.mjs

@@ -1,4 +1,4 @@
-import { WarlockConfigManager, isUnknownTsExtensionError, warlockConfigManager } from "./warlock-config.manager.mjs";
+import { WarlockConfigManager, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, warlockConfigManager } from "./warlock-config.manager.mjs";
 import { defineConfig } from "./define-config.mjs";
 
 export {  };

package/esm/warlock-config/normalize-build-config.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/warlock-config/normalize-build-config.ts
+//#region ../../packages/core/src/warlock-config/normalize-build-config.ts
 /**
 * Fold the `outDirectory` alias into the canonical `outdir`.
 *

package/esm/warlock-config/normalize-build-config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"normalize-build-config.mjs","names":[],"sources":["../../../../../../../core/src/warlock-config/normalize-build-config.ts"],"sourcesContent":["import type { WarlockConfig } from \"./types\";\n\ntype BuildConfig = NonNullable<WarlockConfig[\"build\"]>;\n\n/**\n * Fold the `outDirectory` alias into the canonical `outdir`.\n *\n * `outDirectory` is the name the documentation used for several releases\n * while the code only ever read `outdir`, so a config written from the docs\n * was silently ignored and the bundle still landed in `dist/`. Accepting both\n * keeps those configs working; `outdir` wins when both are set, since that is\n * the name esbuild uses and the one we tell people to prefer.\n *\n * Returns the input untouched when there is nothing to fold, so the common\n * case allocates nothing.\n */\nexport function normalizeBuildConfig<T extends BuildConfig>(\n  build: T,\n): T & Pick<BuildConfig, \"outdir\"> {\n  if (!build.outDirectory || build.outdir) {\n    return build;\n  }\n\n  return { ...build, outdir: build.outDirectory };\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,SAAgB,qBACd,OACiC;CACjC,IAAI,CAAC,MAAM,gBAAgB,MAAM,QAC/B,OAAO;CAGT,OAAO;EAAE,GAAG;EAAO,QAAQ,MAAM;CAAa;AAChD"}
+{"version":3,"file":"normalize-build-config.mjs","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/normalize-build-config.ts"],"sourcesContent":["import type { WarlockConfig } from \"./types\";\n\ntype BuildConfig = NonNullable<WarlockConfig[\"build\"]>;\n\n/**\n * Fold the `outDirectory` alias into the canonical `outdir`.\n *\n * `outDirectory` is the name the documentation used for several releases\n * while the code only ever read `outdir`, so a config written from the docs\n * was silently ignored and the bundle still landed in `dist/`. Accepting both\n * keeps those configs working; `outdir` wins when both are set, since that is\n * the name esbuild uses and the one we tell people to prefer.\n *\n * Returns the input untouched when there is nothing to fold, so the common\n * case allocates nothing.\n */\nexport function normalizeBuildConfig<T extends BuildConfig>(\n  build: T,\n): T & Pick<BuildConfig, \"outdir\"> {\n  if (!build.outDirectory || build.outdir) {\n    return build;\n  }\n\n  return { ...build, outdir: build.outDirectory };\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,SAAgB,qBACd,OACiC;CACjC,IAAI,CAAC,MAAM,gBAAgB,MAAM,QAC/B,OAAO;CAGT,OAAO;EAAE,GAAG;EAAO,QAAQ,MAAM;CAAa;AAChD"}

package/esm/warlock-config/types.d.mts

@@ -4,7 +4,7 @@ import { CLICommand } from "../commands/cli-command.mjs";
 import { MigrationConstructor } from "@warlock.js/cascade";
 import { BuildOptions } from "esbuild";
 
-//#region ../core/src/warlock-config/types.d.ts
+//#region ../../packages/core/src/warlock-config/types.d.ts
 /**
  * Resolved Warlock Configuration
  *

package/esm/warlock-config/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../core/src/warlock-config/types.ts"],"mappings":";;;;;;;;;AAWA;;;KAAY,aAAA;EA8BF;;;EA1BR,MAAA;IAsOqB;;;IAlOnB,IAAA;IAJF;;;IAQE,IAAA;IAkBF;;;IAdE,cAAA;EAAA;EAqCA;;;;;;;;;;;EAvBF,KAAA,GAAQ,IAAA,CAAK,YAAA;IAsHX;;;;;IAhHA,MAAA;IA+IA;;;;;;;;;;IApIA,YAAA;IAsNO;AAAA;;;;IAhNP,OAAA;;;;;;;IAOA,0BAAA;;;;;;;;;;;;;;;;;IAiBA,YAAA;;;;;;;;;;;;;;;;IAgBA,OAAA;;;;;;IAMA,MAAA;;;;;;IAMA,SAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;EA2BF,UAAA,GAAa,SAAA;;;;EAKb,GAAA;IACE,QAAA,GAAW,UAAA;EAAA;;;;EAMb,SAAA;;;;IAIE,KAAA;;;;;;MAME,OAAA;;;;;;MAMA,OAAA;IAAA;;;;IAKF,cAAA,GAAiB,yBAAA;;;;;IAKjB,eAAA;;;;;;;;;IASA,eAAA;;;;;;;;;IASA,qBAAA;;;;;;;;;;IAUA,mBAAA;;;;;;;;;;;;IAYA,OAAA;EAAA;;;;EAMF,QAAA;;;;;;;;;;;;;;;;;;IAkBE,UAAA,GAAa,KAAA,CAAM,oBAAA;EAAA;;;;;;;EASrB,OAAA;;;;;;;;;IASE,OAAA;;;;;;;;IASA,OAAA;EAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/types.ts"],"mappings":";;;;;;;;;AAWA;;;KAAY,aAAA;EA8BF;;;EA1BR,MAAA;IAsOqB;;;IAlOnB,IAAA;IAJF;;;IAQE,IAAA;IAkBF;;;IAdE,cAAA;EAAA;EAqCA;;;;;;;;;;;EAvBF,KAAA,GAAQ,IAAA,CAAK,YAAA;IAsHX;;;;;IAhHA,MAAA;IA+IA;;;;;;;;;;IApIA,YAAA;IAsNO;AAAA;;;;IAhNP,OAAA;;;;;;;IAOA,0BAAA;;;;;;;;;;;;;;;;;IAiBA,YAAA;;;;;;;;;;;;;;;;IAgBA,OAAA;;;;;;IAMA,MAAA;;;;;;IAMA,SAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;EA2BF,UAAA,GAAa,SAAA;;;;EAKb,GAAA;IACE,QAAA,GAAW,UAAA;EAAA;;;;EAMb,SAAA;;;;IAIE,KAAA;;;;;;MAME,OAAA;;;;;;MAMA,OAAA;IAAA;;;;IAKF,cAAA,GAAiB,yBAAA;;;;;IAKjB,eAAA;;;;;;;;;IASA,eAAA;;;;;;;;;IASA,qBAAA;;;;;;;;;;IAUA,mBAAA;;;;;;;;;;;;IAYA,OAAA;EAAA;;;;EAMF,QAAA;;;;;;;;;;;;;;;;;;IAkBE,UAAA,GAAa,KAAA,CAAM,oBAAA;EAAA;;;;;;;EASrB,OAAA;;;;;;;;;IASE,OAAA;;;;;;;;IASA,OAAA;EAAA;AAAA"}

package/esm/warlock-config/warlock-config.manager.d.mts

@@ -1,6 +1,6 @@
 import { WarlockConfig } from "./types.mjs";
 
-//#region ../core/src/warlock-config/warlock-config.manager.d.ts
+//#region ../../packages/core/src/warlock-config/warlock-config.manager.d.ts
 /**
  * True when `error` is Node's "this runtime can't import a `.ts` file" error.
  *
@@ -10,6 +10,27 @@ import { WarlockConfig } from "./types.mjs";
  * the signal to fall back to transpiling the config ourselves.
  */
 declare function isUnknownTsExtensionError(error: unknown): boolean;
+/**
+ * True when `error` is Node failing to RESOLVE an import of the config's OWN
+ * graph: an extensionless relative import (`./src/connectors/local`), a
+ * directory import, or a tsconfig `paths` alias (`app/connectors`) — all of
+ * which only a TypeScript toolchain resolves. Native type stripping
+ * (Node ≥ 22.18) loads `warlock.config.ts` itself, then fails here.
+ *
+ * A package that is genuinely not installed is NOT a fallback case: the error
+ * names a bare specifier that matches no `paths` pattern, and it is rethrown
+ * as is. Neither is a missing module imported from inside `node_modules`.
+ *
+ * `pathAliases` are the tsconfig `paths` patterns (`app/*`). When the message
+ * cannot be parsed the error is treated as a graph error, as before.
+ */
+declare function isUnresolvedConfigImportError(error: unknown, pathAliases?: readonly string[]): boolean;
+/**
+ * True when `error` is native type stripping refusing TypeScript it cannot
+ * strip (an `enum`, a `namespace`, a parameter property) or a `.ts` file under
+ * `node_modules`. Both are raised while loading, before the graph runs.
+ */
+declare function isUnsupportedTypeStrippingError(error: unknown): boolean;
 /**
  * Warlock Config Manager
  *
@@ -39,12 +60,16 @@ declare class WarlockConfigManager {
    */
   private doLoad;
   /**
-   * Fallback config loader for runtimes without native TypeScript support.
+   * Fallback config loader for runtimes that cannot import the config as written.
    *
-   * Transpiles `warlock.config.ts` with esbuild (already a core dependency),
-   * writes the result as a sibling `.mjs` — so the config's own imports (bare
-   * `@warlock.js/*` and any relative paths) resolve exactly as they would from
-   * the original location — imports it, then removes the temp file.
+   * Bundles `warlock.config.ts` with its LOCAL import graph (relative imports,
+   * extensionless TS imports, tsconfig `paths` aliases) through esbuild, keeping
+   * every package external so `BaseConnector`, the container and other
+   * registries keep the application's identity (see `bundleWarlockConfig`).
+   * The bundle is written as a sibling `.mjs` — so its external imports resolve
+   * from the project exactly as they would from the original config — imported
+   * once, then removed whether it loaded or threw. An error thrown by the
+   * user's config propagates unchanged.
    */
   private loadViaEsbuild;
   /**
@@ -100,5 +125,5 @@ declare class WarlockConfigManager {
  */
 declare const warlockConfigManager: WarlockConfigManager;
 //#endregion
-export { WarlockConfigManager, isUnknownTsExtensionError, warlockConfigManager };
+export { WarlockConfigManager, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, warlockConfigManager };
 //# sourceMappingURL=warlock-config.manager.d.mts.map

package/esm/warlock-config/warlock-config.manager.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"warlock-config.manager.d.mts","names":[],"sources":["../../../../../../../core/src/warlock-config/warlock-config.manager.ts"],"mappings":";;;;;AAgBA;;;;AAAwD;AAaxD;iBAbgB,yBAAA,CAA0B,KAAc;;;;;;;cAa3C,oBAAA;EAgIR;;;EAAA,QA5HK,MAAA;EAgJS;;;EAAA,QA3IT,OAAA;EA4IL;;;;;EArIU,IAAA,IAAQ,OAAA,CAAQ,aAAA;EAPrB;;;;;;EAAA,QAqCM,MAAA;EA+EH;;;;;;;;EAAA,QAtCG,cAAA;EA2DR;;;;;;;;;;;EArBC,GAAA,mBAAsB,aAAA,EAC3B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,aAAA,CAAc,GAAA;EAsCV;;;;;AAWuB;AAoBhC;;;;EAnDQ,OAAA,mBAA0B,aAAA,EAC9B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,OAAA,CAAQ,aAAA,CAAc,GAAA;;;;MAQd,QAAA;;;;;;EASJ,MAAA,IAAU,aAAA;;;;EAWJ,MAAA,IAAU,OAAA;AAAA;;;;;;;;;;;;;;cAoBZ,oBAAA,EAAoB,oBAA6B"}
+{"version":3,"file":"warlock-config.manager.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/warlock-config.manager.ts"],"mappings":";;;;;AAyBA;;;;AAAwD;AAqBxD;iBArBgB,yBAAA,CAA0B,KAAc;;;AAuBnB;AA4BrC;;;;AAA8D;AA+B9D;;;;;;iBA7DgB,6BAAA,CACd,KAAA,WACA,WAAmC;;;;;;iBA4BrB,+BAAA,CAAgC,KAAc;;;;;;;cA+BjD,oBAAA;EA0LmB;;;EAAA,QAtLtB,MAAA;EAYK;;;EAAA,QAPL,OAAA;EA6FM;;;;;EAtFD,IAAA,IAAQ,OAAA,CAAQ,aAAA;EAwHZ;;;;;;EAAA,QA1FH,MAAA;EA6GkB;;;;;;;;;;;;EAAA,QArDlB,cAAA;EAoFS;;AAAO;AAwDhC;;;;AAA8D;;;;EA5GrD,GAAA,mBAAsB,aAAA,EAC3B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,aAAA,CAAc,GAAA;;;;;;;;;;;EAkBX,OAAA,mBAA0B,aAAA,EAC9B,GAAA,EAAK,GAAA,EACL,YAAA,GAAe,aAAA,CAAc,GAAA,IAC5B,OAAA,CAAQ,aAAA,CAAc,GAAA;;;;MAQd,QAAA;;;;;;EASJ,MAAA,IAAU,aAAA;;;;EAWJ,MAAA,IAAU,OAAA;AAAA;;;;;;;;;;;;;;cAwDZ,oBAAA,EAAoB,oBAA6B"}

package/esm/warlock-config/warlock-config.manager.mjs

@@ -1,12 +1,20 @@
 import { rootPath } from "../utils/paths.mjs";
 import "../utils/index.mjs";
+import { bundleWarlockConfig } from "./bundle-config.mjs";
 import { getDeprecatedConfigWarnings } from "./warn-deprecated-config.mjs";
+import path from "node:path";
 import { get } from "@mongez/reinforcements";
 import { fileExistsAsync } from "@warlock.js/fs";
-import { readFile, unlink, writeFile } from "node:fs/promises";
+import { unlink, writeFile } from "node:fs/promises";
+import { getTsconfig } from "get-tsconfig";
 import { pathToFileURL } from "url";
 
-//#region ../core/src/warlock-config/warlock-config.manager.ts
+//#region ../../packages/core/src/warlock-config/warlock-config.manager.ts
+/**
+* `Error` with the ES2022 `cause` option, typed for packages still compiled
+* against an older lib (see `application.ts`).
+*/
+const ErrorWithCause = Error;
 /**
 * True when `error` is Node's "this runtime can't import a `.ts` file" error.
 *
@@ -19,6 +27,52 @@ function isUnknownTsExtensionError(error) {
 	return error?.code === "ERR_UNKNOWN_FILE_EXTENSION" || /Unknown file extension "\.tsx?"/.test(String(error?.message));
 }
 /**
+* True when `error` is Node failing to RESOLVE an import of the config's OWN
+* graph: an extensionless relative import (`./src/connectors/local`), a
+* directory import, or a tsconfig `paths` alias (`app/connectors`) — all of
+* which only a TypeScript toolchain resolves. Native type stripping
+* (Node ≥ 22.18) loads `warlock.config.ts` itself, then fails here.
+*
+* A package that is genuinely not installed is NOT a fallback case: the error
+* names a bare specifier that matches no `paths` pattern, and it is rethrown
+* as is. Neither is a missing module imported from inside `node_modules`.
+*
+* `pathAliases` are the tsconfig `paths` patterns (`app/*`). When the message
+* cannot be parsed the error is treated as a graph error, as before.
+*/
+function isUnresolvedConfigImportError(error, pathAliases = []) {
+	const code = error?.code;
+	if (code === "ERR_UNSUPPORTED_DIR_IMPORT") return true;
+	if (code !== "ERR_MODULE_NOT_FOUND") return false;
+	const message = String(error?.message ?? "");
+	const match = /Cannot find (module|package) '([^']+)' imported from (.+)$/m.exec(message);
+	if (!match) return true;
+	const [, kind, specifier = "", importer = ""] = match;
+	if (/[\\/]node_modules[\\/]/.test(importer)) return false;
+	if (kind === "module") return true;
+	return pathAliases.some((pattern) => aliasCovers(pattern, specifier));
+}
+/**
+* True when `error` is native type stripping refusing TypeScript it cannot
+* strip (an `enum`, a `namespace`, a parameter property) or a `.ts` file under
+* `node_modules`. Both are raised while loading, before the graph runs.
+*/
+function isUnsupportedTypeStrippingError(error) {
+	const code = error?.code;
+	return code === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX" || code === "ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING";
+}
+/**
+* True when a tsconfig `paths` pattern can produce `packageName` as the first
+* segment(s) of a specifier: `app/*` covers `app`, `@shared/*` covers
+* `@shared`, a catch-all `*` covers anything.
+*/
+function aliasCovers(pattern, packageName) {
+	const star = pattern.indexOf("*");
+	const prefix = star === -1 ? pattern : pattern.slice(0, star);
+	if (prefix === "") return true;
+	return prefix === packageName || prefix.startsWith(`${packageName}/`) || packageName.startsWith(prefix);
+}
+/**
 * Warlock Config Manager
 *
 * Manages lazy loading of the pre-compiled warlock.config.js file
@@ -54,30 +108,30 @@ var WarlockConfigManager = class {
 		try {
 			return (await import(pathToFileURL(configPath).href)).default;
 		} catch (error) {
-			if (isUnknownTsExtensionError(error)) return await this.loadViaEsbuild(configPath);
-			throw new Error(`Failed to load warlock.config.ts: ${error}`);
+			if (isUnknownTsExtensionError(error) || isUnsupportedTypeStrippingError(error) || isUnresolvedConfigImportError(error, configPathAliases(configPath))) return await this.loadViaEsbuild(configPath);
+			throw new ErrorWithCause(`Failed to load warlock.config.ts: ${error}`, { cause: error });
 		}
 	}
 	/**
-	* Fallback config loader for runtimes without native TypeScript support.
+	* Fallback config loader for runtimes that cannot import the config as written.
 	*
-	* Transpiles `warlock.config.ts` with esbuild (already a core dependency),
-	* writes the result as a sibling `.mjs` — so the config's own imports (bare
-	* `@warlock.js/*` and any relative paths) resolve exactly as they would from
-	* the original location — imports it, then removes the temp file.
+	* Bundles `warlock.config.ts` with its LOCAL import graph (relative imports,
+	* extensionless TS imports, tsconfig `paths` aliases) through esbuild, keeping
+	* every package external so `BaseConnector`, the container and other
+	* registries keep the application's identity (see `bundleWarlockConfig`).
+	* The bundle is written as a sibling `.mjs` — so its external imports resolve
+	* from the project exactly as they would from the original config — imported
+	* once, then removed whether it loaded or threw. An error thrown by the
+	* user's config propagates unchanged.
 	*/
 	async loadViaEsbuild(configPath) {
-		const { transformSync } = await import("esbuild");
-		const { code } = transformSync(await readFile(configPath, "utf8"), {
-			loader: "ts",
-			format: "esm",
-			target: `node${process.versions.node.split(".")[0]}`,
-			sourcefile: configPath
-		});
-		const compiledPath = configPath.replace(/warlock\.config\.ts$/, `.warlock.config.${process.pid}.mjs`);
+		const code = await bundleWarlockConfig(configPath);
+		const compiledPath = configPath.replace(/warlock\.config\.ts$/, `.warlock.config.${process.pid}.${Date.now()}.mjs`);
 		await writeFile(compiledPath, code, "utf8");
 		try {
 			return (await import(pathToFileURL(compiledPath).href)).default;
+		} catch (error) {
+			throw nameOriginalConfig(error, compiledPath, configPath);
 		} finally {
 			await unlink(compiledPath).catch(() => {});
 		}
@@ -136,6 +190,28 @@ var WarlockConfigManager = class {
 	}
 };
 /**
+* The tsconfig `paths` patterns of the project holding `configPath`.
+*/
+function configPathAliases(configPath) {
+	try {
+		return Object.keys(getTsconfig(path.dirname(configPath))?.config.compilerOptions?.paths ?? {});
+	} catch {
+		return [];
+	}
+}
+/**
+* A loader error raised by the bundled config names the temporary `.mjs`
+* module. Rewrite it to name `warlock.config.ts`, keeping the original as the
+* cause. An error thrown by the user's own config is returned unchanged.
+*/
+function nameOriginalConfig(error, compiledPath, configPath) {
+	const code = error?.code;
+	if (typeof code !== "string" || !code.startsWith("ERR_")) return error;
+	const wrapped = new ErrorWithCause(`Failed to load warlock.config.ts: ${String(error.message ?? error).split(pathToFileURL(compiledPath).href).join(pathToFileURL(configPath).href).split(compiledPath).join(configPath)}`, { cause: error });
+	wrapped.code = code;
+	return wrapped;
+}
+/**
 * Exported singleton instance
 *
 * @example
@@ -151,5 +227,5 @@ var WarlockConfigManager = class {
 const warlockConfigManager = new WarlockConfigManager();
 
 //#endregion
-export { WarlockConfigManager, isUnknownTsExtensionError, warlockConfigManager };
+export { WarlockConfigManager, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, warlockConfigManager };
 //# sourceMappingURL=warlock-config.manager.mjs.map

package/esm/warlock-config/warlock-config.manager.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"warlock-config.manager.mjs","names":[],"sources":["../../../../../../../core/src/warlock-config/warlock-config.manager.ts"],"sourcesContent":["import { fileExistsAsync } from \"@warlock.js/fs\";\nimport { get } from \"@mongez/reinforcements\";\nimport { readFile, unlink, writeFile } from \"node:fs/promises\";\nimport { pathToFileURL } from \"url\";\nimport { rootPath } from \"../utils\";\nimport { type WarlockConfig } from \"./types\";\nimport { getDeprecatedConfigWarnings } from \"./warn-deprecated-config\";\n\n/**\n * True when `error` is Node's \"this runtime can't import a `.ts` file\" error.\n *\n * Node only executes TypeScript natively from v22.18 / v23.6 onward (earlier\n * 22.x needs `--experimental-strip-types`). On older runtimes a bare\n * `import(\"warlock.config.ts\")` throws `ERR_UNKNOWN_FILE_EXTENSION` — which is\n * the signal to fall back to transpiling the config ourselves.\n */\nexport function isUnknownTsExtensionError(error: unknown): boolean {\n  return (\n    (error as { code?: string })?.code === \"ERR_UNKNOWN_FILE_EXTENSION\" ||\n    /Unknown file extension \"\\.tsx?\"/.test(String((error as Error)?.message))\n  );\n}\n\n/**\n * Warlock Config Manager\n *\n * Manages lazy loading of the pre-compiled warlock.config.js file\n * from the .warlock/cache directory.\n */\nexport class WarlockConfigManager {\n  /**\n   * Cached config instance\n   */\n  private config?: WarlockConfig;\n\n  /**\n   * Loading promise to prevent duplicate loads\n   */\n  private loading?: Promise<WarlockConfig | undefined>;\n\n  /**\n   * Load warlock.config.js (cached after first load)\n   *\n   * @returns The resolved Warlock configuration\n   */\n  public async load(): Promise<WarlockConfig | undefined> {\n    // Already loaded\n    if (this.config) {\n      return this.config;\n    }\n\n    // Currently loading (prevent duplicate loads)\n    if (this.loading) {\n      return this.loading;\n    }\n\n    // Start loading\n    this.loading = this.doLoad();\n    this.config = await this.loading;\n    this.loading = undefined;\n\n    // Console, not the logger: this runs before any log channel exists.\n    for (const warning of getDeprecatedConfigWarnings(this.config)) {\n      console.warn(warning);\n    }\n\n    return this.config;\n  }\n\n  /**\n   * Internal load implementation\n   *\n   * The ESM loader hook transpiles `warlock.config.ts` on import — no\n   * separate compile-to-disk step is needed.\n   */\n  private async doLoad(): Promise<WarlockConfig | undefined> {\n    const configPath = rootPath(\"warlock.config.ts\");\n\n    if (!(await fileExistsAsync(configPath))) {\n      // Written straight to the console, NOT through `@warlock.js/logger`.\n      // This runs during CLI bootstrap, before `LoggerConnector.start()` has\n      // configured a single channel, so a logger call here reaches nobody in\n      // any application — the warning would be silently dropped exactly when\n      // the user most needs it.\n      console.warn(\n        \"warlock.config.ts is missing — create it at the project root (see https://warlock.js.org/docs for the config reference)\",\n      );\n      return;\n    }\n\n    try {\n      const configModule = await import(pathToFileURL(configPath).href);\n      return configModule.default;\n    } catch (error) {\n      // `dev` registers a TS loader hook, and Node ≥ 22.18 / 23.6 strips types\n      // natively — in both cases the direct import above works. But `build` /\n      // `start` register no hook, so on an older Node the import throws\n      // ERR_UNKNOWN_FILE_EXTENSION. Transpile the config with esbuild ourselves\n      // so config loading is Node-version-independent rather than relying on an\n      // experimental runtime feature.\n      if (isUnknownTsExtensionError(error)) {\n        return await this.loadViaEsbuild(configPath);\n      }\n\n      throw new Error(`Failed to load warlock.config.ts: ${error}`);\n    }\n  }\n\n  /**\n   * Fallback config loader for runtimes without native TypeScript support.\n   *\n   * Transpiles `warlock.config.ts` with esbuild (already a core dependency),\n   * writes the result as a sibling `.mjs` — so the config's own imports (bare\n   * `@warlock.js/*` and any relative paths) resolve exactly as they would from\n   * the original location — imports it, then removes the temp file.\n   */\n  private async loadViaEsbuild(configPath: string): Promise<WarlockConfig | undefined> {\n    const { transformSync } = await import(\"esbuild\");\n    const source = await readFile(configPath, \"utf8\");\n\n    const { code } = transformSync(source, {\n      loader: \"ts\",\n      format: \"esm\",\n      target: `node${process.versions.node.split(\".\")[0]}`,\n      sourcefile: configPath,\n    });\n\n    // Unique sibling name so concurrent processes never clobber each other.\n    const compiledPath = configPath.replace(\n      /warlock\\.config\\.ts$/,\n      `.warlock.config.${process.pid}.mjs`,\n    );\n\n    await writeFile(compiledPath, code, \"utf8\");\n\n    try {\n      const configModule = await import(pathToFileURL(compiledPath).href);\n      return configModule.default;\n    } finally {\n      await unlink(compiledPath).catch(() => {});\n    }\n  }\n\n  /**\n   * Get config value by key (dot notation supported)\n   *\n   * @example\n   * config.get(\"server.port\") // Returns 3000\n   * config.get(\"cli.commands\") // Returns array of commands\n   *\n   * @param key - Config key (supports dot notation), autocompletes for first level only\n   * @returns The config value\n   * @throws Error if config is not loaded\n   */\n  public get<Key extends keyof WarlockConfig>(\n    key: Key,\n    defaultValue?: WarlockConfig[Key],\n  ): WarlockConfig[Key] {\n    if (!this.config) {\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\n    }\n\n    return get(this.config, key as string, defaultValue);\n  }\n\n  /**\n   * Lazy get - loads config if not already loaded\n   *\n   * @example\n   * const port = await config.lazyGet(\"server\");\n   *\n   * @param key - Config key (supports dot notation), autocompletes for first level only\n   * @param defaultValue - Default value if config key is undefined\n   * @returns The config value\n   */\n  async lazyGet<Key extends keyof WarlockConfig>(\n    key: Key,\n    defaultValue?: WarlockConfig[Key],\n  ): Promise<WarlockConfig[Key]> {\n    await this.load();\n    return this.get(key, defaultValue);\n  }\n\n  /**\n   * Check if config is loaded\n   */\n  public get isLoaded(): boolean {\n    return this.config !== undefined;\n  }\n\n  /**\n   * Get the entire config object\n   *\n   * @throws Error if config is not loaded\n   */\n  public getAll(): WarlockConfig {\n    if (!this.config) {\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\n    }\n\n    return this.config;\n  }\n\n  /**\n   * Reload config (useful for HMR/development)\n   */\n  public async reload(): Promise<void> {\n    this.config = undefined;\n    this.loading = undefined;\n    await this.load();\n  }\n}\n\n/**\n * Exported singleton instance\n *\n * @example\n * import { warlockConfig } from \"@warlock.js/core\";\n *\n * // Lazy load and get value\n * const port = await warlockConfig.lazyGet(\"server.port\");\n *\n * // Or load first, then get\n * await warlockConfig.load();\n * const commands = warlockConfig.get(\"cli.commands\");\n */\nexport const warlockConfigManager = new WarlockConfigManager();\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,0BAA0B,OAAyB;CACjE,OACG,OAA6B,SAAS,gCACvC,kCAAkC,KAAK,OAAQ,OAAiB,OAAO,CAAC;AAE5E;;;;;;;AAQA,IAAa,uBAAb,MAAkC;;;;;;CAgBhC,MAAa,OAA2C;EAEtD,IAAI,KAAK,QACP,OAAO,KAAK;EAId,IAAI,KAAK,SACP,OAAO,KAAK;EAId,KAAK,UAAU,KAAK,OAAO;EAC3B,KAAK,SAAS,MAAM,KAAK;EACzB,KAAK,UAAU;EAGf,KAAK,MAAM,WAAW,4BAA4B,KAAK,MAAM,GAC3D,QAAQ,KAAK,OAAO;EAGtB,OAAO,KAAK;CACd;;;;;;;CAQA,MAAc,SAA6C;EACzD,MAAM,aAAa,SAAS,mBAAmB;EAE/C,IAAI,CAAE,MAAM,gBAAgB,UAAU,GAAI;GAMxC,QAAQ,KACN,yHACF;GACA;EACF;EAEA,IAAI;GAEF,QAAO,MADoB,OAAO,cAAc,UAAU,CAAC,CAAC,MACzC,CAAC;EACtB,SAAS,OAAO;GAOd,IAAI,0BAA0B,KAAK,GACjC,OAAO,MAAM,KAAK,eAAe,UAAU;GAG7C,MAAM,IAAI,MAAM,qCAAqC,OAAO;EAC9D;CACF;;;;;;;;;CAUA,MAAc,eAAe,YAAwD;EACnF,MAAM,EAAE,kBAAkB,MAAM,OAAO;EAGvC,MAAM,EAAE,SAAS,cAAc,MAFV,SAAS,YAAY,MAAM,GAET;GACrC,QAAQ;GACR,QAAQ;GACR,QAAQ,OAAO,QAAQ,SAAS,KAAK,MAAM,GAAG,CAAC,CAAC;GAChD,YAAY;EACd,CAAC;EAGD,MAAM,eAAe,WAAW,QAC9B,wBACA,mBAAmB,QAAQ,IAAI,KACjC;EAEA,MAAM,UAAU,cAAc,MAAM,MAAM;EAE1C,IAAI;GAEF,QAAO,MADoB,OAAO,cAAc,YAAY,CAAC,CAAC,MAC3C,CAAC;EACtB,UAAU;GACR,MAAM,OAAO,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC;EAC3C;CACF;;;;;;;;;;;;CAaA,AAAO,IACL,KACA,cACoB;EACpB,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,MAAM,+DAA+D;EAGjF,OAAO,IAAI,KAAK,QAAQ,KAAe,YAAY;CACrD;;;;;;;;;;;CAYA,MAAM,QACJ,KACA,cAC6B;EAC7B,MAAM,KAAK,KAAK;EAChB,OAAO,KAAK,IAAI,KAAK,YAAY;CACnC;;;;CAKA,IAAW,WAAoB;EAC7B,OAAO,KAAK,WAAW;CACzB;;;;;;CAOA,AAAO,SAAwB;EAC7B,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,MAAM,+DAA+D;EAGjF,OAAO,KAAK;CACd;;;;CAKA,MAAa,SAAwB;EACnC,KAAK,SAAS;EACd,KAAK,UAAU;EACf,MAAM,KAAK,KAAK;CAClB;AACF;;;;;;;;;;;;;;AAeA,MAAa,uBAAuB,IAAI,qBAAqB"}
+{"version":3,"file":"warlock-config.manager.mjs","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/warlock-config.manager.ts"],"sourcesContent":["import { fileExistsAsync } from \"@warlock.js/fs\";\nimport { get } from \"@mongez/reinforcements\";\nimport { getTsconfig } from \"get-tsconfig\";\nimport { unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { pathToFileURL } from \"url\";\nimport { rootPath } from \"../utils\";\nimport { bundleWarlockConfig } from \"./bundle-config\";\nimport { type WarlockConfig } from \"./types\";\nimport { getDeprecatedConfigWarnings } from \"./warn-deprecated-config\";\n\n/**\n * `Error` with the ES2022 `cause` option, typed for packages still compiled\n * against an older lib (see `application.ts`).\n */\nconst ErrorWithCause = Error as new (message: string, options: { cause: unknown }) => Error;\n\n/**\n * True when `error` is Node's \"this runtime can't import a `.ts` file\" error.\n *\n * Node only executes TypeScript natively from v22.18 / v23.6 onward (earlier\n * 22.x needs `--experimental-strip-types`). On older runtimes a bare\n * `import(\"warlock.config.ts\")` throws `ERR_UNKNOWN_FILE_EXTENSION` — which is\n * the signal to fall back to transpiling the config ourselves.\n */\nexport function isUnknownTsExtensionError(error: unknown): boolean {\n  return (\n    (error as { code?: string })?.code === \"ERR_UNKNOWN_FILE_EXTENSION\" ||\n    /Unknown file extension \"\\.tsx?\"/.test(String((error as Error)?.message))\n  );\n}\n\n/**\n * True when `error` is Node failing to RESOLVE an import of the config's OWN\n * graph: an extensionless relative import (`./src/connectors/local`), a\n * directory import, or a tsconfig `paths` alias (`app/connectors`) — all of\n * which only a TypeScript toolchain resolves. Native type stripping\n * (Node ≥ 22.18) loads `warlock.config.ts` itself, then fails here.\n *\n * A package that is genuinely not installed is NOT a fallback case: the error\n * names a bare specifier that matches no `paths` pattern, and it is rethrown\n * as is. Neither is a missing module imported from inside `node_modules`.\n *\n * `pathAliases` are the tsconfig `paths` patterns (`app/*`). When the message\n * cannot be parsed the error is treated as a graph error, as before.\n */\nexport function isUnresolvedConfigImportError(\n  error: unknown,\n  pathAliases: readonly string[] = [],\n): boolean {\n  const code = (error as { code?: string })?.code;\n\n  if (code === \"ERR_UNSUPPORTED_DIR_IMPORT\") return true;\n  if (code !== \"ERR_MODULE_NOT_FOUND\") return false;\n\n  const message = String((error as Error)?.message ?? \"\");\n  const match = /Cannot find (module|package) '([^']+)' imported from (.+)$/m.exec(message);\n\n  if (!match) return true;\n\n  const [, kind, specifier = \"\", importer = \"\"] = match;\n\n  if (/[\\\\/]node_modules[\\\\/]/.test(importer)) return false;\n\n  // An unresolved relative or absolute path: an extensionless TS import.\n  if (kind === \"module\") return true;\n\n  // A bare name: only a tsconfig alias is the config graph's own code.\n  return pathAliases.some((pattern) => aliasCovers(pattern, specifier));\n}\n\n/**\n * True when `error` is native type stripping refusing TypeScript it cannot\n * strip (an `enum`, a `namespace`, a parameter property) or a `.ts` file under\n * `node_modules`. Both are raised while loading, before the graph runs.\n */\nexport function isUnsupportedTypeStrippingError(error: unknown): boolean {\n  const code = (error as { code?: string })?.code;\n\n  return (\n    code === \"ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX\" ||\n    code === \"ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING\"\n  );\n}\n\n/**\n * True when a tsconfig `paths` pattern can produce `packageName` as the first\n * segment(s) of a specifier: `app/*` covers `app`, `@shared/*` covers\n * `@shared`, a catch-all `*` covers anything.\n */\nfunction aliasCovers(pattern: string, packageName: string): boolean {\n  const star = pattern.indexOf(\"*\");\n  const prefix = star === -1 ? pattern : pattern.slice(0, star);\n\n  if (prefix === \"\") return true;\n\n  return (\n    prefix === packageName || prefix.startsWith(`${packageName}/`) || packageName.startsWith(prefix)\n  );\n}\n\n/**\n * Warlock Config Manager\n *\n * Manages lazy loading of the pre-compiled warlock.config.js file\n * from the .warlock/cache directory.\n */\nexport class WarlockConfigManager {\n  /**\n   * Cached config instance\n   */\n  private config?: WarlockConfig;\n\n  /**\n   * Loading promise to prevent duplicate loads\n   */\n  private loading?: Promise<WarlockConfig | undefined>;\n\n  /**\n   * Load warlock.config.js (cached after first load)\n   *\n   * @returns The resolved Warlock configuration\n   */\n  public async load(): Promise<WarlockConfig | undefined> {\n    // Already loaded\n    if (this.config) {\n      return this.config;\n    }\n\n    // Currently loading (prevent duplicate loads)\n    if (this.loading) {\n      return this.loading;\n    }\n\n    // Start loading\n    this.loading = this.doLoad();\n    this.config = await this.loading;\n    this.loading = undefined;\n\n    // Console, not the logger: this runs before any log channel exists.\n    for (const warning of getDeprecatedConfigWarnings(this.config)) {\n      console.warn(warning);\n    }\n\n    return this.config;\n  }\n\n  /**\n   * Internal load implementation\n   *\n   * The ESM loader hook transpiles `warlock.config.ts` on import — no\n   * separate compile-to-disk step is needed.\n   */\n  private async doLoad(): Promise<WarlockConfig | undefined> {\n    const configPath = rootPath(\"warlock.config.ts\");\n\n    if (!(await fileExistsAsync(configPath))) {\n      // Written straight to the console, NOT through `@warlock.js/logger`.\n      // This runs during CLI bootstrap, before `LoggerConnector.start()` has\n      // configured a single channel, so a logger call here reaches nobody in\n      // any application — the warning would be silently dropped exactly when\n      // the user most needs it.\n      console.warn(\n        \"warlock.config.ts is missing — create it at the project root (see https://warlock.js.org/docs for the config reference)\",\n      );\n      return;\n    }\n\n    try {\n      const configModule = await import(pathToFileURL(configPath).href);\n      return configModule.default;\n    } catch (error) {\n      // `dev` registers a TS loader hook, and Node ≥ 22.18 / 23.6 strips types\n      // natively — in both cases the direct import above works for a\n      // self-contained config. But `build` / `start` register no hook, so on an\n      // older Node the import throws ERR_UNKNOWN_FILE_EXTENSION; native\n      // stripping cannot resolve extensionless or tsconfig-aliased local\n      // imports, nor strip an `enum` or a parameter property. Bundle the\n      // config's local graph with esbuild ourselves so config loading is\n      // Node-version-independent.\n      //\n      // These errors are raised while resolving and loading the STATIC graph,\n      // before any of it runs. An unresolved import reached later — a dynamic\n      // `import()` while the config runs — is indistinguishable by code, so the\n      // fallback is limited to the config's own relative and aliased imports.\n      if (\n        isUnknownTsExtensionError(error) ||\n        isUnsupportedTypeStrippingError(error) ||\n        isUnresolvedConfigImportError(error, configPathAliases(configPath))\n      ) {\n        return await this.loadViaEsbuild(configPath);\n      }\n\n      throw new ErrorWithCause(`Failed to load warlock.config.ts: ${error}`, { cause: error });\n    }\n  }\n\n  /**\n   * Fallback config loader for runtimes that cannot import the config as written.\n   *\n   * Bundles `warlock.config.ts` with its LOCAL import graph (relative imports,\n   * extensionless TS imports, tsconfig `paths` aliases) through esbuild, keeping\n   * every package external so `BaseConnector`, the container and other\n   * registries keep the application's identity (see `bundleWarlockConfig`).\n   * The bundle is written as a sibling `.mjs` — so its external imports resolve\n   * from the project exactly as they would from the original config — imported\n   * once, then removed whether it loaded or threw. An error thrown by the\n   * user's config propagates unchanged.\n   */\n  private async loadViaEsbuild(configPath: string): Promise<WarlockConfig | undefined> {\n    const code = await bundleWarlockConfig(configPath);\n\n    // Unique sibling name so concurrent processes never clobber each other.\n    const compiledPath = configPath.replace(\n      /warlock\\.config\\.ts$/,\n      `.warlock.config.${process.pid}.${Date.now()}.mjs`,\n    );\n\n    await writeFile(compiledPath, code, \"utf8\");\n\n    try {\n      const configModule = await import(pathToFileURL(compiledPath).href);\n      return configModule.default;\n    } catch (error) {\n      throw nameOriginalConfig(error, compiledPath, configPath);\n    } finally {\n      await unlink(compiledPath).catch(() => {});\n    }\n  }\n\n  /**\n   * Get config value by key (dot notation supported)\n   *\n   * @example\n   * config.get(\"server.port\") // Returns 3000\n   * config.get(\"cli.commands\") // Returns array of commands\n   *\n   * @param key - Config key (supports dot notation), autocompletes for first level only\n   * @returns The config value\n   * @throws Error if config is not loaded\n   */\n  public get<Key extends keyof WarlockConfig>(\n    key: Key,\n    defaultValue?: WarlockConfig[Key],\n  ): WarlockConfig[Key] {\n    if (!this.config) {\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\n    }\n\n    return get(this.config, key as string, defaultValue);\n  }\n\n  /**\n   * Lazy get - loads config if not already loaded\n   *\n   * @example\n   * const port = await config.lazyGet(\"server\");\n   *\n   * @param key - Config key (supports dot notation), autocompletes for first level only\n   * @param defaultValue - Default value if config key is undefined\n   * @returns The config value\n   */\n  async lazyGet<Key extends keyof WarlockConfig>(\n    key: Key,\n    defaultValue?: WarlockConfig[Key],\n  ): Promise<WarlockConfig[Key]> {\n    await this.load();\n    return this.get(key, defaultValue);\n  }\n\n  /**\n   * Check if config is loaded\n   */\n  public get isLoaded(): boolean {\n    return this.config !== undefined;\n  }\n\n  /**\n   * Get the entire config object\n   *\n   * @throws Error if config is not loaded\n   */\n  public getAll(): WarlockConfig {\n    if (!this.config) {\n      throw new Error(\"WarlockConfig not loaded. Call load() first or use lazyGet().\");\n    }\n\n    return this.config;\n  }\n\n  /**\n   * Reload config (useful for HMR/development)\n   */\n  public async reload(): Promise<void> {\n    this.config = undefined;\n    this.loading = undefined;\n    await this.load();\n  }\n}\n\n/**\n * The tsconfig `paths` patterns of the project holding `configPath`.\n */\nfunction configPathAliases(configPath: string): string[] {\n  try {\n    return Object.keys(getTsconfig(path.dirname(configPath))?.config.compilerOptions?.paths ?? {});\n  } catch {\n    return [];\n  }\n}\n\n/**\n * A loader error raised by the bundled config names the temporary `.mjs`\n * module. Rewrite it to name `warlock.config.ts`, keeping the original as the\n * cause. An error thrown by the user's own config is returned unchanged.\n */\nfunction nameOriginalConfig(error: unknown, compiledPath: string, configPath: string): unknown {\n  const code = (error as { code?: string })?.code;\n\n  if (typeof code !== \"string\" || !code.startsWith(\"ERR_\")) return error;\n\n  const message = String((error as Error).message ?? error)\n    .split(pathToFileURL(compiledPath).href)\n    .join(pathToFileURL(configPath).href)\n    .split(compiledPath)\n    .join(configPath);\n\n  const wrapped = new ErrorWithCause(`Failed to load warlock.config.ts: ${message}`, {\n    cause: error,\n  });\n\n  (wrapped as Error & { code?: string }).code = code;\n\n  return wrapped;\n}\n\n/**\n * Exported singleton instance\n *\n * @example\n * import { warlockConfig } from \"@warlock.js/core\";\n *\n * // Lazy load and get value\n * const port = await warlockConfig.lazyGet(\"server.port\");\n *\n * // Or load first, then get\n * await warlockConfig.load();\n * const commands = warlockConfig.get(\"cli.commands\");\n */\nexport const warlockConfigManager = new WarlockConfigManager();\n"],"mappings":"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"}

package/esm/warlock-config/warn-deprecated-config.mjs

@@ -1,6 +1,6 @@
 import { get } from "@mongez/reinforcements";
 
-//#region ../core/src/warlock-config/warn-deprecated-config.ts
+//#region ../../packages/core/src/warlock-config/warn-deprecated-config.ts
 /**
 * Keys of `warlock.config.ts` that are declared but never read, and where the
 * setting lives instead.

package/esm/warlock-config/warn-deprecated-config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"warn-deprecated-config.mjs","names":[],"sources":["../../../../../../../core/src/warlock-config/warn-deprecated-config.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\nimport type { WarlockConfig } from \"./types\";\n\n/**\n * Keys of `warlock.config.ts` that are declared but never read, and where the\n * setting lives instead.\n */\nexport const deprecatedConfigKeys: Record<string, string> = {\n  \"server.port\": \"set the HTTP port in `config/http.ts` (`port`)\",\n  \"server.host\": \"set the HTTP host in `config/http.ts` (`host`)\",\n  \"server.retryOtherPort\": \"port fallback is not implemented, remove it\",\n  \"tests.include\": \"configure test discovery in `config/tests.ts`\",\n  \"tests.exclude\": \"configure test discovery in `config/tests.ts`\",\n};\n\n/**\n * Build one warning per deprecated key the app actually sets.\n */\nexport function getDeprecatedConfigWarnings(config: WarlockConfig | undefined): string[] {\n  if (!config) return [];\n\n  return Object.entries(deprecatedConfigKeys)\n    .filter(([key]) => get(config, key) !== undefined)\n    .map(\n      ([key, instead]) =>\n        `warlock.config.ts: \\`${key}\\` is deprecated and ignored by the framework; ${instead}.`,\n    );\n}\n"],"mappings":";;;;;;;AAOA,MAAa,uBAA+C;CAC1D,eAAe;CACf,eAAe;CACf,yBAAyB;CACzB,iBAAiB;CACjB,iBAAiB;AACnB;;;;AAKA,SAAgB,4BAA4B,QAA6C;CACvF,IAAI,CAAC,QAAQ,OAAO,CAAC;CAErB,OAAO,OAAO,QAAQ,oBAAoB,CAAC,CACxC,QAAQ,CAAC,SAAS,IAAI,QAAQ,GAAG,MAAM,MAAS,CAAC,CACjD,KACE,CAAC,KAAK,aACL,wBAAwB,IAAI,iDAAiD,QAAQ,EACzF;AACJ"}
+{"version":3,"file":"warn-deprecated-config.mjs","names":[],"sources":["../../../../../../../../packages/core/src/warlock-config/warn-deprecated-config.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\nimport type { WarlockConfig } from \"./types\";\n\n/**\n * Keys of `warlock.config.ts` that are declared but never read, and where the\n * setting lives instead.\n */\nexport const deprecatedConfigKeys: Record<string, string> = {\n  \"server.port\": \"set the HTTP port in `config/http.ts` (`port`)\",\n  \"server.host\": \"set the HTTP host in `config/http.ts` (`host`)\",\n  \"server.retryOtherPort\": \"port fallback is not implemented, remove it\",\n  \"tests.include\": \"configure test discovery in `config/tests.ts`\",\n  \"tests.exclude\": \"configure test discovery in `config/tests.ts`\",\n};\n\n/**\n * Build one warning per deprecated key the app actually sets.\n */\nexport function getDeprecatedConfigWarnings(config: WarlockConfig | undefined): string[] {\n  if (!config) return [];\n\n  return Object.entries(deprecatedConfigKeys)\n    .filter(([key]) => get(config, key) !== undefined)\n    .map(\n      ([key, instead]) =>\n        `warlock.config.ts: \\`${key}\\` is deprecated and ignored by the framework; ${instead}.`,\n    );\n}\n"],"mappings":";;;;;;;AAOA,MAAa,uBAA+C;CAC1D,eAAe;CACf,eAAe;CACf,yBAAyB;CACzB,iBAAiB;CACjB,iBAAiB;AACnB;;;;AAKA,SAAgB,4BAA4B,QAA6C;CACvF,IAAI,CAAC,QAAQ,OAAO,CAAC;CAErB,OAAO,OAAO,QAAQ,oBAAoB,CAAC,CACxC,QAAQ,CAAC,SAAS,IAAI,QAAQ,GAAG,MAAM,MAAS,CAAC,CACjD,KACE,CAAC,KAAK,aACL,wBAAwB,IAAI,iDAAiD,QAAQ,EACzF;AACJ"}