tsrx-typegen 0.2.0 → 0.2.2

package/README.md

@@ -5,6 +5,10 @@ command uses the consuming package's TypeScript and tsrx compiler, then maps
 source-extension imports in the emitted declarations to JavaScript module
 specifiers.
 
+```sh
+pnpm exec tsrx-typegen --target octane
+```
+
 Install `tsrx-typegen` as a development tool alongside `typescript` and
 `@tsrx/typescript-plugin`. Each target in `tsrx-typegen.json` names its
 renderer, project config, declaration output directory, and public subpaths.
@@ -26,7 +30,13 @@ missing or stale output, unresolved `.tsrx` references, and code export paths
 without declaration targets. It refuses to overwrite an unmanaged declaration
 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.
+explicit declaration override. Case-only source renames replace the prior
+manifest-owned declaration, including on case-insensitive filesystems; manual
+declarations remain protected.
+
+```sh
+pnpm exec tsrx-typegen --target octane --check
+```
 
 Treat the output directory, including its ownership manifest, as generated
 build artifacts: ignore it in Git, formatting, and linting. Keep handwritten
@@ -36,7 +46,7 @@ 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).
+[Develop against generated declarations](../../docs/notes/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:
@@ -56,7 +66,7 @@ select a named target directly. A target can look like this:
 				}
 			}
 		}
-  }
+	}
 }
 ```
 
@@ -65,9 +75,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"
+	}
 }
 ```
 
@@ -76,10 +86,22 @@ manifest; check mode detects edits to either the source mapping or generated
 copy. Override declarations must use publishable module specifiers and may not
 reference `.tsrx` files.
 
+```sh
+pnpm exec tsrx-typegen --target octane --check
+```
+
 Relative imports between generated declarations receive runtime extensions
 from the source map, including extensionless imports. This supports NodeNext
 consumers as well as bundler resolution without requiring `allowArbitraryExtensions`.
 
+```ts
+// Plain TypeScript consumer of the package whose exports are configured above.
+import { Button } from 'my-component-library'
+
+// Button is a component exported by your library's src/index.ts.
+export { Button }
+```
+
 Use separate target records and project configs when public signatures differ.
 Each config must select the same source variants as its runtime build.
 `runtime` records the published runtime path or condition map, while `types`
@@ -89,6 +111,12 @@ and `.ts` to `.js`, with `.mts` to `.mjs` and `.cts` to `.cjs`. Packages with
 another runtime layout can override these mappings in `sourceExtensions` at
 the target or root level.
 
+```json
+{
+	"sourceExtensions": { ".tsrx": ".js", ".mts": ".mjs", ".cts": ".cjs" }
+}
+```
+
 ## Publish checks
 
 Use `--pack-check` before publishing. It checks every configured target unless
@@ -101,6 +129,11 @@ 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.
 
+```sh
+pnpm exec tsrx-typegen --pack-check
+pnpm exec tsrx-typegen --pack-check --target octane
+```
+
 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
@@ -109,15 +142,35 @@ 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.
 
+```json
+{
+	"targets": {
+		"manual": {
+			"emit": false,
+			"renderer": "octane",
+			"project": "tsconfig.types.json",
+			"outDir": "types/generated",
+			"entrypoints": {
+				".": {
+					"source": "src/index.ts",
+					"runtime": "./dist/index.js",
+					"types": "./types/index.d.ts"
+				}
+			}
+		}
+	}
+}
+```
+
 Run the same gate from `prepack` so `pnpm pack` and publication share it:
 
 ```json
 {
-  "scripts": {
-    "typegen": "tsrx-typegen --target octane",
-    "build": "vite build && pnpm typegen",
-    "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"
+	}
 }
 ```
 
@@ -125,6 +178,10 @@ When run from a package root that has `tsrx-typegen.json`, `xplat doctor`
 delegates to `tsrx-typegen --pack-check` and returns a failing exit status if
 that declaration gate fails.
 
+```sh
+pnpm exec xplat doctor
+```
+
 The first supported backend is the classic `tsrx-tsc` path with TypeScript
 5.9.x. TypeScript 7 content-mapper output needs upstream declaration naming and
 specifier support before it can replace this backend. Generation rejects
