limina 0.1.3 → 0.2.0

package/chunks/{dep-BizOzD0V.js → dep-D63Sc9OL.js}

@@ -6,16 +6,14 @@ import { pathToFileURL } from "node:url";
 function uniqueValues(values) {
 	return [...new Set(values)];
 }
-function uniqueBy(values, getKey) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
+function countDefinedBy(values, getKey) {
+	const counts = /* @__PURE__ */ new Map();
 	for (const value of values) {
 		const key = getKey(value);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		result.push(value);
+		if (!key) continue;
+		counts.set(key, (counts.get(key) ?? 0) + 1);
 	}
-	return result;
+	return counts;
 }
 function uniqueSortedStrings(values) {
 	return uniqueValues(values).sort((left, right) => left.localeCompare(right));
@@ -605,6 +603,11 @@ function getNativeTypeScriptProjectExtensions() {
 	};
 	return normalizeExtensions(flattenTypeScriptExtensionGroups(api.getSupportedExtensionsWithJsonIfResolveJsonModule(options, api.getSupportedExtensions(options))));
 }
+/** Uses the active compiler's supported-extension metadata, not a hard-coded list. */
+function isNativeTypeScriptProjectInput(fileName) {
+	const normalizedFileName = fileName.toLowerCase();
+	return getNativeTypeScriptProjectExtensions().some((extension) => normalizedFileName.endsWith(extension.toLowerCase()));
+}
 function getBuildCheckerSupportedExtensions(preset) {
 	const adapter = getCheckerAdapter(preset);
 	if (!adapter || adapter.execution !== "build") return [];
@@ -615,6 +618,18 @@ function getSvelteCheckerExtensions() {
 	return normalizeExtensions([...getTypeScriptCheckerExtensions(), ".svelte"]);
 }
 const parsedProjectConfigCache = /* @__PURE__ */ new Map();
+function createProjectParseHost(virtualFiles) {
+	if (!virtualFiles) return ts.sys;
+	return {
+		...ts.sys,
+		fileExists(fileName) {
+			return virtualFiles.has(normalizeAbsolutePath(fileName)) || ts.sys.fileExists(fileName);
+		},
+		readFile(fileName, encoding) {
+			return virtualFiles.get(normalizeAbsolutePath(fileName)) ?? ts.sys.readFile(fileName, encoding);
+		}
+	};
+}
 function createFormatHost(rootDir) {
 	return {
 		getCanonicalFileName: (fileName) => fileName,
@@ -624,8 +639,9 @@ function createFormatHost(rootDir) {
 }
 function readTypeScriptProjectConfig(options) {
 	const diagnostics = [];
+	const host = createProjectParseHost(options.virtualFiles);
 	const parsed = ts.getParsedCommandLineOfConfigFile(options.configPath, {}, {
-		...ts.sys,
+		...host,
 		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
 			diagnostics.push(diagnostic);
 		}
@@ -654,19 +670,18 @@ function resolveContextCheckerPresets(context) {
 	return context.checkerPresets.length > 0 ? uniqueSortedStrings(context.checkerPresets) : ["tsc"];
 }
 function createParsedProjectConfigCacheKey(options) {
-	const configStat = statSync(options.configPath);
+	const normalizedConfigPath = normalizeAbsolutePath(options.configPath);
+	const virtualContent = options.virtualFiles?.get(normalizedConfigPath);
+	const configStat = virtualContent === void 0 ? statSync(options.configPath) : null;
 	return JSON.stringify({
 		checkerPresets: options.checkerPresets,
-		configPath: normalizeAbsolutePath(options.configPath),
-		configSize: configStat.size,
-		configTime: configStat.mtimeMs,
+		configPath: normalizedConfigPath,
+		configSize: virtualContent?.length ?? configStat?.size,
+		configTime: virtualContent ?? configStat?.mtimeMs,
 		extensions: normalizeExtensions(options.extensions),
 		projectRootDir: normalizeAbsolutePath(options.projectRootDir)
 	});
 }
-function clearCheckerProjectConfigCache() {
-	parsedProjectConfigCache.clear();
-}
 function createExtraFileExtensions(extensions) {
 	const nativeExtensions = new Set(getNativeTypeScriptProjectExtensions());
 	return extensions.filter((extension) => !nativeExtensions.has(extension)).map((extension) => ({
@@ -677,8 +692,9 @@ function createExtraFileExtensions(extensions) {
 }
 function parseProjectConfigWithExtraFileExtensions(options, extensions) {
 	const diagnostics = [];
+	const host = createProjectParseHost(options.virtualFiles);
 	const parsed = ts.getParsedCommandLineOfConfigFile(options.configPath, {}, {
-		...ts.sys,
+		...host,
 		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
 			diagnostics.push(diagnostic);
 		}
@@ -743,7 +759,7 @@ function createVueParsedCommandLine(options) {
 	});
 	const configPath = normalizeAbsolutePath(options.configPath);
 	return {
-		commandLine: vueLanguageCore.createParsedCommandLine(ts, ts.sys, configPath),
+		commandLine: vueLanguageCore.createParsedCommandLine(ts, createProjectParseHost(options.virtualFiles), configPath),
 		configPath,
 		vueLanguageCore
 	};
@@ -752,7 +768,8 @@ function resolveVueProjectExtensions(options, packageName) {
 	const { commandLine, vueLanguageCore } = createVueParsedCommandLine({
 		configPath: options.configPath,
 		packageName,
-		projectRootDir: options.projectRootDir
+		projectRootDir: options.projectRootDir,
+		virtualFiles: options.virtualFiles
 	});
 	try {
 		return normalizeExtensions([...getTypeScriptCheckerExtensions(), ...vueLanguageCore.getAllExtensions(commandLine.vueOptions)]);
@@ -773,15 +790,17 @@ function parseVueProjectConfig(options, packageName) {
 	const { commandLine, configPath, vueLanguageCore } = createVueParsedCommandLine({
 		configPath: options.configPath,
 		packageName,
-		projectRootDir: options.projectRootDir
+		projectRootDir: options.projectRootDir,
+		virtualFiles: options.virtualFiles
 	});
 	const extensions = normalizeExtensions([
 		...options.extensions ?? [],
 		...getTypeScriptCheckerExtensions(),
 		...vueLanguageCore.getAllExtensions(commandLine.vueOptions)
 	]);
-	const configFile = ts.readJsonConfigFile(configPath, ts.sys.readFile);
-	const parsed = ts.parseJsonSourceFileConfigFileContent(configFile, ts.sys, posix.dirname(configPath), {}, configPath, void 0, createExtraFileExtensions(extensions));
+	const host = createProjectParseHost(options.virtualFiles);
+	const configFile = ts.readJsonConfigFile(configPath, host.readFile);
+	const parsed = ts.parseJsonSourceFileConfigFileContent(configFile, host, posix.dirname(configPath), {}, configPath, void 0, createExtraFileExtensions(extensions));
 	const errors = parsed.errors;
 	if (errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(errors, createFormatHost(options.projectRootDir)));
 	return createParsedCheckerProjectConfig({
@@ -800,15 +819,26 @@ function resolveTypeScriptModuleName(options) {
 	return resolveTypeScriptModuleNameDetailed(options)?.resolvedFileName ?? null;
 }
 function resolveTypeScriptModuleNameDetailed(options) {
-	const resolved = ts.resolveModuleName(options.specifier, options.containingFile, options.compilerOptions, ts.sys).resolvedModule;
+	options.metrics?.record({
+		kind: "request",
+		name: "typescript-resolution",
+		provider: "module-resolution"
+	});
+	const nativeCacheHit = Boolean(options.moduleResolutionCache && ts.resolveModuleNameFromCache(options.specifier, options.containingFile, options.moduleResolutionCache) !== void 0);
+	options.metrics?.record({
+		kind: "module-resolution",
+		name: nativeCacheHit ? "typescript-module-resolution-cache-hit" : "typescript-module-resolution-cache-miss",
+		provider: "typescript"
+	});
+	const resolved = ts.resolveModuleName(options.specifier, options.containingFile, options.compilerOptions, ts.sys, options.moduleResolutionCache).resolvedModule;
 	if (resolved?.resolvedFileName) return {
 		isExternalLibraryImport: resolved.isExternalLibraryImport === true,
 		resolvedBy: "typescript",
 		resolvedFileName: normalizeAbsolutePath(resolved.resolvedFileName)
 	};
-	return resolveCheckerExtensionModuleName(options);
+	return resolveCheckerSourceModuleName(options);
 }
-function resolveCheckerExtensionModuleName(options) {
+function resolveCheckerSourceModuleName(options) {
 	const typeScriptExtensions = new Set(getTypeScriptCheckerExtensions());
 	const checkerOnlyExtensions = options.extensions.filter((extension) => !typeScriptExtensions.has(extension));
 	if (checkerOnlyExtensions.length === 0) return null;
@@ -825,9 +855,11 @@ function resolveCheckerExtensionModuleName(options) {
 		extensions: checkerOnlyExtensions,
 		specifier: options.specifier
 	});
-	return resolvedFileName ? {
+	const normalizedResolvedFileName = resolvedFileName?.toLowerCase();
+	const isDeclaredCheckerSource = checkerOnlyExtensions.some((extension) => normalizedResolvedFileName?.endsWith(extension.toLowerCase()));
+	return resolvedFileName && isDeclaredCheckerSource ? {
 		isExternalLibraryImport: false,
-		resolvedBy: "checker-extension",
+		resolvedBy: "checker-source",
 		resolvedFileName
 	} : null;
 }
@@ -916,7 +948,8 @@ function parseCheckerProjectConfigForContext(options) {
 		checkerPresets,
 		configPath: options.configPath,
 		extensions: options.context.extensions,
-		projectRootDir: options.projectRootDir
+		projectRootDir: options.projectRootDir,
+		virtualFiles: options.virtualFiles
 	});
 	const cached = parsedProjectConfigCache.get(cacheKey);
 	if (cached) return cloneParsedCheckerProjectConfig(cached);
@@ -926,35 +959,31 @@ function parseCheckerProjectConfigForContext(options) {
 		return adapter.parseProjectConfig({
 			configPath: options.configPath,
 			extensions: options.context.extensions,
-			projectRootDir: options.projectRootDir
+			projectRootDir: options.projectRootDir,
+			virtualFiles: options.virtualFiles
 		});
 	}), options.context.extensions);
 	parsedProjectConfigCache.set(cacheKey, cloneParsedCheckerProjectConfig(parsedConfig));
 	return cloneParsedCheckerProjectConfig(parsedConfig);
 }
-function resolveModuleNameWithCheckers(options) {
-	return resolveModuleNameWithCheckersDetailed(options)?.resolvedFileName ?? null;
-}
 function resolveModuleNameWithCheckersDetailed(options) {
-	const checkerPresets = options.context.checkerPresets.length > 0 ? options.context.checkerPresets : ["tsc"];
-	for (const preset of checkerPresets) {
-		if (!getCheckerAdapter(preset)) continue;
-		const resolved = resolveTypeScriptModuleNameDetailed({
-			compilerOptions: options.compilerOptions,
-			containingFile: options.containingFile,
-			extensions: options.context.extensions,
-			specifier: options.specifier
-		});
-		if (resolved) return resolved;
-	}
-	return null;
+	if (!(options.context.checkerPresets.length > 0 ? options.context.checkerPresets : ["tsc"]).some((preset) => Boolean(getCheckerAdapter(preset)))) return null;
+	return resolveTypeScriptModuleNameDetailed({
+		compilerOptions: options.compilerOptions,
+		containingFile: options.containingFile,
+		extensions: options.context.extensions,
+		metrics: options.metrics,
+		moduleResolutionCache: options.moduleResolutionCache,
+		specifier: options.specifier
+	});
 }
 function resolveCheckerProjectExtensions(options) {
 	const adapter = getCheckerAdapter(options.preset);
 	if (!adapter) throw new Error(`Checker preset "${options.preset}" is not supported.`);
 	return adapter.extensions({
 		configPath: options.configPath,
-		projectRootDir: options.projectRootDir
+		projectRootDir: options.projectRootDir,
+		virtualFiles: options.virtualFiles
 	});
 }
 function createTscCommandTarget(options) {
@@ -1029,6 +1058,7 @@ const builtinCheckerAdapters = {
 		createCommandTarget: createSvelteCheckCommandTarget,
 		extensions: (options) => resolveExtensionsForChecker(options, getSvelteCheckerExtensions()),
 		execution: "typecheck",
+		emitProjection: "typescript",
 		packageNames: ["svelte-check"],
 		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getSvelteCheckerExtensions()),
 		preset: "svelte-check",
@@ -1039,6 +1069,7 @@ const builtinCheckerAdapters = {
 		createCommandTarget: createTscCommandTarget,
 		extensions: (options) => resolveExtensionsForChecker(options, getTypeScriptCheckerExtensions()),
 		execution: "build",
+		emitProjection: "typescript",
 		packageNames: ["typescript"],
 		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getTypeScriptCheckerExtensions()),
 		preset: "tsc",
@@ -1049,6 +1080,7 @@ const builtinCheckerAdapters = {
 		createCommandTarget: createTsgoCommandTarget,
 		extensions: (options) => resolveExtensionsForChecker(options, getTypeScriptCheckerExtensions()),
 		execution: "build",
+		emitProjection: "typescript",
 		packageNames: ["@typescript/native-preview"],
 		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getTypeScriptCheckerExtensions()),
 		preset: "tsgo",
@@ -1059,6 +1091,7 @@ const builtinCheckerAdapters = {
 		createCommandTarget: createVueTscCommandTarget,
 		extensions: (options) => resolveVueProjectExtensionsForChecker(options, "vue-tsc"),
 		execution: "build",
+		emitProjection: "vue-bounded",
 		packageNames: ["vue-tsc"],
 		parseProjectConfig: (options) => parseVueProjectConfig(options, "vue-tsc"),
 		preset: "vue-tsc",
@@ -1069,6 +1102,7 @@ const builtinCheckerAdapters = {
 		createCommandTarget: createVueTsgoCommandTarget,
 		extensions: (options) => resolveVueProjectExtensionsForChecker(options, "vue-tsgo"),
 		execution: "typecheck",
+		emitProjection: "vue-bounded",
 		packageNames: ["vue-tsgo", "@typescript/native-preview"],
 		parseProjectConfig: (options) => parseVueProjectConfig(options, "vue-tsgo"),
 		preset: "vue-tsgo",
@@ -1082,6 +1116,19 @@ function isBuiltinCheckerPreset(value) {
 function getCheckerAdapter(preset) {
 	return isBuiltinCheckerPreset(preset) ? builtinCheckerAdapters[preset] : null;
 }
+const checkerBuildEngines = {
+	"svelte-check": "typecheck-only",
+	tsc: "tsc",
+	tsgo: "tsgo",
+	"vue-tsc": "vue-tsc",
+	"vue-tsgo": "typecheck-only"
+};
+function getCheckerBuildEngine(preset) {
+	return checkerBuildEngines[preset] ?? "unknown";
+}
+function isBuildCapablePreset(preset) {
+	return getCheckerAdapter(preset)?.execution === "build";
+}
 function isVueCheckerPreset(preset) {
 	return preset === "vue-tsc" || preset === "vue-tsgo";
 }
@@ -1255,6 +1302,17 @@ function cleanRegex(source) {
 	const end = source.endsWith("$") ? source.length - 1 : source.length;
 	return source.slice(start, end);
 }
+function floatSafeRemainder(val, step) {
+	const valDecCount = (val.toString().split(".")[1] || "").length;
+	const stepString = step.toString();
+	let stepDecCount = (stepString.split(".")[1] || "").length;
+	if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+		const match = stepString.match(/\d?e-(\d?)/);
+		if (match?.[1]) stepDecCount = Number.parseInt(match[1]);
+	}
+	const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+	return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
+}
 const EVALUATING = Symbol("evaluating");
 function defineLazy(object, key, getter) {
 	let value = void 0;
@@ -1353,7 +1411,13 @@ function optionalKeys(shape) {
 		return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
 	});
 }
-Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, -Number.MAX_VALUE, Number.MAX_VALUE;
+const NUMBER_FORMAT_RANGES = {
+	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+	int32: [-2147483648, 2147483647],
+	uint32: [0, 4294967295],
+	float32: [-34028234663852886e22, 34028234663852886e22],
+	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
 function pick(schema, mask) {
 	const currDef = schema._zod.def;
 	const checks = currDef.checks;
@@ -1670,6 +1734,8 @@ const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
 const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 	return _safeParseAsync(_Err)(schema, value, _ctx);
 };
+const integer = /^-?\d+$/;
+const number$1 = /^-?\d+(?:\.\d+)?$/;
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
 const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def) => {
@@ -1678,6 +1744,145 @@ const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def) => {
 	inst._zod.def = def;
 	(_a = inst._zod).onattach ?? (_a.onattach = []);
 });
+const numericOriginMap = {
+	number: "number",
+	bigint: "bigint",
+	object: "date"
+};
+const $ZodCheckLessThan = /*@__PURE__*/ $constructor("$ZodCheckLessThan", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const origin = numericOriginMap[typeof def.value];
+	inst._zod.onattach.push((inst) => {
+		const bag = inst._zod.bag;
+		const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+		if (def.value < curr) if (def.inclusive) bag.maximum = def.value;
+		else bag.exclusiveMaximum = def.value;
+	});
+	inst._zod.check = (payload) => {
+		if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
+		payload.issues.push({
+			origin,
+			code: "too_big",
+			maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckGreaterThan = /*@__PURE__*/ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const origin = numericOriginMap[typeof def.value];
+	inst._zod.onattach.push((inst) => {
+		const bag = inst._zod.bag;
+		const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+		if (def.value > curr) if (def.inclusive) bag.minimum = def.value;
+		else bag.exclusiveMinimum = def.value;
+	});
+	inst._zod.check = (payload) => {
+		if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
+		payload.issues.push({
+			origin,
+			code: "too_small",
+			minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckMultipleOf = /*@__PURE__*/ $constructor("$ZodCheckMultipleOf", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	inst._zod.onattach.push((inst) => {
+		var _a;
+		(_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
+	});
+	inst._zod.check = (payload) => {
+		if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
+		if (typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0) return;
+		payload.issues.push({
+			origin: typeof payload.value,
+			code: "not_multiple_of",
+			divisor: def.value,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	def.format = def.format || "float64";
+	const isInt = def.format?.includes("int");
+	const origin = isInt ? "int" : "number";
+	const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+	inst._zod.onattach.push((inst) => {
+		const bag = inst._zod.bag;
+		bag.format = def.format;
+		bag.minimum = minimum;
+		bag.maximum = maximum;
+		if (isInt) bag.pattern = integer;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (isInt) {
+			if (!Number.isInteger(input)) {
+				payload.issues.push({
+					expected: origin,
+					format: def.format,
+					code: "invalid_type",
+					continue: false,
+					input,
+					inst
+				});
+				return;
+			}
+			if (!Number.isSafeInteger(input)) {
+				if (input > 0) payload.issues.push({
+					input,
+					code: "too_big",
+					maximum: Number.MAX_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				else payload.issues.push({
+					input,
+					code: "too_small",
+					minimum: Number.MIN_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				return;
+			}
+		}
+		if (input < minimum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_small",
+			minimum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+		if (input > maximum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_big",
+			maximum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
 const $ZodCheckMaxLength = /*@__PURE__*/ $constructor("$ZodCheckMaxLength", (inst, def) => {
 	var _a;
 	$ZodCheck.init(inst, def);
@@ -1900,6 +2105,30 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
 		version: 1
 	}));
 });
+const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Number(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+		const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+		payload.issues.push({
+			expected: "number",
+			code: "invalid_type",
+			input,
+			inst,
+			...received ? { received } : {}
+		});
+		return payload;
+	};
+});
+const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, def) => {
+	$ZodCheckNumberFormat.init(inst, def);
+	$ZodNumber.init(inst, def);
+});
 const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
@@ -2321,6 +2550,24 @@ const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def) => {
 		return payload;
 	};
 });
+const $ZodLiteral = /*@__PURE__*/ $constructor("$ZodLiteral", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (def.values.length === 0) throw new Error("Cannot create literal schema with no valid values");
+	const values = new Set(def.values);
+	inst._zod.values = values;
+	inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (values.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values: def.values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -2592,6 +2839,24 @@ const globalRegistry = globalThis.__zod_globalRegistry;
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js
 // @__NO_SIDE_EFFECTS__
+function _number(Class, params) {
+	return new Class({
+		type: "number",
+		checks: [],
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _int(Class, params) {
+	return new Class({
+		type: "number",
+		check: "number_format",
+		abort: false,
+		format: "safeint",
+		...normalizeParams(params)
+	});
+}
+// @__NO_SIDE_EFFECTS__
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
@@ -2603,6 +2868,50 @@ function _never(Class, params) {
 	});
 }
 // @__NO_SIDE_EFFECTS__
+function _lt(value, params) {
+	return new $ZodCheckLessThan({
+		check: "less_than",
+		...normalizeParams(params),
+		value,
+		inclusive: false
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _lte(value, params) {
+	return new $ZodCheckLessThan({
+		check: "less_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _gt(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: false
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _gte(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+// @__NO_SIDE_EFFECTS__
+function _multipleOf(value, params) {
+	return new $ZodCheckMultipleOf({
+		check: "multiple_of",
+		...normalizeParams(params),
+		value
+	});
+}
+// @__NO_SIDE_EFFECTS__
 function _maxLength(maximum, params) {
 	return new $ZodCheckMaxLength({
 		check: "max_length",
@@ -2965,6 +3274,31 @@ const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params)
 };
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema-processors.js
+const numberProcessor = (schema, ctx, _json, _params) => {
+	const json = _json;
+	const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+	if (typeof format === "string" && format.includes("int")) json.type = "integer";
+	else json.type = "number";
+	if (typeof exclusiveMinimum === "number") if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+		json.minimum = exclusiveMinimum;
+		json.exclusiveMinimum = true;
+	} else json.exclusiveMinimum = exclusiveMinimum;
+	if (typeof minimum === "number") {
+		json.minimum = minimum;
+		if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") if (exclusiveMinimum >= minimum) delete json.minimum;
+		else delete json.exclusiveMinimum;
+	}
+	if (typeof exclusiveMaximum === "number") if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+		json.maximum = exclusiveMaximum;
+		json.exclusiveMaximum = true;
+	} else json.exclusiveMaximum = exclusiveMaximum;
+	if (typeof maximum === "number") {
+		json.maximum = maximum;
+		if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") if (exclusiveMaximum <= maximum) delete json.maximum;
+		else delete json.exclusiveMaximum;
+	}
+	if (typeof multipleOf === "number") json.multipleOf = multipleOf;
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -2975,6 +3309,27 @@ const enumProcessor = (schema, _ctx, json, _params) => {
 	if (values.every((v) => typeof v === "string")) json.type = "string";
 	json.enum = values;
 };
+const literalProcessor = (schema, ctx, json, _params) => {
+	const def = schema._zod.def;
+	const vals = [];
+	for (const val of def.values) if (val === void 0) {
+		if (ctx.unrepresentable === "throw") throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+	} else if (typeof val === "bigint") if (ctx.unrepresentable === "throw") throw new Error("BigInt literals cannot be represented in JSON Schema");
+	else vals.push(Number(val));
+	else vals.push(val);
+	if (vals.length === 0) {} else if (vals.length === 1) {
+		const val = vals[0];
+		json.type = val === null ? "null" : typeof val;
+		if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") json.enum = [val];
+		else json.const = val;
+	} else {
+		if (vals.every((v) => typeof v === "number")) json.type = "number";
+		if (vals.every((v) => typeof v === "string")) json.type = "string";
+		if (vals.every((v) => typeof v === "boolean")) json.type = "boolean";
+		if (vals.every((v) => v === null)) json.type = "null";
+		json.enum = vals;
+	}
+};
 const customProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
 };
@@ -3234,6 +3589,42 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 	inst.apply = (fn) => fn(inst);
 	return inst;
 });
+const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
+	inst.gt = (value, params) => inst.check(/* @__PURE__ */ _gt(value, params));
+	inst.gte = (value, params) => inst.check(/* @__PURE__ */ _gte(value, params));
+	inst.min = (value, params) => inst.check(/* @__PURE__ */ _gte(value, params));
+	inst.lt = (value, params) => inst.check(/* @__PURE__ */ _lt(value, params));
+	inst.lte = (value, params) => inst.check(/* @__PURE__ */ _lte(value, params));
+	inst.max = (value, params) => inst.check(/* @__PURE__ */ _lte(value, params));
+	inst.int = (params) => inst.check(int(params));
+	inst.safe = (params) => inst.check(int(params));
+	inst.positive = (params) => inst.check(/* @__PURE__ */ _gt(0, params));
+	inst.nonnegative = (params) => inst.check(/* @__PURE__ */ _gte(0, params));
+	inst.negative = (params) => inst.check(/* @__PURE__ */ _lt(0, params));
+	inst.nonpositive = (params) => inst.check(/* @__PURE__ */ _lte(0, params));
+	inst.multipleOf = (value, params) => inst.check(/* @__PURE__ */ _multipleOf(value, params));
+	inst.step = (value, params) => inst.check(/* @__PURE__ */ _multipleOf(value, params));
+	inst.finite = () => inst;
+	const bag = inst._zod.bag;
+	inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+	inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+	inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? .5);
+	inst.isFinite = true;
+	inst.format = bag.format ?? null;
+});
+function number(params) {
+	return /* @__PURE__ */ _number(ZodNumber, params);
+}
+const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def) => {
+	$ZodNumberFormat.init(inst, def);
+	ZodNumber.init(inst, def);
+});
+function int(params) {
+	return /* @__PURE__ */ _int(ZodNumberFormat, params);
+}
 const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -3368,9 +3759,27 @@ const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def) => {
 	};
 });
 function _enum(values, params) {
+	const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
 	return new ZodEnum({
 		type: "enum",
-		entries: Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values,
+		entries,
+		...normalizeParams(params)
+	});
+}
+const ZodLiteral = /*@__PURE__*/ $constructor("ZodLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json, params);
+	inst.values = new Set(def.values);
+	Object.defineProperty(inst, "value", { get() {
+		if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+		return def.values[0];
+	} });
+});
+function literal(value, params) {
+	return new ZodLiteral({
+		type: "literal",
+		values: Array.isArray(value) ? value : [value],
 		...normalizeParams(params)
 	});
 }
@@ -3538,36 +3947,76 @@ function superRefine(fn) {
 	return /* @__PURE__ */ _superRefine(fn);
 }
 //#endregion
+//#region src/domain/validation/errors.ts
+var ConfigurationError = class extends Error {
+	name = "ConfigurationError";
+	problems;
+	constructor(message, problems = []) {
+		super(message);
+		this.problems = problems;
+	}
+};
+var ExecutionFailure = class extends Error {
+	name = "ExecutionFailure";
+	cause;
+	stage;
+	constructor(message, options) {
+		super(message);
+		this.cause = options.cause;
+		this.stage = options.stage;
+	}
+};
+var CancelledFailure = class extends Error {
+	name = "CancelledFailure";
+	constructor(message = "Analysis was cancelled.") {
+		super(message);
+	}
+};
+//#endregion
 //#region src/config/schema.ts
-const checkerExtensionsConfigReason = "checker extensions are fixed by built-in presets and cannot be configured.";
-const checkerRoutesConfigReason = "checker routes are not supported; configure checker.include with source tsconfig selectors.";
 const unsupportedCheckerPresetReason = "configured checkers require a built-in checker adapter.";
-const checkerEntryConfigReason = "checker.entry has been removed; configure checker.include with source tsconfig selectors.";
 const checkerConfigReason = "config.checkers must be an object auto config or an object keyed by checker name.";
-const checkerAutoStringConfigReason = "checkers: \"auto\" has been removed; omit config.checkers or use { mode: \"auto\" }.";
 const autoCheckerMixedConfigReason = "auto checker config must not be mixed with named checker entries.";
 const autoCheckerModeConfigReason = "auto checker config requires mode: \"auto\".";
 const importAnalysisConfigReason = "config.imports must be an object when configured.";
 const vueImportParserConfigReason = "config.imports.vue must be \"heuristic\" or \"compiler-sfc\".";
+const checkerConfigKeys = /* @__PURE__ */ new Set([
+	"exclude",
+	"include",
+	"preset"
+]);
+const importAuthorityGrantKeys = /* @__PURE__ */ new Set([
+	"include",
+	"reason",
+	"workspaceRootDependencies"
+]);
+const liminaConfigKeys = /* @__PURE__ */ new Set([
+	"config",
+	"execution",
+	"graph",
+	"package",
+	"pipelines",
+	"proof",
+	"release",
+	"regions",
+	"source"
+]);
+function isAbsolutePublicSelector(value) {
+	const selector = value.trim().replace(/^!+/u, "");
+	return posix.isAbsolute(selector) || /^[A-Za-z]:[\\/]/u.test(selector);
+}
 const checkerConfigShapeSchema = looseObject({}).superRefine((checker, ctx) => {
 	const preset = checker.preset;
 	const include = checker.include;
 	const exclude = checker.exclude;
-	if (Object.hasOwn(checker, "entry")) ctx.addIssue({
-		code: "custom",
-		message: checkerEntryConfigReason,
-		path: ["entry"]
-	});
-	if (Object.hasOwn(checker, "extensions")) ctx.addIssue({
-		code: "custom",
-		message: checkerExtensionsConfigReason,
-		path: ["extensions"]
-	});
-	if (Object.hasOwn(checker, "routes")) ctx.addIssue({
-		code: "custom",
-		message: checkerRoutesConfigReason,
-		path: ["routes"]
-	});
+	for (const key of Object.keys(checker)) {
+		if (checkerConfigKeys.has(key)) continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown checker config field.",
+			path: [key]
+		});
+	}
 	if (typeof preset !== "string" || preset.trim().length === 0) ctx.addIssue({
 		code: "custom",
 		message: "checker preset must be a non-empty string.",
@@ -3588,6 +4037,11 @@ const checkerConfigShapeSchema = looseObject({}).superRefine((checker, ctx) => {
 		message: "checker include entries must be non-empty string paths.",
 		path: ["include", index]
 	});
+	else if (isAbsolutePublicSelector(value)) ctx.addIssue({
+		code: "custom",
+		message: "checker include entries must be config.rootDir-relative paths; ../ is allowed.",
+		path: ["include", index]
+	});
 	if (exclude === void 0) return;
 	if (!Array.isArray(exclude)) {
 		ctx.addIssue({
@@ -3602,20 +4056,65 @@ const checkerConfigShapeSchema = looseObject({}).superRefine((checker, ctx) => {
 		message: "checker exclude entries must be non-empty string paths.",
 		path: ["exclude", index]
 	});
+	else if (isAbsolutePublicSelector(value)) ctx.addIssue({
+		code: "custom",
+		message: "checker exclude entries must be config.rootDir-relative paths; ../ is allowed.",
+		path: ["exclude", index]
+	});
 });
 function isPlainConfigRecord(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function validateSourcePatternConfig(options) {
+	const patterns = options.source[options.field];
+	if (patterns === void 0) return;
+	if (!Array.isArray(patterns) || patterns.length === 0) {
+		options.ctx.addIssue({
+			code: "custom",
+			message: `config.source.${options.field} must be a non-empty string array.`,
+			path: ["source", options.field]
+		});
+		return;
+	}
+	let defaultTokenCount = 0;
+	for (const [index, value] of patterns.entries()) {
+		if (typeof value !== "string" || value.trim().length === 0) {
+			options.ctx.addIssue({
+				code: "custom",
+				message: `config.source.${options.field} entries must be non-empty strings.`,
+				path: [
+					"source",
+					options.field,
+					index
+				]
+			});
+			continue;
+		}
+		if (value !== "..." && isAbsolutePublicSelector(value)) {
+			options.ctx.addIssue({
+				code: "custom",
+				message: `config.source.${options.field} entries must be config.rootDir-relative paths; ../ is allowed.`,
+				path: [
+					"source",
+					options.field,
+					index
+				]
+			});
+			continue;
+		}
+		if (value === "...") defaultTokenCount += 1;
+	}
+	if (defaultTokenCount > 1) options.ctx.addIssue({
+		code: "custom",
+		message: `config.source.${options.field} may contain "..." at most once.`,
+		path: ["source", options.field]
+	});
+}
 const sharedLiminaConfigShapeSchema = looseObject({}).superRefine((sharedConfig, ctx) => {
 	const checkers = sharedConfig.checkers;
 	const imports = sharedConfig.imports;
 	const source = sharedConfig.source;
-	if (checkers !== void 0) if (checkers === "auto") ctx.addIssue({
-		code: "custom",
-		message: checkerAutoStringConfigReason,
-		path: ["checkers"]
-	});
-	else if (!isPlainConfigRecord(checkers)) ctx.addIssue({
+	if (checkers !== void 0) if (!isPlainConfigRecord(checkers)) ctx.addIssue({
 		code: "custom",
 		message: checkerConfigReason,
 		path: ["checkers"]
@@ -3642,6 +4141,15 @@ const sharedLiminaConfigShapeSchema = looseObject({}).superRefine((sharedConfig,
 					index
 				]
 			});
+			else if (isAbsolutePublicSelector(value)) ctx.addIssue({
+				code: "custom",
+				message: "auto checker exclude entries must be config.rootDir-relative paths; ../ is allowed.",
+				path: [
+					"checkers",
+					"exclude",
+					index
+				]
+			});
 		}
 		for (const key of Object.keys(checkers)) {
 			if (key === "mode" || key === "exclude") continue;
@@ -3652,6 +4160,14 @@ const sharedLiminaConfigShapeSchema = looseObject({}).superRefine((sharedConfig,
 			});
 		}
 	} else for (const [checkerName, checker] of Object.entries(checkers)) {
+		if (checkerName.length === 0 || checkerName === "." || checkerName === ".." || checkerName.includes("/") || checkerName.includes("\\")) {
+			ctx.addIssue({
+				code: "custom",
+				message: "checker names must be non-empty path-safe identifiers without slash segments.",
+				path: ["checkers", checkerName]
+			});
+			continue;
+		}
 		const result = checkerConfigShapeSchema.safeParse(checker);
 		if (result.success) continue;
 		for (const issue of result.error.issues) ctx.addIssue({
@@ -3692,8 +4208,18 @@ const sharedLiminaConfigShapeSchema = looseObject({}).superRefine((sharedConfig,
 			path: ["source", key]
 		});
 	}
+	validateSourcePatternConfig({
+		ctx,
+		field: "include",
+		source
+	});
+	validateSourcePatternConfig({
+		ctx,
+		field: "exclude",
+		source
+	});
 });
-const releaseConfigShapeSchema = looseObject({ contentHash: looseObject({}).superRefine((contentHash, ctx) => {
+const releaseContentHashShapeSchema = looseObject({}).superRefine((contentHash, ctx) => {
 	const baselineTag = contentHash.baselineTag;
 	if (baselineTag !== void 0 && typeof baselineTag !== "function" && (typeof baselineTag !== "string" || baselineTag.trim().length === 0)) ctx.addIssue({
 		code: "custom",
@@ -3724,40 +4250,84 @@ const releaseConfigShapeSchema = looseObject({ contentHash: looseObject({}).supe
 			path: ["ignore", index]
 		});
 	}
-}).optional() });
-const executionConcurrencyFields = [
-	"tasks",
-	"checkerBuild",
-	"checkerTypecheck",
-	"packageEntries",
-	"releaseEntries"
-];
-function isValidExecutionConcurrencyValue(value) {
-	return value === "auto" || typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-const executionConfigShapeSchema = looseObject({}).superRefine((execution, ctx) => {
-	for (const key of Object.keys(execution)) {
-		if (key === "failFast" || executionConcurrencyFields.includes(key)) continue;
+});
+const releaseNpmPackageJsonLintSeverities = /* @__PURE__ */ new Set([
+	"error",
+	"off",
+	"warning"
+]);
+function isReleaseNpmPackageJsonLintRuleConfig(value) {
+	if (typeof value === "string" && releaseNpmPackageJsonLintSeverities.has(value)) return true;
+	if (!Array.isArray(value) || value.length !== 2) return false;
+	const [severity, ruleOptions] = value;
+	return typeof severity === "string" && releaseNpmPackageJsonLintSeverities.has(severity) && (Array.isArray(ruleOptions) || isPlainConfigRecord(ruleOptions));
+}
+const releaseNpmPackageJsonLintShapeSchema = unknown().superRefine((npmPackageJsonLint, ctx) => {
+	if (typeof npmPackageJsonLint === "boolean") return;
+	if (!isPlainConfigRecord(npmPackageJsonLint)) {
 		ctx.addIssue({
 			code: "custom",
-			message: "unknown execution config field.",
+			message: "npmPackageJsonLint must be a boolean or object."
+		});
+		return;
+	}
+	for (const key of Object.keys(npmPackageJsonLint)) {
+		if (key === "rules") continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown npmPackageJsonLint config field.",
 			path: [key]
 		});
 	}
-	for (const key of executionConcurrencyFields) {
-		const value = execution[key];
-		if (value === void 0 || isValidExecutionConcurrencyValue(value)) continue;
+	const rules = npmPackageJsonLint.rules;
+	if (rules === void 0) return;
+	if (!isPlainConfigRecord(rules)) {
 		ctx.addIssue({
 			code: "custom",
-			message: "execution concurrency must be a positive integer or \"auto\".",
+			message: "npmPackageJsonLint.rules must be an object.",
+			path: ["rules"]
+		});
+		return;
+	}
+	for (const [ruleName, ruleConfig] of Object.entries(rules)) {
+		if (ruleName.trim().length === 0) {
+			ctx.addIssue({
+				code: "custom",
+				message: "npmPackageJsonLint rule names must be non-empty strings.",
+				path: ["rules"]
+			});
+			continue;
+		}
+		if (isReleaseNpmPackageJsonLintRuleConfig(ruleConfig)) continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "rule config must be \"off\", \"warning\", \"error\", or a [severity, options] tuple.",
+			path: ["rules", ruleName]
+		});
+	}
+});
+const releaseConfigShapeSchema = looseObject({
+	contentHash: releaseContentHashShapeSchema.optional(),
+	npmPackageJsonLint: releaseNpmPackageJsonLintShapeSchema.optional()
+});
+const executionConcurrencyError = "execution concurrency must be a positive integer or \"auto\".";
+const executionConcurrencySchema = union([literal("auto", { error: executionConcurrencyError }), number({ error: executionConcurrencyError }).int({ error: executionConcurrencyError }).positive({ error: executionConcurrencyError })], { error: executionConcurrencyError });
+const executionConfigShape = {
+	checkerBuild: executionConcurrencySchema.optional(),
+	checkerTypecheck: executionConcurrencySchema.optional(),
+	packageEntries: executionConcurrencySchema.optional(),
+	releaseEntries: executionConcurrencySchema.optional(),
+	tasks: executionConcurrencySchema.optional()
+};
+const executionConfigShapeSchema = looseObject(executionConfigShape).superRefine((execution, ctx) => {
+	for (const key of Object.keys(execution)) {
+		if (Object.hasOwn(executionConfigShape, key)) continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown execution config field.",
 			path: [key]
 		});
 	}
-	if (execution.failFast !== void 0 && typeof execution.failFast !== "boolean") ctx.addIssue({
-		code: "custom",
-		message: "execution failFast must be a boolean.",
-		path: ["failFast"]
-	});
 });
 function validateStringArrayField(options) {
 	if (options.value === void 0) {
@@ -3798,10 +4368,10 @@ function validateSourceImportAuthorityConfig(value, ctx) {
 	}
 	const allow = value.allow;
 	if (allow === void 0) return;
-	if (!Array.isArray(allow)) {
+	if (Array.isArray(allow) || !isPlainConfigRecord(allow)) {
 		ctx.addIssue({
 			code: "custom",
-			message: "importAuthority.allow must be an array.",
+			message: "allow must be an object keyed by source owner identity.\n  fix: use allow: { \"@scope/package\": [{ include: [\"test/**/*.ts\"], workspaceRootDependencies: [\"@example/fixture\"], reason: \"...\" }] }.",
 			path: [
 				"source",
 				"importAuthority",
@@ -3810,69 +4380,258 @@ function validateSourceImportAuthorityConfig(value, ctx) {
 		});
 		return;
 	}
-	for (const [index, entry] of allow.entries()) {
-		const path = [
+	for (const [ownerIdentity, grants] of Object.entries(allow)) {
+		const ownerPath = [
 			"source",
 			"importAuthority",
 			"allow",
-			index
+			ownerIdentity
 		];
-		if (!isPlainConfigRecord(entry)) {
+		if (ownerIdentity.trim().length === 0) ctx.addIssue({
+			code: "custom",
+			message: "allow keys must be non-empty source owner identities.",
+			path: ownerPath
+		});
+		if (!Array.isArray(grants)) {
+			ctx.addIssue({
+				code: "custom",
+				message: "allow owner entries must be arrays of grants.",
+				path: ownerPath
+			});
+			continue;
+		}
+		for (const [index, grant] of grants.entries()) {
+			const grantPath = [...ownerPath, index];
+			if (!isPlainConfigRecord(grant)) {
+				ctx.addIssue({
+					code: "custom",
+					message: "importAuthority allow grants must be objects with workspaceRootDependencies and reason fields.",
+					path: grantPath
+				});
+				continue;
+			}
+			for (const key of Object.keys(grant)) {
+				if (importAuthorityGrantKeys.has(key)) continue;
+				ctx.addIssue({
+					code: "custom",
+					message: "unknown source import authority grant field.",
+					path: [...grantPath, key]
+				});
+			}
+			validateStringArrayField({
+				ctx,
+				path: [...grantPath, "workspaceRootDependencies"],
+				required: true,
+				value: grant.workspaceRootDependencies,
+				valueName: "workspaceRootDependencies"
+			});
+			validateStringArrayField({
+				ctx,
+				path: [...grantPath, "include"],
+				value: grant.include,
+				valueName: "include"
+			});
+			if (Array.isArray(grant.include)) {
+				for (const [includeIndex, include] of grant.include.entries()) if (typeof include === "string" && include.trim().length > 0 && isAbsolutePublicSelector(include)) ctx.addIssue({
+					code: "custom",
+					message: "source.importAuthority allow include entries must be config.rootDir-relative paths; ../ is allowed.",
+					path: [
+						...grantPath,
+						"include",
+						includeIndex
+					]
+				});
+			}
+			if (typeof grant.reason !== "string" || grant.reason.trim().length === 0) ctx.addIssue({
+				code: "custom",
+				message: "reason must be a non-empty string.",
+				path: [...grantPath, "reason"]
+			});
+		}
+	}
+}
+function validateSourceDeclarationsConfig(value, ctx) {
+	if (value === void 0) return;
+	const declarationsPath = ["source", "declarations"];
+	if (!isPlainConfigRecord(value)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "declarations must be an object.",
+			path: declarationsPath
+		});
+		return;
+	}
+	for (const key of Object.keys(value)) if (key !== "ambient") ctx.addIssue({
+		code: "custom",
+		message: "unknown source declarations config field.",
+		path: [...declarationsPath, key]
+	});
+	if (value.ambient === void 0) return;
+	const ambientPath = [...declarationsPath, "ambient"];
+	if (!Array.isArray(value.ambient)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "ambient must be an array.",
+			path: ambientPath
+		});
+		return;
+	}
+	for (const [index, rule] of value.ambient.entries()) {
+		const rulePath = [...ambientPath, index];
+		if (!isPlainConfigRecord(rule)) {
 			ctx.addIssue({
 				code: "custom",
-				message: "importAuthority allow entries must be objects with files, packages or specifiers, and reason fields.",
-				path
+				message: "ambient declaration rules must be objects.",
+				path: rulePath
 			});
 			continue;
 		}
+		for (const key of Object.keys(rule)) if (![
+			"include",
+			"allowSharedAcrossOwners",
+			"allowTripleSlashReferences",
+			"reason"
+		].includes(key)) ctx.addIssue({
+			code: "custom",
+			message: "unknown ambient declaration rule field.",
+			path: [...rulePath, key]
+		});
 		validateStringArrayField({
 			ctx,
-			path: [...path, "files"],
+			path: [...rulePath, "include"],
 			required: true,
-			value: entry.files,
-			valueName: "files"
+			value: rule.include,
+			valueName: "ambient declaration include"
 		});
-		const hasPackages = validateStringArrayField({
-			ctx,
-			path: [...path, "packages"],
-			value: entry.packages,
-			valueName: "packages"
+		if (Array.isArray(rule.include)) {
+			for (const [includeIndex, include] of rule.include.entries()) if (typeof include === "string" && include.trim().length > 0 && isAbsolutePublicSelector(include)) ctx.addIssue({
+				code: "custom",
+				message: "ambient declaration include entries must be config.rootDir-relative paths; ../ is allowed.",
+				path: [
+					...rulePath,
+					"include",
+					includeIndex
+				]
+			});
+		}
+		if (typeof rule.reason !== "string" || rule.reason.trim().length === 0) ctx.addIssue({
+			code: "custom",
+			message: "ambient declaration reason must be a non-empty string.",
+			path: [...rulePath, "reason"]
 		});
-		const hasSpecifiers = validateStringArrayField({
-			ctx,
-			path: [...path, "specifiers"],
-			value: entry.specifiers,
-			valueName: "specifiers"
+		for (const key of ["allowSharedAcrossOwners", "allowTripleSlashReferences"]) if (rule[key] !== void 0 && typeof rule[key] !== "boolean") ctx.addIssue({
+			code: "custom",
+			message: `${key} must be a boolean.`,
+			path: [...rulePath, key]
+		});
+	}
+}
+const regionExcludeKinds = ["workspace-package", "package-scope"];
+function validateRegionsConfig(value, ctx) {
+	if (value === void 0) return;
+	if (!isPlainConfigRecord(value)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "regions config must be an object.",
+			path: ["regions"]
+		});
+		return;
+	}
+	for (const key of Object.keys(value)) {
+		if (key === "exclude" || key === "extendNestedPackageScopes") continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown regions config field.",
+			path: ["regions", key]
+		});
+	}
+	if (value.extendNestedPackageScopes !== void 0 && typeof value.extendNestedPackageScopes !== "boolean") ctx.addIssue({
+		code: "custom",
+		message: "regions.extendNestedPackageScopes must be a boolean.",
+		path: ["regions", "extendNestedPackageScopes"]
+	});
+	const exclude = value.exclude;
+	if (exclude === void 0) return;
+	if (!Array.isArray(exclude)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "regions.exclude must be an array.",
+			path: ["regions", "exclude"]
+		});
+		return;
+	}
+	for (const [index, entry] of exclude.entries()) {
+		const entryPath = [
+			"regions",
+			"exclude",
+			index
+		];
+		if (!isPlainConfigRecord(entry)) {
+			ctx.addIssue({
+				code: "custom",
+				message: "regions.exclude entries must be objects with kind, include, and reason fields.",
+				path: entryPath
+			});
+			continue;
+		}
+		for (const key of Object.keys(entry)) {
+			if (key === "include" || key === "kind" || key === "reason") continue;
+			ctx.addIssue({
+				code: "custom",
+				message: "unknown regions.exclude entry field.",
+				path: [...entryPath, key]
+			});
+		}
+		if (!Object.hasOwn(entry, "kind")) ctx.addIssue({
+			code: "custom",
+			message: `regions.exclude[${index}].kind is required.`,
+			path: [...entryPath, "kind"]
 		});
-		if (!hasPackages && !hasSpecifiers) ctx.addIssue({
+		else if (typeof entry.kind !== "string" || !regionExcludeKinds.includes(entry.kind)) ctx.addIssue({
 			code: "custom",
-			message: "importAuthority allow entries must declare packages or specifiers.",
-			path
+			message: [`regions.exclude[${index}].kind must be one of:`, ...regionExcludeKinds.map((kind) => `  ${kind}`)].join("\n"),
+			path: [...entryPath, "kind"]
 		});
-		if (entry.owner !== void 0) {
-			if (typeof entry.owner !== "string" || entry.owner.trim().length === 0) ctx.addIssue({
+		validateStringArrayField({
+			ctx,
+			path: [...entryPath, "include"],
+			required: true,
+			value: entry.include,
+			valueName: "regions.exclude.include"
+		});
+		if (Array.isArray(entry.include)) {
+			for (const [includeIndex, include] of entry.include.entries()) if (typeof include === "string" && include.trim().length > 0 && isAbsolutePublicSelector(include)) ctx.addIssue({
 				code: "custom",
-				message: "owner must be a non-empty string when configured.",
-				path: [...path, "owner"]
+				message: "regions.exclude.include entries must be config.rootDir-relative paths; ../ is allowed.",
+				path: [
+					...entryPath,
+					"include",
+					includeIndex
+				]
 			});
 		}
 		if (typeof entry.reason !== "string" || entry.reason.trim().length === 0) ctx.addIssue({
 			code: "custom",
 			message: "reason must be a non-empty string.",
-			path: [...path, "reason"]
+			path: [...entryPath, "reason"]
 		});
 	}
 }
 const liminaConfigShapeSchema = looseObject({
 	config: sharedLiminaConfigShapeSchema.optional(),
 	execution: executionConfigShapeSchema.optional(),
+	regions: unknown().optional(),
 	release: releaseConfigShapeSchema.optional()
 }).superRefine((config, ctx) => {
-	if (Object.hasOwn(config, "paths")) ctx.addIssue({
-		code: "custom",
-		message: "paths config has been removed; use graph/proof/source checks instead.",
-		path: ["paths"]
-	});
+	for (const key of Object.keys(config)) {
+		if (liminaConfigKeys.has(key)) continue;
+		ctx.addIssue({
+			code: "custom",
+			message: "unknown Limina config field.",
+			path: [key]
+		});
+	}
+	validateRegionsConfig(config.regions, ctx);
 	const source = config.source;
 	if (source === void 0) return;
 	if (!isPlainConfigRecord(source)) {
@@ -3884,7 +4643,7 @@ const liminaConfigShapeSchema = looseObject({
 		return;
 	}
 	for (const key of Object.keys(source)) {
-		if (key === "knip" || key === "importAuthority") continue;
+		if (key === "knip" || key === "importAuthority" || key === "declarations") continue;
 		ctx.addIssue({
 			code: "custom",
 			message: "unknown source config field.",
@@ -3892,9 +4651,10 @@ const liminaConfigShapeSchema = looseObject({
 		});
 	}
 	validateSourceImportAuthorityConfig(source.importAuthority, ctx);
+	validateSourceDeclarationsConfig(source.declarations, ctx);
 });
 function formatZodPath(pathSegments) {
-	return pathSegments.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${String(segment)}`).join("").replace(/^\./u, "");
+	return pathSegments.map((segment) => typeof segment === "number" ? `[${segment}]` : /^[A-Za-z_$][\w$]*$/u.test(String(segment)) ? `.${String(segment)}` : `[${JSON.stringify(String(segment))}]`).join("").replace(/^\./u, "");
 }
 function getValueAtPath(value, pathSegments) {
 	let current = value;
@@ -3914,24 +4674,12 @@ function formatLiminaConfigShapeIssue(value, issue) {
 		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
 		"  reason: config must be an object."
 	].join("\n");
-	if (field === "paths") return [
-		"Invalid Limina paths config:",
-		"  field: paths",
-		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
-		`  reason: ${issue.message}`
-	].join("\n");
 	if (field === "execution") return [
 		"Invalid Limina execution config:",
 		"  field: execution",
 		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
 		"  reason: execution must be an object."
 	].join("\n");
-	if (field === "execution.failFast") return [
-		"Invalid Limina execution config:",
-		"  field: execution.failFast",
-		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
-		"  reason: execution failFast must be a boolean."
-	].join("\n");
 	if (field.startsWith("execution.")) return [
 		"Invalid Limina execution config:",
 		`  field: ${field}`,
@@ -3968,6 +4716,12 @@ function formatLiminaConfigShapeIssue(value, issue) {
 		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
 		`  reason: ${issue.message}`
 	].join("\n");
+	if (field === "source.importAuthority" || field.startsWith("source.importAuthority.")) return [
+		"Invalid source import authority config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
 	if (field === "source" || field.startsWith("source.")) return [
 		"Invalid Limina source config:",
 		`  field: ${field}`,
@@ -3997,21 +4751,9 @@ function formatLiminaConfigShapeIssue(value, issue) {
 				"  reason: checker preset must be a non-empty string."
 			].join("\n");
 		}
-		if (pathSegments[3] === "entry") return [
-			"Invalid Limina checker entry config:",
-			`  field: ${checkerField}.entry`,
-			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
-			`  reason: ${issue.message}`
-		].join("\n");
-		if (pathSegments[3] === "extensions") return [
+		return [
 			"Invalid Limina checker config:",
-			`  field: ${checkerField}.extensions`,
-			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
-			`  reason: ${issue.message}`
-		].join("\n");
-		if (pathSegments[3] === "routes") return [
-			"Invalid Limina checker config:",
-			`  field: ${checkerField}.routes`,
+			`  field: ${field}`,
 			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
 			`  reason: ${issue.message}`
 		].join("\n");
@@ -4028,6 +4770,12 @@ function formatLiminaConfigShapeIssue(value, issue) {
 		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
 		"  reason: release.contentHash must be an object."
 	].join("\n");
+	if (field === "release.npmPackageJsonLint" || field.startsWith("release.npmPackageJsonLint.")) return [
+		"Invalid Limina release config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
 	if (field === "release.contentHash.baselineTag") return [
 		"Invalid Limina release config:",
 		"  field: release.contentHash.baselineTag",
@@ -4066,18 +4814,32 @@ function collectLiminaConfigShapeProblems(value) {
 }
 function validateLiminaConfig(config) {
 	const problems = collectLiminaConfigShapeProblems(config);
-	if (problems.length > 0) throw new Error(problems.join("\n\n"));
+	if (problems.length > 0) throw new ConfigurationError(problems.join("\n\n"), problems.map((message) => ({
+		message,
+		path: []
+	})));
 }
 //#endregion
 //#region src/config/runner.ts
 function isAutoCheckerConfigMode(checkers) {
 	return Boolean(checkers && checkers.mode === "auto");
 }
+const DEFAULT_LIMINA_CONFIG_FILES = [
+	"limina.config.mts",
+	"limina.config.mjs",
+	"limina.config.ts",
+	"limina.config.js"
+];
 function defineConfig(config) {
 	return config;
 }
 function getActiveCheckers(config) {
-	validateLiminaConfig(config);
+	if ("configPath" in config && "rootDir" in config) {
+		const userConfig = { ...config };
+		delete userConfig.configPath;
+		delete userConfig.rootDir;
+		validateLiminaConfig(userConfig);
+	} else validateLiminaConfig(config);
 	return getResolvedCheckers(config);
 }
 function normalizeConfig(value) {
@@ -4104,8 +4866,10 @@ function findLiminaConfigPath(startDir, rootDir) {
 	let currentDir = posix.resolve(startDir);
 	const workspaceRootDir = posix.resolve(rootDir);
 	while (isPathInsideDirectory(currentDir, workspaceRootDir)) {
-		const candidatePath = posix.join(currentDir, "limina.config.mjs");
-		if (existsSync(candidatePath)) return candidatePath;
+		for (const fileName of DEFAULT_LIMINA_CONFIG_FILES) {
+			const candidatePath = posix.join(currentDir, fileName);
+			if (existsSync(candidatePath)) return candidatePath;
+		}
 		if (currentDir === workspaceRootDir) return null;
 		const parentDir = posix.dirname(currentDir);
 		if (parentDir === currentDir) return null;
@@ -4125,32 +4889,91 @@ function validateConfigPathInsideWorkspace(configPath, rootDir) {
 async function resolveConfigExport(configExport, configEnv) {
 	return normalizeConfig(typeof configExport === "function" ? await configExport(configEnv) : await configExport);
 }
-function hasSourceImportAuthorityPackageRules(config) {
-	return Boolean(config.source?.importAuthority?.allow?.some((rule) => rule.packages?.some((packageName) => packageName.trim().length > 0)));
+function hasSourceImportAuthorityWorkspaceRootGrants(config) {
+	const allow = config.source?.importAuthority?.allow;
+	if (!allow) return false;
+	return Boolean(Object.values(allow).some((grants) => grants.some((grant) => grant.workspaceRootDependencies.some((packageName) => packageName.trim().length > 0))));
 }
 function validateRootPackageImportAuthorityConfig(config, rootDir) {
-	if (!hasSourceImportAuthorityPackageRules(config)) return;
+	if (!hasSourceImportAuthorityWorkspaceRootGrants(config)) return;
 	if (existsSync(posix.join(rootDir, "package.json"))) return;
 	throw new Error([
-		"Invalid Limina source config:",
-		"  field: source.importAuthority.allow[].packages",
-		`  value: ${JSON.stringify(config.source?.importAuthority?.allow)}`,
-		"  reason: package allow rules enable workspace root package.json as a dependency authority manifest, but no package.json exists at the workspace root."
+		"Invalid source import authority config:",
+		"  field: source.importAuthority.allow",
+		"  reason: workspaceRootDependencies grants require a workspace root package.json.",
+		"  fix: create a workspace root package.json, or remove workspaceRootDependencies grants."
 	].join("\n"));
 }
+function resolveConfigLoader(configLoader) {
+	if (configLoader === void 0 || configLoader === "native") return "native";
+	if (configLoader === "tsx") return "tsx";
+	throw new Error(`Unsupported Limina config loader "${String(configLoader)}". Expected one of: native, tsx.`);
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function getErrorCode(error) {
+	return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+function shouldSuggestTsxLoader(error) {
+	const code = getErrorCode(error);
+	const message = getErrorMessage(error);
+	const stack = error instanceof Error ? error.stack : void 0;
+	return code === "ERR_UNKNOWN_FILE_EXTENSION" || code === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX" || message.includes("Unknown file extension \".ts\"") || message.includes("Unknown file extension \".mts\"") || message.includes("Cannot find module") || typeof stack === "string" && stack.includes("node:internal/modules/esm/translators");
+}
+function unwrapModuleDefault(module) {
+	if (typeof module === "object" && module !== null && "default" in module && Object.prototype.toString.call(module) === "[object Module]") return module.default;
+	return module;
+}
+function unwrapTsxConfigExport(module) {
+	const value = unwrapModuleDefault(module);
+	if (typeof value === "object" && value !== null && "default" in value && Object.prototype.toString.call(value) === "[object Object]" && Object.keys(value).length === 1) return value.default;
+	return value;
+}
+async function nativeImportConfig(configPath) {
+	const url = pathToFileURL(configPath);
+	url.searchParams.set("t", String(Date.now()));
+	try {
+		return unwrapModuleDefault(await import(url.href));
+	} catch (error) {
+		if (shouldSuggestTsxLoader(error)) throw new Error([
+			"Failed to load the Limina config file with the native loader.",
+			"Try setting the --config-loader CLI flag to `tsx`.",
+			"",
+			getErrorMessage(error)
+		].join("\n"), { cause: error });
+		throw error;
+	}
+}
+async function tsxImportConfig(configPath) {
+	let tsxApi;
+	try {
+		tsxApi = await import("tsx/esm/api");
+	} catch (error) {
+		throw new Error(["Failed to load the Limina config file with the tsx loader.", "Please install `tsx` in the current workspace before using --config-loader tsx."].join("\n"), { cause: error });
+	}
+	return unwrapTsxConfigExport(await tsxApi.tsImport(pathToFileURL(configPath).href, import.meta.url));
+}
+async function loadConfigModule(configPath, configLoader) {
+	return resolveConfigLoader(configLoader) === "native" ? nativeImportConfig(configPath) : tsxImportConfig(configPath);
+}
+function formatDefaultConfigFileList() {
+	return DEFAULT_LIMINA_CONFIG_FILES.map((fileName) => `"${fileName}"`).join(", ");
+}
 async function loadConfig(options = {}) {
 	const cwd = options.cwd ? posix.resolve(options.cwd) : process.cwd();
-	const rootDir = inferWorkspaceRoot(cwd);
-	const configPath = options.configPath ? posix.resolve(cwd, options.configPath) : findLiminaConfigPath(cwd, rootDir);
-	if (configPath) validateConfigPathInsideWorkspace(configPath, rootDir);
-	if (!configPath || !existsSync(configPath)) throw new Error(options.configPath ? `Unable to find limina config at ${configPath}` : `Unable to find limina config. Searched for limina.config.mjs from ${cwd} up to the pnpm workspace root at ${rootDir}.`);
-	const config = await resolveConfigExport((await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`)).default, createConfigEnv(options));
+	const configPath = options.configPath ? posix.resolve(cwd, options.configPath) : void 0;
+	const rootDir = configPath ? inferWorkspaceRoot(posix.dirname(configPath)) : inferWorkspaceRoot(cwd);
+	const resolvedConfigPath = configPath ?? findLiminaConfigPath(cwd, rootDir);
+	if (resolvedConfigPath) validateConfigPathInsideWorkspace(resolvedConfigPath, rootDir);
+	if (!resolvedConfigPath || !existsSync(resolvedConfigPath)) throw new Error(options.configPath ? `Unable to find limina config at ${resolvedConfigPath}` : `Unable to find limina config. Searched for ${formatDefaultConfigFileList()} from ${cwd} up to the pnpm workspace root at ${rootDir}.`);
+	const config = await resolveConfigExport(await loadConfigModule(resolvedConfigPath, options.configLoader), createConfigEnv(options));
 	validateRootPackageImportAuthorityConfig(config, rootDir);
 	return {
 		...config,
-		configPath,
+		configPath: resolvedConfigPath,
 		rootDir
 	};
 }
 //#endregion
-export { isPackageImportSpecifier as A, resolveRelativeModuleCandidate as C, toPosixPath as D, normalizeSlashes as E, uniqueBy as F, uniqueSortedStrings as I, uniqueTrimmedNonEmptySortedStrings as L, isUrlOrDataOrFileSpecifier as M, isVirtualModuleSpecifier as N, toRelativePath as O, posix as P, uniqueValues as R, resolvePathMappedModuleCandidate as S, normalizeAbsolutePath as T, resolveModuleNameWithCheckers as _, formatUnknownValue as a, resolveBaseUrlModuleCandidate as b, clearCheckerProjectConfigCache as c, getBuildCheckerSupportedExtensions as d, getCheckerAdapter as f, resolveCheckerProjectExtensions as g, parseCheckerProjectConfigForContext as h, loadConfig as i, isRelativeSpecifier as j, isBarePackageSpecifier as k, collectMissingCheckerPeerDependencies as l, normalizeExtensions as m, getActiveCheckers as n, isNonEmptyString as o, getCheckerExtensions as p, isAutoCheckerConfigMode as r, isPlainRecord as s, defineConfig as t, formatMissingCheckerPeerDependencies as u, resolveModuleNameWithCheckersDetailed as v, isPathInsideDirectory as w, resolveExistingFilePath as x, candidatePathsForBasePath as y };
+export { normalizeAbsolutePathIdentity as A, countDefinedBy as B, candidatePathsForBasePath as C, resolveRelativeModuleCandidate as D, resolvePathMappedModuleCandidate as E, isPackageImportSpecifier as F, uniqueTrimmedNonEmptySortedStrings as H, isRelativeSpecifier as I, isUrlOrDataOrFileSpecifier as L, toPosixPath as M, toRelativePath as N, isPathInsideDirectory as O, isBarePackageSpecifier as P, isVirtualModuleSpecifier as R, resolveModuleNameWithCheckersDetailed as S, resolveExistingFilePath as T, uniqueValues as U, uniqueSortedStrings as V, isBuildCapablePreset as _, CancelledFailure as a, parseCheckerProjectConfigForContext as b, formatUnknownValue as c, collectMissingCheckerPeerDependencies as d, formatMissingCheckerPeerDependencies as f, getCheckerExtensions as g, getCheckerBuildEngine as h, loadConfig as i, normalizeSlashes as j, normalizeAbsolutePath as k, isNonEmptyString as l, getCheckerAdapter as m, getActiveCheckers as n, ConfigurationError as o, getBuildCheckerSupportedExtensions as p, isAutoCheckerConfigMode as r, ExecutionFailure as s, defineConfig as t, isPlainRecord as u, isNativeTypeScriptProjectInput as v, resolveBaseUrlModuleCandidate as w, resolveCheckerProjectExtensions as x, normalizeExtensions as y, posix as z };