limina 0.0.1 → 0.0.3

package/chunks/{dep-DoSHsBSP.js → dep-UWxsul2A.js}

@@ -1,20 +1,20 @@
-import { c as getCheckerAdapter, h as toRelativePath, l as isPathInsideDirectory, o as collectMissingCheckerPeerDependencies, r as getActiveCheckers, s as formatMissingCheckerPeerDependencies, u as normalizeAbsolutePath } from "./dep-jgc7X0zw.js";
-import { builtinModules } from "node:module";
-import { createElapsedTimer, formatErrorMessage, formatErrorMessage as formatErrorMessage$1 } from "@docs-islands/logger/helper";
+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 "@docs-islands/logger";
+import { createLogger } from "logaria";
 import readline from "node:readline";
-import { availableParallelism } from "node:os";
 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 deprecatedGraphConfigFilePattern = /^tsconfig(?:\..+)?\.graph\.json$/u;
 const generatedConfigFilePattern = /^tsconfig(?:\..+)?\.paths\.generated\.json$/u;
 const baseConfigFilePattern = /^tsconfig(?:\..+)?\.base\.json$/u;
 const checkConfigFilePattern = /^tsconfig(?:\..+)?\.check\.json$/u;
@@ -30,7 +30,7 @@ function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 function createExtensionPattern(extensions) {
-	if (extensions.length === 0) return /$./u;
+	if (extensions.length === 0) return /(?!)/u;
 	return new RegExp(`(?:${extensions.sort((left, right) => right.length - left.length).map(escapeRegExp).join("|")})$`, "u");
 }
 function createExtraFileExtensions(extensions) {
@@ -140,13 +140,6 @@ function collectReferencePathInfosFromConfigObject(rootDir, configPath, configOb
 		references: referenceInfos
 	};
 }
-function isNonEmptyStringArray(value) {
-	return Array.isArray(value) && value.some((item) => typeof item === "string");
-}
-function hasOwnTypecheckInputs(configObject) {
-	if (!Object.hasOwn(configObject, "files") && !Object.hasOwn(configObject, "include")) return true;
-	return isNonEmptyStringArray(configObject.files) || isNonEmptyStringArray(configObject.include);
-}
 function isDtsConfigPath(configPath) {
 	return dtsConfigFilePattern.test(path.basename(configPath));
 }