@@ -137,3 +194,10 @@ packed package with a plain TypeScript consumer; generated declarations may
 still express a different contract even when their paths and exports are
 valid. Use explicit overrides for exceptional signatures and keep those
 overrides outside the generated output directory.
+
+```ts
+// Source of your component package; use an explicit return type for helpers.
+export function formatCount(count: number): string {
+	return `${count} packed`
+}
+```

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "tsrx-typegen",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Generate consumer-ready TypeScript declarations for TSRX libraries",
   "keywords": [
-    "tsrx",
-    "typegen",
-    "typescript",
+    "build-tool",
+    "codegen",
     "declarations",
     "dts",
-    "codegen",
-    "build-tool"
+    "tsrx",
+    "typegen",
+    "typescript"
   ],
-  "license": "MIT",
   "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

@@ -92,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`)
 	}
 
@@ -124,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(
@@ -149,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 {
@@ -163,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) {
@@ -178,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}`)
@@ -187,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(
@@ -211,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,
@@ -235,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,
@@ -245,15 +275,18 @@ 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`)
+			throw new Error(
+				`${path}: target ${selectedName} has emit: false — it configures --pack-check only`,
+			)
 		}
 
 		if (typeof selected.project !== 'string' || !selected.project) {
@@ -282,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)]) {
@@ -304,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}`,
+				)
 			}
 		}
 
@@ -325,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`,
+			)
 		}
 	}
 
@@ -378,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())
 }
 
@@ -390,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
@@ -428,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}`)
 	}
@@ -440,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),
 		)
@@ -464,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)
@@ -498,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),
 		]),
 	)
 }
@@ -532,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}`)
 	}
 }
@@ -547,21 +608,54 @@ function pathInside(root, file) {
 	)
 }
 
+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()) {
-		if (oldFiles?.has(file) || overrideFiles.has(file)) {continue}
-		try {
-			statSync(join(outputDir, file))
+		const existing = existingOutputPath(outputDir, file)
+		if (existing && !oldFiles?.has(existing) && !overrideFiles.has(existing)) {
 			throw new Error(`refusing to overwrite unmanaged declaration: ${file}`)
-		} catch (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) {
@@ -579,40 +673,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)
@@ -647,13 +758,20 @@ 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}`)
+			// TypeScript emits forward-slash paths even on Windows; resolve both
+			// sides before comparing them with the platform-native entry path.
+			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)
@@ -680,7 +798,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`)
@@ -688,7 +809,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}`)
@@ -696,10 +820,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}`)
 				}
@@ -712,14 +840,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) {
@@ -751,16 +883,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.',
@@ -783,7 +933,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
 			}
 
@@ -805,7 +958,10 @@ 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
 	}
 

package/src/pack-check.mjs

@@ -262,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)) {
@@ -350,8 +354,7 @@ function compilerExports(ts, program, file, cache = new Map(), pending = new Set
 				ts.sys,
 			).resolvedModule?.resolvedFileName
 
-			const targetExports =
-				target && compilerExports(ts, program, target, cache, pending)
+			const targetExports = target && compilerExports(ts, program, target, cache, pending)
 
 			pending.delete(absolute)
 			for (const name of targetExports?.all ?? []) {
@@ -596,8 +599,6 @@ export function checkPackedPackage(projectRoot, ts) {
 	mkdirSync(packOutput)
 	mkdirSync(extractedRoot)
 	try {
-		verifyPackedPackage(ts, projectRoot)
-		console.log('tsrx-typegen: workspace exports and declaration graph are valid')
 		const packed = spawnSync(
 			'pnpm',
 			['--config.ignore-scripts=true', 'pack', '--pack-destination', packOutput],
@@ -651,7 +652,7 @@ export function checkPackedPackage(projectRoot, ts) {
 		}
 
 		verifyPackedPackage(ts, join(extractedRoot, 'package'))
-		console.log('tsrx-typegen: packed runtime exports and declaration graph are valid')
+		console.log('tsrx-typegen: packed exports and declaration graph are valid')
 	} finally {
 		rmSync(temporary, { recursive: true, force: true })
 	}