@antelopejs/tooling-configs 0.2.1 → 0.2.2

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
 
@@ -174,9 +176,28 @@ pnpm install
 - 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.
 - `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, 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,165 @@
+#!/usr/bin/env node
+import { a as runCli, i as repositoryRoot } from "../files-DAD5OtfV.mjs";
+import { i as compareRevisions, n as isTestSource, r as packagesAt, t as emitPackage } from "../typescript-CHOlkIXa.mjs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { generateDtsBundle } from "dts-bundle-generator";
+//#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"), "dir");
+}
+/** 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;
+}
+/** Proves published declarations match between a base commit and committed HEAD. */
+function apiDiff(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
+		};
+	});
+}
+//#endregion
+//#region src/bin/api-diff.ts
+runCli(() => {
+	const args = process.argv.slice(2);
+	if (args.length !== 1) throw new Error("Usage: antelopejs-api-diff <base-ref>");
+	const result = apiDiff(repositoryRoot(), args[0]);
+	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 { a as runCli, i as repositoryRoot, r as repositoryPath, t as authoredSizes } from "../files-DAD5OtfV.mjs";
+import { t as checkSize } from "../size-D7JJp_W4.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 { a as runCli, i as repositoryRoot } from "../files-DAD5OtfV.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;
@@ -37,7 +39,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,39 @@
+#!/usr/bin/env node
+import { a as runCli, i as repositoryRoot } from "../files-DAD5OtfV.mjs";
+import { i as compareRevisions, r as packagesAt, t as emitPackage } from "../typescript-CHOlkIXa.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) {
+	return 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
+		};
+	});
+}
+//#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,7 @@
 #!/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 { a as runCli, i as repositoryRoot, r as repositoryPath } from "../files-DAD5OtfV.mjs";
+import { n as ratchet, r as lintDiagnostics } from "../ratchet-B2_QUucT.mjs";
 import { resolve } from "node:path";
 import { execFileSync } from "node:child_process";
 import { parseArgs } from "node:util";
@@ -55,8 +55,10 @@ runCli(() => {
 	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: []
+		lowered: [],
+		retired: false
 	} : ratchet(root, values.update);
+	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");

package/dist/bin/sync.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { a as formatCeilings, t as CEILINGS_FILE } from "../ceilings--pJmhSde.mjs";
-import { a as repositoryRoot, o as runCli } from "../files-Bocv-qA8.mjs";
-import { a as repositoryTools, i as parseManifest, n as managedPackage, o as toolingVersions, r as packageManager, t as execCommand } from "../package-B1aipTbn.mjs";
-import { t as measureBaseline } from "../ratchet-B2-4XxAl.mjs";
+import { a as formatCeilings, o as isRetired, s as readCeilings, t as CEILINGS_FILE } from "../ceilings-BSw9p4YB.mjs";
+import { a as runCli, i as repositoryRoot } from "../files-DAD5OtfV.mjs";
+import { a as repositoryTools, i as parseManifest, n as managedPackage, o as toolingVersions, r as packageManager, t as execCommand } from "../package-Ckd7e4tA.mjs";
+import { t as measureBaseline } from "../ratchet-B2_QUucT.mjs";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
@@ -20,6 +20,9 @@ Hold every test you write or keep to this checklist:
 - Name the wrong implementation this test fails on. A test with no answer is deleted, not kept.
 - No test reads the file it tests. Drive the behaviour through the public interface.
 - An invariant over many files is a lint rule, not a test.`;
