limina 0.0.4 → 0.0.5

package/chunks/dep-CBKvJc4Y.js

@@ -0,0 +1,846 @@
+import { createRequire } from "node:module";
+import { existsSync, statSync } from "node:fs";
+import path, { normalize, relative, resolve } from "pathe";
+import ts from "typescript";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+
+//#region src/utils/path.ts
+function toPosixPath(value) {
+	return normalizeSlashes(value);
+}
+function normalizeAbsolutePath(value) {
+	return resolve(value);
+}
+function toRelativePath(rootDir, absolutePath) {
+	const relativePath = relative(rootDir, resolve(absolutePath));
+	return relativePath.length === 0 ? "." : relativePath;
+}
+function toAbsolutePath(rootDir, workspacePath) {
+	return resolve(rootDir, workspacePath);
+}
+function normalizeWorkspacePath(rootDir, value) {
+	return toRelativePath(rootDir, value);
+}
+function normalizeSlashes(value) {
+	return value.replaceAll("\\", "/");
+}
+function normalizeAbsolutePathIdentity(value) {
+	const normalizedPath = normalize(value);
+	return normalizedPath.length > 1 && !/^[A-Za-z]:\/$/u.test(normalizedPath) ? normalizedPath.replace(/\/+$/u, "") : normalizedPath;
+}
+function isPathInsideDirectory(filePath, directoryPath) {
+	const normalizedFilePath = normalizeAbsolutePath(filePath);
+	const normalizedDirectoryPath = normalizeAbsolutePath(directoryPath);
+	return normalizedFilePath === normalizedDirectoryPath || normalizedFilePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+
+//#endregion
+//#region src/checkers.ts
+function getTypeScriptExtensionApi() {
+	const api = ts;
+	if (typeof api.getSupportedExtensions !== "function" || typeof api.getSupportedExtensionsWithJsonIfResolveJsonModule !== "function") throw new TypeError("Unable to resolve TypeScript checker extensions: the TypeScript compiler API does not expose supported extension metadata.");
+	return api;
+}
+function flattenTypeScriptExtensionGroups(groups) {
+	return groups.flatMap((group) => [...group]);
+}
+function getTypeScriptCheckerExtensions() {
+	const api = getTypeScriptExtensionApi();
+	const options = { resolveJsonModule: true };
+	return normalizeExtensions(flattenTypeScriptExtensionGroups(api.getSupportedExtensionsWithJsonIfResolveJsonModule(options, api.getSupportedExtensions(options))));
+}
+function getNativeTypeScriptProjectExtensions() {
+	const api = getTypeScriptExtensionApi();
+	const options = {
+		allowJs: true,
+		resolveJsonModule: true
+	};
+	return normalizeExtensions(flattenTypeScriptExtensionGroups(api.getSupportedExtensionsWithJsonIfResolveJsonModule(options, api.getSupportedExtensions(options))));
+}
+function getSvelteCheckerExtensions() {
+	return normalizeExtensions([...getTypeScriptCheckerExtensions(), ".svelte"]);
+}
+const parsedProjectConfigCache = /* @__PURE__ */ new Map();
+function createFormatHost(rootDir) {
+	return {
+		getCanonicalFileName: (fileName) => fileName,
+		getCurrentDirectory: () => rootDir,
+		getNewLine: () => "\n"
+	};
+}
+function readTypeScriptProjectConfig(options) {
+	const diagnostics = [];
+	const parsed = ts.getParsedCommandLineOfConfigFile(options.configPath, {}, {
+		...ts.sys,
+		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+			diagnostics.push(diagnostic);
+		}
+	});
+	if (!parsed) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, createFormatHost(options.projectRootDir)));
+	return {
+		diagnostics,
+		parsed
+	};
+}
+function createParsedCheckerProjectConfig(options) {
+	return {
+		extensions: normalizeExtensions(options.extensions),
+		fileNames: options.fileNames.map(normalizeAbsolutePath).sort(),
+		options: options.parsed.options
+	};
+}
+function cloneParsedCheckerProjectConfig(parsedConfig) {
+	return {
+		extensions: [...parsedConfig.extensions],
+		fileNames: [...parsedConfig.fileNames],
+		options: { ...parsedConfig.options }
+	};
+}
+function resolveContextCheckerPresets(context) {
+	return context.checkerPresets.length > 0 ? [...new Set(context.checkerPresets)].sort((left, right) => left.localeCompare(right)) : ["tsc"];
+}
+function createParsedProjectConfigCacheKey(options) {
+	const configStat = statSync(options.configPath);
+	return JSON.stringify({
+		checkerPresets: options.checkerPresets,
+		configPath: normalizeAbsolutePath(options.configPath),
+		configSize: configStat.size,
+		configTime: configStat.mtimeMs,
+		extensions: normalizeExtensions(options.extensions),
+		projectRootDir: normalizeAbsolutePath(options.projectRootDir)
+	});
+}
+function createExtraFileExtensions(extensions) {
+	const nativeExtensions = new Set(getNativeTypeScriptProjectExtensions());
+	return extensions.filter((extension) => !nativeExtensions.has(extension)).map((extension) => ({
+		extension: extension.startsWith(".") ? extension.slice(1) : extension,
+		isMixedContent: true,
+		scriptKind: ts.ScriptKind.Deferred
+	}));
+}
+function parseProjectConfigWithExtraFileExtensions(options, extensions) {
+	const diagnostics = [];
+	const parsed = ts.getParsedCommandLineOfConfigFile(options.configPath, {}, {
+		...ts.sys,
+		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+			diagnostics.push(diagnostic);
+		}
+	}, void 0, void 0, createExtraFileExtensions(extensions));
+	if (!parsed) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, createFormatHost(options.projectRootDir)));
+	const errors = [...diagnostics, ...parsed.errors];
+	if (errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(errors, createFormatHost(options.projectRootDir)));
+	return createParsedCheckerProjectConfig({
+		extensions,
+		fileNames: parsed.fileNames,
+		parsed
+	});
+}
+function parseTypeScriptProjectConfig(options, extensions) {
+	const { diagnostics, parsed } = readTypeScriptProjectConfig(options);
+	const errors = [...diagnostics, ...parsed.errors];
+	if (errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(errors, createFormatHost(options.projectRootDir)));
+	return createParsedCheckerProjectConfig({
+		extensions,
+		fileNames: parsed.fileNames,
+		parsed
+	});
+}
+function isModuleNotFoundError(error) {
+	return error !== null && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND";
+}
+function createCheckerPackageRequire(options) {
+	for (const basePath of [path.join(options.projectRootDir, "package.json"), import.meta.url]) {
+		const requireFromBase = createRequire(basePath);
+		try {
+			return createRequire(requireFromBase.resolve(`${options.packageName}/package.json`));
+		} catch (error) {
+			if (error && typeof error === "object" && "code" in error && error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return createRequire(requireFromBase.resolve(options.packageName));
+			if (isModuleNotFoundError(error)) continue;
+			throw error;
+		}
+	}
+	return null;
+}
+function getVueLanguageCore(options) {
+	const requireFromChecker = createCheckerPackageRequire(options);
+	if (!requireFromChecker) throw new Error([
+		"Unable to resolve Vue checker package:",
+		`  package: ${options.packageName}`,
+		`  root: ${options.projectRootDir}`
+	].join("\n"));
+	try {
+		return requireFromChecker("@vue/language-core");
+	} catch (error) {
+		if (isModuleNotFoundError(error)) throw new Error([
+			"Unable to resolve Vue checker language core:",
+			`  checker package: ${options.packageName}`,
+			"  required package: @vue/language-core"
+		].join("\n"));
+		throw error;
+	}
+}
+function createVueParsedCommandLine(options) {
+	const vueLanguageCore = getVueLanguageCore({
+		packageName: options.packageName,
+		projectRootDir: options.projectRootDir
+	});
+	const configPath = normalizeAbsolutePath(options.configPath);
+	return {
+		commandLine: vueLanguageCore.createParsedCommandLine(ts, ts.sys, configPath),
+		configPath,
+		vueLanguageCore
+	};
+}
+function resolveVueProjectExtensions(options, packageName) {
+	const { commandLine, vueLanguageCore } = createVueParsedCommandLine({
+		configPath: options.configPath,
+		packageName,
+		projectRootDir: options.projectRootDir
+	});
+	try {
+		return normalizeExtensions([...getTypeScriptCheckerExtensions(), ...vueLanguageCore.getAllExtensions(commandLine.vueOptions)]);
+	} catch (error) {
+		throw new Error([
+			"Unable to resolve Vue checker extensions:",
+			`  checker package: ${packageName}`,
+			`  config: ${toRelativePath(options.projectRootDir, options.configPath)}`,
+			`  reason: ${String(error)}`
+		].join("\n"));
+	}
+}
+function parseProjectConfigWithExtensions(options, extensions) {
+	const resolvedExtensions = options.extensions && options.extensions.length > 0 ? options.extensions : extensions;
+	return createExtraFileExtensions(resolvedExtensions).length > 0 ? parseProjectConfigWithExtraFileExtensions(options, resolvedExtensions) : parseTypeScriptProjectConfig(options, resolvedExtensions);
+}
+function parseVueProjectConfig(options, packageName) {
+	const { commandLine, configPath, vueLanguageCore } = createVueParsedCommandLine({
+		configPath: options.configPath,
+		packageName,
+		projectRootDir: options.projectRootDir
+	});
+	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, path.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({
+		extensions,
+		fileNames: parsed.fileNames,
+		parsed
+	});
+}
+function resolveExtensionsForChecker(options, extensions) {
+	return normalizeExtensions(options.extensions && options.extensions.length > 0 ? options.extensions : extensions);
+}
+function resolveVueProjectExtensionsForChecker(options, packageName) {
+	return normalizeExtensions([...options.extensions ?? [], ...resolveVueProjectExtensions(options, packageName)]);
+}
+function isRelativeSpecifier(specifier) {
+	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function pathHasExtension(value) {
+	return path.extname(value).length > 0;
+}
+function candidatePathsForBasePath(basePath, extensions) {
+	if (pathHasExtension(basePath)) return [basePath];
+	return extensions.flatMap((extension) => [`${basePath}${extension}`, path.join(basePath, `index${extension}`)]);
+}
+function resolveCandidatePath(candidatePath) {
+	if (!existsSync(candidatePath)) return null;
+	if (!statSync(candidatePath).isFile()) return null;
+	return normalizeAbsolutePath(candidatePath);
+}
+function resolveRelativeModuleCandidate(options) {
+	if (!isRelativeSpecifier(options.specifier)) return null;
+	const resolvedSpecifierPath = path.resolve(path.dirname(options.containingFile), options.specifier);
+	for (const candidatePath of candidatePathsForBasePath(resolvedSpecifierPath, options.extensions)) {
+		const resolvedPath = resolveCandidatePath(candidatePath);
+		if (resolvedPath) return resolvedPath;
+	}
+	return null;
+}
+function matchPathPattern(pattern, specifier) {
+	const wildcardIndex = pattern.indexOf("*");
+	if (wildcardIndex === -1) return pattern === specifier ? "" : null;
+	const prefix = pattern.slice(0, wildcardIndex);
+	const suffix = pattern.slice(wildcardIndex + 1);
+	if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) return null;
+	return specifier.slice(prefix.length, specifier.length - suffix.length);
+}
+function applyPathPattern(pattern, matchedText) {
+	return pattern.includes("*") ? pattern.replace("*", matchedText) : pattern;
+}
+function getPathsBasePath(compilerOptions) {
+	const pathsBasePath = compilerOptions.pathsBasePath;
+	if (typeof pathsBasePath === "string") return pathsBasePath;
+	return compilerOptions.baseUrl ?? null;
+}
+function resolvePathMappedModuleCandidate(options) {
+	const paths = options.compilerOptions.paths;
+	const pathsBasePath = getPathsBasePath(options.compilerOptions);
+	if (!paths || !pathsBasePath) return null;
+	const pathEntries = Object.entries(paths).sort(([left], [right]) => {
+		const leftPrefixLength = left.split("*")[0]?.length ?? left.length;
+		return (right.split("*")[0]?.length ?? right.length) - leftPrefixLength;
+	});
+	for (const [alias, targets] of pathEntries) {
+		const matchedText = matchPathPattern(alias, options.specifier);
+		if (matchedText === null) continue;
+		for (const target of targets) {
+			const resolvedTargetPath = path.resolve(pathsBasePath, applyPathPattern(target, matchedText));
+			for (const candidatePath of candidatePathsForBasePath(resolvedTargetPath, options.extensions)) {
+				const resolvedPath = resolveCandidatePath(candidatePath);
+				if (resolvedPath) return resolvedPath;
+			}
+		}
+	}
+	return null;
+}
+function resolveTypeScriptModuleName(options) {
+	const resolved = ts.resolveModuleName(options.specifier, options.containingFile, options.compilerOptions, ts.sys).resolvedModule;
+	if (resolved?.resolvedFileName) return normalizeAbsolutePath(resolved.resolvedFileName);
+	return resolveRelativeModuleCandidate(options) ?? resolvePathMappedModuleCandidate(options);
+}
+function mergeParsedProjectConfigs(parsedConfigs, extensions) {
+	const firstConfig = parsedConfigs[0];
+	if (!firstConfig) throw new Error("Unable to parse checker project config: no parser ran.");
+	return {
+		extensions: normalizeExtensions([...extensions, ...parsedConfigs.flatMap((parsedConfig) => parsedConfig.extensions)]),
+		fileNames: [...new Set(parsedConfigs.flatMap((parsedConfig) => parsedConfig.fileNames))].sort(),
+		options: firstConfig.options
+	};
+}
+function parseCheckerProjectConfigForContext(options) {
+	const checkerPresets = resolveContextCheckerPresets(options.context);
+	const cacheKey = createParsedProjectConfigCacheKey({
+		checkerPresets,
+		configPath: options.configPath,
+		extensions: options.context.extensions,
+		projectRootDir: options.projectRootDir
+	});
+	const cached = parsedProjectConfigCache.get(cacheKey);
+	if (cached) return cloneParsedCheckerProjectConfig(cached);
+	const parsedConfig = mergeParsedProjectConfigs(checkerPresets.map((preset) => {
+		const adapter = getCheckerAdapter(preset);
+		if (!adapter) throw new Error(`Checker preset "${preset}" is not supported.`);
+		return adapter.parseProjectConfig({
+			configPath: options.configPath,
+			extensions: options.context.extensions,
+			projectRootDir: options.projectRootDir
+		});
+	}), options.context.extensions);
+	parsedProjectConfigCache.set(cacheKey, cloneParsedCheckerProjectConfig(parsedConfig));
+	return cloneParsedCheckerProjectConfig(parsedConfig);
+}
+function resolveModuleNameWithCheckers(options) {
+	const checkerPresets = options.context.checkerPresets.length > 0 ? options.context.checkerPresets : ["tsc"];
+	for (const preset of checkerPresets) {
+		const adapter = getCheckerAdapter(preset);
+		if (!adapter) continue;
+		const resolved = adapter.resolveModuleName({
+			compilerOptions: options.compilerOptions,
+			containingFile: options.containingFile,
+			extensions: options.context.extensions,
+			specifier: options.specifier
+		});
+		if (resolved) return resolved;
+	}
+	return null;
+}
+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
+	});
+}
+function createTscCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false"
+		],
+		command: options.commandOverride ?? "tsc",
+		label: `tsc -b ${relativeConfigPath}`
+	};
+}
+function createTsgoCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false"
+		],
+		command: "tsgo",
+		label: `tsgo -b ${relativeConfigPath}`
+	};
+}
+function createVueTscCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: [
+			"-b",
+			relativeConfigPath,
+			"--pretty",
+			"false"
+		],
+		command: "vue-tsc",
+		label: `${options.checker.name}: vue-tsc -b ${relativeConfigPath}`
+	};
+}
+function createVueTsgoCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	/**
+	* vue-tsgo exposes a --build flag, but in current releases that mode
+	* generates a transient virtual TS workspace and asks tsgo's LSP for
+	* diagnostics. It does not preserve TypeScript project-reference boundaries
+	* or provide incremental build semantics, so Limina only uses vue-tsgo as a
+	* second-class typecheck execution checker while still using its tsconfig
+	* entry for Limina's own graph and proof coverage. Prefer vue-tsc for
+	* first-class Vue build checks.
+	*/
+	return {
+		args: ["--project", relativeConfigPath],
+		command: "vue-tsgo",
+		label: `${options.checker.name}: vue-tsgo --project ${relativeConfigPath}`
+	};
+}
+function createSvelteCheckCommandTarget(options) {
+	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
+	return {
+		args: ["--tsconfig", relativeConfigPath],
+		command: "svelte-check",
+		label: `${options.checker.name}: svelte-check --tsconfig ${relativeConfigPath}`
+	};
+}
+const builtinCheckerAdapters = {
+	"svelte-check": {
+		createCommandTarget: createSvelteCheckCommandTarget,
+		extensions: (options) => resolveExtensionsForChecker(options, getSvelteCheckerExtensions()),
+		execution: "typecheck",
+		packageNames: ["svelte-check"],
+		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getSvelteCheckerExtensions()),
+		preset: "svelte-check",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: false
+	},
+	tsc: {
+		createCommandTarget: createTscCommandTarget,
+		extensions: (options) => resolveExtensionsForChecker(options, getTypeScriptCheckerExtensions()),
+		execution: "build",
+		packageNames: ["typescript"],
+		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getTypeScriptCheckerExtensions()),
+		preset: "tsc",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	},
+	tsgo: {
+		createCommandTarget: createTsgoCommandTarget,
+		extensions: (options) => resolveExtensionsForChecker(options, getTypeScriptCheckerExtensions()),
+		execution: "build",
+		packageNames: ["@typescript/native-preview"],
+		parseProjectConfig: (options) => parseProjectConfigWithExtensions(options, getTypeScriptCheckerExtensions()),
+		preset: "tsgo",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	},
+	"vue-tsc": {
+		createCommandTarget: createVueTscCommandTarget,
+		extensions: (options) => resolveVueProjectExtensionsForChecker(options, "vue-tsc"),
+		execution: "build",
+		packageNames: ["vue-tsc", "@vue/compiler-sfc"],
+		parseProjectConfig: (options) => parseVueProjectConfig(options, "vue-tsc"),
+		preset: "vue-tsc",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	},
+	"vue-tsgo": {
+		createCommandTarget: createVueTsgoCommandTarget,
+		extensions: (options) => resolveVueProjectExtensionsForChecker(options, "vue-tsgo"),
+		execution: "typecheck",
+		packageNames: ["vue-tsgo", "@typescript/native-preview"],
+		parseProjectConfig: (options) => parseVueProjectConfig(options, "vue-tsgo"),
+		preset: "vue-tsgo",
+		resolveModuleName: resolveTypeScriptModuleName,
+		sourceGraph: true
+	}
+};
+function isBuiltinCheckerPreset(value) {
+	return Object.hasOwn(builtinCheckerAdapters, value);
+}
+function getCheckerAdapter(preset) {
+	return isBuiltinCheckerPreset(preset) ? builtinCheckerAdapters[preset] : null;
+}
+function isVueCheckerPreset(preset) {
+	return preset === "vue-tsc" || preset === "vue-tsgo";
+}
+function resolveCheckerPackageFromRoot(options) {
+	const requireFromRoot = createRequire(path.join(options.projectRootDir, "package.json"));
+	try {
+		return requireFromRoot.resolve(`${options.packageName}/package.json`);
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return options.packageName;
+		if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") return;
+		throw error;
+	}
+}
+function collectMissingCheckerPeerDependencies(options) {
+	const resolvePackage = options.resolvePackage ?? resolveCheckerPackageFromRoot;
+	const missingCheckersByPackage = /* @__PURE__ */ new Map();
+	for (const checker of options.checkers) {
+		const packageNames = getCheckerAdapter(checker.preset)?.packageNames ?? [];
+		for (const packageName of packageNames) {
+			if (resolvePackage({
+				packageName,
+				projectRootDir: options.projectRootDir
+			})) continue;
+			const checkerNames = missingCheckersByPackage.get(packageName) ?? /* @__PURE__ */ new Set();
+			checkerNames.add(checker.name);
+			missingCheckersByPackage.set(packageName, checkerNames);
+		}
+	}
+	return [...missingCheckersByPackage.entries()].map(([packageName, checkerNames]) => ({
+		checkerNames: [...checkerNames].sort((left, right) => left.localeCompare(right)),
+		packageName
+	})).sort((left, right) => left.packageName.localeCompare(right.packageName));
+}
+function formatMissingCheckerPeerDependencies(missingDependencies) {
+	const packageNames = missingDependencies.map((dependency) => dependency.packageName);
+	return [
+		"Missing checker peer dependencies:",
+		...missingDependencies.map((dependency) => {
+			const checkerList = dependency.checkerNames.map((checkerName) => `"${checkerName}"`).join(", ");
+			return `  - ${dependency.packageName} (used by checker ${checkerList})`;
+		}),
+		`Fix: pnpm add -D ${packageNames.join(" ")}`
+	].join("\n");
+}
+function getCheckerExtensions(checker, options = {}) {
+	const adapter = getCheckerAdapter(checker.preset);
+	if (adapter) {
+		if (isVueCheckerPreset(checker.preset)) {
+			if (!options.projectRootDir) throw new Error([
+				"Unable to resolve Vue checker extensions:",
+				`  preset: ${checker.preset}`,
+				"  reason: Vue checker extensions must be read from the checker API and require a resolved project root."
+			].join("\n"));
+			return adapter.extensions({
+				configPath: normalizeAbsolutePath(path.resolve(options.projectRootDir, checker.entry)),
+				projectRootDir: options.projectRootDir
+			});
+		}
+		return adapter.extensions({
+			configPath: normalizeAbsolutePath(path.resolve(options.projectRootDir ?? "", checker.entry)),
+			projectRootDir: options.projectRootDir ?? ""
+		});
+	}
+	throw new Error(`Checker preset "${checker.preset}" is not supported.`);
+}
+function getResolvedCheckers(config) {
+	const checkers = config.config?.checkers;
+	if (!checkers) return [];
+	return Object.entries(checkers).map(([name, checker]) => ({
+		entry: checker.entry.trim(),
+		extensions: getCheckerExtensions(checker, { projectRootDir: config.rootDir }),
+		name,
+		preset: checker.preset
+	})).sort((left, right) => left.name.localeCompare(right.name));
+}
+function normalizeExtensions(extensions) {
+	return [...new Set(extensions)].sort((left, right) => {
+		const lengthDelta = right.length - left.length;
+		return lengthDelta === 0 ? left.localeCompare(right) : lengthDelta;
+	});
+}
+
+//#endregion
+//#region src/config.ts
+function defineConfig(config) {
+	return config;
+}
+const nonEmptyStringSchema = z.string().refine((value) => value.trim().length > 0);
+const checkerObjectSchema = z.looseObject({});
+const checkerConfigShapeSchema = z.looseObject({
+	entry: nonEmptyStringSchema,
+	preset: nonEmptyStringSchema
+});
+const liminaConfigShapeSchema = z.looseObject({
+	strict: z.boolean().optional(),
+	config: z.looseObject({ checkers: z.record(z.string(), checkerConfigShapeSchema).optional() }).optional()
+});
+function formatUnknownValue(value) {
+	if (value === void 0) return "undefined";
+	return JSON.stringify(value);
+}
+function formatZodPath(pathSegments) {
+	return pathSegments.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${String(segment)}`).join("").replace(/^\./u, "");
+}
+function getValueAtPath(value, pathSegments) {
+	let current = value;
+	for (const segment of pathSegments) {
+		if (current === void 0 || current === null) return;
+		current = current[segment];
+	}
+	return current;
+}
+function formatLiminaConfigShapeIssue(value, issue) {
+	const pathSegments = issue.path;
+	const field = formatZodPath(pathSegments);
+	if (pathSegments.length === 0) return "limina config must export or return an object.";
+	if (field === "config") return [
+		"Invalid Limina config:",
+		"  field: config",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: config must be an object."
+	].join("\n");
+	if (field === "strict") return [
+		"Invalid Limina config:",
+		"  field: strict",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: strict must be a boolean."
+	].join("\n");
+	if (field === "config.checkers") return [
+		"Invalid Limina checker config:",
+		"  field: config.checkers",
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		"  reason: config.checkers must be an object keyed by checker name."
+	].join("\n");
+	if (pathSegments[0] === "config" && pathSegments[1] === "checkers") {
+		const checkerName = pathSegments[2];
+		const checkerField = `config.checkers.${String(checkerName)}`;
+		if (pathSegments.length === 3) return [
+			"Invalid Limina checker config:",
+			`  field: ${checkerField}`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			"  reason: checker entries must be objects."
+		].join("\n");
+		if (pathSegments[3] === "preset") return [
+			"Invalid Limina checker config:",
+			`  field: ${checkerField}.preset`,
+			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+			"  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: checker entry must be a non-empty string path."
+		].join("\n");
+	}
+	return [
+		"Invalid Limina config:",
+		`  field: ${field}`,
+		`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
+		`  reason: ${issue.message}`
+	].join("\n");
+}
+function collectLiminaConfigShapeProblems(value) {
+	const result = liminaConfigShapeSchema.safeParse(value);
+	if (result.success) return [];
+	return result.error.issues.map((issue) => formatLiminaConfigShapeIssue(value, issue));
+}
+function collectCheckerConfigProblems(config) {
+	const problems = collectLiminaConfigShapeProblems(config);
+	if (!checkerObjectSchema.safeParse(config).success) return problems;
+	const checkers = config.config?.checkers;
+	if (checkers === void 0) return problems;
+	if (!checkerObjectSchema.safeParse(checkers).success) return problems;
+	for (const [checkerName, checker] of Object.entries(checkers)) {
+		const field = `config.checkers.${checkerName}`;
+		const checkerObjectResult = checkerObjectSchema.safeParse(checker);
+		if (!checkerObjectResult.success) continue;
+		const checkerRecord = checkerObjectResult.data;
+		const preset = checkerRecord.preset;
+		if (Object.hasOwn(checkerRecord, "extensions")) problems.push([
+			"Invalid Limina checker config:",
+			`  field: ${field}.extensions`,
+			`  value: ${formatUnknownValue(checkerRecord.extensions)}`,
+			"  reason: checker extensions are fixed by built-in presets and cannot be configured."
+		].join("\n"));
+		if (Object.hasOwn(checkerRecord, "routes")) problems.push([
+			"Invalid Limina checker config:",
+			`  field: ${field}.routes`,
+			`  value: ${formatUnknownValue(checkerRecord.routes)}`,
+			"  reason: checker routes are not supported; move routes.build to entry and migrate routes.typecheck targets to tsconfig*.dts.json leaves reachable from that entry with local companions."
+		].join("\n"));
+		if (typeof preset !== "string" || preset.trim().length === 0) continue;
+		if (!getCheckerAdapter(preset)) {
+			problems.push([
+				"Unsupported Limina checker preset:",
+				`  field: ${field}.preset`,
+				`  value: ${formatUnknownValue(preset)}`,
+				"  reason: configured checker entries require a built-in checker adapter."
+			].join("\n"));
+			continue;
+		}
+	}
+	return problems;
+}
+function collectReleaseConfigProblems(config) {
+	const problems = [];
+	if (!checkerObjectSchema.safeParse(config).success) return problems;
+	const release = config.release;
+	if (release === void 0) return problems;
+	if (!checkerObjectSchema.safeParse(release).success) {
+		problems.push([
+			"Invalid Limina release config:",
+			"  field: release",
+			`  value: ${formatUnknownValue(release)}`,
+			"  reason: release must be an object."
+		].join("\n"));
+		return problems;
+	}
+	const contentHash = release.contentHash;
+	if (contentHash === void 0) return problems;
+	if (!checkerObjectSchema.safeParse(contentHash).success) {
+		problems.push([
+			"Invalid Limina release config:",
+			"  field: release.contentHash",
+			`  value: ${formatUnknownValue(contentHash)}`,
+			"  reason: release.contentHash must be an object."
+		].join("\n"));
+		return problems;
+	}
+	const baselineTag = contentHash.baselineTag;
+	if (baselineTag !== void 0 && typeof baselineTag !== "function" && (typeof baselineTag !== "string" || baselineTag.trim().length === 0)) problems.push([
+		"Invalid Limina release config:",
+		"  field: release.contentHash.baselineTag",
+		`  value: ${formatUnknownValue(baselineTag)}`,
+		"  reason: baselineTag must be a non-empty string or function."
+	].join("\n"));
+	const builtinIgnore = contentHash.builtinIgnore;
+	if (builtinIgnore !== void 0 && typeof builtinIgnore !== "boolean") problems.push([
+		"Invalid Limina release config:",
+		"  field: release.contentHash.builtinIgnore",
+		`  value: ${formatUnknownValue(builtinIgnore)}`,
+		"  reason: builtinIgnore must be a boolean."
+	].join("\n"));
+	const ignore = contentHash.ignore;
+	if (ignore === void 0 || typeof ignore === "function") return problems;
+	if (!Array.isArray(ignore)) {
+		problems.push([
+			"Invalid Limina release config:",
+			"  field: release.contentHash.ignore",
+			`  value: ${formatUnknownValue(ignore)}`,
+			"  reason: ignore must be an array of non-empty strings or function."
+		].join("\n"));
+		return problems;
+	}
+	for (const [index, pattern] of ignore.entries()) {
+		if (typeof pattern === "string" && pattern.trim().length > 0) continue;
+		problems.push([
+			"Invalid Limina release config:",
+			`  field: release.contentHash.ignore[${index}]`,
+			`  value: ${formatUnknownValue(pattern)}`,
+			"  reason: ignore patterns must be non-empty strings."
+		].join("\n"));
+	}
+	return problems;
+}
+function collectNestedSourceCheckConfigProblems(config) {
+	const source = config?.config?.source;
+	const problems = [];
+	if (!source || typeof source !== "object") return problems;
+	if (Object.hasOwn(source, "unusedDependencies")) problems.push([
+		"Invalid Limina source config:",
+		"  field: config.source.unusedDependencies",
+		`  value: ${formatUnknownValue(source.unusedDependencies)}`,
+		"  reason: source.unusedDependencies belongs at the top-level source config, not under config.source."
+	].join("\n"));
+	if (Object.hasOwn(source, "unusedModules")) problems.push([
+		"Invalid Limina source config:",
+		"  field: config.source.unusedModules.ignore",
+		`  value: ${formatUnknownValue(source.unusedModules?.ignore)}`,
+		"  reason: source.unusedModules belongs at the top-level source config, not under config.source."
+	].join("\n"));
+	return problems;
+}
+function validateLiminaConfig(config) {
+	const problems = [
+		...collectCheckerConfigProblems(config),
+		...collectReleaseConfigProblems(config),
+		...collectNestedSourceCheckConfigProblems(config)
+	];
+	if (problems.length > 0) throw new Error(problems.join("\n\n"));
+}
+function isStrictConfig(config) {
+	return config.strict === true;
+}
+function getActiveCheckers(config) {
+	validateLiminaConfig(config);
+	return getResolvedCheckers(config);
+}
+function getActiveCheckerExtensions(config) {
+	return normalizeExtensions(getActiveCheckers(config).flatMap((checker) => checker.extensions));
+}
+function normalizeConfig(value) {
+	const config = value;
+	validateLiminaConfig(config);
+	return config;
+}
+function createConfigEnv(options) {
+	return {
+		command: options.command ?? "check",
+		mode: options.mode ?? process.env.NODE_ENV ?? "default"
+	};
+}
+function findPnpmWorkspaceRoot(startDir) {
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(currentDir, "pnpm-workspace.yaml"))) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function findLiminaConfigPath(startDir, rootDir) {
+	let currentDir = path.resolve(startDir);
+	const workspaceRootDir = path.resolve(rootDir);
+	while (isPathInsideDirectory(currentDir, workspaceRootDir)) {
+		const candidatePath = path.join(currentDir, "limina.config.mjs");
+		if (existsSync(candidatePath)) return candidatePath;
+		if (currentDir === workspaceRootDir) return null;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+	return null;
+}
+function inferWorkspaceRoot(startDir) {
+	const rootDir = findPnpmWorkspaceRoot(startDir);
+	if (!rootDir) throw new Error([`Unable to infer Limina workspace root from ${startDir}:`, "no pnpm-workspace.yaml was found in this directory or its parents."].join(" "));
+	return rootDir;
+}
+function validateConfigPathInsideWorkspace(configPath, rootDir) {
+	if (isPathInsideDirectory(configPath, rootDir)) return;
+	throw new Error([`Unable to load Limina config at ${configPath}:`, `config file must be inside the governed pnpm workspace at ${rootDir}.`].join(" "));
+}
+async function resolveConfigExport(configExport, configEnv) {
+	return normalizeConfig(typeof configExport === "function" ? await configExport(configEnv) : await configExport);
+}
+async function loadConfig(options = {}) {
+	const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+	const rootDir = inferWorkspaceRoot(cwd);
+	const configPath = options.configPath ? path.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}.`);
+	return {
+		...await resolveConfigExport((await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`)).default, createConfigEnv(options)),
+		configPath,
+		rootDir
+	};
+}
+
+//#endregion
+export { normalizeSlashes as _, loadConfig as a, toPosixPath as b, formatMissingCheckerPeerDependencies as c, parseCheckerProjectConfigForContext as d, resolveCheckerProjectExtensions as f, normalizeAbsolutePathIdentity as g, normalizeAbsolutePath as h, isStrictConfig as i, getCheckerAdapter as l, isPathInsideDirectory as m, getActiveCheckerExtensions as n, validateLiminaConfig as o, resolveModuleNameWithCheckers as p, getActiveCheckers as r, collectMissingCheckerPeerDependencies as s, defineConfig as t, normalizeExtensions as u, normalizeWorkspacePath as v, toRelativePath as x, toAbsolutePath as y };