limina 0.0.4 → 0.0.5

package/chunks/dep-ZRIm_-Zk.js

@@ -1,2401 +0,0 @@
-import { c as getCheckerAdapter, d as normalizeAbsolutePath, g as toRelativePath, h as toPosixPath, l as normalizeExtensions, o as collectMissingCheckerPeerDependencies, r as getActiveCheckers, s as formatMissingCheckerPeerDependencies, u as isPathInsideDirectory } from "./dep-DzYrmtQJ.js";
-import { builtinModules, createRequire } from "node:module";
-import { createElapsedTimer, formatErrorMessage, formatErrorMessage as formatErrorMessage$1 } from "logaria/helper";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import ts from "typescript";
-import { execFile, spawn } from "node:child_process";
-import { glob } from "tinyglobby";
-import { createLogger } from "logaria";
-import readline from "node:readline";
-import * as prompts from "@clack/prompts";
-import { mkdir, writeFile } from "node:fs/promises";
-import { parse } from "yaml";
-
-//#region src/tsconfig.ts
-const dtsConfigFilePattern = /^tsconfig(?:\..+)?\.dts\.json$/u;
-const buildGraphConfigFilePattern = /^tsconfig(?:\..+)?\.build\.json$/u;
-const generatedConfigFilePattern = /^tsconfig(?:\..+)?\.paths\.generated\.json$/u;
-const baseConfigFilePattern = /^tsconfig(?:\..+)?\.base\.json$/u;
-const checkConfigFilePattern = /^tsconfig(?:\..+)?\.check\.json$/u;
-const tsconfigFilePattern = /^tsconfig(?:\..+)?\.json$/u;
-function createFormatHost(rootDir) {
-	return {
-		getCanonicalFileName: (fileName) => fileName,
-		getCurrentDirectory: () => rootDir,
-		getNewLine: () => "\n"
-	};
-}
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-function createExtensionPattern(extensions) {
-	if (extensions.length === 0) return /(?!)/u;
-	return new RegExp(`(?:${extensions.sort((left, right) => right.length - left.length).map(escapeRegExp).join("|")})$`, "u");
-}
-function createExtraFileExtensions(extensions) {
-	const nativeExtensions = new Set([
-		".ts",
-		".tsx",
-		".cts",
-		".mts",
-		".d.ts",
-		".d.cts",
-		".d.mts",
-		".js",
-		".jsx",
-		".cjs",
-		".mjs",
-		".json"
-	]);
-	return extensions.filter((extension) => !nativeExtensions.has(extension)).map((extension) => ({
-		extension,
-		isMixedContent: true,
-		scriptKind: ts.ScriptKind.Deferred
-	}));
-}
-function readJsonConfigFile(rootDir, configPath) {
-	const result = ts.readConfigFile(configPath, ts.sys.readFile);
-	if (result.error) throw new Error(ts.formatDiagnostic(result.error, createFormatHost(rootDir)));
-	return result.config;
-}
-function readJsonConfig(config, configPath) {
-	return readJsonConfigFile(config.rootDir, configPath);
-}
-function resolveProjectConfigPath(baseDirectory, value) {
-	const candidate = value ? path.resolve(baseDirectory, value) : path.join(baseDirectory, "tsconfig.json");
-	if (existsSync(candidate) && statSync(candidate).isDirectory()) return normalizeAbsolutePath(path.join(candidate, "tsconfig.json"));
-	return normalizeAbsolutePath(candidate);
-}
-function resolveReferencePath(configPath, referencePath) {
-	const absoluteReferencePath = path.resolve(path.dirname(configPath), referencePath);
-	if (path.extname(absoluteReferencePath) === ".json") return normalizeAbsolutePath(absoluteReferencePath);
-	return normalizeAbsolutePath(path.join(absoluteReferencePath, "tsconfig.json"));
-}
-function getRawReferencePaths(config, configPath) {
-	return getRawReferencePathsForConfig(config.rootDir, configPath);
-}
-function getRawReferencePathsForConfig(rootDir, configPath) {
-	return collectReferencePathInfosForConfig(rootDir, configPath).references.map((reference) => reference.resolvedPath);
-}
-function formatUnknownValue$2(value) {
-	if (value === void 0) return "undefined";
-	return JSON.stringify(value);
-}
-function collectReferencePathInfosForConfig(rootDir, configPath) {
-	return collectReferencePathInfosFromConfigObject(rootDir, configPath, readJsonConfigFile(rootDir, configPath));
-}
-function collectReferencePathInfosFromConfigObject(rootDir, configPath, configObject) {
-	const references = configObject.references;
-	const problems = [];
-	const referenceInfos = [];
-	const formatConfigPath = (pathValue) => toRelativePath(rootDir, pathValue);
-	if (references === void 0) return {
-		problems,
-		references: referenceInfos
-	};
-	if (!Array.isArray(references)) {
-		problems.push([
-			"Invalid tsconfig references field:",
-			`  config: ${formatConfigPath(configPath)}`,
-			`  field: references`,
-			`  value: ${formatUnknownValue$2(references)}`,
-			"  reason: references must be an array of objects with a non-empty string path."
-		].join("\n"));
-		return {
-			problems,
-			references: referenceInfos
-		};
-	}
-	references.forEach((reference, index) => {
-		const field = `references[${index}]`;
-		if (!reference || typeof reference !== "object" || Array.isArray(reference)) {
-			problems.push([
-				"Invalid tsconfig reference entry:",
-				`  config: ${formatConfigPath(configPath)}`,
-				`  field: ${field}`,
-				`  value: ${formatUnknownValue$2(reference)}`,
-				"  reason: each reference entry must be an object with a non-empty string path."
-			].join("\n"));
-			return;
-		}
-		const pathValue = reference.path;
-		if (typeof pathValue !== "string" || pathValue.trim().length === 0) {
-			problems.push([
-				"Invalid tsconfig reference path:",
-				`  config: ${formatConfigPath(configPath)}`,
-				`  field: ${field}.path`,
-				`  value: ${formatUnknownValue$2(pathValue)}`,
-				"  reason: reference path must be a non-empty string."
-			].join("\n"));
-			return;
-		}
-		referenceInfos.push({
-			rawPath: pathValue,
-			resolvedPath: resolveReferencePath(configPath, pathValue)
-		});
-	});
-	return {
-		problems,
-		references: referenceInfos
-	};
-}
-function isDtsConfigPath(configPath) {
-	return dtsConfigFilePattern.test(path.basename(configPath));
-}
-function getDtsCompanionConfigPath(dtsConfigPath) {
-	const directory = path.dirname(dtsConfigPath);
-	const fileName = path.basename(dtsConfigPath);
-	const companionFileName = fileName === "tsconfig.dts.json" ? "tsconfig.json" : fileName.replace(/\.dts\.json$/u, ".json");
-	const scopedCompanionPath = normalizeAbsolutePath(path.join(directory, companionFileName));
-	if (companionFileName === "tsconfig.json" || existsSync(scopedCompanionPath)) return scopedCompanionPath;
-	return normalizeAbsolutePath(path.join(directory, "tsconfig.json"));
-}
-function isBuildGraphConfigPath(configPath) {
-	return buildGraphConfigFilePattern.test(path.basename(configPath));
-}
-function isReservedTypeScriptConfigFile(fileName) {
-	return dtsConfigFilePattern.test(fileName) || buildGraphConfigFilePattern.test(fileName) || generatedConfigFilePattern.test(fileName) || baseConfigFilePattern.test(fileName) || checkConfigFilePattern.test(fileName);
-}
-function isOrdinaryTypecheckConfigPath(configPath) {
-	const fileName = path.basename(configPath);
-	return tsconfigFilePattern.test(fileName) && !isReservedTypeScriptConfigFile(fileName);
-}
-function collectGraphProjectRouteFromRoot(options) {
-	const rootGraphConfigPath = normalizeAbsolutePath(options.rootConfigPath);
-	const seen = /* @__PURE__ */ new Set();
-	const orderedProjects = [];
-	const problems = [];
-	const rootReferences = collectReferencePathInfosForConfig(options.rootDir, rootGraphConfigPath);
-	const queue = rootReferences.references.map((reference) => ({
-		projectPath: reference.resolvedPath,
-		rawReferencePath: reference.rawPath,
-		referrerPath: rootGraphConfigPath
-	}));
-	const formatConfigPath = (configPath) => toRelativePath(options.rootDir, configPath);
-	problems.push(...rootReferences.problems);
-	if (!isBuildGraphConfigPath(rootGraphConfigPath) && !isDtsConfigPath(rootGraphConfigPath)) problems.push([
-		"Invalid checker entry config:",
-		`  config: ${formatConfigPath(rootGraphConfigPath)}`,
-		"  reason: checker entries should point to a tsconfig*.build.json graph aggregator or a direct tsconfig*.dts.json declaration leaf."
-	].join("\n"));
-	if (isDtsConfigPath(rootGraphConfigPath)) {
-		seen.add(rootGraphConfigPath);
-		orderedProjects.push(rootGraphConfigPath);
-	}
-	for (const { projectPath } of queue) seen.add(projectPath);
-	for (const { projectPath, rawReferencePath, referrerPath } of queue) {
-		if (!projectPath) continue;
-		if (!existsSync(projectPath)) {
-			problems.push([
-				"Checker entry references a missing tsconfig:",
-				`  from: ${formatConfigPath(referrerPath)}`,
-				`  reference: ${rawReferencePath}`,
-				`  resolved: ${formatConfigPath(projectPath)}`,
-				"  reason: every project reference reachable from a checker entry must point to an existing tsconfig file or directory with tsconfig.json."
-			].join("\n"));
-			continue;
-		}
-		if (!isBuildGraphConfigPath(projectPath) && !isDtsConfigPath(projectPath)) {
-			problems.push([
-				"Invalid checker entry reference:",
-				`  from: ${formatConfigPath(referrerPath)}`,
-				`  reference: ${rawReferencePath}`,
-				`  resolved: ${formatConfigPath(projectPath)}`,
-				"  reason: checker entries may only reach tsconfig*.build.json graph aggregators and tsconfig*.dts.json declaration leaves."
-			].join("\n"));
-			continue;
-		}
-		orderedProjects.push(projectPath);
-		const referenceCollection = collectReferencePathInfosForConfig(options.rootDir, projectPath);
-		problems.push(...referenceCollection.problems);
-		for (const reference of referenceCollection.references) {
-			const referencePath = reference.resolvedPath;
-			if (seen.has(referencePath)) continue;
-			seen.add(referencePath);
-			queue.push({
-				projectPath: referencePath,
-				rawReferencePath: reference.rawPath,
-				referrerPath: projectPath
-			});
-		}
-	}
-	return {
-		problems,
-		projectPaths: orderedProjects
-	};
-}
-function collectGraphProjectRoutes(config) {
-	const routes = [];
-	const problems = [];
-	for (const checker of getActiveCheckers(config)) {
-		if (!getCheckerAdapter(checker.preset)?.sourceGraph) continue;
-		const rootConfigPath = resolveProjectConfigPath(config.rootDir, checker.entry);
-		if (!existsSync(rootConfigPath)) {
-			problems.push([
-				"Checker graph entry references a missing tsconfig:",
-				`  checker: ${checker.name}`,
-				`  config: ${toRelativePath(config.rootDir, rootConfigPath)}`
-			].join("\n"));
-			continue;
-		}
-		const routeCollection = collectGraphProjectRouteFromRoot({
-			rootConfigPath,
-			rootDir: config.rootDir
-		});
-		problems.push(...routeCollection.problems);
-		routes.push({
-			checkerName: checker.name,
-			extensions: checker.extensions,
-			projectPaths: routeCollection.projectPaths,
-			rootConfigPath
-		});
-	}
-	return {
-		problems,
-		routes
-	};
-}
-function collectCheckerEntryProjectRoutes(config) {
-	const routes = [];
-	const problems = [];
-	for (const checker of getActiveCheckers(config)) {
-		const rootConfigPath = resolveProjectConfigPath(config.rootDir, checker.entry);
-		if (!existsSync(rootConfigPath)) {
-			problems.push([
-				"Checker entry references a missing tsconfig:",
-				`  checker: ${checker.name}`,
-				`  config: ${toRelativePath(config.rootDir, rootConfigPath)}`
-			].join("\n"));
-			continue;
-		}
-		const routeCollection = collectGraphProjectRouteFromRoot({
-			rootConfigPath,
-			rootDir: config.rootDir
-		});
-		problems.push(...routeCollection.problems);
-		routes.push({
-			checkerName: checker.name,
-			extensions: checker.extensions,
-			projectPaths: routeCollection.projectPaths,
-			rootConfigPath
-		});
-	}
-	return {
-		problems,
-		routes
-	};
-}
-function collectGraphProjectRoute(config) {
-	const routeCollection = collectGraphProjectRoutes(config);
-	return {
-		problems: routeCollection.problems,
-		projectPaths: [...new Set(routeCollection.routes.flatMap((route) => route.projectPaths))].sort()
-	};
-}
-function collectSourceGraphProjectExtensions(config) {
-	const routeCollection = collectGraphProjectRoutes(config);
-	const projectExtensionsByPath = /* @__PURE__ */ new Map();
-	const typeScriptExtensions = getCheckerAdapter("tsc")?.defaultExtensions ?? [];
-	for (const route of routeCollection.routes) {
-		const routeExtensions = normalizeExtensions([...typeScriptExtensions, ...route.extensions]);
-		for (const projectPath of route.projectPaths) projectExtensionsByPath.set(projectPath, normalizeExtensions([...projectExtensionsByPath.get(projectPath) ?? [], ...routeExtensions]));
-	}
-	return {
-		problems: routeCollection.problems,
-		projectExtensionsByPath
-	};
-}
-function parseProjectFileNamesForExtensions(config, configPath, extensions, pattern = createExtensionPattern(extensions)) {
-	const diagnostics = [];
-	const configObject = readJsonConfig(config, configPath);
-	const parsed = ts.parseJsonConfigFileContent(configObject, ts.sys, path.dirname(configPath), {}, configPath, void 0, createExtraFileExtensions(extensions));
-	if (diagnostics.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, createFormatHost(config.rootDir)));
-	if (parsed.errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(parsed.errors, createFormatHost(config.rootDir)));
-	return parsed.fileNames.filter((fileName) => pattern.test(fileName)).map(normalizeAbsolutePath);
-}
-function formatReferences(rootDir, references) {
-	if (references.size === 0) return "(none)";
-	return [...references].sort().map((value) => toRelativePath(rootDir, value)).join(", ");
-}
-
-//#endregion
-//#region src/workspace.ts
-const pnpmWorkspaceFileName$1 = "pnpm-workspace.yaml";
-const pnpmWorkspaceListTimeoutMs = 3e3;
-function readJsonFile(filePath) {
-	return JSON.parse(readFileSync(filePath, "utf8"));
-}
-function stripYamlQuotes(value) {
-	const trimmed = value.trim();
-	if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
-	return trimmed;
-}
-function collectPnpmWorkspacePatterns(source) {
-	const patterns = [];
-	const lines = source.split(/\r?\n/u);
-	let isInsidePackagesSection = false;
-	for (const rawLine of lines) {
-		const line = rawLine.replaceAll("	", "    ");
-		const trimmedLine = line.trim();
-		if (!isInsidePackagesSection) {
-			if (trimmedLine === "packages:") isInsidePackagesSection = true;
-			continue;
-		}
-		if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) continue;
-		if (line.length - line.trimStart().length === 0) break;
-		if (trimmedLine.startsWith("- ")) patterns.push(stripYamlQuotes(trimmedLine.slice(2)));
-	}
-	return patterns;
-}
-function parsePnpmWorkspaceListJson(source) {
-	const parsed = JSON.parse(source);
-	if (!Array.isArray(parsed)) return [];
-	return parsed.flatMap((entry) => {
-		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
-		const record = entry;
-		if (typeof record.name !== "string" || typeof record.path !== "string") return [];
-		return [{
-			name: record.name,
-			path: record.path
-		}];
-	});
-}
-function collectWorkspacePatterns(config) {
-	const rootPackageJsonPath = path.join(config.rootDir, "package.json");
-	const patterns = /* @__PURE__ */ new Set();
-	if (existsSync(rootPackageJsonPath)) {
-		const rootPackageJson = readJsonFile(rootPackageJsonPath);
-		if (Array.isArray(rootPackageJson.workspaces)) for (const pattern of rootPackageJson.workspaces) patterns.add(pattern);
-	}
-	const workspacePath = path.join(config.rootDir, pnpmWorkspaceFileName$1);
-	if (existsSync(workspacePath)) for (const pattern of collectPnpmWorkspacePatterns(readFileSync(workspacePath, "utf8"))) patterns.add(pattern);
-	return [...patterns].sort();
-}
-function runTextCommand(command, args, cwd) {
-	return new Promise((resolve, reject) => {
-		execFile(command, args, {
-			cwd,
-			encoding: "utf8",
-			maxBuffer: 10 * 1024 * 1024,
-			timeout: pnpmWorkspaceListTimeoutMs
-		}, (error, stdout) => {
-			if (error) {
-				reject(error);
-				return;
-			}
-			resolve(stdout);
-		});
-	});
-}
-function getPnpmCommandCandidates() {
-	const candidates = [];
-	const npmExecPath = process.env.npm_execpath;
-	if (npmExecPath?.includes("pnpm")) candidates.push({
-		argsPrefix: [npmExecPath],
-		command: process.execPath
-	});
-	candidates.push({
-		argsPrefix: ["pnpm"],
-		command: "corepack"
-	}, {
-		argsPrefix: [],
-		command: "pnpm"
-	});
-	const seen = /* @__PURE__ */ new Set();
-	return candidates.filter((candidate) => {
-		const key = `${candidate.command}\0${candidate.argsPrefix.join("\0")}`;
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-async function collectPnpmListedPackages(config) {
-	const args = [
-		"recursive",
-		"list",
-		"--depth",
-		"-1",
-		"--json"
-	];
-	for (const candidate of getPnpmCommandCandidates()) try {
-		const entries = parsePnpmWorkspaceListJson(await runTextCommand(candidate.command, [...candidate.argsPrefix, ...args], config.rootDir));
-		const packages = [];
-		for (const entry of entries) {
-			if (!entry.path) continue;
-			const directory = normalizeAbsolutePath(entry.path);
-			const packageJsonPath = path.join(directory, "package.json");
-			if (!existsSync(packageJsonPath)) continue;
-			const manifest = readJsonFile(packageJsonPath);
-			const name = manifest.name ?? entry.name;
-			if (!name) continue;
-			packages.push({
-				directory,
-				manifest,
-				name
-			});
-		}
-		if (packages.length > 0) return packages;
-	} catch {}
-	return [];
-}
-async function collectWorkspacePackagesFromPatterns(config) {
-	const workspacePatterns = collectWorkspacePatterns(config);
-	const includePatterns = workspacePatterns.filter((pattern) => !pattern.startsWith("!")).map((pattern) => `${pattern.replace(/\/$/u, "")}/package.json`);
-	const ignorePatterns = workspacePatterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => `${pattern.slice(1).replace(/\/$/u, "")}/**`);
-	const packageJsonPaths = await glob(includePatterns, {
-		cwd: config.rootDir,
-		absolute: false,
-		ignore: [
-			"**/node_modules/**",
-			"**/dist/**",
-			...ignorePatterns
-		]
-	});
-	const packages = [];
-	for (const packageJsonPath of [...new Set(packageJsonPaths)].sort()) {
-		const manifest = readJsonFile(path.join(config.rootDir, packageJsonPath));
-		if (!manifest.name) continue;
-		packages.push({
-			directory: normalizeAbsolutePath(path.dirname(path.join(config.rootDir, packageJsonPath))),
-			manifest,
-			name: manifest.name
-		});
-	}
-	return packages;
-}
-function mergeWorkspacePackages(packages) {
-	const byDirectory = /* @__PURE__ */ new Map();
-	for (const workspacePackage of packages) byDirectory.set(workspacePackage.directory, workspacePackage);
-	return [...byDirectory.values()].sort((left, right) => left.name.localeCompare(right.name));
-}
-async function collectWorkspacePackages(config) {
-	const [pnpmPackages, patternPackages] = await Promise.all([collectPnpmListedPackages(config), collectWorkspacePackagesFromPatterns(config)]);
-	return mergeWorkspacePackages([...pnpmPackages, ...patternPackages]);
-}
-async function collectPackageOwners(config) {
-	const packageJsonPaths = await glob(["package.json", "**/package.json"], {
-		cwd: config.rootDir,
-		absolute: false,
-		ignore: [
-			"**/.git/**",
-			"**/.pnpm-store/**",
-			"**/.tsbuild/**",
-			"**/coverage/**",
-			"**/dist/**",
-			"**/node_modules/**"
-		]
-	});
-	return [...new Set(packageJsonPaths)].sort().map((packageJsonPath) => {
-		const absolutePackageJsonPath = normalizeAbsolutePath(path.join(config.rootDir, packageJsonPath));
-		const manifest = readJsonFile(absolutePackageJsonPath);
-		return {
-			directory: normalizeAbsolutePath(path.dirname(absolutePackageJsonPath)),
-			manifest,
-			name: manifest.name,
-			packageJsonPath: absolutePackageJsonPath
-		};
-	}).sort((left, right) => right.directory.length - left.directory.length);
-}
-function getDependencySections(importer) {
-	return [
-		importer.dependencies,
-		importer.devDependencies,
-		importer.optionalDependencies,
-		importer.peerDependencies
-	].filter((section) => Boolean(section));
-}
-function getPublishDependencySections(importer) {
-	return [
-		{
-			dependencies: importer.dependencies,
-			name: "dependencies"
-		},
-		{
-			dependencies: importer.peerDependencies,
-			name: "peerDependencies"
-		},
-		{
-			dependencies: importer.optionalDependencies,
-			name: "optionalDependencies"
-		}
-	].filter((section) => Boolean(section.dependencies));
-}
-function isWorkspaceDependencySpecifier(specifier) {
-	return specifier.startsWith("workspace:");
-}
-function getPackageRootSpecifier(specifier) {
-	if (specifier.startsWith("@")) {
-		const [scope, name] = specifier.split("/");
-		return scope && name ? `${scope}/${name}` : specifier;
-	}
-	return specifier.split("/")[0] ?? specifier;
-}
-function findPackageForSpecifier(specifier, packages) {
-	const packageName = getPackageRootSpecifier(specifier);
-	return packages.find((workspacePackage) => workspacePackage.name === packageName) ?? null;
-}
-function collectImporters(config, packages) {
-	const workspacePackageNames = new Set(packages.map((workspacePackage) => workspacePackage.name));
-	const importerDirectories = new Set([config.rootDir, ...packages.map((workspacePackage) => workspacePackage.directory)]);
-	const importers = [];
-	for (const importerDirectory of importerDirectories) {
-		const packageJsonPath = path.join(importerDirectory, "package.json");
-		if (!existsSync(packageJsonPath)) continue;
-		const manifest = readJsonFile(packageJsonPath);
-		const workspaceDependencies = /* @__PURE__ */ new Set();
-		for (const dependencies of getDependencySections(manifest)) for (const [dependencyName, specifier] of Object.entries(dependencies)) {
-			if (!workspacePackageNames.has(dependencyName) || !isWorkspaceDependencySpecifier(specifier)) continue;
-			workspaceDependencies.add(dependencyName);
-		}
-		importers.push({
-			directory: importerDirectory,
-			name: manifest.name,
-			workspaceDependencies
-		});
-	}
-	return importers.sort((left, right) => right.directory.length - left.directory.length);
-}
-
-//#endregion
-//#region src/graph-context.ts
-function isRelativeSpecifier$1(specifier) {
-	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
-}
-function isDtsProjectConfig(configPath) {
-	return isDtsConfigPath(configPath);
-}
-function getTypecheckConfigPath(dtsConfigPath) {
-	return getDtsCompanionConfigPath(dtsConfigPath);
-}
-function formatUnknownValue$1(value) {
-	if (value === void 0) return "undefined";
-	return JSON.stringify(value);
-}
-function readProjectLabel(config, configPath) {
-	if (!isDtsProjectConfig(configPath)) return {
-		label: null,
-		labelProblem: null
-	};
-	const configObject = readJsonConfig(config, configPath);
-	if (!Object.hasOwn(configObject, "limina")) return {
-		label: null,
-		labelProblem: null
-	};
-	const value = configObject.limina;
-	if (typeof value === "string" && value.trim()) return {
-		label: value.trim(),
-		labelProblem: null
-	};
-	return {
-		label: null,
-		labelProblem: [
-			"Invalid Limina graph label:",
-			`  project: ${toRelativePath(config.rootDir, configPath)}`,
-			`  field: limina`,
-			`  value: ${formatUnknownValue$1(value)}`,
-			"  reason: tsconfig*.dts.json may declare one non-empty string label with \"limina\"."
-		].join("\n")
-	};
-}
-function parseProject(config, configPath, extensions) {
-	const diagnostics = [];
-	const parsed = extensions ? ts.parseJsonConfigFileContent(readJsonConfig(config, configPath), ts.sys, path.dirname(configPath), {}, configPath, void 0, createExtraFileExtensions(extensions)) : ts.getParsedCommandLineOfConfigFile(configPath, {}, {
-		...ts.sys,
-		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
-			diagnostics.push(diagnostic);
-		}
-	});
-	if (!parsed) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-		getCanonicalFileName: (fileName) => fileName,
-		getCurrentDirectory: () => config.rootDir,
-		getNewLine: () => "\n"
-	}));
-	if (parsed.errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(parsed.errors, {
-		getCanonicalFileName: (fileName) => fileName,
-		getCurrentDirectory: () => config.rootDir,
-		getNewLine: () => "\n"
-	}));
-	const labelInfo = readProjectLabel(config, configPath);
-	const projectExtensions = extensions ?? [
-		".ts",
-		".tsx",
-		".cts",
-		".mts",
-		".d.ts",
-		".d.cts",
-		".d.mts"
-	];
-	const filePattern = createExtensionPattern(projectExtensions);
-	return {
-		configPath: normalizeAbsolutePath(configPath),
-		extensions: projectExtensions,
-		fileNames: parsed.fileNames.filter((fileName) => filePattern.test(fileName)).map(normalizeAbsolutePath),
-		label: labelInfo.label,
-		labelProblem: labelInfo.labelProblem,
-		options: parsed.options,
-		references: new Set(getRawReferencePaths(config, configPath))
-	};
-}
-function getSourceFileKind(filePath) {
-	if (filePath.endsWith(".tsx")) return ts.ScriptKind.TSX;
-	if (filePath.endsWith(".jsx")) return ts.ScriptKind.JSX;
-	return ts.ScriptKind.TS;
-}
-function stringLiteralValue(node) {
-	return node && ts.isStringLiteralLike(node) ? node.text : null;
-}
-function getVueCompilerSfc(rootDir) {
-	const requireFromRoot = createRequire(path.join(rootDir, "package.json"));
-	try {
-		return requireFromRoot("@vue/compiler-sfc");
-	} catch (error) {
-		if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") throw new Error("Vue source graph support requires @vue/compiler-sfc. Fix: pnpm add -D @vue/compiler-sfc");
-		throw error;
-	}
-}
-function getVueBlockScriptKind(block) {
-	return block.lang === "tsx" || block.lang === "jsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-}
-function collectImportsFromSourceText(options) {
-	const sourceFile = ts.createSourceFile(options.filePath, options.sourceText, ts.ScriptTarget.Latest, true, options.scriptKind);
-	const imports = [];
-	const lineOffset = options.lineOffset ?? 0;
-	const addImport = (specifier, node) => {
-		const location = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-		imports.push({
-			filePath: options.filePath,
-			line: lineOffset + location.line + 1,
-			specifier
-		});
-	};
-	const visit = (node) => {
-		if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-			const specifier = stringLiteralValue(node.moduleSpecifier);
-			if (specifier) addImport(specifier, node);
-		} else if (ts.isImportTypeNode(node)) {
-			const specifier = ts.isLiteralTypeNode(node.argument) ? stringLiteralValue(node.argument.literal) : null;
-			if (specifier) addImport(specifier, node);
-		} else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-			const specifier = stringLiteralValue(node.arguments[0]);
-			if (specifier) addImport(specifier, node);
-		}
-		ts.forEachChild(node, visit);
-	};
-	visit(sourceFile);
-	return imports;
-}
-function collectVueImportsFromFile(filePath, rootDir) {
-	const sourceText = readFileSync(filePath, "utf8");
-	const result = getVueCompilerSfc(rootDir).parse(sourceText, { filename: filePath });
-	if (result.errors.length > 0) throw new Error(`Failed to parse Vue SFC imports for ${toRelativePath(rootDir, filePath)}: ${String(result.errors[0])}`);
-	return [result.descriptor.script, result.descriptor.scriptSetup].filter((block) => Boolean(block && !block.src)).flatMap((block) => collectImportsFromSourceText({
-		filePath,
-		lineOffset: block.loc.start.line - 1,
-		scriptKind: getVueBlockScriptKind(block),
-		sourceText: block.content
-	}));
-}
-function collectImportsFromFile(filePath, rootDir) {
-	if (filePath.endsWith(".vue")) return collectVueImportsFromFile(filePath, rootDir);
-	return collectImportsFromSourceText({
-		filePath,
-		scriptKind: getSourceFileKind(filePath),
-		sourceText: readFileSync(filePath, "utf8")
-	});
-}
-function resolveInternalImport(specifier, containingFile, options, extensions = []) {
-	const resolved = ts.resolveModuleName(specifier, containingFile, options, ts.sys).resolvedModule;
-	if (resolved?.resolvedFileName) return normalizeAbsolutePath(resolved.resolvedFileName);
-	if (!isRelativeSpecifier$1(specifier)) return null;
-	const resolvedSpecifierPath = path.resolve(path.dirname(containingFile), specifier);
-	const candidatePaths = path.extname(specifier) ? [resolvedSpecifierPath] : extensions.flatMap((extension) => [`${resolvedSpecifierPath}${extension}`, path.join(resolvedSpecifierPath, `index${extension}`)]);
-	for (const candidatePath of candidatePaths) {
-		if (!existsSync(candidatePath)) continue;
-		if (!statSync(candidatePath).isFile()) continue;
-		return normalizeAbsolutePath(candidatePath);
-	}
-	return null;
-}
-function chooseOwningProject(projectPaths) {
-	return [...projectPaths].sort((left, right) => {
-		const directoryDepthDelta = path.dirname(right).length - path.dirname(left).length;
-		return directoryDepthDelta === 0 ? left.localeCompare(right) : directoryDepthDelta;
-	})[0];
-}
-function findPackageForFile(filePath, packages) {
-	return [...packages].sort((left, right) => right.directory.length - left.directory.length).find((workspacePackage) => isPathInsideDirectory(filePath, workspacePackage.directory)) ?? null;
-}
-function findImporterForFile(filePath, importers) {
-	return importers.find((importer) => isPathInsideDirectory(filePath, importer.directory)) ?? null;
-}
-function shouldResolveThroughGraph(importer, targetPackage) {
-	if (!importer || !targetPackage) return false;
-	return importer.name === targetPackage.name || importer.workspaceDependencies.has(targetPackage.name);
-}
-function formatArtifactDependencyPolicy(targetPackage) {
-	return targetPackage.manifest.private === true ? "private workspace packages cannot be consumed from a registry, so artifact consumers should use link: and should not keep a project reference." : "artifact consumers should use link: for local dist output, or catalog:/semver to consume the published production package, and should not keep a project reference.";
-}
-function inferPackageProject(resolvedFilePath, workspacePackage, projectPaths) {
-	if (!isPathInsideDirectory(resolvedFilePath, workspacePackage.directory)) return null;
-	return projectPaths.find((projectPath) => {
-		return projectPath.startsWith(`${workspacePackage.directory}/`) && projectPath.endsWith("/tsconfig.lib.dts.json");
-	}) ?? null;
-}
-function createFileOwnerLookup(projects) {
-	const ownerLookup = /* @__PURE__ */ new Map();
-	for (const project of projects) for (const fileName of project.fileNames) {
-		const owners = ownerLookup.get(fileName) ?? [];
-		owners.push(project.configPath);
-		ownerLookup.set(fileName, owners);
-	}
-	return ownerLookup;
-}
-function findTargetProject(options) {
-	const ownerProjects = options.fileOwnerLookup.get(options.resolvedFilePath);
-	if (ownerProjects && ownerProjects.length > 0) return chooseOwningProject(ownerProjects);
-	const workspacePackage = findPackageForSpecifier(options.specifier, options.packages);
-	if (!workspacePackage) return null;
-	return inferPackageProject(options.resolvedFilePath, workspacePackage, options.projectPaths);
-}
-
-//#endregion
-//#region src/graph-rules.ts
-const nodeBuiltinNames = new Set(builtinModules.flatMap((specifier) => {
-	const normalized = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-	return [normalized, `node:${normalized}`];
-}));
-function isPlainRecord(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
-}
-function formatUnknownValue(value) {
-	if (value === void 0) return "undefined";
-	return JSON.stringify(value);
-}
-function addRuleEntryConfigProblem(problems, details) {
-	problems.push(["Invalid graph rule config:", ...details].join("\n"));
-}
-function isUrlOrDataOrFileSpecifier$1(specifier) {
-	return specifier.startsWith("data:") || specifier.startsWith("file:") || specifier.startsWith("http:") || specifier.startsWith("https:");
-}
-function isRelativeSpecifier(specifier) {
-	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
-}
-function isPackageImportPattern(name) {
-	return name.startsWith("#");
-}
-function matchWildcardPattern(pattern, value) {
-	if (pattern === value) return true;
-	const wildcardIndex = pattern.indexOf("*");
-	if (wildcardIndex === -1) return false;
-	const prefix = pattern.slice(0, wildcardIndex);
-	const suffix = pattern.slice(wildcardIndex + 1);
-	return value.startsWith(prefix) && value.endsWith(suffix);
-}
-function getNodeBuiltinRuleName(name) {
-	if (name === "node:*") return {
-		matchAllNodeBuiltins: true,
-		normalizedName: "*"
-	};
-	const normalizedName = name.startsWith("node:") ? name.slice(5) : name;
-	if (!nodeBuiltinNames.has(normalizedName)) return null;
-	return {
-		matchAllNodeBuiltins: false,
-		normalizedName
-	};
-}
-function createNormalizedDep(name, reason) {
-	const nodeBuiltin = getNodeBuiltinRuleName(name);
-	if (nodeBuiltin) return {
-		kind: "node-builtin",
-		matchAllNodeBuiltins: nodeBuiltin.matchAllNodeBuiltins,
-		name,
-		normalizedName: nodeBuiltin.normalizedName,
-		reason
-	};
-	if (isPackageImportPattern(name)) return {
-		kind: "package-import",
-		matchAllNodeBuiltins: false,
-		name,
-		normalizedName: name,
-		reason
-	};
-	if (isRelativeSpecifier(name) || isUrlOrDataOrFileSpecifier$1(name) || path.isAbsolute(name) || getPackageRootSpecifier(name) !== name) return null;
-	return {
-		kind: "package",
-		matchAllNodeBuiltins: false,
-		name,
-		normalizedName: name,
-		reason
-	};
-}
-function getRulesRecord(config, problems) {
-	const rules = config.graph?.rules;
-	if (rules === void 0) return {};
-	if (!isPlainRecord(rules)) {
-		problems.push([
-			"Invalid graph rules config:",
-			"  field: graph.rules",
-			`  value: ${formatUnknownValue(rules)}`,
-			"  reason: graph.rules must be an object keyed by Limina labels."
-		].join("\n"));
-		return {};
-	}
-	return rules;
-}
-function addNormalizedRuleRef(options) {
-	const field = `graph.rules.${options.label}.deny.refs[${options.index}]`;
-	if (!isPlainRecord(options.entry)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}`,
-			`  value: ${formatUnknownValue(options.entry)}`,
-			"  reason: deny.refs entries must be objects with non-empty path and reason fields."
-		]);
-		return;
-	}
-	const pathValue = options.entry.path;
-	const reasonValue = options.entry.reason;
-	if (!isNonEmptyString(pathValue)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.path`,
-			`  value: ${formatUnknownValue(pathValue)}`,
-			"  reason: deny.refs path is required and must be a non-empty string."
-		]);
-		return;
-	}
-	if (!isNonEmptyString(reasonValue)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.reason`,
-			`  value: ${formatUnknownValue(reasonValue)}`,
-			"  reason: deny.refs reason is required and must be a non-empty string."
-		]);
-		return;
-	}
-	const refPath = normalizeAbsolutePath(path.resolve(options.config.rootDir, pathValue));
-	if (!options.projectPathSet.has(refPath)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.path`,
-			`  path: ${pathValue}`,
-			"  reason: deny.refs path must point to a project reachable from a checker entry."
-		]);
-		return;
-	}
-	if (!isDtsProjectConfig(refPath)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.path`,
-			`  path: ${pathValue}`,
-			"  reason: deny.refs path must point to a tsconfig*.dts.json declaration leaf."
-		]);
-		return;
-	}
-	const refs = options.refsByLabel.get(options.label) ?? /* @__PURE__ */ new Map();
-	refs.set(refPath, {
-		path: refPath,
-		reason: reasonValue.trim()
-	});
-	options.refsByLabel.set(options.label, refs);
-}
-function addNormalizedDep(options) {
-	const field = `graph.rules.${options.label}.deny.deps[${options.index}]`;
-	if (!isPlainRecord(options.entry)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}`,
-			`  value: ${formatUnknownValue(options.entry)}`,
-			"  reason: deny.deps entries must be objects with non-empty name and reason fields."
-		]);
-		return;
-	}
-	const nameValue = options.entry.name;
-	const reasonValue = options.entry.reason;
-	if (!isNonEmptyString(nameValue)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.name`,
-			`  value: ${formatUnknownValue(nameValue)}`,
-			"  reason: deny.deps name is required and must be a non-empty string."
-		]);
-		return;
-	}
-	if (!isNonEmptyString(reasonValue)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.reason`,
-			`  value: ${formatUnknownValue(reasonValue)}`,
-			"  reason: deny.deps reason is required and must be a non-empty string."
-		]);
-		return;
-	}
-	const name = nameValue.trim();
-	const normalizedDep = createNormalizedDep(name, reasonValue.trim());
-	if (!normalizedDep) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.name`,
-			`  name: ${name}`,
-			"  reason: deny.deps name must be a package root, a package.json imports specifier such as \"#internal/*\", or a Node builtin such as \"fs\", \"node:fs\", or \"node:*\"."
-		]);
-		return;
-	}
-	const deps = options.depsByLabel.get(options.label) ?? [];
-	deps.push(normalizedDep);
-	options.depsByLabel.set(options.label, deps);
-}
-function shouldNormalizeRuleKind(include, kind) {
-	return include?.[kind] ?? true;
-}
-function normalizeGraphRules(options) {
-	const depsByLabel = /* @__PURE__ */ new Map();
-	const refsByLabel = /* @__PURE__ */ new Map();
-	const projectPathSet = new Set(options.projectPaths);
-	for (const [rawLabel, rawRule] of Object.entries(getRulesRecord(options.config, options.problems))) {
-		const label = rawLabel.trim();
-		if (!label) {
-			addRuleEntryConfigProblem(options.problems, ["  field: graph.rules", "  reason: graph.rules keys must be non-empty labels."]);
-			continue;
-		}
-		if (!isPlainRecord(rawRule)) {
-			addRuleEntryConfigProblem(options.problems, [
-				`  field: graph.rules.${rawLabel}`,
-				`  value: ${formatUnknownValue(rawRule)}`,
-				"  reason: each graph rule must be an object."
-			]);
-			continue;
-		}
-		if (rawRule.deny === void 0) continue;
-		if (!isPlainRecord(rawRule.deny)) {
-			addRuleEntryConfigProblem(options.problems, [
-				`  field: graph.rules.${label}.deny`,
-				`  value: ${formatUnknownValue(rawRule.deny)}`,
-				"  reason: graph rule deny must be an object."
-			]);
-			continue;
-		}
-		const refs = rawRule.deny.refs;
-		if (shouldNormalizeRuleKind(options.include, "refs") && refs !== void 0) if (!Array.isArray(refs)) addRuleEntryConfigProblem(options.problems, [
-			`  field: graph.rules.${label}.deny.refs`,
-			`  value: ${formatUnknownValue(refs)}`,
-			"  reason: deny.refs must be an array."
-		]);
-		else refs.forEach((entry, index) => {
-			addNormalizedRuleRef({
-				config: options.config,
-				entry,
-				index,
-				label,
-				problems: options.problems,
-				projectPathSet,
-				refsByLabel
-			});
-		});
-		if (shouldNormalizeRuleKind(options.include, "deps") && rawRule.deny.workspaceDeps !== void 0) addRuleEntryConfigProblem(options.problems, [
-			`  field: graph.rules.${label}.deny.workspaceDeps`,
-			`  value: ${formatUnknownValue(rawRule.deny.workspaceDeps)}`,
-			"  reason: deny.workspaceDeps has been removed; use deny.deps."
-		]);
-		if (shouldNormalizeRuleKind(options.include, "deps") && rawRule.deny.nodeBuiltins !== void 0) addRuleEntryConfigProblem(options.problems, [
-			`  field: graph.rules.${label}.deny.nodeBuiltins`,
-			`  value: ${formatUnknownValue(rawRule.deny.nodeBuiltins)}`,
-			"  reason: deny.nodeBuiltins has been removed; use deny.deps."
-		]);
-		const deps = rawRule.deny.deps;
-		if (shouldNormalizeRuleKind(options.include, "deps") && deps !== void 0) if (!Array.isArray(deps)) addRuleEntryConfigProblem(options.problems, [
-			`  field: graph.rules.${label}.deny.deps`,
-			`  value: ${formatUnknownValue(deps)}`,
-			"  reason: deny.deps must be an array."
-		]);
-		else deps.forEach((entry, index) => {
-			addNormalizedDep({
-				depsByLabel,
-				entry,
-				index,
-				label,
-				problems: options.problems
-			});
-		});
-	}
-	return {
-		depsByLabel,
-		refsByLabel
-	};
-}
-function isNodeBuiltinSpecifier(specifier) {
-	return nodeBuiltinNames.has(specifier);
-}
-function getDeniedRefRule(rules, label, targetProjectPath) {
-	if (!label) return null;
-	return rules.refsByLabel.get(label)?.get(targetProjectPath) ?? null;
-}
-function getRuleDeps(rules, label) {
-	if (!label) return [];
-	return rules.depsByLabel.get(label) ?? [];
-}
-function getDeniedDepRuleForPackage(rules, label, packageName) {
-	return getRuleDeps(rules, label).find((rule) => rule.kind === "package" && rule.normalizedName === packageName) ?? null;
-}
-function getDeniedDepRuleForSpecifier(rules, label, specifier) {
-	const deps = getRuleDeps(rules, label);
-	const packageImportRule = deps.find((rule) => rule.kind === "package-import" && matchWildcardPattern(rule.normalizedName, specifier));
-	if (packageImportRule) return packageImportRule;
-	if (isNodeBuiltinSpecifier(specifier)) {
-		const normalizedSpecifier = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-		const nodeRule = deps.find((rule) => rule.kind === "node-builtin" && (rule.matchAllNodeBuiltins || rule.normalizedName === normalizedSpecifier));
-		if (nodeRule) return nodeRule;
-	}
-	if (isRelativeSpecifier(specifier) || isPackageImportPattern(specifier) || isUrlOrDataOrFileSpecifier$1(specifier) || path.isAbsolute(specifier)) return null;
-	return getDeniedDepRuleForPackage(rules, label, getPackageRootSpecifier(specifier));
-}
-
-//#endregion
-//#region src/logger.ts
-const logger = createLogger({ main: "limina" });
-const CliLogger = logger.getLoggerByGroup("task.cli");
-const GraphLogger = logger.getLoggerByGroup("task.graph");
-const InitLogger = logger.getLoggerByGroup("task.init");
-const PackageLogger = logger.getLoggerByGroup("task.package");
-const PathsLogger = logger.getLoggerByGroup("task.paths");
-const ProofLogger = logger.getLoggerByGroup("task.proof");
-const ReleaseLogger = logger.getLoggerByGroup("task.release");
-const SourceLogger = logger.getLoggerByGroup("task.source");
-const TypecheckLogger = logger.getLoggerByGroup("task.typecheck");
-function clearCliScreen() {
-	if (!process.stdout.isTTY || process.env.CI) return;
-	const repeatCount = (process.stdout.rows ?? 0) - 2;
-	const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
-	process.stdout.write(blank);
-	readline.cursorTo(process.stdout, 0, 0);
-	readline.clearScreenDown(process.stdout);
-}
-
-//#endregion
-//#region src/commands/init.ts
-const pnpmWorkspaceFileName = "pnpm-workspace.yaml";
-const liminaConfigFileName = "limina.config.mjs";
-const liminaCheckScriptName = "limina:check";
-const liminaCheckScriptValue = "limina check";
-const ignoredGlobPatterns = [
-	"**/.git/**",
-	"**/.limina/**",
-	"**/.pnpm-store/**",
-	"**/.tsbuild/**",
-	"**/coverage/**",
-	"**/dist/**",
-	"**/node_modules/**"
-];
-function findPnpmWorkspaceRoot(startDir) {
-	let currentDir = path.resolve(startDir);
-	while (true) {
-		if (existsSync(path.join(currentDir, pnpmWorkspaceFileName))) return normalizeAbsolutePath(currentDir);
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) return null;
-		currentDir = parentDir;
-	}
-}
-function createInitConfig(rootDir) {
-	return {
-		configPath: path.join(rootDir, liminaConfigFileName),
-		rootDir
-	};
-}
-function formatConfigPath(rootDir, configPath) {
-	return toRelativePath(rootDir, configPath);
-}
-function formatReferencePath(fromConfigPath, toConfigPath) {
-	const relativePath = toPosixPath(path.relative(path.dirname(fromConfigPath), toConfigPath));
-	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-function stringifyJson(value) {
-	return `${JSON.stringify(value, null, 2)}\n`;
-}
-function getProjectScope(configPath) {
-	const fileName = path.basename(configPath);
-	if (fileName === "tsconfig.json") return "tsconfig";
-	return /^tsconfig\.(.+)\.json$/u.exec(fileName)?.[1] ?? "tsconfig";
-}
-function getDtsConfigPath(configPath) {
-	const directory = path.dirname(configPath);
-	const fileName = path.basename(configPath);
-	const dtsFileName = fileName === "tsconfig.json" ? "tsconfig.dts.json" : fileName.replace(/\.json$/u, ".dts.json");
-	return path.join(directory, dtsFileName);
-}
-function hasReferences(configObject) {
-	return Array.isArray(configObject.references) && configObject.references.length > 0;
-}
-function parseTypeScriptConfig(rootDir, configPath) {
-	const diagnostics = [];
-	const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, {
-		...ts.sys,
-		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
-			diagnostics.push(diagnostic);
-		}
-	});
-	if (!parsed) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-		getCanonicalFileName: (fileName) => fileName,
-		getCurrentDirectory: () => rootDir,
-		getNewLine: () => "\n"
-	}));
-	if (parsed.errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(parsed.errors, {
-		getCanonicalFileName: (fileName) => fileName,
-		getCurrentDirectory: () => rootDir,
-		getNewLine: () => "\n"
-	}));
-	return {
-		fileNames: parsed.fileNames.map(normalizeAbsolutePath),
-		options: parsed.options
-	};
-}
-function findNearestWorkspacePackage(filePath, packages) {
-	return [...packages].sort((left, right) => right.directory.length - left.directory.length).find((workspacePackage) => isPathInsideDirectory(filePath, workspacePackage.directory)) ?? null;
-}
-function collectWorkspaceDependencyNames(manifest) {
-	const dependencyNames = /* @__PURE__ */ new Set();
-	for (const dependencies of getDependencySections(manifest)) for (const [dependencyName, specifier] of Object.entries(dependencies)) if (isWorkspaceDependencySpecifier(specifier)) dependencyNames.add(dependencyName);
-	return dependencyNames;
-}
-function findOwningProjectForFile(filePath, projects) {
-	const normalizedFilePath = normalizeAbsolutePath(filePath);
-	return projects.filter((project) => project.fileNames.includes(normalizedFilePath)).sort((left, right) => {
-		const depthDelta = path.dirname(right.configPath).length - path.dirname(left.configPath).length;
-		return depthDelta === 0 ? left.configPath.localeCompare(right.configPath) : depthDelta;
-	})[0] ?? null;
-}
-function isDirectory(filePath) {
-	try {
-		return statSync(filePath).isDirectory();
-	} catch {
-		return false;
-	}
-}
-function mapVirtualWorkspacePath(filePath, packageByName) {
-	const segments = normalizeAbsolutePath(filePath).split("/");
-	for (let index = 0; index < segments.length; index += 1) {
-		if (segments[index] !== "node_modules") continue;
-		const firstPackageSegment = segments[index + 1];
-		if (!firstPackageSegment) continue;
-		const isScopedPackage = firstPackageSegment.startsWith("@");
-		const packageName = isScopedPackage ? `${firstPackageSegment}/${segments[index + 2] ?? ""}` : firstPackageSegment;
-		const restStart = index + (isScopedPackage ? 3 : 2);
-		const workspacePackage = packageByName.get(packageName);
-		if (!workspacePackage) continue;
-		return path.join(workspacePackage.directory, ...segments.slice(restStart));
-	}
-	return null;
-}
-function isVirtualWorkspaceDirectory(directoryPath, packageByName) {
-	const segments = normalizeAbsolutePath(directoryPath).split("/");
-	for (let index = 0; index < segments.length; index += 1) {
-		if (segments[index] !== "node_modules") continue;
-		const firstPackageSegment = segments[index + 1];
-		if (!firstPackageSegment) return packageByName.size > 0;
-		if (firstPackageSegment.startsWith("@") && segments[index + 2] === void 0) return [...packageByName.keys()].some((packageName) => packageName.startsWith(`${firstPackageSegment}/`));
-	}
-	const mappedPath = mapVirtualWorkspacePath(directoryPath, packageByName);
-	return mappedPath ? isDirectory(mappedPath) : false;
-}
-function createWorkspaceModuleResolutionHost(options) {
-	const mapPath = (filePath) => mapVirtualWorkspacePath(filePath, options.packageByName) ?? filePath;
-	return {
-		directoryExists: (directoryPath) => isVirtualWorkspaceDirectory(directoryPath, options.packageByName) || (ts.sys.directoryExists?.(directoryPath) ?? isDirectory(directoryPath)),
-		fileExists: (filePath) => {
-			const mappedPath = mapPath(filePath);
-			return existsSync(mappedPath) && !isDirectory(mappedPath);
-		},
-		getCurrentDirectory: () => options.rootDir,
-		readFile: (filePath) => ts.sys.readFile(mapPath(filePath)),
-		realpath: (filePath) => normalizeAbsolutePath(mapPath(filePath)),
-		useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames
-	};
-}
-function resolveImportWithTypeScript(options) {
-	const resolvedModule = ts.resolveModuleName(options.importRecord.specifier, options.importRecord.filePath, options.project.options, options.host, options.cache).resolvedModule;
-	if (!resolvedModule?.resolvedFileName) return null;
-	return normalizeAbsolutePath(mapVirtualWorkspacePath(resolvedModule.resolvedFileName, options.packageByName) ?? resolvedModule.resolvedFileName);
-}
-function isPackageImportSpecifier$1(specifier) {
-	return specifier.startsWith("#");
-}
-function createDtsConfig(project) {
-	const fileName = path.basename(project.configPath);
-	const scope = project.scope;
-	const output = {
-		$schema: "https://json.schemastore.org/tsconfig",
-		extends: [`./${fileName}`],
-		compilerOptions: {
-			composite: true,
-			incremental: true,
-			noEmit: false,
-			declaration: true,
-			emitDeclarationOnly: true,
-			declarationMap: false,
-			rootDir: ".",
-			outDir: "./.limina",
-			tsBuildInfoFile: `./.limina/${scope}.tsbuildinfo`
-		}
-	};
-	if (project.references.length > 0) output.references = project.references.map((referencePath) => ({ path: referencePath }));
-	return output;
-}
-function createBuildAggregator(references) {
-	return {
-		$schema: "https://json.schemastore.org/tsconfig",
-		files: [],
-		references: references.map((referencePath) => ({ path: referencePath }))
-	};
-}
-function createLiminaConfigContent() {
-	return `import { defineConfig } from 'limina';
-
-export default defineConfig({
-  // Shared checker entries used by graph, proof, paths, and typecheck checks.
-  config: {
-    checkers: {
-      typescript: {
-        preset: 'tsc',
-        entry: 'tsconfig.build.json',
-      },
-    },
-  },
-});
-`;
-}
-async function confirmAction(options, message) {
-	if (options.yes) return true;
-	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error(`${message} Run limina init --yes to accept the default confirmation in non-interactive environments.`);
-	const result = await prompts.confirm({
-		initialValue: true,
-		message
-	});
-	if (prompts.isCancel(result)) throw new Error("limina init canceled.");
-	return result;
-}
-async function writeTextFile(filePath, content, writtenFiles) {
-	await mkdir(path.dirname(filePath), { recursive: true });
-	await writeFile(filePath, content);
-	writtenFiles.push(filePath);
-}
-async function writeBuildAggregatorFile(options) {
-	if (options.references.length === 0) return false;
-	await writeTextFile(options.configPath, stringifyJson(createBuildAggregator(options.references)), options.writtenFiles);
-	return true;
-}
-function findPnpmWorkspacePath(startDir) {
-	const rootDir = findPnpmWorkspaceRoot(startDir);
-	return rootDir ? path.join(rootDir, pnpmWorkspaceFileName) : null;
-}
-function resolveCatalogRange(range, packageName, packageManifestPath) {
-	if (!range) return null;
-	if (!range.startsWith("catalog:")) return range;
-	const workspacePath = findPnpmWorkspacePath(path.dirname(packageManifestPath));
-	if (!workspacePath || !existsSync(workspacePath)) return null;
-	const parsed = parse(readFileSync(workspacePath, "utf8"));
-	const catalogName = range.slice(8);
-	if (catalogName.length === 0 || catalogName === "default") return parsed?.catalog?.[packageName] ?? null;
-	return parsed?.catalogs?.[catalogName]?.[packageName] ?? null;
-}
-function readLiminaPackageMetadata() {
-	const manifestPath = createRequire(import.meta.url).resolve("limina/package.json");
-	const manifest = readJsonFile(manifestPath);
-	const versionRange = manifest.version ? `^${manifest.version}` : "^0.0.1";
-	const rawTypeScriptRange = manifest.peerDependencies?.typescript ?? manifest.devDependencies?.typescript ?? manifest.dependencies?.typescript;
-	return {
-		typescriptRange: resolveCatalogRange(rawTypeScriptRange, "typescript", manifestPath) ?? rawTypeScriptRange ?? "^5.9.0",
-		versionRange
-	};
-}
-function hasDependency(manifest, dependencyName) {
-	return Boolean(manifest.dependencies?.[dependencyName] || manifest.devDependencies?.[dependencyName] || manifest.optionalDependencies?.[dependencyName] || manifest.peerDependencies?.[dependencyName]);
-}
-async function updateRootPackageJson(options) {
-	const packageJsonPath = path.join(options.rootDir, "package.json");
-	let installRequired = false;
-	if (!existsSync(packageJsonPath)) {
-		if (!await confirmAction(options.prompt, `No package.json found at ${formatConfigPath(options.rootDir, packageJsonPath)}. Create one?`)) {
-			options.skippedFiles.push(packageJsonPath);
-			return false;
-		}
-		await writeTextFile(packageJsonPath, stringifyJson({
-			private: true,
-			type: "module",
-			scripts: { [liminaCheckScriptName]: liminaCheckScriptValue },
-			devDependencies: {
-				limina: options.metadata.versionRange,
-				typescript: options.metadata.typescriptRange
-			}
-		}), options.writtenFiles);
-		return true;
-	}
-	const manifest = readJsonFile(packageJsonPath);
-	const scripts = { ...manifest.scripts ?? {} };
-	let changed = false;
-	if (scripts[liminaCheckScriptName] && scripts[liminaCheckScriptName] !== liminaCheckScriptValue) {
-		if (await confirmAction(options.prompt, `Script "${liminaCheckScriptName}" already exists in package.json. Overwrite it?`)) {
-			scripts[liminaCheckScriptName] = liminaCheckScriptValue;
-			changed = true;
-		}
-	} else if (!scripts[liminaCheckScriptName]) {
-		scripts[liminaCheckScriptName] = liminaCheckScriptValue;
-		changed = true;
-	}
-	if (!hasDependency(manifest, "limina")) {
-		manifest.devDependencies = {
-			...manifest.devDependencies ?? {},
-			limina: options.metadata.versionRange
-		};
-		installRequired = true;
-		changed = true;
-	}
-	if (changed) await writeTextFile(packageJsonPath, stringifyJson({
-		...manifest,
-		scripts
-	}), options.writtenFiles);
-	return installRequired;
-}
-async function collectReservedConfigConflicts(rootDir) {
-	const conflicts = await glob([
-		"tsconfig*.build.json",
-		"**/tsconfig*.build.json",
-		"tsconfig*.dts.json",
-		"**/tsconfig*.dts.json"
-	], {
-		absolute: false,
-		cwd: rootDir,
-		ignore: ignoredGlobPatterns
-	});
-	return [...new Set(conflicts)].sort();
-}
-async function collectOrdinaryTsconfigPaths(rootDir) {
-	const configPaths = await glob(["tsconfig*.json", "**/tsconfig*.json"], {
-		absolute: false,
-		cwd: rootDir,
-		ignore: ignoredGlobPatterns
-	});
-	return [...new Set(configPaths)].map((configPath) => normalizeAbsolutePath(path.join(rootDir, configPath))).filter(isOrdinaryTypecheckConfigPath).sort();
-}
-function analyzeTypecheckProjects(options) {
-	const problems = [];
-	const projects = [];
-	for (const configPath of options.configPaths) {
-		const configObject = readJsonConfig(options.config, configPath);
-		const parsed = parseTypeScriptConfig(options.config.rootDir, configPath);
-		const hasProjectReferences = hasReferences(configObject);
-		const fileName = path.basename(configPath);
-		if (fileName === "tsconfig.json" && hasProjectReferences && parsed.fileNames.length > 0) {
-			problems.push([
-				"Invalid tsconfig role:",
-				`  config: ${formatConfigPath(options.config.rootDir, configPath)}`,
-				"  reason: tsconfig.json must be either a pure aggregator with files: [] and references, or a typecheck leaf with source files, but not both."
-			].join("\n"));
-			continue;
-		}
-		if (fileName !== "tsconfig.json" && hasProjectReferences) {
-			problems.push([
-				"Invalid scoped tsconfig role:",
-				`  config: ${formatConfigPath(options.config.rootDir, configPath)}`,
-				"  reason: tsconfig.<scope>.json files may only be typecheck leaves; graph aggregation belongs in tsconfig*.build.json."
-			].join("\n"));
-			continue;
-		}
-		if (fileName === "tsconfig.json" && hasProjectReferences) continue;
-		projects.push({
-			configPath,
-			dtsConfigPath: getDtsConfigPath(configPath),
-			fileNames: parsed.fileNames,
-			options: parsed.options,
-			owner: findNearestWorkspacePackage(configPath, options.workspacePackages),
-			references: [],
-			scope: getProjectScope(configPath)
-		});
-	}
-	return {
-		problems,
-		projects
-	};
-}
-function inferProjectReferences(options) {
-	const problems = [];
-	const packageByName = new Map(options.workspacePackages.map((workspacePackage) => [workspacePackage.name, workspacePackage]));
-	const host = createWorkspaceModuleResolutionHost({
-		packageByName,
-		rootDir: options.config.rootDir
-	});
-	for (const project of options.projects) {
-		if (!project.owner) continue;
-		const workspaceDependencyNames = collectWorkspaceDependencyNames(project.owner.manifest);
-		const resolutionCache = ts.createModuleResolutionCache(path.dirname(project.configPath), (fileName) => fileName, project.options);
-		const referencePaths = /* @__PURE__ */ new Set();
-		for (const fileName of project.fileNames) {
-			if (!/\.(?:[cm]?tsx?|d\.[cm]?ts)$/u.test(fileName)) continue;
-			for (const importRecord of collectImportsFromFile(fileName, options.config.rootDir)) {
-				const resolvedFilePath = resolveImportWithTypeScript({
-					cache: resolutionCache,
-					host,
-					importRecord,
-					packageByName,
-					project
-				});
-				const packageName = isRelativeSpecifier$1(importRecord.specifier) || isPackageImportSpecifier$1(importRecord.specifier) ? null : getPackageRootSpecifier(importRecord.specifier);
-				const targetPackage = packageName ? packageByName.get(packageName) : null;
-				const isWorkspaceGraphDependency = targetPackage && (targetPackage.name === project.owner.name || workspaceDependencyNames.has(targetPackage.name));
-				if (packageName && workspaceDependencyNames.has(packageName) && !targetPackage) {
-					problems.push([
-						"Workspace dependency was not discovered by pnpm:",
-						`  importing project: ${formatConfigPath(options.config.rootDir, project.dtsConfigPath)}`,
-						`  file: ${formatConfigPath(options.config.rootDir, importRecord.filePath)}:${importRecord.line}`,
-						`  imported specifier: ${importRecord.specifier}`,
-						`  package: ${packageName}`,
-						"  reason: package.json declares this dependency with the workspace: protocol, but limina init could not find a matching workspace package."
-					].join("\n"));
-					continue;
-				}
-				if (targetPackage && !isWorkspaceGraphDependency) continue;
-				if (!resolvedFilePath) {
-					if (targetPackage && isWorkspaceGraphDependency) problems.push([
-						"Unable to resolve workspace import with TypeScript:",
-						`  importing project: ${formatConfigPath(options.config.rootDir, project.dtsConfigPath)}`,
-						`  file: ${formatConfigPath(options.config.rootDir, importRecord.filePath)}:${importRecord.line}`,
-						`  imported specifier: ${importRecord.specifier}`,
-						`  package: ${targetPackage.name}`,
-						"  reason: workspace:* imports must resolve with the project TypeScript compilerOptions before limina init can generate project references."
-					].join("\n"));
-					continue;
-				}
-				if (isRelativeSpecifier$1(importRecord.specifier)) {
-					const sourcePackage = findNearestWorkspacePackage(importRecord.filePath, options.workspacePackages);
-					const resolvedPackage = findNearestWorkspacePackage(resolvedFilePath, options.workspacePackages);
-					if (sourcePackage && resolvedPackage && sourcePackage.name !== resolvedPackage.name) continue;
-				}
-				const targetProject = findOwningProjectForFile(resolvedFilePath, options.projects);
-				if (!targetProject) {
-					if (targetPackage && isWorkspaceGraphDependency) problems.push([
-						"Unable to map workspace import to a generated declaration leaf:",
-						`  importing project: ${formatConfigPath(options.config.rootDir, project.dtsConfigPath)}`,
-						`  file: ${formatConfigPath(options.config.rootDir, importRecord.filePath)}:${importRecord.line}`,
-						`  imported specifier: ${importRecord.specifier}`,
-						`  resolved file: ${formatConfigPath(options.config.rootDir, resolvedFilePath)}`,
-						"  reason: TypeScript resolved this workspace import, but the resolved module is not covered by any ordinary tsconfig*.json leaf."
-					].join("\n"));
-					continue;
-				}
-				if (targetProject.dtsConfigPath !== project.dtsConfigPath) referencePaths.add(formatReferencePath(project.dtsConfigPath, targetProject.dtsConfigPath));
-			}
-		}
-		project.references = [...referencePaths].sort();
-	}
-	return problems;
-}
-function collectProjectReferencesForOwner(options) {
-	return options.projects.filter((project) => project.owner?.directory === options.owner?.directory).map((project) => formatReferencePath(options.targetConfigPath, project.dtsConfigPath)).sort();
-}
-function collectRootBuildProjectReferences(options) {
-	return options.projects.filter((project) => !project.owner || project.owner.directory === options.rootDir || path.dirname(project.configPath) === options.rootDir).map((project) => formatReferencePath(options.targetConfigPath, project.dtsConfigPath)).sort();
-}
-async function writeGeneratedTsconfigs(options) {
-	for (const project of options.projects) await writeTextFile(project.dtsConfigPath, stringifyJson(createDtsConfig(project)), options.writtenFiles);
-	const nonRootWorkspacePackages = options.workspacePackages.filter((workspacePackage) => workspacePackage.directory !== options.rootDir);
-	const workspaceBuildConfigPaths = [];
-	for (const workspacePackage of nonRootWorkspacePackages) {
-		const buildConfigPath = path.join(workspacePackage.directory, "tsconfig.build.json");
-		if (await writeBuildAggregatorFile({
-			configPath: buildConfigPath,
-			references: collectProjectReferencesForOwner({
-				owner: workspacePackage,
-				projects: options.projects,
-				targetConfigPath: buildConfigPath
-			}),
-			writtenFiles: options.writtenFiles
-		})) workspaceBuildConfigPaths.push(buildConfigPath);
-	}
-	const rootBuildConfigPath = path.join(options.rootDir, "tsconfig.build.json");
-	await writeBuildAggregatorFile({
-		configPath: rootBuildConfigPath,
-		references: [...collectRootBuildProjectReferences({
-			projects: options.projects,
-			rootDir: options.rootDir,
-			targetConfigPath: rootBuildConfigPath
-		}), ...workspaceBuildConfigPaths.map((buildConfigPath) => formatReferencePath(rootBuildConfigPath, buildConfigPath))].sort(),
-		writtenFiles: options.writtenFiles
-	});
-}
-async function writeLiminaConfig(options) {
-	const configPath = path.join(options.rootDir, liminaConfigFileName);
-	if (existsSync(configPath)) {
-		if (!await confirmAction(options.prompt, `${liminaConfigFileName} already exists. Overwrite it?`)) {
-			options.skippedFiles.push(configPath);
-			return;
-		}
-	}
-	await writeTextFile(configPath, createLiminaConfigContent(), options.writtenFiles);
-}
-async function runInitInternal(options) {
-	const cwd = normalizeAbsolutePath(options.cwd ?? process.cwd());
-	const rootDir = findPnpmWorkspaceRoot(cwd);
-	if (!rootDir) throw new Error(`Unable to run limina init from ${cwd}: no pnpm-workspace.yaml was found in this directory or its parents.`);
-	const rootPackageJsonPath = path.join(rootDir, "package.json");
-	const rootPackageName = existsSync(rootPackageJsonPath) ? readJsonFile(rootPackageJsonPath).name : void 0;
-	if (!await confirmAction(options, `Use pnpm workspace ${rootPackageName ? `"${rootPackageName}" ` : ""}at ${rootDir}?`)) throw new Error("limina init canceled.");
-	const reservedConflicts = await collectReservedConfigConflicts(rootDir);
-	if (reservedConflicts.length > 0) throw new Error([
-		"Unable to run limina init because reserved Limina tsconfig names already exist:",
-		...reservedConflicts.map((configPath) => `  - ${configPath}`),
-		"reason: tsconfig*.build.json and tsconfig*.dts.json are Limina init output names; rename existing files before running init."
-	].join("\n"));
-	const config = createInitConfig(rootDir);
-	const workspacePackages = (await collectWorkspacePackages(config)).filter((workspacePackage) => workspacePackage.directory !== rootDir);
-	const projectAnalysis = analyzeTypecheckProjects({
-		config,
-		configPaths: await collectOrdinaryTsconfigPaths(rootDir),
-		workspacePackages
-	});
-	const problems = [...projectAnalysis.problems];
-	if (problems.length === 0) problems.push(...inferProjectReferences({
-		config,
-		projects: projectAnalysis.projects,
-		workspacePackages
-	}));
-	if (problems.length > 0) throw new Error(problems.join("\n\n"));
-	const metadata = readLiminaPackageMetadata();
-	const writtenFiles = [];
-	const skippedFiles = [];
-	await writeGeneratedTsconfigs({
-		projects: projectAnalysis.projects,
-		rootDir,
-		workspacePackages,
-		writtenFiles
-	});
-	await writeLiminaConfig({
-		prompt: options,
-		rootDir,
-		skippedFiles,
-		writtenFiles
-	});
-	return {
-		checkCommand: "pnpm limina:check",
-		installRequired: await updateRootPackageJson({
-			metadata,
-			prompt: options,
-			rootDir,
-			skippedFiles,
-			writtenFiles
-		}),
-		rootDir,
-		skippedFiles,
-		workspacePackageCount: workspacePackages.length,
-		writtenFiles
-	};
-}
-async function runInit(options = {}) {
-	if (options.clearScreen ?? true) clearCliScreen();
-	const elapsed = createElapsedTimer();
-	const task = options.flow?.start("init workspace", { depth: options.flowDepth ?? 0 });
-	InitLogger.info("init started");
-	try {
-		const result = await runInitInternal(options);
-		InitLogger.success(`init generated ${result.writtenFiles.length} files for ${result.workspacePackageCount} workspace packages.`, elapsed());
-		if (result.installRequired) InitLogger.info("limina was added to devDependencies; run pnpm i before checking.");
-		InitLogger.info(`next: ${result.installRequired ? "pnpm i && " : ""}${result.checkCommand}`);
-		task?.pass();
-		return result;
-	} catch (error) {
-		InitLogger.error(`init failed: ${formatErrorMessage$1(error)}`, elapsed());
-		task?.fail("init failed", { error });
-		throw error;
-	}
-}
-
-//#endregion
-//#region src/commands/source.ts
-function findOwnerForFile(filePath, owners) {
-	return owners.find((owner) => isPathInsideDirectory(filePath, owner.directory)) ?? null;
-}
-function isUrlOrDataOrFileSpecifier(specifier) {
-	return specifier.startsWith("data:") || specifier.startsWith("file:") || specifier.startsWith("http:") || specifier.startsWith("https:");
-}
-function isVirtualModuleSpecifier(specifier) {
-	return specifier.startsWith("virtual:");
-}
-function isPackageImportSpecifier(specifier) {
-	return specifier.startsWith("#");
-}
-function isBarePackageSpecifier(specifier) {
-	return !isRelativeSpecifier$1(specifier) && !isPackageImportSpecifier(specifier) && !isUrlOrDataOrFileSpecifier(specifier) && !isVirtualModuleSpecifier(specifier) && !path.isAbsolute(specifier);
-}
-function isDependencyAuthorized(manifest, packageName) {
-	return Boolean(manifest.dependencies?.[packageName] || manifest.devDependencies?.[packageName]);
-}
-function findNonAuthorizingDependencySection(manifest, packageName) {
-	if (manifest.peerDependencies?.[packageName]) return "peerDependencies";
-	if (manifest.optionalDependencies?.[packageName]) return "optionalDependencies";
-	return null;
-}
-function packageImportsMatch(importsField, specifier) {
-	if (!importsField || typeof importsField !== "object") return false;
-	for (const key of Object.keys(importsField)) {
-		if (key === specifier) return true;
-		const wildcardIndex = key.indexOf("*");
-		if (wildcardIndex === -1) continue;
-		const prefix = key.slice(0, wildcardIndex);
-		const suffix = key.slice(wildcardIndex + 1);
-		if (specifier.startsWith(prefix) && specifier.endsWith(suffix)) return true;
-	}
-	return false;
-}
-function addProjectOwnerProblems(options) {
-	const ownerPaths = /* @__PURE__ */ new Map();
-	const missingOwnerFiles = [];
-	for (const fileName of options.fileNames) {
-		const owner = findOwnerForFile(fileName, options.owners);
-		if (!owner) {
-			missingOwnerFiles.push(fileName);
-			continue;
-		}
-		ownerPaths.set(owner.packageJsonPath, owner);
-	}
-	if (missingOwnerFiles.length > 0) options.problems.push([
-		"Source file has no package owner:",
-		`  ${options.role}: ${toRelativePath(options.config.rootDir, options.configPath)}`,
-		"  files:",
-		...missingOwnerFiles.slice(0, 10).map((fileName) => `    - ${toRelativePath(options.config.rootDir, fileName)}`),
-		...missingOwnerFiles.length > 10 ? [`    ...and ${missingOwnerFiles.length - 10} more`] : [],
-		"  reason: every source file checked by Limina must be governed by the nearest package.json owner."
-	].join("\n"));
-	if (ownerPaths.size <= 1) return;
-	options.problems.push([
-		"Tsconfig source file set mixes package owners:",
-		`  ${options.role}: ${toRelativePath(options.config.rootDir, options.configPath)}`,
-		"  owners:",
-		...[...ownerPaths.values()].map((owner) => `    - ${toRelativePath(options.config.rootDir, owner.packageJsonPath)}`),
-		"  reason: non-aggregator tsconfig leaves and their companion typecheck configs must stay within one nearest package.json owner scope."
-	].join("\n"));
-}
-function addRelativeImportOwnerProblem(options) {
-	options.problems.push([
-		"Relative import escapes package owner scope:",
-		`  package owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
-		`  file: ${toRelativePath(options.config.rootDir, options.importRecord.filePath)}:${options.importRecord.line}`,
-		`  imported specifier: ${options.importRecord.specifier}`,
-		`  resolved file: ${toRelativePath(options.config.rootDir, options.resolvedFilePath)}`,
-		...options.targetOwner ? [`  target owner: ${toRelativePath(options.config.rootDir, options.targetOwner.packageJsonPath)}`] : [],
-		"  reason: relative source imports must not cross the nearest package.json owner boundary."
-	].join("\n"));
-}
-function addPackageImportAuthorizationProblem(options) {
-	const nonAuthorizingSection = findNonAuthorizingDependencySection(options.owner.manifest, options.packageName);
-	options.problems.push([
-		"Unauthorized bare package import:",
-		`  package owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
-		`  file: ${toRelativePath(options.config.rootDir, options.importRecord.filePath)}:${options.importRecord.line}`,
-		`  imported specifier: ${options.importRecord.specifier}`,
-		`  package: ${options.packageName}`,
-		...options.workspacePackage ? [`  workspace package: ${options.workspacePackage.name}`] : [],
-		...nonAuthorizingSection ? [`  found in: ${nonAuthorizingSection}`] : [],
-		"  reason: source imports must be authorized by the nearest package.json dependencies or devDependencies."
-	].join("\n"));
-}
-function addPackageImportProblem(options) {
-	if (!packageImportsMatch(options.owner.manifest.imports, options.importRecord.specifier)) {
-		options.problems.push([
-			"Unauthorized package import specifier:",
-			`  package owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
-			`  file: ${toRelativePath(options.config.rootDir, options.importRecord.filePath)}:${options.importRecord.line}`,
-			`  imported specifier: ${options.importRecord.specifier}`,
-			"  reason: #... package imports must match the nearest package.json imports field."
-		].join("\n"));
-		return;
-	}
-	if (!options.resolvedFilePath) {
-		options.problems.push([
-			"Unresolved package import specifier:",
-			`  package owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
-			`  file: ${toRelativePath(options.config.rootDir, options.importRecord.filePath)}:${options.importRecord.line}`,
-			`  imported specifier: ${options.importRecord.specifier}`,
-			"  reason: matched #... package imports must resolve to a file within the same package owner scope."
-		].join("\n"));
-		return;
-	}
-	if (!isPathInsideDirectory(options.resolvedFilePath, options.owner.directory)) options.problems.push([
-		"Package import escapes package owner scope:",
-		`  package owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
-		`  file: ${toRelativePath(options.config.rootDir, options.importRecord.filePath)}:${options.importRecord.line}`,
-		`  imported specifier: ${options.importRecord.specifier}`,
-		`  resolved file: ${toRelativePath(options.config.rootDir, options.resolvedFilePath)}`,
-		"  reason: #... package imports must resolve within the nearest package.json owner scope."
-	].join("\n"));
-}
-function createSourceProjectEntries(config, projects) {
-	return projects.filter((project) => isDtsProjectConfig(project.configPath)).map((project) => {
-		const typecheckConfigPath = getTypecheckConfigPath(project.configPath);
-		const fileNames = new Set(project.fileNames);
-		if (existsSync(typecheckConfigPath)) for (const fileName of parseProject(config, typecheckConfigPath, project.extensions).fileNames) fileNames.add(fileName);
-		return {
-			fileNames: [...fileNames].sort(),
-			project
-		};
-	});
-}
-async function runSourceCheckInternal(config, options = {}) {
-	const graphRoute = collectSourceGraphProjectExtensions(config);
-	const projects = [...graphRoute.projectExtensionsByPath.keys()].sort().map((projectPath) => parseProject(config, projectPath, graphRoute.projectExtensionsByPath.get(projectPath)));
-	const sourceProjectEntries = createSourceProjectEntries(config, projects);
-	const packages = await collectWorkspacePackages(config);
-	const packageOwners = await collectPackageOwners(config);
-	const problems = [...graphRoute.problems];
-	for (const project of projects) {
-		if (project.labelProblem) problems.push(project.labelProblem);
-		if (!isDtsProjectConfig(project.configPath)) continue;
-		addProjectOwnerProblems({
-			config,
-			configPath: project.configPath,
-			fileNames: project.fileNames,
-			owners: packageOwners,
-			problems,
-			role: "declaration leaf"
-		});
-		const typecheckConfigPath = getTypecheckConfigPath(project.configPath);
-		if (existsSync(typecheckConfigPath)) addProjectOwnerProblems({
-			config,
-			configPath: typecheckConfigPath,
-			fileNames: parseProject(config, typecheckConfigPath, project.extensions).fileNames,
-			owners: packageOwners,
-			problems,
-			role: "typecheck companion"
-		});
-	}
-	for (const { fileNames, project } of sourceProjectEntries) for (const filePath of fileNames) {
-		const owner = findOwnerForFile(filePath, packageOwners);
-		if (!owner) continue;
-		for (const importRecord of collectImportsFromFile(filePath, config.rootDir)) {
-			const resolvedFilePath = resolveInternalImport(importRecord.specifier, filePath, project.options, project.extensions);
-			if (isRelativeSpecifier$1(importRecord.specifier)) {
-				if (!resolvedFilePath) continue;
-				const targetOwner = findOwnerForFile(resolvedFilePath, packageOwners);
-				if (targetOwner?.packageJsonPath !== owner.packageJsonPath) addRelativeImportOwnerProblem({
-					config,
-					importRecord,
-					owner,
-					problems,
-					resolvedFilePath,
-					targetOwner
-				});
-				continue;
-			}
-			if (isPackageImportSpecifier(importRecord.specifier)) {
-				addPackageImportProblem({
-					config,
-					importRecord,
-					owner,
-					problems,
-					resolvedFilePath
-				});
-				continue;
-			}
-			if (isUrlOrDataOrFileSpecifier(importRecord.specifier) || isVirtualModuleSpecifier(importRecord.specifier)) continue;
-			if (!isBarePackageSpecifier(importRecord.specifier)) continue;
-			if (isNodeBuiltinSpecifier(importRecord.specifier)) continue;
-			const packageName = getPackageRootSpecifier(importRecord.specifier);
-			if (owner.name === packageName) continue;
-			const workspacePackage = packages.find((candidate) => candidate.name === packageName) ?? null;
-			if (isDependencyAuthorized(owner.manifest, packageName)) continue;
-			addPackageImportAuthorizationProblem({
-				config,
-				importRecord,
-				owner,
-				packageName,
-				problems,
-				workspacePackage
-			});
-		}
-	}
-	if (problems.length > 0) {
-		SourceLogger.error(problems.join("\n\n"));
-		return false;
-	}
-	if (options.logSuccess ?? true) SourceLogger.success(`Checked ${sourceProjectEntries.length} source project owners; package scopes are valid.`);
-	return true;
-}
-async function runSourceCheck(config, options = {}) {
-	if (options.clearScreen ?? true) clearCliScreen();
-	const elapsed = createElapsedTimer();
-	const task = options.flow?.start("source check", { depth: options.flowDepth ?? 0 });
-	SourceLogger.info("source check started");
-	try {
-		const logSuccess = !options.flow?.interactive;
-		const passed = await runSourceCheckInternal(config, { logSuccess });
-		if (passed) {
-			if (logSuccess) SourceLogger.success("source check finished", elapsed());
-			task?.pass();
-		} else {
-			SourceLogger.error("source check finished with failures", elapsed());
-			task?.fail("source check finished with failures");
-		}
-		return passed;
-	} catch (error) {
-		SourceLogger.error(`source check failed: ${formatErrorMessage$1(error)}`, elapsed());
-		task?.fail("source check failed", { error });
-		throw error;
-	}
-}
-
-//#endregion
-//#region src/commands/typecheck.ts
-function getExecutionCheckers(options) {
-	return options.checkers.filter((checker) => {
-		return getCheckerAdapter(checker.preset)?.execution === options.executionKind;
-	});
-}
-function collectCheckerPeerDependencyProblems(options) {
-	const missingDependencies = collectMissingCheckerPeerDependencies({
-		checkers: options.checkers,
-		projectRootDir: options.projectRootDir,
-		resolvePackage: options.resolvePackage
-	});
-	return missingDependencies.length === 0 ? [] : [formatMissingCheckerPeerDependencies(missingDependencies)];
-}
-function createCheckerTarget(options) {
-	const adapter = getCheckerAdapter(options.checker.preset);
-	if (!adapter) throw new Error(`Checker "${options.checker.name}" uses unsupported preset "${options.checker.preset}".`);
-	return {
-		...adapter.createCommandTarget(options),
-		checkerName: options.checker.name,
-		configPath: options.configPath,
-		cwd: options.projectRootDir,
-		executionKind: options.executionKind
-	};
-}
-function createDefaultRunner() {
-	return async (target) => await new Promise((resolve) => {
-		const child = spawn(target.command, target.args, {
-			cwd: target.cwd,
-			env: {
-				...process.env,
-				PATH: [path.join(target.cwd, "node_modules/.bin"), process.env.PATH].filter(Boolean).join(path.delimiter)
-			},
-			shell: process.platform === "win32",
-			stdio: "inherit"
-		});
-		child.on("error", (error) => {
-			resolve({
-				configPath: target.configPath,
-				error,
-				status: 1
-			});
-		});
-		child.on("close", (code) => {
-			resolve({
-				configPath: target.configPath,
-				status: code ?? 1
-			});
-		});
-	});
-}
-async function runWithConcurrency(targets, concurrency, runner, options = {}) {
-	const results = new Array(targets.length);
-	let nextIndex = 0;
-	await Promise.all(Array.from({ length: Math.min(concurrency, targets.length) }).map(async () => {
-		for (;;) {
-			const targetIndex = nextIndex;
-			nextIndex += 1;
-			if (targetIndex >= targets.length) return;
-			try {
-				const target = targets[targetIndex];
-				options.onTargetStart?.(target);
-				results[targetIndex] = await runner(target);
-				options.onTargetResult?.(target, results[targetIndex]);
-			} catch (error) {
-				const target = targets[targetIndex];
-				results[targetIndex] = {
-					configPath: target.configPath,
-					error: error instanceof Error ? error : new Error(String(error)),
-					status: 1
-				};
-				options.onTargetResult?.(target, results[targetIndex]);
-			}
-		}
-	}));
-	return results;
-}
-async function runCheckerBuildInternal(options) {
-	const cwd = path.resolve(options.cwd ?? process.cwd());
-	const projectRootDir = normalizeAbsolutePath(options.config.rootDir);
-	const allCheckers = getActiveCheckers(options.config);
-	const checkers = getExecutionCheckers({
-		checkers: allCheckers,
-		executionKind: "build"
-	});
-	const flowDepth = options.flowDepth ?? 0;
-	const rootConfigPaths = [];
-	const problems = collectCheckerPeerDependencyProblems({
-		checkers: allCheckers,
-		projectRootDir,
-		resolvePackage: options.checkerPackageResolver
-	});
-	if (problems.length > 0) {
-		options.flow?.fail("checker dependency preflight failed", { depth: flowDepth + 1 });
-		TypecheckLogger.error(problems.join("\n\n"));
-		return {
-			passed: false,
-			projectRootDir,
-			rootConfigPaths
-		};
-	}
-	const targets = checkers.flatMap((checker) => {
-		const configPath = resolveProjectConfigPath(projectRootDir, checker.entry);
-		rootConfigPaths.push(configPath);
-		return [createCheckerTarget({
-			checker,
-			commandOverride: options.tscCommand,
-			configPath,
-			executionKind: "build",
-			projectRootDir
-		})];
-	});
-	options.flow?.info(`found ${targets.length} checker build entry(s)`, { depth: flowDepth + 1 });
-	TypecheckLogger.info([
-		`Running build checks for ${targets.length} checker entry(s).`,
-		`CWD: ${toRelativePath(cwd, projectRootDir)}`,
-		`Entries: ${rootConfigPaths.map((configPath) => toRelativePath(projectRootDir, configPath)).join(", ")}`
-	].join("\n"));
-	const targetTasks = /* @__PURE__ */ new Map();
-	const failedResults = (await runWithConcurrency(targets, 1, options.runner ?? createDefaultRunner(), {
-		onTargetResult: (target, result) => {
-			const task = targetTasks.get(target.configPath);
-			if (!task) return;
-			if (result.status === 0) task.pass();
-			else {
-				const suffix = result.error ? formatErrorMessage$1(result.error) : `exited with code ${result.status}`;
-				task.fail(void 0, { error: suffix });
-			}
-		},
-		onTargetStart: (target) => {
-			if (!options.flow) return;
-			targetTasks.set(target.configPath, options.flow.start(target.label ?? `checker build: ${toRelativePath(projectRootDir, target.configPath)}`, {
-				collapseOnSuccess: false,
-				depth: flowDepth + 1
-			}));
-		}
-	})).filter((result) => result.status !== 0);
-	const passed = failedResults.length === 0;
-	if (!passed) TypecheckLogger.error(["build checks failed:", ...failedResults.map((result) => {
-		const suffix = result.error ? `: ${formatErrorMessage$1(result.error)}` : ` exited with code ${result.status}`;
-		return `  ${toRelativePath(projectRootDir, result.configPath)}${suffix}`;
-	})].join("\n"));
-	else if (!options.flow?.interactive) TypecheckLogger.success(`Checked ${targets.length} checker build entry(s).`);
-	return {
-		passed,
-		projectRootDir,
-		rootConfigPaths
-	};
-}
-async function runCheckerBuild(options) {
-	if (options.clearScreen ?? true) clearCliScreen();
-	const elapsed = createElapsedTimer();
-	const task = options.flow?.start("checker build", { depth: options.flowDepth ?? 0 });
-	TypecheckLogger.info("checker build started");
-	try {
-		const result = await runCheckerBuildInternal(options);
-		if (result.passed) {
-			if (!options.flow?.interactive) TypecheckLogger.success("checker build finished", elapsed());
-			task?.pass();
-		} else {
-			TypecheckLogger.error("checker build finished with failures", elapsed());
-			task?.fail("checker build finished with failures");
-		}
-		return result;
-	} catch (error) {
-		TypecheckLogger.error(`checker build failed: ${formatErrorMessage$1(error)}`, elapsed());
-		task?.fail("checker build failed", { error });
-		throw error;
-	}
-}
-async function runCheckerTypecheckInternal(options) {
-	const cwd = path.resolve(options.cwd ?? process.cwd());
-	const projectRootDir = normalizeAbsolutePath(options.config.rootDir);
-	const allCheckers = getActiveCheckers(options.config);
-	const checkers = getExecutionCheckers({
-		checkers: allCheckers,
-		executionKind: "typecheck"
-	});
-	const flowDepth = options.flowDepth ?? 0;
-	const rootConfigPaths = [];
-	const problems = collectCheckerPeerDependencyProblems({
-		checkers: allCheckers,
-		projectRootDir,
-		resolvePackage: options.checkerPackageResolver
-	});
-	if (problems.length > 0) {
-		options.flow?.fail("checker dependency preflight failed", { depth: flowDepth + 1 });
-		TypecheckLogger.error(problems.join("\n\n"));
-		return {
-			passed: false,
-			projectRootDir,
-			rootConfigPaths
-		};
-	}
-	const targets = checkers.map((checker) => {
-		const configPath = resolveProjectConfigPath(projectRootDir, checker.entry);
-		rootConfigPaths.push(configPath);
-		return createCheckerTarget({
-			checker,
-			commandOverride: options.tscCommand,
-			configPath,
-			executionKind: "typecheck",
-			projectRootDir
-		});
-	});
-	if (targets.length === 0) {
-		options.flow?.info("no source-only checker entries configured", { depth: flowDepth + 1 });
-		if (!options.flow?.interactive) TypecheckLogger.success("No source-only checker entries configured.");
-		return {
-			passed: true,
-			projectRootDir,
-			rootConfigPaths
-		};
-	}
-	options.flow?.info(`found ${targets.length} checker typecheck entry(s)`, { depth: flowDepth + 1 });
-	TypecheckLogger.info([
-		`Running typecheck for ${targets.length} checker entry(s).`,
-		`CWD: ${toRelativePath(cwd, projectRootDir)}`,
-		`Entries: ${rootConfigPaths.map((configPath) => toRelativePath(projectRootDir, configPath)).join(", ")}`
-	].join("\n"));
-	const targetTasks = /* @__PURE__ */ new Map();
-	const failedResults = (await runWithConcurrency(targets, 1, options.runner ?? createDefaultRunner(), {
-		onTargetResult: (target, result) => {
-			const task = targetTasks.get(target.configPath);
-			if (!task) return;
-			if (result.status === 0) task.pass();
-			else {
-				const suffix = result.error ? formatErrorMessage$1(result.error) : `exited with code ${result.status}`;
-				task.fail(void 0, { error: suffix });
-			}
-		},
-		onTargetStart: (target) => {
-			if (!options.flow) return;
-			targetTasks.set(target.configPath, options.flow.start(target.label ?? `checker typecheck: ${toRelativePath(projectRootDir, target.configPath)}`, {
-				collapseOnSuccess: false,
-				depth: flowDepth + 1
-			}));
-		}
-	})).filter((result) => result.status !== 0);
-	const passed = failedResults.length === 0;
-	if (!passed) TypecheckLogger.error(["typecheck checks failed:", ...failedResults.map((result) => {
-		const suffix = result.error ? `: ${formatErrorMessage$1(result.error)}` : ` exited with code ${result.status}`;
-		return `  ${toRelativePath(projectRootDir, result.configPath)}${suffix}`;
-	})].join("\n"));
-	else if (!options.flow?.interactive) TypecheckLogger.success(`Checked ${targets.length} checker typecheck entry(s).`);
-	return {
-		passed,
-		projectRootDir,
-		rootConfigPaths
-	};
-}
-async function runCheckerTypecheck(options) {
-	if (options.clearScreen ?? true) clearCliScreen();
-	const elapsed = createElapsedTimer();
-	const task = options.flow?.start("checker typecheck", { depth: options.flowDepth ?? 0 });
-	TypecheckLogger.info("checker typecheck started");
-	try {
-		const result = await runCheckerTypecheckInternal(options);
-		if (result.passed) {
-			if (!options.flow?.interactive) TypecheckLogger.success("checker typecheck finished", elapsed());
-			task?.pass();
-		} else {
-			TypecheckLogger.error("checker typecheck finished with failures", elapsed());
-			task?.fail("checker typecheck finished with failures");
-		}
-		return result;
-	} catch (error) {
-		TypecheckLogger.error(`checker typecheck failed: ${formatErrorMessage$1(error)}`, elapsed());
-		task?.fail("checker typecheck failed", { error });
-		throw error;
-	}
-}
-
-//#endregion
-//#region src/flow.ts
-const DEFAULT_CI_ENV_VALUES = ["1", "true"];
-const DEFAULT_TERMINAL_COLUMNS = 80;
-const ANSI_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/gu;
-const ANSI_RESET = "\x1B[0m";
-const ANSI_GREEN = "\x1B[32m";
-const ANSI_RED = "\x1B[31m";
-const ANSI_YELLOW = "\x1B[33m";
-const FLOW_SYMBOL_BY_STATUS = {
-	fail: "■",
-	info: "│",
-	pass: "◆",
-	skip: "◇",
-	start: "◇",
-	warn: "▲"
-};
-function isCiEnvironment(env) {
-	return DEFAULT_CI_ENV_VALUES.includes(String(env.CI).toLowerCase());
-}
-function formatElapsedTime(milliseconds) {
-	if (milliseconds < 1e3) return `${Math.round(milliseconds)}ms`;
-	return `${(milliseconds / 1e3).toFixed(2)}s`;
-}
-function formatMessageWithElapsed(message, elapsedTimeMs) {
-	return typeof elapsedTimeMs === "number" ? `${message} (${formatElapsedTime(elapsedTimeMs)})` : message;
-}
-function formatFailureMessage(message, error) {
-	if (error === void 0) return message;
-	const detail = formatErrorMessage(error).replace(/\s+/gu, " ").trim();
-	return detail ? `${message}: ${detail}` : message;
-}
-function indentMessage(message, depth) {
-	if (depth <= 0) return message;
-	return `${"  ".repeat(depth)}${message}`;
-}
-function writeLine(output, message) {
-	output.write(`${message}\n`);
-}
-function toWritableText(chunk) {
-	if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString();
-	return String(chunk);
-}
-function stripControlSequences(text) {
-	return text.replace(ANSI_PATTERN, "").replaceAll("\r", "");
-}
-function colorInteractiveSymbol(status, symbol) {
-	if (status === "pass") return `${ANSI_GREEN}${symbol}${ANSI_RESET}`;
-	if (status === "fail") return `${ANSI_RED}${symbol}${ANSI_RESET}`;
-	if (status === "warn") return `${ANSI_YELLOW}${symbol}${ANSI_RESET}`;
-	return symbol;
-}
-var LiminaFlowReporter = class {
-	#clack;
-	#interactive;
-	#output;
-	#stderr;
-	#stdout;
-	#tracksProcessWrites;
-	#interactiveHistory = [];
-	#restoreWriteStreams;
-	#trackedTaskCount = 0;
-	#terminalColumn = 0;
-	#terminalLineCount = 0;
-	constructor(options = {}) {
-		const env = options.env ?? process.env;
-		const stdout = options.stdout ?? process.stdout;
-		this.#interactive = options.forceTty ?? Boolean(stdout.isTTY && !isCiEnvironment(env));
-		this.#clack = options.clack ?? prompts;
-		this.#output = options.output ?? { write: (message) => {
-			if (typeof stdout.write === "function") {
-				stdout.write(message);
-				return;
-			}
-			process.stdout.write(message);
-		} };
-		this.#stdout = stdout;
-		this.#stderr = options.stderr ?? process.stderr;
-		this.#tracksProcessWrites = this.#interactive && options.output === void 0;
-	}
-	get interactive() {
-		return this.#interactive;
-	}
-	intro(message) {
-		if (this.#interactive) {
-			this.#clack.intro(message);
-			this.#interactiveHistory.push(`┌  ${message}`);
-			return;
-		}
-		writeLine(this.#output, `[start] ${message}`);
-	}
-	outro(message) {
-		if (this.#interactive) {
-			this.#clack.outro(message);
-			return;
-		}
-		writeLine(this.#output, `[done] ${message}`);
-	}
-	start(message, options = {}) {
-		const depth = options.depth ?? 0;
-		const collapseOnSuccess = options.collapseOnSuccess ?? true;
-		const shouldTrackTask = this.#interactive && collapseOnSuccess;
-		const persistStart = !shouldTrackTask && this.#trackedTaskCount === 0;
-		const startLine = this.#terminalLineCount;
-		const startTime = performance.now();
-		let completed = false;
-		if (shouldTrackTask) this.#beginTerminalTracking();
-		const persistedStartIndex = this.#emit("start", message, options, { persistInteractive: persistStart });
-		const finishTrackedTask = () => {
-			if (!shouldTrackTask || completed) return;
-			completed = true;
-			this.#endTerminalTracking();
-		};
-		return {
-			fail: (nextMessage, nextOptions) => {
-				this.#emit("fail", formatFailureMessage(nextMessage ?? message, nextOptions?.error), {
-					...nextOptions,
-					depth,
-					elapsedTimeMs: nextOptions?.elapsedTimeMs ?? performance.now() - startTime
-				}, { persistInteractive: true });
-				if (!this.#interactive) return;
-				finishTrackedTask();
-			},
-			info: (nextMessage, nextOptions) => {
-				this.info(nextMessage, {
-					...nextOptions,
-					depth: nextOptions?.depth ?? depth + 1
-				});
-			},
-			pass: (nextMessage, nextOptions) => {
-				const passOptions = {
-					...nextOptions,
-					depth,
-					elapsedTimeMs: nextOptions?.elapsedTimeMs ?? performance.now() - startTime
-				};
-				const persistInteractive = shouldTrackTask ? this.#trackedTaskCount <= 1 : this.#trackedTaskCount === 0;
-				if (shouldTrackTask) this.#clearInteractiveTaskBlock(startLine, { redrawHistory: persistInteractive && depth === 0 });
-				if (!shouldTrackTask && this.#interactive && persistedStartIndex !== void 0) {
-					this.#replaceInteractiveHistoryLine(persistedStartIndex, "pass", nextMessage ?? message, passOptions);
-					this.#redrawInteractiveHistory();
-					finishTrackedTask();
-					return;
-				}
-				this.#emit("pass", nextMessage ?? message, passOptions, { persistInteractive });
-				finishTrackedTask();
-			},
-			skip: (nextMessage, nextOptions) => {
-				const skipOptions = {
-					...nextOptions,
-					depth,
-					elapsedTimeMs: nextOptions?.elapsedTimeMs ?? performance.now() - startTime
-				};
-				if (!shouldTrackTask && this.#interactive && persistedStartIndex !== void 0) {
-					this.#replaceInteractiveHistoryLine(persistedStartIndex, "skip", nextMessage ?? message, skipOptions);
-					this.#redrawInteractiveHistory();
-					finishTrackedTask();
-					return;
-				}
-				this.#emit("skip", nextMessage ?? message, skipOptions, { persistInteractive: this.#trackedTaskCount === 0 });
-				finishTrackedTask();
-			},
-			warn: (nextMessage, nextOptions) => {
-				this.warn(nextMessage, {
-					...nextOptions,
-					depth: nextOptions?.depth ?? depth + 1
-				});
-			}
-		};
-	}
-	fail(message, options = {}) {
-		this.#emit("fail", formatFailureMessage(message, options.error), options, { persistInteractive: true });
-	}
-	info(message, options = {}) {
-		this.#emit("info", message, options);
-	}
-	pass(message, options = {}) {
-		this.#emit("pass", message, options, { persistInteractive: true });
-	}
-	skip(message, options = {}) {
-		this.#emit("skip", message, options, { persistInteractive: true });
-	}
-	warn(message, options = {}) {
-		this.#emit("warn", message, options);
-	}
-	writeOutput(message, options = {}) {
-		const stream = options.stream === "stderr" ? this.#stderr : this.#stdout;
-		if (this.#interactive && this.#tracksProcessWrites && typeof stream?.write === "function") {
-			stream.write(message);
-			return;
-		}
-		this.#writeTracked(toWritableText(message));
-	}
-	#emit(status, rawMessage, options, meta = {}) {
-		const message = formatMessageWithElapsed(rawMessage, options.elapsedTimeMs);
-		const depth = options.depth ?? 0;
-		if (this.#interactive) {
-			const renderedLine = this.#formatInteractiveLine(status, message, depth);
-			let historyIndex;
-			if (meta.persistInteractive) {
-				historyIndex = this.#interactiveHistory.length;
-				this.#interactiveHistory.push(renderedLine);
-			}
-			writeLine({ write: (nextMessage) => {
-				this.#writeTracked(nextMessage);
-			} }, renderedLine);
-			return historyIndex;
-		}
-		writeLine(this.#output, `${"  ".repeat(depth)}[${status}] ${message}`);
-	}
-	#beginTerminalTracking() {
-		this.#trackedTaskCount += 1;
-		if (this.#trackedTaskCount > 1 || !this.#tracksProcessWrites) return;
-		const restoreStdout = this.#patchWriteStream(this.#stdout);
-		const restoreStderr = this.#patchWriteStream(this.#stderr);
-		this.#restoreWriteStreams = () => {
-			restoreStdout?.();
-			restoreStderr?.();
-			this.#restoreWriteStreams = void 0;
-		};
-	}
-	#clearInteractiveTaskBlock(startLine, options = {}) {
-		const linesToClear = this.#terminalLineCount - startLine;
-		if (linesToClear <= 0) return;
-		if (options.redrawHistory) {
-			this.#redrawInteractiveHistory();
-			return;
-		}
-		this.#writeControl(`\r\u001B[${linesToClear}A\u001B[J`);
-		this.#terminalLineCount = startLine;
-		this.#terminalColumn = 0;
-	}
-	#endTerminalTracking() {
-		this.#trackedTaskCount = Math.max(0, this.#trackedTaskCount - 1);
-		if (this.#trackedTaskCount === 0) this.#restoreWriteStreams?.();
-	}
-	#patchWriteStream(stream) {
-		if (typeof stream?.write !== "function") return;
-		const originalWrite = stream.write;
-		stream.write = (...args) => {
-			this.#recordTerminalWrite(args[0]);
-			return Reflect.apply(originalWrite, stream, args);
-		};
-		return () => {
-			stream.write = originalWrite;
-		};
-	}
-	#recordTerminalWrite(chunk) {
-		const text = stripControlSequences(toWritableText(chunk));
-		const columns = Math.max(1, this.#stdout?.columns ?? DEFAULT_TERMINAL_COLUMNS);
-		for (const char of text) {
-			if (char === "\n") {
-				this.#terminalLineCount += 1;
-				this.#terminalColumn = 0;
-				continue;
-			}
-			this.#terminalColumn += 1;
-			if (this.#terminalColumn >= columns) {
-				this.#terminalLineCount += 1;
-				this.#terminalColumn = 0;
-			}
-		}
-	}
-	#redrawInteractiveHistory() {
-		this.#writeControl("\r\x1B[H\x1B[2J\x1B[3J");
-		this.#terminalLineCount = 0;
-		this.#terminalColumn = 0;
-		for (const line of this.#interactiveHistory) writeLine({ write: (message) => {
-			this.#writeTracked(message);
-		} }, line);
-	}
-	#formatInteractiveLine(status, message, depth) {
-		const renderedMessage = indentMessage(message, depth);
-		return `${colorInteractiveSymbol(status, FLOW_SYMBOL_BY_STATUS[status])}    ${renderedMessage}`;
-	}
-	#replaceInteractiveHistoryLine(index, status, rawMessage, options) {
-		this.#interactiveHistory[index] = this.#formatInteractiveLine(status, formatMessageWithElapsed(rawMessage, options.elapsedTimeMs), options.depth ?? 0);
-	}
-	#writeControl(message) {
-		this.#output.write(message);
-	}
-	#writeTracked(message) {
-		if (!this.#tracksProcessWrites) this.#recordTerminalWrite(message);
-		this.#output.write(message);
-	}
-};
-function createLiminaFlowReporter(options = {}) {
-	return new LiminaFlowReporter(options);
-}
-
-//#endregion
-export { resolveReferencePath as $, resolveInternalImport as A, collectGraphProjectRouteFromRoot as B, findTargetProject as C, isDtsProjectConfig as D, inferPackageProject as E, getPackageRootSpecifier as F, createFormatHost as G, collectSourceGraphProjectExtensions as H, getPublishDependencySections as I, getRawReferencePaths as J, formatReferences as K, isWorkspaceDependencySpecifier as L, collectImporters as M, collectWorkspacePackages as N, isRelativeSpecifier$1 as O, findPackageForSpecifier as P, resolveProjectConfigPath as Q, collectCheckerEntryProjectRoutes as R, findPackageForFile as S, getTypecheckConfigPath as T, createExtensionPattern as U, collectGraphProjectRoutes as V, createExtraFileExtensions as W, parseProjectFileNamesForExtensions as X, isOrdinaryTypecheckConfigPath as Y, readJsonConfig as Z, getDeniedRefRule as _, runSourceCheck as a, createFileOwnerLookup as b, GraphLogger as c, ProofLogger as d, ReleaseLogger as f, getDeniedDepRuleForSpecifier as g, getDeniedDepRuleForPackage as h, runCheckerTypecheck as i, shouldResolveThroughGraph as j, parseProject as k, PackageLogger as l, formatErrorMessage$1 as m, createLiminaFlowReporter as n, runInit as o, clearCliScreen as p, getDtsCompanionConfigPath as q, runCheckerBuild as r, CliLogger as s, LiminaFlowReporter as t, PathsLogger as u, normalizeGraphRules as v, formatArtifactDependencyPolicy as w, findImporterForFile as x, collectImportsFromFile as y, collectGraphProjectRoute as z };