c12 3.3.3 → 4.0.0-beta.2

package/README.md

@@ -12,11 +12,11 @@ c12 (pronounced as /siːtwelv/, like c-twelve) is a smart configuration loader.
 
 ## ✅ Features
 
-- `.js`, `.ts`, `.mjs`, `.cjs`, `.mts`, `.cts` `.json` config loader with [unjs/jiti](https://jiti.unjs.io)
+- `.js`, `.ts`, `.mjs`, `.cjs`, `.mts`, `.cts` `.json` config loader with customizable import or [unjs/jiti](https://jiti.unjs.io) fallback.
 - `.jsonc`, `.json5`, `.yaml`, `.yml`, `.toml` config loader with [unjs/confbox](https://confbox.unjs.io)
 - `.config/` directory support ([config dir proposal](https://github.com/pi0/config-dir))
 - `.rc` config support with [unjs/rc9](https://github.com/unjs/rc9)
-- `.env` support with [dotenv](https://www.npmjs.com/package/dotenv)
+- `.env` support with variable interpolation and `_FILE` references resolution
 - Multiple sources merged with [unjs/defu](https://github.com/unjs/defu)
 - Reads config from the nearest `package.json` file
 - [Extends configurations](https://github.com/unjs/c12#extending-configuration) from multiple local or git sources
@@ -139,6 +139,25 @@ console.log(config.config.connectionPoolMax); // "10"
 console.log(config.config.databaseURL); // "<...localhost...>"
 ```
 
+#### `expandFileReferences`
+
+Enabled by default. Environment variables ending with `_FILE` are resolved by reading the file at the specified path and assigning its trimmed content to the base key (without the `_FILE` suffix). This is useful for container secrets (e.g. Docker, Kubernetes) where sensitive values are mounted as files. Set to `false` to disable.
+
+```ini
+# .env
+DATABASE_PASSWORD_FILE="/run/secrets/db_password"
+```
+
+```ts
+import { loadConfig } from "c12";
+
+const config = await loadConfig({
+  dotenv: true,
+});
+
+// DATABASE_PASSWORD is now set to the contents of /run/secrets/db_password
+```
+
 ### `packageJson`
 
 Loads config from nearest `package.json` file. It is disabled by default.
@@ -163,13 +182,35 @@ Specify override configuration. It has the **highest** priority and is applied *
 
 Exclude environment-specific and built-in keys start with `$` in the resolved config. The default is `false`.
 
-### `jiti`
+### `import`
 
-Custom [unjs/jiti](https://github.com/unjs/jiti) instance used to import configuration files.
+Custom import function used to load configuration files. By default, c12 uses native `import()` with [unjs/jiti](https://github.com/unjs/jiti) as fallback.
 
-### `jitiOptions`
+**Example:** Using a custom [jiti](https://github.com/unjs/jiti) instance with options:
 
-Custom [unjs/jiti](https://github.com/unjs/jiti) options to import configuration files.
+```js
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  /* jiti options */
+});
+
+const { config } = await loadConfig({
+  import: (id) => jiti.import(id),
+});
+```
+
+### `resolveModule`
+
+Custom resolver for picking which export to use from the loaded module. Default: `(mod) => mod.default || mod`.
+
+**Example:** Using a named export:
+
+```js
+const { config } = await loadConfig({
+  resolveModule: (mod) => mod.myConfig,
+});
+```
 
 ### `giget`
 
@@ -295,6 +336,14 @@ Layers:
 
 ## Extending config layer from remote sources
 
+> [!NOTE]
+> Extending from remote sources requires the [`giget`](https://giget.unjs.io) peer dependency to be installed.
+>
+> ```sh
+> # ✨ Auto-detect
+> npx nypm install giget
+> ```
+
 You can also extend configuration from remote sources such as npm or github.
 
 In the repo, there should be a `config.ts` (or `config.{name}.ts`) file to be considered as a valid config layer.
@@ -364,6 +413,14 @@ export default {
 
 you can use `watchConfig` instead of `loadConfig` to load config and watch for changes, add and removals in all expected configuration paths and auto reload with new config.
 
+> [!NOTE]
+> Watching requires the [`chokidar`](https://github.com/paulmillr/chokidar) peer dependency to be installed.
+>
+> ```sh
+> # ✨ Auto-detect
+> npx nypm install chokidar
+> ```
+
 ### Lifecycle hooks
 
 - `onWatch`: This function is always called when config is updated, added, or removed before attempting to reload the config.

package/dist/THIRD-PARTY-LICENSES.md

@@ -0,0 +1,33 @@
+# Licenses of Bundled Dependencies
+
+The published artifact additionally contains code with the following licenses:
+MIT
+
+# Bundled Dependencies
+
+## ohash, perfect-debounce
+
+License: MIT
+Repositories: https://github.com/unjs/ohash, https://github.com/unjs/perfect-debounce
+
+> MIT License
+> 
+> Copyright (c) Pooya Parsa <pooya@pi0.io>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.

package/dist/_chunks/libs/ohash.d.mts

@@ -0,0 +1,30 @@
+//#region node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/utils/index.d.mts
+/**
+ * Calculates the difference between two objects and returns a list of differences.
+ *
+ * @param {any} obj1 - The first object to compare.
+ * @param {any} obj2 - The second object to compare.
+ * @param {HashOptions} [opts={}] - Configuration options for hashing the objects. See {@link HashOptions}.
+ * @returns {DiffEntry[]} An array with the differences between the two objects.
+ */
+declare function diff(obj1: any, obj2: any): DiffEntry[];
+declare class DiffEntry {
+  key: string;
+  type: "changed" | "added" | "removed";
+  newValue: DiffHashedObject;
+  oldValue?: DiffHashedObject | undefined;
+  constructor(key: string, type: "changed" | "added" | "removed", newValue: DiffHashedObject, oldValue?: DiffHashedObject | undefined);
+  toString(): string;
+  toJSON(): string;
+}
+declare class DiffHashedObject {
+  key: string;
+  value: any;
+  hash?: string | undefined;
+  props?: Record<string, DiffHashedObject> | undefined;
+  constructor(key: string, value: any, hash?: string | undefined, props?: Record<string, DiffHashedObject> | undefined);
+  toString(): string;
+  toJSON(): string;
+}
+//#endregion
+export { diff as t };

package/dist/_chunks/libs/ohash.mjs

@@ -0,0 +1,182 @@
+import "node:module";
+import { createHash } from "node:crypto";
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+function serialize(o) {
+	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
+}
+const c = /* @__PURE__ */ function() {
+	class o {
+		#t = /* @__PURE__ */ new Map();
+		compare(t, r) {
+			const e = typeof t, n = typeof r;
+			return e === "string" && n === "string" ? t.localeCompare(r) : e === "number" && n === "number" ? t - r : String.prototype.localeCompare.call(this.serialize(t, true), this.serialize(r, true));
+		}
+		serialize(t, r) {
+			if (t === null) return "null";
+			switch (typeof t) {
+				case "string": return r ? t : `'${t}'`;
+				case "bigint": return `${t}n`;
+				case "object": return this.$object(t);
+				case "function": return this.$function(t);
+			}
+			return String(t);
+		}
+		serializeObject(t) {
+			const r = Object.prototype.toString.call(t);
+			if (r !== "[object Object]") return this.serializeBuiltInType(r.length < 10 ? `unknown:${r}` : r.slice(8, -1), t);
+			const e = t.constructor, n = e === Object || e === void 0 ? "" : e.name;
+			if (n !== "" && globalThis[n] === e) return this.serializeBuiltInType(n, t);
+			if (typeof t.toJSON == "function") {
+				const i = t.toJSON();
+				return n + (i !== null && typeof i == "object" ? this.$object(i) : `(${this.serialize(i)})`);
+			}
+			return this.serializeObjectEntries(n, Object.entries(t));
+		}
+		serializeBuiltInType(t, r) {
+			const e = this["$" + t];
+			if (e) return e.call(this, r);
+			if (typeof r?.entries == "function") return this.serializeObjectEntries(t, r.entries());
+			throw new Error(`Cannot serialize ${t}`);
+		}
+		serializeObjectEntries(t, r) {
+			const e = Array.from(r).sort((i, a) => this.compare(i[0], a[0]));
+			let n = `${t}{`;
+			for (let i = 0; i < e.length; i++) {
+				const [a, l] = e[i];
+				n += `${this.serialize(a, true)}:${this.serialize(l)}`, i < e.length - 1 && (n += ",");
+			}
+			return n + "}";
+		}
+		$object(t) {
+			let r = this.#t.get(t);
+			return r === void 0 && (this.#t.set(t, `#${this.#t.size}`), r = this.serializeObject(t), this.#t.set(t, r)), r;
+		}
+		$function(t) {
+			const r = Function.prototype.toString.call(t);
+			return r.slice(-15) === "[native code] }" ? `${t.name || ""}()[native]` : `${t.name}(${t.length})${r.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(t) {
+			let r = "[";
+			for (let e = 0; e < t.length; e++) r += this.serialize(t[e]), e < t.length - 1 && (r += ",");
+			return r + "]";
+		}
+		$Date(t) {
+			try {
+				return `Date(${t.toISOString()})`;
+			} catch {
+				return "Date(null)";
+			}
+		}
+		$ArrayBuffer(t) {
+			return `ArrayBuffer[${new Uint8Array(t).join(",")}]`;
+		}
+		$Set(t) {
+			return `Set${this.$Array(Array.from(t).sort((r, e) => this.compare(r, e)))}`;
+		}
+		$Map(t) {
+			return this.serializeObjectEntries("Map", t.entries());
+		}
+	}
+	for (const s of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}(${t})`;
+	};
+	for (const s of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join(",")}]`;
+	};
+	for (const s of ["BigInt64Array", "BigUint64Array"]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join("n,")}${t.length > 0 ? "n" : ""}]`;
+	};
+	return o;
+}();
+const e = globalThis.process?.getBuiltinModule?.("crypto")?.hash, r = "sha256", s = "base64url";
+function digest(t) {
+	if (e) return e(r, t, s);
+	const o = createHash(r).update(t);
+	return globalThis.process?.versions?.webcontainer ? o.digest().toString(s) : o.digest(s);
+}
+var dist_exports = /* @__PURE__ */ __exportAll({ digest: () => digest });
+var utils_exports = /* @__PURE__ */ __exportAll({ diff: () => diff });
+function diff(obj1, obj2) {
+	return _diff(_toHashedObject(obj1), _toHashedObject(obj2));
+}
+function _diff(h1, h2) {
+	const diffs = [];
+	const allProps = /* @__PURE__ */ new Set([...Object.keys(h1.props || {}), ...Object.keys(h2.props || {})]);
+	if (h1.props && h2.props) for (const prop of allProps) {
+		const p1 = h1.props[prop];
+		const p2 = h2.props[prop];
+		if (p1 && p2) diffs.push(..._diff(h1.props?.[prop], h2.props?.[prop]));
+		else if (p1 || p2) diffs.push(new DiffEntry((p2 || p1).key, p1 ? "removed" : "added", p2, p1));
+	}
+	if (allProps.size === 0 && h1.hash !== h2.hash) diffs.push(new DiffEntry((h2 || h1).key, "changed", h2, h1));
+	return diffs;
+}
+function _toHashedObject(obj, key = "") {
+	if (obj && typeof obj !== "object") return new DiffHashedObject(key, obj, serialize(obj));
+	const props = {};
+	const hashes = [];
+	for (const _key in obj) {
+		props[_key] = _toHashedObject(obj[_key], key ? `${key}.${_key}` : _key);
+		hashes.push(props[_key].hash);
+	}
+	return new DiffHashedObject(key, obj, `{${hashes.join(":")}}`, props);
+}
+var DiffEntry = class {
+	constructor(key, type, newValue, oldValue) {
+		this.key = key;
+		this.type = type;
+		this.newValue = newValue;
+		this.oldValue = oldValue;
+	}
+	toString() {
+		return this.toJSON();
+	}
+	toJSON() {
+		switch (this.type) {
+			case "added": return `Added   \`${this.key}\``;
+			case "removed": return `Removed \`${this.key}\``;
+			case "changed": return `Changed \`${this.key}\` from \`${this.oldValue?.toString() || "-"}\` to \`${this.newValue.toString()}\``;
+		}
+	}
+};
+var DiffHashedObject = class {
+	constructor(key, value, hash, props) {
+		this.key = key;
+		this.value = value;
+		this.hash = hash;
+		this.props = props;
+	}
+	toString() {
+		if (this.props) return `{${Object.keys(this.props).join(",")}}`;
+		else return JSON.stringify(this.value);
+	}
+	toJSON() {
+		const k = this.key || ".";
+		if (this.props) return `${k}({${Object.keys(this.props).join(",")}})`;
+		return `${k}(${this.value})`;
+	}
+};
+export { dist_exports as n, utils_exports as t };

package/dist/_chunks/libs/perfect-debounce.mjs

@@ -0,0 +1,68 @@
+const DEBOUNCE_DEFAULTS = { trailing: true };
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+export { debounce as t };

package/dist/index.d.mts

@@ -1,7 +1,6 @@
-import { Jiti, JitiOptions } from "jiti";
+import { t as diff } from "./_chunks/libs/ohash.mjs";
 import { ChokidarOptions } from "chokidar";
 import { DownloadTemplateOptions } from "giget";
-import { diff } from "ohash/utils";
 
 //#region src/dotenv.d.ts
 interface DotenvOptions {
@@ -32,6 +31,22 @@ interface DotenvOptions {
    * An object describing environment variables (key, value pairs).
    */
   env?: NodeJS.ProcessEnv;
+  /**
+   * Resolve `_FILE` suffixed environment variables by reading the file at the
+   * specified path and assigning its trimmed content to the base key.
+   *
+   * This is useful for container secrets (e.g. Docker, Kubernetes) where
+   * sensitive values are mounted as files.
+   *
+   * @default true
+   *
+   * @example
+   * ```env
+   * DATABASE_PASSWORD_FILE="/run/secrets/db_password"
+   * # resolves to DATABASE_PASSWORD=<contents of /run/secrets/db_password>
+   * ```
+   */
+  expandFileReferences?: boolean;
 }
 type Env = typeof process.env;
 /**
@@ -125,8 +140,10 @@ interface LoadConfigOptions<T extends UserInputConfig = UserInputConfig, MT exte
   /** Context passed to config functions */
   context?: ConfigFunctionContext;
   resolve?: (id: string, options: LoadConfigOptions<T, MT>) => null | undefined | ResolvedConfig<T, MT> | Promise<ResolvedConfig<T, MT> | undefined | null>;
-  jiti?: Jiti;
-  jitiOptions?: JitiOptions;
+  /** Custom import function used to load configuration files */
+  import?: (id: string) => Promise<unknown>;
+  /** Custom resolver for picking which export to use from the loaded module. Default: `(mod) => mod.default || mod` */
+  resolveModule?: (mod: any) => any;
   giget?: false | DownloadTemplateOptions;
   merger?: (...sources: Array<T | null | undefined>) => T;
   extend?: false | {
@@ -167,4 +184,4 @@ interface WatchConfigOptions<T extends UserInputConfig = UserInputConfig, MT ext
 }
 declare function watchConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta>(options: WatchConfigOptions<T, MT>): Promise<ConfigWatcher<T, MT>>;
 //#endregion
-export { C12InputConfig, ConfigFunctionContext, ConfigLayer, ConfigLayerMeta, ConfigSource, ConfigWatcher, DefineConfig, DotenvOptions, Env, InputConfig, LoadConfigOptions, ResolvableConfig, ResolvableConfigContext, ResolvedConfig, SUPPORTED_EXTENSIONS, SourceOptions, UserInputConfig, WatchConfigOptions, createDefineConfig, loadConfig, loadDotenv, setupDotenv, watchConfig };
+export { C12InputConfig, ConfigFunctionContext, ConfigLayer, ConfigLayerMeta, ConfigSource, type ConfigWatcher, DefineConfig, type DotenvOptions, type Env, InputConfig, LoadConfigOptions, ResolvableConfig, ResolvableConfigContext, ResolvedConfig, SUPPORTED_EXTENSIONS, SourceOptions, UserInputConfig, type WatchConfigOptions, createDefineConfig, loadConfig, loadDotenv, setupDotenv, watchConfig };

package/dist/index.mjs

@@ -1,29 +1,22 @@
-import { existsSync, promises, statSync } from "node:fs";
+import { t as debounce } from "./_chunks/libs/perfect-debounce.mjs";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import * as nodeUtil from "node:util";
 import { basename, dirname, extname, join, normalize, resolve } from "pathe";
-import * as dotenv from "dotenv";
 import { readFile, rm } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { homedir } from "node:os";
 import { resolveModulePath } from "exsolve";
-import { createJiti } from "jiti";
 import * as rc9 from "rc9";
 import { defu } from "defu";
 import { findWorkspaceDir, readPackageJSON } from "pkg-types";
-import { debounce } from "perfect-debounce";
-
-//#region src/dotenv.ts
-/**
-* Load and interpolate environment variables into `process.env`.
-* If you need more control (or access to the values), consider using `loadDotenv` instead
-*
-*/
 async function setupDotenv(options) {
 	const targetEnvironment = options.env ?? process.env;
 	const environment = await loadDotenv({
 		cwd: options.cwd,
 		fileName: options.fileName ?? ".env",
 		env: targetEnvironment,
-		interpolate: options.interpolate ?? true
+		interpolate: options.interpolate ?? true,
+		expandFileReferences: options.expandFileReferences ?? true
 	});
 	const dotenvVars = getDotEnvVars(targetEnvironment);
 	for (const key in environment) {
@@ -32,7 +25,6 @@ async function setupDotenv(options) {
 	}
 	return environment;
 }
-/** Load environment variables into an object. */
 async function loadDotenv(options) {
 	const environment = Object.create(null);
 	const cwd = resolve(options.cwd || ".");
@@ -43,29 +35,52 @@ async function loadDotenv(options) {
 	for (const file of dotenvFiles) {
 		const dotenvFile = resolve(cwd, file);
 		if (!statSync(dotenvFile, { throwIfNoEntry: false })?.isFile()) continue;
-		const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8"));
+		const parsed = await readEnvFile(dotenvFile);
 		for (const key in parsed) {
 			if (key in environment && !dotenvVars.has(key)) continue;
 			environment[key] = parsed[key];
 			dotenvVars.add(key);
 		}
 	}
+	if (options.expandFileReferences !== false) {
+		for (const key in environment) if (key.endsWith("_FILE")) {
+			const targetKey = key.slice(0, -5);
+			if (environment[targetKey] === void 0) {
+				const filePath = environment[key];
+				if (filePath && statSync(filePath, { throwIfNoEntry: false })?.isFile()) {
+					environment[targetKey] = readFileSync(filePath, "utf8").trim();
+					dotenvVars.add(targetKey);
+				}
+			}
+		}
+	}
 	if (options.interpolate) interpolate(environment);
 	return environment;
 }
+let _parseEnv = nodeUtil.parseEnv;
+async function readEnvFile(path) {
+	const src = readFileSync(path, "utf8");
+	if (!_parseEnv) try {
+		const dotenv = await import("dotenv");
+		_parseEnv = (src) => dotenv.parse(src);
+	} catch {
+		throw new Error("Failed to parse .env file: `node:util.parseEnv` is not available and `dotenv` package is not installed. Please upgrade your runtime or install `dotenv` as a dependency.");
+	}
+	return _parseEnv(src);
+}
 function interpolate(target, source = {}, parse = (v) => v) {
 	function getValue(key) {
 		return source[key] === void 0 ? target[key] : source[key];
 	}
-	function interpolate$1(value, parents = []) {
+	function interpolate(value, parents = []) {
 		if (typeof value !== "string") return value;
 		return parse((value.match(/(.?\${?(?:[\w:]+)?}?)/g) || []).reduce((newValue, match) => {
 			const parts = /(.?)\${?([\w:]+)?}?/g.exec(match) || [];
 			const prefix = parts[1];
-			let value$1, replacePart;
+			let value, replacePart;
 			if (prefix === "\\") {
 				replacePart = parts[0] || "";
-				value$1 = replacePart.replace(String.raw`\$`, "$");
+				value = replacePart.replace(String.raw`\$`, "$");
 			} else {
 				const key = parts[2];
 				replacePart = (parts[0] || "").slice(prefix.length);
@@ -73,22 +88,19 @@ function interpolate(target, source = {}, parse = (v) => v) {
 					console.warn(`Please avoid recursive environment variables ( loop: ${parents.join(" > ")} > ${key} )`);
 					return "";
 				}
-				value$1 = getValue(key);
-				value$1 = interpolate$1(value$1, [...parents, key]);
+				value = getValue(key);
+				value = interpolate(value, [...parents, key]);
 			}
-			return value$1 === void 0 ? newValue : newValue.replace(replacePart, value$1);
+			return value === void 0 ? newValue : newValue.replace(replacePart, value);
 		}, value));
 	}
-	for (const key in target) target[key] = interpolate$1(getValue(key));
+	for (const key in target) target[key] = interpolate(getValue(key));
 }
 function getDotEnvVars(targetEnvironment) {
 	const globalRegistry = globalThis.__c12_dotenv_vars__ ||= /* @__PURE__ */ new Map();
 	if (!globalRegistry.has(targetEnvironment)) globalRegistry.set(targetEnvironment, /* @__PURE__ */ new Set());
 	return globalRegistry.get(targetEnvironment);
 }
-
-//#endregion
-//#region src/loader.ts
 const _normalize = (p) => p?.replace(/\\/g, "/");
 const ASYNC_LOADERS = {
 	".yaml": () => import("confbox/yaml").then((r) => r.parseYAML),
@@ -122,12 +134,6 @@ async function loadConfig(options) {
 		...options.extend
 	};
 	const _merger = options.merger || defu;
-	options.jiti = options.jiti || createJiti(join(options.cwd, options.configFile), {
-		interopDefault: true,
-		moduleCache: false,
-		extensions: [...SUPPORTED_EXTENSIONS],
-		...options.jitiOptions
-	});
 	const r = {
 		config: {},
 		cwd: options.cwd,
@@ -274,15 +280,17 @@ const GIGET_PREFIXES = [
 const NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/;
 async function resolveConfig(source, options, sourceOptions = {}) {
 	if (options.resolve) {
-		const res$1 = await options.resolve(source, options);
-		if (res$1) return res$1;
+		const res = await options.resolve(source, options);
+		if (res) return res;
 	}
 	const _merger = options.merger || defu;
 	const customProviderKeys = Object.keys(sourceOptions.giget?.providers || {}).map((key) => `${key}:`);
 	const gigetPrefixes = customProviderKeys.length > 0 ? [...new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
 	if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
-		const { downloadTemplate } = await import("giget");
-		const { digest } = await import("ohash");
+		const { downloadTemplate } = await import("giget").catch((error) => {
+			throw new Error(`Extending config from \`${source}\` requires \`giget\` peer dependency to be installed.\n\nInstall it with: \`npx nypm i giget\``, { cause: error });
+		});
+		const { digest } = await import("./_chunks/libs/ohash.mjs").then((n) => n.n);
 		const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
 		let cloneDir;
 		const localNodeModules = resolve(options.cwd, "node_modules");
@@ -317,7 +325,22 @@ async function resolveConfig(source, options, sourceOptions = {}) {
 	res._configFile = res.configFile;
 	const configFileExt = extname(res.configFile) || "";
 	if (configFileExt in ASYNC_LOADERS) res.config = (await ASYNC_LOADERS[configFileExt]())(await readFile(res.configFile, "utf8"));
-	else res.config = await options.jiti.import(res.configFile, { default: true });
+	else {
+		const _resolveModule = options.resolveModule || ((mod) => mod.default || mod);
+		if (options.import) res.config = _resolveModule(await options.import(res.configFile));
+		else res.config = await import(res.configFile).then(_resolveModule, async (error) => {
+			const { createJiti } = await import("jiti").catch(() => {
+				throw new Error(`Failed to load config file \`${res.configFile}\`: ${error?.message}.  Hint install \`jiti\` for compatibility.`, { cause: error });
+			});
+			const jiti = createJiti(join(options.cwd || ".", options.configFile || "/"), {
+				interopDefault: true,
+				moduleCache: false,
+				extensions: [...SUPPORTED_EXTENSIONS]
+			});
+			options.import = (id) => jiti.import(id);
+			return _resolveModule(await options.import(res.configFile));
+		});
+	}
 	if (typeof res.config === "function") res.config = await res.config(options.context);
 	if (options.envName) {
 		const envConfig = {
@@ -343,15 +366,9 @@ function tryResolve(id, options) {
 	});
 	return res ? normalize(res) : void 0;
 }
-
-//#endregion
-//#region src/types.ts
 function createDefineConfig() {
 	return (input) => input;
 }
-
-//#endregion
-//#region src/watch.ts
 const eventMap = {
 	add: "created",
 	change: "updated",
@@ -372,7 +389,7 @@ async function watchConfig(options) {
 		options.packageJson && resolve(l.cwd, "package.json")
 	]).filter(Boolean))];
 	const watch = await import("chokidar").then((r) => r.watch || r.default || r);
-	const { diff } = await import("ohash/utils");
+	const { diff } = await import("./_chunks/libs/ohash.mjs").then((n) => n.t);
 	const _fswatcher = watch(watchingFiles, {
 		ignoreInitial: true,
 		...options.chokidarOptions
@@ -414,6 +431,4 @@ async function watchConfig(options) {
 		return config[prop];
 	} });
 }
-
-//#endregion
-export { SUPPORTED_EXTENSIONS, createDefineConfig, loadConfig, loadDotenv, setupDotenv, watchConfig };
+export { SUPPORTED_EXTENSIONS, createDefineConfig, loadConfig, loadDotenv, setupDotenv, watchConfig };

package/dist/update.d.mts

@@ -1,4 +1,4 @@
-import * as magicast0 from "magicast";
+import * as magicast from "magicast";
 
 //#region src/update.d.ts
 /**
@@ -10,7 +10,7 @@ interface UpdateConfigResult {
   created?: boolean;
 }
 type MaybePromise<T> = T | Promise<T>;
-type MagicAstOptions = Exclude<Parameters<(typeof magicast0)["parseModule"]>[1], undefined>;
+type MagicAstOptions = Exclude<Parameters<(typeof magicast)["parseModule"]>[1], undefined>;
 interface UpdateConfigOptions {
   /**
    * Current working directory

package/dist/update.mjs

@@ -4,13 +4,10 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import "node:url";
 import "node:os";
 import { join, normalize } from "pathe";
-import "jiti";
 import "rc9";
 import "defu";
 import "pkg-types";
 import { dirname, extname } from "node:path";
-
-//#region src/loader.ts
 const SUPPORTED_EXTENSIONS = Object.freeze([
 	".js",
 	".ts",
@@ -25,9 +22,6 @@ const SUPPORTED_EXTENSIONS = Object.freeze([
 	".yml",
 	".toml"
 ]);
-
-//#endregion
-//#region src/update.ts
 const UPDATABLE_EXTS = [
 	".js",
 	".ts",
@@ -36,9 +30,6 @@ const UPDATABLE_EXTS = [
 	".mts",
 	".cts"
 ];
-/**
-* @experimental Update a config file or create a new one.
-*/
 async function updateConfig(opts) {
 	const { parseModule } = await import("magicast");
 	let configFile = tryResolve(`./${opts.configFile}`, opts.cwd, SUPPORTED_EXTENSIONS) || tryResolve(`./.config/${opts.configFile}`, opts.cwd, SUPPORTED_EXTENSIONS) || tryResolve(`./.config/${opts.configFile.split(".")[0]}`, opts.cwd, SUPPORTED_EXTENSIONS);
@@ -75,6 +66,4 @@ function tryResolve(path, cwd, extensions) {
 	});
 	return res ? normalize(res) : void 0;
 }
-
-//#endregion
-export { updateConfig };
+export { updateConfig };

package/package.json

@@ -1,69 +1,80 @@
 {
   "name": "c12",
-  "version": "3.3.3",
+  "version": "4.0.0-beta.2",
   "description": "Smart Config Loader",
-  "repository": "unjs/c12",
   "license": "MIT",
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
-    },
-    "./update": {
-      "types": "./dist/update.d.mts",
-      "default": "./dist/update.mjs"
-    }
-  },
-  "types": "./dist/index.d.mts",
+  "repository": "unjs/c12",
   "files": [
     "dist"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./update": "./dist/update.mjs"
+  },
   "scripts": {
     "build": "obuild",
     "dev": "vitest dev",
-    "lint": "eslint . && prettier -c src test",
-    "lint:fix": "automd && eslint . --fix && prettier -w src test",
-    "release": "pnpm build && pnpm test && changelogen --release --push --publish",
+    "lint": "oxlint . && oxfmt --check src test",
+    "lint:fix": "automd && oxlint . --fix && oxfmt src test",
+    "release": "pnpm test && pnpm build && changelogen --release --prerelease --publish && git push --follow-tags",
     "test": "pnpm lint && vitest run --coverage && pnpm test:types",
-    "test:types": "tsc --noEmit"
+    "test:types": "tsgo --noEmit"
   },
   "dependencies": {
-    "chokidar": "^5.0.0",
-    "confbox": "^0.2.2",
+    "confbox": "^0.2.4",
     "defu": "^6.1.4",
-    "dotenv": "^17.2.3",
     "exsolve": "^1.0.8",
-    "giget": "^2.0.0",
-    "jiti": "^2.6.1",
-    "ohash": "^2.0.11",
     "pathe": "^2.0.3",
-    "perfect-debounce": "^2.0.0",
     "pkg-types": "^2.3.0",
-    "rc9": "^2.1.2"
+    "rc9": "^3.0.0"
   },
   "devDependencies": {
-    "@types/node": "^25.0.2",
-    "@vitest/coverage-v8": "^4.0.15",
-    "automd": "^0.4.2",
+    "@types/node": "^25.2.1",
+    "@typescript/native-preview": "^7.0.0-dev.20260206.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "automd": "^0.4.3",
     "changelogen": "^0.6.2",
-    "eslint": "^9.39.2",
-    "eslint-config-unjs": "^0.5.0",
+    "chokidar": "^5.0.0",
+    "dotenv": "^17.2.4",
+    "eslint-config-unjs": "^0.6.2",
     "expect-type": "^1.3.0",
-    "magicast": "^0.5.1",
-    "obuild": "^0.4.8",
-    "prettier": "^3.7.4",
+    "giget": "^3.1.2",
+    "jiti": "^2.6.1",
+    "magicast": "^0.5.2",
+    "obuild": "^0.4.27",
+    "ohash": "^2.0.11",
+    "oxfmt": "^0.28.0",
+    "oxlint": "^1.43.0",
+    "perfect-debounce": "^2.1.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.15"
+    "vitest": "^4.0.18"
   },
   "peerDependencies": {
+    "chokidar": "^5",
+    "dotenv": "*",
+    "giget": "*",
+    "jiti": "*",
     "magicast": "*"
   },
   "peerDependenciesMeta": {
+    "dotenv": {
+      "optional": true
+    },
     "magicast": {
       "optional": true
+    },
+    "chokidar": {
+      "optional": true
+    },
+    "jiti": {
+      "optional": true
+    },
+    "giget": {
+      "optional": true
     }
   },
-  "packageManager": "pnpm@10.26.0"
+  "packageManager": "pnpm@10.28.2"
 }