@warlock.js/core 5.29.0 → 5.31.0

package/esm/config/config-loader.mjs

@@ -1,19 +1,28 @@
 import { configSpecialHandlers } from "./config-special-handlers.mjs";
+import { InvalidConfigError, validateConfigValue } from "./config-schema.mjs";
 import { importAppModule } from "../loader/app-module-importer.mjs";
 import { configKeyFromPath } from "./config-key-from-path.mjs";
 import config from "@mongez/config";
-import { colors } from "@mongez/copper";
 import { pathToFileURL } from "node:url";
+import { colors } from "@mongez/copper";
 
-//#region ../core/src/config/config-loader.ts
+//#region ../../packages/core/src/config/config-loader.ts
 /**
 * Config Loader
 * Dynamically loads all configuration files and registers them with @mongez/config
 * Supports special handlers for configs that require additional processing
 */
 var ConfigLoader = class {
+	/**
+	* Load every config file, then throw one {@link InvalidConfigError} listing
+	* every value that fails its file's `configSchema`. An invalid config is
+	* still registered (later files may read it while loading) but its special
+	* handler does not run, so nothing connects with a broken configuration.
+	*/
 	async loadAll(configFiles) {
-		for (const file of configFiles) await this.loadConfig(file);
+		const issues = [];
+		for (const file of configFiles) issues.push(...await this.loadConfigFile(file, "register-invalid"));
+		if (issues.length > 0) throw new InvalidConfigError(issues);
 	}
 	/**
 	* Load a single configuration file.
@@ -22,19 +31,31 @@ var ConfigLoader = class {
 	* cycle gets a fresh module — no manual cache-busting needed here.
 	*/
 	async loadConfig(file) {
+		const issues = await this.loadConfigFile(file, "keep-previous");
+		if (issues.length > 0) throw new InvalidConfigError(issues);
+	}
+	/**
+	* Import, validate and register one config file. Returns the schema issues.
+	* On a hot reload (`keep-previous`) an invalid value is not registered, so
+	* the running app keeps its last valid configuration.
+	*/
+	async loadConfigFile(file, whenInvalid) {
 		const configName = this.getConfigName(file.relativePath);
-		try {
-			const fileUrl = pathToFileURL(file.absolutePath).href;
-			const configValue = (await importAppModule(fileUrl)).default;
-			if (configValue === void 0) {
-				console.log(colors.red(`config error: `), `Config file ${colors.yellow(file.relativePath)} does not have a default export`);
-				return;
-			}
-			config.set(configName, configValue);
-			await configSpecialHandlers.execute(configName, configValue);
-		} catch (error) {
-			throw error;
+		const fileUrl = pathToFileURL(file.absolutePath).href;
+		const configModule = await importAppModule(fileUrl);
+		const configValue = configModule.default;
+		if (configValue === void 0) {
+			console.log(colors.red(`config error: `), `Config file ${colors.yellow(file.relativePath)} does not have a default export`);
+			return [];
+		}
+		const issues = await validateConfigValue(configName, configValue, configModule.configSchema);
+		if (issues.length > 0) {
+			if (whenInvalid === "register-invalid") config.set(configName, configValue);
+			return issues;
 		}
+		config.set(configName, configValue);
+		await configSpecialHandlers.execute(configName, configValue);
+		return [];
 	}
 	async reloadConfig(file) {
 		await this.loadConfig(file);

package/esm/config/config-loader.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"config-loader.mjs","names":[],"sources":["../../../../../../../core/src/config/config-loader.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { colors } from \"@mongez/copper\";\nimport { pathToFileURL } from \"node:url\";\nimport type { FileManager } from \"../dev-server/file-manager\";\nimport { importAppModule } from \"../loader/app-module-importer\";\nimport { configKeyFromPath } from \"./config-key-from-path\";\nimport { configSpecialHandlers } from \"./config-special-handlers\";\n\n/**\n * Special Config Handler\n * A function that handles special configuration loading\n */\n// Returns unknown, not void: ConfigSpecialHandlers.execute() RETURNS handler(config)\n// rather than discarding it, and a test pins that (\"returns the handler's resolved\n// value\"). The implementation and the test agreed; only this type said handlers\n// produce nothing, which made any value-returning handler fail to typecheck.\nexport type SpecialConfigHandler = (configValue: any) => unknown | Promise<unknown>;\n\n/**\n * Config Loader\n * Dynamically loads all configuration files and registers them with @mongez/config\n * Supports special handlers for configs that require additional processing\n */\nexport class ConfigLoader {\n  public async loadAll(configFiles: FileManager[]): Promise<void> {\n    for (const file of configFiles) {\n      await this.loadConfig(file);\n    }\n  }\n\n  /**\n   * Load a single configuration file.\n   *\n   * The ESM loader hook stamps a version token onto the URL so that each HMR\n   * cycle gets a fresh module — no manual cache-busting needed here.\n   */\n  public async loadConfig(file: FileManager): Promise<void> {\n    const configName = this.getConfigName(file.relativePath);\n\n    try {\n      const fileUrl = pathToFileURL(file.absolutePath).href;\n      const configModule = await importAppModule(fileUrl);\n      const configValue = configModule.default;\n\n      if (configValue === undefined) {\n        console.log(\n          colors.red(`config error: `),\n          `Config file ${colors.yellow(file.relativePath)} does not have a default export`,\n        );\n        return;\n      }\n\n      config.set(configName, configValue);\n      await configSpecialHandlers.execute(configName, configValue);\n    } catch (error) {\n      throw error;\n    }\n  }\n\n  public async reloadConfig(file: FileManager): Promise<void> {\n    await this.loadConfig(file);\n  }\n\n  private getConfigName(relativePath: string): string {\n    const configName = configKeyFromPath(relativePath);\n\n    if (!configName) {\n      throw new Error(`Invalid config file path: ${relativePath}`);\n    }\n\n    return configName;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAuBA,IAAa,eAAb,MAA0B;CACxB,MAAa,QAAQ,aAA2C;EAC9D,KAAK,MAAM,QAAQ,aACjB,MAAM,KAAK,WAAW,IAAI;CAE9B;;;;;;;CAQA,MAAa,WAAW,MAAkC;EACxD,MAAM,aAAa,KAAK,cAAc,KAAK,YAAY;EAEvD,IAAI;GACF,MAAM,UAAU,cAAc,KAAK,YAAY,CAAC,CAAC;GAEjD,MAAM,eAAc,MADO,gBAAgB,OAAO,EAClB,CAAC;GAEjC,IAAI,gBAAgB,QAAW;IAC7B,QAAQ,IACN,OAAO,IAAI,gBAAgB,GAC3B,eAAe,OAAO,OAAO,KAAK,YAAY,EAAE,gCAClD;IACA;GACF;GAEA,OAAO,IAAI,YAAY,WAAW;GAClC,MAAM,sBAAsB,QAAQ,YAAY,WAAW;EAC7D,SAAS,OAAO;GACd,MAAM;EACR;CACF;CAEA,MAAa,aAAa,MAAkC;EAC1D,MAAM,KAAK,WAAW,IAAI;CAC5B;CAEA,AAAQ,cAAc,cAA8B;EAClD,MAAM,aAAa,kBAAkB,YAAY;EAEjD,IAAI,CAAC,YACH,MAAM,IAAI,MAAM,6BAA6B,cAAc;EAG7D,OAAO;CACT;AACF"}
+{"version":3,"file":"config-loader.mjs","names":[],"sources":["../../../../../../../../packages/core/src/config/config-loader.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { colors } from \"@mongez/copper\";\nimport { pathToFileURL } from \"node:url\";\nimport type { FileManager } from \"../dev-server/file-manager\";\nimport { importAppModule } from \"../loader/app-module-importer\";\nimport { configKeyFromPath } from \"./config-key-from-path\";\nimport { type ConfigIssue, InvalidConfigError, validateConfigValue } from \"./config-schema\";\nimport { configSpecialHandlers } from \"./config-special-handlers\";\n\n/**\n * Special Config Handler\n * A function that handles special configuration loading\n */\n// Returns unknown, not void: ConfigSpecialHandlers.execute() RETURNS handler(config)\n// rather than discarding it, and a test pins that (\"returns the handler's resolved\n// value\"). The implementation and the test agreed; only this type said handlers\n// produce nothing, which made any value-returning handler fail to typecheck.\nexport type SpecialConfigHandler = (configValue: any) => unknown | Promise<unknown>;\n\n/**\n * Config Loader\n * Dynamically loads all configuration files and registers them with @mongez/config\n * Supports special handlers for configs that require additional processing\n */\nexport class ConfigLoader {\n  /**\n   * Load every config file, then throw one {@link InvalidConfigError} listing\n   * every value that fails its file's `configSchema`. An invalid config is\n   * still registered (later files may read it while loading) but its special\n   * handler does not run, so nothing connects with a broken configuration.\n   */\n  public async loadAll(configFiles: FileManager[]): Promise<void> {\n    const issues: ConfigIssue[] = [];\n\n    for (const file of configFiles) {\n      issues.push(...(await this.loadConfigFile(file, \"register-invalid\")));\n    }\n\n    if (issues.length > 0) throw new InvalidConfigError(issues);\n  }\n\n  /**\n   * Load a single configuration file.\n   *\n   * The ESM loader hook stamps a version token onto the URL so that each HMR\n   * cycle gets a fresh module — no manual cache-busting needed here.\n   */\n  public async loadConfig(file: FileManager): Promise<void> {\n    const issues = await this.loadConfigFile(file, \"keep-previous\");\n\n    if (issues.length > 0) throw new InvalidConfigError(issues);\n  }\n\n  /**\n   * Import, validate and register one config file. Returns the schema issues.\n   * On a hot reload (`keep-previous`) an invalid value is not registered, so\n   * the running app keeps its last valid configuration.\n   */\n  private async loadConfigFile(\n    file: FileManager,\n    whenInvalid: \"register-invalid\" | \"keep-previous\",\n  ): Promise<ConfigIssue[]> {\n    const configName = this.getConfigName(file.relativePath);\n\n    const fileUrl = pathToFileURL(file.absolutePath).href;\n    const configModule = await importAppModule(fileUrl);\n    const configValue = configModule.default;\n\n    if (configValue === undefined) {\n      console.log(\n        colors.red(`config error: `),\n        `Config file ${colors.yellow(file.relativePath)} does not have a default export`,\n      );\n      return [];\n    }\n\n    const issues = await validateConfigValue(configName, configValue, configModule.configSchema);\n\n    if (issues.length > 0) {\n      if (whenInvalid === \"register-invalid\") config.set(configName, configValue);\n      return issues;\n    }\n\n    config.set(configName, configValue);\n    await configSpecialHandlers.execute(configName, configValue);\n\n    return [];\n  }\n\n  public async reloadConfig(file: FileManager): Promise<void> {\n    await this.loadConfig(file);\n  }\n\n  private getConfigName(relativePath: string): string {\n    const configName = configKeyFromPath(relativePath);\n\n    if (!configName) {\n      throw new Error(`Invalid config file path: ${relativePath}`);\n    }\n\n    return configName;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAwBA,IAAa,eAAb,MAA0B;;;;;;;CAOxB,MAAa,QAAQ,aAA2C;EAC9D,MAAM,SAAwB,CAAC;EAE/B,KAAK,MAAM,QAAQ,aACjB,OAAO,KAAK,GAAI,MAAM,KAAK,eAAe,MAAM,kBAAkB,CAAE;EAGtE,IAAI,OAAO,SAAS,GAAG,MAAM,IAAI,mBAAmB,MAAM;CAC5D;;;;;;;CAQA,MAAa,WAAW,MAAkC;EACxD,MAAM,SAAS,MAAM,KAAK,eAAe,MAAM,eAAe;EAE9D,IAAI,OAAO,SAAS,GAAG,MAAM,IAAI,mBAAmB,MAAM;CAC5D;;;;;;CAOA,MAAc,eACZ,MACA,aACwB;EACxB,MAAM,aAAa,KAAK,cAAc,KAAK,YAAY;EAEvD,MAAM,UAAU,cAAc,KAAK,YAAY,CAAC,CAAC;EACjD,MAAM,eAAe,MAAM,gBAAgB,OAAO;EAClD,MAAM,cAAc,aAAa;EAEjC,IAAI,gBAAgB,QAAW;GAC7B,QAAQ,IACN,OAAO,IAAI,gBAAgB,GAC3B,eAAe,OAAO,OAAO,KAAK,YAAY,EAAE,gCAClD;GACA,OAAO,CAAC;EACV;EAEA,MAAM,SAAS,MAAM,oBAAoB,YAAY,aAAa,aAAa,YAAY;EAE3F,IAAI,OAAO,SAAS,GAAG;GACrB,IAAI,gBAAgB,oBAAoB,OAAO,IAAI,YAAY,WAAW;GAC1E,OAAO;EACT;EAEA,OAAO,IAAI,YAAY,WAAW;EAClC,MAAM,sBAAsB,QAAQ,YAAY,WAAW;EAE3D,OAAO,CAAC;CACV;CAEA,MAAa,aAAa,MAAkC;EAC1D,MAAM,KAAK,WAAW,IAAI;CAC5B;CAEA,AAAQ,cAAc,cAA8B;EAClD,MAAM,aAAa,kBAAkB,YAAY;EAEjD,IAAI,CAAC,YACH,MAAM,IAAI,MAAM,6BAA6B,cAAc;EAG7D,OAAO;CACT;AACF"}

package/esm/config/config-manager.mjs

@@ -1,6 +1,6 @@
 import { ConfigLoader } from "./config-loader.mjs";
 
-//#region ../core/src/config/config-manager.ts
+//#region ../../packages/core/src/config/config-manager.ts
 var ConfigManager = class {
 	/**
 	* Constructor

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

@@ -1 +1 @@
-{"version":3,"file":"config-manager.mjs","names":[],"sources":["../../../../../../../core/src/config/config-manager.ts"],"sourcesContent":["import { FileManager } from \"../dev-server/file-manager\";\nimport { ConfigLoader } from \"./config-loader\";\n\nexport class ConfigManager {\n  /**\n   * Config loader instance\n   */\n  public loader = new ConfigLoader();\n\n  /**\n   * Constructor\n   */\n  public constructor() {\n    //\n  }\n\n  /**\n   * Load all config files\n   */\n  public async loadAll(files: FileManager[]) {\n    return this.loader.loadAll(files);\n  }\n\n  /**\n   * Reload a config file\n   */\n  public async reload(file: FileManager) {\n    return this.loader.reloadConfig(file);\n  }\n}\n\nexport const configManager = new ConfigManager();\n"],"mappings":";;;AAGA,IAAa,gBAAb,MAA2B;;;;CASzB,AAAO,cAAc;gBALL,IAAI,aAAa;CAOjC;;;;CAKA,MAAa,QAAQ,OAAsB;EACzC,OAAO,KAAK,OAAO,QAAQ,KAAK;CAClC;;;;CAKA,MAAa,OAAO,MAAmB;EACrC,OAAO,KAAK,OAAO,aAAa,IAAI;CACtC;AACF;AAEA,MAAa,gBAAgB,IAAI,cAAc"}
+{"version":3,"file":"config-manager.mjs","names":[],"sources":["../../../../../../../../packages/core/src/config/config-manager.ts"],"sourcesContent":["import { FileManager } from \"../dev-server/file-manager\";\nimport { ConfigLoader } from \"./config-loader\";\n\nexport class ConfigManager {\n  /**\n   * Config loader instance\n   */\n  public loader = new ConfigLoader();\n\n  /**\n   * Constructor\n   */\n  public constructor() {\n    //\n  }\n\n  /**\n   * Load all config files\n   */\n  public async loadAll(files: FileManager[]) {\n    return this.loader.loadAll(files);\n  }\n\n  /**\n   * Reload a config file\n   */\n  public async reload(file: FileManager) {\n    return this.loader.reloadConfig(file);\n  }\n}\n\nexport const configManager = new ConfigManager();\n"],"mappings":";;;AAGA,IAAa,gBAAb,MAA2B;;;;CASzB,AAAO,cAAc;gBALL,IAAI,aAAa;CAOjC;;;;CAKA,MAAa,QAAQ,OAAsB;EACzC,OAAO,KAAK,OAAO,QAAQ,KAAK;CAClC;;;;CAKA,MAAa,OAAO,MAAmB;EACrC,OAAO,KAAK,OAAO,aAAa,IAAI;CACtC;AACF;AAEA,MAAa,gBAAgB,IAAI,cAAc"}

package/esm/config/config-schema.d.mts

@@ -0,0 +1,67 @@
+import { BaseValidator, Infer } from "@warlock.js/seal";
+
+//#region ../../packages/core/src/config/config-schema.d.ts
+declare const CONFIG_SCHEMA_MARKER: unique symbol;
+type ConfigSchemaOptions = {
+  /**
+   * The environment variable each key is read from, by key path
+   * (`{ host: "MAIL_HOST", "smtp.password": "SMTP_PASSWORD" }`). Named in the
+   * boot error so the fix is obvious.
+   */
+  env?: Readonly<Record<string, string>>;
+};
+/** A config file's schema, as returned by {@link defineConfigSchema}. */
+type ConfigSchema<TValidator extends BaseValidator = BaseValidator> = {
+  readonly [CONFIG_SCHEMA_MARKER]: true;
+  readonly validator: TValidator;
+  readonly env: Readonly<Record<string, string>>;
+};
+/** The config value a schema describes, for typing the default export. */
+type ConfigOf<TSchema extends ConfigSchema> = TSchema extends ConfigSchema<infer TValidator> ? Infer.Input<TValidator> : never;
+/** One problem found while validating configuration. */
+type ConfigIssue = {
+  /** Config name (the file's key, e.g. `mail`). */config: string; /** Key path inside it (`smtp.host`); empty for the config value as a whole. */
+  key: string; /** What is wrong, from the schema's rule. */
+  message: string; /** The environment variable that feeds this key, when the schema names it. */
+  env?: string;
+};
+/**
+ * Declare the schema a config file's default export must satisfy. Export the
+ * result as `configSchema` from the same file.
+ */
+declare function defineConfigSchema<TValidator extends BaseValidator>(validator: TValidator, options?: ConfigSchemaOptions): ConfigSchema<TValidator>;
+/** Whether a value is a {@link ConfigSchema}. */
+declare function isConfigSchema(value: unknown): value is ConfigSchema;
+/**
+ * Thrown at boot when one or more config files do not satisfy their
+ * `configSchema`. `issues` lists every problem; the message is ready to print.
+ */
+declare class InvalidConfigError extends Error {
+  readonly issues: readonly ConfigIssue[];
+  readonly name = "InvalidConfigError";
+  constructor(issues: readonly ConfigIssue[]);
+}
+/** Render issues as the boot error message. */
+declare function formatConfigIssues(issues: readonly ConfigIssue[]): string;
+/**
+ * Validate one config value against its schema. Returns the issues found (an
+ * empty list when it is valid, or when `schema` is not a config schema).
+ */
+declare function validateConfigValue(configName: string, value: unknown, schema: unknown): Promise<ConfigIssue[]>;
+/** A loaded config module: its default export and, optionally, its `configSchema`. */
+type ConfigModuleEntry = {
+  name: string;
+  module: {
+    default?: unknown;
+    configSchema?: unknown;
+  };
+};
+/**
+ * Validate every config module that exports a `configSchema` and throw one
+ * {@link InvalidConfigError} listing all problems. Used by the production
+ * config loader `warlock build` generates.
+ */
+declare function assertValidConfigModules(entries: readonly ConfigModuleEntry[]): Promise<void>;
+//#endregion
+export { ConfigIssue, ConfigModuleEntry, ConfigOf, ConfigSchema, ConfigSchemaOptions, InvalidConfigError, assertValidConfigModules, defineConfigSchema, formatConfigIssues, isConfigSchema, validateConfigValue };
+//# sourceMappingURL=config-schema.d.mts.map

package/esm/config/config-schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/config/config-schema.ts"],"mappings":";;;cAmCM,oBAAA;AAAA,KAEM,mBAAA;EAaD;;;;AAAoB;EAP7B,GAAA,GAAM,QAAQ,CAAC,MAAA;AAAA;;KAIL,YAAA,oBAAgC,aAAA,GAAgB,aAAA;EAAA,UAChD,oBAAA;EAAA,SACD,SAAA,EAAW,UAAA;EAAA,SACX,GAAA,EAAK,QAAA,CAAS,MAAA;AAAA;;KAIb,QAAA,iBAAyB,YAAA,IACnC,OAAA,SAAgB,YAAA,qBAAiC,KAAA,CAAM,KAAA,CAAM,UAAA;;KAGnD,WAAA;EAHV,iDAKA,MAAA,UALmC;EAOnC,GAAA,UAPuD;EASvD,OAAA,UATuE;EAWvE,GAAA;AAAA;;;;;iBAOc,kBAAA,oBAAsC,aAAA,EACpD,SAAA,EAAW,UAAA,EACX,OAAA,GAAS,mBAAA,GACR,YAAA,CAAa,UAAA;;iBAKA,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,YAAY;;AAfhE;AAOL;;cAoBa,kBAAA,SAA2B,KAAA;EAAA,SAGH,MAAA,WAAiB,WAAA;EAAA,SAF3B,IAAA;cAEU,MAAA,WAAiB,WAAA;AAAA;;iBAMtC,kBAAA,CAAmB,MAA8B,WAAb,WAAW;;;;;iBAgBzC,mBAAA,CACpB,UAAA,UACA,KAAA,WACA,MAAA,YACC,OAAO,CAAC,WAAA;;KAuBC,iBAAA;EACV,IAAA;EACA,MAAA;IAAU,OAAA;IAAmB,YAAA;EAAA;AAAA;;;;;;iBAQT,wBAAA,CACpB,OAAA,WAAkB,iBAAA,KACjB,OAAO"}

package/esm/config/config-schema.mjs

@@ -0,0 +1,77 @@
+import { validate } from "@warlock.js/seal";
+
+//#region ../../packages/core/src/config/config-schema.ts
+const CONFIG_SCHEMA_MARKER = Symbol.for("warlock.js.configSchema");
+/**
+* Declare the schema a config file's default export must satisfy. Export the
+* result as `configSchema` from the same file.
+*/
+function defineConfigSchema(validator, options = {}) {
+	return {
+		[CONFIG_SCHEMA_MARKER]: true,
+		validator,
+		env: { ...options.env }
+	};
+}
+/** Whether a value is a {@link ConfigSchema}. */
+function isConfigSchema(value) {
+	return typeof value === "object" && value !== null && value[CONFIG_SCHEMA_MARKER] === true;
+}
+/**
+* Thrown at boot when one or more config files do not satisfy their
+* `configSchema`. `issues` lists every problem; the message is ready to print.
+*/
+var InvalidConfigError = class extends Error {
+	constructor(issues) {
+		super(formatConfigIssues(issues));
+		this.issues = issues;
+		this.name = "InvalidConfigError";
+	}
+};
+/** Render issues as the boot error message. */
+function formatConfigIssues(issues) {
+	const lines = issues.map((issue) => {
+		const path = issue.key ? `${issue.config}.${issue.key}` : issue.config;
+		const hint = issue.env ? ` (set ${issue.env} in your environment or .env)` : "";
+		return `  - ${path}: ${issue.message}${hint}`;
+	});
+	return `Invalid configuration (${issues.length === 1 ? "1 problem" : `${issues.length} problems`}); the app cannot start until it is fixed:\n${lines.join("\n")}`;
+}
+/**
+* Validate one config value against its schema. Returns the issues found (an
+* empty list when it is valid, or when `schema` is not a config schema).
+*/
+async function validateConfigValue(configName, value, schema) {
+	if (!isConfigSchema(schema)) return [];
+	const result = await validate(schema.validator, value);
+	if (result.isValid) return [];
+	if (result.errors.length === 0) return [{
+		config: configName,
+		key: "",
+		message: "does not match its config schema"
+	}];
+	return result.errors.map((error) => {
+		const key = error.input ?? "";
+		const env = schema.env[key];
+		return {
+			config: configName,
+			key,
+			message: error.error,
+			...env !== void 0 && { env }
+		};
+	});
+}
+/**
+* Validate every config module that exports a `configSchema` and throw one
+* {@link InvalidConfigError} listing all problems. Used by the production
+* config loader `warlock build` generates.
+*/
+async function assertValidConfigModules(entries) {
+	const issues = [];
+	for (const entry of entries) issues.push(...await validateConfigValue(entry.name, entry.module.default, entry.module.configSchema));
+	if (issues.length > 0) throw new InvalidConfigError(issues);
+}
+
+//#endregion
+export { InvalidConfigError, assertValidConfigModules, defineConfigSchema, formatConfigIssues, isConfigSchema, validateConfigValue };
+//# sourceMappingURL=config-schema.mjs.map

package/esm/config/config-schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.mjs","names":[],"sources":["../../../../../../../../packages/core/src/config/config-schema.ts"],"sourcesContent":["/**\n * Typed, validated configuration.\n *\n * A config file (`src/config/<name>.ts`) may export a `configSchema` next to\n * its default export. Before the config is registered, at `warlock dev` boot,\n * on every config hot reload, and at production start, its value is validated\n * against that schema. Every problem across every config file is collected and\n * the app refuses to start with ONE error that lists them all — key path, what\n * is wrong, and the environment variable to set when the schema names one.\n * Values are never printed, so a secret cannot end up in the boot log.\n *\n * Config files without a `configSchema` load exactly as before.\n *\n * @example\n * // src/config/mail.ts\n * import { defineConfigSchema, env, type ConfigOf } from \"@warlock.js/core\";\n * import { v } from \"@warlock.js/seal\";\n *\n * export const configSchema = defineConfigSchema(\n *   v.object({ host: v.string(), port: v.int(), from: v.email() }),\n *   { env: { host: \"MAIL_HOST\", port: \"MAIL_PORT\", from: \"MAIL_FROM\" } },\n * );\n *\n * const mailConfig: ConfigOf<typeof configSchema> = {\n *   host: env(\"MAIL_HOST\"),\n *   port: Number(env(\"MAIL_PORT\", 587)),\n *   from: env(\"MAIL_FROM\"),\n * };\n *\n * export default mailConfig;\n */\n\nimport type { BaseValidator, Infer } from \"@warlock.js/seal\";\nimport { validate } from \"@warlock.js/seal\";\n\nconst CONFIG_SCHEMA_MARKER: unique symbol = Symbol.for(\"warlock.js.configSchema\");\n\nexport type ConfigSchemaOptions = {\n  /**\n   * The environment variable each key is read from, by key path\n   * (`{ host: \"MAIL_HOST\", \"smtp.password\": \"SMTP_PASSWORD\" }`). Named in the\n   * boot error so the fix is obvious.\n   */\n  env?: Readonly<Record<string, string>>;\n};\n\n/** A config file's schema, as returned by {@link defineConfigSchema}. */\nexport type ConfigSchema<TValidator extends BaseValidator = BaseValidator> = {\n  readonly [CONFIG_SCHEMA_MARKER]: true;\n  readonly validator: TValidator;\n  readonly env: Readonly<Record<string, string>>;\n};\n\n/** The config value a schema describes, for typing the default export. */\nexport type ConfigOf<TSchema extends ConfigSchema> =\n  TSchema extends ConfigSchema<infer TValidator> ? Infer.Input<TValidator> : never;\n\n/** One problem found while validating configuration. */\nexport type ConfigIssue = {\n  /** Config name (the file's key, e.g. `mail`). */\n  config: string;\n  /** Key path inside it (`smtp.host`); empty for the config value as a whole. */\n  key: string;\n  /** What is wrong, from the schema's rule. */\n  message: string;\n  /** The environment variable that feeds this key, when the schema names it. */\n  env?: string;\n};\n\n/**\n * Declare the schema a config file's default export must satisfy. Export the\n * result as `configSchema` from the same file.\n */\nexport function defineConfigSchema<TValidator extends BaseValidator>(\n  validator: TValidator,\n  options: ConfigSchemaOptions = {},\n): ConfigSchema<TValidator> {\n  return { [CONFIG_SCHEMA_MARKER]: true, validator, env: { ...options.env } };\n}\n\n/** Whether a value is a {@link ConfigSchema}. */\nexport function isConfigSchema(value: unknown): value is ConfigSchema {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    (value as Record<PropertyKey, unknown>)[CONFIG_SCHEMA_MARKER] === true\n  );\n}\n\n/**\n * Thrown at boot when one or more config files do not satisfy their\n * `configSchema`. `issues` lists every problem; the message is ready to print.\n */\nexport class InvalidConfigError extends Error {\n  public override readonly name = \"InvalidConfigError\";\n\n  public constructor(public readonly issues: readonly ConfigIssue[]) {\n    super(formatConfigIssues(issues));\n  }\n}\n\n/** Render issues as the boot error message. */\nexport function formatConfigIssues(issues: readonly ConfigIssue[]): string {\n  const lines = issues.map((issue) => {\n    const path = issue.key ? `${issue.config}.${issue.key}` : issue.config;\n    const hint = issue.env ? ` (set ${issue.env} in your environment or .env)` : \"\";\n    return `  - ${path}: ${issue.message}${hint}`;\n  });\n\n  const count = issues.length === 1 ? \"1 problem\" : `${issues.length} problems`;\n\n  return `Invalid configuration (${count}); the app cannot start until it is fixed:\\n${lines.join(\"\\n\")}`;\n}\n\n/**\n * Validate one config value against its schema. Returns the issues found (an\n * empty list when it is valid, or when `schema` is not a config schema).\n */\nexport async function validateConfigValue(\n  configName: string,\n  value: unknown,\n  schema: unknown,\n): Promise<ConfigIssue[]> {\n  if (!isConfigSchema(schema)) return [];\n\n  const result = await validate(schema.validator, value);\n  if (result.isValid) return [];\n\n  if (result.errors.length === 0) {\n    return [{ config: configName, key: \"\", message: \"does not match its config schema\" }];\n  }\n\n  return result.errors.map((error) => {\n    const key = error.input ?? \"\";\n    const env = schema.env[key];\n    return {\n      config: configName,\n      key,\n      message: error.error,\n      ...(env !== undefined && { env }),\n    };\n  });\n}\n\n/** A loaded config module: its default export and, optionally, its `configSchema`. */\nexport type ConfigModuleEntry = {\n  name: string;\n  module: { default?: unknown; configSchema?: unknown };\n};\n\n/**\n * Validate every config module that exports a `configSchema` and throw one\n * {@link InvalidConfigError} listing all problems. Used by the production\n * config loader `warlock build` generates.\n */\nexport async function assertValidConfigModules(\n  entries: readonly ConfigModuleEntry[],\n): Promise<void> {\n  const issues: ConfigIssue[] = [];\n\n  for (const entry of entries) {\n    issues.push(\n      ...(await validateConfigValue(entry.name, entry.module.default, entry.module.configSchema)),\n    );\n  }\n\n  if (issues.length > 0) throw new InvalidConfigError(issues);\n}\n"],"mappings":";;;AAmCA,MAAM,uBAAsC,OAAO,IAAI,yBAAyB;;;;;AAsChF,SAAgB,mBACd,WACA,UAA+B,CAAC,GACN;CAC1B,OAAO;GAAG,uBAAuB;EAAM;EAAW,KAAK,EAAE,GAAG,QAAQ,IAAI;CAAE;AAC5E;;AAGA,SAAgB,eAAe,OAAuC;CACpE,OACE,OAAO,UAAU,YACjB,UAAU,QACT,MAAuC,0BAA0B;AAEtE;;;;;AAMA,IAAa,qBAAb,cAAwC,MAAM;CAG5C,AAAO,YAAY,AAAgB,QAAgC;EACjE,MAAM,mBAAmB,MAAM,CAAC;EADC;cAFH;CAIhC;AACF;;AAGA,SAAgB,mBAAmB,QAAwC;CACzE,MAAM,QAAQ,OAAO,KAAK,UAAU;EAClC,MAAM,OAAO,MAAM,MAAM,GAAG,MAAM,OAAO,GAAG,MAAM,QAAQ,MAAM;EAChE,MAAM,OAAO,MAAM,MAAM,SAAS,MAAM,IAAI,iCAAiC;EAC7E,OAAO,OAAO,KAAK,IAAI,MAAM,UAAU;CACzC,CAAC;CAID,OAAO,0BAFO,OAAO,WAAW,IAAI,cAAc,GAAG,OAAO,OAAO,WAE5B,8CAA8C,MAAM,KAAK,IAAI;AACtG;;;;;AAMA,eAAsB,oBACpB,YACA,OACA,QACwB;CACxB,IAAI,CAAC,eAAe,MAAM,GAAG,OAAO,CAAC;CAErC,MAAM,SAAS,MAAM,SAAS,OAAO,WAAW,KAAK;CACrD,IAAI,OAAO,SAAS,OAAO,CAAC;CAE5B,IAAI,OAAO,OAAO,WAAW,GAC3B,OAAO,CAAC;EAAE,QAAQ;EAAY,KAAK;EAAI,SAAS;CAAmC,CAAC;CAGtF,OAAO,OAAO,OAAO,KAAK,UAAU;EAClC,MAAM,MAAM,MAAM,SAAS;EAC3B,MAAM,MAAM,OAAO,IAAI;EACvB,OAAO;GACL,QAAQ;GACR;GACA,SAAS,MAAM;GACf,GAAI,QAAQ,UAAa,EAAE,IAAI;EACjC;CACF,CAAC;AACH;;;;;;AAaA,eAAsB,yBACpB,SACe;CACf,MAAM,SAAwB,CAAC;CAE/B,KAAK,MAAM,SAAS,SAClB,OAAO,KACL,GAAI,MAAM,oBAAoB,MAAM,MAAM,MAAM,OAAO,SAAS,MAAM,OAAO,YAAY,CAC3F;CAGF,IAAI,OAAO,SAAS,GAAG,MAAM,IAAI,mBAAmB,MAAM;AAC5D"}

package/esm/config/config-setter.d.mts

@@ -1,6 +1,6 @@
 import { ConfigRegistry } from "./types.mjs";
 
-//#region ../core/src/config/config-setter.d.ts
+//#region ../../packages/core/src/config/config-setter.d.ts
 /**
  * Register a config group under its name.
  *

package/esm/config/config-setter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config-setter.d.mts","names":[],"sources":["../../../../../../../core/src/config/config-setter.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;;;;iBAAgB,SAAA,iBAA0B,cAAA,EAAgB,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,cAAA,CAAe,CAAA;AAAA,iBACzE,SAAA,CAAU,IAAA,UAAc,KAAc"}
+{"version":3,"file":"config-setter.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/config/config-setter.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;;;;iBAAgB,SAAA,iBAA0B,cAAA,EAAgB,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,cAAA,CAAe,CAAA;AAAA,iBACzE,SAAA,CAAU,IAAA,UAAc,KAAc"}

package/esm/config/config-setter.mjs

@@ -1,6 +1,6 @@
 import config from "@mongez/config";
 
-//#region ../core/src/config/config-setter.ts
+//#region ../../packages/core/src/config/config-setter.ts
 function setConfig(name, value) {
 	config.set(name, value);
 }

package/esm/config/config-setter.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"config-setter.mjs","names":[],"sources":["../../../../../../../core/src/config/config-setter.ts"],"sourcesContent":["import baseConfig from \"@mongez/config\";\nimport type { ConfigRegistry } from \"./types\";\n\n/**\n * Register a config group under its name.\n *\n * The write side of the config store, kept separate from the `config` accessor\n * on purpose: `config` is a read-only surface and widening it would invite app\n * code to mutate configuration at runtime. Registration is a boot-time act.\n *\n * Exported chiefly so the production build's generated config loader has a\n * specifier the consuming app actually declares — `@warlock.js/core` — rather\n * than `@mongez/config`, which is core's dependency and not the app's.\n *\n * @example\n * ```typescript\n * import { setConfig } from \"@warlock.js/core\";\n * import databaseConfig from \"../../src/config/database\";\n *\n * setConfig(\"database\", databaseConfig);\n * ```\n */\nexport function setConfig<K extends keyof ConfigRegistry>(name: K, value: ConfigRegistry[K]): void;\nexport function setConfig(name: string, value: unknown): void;\nexport function setConfig(name: string, value: unknown): void {\n  baseConfig.set(name, value);\n}\n"],"mappings":";;;AAwBA,SAAgB,UAAU,MAAc,OAAsB;CAC5D,OAAW,IAAI,MAAM,KAAK;AAC5B"}
+{"version":3,"file":"config-setter.mjs","names":[],"sources":["../../../../../../../../packages/core/src/config/config-setter.ts"],"sourcesContent":["import baseConfig from \"@mongez/config\";\nimport type { ConfigRegistry } from \"./types\";\n\n/**\n * Register a config group under its name.\n *\n * The write side of the config store, kept separate from the `config` accessor\n * on purpose: `config` is a read-only surface and widening it would invite app\n * code to mutate configuration at runtime. Registration is a boot-time act.\n *\n * Exported chiefly so the production build's generated config loader has a\n * specifier the consuming app actually declares — `@warlock.js/core` — rather\n * than `@mongez/config`, which is core's dependency and not the app's.\n *\n * @example\n * ```typescript\n * import { setConfig } from \"@warlock.js/core\";\n * import databaseConfig from \"../../src/config/database\";\n *\n * setConfig(\"database\", databaseConfig);\n * ```\n */\nexport function setConfig<K extends keyof ConfigRegistry>(name: K, value: ConfigRegistry[K]): void;\nexport function setConfig(name: string, value: unknown): void;\nexport function setConfig(name: string, value: unknown): void {\n  baseConfig.set(name, value);\n}\n"],"mappings":";;;AAwBA,SAAgB,UAAU,MAAc,OAAsB;CAC5D,OAAW,IAAI,MAAM,KAAK;AAC5B"}

package/esm/config/config-special-handlers.d.mts

@@ -1,6 +1,6 @@
 import { SpecialConfigHandler } from "./config-loader.mjs";
 
-//#region ../core/src/config/config-special-handlers.d.ts
+//#region ../../packages/core/src/config/config-special-handlers.d.ts
 declare class ConfigSpecialHandlers {
   /**
    * Handlers

package/esm/config/config-special-handlers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config-special-handlers.d.mts","names":[],"sources":["../../../../../../../core/src/config/config-special-handlers.ts"],"mappings":";;;cAEa,qBAAA;;AAAb;;YAIY,QAAA,EAAU,GAAA,SAAY,oBAAA;EAAA;;;EAKzB,QAAA,CAAS,UAAA,UAAoB,OAAA,EAAS,oBAAA;EAOO;;;EAAvC,OAAA,CAAQ,UAAA,UAAoB,MAAA,QAAW,OAAA;AAAA;AAAA,cAUzC,qBAAA,EAAqB,qBAA8B"}
+{"version":3,"file":"config-special-handlers.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/config/config-special-handlers.ts"],"mappings":";;;cAEa,qBAAA;;AAAb;;YAIY,QAAA,EAAU,GAAA,SAAY,oBAAA;EAAA;;;EAKzB,QAAA,CAAS,UAAA,UAAoB,OAAA,EAAS,oBAAA;EAOO;;;EAAvC,OAAA,CAAQ,UAAA,UAAoB,MAAA,QAAW,OAAA;AAAA;AAAA,cAUzC,qBAAA,EAAqB,qBAA8B"}

package/esm/config/config-special-handlers.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/config/config-special-handlers.ts
+//#region ../../packages/core/src/config/config-special-handlers.ts
 var ConfigSpecialHandlers = class {
 	constructor() {
 		this.handlers = /* @__PURE__ */ new Map();

package/esm/config/config-special-handlers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"config-special-handlers.mjs","names":[],"sources":["../../../../../../../core/src/config/config-special-handlers.ts"],"sourcesContent":["import { type SpecialConfigHandler } from \"./config-loader\";\n\nexport class ConfigSpecialHandlers {\n  /**\n   * Handlers\n   */\n  protected handlers: Map<string, SpecialConfigHandler> = new Map();\n\n  /**\n   * Register a new handler\n   */\n  public register(configName: string, handler: SpecialConfigHandler) {\n    this.handlers.set(configName, handler);\n  }\n\n  /**\n   * Execute handler for the given config name\n   */\n  public async execute(configName: string, config: any) {\n    const handler = this.handlers.get(configName);\n    if (!handler) {\n      return; // do nothing\n    }\n\n    return handler(config);\n  }\n}\n\nexport const configSpecialHandlers = new ConfigSpecialHandlers();\n"],"mappings":";AAEA,IAAa,wBAAb,MAAmC;;kCAIuB,IAAI,IAAI;;;;;CAKhE,AAAO,SAAS,YAAoB,SAA+B;EACjE,KAAK,SAAS,IAAI,YAAY,OAAO;CACvC;;;;CAKA,MAAa,QAAQ,YAAoB,QAAa;EACpD,MAAM,UAAU,KAAK,SAAS,IAAI,UAAU;EAC5C,IAAI,CAAC,SACH;EAGF,OAAO,QAAQ,MAAM;CACvB;AACF;AAEA,MAAa,wBAAwB,IAAI,sBAAsB"}
+{"version":3,"file":"config-special-handlers.mjs","names":[],"sources":["../../../../../../../../packages/core/src/config/config-special-handlers.ts"],"sourcesContent":["import { type SpecialConfigHandler } from \"./config-loader\";\n\nexport class ConfigSpecialHandlers {\n  /**\n   * Handlers\n   */\n  protected handlers: Map<string, SpecialConfigHandler> = new Map();\n\n  /**\n   * Register a new handler\n   */\n  public register(configName: string, handler: SpecialConfigHandler) {\n    this.handlers.set(configName, handler);\n  }\n\n  /**\n   * Execute handler for the given config name\n   */\n  public async execute(configName: string, config: any) {\n    const handler = this.handlers.get(configName);\n    if (!handler) {\n      return; // do nothing\n    }\n\n    return handler(config);\n  }\n}\n\nexport const configSpecialHandlers = new ConfigSpecialHandlers();\n"],"mappings":";AAEA,IAAa,wBAAb,MAAmC;;kCAIuB,IAAI,IAAI;;;;;CAKhE,AAAO,SAAS,YAAoB,SAA+B;EACjE,KAAK,SAAS,IAAI,YAAY,OAAO;CACvC;;;;CAKA,MAAa,QAAQ,YAAoB,QAAa;EACpD,MAAM,UAAU,KAAK,SAAS,IAAI,UAAU;EAC5C,IAAI,CAAC,SACH;EAGF,OAAO,QAAQ,MAAM;CACvB;AACF;AAEA,MAAa,wBAAwB,IAAI,sBAAsB"}

package/esm/config/index.d.mts

@@ -0,0 +1,6 @@
+import { ConfigKey, ConfigKeyRegistry, ConfigName, ConfigRegistry } from "./types.mjs";
+import { config } from "./config-getter.mjs";
+import { registerAppConfig } from "./config-handlers.mjs";
+import { ConfigIssue, ConfigModuleEntry, ConfigOf, ConfigSchema, ConfigSchemaOptions, InvalidConfigError, assertValidConfigModules, defineConfigSchema, formatConfigIssues, isConfigSchema, validateConfigValue } from "./config-schema.mjs";
+import { setConfig } from "./config-setter.mjs";
+import { ConfigSpecialHandlers, configSpecialHandlers } from "./config-special-handlers.mjs";

package/esm/config/index.mjs

@@ -1,6 +1,7 @@
 import { config } from "./config-getter.mjs";
 import { ConfigSpecialHandlers, configSpecialHandlers } from "./config-special-handlers.mjs";
 import { registerAppConfig } from "./config-handlers.mjs";
+import { InvalidConfigError, assertValidConfigModules, defineConfigSchema, formatConfigIssues, isConfigSchema, validateConfigValue } from "./config-schema.mjs";
 import { setConfig } from "./config-setter.mjs";
 
 export {  };

package/esm/config/load-config-files.mjs

@@ -5,7 +5,7 @@ import { getCertainFilesFromDirectory, getFilesFromDirectory } from "../dev-serv
 import { filesOrchestrator } from "../dev-server/files-orchestrator.mjs";
 import { configManager } from "./config-manager.mjs";
 
-//#region ../core/src/config/load-config-files.ts
+//#region ../../packages/core/src/config/load-config-files.ts
 /**
 * Load config files
 * either config file names (without extensions) or true to load all config files

package/esm/config/load-config-files.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"load-config-files.mjs","names":[],"sources":["../../../../../../../core/src/config/load-config-files.ts"],"sourcesContent":["import { filesOrchestrator } from \"../dev-server/files-orchestrator\";\nimport { Path } from \"../utils/normalized-path\";\nimport { getCertainFilesFromDirectory, getFilesFromDirectory } from \"../dev-server/utils\";\nimport { srcPath } from \"../utils\";\nimport { configManager } from \"./config-manager\";\n\n/**\n * Load config files\n * either config file names (without extensions) or true to load all config files\n */\nexport async function loadConfigFiles(config: string[] | true) {\n  let relativePaths: string[] = [];\n  if (config === true) {\n    const configFilesAbsulatePaths = await getFilesFromDirectory(srcPath(\"config\"));\n    relativePaths = configFilesAbsulatePaths.map((path) => Path.toRelative(path));\n  } else {\n    // define only the given config files\n\n    const configFilesAbsulatePaths = await getCertainFilesFromDirectory(srcPath(\"config\"), config);\n\n    relativePaths = configFilesAbsulatePaths.map((path) => Path.toRelative(path));\n  }\n\n  const configFiles = await Promise.all(\n    relativePaths.map((relativePath) => filesOrchestrator.add(relativePath)),\n  );\n\n  filesOrchestrator.specialFilesCollector.collect(filesOrchestrator.files);\n\n  await configManager.loadAll(configFiles);\n}\n"],"mappings":";;;;;;;;;;;;AAUA,eAAsB,gBAAgB,QAAyB;CAC7D,IAAI,gBAA0B,CAAC;CAC/B,IAAI,WAAW,MAEb,iBAAgB,MADuB,sBAAsB,QAAQ,QAAQ,CAAC,EACtC,CAAC,KAAK,SAAS,KAAK,WAAW,IAAI,CAAC;MAM5E,iBAAgB,MAFuB,6BAA6B,QAAQ,QAAQ,GAAG,MAAM,EAErD,CAAC,KAAK,SAAS,KAAK,WAAW,IAAI,CAAC;CAG9E,MAAM,cAAc,MAAM,QAAQ,IAChC,cAAc,KAAK,iBAAiB,kBAAkB,IAAI,YAAY,CAAC,CACzE;CAEA,kBAAkB,sBAAsB,QAAQ,kBAAkB,KAAK;CAEvE,MAAM,cAAc,QAAQ,WAAW;AACzC"}
+{"version":3,"file":"load-config-files.mjs","names":[],"sources":["../../../../../../../../packages/core/src/config/load-config-files.ts"],"sourcesContent":["import { filesOrchestrator } from \"../dev-server/files-orchestrator\";\nimport { Path } from \"../utils/normalized-path\";\nimport { getCertainFilesFromDirectory, getFilesFromDirectory } from \"../dev-server/utils\";\nimport { srcPath } from \"../utils\";\nimport { configManager } from \"./config-manager\";\n\n/**\n * Load config files\n * either config file names (without extensions) or true to load all config files\n */\nexport async function loadConfigFiles(config: string[] | true) {\n  let relativePaths: string[] = [];\n  if (config === true) {\n    const configFilesAbsulatePaths = await getFilesFromDirectory(srcPath(\"config\"));\n    relativePaths = configFilesAbsulatePaths.map((path) => Path.toRelative(path));\n  } else {\n    // define only the given config files\n\n    const configFilesAbsulatePaths = await getCertainFilesFromDirectory(srcPath(\"config\"), config);\n\n    relativePaths = configFilesAbsulatePaths.map((path) => Path.toRelative(path));\n  }\n\n  const configFiles = await Promise.all(\n    relativePaths.map((relativePath) => filesOrchestrator.add(relativePath)),\n  );\n\n  filesOrchestrator.specialFilesCollector.collect(filesOrchestrator.files);\n\n  await configManager.loadAll(configFiles);\n}\n"],"mappings":";;;;;;;;;;;;AAUA,eAAsB,gBAAgB,QAAyB;CAC7D,IAAI,gBAA0B,CAAC;CAC/B,IAAI,WAAW,MAEb,iBAAgB,MADuB,sBAAsB,QAAQ,QAAQ,CAAC,EACtC,CAAC,KAAK,SAAS,KAAK,WAAW,IAAI,CAAC;MAM5E,iBAAgB,MAFuB,6BAA6B,QAAQ,QAAQ,GAAG,MAAM,EAErD,CAAC,KAAK,SAAS,KAAK,WAAW,IAAI,CAAC;CAG9E,MAAM,cAAc,MAAM,QAAQ,IAChC,cAAc,KAAK,iBAAiB,kBAAkB,IAAI,YAAY,CAAC,CACzE;CAEA,kBAAkB,sBAAsB,QAAQ,kBAAkB,KAAK;CAEvE,MAAM,cAAc,QAAQ,WAAW;AACzC"}

package/esm/config/locale-configuration.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/config/locale-configuration.ts
+//#region ../../packages/core/src/config/locale-configuration.ts
 /**
 * The name of the cookie the framework uses to persist a request's locale
 * across requests.

package/esm/config/locale-configuration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"locale-configuration.mjs","names":[],"sources":["../../../../../../../core/src/config/locale-configuration.ts"],"sourcesContent":["/**\n * The name of the cookie the framework uses to persist a request's locale\n * across requests.\n *\n * The ONE place this string is written. `Request.resolveLocale()` reads it,\n * `Response.setLocale()` writes it; neither hardcodes the literal. Changing\n * this constant changes both sides together instead of requiring two edits\n * that can silently fall out of sync.\n */\nexport const LOCALE_COOKIE_NAME = \"locale\";\n\n/**\n * A client-readable, host-only locale preference. It is deliberately separate\n * from `LOCALE_COOKIE_NAME`: the latter remains the server-authoritative\n * HttpOnly locale cookie.\n */\nexport const LOCALE_PREFERENCE_COOKIE_NAME = \"warlock.locale-preference\";\n\nexport type LocaleConfiguration = {\n  defaultLocaleCode: string;\n  /**\n   * The declared allow-list, or `undefined` when the application declares none.\n   *\n   * The absence of a list is NOT an implicit list of one. With nothing to\n   * validate against, a client locale has nothing it can fail — coercing it to\n   * the default would discard what the client actually asked for.\n   */\n  localeCodes: string[] | undefined;\n};\n\ntype AppLocaleConfiguration = {\n  localeCode?: unknown;\n  localeCodes?: unknown;\n};\n\nfunction isNonEmptyStringArray(value: unknown): value is string[] {\n  return (\n    Array.isArray(value) &&\n    value.length > 0 &&\n    value.every((candidate) => typeof candidate === \"string\")\n  );\n}\n\n/**\n * Resolve the locale configuration used by every request.\n *\n * It fails closed only where there is a declared allow-list to fail against;\n * an application that declares none opts out of validation, not into a\n * single-locale list.\n */\nexport function resolveLocaleConfiguration(\n  localeCode: unknown,\n  localeCodes: unknown,\n): LocaleConfiguration {\n  const defaultLocaleCode =\n    typeof localeCode === \"string\" && localeCode.length > 0 ? localeCode : \"en\";\n\n  return {\n    defaultLocaleCode,\n    localeCodes: isNonEmptyStringArray(localeCodes) ? localeCodes : undefined,\n  };\n}\n\n/**\n * A default outside the declared list makes every fallback contradictory, so\n * configuration loading must stop before the application can accept requests.\n */\nexport function assertLocaleConfiguration(config: AppLocaleConfiguration): void {\n  const { defaultLocaleCode } = resolveLocaleConfiguration(config.localeCode, config.localeCodes);\n\n  if (\n    isNonEmptyStringArray(config.localeCodes) &&\n    !config.localeCodes.includes(defaultLocaleCode)\n  ) {\n    throw new Error(\n      `app.localeCodes does not include the resolved default locale \"${defaultLocaleCode}\". ` +\n        `Add \"${defaultLocaleCode}\" to app.localeCodes or change app.localeCode; ` +\n        `boot cannot continue with a default that the application does not support.`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,MAAa,qBAAqB;;;;;;AAOlC,MAAa,gCAAgC;AAmB7C,SAAS,sBAAsB,OAAmC;CAChE,OACE,MAAM,QAAQ,KAAK,KACnB,MAAM,SAAS,KACf,MAAM,OAAO,cAAc,OAAO,cAAc,QAAQ;AAE5D;;;;;;;;AASA,SAAgB,2BACd,YACA,aACqB;CAIrB,OAAO;EACL,mBAHA,OAAO,eAAe,YAAY,WAAW,SAAS,IAAI,aAAa;EAIvE,aAAa,sBAAsB,WAAW,IAAI,cAAc;CAClE;AACF;;;;;AAMA,SAAgB,0BAA0B,QAAsC;CAC9E,MAAM,EAAE,sBAAsB,2BAA2B,OAAO,YAAY,OAAO,WAAW;CAE9F,IACE,sBAAsB,OAAO,WAAW,KACxC,CAAC,OAAO,YAAY,SAAS,iBAAiB,GAE9C,MAAM,IAAI,MACR,iEAAiE,kBAAkB,UACzE,kBAAkB,0HAE9B;AAEJ"}
+{"version":3,"file":"locale-configuration.mjs","names":[],"sources":["../../../../../../../../packages/core/src/config/locale-configuration.ts"],"sourcesContent":["/**\n * The name of the cookie the framework uses to persist a request's locale\n * across requests.\n *\n * The ONE place this string is written. `Request.resolveLocale()` reads it,\n * `Response.setLocale()` writes it; neither hardcodes the literal. Changing\n * this constant changes both sides together instead of requiring two edits\n * that can silently fall out of sync.\n */\nexport const LOCALE_COOKIE_NAME = \"locale\";\n\n/**\n * A client-readable, host-only locale preference. It is deliberately separate\n * from `LOCALE_COOKIE_NAME`: the latter remains the server-authoritative\n * HttpOnly locale cookie.\n */\nexport const LOCALE_PREFERENCE_COOKIE_NAME = \"warlock.locale-preference\";\n\nexport type LocaleConfiguration = {\n  defaultLocaleCode: string;\n  /**\n   * The declared allow-list, or `undefined` when the application declares none.\n   *\n   * The absence of a list is NOT an implicit list of one. With nothing to\n   * validate against, a client locale has nothing it can fail — coercing it to\n   * the default would discard what the client actually asked for.\n   */\n  localeCodes: string[] | undefined;\n};\n\ntype AppLocaleConfiguration = {\n  localeCode?: unknown;\n  localeCodes?: unknown;\n};\n\nfunction isNonEmptyStringArray(value: unknown): value is string[] {\n  return (\n    Array.isArray(value) &&\n    value.length > 0 &&\n    value.every((candidate) => typeof candidate === \"string\")\n  );\n}\n\n/**\n * Resolve the locale configuration used by every request.\n *\n * It fails closed only where there is a declared allow-list to fail against;\n * an application that declares none opts out of validation, not into a\n * single-locale list.\n */\nexport function resolveLocaleConfiguration(\n  localeCode: unknown,\n  localeCodes: unknown,\n): LocaleConfiguration {\n  const defaultLocaleCode =\n    typeof localeCode === \"string\" && localeCode.length > 0 ? localeCode : \"en\";\n\n  return {\n    defaultLocaleCode,\n    localeCodes: isNonEmptyStringArray(localeCodes) ? localeCodes : undefined,\n  };\n}\n\n/**\n * A default outside the declared list makes every fallback contradictory, so\n * configuration loading must stop before the application can accept requests.\n */\nexport function assertLocaleConfiguration(config: AppLocaleConfiguration): void {\n  const { defaultLocaleCode } = resolveLocaleConfiguration(config.localeCode, config.localeCodes);\n\n  if (\n    isNonEmptyStringArray(config.localeCodes) &&\n    !config.localeCodes.includes(defaultLocaleCode)\n  ) {\n    throw new Error(\n      `app.localeCodes does not include the resolved default locale \"${defaultLocaleCode}\". ` +\n        `Add \"${defaultLocaleCode}\" to app.localeCodes or change app.localeCode; ` +\n        `boot cannot continue with a default that the application does not support.`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,MAAa,qBAAqB;;;;;;AAOlC,MAAa,gCAAgC;AAmB7C,SAAS,sBAAsB,OAAmC;CAChE,OACE,MAAM,QAAQ,KAAK,KACnB,MAAM,SAAS,KACf,MAAM,OAAO,cAAc,OAAO,cAAc,QAAQ;AAE5D;;;;;;;;AASA,SAAgB,2BACd,YACA,aACqB;CAIrB,OAAO;EACL,mBAHA,OAAO,eAAe,YAAY,WAAW,SAAS,IAAI,aAAa;EAIvE,aAAa,sBAAsB,WAAW,IAAI,cAAc;CAClE;AACF;;;;;AAMA,SAAgB,0BAA0B,QAAsC;CAC9E,MAAM,EAAE,sBAAsB,2BAA2B,OAAO,YAAY,OAAO,WAAW;CAE9F,IACE,sBAAsB,OAAO,WAAW,KACxC,CAAC,OAAO,YAAY,SAAS,iBAAiB,GAE9C,MAAM,IAAI,MACR,iEAAiE,kBAAkB,UACzE,kBAAkB,0HAE9B;AAEJ"}

package/esm/config/types.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/config/types.d.ts
+//#region ../../packages/core/src/config/types.d.ts
 /**
  * Config registry interface.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../core/src/config/types.ts"],"mappings":";;AAiBA;;;;AAA+B;AAQ/B;;;;AAA2F;AAkB3F;;;;AAAkC;AAQlC;UAlCiB,cAAA;;AAkC+E;;;;;KA1BpF,UAAA,SAAmB,cAAA,gCAA8C,cAAc;;;;;;;;;;;;;;;;;UAkB1E,iBAAA;;;;;;;KAQL,SAAA,SAAkB,iBAAA,gCAAiD,iBAAiB"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/config/types.ts"],"mappings":";;AAiBA;;;;AAA+B;AAQ/B;;;;AAA2F;AAkB3F;;;;AAAkC;AAQlC;UAlCiB,cAAA;;AAkC+E;;;;;KA1BpF,UAAA,SAAmB,cAAA,gCAA8C,cAAc;;;;;;;;;;;;;;;;;UAkB1E,iBAAA;;;;;;;KAQL,SAAA,SAAkB,iBAAA,gCAAiD,iBAAiB"}

package/esm/connectors/access-connector.d.mts

@@ -1,7 +1,7 @@
 import { ConnectorLifecyclePhase, ConnectorPriority } from "./types.mjs";
 import { BaseConnector } from "./base-connector.mjs";
 
-//#region ../core/src/connectors/access-connector.d.ts
+//#region ../../packages/core/src/connectors/access-connector.d.ts
 /**
  * Access Connector
  *

package/esm/connectors/access-connector.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"access-connector.d.mts","names":[],"sources":["../../../../../../../core/src/connectors/access-connector.ts"],"mappings":";;;;;;AAkBA;;;;;;;;;;;cAAa,eAAA,SAAwB,aAAA;EAAA,SACnB,IAAA;EAAA,SACA,QAAA,GAAQ,iBAAA,CAAA,MAAA;EAAA,SACR,cAAA,GAAc,uBAAA,CAAA,KAAA;EAAd;;;EAAA,mBAKG,YAAA;EAKN;;;EAAA,KAAA,IAAS,OAAA;EAoBU;AAAA;;;;EAAnB,QAAA,IAAY,OAAA;AAAA"}
+{"version":3,"file":"access-connector.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/connectors/access-connector.ts"],"mappings":";;;;;;AAkBA;;;;;;;;;;;cAAa,eAAA,SAAwB,aAAA;EAAA,SACnB,IAAA;EAAA,SACA,QAAA,GAAQ,iBAAA,CAAA,MAAA;EAAA,SACR,cAAA,GAAc,uBAAA,CAAA,KAAA;EAAd;;;EAAA,mBAKG,YAAA;EAKN;;;EAAA,KAAA,IAAS,OAAA;EAoBU;AAAA;;;;EAAnB,QAAA,IAAY,OAAA;AAAA"}

package/esm/connectors/access-connector.mjs

@@ -3,7 +3,7 @@ import { BaseConnector } from "./base-connector.mjs";
 import config from "@mongez/config";
 import { log } from "@warlock.js/logger";
 
-//#region ../core/src/connectors/access-connector.ts
+//#region ../../packages/core/src/connectors/access-connector.ts
 /**
 * Access Connector
 *

package/esm/connectors/access-connector.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"access-connector.mjs","names":[],"sources":["../../../../../../../core/src/connectors/access-connector.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { log } from \"@warlock.js/logger\";\nimport { BaseConnector } from \"./base-connector\";\nimport { ConnectorLifecyclePhase, ConnectorPriority } from \"./types\";\n\n/**\n * Access Connector\n *\n * Wires `@warlock.js/access` from `src/config/access.ts` at boot: reads the\n * exported config object and hands it to the package's `setAccessConfig`, which\n * validates that a resolver is present — so a misconfigured authorization layer\n * fails at STARTUP, not on the first protected request. Config files stay\n * declarative; the connector performs the side-effect.\n *\n * The package is lazy-imported (only when an access config is present), so core\n * carries no hard dependency on it — the same pattern as the notifications and\n * herald connectors.\n */\nexport class AccessConnector extends BaseConnector {\n  public readonly name = \"access\";\n  public readonly priority = ConnectorPriority.ACCESS;\n  public readonly lifecyclePhase = ConnectorLifecyclePhase.Early;\n\n  /**\n   * Files that trigger an access restart\n   */\n  protected readonly watchedFiles = [\"src/config/access.ts\"];\n\n  /**\n   * Register the access configuration with the package.\n   */\n  public async start(): Promise<void> {\n    const accessConfiguration = config.get(\"access\");\n\n    if (!accessConfiguration) {\n      return;\n    }\n\n    const { setAccessConfig } = await import(\"@warlock.js/access\");\n\n    setAccessConfig(accessConfiguration);\n    this.active = true;\n\n    log.info(\"access\", \"configured\", \"Authorization wired from config/access.ts\");\n  }\n\n  /**\n   * Clear the active config so a dev restart re-registers from the (possibly\n   * changed, or now-removed) config file. The package holds no external\n   * connection of its own.\n   */\n  public async shutdown(): Promise<void> {\n    if (!this.active) {\n      return;\n    }\n\n    const { resetAccessConfig } = await import(\"@warlock.js/access\");\n\n    resetAccessConfig();\n    this.active = false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,IAAa,kBAAb,cAAqC,cAAc;;;cAC1B;;;sBAOW,CAAC,sBAAsB;;;;;CAKzD,MAAa,QAAuB;EAClC,MAAM,sBAAsB,OAAO,IAAI,QAAQ;EAE/C,IAAI,CAAC,qBACH;EAGF,MAAM,EAAE,oBAAoB,MAAM,OAAO;EAEzC,gBAAgB,mBAAmB;EACnC,KAAK,SAAS;EAEd,IAAI,KAAK,UAAU,cAAc,2CAA2C;CAC9E;;;;;;CAOA,MAAa,WAA0B;EACrC,IAAI,CAAC,KAAK,QACR;EAGF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAE3C,kBAAkB;EAClB,KAAK,SAAS;CAChB;AACF"}
+{"version":3,"file":"access-connector.mjs","names":[],"sources":["../../../../../../../../packages/core/src/connectors/access-connector.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { log } from \"@warlock.js/logger\";\nimport { BaseConnector } from \"./base-connector\";\nimport { ConnectorLifecyclePhase, ConnectorPriority } from \"./types\";\n\n/**\n * Access Connector\n *\n * Wires `@warlock.js/access` from `src/config/access.ts` at boot: reads the\n * exported config object and hands it to the package's `setAccessConfig`, which\n * validates that a resolver is present — so a misconfigured authorization layer\n * fails at STARTUP, not on the first protected request. Config files stay\n * declarative; the connector performs the side-effect.\n *\n * The package is lazy-imported (only when an access config is present), so core\n * carries no hard dependency on it — the same pattern as the notifications and\n * herald connectors.\n */\nexport class AccessConnector extends BaseConnector {\n  public readonly name = \"access\";\n  public readonly priority = ConnectorPriority.ACCESS;\n  public readonly lifecyclePhase = ConnectorLifecyclePhase.Early;\n\n  /**\n   * Files that trigger an access restart\n   */\n  protected readonly watchedFiles = [\"src/config/access.ts\"];\n\n  /**\n   * Register the access configuration with the package.\n   */\n  public async start(): Promise<void> {\n    const accessConfiguration = config.get(\"access\");\n\n    if (!accessConfiguration) {\n      return;\n    }\n\n    const { setAccessConfig } = await import(\"@warlock.js/access\");\n\n    setAccessConfig(accessConfiguration);\n    this.active = true;\n\n    log.info(\"access\", \"configured\", \"Authorization wired from config/access.ts\");\n  }\n\n  /**\n   * Clear the active config so a dev restart re-registers from the (possibly\n   * changed, or now-removed) config file. The package holds no external\n   * connection of its own.\n   */\n  public async shutdown(): Promise<void> {\n    if (!this.active) {\n      return;\n    }\n\n    const { resetAccessConfig } = await import(\"@warlock.js/access\");\n\n    resetAccessConfig();\n    this.active = false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,IAAa,kBAAb,cAAqC,cAAc;;;cAC1B;;;sBAOW,CAAC,sBAAsB;;;;;CAKzD,MAAa,QAAuB;EAClC,MAAM,sBAAsB,OAAO,IAAI,QAAQ;EAE/C,IAAI,CAAC,qBACH;EAGF,MAAM,EAAE,oBAAoB,MAAM,OAAO;EAEzC,gBAAgB,mBAAmB;EACnC,KAAK,SAAS;EAEd,IAAI,KAAK,UAAU,cAAc,2CAA2C;CAC9E;;;;;;CAOA,MAAa,WAA0B;EACrC,IAAI,CAAC,KAAK,QACR;EAGF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAE3C,kBAAkB;EAClB,KAAK,SAAS;CAChB;AACF"}

package/esm/connectors/ai-connector.d.mts

@@ -1,7 +1,7 @@
 import { ConnectorLifecyclePhase, ConnectorPriority } from "./types.mjs";
 import { BaseConnector } from "./base-connector.mjs";
 
-//#region ../core/src/connectors/ai-connector.d.ts
+//#region ../../packages/core/src/connectors/ai-connector.d.ts
 /**
  * AI Connector
  *

package/esm/connectors/ai-connector.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-connector.d.mts","names":[],"sources":["../../../../../../../core/src/connectors/ai-connector.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;;;;cAAa,WAAA,SAAoB,aAAA;EAAA,SACf,IAAA;EAAA,SACA,QAAA,GAAQ,iBAAA,CAAA,EAAA;EAAA,SACR,cAAA,GAAc,uBAAA,CAAA,KAAA;EAUjB;;;EAAA,mBALM,YAAA;EAuBa;AAAA;;EAlBnB,KAAA,IAAS,OAAA;;;;;;EAkBT,QAAA,IAAY,OAAA;AAAA"}
+{"version":3,"file":"ai-connector.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/connectors/ai-connector.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;;;;cAAa,WAAA,SAAoB,aAAA;EAAA,SACf,IAAA;EAAA,SACA,QAAA,GAAQ,iBAAA,CAAA,EAAA;EAAA,SACR,cAAA,GAAc,uBAAA,CAAA,KAAA;EAUjB;;;EAAA,mBALM,YAAA;EAuBa;AAAA;;EAlBnB,KAAA,IAAS,OAAA;;;;;;EAkBT,QAAA,IAAY,OAAA;AAAA"}

package/esm/connectors/ai-connector.mjs

@@ -3,7 +3,7 @@ import { BaseConnector } from "./base-connector.mjs";
 import config from "@mongez/config";
 import { log } from "@warlock.js/logger";
 
-//#region ../core/src/connectors/ai-connector.ts
+//#region ../../packages/core/src/connectors/ai-connector.ts
 /**
 * AI Connector
 *

package/esm/connectors/ai-connector.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ai-connector.mjs","names":[],"sources":["../../../../../../../core/src/connectors/ai-connector.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { log } from \"@warlock.js/logger\";\nimport { BaseConnector } from \"./base-connector\";\nimport { ConnectorLifecyclePhase, ConnectorPriority } from \"./types\";\n\n/**\n * AI Connector\n *\n * Wires `@warlock.js/ai` from `src/config/ai.ts` at boot: reads the exported\n * config object and hands it to the package's `ai.config(...)`. Config files stay\n * declarative; the connector performs the side-effect.\n *\n * The package is lazy-imported (only when an ai config is present), so core\n * carries no hard dependency on it — the same pattern as the access,\n * notifications and herald connectors.\n *\n * Because the satellite packages' side-effect imports sit at the TOP of\n * config/ai.ts, they have already registered their surface on `ai` (ai.tools /\n * ai.mcp, ai.workspace, panoptic) by the time config-loader runs the file and\n * this connector applies the config — so this single `ai.config(...)` call also\n * fires panoptic's onConfigApplied wiring.\n */\nexport class AiConnector extends BaseConnector {\n  public readonly name = \"ai\";\n  public readonly priority = ConnectorPriority.AI;\n  public readonly lifecyclePhase = ConnectorLifecyclePhase.Early;\n\n  /**\n   * Files that trigger an ai restart\n   */\n  protected readonly watchedFiles = [\"src/config/ai.ts\"];\n\n  /**\n   * Register the ai configuration with the package.\n   */\n  public async start(): Promise<void> {\n    const aiConfiguration = config.get(\"ai\");\n\n    if (!aiConfiguration) return;\n\n    const { ai } = await import(\"@warlock.js/ai\");\n\n    ai.config(aiConfiguration);\n    this.active = true;\n\n    log.info(\"ai\", \"configured\", \"AI wired from config/ai.ts\");\n  }\n\n  /**\n   * Clear the active flag so a dev restart re-registers from the (possibly\n   * changed, or now-removed) config file. The package holds no external\n   * connection of its own.\n   */\n  public async shutdown(): Promise<void> {\n    if (!this.active) return;\n\n    this.active = false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,cAAb,cAAiC,cAAc;;;cACtB;;;sBAOW,CAAC,kBAAkB;;;;;CAKrD,MAAa,QAAuB;EAClC,MAAM,kBAAkB,OAAO,IAAI,IAAI;EAEvC,IAAI,CAAC,iBAAiB;EAEtB,MAAM,EAAE,OAAO,MAAM,OAAO;EAE5B,GAAG,OAAO,eAAe;EACzB,KAAK,SAAS;EAEd,IAAI,KAAK,MAAM,cAAc,4BAA4B;CAC3D;;;;;;CAOA,MAAa,WAA0B;EACrC,IAAI,CAAC,KAAK,QAAQ;EAElB,KAAK,SAAS;CAChB;AACF"}
+{"version":3,"file":"ai-connector.mjs","names":[],"sources":["../../../../../../../../packages/core/src/connectors/ai-connector.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { log } from \"@warlock.js/logger\";\nimport { BaseConnector } from \"./base-connector\";\nimport { ConnectorLifecyclePhase, ConnectorPriority } from \"./types\";\n\n/**\n * AI Connector\n *\n * Wires `@warlock.js/ai` from `src/config/ai.ts` at boot: reads the exported\n * config object and hands it to the package's `ai.config(...)`. Config files stay\n * declarative; the connector performs the side-effect.\n *\n * The package is lazy-imported (only when an ai config is present), so core\n * carries no hard dependency on it — the same pattern as the access,\n * notifications and herald connectors.\n *\n * Because the satellite packages' side-effect imports sit at the TOP of\n * config/ai.ts, they have already registered their surface on `ai` (ai.tools /\n * ai.mcp, ai.workspace, panoptic) by the time config-loader runs the file and\n * this connector applies the config — so this single `ai.config(...)` call also\n * fires panoptic's onConfigApplied wiring.\n */\nexport class AiConnector extends BaseConnector {\n  public readonly name = \"ai\";\n  public readonly priority = ConnectorPriority.AI;\n  public readonly lifecyclePhase = ConnectorLifecyclePhase.Early;\n\n  /**\n   * Files that trigger an ai restart\n   */\n  protected readonly watchedFiles = [\"src/config/ai.ts\"];\n\n  /**\n   * Register the ai configuration with the package.\n   */\n  public async start(): Promise<void> {\n    const aiConfiguration = config.get(\"ai\");\n\n    if (!aiConfiguration) return;\n\n    const { ai } = await import(\"@warlock.js/ai\");\n\n    ai.config(aiConfiguration);\n    this.active = true;\n\n    log.info(\"ai\", \"configured\", \"AI wired from config/ai.ts\");\n  }\n\n  /**\n   * Clear the active flag so a dev restart re-registers from the (possibly\n   * changed, or now-removed) config file. The package holds no external\n   * connection of its own.\n   */\n  public async shutdown(): Promise<void> {\n    if (!this.active) return;\n\n    this.active = false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,cAAb,cAAiC,cAAc;;;cACtB;;;sBAOW,CAAC,kBAAkB;;;;;CAKrD,MAAa,QAAuB;EAClC,MAAM,kBAAkB,OAAO,IAAI,IAAI;EAEvC,IAAI,CAAC,iBAAiB;EAEtB,MAAM,EAAE,OAAO,MAAM,OAAO;EAE5B,GAAG,OAAO,eAAe;EACzB,KAAK,SAAS;EAEd,IAAI,KAAK,MAAM,cAAc,4BAA4B;CAC3D;;;;;;CAOA,MAAa,WAA0B;EACrC,IAAI,CAAC,KAAK,QAAQ;EAElB,KAAK,SAAS;CAChB;AACF"}

package/esm/connectors/assert-no-reserved-connector-names.d.mts

@@ -1,6 +1,6 @@
 import { Connector } from "./types.mjs";
 
-//#region ../core/src/connectors/assert-no-reserved-connector-names.d.ts
+//#region ../../packages/core/src/connectors/assert-no-reserved-connector-names.d.ts
 declare function assertNoReservedConnectorNames(connectors: Connector[]): void;
 //#endregion
 export { assertNoReservedConnectorNames };

package/esm/connectors/assert-no-reserved-connector-names.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"assert-no-reserved-connector-names.d.mts","names":[],"sources":["../../../../../../../core/src/connectors/assert-no-reserved-connector-names.ts"],"mappings":";;;iBA+BgB,8BAAA,CAA+B,UAAuB,EAAX,SAAS"}
+{"version":3,"file":"assert-no-reserved-connector-names.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/connectors/assert-no-reserved-connector-names.ts"],"mappings":";;;iBAgCgB,8BAAA,CAA+B,UAAuB,EAAX,SAAS"}

package/esm/connectors/assert-no-reserved-connector-names.mjs

@@ -1,6 +1,7 @@
+import { WarlockError } from "../errors/warlock-error.mjs";
 import { connectorsManager } from "./connectors-manager.mjs";
 
-//#region ../core/src/connectors/assert-no-reserved-connector-names.ts
+//#region ../../packages/core/src/connectors/assert-no-reserved-connector-names.ts
 /**
 * Refuses a `connectors` array that claims a name a framework built-in owns.
 *
@@ -36,7 +37,7 @@ function assertNoReservedConnectorNames(connectors) {
 	const names = unique.map((name) => JSON.stringify(name)).join(", ");
 	const subject = unique.length === 1 ? "name is" : "names are";
 	const object = unique.length === 1 ? "it" : "one of them";
-	throw new Error(`The following connector ${subject} reserved by a framework built-in connector: [${names}].\nEvery connector name must be unique, and the framework already registers a built-in connector under ${unique.length === 1 ? "that name" : "those names"}, so a custom connector carrying ${object} would be built for and then never booted. Rename the custom connector in \`warlock.config.ts > connectors\` to a name of your own.`);
+	throw new WarlockError("WL1009", `The following connector ${subject} reserved by a framework built-in connector: [${names}].\nEvery connector name must be unique, and the framework already registers a built-in connector under ${unique.length === 1 ? "that name" : "those names"}, so a custom connector carrying ${object} would be built for and then never booted. Rename the custom connector in \`warlock.config.ts > connectors\` to a name of your own.`);
 }
 
 //#endregion

package/esm/connectors/assert-no-reserved-connector-names.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"assert-no-reserved-connector-names.mjs","names":[],"sources":["../../../../../../../core/src/connectors/assert-no-reserved-connector-names.ts"],"sourcesContent":["/**\n * Refuses a `connectors` array that claims a name a framework built-in owns.\n *\n * The uniqueness check rejects a name repeated inside the array; this rejects\n * one already held by a BUILT-IN outside it. The manager registers its\n * built-ins in its own constructor, so those names are taken before any config\n * is read — and the two halves disagreed about what that meant. The build\n * drains per ENTRY and knows nothing of the manager, so it prepared the custom\n * connector's artifacts; the runtime registers per NAME and found the built-in\n * already there, so it skipped the entry. The result booted the built-in the\n * app did not ask for, never booted the connector it did, and reported success\n * from both halves.\n *\n * Refused rather than resolved in the app's favour: the built-ins are the\n * framework's own wiring — other framework code reaches for `http`, `cache`,\n * `database` by name — so letting a config replace one silently repoints\n * everything that looks it up. The name is the app's to change; the built-in's\n * is not.\n *\n * Scope, precisely: BUILT-IN names only. A name held by a PREVIOUSLY\n * CONFIGURED connector (an earlier call in the same process) is not this\n * check's business — that case is the registration skip's deliberate\n * idempotency, and stays out of both validators.\n *\n * Reads {@link ConnectorsManager.isBuiltInName}, which is the ONLY inventory of\n * built-in names, so this cannot fall out of step with what the manager\n * actually registered.\n */\nimport { connectorsManager } from \"./connectors-manager\";\nimport type { Connector } from \"./types\";\n\nexport function assertNoReservedConnectorNames(connectors: Connector[]): void {\n  const reserved = connectors\n    .map((connector) => connector.name)\n    .filter((name) => connectorsManager.isBuiltInName(name));\n\n  if (reserved.length === 0) return;\n\n  const unique = [...new Set(reserved)];\n  const names = unique.map((name) => JSON.stringify(name)).join(\", \");\n  const subject = unique.length === 1 ? \"name is\" : \"names are\";\n  const object = unique.length === 1 ? \"it\" : \"one of them\";\n\n  throw new Error(\n    `The following connector ${subject} reserved by a framework built-in connector: [${names}].\\n` +\n      \"Every connector name must be unique, and the framework already registers a built-in connector under \" +\n      `${unique.length === 1 ? \"that name\" : \"those names\"}, so a custom connector carrying ${object} ` +\n      \"would be built for and then never booted. \" +\n      \"Rename the custom connector in `warlock.config.ts > connectors` to a name of your own.\",\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,+BAA+B,YAA+B;CAC5E,MAAM,WAAW,WACd,KAAK,cAAc,UAAU,IAAI,CAAC,CAClC,QAAQ,SAAS,kBAAkB,cAAc,IAAI,CAAC;CAEzD,IAAI,SAAS,WAAW,GAAG;CAE3B,MAAM,SAAS,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC;CACpC,MAAM,QAAQ,OAAO,KAAK,SAAS,KAAK,UAAU,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI;CAClE,MAAM,UAAU,OAAO,WAAW,IAAI,YAAY;CAClD,MAAM,SAAS,OAAO,WAAW,IAAI,OAAO;CAE5C,MAAM,IAAI,MACR,2BAA2B,QAAQ,gDAAgD,MAAM,0GAEpF,OAAO,WAAW,IAAI,cAAc,cAAc,mCAAmC,OAAO,oIAGnG;AACF"}
+{"version":3,"file":"assert-no-reserved-connector-names.mjs","names":[],"sources":["../../../../../../../../packages/core/src/connectors/assert-no-reserved-connector-names.ts"],"sourcesContent":["/**\n * Refuses a `connectors` array that claims a name a framework built-in owns.\n *\n * The uniqueness check rejects a name repeated inside the array; this rejects\n * one already held by a BUILT-IN outside it. The manager registers its\n * built-ins in its own constructor, so those names are taken before any config\n * is read — and the two halves disagreed about what that meant. The build\n * drains per ENTRY and knows nothing of the manager, so it prepared the custom\n * connector's artifacts; the runtime registers per NAME and found the built-in\n * already there, so it skipped the entry. The result booted the built-in the\n * app did not ask for, never booted the connector it did, and reported success\n * from both halves.\n *\n * Refused rather than resolved in the app's favour: the built-ins are the\n * framework's own wiring — other framework code reaches for `http`, `cache`,\n * `database` by name — so letting a config replace one silently repoints\n * everything that looks it up. The name is the app's to change; the built-in's\n * is not.\n *\n * Scope, precisely: BUILT-IN names only. A name held by a PREVIOUSLY\n * CONFIGURED connector (an earlier call in the same process) is not this\n * check's business — that case is the registration skip's deliberate\n * idempotency, and stays out of both validators.\n *\n * Reads {@link ConnectorsManager.isBuiltInName}, which is the ONLY inventory of\n * built-in names, so this cannot fall out of step with what the manager\n * actually registered.\n */\nimport { WarlockError } from \"../errors/warlock-error\";\nimport { connectorsManager } from \"./connectors-manager\";\nimport type { Connector } from \"./types\";\n\nexport function assertNoReservedConnectorNames(connectors: Connector[]): void {\n  const reserved = connectors\n    .map((connector) => connector.name)\n    .filter((name) => connectorsManager.isBuiltInName(name));\n\n  if (reserved.length === 0) return;\n\n  const unique = [...new Set(reserved)];\n  const names = unique.map((name) => JSON.stringify(name)).join(\", \");\n  const subject = unique.length === 1 ? \"name is\" : \"names are\";\n  const object = unique.length === 1 ? \"it\" : \"one of them\";\n\n  throw new WarlockError(\n    \"WL1009\",\n    `The following connector ${subject} reserved by a framework built-in connector: [${names}].\\n` +\n      \"Every connector name must be unique, and the framework already registers a built-in connector under \" +\n      `${unique.length === 1 ? \"that name\" : \"those names\"}, so a custom connector carrying ${object} ` +\n      \"would be built for and then never booted. \" +\n      \"Rename the custom connector in `warlock.config.ts > connectors` to a name of your own.\",\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,+BAA+B,YAA+B;CAC5E,MAAM,WAAW,WACd,KAAK,cAAc,UAAU,IAAI,CAAC,CAClC,QAAQ,SAAS,kBAAkB,cAAc,IAAI,CAAC;CAEzD,IAAI,SAAS,WAAW,GAAG;CAE3B,MAAM,SAAS,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC;CACpC,MAAM,QAAQ,OAAO,KAAK,SAAS,KAAK,UAAU,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI;CAClE,MAAM,UAAU,OAAO,WAAW,IAAI,YAAY;CAClD,MAAM,SAAS,OAAO,WAAW,IAAI,OAAO;CAE5C,MAAM,IAAI,aACR,UACA,2BAA2B,QAAQ,gDAAgD,MAAM,0GAEpF,OAAO,WAAW,IAAI,cAAc,cAAc,mCAAmC,OAAO,oIAGnG;AACF"}

package/esm/connectors/assert-unique-connector-names.d.mts

@@ -1,6 +1,6 @@
 import { Connector } from "./types.mjs";
 
-//#region ../core/src/connectors/assert-unique-connector-names.d.ts
+//#region ../../packages/core/src/connectors/assert-unique-connector-names.d.ts
 declare function assertUniqueConnectorNames(connectors: Connector[]): void;
 //#endregion
 export { assertUniqueConnectorNames };

package/esm/connectors/assert-unique-connector-names.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"assert-unique-connector-names.d.mts","names":[],"sources":["../../../../../../../core/src/connectors/assert-unique-connector-names.ts"],"mappings":";;;iBAyBgB,0BAAA,CAA2B,UAAuB,EAAX,SAAS"}
+{"version":3,"file":"assert-unique-connector-names.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/connectors/assert-unique-connector-names.ts"],"mappings":";;;iBA0BgB,0BAAA,CAA2B,UAAuB,EAAX,SAAS"}