@antelopejs/tooling-configs 0.2.1 → 0.2.3

package/README.md

@@ -29,6 +29,8 @@ The AntelopeJS guardrail pack: shared lint, format and dead-code presets, the co
 | bin                | `antelopejs-checks`                                                       | Runs every check and prints only the failures                               |
 | bin                | `antelopejs-ratchet`                                                      | Fails when recorded debt grows; `--update` lowers the record                |
 | bin                | `antelopejs-check-size`                                                   | Fails on authored files over 20,000 bytes and on blanket disable directives |
+| bin                | `antelopejs-api-diff <base-ref>`                                          | Compares published declaration bundles against committed HEAD               |
+| bin                | `antelopejs-comment-proof <base-ref>`                                     | Compares comment-free JavaScript emit against committed HEAD                |
 | bin                | `antelopejs-check-interface-ranges`                                       | Fails on interface ranges that break module startup                         |
 
 ## Install
@@ -153,11 +155,11 @@ pnpm install
 | `.agents/setup`                                         | Orb setup: switches to the `.nvmrc` Node, activates `packageManager` through corepack, installs with the frozen lockfile                                                                              |
 | `AGENTS.md`                                             | Writes the managed block between `<!-- antelopejs-guardrails:start -->` and `:end -->`; text outside the markers stays                                                                                |
 | `CLAUDE.md`                                             | `@AGENTS.md`                                                                                                                                                                                          |
-| `guardrails.ratchet.json`                               | Records the current findings, once, when the file is missing                                                                                                                                          |
+| `guardrails.ratchet.json`                               | Records non-empty debt on first adoption, before `sync:check` exists                                                                                                                                  |
 
 `--profile template` writes only the three preset configs and a user-facing `AGENTS.md` block, for template repositories. `antelopejs-sync --check` writes nothing and exits 1 on any drift; `pnpm run checks` runs it.
 
-`pnpm run checks` runs `typecheck`, `lint`, `format:check`, `knip`, `test`, `size`, `ratchet` and `sync:check`, and prints only the output of the steps that failed.
+`pnpm run checks` runs `typecheck`, `lint`, `format:check`, `knip`, `test`, `size` and `sync:check`, plus `ratchet` when `guardrails.ratchet.json` exists. It prints only the output of the steps that failed. Sync adds the ratchet scripts and pre-commit hook only while that file exists.
 
 ### Ratchet
 
