tsrx-typegen 0.1.0 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alec Larson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -28,6 +28,16 @@ and removes stale files only when the manifest says it owns them. Same-name
 sources such as `Button.ts` and `Button.tsrx` need separate target configs or an
 explicit declaration override.
 
+Treat the output directory, including its ownership manifest, as generated
+build artifacts: ignore it in Git, formatting, and linting. Keep handwritten
+declarations and override sources outside that directory. Include the output
+directory in the package's `files` list so ignored declarations still ship in
+the tarball. Generate before local consumer typechecks, and regenerate in
+`prepack` before validating the package. Workspaces that resolve generated
+types directly also need generation during setup and refreshes during
+development; this repository's workflow is documented in
+[Develop against generated declarations](../../docs/toolchain-notes.md#develop-against-generated-declarations).
+
 `--project` selects the target whose project path matches. Use `--target` to
 select a named target directly. A target can look like this:
 
@@ -46,7 +56,7 @@ select a named target directly. A target can look like this:
 				}
 			}
 		}
-  }
+	}
 }
 ```
 
@@ -55,9 +65,9 @@ generated directory, then map their generated output path explicitly:
 
 ```json
 {
-  "overrides": {
-    "Button.d.ts": "types/overrides/Button.d.ts"
-  }
+	"overrides": {
+		"Button.d.ts": "types/overrides/Button.d.ts"
+	}
 }
 ```
 
@@ -91,14 +101,23 @@ bare package imports are declared dependencies or peers. The command needs
 TypeScript consumer test for the module-resolution modes and public prop
 contracts your package supports.
 
+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
+checks for it and only validates the packed package. Such targets cannot be
+selected for generation; a plain `--target` run against them fails. Every code
+export path still needs a `types` condition — pointing at a `.d.ts` file or,
+for source-published packages, the `.ts` source itself.
+
 Run the same gate from `prepack` so `pnpm pack` and publication share it:
 
 ```json
 {
-  "scripts": {
-    "build": "vite build && tsrx-typegen --target octane",
-    "prepack": "pnpm build && tsrx-typegen --pack-check"
-  }
+	"scripts": {
+		"typegen": "tsrx-typegen --target octane",
+		"build": "vite build && pnpm typegen",
+		"prepack": "pnpm build && tsrx-typegen --pack-check"
+	}
 }
 ```
 

package/package.json

@@ -1,10 +1,21 @@
 {
   "name": "tsrx-typegen",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Generate consumer-ready TypeScript declarations for TSRX libraries",
+  "keywords": [
+    "build-tool",
+    "codegen",
+    "declarations",
+    "dts",
+    "tsrx",
+    "typegen",
+    "typescript"
+  ],
+  "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/tsrx-typegen",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/octane-xplat/octane-xplat.git",
+    "url": "https://github.com/octane-xplat/octane-xplat",
     "directory": "packages/tsrx-typegen"
   },
   "bin": {

package/src/cli.mjs

@@ -36,6 +36,7 @@ Options:
   --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`)
 }
 
@@ -91,7 +92,12 @@ function configuredTargetNames(projectRoot, selectedTarget) {
 	}
 
 	const targets = config?.targets
