limina 0.0.1 → 0.0.2

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

@@ -1,20 +1,21 @@
-import { c as getCheckerAdapter, h as toRelativePath, l as isPathInsideDirectory, o as collectMissingCheckerPeerDependencies, r as getActiveCheckers, s as formatMissingCheckerPeerDependencies, u as normalizeAbsolutePath } from "./dep-jgc7X0zw.js";
-import { builtinModules } from "node:module";
-import { createElapsedTimer, formatErrorMessage, formatErrorMessage as formatErrorMessage$1 } from "@docs-islands/logger/helper";
+import { c as getCheckerAdapter, h as toRelativePath, l as isPathInsideDirectory, m as toPosixPath, o as collectMissingCheckerPeerDependencies, r as getActiveCheckers, s as formatMissingCheckerPeerDependencies, u as normalizeAbsolutePath } from "./dep-jgc7X0zw.js";
+import { builtinModules, createRequire } from "node:module";
+import { createElapsedTimer, formatErrorMessage, formatErrorMessage as formatErrorMessage$1 } from "logaria/helper";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import ts from "typescript";
 import { execFile, spawn } from "node:child_process";
 import { glob } from "tinyglobby";
-import { createLogger } from "@docs-islands/logger";
+import { createLogger } from "logaria";
 import readline from "node:readline";
-import { availableParallelism } from "node:os";
 import * as prompts from "@clack/prompts";
+import { mkdir, writeFile } from "node:fs/promises";
+import { parse } from "yaml";
+import { availableParallelism } from "node:os";
 
 //#region src/tsconfig.ts
 const dtsConfigFilePattern = /^tsconfig(?:\..+)?\.dts\.json$/u;
 const buildGraphConfigFilePattern = /^tsconfig(?:\..+)?\.build\.json$/u;
-const deprecatedGraphConfigFilePattern = /^tsconfig(?:\..+)?\.graph\.json$/u;
 const generatedConfigFilePattern = /^tsconfig(?:\..+)?\.paths\.generated\.json$/u;
 const baseConfigFilePattern = /^tsconfig(?:\..+)?\.base\.json$/u;
 const checkConfigFilePattern = /^tsconfig(?:\..+)?\.check\.json$/u;
@@ -161,11 +162,8 @@ function getDtsCompanionConfigPath(dtsConfigPath) {
 function isBuildGraphConfigPath(configPath) {
 	return buildGraphConfigFilePattern.test(path.basename(configPath));
 }
-function isDeprecatedGraphConfigPath(configPath) {
-	return deprecatedGraphConfigFilePattern.test(path.basename(configPath));
-}
 function isReservedTypeScriptConfigFile(fileName) {
-	return dtsConfigFilePattern.test(fileName) || buildGraphConfigFilePattern.test(fileName) || deprecatedGraphConfigFilePattern.test(fileName) || generatedConfigFilePattern.test(fileName) || baseConfigFilePattern.test(fileName) || checkConfigFilePattern.test(fileName);
+	return dtsConfigFilePattern.test(fileName) || buildGraphConfigFilePattern.test(fileName) || generatedConfigFilePattern.test(fileName) || baseConfigFilePattern.test(fileName) || checkConfigFilePattern.test(fileName);
 }
 function isOrdinaryTypecheckConfigPath(configPath) {
 	const fileName = path.basename(configPath);
@@ -269,13 +267,7 @@ function collectGraphProjectRouteFromRoot(options) {
 	}));
 	const formatConfigPath = (configPath) => toRelativePath(options.rootDir, configPath);
 	problems.push(...rootReferences.problems);
