limina 0.0.2 → 0.0.3

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

@@ -1,4 +1,4 @@
-import { c as getCheckerAdapter, h as toRelativePath, l as isPathInsideDirectory, m as toPosixPath, o as collectMissingCheckerPeerDependencies, r as getActiveCheckers, s as formatMissingCheckerPeerDependencies, u as normalizeAbsolutePath } from "./dep-jgc7X0zw.js";
+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";
@@ -11,7 +11,6 @@ import readline from "node:readline";
 import * as prompts from "@clack/prompts";
 import { mkdir, writeFile } from "node:fs/promises";
 import { parse } from "yaml";
-import { availableParallelism } from "node:os";
 
 //#region src/tsconfig.ts
 const dtsConfigFilePattern = /^tsconfig(?:\..+)?\.dts\.json$/u;
@@ -31,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) {
@@ -141,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));
 }
@@ -169,91 +161,6 @@ 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();
@@ -322,7 +229,7 @@ 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 (!existsSync(rootConfigPath)) {
 			problems.push([
@@ -339,6 +246,7 @@ function collectGraphProjectRoutes(config) {
 		problems.push(...routeCollection.problems);
 		routes.push({
 			checkerName: checker.name,
+			extensions: checker.extensions,
 			projectPaths: routeCollection.projectPaths,
 			rootConfigPath
 		});
@@ -368,6 +276,7 @@ function collectCheckerEntryProjectRoutes(config) {
 		problems.push(...routeCollection.problems);
 		routes.push({
 			checkerName: checker.name,
+			extensions: checker.extensions,
 			projectPaths: routeCollection.projectPaths,
 			rootConfigPath
 		});
@@ -384,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 = [];
@@ -586,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,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);
@@ -682,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,
@@ -699,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
 		});
 	};
@@ -727,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) => {
@@ -1437,7 +1423,7 @@ function inferProjectReferences(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)) {
+			for (const importRecord of collectImportsFromFile(fileName, options.config.rootDir)) {
 				const resolvedFilePath = resolveImportWithTypeScript({
 					cache: resolutionCache,
 					host,
@@ -1622,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$1(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]);
@@ -1734,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
@@ -1742,8 +1731,8 @@ function createSourceProjectEntries(config, projects) {
 	});
 }
 async function runSourceCheckInternal(config, options = {}) {
-	const graphRoute = collectGraphProjectRoute(config);
-	const projects = graphRoute.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);
@@ -1763,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"
@@ -1772,8 +1761,8 @@ 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);
+		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);
@@ -1797,7 +1786,7 @@ 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)) continue;
 			const packageName = getPackageRootSpecifier(importRecord.specifier);
@@ -1846,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) {
@@ -1875,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"
 		});
@@ -1962,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 = [];
@@ -2111,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"));
@@ -2141,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;
 	}
 }
@@ -2471,4 +2397,4 @@ function createLiminaFlowReporter(options = {}) {
 }
 
 //#endregion
-export { shouldResolveThroughGraph as A, createExtensionPattern as B, formatArtifactDependencyPolicy as C, isRelativeSpecifier$1 as D, isDtsProjectConfig as E, collectCheckerEntryProjectRoutes as F, isDtsConfigPath as G, formatReferences as H, collectGraphProjectRoute as I, parseProjectFileNamesForExtensions as J, isOrdinaryTypecheckConfigPath as K, collectGraphProjectRouteFromRoot as L, collectWorkspacePackages as M, findPackageForSpecifier as N, parseProject as O, getPackageRootSpecifier as P, collectGraphProjectRoutes as R, findTargetProject as S, inferPackageProject as T, getDtsCompanionConfigPath as U, createFormatHost as V, getRawReferencePaths as W, resolveProjectConfigPath as X, readJsonConfig as Y, resolveReferencePath 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, parseProjectFileNames 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, collectTypecheckTargetProjectPaths 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 };