limina 0.0.2 → 0.0.4

package/README.md

@@ -34,6 +34,7 @@ Limina makes these rules reviewable, runnable, and suitable for CI.
 - **Compatibility path generation**: writes opt-in `tsconfig.dts.paths.generated.json` files for `workspace:*` dependencies whose package exports still point at build artifacts.
 - **Checker target runner**: runs configured TypeScript and UI-framework checker entries in `typecheck` or `build` execution mode.
 - **Published package checks**: validates built package outputs with `publint`, Are The Types Wrong, and a runtime import boundary audit.
+- **Release checks**: verifies npm tarball hygiene, source/packed manifest consistency, and registry-backed workspace publish order.
 - **Composable pipelines**: combines built-in checks and shell commands into named workflows such as `typecheck`, `package`, and `publish`.
 - **Typed configuration**: ships `defineConfig(...)` for editor hints and typed user configs.
 
@@ -95,8 +96,8 @@ export default defineConfig({
     ],
   },
 
-  packageChecks: {
-    targets: [
+  package: {
+    entries: [
       {
         name: '@acme/core',
         outDir: 'packages/core/dist',
@@ -106,7 +107,7 @@ export default defineConfig({
 
   pipelines: {
     package: ['package:check'],
-    publish: ['graph:check', 'proof:check', 'package:check'],
+    publish: ['graph:check', 'proof:check', 'package:check', 'release:check'],
   },
 });
 ```
@@ -135,7 +136,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
 
@@ -151,7 +152,7 @@ A dependency declared as `link:`, `file:`, `catalog:`, or normal semver is treat
 
 ### Package checks
 
-Source graph checks do not prove that an installed package works for consumers. `limina package check` inspects built package outputs under `packageChecks.targets[].outDir` and checks the actual package manifest, exports, type resolution, and runtime imports. Publishable outputs whose `package.json` does not set `private: true` must also include root `README.md` and `LICENSE.md` files.
+Source graph checks do not prove that an installed package works for consumers. `limina package check` inspects built package outputs under `package.entries[].outDir` and checks the actual package manifest, exports, type resolution, and runtime imports with `publint`, `attw`, and `boundary`. `limina release check` owns npm publish hygiene: private-output rejection, required README/license files, source map bans, source/packed manifest consistency, and registry-backed workspace publish order.
 
 ## CLI
 
@@ -168,13 +169,14 @@ 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 --package <name>`         | Check one configured package entry.                                                   |
 | `limina package check --tool <tool>`            | Run only `publint`, `attw`, or `boundary`.                                            |
 | `limina package check --attw-profile <profile>` | Override the ATTW profile: `strict`, `node16`, or `esm-only`.                         |
+| `limina release check`                          | Check release hygiene and dependency consistency for the cwd package entry.           |
+| `limina release check --package <name>`         | Check release hygiene and dependency consistency for one or more package entries.     |
 
 ## Configuration reference
 
@@ -198,7 +200,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`
 
@@ -270,11 +272,11 @@ proof: {
 
 Checker entries cover files validated by TypeScript or framework-aware tools. Allowlist entries are the final fallback after all configured checker entries fail to cover a source file; they should be rare and must include a reason.
 
-### `packageChecks`
+### `package`
 
 ```js
-packageChecks: {
-  targets: [
+package: {
+  entries: [
     {
       name: '@acme/core',
       outDir: 'packages/core/dist',
@@ -290,7 +292,7 @@ packageChecks: {
 }
 ```
 
-`outDir` must point at the built package directory that contains the publish-ready `package.json`. If that manifest does not set `private: true`, the same directory must also contain `README.md` and `LICENSE.md`.
+`outDir` must point at the built package directory that contains the publish-ready `package.json`. `package:check` uses this output for consumer-facing resolver and runtime checks; `release:check` packs the same output and verifies publish hygiene such as README/license files and source map bans.
 
 ### `pipelines`
 
@@ -303,7 +305,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.
 
@@ -357,7 +359,7 @@ Run the command from inside the workspace, or pass `--config ./limina.config.mjs
 
 Limina infers the workspace root from `pnpm-workspace.yaml`. Place the config inside the workspace or pass a config path located under the workspace root.
 
-### `packageChecks.targets[x].outDir` is invalid
+### `package.entries[x].outDir` is invalid
 
 Set `outDir` to the built package directory, not the source package directory, unless that directory is itself the publish-ready package output.
 

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 };