+const CLEANUP_PROOF = `### Cleanup proof
+
+A behaviour-preserving cleanup PR shows \`antelopejs-api-diff <base-ref>\` passing. Published declarations stay unchanged. A comment-only PR shows \`antelopejs-comment-proof <base-ref>\` passing instead of a verifier. Both compare committed HEAD.`;
 const SHARED_RULES = [
 	["Formatting", "oxfmt"],
 	["Lint findings are errors; no rule warns", "oxlint preset"],
@@ -28,11 +31,12 @@ const SHARED_RULES = [
 	["Tests read no files outside fixtures, helpers, locales", "`antelopejs/no-fs-read-in-tests`"],
 	["No assertion that restates a constant", "`antelopejs/no-constant-value-assertion`"],
 	["No test whose only check is \"is a function\"", "`antelopejs/no-typeof-function-only-test`"],
-	["Params ≤ 5, function ≤ 120 lines, file ≤ 500 lines, depth ≤ 4, complexity ≤ 20", "`eslint/max-*`, `eslint/complexity`"]
+	["Params ≤ 5, function ≤ 120 lines, file ≤ 500 lines, depth ≤ 4, complexity ≤ 20", "`eslint/max-*`, `eslint/complexity`"],
+	["Cleanup preserves published declarations", "`antelopejs-api-diff <base-ref>`"],
+	["Comment-only changes preserve JavaScript emit", "`antelopejs-comment-proof <base-ref>`"]
 ];
 const FULL_RULES = [
 	["Files ≤ 20,000 bytes, tests included", "`antelopejs-check-size` (pre-commit)"],
-	["Existing debt only shrinks", "`antelopejs-ratchet`"],
 	["Types check", "`tsc` (pre-push)"],
 	["No dead files, exports, or dependencies", "knip"],
 	["Managed files match the pack", "`antelopejs-sync --check`"],
@@ -62,7 +66,7 @@ function fullBody(context) {
 	return [
 		"## Guardrails",
 		"",
-		"Finish every change with `pnpm run checks`. It runs typecheck, lint, format, knip, tests, size, ratchet, and sync, and prints only what failed. The change is done when it prints no failure.",
+		`Finish every change with \`pnpm run checks\`. It runs typecheck, lint, format, knip, tests, size, ${context.ratchet ? "ratchet, " : ""}and sync, and prints only what failed. The change is done when it prints no failure.`,
 		"",
 		...pointers(context).flatMap((line) => [line, ""]),
 		"The tools enforce most rules, listed in the table at the end. The sections below hold the rules no tool checks.",
@@ -71,11 +75,19 @@ function fullBody(context) {
 		"",
 		TESTS,
 		"",
-		"### Debt",
-		"",
-		"`guardrails.ratchet.json` records the lint findings and oversize files this repository already had. Its numbers only go down. After you remove debt, run `pnpm run ratchet:update` and commit the lowered file. A rule listed there is off for `oxlint`. The ratchet counts it instead, and the pre-commit hook rejects it on every line you add.",
+		CLEANUP_PROOF,
 		"",
-		ruleTable([...SHARED_RULES, ...FULL_RULES])
+		...context.ratchet ? [
+			"### Debt",
+			"",
+			"`guardrails.ratchet.json` records the lint findings and oversize files this repository already had. Its numbers only go down. After you remove debt, run `pnpm run ratchet:update` and commit the lowered file. A rule listed there is off for `oxlint`. The ratchet counts it instead, and the pre-commit hook rejects it on every line you add.",
+			""
+		] : [],
+		ruleTable([
+			...SHARED_RULES,
+			...FULL_RULES,
+			...context.ratchet ? [["Existing debt only shrinks", "`antelopejs-ratchet`"]] : []
+		])
 	];
 }
 function templateBody(context) {
@@ -89,6 +101,8 @@ function templateBody(context) {
 		"",
 		TESTS,
 		"",
+		CLEANUP_PROOF,
+		"",
 		ruleTable(SHARED_RULES)
 	];
 }
@@ -140,7 +154,7 @@ function presetConfig(current, preset, tools) {
 	const importLine = preset.content.split("\n").filter((line) => line.includes(preset.specifier)).join("\n").replace(preset.specifier, target);
 	throw new Error(`${preset.path} does not import its preset. Add \`${importLine}\` and extend that preset, then rerun antelopejs-sync. The file was not replaced.`);
 }
-function lefthook(current, manager, tools) {
+function lefthook(current, manager, tools, ratchet = true) {
 	const exec = execCommand(manager);
 	const document = parseDocument(current ?? "{}\n");
 	if (document.errors.length) throw new Error(`lefthook.yml: ${document.errors.map(({ message }) => message).join("; ")}`);
@@ -176,6 +190,11 @@ function lefthook(current, manager, tools) {
 			key
 		], document.createNode(command));
 	}
+	if (!ratchet) document.deleteIn([
+		"pre-commit",
+		"commands",
+		"antelopejs-ratchet"
+	]);
 	return document.toString({ lineWidth: 0 });
 }
 const SETUP_SCRIPT = `#!/usr/bin/env bash
@@ -241,6 +260,7 @@ function hasChecksWorkflow(root) {
 //#endregion
 //#region src/guardrails/sync.ts
 const LEGACY_COMMENT_INSTRUCTION = "- Explain non-obvious constraints and decisions in comments; avoid restating the code. Document public contracts with TSDoc.";
+const RETIRED_RATCHET = `${CEILINGS_FILE} has no debt left. Run ratchet:update to delete it, then run antelopejs-sync.`;
 function managedAgents(current = "", context) {
 	const start = current.indexOf(AGENTS_BLOCK_START);
 	const end = current.indexOf(AGENTS_BLOCK_END);
@@ -273,7 +293,7 @@ const MANAGED_ARTIFACTS = [
 		path: "lefthook.yml",
 		profiles: ["full"],
 		desired: (current, context) => ({
-			content: lefthook(current, context.manager, context.tools),
+			content: lefthook(current, context.manager, context.tools, context.ratchet),
 			notes: []
 		})
 	},
@@ -333,6 +353,7 @@ function planSync(current, modes, context) {
 	});
 	for (const artifact of MANAGED_ARTIFACTS) {
 		if (!artifact.profiles.includes(context.profile)) continue;
+		if (artifact.path === "guardrails.ratchet.json" && !context.ratchet) continue;
 		try {
 			const { content, notes } = artifact.desired(current.get(artifact.path), context);
 			const changed = current.get(artifact.path) !== content || artifact.mode !== void 0 && (artifact.mode & 73) !== 0 && ((modes.get(artifact.path) ?? 0) & 73) === 0;
@@ -407,6 +428,7 @@ function repositoryContext(root, current, profile) {
 	const desiredLint = current.get(lint.path) ?? lint.content;
 	return {
 		profile,
+		ratchet: current.has(CEILINGS_FILE),
 		manager: packageManager(manifest),
 		versions: toolingVersions(),
 		tools: repositoryTools(manifest),
@@ -427,6 +449,13 @@ function writeArtifacts(root, artifacts) {
 		if (artifact.mode !== void 0) chmodSync(path, artifact.mode);
 	}
 }
+function repositoryNotices(root, context) {
+	const notices = [];
+	if (context.profile === "full" && !hasChecksWorkflow(root)) notices.push(MISSING_CHECKS_WORKFLOW);
+	if (context.ratchet && isRetired(readCeilings(root))) notices.push(RETIRED_RATCHET);
+	return notices;
+}
+/** Measures debt only on first adoption, before sync has written the sync:check script; retired repositories stay retired. */
 function syncRepository(root, options = {}) {
 	const profile = options.profile ?? "full";
 	const { current, modes } = repositorySnapshot(root);
@@ -435,14 +464,13 @@ function syncRepository(root, options = {}) {
 	let plan = planSync(current, modes, context);
 	const errors = plan.filter((artifact) => artifact.kind === "error").map(({ message }) => message);
 	const notes = plan.flatMap((artifact) => artifact.kind === "migrated" ? artifact.notes : []);
-	if (profile === "full" && !hasChecksWorkflow(root)) {
-		if (options.check) errors.push(MISSING_CHECKS_WORKFLOW);
-		else notes.push(MISSING_CHECKS_WORKFLOW);
-	}
-	if (!errors.length && profile === "full" && !options.check && !current.has("guardrails.ratchet.json")) {
+	(options.check ? errors : notes).push(...repositoryNotices(root, context));
+	if (!errors.length && profile === "full" && !options.check && !current.has("guardrails.ratchet.json") && manifest.scripts?.["sync:check"] === void 0) {
 		const lint = PRESET_CONFIGS[0];
 		const desired = presetConfig(current.get(lint.path), lint, context.tools);
-		context.baseline = formatCeilings(measureBaseline(root, desired === current.get(lint.path) ? void 0 : desired));
+		const baseline = measureBaseline(root, desired === current.get(lint.path) ? void 0 : desired);
+		context.ratchet = !isRetired(baseline);
+		context.baseline = formatCeilings(baseline);
 		plan = planSync(current, modes, context);
 	}
 	const writes = plan.filter((artifact) => artifact.kind === "write" || artifact.kind === "migrated");

package/dist/{ceilings--pJmhSde.mjs → ceilings-BSw9p4YB.mjs}

@@ -14,6 +14,10 @@ const EMPTY_CEILINGS = {
 	rules: {},
 	oversizeFiles: {}
 };
+/** A repository retires its ratchet once no lint or file debt remains. */
+function isRetired(ceilings) {
+	return Object.values(ceilings.rules).every((count) => count === 0) && Object.keys(ceilings.oversizeFiles).length === 0;
+}
 /** Finds the nearest git directory or worktree marker, falling back to cwd outside git. */
 function findGitRoot(cwd = process.cwd()) {
 	let directory = resolve(cwd);
@@ -61,4 +65,4 @@ function formatCeilings(ceilings) {
 	return `${JSON.stringify(sorted, null, 2)}\n`;
 }
 //#endregion
-export { formatCeilings as a, findGitRoot as i, MAX_FILE_BYTES as n, readCeilings as o, MEASURE_ENV as r, CEILINGS_FILE as t };
+export { formatCeilings as a, findGitRoot as i, MAX_FILE_BYTES as n, isRetired as o, MEASURE_ENV as r, readCeilings as s, CEILINGS_FILE as t };

package/dist/{files-Bocv-qA8.mjs → files-DAD5OtfV.mjs}

@@ -1,5 +1,6 @@
+import "./ceilings-BSw9p4YB.mjs";
 import { n as IGNORE_PATTERNS, t as AGENT_IGNORE_PATTERNS } from "./shared-NC0T8ykm.mjs";
-import { existsSync, lstatSync } from "node:fs";
+import { closeSync, existsSync, lstatSync, openSync, readSync } from "node:fs";
 import { join, matchesGlob, relative, resolve } from "node:path";
 import { execFileSync, spawnSync } from "node:child_process";
 //#region src/guardrails/cli.ts
@@ -28,6 +29,16 @@ const SIZE_EXCLUSIONS = [
 		kind: "fixtures",
 		patterns: ["**/fixtures/**", "**/__fixtures__/**"]
 	},
+	{
+		kind: "data",
+		patterns: [
+			"**/locales/**/*.json",
+			"**/i18n/**/*.json",
+			"**/blocks.json",
+			"**/schema.json",
+			"**/evals/**/cases.json"
+		]
+	},
 	{
 		kind: "lockfiles",
 		patterns: [
@@ -89,15 +100,30 @@ function isExcluded(file) {
 	const undotted = file.replace(/(^|\/)\./gu, "$1");
 	return SIZE_EXCLUSIONS.some(({ patterns }) => patterns.some((pattern) => matchesGlob(file, pattern) || matchesGlob(undotted, pattern)));
 }
+function isBinary(root, file, staged) {
+	if (staged) return execFileSync("git", ["show", `:${file}`], {
+		cwd: root,
+		maxBuffer: fileBytes(root, file, true)
+	}).subarray(0, 8e3).includes(0);
+	const descriptor = openSync(join(root, file), "r");
+	try {
+		const prefix = Buffer.alloc(8e3);
+		const length = readSync(descriptor, prefix, 0, prefix.length, 0);
+		return prefix.subarray(0, length).includes(0);
+	} finally {
+		closeSync(descriptor);
+	}
+}
 function authoredSizes(root, files = gitFiles(root), staged = false) {
 	const sizes = /* @__PURE__ */ new Map();
 	for (const input of files) {
 		const file = repositoryPath(root, input);
 		if (isExcluded(file)) continue;
 		const size = fileBytes(root, file, staged);
+		if (size !== void 0 && size > 2e4 && isBinary(root, file, staged)) continue;
 		if (size !== void 0) sizes.set(file, size);
 	}
 	return sizes;
 }
 //#endregion
-export { repositoryRoot as a, repositoryPath as i, fileBytes as n, runCli as o, gitFiles as r, authoredSizes as t };
+export { runCli as a, repositoryRoot as i, gitFiles as n, repositoryPath as r, authoredSizes as t };

package/dist/oxc/lint.mjs

@@ -1,4 +1,4 @@
-import { i as findGitRoot, o as readCeilings } from "../ceilings--pJmhSde.mjs";
+import { i as findGitRoot, s as readCeilings } from "../ceilings-BSw9p4YB.mjs";
 import { n as TEST_FILE_GLOBS, t as ASSERTION_FUNCTION_NAMES } from "../shared-WC0z3y9F.mjs";
 import { n as IGNORE_PATTERNS, t as AGENT_IGNORE_PATTERNS } from "../shared-NC0T8ykm.mjs";
 import { defineConfig } from "oxlint";

package/dist/{package-B1aipTbn.mjs → package-Ckd7e4tA.mjs}

@@ -101,6 +101,10 @@ function managedPackage(current, versions, options = {}) {
 		"ratchet:update": `${tools.commands.ratchet} --update`,
 		"sync:check": `${tools.commands.sync} --check`
 	});
+	if (options.ratchet === false) {
+		delete scripts.ratchet;
+		delete scripts["ratchet:update"];
+	}
 	for (const [name, command] of Object.entries(DEFAULT_SCRIPTS)) scripts[name] ??= name === "typecheck" && options.nuxt ? "nuxi typecheck" : command;
 	const dependencies = manifest.devDependencies ??= {};
 	dependencies.lefthook ??= versions.lefthook;

package/dist/{ratchet-B2-4XxAl.mjs → ratchet-B2_QUucT.mjs}

@@ -1,8 +1,8 @@
-import { a as formatCeilings, n as MAX_FILE_BYTES, o as readCeilings, r as MEASURE_ENV, t as CEILINGS_FILE } from "./ceilings--pJmhSde.mjs";
-import { i as repositoryPath, n as fileBytes, r as gitFiles, t as authoredSizes } from "./files-Bocv-qA8.mjs";
-import { n as sizeFailure } from "./size-DJ7YSry_.mjs";
+import { a as formatCeilings, n as MAX_FILE_BYTES, o as isRetired, r as MEASURE_ENV, s as readCeilings, t as CEILINGS_FILE } from "./ceilings-BSw9p4YB.mjs";
+import { n as gitFiles, r as repositoryPath, t as authoredSizes } from "./files-DAD5OtfV.mjs";
+import { n as sizeFailure } from "./size-D7JJp_W4.mjs";
 import { createRequire } from "node:module";
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { execFileSync, spawnSync } from "node:child_process";
 //#region src/guardrails/oxlint.ts
@@ -77,11 +77,12 @@ function lintDiagnostics(root, config, files) {
 function baseline(root, diagnostics) {
 	const rules = {};
 	const oversizeFiles = {};
+	const sizes = authoredSizes(root);
 	for (const diagnostic of diagnostics) if (diagnostic.rule === "eslint/max-lines") {
-		const size = fileBytes(root, diagnostic.file);
+		const size = sizes.get(diagnostic.file);
 		if (size !== void 0) oversizeFiles[diagnostic.file] = size;
 	} else rules[diagnostic.rule] = (rules[diagnostic.rule] ?? 0) + 1;
-	for (const [file, size] of authoredSizes(root)) if (size > 2e4) oversizeFiles[file] = size;
+	for (const [file, size] of sizes) if (size > 2e4) oversizeFiles[file] = size;
 	return {
 		rules,
 		oversizeFiles
@@ -154,18 +155,22 @@ function ratchet(root, update = false) {
 		if (shown.length < matches.length) failures.push(`  ...and ${matches.length - shown.length} recorded in files this change does not touch.`);
 	}
 	for (const [file, size] of Object.entries(current.oversizeFiles)) if (ceilings.oversizeFiles[file] === void 0) failures.push(size > 2e4 ? sizeFailure(file, size, MAX_FILE_BYTES) : `${file}: ${size} bytes and an eslint/max-lines diagnostic; this file has no oversize allowance. Split by responsibility into sibling modules, or split tests by behaviour under test, one file per describe.`);
+	const sizes = authoredSizes(root, Object.keys(ceilings.oversizeFiles));
 	for (const [file, limit] of Object.entries(ceilings.oversizeFiles)) {
-		const size = fileBytes(root, file);
+		const size = sizes.get(file);
 		if (size !== void 0 && size > limit) failures.push(sizeFailure(file, size, limit));
 	}
 	const lowered = update ? lowerCeilings(ceilings, current) : [];
+	const retired = update && isRetired(ceilings);
 	if (update) {
 		const path = join(root, CEILINGS_FILE);
-		writeFileSync(path, formatCeilings(ceilings));
+		if (retired) unlinkSync(path);
+		else writeFileSync(path, formatCeilings(ceilings));
 	}
 	return {
 		failures,
-		lowered
+		lowered,
+		retired
 	};
 }
 //#endregion

package/dist/{size-DJ7YSry_.mjs → size-D7JJp_W4.mjs}

@@ -1,5 +1,5 @@
-import { o as readCeilings } from "./ceilings--pJmhSde.mjs";
-import { t as authoredSizes } from "./files-Bocv-qA8.mjs";
+import { s as readCeilings } from "./ceilings-BSw9p4YB.mjs";
+import { t as authoredSizes } from "./files-DAD5OtfV.mjs";
 //#region src/guardrails/size.ts
 function sizeFailure(file, size, limit) {
 	return `${file}: ${size} bytes, ${size - limit} bytes over the ${limit}-byte ceiling. Split by responsibility into sibling modules, one cohesive group of exports each; keep the original path re-exporting only if it is a public entry point. Split a test file by behaviour under test, one file per describe. Do not minify, strip whitespace, or move code under an excluded path to pass.`;

package/dist/typescript-CHOlkIXa.mjs

@@ -0,0 +1,202 @@
+import { n as TEST_FILE_GLOBS } from "./shared-WC0z3y9F.mjs";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, matchesGlob, relative, sep } from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+//#region src/guardrails/revisions.ts
+function trackedManifests(root) {
+	return execFileSync("git", ["ls-files", "-z"], {
+		cwd: root,
+		encoding: "utf8"
+	}).split("\0").filter((file) => file === "package.json" || file.endsWith("/package.json"));
+}
+function linkDependencies(root, worktree) {
+	const directories = /* @__PURE__ */ new Set([".", ...trackedManifests(root).map(dirname)]);
+	for (const directory of directories) {
+		const source = join(root, directory, "node_modules");
+		const target = join(worktree, directory, "node_modules");
+		if (existsSync(source) && existsSync(dirname(target)) && !existsSync(target)) symlinkSync(source, target, "dir");
+	}
+}
+/** Compares isolated committed revisions and removes both worktrees even when compilation fails. */
+function compareRevisions(root, baseRef, label, emit) {
+	const temporary = mkdtempSync(join(tmpdir(), "antelope-proof-"));
+	const worktrees = [];
+	const results = [];
+	try {
+		for (const [side, ref] of [["base", baseRef], ["head", "HEAD"]]) {
+			const revision = execFileSync("git", [
+				"rev-parse",
+				"--verify",
+				"--end-of-options",
+				`${ref}^{commit}`
+			], {
+				cwd: root,
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			}).trim();
+			const worktree = join(temporary, "worktrees", side);
+			execFileSync("git", [
+				"worktree",
+				"add",
+				"--quiet",
+				"--detach",
+				worktree,
+				revision
+			], {
+				cwd: root,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			worktrees.push(worktree);
+			linkDependencies(root, worktree);
+			const output = join(temporary, side);
+			mkdirSync(output, { recursive: true });
+			results.push(emit(worktree, output, join(temporary, "emit", side)));
+		}
+		const diff = spawnSync("git", [
+			"diff",
+			"--no-index",
+			"--no-color",
+			"--no-renames",
+			"--no-ext-diff",
+			"--no-textconv",
+			"--",
+			"base",
+			"head"
+		], {
+			cwd: temporary,
+			encoding: "utf8",
+			maxBuffer: 67108864
+		});
+		if (diff.error) throw diff.error;
+		if (diff.status !== 0 && diff.status !== 1) throw new Error(diff.stderr || "Could not compare revision outputs.");
+		const packages = new Set(results.flatMap((result) => result.packages)).size;
+		return {
+			different: diff.status === 1,
+			output: diff.status === 1 ? `${label}: differences against ${baseRef} (committed HEAD).\n${diff.stdout}` : `${label}: ${packages} packages, ${results[1].entries} entries unchanged against ${baseRef} (committed HEAD).\n`
+		};
+	} finally {
+		for (const worktree of worktrees.reverse()) execFileSync("git", [
+			"worktree",
+			"remove",
+			"--force",
+			worktree
+		], {
+			cwd: root,
+			stdio: "pipe"
+		});
+		rmSync(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+//#region src/guardrails/typescript.ts
+function packagesAt(root, publishedOnly) {
+	return trackedManifests(root).flatMap((file) => {
+		const directory = dirname(file);
+		if (!existsSync(join(root, directory, "tsconfig.json"))) return [];
+		const manifest = JSON.parse(readFileSync(join(root, file), "utf8"));
+		if (publishedOnly && manifest.private === true) return [];
+		return [{
+			directory,
+			manifest
+		}];
+	});
+}
+/** Loads the consumer's compiler, including a package-local installation in a workspace. */
+function loadTypeScript(directory) {
+	return createRequire(join(directory, "package.json"))("typescript");
+}
+function isTestSource(root, file) {
+	const path = relative(root, file).split("\\").join("/");
+	return TEST_FILE_GLOBS.some((pattern) => matchesGlob(path, pattern));
+}
+function failDiagnostics(compiler, diagnostics) {
+	const errors = diagnostics.filter((item) => item.category === compiler.DiagnosticCategory.Error);
+	if (errors.length) throw new Error(compiler.formatDiagnostics(errors, {
+		getCanonicalFileName: (file) => file,
+		getCurrentDirectory: () => process.cwd(),
+		getNewLine: () => "\n"
+	}));
+}
+/** Declaration inputs are part of the local closure but TypeScript does not emit copies of them. */
+function copyDeclarations(program, directory, output) {
+	const sources = program.getSourceFiles().filter((source) => !program.isSourceFileDefaultLibrary(source) && !program.isSourceFileFromExternalLibrary(source) && !relative(directory, source.fileName).startsWith(`..${sep}`) && !isTestSource(directory, source.fileName));
+	const authored = sources.filter((source) => !source.isDeclarationFile);
+	let root = dirname((authored[0] ?? sources[0])?.fileName ?? join(directory, "index.ts"));
+	for (const source of authored.length ? authored : sources) while (relative(root, source.fileName).startsWith(`..${sep}`)) root = dirname(root);
+	root = program.getCompilerOptions().rootDir ?? root;
+	const files = [];
+	for (const source of sources) {
+		if (!source.isDeclarationFile) continue;
+		const path = relative(root, source.fileName);
+		if (path.startsWith(`..${sep}`)) continue;
+		const target = join(output, path);
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, source.text);
+		files.push(target);
+	}
+	return files;
+}
+/** Emits with the package's compiler and config; test roots and outputs never enter either proof. */
+function emitPackage(directory, output, declarations) {
+	const compiler = loadTypeScript(directory);
+	const configPath = join(directory, "tsconfig.json");
+	const config = compiler.readConfigFile(configPath, compiler.sys.readFile);
+	if (config.error) failDiagnostics(compiler, [config.error]);
+	const parsed = compiler.parseJsonConfigFileContent(config.config, compiler.sys, directory);
+	failDiagnostics(compiler, parsed.errors);
+	const options = {
+		...parsed.options,
+		rootDir: parsed.options.rootDir ?? (parsed.options.outDir ? void 0 : directory),
+		outDir: output,
+		declarationDir: declarations ? output : void 0,
+		declaration: declarations,
+		emitDeclarationOnly: declarations,
+		removeComments: true,
+		declarationMap: false,
+		sourceMap: false,
+		inlineSourceMap: false,
+		noEmit: false,
+		noEmitOnError: false,
+		composite: false,
+		incremental: false,
+		tsBuildInfoFile: void 0,
+		outFile: void 0,
+		allowImportingTsExtensions: declarations ? parsed.options.allowImportingTsExtensions : false
+	};
+	const program = compiler.createProgram({
+		rootNames: parsed.fileNames.filter((file) => !isTestSource(directory, file)),
+		options,
+		projectReferences: parsed.projectReferences
+	});
+	if (declarations) failDiagnostics(compiler, compiler.getPreEmitDiagnostics(program));
+	const files = [];
+	const result = program.emit(void 0, (file, text, _bom, _onError, sources) => {
+		if (sources?.some((source) => isTestSource(directory, source.fileName))) return;
+		if (declarations ? !/\.d\.[cm]?ts$/.test(file) : !/\.[cm]?jsx?$/.test(file)) return;
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(file, text);
+		files.push(file);
+	});
+	if (declarations) failDiagnostics(compiler, result.diagnostics);
+	if (declarations) files.push(...copyDeclarations(program, directory, output));
+	return {
+		compiler,
+		files,
+		options: parsed.options
+	};
+}
+//#endregion
+export { compareRevisions as i, isTestSource as n, packagesAt as r, emitPackage as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/tooling-configs",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Shared tooling presets for AntelopeJS repositories: oxlint (with the vendored anti-slop rules), oxfmt, ESLint for Nuxt layers, Knip, and an interface range check",
   "keywords": [
     "antelopejs",
@@ -21,9 +21,11 @@
     "url": "git+https://github.com/AntelopeJS/tooling-configs.git"
   },
   "bin": {
+    "antelopejs-api-diff": "./dist/bin/api-diff.mjs",
     "antelopejs-check-interface-ranges": "./dist/bin/check-interface-ranges.mjs",
     "antelopejs-check-size": "./dist/bin/check-size.mjs",
     "antelopejs-checks": "./dist/bin/checks.mjs",
+    "antelopejs-comment-proof": "./dist/bin/comment-proof.mjs",
     "antelopejs-ratchet": "./dist/bin/ratchet.mjs",
     "antelopejs-sync": "./dist/bin/sync.mjs"
   },
@@ -55,15 +57,14 @@
     "checks": "node src/bin/checks.ts",
     "format:check": "oxfmt --check .",
     "size": "node src/bin/check-size.ts",
-    "ratchet": "node src/bin/ratchet.ts",
     "prepare": "if git rev-parse --is-inside-work-tree >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1; then lefthook install; fi",
     "sync": "node src/bin/sync.ts",
-    "ratchet:update": "node src/bin/ratchet.ts --update",
     "sync:check": "node src/bin/sync.ts --check",
     "knip": "knip"
   },
   "dependencies": {
     "@oxlint/plugins": "1.81.0",
+    "dts-bundle-generator": "^9.5.1",
     "yaml": "^2.9.1"
   },
   "devDependencies": {