limina 0.0.2 → 0.0.3

package/README.md

@@ -135,7 +135,7 @@ pnpm exec limina package check --package @acme/core
 
 ### Checker entry
 
-Each checker has one required `config.checkers.<name>.entry`, usually a `tsconfig*.build.json` graph aggregator. `limina checker build` runs the checker's build execution from that entry when the preset supports it. `limina checker typecheck` walks the same entry, finds reachable `tsconfig*.dts.json` declaration leaves, and checks their paired local companions.
+Each checker has one required `config.checkers.<name>.entry`, usually a `tsconfig*.build.json` graph aggregator. Built-in first-class presets (`tsc` and `vue-tsc`) participate in graph, source, proof, and build checks. Source-only presets such as `svelte-check` prove source coverage and run direct checker execution through `limina checker typecheck`.
 
 ### Declaration leaf and local companion
 
@@ -168,9 +168,8 @@ limina [--config limina.config.mjs] [--mode mode] <command>
 | `limina paths generate`                         | Generate compatibility source `paths` configs for artifact-facing workspace exports.  |
 | `limina paths apply`                            | Compatibility alias for `paths generate`.                                             |
 | `limina paths check`                            | Fail when generated path files are stale.                                             |
-| `limina checker typecheck`                      | Run typecheck targets derived from checker entries.                                   |
 | `limina checker build`                          | Run build execution for checker entries that support it.                              |
-| `limina checker typecheck --concurrency <n>`    | Limit concurrent checker processes.                                                   |
+| `limina checker typecheck`                      | Run source-only checker entries such as `svelte-check`.                               |
 | `limina package check`                          | Run configured package output checks.                                                 |
 | `limina package check --package <name>`         | Check one configured package target.                                                  |
 | `limina package check --tool <tool>`            | Run only `publint`, `attw`, or `boundary`.                                            |
@@ -198,7 +197,7 @@ config: {
 }
 ```
 
-`config.checkers` defines checker entries. Every configured checker must declare a non-empty `entry`. Built-in presets can omit `extensions`; if `source.include` is omitted, Limina derives the source boundary from configured checker extensions, then applies `source.exclude`.
+`config.checkers` defines checker entries. Every configured checker must declare a non-empty `entry` and use a built-in preset. Checker `extensions` are fixed by Limina and cannot be configured; if `source.include` is omitted, Limina derives the source boundary from configured checker extensions, then applies `source.exclude`.
 
 ### `graph`
 
@@ -303,7 +302,7 @@ pipelines: {
 }
 ```
 
-`limina check` runs the built-in default pipeline: `graph:check`, `source:check`, `proof:check`, and `checker:typecheck`. `limina check <pipeline>` only runs user pipelines from `limina.config.mjs#pipelines`; if the name is missing, Limina reports the missing pipeline and asks you to define it there.
+`limina check` runs the built-in default pipeline: `graph:check`, `source:check`, `proof:check`, `checker:build`, and `checker:typecheck`. `limina check <pipeline>` only runs user pipelines from `limina.config.mjs#pipelines`; if the name is missing, Limina reports the missing pipeline and asks you to define it there.
 
 String steps can be built-in task names or simple commands. Use object command steps when arguments, `cwd`, or `env` need to be explicit.
 

package/chunks/{dep-jgc7X0zw.js → dep-DzYrmtQJ.js}