-	if (!targets || typeof targets !== 'object' || Array.isArray(targets) || !Object.keys(targets).length) {
+	if (
+		!targets ||
+		typeof targets !== 'object' ||
+		Array.isArray(targets) ||
+		!Object.keys(targets).length
+	) {
 		throw new Error(`${path}: --pack-check requires at least one configured target`)
 	}
 
@@ -99,7 +105,7 @@ function configuredTargetNames(projectRoot, selectedTarget) {
 		throw new Error(`${path}: unknown target ${selectedTarget}`)
 	}
 
-	return selectedTarget ? [selectedTarget] : Object.keys(targets)
+	return { names: selectedTarget ? [selectedTarget] : Object.keys(targets), targets }
 }
 
 function loadProjectModule(projectRoot, specifier) {
@@ -123,16 +129,24 @@ function readProjectConfig(ts, configPath, projectRoot, target) {
 		[{ extension: '.tsrx', isMixedContent: true, scriptKind: ts.ScriptKind.Deferred }],
 	)
 
-	if (!parsed) {throw new Error(`Could not read ${configPath}`)}
+	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'))}
+	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' : undefined)
+		(options.jsx === ts.JsxEmit.ReactJSX || options.jsx === ts.JsxEmit.ReactJSXDev
+			? 'react'
+			: undefined)
 
 	if (target?.renderer && jsxRenderer && target.renderer !== jsxRenderer) {
 		throw new Error(
@@ -148,7 +162,9 @@ function readProjectConfig(ts, configPath, projectRoot, target) {
 
 	const outputDirectory = target?.outDir ?? options.declarationDir ?? options.outDir
 	if (!outputDirectory) {
-		throw new Error(`${configPath} must set target outDir, compilerOptions.outDir, or declarationDir.`)
+		throw new Error(
+			`${configPath} must set target outDir, compilerOptions.outDir, or declarationDir.`,
+		)
 	}
 
 	return {
@@ -162,7 +178,10 @@ function readProjectConfig(ts, configPath, projectRoot, target) {
 }
 
 function commonDirectory(paths) {
-	if (!paths.length) {throw new Error('TypeScript project has no root files.')}
+	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) {
@@ -177,7 +196,10 @@ function sourceDeclarationMap(rootDir, fileNames, extensions, overrides) {
 	const runtimeByDeclaration = new Map()
 	for (const source of fileNames) {
 		const sourceExtension = extname(source).toLowerCase()
-		if (!Object.hasOwn(extensions, sourceExtension) || /\.d\.[cm]?ts$/i.test(source)) {continue}
+		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}`)
@@ -186,7 +208,10 @@ function sourceDeclarationMap(rootDir, fileNames, extensions, overrides) {
 		const declarationExtension =
 			sourceExtension === '.mts' ? '.d.mts' : sourceExtension === '.cts' ? '.d.cts' : '.d.ts'
 
-		const declaration = normalize(sourcePath.slice(0, -sourceExtension.length) + declarationExtension)
+		const declaration = normalize(
+			sourcePath.slice(0, -sourceExtension.length) + declarationExtension,
+		)
+
 		const prior = sourceOutputs.get(declaration)
 		if (prior && !overrides.has(declaration)) {
 			throw new Error(
@@ -210,7 +235,10 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 		config = JSON.parse(readFileSync(path, 'utf8'))
 	} catch (error) {
 		if (error.code === 'ENOENT') {
-			if (targetArgument) {throw new Error(`No tsrx-typegen.json defines target ${targetArgument}.`)}
+			if (targetArgument) {
+				throw new Error(`No tsrx-typegen.json defines target ${targetArgument}.`)
+			}
+
 			return {
 				project: projectArgument,
 				target: null,
@@ -234,7 +262,10 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 	const resolveProject = (value) => resolve(projectRoot, value)
 	let selectedName = targetArgument
 	let selected = selectedName ? targets[selectedName] : undefined
-	if (selectedName && !selected) {throw new Error(`${path}: unknown target ${selectedName}`)}
+	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,
@@ -244,13 +275,20 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 			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) {
+		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`)
 		}
@@ -277,10 +315,12 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 				!entry ||
 				typeof entry !== 'object' ||
 				typeof entry.source !== 'string' ||
-			!stringsIn(entry.runtime).length ||
+				!stringsIn(entry.runtime).length ||
 				!stringsIn(entry.types).length
 			) {
-				throw new Error(`${path}: target ${selectedName} entrypoint ${subpath} needs source, runtime, and types`)
+				throw new Error(
+					`${path}: target ${selectedName} entrypoint ${subpath} needs source, runtime, and types`,
+				)
 			}
 
 			for (const publishedPath of [...stringsIn(entry.runtime), ...stringsIn(entry.types)]) {
@@ -299,7 +339,9 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 			} catch {}
 
 			if (!pathInside(projectRoot, source) || !isFile) {
-				throw new Error(`${path}: target ${selectedName} entrypoint source is missing: ${entry.source}`)
+				throw new Error(
+					`${path}: target ${selectedName} entrypoint source is missing: ${entry.source}`,
+				)
 			}
 		}
 
@@ -320,10 +362,17 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 	}
 
 	const project = projectArgument ?? resolveProject(selected.project)
-	const sourceExtensions = { ...defaultExtensions, ...config.sourceExtensions, ...selected?.sourceExtensions }
+	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`)
+			throw new Error(
+				`${path}: sourceExtensions must map dot-prefixed extensions to dot-prefixed runtime extensions`,
+			)
 		}
 	}
 
@@ -373,7 +422,10 @@ function applyOverrides(ts, projectRoot, outputDir, generated, overrides) {
 		normalized.set(outputFile, content)
 	}
 
-	for (const [outputPath, content] of normalized) {generated.set(outputPath, content)}
+	for (const [outputPath, content] of normalized) {
+		generated.set(outputPath, content)
+	}
+
 	return new Set(normalized.keys())
 }
 
@@ -385,8 +437,11 @@ function collectFiles(root, 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)}
+		if (entry.isDirectory()) {
+			collectFiles(path, output)
+		} else if (entry.isFile()) {
+			output.push(path)
+		}
 	}
 
 	return output
@@ -423,7 +478,10 @@ function moduleSpecifierNodes(ts, sourceFile) {
 
 function assertNoTsrxModuleReferences(ts, path, text) {
 	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-	const unresolved = moduleSpecifierNodes(ts, source).find((node) => /\.tsrx(?:$|[?#])/.test(node.text))
+	const unresolved = moduleSpecifierNodes(ts, source).find((node) =>
+		/\.tsrx(?:$|[?#])/.test(node.text),
+	)
+
 	if (unresolved) {
 		throw new Error(`${path}: unresolved .tsrx module specifier ${unresolved.text}`)
 	}
@@ -435,8 +493,14 @@ function rewriteDeclaration(ts, path, outputDir, extensions, generatedFiles, run
 	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}
+		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),
 		)
@@ -459,7 +523,10 @@ function rewriteDeclaration(ts, path, outputDir, extensions, generatedFiles, run
 				generatedFiles.has(relative(outputDir, candidate)),
 			)
 
-			if (!target) {continue}
+			if (!target) {
+				continue
+			}
+
 			const declaration = relative(outputDir, target)
 			const runtimeExtension = runtimeByDeclaration.get(declaration) ?? '.js'
 			const isIndex = /[\\/]index\.d\.[cm]?ts$/.test(target)
@@ -493,19 +560,15 @@ function normalizeOutput(ts, outputDir, extensions, runtimeByDeclaration) {
 		.filter((path) => /\.d\.[cm]?ts$/.test(path))
 		.sort()
 
-	if (!files.length) {throw new Error('TypeScript emitted no declaration files.')}
+	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,
-			),
+			rewriteDeclaration(ts, path, outputDir, extensions, generatedFiles, runtimeByDeclaration),
 		]),
 	)
 }
@@ -527,7 +590,10 @@ function previousManifest(outputDir) {
 
 		return new Set(manifest.files)
 	} catch (error) {
-		if (error.code === 'ENOENT') {return null}
+		if (error.code === 'ENOENT') {
+			return null
+		}
+
 		throw new Error(`${path}: ${error.message}`)
 	}
 }
@@ -544,19 +610,29 @@ function pathInside(root, file) {
 
 function writeOutput(outputDir, generated, oldFiles, overrideFiles) {
 	for (const file of generated.keys()) {
-		if (oldFiles?.has(file) || overrideFiles.has(file)) {continue}
+		if (oldFiles?.has(file) || overrideFiles.has(file)) {
+			continue
+		}
+
 		try {
 			statSync(join(outputDir, file))
 			throw new Error(`refusing to overwrite unmanaged declaration: ${file}`)
 		} catch (error) {
-			if (error.code !== 'ENOENT') {throw error}
+			if (error.code !== 'ENOENT') {
+				throw error
+			}
 		}
 	}
 
 	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 })}
+		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) {
@@ -574,40 +650,57 @@ function writeOutput(outputDir, generated, oldFiles, overrideFiles) {
 
 function compareOutput(outputDir, generated, oldFiles, overrideFiles) {
 	const errors = []
-	if (!oldFiles) {errors.push(`missing ${manifestName}; run tsrx-typegen --project <tsconfig> first`)}
+	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}
+				if (error.code !== 'ENOENT') {
+					throw error
+				}
 			}
 		}
 
 		try {
-			if (readFileSync(join(outputDir, file), 'utf8') !== generated.get(file))
-				{errors.push(`${file} is stale`)}
+			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`)}
+		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 []}
+	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 []}
+	if (!value || typeof value !== 'object' || Array.isArray(value)) {
+		return []
+	}
+
 	return [
 		...(Object.hasOwn(value, 'types') ? stringsIn(value.types) : []),
 		...Object.entries(value)
@@ -642,13 +735,18 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 		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`)
+				failures.push(
+					`${subpath} is configured for ${target.name} but missing from effective package exports`,
+				)
+
 				continue
 			}
 
 			const source = resolve(projectRoot, entry.source)
 			if (![...sourceOutputs.values()].includes(source)) {
-				failures.push(`${subpath} source is not included by its TypeScript project: ${entry.source}`)
+				failures.push(
+					`${subpath} source is not included by its TypeScript project: ${entry.source}`,
+				)
 			}
 
 			const declaredRuntime = stringsIn(entry.runtime)
@@ -675,7 +773,10 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 				/\.(?:[cm]?[jt]sx?|tsrx)$/.test(target),
 			)
 
-			if (!runtimeTargets.length) {continue}
+			if (!runtimeTargets.length) {
+				continue
+			}
+
 			const targets = typeTargets(mapping)
 			if (!targets.length) {
 				failures.push(`${subpath} has code exports but no types condition`)
@@ -683,7 +784,10 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 			}
 
 			for (const target of targets) {
-				if (!target.startsWith('./') || target.includes('*')) {continue}
+				if (!target.startsWith('./') || target.includes('*')) {
+					continue
+				}
+
 				const absolute = resolve(projectRoot, target)
 				if (!pathInside(projectRoot, absolute)) {
 					failures.push(`${subpath} types target escapes the package: ${target}`)
@@ -691,10 +795,14 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 				}
 
 				const generatedPath = relative(outDir, absolute)
-				if (pathInside(outDir, absolute) && generated.has(generatedPath)) {continue}
+				if (pathInside(outDir, absolute) && generated.has(generatedPath)) {
+					continue
+				}
+
 				try {
-					if (!statSync(absolute).isFile())
-						{failures.push(`${subpath} types target is not a file: ${target}`)}
+					if (!statSync(absolute).isFile()) {
+						failures.push(`${subpath} types target is not a file: ${target}`)
+					}
 				} catch {
 					failures.push(`${subpath} types target is missing: ${target}`)
 				}
@@ -707,14 +815,18 @@ function verifyPublicTypes(projectRoot, generated, outDir, target, sourceOutputs
 			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}`)}
