limina 0.1.1 → 0.1.2

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { a as __toESM, i as __require, n as __commonJSMin, r as __exportAll, t as require_picocolors } from "./chunks/dep-BPK-6PAr.js";
-import { A as isRelativeSpecifier, C as isPathInsideDirectory, D as toRelativePath, E as toPosixPath, F as uniqueSortedStrings, I as uniqueTrimmedNonEmptySortedStrings, L as uniqueValues, M as isVirtualModuleSpecifier, N as posix, O as isBarePackageSpecifier, P as uniqueBy, S as resolveRelativeModuleCandidate, T as normalizeSlashes, _ as resolveModuleNameWithCheckers, a as formatUnknownValue, b as resolveExistingFilePath, c as clearCheckerProjectConfigCache, d as getBuildCheckerSupportedExtensions, f as getCheckerAdapter, g as resolveCheckerProjectExtensions, h as parseCheckerProjectConfigForContext, i as loadConfig, j as isUrlOrDataOrFileSpecifier, k as isPackageImportSpecifier, l as collectMissingCheckerPeerDependencies, m as normalizeExtensions, n as getActiveCheckers, o as isNonEmptyString, p as getCheckerExtensions, r as isAutoCheckerConfigMode, s as isPlainRecord, u as formatMissingCheckerPeerDependencies, v as candidatePathsForBasePath, w as normalizeAbsolutePath, x as resolvePathMappedModuleCandidate, y as resolveBaseUrlModuleCandidate } from "./chunks/dep-C5gcXDHp.js";
-import { a as hasRunningSnapshotWork, c as toWritableText, i as formatMessageWithElapsed, n as SPINNER_INTERVAL_MS, o as renderSnapshotLines, r as formatInteractiveLine, s as toTreeFlowStatus, t as SPINNER_FRAMES } from "./chunks/dep-CuMHuWBQ.js";
+import { A as isPackageImportSpecifier, C as resolveRelativeModuleCandidate, D as toPosixPath, E as normalizeSlashes, F as uniqueBy, I as uniqueSortedStrings, L as uniqueTrimmedNonEmptySortedStrings, M as isUrlOrDataOrFileSpecifier, N as isVirtualModuleSpecifier, O as toRelativePath, P as posix, R as uniqueValues, S as resolvePathMappedModuleCandidate, T as normalizeAbsolutePath, _ as resolveModuleNameWithCheckers, a as formatUnknownValue, b as resolveBaseUrlModuleCandidate, c as clearCheckerProjectConfigCache, d as getBuildCheckerSupportedExtensions, f as getCheckerAdapter, g as resolveCheckerProjectExtensions, h as parseCheckerProjectConfigForContext, i as loadConfig, j as isRelativeSpecifier, k as isBarePackageSpecifier, l as collectMissingCheckerPeerDependencies, m as normalizeExtensions, n as getActiveCheckers, o as isNonEmptyString, p as getCheckerExtensions, r as isAutoCheckerConfigMode, s as isPlainRecord, u as formatMissingCheckerPeerDependencies, v as resolveModuleNameWithCheckersDetailed, w as isPathInsideDirectory, x as resolveExistingFilePath, y as candidatePathsForBasePath } from "./chunks/dep-DJz9JBTi.js";
+import { a as SPINNER_FRAMES, c as formatMessageWithElapsed, d as toTreeFlowStatus, f as toWritableText, i as writeWithFlowArgs, l as hasRunningSnapshotWork, n as TerminalFrameTracker, o as SPINNER_INTERVAL_MS, r as patchWriteStream, s as formatInteractiveLine, t as DEFAULT_TERMINAL_COLUMNS, u as renderSnapshotLinesForTerminal } from "./chunks/dep-mnWOqiGN.js";
 import { builtinModules, createRequire } from "node:module";
 import { existsSync, lstatSync, readFileSync, readdirSync, statSync } from "node:fs";
 import ts from "typescript";
@@ -12,7 +12,7 @@ import { parseSync, rawTransferSupported } from "oxc-parser";
 import { ResolverFactory } from "oxc-resolver";
 import fs, { access, mkdir, mkdtemp, readFile, readdir, rm, rmdir, writeFile } from "node:fs/promises";
 import { glob } from "tinyglobby";
-import V, { stdin, stdout } from "node:process";
+import process$1, { stdin, stdout } from "node:process";
 import os, { availableParallelism, tmpdir } from "node:os";
 import tty, { ReadStream } from "node:tty";
 import { createHash } from "node:crypto";
@@ -361,7 +361,7 @@ function parsePnpmWorkspaceListJson(source) {
 		}];
 	});
 }
