@stll/oxlint-config 0.12.2 → 0.14.1

package/dist/typecheck-parity-cli.mjs

@@ -1,912 +1,48 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-import { readFileSync, realpathSync, statSync } from "node:fs";
-import { spawnSync } from "node:child_process";
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { performance } from "node:perf_hooks";
-import { stripVTControlCharacters } from "node:util";
-//#region src/typecheck-parity.ts
-const fixtures = [
-	{
-		name: "module-detection",
-		flags: ["noUnusedLocals"],
-		files: { "input.ts": "const unused = 1;" },
-		codes: [6133]
-	},
-	{
-		name: "skip-declaration-check",
-		flags: ["skipLibCheck"],
-		files: { "input.d.ts": "export declare const value: MissingType;" },
-		codes: []
-	},
-	{
-		name: "json-import",
-		flags: ["resolveJsonModule"],
-		files: {
-			"data.json": "{ \"name\": \"value\" }",
-			"input.ts": "import data from \"./data.json\"; export const value: string = data.name;"
-		},
-		codes: []
-	},
-	{
-		name: "interop-import",
-		flags: ["esModuleInterop"],
-		files: {
-			"types.d.cts": "declare const value: string; export = value;",
-			"input.ts": "import value from \"./types.cjs\"; export const result: string = value;"
-		},
-		codes: []
-	},
-	{
-		name: "valid-control",
-		flags: [],
-		files: { "input.ts": "export const value: string = \"correct\";" },
-		codes: []
-	},
-	{
-		name: "type-mismatch",
-		flags: [],
-		files: { "input.ts": "export const value: number = \"wrong\";" },
-		codes: [2322]
-	},
-	{
-		name: "missing-property",
-		flags: [],
-		files: { "input.ts": "export const value: { name: string } = {};" },
-		codes: [2741]
-	},
-	{
-		name: "strict-null",
-		flags: ["strictNullChecks"],
-		files: { "input.ts": "export const value: string = null;" },
-		codes: [2322]
-	},
-	{
-		name: "unchecked-index",
-		flags: ["noUncheckedIndexedAccess"],
-		files: { "input.ts": "export const value: string = [\"value\"][1];" },
-		codes: [2322]
-	},
-	{
-		name: "unused-local",
-		flags: ["noUnusedLocals"],
-		files: { "input.ts": "const unused = 1; export {};" },
-		codes: [6133]
-	},
-	{
-		name: "unused-parameter",
-		flags: ["noUnusedParameters"],
-		files: { "input.ts": "export const value = (unused: string) => 1;" },
-		codes: [6133]
-	},
-	{
-		name: "implicit-any",
-		flags: ["noImplicitAny"],
-		files: { "input.ts": "export const value = (input) => input;" },
-		codes: [7006]
-	},
-	{
-		name: "missing-import",
-		flags: [],
-		files: { "input.ts": "import { value } from \"./missing.js\"; export { value };" },
-		codes: [2307]
-	},
-	{
-		name: "side-effect-import",
-		flags: ["noUncheckedSideEffectImports"],
-		files: { "input.ts": "import \"./missing.js\";" },
-		codes: [2882]
-	},
-	{
-		name: "generic-constraint",
-		flags: [],
-		files: { "input.ts": "type Box<T extends string> = { value: T }; export type Value = Box<number>;" },
-		codes: [2344]
-	},
-	{
-		name: "exact-optional",
-		flags: ["exactOptionalPropertyTypes"],
-		files: { "input.ts": "export const value: { optional?: string } = { optional: undefined };" },
-		codes: [2375]
-	},
-	{
-		name: "fallthrough",
-		flags: ["noFallthroughCasesInSwitch"],
-		files: { "input.ts": "export const run = (value: number) => { switch (value) { case 0: value++; case 1: return value; default: return 0; } };" },
-		codes: [7029]
-	},
-	{
-		name: "implicit-override",
-		flags: ["noImplicitOverride"],
-		files: { "input.ts": "class Base { value = 1; } export class Child extends Base { value = 2; }" },
-		codes: [4114]
-	},
-	{
-		name: "implicit-return",
-		flags: ["noImplicitReturns"],
-		files: { "input.ts": "export const run = (value: boolean) => { if (value) return 1; };" },
-		codes: [7030]
-	},
-	{
-		name: "unknown-catch",
-		flags: ["useUnknownInCatchVariables"],
-		files: { "input.ts": "export const run = () => { try { return 1; } catch (error) { return error.message; } };" },
-		codes: [18046]
-	},
-	{
-		name: "index-property",
-		flags: ["noPropertyAccessFromIndexSignature"],
-		files: { "input.ts": "export const run = (value: Record<string, string>) => value.name;" },
-		codes: [4111]
-	},
-	{
-		name: "erasable-syntax",
-		flags: ["erasableSyntaxOnly"],
-		files: { "input.ts": "export enum Value { First }" },
-		codes: [1294]
-	},
-	{
-		name: "type-only-import",
-		flags: ["verbatimModuleSyntax"],
-		files: {
-			"types.ts": "export type Value = string;",
-			"input.ts": "import { Value } from \"./types.js\"; export const value: Value = \"value\";"
-		},
-		codes: [1484]
-	},
-	{
-		name: "checked-javascript",
-		flags: ["allowJs", "checkJs"],
-		files: { "input.js": "/** @type {number} */\nexport const value = \"wrong\";" },
-		codes: [2322]
-	},
-	{
-		name: "strict-function",
-		flags: ["strictFunctionTypes"],
-		files: { "input.ts": "export const value: (input: string | number) => void = (input: string) => { input.toUpperCase(); };" },
-		codes: [2322]
-	},
-	{
-		name: "strict-initialization",
-		flags: ["strictPropertyInitialization"],
-		files: { "input.ts": "export class Value { name: string; }" },
-		codes: [2564]
-	},
-	{
-		name: "strict-bind",
-		flags: ["strictBindCallApply"],
-		files: { "input.ts": "const value = (input: string) => input; export const result = value.call(undefined, 1);" },
-		codes: [2345]
-	},
-	{
-		name: "implicit-this",
-		flags: ["noImplicitThis"],
-		files: { "input.ts": "export function value() { return this.name; }" },
-		codes: [2683]
-	},
-	{
-		name: "strict-iterator",
-		flags: ["strictBuiltinIteratorReturn"],
-		files: { "input.ts": "export const value: string = [\"value\"].values().next().value;" },
-		codes: [2322]
-	},
-	{
-		name: "always-strict",
-		flags: ["alwaysStrict"],
-		files: { "input.ts": "export const value = (eval: string) => eval;" },
-		codes: [1215]
-	},
-	{
-		name: "file-casing",
-		flags: ["forceConsistentCasingInFileNames"],
-		files: {
-			"named.ts": "export const name = \"value\";",
-			"Named.ts": "export const name = \"value\";",
-			"input.ts": "import { name } from \"./named.js\"; import { name as other } from \"./Named.js\"; export const value = name + other;"
-		},
-		codes: [1149, 1261],
-		anyCode: true
-	}
-];
-const diagnosticCodes = (text) => [...new Set([...text.matchAll(/(?:TS|(?:error|warning)\s+)(\d{4,5})/g)].map((match) => Number(match.at(1))))].sort((a, b) => a - b);
-const diagnosticParity = ({ expected, match, baseline, candidate }) => {
-	const tscCodes = diagnosticCodes(baseline.output);
-	const bunCodes = diagnosticCodes(candidate.output);
-	const seeded = match === "any" ? expected.some((code) => tscCodes.includes(code)) : expected.every((code) => tscCodes.includes(code));
-	const missing = tscCodes.filter((code) => !bunCodes.includes(code));
-	const extra = bunCodes.filter((code) => !tscCodes.includes(code));
-	const exitsMatch = expected.length === 0 ? baseline.status === 0 && candidate.status === 0 && tscCodes.length === 0 && bunCodes.length === 0 : baseline.status !== null && baseline.status !== 0 && candidate.status !== null && candidate.status !== 0;
-	return {
-		tscCodes,
-		bunCodes,
-		missing,
-		extra,
-		passed: seeded && exitsMatch && baseline.status === candidate.status && missing.length === 0 && extra.length === 0
-	};
-};
-const configurationDiagnostics = (output, repo) => diagnosticSet(output, repo).filter((diagnostic) => /^(?:<config>:0:|.*\.json:[0-9]+:)(?:[56][0-9]{3}|1800[23]|2688)(?::|$)/.test(diagnostic) || /:1800[23](?::|$)/.test(diagnostic));
-const fixtureParity = (options) => {
-	const result = diagnosticParity(options);
-	const { baseline, candidate, expected, match } = options;
-	const identityParity = compareDiagnosticSets({
-		status: baseline.status,
-		diagnostics: diagnosticSet(baseline.output, options.repo ?? process.cwd())
-	}, {
-		status: candidate.status,
-		diagnostics: diagnosticSet(candidate.output, options.repo ?? process.cwd())
-	});
-	const configDiagnostics = [...configurationDiagnostics(baseline.output, options.repo ?? process.cwd()).map((diagnostic) => `TypeScript: ${diagnostic}`), ...configurationDiagnostics(candidate.output, options.repo ?? process.cwd()).map((diagnostic) => `Bun: ${diagnostic}`)];
-	const seedFiles = new Set(options.seedFiles.map((file) => resolve(options.repo ?? process.cwd(), file)));
-	const seededCodes = new Set(diagnosticSet(baseline.output, options.repo ?? process.cwd()).flatMap((diagnostic) => {
-		const diagnosticMatch = /^(.*):[0-9]+:([0-9]+)$/.exec(diagnostic);
-		const file = diagnosticMatch?.at(1);
-		const code = diagnosticMatch?.at(2);
-		return file !== void 0 && code !== void 0 && seedFiles.has(resolve(options.repo ?? process.cwd(), file)) ? [Number(code)] : [];
-	}));
-	const active = expected.length > 0 && (match === "any" ? expected.some((code) => seededCodes.has(code)) : expected.every((code) => seededCodes.has(code)));
-	const validExits = baseline.status !== null && candidate.status !== null && (result.tscCodes.length === 0 ? baseline.status === 0 : baseline.status !== 0) && (result.bunCodes.length === 0 ? candidate.status === 0 : candidate.status !== 0);
-	return {
-		...result,
-		active,
-		configurationDiagnostics: configDiagnostics,
-		identityMissing: identityParity.missing,
-		identityExtra: identityParity.extra,
-		passed: configDiagnostics.length === 0 && identityParity.passed && validExits && baseline.status === candidate.status && result.missing.length === 0 && result.extra.length === 0
-	};
-};
-const fixtureRunPassed = (results) => results.some(({ active }) => active) && results.every(({ passed }) => passed);
-const diagnosticLocation = (file, repo) => {
-	const normalized = file.replaceAll("\\", "/");
-	const bundled = /^bundled:\/\/\/libs\/(lib\.[^/]+\.d\.ts)$/.exec(normalized);
-	const installed = /(?:^|\/)node_modules\/(?:typescript|@typescript\/(?:native|typescript-[^/]+))\/(?:.*\/)?(lib\.[^/]+\.d\.ts)$/.exec(normalized);
-	const library = bundled?.at(1) ?? installed?.at(1);
-	return library === void 0 ? relative(repo, resolve(repo, file)).replaceAll("\\", "/") : `<lib>/${library}`;
-};
-const globalDiagnosticKey = (code, message) => `<config>:0:${code}:${message.trim().replaceAll(/\s+/g, " ")}`;
-const diagnosticSet = (output, repo) => {
-	const clean = stripVTControlCharacters(output);
-	const diagnostics = /* @__PURE__ */ new Set();
-	for (const block of clean.matchAll(/<error\b([^>]*)>([\s\S]*?)<\/error>/g)) {
-		const attributes = new Map([...(block.at(1) ?? "").matchAll(/(\w+)="([^"]*)"/g)].map((match) => [match.at(1), match.at(2)]));
-		const file = attributes.get("file");
-		const row = attributes.get("line");
-		const code = attributes.get("code");
-		if (code === void 0 || !/^TS\d+$/.test(code)) continue;
-		if (file !== void 0 && row !== void 0 && row !== "0") diagnostics.add(`${diagnosticLocation(file, repo)}:${row}:${code.slice(2)}`);
-		else {
-			const message = (block.at(2) ?? "").split(/<(?:source|related)\b/).at(0) ?? "";
-			diagnostics.add(globalDiagnosticKey(code.slice(2), message));
-		}
-	}
-	for (const line of clean.split("\n")) {
-		if (line.startsWith("<error ")) continue;
-		const match = /^(.*?)\((\d+),\d+\):\s*(?:error|warning) TS(\d+)/.exec(line) ?? /^(.*?):(\d+):\d+:\s*(?:error|warning) (?:TS)?(\d+)/.exec(line);
-		if (match) {
-			const [, file = "", row = "", code = ""] = match;
-			diagnostics.add(`${diagnosticLocation(file, repo)}:${row}:${code}`);
-		} else {
-			const global = /^(?:error|warning) TS(\d+):\s*(.*)/.exec(line);
-			if (global) diagnostics.add(globalDiagnosticKey(global.at(1) ?? "", global.at(2) ?? ""));
-		}
-	}
-	return [...diagnostics].sort();
-};
-const compareDiagnosticSets = (baseline, candidate) => {
-	const missing = baseline.diagnostics.filter((item) => !candidate.diagnostics.includes(item));
-	const extra = candidate.diagnostics.filter((item) => !baseline.diagnostics.includes(item));
-	const valid = (result) => result.status !== null && (result.diagnostics.length === 0 ? result.status === 0 : result.status !== 0);
-	return {
-		missing,
-		extra,
-		passed: valid(baseline) && valid(candidate) && baseline.status === candidate.status && missing.length === 0 && extra.length === 0
-	};
-};
-const assertUnshadowedCheck = async (repo) => {
-	const manifest = JSON.parse(await readFile(join(repo, "package.json"), "utf8"));
-	if (typeof manifest !== "object" || manifest === null) throw new Error("Invalid repository package.json");
-	if ("scripts" in manifest && typeof manifest.scripts === "object" && manifest.scripts !== null && "check" in manifest.scripts) throw new Error("Repository package.json must not define a \"check\" script: it shadows Bun typechecking; rename that script before running parity");
-};
-const resolveCompiler = async (repo, policy) => {
-	if (typeof policy !== "object" || policy === null || !("typescriptInstallLayouts" in policy) || !Array.isArray(policy.typescriptInstallLayouts)) throw new Error("toolchain.json must define typescriptInstallLayouts");
-	const manifest = JSON.parse(await readFile(join(repo, "package.json"), "utf8"));
-	if (typeof manifest !== "object" || manifest === null) throw new Error("Invalid repository package.json");
-	const dependencies = /* @__PURE__ */ new Map();
-	for (const key of ["dependencies", "devDependencies"]) {
-		if (!(key in manifest)) continue;
-		const section = Reflect.get(manifest, key);
-		if (typeof section === "object" && section !== null) for (const [name, specifier] of Object.entries(section)) dependencies.set(name, specifier);
-	}
-	const require = createRequire(join(repo, "package.json"));
-	for (const layout of [...policy.typescriptInstallLayouts].reverse()) {
-		if (typeof layout !== "object" || layout === null || !("compilerPackage" in layout) || typeof layout.compilerPackage !== "string") throw new Error("Invalid TypeScript install layout");
-		if (!dependencies.has(layout.compilerPackage)) continue;
-		const packagePath = require.resolve(`${layout.compilerPackage}/package.json`);
-		const installed = JSON.parse(await readFile(packagePath, "utf8"));
-		if (typeof installed !== "object" || installed === null || !("bin" in installed) || typeof installed.bin !== "object" || installed.bin === null || !("tsc" in installed.bin) || typeof installed.bin.tsc !== "string") throw new Error(`${layout.compilerPackage} must expose a tsc binary`);
-		if (!("compilerSpecifier" in layout) || typeof layout.compilerSpecifier !== "string") throw new Error("TypeScript install layout must define compilerSpecifier");
-		const expectedVersion = layout.compilerSpecifier.replace(/^npm:typescript@/, "");
-		if (!("version" in installed) || installed.version !== expectedVersion) throw new Error(`${layout.compilerPackage} must install TypeScript ${expectedVersion}`);
-		return resolve(packagePath, "..", installed.bin.tsc);
-	}
-	throw new Error("Repository must declare a compiler from typescriptInstallLayouts");
-};
-const assertBunVersion = (bun, policy) => {
-	if (typeof policy !== "object" || policy === null || !("bun" in policy) || typeof policy.bun !== "string") throw new Error("toolchain.json must define bun");
-	const result = spawnSync(bun, ["--version"], { encoding: "utf8" });
-	if (result.error) throw result.error;
-	const installed = result.stdout.trim();
-	if (result.status !== 0 || installed !== policy.bun) throw new Error(`Bun must be ${policy.bun}; selected runtime reports ${installed || "no version"}`);
-};
-const bunCheckArgs = (project, build = false) => [
-	"check",
-	"--no-pretty",
-	"--all",
-	...build ? ["--build"] : [],
-	...project === void 0 ? [] : [`--project=${project}`]
-];
-const canonicalOptions = (value) => {
-	if (Array.isArray(value)) return `[${value.map(canonicalOptions).join(",")}]`;
-	if (typeof value === "object" && value !== null) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalOptions(Reflect.get(value, key))}`).join(",")}}`;
-	if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new Error("Invalid effective compiler option");
-	return JSON.stringify(value);
-};
-const EMIT_ONLY_OPTIONS = /* @__PURE__ */ new Set([
-	"composite",
-	"declaration",
-	"declarationDir",
-	"declarationMap",
-	"emitDeclarationOnly",
-	"outDir",
-	"outFile",
-	"rootDir",
-	"sourceMap",
-	"inlineSourceMap",
-	"inlineSources",
-	"incremental",
-	"tsBuildInfoFile",
-	"noEmitOnError",
-	"importHelpers",
-	"noEmitHelpers",
-	"emitBOM",
-	"mapRoot",
-	"sourceRoot",
-	"newLine",
-	"preserveConstEnums",
-	"removeComments",
-	"stripInternal",
-	"downlevelIteration",
-	"isolatedDeclarations",
-	"noEmit"
-]);
-const resolvedCompilerOptions = ({ compilerOptions, configPath }) => {
-	if (typeof compilerOptions !== "object" || compilerOptions === null || Array.isArray(compilerOptions)) throw new Error(`Invalid compiler options: ${configPath}`);
-	const options = Object.fromEntries(Object.entries(compilerOptions));
-	const directory = dirname(configPath);
-	const rootDir = options["rootDir"];
-	if (rootDir !== void 0 && typeof rootDir !== "string") throw new Error(`Invalid rootDir: ${configPath}`);
-	if (typeof rootDir === "string") options["rootDir"] = resolve(directory, rootDir);
-	let resolutionDirectory = directory;
-	const absolutePaths = (value) => {
-		if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) throw new Error(`Invalid compiler path option: ${configPath}`);
-		return value.map((entry) => resolve(resolutionDirectory, entry));
-	};
-	for (const name of ["rootDirs", "typeRoots"]) if (name in options) options[name] = absolutePaths(options[name]);
-	if ("baseUrl" in options) {
-		const baseUrl = options["baseUrl"];
-		if (typeof baseUrl !== "string") throw new Error(`Invalid baseUrl: ${configPath}`);
-		resolutionDirectory = resolve(directory, baseUrl);
-		options["baseUrl"] = resolutionDirectory;
-	}
-	if ("paths" in options) {
-		const paths = options["paths"];
-		if (typeof paths !== "object" || paths === null || Array.isArray(paths)) throw new Error(`Invalid paths: ${configPath}`);
-		options["paths"] = Object.fromEntries(Object.entries(paths).map(([key, value]) => [key, absolutePaths(value)]));
-	}
-	return options;
-};
-const fixtureCompilerOptions = (args) => {
-	const options = Object.fromEntries(Object.entries(resolvedCompilerOptions(args)).filter(([name]) => !EMIT_ONLY_OPTIONS.has(name)));
-	options["noEmit"] = true;
-	return options;
-};
-const fixtureInputs = ({ files, compilerOptions }) => {
-	const inputs = files.filter((file) => /\.(?:[cm]?[jt]sx?|json)$/.test(file));
-	for (const input of inputs) {
-		if (/\.[cm]?jsx?$/.test(input) && compilerOptions["allowJs"] !== true) return {
-			status: "inapplicable",
-			reason: `${input} requires allowJs`
-		};
-		if (input.endsWith(".json") && compilerOptions["resolveJsonModule"] !== true) return {
-			status: "inapplicable",
-			reason: `${input} requires resolveJsonModule`
-		};
-	}
-	return {
-		status: "applicable",
-		files: inputs
-	};
-};
-const fixturePackageContext = (configPath) => {
-	for (let folder = dirname(configPath);; folder = dirname(folder)) {
-		try {
-			const manifest = JSON.parse(readFileSync(join(folder, "package.json"), "utf8"));
-			if (typeof manifest !== "object" || manifest === null) throw new Error(`Invalid package.json: ${folder}`);
-			if (!("type" in manifest)) return {};
-			if (manifest.type !== "module" && manifest.type !== "commonjs") throw new Error(`Invalid package type: ${folder}`);
-			return { type: manifest.type };
-		} catch (error) {
-			if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
-		}
-		if (dirname(folder) === folder) return {};
-	}
-};
-const groupCompilerConfigs = (configs) => {
-	const groups = /* @__PURE__ */ new Map();
-	for (const config of configs) {
-		const compilerOptions = fixtureCompilerOptions({
-			compilerOptions: config.compilerOptions,
-			configPath: config.path
-		});
-		const key = canonicalOptions({
-			compilerOptions,
-			resolutionContext: "typeRoots" in compilerOptions ? null : dirname(config.path),
-			packageContext: config.packageContext ?? {}
-		});
-		const existing = groups.get(key);
-		if (existing) existing.projects.push(config.path);
-		else groups.set(key, {
-			path: config.path,
-			projects: [config.path],
-			compilerOptions: config.compilerOptions,
-			...config.packageContext === void 0 ? {} : { packageContext: config.packageContext }
-		});
-	}
-	return [...groups.values()];
-};
-const discoverConfigGroups = ({ repo, compiler, project }) => {
-	const configs = [];
-	const visited = /* @__PURE__ */ new Set();
-	const projects = [];
-	let build = false;
-	const visit = (inputPath) => {
-		const path = realpathSync(statSync(inputPath).isDirectory() ? join(inputPath, "tsconfig.json") : inputPath);
-		readFileSync(path, "utf8");
-		if (visited.has(path)) return;
-		visited.add(path);
-		const result = spawnSync(process.execPath, [
-			compiler,
-			"--showConfig",
-			"--project",
-			path
-		], {
-			cwd: repo,
-			encoding: "utf8",
-			maxBuffer: 64 * 1024 * 1024
-		});
-		if (result.error) throw result.error;
-		if (result.status !== 0) throw new Error(result.stdout + result.stderr);
-		const config = JSON.parse(result.stdout);
-		if (typeof config !== "object" || config === null) throw new Error(`Invalid resolved config: ${path}`);
-		const references = "references" in config && Array.isArray(config.references) ? config.references : [];
-		build ||= project === void 0 && references.length > 0;
-		const compilerOptions = "compilerOptions" in config ? config.compilerOptions : {};
-		if (typeof compilerOptions !== "object" || compilerOptions === null || Array.isArray(compilerOptions)) throw new Error(`Invalid compiler options: ${path}`);
-		const rawFiles = "files" in config ? config.files : [];
-		if (!Array.isArray(rawFiles)) throw new Error(`Invalid project files: ${path}`);
-		const files = rawFiles.map((file) => {
-			if (typeof file !== "string") throw new Error(`Invalid project file: ${path}`);
-			return resolve(dirname(path), file);
-		});
-		if (files.length === 0 && (project !== void 0 || references.length === 0)) throw new Error(`Project resolves to zero input files: ${path}`);
-		const referencePaths = [];
-		const resolvedReferences = [];
-		projects.push({
-			path,
-			compilerOptions,
-			files,
-			references: referencePaths,
-			resolvedReferences
-		});
-		if (files.length > 0 || references.length === 0) configs.push({
-			path,
-			compilerOptions,
-			packageContext: fixturePackageContext(path)
-		});
-		for (const reference of references) {
-			if (typeof reference !== "object" || reference === null || !("path" in reference) || typeof reference.path !== "string") throw new Error(`Invalid project reference: ${path}`);
-			const referencedProject = resolve(dirname(path), reference.path);
-			const referencePath = realpathSync(statSync(referencedProject).isDirectory() ? join(referencedProject, "tsconfig.json") : referencedProject);
-			referencePaths.push(referencePath);
-			resolvedReferences.push({
-				...reference,
-				path: referencePath
-			});
-			if (project === void 0) visit(referencePath);
-		}
-	};
-	const selected = resolve(repo, project ?? "tsconfig.json");
-	const root = realpathSync(statSync(selected).isDirectory() ? join(selected, "tsconfig.json") : selected);
-	visit(root);
-	const groups = groupCompilerConfigs(configs);
-	if (groups.length === 0) throw new Error("No consumer compiler configurations to compare");
-	return {
-		build,
-		groups,
-		projects,
-		root
-	};
-};
-const discoverProjectGraphs = ({ repo, compiler, projects }) => {
-	if (projects === void 0) return [discoverConfigGroups({
-		repo,
-		compiler
-	})];
-	if (projects.length === 0) throw new Error("Select at least one project");
-	const graphs = /* @__PURE__ */ new Map();
-	for (const project of projects) {
-		const graph = discoverConfigGroups({
-			repo,
-			compiler,
-			project
-		});
-		if (!graphs.has(graph.root)) graphs.set(graph.root, graph);
-	}
-	return [...graphs.values()];
-};
-const timedCommand = ({ command, args, repo }) => {
-	const started = performance.now();
-	const result = spawnSync("/usr/bin/time", [
-		process.platform === "darwin" ? "-l" : "-v",
-		command,
-		...args
-	], {
-		cwd: repo,
-		encoding: "utf8",
-		maxBuffer: 64 * 1024 * 1024
-	});
-	if (result.error) throw result.error;
-	const rss = process.platform === "darwin" ? /([0-9]+)\s+maximum resident set size/.exec(result.stderr) : /Maximum resident set size \(kbytes\):\s*([0-9]+)/.exec(result.stderr);
-	if (!rss) throw new Error("Cannot measure maximum RSS with /usr/bin/time");
-	return {
-		status: result.status,
-		output: result.stdout + result.stderr,
-		wall: (performance.now() - started) / 1e3,
-		maxRssKiB: Number(rss[1]) / (process.platform === "darwin" ? 1024 : 1)
-	};
-};
-const NO_WORK_MAX_RSS_KIB = 16 * 1024;
-const NO_WORK_MAX_WALL_SECONDS = .25;
-const sourceDiagnosticSet = ({ output, repo, scratch, configPaths }) => {
-	const configs = new Set(configPaths.map((path) => resolve(path)));
-	const invalid = new Set(configurationDiagnostics(output, repo));
-	return diagnosticSet(output, repo).filter((diagnostic) => {
-		if (invalid.has(diagnostic)) return false;
-		if (diagnostic.startsWith("<config>:")) return true;
-		const file = /^(.*):[0-9]+:[0-9]+$/.exec(diagnostic)?.at(1);
-		if (file === void 0) return false;
-		const path = resolve(repo, file);
-		return !configs.has(path) && path !== scratch && !path.startsWith(scratch + "/");
-	});
-};
-const diagnosticExitStatus = ({ status, output, repo }) => status === 2 && configurationDiagnostics(output, repo).length === 0 && diagnosticSet(output, repo).some((diagnostic) => !diagnostic.startsWith("<config>:")) ? 1 : status;
-const repositoryDiagnosticComparison = ({ baseline, candidate, repo, scratch, configPaths }) => {
-	const configs = new Set(configPaths.map((path) => resolve(path)));
-	const configurationErrors = (output) => [.../* @__PURE__ */ new Set([...configurationDiagnostics(output, repo), ...diagnosticSet(output, repo).filter((diagnostic) => {
-		const file = /^(.*):[0-9]+:[0-9]+$/.exec(diagnostic)?.at(1);
-		return file !== void 0 && configs.has(resolve(repo, file));
-	})])];
-	const configurationErrorsFound = [...configurationErrors(baseline.output).map((diagnostic) => `TypeScript: ${diagnostic}`), ...configurationErrors(candidate.output).map((diagnostic) => `Bun: ${diagnostic}`)];
-	const diagnostics = (output) => sourceDiagnosticSet({
-		output,
-		repo,
-		scratch,
-		configPaths
-	});
-	const comparison = compareDiagnosticSets({
-		status: baseline.status,
-		diagnostics: diagnostics(baseline.output)
-	}, {
-		status: candidate.status,
-		diagnostics: diagnostics(candidate.output)
-	});
-	return {
-		...comparison,
-		passed: configurationErrorsFound.length === 0 && comparison.passed,
-		configurationDiagnostics: configurationErrorsFound
-	};
-};
-const temporaryProjectTree = async ({ scratch, projects }) => {
-	const contexts = /* @__PURE__ */ new Map();
-	const linkedFolders = /* @__PURE__ */ new Set();
-	for (const project of projects) {
-		const path = join(scratch, "projects", relative(resolve("/"), project));
-		const folder = dirname(path);
-		await mkdir(folder, { recursive: true });
-		for (let original = dirname(project);; original = dirname(original)) {
-			if (!linkedFolders.has(original)) {
-				linkedFolders.add(original);
-				const modules = join(original, "node_modules");
-				try {
-					if (statSync(modules).isDirectory()) {
-						const destination = join(scratch, "projects", relative(resolve("/"), original));
-						await mkdir(destination, { recursive: true });
-						await symlink(modules, join(destination, "node_modules"), "dir");
-					}
-				} catch (error) {
-					if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
-				}
-			}
-			if (dirname(original) === original) break;
-		}
-		contexts.set(project, {
-			path,
-			folder,
-			outputFolder: join(folder, `${basename(path)}.parity-output`)
-		});
-	}
-	return contexts;
-};
-const compareRepository = async ({ repo, compiler, bun, graph }) => {
-	const scratch = await mkdtemp(join(tmpdir(), "parity-repository-"));
-	try {
-		const contexts = await temporaryProjectTree({
-			scratch,
-			projects: graph.projects.map(({ path }) => path)
-		});
-		const configPaths = new Map([...contexts].map(([original, context]) => [original, context.path]));
-		const requiredOutputs = new Set(graph.projects.flatMap(({ references }) => references));
-		for (const project of graph.projects) {
-			const context = contexts.get(project.path);
-			if (context === void 0) throw new Error(`Missing temporary project: ${project.path}`);
-			const { path: configPath, outputFolder } = context;
-			const options = resolvedCompilerOptions({
-				configPath: project.path,
-				compilerOptions: project.compilerOptions
-			});
-			const declarationsRequired = graph.build && requiredOutputs.has(project.path) && options["composite"] === true;
-			options["noEmit"] = !graph.build || options["noEmit"] === true && !declarationsRequired;
-			const relocatesOutput = options["noEmit"] !== true || "outDir" in options || "declarationDir" in options;
-			if (!("rootDir" in options) && relocatesOutput) options["rootDir"] = dirname(project.path);
-			if (relocatesOutput) options["outDir"] = join(outputFolder, "output");
-			const emitsDeclarations = options["declaration"] === true || options["composite"] === true && options["declaration"] !== false;
-			if (graph.build && emitsDeclarations || "declarationDir" in options) options["declarationDir"] = join(outputFolder, "declarations");
-			if (graph.build || options["incremental"] === true || options["composite"] === true) options["tsBuildInfoFile"] = join(outputFolder, "project.tsbuildinfo");
-			if (graph.build) {
-				options["declarationMap"] = false;
-				if (emitsDeclarations) options["emitDeclarationOnly"] = true;
-				options["noEmitOnError"] = false;
-			}
-			if ("outFile" in options) options["outFile"] = join(outputFolder, "bundle.js");
-			await writeFile(configPath, JSON.stringify({
-				compilerOptions: options,
-				files: project.files,
-				include: [],
-				references: graph.build ? project.references.map((path) => {
-					const temporary = configPaths.get(path);
-					if (temporary === void 0) throw new Error(`Missing referenced temporary project: ${path}`);
-					return { path: temporary };
-				}) : project.resolvedReferences
-			}));
-		}
-		const root = configPaths.get(graph.root);
-		if (root === void 0) throw new Error("Missing temporary root config");
-		const baselineRaw = timedCommand({
-			command: process.execPath,
-			args: [
-				compiler,
-				...graph.build ? [
-					"--build",
-					"--force",
-					root
-				] : [
-					"--noEmit",
-					"--project",
-					root
-				],
-				"--pretty",
-				"false"
-			],
-			repo
-		});
-		const candidate = timedCommand({
-			command: bun,
-			args: bunCheckArgs(root, graph.build),
-			repo
-		});
-		const sourceDiagnostics = (output) => sourceDiagnosticSet({
-			output,
-			repo,
-			scratch,
-			configPaths: graph.projects.map(({ path }) => path)
-		});
-		const baselineDiagnostics = sourceDiagnostics(baselineRaw.output);
-		const baseline = {
-			...baselineRaw,
-			rawStatus: baselineRaw.status,
-			status: diagnosticExitStatus({
-				status: baselineRaw.status,
-				output: baselineRaw.output,
-				repo
-			}),
-			diagnostics: baselineDiagnostics
-		};
-		const repository = repositoryDiagnosticComparison({
-			baseline,
-			candidate,
-			repo,
-			scratch,
-			configPaths: [...graph.projects.map(({ path }) => path), ...configPaths.values()]
-		});
-		return {
-			baseline,
-			candidate: {
-				...candidate,
-				rawStatus: candidate.status,
-				diagnostics: sourceDiagnostics(candidate.output)
-			},
-			repository
-		};
-	} finally {
-		await rm(scratch, {
-			recursive: true,
-			force: true
-		});
-	}
-};
-const runTypecheckParity = async ({ repo, policy, bun = process.versions.bun ? process.execPath : "bun", projects }) => {
-	await assertUnshadowedCheck(repo);
-	assertBunVersion(bun, policy);
-	const compiler = await resolveCompiler(repo, policy);
-	const graphs = discoverProjectGraphs({
-		repo,
-		compiler,
-		projects
-	});
-	const results = [];
-	for (const graph of graphs) results.push(await runConfigParity({
-		repo,
-		compiler,
-		bun,
-		graph
-	}));
-	return results.every((passed) => passed);
-};
-const runConfigParity = async ({ repo, compiler, bun, graph }) => {
-	const { groups } = graph;
-	const { baseline, candidate, repository } = await compareRepository({
-		repo,
-		compiler,
-		bun,
-		graph
-	});
-	console.log("Class | TypeScript diagnostics | Bun diagnostics | Result");
-	console.log(`repository | ${baseline.diagnostics.join(",")} | ${candidate.diagnostics.join(",")} | ${repository.passed ? "PASS" : "FAIL"}`);
-	console.log(`repository tsc: wall=${baseline.wall.toFixed(3)}s maxRSS=${baseline.maxRssKiB}KiB exit=${baseline.rawStatus}`);
-	console.log(`repository bun: wall=${candidate.wall.toFixed(3)}s maxRSS=${candidate.maxRssKiB}KiB exit=${candidate.rawStatus}`);
-	for (const diagnostic of repository.configurationDiagnostics) console.error(`FAIL: invalid repository configuration: ${diagnostic}`);
-	const scratch = await mkdtemp(join(tmpdir(), "typecheck-parity-"));
-	const groupResults = [];
-	try {
-		for (const [index, group] of groups.entries()) {
-			console.log(`Config group ${index + 1}: ${relative(repo, group.path)} (${group.projects.length} projects)`);
-			const results = [];
-			let tscWall = 0;
-			let bunWall = 0;
-			let tscRss = 0;
-			let bunRss = 0;
-			const context = (await temporaryProjectTree({
-				scratch: join(scratch, `config-${index + 1}`),
-				projects: [group.path]
-			})).get(group.path);
-			if (context === void 0) throw new Error(`Missing temporary fixture context: ${group.path}`);
-			const groupFolder = context.folder;
-			const compilerOptions = fixtureCompilerOptions({
-				compilerOptions: group.compilerOptions,
-				configPath: group.path
-			});
-			await writeFile(join(groupFolder, "package.json"), JSON.stringify(group.packageContext ?? fixturePackageContext(group.path)));
-			for (const fixture of fixtures) {
-				const inputs = fixtureInputs({
-					files: Object.keys(fixture.files),
-					compilerOptions
-				});
-				if (inputs.status === "inapplicable") {
-					console.log(`${fixture.name} (inactive under this config: ${inputs.reason}) | | | INACTIVE`);
-					continue;
-				}
-				const folder = join(groupFolder, fixture.name);
-				await mkdir(folder);
-				await writeFile(join(folder, "tsconfig.json"), JSON.stringify({
-					compilerOptions,
-					files: inputs.files,
-					include: [],
-					exclude: []
-				}));
-				for (const [name, content] of Object.entries(fixture.files)) await writeFile(join(folder, name), content);
-				const tsc = timedCommand({
-					command: process.execPath,
-					args: [
-						compiler,
-						"--noEmit",
-						"--pretty",
-						"false",
-						"-p",
-						folder
-					],
-					repo: folder
-				});
-				const checked = timedCommand({
-					command: bun,
-					args: [...bunCheckArgs(folder), "--threads=1"],
-					repo: folder
-				});
-				const result = fixtureParity({
-					seedFiles: inputs.files,
-					expected: fixture.codes,
-					match: fixture.anyCode ? "any" : "all",
-					repo: folder,
-					baseline: {
-						...tsc,
-						status: diagnosticExitStatus({
-							status: tsc.status,
-							output: tsc.output,
-							repo: folder
-						})
-					},
-					candidate: checked
-				});
-				results.push(result);
-				tscWall += tsc.wall;
-				bunWall += checked.wall;
-				tscRss = Math.max(tscRss, tsc.maxRssKiB);
-				bunRss = Math.max(bunRss, checked.maxRssKiB);
-				if (result.configurationDiagnostics.length > 0) {
-					console.error(`FAIL: invalid fixture configuration for ${fixture.name}: ${result.configurationDiagnostics.join("; ")}`);
-					console.log(`${fixture.name} | configuration error | configuration error | FAIL`);
-					continue;
-				}
-				let outcome = "INACTIVE";
-				if (result.active) outcome = result.passed ? "PASS" : "FAIL";
-				console.log(`${fixture.name}${result.active ? "" : " (inactive under this config)"} | ${result.tscCodes.join(",")} | ${result.bunCodes.join(",")} | ${outcome}`);
-				if (!result.active && !result.passed) console.error(`FAIL: diagnostic comparison differs for inactive class ${fixture.name}: TypeScript exit=${tsc.status}, Bun exit=${checked.status}; missing=${result.identityMissing.join(",")}; extra=${result.identityExtra.join(",")}`);
-				if (result.active && result.bunCodes.length === 0) {
-					console.error(`FAIL: Bun returned zero diagnostics for active class ${fixture.name} (exit ${checked.status})`);
-					if (checked.maxRssKiB <= NO_WORK_MAX_RSS_KIB && checked.wall <= NO_WORK_MAX_WALL_SECONDS) console.error(`Bun measured little checker work: wall=${checked.wall.toFixed(3)}s maxRSS=${checked.maxRssKiB}KiB; verify the checker invocation`);
-				}
-			}
-			console.log(`fixtures tsc: wall=${tscWall.toFixed(3)}s maxRSS=${tscRss}KiB`);
-			console.log(`fixtures bun: wall=${bunWall.toFixed(3)}s maxRSS=${bunRss}KiB`);
-			if (!results.some(({ active }) => active)) console.error(`FAIL: zero seeded fixture classes active under config group ${index + 1}`);
-			groupResults.push(fixtureRunPassed(results));
-		}
-	} finally {
-		await rm(scratch, {
-			recursive: true,
-			force: true
-		});
-	}
-	return repository.passed && groupResults.every((passed) => passed);
-};
-//#endregion
+import { n as runTypecheckParity } from "./typecheck-parity.mjs";
+import { t as detectToolchainChanges } from "./toolchain-changed.mjs";
+import { readFile } from "node:fs/promises";
 //#region src/typecheck-parity-args.ts