@@ -171,12 +173,31 @@ pnpm install
 ```
 
 - A rule listed under `rules` is off for `oxlint`, so editors, hooks and `lint` stay green. `antelopejs-ratchet` counts it with every rule on, and fails when a count rises. It prints the findings in the files the change touched.
-- A file listed under `oversizeFiles` may exceed 20,000 bytes and `max-lines`, up to its recorded size. Any other file over either limit fails.
+- A file listed under `oversizeFiles` may exceed 20,000 bytes and `max-lines`, up to its recorded size. Any other file over either limit fails. When git sees a listed file renamed (`git mv`, or a staged delete and add), the allowance moves to the new path and never exceeds the old one; a copy or a new file inherits nothing. `antelopejs-ratchet --base <ref>` detects renames against that revision instead of `HEAD`, for a rename that was committed before the file was updated.
 - `antelopejs-ratchet --update` lowers each number to the current count and removes what reached zero. It never raises a number or adds an entry. Commit the lowered file.
 
+When every rule count is zero and `oversizeFiles` is empty, the ratchet is retired. `antelopejs-ratchet --update` deletes the file and asks you to run `antelopejs-sync`. Sync then removes `ratchet`, `ratchet:update`, the ratchet hook and the Debt instructions. Commit those changes together. An empty baseline on first adoption creates no file. Later syncs never recreate it because the `sync:check` script marks adoption.
+
+`antelopejs-sync --check` rejects an existing retired file and tells you to run `ratchet:update`. Plain sync reports the same note but leaves deletion to the update command.
+
 ### Size
 
-`antelopejs-check-size` fails on an authored file over 20,000 bytes, tests included. Generated code, fixtures, lockfiles, `CHANGELOG.md`, Markdown and binary assets are excluded. Pass paths to check only those files, as the pre-commit hook does. It also fails on an `oxlint-disable` or `eslint-disable` directive (line, next-line or file form) that names no rule: oxlint applies such a directive before any rule runs, so `no-comments` cannot report it.
+`antelopejs-check-size` fails on an authored file over 20,000 bytes, tests included. Generated code (`dist`, `coverage`, `.nuxt`, `.output`, and `build` or `output` at the repository root or a package root, never under `src/` or `test/`), fixtures, lockfiles, `CHANGELOG.md`, Markdown and binary assets are excluded. Data JSON under `locales/` or `i18n/`, `blocks.json`, `schema.json`, and `evals/**/cases.json` are excluded too. Files over the limit with a NUL byte in their first 8,000 bytes are binary even without a known extension. Staged checks inspect the index blob. Excluded files are also removed from recorded size allowances on ratchet update.
+
+Pass paths to check only those files, as the pre-commit hook does. The command also fails on an `oxlint-disable` or `eslint-disable` directive (line, next-line or file form) that names no rule: oxlint applies such a directive before any rule runs, so `no-comments` cannot report it.
+
+### Cleanup proof
+
+A behaviour-preserving cleanup PR shows `antelopejs-api-diff <base-ref>` passing. It checks each tracked, non-private package with a `tsconfig.json`, using that package's installed TypeScript. It emits declarations without comments, resolves published entries from `exports` (preferring `types`), `main`, `types`/`typings` and `typesVersions`, and bundles each entry's local declaration closure. External packages stay external. Stable top-level ordering ignores declaration moves between internal files while preserving overload order. Compiler errors fail the proof.
+
+A comment-only PR shows `antelopejs-comment-proof <base-ref>` passing instead of a verifier. It includes private packages, ignores type diagnostics and compares comment-free JavaScript emit byte for byte. Both commands exclude test sources, fail on added or removed outputs, and print unified diffs for changes.
+
+Both commands compare **committed HEAD**, not staged or working-tree edits. They check out the base and HEAD in temporary detached worktrees, reuse the current checkout's root and package `node_modules`, and remove the worktrees afterwards. Install the consumer's dependencies before running them.
+
+```bash
+pnpm exec antelopejs-api-diff origin/main
+pnpm exec antelopejs-comment-proof origin/main
+```
 
 ## oxfmt
 
@@ -279,7 +300,7 @@ checks that remain the author's responsibility.
 
 ## Contributing
 
-See [CONTRIBUTING.md](./CONTRIBUTING.md). `pnpm install`, then `pnpm checks` runs the typecheck, lint, format check, tests, size check and ratchet.
+See [CONTRIBUTING.md](./CONTRIBUTING.md). `pnpm install`, then `pnpm checks` runs the typecheck, lint, format check, Knip, tests, size and sync checks. Repositories with recorded debt also run the ratchet.
 
 ## License
 

package/dist/bin/api-diff.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/bin/api-diff.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+import { c as revisionCounts, i as repositoryRoot, o as DIRECTORY_LINK, s as compareRevisions, u as runCli } from "../files-jKlueTMd.mjs";
+import { i as parseManifest, r as packageManager } from "../package-Ckd7e4tA.mjs";
+import { i as packagesAt, n as isTestSource, r as outputRoot, t as emitPackage } from "../typescript-aLCrMi2y.mjs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+import { generateDtsBundle } from "dts-bundle-generator";
+//#region src/guardrails/runtime-diff.ts
+const DESCRIBE = `
+const { readFileSync, existsSync } = require("node:fs");
+const { dirname, join, extname } = require("node:path");
+const { pathToFileURL } = require("node:url");
+const file = process.argv[1];
+let directory = dirname(file);
+while (!existsSync(join(directory, "package.json")) && dirname(directory) !== directory) directory = dirname(directory);
+const manifest = existsSync(join(directory, "package.json")) ? JSON.parse(readFileSync(join(directory, "package.json"), "utf8")) : {};
+const esm = extname(file) === ".mjs" || (extname(file) === ".js" && manifest.type === "module");
+const seen = new Map();
+function functionInfo(fn) {
+  let constructible = true;
+  try { Reflect.construct(Object, [], fn); } catch { constructible = false; }
+  return { name: fn.name, length: fn.length, async: Object.getPrototypeOf(fn) === Object.getPrototypeOf(async function() {}), constructible };
+}
+function valueInfo(value) {
+  if (typeof value !== "function") return { kind: value === null ? "null" : typeof value };
+  if (seen.has(value)) return { kind: "reference", id: seen.get(value) };
+  const id = seen.size;
+  seen.set(value, id);
+  return { kind: "function", id, function: functionInfo(value), static: properties(value, false), prototype: value.prototype ? properties(value.prototype, false) : [] };
+}
+function properties(object, observe) {
+  if (object === null || !["object", "function"].includes(typeof object)) return [];
+  return Reflect.ownKeys(object).map(key => {
+    const d = Object.getOwnPropertyDescriptor(object, key);
+    const common = { key: typeof key === "symbol" ? { symbol: String(key) } : key, enumerable: d.enumerable, configurable: d.configurable };
+    return "value" in d
+      ? { ...common, kind: "data", writable: d.writable, value: valueInfo(d.value) }
+      : { ...common, kind: "accessor", get: d.get ? functionInfo(d.get) : null, set: d.set ? functionInfo(d.set) : null, observed: observe ? valueInfo(Reflect.get(object, key)) : null };
+  });
+}
+(async () => {
+  const value = esm ? await import(pathToFileURL(file).href) : require(file);
+  process.stdout.write(JSON.stringify({ kind: esm ? "esm" : "cjs", value: valueInfo(value), properties: typeof value === "function" ? [] : properties(value, true) }));
+})().catch(error => { process.stderr.write(String(error.stack)); process.exitCode = 1; });
+`;
+function runtimeTargets(target, entry = "exports") {
+	if (target == null) return [];
+	if (Array.isArray(target)) return target.flatMap((value, index) => runtimeTargets(value, `${entry}/${index}`));
+	if (target.constructor === String) return [{
+		entry,
+		target: String(target)
+	}];
+	return Object.entries(target).flatMap(([key, value]) => {
+		if (key === "types") return [];
+		if ([
+			"browser",
+			"deno",
+			"react-native"
+		].includes(key)) throw new Error(`${entry}/${key}: unsupported runtime environment.`);
+		return runtimeTargets(value, `${entry}/${key}`);
+	});
+}
+function builtEntries(directory, manifest) {
+	const targets = runtimeTargets(manifest.exports);
+	if (manifest.main) targets.push({
+		entry: "main",
+		target: manifest.main
+	});
+	if (!targets.length) throw new Error(`${directory}: no published runtime entry.`);
+	return targets.filter(({ target }) => !target.endsWith(".json")).flatMap(({ entry, target }) => {
+		if (!target.includes("*")) {
+			const file = resolve(directory, target);
+			if (!existsSync(file)) throw new Error(`${directory}: missing built runtime entry ${target}.`);
+			return [{
+				entry,
+				file
+			}];
+		}
+		const prefix = resolve(directory, target.slice(0, target.indexOf("*")));
+		const parent = dirname(prefix);
+		const pattern = new RegExp(`^${resolve(directory, target).split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join("(.*)")}$`, "u");
+		if (!existsSync(parent)) throw new Error(`${directory}: missing build output for ${target}.`);
+		const output = outputRoot(directory);
+		const matches = readdirSync(parent, {
+			recursive: true,
+			withFileTypes: true
+		}).filter((file) => file.isFile()).map((file) => join(file.parentPath, file.name)).filter((file) => pattern.test(file) && !isTestSource(output, file));
+		if (!matches.length) throw new Error(`${directory}: missing built runtime entry ${target}.`);
+		return matches.sort().map((file) => {
+			const capture = pattern.exec(file)?.[1] ?? relative(directory, file);
+			return {
+				entry: entry.replaceAll("*", capture),
+				file
+			};
+		});
+	});
+}
+function childJson(args, cwd) {
+	const result = spawnSync(process.execPath, args, {
+		cwd,
+		encoding: "utf8",
+		timeout: 1e4,
+		maxBuffer: 16777216,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	if (result.error) throw result.error;
+	if (result.status !== 0) throw new Error(result.stderr || `Runtime child exited with ${result.status ?? result.signal}.`);
+	return `${JSON.stringify(JSON.parse(result.stdout), null, 2)}\n`;
+}
+function buildPackage(directory, output, manifest) {
+	const buildManifest = parseManifest(readFileSync(join(directory, "package.json"), "utf8"));
+	if (buildManifest.scripts?.build) execFileSync(packageManager(buildManifest), ["run", "build"], {
+		cwd: directory,
+		encoding: "utf8",
+		shell: process.platform === "win32",
+		env: {
+			...process.env,
+			pnpm_config_verify_deps_before_run: "false"
+		},
+		timeout: 12e4,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	let entries;
+	try {
+		entries = builtEntries(directory, manifest);
+	} catch (error) {
+		if (buildManifest.scripts?.build) throw error;
+		return;
+	}
+	for (const { entry, file } of entries) {
+		const destination = join(output, `${encodeURIComponent(entry)}.json`);
+		const metadata = childJson([
+			"-e",
+			DESCRIBE,
+			file
+		], directory);
+		mkdirSync(dirname(destination), { recursive: true });
+		writeFileSync(destination, metadata);
+	}
+	return entries.length;
+}
+/** Builds both committed revisions and compares published runtime metadata and one captured optional probe. */
+function runtimeDiff(root, baseRef, probe) {
+	const errors = [];
+	const failedPackages = /* @__PURE__ */ new Set();
+	const skippedPackages = /* @__PURE__ */ new Set();
+	const result = compareRevisions(root, baseRef, "Runtime API", (worktree, output, scratch) => {
+		const packages = packagesAt(worktree, true);
+		let entries = 0;
+		for (const { directory, manifest } of packages) try {
+			const built = buildPackage(join(worktree, directory), join(output, encodeURIComponent(directory).replaceAll(".", "%2E")), manifest);
+			if (built === void 0) skippedPackages.add(directory);
+			else entries += built;
+		} catch (error) {
+			failedPackages.add(directory);
+			errors.push(`Execution error: ${directory}: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
+		for (const directory of failedPackages) for (const side of ["base", "head"]) rmSync(join(dirname(output), side, encodeURIComponent(directory).replaceAll(".", "%2E")), {
+			recursive: true,
+			force: true
+		});
+		if (probe !== void 0) {
+			mkdirSync(scratch, { recursive: true });
+			const script = join(scratch, "probe.cjs");
+			writeFileSync(script, probe);
+			writeFileSync(join(output, "probe.json"), childJson([script, worktree], worktree));
+		}
+		return {
+			packages: packages.map(({ directory }) => directory),
+			entries
+		};
+	});
+	return {
+		different: result.different || errors.length > 0,
+		output: (errors.length && !result.different ? result.output.replace(/^Runtime API:[^\n]*\n/u, "Runtime API: comparison incomplete due to execution errors.\n") : result.output) + [...skippedPackages].map((directory) => `Runtime API: skipped ${directory}, which has no build script and no committed runtime entry.\n`).join("") + errors.join("")
+	};
+}
+//#endregion
+//#region src/guardrails/api-diff.ts
+function entrySegment(value) {
+	return encodeURIComponent(value).replaceAll(".", "%2E").replaceAll("*", "%2A");
+}
+function entryPattern(value) {
+	return value.split("*").map(entrySegment).join("*");
+}
+function exportTargets(target, entry = "exports/root") {
+	if (typeof target === "string") return [{
+		entry,
+		target
+	}];
+	if (target == null) return [];
+	if (Array.isArray(target)) return target.flatMap((value, index) => exportTargets(value, `${entry}/fallback/${index}`));
+	if (target.types !== void 0) return exportTargets(target.types, entry);
+	return Object.entries(target).flatMap(([key, value]) => {
+		return exportTargets(value, key.startsWith(".") ? key === "." ? "exports/root" : `exports/subpath/${entryPattern(key.slice(2))}` : `${entry}/condition/${entrySegment(key)}`);
+	});
+}
+function declarationTarget(target) {
+	return target.replace(/(?<!\.d)\.(mjs|cjs|js|mts|cts|tsx?|jsx)$/u, (extension) => {
+		if (extension === ".mjs" || extension === ".mts") return ".d.mts";
+		if (extension === ".cjs" || extension === ".cts") return ".d.cts";
+		return ".d.ts";
+	});
+}
+function entryPatterns(manifest) {
+	const targets = exportTargets(manifest.exports);
+	for (const key of [
+		"main",
+		"types",
+		"typings"
+	]) {
+		const target = manifest[key];
+		if (target !== void 0) targets.push({
+			entry: key,
+			target
+		});
+	}
+	for (const [version, mappings] of Object.entries(manifest.typesVersions ?? {})) for (const [entry, paths] of Object.entries(mappings)) for (const [index, target] of paths.entries()) targets.push({
+		entry: `typesVersions/${entrySegment(version)}/${entryPattern(entry)}/${index}`,
+		target
+	});
+	return targets.map(({ entry, target }) => ({
+		entry,
+		target: declarationTarget(target)
+	})).filter(({ target }) => /\.d\.[cm]?ts$/u.test(target) || target.includes("*"));
+}
+/** Export stars are substitutions rather than path globs and can span directory separators. */
+function targetPattern(target) {
+	return new RegExp(`^${target.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join("(.*)")}$`, "u");
+}
+function publishedEntries(directory, manifest, emitted, scratch) {
+	const outputRoot = resolve(directory, emitted.options.outDir ?? ".");
+	const files = emitted.files.map((file) => relative(scratch, file).split("\\").join("/"));
+	const entries = [];
+	for (const { entry, target } of entryPatterns(manifest)) {
+		if (isTestSource(outputRoot, resolve(directory, target))) continue;
+		const path = relative(outputRoot, resolve(directory, target)).split("\\").join("/");
+		const pattern = targetPattern(path);
+		const matches = files.filter((file) => pattern.test(file));
+		if (!matches.length && !path.includes("*")) throw new Error(`${directory}: published target ${target} has no emitted declaration.`);
+		for (const file of matches) {
+			const captures = pattern.exec(file)?.slice(1) ?? [];
+			let index = 0;
+			const name = entry.includes("*") ? entry.replaceAll("*", () => entrySegment(captures[index++] ?? captures[0] ?? "")) : `${entry}${captures.length ? `/file/${entrySegment(file)}` : ""}`;
+			entries.push({
+				entry: `${name}.d.ts`,
+				file
+			});
+		}
+	}
+	return entries.sort((a, b) => a.entry.localeCompare(b.entry));
+}
+function statementName(compiler, statement, source) {
+	if (compiler.isVariableStatement(statement)) return statement.declarationList.declarations[0]?.name.getText(source) ?? "";
+	if (compiler.isFunctionDeclaration(statement) || compiler.isClassDeclaration(statement) || compiler.isInterfaceDeclaration(statement) || compiler.isTypeAliasDeclaration(statement) || compiler.isEnumDeclaration(statement) || compiler.isModuleDeclaration(statement) || compiler.isImportEqualsDeclaration(statement)) return statement.name?.getText(source) ?? "default";
+	return statement.getText(source);
+}
+function normalizeBundle(compiler, text) {
+	const source = compiler.createSourceFile("bundle.d.ts", text, compiler.ScriptTarget.Latest, true);
+	const statements = [...source.statements].sort((a, b) => statementName(compiler, a, source).localeCompare(statementName(compiler, b, source)));
+	const normalized = compiler.factory.updateSourceFile(source, statements);
+	return compiler.createPrinter({
+		removeComments: true,
+		newLine: compiler.NewLineKind.LineFeed
+	}).printFile(normalized);
+}
+function bundleDependencies(directory, scratch) {
+	let current = directory;
+	while (!existsSync(join(current, "node_modules"))) {
+		const parent = dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+	symlinkSync(join(current, "node_modules"), join(scratch, "node_modules"), DIRECTORY_LINK);
+}
+/** dts-bundle-generator 9 remaps a .d.mts/.d.cts root twice; a source-named copy preserves its declaration text. */
+function generatorEntry(file) {
+	const alias = file.replace(/\.d\.([cm]ts)$/u, ".$1");
+	if (alias !== file) copyFileSync(file, alias);
+	return alias;
+}
+function bundlePackage(directory, output, scratch, manifest) {
+	const emitted = emitPackage(directory, scratch, true);
+	const entries = publishedEntries(directory, manifest, emitted, scratch);
+	if (!entries.length) return 0;
+	bundleDependencies(directory, scratch);
+	writeFileSync(join(scratch, "package.json"), readFileSync(join(directory, "package.json")));
+	const config = join(scratch, "tsconfig.json");
+	writeFileSync(config, JSON.stringify({
+		extends: join(directory, "tsconfig.json"),
+		compilerOptions: {
+			composite: false,
+			incremental: false,
+			noEmit: false,
+			rootDir: scratch
+		},
+		files: entries.map(({ file }) => join(scratch, file)),
+		include: []
+	}));
+	const bundles = generateDtsBundle(entries.map(({ file }) => ({
+		filePath: generatorEntry(join(scratch, file)),
+		output: {
+			exportReferencedTypes: false,
+			noBanner: true
+		},
+		libraries: { inlinedLibraries: [] }
+	})), { preferredConfigPath: config });
+	for (const [index, { entry }] of entries.entries()) {
+		const path = join(output, entry);
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, normalizeBundle(emitted.compiler, bundles[index]));
+	}
+	return entries.length;
+}
+function declarationDiff(root, baseRef) {
+	return compareRevisions(root, baseRef, "API", (worktree, output, scratch) => {
+		const packages = packagesAt(worktree, true);
+		let entries = 0;
+		for (const { directory, manifest } of packages) entries += bundlePackage(join(worktree, directory), join(output, directory === "." ? "_root" : directory), join(scratch, directory === "." ? "_root" : directory), manifest);
+		return {
+			packages: packages.map(({ directory }) => directory),
+			entries
+		};
+	});
+}
+/** Compares declarations and built runtime exports, with an optional behavioral probe captured before either build. */
+function apiDiff(root, baseRef, probeFile) {
+	const probe = probeFile === void 0 ? void 0 : readFileSync(resolve(root, probeFile));
+	const results = [];
+	const errors = [];
+	for (const compare of [() => declarationDiff(root, baseRef), () => runtimeDiff(root, baseRef, probe)]) try {
+		results.push(compare());
+	} catch (error) {
+		errors.push(`Execution error: ${error instanceof Error ? error.message : String(error)}\n`);
+	}
+	return {
+		different: errors.length > 0 || results.some((result) => result.different),
+		output: results.map((result) => result.output).join("") + errors.join("") + (probe === void 0 ? "No behavioural probe ran.\n" : "Behavioural probe supplied.\n") + revisionCounts(root, baseRef)
+	};
+}
+//#endregion
+//#region src/bin/api-diff.ts
+runCli(() => {
+	const args = process.argv.slice(2);
+	if (args.length !== 1 && !(args.length === 3 && args[1] === "--probe")) throw new Error("Usage: antelopejs-api-diff <base-ref> [--probe <file.cjs>]");
+	const result = apiDiff(repositoryRoot(), args[0], args[2]);
+	process.stdout.write(result.output);
+	return result.different ? 1 : 0;
+});
+//#endregion
+export {};