+				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'))}
+	if (failures.length) {
+		throw new Error(failures.join('\n'))
+	}
 }
 
 function runTarget(projectRoot, args) {
@@ -746,16 +858,34 @@ function runTarget(projectRoot, args) {
 	const temporaryOut = join(temporaryRoot, 'types')
 	const outputDir = temporaryOut
 	try {
-		const compilerArgs = [compilerPath, '--pretty', 'false', '--project', project, outputFlag, temporaryOut]
+		const compilerArgs = [
+			compilerPath,
+			'--pretty',
+			'false',
+			'--project',
+			project,
+			outputFlag,
+			temporaryOut,
+		]
+
 		const result = spawnSync(process.execPath, compilerArgs, {
 			cwd: projectRoot,
 			encoding: 'utf8',
 			maxBuffer: 32 * 1024 * 1024,
 		})
 
-		if (result.stdout) {process.stdout.write(result.stdout)}
-		if (result.stderr) {process.stderr.write(result.stderr)}
-		if (result.error) {throw result.error}
+		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.',
@@ -778,7 +908,10 @@ function runTarget(projectRoot, args) {
 		if (args.check) {
 			const errors = compareOutput(outDir, generated, oldFiles, managedOverrides)
 			if (errors.length) {
-				for (const error of errors) {console.error(`tsrx-typegen: ${error}`)}
+				for (const error of errors) {
+					console.error(`tsrx-typegen: ${error}`)
+				}
+
 				return false
 			}
 
@@ -800,12 +933,19 @@ function run() {
 	const args = parseArgs(process.argv.slice(2))
 	const projectRoot = process.cwd()
 	if (!args.packCheck) {
-		if (!runTarget(projectRoot, args)) {process.exitCode = 1}
+		if (!runTarget(projectRoot, args)) {
+			process.exitCode = 1
+		}
+
 		return
 	}
 
-	const targets = configuredTargetNames(projectRoot, args.target)
-	for (const target of targets) {
+	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

package/src/pack-check.mjs

@@ -190,10 +190,15 @@ function localSourceModule(file, specifier) {
 	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`)
+		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`)
-		candidates.push(join(target, 'index.ts'), join(target, 'index.tsx'), join(target, 'index.tsrx'))
+		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) {
@@ -257,7 +262,11 @@ function staticRuntimeExports(ts, file, seen = new Set()) {
 		}
 
 		if (ts.isExportDeclaration(statement) && !statement.isTypeOnly) {
-			if (!statement.exportClause && statement.moduleSpecifier && ts.isStringLiteralLike(statement.moduleSpecifier)) {
+			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)) {
@@ -285,7 +294,16 @@ function staticRuntimeExports(ts, file, seen = new Set()) {
 	return names
 }
 
-function compilerExports(ts, program, file) {
+function compilerExports(ts, program, file, cache = new Map(), pending = new Set()) {
+	const absolute = resolve(file)
+	if (cache.has(absolute)) {
+		return cache.get(absolute)
+	}
+
+	if (pending.has(absolute)) {
+		return { all: new Set(), values: new Set() }
+	}
+
 	const source = program.getSourceFile(file)
 	if (!source) {
 		return undefined
@@ -313,7 +331,56 @@ function compilerExports(ts, program, file) {
 		}
 	}
 
-	return { all, values }
+	// Type-only edges (`export type *`, `export type { X }`) re-list the
+	// 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()
+	for (const statement of source.statements) {
+		if (!ts.isExportDeclaration(statement) || !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) {