-function getManifestPackageName$1(manifest) {
+function getManifestPackageName$2(manifest) {
 	return typeof manifest.name === "string" && manifest.name.trim().length > 0 ? manifest.name.trim() : null;
 }
 function isNamedWorkspacePackage(workspacePackage) {
@@ -370,7 +370,7 @@ function isNamedWorkspacePackage(workspacePackage) {
 function readWorkspacePackage(options) {
 	const packageJsonPath = normalizeAbsolutePath(options.packageJsonPath);
 	const manifest = readJsonFile(packageJsonPath);
-	const name = getManifestPackageName$1(manifest);
+	const name = getManifestPackageName$2(manifest);
 	return {
 		directory: normalizeAbsolutePath(posix.dirname(packageJsonPath)),
 		manifest,
@@ -1217,6 +1217,18 @@ function createImportAnalysisContext(options = {}) {
 		caches.importsCache.set(cacheKey, imports);
 		return imports;
 	};
+	const resolveTypeScriptImport = (specifier, containingFile, compilerOptions, contextOrExtensions) => resolveModuleNameWithCheckersDetailed({
+		compilerOptions,
+		containingFile: normalizeAbsolutePath(containingFile),
+		context: normalizeContextInput(contextOrExtensions),
+		specifier
+	});
+	const resolveOxcImport = (specifier, containingFile, compilerOptions, contextOrExtensions) => resolveModuleNameWithOxcCaches(caches, {
+		compilerOptions,
+		containingFile: normalizeAbsolutePath(containingFile),
+		context: normalizeContextInput(contextOrExtensions),
+		specifier
+	});
 	const resolveInternalImport = (specifier, containingFile, options, contextOrExtensions) => {
 		const normalizedContainingFile = normalizeAbsolutePath(containingFile);
 		const context = normalizeContextInput(contextOrExtensions);
@@ -1248,12 +1260,7 @@ function createImportAnalysisContext(options = {}) {
 		const cached = caches.resolutionCache.get(cacheKey);
 		if (cached !== void 0) return cached;
 		const preferTypeScriptResolver = hasTypeScriptOnlyResolutionOptions(options);
-		const resolved = (preferTypeScriptResolver ? resolveModuleNameWithCheckers({
-			compilerOptions: options,
-			containingFile: normalizedContainingFile,
-			context,
-			specifier
-		}) : null) ?? resolveRelativeModuleCandidate({
+		const resolved = (preferTypeScriptResolver ? resolveTypeScriptImport(specifier, normalizedContainingFile, options, context)?.resolvedFileName : null) ?? resolveRelativeModuleCandidate({
 			containingFile: normalizedContainingFile,
 			extensions,
 			specifier
@@ -1265,12 +1272,7 @@ function createImportAnalysisContext(options = {}) {
 			compilerOptions: options,
 			extensions,
 			specifier
-		}) ?? (preferTypeScriptResolver ? null : resolveModuleNameWithOxcCaches(caches, {
-			compilerOptions: options,
-			containingFile: normalizedContainingFile,
-			context,
-			specifier
-		}) ?? resolveModuleNameWithCheckers({
+		}) ?? (preferTypeScriptResolver ? null : resolveOxcImport(specifier, normalizedContainingFile, options, context) ?? resolveModuleNameWithCheckers({
 			compilerOptions: options,
 			containingFile: normalizedContainingFile,
 			context,
@@ -1281,7 +1283,9 @@ function createImportAnalysisContext(options = {}) {
 	};
 	return {
 		collectImportsFromFile,
-		resolveInternalImport
+		resolveInternalImport,
+		resolveOxcImport,
+		resolveTypeScriptImport
 	};
 }
 function collectImportsFromFile(filePath, rootDir, context) {
@@ -1408,9 +1412,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 findImporterForFile(filePath, importers) {
-	return importers.find((importer) => isPathInsideDirectory(filePath, importer.directory)) ?? null;
-}
 function shouldResolveThroughGraph(importer, targetPackage) {
 	if (!importer || !targetPackage?.name) return false;
 	return importer.name === targetPackage.name || importer.declaredWorkspaceDependencies.has(targetPackage.name);
@@ -1459,6 +1460,7 @@ const LIMINA_CHECK_ISSUE_CODES = {
 	graphConfigInvalid: "LIMINA_GRAPH_CONFIG_INVALID",
 	graphImportTargetUnmapped: "LIMINA_GRAPH_IMPORT_TARGET_UNMAPPED",
 	graphPrepareFailed: "LIMINA_GRAPH_PREPARE_FAILED",
+	graphReferenceCycle: "LIMINA_GRAPH_REFERENCE_CYCLE",
 	graphReferenceExtra: "LIMINA_GRAPH_REFERENCE_EXTRA",
 	graphReferenceMissing: "LIMINA_GRAPH_REFERENCE_MISSING",
 	graphTargetUnreachable: "LIMINA_GRAPH_TARGET_UNREACHABLE",
@@ -1553,6 +1555,11 @@ const LIMINA_CHECK_ISSUE_RULE_METADATA = {
 		description: "Generated graph preparation failed.",
 		task: "graph:prepare"
 	},
+	[LIMINA_CHECK_ISSUE_CODES.graphReferenceCycle]: {
+		code: LIMINA_CHECK_ISSUE_CODES.graphReferenceCycle,
+		description: "Generated TypeScript project references contain a cycle.",
+		task: "graph:check"
+	},
 	[LIMINA_CHECK_ISSUE_CODES.graphReferenceExtra]: {
 		code: LIMINA_CHECK_ISSUE_CODES.graphReferenceExtra,
 		description: "A TypeScript project reference exists without a matching source edge.",
@@ -2002,13 +2009,13 @@ const ansiStyles$1 = assembleStyles$1();
 
 //#endregion
 //#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : V.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
 	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
 	const position = argv.indexOf(prefix + flag);
 	const terminatorPosition = argv.indexOf("--");
 	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-const { env } = V;
+const { env } = process$1;
 let flagForceColor;
 if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
 else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
@@ -2041,7 +2048,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
 	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
 	const min = forceColor || 0;
 	if (env.TERM === "dumb") return min;
-	if (V.platform === "win32") {
+	if (process$1.platform === "win32") {
 		const osRelease = os.release().split(".");
 		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
 		return 1;
@@ -2821,7 +2828,7 @@ const NEWLINE = "\n";
 const PAD = " ";
 const NONE = "none";
 const terminalColumns = () => {
-	const { env, stdout, stderr } = V;
+	const { env, stdout, stderr } = process$1;
 	if (stdout?.columns) return stdout.columns;
 	if (stderr?.columns) return stderr.columns;
 	if (env.COLUMNS) return Number.parseInt(env.COLUMNS, 10);
@@ -2964,8 +2971,8 @@ const boxContent = (content, contentWidth, options) => {
 	return result;
 };
 const sanitizeOptions = (options) => {
-	if (options.fullscreen && V?.stdout) {
-		let newDimensions = [V.stdout.columns, V.stdout.rows];
+	if (options.fullscreen && process$1?.stdout) {
+		let newDimensions = [process$1.stdout.columns, process$1.stdout.rows];
 		if (typeof options.fullscreen === "function") newDimensions = options.fullscreen(...newDimensions);
 		options.width ||= newDimensions[0];
 		options.height ||= newDimensions[1];
@@ -3699,6 +3706,9 @@ function createSourceConfigScope(sourceConfigPath) {
 	if (fileName === "tsconfig.json") return "tsconfig";
 	return fileName.replace(/^tsconfig\./u, "").replace(/\.json$/u, "");
 }
+function createOutputFileName(sourceFileName) {
+	return sourceFileName === "tsconfig.json" ? "tsconfig.output.json" : sourceFileName.replace(/\.json$/u, ".output.json");
+}
 function getGeneratedDtsConfigPath(options) {
 	const relativeSourcePath = toRelativePath(options.rootDir, options.sourceConfigPath);
 	const relativeDir = posix.dirname(relativeSourcePath);
@@ -3710,6 +3720,17 @@ function getGeneratedSolutionBuildConfigPath(options) {
 	const relativeDir = posix.dirname(relativeSourcePath);
 	return normalizeAbsolutePath(posix.join(options.rootDir, generatedTsconfigDir, "checkers", options.checkerName, "solutions", relativeDir === "." ? "" : relativeDir, "tsconfig.build.json"));
 }
+function getGeneratedOutputProjectConfigPath(options) {
+	const relativeSourcePath = toRelativePath(options.rootDir, options.sourceConfigPath);
+	const relativeDir = posix.dirname(relativeSourcePath);
+	const outputFileName = createOutputFileName(posix.basename(relativeSourcePath));
+	return normalizeAbsolutePath(posix.join(options.rootDir, generatedTsconfigDir, "checkers", options.checkerName, "outputs", "projects", relativeDir === "." ? "" : relativeDir, outputFileName));
+}
+function getGeneratedOutputSolutionConfigPath(options) {
+	const relativeSourcePath = toRelativePath(options.rootDir, options.sourceConfigPath);
+	const relativeDir = posix.dirname(relativeSourcePath);
+	return normalizeAbsolutePath(posix.join(options.rootDir, generatedTsconfigDir, "checkers", options.checkerName, "outputs", "solutions", relativeDir === "." ? "" : relativeDir, "tsconfig.output.json"));
+}
 function getGeneratedCheckerEntryPath(options) {
 	return normalizeAbsolutePath(posix.join(options.rootDir, generatedTsconfigDir, "checkers", options.checkerName, "tsconfig.build.json"));
 }
@@ -4622,6 +4643,37 @@ function formatCheckIssueSnapshotInventory(options) {
 	return issueSummary;
 }
 
+//#endregion
+//#region src/core/import-graph/declaration-provider.ts
+const declarationFileFamilyPattern = /\.d\.(?:cts|mts|ts)$/u;
+function isDeclarationFileFamily(filePath) {
+	return declarationFileFamilyPattern.test(filePath);
+}
+function resolveDeclarationProvider(options) {
+	const typeScriptResolution = options.importAnalysis.resolveTypeScriptImport(options.importRecord.specifier, options.containingFile, options.compilerOptions, options.project);
+	const oxcResolvedFilePath = options.importAnalysis.resolveOxcImport(options.importRecord.specifier, options.containingFile, options.compilerOptions, options.project);
+	if (!typeScriptResolution) return oxcResolvedFilePath ? {
+		kind: "oxc-only",
+		oxcResolvedFilePath,
+		typeScriptResolution: null
+	} : {
+		kind: "unresolved",
+		oxcResolvedFilePath: null,
+		typeScriptResolution: null
+	};
+	if (isDeclarationFileFamily(typeScriptResolution.resolvedFileName)) return {
+		kind: "declaration",
+		oxcResolvedFilePath,
+		typeScriptResolution
+	};
+	return {
+		kind: "source",
+		ownerProjectPaths: options.fileOwnerLookup.get(typeScriptResolution.resolvedFileName) ?? [],
+		oxcResolvedFilePath,
+		typeScriptResolution
+	};
+}
+
 //#endregion
 //#region src/core/packages/build-scripts.ts
 const supportedBuildCheckers = new Set([
@@ -4629,10 +4681,7 @@ const supportedBuildCheckers = new Set([
 	"vue-tsc",
 	"tsgo"
 ]);
-function hasLiminaCheckerBuildIntent(command) {
-	return /\blimina\s+checker\s+build\b/u.test(command);
-}
-function hasLegacyLiminaBuildIntent(command) {
+function hasLiminaBuildIntent(command) {
 	return /\blimina\s+build\b/u.test(command);
 }
 function hasShellControlOperator(command) {
@@ -4666,10 +4715,10 @@ function tokenizeStaticCommand(command) {
 	if (current.length > 0) tokens.push(current);
 	return tokens;
 }
-function getLiminaCheckerBuildArgumentOffset(tokens) {
-	if (tokens[0] === "limina" && tokens[1] === "checker" && tokens[2] === "build") return 3;
-	if (tokens[0] === "pnpm" && tokens[1] === "limina" && tokens[2] === "checker" && tokens[3] === "build") return 4;
-	if (tokens[0] === "pnpm" && tokens[1] === "exec" && tokens[2] === "limina" && tokens[3] === "checker" && tokens[4] === "build") return 5;
+function getLiminaBuildArgumentOffset(tokens) {
+	if (tokens[0] === "limina" && tokens[1] === "build") return 2;
+	if (tokens[0] === "pnpm" && tokens[1] === "limina" && tokens[2] === "build") return 3;
+	if (tokens[0] === "pnpm" && tokens[1] === "exec" && tokens[2] === "limina" && tokens[3] === "build") return 4;
 	return null;
 }
 function parseChecker(value) {
@@ -4679,12 +4728,12 @@ function createDiagnostic(options) {
 	return options;
 }
 function parsePackageBuildScript(options) {
-	if (!hasLiminaCheckerBuildIntent(options.command) && !hasLegacyLiminaBuildIntent(options.command)) return null;
+	if (!hasLiminaBuildIntent(options.command)) return null;
 	if (hasShellControlOperator(options.command) || /[$`]/u.test(options.command)) return createDiagnostic({
 		command: options.command,
 		packageJsonPath: options.packageJsonPath,
 		packageName: options.packageName,
-		reason: "Limina only derives Knip source configs from static limina checker build scripts without shell control operators or dynamic expansion.",
+		reason: "Limina only derives Knip source configs from static limina build scripts without shell control operators or dynamic expansion.",
 		scriptName: options.scriptName
 	});
 	const tokens = tokenizeStaticCommand(options.command);
@@ -4695,21 +4744,22 @@ function parsePackageBuildScript(options) {
 		reason: "Limina could not statically tokenize this package script.",
 		scriptName: options.scriptName
 	});
-	const argumentOffset = getLiminaCheckerBuildArgumentOffset(tokens);
+	const argumentOffset = getLiminaBuildArgumentOffset(tokens);
 	if (argumentOffset === null) return createDiagnostic({
 		command: options.command,
 		packageJsonPath: options.packageJsonPath,
 		packageName: options.packageName,
-		reason: "Limina only recognizes limina checker build, pnpm limina checker build, and pnpm exec limina checker build.",
+		reason: "Limina only recognizes direct limina build, pnpm limina build, and pnpm exec limina build package scripts.",
 		scriptName: options.scriptName
 	});
 	let checker;
 	let configPath;
-	let sawTargetOption = false;
+	let raw = false;
 	for (let index = argumentOffset; index < tokens.length; index += 1) {
 		const token = tokens[index];
-		if (token === "-w" || token === "--watch") {
-			sawTargetOption = true;
+		if (token === "-w" || token === "--watch") continue;
+		if (token === "--raw") {
+			raw = true;
 			continue;
 		}
 		if (token === "--checker" || token.startsWith("--checker=")) return createDiagnostic({
@@ -4720,7 +4770,6 @@ function parsePackageBuildScript(options) {
 			scriptName: options.scriptName
 		});
 		if (token === "--preset") {
-			sawTargetOption = true;
 			const parsedChecker = parseChecker(tokens[index + 1]);
 			if (!parsedChecker) return createDiagnostic({
 				command: options.command,
@@ -4734,7 +4783,6 @@ function parsePackageBuildScript(options) {
 			continue;
 		}
 		if (token.startsWith("--preset=")) {
-			sawTargetOption = true;
 			const parsedChecker = parseChecker(token.slice(9));
 			if (!parsedChecker) return createDiagnostic({
 				command: options.command,
@@ -4750,32 +4798,37 @@ function parsePackageBuildScript(options) {
 			command: options.command,
 			packageJsonPath: options.packageJsonPath,
 			packageName: options.packageName,
-			reason: "Limina checker build script analysis only supports --preset, -w/--watch, plus one config argument.",
+			reason: "Limina build script analysis only supports --raw, --preset, -w/--watch, plus one literal config argument.",
 			scriptName: options.scriptName
 		});
 		if (configPath) return createDiagnostic({
 			command: options.command,
 			packageJsonPath: options.packageJsonPath,
 			packageName: options.packageName,
-			reason: "Limina checker build script analysis found multiple config arguments.",
+			reason: "Limina build script analysis found multiple config arguments.",
 			scriptName: options.scriptName
 		});
 		configPath = token;
 	}
-	if (!configPath) {
-		if (!sawTargetOption) return null;
-		return createDiagnostic({
-			command: options.command,
-			packageJsonPath: options.packageJsonPath,
-			packageName: options.packageName,
-			reason: "Limina checker build script analysis requires a config argument.",
-			scriptName: options.scriptName
-		});
-	}
+	if (!configPath) return createDiagnostic({
+		command: options.command,
+		packageJsonPath: options.packageJsonPath,
+		packageName: options.packageName,
+		reason: "Limina build script analysis requires a config argument.",
+		scriptName: options.scriptName
+	});
+	if (raw && !checker) return createDiagnostic({
+		command: options.command,
+		packageJsonPath: options.packageJsonPath,
+		packageName: options.packageName,
+		reason: "limina build --raw package scripts require --preset.",
+		scriptName: options.scriptName
+	});
 	return {
 		...checker ? { checker } : {},
 		command: options.command,
 		configPath: normalizeAbsolutePath(posix.resolve(options.packageDirectory, configPath)),
+		raw,
 		name: options.scriptName,
 		packageJsonPath: options.packageJsonPath,
 		packageName: options.packageName
@@ -4816,9 +4869,14 @@ function getGeneratedKnipConfigPath(options) {
 	const relativeOutputPath = relativePackageDirectory === "." ? posix.join(".limina/knip", "tsconfig.knip.json") : posix.join(".limina/knip", relativePackageDirectory, "tsconfig.knip.json");
 	return normalizeAbsolutePath(posix.join(options.rootDir, relativeOutputPath));
 }
-function isManagedBuildConfig(options) {
-	for (const sourceToBuild of options.sourceToBuildByChecker.values()) if (sourceToBuild.has(options.configPath)) return true;
-	return false;
+function resolveManagedBuildConfigPaths(options) {
+	const configPaths = /* @__PURE__ */ new Set();
+	for (const checker of options.checkers) {
+		if (options.script.checker && checker.preset !== options.script.checker) continue;
+		const outputModule = options.configToOutputBuildByChecker.get(checker.name)?.get(options.script.configPath);
+		if (outputModule) configPaths.add(outputModule.path);
+	}
+	return [...configPaths].sort((left, right) => left.localeCompare(right));
 }
 function toPackageScriptDiagnostic(diagnostic) {
 	return {
@@ -4928,10 +4986,12 @@ function prepareGeneratedKnipPackageConfigs(options) {
 		const references = /* @__PURE__ */ new Set();
 		const scripts = [];
 		for (const script of packageScripts) {
-			const mode = isManagedBuildConfig({
-				configPath: script.configPath,
-				sourceToBuildByChecker: options.sourceToBuildByChecker
-			}) ? "managed" : "raw";
+			const managedConfigPaths = script.raw ? [] : resolveManagedBuildConfigPaths({
+				checkers: options.checkers,
+				configToOutputBuildByChecker: options.configToOutputBuildByChecker,
+				script
+			});
+			const mode = script.raw ? "raw" : "managed";
 			const diagnostic = validatePackageBuildScript({
 				config: options.config,
 				mode,
@@ -4942,7 +5002,17 @@ function prepareGeneratedKnipPackageConfigs(options) {
 				diagnostics.push(diagnostic);
 				continue;
 			}
-			references.add(script.configPath);
+			if (!script.raw && managedConfigPaths.length === 0) {
+				diagnostics.push({
+					command: script.command,
+					packageJsonPath: script.packageJsonPath,
+					packageName: script.packageName,
+					reason: "managed limina build package scripts must point to a Limina-managed config with liminaOptions.outputs.",
+					scriptName: script.name
+				});
+				continue;
+			}
+			for (const referencePath of script.raw ? [script.configPath] : managedConfigPaths) references.add(referencePath);
 			scripts.push({
 				...script.checker ? { checker: script.checker } : {},
 				command: script.command,
@@ -5000,6 +5070,154 @@ function readGraphRules(config, sourceConfigPath) {
 	const graphRules = liminaOptions.graphRules;
 	return Array.isArray(graphRules) ? uniqueValues(graphRules.filter((label) => typeof label === "string" && label.trim().length > 0)).map((label) => label.trim()) : [];
 }
+function addOutputOptionsProblem(options) {
+	options.problems.push([
+		"Invalid Limina output options:",
+		`  config: ${toRelativePath(options.config.rootDir, options.sourceConfigPath)}`,
+		`  field: ${options.field}`,
+		...Object.hasOwn(options, "value") ? [`  value: ${formatUnknownValue(options.value)}`] : [],
+		`  reason: ${options.reason}`
+	].join("\n"));
+}
+function normalizeExtendsConfigPath(configPath, extendsValue) {
+	const trimmedValue = extendsValue.trim();
+	if (trimmedValue.length === 0) return null;
+	if (posix.isAbsolute(trimmedValue) || trimmedValue.startsWith("./") || trimmedValue.startsWith("../")) {
+		const resolvedPath = posix.resolve(posix.dirname(configPath), trimmedValue);
+		return normalizeAbsolutePath(posix.extname(resolvedPath) ? resolvedPath : `${resolvedPath}.json`);
+	}
+	try {
+		return normalizeAbsolutePath(createRequire(configPath).resolve(trimmedValue));
+	} catch {
+		return null;
+	}
+}
+function readExplicitSourceCompilerTarget(options) {
+	const seenConfigPaths = options.seenConfigPaths ?? /* @__PURE__ */ new Set();
+	const configPath = normalizeAbsolutePath(options.configPath);
+	if (seenConfigPaths.has(configPath) || !existsSync(configPath)) return null;
+	seenConfigPaths.add(configPath);
+	const configObject = readJsonConfig(options.config, configPath);
+	const extendsValue = configObject.extends;
+	const extendsValues = typeof extendsValue === "string" ? [extendsValue] : Array.isArray(extendsValue) ? extendsValue.filter((entry) => typeof entry === "string") : [];
+	let target = null;
+	for (const entry of extendsValues) {
+		const extendedConfigPath = normalizeExtendsConfigPath(configPath, entry);
+		if (!extendedConfigPath) continue;
+		target = readExplicitSourceCompilerTarget({
+			config: options.config,
+			configPath: extendedConfigPath,
+			seenConfigPaths
+		}) ?? target;
+	}
+	const compilerOptions = configObject.compilerOptions;
+	if (isPlainRecord(compilerOptions)) {
+		const targetValue = compilerOptions.target;
+		if (isNonEmptyString(targetValue)) target = targetValue.trim();
+	}
+	return target;
+}
+function readOutputOptions(config, sourceConfigPath) {
+	const liminaOptions = readJsonConfig(config, sourceConfigPath).liminaOptions;
+	const problems = [];
+	if (liminaOptions === void 0) return {
+		outputs: null,
+		problems
+	};
+	if (!isPlainRecord(liminaOptions)) {
+		addOutputOptionsProblem({
+			config,
+			field: "liminaOptions",
+			problems,
+			reason: "liminaOptions must be an object before outputs can be read.",
+			sourceConfigPath,
+			value: liminaOptions
+		});
+		return {
+			outputs: null,
+			problems
+		};
+	}
+	const outputs = liminaOptions.outputs;
+	if (outputs === void 0) return {
+		outputs: null,
+		problems
+	};
+	if (!isPlainRecord(outputs)) {
+		addOutputOptionsProblem({
+			config,
+			field: "liminaOptions.outputs",
+			problems,
+			reason: "outputs must be an object.",
+			sourceConfigPath,
+			value: outputs
+		});
+		return {
+			outputs: null,
+			problems
+		};
+	}
+	const allowedFields = new Set([
+		"outDir",
+		"rootDir",
+		"target",
+		"tsBuildInfoFile"
+	]);
+	for (const fieldName of Object.keys(outputs)) if (!allowedFields.has(fieldName)) addOutputOptionsProblem({
+		config,
+		field: `liminaOptions.outputs.${fieldName}`,
+		problems,
+		reason: "outputs only supports target, rootDir, outDir, and tsBuildInfoFile.",
+		sourceConfigPath,
+		value: outputs[fieldName]
+	});
+	const outputValues = {};
+	for (const fieldName of allowedFields) {
+		const fieldValue = outputs[fieldName];
+		if (fieldValue === void 0) continue;
+		if (!isNonEmptyString(fieldValue)) {
+			addOutputOptionsProblem({
+				config,
+				field: `liminaOptions.outputs.${fieldName}`,
+				problems,
+				reason: "output option fields must be non-empty strings.",
+				sourceConfigPath,
+				value: fieldValue
+			});
+			continue;
+		}
+		if ((fieldName === "rootDir" || fieldName === "outDir" || fieldName === "tsBuildInfoFile") && posix.isAbsolute(fieldValue)) {
+			addOutputOptionsProblem({
+				config,
+				field: `liminaOptions.outputs.${fieldName}`,
+				problems,
+				reason: "output path fields must be relative to the tsconfig that declares them.",
+				sourceConfigPath,
+				value: fieldValue
+			});
+			continue;
+		}
+		outputValues[fieldName] = fieldValue.trim();
+	}
+	if (problems.length > 0) return {
+		outputs: null,
+		problems
+	};
+	const sourceConfigDirectory = posix.dirname(sourceConfigPath);
+	const scope = createSourceConfigScope(sourceConfigPath);
+	return {
+		outputs: {
+			target: outputValues.target ?? readExplicitSourceCompilerTarget({
+				config,
+				configPath: sourceConfigPath
+			}) ?? "ESNext",
+			rootDir: normalizeAbsolutePath(posix.resolve(sourceConfigDirectory, outputValues.rootDir ?? ".")),
+			outDir: normalizeAbsolutePath(posix.resolve(sourceConfigDirectory, outputValues.outDir ?? "./dist")),
+			tsBuildInfoFile: normalizeAbsolutePath(posix.resolve(sourceConfigDirectory, outputValues.tsBuildInfoFile ?? `./dist/.${scope}_tsbuildinfo`))
+		},
+		problems
+	};
+}
 function addImplicitRefProblem(options) {
 	options.problems.push([
 		"Invalid Limina implicit reference:",
@@ -5372,12 +5590,26 @@ function createSolutionBuildModule(options) {
 		path: getGeneratedSolutionBuildConfigPath(options)
 	};
 }
+function createOutputProjectBuildModule(options) {
+	return {
+		kind: "project",
+		path: getGeneratedOutputProjectConfigPath(options)
+	};
+}
+function createOutputSolutionBuildModule(options) {
+	return {
+		kind: "solution",
+		path: getGeneratedOutputSolutionConfigPath(options)
+	};
+}
 function collectCheckerSourceConfigModules(options) {
 	if (options.excludedConfigPaths.has(options.sourceConfigPath)) return;
 	if (options.seenConfigs.has(options.sourceConfigPath)) return;
 	options.seenConfigs.add(options.sourceConfigPath);
 	const configObject = readJsonConfig(options.config, options.sourceConfigPath);
 	const hasReferences = Object.hasOwn(configObject, "references");
+	const outputOptions = readOutputOptions(options.config, options.sourceConfigPath);
+	options.problems.push(...outputOptions.problems);
 	if (hasReferences && !isDefaultTsconfigPath(options.sourceConfigPath)) {
 		addSourceReferenceConfigProblems({
 			config: options.config,
@@ -5387,6 +5619,13 @@ function collectCheckerSourceConfigModules(options) {
 		return;
 	}
 	if (hasReferences && isDefaultTsconfigPath(options.sourceConfigPath)) {
+		if (outputOptions.outputs) options.problems.push([
+			"Invalid Limina output options:",
+			`  config: ${toRelativePath(options.config.rootDir, options.sourceConfigPath)}`,
+			"  field: liminaOptions.outputs",
+			"  reason: liminaOptions.outputs is only allowed on ordinary source leaf configs, not solution-style configs.",
+			"  fix: move liminaOptions.outputs to one or more referenced source leaf tsconfigs."
+		].join("\n"));
 		options.collection.solutionConfigPaths.add(options.sourceConfigPath);
 		options.collection.buildModulesBySourcePath.set(options.sourceConfigPath, createSolutionBuildModule({
 			checkerName: options.checkerName,
@@ -5702,6 +5941,7 @@ function createSourceProject(options) {
 		projectRootDir: options.config.rootDir
 	});
 	const ownedFileNames = parsed.fileNames.map(normalizeAbsolutePath).sort();
+	const outputOptions = readOutputOptions(options.config, options.sourceConfigPath);
 	return {
 		checkerName: options.checkerName,
 		configPath: options.sourceConfigPath,
@@ -5714,6 +5954,13 @@ function createSourceProject(options) {
 		fileNames: uniqueSortedStrings([...ownedFileNames, ...readRelativeTypeFiles$1(options.config, options.sourceConfigPath)]),
 		graphRules: readGraphRules(options.config, options.sourceConfigPath),
 		ownedFileNames,
+		outputConfigPath: getGeneratedOutputProjectConfigPath({
+			checkerName: options.checkerName,
+			rootDir: options.config.rootDir,
+			sourceConfigPath: options.sourceConfigPath
+		}),
+		outputOptions: outputOptions.outputs,
+		outputReferences: /* @__PURE__ */ new Set(),
 		options: parsed.options,
 		references: /* @__PURE__ */ new Set()
 	};
@@ -5731,6 +5978,104 @@ function createSolutionProject(options) {
 		references: new Set(referenceSourceConfigPaths.map((sourceConfigPath) => options.collection.buildModulesBySourcePath.get(sourceConfigPath)?.path).filter((buildPath) => Boolean(buildPath)))
 	};
 }
+function createSourceProjectsByDtsPath(projects) {
+	return new Map(projects.map((project) => [project.dtsConfigPath, project]));
+}
+function createOutputSolutionProject(options) {
+	return {
+		buildConfigPath: getGeneratedOutputSolutionConfigPath({
+			checkerName: options.checkerName,
+			rootDir: options.config.rootDir,
+			sourceConfigPath: options.sourceConfigPath
+		}),
+		checkerName: options.checkerName,
+		configPath: options.sourceConfigPath,
+		references: new Set(options.references)
+	};
+}
+function collectFlattenedOutputSolutionReferences(options) {
+	const seenConfigPaths = options.seenConfigPaths ?? /* @__PURE__ */ new Set();
+	if (seenConfigPaths.has(options.sourceConfigPath)) return [];
+	seenConfigPaths.add(options.sourceConfigPath);
+	const references = options.collection.solutionReferencesBySourcePath.get(options.sourceConfigPath) ?? [];
+	const outputReferences = /* @__PURE__ */ new Set();
+	for (const referencePath of references) {
+		const outputProjectModule = options.outputProjectModuleBySourcePath.get(referencePath);
+		if (outputProjectModule) {
+			outputReferences.add(outputProjectModule.path);
+			continue;
+		}
+		for (const nestedReferencePath of collectFlattenedOutputSolutionReferences({
+			collection: options.collection,
+			outputProjectModuleBySourcePath: options.outputProjectModuleBySourcePath,
+			sourceConfigPath: referencePath,
+			seenConfigPaths
+		})) outputReferences.add(nestedReferencePath);
+	}
+	return [...outputReferences].sort((left, right) => left.localeCompare(right));
+}
+function formatMissingOutputDependencyProblem(options) {
+	return [
+		"Missing Limina output options for referenced source project:",
+		`  config: ${toRelativePath(options.config.rootDir, options.project.configPath)}`,
+		`  referenced config: ${toRelativePath(options.config.rootDir, options.targetProject.configPath)}`,
+		"  reason: this output-enabled source project has a Limina-generated project reference to another managed source project that does not declare liminaOptions.outputs.",
+		"  fix: add liminaOptions.outputs to the referenced source config, or move the dependency behind a declaration or artifact boundary."
+	].join("\n");
+}
+function createCheckerOutputGraph(options) {
+	if (getCheckerAdapter(options.checker.preset)?.execution !== "build") return {
+		configToOutputBuild: /* @__PURE__ */ new Map(),
+		outputProjects: [],
+		outputSolutions: []
+	};
+	const outputProjects = options.projects.filter((project) => Boolean(project.outputOptions));
+	const outputProjectModuleBySourcePath = new Map(outputProjects.map((project) => [project.configPath, createOutputProjectBuildModule({
+		checkerName: options.checker.name,
+		rootDir: options.config.rootDir,
+		sourceConfigPath: project.configPath
+	})]));
+	const configToOutputBuild = new Map(outputProjectModuleBySourcePath);
+	for (const project of outputProjects) for (const referencePath of project.references) {
+		const targetProject = options.allProjectsByDtsPath.get(referencePath);
+		if (!targetProject) continue;
+		if (!targetProject.outputOptions) {
+			options.problems.push(formatMissingOutputDependencyProblem({
+				config: options.config,
+				project,
+				targetProject
+			}));
+			continue;
+		}
+		project.outputReferences.add(targetProject.outputConfigPath);
+	}
+	const outputSolutions = [];
+	for (const sourceConfigPath of [...options.collection.solutionConfigPaths].sort((left, right) => left.localeCompare(right))) {
+		const references = collectFlattenedOutputSolutionReferences({
+			collection: options.collection,
+			outputProjectModuleBySourcePath,
+			sourceConfigPath
+		});
+		if (references.length === 0) continue;
+		const outputSolution = createOutputSolutionProject({
+			checkerName: options.checker.name,
+			config: options.config,
+			references,
+			sourceConfigPath
+		});
+		outputSolutions.push(outputSolution);
+		configToOutputBuild.set(sourceConfigPath, createOutputSolutionBuildModule({
+			checkerName: options.checker.name,
+			rootDir: options.config.rootDir,
+			sourceConfigPath
+		}));
+	}
+	return {
+		configToOutputBuild,
+		outputProjects,
+		outputSolutions
+	};
+}
 function createDtsProjectsBySourcePath(projects) {
 	const projectsBySourcePath = /* @__PURE__ */ new Map();
 	for (const project of projects) projectsBySourcePath.set(project.configPath, [...projectsBySourcePath.get(project.configPath) ?? [], project]);
@@ -5849,6 +6194,17 @@ function formatMissingCrossCheckerProviderProblem(options) {
 		"  fix: cover the target source config with a build-capable checker preset such as tsc, tsgo, or vue-tsc."
 	].join("\n");
 }
+function formatOxcOnlyDeclarationProviderProblem(options) {
+	return [
+		"Oxc can resolve this specifier, but TypeScript cannot:",
+		`  importing config: ${toRelativePath(options.config.rootDir, options.project.configPath)}`,
+		`  file: ${formatImportRecordLocation(options.config.rootDir, options.importRecord)}`,
+		`  imported specifier: ${options.importRecord.specifier}`,
+		`  Oxc resolved file: ${toRelativePath(options.config.rootDir, options.oxcResolvedFilePath)}`,
+		"  reason: generated declaration references follow the checker-aware TypeScript declaration provider, not the Oxc runtime-like resolver.",
+		"  fix: check moduleResolution, exports.types/types conditions, paths, customConditions, and package boundaries."
+	].join("\n");
+}
 function inferProjectReferences(config, projects, ownerProjects = projects, options = {}) {
 	const problems = [];
 	const providerEdgesByKey = /* @__PURE__ */ new Map();
@@ -5900,13 +6256,31 @@ function inferProjectReferences(config, projects, ownerProjects = projects, opti
 		}
 	}
 	for (const project of projects) for (const fileName of project.ownedFileNames) for (const importRecord of collectImportsFromFile(fileName, config.rootDir, importAnalysis)) {
-		const resolvedFilePath = resolveInternalImport(importRecord.specifier, fileName, project.options, {
-			...project.context,
-			configPath: project.configPath,
-			resolverConfigPath: project.configPath
-		}, importAnalysis);
-		if (!resolvedFilePath) continue;
-		const owners = ownerLookup.get(resolvedFilePath);
+		const declarationProvider = resolveDeclarationProvider({
+			compilerOptions: project.options,
+			containingFile: fileName,
+			fileOwnerLookup: ownerLookup,
+			importAnalysis,
+			importRecord,
+			project: {
+				...project.context,
+				configPath: project.configPath,
+				resolverConfigPath: project.configPath
+			}
+		});
+		if (declarationProvider.kind === "declaration") continue;
+		if (declarationProvider.kind === "oxc-only") {
+			problems.push(formatOxcOnlyDeclarationProviderProblem({
+				config,
+				importRecord,
+				oxcResolvedFilePath: declarationProvider.oxcResolvedFilePath,
+				project
+			}));
+			continue;
+		}
+		if (declarationProvider.kind === "unresolved") continue;
+		const resolvedFilePath = declarationProvider.typeScriptResolution.resolvedFileName;
+		const owners = declarationProvider.ownerProjectPaths;
 		if (!owners || owners.length === 0) continue;
 		const targetSourceConfigPath = owners.filter((owner) => owner !== project.configPath).sort((left, right) => posix.dirname(right).length - posix.dirname(left).length || left.localeCompare(right))[0] ?? null;
 		if (!targetSourceConfigPath) continue;
@@ -6044,6 +6418,33 @@ function createGeneratedDtsConfig(config, project) {
 		liminaOptions
 	};
 }
+function createGeneratedOutputProjectConfig(config, project) {
+	if (!project.outputOptions) throw new Error(`Missing output options for ${toRelativePath(config.rootDir, project.configPath)}.`);
+	const outputOptions = project.outputOptions;
+	return {
+		$schema: createLiminaTsconfigSchemaPath(config.rootDir, project.outputConfigPath),
+		extends: [createRelativePath(project.outputConfigPath, project.configPath)],
+		files: project.fileNames.map((fileName) => createRelativePath(project.outputConfigPath, fileName)),
+		compilerOptions: {
+			composite: true,
+			incremental: true,
+			noEmit: false,
+			declaration: true,
+			emitDeclarationOnly: false,
+			target: outputOptions.target,
+			rootDir: createRelativePath(project.outputConfigPath, outputOptions.rootDir),
+			outDir: createRelativePath(project.outputConfigPath, outputOptions.outDir),
+			declarationDir: createRelativePath(project.outputConfigPath, outputOptions.outDir),
+			tsBuildInfoFile: createRelativePath(project.outputConfigPath, outputOptions.tsBuildInfoFile)
+		},
+		references: [...project.outputReferences].sort().map((referencePath) => ({ path: createRelativePath(project.outputConfigPath, referencePath) })),
+		liminaOptions: {
+			generated: true,
+			checker: project.checkerName,
+			sourceConfig: createRelativePath(project.outputConfigPath, project.configPath)
+		}
+	};
+}
 function createGeneratedSolutionBuildConfig(config, solution) {
 	return {
 		$schema: createLiminaTsconfigSchemaPath(config.rootDir, solution.buildConfigPath),
@@ -6056,6 +6457,18 @@ function createGeneratedSolutionBuildConfig(config, solution) {
 		}
 	};
 }
+function createGeneratedOutputSolutionConfig(config, solution) {
+	return {
+		$schema: createLiminaTsconfigSchemaPath(config.rootDir, solution.buildConfigPath),
+		files: [],
+		references: [...solution.references].sort().map((referencePath) => ({ path: createRelativePath(solution.buildConfigPath, referencePath) })),
+		liminaOptions: {
+			generated: true,
+			checker: solution.checkerName,
+			sourceConfig: createRelativePath(solution.buildConfigPath, solution.configPath)
+		}
+	};
+}
 function createCheckerBuildConfig(options) {
 	return {
 		$schema: createLiminaTsconfigSchemaPath(options.rootDir, options.entryPath),
@@ -6098,11 +6511,20 @@ function createManifest(options) {
 	for (const checker of options.checkers) {
 		const projects = options.projectsByChecker.get(checker.name) ?? [];
 		const entryPath = options.checkerEntries.get(checker.name);
+		const configToOutputBuildByConfigPath = options.configToOutputBuildByChecker.get(checker.name) ?? /* @__PURE__ */ new Map();
 		const sourceToBuildBySourcePath = options.sourceToBuildByChecker.get(checker.name) ?? /* @__PURE__ */ new Map();
 		if (!entryPath) continue;
+		const configToOutputBuild = {};
 		const sourceToBuild = {};
 		const sourceToDts = {};
 		const dtsToSource = {};
+		for (const [sourceConfigPath, outputModule] of configToOutputBuildByConfigPath) {
+			const sourcePath = toPosixPath(toRelativePath(options.rootDir, sourceConfigPath));
+			configToOutputBuild[sourcePath] = {
+				kind: outputModule.kind,
+				path: toPosixPath(toRelativePath(options.rootDir, outputModule.path))
+			};
+		}
 		for (const [sourceConfigPath, buildModule] of sourceToBuildBySourcePath) {
 			const sourcePath = toPosixPath(toRelativePath(options.rootDir, sourceConfigPath));
 			sourceToBuild[sourcePath] = {
@@ -6117,6 +6539,7 @@ function createManifest(options) {
 			dtsToSource[dtsPath] = sourcePath;
 		}
 		manifestCheckers[checker.name] = {
+			configToOutputBuild: Object.fromEntries(Object.entries(configToOutputBuild).sort(([left], [right]) => left.localeCompare(right))),
 			preset: checker.preset,
 			entry: toPosixPath(toRelativePath(options.rootDir, entryPath)),
 			roots: projects.map((project) => toPosixPath(toRelativePath(options.rootDir, project.configPath))).sort(),
@@ -6126,7 +6549,7 @@ function createManifest(options) {
 		};
 	}
 	return {
-		version: 1,
+		version: 2,
 		generatedBy: "limina",
 		checkers: manifestCheckers,
 		knip: {
@@ -6146,6 +6569,7 @@ function createManifest(options) {
 }
 function createResult(options) {
 	const checkerEntries = /* @__PURE__ */ new Map();
+	const configToOutputBuild = /* @__PURE__ */ new Map();
 	const sourceToBuild = /* @__PURE__ */ new Map();
 	const sourceToDts = /* @__PURE__ */ new Map();
 	const dtsToSource = /* @__PURE__ */ new Map();
@@ -6160,6 +6584,10 @@ function createResult(options) {
 	}));
 	for (const [checkerName, checkerManifest] of Object.entries(options.manifest.checkers)) {
 		checkerEntries.set(checkerName, normalizeAbsolutePath(posix.join(options.rootDir, checkerManifest.entry)));
+		configToOutputBuild.set(checkerName, new Map(Object.entries(checkerManifest.configToOutputBuild ?? {}).map(([sourcePath, buildModule]) => [normalizeAbsolutePath(posix.join(options.rootDir, sourcePath)), {
+			kind: buildModule.kind,
+			path: normalizeAbsolutePath(posix.join(options.rootDir, buildModule.path))
+		}])));
 		sourceToBuild.set(checkerName, new Map(Object.entries(checkerManifest.sourceToBuild ?? {}).map(([sourcePath, buildModule]) => [normalizeAbsolutePath(posix.join(options.rootDir, sourcePath)), {
 			kind: buildModule.kind,
 			path: normalizeAbsolutePath(posix.join(options.rootDir, buildModule.path))
@@ -6172,6 +6600,7 @@ function createResult(options) {
 		checkers: options.checkers,
 		manifestPath: options.manifestPath,
 		checkerEntries,
+		configToOutputBuild,
 		sourceToBuild,
 		sourceToDts,
 		dtsToSource,
@@ -6193,6 +6622,9 @@ function collectGeneratedSourceConfigPaths(generatedGraph) {
 async function prepareGeneratedTsconfigGraph(config, options = {}) {
 	const checkers = await resolveGeneratedGraphCheckers(config, options);
 	const checkerCollectionsByName = /* @__PURE__ */ new Map();
+	const configToOutputBuildByChecker = /* @__PURE__ */ new Map();
+	const outputProjectsByChecker = /* @__PURE__ */ new Map();
+	const outputSolutionsByChecker = /* @__PURE__ */ new Map();
 	const projectsByChecker = /* @__PURE__ */ new Map();
 	const rootBuildPathsByChecker = /* @__PURE__ */ new Map();
 	const solutionsByChecker = /* @__PURE__ */ new Map();
@@ -6269,6 +6701,27 @@ async function prepareGeneratedTsconfigGraph(config, options = {}) {
 		projects: allProjects,
 		providerEdges
 	});
+	const allProjectsByDtsPath = createSourceProjectsByDtsPath(allProjects);
+	for (const checker of checkers) {
+		const outputGraph = createCheckerOutputGraph({
+			allProjectsByDtsPath,
+			checker,
+			collection: checkerCollectionsByName.get(checker.name) ?? {
+				buildModulesBySourcePath: /* @__PURE__ */ new Map(),
+				entryConfigPaths: /* @__PURE__ */ new Set(),
+				projectConfigPaths: /* @__PURE__ */ new Set(),
+				rootConfigPaths: [],
+				solutionConfigPaths: /* @__PURE__ */ new Set(),
+				solutionReferencesBySourcePath: /* @__PURE__ */ new Map()
+			},
+			config,
+			problems,
+			projects: projectsByChecker.get(checker.name) ?? []
+		});
+		configToOutputBuildByChecker.set(checker.name, outputGraph.configToOutputBuild);
+		outputProjectsByChecker.set(checker.name, outputGraph.outputProjects);
+		outputSolutionsByChecker.set(checker.name, outputGraph.outputSolutions);
+	}
 	providerEdges.sort((left, right) => left.fromChecker.localeCompare(right.fromChecker) || left.fromConfigPath.localeCompare(right.fromConfigPath) || left.toChecker.localeCompare(right.toChecker) || left.toConfigPath.localeCompare(right.toConfigPath) || left.file.localeCompare(right.file) || left.importedSpecifier.localeCompare(right.importedSpecifier));
 	if (problems.length > 0) throw createGeneratedGraphStructuredError({
 		config,
@@ -6276,20 +6729,25 @@ async function prepareGeneratedTsconfigGraph(config, options = {}) {
 		problems
 	});
 	const generatedKnip = prepareGeneratedKnipPackageConfigs({
+		checkers,
+		configToOutputBuildByChecker,
 		config,
-		sourceToBuildByChecker,
 		workspacePackages: options.workspacePackagesProvider ? await options.workspacePackagesProvider() : await collectWorkspacePackages(config)
 	});
 	await Promise.all(checkers.map(async (checker) => {
 		const checkerName = checker.name;
 		const projects = projectsByChecker.get(checkerName) ?? [];
 		const entryPath = checkerEntries.get(checkerName);
+		const outputProjects = outputProjectsByChecker.get(checkerName) ?? [];
+		const outputSolutions = outputSolutionsByChecker.get(checkerName) ?? [];
 		const solutions = solutionsByChecker.get(checkerName) ?? [];
 		const rootBuildPaths = rootBuildPathsByChecker.get(checkerName) ?? [];
 		if (!entryPath) return;
 		await Promise.all([
 			...projects.map((project) => writeGeneratedJson(writeContext, project.dtsConfigPath, createGeneratedDtsConfig(config, project))),
 			...solutions.map((solution) => writeGeneratedJson(writeContext, solution.buildConfigPath, createGeneratedSolutionBuildConfig(config, solution))),
+			...outputProjects.map((project) => writeGeneratedJson(writeContext, project.outputConfigPath, createGeneratedOutputProjectConfig(config, project))),
+			...outputSolutions.map((solution) => writeGeneratedJson(writeContext, solution.buildConfigPath, createGeneratedOutputSolutionConfig(config, solution))),
 			writeGeneratedJson(writeContext, entryPath, createCheckerBuildConfig({
 				checkerName,
 				entryPath,
@@ -6302,6 +6760,7 @@ async function prepareGeneratedTsconfigGraph(config, options = {}) {
 	const manifest = createManifest({
 		checkerEntries,
 		checkers,
+		configToOutputBuildByChecker,
 		generatedKnipDiagnostics: generatedKnip.diagnostics,
 		generatedKnipPackageConfigs: generatedKnip.configs.map((entry) => entry.config),
 		projectsByChecker,
@@ -7557,17 +8016,17 @@ function createProjectResolveContext(project) {
 function findOwnerForFile(filePath, owners) {
 	return owners.filter((owner) => isPathInsideDirectory(filePath, owner.directory)).sort((left, right) => right.directory.length - left.directory.length)[0] ?? null;
 }
-function getManifestPackageName(manifest) {
+function getManifestPackageName$1(manifest) {
 	return typeof manifest.name === "string" && manifest.name.trim().length > 0 ? manifest.name.trim() : void 0;
 }
-function isNodeModulesPackageRoot(directory) {
+function isNodeModulesPackageRoot$1(directory) {
 	const parentDirectory = posix.dirname(directory);
 	const parentName = posix.basename(parentDirectory);
 	if (parentName === "node_modules") return true;
 	if (parentName.startsWith("@")) return posix.basename(posix.dirname(parentDirectory)) === "node_modules";
 	return false;
 }
-function isPackageInfoInsideNodeModules(packageInfo) {
+function isPackageInfoInsideNodeModules$1(packageInfo) {
 	return normalizeAbsolutePath(packageInfo.directory).split("/").includes("node_modules");
 }
 function readPackageInfo(packageJsonPath) {
@@ -7577,21 +8036,10 @@ function readPackageInfo(packageJsonPath) {
 	return {
 		directory,
 		manifest,
-		name: getManifestPackageName(manifest),
+		name: getManifestPackageName$1(manifest),
 		packageJsonPath: normalizedPackageJsonPath
 	};
 }
-function findNearestPackageScopeInfo(filePath) {
-	const normalizedFilePath = normalizeAbsolutePath(filePath);
-	let currentDir = normalizeAbsolutePath(posix.dirname(normalizedFilePath));
-	while (true) {
-		const packageJsonPath = normalizeAbsolutePath(posix.join(currentDir, "package.json"));
-		if (existsSync(packageJsonPath)) return readPackageInfo(packageJsonPath);
-		const parentDir = posix.dirname(currentDir);
-		if (parentDir === currentDir) return null;
-		currentDir = parentDir;
-	}
-}
 function findNearestPackageInfo(filePath) {
 	const normalizedFilePath = normalizeAbsolutePath(filePath);
 	let currentDir = normalizeAbsolutePath(posix.dirname(normalizedFilePath));
@@ -7599,7 +8047,7 @@ function findNearestPackageInfo(filePath) {
 		const packageJsonPath = normalizeAbsolutePath(posix.join(currentDir, "package.json"));
 		if (existsSync(packageJsonPath)) {
 			const packageInfo = readPackageInfo(packageJsonPath);
-			if (packageInfo.name || isNodeModulesPackageRoot(currentDir)) return packageInfo;
+			if (packageInfo.name || isNodeModulesPackageRoot$1(currentDir)) return packageInfo;
 		}
 		const parentDir = posix.dirname(currentDir);
 		if (parentDir === currentDir) return null;
@@ -7626,7 +8074,7 @@ function classifyResolvedPackageTarget(options) {
 		};
 		return { kind: "unowned" };
 	}
-	if (targetOwner?.packageJsonPath === options.owner.packageJsonPath && !isPackageInfoInsideNodeModules(packageInfo)) return {
+	if (targetOwner?.packageJsonPath === options.owner.packageJsonPath && !isPackageInfoInsideNodeModules$1(packageInfo)) return {
 		kind: "current-owner",
 		packageInfo
 	};
@@ -7872,15 +8320,55 @@ function isDependencyAuthorized(manifest, packageName) {
 function findPackageImportMatch(importsField, specifier) {
 	if (!importsField || typeof importsField !== "object") return null;
 	for (const key of Object.keys(importsField)) {
-		if (key === specifier) return { key };
+		const value = importsField[key];
+		if (key === specifier) return {
+			key,
+			targetKind: classifyPackageImportTarget(value),
+			value
+		};
 		const wildcardIndex = key.indexOf("*");
 		if (wildcardIndex === -1) continue;
 		const prefix = key.slice(0, wildcardIndex);
 		const suffix = key.slice(wildcardIndex + 1);
-		if (specifier.startsWith(prefix) && specifier.endsWith(suffix)) return { key };
+		if (specifier.startsWith(prefix) && specifier.endsWith(suffix)) return {
+			key,
+			targetKind: classifyPackageImportTarget(value),
+			value
+		};
 	}
 	return null;
 }
+function classifyPackageImportTarget(value) {
+	const kinds = /* @__PURE__ */ new Set();
+	collectPackageImportTargetKinds(value, kinds);
+	if (kinds.size === 0) return "unknown";
+	if (kinds.size === 1) return kinds.values().next().value ?? "unknown";
+	return "mixed";
+}
+function collectPackageImportTargetKinds(value, kinds) {
+	if (typeof value === "string") {
+		const target = value.trim();
+		if (isRelativeSpecifier(target)) {
+			kinds.add("relative");
+			return;
+		}
+		if (isBarePackageSpecifier(target)) {
+			kinds.add("package");
+			return;
+		}
+		kinds.add("unknown");
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) collectPackageImportTargetKinds(item, kinds);
+		return;
+	}
+	if (isPlainRecord(value)) {
+		for (const item of Object.values(value)) collectPackageImportTargetKinds(item, kinds);
+		return;
+	}
+	if (value !== null && value !== void 0) kinds.add("unknown");
+}
 
 //#endregion
 //#region src/core/workspace.ts
@@ -8062,7 +8550,7 @@ function sortEdges(edges) {
 function resolveTargetPackage(options) {
 	return options.declaredTargetPackage ?? (options.graphResolvedFilePath ? findPackageForFile(options.graphResolvedFilePath, options.packages) : null) ?? findPackageForFile(options.resolvedFilePath, options.packages);
 }
-function shouldUseWorkspaceExportResolution$1(options) {
+function shouldUseWorkspaceExportResolution(options) {
 	if (!options.declaredTargetPackage) return false;
 	return !options.resolvedFilePath;
 }
@@ -8107,7 +8595,7 @@ async function collectDependencyGraph(config, options = {}) {
 			const declaredTargetPackage = findPackageForSpecifier(importRecord.specifier, workspacePackages);
 			const workspaceExportResolution = declaredTargetPackage && workspaceExports.hasExports(declaredTargetPackage.name) ? workspaceExports.get(project.configPath, importRecord.specifier) : null;
 			const internalResolvedFilePath = resolveInternalImport(importRecord.specifier, fileName, project.options, project, importAnalysis);
-			const useWorkspaceExportResolution = shouldUseWorkspaceExportResolution$1({
+			const useWorkspaceExportResolution = shouldUseWorkspaceExportResolution({
 				declaredTargetPackage,
 				resolvedFilePath: internalResolvedFilePath
 			});
@@ -9109,6 +9597,202 @@ function clearCliScreen() {
 	readline.clearScreenDown(process.stdout);
 }
 
+//#endregion
+//#region src/core/workspace/lookup.ts
+var WorkspaceLookupIndex = class {
+	rootDir;
+	#importers;
+	#namedPackagesByName = /* @__PURE__ */ new Map();
+	#ownersByDirectory;
+	#packageInfoByPackageJsonPath = /* @__PURE__ */ new Map();
+	#packagesByDirectory;
+	#packagesByPackageJsonPath = /* @__PURE__ */ new Map();
+	#importerByFilePath = /* @__PURE__ */ new Map();
+	#nearestNamedPackageInfoByDirectory = /* @__PURE__ */ new Map();
+	#nearestPackageScopeInfoByDirectory = /* @__PURE__ */ new Map();
+	#ownerByFilePath = /* @__PURE__ */ new Map();
+	#packageByFilePath = /* @__PURE__ */ new Map();
+	#resolvedPackageTargetByKey = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.rootDir = normalizeAbsolutePath(options.rootDir);
+		this.#importers = options.importers.map((importer) => ({
+			directory: normalizeAbsolutePath(importer.directory),
+			importer
+		}));
+		this.#ownersByDirectory = createDirectoryMap(options.owners);
+		this.#packagesByDirectory = createDirectoryMap(options.packages);
+		for (const workspacePackage of options.packages) {
+			const packageJsonPath = normalizeAbsolutePath(posix.join(workspacePackage.directory, "package.json"));
+			this.#packagesByPackageJsonPath.set(packageJsonPath, workspacePackage);
+			if (isNamedWorkspacePackage(workspacePackage) && !this.#namedPackagesByName.has(workspacePackage.name)) this.#namedPackagesByName.set(workspacePackage.name, workspacePackage);
+		}
+	}
+	findPackageForFile(filePath) {
+		const normalizedFilePath = normalizeAbsolutePath(filePath);
+		const cached = this.#packageByFilePath.get(normalizedFilePath);
+		if (cached !== void 0) return cached;
+		const workspacePackage = findNearestDirectoryItem(normalizedFilePath, this.#packagesByDirectory);
+		this.#packageByFilePath.set(normalizedFilePath, workspacePackage);
+		return workspacePackage;
+	}
+	findOwnerForFile(filePath) {
+		const normalizedFilePath = normalizeAbsolutePath(filePath);
+		const cached = this.#ownerByFilePath.get(normalizedFilePath);
+		if (cached !== void 0) return cached;
+		const owner = findNearestDirectoryItem(normalizedFilePath, this.#ownersByDirectory);
+		this.#ownerByFilePath.set(normalizedFilePath, owner);
+		return owner;
+	}
+	findImporterForFile(filePath) {
+		const normalizedFilePath = normalizeAbsolutePath(filePath);
+		const cached = this.#importerByFilePath.get(normalizedFilePath);
+		if (cached !== void 0) return cached;
+		const importer = this.#importers.find((candidate) => isPathInsideNormalizedDirectory(normalizedFilePath, candidate.directory))?.importer ?? null;
+		this.#importerByFilePath.set(normalizedFilePath, importer);
+		return importer;
+	}
+	findNearestPackageScopeInfo(filePath) {
+		const directory = normalizeAbsolutePath(posix.dirname(normalizeAbsolutePath(filePath)));
+		return this.#findNearestPackageInfoFromDirectory(directory, { requireNamedPackageOrNodeModulesPackage: false });
+	}
+	findPackageForSpecifier(specifier) {
+		return this.#namedPackagesByName.get(getPackageRootSpecifier(specifier)) ?? null;
+	}
+	classifyResolvedPackageTarget(options) {
+		const normalizedResolvedFilePath = normalizeAbsolutePath(options.resolvedFilePath);
+		const cacheKey = `${options.owner.packageJsonPath}\0${normalizedResolvedFilePath}`;
+		const cached = this.#resolvedPackageTargetByKey.get(cacheKey);
+		if (cached) return cached;
+		const packageInfo = this.#findNearestPackageInfoFromDirectory(normalizeAbsolutePath(posix.dirname(normalizedResolvedFilePath)), { requireNamedPackageOrNodeModulesPackage: true });
+		const targetOwner = this.findOwnerForFile(normalizedResolvedFilePath);
+		const target = this.#classifyResolvedPackageTarget({
+			owner: options.owner,
+			packageInfo,
+			targetOwner
+		});
+		this.#resolvedPackageTargetByKey.set(cacheKey, target);
+		return target;
+	}
+	#classifyResolvedPackageTarget(options) {
+		if (!options.packageInfo) {
+			if (options.targetOwner?.packageJsonPath === options.owner.packageJsonPath) return {
+				kind: "current-owner",
+				packageInfo: {
+					directory: options.owner.directory,
+					manifest: options.owner.manifest,
+					...options.owner.name ? { name: options.owner.name } : {},
+					packageJsonPath: options.owner.packageJsonPath
+				}
+			};
+			return { kind: "unowned" };
+		}
+		if (options.targetOwner?.packageJsonPath === options.owner.packageJsonPath && !isPackageInfoInsideNodeModules(options.packageInfo)) return {
+			kind: "current-owner",
+			packageInfo: options.packageInfo
+		};
+		if (options.targetOwner && options.targetOwner.packageJsonPath !== options.owner.packageJsonPath) return {
+			kind: "other-owner",
+			packageInfo: options.packageInfo,
+			targetOwner: options.targetOwner,
+			workspacePackage: this.#findWorkspacePackageForPackageInfo(options.packageInfo)
+		};
+		return {
+			kind: "artifact-package",
+			packageInfo: options.packageInfo
+		};
+	}
+	#findNearestPackageInfoFromDirectory(directory, options) {
+		const cache = options.requireNamedPackageOrNodeModulesPackage ? this.#nearestNamedPackageInfoByDirectory : this.#nearestPackageScopeInfoByDirectory;
+		const visitedDirectories = [];
+		let currentDir = normalizeAbsolutePath(directory);
+		while (true) {
+			const cached = cache.get(currentDir);
+			if (cached !== void 0) {
+				setCachedPackageInfo(cache, visitedDirectories, cached);
+				return cached;
+			}
+			visitedDirectories.push(currentDir);
+			const packageJsonPath = normalizeAbsolutePath(posix.join(currentDir, "package.json"));
+			if (existsSync(packageJsonPath)) {
+				const packageInfo = this.#readPackageInfo(packageJsonPath);
+				if (!options.requireNamedPackageOrNodeModulesPackage || packageInfo.name || isNodeModulesPackageRoot(currentDir)) {
+					setCachedPackageInfo(cache, visitedDirectories, packageInfo);
+					return packageInfo;
+				}
+			}
+			const parentDir = posix.dirname(currentDir);
+			if (parentDir === currentDir) {
+				setCachedPackageInfo(cache, visitedDirectories, null);
+				return null;
+			}
+			currentDir = parentDir;
+		}
+	}
+	#findWorkspacePackageForPackageInfo(packageInfo) {
+		return this.#packagesByPackageJsonPath.get(packageInfo.packageJsonPath) ?? (packageInfo.name ? this.#namedPackagesByName.get(packageInfo.name) : void 0) ?? null;
+	}
+	#readPackageInfo(packageJsonPath) {
+		const normalizedPackageJsonPath = normalizeAbsolutePath(packageJsonPath);
+		const cached = this.#packageInfoByPackageJsonPath.get(normalizedPackageJsonPath);
+		if (cached) return cached;
+		const directory = normalizeAbsolutePath(posix.dirname(packageJsonPath));
+		const manifest = readJsonFile(normalizedPackageJsonPath);
+		const name = getManifestPackageName(manifest);
+		const packageInfo = {
+			directory,
+			manifest,
+			...name ? { name } : {},
+			packageJsonPath: normalizedPackageJsonPath
+		};
+		this.#packageInfoByPackageJsonPath.set(normalizedPackageJsonPath, packageInfo);
+		return packageInfo;
+	}
+};
+function createWorkspaceLookupIndex(options) {
+	return new WorkspaceLookupIndex(options);
+}
+function createDirectoryMap(items) {
+	const itemsByDirectory = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const directory = normalizeAbsolutePath(item.directory);
+		if (!itemsByDirectory.has(directory)) itemsByDirectory.set(directory, item);
+	}
+	return itemsByDirectory;
+}
+function findNearestDirectoryItem(filePath, itemsByDirectory) {
+	let currentDir = normalizeAbsolutePath(filePath);
+	const exactMatch = itemsByDirectory.get(currentDir);
+	if (exactMatch) return exactMatch;
+	currentDir = normalizeAbsolutePath(posix.dirname(currentDir));
+	while (true) {
+		const item = itemsByDirectory.get(currentDir);
+		if (item) return item;
+		const parentDir = posix.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function getManifestPackageName(manifest) {
+	return typeof manifest.name === "string" && manifest.name.trim().length > 0 ? manifest.name.trim() : void 0;
+}
+function isNodeModulesPackageRoot(directory) {
+	const parentDirectory = posix.dirname(directory);
+	const parentName = posix.basename(parentDirectory);
+	if (parentName === "node_modules") return true;
+	if (parentName.startsWith("@")) return posix.basename(posix.dirname(parentDirectory)) === "node_modules";
+	return false;
+}
+function isPackageInfoInsideNodeModules(packageInfo) {
+	return normalizeAbsolutePath(packageInfo.directory).split("/").includes("node_modules");
+}
+function isPathInsideNormalizedDirectory(normalizedFilePath, normalizedDirectoryPath) {
+	const directoryPrefix = normalizedDirectoryPath.endsWith("/") ? normalizedDirectoryPath : `${normalizedDirectoryPath}/`;
+	return normalizedFilePath === normalizedDirectoryPath || normalizedFilePath.startsWith(directoryPrefix);
+}
+function setCachedPackageInfo(cache, directories, packageInfo) {
+	for (const directory of directories) cache.set(directory, packageInfo);
+}
+
 //#endregion
 //#region src/package-check/entry-selection.ts
 const DEFAULT_PACKAGE_CHECKS = [
@@ -9585,6 +10269,14 @@ var LiminaPreflightManager = class {
 	ensureImporters() {
 		return this.#ensure("importers", () => this.core.workspace.getImporters());
 	}
+	ensureWorkspaceLookupIndex() {
+		return this.#ensure("workspaceLookupIndex", async () => createWorkspaceLookupIndex({
+			importers: await this.ensureImporters(),
+			owners: await this.ensurePackageOwners(),
+			packages: await this.ensureWorkspacePackages(),
+			rootDir: this.config.rootDir
+		}));
+	}
 	ensureWorkspaceDependencyDeclarations() {
 		return this.#ensure("workspaceDependencyDeclarations", () => this.core.workspace.getWorkspaceDependencyDeclarations());
 	}
@@ -10318,6 +11010,8 @@ const GRAPH_CHECK_ITEM_NAMES = [
 	"condition domains",
 	"reference completeness"
 ];
+const GENERATED_REFERENCE_CYCLE_REASON = "Generated declaration project references must be acyclic so build-mode checkers can order declaration builds.";
+const GENERATED_REFERENCE_CYCLE_FIX = "Break the cycle by merging tightly coupled source scopes, extracting shared contracts, moving runtime wiring to a higher-level entry, or using an intentional declaration boundary.";
 function getGeneratedCheckerNamespace(configPath) {
 	const markerIndex = configPath.indexOf("/.limina/tsconfig/checkers/");
 	if (markerIndex === -1) return null;
@@ -10389,7 +11083,7 @@ function addDeniedReferenceProblems(options) {
 		options.checks.add();
 		if (!options.projectsByPath.has(referencePath)) continue;
 		const deniedRefRule = getDeniedRefRule(options.rules, options.project.labels, referencePath);
-		const targetPackage = findPackageForFile(referencePath, options.packages);
+		const targetPackage = options.workspaceLookup.findPackageForFile(referencePath);
 		const deniedDepRule = targetPackage?.name ? getDeniedDepRuleForPackage(options.rules, options.project.labels, targetPackage.name) : null;
 		if (!deniedRefRule && !deniedDepRule) continue;
 		const lines = [
@@ -10456,8 +11150,8 @@ function getNodeModulesPackageName(filePath) {
 	}
 	return packageName;
 }
-function getResolvedPackageName(filePath, packages) {
-	return getNodeModulesPackageName(filePath) ?? findPackageForFile(filePath, packages)?.name ?? null;
+function getResolvedPackageName(filePath, workspaceLookup) {
+	return getNodeModulesPackageName(filePath) ?? workspaceLookup.findPackageForFile(filePath)?.name ?? null;
 }
 function addNamelessWorkspaceReferenceProblem(options) {
 	const packageManifestPath = posix.join(options.workspacePackage.directory, "package.json");
@@ -10478,23 +11172,19 @@ function addNamelessWorkspaceReferenceProblem(options) {
 		title: "Project reference crosses workspace package without package identity"
 	});
 }
-function getResolvedWorkspacePackage(filePath, packages) {
+function getResolvedWorkspacePackage(filePath, workspaceLookup) {
 	if (getNodeModulesPackageName(filePath)) return null;
-	return findPackageForFile(filePath, packages);
+	return workspaceLookup.findPackageForFile(filePath);
 }
-function shouldUseWorkspaceExportResolution(options) {
-	if (!options.targetPackage) return false;
-	return !options.resolvedFilePath;
-}
-function addWorkspaceReferenceDependencyProblems(config, project, projectsByPath, packages, importers, problems, checks) {
+function addWorkspaceReferenceDependencyProblems(config, project, projectsByPath, workspaceLookup, problems, checks) {
 	if (!isDtsProjectConfig(project.configPath)) return;
-	const sourcePackage = findPackageForFile(project.configPath, packages);
-	const importer = sourcePackage ? findImporterForFile(project.configPath, importers) : null;
+	const sourcePackage = workspaceLookup.findPackageForFile(project.configPath);
+	const importer = sourcePackage ? workspaceLookup.findImporterForFile(project.configPath) : null;
 	if (!sourcePackage) return;
 	for (const referencePath of project.references) {
 		checks.add();
 		if (!projectsByPath.has(referencePath)) continue;
-		const targetPackage = findPackageForFile(referencePath, packages);
+		const targetPackage = workspaceLookup.findPackageForFile(referencePath);
 		if (!targetPackage || targetPackage.directory === sourcePackage.directory) continue;
 		if (!isNamedWorkspacePackage(sourcePackage)) {
 			addNamelessWorkspaceReferenceProblem({
@@ -10540,6 +11230,80 @@ function addWorkspaceReferenceDependencyProblems(config, project, projectsByPath
 		});
 	}
 }
+function createGeneratedReferenceGraph(projects) {
+	const dtsProjects = projects.filter((project) => isDtsProjectConfig(project.configPath));
+	const dtsProjectPaths = new Set(dtsProjects.map((project) => project.configPath));
+	const graph = /* @__PURE__ */ new Map();
+	for (const project of dtsProjects) graph.set(project.configPath, new Set([...project.references].filter((referencePath) => dtsProjectPaths.has(referencePath)).sort()));
+	return graph;
+}
+function collectGeneratedReferenceComponents(graph) {
+	const components = [];
+	const indexByPath = /* @__PURE__ */ new Map();
+	const lowLinkByPath = /* @__PURE__ */ new Map();
+	const stack = [];
+	const pathsOnStack = /* @__PURE__ */ new Set();
+	let nextIndex = 0;
+	function visit(configPath) {
+		indexByPath.set(configPath, nextIndex);
+		lowLinkByPath.set(configPath, nextIndex);
+		nextIndex += 1;
+		stack.push(configPath);
+		pathsOnStack.add(configPath);
+		for (const referencePath of graph.get(configPath) ?? []) {
+			if (!indexByPath.has(referencePath)) {
+				visit(referencePath);
+				lowLinkByPath.set(configPath, Math.min(lowLinkByPath.get(configPath), lowLinkByPath.get(referencePath)));
+				continue;
+			}
+			if (pathsOnStack.has(referencePath)) lowLinkByPath.set(configPath, Math.min(lowLinkByPath.get(configPath), indexByPath.get(referencePath)));
+		}
+		if (lowLinkByPath.get(configPath) !== indexByPath.get(configPath)) return;
+		const component = [];
+		while (stack.length > 0) {
+			const currentPath = stack.pop();
+			pathsOnStack.delete(currentPath);
+			component.push(currentPath);
+			if (currentPath === configPath) break;
+		}
+		components.push(component.sort());
+	}
+	for (const configPath of [...graph.keys()].sort()) if (!indexByPath.has(configPath)) visit(configPath);
+	return components.sort((left, right) => left[0].localeCompare(right[0]));
+}
+function getGeneratedReferenceCycleEdges(graph, members) {
+	const memberPaths = new Set(members);
+	return members.flatMap((from) => [...graph.get(from) ?? []].filter((to) => memberPaths.has(to)).map((to) => ({
+		from,
+		to
+	}))).sort((left, right) => left.from.localeCompare(right.from) || left.to.localeCompare(right.to));
+}
+function addGeneratedReferenceCycleProblems(options) {
+	const graph = createGeneratedReferenceGraph(options.projects);
+	options.checks.add(graph.size);
+	for (const component of collectGeneratedReferenceComponents(graph)) {
+		const hasSelfReference = Boolean(component[0] && graph.get(component[0])?.has(component[0]));
+		if (component.length === 1 && !hasSelfReference) continue;
+		const members = [...component].sort();
+		const internalEdges = getGeneratedReferenceCycleEdges(graph, members);
+		const lines = [
+			"Generated project reference cycle:",
+			"  projects:",
+			...members.map((member) => `    - ${toRelativePath(options.config.rootDir, member)}`),
+			"  references in cycle:",
+			...internalEdges.map((edge) => `    - ${toRelativePath(options.config.rootDir, edge.from)} -> ${toRelativePath(options.config.rootDir, edge.to)}`),
+			`  reason: ${GENERATED_REFERENCE_CYCLE_REASON}`,
+			`  fix: ${GENERATED_REFERENCE_CYCLE_FIX}`
+		];
+		addGraphProblem(options.problems, lines, {
+			code: LIMINA_CHECK_ISSUE_CODES.graphReferenceCycle,
+			filePath: members[0],
+			fix: GENERATED_REFERENCE_CYCLE_FIX,
+			reason: GENERATED_REFERENCE_CYCLE_REASON,
+			title: "Generated project reference cycle"
+		});
+	}
+}
 function getExpectedReferencesForProject(expectedReferencesByProjectPath, project) {
 	const expectedReferences = expectedReferencesByProjectPath.get(project.configPath) ?? /* @__PURE__ */ new Map();
 	expectedReferencesByProjectPath.set(project.configPath, expectedReferences);
@@ -10673,30 +11437,34 @@ function collectExpectedReferenceForImport(options) {
 	});
 }
 function resolveImportForReferenceExpectation(options) {
-	const targetPackage = findPackageForSpecifier(options.importRecord.specifier, options.context.packages);
-	const importer = findImporterForFile(options.importRecord.filePath, options.context.importers);
+	const targetPackage = options.context.workspaceLookup.findPackageForSpecifier(options.importRecord.specifier);
+	const importer = options.context.workspaceLookup.findImporterForFile(options.importRecord.filePath);
 	const workspaceExportResolution = getWorkspaceExportResolution({
 		context: options.context,
 		importRecord: options.importRecord,
 		project: options.project,
 		targetPackage
 	});
-	if (workspaceExportResolution && !workspaceExportResolution.hasTypeScriptStableEntry) {
-		addWorkspacePackageExportWithoutTypeEntryProblem({
+	const declarationProvider = resolveDeclarationProvider({
+		compilerOptions: options.project.options,
+		containingFile: options.filePath,
+		fileOwnerLookup: options.context.fileOwnerLookup,
+		importAnalysis: options.context.importAnalysis,
+		importRecord: options.importRecord,
+		project: options.project
+	});
+	const workspaceTypeScriptResolvedFilePath = workspaceExportResolution?.typeScriptResolvedFileName ?? null;
+	const graphResolvedFilePath = declarationProvider.kind === "declaration" || declarationProvider.kind === "source" ? declarationProvider.typeScriptResolution.resolvedFileName : workspaceTypeScriptResolvedFilePath;
+	if (!graphResolvedFilePath && declarationProvider.kind === "oxc-only") {
+		addOxcOnlyDeclarationProviderProblem({
 			context: options.context,
 			importRecord: options.importRecord,
-			project: options.project,
-			resolution: workspaceExportResolution
+			oxcResolvedFilePath: declarationProvider.oxcResolvedFilePath,
+			project: options.project
 		});
 		return null;
 	}
-	const internalResolvedFilePath = resolveInternalImport(options.importRecord.specifier, options.filePath, options.project.options, options.project, options.context.importAnalysis);
-	const useWorkspaceExportResolution = shouldUseWorkspaceExportResolution({
-		resolvedFilePath: internalResolvedFilePath,
-		targetPackage
-	});
-	const resolvedFilePath = (useWorkspaceExportResolution ? workspaceExportResolution?.oxcResolvedFileName : null) ?? internalResolvedFilePath;
-	if (!resolvedFilePath) {
+	if (!graphResolvedFilePath && declarationProvider.kind === "unresolved") {
 		addUnresolvedWorkspaceImportProblem({
 			context: options.context,
 			importRecord: options.importRecord,
@@ -10706,22 +11474,22 @@ function resolveImportForReferenceExpectation(options) {
 		});
 		return null;
 	}
-	const graphResolvedFilePath = (useWorkspaceExportResolution ? workspaceExportResolution?.typeScriptResolvedFileName : null) ?? resolvedFilePath;
-	if (!graphResolvedFilePath) {
-		addUnresolvedWorkspaceImportProblem({
+	if (workspaceExportResolution && !workspaceExportResolution.hasTypeScriptStableEntry) {
+		addWorkspacePackageExportWithoutTypeEntryProblem({
 			context: options.context,
 			importRecord: options.importRecord,
 			project: options.project,
-			targetPackage,
-			title: "Unresolved workspace import in TypeScript:"
+			resolution: workspaceExportResolution
 		});
 		return null;
 	}
-	const targetWorkspacePackageForResolved = getResolvedWorkspacePackage(graphResolvedFilePath, options.context.packages);
+	if (!graphResolvedFilePath) return null;
+	const resolvedFilePath = graphResolvedFilePath;
+	const targetWorkspacePackageForResolved = getResolvedWorkspacePackage(graphResolvedFilePath, options.context.workspaceLookup);
 	const targetPackageForGraph = getTargetPackageForGraph({
 		targetPackage,
 		targetWorkspacePackageForResolved,
-		useWorkspaceExportResolution
+		useWorkspaceExportResolution: Boolean(workspaceExportResolution)
 	});
 	const deniedDepRule = getDeniedDepRuleForResolvedPackage({
 		context: options.context,
@@ -10738,6 +11506,7 @@ function resolveImportForReferenceExpectation(options) {
 		});
 		return null;
 	}
+	if (isDeclarationFileFamily(graphResolvedFilePath)) return null;
 	return {
 		graphResolvedFilePath,
 		importer,
@@ -10774,7 +11543,7 @@ function getTargetPackageForGraph(options) {
 	return null;
 }
 function getDeniedDepRuleForResolvedPackage(options) {
-	const resolvedPackageName = getResolvedPackageName(options.resolvedFilePath, options.context.packages);
+	const resolvedPackageName = getResolvedPackageName(options.resolvedFilePath, options.context.workspaceLookup);
 	if (!resolvedPackageName) return null;
 	return getDeniedDepRuleForPackage(options.context.graphRules, options.project.labels, resolvedPackageName);
 }
@@ -10789,6 +11558,23 @@ function addUnresolvedWorkspaceImportProblem(options) {
 		`  current references: ${formatReferences(options.context.config.rootDir, options.project.references)}`
 	].join("\n"));
 }
+function addOxcOnlyDeclarationProviderProblem(options) {
+	addGraphProblem(options.context.problems, [
+		"Oxc can resolve this specifier, but TypeScript cannot:",
+		`  importing project: ${toRelativePath(options.context.config.rootDir, options.project.configPath)}`,
+		`  file: ${formatImportRecordLocation(options.context.config.rootDir, options.importRecord)}`,
+		`  imported specifier: ${options.importRecord.specifier}`,
+		`  Oxc resolved file: ${toRelativePath(options.context.config.rootDir, options.oxcResolvedFilePath)}`,
+		"  reason: declaration references follow the checker-aware TypeScript declaration provider, not the Oxc runtime-like resolver.",
+		"  fix: check moduleResolution, exports.types/types conditions, paths, customConditions, and package boundaries."
+	], {
+		code: LIMINA_CHECK_ISSUE_CODES.graphWorkspaceImportUnresolved,
+		filePath: options.importRecord.filePath,
+		fix: "Check moduleResolution, exports.types/types conditions, paths, customConditions, and package boundaries.",
+		reason: "Oxc resolved this specifier, but TypeScript could not resolve a declaration provider.",
+		title: "Oxc can resolve this specifier, but TypeScript cannot"
+	});
+}
 function findExpectedReferenceTargetProjectPath(options) {
 	if (shouldSkipWorkspaceExportResolvedOutsideGraph(options)) return null;
 	if (addBuildArtifactImportProblem(options)) return null;
@@ -10929,7 +11715,7 @@ async function runGraphCheckImpl(config, options = {}) {
 	const projectsByPath = new Map(projects.map((project) => [project.configPath, project]));
 	const fileOwnerLookup = createFileOwnerLookup(projects);
 	const packages = await preflight.ensureWorkspacePackages();
-	const importers = await preflight.ensureImporters();
+	const workspaceLookup = await preflight.ensureWorkspaceLookupIndex();
 	checkItems.start("source graph routes");
 	problems.push(...graphRoute.problems);
 	const customConditionConsistencyContext = createCustomConditionConsistencyContext(projectsByPath);
@@ -10960,14 +11746,20 @@ async function runGraphCheckImpl(config, options = {}) {
 		addDeniedReferenceProblems({
 			checks,
 			config,
-			packages,
 			problems,
 			project,
 			projectsByPath,
-			rules: graphRules
+			rules: graphRules,
+			workspaceLookup
 		});
-		addWorkspaceReferenceDependencyProblems(config, project, projectsByPath, packages, importers, problems, checks);
+		addWorkspaceReferenceDependencyProblems(config, project, projectsByPath, workspaceLookup, problems, checks);
 	}
+	addGeneratedReferenceCycleProblems({
+		checks,
+		config,
+		problems,
+		projects
+	});
 	checkItems.record("project references");
 	checkItems.start("condition domains");
 	addDefaultCustomConditionProblems({
@@ -10996,13 +11788,13 @@ async function runGraphCheckImpl(config, options = {}) {
 			generatedGraph,
 			graphRules,
 			importAnalysis: preflight.importAnalysis,
-			importers,
 			packages,
 			problems,
 			projectPaths,
 			projects,
 			projectsByPath,
-			workspaceExports
+			workspaceExports,
+			workspaceLookup
 		}),
 		generatedGraph,
 		graphRules,
@@ -12474,7 +13266,7 @@ var dist_exports = /* @__PURE__ */ __exportAll({
 	updateSettings: () => j$1
 });
 function ee() {
-	return V.platform !== "win32" ? V.env.TERM !== "linux" : !!V.env.CI || !!V.env.WT_SESSION || !!V.env.TERMINUS_SUBLIME || V.env.ConEmuTask === "{cmd::Cmder}" || V.env.TERM_PROGRAM === "Terminus-Sublime" || V.env.TERM_PROGRAM === "vscode" || V.env.TERM === "xterm-256color" || V.env.TERM === "alacritty" || V.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+	return process$1.platform !== "win32" ? process$1.env.TERM !== "linux" : !!process$1.env.CI || !!process$1.env.WT_SESSION || !!process$1.env.TERMINUS_SUBLIME || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 const tt$1 = ee(), ot = () => process.env.CI === "true", It = (t) => t.isTTY === !0, w$1 = (t, i) => tt$1 ? t : i, Tt = w$1("◆", "*"), at = w$1("■", "x"), ut = w$1("▲", "x"), H = w$1("◇", "o"), lt = w$1("┌", "T"), $ = w$1("│", "|"), x = w$1("└", "—"), _t = w$1("┐", "T"), xt = w$1("┘", "—"), z$1 = w$1("●", ">"), U = w$1("○", " "), et$1 = w$1("◻", "[•]"), K = w$1("◼", "[+]"), Y = w$1("◻", "[ ]"), Et = w$1("▪", "•"), st = w$1("─", "-"), ct = w$1("╮", "+"), Gt = w$1("├", "+"), $t = w$1("╯", "+"), dt = w$1("╰", "+"), Mt = w$1("╭", "+"), ht = w$1("●", "•"), pt = w$1("◆", "*"), mt = w$1("▲", "!"), gt = w$1("■", "x"), P = (t) => {
 	switch (t) {
@@ -13088,7 +13880,7 @@ ${r ? styleText("cyan", x) : ""}
 `), n = u.reduce((o, l) => Math.max(fastStringWidth(l), o), 0);
 	return wrapAnsi(t, i - (u.map(s).reduce((o, l) => Math.max(fastStringWidth(l), o), 0) - n), r);
 }, Se = (t = "", i = "", s) => {
-	const r = s?.output ?? V.stdout, u = s?.withGuide ?? h.withGuide, n = s?.format ?? we$1, a = [
+	const r = s?.output ?? process$1.stdout, u = s?.withGuide ?? h.withGuide, n = s?.format ?? we$1, a = [
 		"",
 		...be$1(t, A$1(r) - 6, n).split(`
 `).map(n),
@@ -44249,8 +45041,8 @@ function collectSourceKnipWorkspaceConfigs(options) {
 		if (Object.hasOwn(rawWorkspaceConfig, "tsConfig")) options.problems.push([
 			"Unsupported source Knip workspace config:",
 			`  field: ${field}.tsConfig`,
-			"  reason: tsConfig is no longer supported. Limina uses Knip default tsconfig behavior unless a package has a static limina checker build script.",
-			"  fix: remove tsConfig, or add a static package script such as \"build\": \"limina checker build tsconfig.json\" when this package needs a specific Knip tsconfig source."
+			"  reason: tsConfig is no longer supported. Limina uses Knip default tsconfig behavior unless a package has a static limina build script.",
+			"  fix: remove tsConfig, or add a static package script such as \"build\": \"limina build tsconfig.json\" when this package needs a specific Knip tsconfig source."
 		].join("\n"));
 		workspaceConfigs.set(packageName, rawWorkspaceConfig);
 	}
@@ -45401,7 +46193,7 @@ function addProjectOwnerProblems(options) {
 	const missingOwnerFiles = [];
 	for (const fileName of options.fileNames) {
 		options.checks.add();
-		const owner = findOwnerForFile(fileName, options.owners);
+		const owner = options.workspaceLookup.findOwnerForFile(fileName);
 		if (!owner) {
 			missingOwnerFiles.push(fileName);
 			continue;
@@ -45617,14 +46409,79 @@ function addPackageImportOtherOwnerProblem(options) {
 		"  reason: #... package imports must not resolve to modules governed by another source owner."
 	].join("\n"));
 }
+function addPackageImportRelativeScopeProblem(options) {
+	options.problems.push([
+		"Package import relative target escapes package scope:",
+		`  source owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
+		`  package scope: ${toRelativePath(options.config.rootDir, options.packageScope.packageJsonPath)}`,
+		`  file: ${formatImportRecordLocation(options.config.rootDir, options.importRecord)}`,
+		`  imported specifier: ${options.importRecord.specifier}`,
+		`  resolved file: ${toRelativePath(options.config.rootDir, options.resolvedFilePath)}`,
+		...options.targetPackageScope ? [`  target package scope: ${toRelativePath(options.config.rootDir, options.targetPackageScope.packageJsonPath)}`] : [],
+		"  reason: #... package imports with relative targets must stay inside the declaring package scope."
+	].join("\n"));
+}
+function isResolvedInsidePackageScope(options) {
+	return options.workspaceLookup.findNearestPackageScopeInfo(options.resolvedFilePath)?.packageJsonPath === options.packageScope.packageJsonPath;
+}
+function addPackageImportArtifactAuthorizationProblem(options) {
+	if (!options.packageInfo.name) {
+		addResolvedPackageWithoutNameProblem({
+			config: options.config,
+			importRecord: options.importRecord,
+			owner: options.owner,
+			packageInfo: options.packageInfo,
+			problems: options.problems
+		});
+		return;
+	}
+	const packageName = getPackageNameForAuthorization({
+		importRecord: options.importRecord,
+		resolvedPackageName: options.packageInfo.name
+	});
+	if (isDependencyAuthorizedBySourceAuthority({
+		config: options.config,
+		importAuthorityAllowRules: options.importAuthorityAllowRules,
+		importRecord: options.importRecord,
+		owner: options.owner,
+		packageName,
+		rootPackage: options.rootPackage
+	})) return;
+	addPackageImportAuthorizationProblem({
+		authorityManifestPaths: getDependencyAuthorityManifestPaths({
+			config: options.config,
+			importAuthorityAllowRules: options.importAuthorityAllowRules,
+			importRecord: options.importRecord,
+			owner: options.owner,
+			packageName,
+			rootPackage: options.rootPackage
+		}),
+		config: options.config,
+		...packageName === options.packageInfo.name ? {} : { dependencySpecifier: options.packageInfo.name },
+		importRecord: options.importRecord,
+		owner: options.owner,
+		packageName,
+		problems: options.problems,
+		workspacePackage: options.workspacePackage
+	});
+}
+function shouldTreatPackageImportAsRelativeTarget(match) {
+	return match.targetKind === "relative";
+}
+function shouldTreatPackageImportAsPackageTarget(match) {
+	return match.targetKind === "package" || match.targetKind === "mixed";
+}
 function addPackageImportProblem(options) {
-	if (!findPackageImportMatch(options.owner.manifest.imports, options.importRecord.specifier)) {
+	const packageScope = options.workspaceLookup.findNearestPackageScopeInfo(options.importRecord.filePath);
+	const match = findPackageImportMatch(packageScope?.manifest.imports, options.importRecord.specifier);
+	if (!match) {
 		options.problems.push([
 			"Unauthorized package import specifier:",
 			`  source owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
+			...packageScope ? [`  package scope: ${toRelativePath(options.config.rootDir, packageScope.packageJsonPath)}`] : [],
 			`  file: ${formatImportRecordLocation(options.config.rootDir, options.importRecord)}`,
 			`  imported specifier: ${options.importRecord.specifier}`,
-			"  reason: #... package imports must match the source owner package.json imports field."
+			"  reason: #... package imports must match the nearest package scope package.json imports field."
 		].join("\n"));
 		return;
 	}
@@ -45632,68 +46489,82 @@ function addPackageImportProblem(options) {
 		options.problems.push([
 			"Unresolved package import specifier:",
 			`  source owner: ${toRelativePath(options.config.rootDir, options.owner.packageJsonPath)}`,
+			...packageScope ? [`  package scope: ${toRelativePath(options.config.rootDir, packageScope.packageJsonPath)}`] : [],
 			`  file: ${formatImportRecordLocation(options.config.rootDir, options.importRecord)}`,
 			`  imported specifier: ${options.importRecord.specifier}`,
-			"  reason: matched #... package imports must resolve to a file within the same source owner scope."
+			"  reason: matched #... package imports must resolve from the nearest package scope package.json imports field."
 		].join("\n"));
 		return;
 	}
-	const target = classifyResolvedPackageTarget({
+	if (packageScope && shouldTreatPackageImportAsRelativeTarget(match) && !isResolvedInsidePackageScope({
+		packageScope,
+		resolvedFilePath: options.resolvedFilePath,
+		workspaceLookup: options.workspaceLookup
+	})) {
+		addPackageImportRelativeScopeProblem({
+			config: options.config,
+			importRecord: options.importRecord,
+			owner: options.owner,
+			packageScope,
+			problems: options.problems,
+			resolvedFilePath: options.resolvedFilePath,
+			targetPackageScope: options.workspaceLookup.findNearestPackageScopeInfo(options.resolvedFilePath)
+		});
+		return;
+	}
+	const target = options.workspaceLookup.classifyResolvedPackageTarget({
 		owner: options.owner,
-		owners: options.owners,
-		packages: options.packages,
 		resolvedFilePath: options.resolvedFilePath
 	});
-	if (target.kind === "current-owner") return;
-	if (target.kind === "other-owner") {
-		addPackageImportOtherOwnerProblem({
+	if (target.kind === "current-owner") {
+		if (packageScope && !shouldTreatPackageImportAsPackageTarget(match) && !isResolvedInsidePackageScope({
+			packageScope,
+			resolvedFilePath: options.resolvedFilePath,
+			workspaceLookup: options.workspaceLookup
+		})) addPackageImportRelativeScopeProblem({
 			config: options.config,
 			importRecord: options.importRecord,
 			owner: options.owner,
+			packageScope,
 			problems: options.problems,
-			targetOwner: target.targetOwner,
-			workspacePackage: target.workspacePackage
+			resolvedFilePath: options.resolvedFilePath,
+			targetPackageScope: options.workspaceLookup.findNearestPackageScopeInfo(options.resolvedFilePath)
 		});
 		return;
 	}
-	if (target.kind === "artifact-package") {
-		if (!target.packageInfo.name) {
-			addResolvedPackageWithoutNameProblem({
+	if (target.kind === "other-owner") {
+		if (shouldTreatPackageImportAsPackageTarget(match)) {
+			addPackageImportArtifactAuthorizationProblem({
 				config: options.config,
+				importAuthorityAllowRules: options.importAuthorityAllowRules,
 				importRecord: options.importRecord,
 				owner: options.owner,
 				packageInfo: target.packageInfo,
-				problems: options.problems
+				problems: options.problems,
+				rootPackage: options.rootPackage,
+				workspacePackage: target.workspacePackage
 			});
 			return;
 		}
-		const packageName = getPackageNameForAuthorization({
-			importRecord: options.importRecord,
-			resolvedPackageName: target.packageInfo.name
-		});
-		if (isDependencyAuthorizedBySourceAuthority({
+		addPackageImportOtherOwnerProblem({
 			config: options.config,
-			importAuthorityAllowRules: options.importAuthorityAllowRules,
 			importRecord: options.importRecord,
 			owner: options.owner,
-			packageName,
-			rootPackage: options.rootPackage
-		})) return;
-		addPackageImportAuthorizationProblem({
-			authorityManifestPaths: getDependencyAuthorityManifestPaths({
-				config: options.config,
-				importAuthorityAllowRules: options.importAuthorityAllowRules,
-				importRecord: options.importRecord,
-				owner: options.owner,
-				packageName,
-				rootPackage: options.rootPackage
-			}),
+			problems: options.problems,
+			targetOwner: target.targetOwner,
+			workspacePackage: target.workspacePackage
+		});
+		return;
+	}
+	if (target.kind === "artifact-package") {
+		addPackageImportArtifactAuthorizationProblem({
 			config: options.config,
-			dependencySpecifier: target.packageInfo.name,
+			importAuthorityAllowRules: options.importAuthorityAllowRules,
 			importRecord: options.importRecord,
 			owner: options.owner,
-			packageName,
+			packageInfo: target.packageInfo,
 			problems: options.problems,
+			rootPackage: options.rootPackage,
 			workspacePackage: null
 		});
 		return;
@@ -45831,7 +46702,7 @@ async function addTsconfigGovernanceProblems(options) {
 	for (const configPath of configPaths) {
 		if (shouldSkipGovernedTsconfig(readJsonConfig(options.config, configPath))) continue;
 		options.checks.add();
-		const owner = findOwnerForFile(configPath, options.owners);
+		const owner = options.workspaceLookup.findOwnerForFile(configPath);
 		if (!owner) {
 			options.problems.push([
 				"Tsconfig has no source owner:",
@@ -45845,7 +46716,7 @@ async function addTsconfigGovernanceProblems(options) {
 		projectFileSetsByConfigPath.set(configPath, new Set(project.fileNames));
 		for (const fileName of project.fileNames) {
 			options.checks.add();
-			const fileOwner = findOwnerForFile(fileName, options.owners);
+			const fileOwner = options.workspaceLookup.findOwnerForFile(fileName);
 			if (fileOwner?.packageJsonPath !== owner.packageJsonPath) options.problems.push([
 				"Tsconfig source file set crosses source owner scope:",
 				`  config: ${toRelativePath(options.config.rootDir, configPath)}`,
@@ -46057,9 +46928,9 @@ async function addSourceProjectOwnerProblems(options) {
 			config: options.config,
 			configPath: project.configPath,
 			fileNames: project.fileNames,
-			owners: options.owners,
 			problems: options.problems,
-			role: "declaration leaf"
+			role: "declaration leaf",
+			workspaceLookup: options.workspaceLookup
 		});
 		const typecheckConfigPath = getTypecheckConfigPath(project.configPath);
 		if (!existsSync(typecheckConfigPath)) continue;
@@ -46068,16 +46939,16 @@ async function addSourceProjectOwnerProblems(options) {
 			config: options.config,
 			configPath: typecheckConfigPath,
 			fileNames: (await options.core.tsconfig.getProject(typecheckConfigPath, project)).fileNames,
-			owners: options.owners,
 			problems: options.problems,
-			role: "typecheck companion"
+			role: "typecheck companion",
+			workspaceLookup: options.workspaceLookup
 		});
 	}
 }
 function addRelativeImportProblems(options) {
 	if (!options.resolvedFilePath) return;
-	const sourcePackageScope = findNearestPackageScopeInfo(options.filePath);
-	const targetPackageScope = findNearestPackageScopeInfo(options.resolvedFilePath);
+	const sourcePackageScope = options.workspaceLookup.findNearestPackageScopeInfo(options.filePath);
+	const targetPackageScope = options.workspaceLookup.findNearestPackageScopeInfo(options.resolvedFilePath);
 	if (sourcePackageScope?.packageJsonPath === targetPackageScope?.packageJsonPath) return;
 	addRelativeImportOwnerProblem({
 		config: options.config,
@@ -46176,10 +47047,8 @@ function addResolvedArtifactBarePackageProblems(options) {
 	});
 }
 function addResolvedBarePackageImportProblems(options) {
-	const target = classifyResolvedPackageTarget({
+	const target = options.workspaceLookup.classifyResolvedPackageTarget({
 		owner: options.owner,
-		owners: options.owners,
-		packages: options.packages,
 		resolvedFilePath: options.resolvedFilePath
 	});
 	if (target.kind === "current-owner") return true;
@@ -46216,11 +47085,10 @@ function addBarePackageImportProblems(options) {
 		importAuthorityAllowRules: options.importAuthorityAllowRules,
 		importRecord: options.importRecord,
 		owner: options.owner,
-		owners: options.owners,
-		packages: options.packages,
 		problems: options.problems,
 		resolvedFilePath: options.resolvedFilePath,
-		rootPackage: options.rootPackage
+		rootPackage: options.rootPackage,
+		workspaceLookup: options.workspaceLookup
 	})) return;
 	const workspacePackage = options.packages.find((candidate) => candidate.name === options.fallbackPackageName) ?? null;
 	if (isDependencyAuthorizedBySourceAuthority({
@@ -46257,7 +47125,8 @@ function addImportRecordProblems(options) {
 			importRecord: options.importRecord,
 			owner: options.owner,
 			problems: options.problems,
-			resolvedFilePath
+			resolvedFilePath,
+			workspaceLookup: options.workspaceLookup
 		});
 		return;
 	}
@@ -46266,12 +47135,11 @@ function addImportRecordProblems(options) {
 			config: options.config,
 			importRecord: options.importRecord,
 			owner: options.owner,
-			owners: options.owners,
-			packages: options.packages,
 			problems: options.problems,
 			resolvedFilePath,
 			importAuthorityAllowRules: options.importAuthorityAllowRules,
-			rootPackage: options.rootPackage
+			rootPackage: options.rootPackage,
+			workspaceLookup: options.workspaceLookup
 		});
 		return;
 	}
@@ -46282,16 +47150,16 @@ function addImportRecordProblems(options) {
 		importAuthorityAllowRules: options.importAuthorityAllowRules,
 		importRecord: options.importRecord,
 		owner: options.owner,
-		owners: options.owners,
 		packages: options.packages,
 		problems: options.problems,
 		resolvedFilePath,
-		rootPackage: options.rootPackage
+		rootPackage: options.rootPackage,
+		workspaceLookup: options.workspaceLookup
 	});
 }
 function addSourceImportProblems(options) {
 	for (const { fileNames, project } of options.sourceProjectEntries) for (const filePath of fileNames) {
-		const owner = findOwnerForFile(filePath, options.owners);
+		const owner = options.workspaceLookup.findOwnerForFile(filePath);
 		if (!owner) continue;
 		for (const importRecord of collectImportsFromFile(filePath, options.config.rootDir, options.importAnalysis)) {
 			options.checks.add();
@@ -46302,11 +47170,11 @@ function addSourceImportProblems(options) {
 				importAuthorityAllowRules: options.importAuthorityAllowRules,
 				importRecord,
 				owner,
-				owners: options.owners,
 				packages: options.packages,
 				problems: options.problems,
 				project,
-				rootPackage: options.rootPackage
+				rootPackage: options.rootPackage,
+				workspaceLookup: options.workspaceLookup
 			});
 		}
 	}
@@ -46404,6 +47272,7 @@ async function runSourceCheckImpl(config, options = {}) {
 	const sourceProjectEntries = await createSourceProjectEntries(core, projects);
 	const packages = await preflight.ensureWorkspacePackages();
 	const packageOwners = await preflight.ensurePackageOwners();
+	const workspaceLookup = await preflight.ensureWorkspaceLookupIndex();
 	const workspaceDependencyDeclarations = await preflight.ensureWorkspaceDependencyDeclarations();
 	const rootPackage = findWorkspaceRootPackage({
 		config,
@@ -46424,8 +47293,8 @@ async function runSourceCheckImpl(config, options = {}) {
 		config,
 		configPaths: collectGeneratedSourceConfigPaths(generatedGraph),
 		generatedGraph,
-		owners: packageOwners,
-		problems
+		problems,
+		workspaceLookup
 	});
 	checkItems.record("tsconfig governance");
 	checkItems.start("knip source usage");
@@ -46446,9 +47315,9 @@ async function runSourceCheckImpl(config, options = {}) {
 		checks,
 		config,
 		core,
-		owners: packageOwners,
 		problems,
-		projects
+		projects,
+		workspaceLookup
 	});
 	checkItems.record("source project ownership");
 	checkItems.start("source import authority");
@@ -46468,11 +47337,11 @@ async function runSourceCheckImpl(config, options = {}) {
 		config,
 		importAnalysis,
 		importAuthorityAllowRules,
-		owners: packageOwners,
 		packages,
 		problems,
 		rootPackage,
-		sourceProjectEntries
+		sourceProjectEntries,
+		workspaceLookup
 	});
 	checkItems.record("source import authority");
 	const ownerNamesByManifestPath = createSourceProblemOwnerLookup(packageOwners);
@@ -46939,6 +47808,135 @@ async function runCheckerBuildImpl(options) {
 	});
 	const flowDepth = options.flowDepth ?? 0;
 	const rootConfigPaths = [];
+	if (options.configPath) {
+		const sourceConfigPath = resolveBuildConfigPath({
+			configPath: options.configPath,
+			cwd,
+			rootDir: projectRootDir
+		});
+		const managedTargets = collectManagedDeclarationBuildTargets({
+			allCheckers,
+			generatedGraph,
+			sourceConfigPath
+		});
+		const buildCapableTargets = managedTargets.filter(({ checker }) => getCheckerAdapter(checker.preset)?.execution === "build");
+		const availableCheckers = uniqueSortedStrings(buildCapableTargets.map(({ checker }) => checker.preset));
+		const checkerTargets = options.checker ? buildCapableTargets.filter(({ checker }) => checker.preset === options.checker) : buildCapableTargets;
+		if (checkerTargets.length === 0) {
+			const selectionProblem = options.checker ? formatManagedBuildCheckerSelectionProblem({
+				availableCheckers,
+				projectRootDir,
+				selectedChecker: options.checker,
+				sourceConfigPath
+			}) : managedTargets.length > 0 ? formatTypecheckOnlyBuildProblem({
+				checkers: managedTargets.map(({ checker }) => checker),
+				projectRootDir,
+				sourceConfigPath
+			}) : [
+				"Unmanaged Limina checker build config:",
+				`  config: ${toRelativePath(projectRootDir, sourceConfigPath)}`,
+				"  reason: limina checker build <config> only accepts source configs managed by Limina checker.include.",
+				"  fix: add the owning tsconfig.json entry to checker.include, or use limina build <config> --raw --preset <checker> for a direct raw build."
+			].join("\n");
+			if (shouldLogCheckReport(options.report)) TypecheckLogger.error(formatTypecheckProblemSummaryReport({
+				pluralIssueLabel: "checker build selection issues",
+				problems: [selectionProblem],
+				singularIssueLabel: "checker build selection issue",
+				title: "Checker build summary"
+			}));
+			return {
+				failedTargets: [],
+				failureKind: "target-selection",
+				passed: false,
+				problems: [selectionProblem],
+				projectRootDir,
+				rootConfigPaths,
+				targetResults: []
+			};
+		}
+		const problems = collectCheckerPeerDependencyProblems({
+			checkers: checkerTargets.map(({ checker }) => checker),
+			imports: options.config.config?.imports,
+			projectRootDir,
+			resolvePackage: options.checkerPackageResolver
+		});
+		if (problems.length > 0) {
+			if (shouldLogCheckReport(options.report)) TypecheckLogger.error(formatTypecheckProblemSummaryReport({
+				pluralIssueLabel: "checker build issues",
+				problems,
+				singularIssueLabel: "checker build issue",
+				title: "Checker build summary"
+			}));
+			return {
+				failedTargets: [],
+				failureKind: "peer-dependency",
+				passed: false,
+				problems,
+				projectRootDir,
+				rootConfigPaths,
+				targetResults: []
+			};
+		}
+		const targets = checkerTargets.map(({ buildModule, checker, sourceConfigPath }) => {
+			rootConfigPaths.push(buildModule.path);
+			return {
+				...createCheckerTarget({
+					checker,
+					commandOverride: options.tscCommand,
+					configPath: buildModule.path,
+					executionKind: "build",
+					projectRootDir,
+					watch: options.watch
+				}),
+				sourceConfigPath
+			};
+		});
+		options.flow?.info(`found ${targets.length} checker build target(s)`, { depth: flowDepth + 1 });
+		const targetTasks = new Map(createPlannedCheckerTargetTasks(targets, options.progress, "checker build", projectRootDir));
+		const results = await runBuildTargets(targets, generatedGraph.providerEdges, resolveTypecheckRunner(options), {
+			config: options.config,
+			onTargetResult: (target, result) => {
+				const task = targetTasks.get(target.configPath);
+				if (!task) return;
+				if (result.status === 0) task.pass();
+				else {
+					const suffix = result.error ? formatErrorMessage(result.error) : `exited with code ${result.status}`;
+					task.fail(void 0, { error: suffix });
+				}
+			},
+			onTargetStart: (target) => {
+				if (options.progress) {
+					targetTasks.get(target.configPath)?.start();
+					return;
+				}
+				if (!options.flow) return;
+				targetTasks.set(target.configPath, options.flow.start(getCheckerTargetFlowLabel(target, "checker build", projectRootDir), {
+					collapseOnSuccess: false,
+					depth: flowDepth + 1
+				}));
+			},
+			watch: options.watch
+		});
+		const failedResults = results.filter((result) => result.status !== 0);
+		const failedTargets = collectFailedCheckerTargets(targets, failedResults);
+		const passed = failedResults.length === 0;
+		if (!passed && shouldLogCheckReport(options.report)) TypecheckLogger.error(formatFailedTargetSummaryReport({
+			failedResults,
+			heading: "build checks failed:",
+			pluralIssueLabel: "failed checker build targets",
+			projectRootDir,
+			singularIssueLabel: "failed checker build target",
+			title: "Checker build summary"
+		}));
+		else if (passed && shouldLogCheckReport(options.report) && !options.flow?.interactive) TypecheckLogger.success(`Checked ${targets.length} checker build target(s).`);
+		return {
+			failedTargets,
+			passed,
+			projectRootDir,
+			rootConfigPaths,
+			targetResults: results
+		};
+	}
 	const problems = collectCheckerPeerDependencyProblems({
 		checkers: allCheckers,
 		imports: options.config.config?.imports,
@@ -47116,13 +48114,49 @@ function formatTypecheckOnlyBuildProblem(options) {
 }
 function formatManagedBuildCheckerSelectionProblem(options) {
 	return [
-		"Invalid Limina checker build preset:",
+		`Invalid Limina ${options.commandLabel ?? "checker build"} preset:`,
 		`  config: ${toRelativePath(options.projectRootDir, options.sourceConfigPath)}`,
 		`  preset: ${options.selectedChecker}`,
 		"  reason: --preset must select a build-capable checker preset that reaches this Limina-managed target.",
 		...options.availableCheckers.length > 0 ? ["  available presets:", ...options.availableCheckers.map((checker) => `    - ${checker}`)] : ["  available presets: none"]
 	].join("\n");
 }
+function formatMultipleOutputBuildPresetProblem(options) {
+	return [
+		"Ambiguous Limina output build preset:",
+		`  config: ${toRelativePath(options.projectRootDir, options.sourceConfigPath)}`,
+		"  reason: multiple build-capable checker presets can produce output artifacts for this config.",
+		"  fix: pass --preset with one of the available presets.",
+		"  available presets:",
+		...options.availableCheckers.map((checker) => `    - ${checker}`)
+	].join("\n");
+}
+function formatOutputBuildTargetResolutionProblem(options) {
+	const configLine = `  config: ${toRelativePath(options.projectRootDir, options.sourceConfigPath)}`;
+	if (options.resolutionKind === "unmanaged") return [
+		"Unmanaged Limina output build config:",
+		configLine,
+		"  reason: limina build <config> only accepts source configs managed by Limina checker.include.",
+		"  fix: add the owning tsconfig.json entry to a build-capable checker include, or use limina build <config> --raw --preset <checker> for a direct raw build."
+	].join("\n");
+	if (options.resolutionKind === "outputless-solution") return [
+		"No output-enabled source configs were found under this solution config.",
+		configLine,
+		"  reason: the solution is Limina-managed, but none of its recursive referenced source leaves declare liminaOptions.outputs.",
+		"  fix: Add liminaOptions.outputs to at least one referenced source leaf."
+	].join("\n");
+	if (options.resolutionKind === "outputless-project") return [
+		"Missing Limina output build options:",
+		configLine,
+		"  reason: this Limina-managed source config does not declare liminaOptions.outputs.",
+		"  fix: add liminaOptions.outputs to this source config, or use limina build <config> --raw --preset <checker> for a direct raw build."
+	].join("\n");
+	return formatTypecheckOnlyBuildProblem({
+		checkers: options.matchingCheckers,
+		projectRootDir: options.projectRootDir,
+		sourceConfigPath: options.sourceConfigPath
+	});
+}
 function getBuildTargetDescriptorKey(descriptor) {
 	return `${descriptor.checker.name}\0${descriptor.sourceConfigPath}`;
 }
@@ -47138,7 +48172,7 @@ function createRawBuildChecker(options) {
 		preset: options.preset
 	};
 }
-function collectManagedBuildTargets(options) {
+function collectManagedDeclarationBuildTargets(options) {
 	return options.allCheckers.flatMap((checker) => {
 		const buildModule = options.generatedGraph.sourceToBuild.get(checker.name)?.get(options.sourceConfigPath);
 		if (!buildModule) return [];
@@ -47149,6 +48183,17 @@ function collectManagedBuildTargets(options) {
 		}];
 	});
 }
+function collectManagedOutputBuildTargets(options) {
+	return options.allCheckers.flatMap((checker) => {
+		const buildModule = options.generatedGraph.configToOutputBuild.get(checker.name)?.get(options.sourceConfigPath);
+		if (!buildModule) return [];
+		return [{
+			buildModule,
+			checker,
+			sourceConfigPath: options.sourceConfigPath
+		}];
+	});
+}
 async function resolveBuildTarget(options) {
 	const projectRootDir = normalizeAbsolutePath(options.config.rootDir);
 	const targetConfigPath = resolveBuildConfigPath({
@@ -47157,26 +48202,49 @@ async function resolveBuildTarget(options) {
 		project: options.project,
 		rootDir: projectRootDir
 	});
+	if (options.raw) {
+		if (!options.checker) throw new Error([
+			"Invalid raw build invocation:",
+			`  config: ${toRelativePath(projectRootDir, targetConfigPath)}`,
+			"  reason: limina build --raw requires --preset."
+		].join("\n"));
+		if (targetConfigPath.split(posix.sep).includes(".limina")) throw new Error([
+			"Invalid raw build config:",
+			`  config: ${toRelativePath(projectRootDir, targetConfigPath)}`,
+			"  reason: raw build expects a user-authored tsconfig, not a .limina generated config."
+		].join("\n"));
+		return {
+			checker: options.checker,
+			kind: "raw",
+			targetConfigPath
+		};
+	}
 	const generatedGraph = await (options.core ?? createLiminaCore(options.config)).buildGraph.getGraph();
 	const allCheckers = generatedGraph.checkers;
-	const managedTargets = isOrdinarySourceTypecheckConfigPath(targetConfigPath) ? collectManagedBuildTargets({
+	const declarationTargets = isOrdinarySourceTypecheckConfigPath(targetConfigPath) ? collectManagedDeclarationBuildTargets({
 		allCheckers,
 		generatedGraph,
 		sourceConfigPath: targetConfigPath
 	}) : [];
-	if (managedTargets.length === 0) return {
-		checker: options.checker ?? "tsc",
-		kind: "raw",
-		targetConfigPath
-	};
-	const buildCapableTargets = managedTargets.filter(({ checker }) => getCheckerAdapter(checker.preset)?.execution === "build");
+	const buildCapableTargets = (isOrdinarySourceTypecheckConfigPath(targetConfigPath) ? collectManagedOutputBuildTargets({
+		allCheckers,
+		generatedGraph,
+		sourceConfigPath: targetConfigPath
+	}) : []).filter(({ checker }) => getCheckerAdapter(checker.preset)?.execution === "build");
+	const buildCapableDeclarationTargets = declarationTargets.filter(({ checker }) => getCheckerAdapter(checker.preset)?.execution === "build");
+	const availableCheckers = uniqueSortedStrings(buildCapableTargets.map(({ checker }) => checker.preset));
+	const checkerTargets = options.checker ? buildCapableTargets.filter(({ checker }) => checker.preset === options.checker) : buildCapableTargets;
+	const managedBuildModules = declarationTargets.length > 0;
+	const targetBuildModuleKinds = uniqueSortedStrings(buildCapableDeclarationTargets.map(({ buildModule }) => buildModule.kind));
+	const resolutionKind = checkerTargets.length > 0 ? "managed-output" : managedBuildModules ? buildCapableDeclarationTargets.length === 0 ? "typecheck-only" : targetBuildModuleKinds.includes("solution") ? "outputless-solution" : "outputless-project" : "unmanaged";
 	return {
-		availableCheckers: uniqueSortedStrings(buildCapableTargets.map(({ checker }) => checker.preset)),
+		availableCheckers,
 		allCheckers,
-		checkerTargets: options.checker ? buildCapableTargets.filter(({ checker }) => checker.preset === options.checker) : buildCapableTargets,
+		checkerTargets,
 		generatedGraph,
 		kind: "managed",
-		matchingCheckers: managedTargets.map(({ checker }) => checker),
+		matchingCheckers: declarationTargets.map(({ checker }) => checker),
+		resolutionKind,
 		...options.checker ? { selectedChecker: options.checker } : {},
 		sourceConfigPath: targetConfigPath
 	};
@@ -47306,7 +48374,7 @@ function collectBuildTargetProviderClosure(options) {
 			if (edge.fromChecker !== current.checker.name || edge.fromConfigPath !== current.sourceConfigPath) continue;
 			const checker = checkerByName.get(edge.toChecker);
 			if (!checker || getCheckerAdapter(checker.preset)?.execution !== "build") continue;
-			const buildModule = options.generatedGraph.sourceToBuild.get(checker.name)?.get(edge.toConfigPath);
+			const buildModule = options.generatedGraph.configToOutputBuild.get(checker.name)?.get(edge.toConfigPath);
 			if (!buildModule) continue;
 			const descriptor = {
 				buildModule,
@@ -47330,7 +48398,8 @@ async function runBuildImpl(options) {
 		configPath: options.configPath,
 		core: options.core,
 		cwd,
-		project: options.project
+		project: options.project,
+		raw: options.raw
 	});
 	const flowDepth = options.flowDepth ?? 0;
 	const rootConfigPaths = [];
@@ -47424,11 +48493,36 @@ async function runBuildImpl(options) {
 	if (resolvedTarget.checkerTargets.length === 0) {
 		const selectionProblem = resolvedTarget.selectedChecker ? formatManagedBuildCheckerSelectionProblem({
 			availableCheckers: resolvedTarget.availableCheckers,
+			commandLabel: "build",
 			projectRootDir,
 			selectedChecker: resolvedTarget.selectedChecker,
 			sourceConfigPath: resolvedTarget.sourceConfigPath
-		}) : formatTypecheckOnlyBuildProblem({
-			checkers: resolvedTarget.matchingCheckers,
+		}) : formatOutputBuildTargetResolutionProblem({
+			matchingCheckers: resolvedTarget.matchingCheckers,
+			projectRootDir,
+			resolutionKind: resolvedTarget.resolutionKind,
+			sourceConfigPath: resolvedTarget.sourceConfigPath
+		});
+		if (shouldLogCheckReport(options.report)) TypecheckLogger.error(formatCheckIssueSummaryReport({
+			details: selectionProblem,
+			issueCount: 1,
+			pluralIssueLabel: "build selection issues",
+			singularIssueLabel: "build selection issue",
+			title: "Build summary"
+		}));
+		return {
+			failedTargets: [],
+			failureKind: "target-selection",
+			passed: false,
+			problems: [selectionProblem],
+			projectRootDir,
+			rootConfigPaths,
+			sourceConfigPath: resolvedTarget.sourceConfigPath
+		};
+	}
+	if (!resolvedTarget.selectedChecker && resolvedTarget.checkerTargets.length > 1) {
+		const selectionProblem = formatMultipleOutputBuildPresetProblem({
+			availableCheckers: resolvedTarget.availableCheckers,
 			projectRootDir,
 			sourceConfigPath: resolvedTarget.sourceConfigPath
 		});
@@ -47520,21 +48614,6 @@ async function runBuildImpl(options) {
 	})).filter((result) => result.status !== 0);
 	const failedTargets = collectFailedCheckerTargets(targets, failedResults);
 	const passed = failedResults.length === 0;
-	reportBuildCheckerCombinationWarning({
-		entries: collectBuildGraphCombinationEntries({
-			generatedGraph: resolvedTarget.generatedGraph,
-			projectRootDir,
-			roots: buildTargetDescriptors.map(({ buildModule, checker, sourceConfigPath }) => ({
-				checker,
-				configPath: buildModule.path,
-				entryConfigPath: sourceConfigPath
-			}))
-		}),
-		flow: options.flow,
-		flowDepth,
-		projectRootDir,
-		report: options.report
-	});
 	if (!passed) {
 		if (shouldLogCheckReport(options.report)) TypecheckLogger.error(formatFailedTargetSummaryReport({
 			failedResults,
@@ -47843,7 +48922,7 @@ async function runBuild(options) {
 				failedTargets: result.failedTargets,
 				fallbackReason: "Checker build finished with failures.",
 				failureKind: result.failureKind,
-				fix: "Inspect the checker build output above, then rerun `limina checker build`.",
+				fix: "Inspect the build output above, then rerun `limina build <config>`.",
 				projectRootDir: result.projectRootDir,
 				problems: result.problems,
 				task: "checker:build",
@@ -47868,7 +48947,7 @@ async function runBuild(options) {
 		const issue = createTaskFailureIssue({
 			code: "LIMINA_CHECKER_BUILD_FAILED",
 			detailLines: [formatErrorMessage(error)],
-			fix: "Inspect the build error above, then rerun `limina checker build`.",
+			fix: "Inspect the build error above, then rerun `limina build <config>`.",
 			reason: `Checker build failed: ${formatErrorMessage(error)}.`,
 			rootDir: options.config.rootDir,
 			task: "checker:build",
@@ -47960,32 +49039,44 @@ async function runCheckerTypecheck(options) {
 
 //#endregion
 //#region src/flow/process-renderer.ts
-function findTsxBinary(packageDir) {
-	const tsxBinName = process.platform === "win32" ? "tsx.cmd" : "tsx";
-	return [posix.join(packageDir, "node_modules/.bin", tsxBinName), posix.join(packageDir, "../../node_modules/.bin", tsxBinName)].find((candidate) => existsSync(candidate)) ?? "tsx";
+const requireFromRenderer = createRequire(import.meta.url);
+function resolveTsxCliPath(packageDir) {
+	try {
+		return requireFromRenderer.resolve("tsx/cli");
+	} catch {
+		return [posix.join(packageDir, "node_modules/tsx/dist/cli.mjs"), posix.join(packageDir, "../../node_modules/tsx/dist/cli.mjs")].find((candidate) => existsSync(candidate));
+	}
 }
 function resolveRendererEntry() {
 	const currentDir = fileURLToPath(new URL(".", import.meta.url));
-	const sourceEntries = [posix.resolve(currentDir, "flow/renderer-process.ts"), posix.resolve(process.cwd(), "src/flow/renderer-process.ts")];
+	const sourceEntries = [posix.resolve(currentDir, "renderer-process.ts"), posix.resolve(process.cwd(), "src/flow/renderer-process.ts")];
 	const distEntries = [
 		posix.resolve(currentDir, "flow-renderer-process.js"),
 		posix.resolve(currentDir, "../flow-renderer-process.js"),
 		posix.resolve(process.cwd(), "dist/flow-renderer-process.js")
 	];
 	const sourceEntry = sourceEntries.find((candidate) => existsSync(candidate));
-	if (sourceEntry) return {
-		args: [sourceEntry],
-		command: findTsxBinary(posix.resolve(posix.dirname(sourceEntry), "../.."))
-	};
+	if (sourceEntry) {
+		const tsxCliPath = resolveTsxCliPath(posix.resolve(posix.dirname(sourceEntry), "../.."));
+		if (!tsxCliPath) return;
+		return {
+			args: [tsxCliPath, sourceEntry],
+			command: process.execPath
+		};
+	}
 	const distEntry = distEntries.find((candidate) => existsSync(candidate));
 	if (distEntry) return {
 		args: [distEntry],
 		command: process.execPath
 	};
 }
+function getWriteCallback(args) {
+	if (args.length === 3) return args[2];
+	if (typeof args[1] === "function") return args[1];
+}
 function callWriteCallback(args) {
-	const callback = args.findLast((arg) => typeof arg === "function");
-	if (typeof callback === "function") queueMicrotask(callback);
+	const callback = getWriteCallback(args);
+	if (callback) queueMicrotask(callback);
 }
 var FlowProcessRenderer = class FlowProcessRenderer {
 	#child;
@@ -48018,7 +49109,6 @@ var FlowProcessRenderer = class FlowProcessRenderer {
 		if (!entry) return;
 		const renderer = new FlowProcessRenderer(spawn(entry.command, entry.args, {
 			env: process.env,
-			shell: process.platform === "win32",
 			stdio: [
 				"ignore",
 				"inherit",
@@ -48092,7 +49182,7 @@ var FlowProcessRenderer = class FlowProcessRenderer {
 				callWriteCallback(args);
 				return true;
 			}
-			return Reflect.apply(originalWrite, stream, args);
+			return writeWithFlowArgs(originalWrite, args);
 		});
 		return () => {
 			stream.write = originalWrite;
@@ -48108,15 +49198,48 @@ var FlowProcessRenderer = class FlowProcessRenderer {
 	}
 };
 
+//#endregion
+//#region src/flow/tree-state.ts
+function createFlowTreeNode(message, depth) {
+	return {
+		children: [],
+		depth,
+		message,
+		status: "planned"
+	};
+}
+function appendFlowTreeChild(parent, message, depth) {
+	const childNode = createFlowTreeNode(message, depth);
+	parent.children.push(childNode);
+	return childNode;
+}
+function cloneFlowTreeNode(node) {
+	return {
+		children: node.children.map(cloneFlowTreeNode),
+		depth: node.depth,
+		elapsedTimeMs: node.elapsedTimeMs,
+		message: node.message,
+		status: node.status
+	};
+}
+function skipPlannedTreeDescendants(node) {
+	for (const child of node.children) {
+		if (child.status === "planned") child.status = "skipped";
+		skipPlannedTreeDescendants(child);
+	}
+}
+
 //#endregion
 //#region src/flow.ts
 const CHECK_FLOW_STATUS_ONLY_OPTION = Symbol("limina.checkFlowStatusOnly");
 const DEFAULT_CI_ENV_VALUES = new Set(["1", "true"]);
-const DEFAULT_TERMINAL_COLUMNS = 80;
-const ANSI_ESCAPE = String.fromCodePoint(27);
-const ANSI_PATTERN = new RegExp(String.raw`${ANSI_ESCAPE}\[[\d:;<=>?]*[\u0020-\u002F]*[\u0040-\u007E]`, "gu");
+const FLOW_RENDERER_TEST_ROWS_ENV = "LIMINA_FLOW_RENDERER_TEST_ROWS";
 function isCiEnvironment(env) {
-	return DEFAULT_CI_ENV_VALUES.has(String(env.CI).toLowerCase());
+	return DEFAULT_CI_ENV_VALUES.has(String(env.CI).toLowerCase()) || DEFAULT_CI_ENV_VALUES.has(String(env.CODEX_CI).toLowerCase());
+}
+function supportsInteractiveTerminal(env, stdout) {
+	if (!stdout.isTTY || isCiEnvironment(env)) return false;
+	return String(env.TERM).toLowerCase() !== "dumb";
 }
 function formatFailureMessage(message, error) {
 	if (error === void 0) return message;
@@ -48126,22 +49249,27 @@ function formatFailureMessage(message, error) {
 function writeLine(output, message) {
 	output.write(`${message}\n`);
 }
-function stripControlSequences(text) {
-	return text.replaceAll(ANSI_PATTERN, "").replaceAll("\r", "");
-}
-function isTreeNodeTerminal(node) {
-	return node.status === "failed" || node.status === "passed" || node.status === "skipped";
+function createTaskFinishOptions(options, depth, startTime) {
+	return {
+		...options,
+		depth,
+		elapsedTimeMs: options?.elapsedTimeMs ?? performance.now() - startTime
+	};
 }
-function areTreeNodeDescendantsTerminal(node) {
-	return node.children.every((child) => isTreeNodeTerminal(child) && areTreeNodeDescendantsTerminal(child));
+function readPositiveInteger(value) {
+	if (value === void 0) return;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
 }
 var LiminaFlowReporter = class {
 	#clack;
+	#env;
 	#interactive;
 	#output;
 	#statusOnly;
 	#stderr;
 	#stdout;
+	#terminalFrame;
 	#tracksProcessWrites;
 	#interactiveHistory = [];
 	#treeRoots = [];
@@ -48155,13 +49283,12 @@ var LiminaFlowReporter = class {
 	#spinnerFrameIndex = 0;
 	#spinnerTimer;
 	#trackedTaskCount = 0;
-	#terminalColumn = 0;
-	#terminalLineCount = 0;
 	constructor(options = {}) {
 		const env = options.env ?? process.env;
 		const stdout = options.stdout ?? process.stdout;
 		this.#statusOnly = options[CHECK_FLOW_STATUS_ONLY_OPTION] === true;
-		this.#interactive = options.forceTty ?? Boolean(stdout.isTTY && !isCiEnvironment(env));
+		this.#env = env;
+		this.#interactive = options.forceTty ?? supportsInteractiveTerminal(env, stdout);
 		this.#clack = options.clack ?? dist_exports;
 		this.#output = options.output ?? { write: (message) => {
 			if (typeof stdout.write === "function") {
@@ -48172,6 +49299,7 @@ var LiminaFlowReporter = class {
 		} };
 		this.#stdout = stdout;
 		this.#stderr = options.stderr ?? process.stderr;
+		this.#terminalFrame = new TerminalFrameTracker(() => this.#stdout?.columns ?? DEFAULT_TERMINAL_COLUMNS);
 		this.#processRenderer = this.#createProcessRenderer(options);
 		this.#tracksProcessWrites = this.#interactive && !this.#statusOnly && options.output === void 0 && !this.#processRenderer;
 	}
@@ -48189,20 +49317,21 @@ var LiminaFlowReporter = class {
 		if (!this.#interactive || rendererMode === "inline" || options.output !== void 0 || options.stdout !== void 0 || options.stderr !== void 0 || options.clack !== void 0) return;
 		return FlowProcessRenderer.start();
 	}
-	#cloneTreeNode(node) {
-		return {
-			children: node.children.map((child) => this.#cloneTreeNode(child)),
-			depth: node.depth,
-			elapsedTimeMs: node.elapsedTimeMs,
-			message: node.message,
-			status: node.status
-		};
-	}
 	#createRenderSnapshot() {
+		const terminalDimensions = this.#getTerminalDimensions();
+		const hasTerminalDimensions = terminalDimensions.columns !== void 0 || terminalDimensions.rows !== void 0;
 		return {
+			...this.#statusOnly ? { compactMode: "check-flow" } : {},
 			entries: [...this.#interactiveHistory, ...this.#processTransientHistory.map(({ entry }) => entry)],
 			...this.#outroMessage === void 0 ? {} : { outroMessage: this.#outroMessage },
-			treeRoots: this.#treeRoots.map((root) => this.#cloneTreeNode(root))
+			...hasTerminalDimensions ? { terminalDimensions } : {},
+			treeRoots: this.#treeRoots.map(cloneFlowTreeNode)
+		};
+	}
+	#getTerminalDimensions() {
+		return {
+			columns: this.#stdout?.columns,
+			rows: readPositiveInteger(this.#env[FLOW_RENDERER_TEST_ROWS_ENV]) ?? this.#stdout?.rows
 		};
 	}
 	#sendProcessSnapshot() {
@@ -48210,7 +49339,8 @@ var LiminaFlowReporter = class {
 		this.#processRenderer.sendSnapshot(this.#createRenderSnapshot());
 	}
 	#writeRenderSnapshotInline(snapshot) {
-		for (const line of renderSnapshotLines(snapshot, this.#spinnerFrameIndex)) writeLine(this.#output, line);
+		const lines = renderSnapshotLinesForTerminal(snapshot, this.#spinnerFrameIndex, this.#getTerminalDimensions());
+		for (const line of lines) writeLine(this.#output, line);
 	}
 	intro(message) {
 		if (this.#interactive) {
@@ -48227,7 +49357,7 @@ var LiminaFlowReporter = class {
 				kind: "line",
 				line: `┌  ${message}`
 			});
-			this.#recordTerminalWrite(`${message}\n`);
+			this.#terminalFrame.record(`${message}\n`);
 			return;
 		}
 		writeLine(this.#output, `[start] ${message}`);
@@ -48239,6 +49369,11 @@ var LiminaFlowReporter = class {
 				this.#sendProcessSnapshot();
 				return;
 			}
+			if (this.#statusOnly) {
+				this.#outroMessage = message;
+				this.#redrawInteractiveHistory();
+				return;
+			}
 			this.#clack.outro(message);
 			return;
 		}
@@ -48249,7 +49384,7 @@ var LiminaFlowReporter = class {
 		const collapseOnSuccess = this.#statusOnly ? false : options.collapseOnSuccess ?? true;
 		const shouldTrackTask = this.#interactive && collapseOnSuccess;
 		const persistStart = !shouldTrackTask && this.#trackedTaskCount === 0;
-		const startLine = this.#terminalLineCount;
+		const startLine = this.#terminalFrame.lineCount;
 		const startTime = performance.now();
 		const processTransientTaskId = shouldTrackTask && this.#processRenderer ? this.#nextProcessTransientTaskId++ : void 0;
 		let completed = false;
@@ -48265,11 +49400,7 @@ var LiminaFlowReporter = class {
 		};
 		return {
 			fail: (nextMessage, nextOptions) => {
-				const failOptions = {
-					...nextOptions,
-					depth,
-					elapsedTimeMs: nextOptions?.elapsedTimeMs ?? performance.now() - startTime
-				};
+				const failOptions = createTaskFinishOptions(nextOptions, depth, startTime);
 				const failMessage = this.#statusOnly ? message : nextMessage ?? message;
 				if (!shouldTrackTask && this.#interactive && persistedStartIndex !== void 0) {
 					this.#replaceInteractiveHistoryLine(persistedStartIndex, "fail", this.#formatFailureMessage(failMessage, nextOptions), failOptions);
@@ -48278,7 +49409,6 @@ var LiminaFlowReporter = class {
 					return;
 				}
 				this.#emit("fail", this.#formatFailureMessage(failMessage, nextOptions), failOptions, { persistInteractive: true });
-				if (!this.#interactive) return;
 				finishTrackedTask();
 			},
 			info: (nextMessage, nextOptions) => {
@@ -48288,11 +49418,7 @@ var LiminaFlowReporter = class {
 				});
 			},
 			pass: (nextMessage, nextOptions) => {
-				const passOptions = {
-					...nextOptions,
-					depth,
-					elapsedTimeMs: nextOptions?.elapsedTimeMs ?? performance.now() - startTime
-				};
+				const passOptions = createTaskFinishOptions(nextOptions, depth, startTime);
 				const persistInteractive = shouldTrackTask ? this.#trackedTaskCount <= 1 : this.#trackedTaskCount === 0;
 				if (shouldTrackTask) if (this.#processRenderer?.active) {
 					this.#processTransientHistory = this.#processTransientHistory.filter((entry) => entry.taskId !== processTransientTaskId);
@@ -48308,11 +49434,7 @@ var LiminaFlowReporter = class {
 				finishTrackedTask();
 			},
 			skip: (nextMessage, nextOptions) => {
-				const skipOptions = {
-					...nextOptions,
-					depth,
-					elapsedTimeMs: nextOptions?.elapsedTimeMs ?? performance.now() - startTime
-				};
+				const skipOptions = createTaskFinishOptions(nextOptions, depth, startTime);
 				if (!shouldTrackTask && this.#interactive && persistedStartIndex !== void 0) {
 					this.#replaceInteractiveHistoryLine(persistedStartIndex, "skip", nextMessage ?? message, skipOptions);
 					this.#redrawInteractiveHistory();
@@ -48331,12 +49453,7 @@ var LiminaFlowReporter = class {
 		};
 	}
 	tree(message, options = {}) {
-		const node = {
-			children: [],
-			depth: options.depth ?? 0,
-			message,
-			status: "planned"
-		};
+		const node = createFlowTreeNode(message, options.depth ?? 0);
 		this.#treeRoots.push(node);
 		this.#ensureInteractiveTree();
 		this.#renderTreeChange();
@@ -48370,7 +49487,7 @@ var LiminaFlowReporter = class {
 		}
 		const stream = options.stream === "stderr" ? this.#stderr : this.#stdout;
 		if (this.#interactive && this.#tracksProcessWrites && typeof stream?.write === "function") {
-			if (this.#restoreWriteStreams === void 0) this.#recordTerminalWrite(message);
+			if (this.#restoreWriteStreams === void 0) this.#terminalFrame.record(message);
 			stream.write(message);
 			return;
 		}
@@ -48437,8 +49554,12 @@ var LiminaFlowReporter = class {
 	#beginTerminalTracking() {
 		this.#trackedTaskCount += 1;
 		if (this.#trackedTaskCount > 1 || !this.#tracksProcessWrites) return;
-		const restoreStdout = this.#patchWriteStream(this.#stdout);
-		const restoreStderr = this.#patchWriteStream(this.#stderr);
+		const restoreStdout = patchWriteStream(this.#stdout, (chunk) => {
+			this.#terminalFrame.record(chunk);
+		});
+		const restoreStderr = patchWriteStream(this.#stderr, (chunk) => {
+			this.#terminalFrame.record(chunk);
+		});
 		this.#restoreWriteStreams = () => {
 			restoreStdout?.();
 			restoreStderr?.();
@@ -48446,64 +49567,30 @@ var LiminaFlowReporter = class {
 		};
 	}
 	#clearInteractiveTaskBlock(startLine, options = {}) {
-		const linesToClear = this.#terminalLineCount - startLine;
+		const linesToClear = this.#terminalFrame.lineCount - startLine;
 		if (linesToClear <= 0) return;
 		if (options.redrawHistory) {
 			this.#redrawInteractiveHistory();
 			return;
 		}
 		this.#writeControl(`\r\u001B[${linesToClear}A\u001B[J`);
-		this.#terminalLineCount = startLine;
-		this.#terminalColumn = 0;
+		this.#terminalFrame.setLineCount(startLine);
 	}
 	#endTerminalTracking() {
 		this.#trackedTaskCount = Math.max(0, this.#trackedTaskCount - 1);
 		if (this.#trackedTaskCount === 0) this.#restoreWriteStreams?.();
 	}
-	#patchWriteStream(stream) {
-		if (typeof stream?.write !== "function") return;
-		const originalWrite = stream.write;
-		stream.write = (...args) => {
-			this.#recordTerminalWrite(args[0]);
-			return Reflect.apply(originalWrite, stream, args);
-		};
-		return () => {
-			stream.write = originalWrite;
-		};
-	}
-	#recordTerminalWrite(chunk) {
-		const text = stripControlSequences(toWritableText(chunk));
-		const columns = Math.max(1, this.#stdout?.columns ?? DEFAULT_TERMINAL_COLUMNS);
-		for (const char of text) {
-			if (char === "\n") {
-				this.#terminalLineCount += 1;
-				this.#terminalColumn = 0;
-				continue;
-			}
-			this.#terminalColumn += 1;
-			if (this.#terminalColumn >= columns) {
-				this.#terminalLineCount += 1;
-				this.#terminalColumn = 0;
-			}
-		}
-	}
 	#redrawInteractiveHistory() {
 		if (this.#processRenderer?.active) {
 			this.#sendProcessSnapshot();
 			return;
 		}
-		if (this.#terminalLineCount > 0) this.#writeControl(`\r\u001B[${this.#terminalLineCount}A\u001B[J`);
-		this.#terminalLineCount = 0;
-		this.#terminalColumn = 0;
-		for (const entry of this.#interactiveHistory) {
-			const lines = entry.kind === "line" ? [entry.line] : entry.kind === "flow-line" ? [this.#renderInteractiveHistoryFlowLine(entry)] : this.#renderTreeLines();
-			for (const line of lines) writeLine({ write: (message) => {
-				this.#writeTracked(message, { forceRecord: this.#restoreWriteStreams === void 0 });
-			} }, line);
-		}
-	}
-	#renderInteractiveHistoryFlowLine(entry) {
-		return this.#formatInteractiveLine(entry.status, formatMessageWithElapsed(entry.message, entry.elapsedTimeMs), entry.depth);
+		if (this.#terminalFrame.lineCount > 0) this.#writeControl(`\r\u001B[${this.#terminalFrame.lineCount}A\u001B[J`);
+		this.#terminalFrame.reset();
+		const frameLines = renderSnapshotLinesForTerminal(this.#createRenderSnapshot(), this.#spinnerFrameIndex, this.#getTerminalDimensions());
+		for (const line of frameLines) writeLine({ write: (message) => {
+			this.#writeTracked(message, { forceRecord: this.#restoreWriteStreams === void 0 });
+		} }, line);
 	}
 	#formatInteractiveLine(status, message, depth) {
 		return formatInteractiveLine(status, message, depth, this.#spinnerFrameIndex);
@@ -48530,10 +49617,12 @@ var LiminaFlowReporter = class {
 	#createTreeNodeHandle(node) {
 		return {
 			child: (message, options = {}) => {
-				return this.#createTreeNodeHandle(this.#appendTreeChild(node, message, options, { redraw: true }));
+				const childNode = appendFlowTreeChild(node, message, options.depth ?? node.depth + 1);
+				this.#renderTreeChange();
+				return this.#createTreeNodeHandle(childNode);
 			},
 			children: (messages, options = {}) => {
-				const childNodes = messages.map((message) => this.#appendTreeChild(node, message, options, { redraw: false }));
+				const childNodes = messages.map((message) => appendFlowTreeChild(node, message, options.depth ?? node.depth + 1));
 				if (childNodes.length > 0) this.#renderTreeChange();
 				return childNodes.map((childNode) => this.#createTreeNodeHandle(childNode));
 			},
@@ -48563,25 +49652,13 @@ var LiminaFlowReporter = class {
 			}
 		};
 	}
-	#appendTreeChild(parent, message, options, meta) {
-		const childNode = {
-			children: [],
-			depth: options.depth ?? parent.depth + 1,
-			message,
-			parent,
-			status: "planned"
-		};
-		parent.children.push(childNode);
-		if (meta.redraw) this.#renderTreeChange();
-		return childNode;
-	}
 	#ensureInteractiveTree() {
 		if (!this.#interactive || this.#hasInteractiveTree) return;
 		this.#interactiveHistory.push({ kind: "tree" });
 		this.#hasInteractiveTree = true;
 	}
 	#finishTreeNode(node, status, message, options) {
-		this.#skipPlannedTreeDescendants(node);
+		skipPlannedTreeDescendants(node);
 		if (message) node.message = status === "failed" ? this.#formatFailureMessage(message, options) : message;
 		else if (status === "failed") node.message = this.#formatFailureMessage(node.message, options);
 		if (options?.depth !== void 0) node.depth = options.depth;
@@ -48598,12 +49675,6 @@ var LiminaFlowReporter = class {
 		}
 		this.#renderTreeChange();
 	}
-	#skipPlannedTreeDescendants(node) {
-		for (const child of node.children) {
-			if (child.status === "planned") child.status = "skipped";
-			this.#skipPlannedTreeDescendants(child);
-		}
-	}
 	#renderTreeChange() {
 		if (!this.#interactive) return;
 		if (this.#processRenderer?.active) {
@@ -48613,13 +49684,6 @@ var LiminaFlowReporter = class {
 		this.#syncSpinnerTimer();
 		this.#redrawInteractiveHistory();
 	}
-	#renderTreeLines() {
-		return this.#treeRoots.flatMap((root) => this.#renderTreeNodeLines(root));
-	}
-	#renderTreeNodeLines(node) {
-		const elapsedTimeMs = isTreeNodeTerminal(node) && areTreeNodeDescendantsTerminal(node) ? node.elapsedTimeMs : void 0;
-		return [this.#formatInteractiveLine(toTreeFlowStatus(node.status), formatMessageWithElapsed(node.message, elapsedTimeMs), node.depth), ...node.children.flatMap((child) => this.#renderTreeNodeLines(child))];
-	}
 	#hasRunningInteractiveWork() {
 		return hasRunningSnapshotWork(this.#createRenderSnapshot());
 	}
@@ -48646,7 +49710,7 @@ var LiminaFlowReporter = class {
 		this.#output.write(message);
 	}
 	#writeTracked(message, options = {}) {
-		if (options.forceRecord || !this.#tracksProcessWrites) this.#recordTerminalWrite(message);
+		if (options.forceRecord || !this.#tracksProcessWrites) this.#terminalFrame.record(message);
 		this.#output.write(message);
 	}
 };
@@ -49549,10 +50613,10 @@ function parsePackageTool(tool) {
 	if (tool === "all" || tool === "publint" || tool === "attw" || tool === "boundary") return tool;
 	throw new Error(`Invalid package check --tool "${tool}". Expected one of: all, publint, attw, boundary.`);
 }
-function parseBuildPreset(preset) {
+function parseBuildPreset(preset, commandLabel = "checker build") {
 	if (!preset) return;
 	if (preset === "tsc" || preset === "vue-tsc" || preset === "tsgo") return preset;
-	throw new Error(`Invalid checker build --preset "${preset}". Expected one of: tsc, vue-tsc, tsgo.`);
+	throw new Error(`Invalid ${commandLabel} --preset "${preset}". Expected one of: tsc, vue-tsc, tsgo.`);
 }
 function rejectUnknownCheckerOptions(flags) {
 	if (flags.checker !== void 0) throw new Error("Unknown option: --checker. Use --preset instead.");
@@ -49570,9 +50634,25 @@ function rejectUnknownCheckerOptions(flags) {
 	]);
 	for (const option of Object.keys(flags)) if (!knownOptions.has(option)) throw new Error(`Unknown option: --${option}.`);
 }
+function rejectUnknownBuildOptions(flags) {
+	const knownOptions = new Set([
+		"--",
+		"config",
+		"mode",
+		"preset",
+		"raw",
+		"verbose",
+		"w",
+		"watch"
+	]);
+	for (const option of Object.keys(flags)) if (!knownOptions.has(option)) throw new Error(`Unknown option: --${option}.`);
+}
 function getCheckerWatchFlag(flags) {
 	return flags.watch ?? flags.w;
 }
+function getBuildWatchFlag(flags) {
+	return flags.watch ?? flags.w;
+}
 function parsePackageAttwProfile(profile) {
 	if (!profile) return;
 	if (profile === "strict" || profile === "node16" || profile === "esm-only") return profile;
@@ -49937,6 +51017,35 @@ function createLiminaCli() {
 		if (!passed) process.exitCode = 1;
 		await closeCliFlow(flow, passed ? "limina source passed" : "limina source failed");
 	});
+	cli.command("build <config>", "Build user-facing artifacts").option("--preset <preset>", "Build checker preset: tsc, vue-tsc, or tsgo").option("--raw", "Run the selected checker directly against the config").option("-w, --watch", "Watch input files and rebuild on changes").option("--verbose", "Show full build issue details").allowUnknownOptions().action(async (configPath, flags) => {
+		rejectUnknownBuildOptions(flags);
+		const watch = getBuildWatchFlag(flags);
+		if (flags.raw && !flags.preset) throw new Error("limina build --raw requires --preset.");
+		const checker = parseBuildPreset(flags.preset, "build");
+		const flow = createCliFlow();
+		flow.intro("limina build");
+		const config = await load(flags, "build");
+		await writeNotRunCheckIssueSnapshot({
+			command: "limina build",
+			rootDir: config.rootDir
+		});
+		const result = await runBuild({
+			checker,
+			clearScreen: false,
+			config,
+			configPath,
+			cwd: process.cwd(),
+			flow,
+			raw: flags.raw,
+			report: {
+				command: "limina build",
+				verbose: flags.verbose
+			},
+			watch
+		});
+		if (!result.passed) process.exitCode = 1;
+		await closeCliFlow(flow, result.passed ? "limina build passed" : "limina build failed");
+	});
 	cli.command("checker <action> [config]", "Run checker build or typecheck entries").option("--preset <preset>", "Build checker preset: tsc, vue-tsc, or tsgo").option("-w, --watch", "Watch input files and rebuild on changes").option("--verbose", "Show full checker issue details").allowUnknownOptions().action(async (action, configPath, flags) => {
 		rejectUnknownCheckerOptions(flags);
 		if (action !== "typecheck" && action !== "build") throw new Error(`Unknown checker action "${action}". Expected build or typecheck.`);
@@ -49951,19 +51060,12 @@ function createLiminaCli() {
 				command: "limina checker build",
 				rootDir: config.rootDir
 			});
-			const result = configPath ? await runBuild({
-				checker: parseBuildPreset(flags.preset),
-				clearScreen: false,
-				config,
-				configPath,
-				cwd: process.cwd(),
-				flow,
-				report: {
-					command: "limina checker build",
-					verbose: flags.verbose
-				},
-				watch
-			}) : await runCheckerBuild({
+			const result = await runCheckerBuild({
+				...configPath ? {
+					checker: parseBuildPreset(flags.preset),
+					configPath,
+					watch
+				} : {},
 				clearScreen: false,
 				config,
 				cwd: process.cwd(),