-	if (isDeprecatedGraphConfigPath(rootGraphConfigPath)) problems.push([
-		"Checker entry uses a deprecated tsconfig name:",
-		`  config: ${formatConfigPath(rootGraphConfigPath)}`,
-		"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-		"  fix: rename the checker entry to tsconfig*.build.json."
-	].join("\n"));
-	else if (!isBuildGraphConfigPath(rootGraphConfigPath) && !isDtsConfigPath(rootGraphConfigPath)) problems.push([
+	if (!isBuildGraphConfigPath(rootGraphConfigPath) && !isDtsConfigPath(rootGraphConfigPath)) problems.push([
 		"Invalid checker entry config:",
 		`  config: ${formatConfigPath(rootGraphConfigPath)}`,
 		"  reason: checker entries should point to a tsconfig*.build.json graph aggregator or a direct tsconfig*.dts.json declaration leaf."
@@ -287,17 +279,6 @@ function collectGraphProjectRouteFromRoot(options) {
 	for (const { projectPath } of queue) seen.add(projectPath);
 	for (const { projectPath, rawReferencePath, referrerPath } of queue) {
 		if (!projectPath) continue;
-		if (isDeprecatedGraphConfigPath(projectPath)) {
-			problems.push([
-				"Deprecated checker entry reference:",
-				`  from: ${formatConfigPath(referrerPath)}`,
-				`  reference: ${rawReferencePath}`,
-				`  resolved: ${formatConfigPath(projectPath)}`,
-				"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-				"  fix: rename the referenced config to tsconfig*.build.json and update this reference."
-			].join("\n"));
-			continue;
-		}
 		if (!existsSync(projectPath)) {
 			problems.push([
 				"Checker entry references a missing tsconfig:",
@@ -343,16 +324,6 @@ function collectGraphProjectRoutes(config) {
 	for (const checker of getActiveCheckers(config)) {
 		if (!getCheckerAdapter(checker.preset)?.graph) continue;
 		const rootConfigPath = resolveProjectConfigPath(config.rootDir, checker.entry);
-		if (isDeprecatedGraphConfigPath(rootConfigPath)) {
-			problems.push([
-				"Checker graph entry uses a deprecated tsconfig name:",
-				`  checker: ${checker.name}`,
-				`  config: ${toRelativePath(config.rootDir, rootConfigPath)}`,
-				"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-				"  fix: rename the checker entry to tsconfig*.build.json."
-			].join("\n"));
-			continue;
-		}
 		if (!existsSync(rootConfigPath)) {
 			problems.push([
 				"Checker graph entry references a missing tsconfig:",
@@ -382,16 +353,6 @@ function collectCheckerEntryProjectRoutes(config) {
 	const problems = [];
 	for (const checker of getActiveCheckers(config)) {
 		const rootConfigPath = resolveProjectConfigPath(config.rootDir, checker.entry);
-		if (isDeprecatedGraphConfigPath(rootConfigPath)) {
-			problems.push([
-				"Checker entry uses a deprecated tsconfig name:",
-				`  checker: ${checker.name}`,
-				`  config: ${toRelativePath(config.rootDir, rootConfigPath)}`,
-				"  reason: tsconfig*.graph.json has been renamed to tsconfig*.build.json for declaration build graph aggregators.",
-				"  fix: rename the checker entry to tsconfig*.build.json."
-			].join("\n"));
-			continue;
-		}
 		if (!existsSync(rootConfigPath)) {
 			problems.push([
 				"Checker entry references a missing tsconfig:",
@@ -441,7 +402,7 @@ function formatReferences(rootDir, references) {
 
 //#endregion
 //#region src/workspace.ts
-const pnpmWorkspaceFileName = "pnpm-workspace.yaml";
+const pnpmWorkspaceFileName$1 = "pnpm-workspace.yaml";
 const pnpmWorkspaceListTimeoutMs = 3e3;
 function readJsonFile(filePath) {
 	return JSON.parse(readFileSync(filePath, "utf8"));
@@ -488,7 +449,7 @@ function collectWorkspacePatterns(config) {
 		const rootPackageJson = readJsonFile(rootPackageJsonPath);
 		if (Array.isArray(rootPackageJson.workspaces)) for (const pattern of rootPackageJson.workspaces) patterns.add(pattern);
 	}
-	const workspacePath = path.join(config.rootDir, pnpmWorkspaceFileName);
+	const workspacePath = path.join(config.rootDir, pnpmWorkspaceFileName$1);
 	if (existsSync(workspacePath)) for (const pattern of collectPnpmWorkspacePatterns(readFileSync(workspacePath, "utf8"))) patterns.add(pattern);
 	return [...patterns].sort();
 }
@@ -663,7 +624,7 @@ function collectImporters(config, packages) {
 
 //#endregion
 //#region src/graph-context.ts
-function isRelativeSpecifier(specifier) {
+function isRelativeSpecifier$1(specifier) {
 	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
 }
 function isDtsProjectConfig(configPath) {
@@ -779,9 +740,6 @@ function chooseOwningProject(projectPaths) {
 function findPackageForFile(filePath, packages) {
 	return [...packages].sort((left, right) => right.directory.length - left.directory.length).find((workspacePackage) => isPathInsideDirectory(filePath, workspacePackage.directory)) ?? null;
 }
-function isWorkspacePackageFile(filePath, packages) {
-	return packages.some((workspacePackage) => isPathInsideDirectory(filePath, workspacePackage.directory));
-}
 function findImporterForFile(filePath, importers) {
 	return importers.find((importer) => isPathInsideDirectory(filePath, importer.directory)) ?? null;
 }
@@ -834,6 +792,60 @@ function formatUnknownValue(value) {
 function addRuleEntryConfigProblem(problems, details) {
 	problems.push(["Invalid graph rule config:", ...details].join("\n"));
 }
+function isUrlOrDataOrFileSpecifier$1(specifier) {
+	return specifier.startsWith("data:") || specifier.startsWith("file:") || specifier.startsWith("http:") || specifier.startsWith("https:");
+}
+function isRelativeSpecifier(specifier) {
+	return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function isPackageImportPattern(name) {
+	return name.startsWith("#");
+}
+function matchWildcardPattern(pattern, value) {
+	if (pattern === value) return true;
+	const wildcardIndex = pattern.indexOf("*");
+	if (wildcardIndex === -1) return false;
+	const prefix = pattern.slice(0, wildcardIndex);
+	const suffix = pattern.slice(wildcardIndex + 1);
+	return value.startsWith(prefix) && value.endsWith(suffix);
+}
+function getNodeBuiltinRuleName(name) {
+	if (name === "node:*") return {
+		matchAllNodeBuiltins: true,
+		normalizedName: "*"
+	};
+	const normalizedName = name.startsWith("node:") ? name.slice(5) : name;
+	if (!nodeBuiltinNames.has(normalizedName)) return null;
+	return {
+		matchAllNodeBuiltins: false,
+		normalizedName
+	};
+}
+function createNormalizedDep(name, reason) {
+	const nodeBuiltin = getNodeBuiltinRuleName(name);
+	if (nodeBuiltin) return {
+		kind: "node-builtin",
+		matchAllNodeBuiltins: nodeBuiltin.matchAllNodeBuiltins,
+		name,
+		normalizedName: nodeBuiltin.normalizedName,
+		reason
+	};
+	if (isPackageImportPattern(name)) return {
+		kind: "package-import",
+		matchAllNodeBuiltins: false,
+		name,
+		normalizedName: name,
+		reason
+	};
+	if (isRelativeSpecifier(name) || isUrlOrDataOrFileSpecifier$1(name) || path.isAbsolute(name) || getPackageRootSpecifier(name) !== name) return null;
+	return {
+		kind: "package",
+		matchAllNodeBuiltins: false,
+		name,
+		normalizedName: name,
+		reason
+	};
+}
 function getRulesRecord(config, problems) {
 	const rules = config.graph?.rules;
 	if (rules === void 0) return {};
@@ -900,57 +912,13 @@ function addNormalizedRuleRef(options) {
 	});
 	options.refsByLabel.set(options.label, refs);
 }
-function addNormalizedWorkspaceDep(options) {
-	const field = `${options.fieldPrefix}[${options.index}]`;
-	if (!isPlainRecord(options.entry)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}`,
-			`  value: ${formatUnknownValue(options.entry)}`,
-			"  reason: deny workspace dependency entries must be objects with non-empty name and reason fields."
-		]);
-		return;
-	}
-	const nameValue = options.entry.name;
-	const reasonValue = options.entry.reason;
-	if (!isNonEmptyString(nameValue)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.name`,
-			`  value: ${formatUnknownValue(nameValue)}`,
-			"  reason: workspace dependency name is required and must be a non-empty string."
-		]);
-		return;
-	}
-	if (!isNonEmptyString(reasonValue)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.reason`,
-			`  value: ${formatUnknownValue(reasonValue)}`,
-			"  reason: workspace dependency reason is required and must be a non-empty string."
-		]);
-		return;
-	}
-	const packageName = nameValue.trim();
-	if (!options.packageNames.has(packageName)) {
-		addRuleEntryConfigProblem(options.problems, [
-			`  field: ${field}.name`,
-			`  name: ${packageName}`,
-			"  reason: deny.workspaceDeps and legacy deny.deps only accept discovered workspace package names. Use deny.nodeBuiltins for Node builtins."
-		]);
-		return;
-	}
-	const deps = options.workspaceDepsByLabel.get(options.label) ?? /* @__PURE__ */ new Map();
-	deps.set(packageName, {
-		name: packageName,
-		reason: reasonValue.trim()
-	});
-	options.workspaceDepsByLabel.set(options.label, deps);
-}
-function addNormalizedNodeBuiltin(options) {
-	const field = `graph.rules.${options.label}.deny.nodeBuiltins[${options.index}]`;
+function addNormalizedDep(options) {
+	const field = `graph.rules.${options.label}.deny.deps[${options.index}]`;
 	if (!isPlainRecord(options.entry)) {
 		addRuleEntryConfigProblem(options.problems, [
 			`  field: ${field}`,
 			`  value: ${formatUnknownValue(options.entry)}`,
-			"  reason: deny.nodeBuiltins entries must be objects with non-empty name and reason fields."
+			"  reason: deny.deps entries must be objects with non-empty name and reason fields."
 		]);
 		return;
 	}
@@ -960,7 +928,7 @@ function addNormalizedNodeBuiltin(options) {
 		addRuleEntryConfigProblem(options.problems, [
 			`  field: ${field}.name`,
 			`  value: ${formatUnknownValue(nameValue)}`,
-			"  reason: deny.nodeBuiltins name is required and must be a non-empty string."
+			"  reason: deny.deps name is required and must be a non-empty string."
 		]);
 		return;
 	}
@@ -968,38 +936,31 @@ function addNormalizedNodeBuiltin(options) {
 		addRuleEntryConfigProblem(options.problems, [
 			`  field: ${field}.reason`,
 			`  value: ${formatUnknownValue(reasonValue)}`,
-			"  reason: deny.nodeBuiltins reason is required and must be a non-empty string."
+			"  reason: deny.deps reason is required and must be a non-empty string."
 		]);
 		return;
 	}
 	const name = nameValue.trim();
-	const normalizedName = name.startsWith("node:") ? name.slice(5) : name;
-	const matchAll = name === "node:*";
-	if (!matchAll && !nodeBuiltinNames.has(normalizedName)) {
+	const normalizedDep = createNormalizedDep(name, reasonValue.trim());
+	if (!normalizedDep) {
 		addRuleEntryConfigProblem(options.problems, [
 			`  field: ${field}.name`,
 			`  name: ${name}`,
-			"  reason: deny.nodeBuiltins name must be \"node:*\" or a Node builtin specifier such as \"fs\" or \"node:fs\"."
+			"  reason: deny.deps name must be a package root, a package.json imports specifier such as \"#internal/*\", or a Node builtin such as \"fs\", \"node:fs\", or \"node:*\"."
 		]);
 		return;
 	}
-	const entries = options.nodeBuiltinsByLabel.get(options.label) ?? [];
-	entries.push({
-		matchAll,
-		name: normalizedName,
-		reason: reasonValue.trim()
-	});
-	options.nodeBuiltinsByLabel.set(options.label, entries);
+	const deps = options.depsByLabel.get(options.label) ?? [];
+	deps.push(normalizedDep);
+	options.depsByLabel.set(options.label, deps);
 }
 function shouldNormalizeRuleKind(include, kind) {
 	return include?.[kind] ?? true;
 }
 function normalizeGraphRules(options) {
+	const depsByLabel = /* @__PURE__ */ new Map();
 	const refsByLabel = /* @__PURE__ */ new Map();
-	const workspaceDepsByLabel = /* @__PURE__ */ new Map();
-	const nodeBuiltinsByLabel = /* @__PURE__ */ new Map();
 	const projectPathSet = new Set(options.projectPaths);
-	const packageNames = new Set(options.packages.map((workspacePackage) => workspacePackage.name));
 	for (const [rawLabel, rawRule] of Object.entries(getRulesRecord(options.config, options.problems))) {
 		const label = rawLabel.trim();
 		if (!label) {
@@ -1040,60 +1001,35 @@ function normalizeGraphRules(options) {
 				refsByLabel
 			});
 		});
-		const legacyDeps = rawRule.deny.deps;
-		if (shouldNormalizeRuleKind(options.include, "workspaceDeps") && legacyDeps !== void 0) if (!Array.isArray(legacyDeps)) addRuleEntryConfigProblem(options.problems, [
-			`  field: graph.rules.${label}.deny.deps`,
-			`  value: ${formatUnknownValue(legacyDeps)}`,
-			"  reason: deny.deps must be an array."
-		]);
-		else legacyDeps.forEach((entry, index) => {
-			addNormalizedWorkspaceDep({
-				entry,
-				fieldPrefix: `graph.rules.${label}.deny.deps`,
-				index,
-				label,
-				packageNames,
-				problems: options.problems,
-				workspaceDepsByLabel
-			});
-		});
-		const workspaceDeps = rawRule.deny.workspaceDeps;
-		if (shouldNormalizeRuleKind(options.include, "workspaceDeps") && workspaceDeps !== void 0) if (!Array.isArray(workspaceDeps)) addRuleEntryConfigProblem(options.problems, [
+		if (shouldNormalizeRuleKind(options.include, "deps") && rawRule.deny.workspaceDeps !== void 0) addRuleEntryConfigProblem(options.problems, [
 			`  field: graph.rules.${label}.deny.workspaceDeps`,
-			`  value: ${formatUnknownValue(workspaceDeps)}`,
-			"  reason: deny.workspaceDeps must be an array."
+			`  value: ${formatUnknownValue(rawRule.deny.workspaceDeps)}`,
+			"  reason: deny.workspaceDeps has been removed; use deny.deps."
 		]);
-		else workspaceDeps.forEach((entry, index) => {
-			addNormalizedWorkspaceDep({
-				entry,
-				fieldPrefix: `graph.rules.${label}.deny.workspaceDeps`,
-				index,
-				label,
-				packageNames,
-				problems: options.problems,
-				workspaceDepsByLabel
-			});
-		});
-		const nodeBuiltins = rawRule.deny.nodeBuiltins;
-		if (shouldNormalizeRuleKind(options.include, "nodeBuiltins") && nodeBuiltins !== void 0) if (!Array.isArray(nodeBuiltins)) addRuleEntryConfigProblem(options.problems, [
+		if (shouldNormalizeRuleKind(options.include, "deps") && rawRule.deny.nodeBuiltins !== void 0) addRuleEntryConfigProblem(options.problems, [
 			`  field: graph.rules.${label}.deny.nodeBuiltins`,
-			`  value: ${formatUnknownValue(nodeBuiltins)}`,
-			"  reason: deny.nodeBuiltins must be an array."
+			`  value: ${formatUnknownValue(rawRule.deny.nodeBuiltins)}`,
+			"  reason: deny.nodeBuiltins has been removed; use deny.deps."
 		]);
-		else nodeBuiltins.forEach((entry, index) => {
-			addNormalizedNodeBuiltin({
+		const deps = rawRule.deny.deps;
+		if (shouldNormalizeRuleKind(options.include, "deps") && deps !== void 0) if (!Array.isArray(deps)) addRuleEntryConfigProblem(options.problems, [
+			`  field: graph.rules.${label}.deny.deps`,
+			`  value: ${formatUnknownValue(deps)}`,
+			"  reason: deny.deps must be an array."
+		]);
+		else deps.forEach((entry, index) => {
+			addNormalizedDep({
+				depsByLabel,
 				entry,
 				index,
 				label,
-				nodeBuiltinsByLabel,
 				problems: options.problems
 			});
 		});
 	}
 	return {
-		nodeBuiltinsByLabel,
-		refsByLabel,
-		workspaceDepsByLabel
+		depsByLabel,
+		refsByLabel
 	};
 }
 function isNodeBuiltinSpecifier(specifier) {
@@ -1103,14 +1039,24 @@ function getDeniedRefRule(rules, label, targetProjectPath) {
 	if (!label) return null;
 	return rules.refsByLabel.get(label)?.get(targetProjectPath) ?? null;
 }
-function getDeniedWorkspaceDepRule(rules, label, targetPackageName) {
-	if (!label) return null;
-	return rules.workspaceDepsByLabel.get(label)?.get(targetPackageName) ?? null;
-}
-function getDeniedNodeBuiltinRule(rules, label, specifier) {
-	if (!label || !isNodeBuiltinSpecifier(specifier)) return null;
-	const normalizedSpecifier = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-	return rules.nodeBuiltinsByLabel.get(label)?.find((rule) => rule.matchAll || rule.name === normalizedSpecifier) ?? null;
+function getRuleDeps(rules, label) {
+	if (!label) return [];
+	return rules.depsByLabel.get(label) ?? [];
+}
+function getDeniedDepRuleForPackage(rules, label, packageName) {
+	return getRuleDeps(rules, label).find((rule) => rule.kind === "package" && rule.normalizedName === packageName) ?? null;
+}
+function getDeniedDepRuleForSpecifier(rules, label, specifier) {
+	const deps = getRuleDeps(rules, label);
+	const packageImportRule = deps.find((rule) => rule.kind === "package-import" && matchWildcardPattern(rule.normalizedName, specifier));
+	if (packageImportRule) return packageImportRule;
+	if (isNodeBuiltinSpecifier(specifier)) {
+		const normalizedSpecifier = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
+		const nodeRule = deps.find((rule) => rule.kind === "node-builtin" && (rule.matchAllNodeBuiltins || rule.normalizedName === normalizedSpecifier));
+		if (nodeRule) return nodeRule;
+	}
+	if (isRelativeSpecifier(specifier) || isPackageImportPattern(specifier) || isUrlOrDataOrFileSpecifier$1(specifier) || path.isAbsolute(specifier)) return null;
+	return getDeniedDepRuleForPackage(rules, label, getPackageRootSpecifier(specifier));
 }
 
 //#endregion
@@ -1118,6 +1064,7 @@ function getDeniedNodeBuiltinRule(rules, label, specifier) {
 const logger = createLogger({ main: "limina" });
 const CliLogger = logger.getLoggerByGroup("task.cli");
 const GraphLogger = logger.getLoggerByGroup("task.graph");
+const InitLogger = logger.getLoggerByGroup("task.init");
 const PackageLogger = logger.getLoggerByGroup("task.package");
 const PathsLogger = logger.getLoggerByGroup("task.paths");
 const ProofLogger = logger.getLoggerByGroup("task.proof");
@@ -1132,6 +1079,541 @@ function clearCliScreen() {
 	readline.clearScreenDown(process.stdout);
 }
 
+//#endregion
+//#region src/commands/init.ts
+const pnpmWorkspaceFileName = "pnpm-workspace.yaml";
+const liminaConfigFileName = "limina.config.mjs";
+const liminaCheckScriptName = "limina:check";
+const liminaCheckScriptValue = "limina check";
+const ignoredGlobPatterns = [
+	"**/.git/**",
+	"**/.limina/**",
+	"**/.pnpm-store/**",
+	"**/.tsbuild/**",
+	"**/coverage/**",
+	"**/dist/**",
+	"**/node_modules/**"
+];
+function findPnpmWorkspaceRoot(startDir) {
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(currentDir, pnpmWorkspaceFileName))) return normalizeAbsolutePath(currentDir);
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function createInitConfig(rootDir) {
+	return {
+		configPath: path.join(rootDir, liminaConfigFileName),
+		rootDir
+	};
+}
+function formatConfigPath(rootDir, configPath) {
+	return toRelativePath(rootDir, configPath);
+}
+function formatReferencePath(fromConfigPath, toConfigPath) {
+	const relativePath = toPosixPath(path.relative(path.dirname(fromConfigPath), toConfigPath));
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function stringifyJson(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+function getProjectScope(configPath) {
+	const fileName = path.basename(configPath);
+	if (fileName === "tsconfig.json") return "tsconfig";
+	return /^tsconfig\.(.+)\.json$/u.exec(fileName)?.[1] ?? "tsconfig";
+}
+function getDtsConfigPath(configPath) {
+	const directory = path.dirname(configPath);
+	const fileName = path.basename(configPath);
+	const dtsFileName = fileName === "tsconfig.json" ? "tsconfig.dts.json" : fileName.replace(/\.json$/u, ".dts.json");
+	return path.join(directory, dtsFileName);
+}
+function hasReferences(configObject) {
+	return Array.isArray(configObject.references) && configObject.references.length > 0;
+}
+function parseTypeScriptConfig(rootDir, configPath) {
+	const diagnostics = [];
+	const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, {
+		...ts.sys,
+		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+			diagnostics.push(diagnostic);
+		}
+	});
+	if (!parsed) throw new Error(ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+		getCanonicalFileName: (fileName) => fileName,
+		getCurrentDirectory: () => rootDir,
+		getNewLine: () => "\n"
+	}));
+	if (parsed.errors.length > 0) throw new Error(ts.formatDiagnosticsWithColorAndContext(parsed.errors, {
+		getCanonicalFileName: (fileName) => fileName,
+		getCurrentDirectory: () => rootDir,
+		getNewLine: () => "\n"
+	}));
+	return {
+		fileNames: parsed.fileNames.map(normalizeAbsolutePath),
+		options: parsed.options
+	};
+}
+function findNearestWorkspacePackage(filePath, packages) {
+	return [...packages].sort((left, right) => right.directory.length - left.directory.length).find((workspacePackage) => isPathInsideDirectory(filePath, workspacePackage.directory)) ?? null;
+}
+function collectWorkspaceDependencyNames(manifest) {
+	const dependencyNames = /* @__PURE__ */ new Set();
+	for (const dependencies of getDependencySections(manifest)) for (const [dependencyName, specifier] of Object.entries(dependencies)) if (isWorkspaceDependencySpecifier(specifier)) dependencyNames.add(dependencyName);
+	return dependencyNames;
+}
+function findOwningProjectForFile(filePath, projects) {
+	const normalizedFilePath = normalizeAbsolutePath(filePath);
+	return projects.filter((project) => project.fileNames.includes(normalizedFilePath)).sort((left, right) => {
+		const depthDelta = path.dirname(right.configPath).length - path.dirname(left.configPath).length;
+		return depthDelta === 0 ? left.configPath.localeCompare(right.configPath) : depthDelta;
+	})[0] ?? null;
+}
+function isDirectory(filePath) {
+	try {
+		return statSync(filePath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function mapVirtualWorkspacePath(filePath, packageByName) {
+	const segments = normalizeAbsolutePath(filePath).split("/");
+	for (let index = 0; index < segments.length; index += 1) {
+		if (segments[index] !== "node_modules") continue;
+		const firstPackageSegment = segments[index + 1];
+		if (!firstPackageSegment) continue;
+		const isScopedPackage = firstPackageSegment.startsWith("@");
+		const packageName = isScopedPackage ? `${firstPackageSegment}/${segments[index + 2] ?? ""}` : firstPackageSegment;
+		const restStart = index + (isScopedPackage ? 3 : 2);
+		const workspacePackage = packageByName.get(packageName);
+		if (!workspacePackage) continue;
+		return path.join(workspacePackage.directory, ...segments.slice(restStart));
+	}
+	return null;
+}
+function isVirtualWorkspaceDirectory(directoryPath, packageByName) {
+	const segments = normalizeAbsolutePath(directoryPath).split("/");
+	for (let index = 0; index < segments.length; index += 1) {
+		if (segments[index] !== "node_modules") continue;
+		const firstPackageSegment = segments[index + 1];
+		if (!firstPackageSegment) return packageByName.size > 0;
+		if (firstPackageSegment.startsWith("@") && segments[index + 2] === void 0) return [...packageByName.keys()].some((packageName) => packageName.startsWith(`${firstPackageSegment}/`));
+	}
+	const mappedPath = mapVirtualWorkspacePath(directoryPath, packageByName);
+	return mappedPath ? isDirectory(mappedPath) : false;
+}
+function createWorkspaceModuleResolutionHost(options) {
+	const mapPath = (filePath) => mapVirtualWorkspacePath(filePath, options.packageByName) ?? filePath;
+	return {
+		directoryExists: (directoryPath) => isVirtualWorkspaceDirectory(directoryPath, options.packageByName) || (ts.sys.directoryExists?.(directoryPath) ?? isDirectory(directoryPath)),
+		fileExists: (filePath) => {
+			const mappedPath = mapPath(filePath);
+			return existsSync(mappedPath) && !isDirectory(mappedPath);
+		},
+		getCurrentDirectory: () => options.rootDir,
+		readFile: (filePath) => ts.sys.readFile(mapPath(filePath)),
+		realpath: (filePath) => normalizeAbsolutePath(mapPath(filePath)),
+		useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames
+	};
+}
+function resolveImportWithTypeScript(options) {
+	const resolvedModule = ts.resolveModuleName(options.importRecord.specifier, options.importRecord.filePath, options.project.options, options.host, options.cache).resolvedModule;
+	if (!resolvedModule?.resolvedFileName) return null;
+	return normalizeAbsolutePath(mapVirtualWorkspacePath(resolvedModule.resolvedFileName, options.packageByName) ?? resolvedModule.resolvedFileName);
+}
+function isPackageImportSpecifier$1(specifier) {
+	return specifier.startsWith("#");
+}
+function createDtsConfig(project) {
+	const fileName = path.basename(project.configPath);
+	const scope = project.scope;
+	const output = {
+		$schema: "https://json.schemastore.org/tsconfig",
+		extends: [`./${fileName}`],
+		compilerOptions: {
+			composite: true,
+			incremental: true,
+			noEmit: false,
+			declaration: true,
+			emitDeclarationOnly: true,
+			declarationMap: false,
+			rootDir: ".",
+			outDir: "./.limina",
+			tsBuildInfoFile: `./.limina/${scope}.tsbuildinfo`
+		}
+	};
+	if (project.references.length > 0) output.references = project.references.map((referencePath) => ({ path: referencePath }));
+	return output;
+}
+function createBuildAggregator(references) {
+	return {
+		$schema: "https://json.schemastore.org/tsconfig",
+		files: [],
+		references: references.map((referencePath) => ({ path: referencePath }))
+	};
+}
+function createLiminaConfigContent() {
+	return `import { defineConfig } from 'limina';
+
+export default defineConfig({
+  // Shared checker entries used by graph, proof, paths, and typecheck checks.
+  config: {
+    checkers: {
+      typescript: {
+        preset: 'tsc',
+        entry: 'tsconfig.build.json',
+      },
+    },
+  },
+});
+`;
+}
+async function confirmAction(options, message) {
+	if (options.yes) return true;
+	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error(`${message} Run limina init --yes to accept the default confirmation in non-interactive environments.`);
+	const result = await prompts.confirm({
+		initialValue: true,
+		message
+	});
+	if (prompts.isCancel(result)) throw new Error("limina init canceled.");
+	return result;
+}
+async function writeTextFile(filePath, content, writtenFiles) {
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, content);
+	writtenFiles.push(filePath);
+}
+async function writeBuildAggregatorFile(options) {
+	if (options.references.length === 0) return false;
+	await writeTextFile(options.configPath, stringifyJson(createBuildAggregator(options.references)), options.writtenFiles);
+	return true;
+}
+function findPnpmWorkspacePath(startDir) {
+	const rootDir = findPnpmWorkspaceRoot(startDir);
+	return rootDir ? path.join(rootDir, pnpmWorkspaceFileName) : null;
+}
+function resolveCatalogRange(range, packageName, packageManifestPath) {
+	if (!range) return null;
+	if (!range.startsWith("catalog:")) return range;
+	const workspacePath = findPnpmWorkspacePath(path.dirname(packageManifestPath));
+	if (!workspacePath || !existsSync(workspacePath)) return null;
+	const parsed = parse(readFileSync(workspacePath, "utf8"));
+	const catalogName = range.slice(8);
+	if (catalogName.length === 0 || catalogName === "default") return parsed?.catalog?.[packageName] ?? null;
+	return parsed?.catalogs?.[catalogName]?.[packageName] ?? null;
+}
+function readLiminaPackageMetadata() {
+	const manifestPath = createRequire(import.meta.url).resolve("limina/package.json");
+	const manifest = readJsonFile(manifestPath);
+	const versionRange = manifest.version ? `^${manifest.version}` : "^0.0.1";
+	const rawTypeScriptRange = manifest.peerDependencies?.typescript ?? manifest.devDependencies?.typescript ?? manifest.dependencies?.typescript;
+	return {
+		typescriptRange: resolveCatalogRange(rawTypeScriptRange, "typescript", manifestPath) ?? rawTypeScriptRange ?? "^5.9.0",
+		versionRange
+	};
+}
+function hasDependency(manifest, dependencyName) {
+	return Boolean(manifest.dependencies?.[dependencyName] || manifest.devDependencies?.[dependencyName] || manifest.optionalDependencies?.[dependencyName] || manifest.peerDependencies?.[dependencyName]);
+}
+async function updateRootPackageJson(options) {
+	const packageJsonPath = path.join(options.rootDir, "package.json");
+	let installRequired = false;
+	if (!existsSync(packageJsonPath)) {
+		if (!await confirmAction(options.prompt, `No package.json found at ${formatConfigPath(options.rootDir, packageJsonPath)}. Create one?`)) {
+			options.skippedFiles.push(packageJsonPath);
+			return false;
+		}
+		await writeTextFile(packageJsonPath, stringifyJson({
+			private: true,
+			type: "module",
+			scripts: { [liminaCheckScriptName]: liminaCheckScriptValue },
+			devDependencies: {
+				limina: options.metadata.versionRange,
+				typescript: options.metadata.typescriptRange
+			}
+		}), options.writtenFiles);
+		return true;
+	}
+	const manifest = readJsonFile(packageJsonPath);
+	const scripts = { ...manifest.scripts ?? {} };
+	let changed = false;
+	if (scripts[liminaCheckScriptName] && scripts[liminaCheckScriptName] !== liminaCheckScriptValue) {
+		if (await confirmAction(options.prompt, `Script "${liminaCheckScriptName}" already exists in package.json. Overwrite it?`)) {
+			scripts[liminaCheckScriptName] = liminaCheckScriptValue;
+			changed = true;
+		}
+	} else if (!scripts[liminaCheckScriptName]) {
+		scripts[liminaCheckScriptName] = liminaCheckScriptValue;
+		changed = true;
+	}
+	if (!hasDependency(manifest, "limina")) {
+		manifest.devDependencies = {
+			...manifest.devDependencies ?? {},
+			limina: options.metadata.versionRange
+		};
+		installRequired = true;
+		changed = true;
+	}
+	if (changed) await writeTextFile(packageJsonPath, stringifyJson({
+		...manifest,
+		scripts
+	}), options.writtenFiles);
+	return installRequired;
+}
+async function collectReservedConfigConflicts(rootDir) {
+	const conflicts = await glob([
+		"tsconfig*.build.json",
+		"**/tsconfig*.build.json",
+		"tsconfig*.dts.json",
+		"**/tsconfig*.dts.json"
+	], {
+		absolute: false,
+		cwd: rootDir,
+		ignore: ignoredGlobPatterns
+	});
+	return [...new Set(conflicts)].sort();
+}
+async function collectOrdinaryTsconfigPaths(rootDir) {
+	const configPaths = await glob(["tsconfig*.json", "**/tsconfig*.json"], {
+		absolute: false,
+		cwd: rootDir,
+		ignore: ignoredGlobPatterns
+	});
+	return [...new Set(configPaths)].map((configPath) => normalizeAbsolutePath(path.join(rootDir, configPath))).filter(isOrdinaryTypecheckConfigPath).sort();
+}
+function analyzeTypecheckProjects(options) {
+	const problems = [];
+	const projects = [];
+	for (const configPath of options.configPaths) {
+		const configObject = readJsonConfig(options.config, configPath);
+		const parsed = parseTypeScriptConfig(options.config.rootDir, configPath);
+		const hasProjectReferences = hasReferences(configObject);
+		const fileName = path.basename(configPath);
+		if (fileName === "tsconfig.json" && hasProjectReferences && parsed.fileNames.length > 0) {
+			problems.push([
+				"Invalid tsconfig role:",
+				`  config: ${formatConfigPath(options.config.rootDir, configPath)}`,
+				"  reason: tsconfig.json must be either a pure aggregator with files: [] and references, or a typecheck leaf with source files, but not both."
+			].join("\n"));
+			continue;
+		}
+		if (fileName !== "tsconfig.json" && hasProjectReferences) {
+			problems.push([
+				"Invalid scoped tsconfig role:",
+				`  config: ${formatConfigPath(options.config.rootDir, configPath)}`,
+				"  reason: tsconfig.<scope>.json files may only be typecheck leaves; graph aggregation belongs in tsconfig*.build.json."
+			].join("\n"));
+			continue;
+		}
+		if (fileName === "tsconfig.json" && hasProjectReferences) continue;
+		projects.push({
+			configPath,
+			dtsConfigPath: getDtsConfigPath(configPath),
+			fileNames: parsed.fileNames,
+			options: parsed.options,
+			owner: findNearestWorkspacePackage(configPath, options.workspacePackages),
+			references: [],
+			scope: getProjectScope(configPath)
+		});
+	}
+	return {
+		problems,
+		projects
+	};
+}
+function inferProjectReferences(options) {
+	const problems = [];
+	const packageByName = new Map(options.workspacePackages.map((workspacePackage) => [workspacePackage.name, workspacePackage]));
+	const host = createWorkspaceModuleResolutionHost({
+		packageByName,
+		rootDir: options.config.rootDir
+	});
+	for (const project of options.projects) {
+		if (!project.owner) continue;
+		const workspaceDependencyNames = collectWorkspaceDependencyNames(project.owner.manifest);
+		const resolutionCache = ts.createModuleResolutionCache(path.dirname(project.configPath), (fileName) => fileName, project.options);
+		const referencePaths = /* @__PURE__ */ new Set();
+		for (const fileName of project.fileNames) {
+			if (!/\.(?:[cm]?tsx?|d\.[cm]?ts)$/u.test(fileName)) continue;
+			for (const importRecord of collectImportsFromFile(fileName)) {
+				const resolvedFilePath = resolveImportWithTypeScript({
+					cache: resolutionCache,
+					host,
+					importRecord,
+					packageByName,
+					project
+				});
+				const packageName = isRelativeSpecifier$1(importRecord.specifier) || isPackageImportSpecifier$1(importRecord.specifier) ? null : getPackageRootSpecifier(importRecord.specifier);
+				const targetPackage = packageName ? packageByName.get(packageName) : null;
+				const isWorkspaceGraphDependency = targetPackage && (targetPackage.name === project.owner.name || workspaceDependencyNames.has(targetPackage.name));
+				if (packageName && workspaceDependencyNames.has(packageName) && !targetPackage) {
+					problems.push([
+						"Workspace dependency was not discovered by pnpm:",
+						`  importing project: ${formatConfigPath(options.config.rootDir, project.dtsConfigPath)}`,
+						`  file: ${formatConfigPath(options.config.rootDir, importRecord.filePath)}:${importRecord.line}`,
+						`  imported specifier: ${importRecord.specifier}`,
+						`  package: ${packageName}`,
+						"  reason: package.json declares this dependency with the workspace: protocol, but limina init could not find a matching workspace package."
+					].join("\n"));
+					continue;
+				}
+				if (targetPackage && !isWorkspaceGraphDependency) continue;
+				if (!resolvedFilePath) {
+					if (targetPackage && isWorkspaceGraphDependency) problems.push([
+						"Unable to resolve workspace import with TypeScript:",
+						`  importing project: ${formatConfigPath(options.config.rootDir, project.dtsConfigPath)}`,
+						`  file: ${formatConfigPath(options.config.rootDir, importRecord.filePath)}:${importRecord.line}`,
+						`  imported specifier: ${importRecord.specifier}`,
+						`  package: ${targetPackage.name}`,
+						"  reason: workspace:* imports must resolve with the project TypeScript compilerOptions before limina init can generate project references."
+					].join("\n"));
+					continue;
+				}
+				if (isRelativeSpecifier$1(importRecord.specifier)) {
+					const sourcePackage = findNearestWorkspacePackage(importRecord.filePath, options.workspacePackages);
+					const resolvedPackage = findNearestWorkspacePackage(resolvedFilePath, options.workspacePackages);
+					if (sourcePackage && resolvedPackage && sourcePackage.name !== resolvedPackage.name) continue;
+				}
+				const targetProject = findOwningProjectForFile(resolvedFilePath, options.projects);
+				if (!targetProject) {
+					if (targetPackage && isWorkspaceGraphDependency) problems.push([
+						"Unable to map workspace import to a generated declaration leaf:",
+						`  importing project: ${formatConfigPath(options.config.rootDir, project.dtsConfigPath)}`,
+						`  file: ${formatConfigPath(options.config.rootDir, importRecord.filePath)}:${importRecord.line}`,
+						`  imported specifier: ${importRecord.specifier}`,
+						`  resolved file: ${formatConfigPath(options.config.rootDir, resolvedFilePath)}`,
+						"  reason: TypeScript resolved this workspace import, but the resolved module is not covered by any ordinary tsconfig*.json leaf."
+					].join("\n"));
+					continue;
+				}
+				if (targetProject.dtsConfigPath !== project.dtsConfigPath) referencePaths.add(formatReferencePath(project.dtsConfigPath, targetProject.dtsConfigPath));
+			}
+		}
+		project.references = [...referencePaths].sort();
+	}
+	return problems;
+}
+function collectProjectReferencesForOwner(options) {
+	return options.projects.filter((project) => project.owner?.directory === options.owner?.directory).map((project) => formatReferencePath(options.targetConfigPath, project.dtsConfigPath)).sort();
+}
+function collectRootBuildProjectReferences(options) {
+	return options.projects.filter((project) => !project.owner || project.owner.directory === options.rootDir || path.dirname(project.configPath) === options.rootDir).map((project) => formatReferencePath(options.targetConfigPath, project.dtsConfigPath)).sort();
+}
+async function writeGeneratedTsconfigs(options) {
+	for (const project of options.projects) await writeTextFile(project.dtsConfigPath, stringifyJson(createDtsConfig(project)), options.writtenFiles);
+	const nonRootWorkspacePackages = options.workspacePackages.filter((workspacePackage) => workspacePackage.directory !== options.rootDir);
+	const workspaceBuildConfigPaths = [];
+	for (const workspacePackage of nonRootWorkspacePackages) {
+		const buildConfigPath = path.join(workspacePackage.directory, "tsconfig.build.json");
+		if (await writeBuildAggregatorFile({
+			configPath: buildConfigPath,
+			references: collectProjectReferencesForOwner({
+				owner: workspacePackage,
+				projects: options.projects,
+				targetConfigPath: buildConfigPath
+			}),
+			writtenFiles: options.writtenFiles
+		})) workspaceBuildConfigPaths.push(buildConfigPath);
+	}
+	const rootBuildConfigPath = path.join(options.rootDir, "tsconfig.build.json");
+	await writeBuildAggregatorFile({
+		configPath: rootBuildConfigPath,
+		references: [...collectRootBuildProjectReferences({
+			projects: options.projects,
+			rootDir: options.rootDir,
+			targetConfigPath: rootBuildConfigPath
+		}), ...workspaceBuildConfigPaths.map((buildConfigPath) => formatReferencePath(rootBuildConfigPath, buildConfigPath))].sort(),
+		writtenFiles: options.writtenFiles
+	});
+}
+async function writeLiminaConfig(options) {
+	const configPath = path.join(options.rootDir, liminaConfigFileName);
+	if (existsSync(configPath)) {
+		if (!await confirmAction(options.prompt, `${liminaConfigFileName} already exists. Overwrite it?`)) {
+			options.skippedFiles.push(configPath);
+			return;
+		}
+	}
+	await writeTextFile(configPath, createLiminaConfigContent(), options.writtenFiles);
+}
+async function runInitInternal(options) {
+	const cwd = normalizeAbsolutePath(options.cwd ?? process.cwd());
+	const rootDir = findPnpmWorkspaceRoot(cwd);
+	if (!rootDir) throw new Error(`Unable to run limina init from ${cwd}: no pnpm-workspace.yaml was found in this directory or its parents.`);
+	const rootPackageJsonPath = path.join(rootDir, "package.json");
+	const rootPackageName = existsSync(rootPackageJsonPath) ? readJsonFile(rootPackageJsonPath).name : void 0;
+	if (!await confirmAction(options, `Use pnpm workspace ${rootPackageName ? `"${rootPackageName}" ` : ""}at ${rootDir}?`)) throw new Error("limina init canceled.");
+	const reservedConflicts = await collectReservedConfigConflicts(rootDir);
+	if (reservedConflicts.length > 0) throw new Error([
+		"Unable to run limina init because reserved Limina tsconfig names already exist:",
+		...reservedConflicts.map((configPath) => `  - ${configPath}`),
+		"reason: tsconfig*.build.json and tsconfig*.dts.json are Limina init output names; rename existing files before running init."
+	].join("\n"));
+	const config = createInitConfig(rootDir);
+	const workspacePackages = (await collectWorkspacePackages(config)).filter((workspacePackage) => workspacePackage.directory !== rootDir);
+	const projectAnalysis = analyzeTypecheckProjects({
+		config,
+		configPaths: await collectOrdinaryTsconfigPaths(rootDir),
+		workspacePackages
+	});
+	const problems = [...projectAnalysis.problems];
+	if (problems.length === 0) problems.push(...inferProjectReferences({
+		config,
+		projects: projectAnalysis.projects,
+		workspacePackages
+	}));
+	if (problems.length > 0) throw new Error(problems.join("\n\n"));
+	const metadata = readLiminaPackageMetadata();
+	const writtenFiles = [];
+	const skippedFiles = [];
+	await writeGeneratedTsconfigs({
+		projects: projectAnalysis.projects,
+		rootDir,
+		workspacePackages,
+		writtenFiles
+	});
+	await writeLiminaConfig({
+		prompt: options,
+		rootDir,
+		skippedFiles,
+		writtenFiles
+	});
+	return {
+		checkCommand: "pnpm limina:check",
+		installRequired: await updateRootPackageJson({
+			metadata,
+			prompt: options,
+			rootDir,
+			skippedFiles,
+			writtenFiles
+		}),
+		rootDir,
+		skippedFiles,
+		workspacePackageCount: workspacePackages.length,
+		writtenFiles
+	};
+}
+async function runInit(options = {}) {
+	if (options.clearScreen ?? true) clearCliScreen();
+	const elapsed = createElapsedTimer();
+	const task = options.flow?.start("init workspace", { depth: options.flowDepth ?? 0 });
+	InitLogger.info("init started");
+	try {
+		const result = await runInitInternal(options);
+		InitLogger.success(`init generated ${result.writtenFiles.length} files for ${result.workspacePackageCount} workspace packages.`, elapsed());
+		if (result.installRequired) InitLogger.info("limina was added to devDependencies; run pnpm i before checking.");
+		InitLogger.info(`next: ${result.installRequired ? "pnpm i && " : ""}${result.checkCommand}`);
+		task?.pass();
+		return result;
+	} catch (error) {
+		InitLogger.error(`init failed: ${formatErrorMessage$1(error)}`, elapsed());
+		task?.fail("init failed", { error });
+		throw error;
+	}
+}
+
 //#endregion
 //#region src/commands/source.ts
 function findOwnerForFile(filePath, owners) {
@@ -1144,7 +1626,7 @@ function isPackageImportSpecifier(specifier) {
 	return specifier.startsWith("#");
 }
 function isBarePackageSpecifier(specifier) {
-	return !isRelativeSpecifier(specifier) && !isPackageImportSpecifier(specifier) && !isUrlOrDataOrFileSpecifier(specifier) && !path.isAbsolute(specifier);
+	return !isRelativeSpecifier$1(specifier) && !isPackageImportSpecifier(specifier) && !isUrlOrDataOrFileSpecifier(specifier) && !path.isAbsolute(specifier);
 }
 function isDependencyAuthorized(manifest, packageName) {
 	return Boolean(manifest.dependencies?.[packageName] || manifest.devDependencies?.[packageName]);
@@ -1218,17 +1700,6 @@ function addPackageImportAuthorizationProblem(options) {
 		"  reason: source imports must be authorized by the nearest package.json dependencies or devDependencies."
 	].join("\n"));
 }
-function addNodeBuiltinDenyProblem(options) {
-	options.problems.push([
-		"Denied Node builtin import:",
-		`  rule: ${options.project.label}`,
-		`  importing project: ${toRelativePath(options.config.rootDir, options.project.configPath)}`,
-		`  file: ${toRelativePath(options.config.rootDir, options.importRecord.filePath)}:${options.importRecord.line}`,
-		`  imported specifier: ${options.importRecord.specifier}`,
-		`  denied builtin: ${options.ruleName}`,
-		`  reason: ${options.reason}`
-	].join("\n"));
-}
 function addPackageImportProblem(options) {
 	if (!packageImportsMatch(options.owner.manifest.imports, options.importRecord.specifier)) {
 		options.problems.push([
@@ -1272,23 +1743,11 @@ function createSourceProjectEntries(config, projects) {
 }
 async function runSourceCheckInternal(config, options = {}) {
 	const graphRoute = collectGraphProjectRoute(config);
-	const projectPaths = graphRoute.projectPaths;
-	const projects = projectPaths.map((projectPath) => parseProject(config, projectPath));
+	const projects = graphRoute.projectPaths.map((projectPath) => parseProject(config, projectPath));
 	const sourceProjectEntries = createSourceProjectEntries(config, projects);
 	const packages = await collectWorkspacePackages(config);
 	const packageOwners = await collectPackageOwners(config);
 	const problems = [...graphRoute.problems];
-	const graphRules = normalizeGraphRules({
-		config,
-		include: {
-			nodeBuiltins: true,
-			refs: false,
-			workspaceDeps: false
-		},
-		packages,
-		problems,
-		projectPaths
-	});
 	for (const project of projects) {
 		if (project.labelProblem) problems.push(project.labelProblem);
 		if (!isDtsProjectConfig(project.configPath)) continue;
@@ -1315,7 +1774,7 @@ async function runSourceCheckInternal(config, options = {}) {
 		if (!owner) continue;
 		for (const importRecord of collectImportsFromFile(filePath)) {
 			const resolvedFilePath = resolveInternalImport(importRecord.specifier, filePath, project.options);
-			if (isRelativeSpecifier(importRecord.specifier)) {
+			if (isRelativeSpecifier$1(importRecord.specifier)) {
 				if (!resolvedFilePath) continue;
 				const targetOwner = findOwnerForFile(resolvedFilePath, packageOwners);
 				if (targetOwner?.packageJsonPath !== owner.packageJsonPath) addRelativeImportOwnerProblem({
@@ -1340,18 +1799,7 @@ async function runSourceCheckInternal(config, options = {}) {
 			}
 			if (isUrlOrDataOrFileSpecifier(importRecord.specifier)) continue;
 			if (!isBarePackageSpecifier(importRecord.specifier)) continue;
-			if (isNodeBuiltinSpecifier(importRecord.specifier)) {
-				const deniedBuiltinRule = getDeniedNodeBuiltinRule(graphRules, project.label, importRecord.specifier);
-				if (deniedBuiltinRule) addNodeBuiltinDenyProblem({
-					config,
-					importRecord,
-					problems,
-					project,
-					reason: deniedBuiltinRule.reason,
-					ruleName: deniedBuiltinRule.matchAll ? "node:*" : deniedBuiltinRule.name
-				});
-				continue;
-			}
+			if (isNodeBuiltinSpecifier(importRecord.specifier)) continue;
 			const packageName = getPackageRootSpecifier(importRecord.specifier);
 			if (owner.name === packageName) continue;
 			const workspacePackage = packages.find((candidate) => candidate.name === packageName) ?? null;
@@ -2023,4 +2471,4 @@ function createLiminaFlowReporter(options = {}) {
 }
 
 //#endregion
-export { collectImporters as A, createFormatHost as B, inferPackageProject as C, parseProject as D, isWorkspacePackageFile as E, collectGraphProjectRoute as F, isOrdinaryTypecheckConfigPath as G, getDtsCompanionConfigPath as H, collectGraphProjectRouteFromRoot as I, readJsonConfig as J, parseProjectFileNames as K, collectGraphProjectRoutes as L, findPackageForSpecifier as M, getPackageRootSpecifier as N, resolveInternalImport as O, collectCheckerEntryProjectRoutes as P, collectTypecheckTargetProjectPaths as R, getTypecheckConfigPath as S, isRelativeSpecifier as T, getRawReferencePaths as U, formatReferences as V, isDtsConfigPath as W, resolveReferencePath as X, resolveProjectConfigPath as Y, createFileOwnerLookup as _, runSourceCheck as a, findTargetProject as b, PackageLogger as c, clearCliScreen as d, formatErrorMessage$1 as f, collectImportsFromFile as g, normalizeGraphRules as h, runCheckerTypecheck as i, collectWorkspacePackages as j, shouldResolveThroughGraph as k, PathsLogger as l, getDeniedWorkspaceDepRule as m, createLiminaFlowReporter as n, CliLogger as o, getDeniedRefRule as p, parseProjectFileNamesForExtensions as q, runCheckerBuild as r, GraphLogger as s, LiminaFlowReporter as t, ProofLogger as u, findImporterForFile as v, isDtsProjectConfig as w, formatArtifactDependencyPolicy as x, findPackageForFile as y, createExtensionPattern as z };
+export { shouldResolveThroughGraph as A, createExtensionPattern as B, formatArtifactDependencyPolicy as C, isRelativeSpecifier$1 as D, isDtsProjectConfig as E, collectCheckerEntryProjectRoutes as F, isDtsConfigPath as G, formatReferences as H, collectGraphProjectRoute as I, parseProjectFileNamesForExtensions as J, isOrdinaryTypecheckConfigPath as K, collectGraphProjectRouteFromRoot as L, collectWorkspacePackages as M, findPackageForSpecifier as N, parseProject as O, getPackageRootSpecifier as P, collectGraphProjectRoutes as R, findTargetProject as S, inferPackageProject as T, getDtsCompanionConfigPath as U, createFormatHost as V, getRawReferencePaths as W, resolveProjectConfigPath as X, readJsonConfig as Y, resolveReferencePath as Z, normalizeGraphRules as _, runSourceCheck as a, findImporterForFile as b, GraphLogger as c, ProofLogger as d, clearCliScreen as f, getDeniedRefRule as g, getDeniedDepRuleForSpecifier as h, runCheckerTypecheck as i, collectImporters as j, resolveInternalImport as k, PackageLogger as l, getDeniedDepRuleForPackage as m, createLiminaFlowReporter as n, runInit as o, formatErrorMessage$1 as p, parseProjectFileNames as q, runCheckerBuild as r, CliLogger as s, LiminaFlowReporter as t, PathsLogger as u, collectImportsFromFile as v, getTypecheckConfigPath as w, findPackageForFile as x, createFileOwnerLookup as y, collectTypecheckTargetProjectPaths as z };