@@ -161,101 +154,13 @@ function getDtsCompanionConfigPath(dtsConfigPath) {
 function isBuildGraphConfigPath(configPath) {
 	return buildGraphConfigFilePattern.test(path.basename(configPath));
 }
-function isDeprecatedGraphConfigPath(configPath) {
-	return deprecatedGraphConfigFilePattern.test(path.basename(configPath));
-}
 function isReservedTypeScriptConfigFile(fileName) {
-	return dtsConfigFilePattern.test(fileName) || buildGraphConfigFilePattern.test(fileName) || deprecatedGraphConfigFilePattern.test(fileName) || generatedConfigFilePattern.test(fileName) || baseConfigFilePattern.test(fileName) || checkConfigFilePattern.test(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 collectTypecheckTargetProjectPaths(options) {
-	const rootConfigPath = normalizeAbsolutePath(options.rootConfigPath);
-	const reportedCycles = /* @__PURE__ */ new Set();
-	const seen = /* @__PURE__ */ new Set();
-	const problems = [];
-	const projectPaths = [];
-	const targetProjectPaths = [];
-	const formatConfigPath = (configPath) => toRelativePath(options.rootDir, configPath);
-	const addCycleProblem = (referencePath, stack) => {
-		const cycleStartIndex = stack.indexOf(referencePath);
-		const cyclePaths = cycleStartIndex === -1 ? [...stack, referencePath] : [...stack.slice(cycleStartIndex), referencePath];
-		const cycleKey = cyclePaths.join("\0");
-		if (reportedCycles.has(cycleKey)) return;
-		reportedCycles.add(cycleKey);
-		problems.push([
-			"Circular reference in ordinary tsconfig references:",
-			`  cycle: ${cyclePaths.map(formatConfigPath).join(" -> ")}`,
-			"  reason: ordinary tsconfig references used by limina checker typecheck must form an acyclic graph.",
-			"  fix: remove one reference from the cycle, or move shared options into extends instead of references."
-		].join("\n"));
-	};
-	const visitProject = (projectPath, stack) => {
-		if (stack.includes(projectPath)) {
-			addCycleProblem(projectPath, stack);
-			return;
-		}
-		if (seen.has(projectPath)) return;
-		if (!existsSync(projectPath)) {
-			problems.push(["Ordinary tsconfig reference graph references a missing tsconfig:", `  config: ${formatConfigPath(projectPath)}`].join("\n"));
-			return;
-		}
-		if (!isOrdinaryTypecheckConfigPath(projectPath)) {
-			problems.push([
-				"Invalid config in ordinary tsconfig reference graph:",
-				`  config: ${formatConfigPath(projectPath)}`,
-				"  reason: ordinary tsconfig references must stay on ordinary tsconfig*.json files; tsconfig*.build.json graph aggregators and tsconfig*.dts.json declaration leaves belong to checker entries."
-			].join("\n"));
-			return;
-		}
-		seen.add(projectPath);
-		projectPaths.push(projectPath);
-		const configObject = readJsonConfigFile(options.rootDir, projectPath);
-		const referenceCollection = collectReferencePathInfosFromConfigObject(options.rootDir, projectPath, configObject);
-		const referencePaths = referenceCollection.references.map((reference) => reference.resolvedPath);
-		problems.push(...referenceCollection.problems);
-		if (referencePaths.length === 0 || hasOwnTypecheckInputs(configObject)) targetProjectPaths.push(projectPath);
-		const nextStack = [...stack, projectPath];
-		for (const referencePath of referencePaths) {
-			if (isBuildGraphConfigPath(referencePath) || isDtsConfigPath(referencePath)) {
-				problems.push([
-					"Invalid reference in ordinary tsconfig reference graph:",
-					`  from: ${formatConfigPath(projectPath)}`,
-					`  to: ${formatConfigPath(referencePath)}`,
-					"  reason: ordinary tsconfig references must stay on ordinary tsconfig*.json files; build graph configs and declaration leaves are checked through checker entries."
-				].join("\n"));
-				continue;
-			}
-			if (!isOrdinaryTypecheckConfigPath(referencePath)) {
-				problems.push([
-					"Invalid reference in ordinary tsconfig reference graph:",
-					`  from: ${formatConfigPath(projectPath)}`,
-					`  to: ${formatConfigPath(referencePath)}`,
-					"  reason: referenced config must be an ordinary tsconfig*.json file."
-				].join("\n"));
-				continue;
-			}
-			if (nextStack.includes(referencePath)) {
-				addCycleProblem(referencePath, nextStack);
-				continue;
-			}
-			visitProject(referencePath, nextStack);
-		}
-	};
-	visitProject(rootConfigPath, []);
-	if (problems.length === 0 && targetProjectPaths.length === 0) problems.push([
-		"Ordinary tsconfig reference graph has no tsconfig targets:",
-		`  root: ${toRelativePath(options.rootDir, rootConfigPath)}`,
-		"  reason: limina checker typecheck runs ordinary tsconfig*.json files without references, plus configs that have references and their own source inputs."
-	].join("\n"));
-	return {
-		problems,
-		projectPaths,
-		targetProjectPaths
-	};
-}
 function collectGraphProjectRouteFromRoot(options) {
 	const rootGraphConfigPath = normalizeAbsolutePath(options.rootConfigPath);
 	const seen = /* @__PURE__ */ new Set();
@@ -269,13 +174,7 @@ function collectGraphProjectRouteFromRoot(options) {
 	}));
 	const formatConfigPath = (configPath) => toRelativePath(options.rootDir, configPath);
 	problems.push(...rootReferences.problems);
-	if (isDeprecatedGraphConfigPath(rootGraphConfigPath)) problems.push([
-		"Checker entry uses a deprecated tsconfig name:",
-		`  config: ${formatConfigPath(rootGraphConfigPath)}`,
-		"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-		"  fix: rename the checker entry to tsconfig*.build.json."
-	].join("\n"));
-	else if (!isBuildGraphConfigPath(rootGraphConfigPath) && !isDtsConfigPath(rootGraphConfigPath)) problems.push([
+	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."
@@ -287,17 +186,6 @@ function collectGraphProjectRouteFromRoot(options) {
 	for (const { projectPath } of queue) seen.add(projectPath);
 	for (const { projectPath, rawReferencePath, referrerPath } of queue) {
 		if (!projectPath) continue;
-		if (isDeprecatedGraphConfigPath(projectPath)) {
-			problems.push([
-				"Deprecated checker entry reference:",
-				`  from: ${formatConfigPath(referrerPath)}`,
-				`  reference: ${rawReferencePath}`,
-				`  resolved: ${formatConfigPath(projectPath)}`,
-				"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-				"  fix: rename the referenced config to tsconfig*.build.json and update this reference."
-			].join("\n"));
-			continue;
-		}
 		if (!existsSync(projectPath)) {
 			problems.push([
 				"Checker entry references a missing tsconfig:",
@@ -341,18 +229,8 @@ function collectGraphProjectRoutes(config) {
 	const routes = [];
 	const problems = [];
 	for (const checker of getActiveCheckers(config)) {
-		if (!getCheckerAdapter(checker.preset)?.graph) continue;
+		if (!getCheckerAdapter(checker.preset)?.sourceGraph) continue;
 		const rootConfigPath = resolveProjectConfigPath(config.rootDir, checker.entry);
-		if (isDeprecatedGraphConfigPath(rootConfigPath)) {
-			problems.push([
-				"Checker graph entry uses a deprecated tsconfig name:",
-				`  checker: ${checker.name}`,
-				`  config: ${toRelativePath(config.rootDir, rootConfigPath)}`,
-				"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-				"  fix: rename the checker entry to tsconfig*.build.json."
-			].join("\n"));
-			continue;
-		}
 		if (!existsSync(rootConfigPath)) {
 			problems.push([
 				"Checker graph entry references a missing tsconfig:",
@@ -368,6 +246,7 @@ function collectGraphProjectRoutes(config) {
 		problems.push(...routeCollection.problems);
 		routes.push({
 			checkerName: checker.name,
+			extensions: checker.extensions,
 			projectPaths: routeCollection.projectPaths,
 			rootConfigPath
 		});
@@ -382,16 +261,6 @@ function collectCheckerEntryProjectRoutes(config) {
 	const problems = [];
 	for (const checker of getActiveCheckers(config)) {
 		const rootConfigPath = resolveProjectConfigPath(config.rootDir, checker.entry);
-		if (isDeprecatedGraphConfigPath(rootConfigPath)) {
-			problems.push([
-				"Checker entry uses a deprecated tsconfig name:",
-				`  checker: ${checker.name}`,
-				`  config: ${toRelativePath(config.rootDir, rootConfigPath)}`,
-				"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-				"  fix: rename the checker entry to tsconfig*.build.json."
-			].join("\n"));
-			continue;
-		}
 		if (!existsSync(rootConfigPath)) {
 			problems.push([
 				"Checker entry references a missing tsconfig:",
@@ -407,6 +276,7 @@ function collectCheckerEntryProjectRoutes(config) {
 		problems.push(...routeCollection.problems);
 		routes.push({
 			checkerName: checker.name,
+			extensions: checker.extensions,
 			projectPaths: routeCollection.projectPaths,
 			rootConfigPath
 		});
@@ -423,8 +293,18 @@ function collectGraphProjectRoute(config) {
 		projectPaths: [...new Set(routeCollection.routes.flatMap((route) => route.projectPaths))].sort()
 	};
 }
-function parseProjectFileNames(config, configPath, pattern = /\.(?:[cm]?tsx?|d\.[cm]?ts|json)$/u) {
-	return parseProjectFileNamesForExtensions(config, configPath, [], pattern);
+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 = [];
@@ -441,7 +321,7 @@ function formatReferences(rootDir, references) {
 
 //#endregion
 //#region src/workspace.ts
-const pnpmWorkspaceFileName = "pnpm-workspace.yaml";
+const pnpmWorkspaceFileName$1 = "pnpm-workspace.yaml";
 const pnpmWorkspaceListTimeoutMs = 3e3;
 function readJsonFile(filePath) {
 	return JSON.parse(readFileSync(filePath, "utf8"));
@@ -488,7 +368,7 @@ function collectWorkspacePatterns(config) {
 		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);
+	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();
 }
@@ -625,6 +505,22 @@ function getDependencySections(importer) {
 		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:");
 }
@@ -663,7 +559,7 @@ function collectImporters(config, packages) {
 
 //#endregion
 //#region src/graph-context.ts
-function isRelativeSpecifier(specifier) {
+function isRelativeSpecifier$1(specifier) {
 	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
 }
 function isDtsProjectConfig(configPath) {
@@ -702,9 +598,9 @@ function readProjectLabel(config, configPath) {
 		].join("\n")
 	};
 }
-function parseProject(config, configPath) {
+function parseProject(config, configPath, extensions) {
 	const diagnostics = [];
-	const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, {
+	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);
@@ -721,9 +617,20 @@ function parseProject(config, configPath) {
 		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),
-		fileNames: parsed.fileNames.filter((fileName) => /\.(?:[cm]?tsx?|d\.[cm]?ts)$/u.test(fileName)).map(normalizeAbsolutePath),
+		extensions: projectExtensions,
+		fileNames: parsed.fileNames.filter((fileName) => filePattern.test(fileName)).map(normalizeAbsolutePath),
 		label: labelInfo.label,
 		labelProblem: labelInfo.labelProblem,
 		options: parsed.options,
@@ -738,15 +645,27 @@ function getSourceFileKind(filePath) {
 function stringLiteralValue(node) {
 	return node && ts.isStringLiteralLike(node) ? node.text : null;
 }
-function collectImportsFromFile(filePath) {
-	const sourceText = readFileSync(filePath, "utf8");
-	const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, getSourceFileKind(filePath));
+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,
-			line: location.line + 1,
+			filePath: options.filePath,
+			line: lineOffset + location.line + 1,
 			specifier
 		});
 	};
@@ -766,9 +685,37 @@ function collectImportsFromFile(filePath) {
 	visit(sourceFile);
 	return imports;
 }
-function resolveInternalImport(specifier, containingFile, options) {
+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;
-	return resolved?.resolvedFileName ? normalizeAbsolutePath(resolved.resolvedFileName) : null;
+	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) => {
@@ -779,9 +726,6 @@ function chooseOwningProject(projectPaths) {
 function findPackageForFile(filePath, packages) {
 	return [...packages].sort((left, right) => right.directory.length - left.directory.length).find((workspacePackage) => isPathInsideDirectory(filePath, workspacePackage.directory)) ?? null;
 }
-function isWorkspacePackageFile(filePath, packages) {
-	return packages.some((workspacePackage) => isPathInsideDirectory(filePath, workspacePackage.directory));
-}
 function findImporterForFile(filePath, importers) {
 	return importers.find((importer) => isPathInsideDirectory(filePath, importer.directory)) ?? null;
 }
@@ -834,6 +778,60 @@ function formatUnknownValue(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 {};
@@ -900,13 +898,13 @@ function addNormalizedRuleRef(options) {
 	});
 	options.refsByLabel.set(options.label, refs);
 }
-function addNormalizedWorkspaceDep(options) {
-	const field = `${options.fieldPrefix}[${options.index}]`;
+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 workspace dependency entries must be objects with non-empty name and reason fields."
+			"  reason: deny.deps entries must be objects with non-empty name and reason fields."
 		]);
 		return;
 	}
@@ -916,7 +914,7 @@ function addNormalizedWorkspaceDep(options) {
 		addRuleEntryConfigProblem(options.problems, [
 			`  field: ${field}.name`,
 			`  value: ${formatUnknownValue(nameValue)}`,
-			"  reason: workspace dependency name is required and must be a non-empty string."
+			"  reason: deny.deps name is required and must be a non-empty string."
 		]);
 		return;
 	}
@@ -924,82 +922,31 @@ function addNormalizedWorkspaceDep(options) {
 		addRuleEntryConfigProblem(options.problems, [
 			`  field: ${field}.reason`,
 			`  value: ${formatUnknownValue(reasonValue)}`,
-			"  reason: workspace dependency reason is required and must be a non-empty string."
-		]);
-		return;
-	}
-	const packageName = nameValue.trim();
-	if (!options.packageNames.has(packageName)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.name`,
-			`  name: ${packageName}`,
-			"  reason: deny.workspaceDeps and legacy deny.deps only accept discovered workspace package names. Use deny.nodeBuiltins for Node builtins."
-		]);
-		return;
-	}
-	const deps = options.workspaceDepsByLabel.get(options.label) ?? /* @__PURE__ */ new Map();
-	deps.set(packageName, {
-		name: packageName,
-		reason: reasonValue.trim()
-	});
-	options.workspaceDepsByLabel.set(options.label, deps);
-}
-function addNormalizedNodeBuiltin(options) {
-	const field = `graph.rules.${options.label}.deny.nodeBuiltins[${options.index}]`;
-	if (!isPlainRecord(options.entry)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}`,
-			`  value: ${formatUnknownValue(options.entry)}`,
-			"  reason: deny.nodeBuiltins 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.nodeBuiltins 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.nodeBuiltins reason is required and must be a non-empty string."
+			"  reason: deny.deps reason is required and must be a non-empty string."
 		]);
 		return;
 	}
 	const name = nameValue.trim();
-	const normalizedName = name.startsWith("node:") ? name.slice(5) : name;
-	const matchAll = name === "node:*";
-	if (!matchAll && !nodeBuiltinNames.has(normalizedName)) {
+	const normalizedDep = createNormalizedDep(name, reasonValue.trim());
+	if (!normalizedDep) {
 		addRuleEntryConfigProblem(options.problems, [
 			`  field: ${field}.name`,
 			`  name: ${name}`,
-			"  reason: deny.nodeBuiltins name must be \"node:*\" or a Node builtin specifier such as \"fs\" or \"node:fs\"."
+			"  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 entries = options.nodeBuiltinsByLabel.get(options.label) ?? [];
-	entries.push({
-		matchAll,
-		name: normalizedName,
-		reason: reasonValue.trim()
-	});
-	options.nodeBuiltinsByLabel.set(options.label, entries);
+	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 workspaceDepsByLabel = /* @__PURE__ */ new Map();
-	const nodeBuiltinsByLabel = /* @__PURE__ */ new Map();
 	const projectPathSet = new Set(options.projectPaths);
-	const packageNames = new Set(options.packages.map((workspacePackage) => workspacePackage.name));
 	for (const [rawLabel, rawRule] of Object.entries(getRulesRecord(options.config, options.problems))) {
 		const label = rawLabel.trim();
 		if (!label) {
@@ -1040,60 +987,35 @@ function normalizeGraphRules(options) {
 				refsByLabel
 			});
 		});
-		const legacyDeps = rawRule.deny.deps;
-		if (shouldNormalizeRuleKind(options.include, "workspaceDeps") && legacyDeps !== void 0) if (!Array.isArray(legacyDeps)) addRuleEntryConfigProblem(options.problems, [
-			`  field: graph.rules.${label}.deny.deps`,
-			`  value: ${formatUnknownValue(legacyDeps)}`,
-			"  reason: deny.deps must be an array."
-		]);
-		else legacyDeps.forEach((entry, index) => {
-			addNormalizedWorkspaceDep({
-				entry,
-				fieldPrefix: `graph.rules.${label}.deny.deps`,
-				index,
-				label,
-				packageNames,
-				problems: options.problems,
-				workspaceDepsByLabel
-			});
-		});
-		const workspaceDeps = rawRule.deny.workspaceDeps;
-		if (shouldNormalizeRuleKind(options.include, "workspaceDeps") && workspaceDeps !== void 0) if (!Array.isArray(workspaceDeps)) addRuleEntryConfigProblem(options.problems, [
+		if (shouldNormalizeRuleKind(options.include, "deps") && rawRule.deny.workspaceDeps !== void 0) addRuleEntryConfigProblem(options.problems, [
 			`  field: graph.rules.${label}.deny.workspaceDeps`,
-			`  value: ${formatUnknownValue(workspaceDeps)}`,
-			"  reason: deny.workspaceDeps must be an array."
+			`  value: ${formatUnknownValue(rawRule.deny.workspaceDeps)}`,
+			"  reason: deny.workspaceDeps has been removed; use deny.deps."
 		]);
-		else workspaceDeps.forEach((entry, index) => {
-			addNormalizedWorkspaceDep({
-				entry,
-				fieldPrefix: `graph.rules.${label}.deny.workspaceDeps`,
-				index,
-				label,
-				packageNames,
-				problems: options.problems,
-				workspaceDepsByLabel
-			});
-		});
-		const nodeBuiltins = rawRule.deny.nodeBuiltins;
-		if (shouldNormalizeRuleKind(options.include, "nodeBuiltins") && nodeBuiltins !== void 0) if (!Array.isArray(nodeBuiltins)) addRuleEntryConfigProblem(options.problems, [
+		if (shouldNormalizeRuleKind(options.include, "deps") && rawRule.deny.nodeBuiltins !== void 0) addRuleEntryConfigProblem(options.problems, [
 			`  field: graph.rules.${label}.deny.nodeBuiltins`,
-			`  value: ${formatUnknownValue(nodeBuiltins)}`,
-			"  reason: deny.nodeBuiltins must be an array."
+			`  value: ${formatUnknownValue(rawRule.deny.nodeBuiltins)}`,
+			"  reason: deny.nodeBuiltins has been removed; use deny.deps."
 		]);
-		else nodeBuiltins.forEach((entry, index) => {
-			addNormalizedNodeBuiltin({
+		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,
-				nodeBuiltinsByLabel,
 				problems: options.problems
 			});
 		});
 	}
 	return {
-		nodeBuiltinsByLabel,
-		refsByLabel,
-		workspaceDepsByLabel
+		depsByLabel,
+		refsByLabel
 	};
 }
 function isNodeBuiltinSpecifier(specifier) {
@@ -1103,14 +1025,24 @@ function getDeniedRefRule(rules, label, targetProjectPath) {
 	if (!label) return null;
 	return rules.refsByLabel.get(label)?.get(targetProjectPath) ?? null;
 }
-function getDeniedWorkspaceDepRule(rules, label, targetPackageName) {
-	if (!label) return null;
-	return rules.workspaceDepsByLabel.get(label)?.get(targetPackageName) ?? null;
-}
-function getDeniedNodeBuiltinRule(rules, label, specifier) {
-	if (!label || !isNodeBuiltinSpecifier(specifier)) return null;
-	const normalizedSpecifier = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-	return rules.nodeBuiltinsByLabel.get(label)?.find((rule) => rule.matchAll || rule.name === normalizedSpecifier) ?? 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
@@ -1118,6 +1050,7 @@ function getDeniedNodeBuiltinRule(rules, label, specifier) {
 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");
@@ -1132,6 +1065,541 @@ function clearCliScreen() {
 	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) {
@@ -1140,11 +1608,14 @@ function findOwnerForFile(filePath, owners) {
 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(specifier) && !isPackageImportSpecifier(specifier) && !isUrlOrDataOrFileSpecifier(specifier) && !path.isAbsolute(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]);
@@ -1218,17 +1689,6 @@ function addPackageImportAuthorizationProblem(options) {
 		"  reason: source imports must be authorized by the nearest package.json dependencies or devDependencies."
 	].join("\n"));
 }
-function addNodeBuiltinDenyProblem(options) {
-	options.problems.push([
-		"Denied Node builtin import:",
-		`  rule: ${options.project.label}`,
-		`  importing project: ${toRelativePath(options.config.rootDir, options.project.configPath)}`,
-		`  file: ${toRelativePath(options.config.rootDir, options.importRecord.filePath)}:${options.importRecord.line}`,
-		`  imported specifier: ${options.importRecord.specifier}`,
-		`  denied builtin: ${options.ruleName}`,
-		`  reason: ${options.reason}`
-	].join("\n"));
-}
 function addPackageImportProblem(options) {
 	if (!packageImportsMatch(options.owner.manifest.imports, options.importRecord.specifier)) {
 		options.problems.push([
@@ -1263,7 +1723,7 @@ 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).fileNames) fileNames.add(fileName);
+		if (existsSync(typecheckConfigPath)) for (const fileName of parseProject(config, typecheckConfigPath, project.extensions).fileNames) fileNames.add(fileName);
 		return {
 			fileNames: [...fileNames].sort(),
 			project
@@ -1271,24 +1731,12 @@ function createSourceProjectEntries(config, projects) {
 	});
 }
 async function runSourceCheckInternal(config, options = {}) {
-	const graphRoute = collectGraphProjectRoute(config);
-	const projectPaths = graphRoute.projectPaths;
-	const projects = projectPaths.map((projectPath) => parseProject(config, projectPath));
+	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];
-	const graphRules = normalizeGraphRules({
-		config,
-		include: {
-			nodeBuiltins: true,
-			refs: false,
-			workspaceDeps: false
-		},
-		packages,
-		problems,
-		projectPaths
-	});
 	for (const project of projects) {
 		if (project.labelProblem) problems.push(project.labelProblem);
 		if (!isDtsProjectConfig(project.configPath)) continue;
@@ -1304,7 +1752,7 @@ async function runSourceCheckInternal(config, options = {}) {
 		if (existsSync(typecheckConfigPath)) addProjectOwnerProblems({
 			config,
 			configPath: typecheckConfigPath,
-			fileNames: parseProject(config, typecheckConfigPath).fileNames,
+			fileNames: parseProject(config, typecheckConfigPath, project.extensions).fileNames,
 			owners: packageOwners,
 			problems,
 			role: "typecheck companion"
@@ -1313,9 +1761,9 @@ async function runSourceCheckInternal(config, options = {}) {
 	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)) {
-			const resolvedFilePath = resolveInternalImport(importRecord.specifier, filePath, project.options);
-			if (isRelativeSpecifier(importRecord.specifier)) {
+		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({
@@ -1338,20 +1786,9 @@ async function runSourceCheckInternal(config, options = {}) {
 				});
 				continue;
 			}
-			if (isUrlOrDataOrFileSpecifier(importRecord.specifier)) continue;
+			if (isUrlOrDataOrFileSpecifier(importRecord.specifier) || isVirtualModuleSpecifier(importRecord.specifier)) continue;
 			if (!isBarePackageSpecifier(importRecord.specifier)) continue;
-			if (isNodeBuiltinSpecifier(importRecord.specifier)) {
-				const deniedBuiltinRule = getDeniedNodeBuiltinRule(graphRules, project.label, importRecord.specifier);
-				if (deniedBuiltinRule) addNodeBuiltinDenyProblem({
-					config,
-					importRecord,
-					problems,
-					project,
-					reason: deniedBuiltinRule.reason,
-					ruleName: deniedBuiltinRule.matchAll ? "node:*" : deniedBuiltinRule.name
-				});
-				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;
@@ -1398,14 +1835,9 @@ async function runSourceCheck(config, options = {}) {
 
 //#endregion
 //#region src/commands/typecheck.ts
-function normalizeConcurrency(value) {
-	if (value === void 0) return Math.max(1, availableParallelism());
-	if (!Number.isInteger(value) || value < 1) throw new Error("Typecheck concurrency must be a positive integer.");
-	return value;
-}
 function getExecutionCheckers(options) {
 	return options.checkers.filter((checker) => {
-		return getCheckerAdapter(checker.preset)?.supportedExecutions.includes(options.executionKind);
+		return getCheckerAdapter(checker.preset)?.execution === options.executionKind;
 	});
 }
 function collectCheckerPeerDependencyProblems(options) {
@@ -1427,49 +1859,14 @@ function createCheckerTarget(options) {
 		executionKind: options.executionKind
 	};
 }
-function collectCompanionTypecheckTargets(options) {
-	const entryConfigPath = resolveProjectConfigPath(options.projectRootDir, options.checker.entry);
-	if (!existsSync(entryConfigPath)) return {
-		entryConfigPath,
-		problems: [[
-			"Checker entry references a missing tsconfig:",
-			`  checker: ${options.checker.name}`,
-			`  config: ${toRelativePath(options.projectRootDir, entryConfigPath)}`
-		].join("\n")],
-		targetProjectPaths: []
-	};
-	const routeCollection = collectGraphProjectRouteFromRoot({
-		rootConfigPath: entryConfigPath,
-		rootDir: options.projectRootDir
-	});
-	const dtsConfigPaths = routeCollection.projectPaths.filter(isDtsConfigPath);
-	const targetProjectPaths = [...new Set(dtsConfigPaths.map(getDtsCompanionConfigPath))].sort();
-	const problems = [...routeCollection.problems];
-	if (dtsConfigPaths.length === 0) problems.push([
-		"Checker entry has no declaration leaf targets:",
-		`  checker: ${options.checker.name}`,
-		`  entry: ${toRelativePath(options.projectRootDir, entryConfigPath)}`,
-		"  reason: checker:typecheck derives targets from tsconfig*.dts.json leaves reachable from the checker entry."
-	].join("\n"));
-	for (const configPath of targetProjectPaths) {
-		if (existsSync(configPath)) continue;
-		problems.push([
-			"DTS leaf companion config is missing:",
-			`  checker: ${options.checker.name}`,
-			`  expected: ${toRelativePath(options.projectRootDir, configPath)}`,
-			"  reason: checker:typecheck runs the strict local tsconfig companion for each reachable declaration leaf."
-		].join("\n"));
-	}
-	return {
-		entryConfigPath,
-		problems,
-		targetProjectPaths
-	};
-}
 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"
 		});
@@ -1514,138 +1911,106 @@ async function runWithConcurrency(targets, concurrency, runner, options = {}) {
 	}));
 	return results;
 }
-async function runCheckerTypecheckInternal(options) {
+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: "typecheck"
+		executionKind: "build"
 	});
 	const flowDepth = options.flowDepth ?? 0;
-	const concurrency = normalizeConcurrency(options.concurrency);
+	const rootConfigPaths = [];
 	const problems = collectCheckerPeerDependencyProblems({
 		checkers: allCheckers,
 		projectRootDir,
 		resolvePackage: options.checkerPackageResolver
 	});
-	const rootConfigPaths = [];
-	const targetProjectPaths = [];
-	const targets = [];
 	if (problems.length > 0) {
 		options.flow?.fail("checker dependency preflight failed", { depth: flowDepth + 1 });
 		TypecheckLogger.error(problems.join("\n\n"));
 		return {
 			passed: false,
 			projectRootDir,
-			results: [],
-			rootConfigPaths,
-			targetProjectPaths
+			rootConfigPaths
 		};
 	}
-	if (checkers.length === 0) problems.push(["No checker typecheck entries configured:", "  reason: configure config.checkers.<name>.entry with a preset that supports checker:typecheck."].join("\n"));
-	for (const checker of checkers) {
-		const targetCollection = collectCompanionTypecheckTargets({
-			checker,
-			projectRootDir
-		});
-		problems.push(...targetCollection.problems);
-		rootConfigPaths.push(targetCollection.entryConfigPath);
-		targetProjectPaths.push(...targetCollection.targetProjectPaths);
-		targets.push(...targetCollection.targetProjectPaths.map((configPath) => createCheckerTarget({
+	const targets = checkers.flatMap((checker) => {
+		const configPath = resolveProjectConfigPath(projectRootDir, checker.entry);
+		rootConfigPaths.push(configPath);
+		return [createCheckerTarget({
 			checker,
 			commandOverride: options.tscCommand,
 			configPath,
-			executionKind: "typecheck",
+			executionKind: "build",
 			projectRootDir
-		})));
-	}
-	if (problems.length > 0) {
-		options.flow?.fail("typecheck target discovery failed", { depth: flowDepth + 1 });
-		TypecheckLogger.error(problems.join("\n\n"));
-		return {
-			passed: false,
-			projectRootDir,
-			results: [],
-			rootConfigPaths,
-			targetProjectPaths
-		};
-	}
-	options.flow?.info(`found ${targets.length} typecheck target config(s) across ${checkers.length} checker(s); concurrency ${concurrency}`, { depth: flowDepth + 1 });
+		})];
+	});
+	options.flow?.info(`found ${targets.length} checker build entry(s)`, { depth: flowDepth + 1 });
 	TypecheckLogger.info([
-		`Running checker typechecks for ${targets.length} target config(s).`,
+		`Running build checks for ${targets.length} checker entry(s).`,
 		`CWD: ${toRelativePath(cwd, projectRootDir)}`,
 		`Entries: ${rootConfigPaths.map((configPath) => toRelativePath(projectRootDir, configPath)).join(", ")}`
 	].join("\n"));
-	const targetFlowStates = /* @__PURE__ */ new Map();
-	const results = await runWithConcurrency(targets, concurrency, options.runner ?? createDefaultRunner(), {
+	const targetTasks = /* @__PURE__ */ new Map();
+	const failedResults = (await runWithConcurrency(targets, 1, options.runner ?? createDefaultRunner(), {
 		onTargetResult: (target, result) => {
-			if (!options.flow) return;
-			const flowState = targetFlowStates.get(target.configPath);
-			if (!flowState) return;
-			const resultOptions = {
-				depth: flowDepth + 1,
-				elapsedTimeMs: performance.now() - flowState.startedAt
-			};
-			if (result.status === 0) options.flow.pass(flowState.label, resultOptions);
+			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}`;
-				options.flow.fail(flowState.label, {
-					...resultOptions,
-					error: suffix
-				});
+				task.fail(void 0, { error: suffix });
 			}
 		},
 		onTargetStart: (target) => {
 			if (!options.flow) return;
-			targetFlowStates.set(target.configPath, {
-				label: target.label ?? `checker: ${toRelativePath(projectRootDir, target.configPath)}`,
-				startedAt: performance.now()
-			});
+			targetTasks.set(target.configPath, options.flow.start(target.label ?? `checker build: ${toRelativePath(projectRootDir, target.configPath)}`, {
+				collapseOnSuccess: false,
+				depth: flowDepth + 1
+			}));
 		}
-	});
-	const failedResults = results.filter((result) => result.status !== 0);
-	if (failedResults.length > 0) TypecheckLogger.error([`Typecheck failed for ${failedResults.length} config(s):`, ...failedResults.map((result) => {
+	})).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} typecheck target config(s) from ${rootConfigPaths.length} checker entry(s).`);
+	else if (!options.flow?.interactive) TypecheckLogger.success(`Checked ${targets.length} checker build entry(s).`);
 	return {
-		passed: failedResults.length === 0,
+		passed,
 		projectRootDir,
-		results,
-		rootConfigPaths,
-		targetProjectPaths
+		rootConfigPaths
 	};
 }
-async function runCheckerTypecheck(options) {
+async function runCheckerBuild(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");
+	const task = options.flow?.start("checker build", { depth: options.flowDepth ?? 0 });
+	TypecheckLogger.info("checker build started");
 	try {
-		const result = await runCheckerTypecheckInternal(options);
+		const result = await runCheckerBuildInternal(options);
 		if (result.passed) {
-			if (!options.flow?.interactive) TypecheckLogger.success("checker typecheck finished", elapsed());
+			if (!options.flow?.interactive) TypecheckLogger.success("checker build finished", elapsed());
 			task?.pass();
 		} else {
-			TypecheckLogger.error("checker typecheck finished with failures", elapsed());
-			task?.fail("checker typecheck finished with failures");
+			TypecheckLogger.error("checker build finished with failures", elapsed());
+			task?.fail("checker build finished with failures");
 		}
 		return result;
 	} catch (error) {
-		TypecheckLogger.error(`checker typecheck failed: ${formatErrorMessage$1(error)}`, elapsed());
-		task?.fail("checker typecheck failed", { error });
+		TypecheckLogger.error(`checker build failed: ${formatErrorMessage$1(error)}`, elapsed());
+		task?.fail("checker build failed", { error });
 		throw error;
 	}
 }
-async function runCheckerBuildInternal(options) {
+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: "build"
+		executionKind: "typecheck"
 	});
 	const flowDepth = options.flowDepth ?? 0;
 	const rootConfigPaths = [];
@@ -1663,20 +2028,29 @@ async function runCheckerBuildInternal(options) {
 			rootConfigPaths
 		};
 	}
-	const targets = checkers.flatMap((checker) => {
+	const targets = checkers.map((checker) => {
 		const configPath = resolveProjectConfigPath(projectRootDir, checker.entry);
 		rootConfigPaths.push(configPath);
-		return [createCheckerTarget({
+		return createCheckerTarget({
 			checker,
 			commandOverride: options.tscCommand,
 			configPath,
-			executionKind: "build",
+			executionKind: "typecheck",
 			projectRootDir
-		})];
+		});
 	});
-	options.flow?.info(`found ${targets.length} checker build entry(s)`, { depth: flowDepth + 1 });
+	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 build checks for ${targets.length} checker entry(s).`,
+		`Running typecheck for ${targets.length} checker entry(s).`,
 		`CWD: ${toRelativePath(cwd, projectRootDir)}`,
 		`Entries: ${rootConfigPaths.map((configPath) => toRelativePath(projectRootDir, configPath)).join(", ")}`
 	].join("\n"));
@@ -1693,42 +2067,42 @@ async function runCheckerBuildInternal(options) {
 		},
 		onTargetStart: (target) => {
 			if (!options.flow) return;
-			targetTasks.set(target.configPath, options.flow.start(target.label ?? `checker build: ${toRelativePath(projectRootDir, target.configPath)}`, {
+			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(["build checks failed:", ...failedResults.map((result) => {
+	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 build entry(s).`);
+	else if (!options.flow?.interactive) TypecheckLogger.success(`Checked ${targets.length} checker typecheck entry(s).`);
 	return {
 		passed,
 		projectRootDir,
 		rootConfigPaths
 	};
 }
-async function runCheckerBuild(options) {
+async function runCheckerTypecheck(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");
+	const task = options.flow?.start("checker typecheck", { depth: options.flowDepth ?? 0 });
+	TypecheckLogger.info("checker typecheck started");
 	try {
-		const result = await runCheckerBuildInternal(options);
+		const result = await runCheckerTypecheckInternal(options);
 		if (result.passed) {
-			if (!options.flow?.interactive) TypecheckLogger.success("checker build finished", elapsed());
+			if (!options.flow?.interactive) TypecheckLogger.success("checker typecheck finished", elapsed());
 			task?.pass();
 		} else {
-			TypecheckLogger.error("checker build finished with failures", elapsed());
-			task?.fail("checker build finished with failures");
+			TypecheckLogger.error("checker typecheck finished with failures", elapsed());
+			task?.fail("checker typecheck finished with failures");
 		}
 		return result;
 	} catch (error) {
-		TypecheckLogger.error(`checker build failed: ${formatErrorMessage$1(error)}`, elapsed());
-		task?.fail("checker build failed", { error });
+		TypecheckLogger.error(`checker typecheck failed: ${formatErrorMessage$1(error)}`, elapsed());
+		task?.fail("checker typecheck failed", { error });
 		throw error;
 	}
 }
@@ -2023,4 +2397,4 @@ function createLiminaFlowReporter(options = {}) {
 }
 
 //#endregion
-export { collectImporters as A, createFormatHost as B, inferPackageProject as C, parseProject as D, isWorkspacePackageFile as E, collectGraphProjectRoute as F, isOrdinaryTypecheckConfigPath as G, getDtsCompanionConfigPath as H, collectGraphProjectRouteFromRoot as I, readJsonConfig as J, parseProjectFileNames as K, collectGraphProjectRoutes as L, findPackageForSpecifier as M, getPackageRootSpecifier as N, resolveInternalImport as O, collectCheckerEntryProjectRoutes as P, collectTypecheckTargetProjectPaths as R, getTypecheckConfigPath as S, isRelativeSpecifier as T, getRawReferencePaths as U, formatReferences as V, isDtsConfigPath as W, resolveReferencePath as X, resolveProjectConfigPath as Y, createFileOwnerLookup as _, runSourceCheck as a, findTargetProject as b, PackageLogger as c, clearCliScreen as d, formatErrorMessage$1 as f, collectImportsFromFile as g, normalizeGraphRules as h, runCheckerTypecheck as i, collectWorkspacePackages as j, shouldResolveThroughGraph as k, PathsLogger as l, getDeniedWorkspaceDepRule as m, createLiminaFlowReporter as n, CliLogger as o, getDeniedRefRule as p, parseProjectFileNamesForExtensions as q, runCheckerBuild as r, GraphLogger as s, LiminaFlowReporter as t, ProofLogger as u, findImporterForFile as v, isDtsProjectConfig as w, formatArtifactDependencyPolicy as x, findPackageForFile as y, createExtensionPattern as z };
+export { shouldResolveThroughGraph as A, collectGraphProjectRoutes as B, formatArtifactDependencyPolicy as C, isRelativeSpecifier$1 as D, isDtsProjectConfig as E, getPublishDependencySections as F, formatReferences as G, createExtensionPattern as H, isWorkspaceDependencySpecifier as I, isOrdinaryTypecheckConfigPath as J, getDtsCompanionConfigPath as K, collectCheckerEntryProjectRoutes as L, collectWorkspacePackages as M, findPackageForSpecifier as N, parseProject as O, getPackageRootSpecifier as P, resolveReferencePath as Q, collectGraphProjectRoute as R, findTargetProject as S, inferPackageProject as T, createExtraFileExtensions as U, collectSourceGraphProjectExtensions as V, createFormatHost as W, readJsonConfig as X, parseProjectFileNamesForExtensions as Y, resolveProjectConfigPath as Z, normalizeGraphRules as _, runSourceCheck as a, findImporterForFile as b, GraphLogger as c, ProofLogger as d, clearCliScreen as f, getDeniedRefRule as g, getDeniedDepRuleForSpecifier as h, runCheckerTypecheck as i, collectImporters as j, resolveInternalImport as k, PackageLogger as l, getDeniedDepRuleForPackage as m, createLiminaFlowReporter as n, runInit as o, formatErrorMessage$1 as p, getRawReferencePaths as q, runCheckerBuild as r, CliLogger as s, LiminaFlowReporter as t, PathsLogger as u, collectImportsFromFile as v, getTypecheckConfigPath as w, findPackageForFile as x, createFileOwnerLookup as y, collectGraphProjectRouteFromRoot as z };