tsrx-typegen 0.2.2 → 0.3.1

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 (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.2.2",
+  "version": "0.3.1",
   "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('.')) {
@@ -529,7 +529,7 @@ function rewriteDeclaration(ts, path, outputDir, extensions, generatedFiles, run
 
 			const declaration = relative(outputDir, target)
 			const runtimeExtension = runtimeByDeclaration.get(declaration) ?? '.js'
-			const isIndex = /[\\/]index\.d\.[cm]?ts$/.test(target)
+			const isIndex = dirname(target) === targetStem
 			const baseSpecifier = specifier.endsWith('/') ? specifier.slice(0, -1) : specifier
 			replacement = isIndex
 				? `${baseSpecifier}/index${runtimeExtension}`
@@ -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,12 +742,12 @@ 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)) {
-			const runtimeTargets = stringsIn(mapping).filter((entry) =>
-				/\.(?:[cm]?[jt]sx?|tsrx)$/.test(entry),
+			const runtimeTargets = stringsIn(mapping).filter(
+				(entry) => !extname(entry) || /\.(?:[cm]?[jt]sx?|tsrx)$/.test(entry),
 			)
 
 			if (runtimeTargets.length && !configuredSubpaths.has(subpath)) {
@@ -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(
@@ -794,8 +794,8 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 
 	if (exportsMap && typeof exportsMap === 'object') {
 		for (const [subpath, mapping] of Object.entries(exportsMap)) {
-			const runtimeTargets = stringsIn(mapping).filter((target) =>
-				/\.(?:[cm]?[jt]sx?|tsrx)$/.test(target),
+			const runtimeTargets = stringsIn(mapping).filter(
+				(target) => !extname(target) || /\.(?:[cm]?[jt]sx?|tsrx)$/.test(target),
 			)
 
 			if (!runtimeTargets.length) {
@@ -925,6 +925,23 @@ function runTarget(projectRoot, args) {
 			return false
 		}
 
+		// TypeScript does not emit declaration inputs. Preserve included, local
+		// declarations beside emitted modules so their references remain closed.
+		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)