@@ -35,39 +35,30 @@ function isPathInsideDirectory(filePath, directoryPath) {
 function createTscCommandTarget(options) {
 	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
 	return {
-		args: options.executionKind === "build" ? [
+		args: [
 			"-b",
 			relativeConfigPath,
 			"--pretty",
 			"false"
-		] : [
-			"-p",
-			relativeConfigPath,
-			"--noEmit"
 		],
 		command: options.commandOverride ?? "tsc",
-		label: options.executionKind === "build" ? `tsc -b ${relativeConfigPath}` : `tsc: ${relativeConfigPath}`
+		label: `tsc -b ${relativeConfigPath}`
 	};
 }
 function createVueTscCommandTarget(options) {
 	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
 	return {
-		args: options.executionKind === "build" ? [
+		args: [
 			"-b",
 			relativeConfigPath,
 			"--pretty",
 			"false"
-		] : [
-			"-p",
-			relativeConfigPath,
-			"--noEmit"
 		],
 		command: "vue-tsc",
-		label: options.executionKind === "build" ? `${options.checker.name}: vue-tsc -b ${relativeConfigPath}` : `${options.checker.name}: vue-tsc -p ${relativeConfigPath}`
+		label: `${options.checker.name}: vue-tsc -b ${relativeConfigPath}`
 	};
 }
 function createSvelteCheckCommandTarget(options) {
-	if (options.executionKind === "build") throw new Error(`Checker "${options.checker.name}" uses svelte-check, which does not support checker:build.`);
 	const relativeConfigPath = toRelativePath(options.projectRootDir, options.configPath);
 	return {
 		args: ["--tsconfig", relativeConfigPath],
@@ -79,10 +70,11 @@ const builtinCheckerAdapters = {
 	"svelte-check": {
 		createCommandTarget: createSvelteCheckCommandTarget,
 		defaultExtensions: [".svelte"],
-		graph: false,
-		packageName: "svelte-check",
+		execution: "typecheck",
+		packageNames: ["svelte-check"],
 		preset: "svelte-check",
-		supportedExecutions: ["typecheck"]
+		sourceGraph: false,
+		tier: "source-only"
 	},
 	tsc: {
 		createCommandTarget: createTscCommandTarget,
@@ -96,18 +88,20 @@ const builtinCheckerAdapters = {
 			".d.mts",
 			".json"
 		],
-		graph: true,
-		packageName: "typescript",
+		execution: "build",
+		packageNames: ["typescript"],
 		preset: "tsc",
-		supportedExecutions: ["typecheck", "build"]
+		sourceGraph: true,
+		tier: "first-class"
 	},
 	"vue-tsc": {
 		createCommandTarget: createVueTscCommandTarget,
 		defaultExtensions: [".vue"],
-		graph: false,
-		packageName: "vue-tsc",
+		execution: "build",
+		packageNames: ["vue-tsc", "@vue/compiler-sfc"],
 		preset: "vue-tsc",
-		supportedExecutions: ["typecheck", "build"]
+		sourceGraph: true,
+		tier: "first-class"
 	}
 };
 function isBuiltinCheckerPreset(value) {
@@ -130,15 +124,16 @@ function collectMissingCheckerPeerDependencies(options) {
 	const resolvePackage = options.resolvePackage ?? resolveCheckerPackageFromRoot;
 	const missingCheckersByPackage = /* @__PURE__ */ new Map();
 	for (const checker of options.checkers) {
-		const packageName = getCheckerAdapter(checker.preset)?.packageName;
-		if (!packageName) continue;
-		if (resolvePackage({
-			packageName,
-			projectRootDir: options.projectRootDir
-		})) continue;
-		const checkerNames = missingCheckersByPackage.get(packageName) ?? /* @__PURE__ */ new Set();
-		checkerNames.add(checker.name);
-		missingCheckersByPackage.set(packageName, checkerNames);
+		const packageNames = getCheckerAdapter(checker.preset)?.packageNames ?? [];
+		for (const packageName of packageNames) {
+			if (resolvePackage({
+				packageName,
+				projectRootDir: options.projectRootDir
+			})) continue;
+			const checkerNames = missingCheckersByPackage.get(packageName) ?? /* @__PURE__ */ new Set();
+			checkerNames.add(checker.name);
+			missingCheckersByPackage.set(packageName, checkerNames);
+		}
 	}
 	return [...missingCheckersByPackage.entries()].map(([packageName, checkerNames]) => ({
 		checkerNames: [...checkerNames].sort((left, right) => left.localeCompare(right)),
@@ -157,10 +152,9 @@ function formatMissingCheckerPeerDependencies(missingDependencies) {
 	].join("\n");
 }
 function getCheckerExtensions(checker) {
-	if (checker.extensions) return normalizeExtensions(checker.extensions);
 	const adapter = getCheckerAdapter(checker.preset);
-	if (adapter?.defaultExtensions) return normalizeExtensions(adapter.defaultExtensions);
-	throw new Error(`Checker preset "${checker.preset}" must declare non-empty extensions because it is not a built-in preset.`);
+	if (adapter) return normalizeExtensions(adapter.defaultExtensions);
+	throw new Error(`Checker preset "${checker.preset}" is not supported.`);
 }
 function getResolvedCheckers(config) {
 	const checkers = config.config?.checkers;
@@ -185,11 +179,9 @@ function defineConfig(config) {
 	return config;
 }
 const nonEmptyStringSchema = z.string().refine((value) => value.trim().length > 0);
-const dotPrefixedStringSchema = nonEmptyStringSchema.refine((value) => value.startsWith("."));
 const checkerObjectSchema = z.looseObject({});
 const checkerConfigShapeSchema = z.looseObject({
 	entry: nonEmptyStringSchema,
-	extensions: z.array(dotPrefixedStringSchema).nonempty().optional(),
 	preset: nonEmptyStringSchema
 });
 const liminaConfigShapeSchema = z.looseObject({ config: z.looseObject({ checkers: z.record(z.string(), checkerConfigShapeSchema).optional() }).optional() });
@@ -245,15 +237,6 @@ function formatLiminaConfigShapeIssue(value, issue) {
 			`  value: ${formatUnknownValue(getValueAtPath(value, pathSegments))}`,
 			"  reason: checker entry must be a non-empty string path."
 		].join("\n");
-		if (pathSegments[3] === "extensions") {
-			const extensionsPath = pathSegments.slice(0, 4);
-			return [
-				"Invalid Limina checker config:",
-				`  field: ${checkerField}.extensions`,
-				`  value: ${formatUnknownValue(getValueAtPath(value, extensionsPath))}`,
-				"  reason: checker extensions must be a non-empty array of dot-prefixed strings."
-			].join("\n");
-		}
 	}
 	return [
 		"Invalid Limina config:",
@@ -279,11 +262,11 @@ function collectCheckerConfigProblems(config) {
 		if (!checkerObjectResult.success) continue;
 		const checkerRecord = checkerObjectResult.data;
 		const preset = checkerRecord.preset;
-		if (checkerRecord.extensions === void 0 && typeof preset === "string" && !isBuiltinCheckerPreset(preset)) problems.push([
+		if (Object.hasOwn(checkerRecord, "extensions")) problems.push([
 			"Invalid Limina checker config:",
 			`  field: ${field}.extensions`,
-			"  value: undefined",
-			"  reason: extensions may only be omitted for built-in presets."
+			`  value: ${formatUnknownValue(checkerRecord.extensions)}`,
+			"  reason: checker extensions are fixed by built-in presets and cannot be configured."
 		].join("\n"));
 		if (Object.hasOwn(checkerRecord, "routes")) problems.push([
 			"Invalid Limina checker config:",
@@ -374,4 +357,4 @@ async function loadConfig(options = {}) {
 }
 
 //#endregion
-export { validateLiminaConfig as a, getCheckerAdapter as c, normalizeSlashes as d, normalizeWorkspacePath as f, toRelativePath as h, loadConfig as i, isPathInsideDirectory as l, toPosixPath as m, getActiveCheckerExtensions as n, collectMissingCheckerPeerDependencies as o, toAbsolutePath as p, getActiveCheckers as r, formatMissingCheckerPeerDependencies as s, defineConfig as t, normalizeAbsolutePath as u };
+export { validateLiminaConfig as a, getCheckerAdapter as c, normalizeAbsolutePath as d, normalizeSlashes as f, toRelativePath as g, toPosixPath as h, loadConfig as i, normalizeExtensions as l, toAbsolutePath as m, getActiveCheckerExtensions as n, collectMissingCheckerPeerDependencies as o, normalizeWorkspacePath as p, getActiveCheckers as r, formatMissingCheckerPeerDependencies as s, defineConfig as t, isPathInsideDirectory as u };