tsrx-typegen 0.3.0 → 0.4.0

package/README.md

@@ -150,6 +150,14 @@ the package and bare package imports are declared dependencies or peers. The com
 TypeScript consumer test for the module-resolution modes and public prop
 contracts your package supports.
 
+The checker requires paired runtime and type exports. Pure type-only export
+maps and mixed Node tooling exports without type entries need separate
+package-specific validation.
+
+```sh
+pnpm exec tsrx-typegen --pack-check
+```
+
 A target with `"emit": false` exists only to drive packed-package
 verification. Packages whose declarations are handwritten or produced by
 another tool declare one so `--pack-check` skips generation and freshness

package/bin/tsrx-typegen.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Published installs live under node_modules, where Node refuses type
+// stripping — run the emitted dist/. In-repo runs always execute src/ (Node
+// ≥22.18 strips types): a stale, gitignored dist/ would otherwise run old code
+// under turbo cache keys hashed from current source.
+const entry = import.meta.url.includes('/node_modules/') ? '../dist/cli.js' : '../src/cli.ts'
+await import(new URL(entry, import.meta.url).href)

package/dist/cli.js

@@ -0,0 +1,546 @@
+#!/usr/bin/env node
+import { checkPackedPackage } from "./pack-check.js";
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+//#region src/cli.ts
+var manifestName = ".tsrx-typegen-manifest.json";
+var defaultExtensions = {
+	".ts": ".js",
+	".tsx": ".js",
+	".tsrx": ".js",
+	".mts": ".mjs",
+	".cts": ".cjs"
+};
+function usage() {
+	console.log(`Usage: tsrx-typegen --project <tsconfig> [--target <name>] [--check]
+       tsrx-typegen --target <name> [--check]
+       tsrx-typegen --pack-check [--target <name>]
+
+Generate declarations with the consuming project's TypeScript and tsrx compiler.
+
+Options:
+  --project <path>  TypeScript config for declaration generation
+  --target <name>   Target in tsrx-typegen.json (selects its project and output)
+  --check           Compare generated declarations without writing files
+  --pack-check      Check declarations, pack the package, and validate the tarball
+                    (targets with emit: false skip generation and only validate)
+  -h, --help        Show this help`);
+}
+function parseArgs(args) {
+	let project;
+	let target;
+	let check = false;
+	let packCheck = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h") {
+			usage();
+			process.exit(0);
+		} else if (arg === "--check") check = true;
+		else if (arg === "--pack-check") packCheck = true;
+		else if (arg === "--project") {
+			if (!args[index + 1] || args[index + 1].startsWith("--")) throw new Error("Pass a path after --project.");
+			project = args[++index];
+		} else if (arg === "--target") {
+			if (!args[index + 1] || args[index + 1].startsWith("--")) throw new Error("Pass a name after --target.");
+			target = args[++index];
+		} else throw new Error(`Unknown argument: ${arg}`);
+	}
+	if (!project && !target && !packCheck) throw new Error("Pass --project <tsconfig>, --target <name>, or --pack-check.");
+	if (packCheck && project) throw new Error("--pack-check uses targets from tsrx-typegen.json; do not pass --project.");
+	return {
+		project: project ? resolve(project) : void 0,
+		target,
+		check,
+		packCheck
+	};
+}
+function configuredTargetNames(projectRoot, selectedTarget) {
+	const path = join(projectRoot, "tsrx-typegen.json");
+	let config;
+	try {
+		config = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new Error(`${path}: ${error.message}`);
+	}
+	const targets = config?.targets;
+	if (!targets || typeof targets !== "object" || Array.isArray(targets) || !Object.keys(targets).length) throw new Error(`${path}: --pack-check requires at least one configured target`);
+	if (selectedTarget && !Object.hasOwn(targets, selectedTarget)) throw new Error(`${path}: unknown target ${selectedTarget}`);
+	return {
+		names: selectedTarget ? [selectedTarget] : Object.keys(targets),
+		targets
+	};
+}
+function loadProjectModule(projectRoot, specifier) {
+	return createRequire(join(projectRoot, "package.json")).resolve(specifier);
+}
+function readProjectConfig(ts, configPath, projectRoot, target) {
+	const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+	if (configFile.error) throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
+	const parsed = ts.parseJsonConfigFileContent(configFile.config, { ...ts.sys }, dirname(configPath), {}, configPath, void 0, [{
+		extension: ".tsrx",
+		isMixedContent: true,
+		scriptKind: ts.ScriptKind.Deferred
+	}]);
+	if (!parsed) throw new Error(`Could not read ${configPath}`);
+	const errors = parsed.errors.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+	if (errors.length) throw new Error(errors.join("\n"));
+	const options = parsed.options;
+	const jsxRenderer = options.jsxImportSource ?? (options.jsx === ts.JsxEmit.ReactJSX || options.jsx === ts.JsxEmit.ReactJSXDev ? "react" : void 0);
+	if (target?.renderer && jsxRenderer && target.renderer !== jsxRenderer) throw new Error(`target ${target.name} renderer ${target.renderer} does not match compilerOptions.jsxImportSource ${jsxRenderer}`);
+	if (!options.declaration || !options.emitDeclarationOnly || options.noEmit) throw new Error(`${configPath} must set declaration: true, emitDeclarationOnly: true, and noEmit: false.`);
+	const outputDirectory = target?.outDir ?? options.declarationDir ?? options.outDir;
+	if (!outputDirectory) throw new Error(`${configPath} must set target outDir, compilerOptions.outDir, or declarationDir.`);
+	return {
+		outDir: target?.outDir ? resolve(projectRoot, outputDirectory) : resolve(dirname(configPath), outputDirectory),
+		outputFlag: options.declarationDir ? "--declarationDir" : "--outDir",
+		rootDir: options.rootDir ? resolve(options.rootDir) : commonDirectory(parsed.fileNames),
+		fileNames: parsed.fileNames
+	};
+}
+function commonDirectory(paths) {
+	if (!paths.length) throw new Error("TypeScript project has no root files.");
+	const segments = paths.map((path) => resolve(dirname(path)).split(sep));
+	const common = [];
+	for (let index = 0; segments.every((parts) => parts[index] === segments[0][index]); index += 1) common.push(segments[0][index]);
+	return common.join(sep) || sep;
+}
+function sourceDeclarationMap(rootDir, fileNames, extensions, overrides) {
+	const sourceOutputs = /* @__PURE__ */ new Map();
+	const runtimeByDeclaration = /* @__PURE__ */ new Map();
+	for (const source of fileNames) {
+		const sourceExtension = extname(source).toLowerCase();
+		if (!Object.hasOwn(extensions, sourceExtension) || /\.d\.[cm]?ts$/i.test(source)) continue;
+		const sourcePath = relative(rootDir, source);
+		if (!sourcePath || sourcePath.startsWith(`..${sep}`) || isAbsolute(sourcePath)) throw new Error(`Source file is outside compilerOptions.rootDir: ${source}`);
+		const declarationExtension = sourceExtension === ".mts" ? ".d.mts" : sourceExtension === ".cts" ? ".d.cts" : ".d.ts";
+		const declaration = normalize(sourcePath.slice(0, -sourceExtension.length) + declarationExtension);
+		const prior = sourceOutputs.get(declaration);
+		if (prior && !overrides.has(declaration)) throw new Error(`source output collision: ${prior} and ${source} both emit ${declaration}; rename one source or declare an override for ${declaration}`);
+		if (!prior) {
+			sourceOutputs.set(declaration, source);
+			runtimeByDeclaration.set(declaration, extensions[sourceExtension]);
+		}
+	}
+	return {
+		sourceOutputs,
+		runtimeByDeclaration
+	};
+}
+function configOptions(projectRoot, projectArgument, targetArgument) {
+	const path = join(projectRoot, "tsrx-typegen.json");
+	let config;
+	try {
+		config = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			if (targetArgument) throw new Error(`No tsrx-typegen.json defines target ${targetArgument}.`);
+			return {
+				project: projectArgument,
+				target: null,
+				sourceExtensions: defaultExtensions,
+				overrides: {}
+			};
+		}
+		throw new Error(`${path}: ${error.message}`);
+	}
+	if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error(`${path}: expected a JSON object`);
+	const targets = config.targets ?? {};
+	if (!targets || typeof targets !== "object" || Array.isArray(targets)) throw new Error(`${path}: targets must be an object`);
+	const resolveProject = (value) => resolve(projectRoot, value);
+	let selectedName = targetArgument;
+	let selected = selectedName ? targets[selectedName] : void 0;
+	if (selectedName && !selected) throw new Error(`${path}: unknown target ${selectedName}`);
+	if (!selected && projectArgument) {
+		const matches = Object.entries(targets).filter(([, target]) => target?.project && resolveProject(target.project) === projectArgument);
+		if (matches.length > 1) throw new Error(`${path}: project matches multiple targets; pass --target <name>`);
+		if (matches.length === 1) [selectedName, selected] = matches[0];
+		else if (Object.keys(targets).length) throw new Error(`${path}: ${projectArgument} is not declared by a target`);
+	}
+	if (selected) {
+		if (selected.emit === false) throw new Error(`${path}: target ${selectedName} has emit: false — it configures --pack-check only`);
+		if (typeof selected.project !== "string" || !selected.project) throw new Error(`${path}: target ${selectedName} must name a project`);
+		if (projectArgument && resolveProject(selected.project) !== projectArgument) throw new Error(`${path}: --project does not match target ${selectedName}`);
+		if (typeof selected.renderer !== "string" || !selected.renderer) throw new Error(`${path}: target ${selectedName} must name its renderer`);
+		if (!selected.entrypoints || typeof selected.entrypoints !== "object" || Array.isArray(selected.entrypoints) || !Object.keys(selected.entrypoints).length) throw new Error(`${path}: target ${selectedName} must declare entrypoints`);
+		for (const [subpath, entry] of Object.entries(selected.entrypoints)) {
+			if (!entry || typeof entry !== "object" || typeof entry.source !== "string" || !stringsIn(entry.runtime).length || !stringsIn(entry.types).length) throw new Error(`${path}: target ${selectedName} entrypoint ${subpath} needs source, runtime, and types`);
+			for (const publishedPath of [...stringsIn(entry.runtime), ...stringsIn(entry.types)]) if (!publishedPath.startsWith("./") || !pathInside(projectRoot, resolve(projectRoot, publishedPath))) throw new Error(`${path}: ${subpath} mapping escapes the package: ${publishedPath}`);
+			const source = resolve(projectRoot, entry.source);
+			let isFile = false;
+			try {
+				isFile = statSync(source).isFile();
+			} catch {}
+			if (!pathInside(projectRoot, source) || !isFile) throw new Error(`${path}: target ${selectedName} entrypoint source is missing: ${entry.source}`);
+		}
+		if (selected.outDir) {
+			if (typeof selected.outDir !== "string") throw new Error(`${path}: target ${selectedName} outDir must be a package-relative path`);
+			if (!pathInside(projectRoot, resolve(projectRoot, selected.outDir))) throw new Error(`${path}: target ${selectedName} outDir escapes the package`);
+		}
+	}
+	if (!selected && Object.keys(targets).length) throw new Error(`${path}: pass --target <name> or a matching --project`);
+	const project = projectArgument ?? resolveProject(selected.project);
+	const sourceExtensions = {
+		...defaultExtensions,
+		...config.sourceExtensions,
+		...selected?.sourceExtensions
+	};
+	for (const [source, runtime] of Object.entries(sourceExtensions)) if (!source.startsWith(".") || typeof runtime !== "string" || !runtime.startsWith(".")) throw new Error(`${path}: sourceExtensions must map dot-prefixed extensions to dot-prefixed runtime extensions`);
+	const globalOverrides = config.overrides ?? {};
+	const targetOverrides = selected?.overrides ?? {};
+	for (const overrides of [globalOverrides, targetOverrides]) if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) throw new Error(`${path}: overrides must map declaration output paths to source files`);
+	return {
+		project,
+		target: selected ? {
+			name: selectedName,
+			...selected
+		} : null,
+		sourceExtensions,
+		overrides: {
+			...globalOverrides,
+			...targetOverrides
+		}
+	};
+}
+function applyOverrides(ts, projectRoot, outputDir, generated, overrides) {
+	const normalized = /* @__PURE__ */ new Map();
+	for (const [outputPath, sourcePath] of Object.entries(overrides)) {
+		if (typeof sourcePath !== "string" || !sourcePath) throw new Error(`override for ${outputPath} must name a source declaration file`);
+		const outputFile = normalize(outputPath);
+		if (!pathInside(outputDir, resolve(outputDir, outputFile)) || !/\.d\.[cm]?ts$/.test(outputFile)) throw new Error(`invalid override output path: ${outputPath}`);
+		const source = resolve(projectRoot, sourcePath);
+		if (!pathInside(projectRoot, source)) throw new Error(`override source escapes the package: ${sourcePath}`);
+		let content;
+		try {
+			content = readFileSync(source, "utf8");
+		} catch (error) {
+			throw new Error(`override source ${sourcePath}: ${error.message}`);
+		}
+		assertNoTsrxModuleReferences(ts, source, content);
+		normalized.set(outputFile, content);
+	}
+	for (const [outputPath, content] of normalized) generated.set(outputPath, content);
+	return new Set(normalized.keys());
+}
+function collectFiles(root, output = []) {
+	if (!statSync(root).isDirectory()) {
+		output.push(root);
+		return output;
+	}
+	for (const entry of readdirSync(root, { withFileTypes: true })) {
+		const path = join(root, entry.name);
+		if (entry.isDirectory()) collectFiles(path, output);
+		else if (entry.isFile()) output.push(path);
+	}
+	return output;
+}
+function moduleSpecifierNodes(ts, sourceFile) {
+	const nodes = [];
+	const visit = (node) => {
+		if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) nodes.push(node.moduleSpecifier);
+		else if (ts.isImportTypeNode(node)) {
+			const argument = node.argument;
+			if (ts.isLiteralTypeNode(argument) && ts.isStringLiteralLike(argument.literal)) nodes.push(argument.literal);
+		} else if (ts.isExternalModuleReference(node) && node.expression && ts.isStringLiteral(node.expression)) nodes.push(node.expression);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return nodes;
+}
+function assertNoTsrxModuleReferences(ts, path, text) {
+	const unresolved = moduleSpecifierNodes(ts, ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)).find((node) => /\.tsrx(?:$|[?#])/.test(node.text));
+	if (unresolved) throw new Error(`${path}: unresolved .tsrx module specifier ${unresolved.text}`);
+}
+function rewriteDeclaration(ts, path, outputDir, extensions, generatedFiles, runtimeByDeclaration) {
+	const text = readFileSync(path, "utf8");
+	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const edits = [];
+	for (const node of moduleSpecifierNodes(ts, source)) {
+		const specifier = node.text;
+		if (!specifier.startsWith(".")) continue;
+		if (/\.d\.[cm]?ts$/i.test(specifier)) continue;
+		const extension = Object.keys(extensions).find((candidate) => !candidate.startsWith(".d.") && specifier.endsWith(candidate));
+		let replacement;
+		if (extension) replacement = specifier.slice(0, -extension.length) + extensions[extension];
+		else if (!/\.[cm]?[jt]sx?$/.test(specifier)) {
+			const targetStem = resolve(dirname(path), specifier);
+			const target = [
+				`${targetStem}.d.ts`,
+				`${targetStem}.d.mts`,
+				`${targetStem}.d.cts`,
+				join(targetStem, "index.d.ts"),
+				join(targetStem, "index.d.mts"),
+				join(targetStem, "index.d.cts")
+			].find((candidate) => generatedFiles.has(relative(outputDir, candidate)));
+			if (!target) continue;
+			const declaration = relative(outputDir, target);
+			const runtimeExtension = runtimeByDeclaration.get(declaration) ?? ".js";
+			const isIndex = dirname(target) === targetStem;
+			const baseSpecifier = specifier.endsWith("/") ? specifier.slice(0, -1) : specifier;
+			replacement = isIndex ? `${baseSpecifier}/index${runtimeExtension}` : `${specifier}${runtimeExtension}`;
+		} else continue;
+		edits.push({
+			start: node.getStart(source),
+			end: node.end,
+			replacement: `${text[node.getStart(source)]}${replacement}${text[node.end - 1]}`
+		});
+	}
+	let result = text;
+	for (const edit of edits.sort((a, b) => b.start - a.start)) result = result.slice(0, edit.start) + edit.replacement + result.slice(edit.end);
+	assertNoTsrxModuleReferences(ts, path, result);
+	return result;
+}
+function normalizeOutput(ts, outputDir, extensions, runtimeByDeclaration) {
+	const files = collectFiles(outputDir).filter((path) => /\.d\.[cm]?ts$/.test(path)).sort();
+	if (!files.length) throw new Error("TypeScript emitted no declaration files.");
+	const generatedFiles = new Set(files.map((path) => relative(outputDir, path)));
+	return new Map(files.map((path) => [relative(outputDir, path), rewriteDeclaration(ts, path, outputDir, extensions, generatedFiles, runtimeByDeclaration)]));
+}
+function verifySourceDeclarations(generated, sourceOutputs) {
+	const missing = [...sourceOutputs.keys()].filter((declaration) => !generated.has(declaration));
+	if (missing.length) throw new Error(`TypeScript emitted no declarations for source file(s): ${missing.join(", ")}`);
+}
+function previousManifest(outputDir) {
+	const path = join(outputDir, manifestName);
+	try {
+		const manifest = JSON.parse(readFileSync(path, "utf8"));
+		if (manifest.version !== 1 || !Array.isArray(manifest.files)) throw new Error("unsupported manifest format");
+		return new Set(manifest.files);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw new Error(`${path}: ${error.message}`);
+	}
+}
+function pathInside(root, file) {
+	const relativePath = relative(root, file);
+	return relativePath && !relativePath.startsWith(`..${sep}`) && relativePath !== ".." && !isAbsolute(relativePath);
+}
+function existingOutputPath(outputDir, file) {
+	let current = outputDir;
+	const actualParts = [];
+	for (const part of normalize(file).split(sep)) {
+		let entries;
+		try {
+			entries = readdirSync(current);
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+		const actual = entries.includes(part) ? part : entries.find((entry) => entry.toLowerCase() === part.toLowerCase());
+		if (!actual) return null;
+		actualParts.push(actual);
+		current = join(current, actual);
+	}
+	return actualParts.join(sep);
+}
+function writeOutput(outputDir, generated, oldFiles, overrideFiles) {
+	for (const file of generated.keys()) {
+		const existing = existingOutputPath(outputDir, file);
+		if (existing && !oldFiles?.has(existing) && !overrideFiles.has(existing)) throw new Error(`refusing to overwrite unmanaged declaration: ${file}`);
+	}
+	for (const file of oldFiles ?? []) {
+		const path = resolve(outputDir, file);
+		if (!pathInside(outputDir, path)) throw new Error(`Invalid generated path in manifest: ${file}`);
+		if (!generated.has(file)) rmSync(path, { force: true });
+	}
+	for (const [file, content] of generated) {
+		const path = join(outputDir, file);
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, content);
+	}
+	mkdirSync(outputDir, { recursive: true });
+	writeFileSync(join(outputDir, manifestName), JSON.stringify({
+		version: 1,
+		files: [...generated.keys()]
+	}, null, 2) + "\n");
+}
+function compareOutput(outputDir, generated, oldFiles, overrideFiles) {
+	const errors = [];
+	if (!oldFiles) errors.push(`missing ${manifestName}; run tsrx-typegen --project <tsconfig> first`);
+	for (const file of generated.keys()) {
+		if (!oldFiles?.has(file) && !overrideFiles.has(file)) try {
+			statSync(join(outputDir, file));
+			errors.push(`${file} conflicts with unmanaged output`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		try {
+			if (readFileSync(join(outputDir, file), "utf8") !== generated.get(file)) errors.push(`${file} is stale`);
+		} catch {
+			errors.push(`${file} is missing`);
+		}
+	}
+	for (const file of oldFiles ?? []) if (!generated.has(file)) errors.push(`${file} is stale`);
+	return errors;
+}
+function stringsIn(value) {
+	if (typeof value === "string") return [value];
+	if (!value || typeof value !== "object") return [];
+	return Object.values(value).flatMap(stringsIn);
+}
+function typeTargets(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+	return [...Object.hasOwn(value, "types") ? stringsIn(value.types) : [], ...Object.entries(value).filter(([key]) => key !== "types" && key !== "default").flatMap(([, child]) => typeTargets(child))];
+}
+function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs) {
+	const manifestPath = join(projectRoot, "package.json");
+	let manifest;
+	try {
+		manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	} catch (error) {
+		throw new Error(`${manifestPath}: ${error.message}`);
+	}
+	const exportsMap = manifest.publishConfig?.exports ?? manifest.exports;
+	const failures = [];
+	if (target && exportsMap && typeof exportsMap === "object") {
+		const configuredSubpaths = new Set(Object.keys(target.entrypoints));
+		for (const [subpath, mapping] of Object.entries(exportsMap)) if (stringsIn(mapping).filter((entry) => !extname(entry) || /\.(?:[cm]?[jt]sx?|tsrx)$/.test(entry)).length && !configuredSubpaths.has(subpath)) failures.push(`${subpath} has code exports but no ${target.name} entrypoint config`);
+		for (const [subpath, entry] of Object.entries(target.entrypoints)) {
+			const mapping = exportsMap[subpath];
+			if (!mapping) {
+				failures.push(`${subpath} is configured for ${target.name} but missing from effective package exports`);
+				continue;
+			}
+			const source = resolve(projectRoot, entry.source);
+			if (![...sourceOutputs.values()].some((included) => resolve(included) === source)) failures.push(`${subpath} source is not included by its TypeScript project: ${entry.source}`);
+			const declaredRuntime = stringsIn(entry.runtime);
+			const publishedRuntime = stringsIn(mapping);
+			for (const runtime of declaredRuntime) if (!publishedRuntime.includes(runtime)) failures.push(`${subpath} runtime mapping is not present in package exports: ${runtime}`);
+			const declaredTypes = stringsIn(entry.types);
+			const publishedTypes = typeTargets(mapping);
+			for (const typePath of declaredTypes) if (!publishedTypes.includes(typePath)) failures.push(`${subpath} types mapping is not present in package exports: ${typePath}`);
+		}
+	}
+	if (exportsMap && typeof exportsMap === "object") for (const [subpath, mapping] of Object.entries(exportsMap)) {
+		if (!stringsIn(mapping).filter((target) => !extname(target) || /\.(?:[cm]?[jt]sx?|tsrx)$/.test(target)).length) continue;
+		const targets = typeTargets(mapping);
+		if (!targets.length) {
+			failures.push(`${subpath} has code exports but no types condition`);
+			continue;
+		}
+		for (const target of targets) {
+			if (!target.startsWith("./") || target.includes("*")) continue;
+			const absolute = resolve(projectRoot, target);
+			if (!pathInside(projectRoot, absolute)) {
+				failures.push(`${subpath} types target escapes the package: ${target}`);
+				continue;
+			}
+			const generatedPath = relative(outDir, absolute);
+			if (pathInside(outDir, absolute) && generated.has(generatedPath)) continue;
+			try {
+				if (!statSync(absolute).isFile()) failures.push(`${subpath} types target is not a file: ${target}`);
+			} catch {
+				failures.push(`${subpath} types target is missing: ${target}`);
+			}
+		}
+	}
+	else if (manifest.types ?? manifest.typings) {
+		const targetPath = manifest.types ?? manifest.typings;
+		const target = resolve(projectRoot, targetPath);
+		if (!pathInside(projectRoot, target)) failures.push(`package types target escapes the package: ${targetPath}`);
+		else if (!(pathInside(outDir, target) && generated.has(relative(outDir, target)))) try {
+			if (!statSync(target).isFile()) failures.push(`package types target is not a file: ${targetPath}`);
+		} catch {
+			failures.push(`package types target is missing: ${targetPath}`);
+		}
+	}
+	if (failures.length) throw new Error(failures.join("\n"));
+}
+function runTarget(projectRoot, args) {
+	const { project, target, sourceExtensions, overrides } = configOptions(projectRoot, args.project, args.target);
+	const tsPath = loadProjectModule(projectRoot, "typescript");
+	const ts = createRequire(import.meta.url)(tsPath);
+	const { outDir, outputFlag, rootDir, fileNames } = readProjectConfig(ts, project, projectRoot, target);
+	const { sourceOutputs, runtimeByDeclaration } = sourceDeclarationMap(rootDir, fileNames, sourceExtensions, new Set(Object.keys(overrides).map(normalize)));
+	const compilerPath = loadProjectModule(projectRoot, "@tsrx/typescript-plugin/dist/tsc.js");
+	const temporaryRoot = mkdtempSync(join(tmpdir(), "tsrx-typegen-"));
+	const temporaryOut = join(temporaryRoot, "types");
+	const outputDir = temporaryOut;
+	try {
+		const compilerArgs = [
+			compilerPath,
+			"--pretty",
+			"false",
+			"--project",
+			project,
+			outputFlag,
+			temporaryOut
+		];
+		const result = spawnSync(process.execPath, compilerArgs, {
+			cwd: projectRoot,
+			encoding: "utf8",
+			maxBuffer: 33554432
+		});
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		if (result.error) throw result.error;
+		if (/\[tsrx-tsc\]/.test(result.stderr ?? "")) throw new Error("tsrx compiler reported transform diagnostics; declarations were not written. Fix the source or configure an explicit declaration override.");
+		if (result.status !== 0) {
+			console.error("tsrx-typegen: declaration emit failed; generated files were not changed. Fix compiler diagnostics or configure an explicit declaration override for an unsupported public signature.");
+			return false;
+		}
+		for (const source of fileNames) {
+			if (!/\.d\.[cm]?ts$/.test(source) || !pathInside(rootDir, source)) continue;
+			const declaration = relative(rootDir, source);
+			if (sourceOutputs.has(declaration)) continue;
+			const output = join(outputDir, declaration);
+			mkdirSync(dirname(output), { recursive: true });
+			writeFileSync(output, readFileSync(source));
+		}
+		const generated = normalizeOutput(ts, outputDir, sourceExtensions, runtimeByDeclaration);
+		const managedOverrides = applyOverrides(ts, projectRoot, outDir, generated, overrides);
+		verifySourceDeclarations(generated, sourceOutputs);
+		const oldFiles = previousManifest(outDir);
+		verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs);
+		if (args.check) {
+			const errors = compareOutput(outDir, generated, oldFiles, managedOverrides);
+			if (errors.length) {
+				for (const error of errors) console.error(`tsrx-typegen: ${error}`);
+				return false;
+			}
+			console.log(`tsrx-typegen: ${generated.size} declaration file(s) are current`);
+		} else {
+			writeOutput(outDir, generated, oldFiles, managedOverrides);
+			console.log(`tsrx-typegen: wrote ${generated.size} declaration file(s) to ${relative(projectRoot, outDir) || outDir}`);
+		}
+		return true;
+	} finally {
+		rmSync(temporaryRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function run() {
+	const args = parseArgs(process.argv.slice(2));
+	const projectRoot = process.cwd();
+	if (!args.packCheck) {
+		if (!runTarget(projectRoot, args)) process.exitCode = 1;
+		return;
+	}
+	const { names, targets } = configuredTargetNames(projectRoot, args.target);
+	for (const target of names) {
+		if (targets[target]?.emit === false) continue;
+		if (!runTarget(projectRoot, {
+			...args,
+			target,
+			check: true
+		})) {
+			process.exitCode = 1;
+			return;
+		}
+	}
+	const tsPath = loadProjectModule(projectRoot, "typescript");
+	const ts = createRequire(import.meta.url)(tsPath);
+	checkPackedPackage(projectRoot, ts);
+}
+try {
+	run();
+} catch (error) {
+	console.error(`tsrx-typegen: ${error.message}`);
+	process.exitCode = 1;
+}
+//#endregion

package/dist/pack-check.js

@@ -0,0 +1,394 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region src/pack-check.ts
+var moduleSpecifierNodes = (ts, sourceFile) => {
+	const nodes = [];
+	const visit = (node) => {
+		if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) nodes.push(node.moduleSpecifier);
+		else if (ts.isImportTypeNode(node)) {
+			const argument = node.argument;
+			if (ts.isLiteralTypeNode(argument) && ts.isStringLiteralLike(argument.literal)) nodes.push(argument.literal);
+		} else if (ts.isExternalModuleReference(node) && node.expression && ts.isStringLiteral(node.expression)) nodes.push(node.expression);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return nodes;
+};
+var pathInside = (root, file) => {
+	const rel = relative(root, file);
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+};
+var stringsIn = (value) => {
+	if (typeof value === "string") return [value];
+	if (!value || typeof value !== "object") return [];
+	return Object.values(value).flatMap(stringsIn);
+};
+var codeTarget = (target) => (!extname(target) || /\.(?:[cm]?[jt]sx?|tsrx)$/.test(target)) && !/\.d\.[cm]?ts$/.test(target);
+function exportBranches(exportsMap, fallbackTypes = []) {
+	const branches = [];
+	for (const [subpath, mapping] of Object.entries(exportsMap ?? {})) {
+		const visit = (value, inheritedTypes) => {
+			if (typeof value === "string") {
+				if (codeTarget(value)) branches.push({
+					subpath,
+					runtime: value,
+					types: inheritedTypes.length ? inheritedTypes : fallbackTypes
+				});
+				return;
+			}
+			if (!value || typeof value !== "object" || Array.isArray(value)) return;
+			let types = inheritedTypes;
+			for (const [condition, child] of Object.entries(value)) if (condition === "types") {
+				if (!types.length) types = stringsIn(child);
+			} else visit(child, types);
+		};
+		visit(mapping, []);
+	}
+	return branches;
+}
+function packageFiles(root) {
+	const files = [];
+	const visit = (dir) => {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			if (entry.name === "node_modules") continue;
+			const file = join(dir, entry.name);
+			if (entry.isDirectory()) visit(file);
+			else files.push(file);
+		}
+	};
+	visit(root);
+	return files;
+}
+function expandTarget(target, files, packageRoot) {
+	const extensionless = !extname(target);
+	if (!target.includes("*") && !extensionless) return [{
+		path: target,
+		capture: void 0
+	}];
+	if ((target.match(/\*/g) ?? []).length > 1) throw new Error(`packed export target uses more than one wildcard: ${target}`);
+	if (!target.startsWith("./")) throw new Error(`packed export target must be package-relative: ${target}`);
+	const pattern = target.slice(2);
+	const marker = pattern.indexOf("*");
+	const prefix = marker === -1 ? pattern : pattern.slice(0, marker);
+	const suffix = marker === -1 ? "" : pattern.slice(marker + 1);
+	const matches = files.flatMap((file) => {
+		const path = relative(packageRoot, file).replaceAll("\\", "/");
+		if (!codeTarget(path) || extensionless && !extname(path)) return [];
+		const matchedPath = extensionless ? path.slice(0, -extname(path).length) : path;
+		if (!matchedPath.startsWith(prefix) || !matchedPath.endsWith(suffix) || matchedPath.length < prefix.length + suffix.length || marker === -1 && matchedPath !== pattern) return [];
+		const capture = marker === -1 ? void 0 : matchedPath.slice(prefix.length, matchedPath.length - suffix.length);
+		return [{
+			path: `./${path}`,
+			capture
+		}];
+	});
+	if (!matches.length) throw new Error(`packed export target matches no files: ${target}`);
+	return matches;
+}
+function packedPath(packageRoot, target) {
+	if (typeof target !== "string" || !target.startsWith("./") || target.includes("*")) throw new Error(`packed export target is not a concrete package-relative path: ${target}`);
+	const file = resolve(packageRoot, target);
+	if (!pathInside(packageRoot, file)) throw new Error(`packed export target escapes the package: ${target}`);
+	try {
+		if (statSync(file).isFile()) return file;
+	} catch {}
+	throw new Error(`packed export target is missing from the tarball: ${target}`);
+}
+function sourceFile(ts, file) {
+	const extension = extname(file).toLowerCase();
+	const scriptKind = extension === ".tsx" || extension === ".tsrx" ? ts.ScriptKind.TSX : extension === ".jsx" ? ts.ScriptKind.JSX : ts.ScriptKind.TS;
+	return ts.createSourceFile(file, readFileSync(file, "utf8"), ts.ScriptTarget.Latest, true, scriptKind);
+}
+function localSourceModule(file, specifier) {
+	if (!specifier.startsWith(".")) return null;
+	const target = resolve(dirname(file), specifier);
+	const extension = extname(target);
+	const candidates = [target];
+	if (extension === ".js" || extension === ".mjs" || extension === ".cjs") {
+		const stem = target.slice(0, -extension.length);
+		candidates.push(`${stem}.ts`, `${stem}.tsx`, `${stem}.tsrx`, `${stem}.d.ts`);
+	} else if (![
+		".ts",
+		".tsx",
+		".tsrx"
+	].includes(extension)) {
+		candidates.push(`${target}.ts`, `${target}.tsx`, `${target}.tsrx`, `${target}.d.ts`);
+		candidates.push(join(target, "index.ts"), join(target, "index.tsx"), join(target, "index.tsrx"), join(target, "index.d.ts"));
+	}
+	for (const candidate of candidates) try {
+		if (statSync(candidate).isFile()) return candidate;
+	} catch {}
+	return null;
+}
+function staticRuntimeExports(ts, file, seen = /* @__PURE__ */ new Set()) {
+	const absolute = resolve(file);
+	if (seen.has(absolute)) return /* @__PURE__ */ new Set();
+	seen.add(absolute);
+	const source = sourceFile(ts, absolute);
+	const names = /* @__PURE__ */ new Set();
+	const addBindingName = (name) => {
+		if (ts.isIdentifier(name)) names.add(name.text);
+		else if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+			for (const element of name.elements) if (element && ts.isBindingElement(element)) addBindingName(element.name);
+		}
+	};
+	for (const statement of source.statements) {
+		const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) ?? [] : [];
+		const exported = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+		if (modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword)) names.add("default");
+		if (exported) {
+			if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) {
+				if (statement.name) names.add(statement.name.text);
+			}
+			if (ts.isVariableStatement(statement)) for (const declaration of statement.declarationList.declarations) addBindingName(declaration.name);
+		}
+		if (ts.isExportDeclaration(statement) && !statement.isTypeOnly) {
+			if (!statement.exportClause && statement.moduleSpecifier && ts.isStringLiteralLike(statement.moduleSpecifier)) {
+				const target = localSourceModule(absolute, statement.moduleSpecifier.text);
+				if (target) {
+					for (const name of staticRuntimeExports(ts, target, seen)) if (name !== "default") names.add(name);
+				}
+			} else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+				for (const element of statement.exportClause.elements) if (!element.isTypeOnly) names.add(element.name.text);
+			} else if (statement.exportClause && ts.isNamespaceExport(statement.exportClause)) names.add(statement.exportClause.name.text);
+		}
+		if (ts.isExportAssignment(statement)) names.add("default");
+	}
+	return names;
+}
+function compilerExports(ts, program, file, cache = /* @__PURE__ */ new Map(), pending = /* @__PURE__ */ new Set()) {
+	const absolute = resolve(file);
+	if (cache.has(absolute)) return cache.get(absolute);
+	if (pending.has(absolute)) return {
+		all: /* @__PURE__ */ new Set(),
+		values: /* @__PURE__ */ new Set()
+	};
+	const source = program.getSourceFile(file);
+	if (!source) return;
+	const checker = program.getTypeChecker();
+	const module = checker.getSymbolAtLocation(source);
+	if (!module) return;
+	const all = /* @__PURE__ */ new Set();
+	const values = /* @__PURE__ */ new Set();
+	for (const symbol of checker.getExportsOfModule(module)) {
+		all.add(symbol.name);
+		let resolved = symbol;
+		if (symbol.flags & ts.SymbolFlags.Alias) try {
+			resolved = checker.getAliasedSymbol(symbol);
+		} catch {}
+		if (!symbol.declarations?.some((declaration) => ts.isExportSpecifier(declaration) && (declaration.isTypeOnly || declaration.parent.parent.isTypeOnly)) && resolved.flags & ts.SymbolFlags.Value) values.add(symbol.name);
+	}
+	const typeOnly = /* @__PURE__ */ new Set();
+	for (const statement of source.statements) {
+		if (!ts.isExportDeclaration(statement)) continue;
+		if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+			for (const element of statement.exportClause.elements) if (statement.isTypeOnly || element.isTypeOnly) typeOnly.add(element.name.text);
+			continue;
+		}
+		if (!statement.isTypeOnly) continue;
+		if (!statement.exportClause && statement.moduleSpecifier && ts.isStringLiteralLike(statement.moduleSpecifier)) {
+			pending.add(absolute);
+			const target = ts.resolveModuleName(statement.moduleSpecifier.text, file, program.getCompilerOptions(), ts.sys).resolvedModule?.resolvedFileName;
+			const targetExports = target && compilerExports(ts, program, target, cache, pending);
+			pending.delete(absolute);
+			for (const name of targetExports?.all ?? []) typeOnly.add(name);
+		} else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) for (const element of statement.exportClause.elements) typeOnly.add(element.name.text);
+		else if (statement.exportClause && ts.isNamespaceExport(statement.exportClause)) typeOnly.add(statement.exportClause.name.text);
+	}
+	if (typeOnly.size) {
+		const valueEdges = staticRuntimeExports(ts, file);
+		for (const name of values) if (typeOnly.has(name) && !valueEdges.has(name)) values.delete(name);
+	}
+	const result = {
+		all,
+		values
+	};
+	cache.set(absolute, result);
+	return result;
+}
+function declarationFiles(packageRoot, files) {
+	return files.filter((file) => /\.d\.[cm]?ts$/.test(relative(packageRoot, file)));
+}
+function moduleResolutionOptions(ts) {
+	return {
+		allowImportingTsExtensions: true,
+		module: ts.ModuleKind.NodeNext,
+		moduleResolution: ts.ModuleResolutionKind.NodeNext,
+		moduleSuffixes: [
+			"",
+			".web",
+			".ios",
+			".android",
+			".mobile",
+			".native",
+			".macos",
+			".linux",
+			".windows"
+		],
+		noEmit: true,
+		skipLibCheck: true,
+		target: ts.ScriptTarget.Latest
+	};
+}
+function verifyDeclarationClosure(ts, packageRoot, files, manifest, failures) {
+	const options = moduleResolutionOptions(ts);
+	const host = ts.sys;
+	const declared = /* @__PURE__ */ new Set([
+		manifest.name,
+		...Object.keys(manifest.dependencies ?? {}),
+		...Object.keys(manifest.optionalDependencies ?? {}),
+		...Object.keys(manifest.peerDependencies ?? {}),
+		...manifest.bundledDependencies ?? []
+	]);
+	for (const file of declarationFiles(packageRoot, files)) {
+		const source = sourceFile(ts, file);
+		for (const node of moduleSpecifierNodes(ts, source)) {
+			const specifier = node.text;
+			if (specifier.startsWith(".") || specifier.startsWith("#")) {
+				const resolved = ts.resolveModuleName(specifier, file, options, host).resolvedModule;
+				if (!resolved) failures.push(`${relative(packageRoot, file)} has unresolved declaration reference ${specifier}`);
+				else if (!pathInside(packageRoot, resolve(resolved.resolvedFileName))) failures.push(`${relative(packageRoot, file)} resolves ${specifier} outside the package`);
+				else if (!/\.d\.[cm]?ts$/.test(resolved.resolvedFileName)) failures.push(`${relative(packageRoot, file)} resolves ${specifier} to implementation source; publish its declaration`);
+				continue;
+			}
+			if (specifier.startsWith("node:")) {
+				if (!declared.has("@types/node")) failures.push(`${relative(packageRoot, file)} imports ${specifier}; declare @types/node as a dependency or peer`);
+				continue;
+			}
+			if (specifier.startsWith("/")) {
+				failures.push(`${relative(packageRoot, file)} has absolute declaration reference ${specifier}`);
+				continue;
+			}
+			const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+			if (!declared.has(name)) failures.push(`${relative(packageRoot, file)} imports ${specifier}; declare ${name} in dependencies or peerDependencies`);
+		}
+	}
+}
+function verifyExportMap(ts, packageRoot, files, manifest, exportsMap, failures, options) {
+	const branches = exportBranches(exportsMap, [manifest.types ?? manifest.typings].filter(Boolean));
+	if (!branches.length) {
+		failures.push("package exports contain no runtime entrypoints to verify");
+		return;
+	}
+	const pairs = [];
+	for (const branch of branches) {
+		if (!branch.types.length) {
+			failures.push(`${branch.subpath} runtime ${branch.runtime} has no types condition`);
+			continue;
+		}
+		let runtimeMatches;
+		try {
+			runtimeMatches = expandTarget(branch.runtime, files, packageRoot);
+		} catch (error) {
+			failures.push(`${branch.subpath}: ${error.message}`);
+			continue;
+		}
+		for (const runtimeMatch of runtimeMatches) {
+			let runtimeFile;
+			try {
+				runtimeFile = packedPath(packageRoot, runtimeMatch.path);
+			} catch (error) {
+				failures.push(`${branch.subpath}: ${error.message}`);
+				continue;
+			}
+			for (const typeTarget of branch.types) {
+				const concreteType = typeTarget.includes("*") && runtimeMatch.capture !== void 0 ? typeTarget.replace("*", runtimeMatch.capture) : typeTarget;
+				let typeFile;
+				try {
+					typeFile = packedPath(packageRoot, concreteType);
+				} catch (error) {
+					failures.push(`${branch.subpath}: ${error.message}`);
+					continue;
+				}
+				pairs.push({
+					branch,
+					runtimeFile,
+					runtimePath: runtimeMatch.path,
+					typeFile,
+					concreteType
+				});
+			}
+		}
+	}
+	const programRoots = [...new Set(pairs.flatMap(({ runtimeFile, typeFile }) => [runtimeFile, typeFile]))].filter((file) => !file.endsWith(".tsrx"));
+	const program = ts.createProgram(programRoots, options);
+	for (const pair of pairs) {
+		const declarationExports = compilerExports(ts, program, pair.typeFile);
+		const runtimeExports = compilerExports(ts, program, pair.runtimeFile);
+		const declaredValues = declarationExports?.values ?? /* @__PURE__ */ new Set();
+		let runtimeValues;
+		if (pair.runtimeFile.endsWith(".ts") || pair.runtimeFile.endsWith(".tsx") || pair.runtimeFile.endsWith(".tsrx")) {
+			runtimeValues = staticRuntimeExports(ts, pair.runtimeFile);
+			for (const name of declarationExports?.all ?? []) if (!declaredValues.has(name)) runtimeValues.delete(name);
+		} else runtimeValues = runtimeExports?.values ?? staticRuntimeExports(ts, pair.runtimeFile);
+		const missing = [...runtimeValues].filter((name) => !declaredValues.has(name)).sort();
+		const extra = [...declaredValues].filter((name) => !runtimeValues.has(name)).sort();
+		if (missing.length || extra.length) failures.push(`${pair.branch.subpath} runtime/type value exports differ for ${pair.runtimePath} → ${pair.concreteType}${missing.length ? `; missing declarations: ${missing.join(", ")}` : ""}${extra.length ? `; declarations without runtime values: ${extra.join(", ")}` : ""}`);
+	}
+}
+function verifyPackedPackage(ts, packageRoot) {
+	const failures = [];
+	const manifestPath = join(packageRoot, "package.json");
+	let manifest;
+	try {
+		manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	} catch (error) {
+		throw new Error(`packed package.json: ${error.message}`);
+	}
+	const files = packageFiles(packageRoot);
+	const maps = [manifest.exports, manifest.publishConfig?.exports].filter((value, index, all) => value && all.indexOf(value) === index);
+	if (maps.length) for (const exportsMap of maps) verifyExportMap(ts, packageRoot, files, manifest, exportsMap, failures, moduleResolutionOptions(ts));
+	else if (manifest.main || manifest.module) verifyExportMap(ts, packageRoot, files, manifest, { ".": manifest.module ?? manifest.main }, failures, moduleResolutionOptions(ts));
+	else failures.push("package has no exports, main, or module entrypoint");
+	verifyDeclarationClosure(ts, packageRoot, files, manifest, failures);
+	if (failures.length) throw new Error(failures.join("\n"));
+}
+function checkPackedPackage(projectRoot, ts) {
+	const temporary = mkdtempSync(join(tmpdir(), "tsrx-typegen-pack-"));
+	const packOutput = join(temporary, "pack");
+	const extractedRoot = join(temporary, "extracted");
+	mkdirSync(packOutput);
+	mkdirSync(extractedRoot);
+	try {
+		const packed = spawnSync("pnpm", [
+			"--config.ignore-scripts=true",
+			"pack",
+			"--pack-destination",
+			packOutput
+		], {
+			cwd: projectRoot,
+			encoding: "utf8",
+			maxBuffer: 16777216
+		});
+		if (packed.stdout) process.stdout.write(packed.stdout);
+		if (packed.stderr) process.stderr.write(packed.stderr);
+		if (packed.error) throw packed.error;
+		if (packed.status !== 0) throw new Error(`pnpm pack exited with ${packed.status}`);
+		const tarballs = readdirSync(packOutput).filter((name) => name.endsWith(".tgz"));
+		if (tarballs.length !== 1) throw new Error(`expected one package tarball; found ${tarballs.length}`);
+		const extracted = spawnSync("tar", [
+			"-xzf",
+			join(packOutput, tarballs[0]),
+			"-C",
+			extractedRoot
+		], {
+			encoding: "utf8",
+			maxBuffer: 16777216
+		});
+		if (extracted.stdout) process.stdout.write(extracted.stdout);
+		if (extracted.stderr) process.stderr.write(extracted.stderr);
+		if (extracted.error) throw extracted.error;
+		if (extracted.status !== 0) throw new Error(`tar extraction exited with ${extracted.status}`);
+		verifyPackedPackage(ts, join(extractedRoot, "package"));
+		console.log("tsrx-typegen: packed exports and declaration graph are valid");
+	} finally {
+		rmSync(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+export { checkPackedPackage, verifyPackedPackage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsrx-typegen",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Generate consumer-ready TypeScript declarations for TSRX libraries",
   "keywords": [
     "build-tool",
@@ -19,17 +19,25 @@
     "directory": "packages/tsrx-typegen"
   },
   "bin": {
-    "tsrx-typegen": "./src/cli.mjs"
+    "tsrx-typegen": "./bin/tsrx-typegen.mjs"
   },
   "files": [
-    "src"
+    "src",
+    "dist",
+    "bin"
   ],
   "type": "module",
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "vite": "8.3.0"
+  },
   "peerDependencies": {
     "@tsrx/typescript-plugin": ">=0.4.11 <1",
     "typescript": ">=5.9.3 <6"
   },
   "scripts": {
-    "test": "node tests/pack-check.mjs && node tests/packed-consumer.mjs"
+    "build": "vite build",
+    "test": "pnpm build && node tests/pack-check.mjs && node tests/packed-consumer.mjs",
+    "typecheck": "tsc -p tsconfig.json"
   }
 }

package/src/{cli.mjs → cli.ts}

@@ -13,7 +13,7 @@ import {
 
 import { tmpdir } from 'node:os'
 import { dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path'
-import { checkPackedPackage } from './pack-check.mjs'
+import { checkPackedPackage } from './pack-check.ts'
 
 const manifestName = '.tsrx-typegen-manifest.json'
 const defaultExtensions = {
@@ -91,7 +91,7 @@ function configuredTargetNames(projectRoot, selectedTarget) {
 		throw new Error(`${path}: ${error.message}`)
 	}
 
-	const targets = config?.targets
+	const targets: Record<string, any> | undefined = config?.targets
 	if (
 		!targets ||
 		typeof targets !== 'object' ||
@@ -183,7 +183,7 @@ function commonDirectory(paths) {
 	}
 
 	const segments = paths.map((path) => resolve(dirname(path)).split(sep))
-	const common = []
+	const common: any[] = []
 	for (let index = 0; segments.every((parts) => parts[index] === segments[0][index]); index += 1) {
 		common.push(segments[0][index])
 	}
@@ -192,8 +192,8 @@ function commonDirectory(paths) {
 }
 
 function sourceDeclarationMap(rootDir, fileNames, extensions, overrides) {
-	const sourceOutputs = new Map()
-	const runtimeByDeclaration = new Map()
+	const sourceOutputs = new Map<any, any>()
+	const runtimeByDeclaration = new Map<any, any>()
 	for (const source of fileNames) {
 		const sourceExtension = extname(source).toLowerCase()
 		if (!Object.hasOwn(extensions, sourceExtension) || /\.d\.[cm]?ts$/i.test(source)) {
@@ -254,7 +254,7 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 		throw new Error(`${path}: expected a JSON object`)
 	}
 
-	const targets = config.targets ?? {}
+	const targets: Record<string, any> = config.targets ?? {}
 	if (!targets || typeof targets !== 'object' || Array.isArray(targets)) {
 		throw new Error(`${path}: targets must be an object`)
 	}
@@ -310,7 +310,7 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 			throw new Error(`${path}: target ${selectedName} must declare entrypoints`)
 		}
 
-		for (const [subpath, entry] of Object.entries(selected.entrypoints)) {
+		for (const [subpath, entry] of Object.entries<any>(selected.entrypoints)) {
 			if (
 				!entry ||
 				typeof entry !== 'object' ||
@@ -393,7 +393,7 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 }
 
 function applyOverrides(ts, projectRoot, outputDir, generated, overrides) {
-	const normalized = new Map()
+	const normalized = new Map<any, any>()
 	for (const [outputPath, sourcePath] of Object.entries(overrides)) {
 		if (typeof sourcePath !== 'string' || !sourcePath) {
 			throw new Error(`override for ${outputPath} must name a source declaration file`)
@@ -429,7 +429,7 @@ function applyOverrides(ts, projectRoot, outputDir, generated, overrides) {
 	return new Set(normalized.keys())
 }
 
-function collectFiles(root, output = []) {
+function collectFiles(root, output: any[] = []) {
 	if (!statSync(root).isDirectory()) {
 		output.push(root)
 		return output
@@ -448,7 +448,7 @@ function collectFiles(root, output = []) {
 }
 
 function moduleSpecifierNodes(ts, sourceFile) {
-	const nodes = []
+	const nodes: any[] = []
 	const visit = (node) => {
 		if (
 			(ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
@@ -490,7 +490,7 @@ function assertNoTsrxModuleReferences(ts, path, text) {
 function rewriteDeclaration(ts, path, outputDir, extensions, generatedFiles, runtimeByDeclaration) {
 	const text = readFileSync(path, 'utf8')
 	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-	const edits = []
+	const edits: any[] = []
 	for (const node of moduleSpecifierNodes(ts, source)) {
 		const specifier = node.text
 		if (!specifier.startsWith('.')) {
@@ -610,7 +610,7 @@ function pathInside(root, file) {
 
 function existingOutputPath(outputDir, file) {
 	let current = outputDir
-	const actualParts = []
+	const actualParts: any[] = []
 
 	for (const part of normalize(file).split(sep)) {
 		let entries
@@ -672,7 +672,7 @@ function writeOutput(outputDir, generated, oldFiles, overrideFiles) {
 }
 
 function compareOutput(outputDir, generated, oldFiles, overrideFiles) {
-	const errors = []
+	const errors: any[] = []
 	if (!oldFiles) {
 		errors.push(`missing ${manifestName}; run tsrx-typegen --project <tsconfig> first`)
 	}
@@ -742,7 +742,7 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 	}
 
 	const exportsMap = manifest.publishConfig?.exports ?? manifest.exports
-	const failures = []
+	const failures: any[] = []
 	if (target && exportsMap && typeof exportsMap === 'object') {
 		const configuredSubpaths = new Set(Object.keys(target.entrypoints))
 		for (const [subpath, mapping] of Object.entries(exportsMap)) {
@@ -755,7 +755,7 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 			}
 		}
 
-		for (const [subpath, entry] of Object.entries(target.entrypoints)) {
+		for (const [subpath, entry] of Object.entries<any>(target.entrypoints)) {
 			const mapping = exportsMap[subpath]
 			if (!mapping) {
 				failures.push(

package/src/{pack-check.mjs → pack-check.ts}

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os'
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path'
 
 const moduleSpecifierNodes = (ts, sourceFile) => {
-	const nodes = []
+	const nodes: any[] = []
 	const visit = (node) => {
 		if (
 			(ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
@@ -52,8 +52,8 @@ const stringsIn = (value) => {
 const codeTarget = (target) =>
 	(!extname(target) || /\.(?:[cm]?[jt]sx?|tsrx)$/.test(target)) && !/\.d\.[cm]?ts$/.test(target)
 
-function exportBranches(exportsMap, fallbackTypes = []) {
-	const branches = []
+function exportBranches(exportsMap, fallbackTypes: any[] = []) {
+	const branches: any[] = []
 	for (const [subpath, mapping] of Object.entries(exportsMap ?? {})) {
 		const visit = (value, inheritedTypes) => {
 			if (typeof value === 'string') {
@@ -92,7 +92,7 @@ function exportBranches(exportsMap, fallbackTypes = []) {
 }
 
 function packageFiles(root) {
-	const files = []
+	const files: any[] = []
 	const visit = (dir) => {
 		for (const entry of readdirSync(dir, { withFileTypes: true })) {
 			if (entry.name === 'node_modules') {
@@ -232,7 +232,7 @@ function localSourceModule(file, specifier) {
 	return null
 }
 
-function staticRuntimeExports(ts, file, seen = new Set()) {
+function staticRuntimeExports(ts, file, seen: Set<any> = new Set()) {
 	const absolute = resolve(file)
 	if (seen.has(absolute)) {
 		return new Set()
@@ -241,7 +241,7 @@ function staticRuntimeExports(ts, file, seen = new Set()) {
 	seen.add(absolute)
 
 	const source = sourceFile(ts, absolute)
-	const names = new Set()
+	const names = new Set<any>()
 	const addBindingName = (name) => {
 		if (ts.isIdentifier(name)) {
 			names.add(name.text)
@@ -314,7 +314,13 @@ function staticRuntimeExports(ts, file, seen = new Set()) {
 	return names
 }
 
-function compilerExports(ts, program, file, cache = new Map(), pending = new Set()) {
+function compilerExports(
+	ts,
+	program,
+	file,
+	cache: Map<any, any> = new Map(),
+	pending: Set<any> = new Set(),
+) {
 	const absolute = resolve(file)
 	if (cache.has(absolute)) {
 		return cache.get(absolute)
@@ -335,8 +341,8 @@ function compilerExports(ts, program, file, cache = new Map(), pending = new Set
 		return undefined
 	}
 
-	const all = new Set()
-	const values = new Set()
+	const all = new Set<any>()
+	const values = new Set<any>()
 	for (const symbol of checker.getExportsOfModule(module)) {
 		all.add(symbol.name)
 		let resolved = symbol
@@ -346,7 +352,15 @@ function compilerExports(ts, program, file, cache = new Map(), pending = new Set
 			} catch {}
 		}
 
-		if (resolved.flags & ts.SymbolFlags.Value) {
+		// Star barrels retain the originating alias declaration. An unresolved
+		// external type resolves to TypeScript's unknown symbol (which has value
+		// flags), so preserve an explicit type-only edge before using those flags.
+		const typeOnlyAlias = symbol.declarations?.some(
+			(declaration) =>
+				ts.isExportSpecifier(declaration) &&
+				(declaration.isTypeOnly || declaration.parent.parent.isTypeOnly),
+		)
+		if (!typeOnlyAlias && resolved.flags & ts.SymbolFlags.Value) {
 			values.add(symbol.name)
 		}
 	}
@@ -355,7 +369,7 @@ function compilerExports(ts, program, file, cache = new Map(), pending = new Set
 	// target's symbols with their original flags — an ambient `declare const`
 	// still reads as a value even though no value binding crosses the edge.
 	// Subtract names whose only export edges are type-only.
-	const typeOnly = new Set()
+	const typeOnly = new Set<any>()
 	for (const statement of source.statements) {
 		if (!ts.isExportDeclaration(statement)) {
 			continue
@@ -517,7 +531,7 @@ function verifyExportMap(ts, packageRoot, files, manifest, exportsMap, failures,
 		return
 	}
 
-	const pairs = []
+	const pairs: any[] = []
 	for (const branch of branches) {
 		if (!branch.types.length) {
 			failures.push(`${branch.subpath} runtime ${branch.runtime} has no types condition`)
@@ -598,7 +612,7 @@ function verifyExportMap(ts, packageRoot, files, manifest, exportsMap, failures,
 }
 
 export function verifyPackedPackage(ts, packageRoot) {
-	const failures = []
+	const failures: any[] = []
 	const manifestPath = join(packageRoot, 'package.json')
 	let manifest
 	try {