-const parityUsage = "Usage: stll-typecheck-parity [--project <tsconfig>]... (run from repository root)\n       stll-typecheck-parity --help";
+const parityUsage = "Usage: stll-typecheck-parity [--changed-since <git-ref>] [--project <tsconfig>]... (run from repository root)\n       stll-typecheck-parity --help";
 const parseParityArguments = (args) => {
 	if (args.length === 1 && args.at(0) === "--help") return { mode: "help" };
 	const projects = [];
+	let changedSince;
 	for (let index = 0; index < args.length; index += 1) {
 		const project = args.at(index + 1);
-		if (args.at(index) !== "--project" || project === void 0 || project.trim() === "" || project.startsWith("--")) throw new Error(parityUsage);
-		projects.push(project);
+		const option = args.at(index);
+		if (option !== "--project" && option !== "--changed-since" || project === void 0 || project.trim() === "" || project.startsWith("--")) throw new Error(parityUsage);
+		if (option === "--project") projects.push(project);
+		else {
+			if (changedSince !== void 0) throw new Error(parityUsage);
+			changedSince = project;
+		}
 		index += 1;
 	}
-	return projects.length === 0 ? { mode: "default" } : {
+	return projects.length === 0 ? {
+		mode: "default",
+		...changedSince === void 0 ? {} : { changedSince }
+	} : {
 		mode: "selected",
-		projects
+		projects,
+		...changedSince === void 0 ? {} : { changedSince }
 	};
 };
 //#endregion
+//#region src/typecheck-parity-selection.ts
+/** CI forcing considers every tool; compiler parity includes Bun, TS, and unclassified shared declarations. */
+const runSelectedTypecheckParity = async ({ repo, since, run, detect = detectToolchainChanges, output = (text) => process.stdout.write(text) }) => {
+	if (since === void 0) return run();
+	const result = await detect({
+		repo,
+		since
+	});
+	if (result.status === "unreadable") return run();
+	if (result.tools.some((tool) => tool === "bun" || tool === "typescript" || tool === "shared")) return run();
+	output(`parity skipped: toolchain unchanged since ${since} (bun ${result.current.bun.join(", ") || "not declared"}, typescript ${result.current.typescript.join(", ") || "not declared"})\n`);
+	return true;
+};
+//#endregion
 //#region src/typecheck-parity-cli.ts
 const main = async () => {
 	const args = parseParityArguments(process.argv.slice(2));
@@ -915,10 +51,14 @@ const main = async () => {
 		return;
 	}
 	const policy = JSON.parse(await readFile(new URL("../toolchain.json", import.meta.url), "utf8"));
-	if (!await runTypecheckParity({
+	if (!await runSelectedTypecheckParity({
 		repo: process.cwd(),
-		policy,
-		...args.mode === "selected" ? { projects: args.projects } : {}
+		since: args.changedSince,
+		run: () => runTypecheckParity({
+			repo: process.cwd(),
+			policy,
+			...args.mode === "selected" ? { projects: args.projects } : {}
+		})
 	})) process.exitCode = 1;
 };
 main().catch((error) => {