package/dist/bin/check-size.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as repositoryRoot, i as repositoryPath, o as runCli, t as authoredSizes } from "../files-Bocv-qA8.mjs";
-import { t as checkSize } from "../size-DJ7YSry_.mjs";
+import { i as repositoryRoot, r as repositoryPath, t as authoredSizes, u as runCli } from "../files-jKlueTMd.mjs";
+import { t as checkSize } from "../size-BdYmv57u.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";

package/dist/bin/checks.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { a as repositoryRoot, o as runCli } from "../files-Bocv-qA8.mjs";
-import { i as parseManifest, r as packageManager } from "../package-B1aipTbn.mjs";
-import { readFileSync } from "node:fs";
+import "../ceilings-BSw9p4YB.mjs";
+import { i as repositoryRoot, u as runCli } from "../files-jKlueTMd.mjs";
+import { i as parseManifest, r as packageManager } from "../package-Ckd7e4tA.mjs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 //#region src/guardrails/checks.ts
@@ -19,7 +20,8 @@ function runChecks(root) {
 	const manifest = parseManifest(readFileSync(join(root, "package.json"), "utf8"));
 	const manager = packageManager(manifest);
 	const failures = [];
-	for (const step of CHECK_STEPS) {
+	const steps = CHECK_STEPS.filter((step) => step !== "ratchet" || existsSync(join(root, "guardrails.ratchet.json")));
+	for (const step of steps) {
 		if (!manifest.scripts?.[step]) {
 			failures.push(`[${step}] Missing package.json script "${step}". Run antelopejs-sync.\n`);
 			continue;
@@ -27,6 +29,7 @@ function runChecks(root) {
 		const result = spawnSync(manager, ["run", step], {
 			cwd: root,
 			encoding: "utf8",
+			shell: process.platform === "win32",
 			env: {
 				...process.env,
 				CI: "1"
@@ -37,7 +40,7 @@ function runChecks(root) {
 	}
 	return {
 		failed: failures.length,
-		output: `${failures.join("\n")}Checks: ${CHECK_STEPS.length - failures.length} passed, ${failures.length} failed.\n`
+		output: `${failures.join("\n")}Checks: ${steps.length - failures.length} passed, ${failures.length} failed.\n`
 	};
 }
 //#endregion

package/dist/bin/comment-proof.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/bin/comment-proof.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { c as revisionCounts, i as repositoryRoot, s as compareRevisions, u as runCli } from "../files-jKlueTMd.mjs";
+import { i as packagesAt, t as emitPackage } from "../typescript-aLCrMi2y.mjs";
+import { copyFileSync, mkdirSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+//#region src/guardrails/comment-proof.ts
+/** Proves comment-free JavaScript emit matches, including private packages and excluding tests. */
+function commentProof(root, baseRef) {
+	const result = compareRevisions(root, baseRef, "Comment proof", (worktree, output, scratch) => {
+		const packages = packagesAt(worktree, false);
+		let entries = 0;
+		for (const { directory } of packages) {
+			const key = directory === "." ? "_root" : directory;
+			const emittedRoot = join(scratch, key);
+			const emitted = emitPackage(join(worktree, directory), emittedRoot, false);
+			for (const file of emitted.files) {
+				const path = join(output, key, relative(emittedRoot, file));
+				mkdirSync(dirname(path), { recursive: true });
+				copyFileSync(file, path);
+				entries++;
+			}
+		}
+		return {
+			packages: packages.map(({ directory }) => directory),
+			entries
+		};
+	});
+	return {
+		...result,
+		output: result.output + revisionCounts(root, baseRef)
+	};
+}
+//#endregion
+//#region src/bin/comment-proof.ts
+runCli(() => {
+	const args = process.argv.slice(2);
+	if (args.length !== 1) throw new Error("Usage: antelopejs-comment-proof <base-ref>");
+	const result = commentProof(repositoryRoot(), args[0]);
+	process.stdout.write(result.output);
+	return result.different ? 1 : 0;
+});
+//#endregion
+export {};

package/dist/bin/ratchet.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { o as readCeilings } from "../ceilings--pJmhSde.mjs";
-import { a as repositoryRoot, i as repositoryPath, o as runCli } from "../files-Bocv-qA8.mjs";
-import { n as ratchet, r as lintDiagnostics } from "../ratchet-B2-4XxAl.mjs";
+import { s as readCeilings, t as CEILINGS_FILE } from "../ceilings-BSw9p4YB.mjs";
+import { n as renamedPaths } from "../renames-BGO4dWJ8.mjs";
+import { a as resolveRevision, i as repositoryRoot, r as repositoryPath, u as runCli } from "../files-jKlueTMd.mjs";
+import { n as ratchet, r as lintDiagnostics } from "../ratchet-CNbpU42F.mjs";
 import { resolve } from "node:path";
 import { execFileSync } from "node:child_process";
 import { parseArgs } from "node:util";
@@ -18,6 +19,7 @@ function stagedRatchet(root, files) {
 		encoding: "utf8"
 	}).split("\0").filter(Boolean);
 	if (!targets.length) return [];
+	const renames = renamedPaths(root, true);
 	const additions = /* @__PURE__ */ new Map();
 	for (const file of targets) {
 		const diff = execFileSync("git", [
@@ -26,8 +28,9 @@ function stagedRatchet(root, files) {
 			"--no-ext-diff",
 			"--no-color",
 			"--unified=0",
+			"--find-renames",
 			"--",
-			file
+			...[renames.get(file), file].filter((path) => path !== void 0)
 		], {
 			cwd: root,
 			encoding: "utf8"
@@ -46,17 +49,21 @@ runCli(() => {
 	const { values, positionals } = parseArgs({
 		options: {
 			update: { type: "boolean" },
-			staged: { type: "boolean" }
+			staged: { type: "boolean" },
+			base: { type: "string" }
 		},
 		allowPositionals: true
 	});
 	const root = repositoryRoot();
+	if (values.base !== void 0 && values.staged) throw new Error("--base cannot be combined with --staged.");
 	if (values.update && values.staged) throw new Error("--staged cannot be combined with --update.");
 	if (positionals.length && !values.staged) throw new Error("File arguments require --staged.");
 	const result = values.staged ? {
 		failures: stagedRatchet(root, positionals.length ? positionals.map((file) => repositoryPath(root, resolve(file))) : void 0),
-		lowered: []
-	} : ratchet(root, values.update);
+		lowered: [],
+		retired: false
+	} : ratchet(root, values.update, values.base === void 0 ? void 0 : resolveRevision(root, values.base));
+	if (result.retired) process.stdout.write(`Deleted ${CEILINGS_FILE}: no debt left. Run antelopejs-sync.\n`);
 	for (const message of result.lowered) process.stdout.write(`Lowered ${message}\n`);
 	for (const message of result.failures) process.stderr.write(`${message}\n`);
 	if (!result.failures.length) process.stdout.write("Ratchet: within ceilings.\n");