@orkestrel/scaffold 0.0.103 → 0.0.104

package/dist/src/core/index.cjs

@@ -4,7 +4,7 @@ let _orkestrel_template = require("@orkestrel/template");
 let _orkestrel_emitter = require("@orkestrel/emitter");
 var package_default = {
 	name: "@orkestrel/scaffold",
-	version: "0.0.103",
+	version: "0.0.104",
 	description: "Scaffold workspaces with commands: new, audit, repair, catalog, and overwrite.",
 	keywords: [
 		"audit",
@@ -104,11 +104,11 @@ var package_default = {
 	},
 	devDependencies: {
 		"@microsoft/api-extractor": "^7.59.4",
-		"@orkestrel/browser": "^0.0.28",
+		"@orkestrel/browser": "^0.0.29",
 		"@orkestrel/guide": "^0.0.24",
 		"@orkestrel/html": "^0.0.12",
-		"@orkestrel/probe": "^0.0.23",
-		"@orkestrel/test": "^0.0.27",
+		"@orkestrel/probe": "^0.0.24",
+		"@orkestrel/test": "^0.0.28",
 		"@types/node": "^26.6.4",
 		"@vitest/browser-playwright": "^4.1.11",
 		"oxfmt": "^0.72.0",
@@ -250,6 +250,8 @@ var APP_MATRIX = Object.freeze({
 var BIN_CONFIGS = Object.freeze(["configs/src/vite.bin.config.ts", "configs/src/tsconfig.bin.json"]);
 /** Names the executable entry whose presence makes a workspace `bin`. */
 var BIN_ENTRY_PATH = "src/bin/main.ts";
+/** Names the built executable a bin workspace's manifest command runs. */
+var BIN_OUTPUT_PATH = "dist/bin/main.js";
 /**
 * Lists the paths a target receives from the vendored data root, frozen.
 *
@@ -478,6 +480,8 @@ var GLOBAL_SETUP_PATH = "tests/setupGlobal.ts";
 var GUIDES_TEST_PATH = "tests/guides.test.ts";
 /** Names the generated packed-package proof every publishing workspace is planned at. */
 var DISTRIBUTION_TEST_PATH = "tests/distribution.test.ts";
+/** Names the content-owned harness imported by the generated distribution proof. */
+var DISTRIBUTION_SETUP_PATH = "tests/setupDistribution.ts";
 /**
 * Names the `prepublishOnly` row that runs the packed-package proof against a real registry.
 *
@@ -496,6 +500,8 @@ var INTEGRATION_TEST_PATH = "tests/integration.test.ts";
 var MANIFEST_PATH = "package.json";
 /** Names the official-tooling drift proof whose presence makes a workspace `conformance`. */
 var CONFORMANCE_TEST_PATH = "tests/conformance.test.ts";
+/** Names the real-tree proof whose presence makes a workspace `tree`. */
+var TREE_TEST_PATH = "tests/tree.test.ts";
 /** Names the live-service readiness module whose presence makes a workspace `service`. */
 var SERVICE_SETUP_PATH = "tests/setupService.ts";
 /**
@@ -527,8 +533,8 @@ var NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
 * @remarks
 * A dependency name reaches a path, because a workspace's guide mirror is
 * derived from it. Fixing the scope and forbidding everything but the bare name
-* after it is what stops a hand-built name from escaping the directory the
-* mirror belongs in.
+* after it is what stops a hand-built name from resolving outside the directory
+* the mirror belongs in.
 */
 var DEPENDENCY_NAME_PATTERN = /^@orkestrel\/[a-z][a-z0-9-]*$/;
 /**
@@ -942,7 +948,13 @@ function isNamedPlugin(plugin: PluginOption): plugin is { name: string } {
 			name: { label: name, color: 'magenta' },
 			root: resolveWorkspacePath('.'),
 			isolate: false,
-			setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts', './tests/setupStyles.ts'],
+			setupFiles: [
+				'./tests/setup.ts',
+				'./tests/setupBrowser.ts',
+				...(existsSync(resolveWorkspacePath('tests/setupStyles.ts'))
+					? ['./tests/setupStyles.ts']
+					: []),
+			],
 			browser: {
 				enabled: true,
 				provider: playwright(browserOptions),
@@ -1462,6 +1474,24 @@ export function skills(override?: UserConfig): UserConfig {
 	}
 	return mergeOverride(project, override)
 }
+`,
+		tree: `// The laws this package states about its own real tree.
+// Standalone Node proof; reads the tree without a build, install, or service.
+export function tree(override?: UserConfig): UserConfig {
+	const project: UserConfig = {
+		resolve,
+		test: {
+			name: { label: 'tree', color: 'magenta' },
+			include: ['${TREE_TEST_PATH}'],
+			setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
+			pool: 'threads',
+			isolate: false,
+			environment: 'node',
+			browser: { enabled: false },
+		},
+	}
+	return mergeOverride(project, override)
+}
 `,
 		conformance: `// Where this package drifts from the official tooling it stays compatible with.
 // The subject is this package, so the proof is hermetic and stays in \`npm test\`.
@@ -2226,11 +2256,11 @@ export function resolveSystemBrowser(
  * verified system channel, then the platform default channel. An operator override outranks
  * discovery and is returned exactly as given: none of those environment values is checked
  * against the filesystem, because verifying an override would defeat the override. The pinned
- * managed revision outranks anything found on the host because it is deterministic. The installed
- * pinned revision returns empty options unless \`PLAYWRIGHT_SCROLLBARS=classic\` is set. Only a
- * discovered system channel is verified before it is named. The platform default is unverified
- * as well and exists only as a last resort: Windows takes \`msedge\`, which ships with the OS and
- * never collides with a foreground Chrome.
+ * managed revision outranks anything found on the host because it is deterministic. Every resolved
+ * managed path names the full Chromium executable so headless launches retain browser permissions.
+ * Only a discovered system channel is verified before it is named. The platform default is
+ * unverified as well and exists only as a last resort: Windows takes \`msedge\`, which ships with the
+ * OS and never collides with a foreground Chrome.
  *
  * Set \`PLAYWRIGHT_SCROLLBARS=classic\` only for runs that measure scrollbar compensation, never
  * for a standing gate. Every Chromium launch in that run omits Playwright's \`--hide-scrollbars\`
@@ -2277,7 +2307,6 @@ export function resolveBrowser(
 	}
 	const managed = pinned === undefined ? undefined : resolveManagedBrowser(pinned)
 	if (managed !== undefined) {
-		if (managed === pinned) return scrollbars === 'classic' ? { launchOptions: launch } : {}
 		return { launchOptions: { executablePath: managed, ...launch } }
 	}
 	const bundled = resolveBundledBrowser(platform, root)
@@ -2451,8 +2480,8 @@ declare module 'vitest' {
 }
 `,
 		sheet: `import sheet from '{{root}}dist/src/{{name}}/index.css?raw'
+import { adoptSheet, readLayerNames } from '@orkestrel/test/browser'
 import { describe, expect, it } from 'vitest'
-import { adoptSheet, readLayerNames } from '{{setup}}'
 
 describe('{{name}} entry', () => {
 	it('opens with the declared cascade order', () => {
@@ -2476,120 +2505,8 @@ describe('{{name}} entry', () => {
 })
 `,
 		styles: Object.freeze({
-			module: `/** Describes an adopted stylesheet and its idempotent release operation. */
-export interface SheetAdoption {
-	readonly sheet: CSSStyleSheet
-	release(): void
-}
-
-/**
- * Adopts CSS text into the document with an idempotent release operation.
- * @param text - The compiled sheet text.
- * @returns The adopted sheet and its release operation.
- * @example
- * \`\`\`ts
- * const adopted = adoptSheet('.sample { color: red }')
- * adopted.release()
- * \`\`\`
- */
-export function adoptSheet(text: string): SheetAdoption {
-	const sheet = new CSSStyleSheet()
-	sheet.replaceSync(text)
-	document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet]
-	return {
-		sheet,
-		release: () => {
-			document.adoptedStyleSheets = document.adoptedStyleSheets.filter(
-				(candidate) => candidate !== sheet,
-			)
-		},
-	}
-}
-
-/**
- * Reads layer statements and blocks in declaration order, including repeated names.
- * @param source - The parsed sheet, or a grouping rule inside it.
- * @param layer - The qualified name of the layer that encloses \`source\`, when one does.
- * @returns Qualified layer names, with an empty name for an anonymous layer.
- * @example
- * \`\`\`ts
- * readLayerNames(new CSSStyleSheet()) // []
- * \`\`\`
- */
-export function readLayerNames(
-	source: CSSStyleSheet | CSSGroupingRule,
-	layer?: string,
-): readonly string[] {
-	return Array.from(source.cssRules).flatMap((rule) => [
-		...(rule instanceof CSSLayerStatementRule
-			? rule.nameList
-			: rule instanceof CSSLayerBlockRule
-				? [rule.name]
-				: []
-		).map((name) => (layer === undefined ? name : layer + '.' + name)),
-		...(rule instanceof CSSGroupingRule
-			? readLayerNames(
-					rule,
-					rule instanceof CSSLayerBlockRule
-						? layer === undefined
-							? rule.name
-							: layer + '.' + rule.name
-						: layer,
-				)
-			: []),
-	])
-}
-`,
-			proof: `import type { SheetAdoption } from './setupStyles.js'
-import { describe, expect, it } from 'vitest'
-import { adoptSheet, readLayerNames } from './setupStyles.js'
-
-describe('CSSOM instruments', () => {
-	it('adopts and releases only its own sheet, including repeated release', () => {
-		const previous = [...document.adoptedStyleSheets]
-		const first: SheetAdoption = adoptSheet('.sample { color: red }')
-		try {
-			const second = adoptSheet('.other { display: block }')
-			try {
-				expect(document.adoptedStyleSheets).toEqual([...previous, first.sheet, second.sheet])
-				expect(first.sheet.cssRules.length).toBe(1)
-				first.release()
-				first.release()
-				expect(document.adoptedStyleSheets).toEqual([...previous, second.sheet])
-			} finally {
-				second.release()
-			}
-		} finally {
-			first.release()
-		}
-		expect(document.adoptedStyleSheets).toEqual(previous)
-	})
-
-	it('reads statements, blocks, nested conditions, and anonymous layers in order', () => {
-		const adopted = adoptSheet(
-			'@layer first, second; @layer first { @media all { @layer nested {} } } @layer {}',
-		)
-		try {
-			expect(readLayerNames(adopted.sheet)).toEqual([
-				'first',
-				'second',
-				'first',
-				'first.nested',
-				'',
-			])
-		} finally {
-			adopted.release()
-		}
-	})
-
-	it('returns no layer names for an empty sheet or an unlayered rule', () => {
-		const sheet = new CSSStyleSheet()
-		expect(readLayerNames(sheet)).toEqual([])
-		sheet.replaceSync('.sample { color: red }')
-		expect(readLayerNames(sheet)).toEqual([])
-	})
-})
-`
+			module: "",
+			proof: ""
 		}),
 		setup: "",
 		global: Object.freeze({
@@ -2625,13 +2542,7 @@ describe('bin entry', () => {
 })
 `,
 		distribution: Object.freeze({
-			proof: `// The artifact a consumer installs, measured rather than described. This workspace
-// is packed and installed into a throwaway consumer, and every following claim is read
-// off that installed tree: the exports map it publishes, the declarations it ships,
-// and the module objects a real runtime hands a consumer. Nothing here names this
-// package, one of its exports, or how many there are, so the proof stays true as
-// the published surface moves.
-{{types}}import type { SpawnSyncReturns } from 'node:child_process'
+			module: `{{types}}import type { SpawnSyncReturns } from 'node:child_process'
 import type { TestContext } from 'vitest'
 import { spawnSync } from 'node:child_process'
 import {
@@ -2646,67 +2557,126 @@ import {
 } from 'node:fs'
 {{transport}}import { createRequire } from 'node:module'
 import { tmpdir } from 'node:os'
-import { dirname, join, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-{{launcher}}import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { dirname, join, relative as relativePath, resolve, sep } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { isDeepStrictEqual } from 'node:util'
+import { parseSync } from 'vite'
+{{launcher}}
+/** Defines the lifecycle and installed consumer read by a distribution proof. */
+export interface DistributionSuiteInterface {
+	readonly scratch: string
+	start(): void
+	read(context: TestContext): DistributionStage
+	destroy(): void
+}
 
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
-const NPM = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+/** Holds the observed and required values for one distribution assertion. */
+export interface DistributionObservation {
+	readonly actual: unknown
+	readonly expected: unknown
+}
+
+/** Defines one independently registered distribution observation. */
+export interface DistributionCase {
+	readonly label: string
+	readonly observe: (
+		context: TestContext,
+	) => DistributionObservation | Promise<DistributionObservation>
+}
+
+/** Holds the installed export map's classified publications. */
+export interface DistributionClassification {
+	readonly entries: readonly DistributionEntry[]
+	readonly subpaths: readonly string[]
+	readonly undeclared: readonly string[]
+	readonly excluded: readonly string[]
+	readonly targets: readonly string[]
+}
+
+/** Names the workspace whose packed artifact the proof consumes. */
+export const DISTRIBUTION_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+/** Names the npm executable on the running host. */
+export const DISTRIBUTION_NPM = process.platform === 'win32' ? 'npm.cmd' : 'npm'
 // The compiler this workspace installs, run as a command rather than called in
 // process: the command and its plain-text diagnostics are the same across the
 // compiler majors this toolchain supports, and its in-process API is not. It is
 // resolved from the workspace under proof, so a consumer of the packed artifact is
 // checked by the same compiler that workspace's own \`check\` script runs.
-const TSC = createRequire(join(ROOT, 'package.json')).resolve('typescript/bin/tsc')
+/** Names the compiler installed by the workspace under proof. */
+export const DISTRIBUTION_COMPILER = createRequire(join(DISTRIBUTION_ROOT, 'package.json')).resolve(
+	'typescript/bin/tsc',
+)
 // Windows needs a shell to launch a \`.cmd\`: Node refuses one directly since the
 // batch-argument hardening, and \`spawnSync\` returns \`EINVAL\` with a null status
 // rather than an exit code a caller can read. Every following argument is a literal or
 // a path this file built, so the shell has nothing to escape.
-const SHELL = process.platform === 'win32'
+/** Selects the Windows command-shell route required by the npm shim. */
+export const DISTRIBUTION_SHELL = process.platform === 'win32'
 // \`prepublishOnly\` runs this proof as \`npm run test:distribution -- --mode release\`,
 // and the root configuration's project factories carry that mode into this project.
 // Release is the publish gate, so evidence it cannot obtain fails there and skips
 // everywhere else: a gate that passes on missing evidence proves nothing.
-const RELEASE = import.meta.env.MODE === 'release'
+/** Indicates whether missing prerequisites must fail the publish gate. */
+export const DISTRIBUTION_RELEASE = import.meta.env?.MODE === 'release'
 // The built output directory convention a browser face may publish from. Every
 // selection reads this prefix off the export target and never off the subpath name. A
 // workspace whose only published face is the browser one publishes that face at the
 // root subpath, so a rule keyed on the subpath name drives a browser bundle through
 // Node and the miss is silent.
-const BROWSER_OUTPUT = './dist/src/browser/'
-const ABSENT_SUBPATH = '/no-subpath-is-published-under-this-name'
+/** Names the conventional output prefix for a browser publication. */
+export const DISTRIBUTION_BROWSER_OUTPUT = './dist/src/browser/'
+/** Names the unpublished subpath used as a resolution control. */
+export const DISTRIBUTION_ABSENT_SUBPATH = '/no-subpath-is-published-under-this-name'
 // A compiler diagnostic that says where it is: the path relative to the directory
 // the compiler ran in, the 1-based line and column, the code, and the message. The
 // diagnostics are the verdict rather than the exit code, which differs between the
 // compiler majors this toolchain supports, so a reported line matching nothing here
 // came from something other than a check of a consumer module.
-const DIAGNOSTIC_PATTERN = /^(.+?)\\(\\d+,\\d+\\): error TS\\d+: /u
-const PING = ['ping', '--fetch-retries=0', '--fetch-timeout=5000', '--loglevel=silent']
-const ESM_DRIVER = 'drive.mjs'
-const CJS_DRIVER = 'drive.cjs'
-const CONSUMER_MANIFEST = \`{ "name": "distribution-consumer", "private": true, "type": "module" }\\n\`
-const ESM_DRIVER_SOURCE = \`const entry = await import(process.argv[2])
+/** Matches the location prefix of a consumer compiler diagnostic. */
+export const DISTRIBUTION_DIAGNOSTIC_PATTERN = /^(.+?)\\(\\d+,\\d+\\): error TS\\d+: /u
+/** Lists the bounded registry-readiness command arguments. */
+export const DISTRIBUTION_PING = Object.freeze([
+	'ping',
+	'--fetch-retries=0',
+	'--fetch-timeout=5000',
+	'--loglevel=silent',
+])
+/** Names the consumer entry that imports an installed module. */
+export const DISTRIBUTION_ESM_DRIVER = 'drive.mjs'
+/** Names the consumer entry that requires an installed module. */
+export const DISTRIBUTION_CJS_DRIVER = 'drive.cjs'
+/** Defines the isolated consumer package manifest. */
+export const DISTRIBUTION_CONSUMER_MANIFEST =
+	'{ "name": "distribution-consumer", "private": true, "type": "module" }\\n'
+/** Reads the names exported by an installed ESM entry. */
+export const DISTRIBUTION_ESM_DRIVER_SOURCE = \`const entry = await import(process.argv[2])
 process.stdout.write(JSON.stringify(Object.keys(entry).sort()))
 \`
-const CJS_DRIVER_SOURCE = \`const entry = require(process.argv[2])
+/** Reads the names exported by an installed CommonJS entry. */
+export const DISTRIBUTION_CJS_DRIVER_SOURCE = \`const entry = require(process.argv[2])
 process.stdout.write(JSON.stringify(Object.keys(entry).sort()))
 \`
 
 // The extensions a JavaScript handler loads as modules. Node loads a native addon
 // through its addon handler instead, so that extension is named separately.
-const MODULE_EXTENSIONS = ['.js', '.mjs', '.cjs']
-const ADDON_EXTENSION = '.node'
+/** Lists extensions loaded as JavaScript modules. */
+export const DISTRIBUTION_MODULE_EXTENSIONS = Object.freeze(['.js', '.mjs', '.cjs'])
+/** Names the extension loaded by the native-addon handler. */
+export const DISTRIBUTION_ADDON_EXTENSION = '.node'
 // The extensions a declaration file carries. A \`require\` condition declares
 // \`.d.cts\` and an ESM-only one \`.d.mts\`, so the \`.d.ts\` spelling alone does not
 // name them.
-const DECLARATION_EXTENSIONS = ['.d.ts', '.d.cts', '.d.mts']
-type Format = 'module' | 'commonjs'
+/** Lists the supported TypeScript declaration extensions. */
+export const DISTRIBUTION_DECLARATION_EXTENSIONS = Object.freeze(['.d.ts', '.d.cts', '.d.mts'])
+/** Names the module format of a typed consumer. */
+export type DistributionFormat = 'module' | 'commonjs'
 
 // The Node import target is resolved with the conditions that driver supplies. The
 // CommonJS compile probe is selected from its declaration's format, and its runtime
 // drive loads the same subpath through Node's require resolver. Vite's production
 // client build enables its module and browser conditions.
-const RUNTIME_CONDITIONS = Object.freeze({
+/** Defines the conditions each runtime uses to resolve an entry. */
+export const DISTRIBUTION_RUNTIME_CONDITIONS = Object.freeze({
 	module: Object.freeze(['node-addons', 'node', 'import', 'module-sync']),
 	commonjs: Object.freeze(['node-addons', 'node', 'require', 'module-sync']),
 	browser: Object.freeze(['module', 'browser', 'production', 'import']),
@@ -2714,24 +2684,28 @@ const RUNTIME_CONDITIONS = Object.freeze({
 // TypeScript's Node resolutions add \`node\` to the format condition. Its bundler
 // resolution does not, so a browser drive compares against the declaration a bundler
 // consumer reads rather than borrowing the Node declaration.
-const BUNDLER_CONDITIONS = Object.freeze({
-	module: ['types', 'import'],
-	commonjs: ['types', 'require'],
+/** Defines the declaration conditions used by bundler consumers. */
+export const DISTRIBUTION_BUNDLER_CONDITIONS = Object.freeze({
+	module: Object.freeze(['types', 'import']),
+	commonjs: Object.freeze(['types', 'require']),
 })
-const DECLARATION_CONDITIONS = Object.freeze({
-	module: ['types', 'node', 'import'],
-	commonjs: ['types', 'node', 'require'],
-	browser: BUNDLER_CONDITIONS.module,
+/** Defines the declaration conditions paired with each runtime. */
+export const DISTRIBUTION_DECLARATION_CONDITIONS = Object.freeze({
+	module: Object.freeze(['types', 'node', 'import']),
+	commonjs: Object.freeze(['types', 'node', 'require']),
+	browser: DISTRIBUTION_BUNDLER_CONDITIONS.module,
 })
 
-interface Resolution {
+/** Describes the compiler options and conditions for one consumer resolution. */
+export interface DistributionResolution {
 	readonly label: string
 	readonly resolution: string
 	readonly module: string
-	readonly conditions: Readonly<Record<Format, readonly string[]>>
+	readonly conditions: Readonly<Record<DistributionFormat, readonly string[]>>
 }
 
-interface TargetResolution {
+/** Holds the target selected by package condition resolution. */
+export interface DistributionTargetResult {
 	readonly target: string
 }
 
@@ -2740,44 +2714,53 @@ interface TargetResolution {
 // \`require\`-only subpath therefore stays in each CommonJS probe that can resolve it.
 // The option values are the spellings the project file takes, so nothing here needs
 // the compiler's own API to name them.
-const RESOLUTIONS: readonly Resolution[] = [
+/** Lists the compiler resolutions driven against installed declarations. */
+export const DISTRIBUTION_RESOLUTIONS: readonly DistributionResolution[] = Object.freeze([
 	{
 		label: 'node16',
 		resolution: 'node16',
 		module: 'node16',
-		conditions: DECLARATION_CONDITIONS,
+		conditions: DISTRIBUTION_DECLARATION_CONDITIONS,
 	},
 	{
 		label: 'nodenext',
 		resolution: 'nodenext',
 		module: 'nodenext',
-		conditions: DECLARATION_CONDITIONS,
+		conditions: DISTRIBUTION_DECLARATION_CONDITIONS,
 	},
 	{
 		label: 'bundler',
 		resolution: 'bundler',
 		module: 'esnext',
-		conditions: BUNDLER_CONDITIONS,
+		conditions: DISTRIBUTION_BUNDLER_CONDITIONS,
 	},
-]
+])
 
 // The driver a bundled consumer reads declarations under. A browser application
 // compiles through a bundler, so the browser drive answers under this one alone,
 // and naming it here is what keeps that selection tied to the driver it selects.
-const BROWSER_DRIVER = RESOLUTIONS.find((candidate) => candidate.label === 'bundler')
-if (BROWSER_DRIVER === undefined) throw new Error("RESOLUTIONS carries no 'bundler' row")
+/** Selects the compiler resolution used by a browser consumer. */
+export const DISTRIBUTION_BROWSER_RESOLUTION = DISTRIBUTION_RESOLUTIONS.find(
+	(candidate) => candidate.label === 'bundler',
+)
+if (DISTRIBUTION_BROWSER_RESOLUTION === undefined)
+	throw new Error("DISTRIBUTION_RESOLUTIONS carries no 'bundler' row")
 
-const FORMATS: ReadonlyArray<readonly [extension: string, format: Format]> = [
+/** Pairs consumer source extensions with their module formats. */
+export const DISTRIBUTION_FORMATS: ReadonlyArray<
+	readonly [extension: string, format: DistributionFormat]
+> = Object.freeze([
 	['ts', 'module'],
 	['cts', 'commonjs'],
-]
+])
 
 // One published subpath, resolved to what this proof can drive: the specifier a
 // consumer writes, whether the declarations its consumer formats resolve at all,
 // whether the exports map answers the browser condition with a target of its own,
 // whether it answers \`import\` and \`require\` at all, and whether the target that
 // \`require\` answers with is one that a CommonJS consumer loads.
-interface Entry {
+/** Describes one published subpath and its runtime and declaration capabilities. */
+export interface DistributionEntry {
 	readonly subpath: string
 	readonly specifier: string
 	readonly mapping: unknown
@@ -2795,29 +2778,48 @@ interface Entry {
 // The installed tree every claim is read from. Every subpath the exports map names
 // lands in exactly one of \`entries\`, \`undeclared\`, and \`excluded\`, so a subpath this
 // proof cannot drive is reported rather than dropped.
-interface Stage {
+/** Holds the installed consumer and the partition of its published subpaths. */
+export interface DistributionStage {
 	readonly consumer: string
 	readonly installed: string
 	readonly archives: readonly string[]
-	readonly entries: readonly Entry[]
+	readonly entries: readonly DistributionEntry[]
 	readonly subpaths: readonly string[]
 	readonly undeclared: readonly string[]
 	readonly excluded: readonly string[]
 	readonly targets: readonly string[]
 }
 
-function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+/**
+ * Checks whether a value is a non-null object other than an array.
+ *
+ * @param value - The value to inspect.
+ * @returns True if the value is a record; false otherwise.
+ */
+export function isDistributionRecord(value: unknown): value is Readonly<Record<string, unknown>> {
 	return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
-function isNames(value: unknown): value is readonly string[] {
+/**
+ * Checks whether a value is an array of strings.
+ *
+ * @param value - The value to inspect.
+ * @returns True if every array member is a string; false otherwise.
+ */
+export function isDistributionNames(value: unknown): value is readonly string[] {
 	return Array.isArray(value) && value.every((name) => typeof name === 'string')
 }
 
 // A fallback list, which is what Node reads an array in an exports entry as. The
 // narrowing is what the following walkers need: \`Array.isArray\` widens an \`unknown\`
 // member to \`any\`, and an entry read that way is not read at all.
-function isList(value: unknown): value is readonly unknown[] {
+/**
+ * Checks whether a value is a fallback array.
+ *
+ * @param value - The value to inspect.
+ * @returns True if the value is an array; false otherwise.
+ */
+export function isDistributionList(value: unknown): value is readonly unknown[] {
 	return Array.isArray(value)
 }
 
@@ -2825,7 +2827,13 @@ function isList(value: unknown): value is readonly unknown[] {
 // package and a target containing a dot, parent, or node_modules segment during
 // package-target resolution. A later module-resolution failure is not the same
 // thing: an array falls through the former and keeps the latter.
-function isPackageTarget(target: string): boolean {
+/**
+ * Checks whether a relative package target contains only admitted segments.
+ *
+ * @param target - The package-relative target.
+ * @returns True if the target passes package-target validation; false otherwise.
+ */
+export function matchesDistributionPackageTarget(target: string): boolean {
 	if (!target.startsWith('./')) return false
 	const refused = ['.', '..', 'node_modules']
 	return target
@@ -2840,59 +2848,113 @@ function isPackageTarget(target: string): boolean {
 		})
 }
 
-function readJson(path: string): unknown {
+/**
+ * Reads and parses a JSON file.
+ *
+ * @param path - The file to read.
+ * @returns The parsed value. Throws when reading or parsing fails.
+ */
+export function readDistributionJSON(path: string): unknown {
 	const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'))
 	return parsed
 }
 
-function readManifestName(path: string): string {
-	const manifest = readJson(path)
-	if (!isRecord(manifest) || typeof manifest.name !== 'string') {
+/**
+ * Reads the package name from a manifest.
+ *
+ * @param path - The manifest to read.
+ * @returns The package name. Throws when the manifest has no string name.
+ */
+export function readDistributionManifestName(path: string): string {
+	const manifest = readDistributionJSON(path)
+	if (!isDistributionRecord(manifest) || typeof manifest.name !== 'string') {
 		throw new Error(\`The manifest at \${path} declares no package name\`)
 	}
 	return manifest.name
 }
 
-function writeFile(path: string, content: string): void {
+/**
+ * Writes a consumer file after creating its parent directory.
+ *
+ * @param path - The file to write.
+ * @param content - The text to write.
+ */
+export function writeDistributionFile(path: string, content: string): void {
 	mkdirSync(dirname(path), { recursive: true })
 	writeFileSync(path, content)
 }
 
-function readOutput(result: SpawnSyncReturns<string>): string {
+/**
+ * Combines the output streams of a completed command.
+ *
+ * @param result - The completed command.
+ * @returns The trimmed diagnostic text.
+ */
+export function readDistributionOutput(result: SpawnSyncReturns<string>): string {
 	return \`\${result.stdout ?? ''}\${result.stderr ?? ''}\`.trim()
 }
 
-function runNpm(args: readonly string[], cwd: string, scratch: string): SpawnSyncReturns<string> {
-	return spawnSync(NPM, [...args], {
+/**
+ * Runs npm with a cache inside the owned scratch directory.
+ *
+ * @param args - The npm arguments.
+ * @param cwd - The working directory.
+ * @param scratch - The owned scratch root.
+ * @returns The command status and captured streams.
+ */
+export function runDistributionNpm(
+	args: readonly string[],
+	cwd: string,
+	scratch: string,
+): SpawnSyncReturns<string> {
+	return spawnSync(DISTRIBUTION_NPM, [...args], {
 		cwd,
 		encoding: 'utf8',
 		env: { ...process.env, npm_config_cache: join(scratch, 'cache') },
-		shell: SHELL,
+		shell: DISTRIBUTION_SHELL,
 		windowsHide: true,
 	})
 }
 
-function runNode(args: readonly string[], cwd: string): SpawnSyncReturns<string> {
+/**
+ * Runs a JavaScript entry with the running Node executable.
+ *
+ * @param args - The Node arguments.
+ * @param cwd - The working directory.
+ * @returns The command status and captured streams.
+ */
+export function runDistributionNode(
+	args: readonly string[],
+	cwd: string,
+): SpawnSyncReturns<string> {
 	return spawnSync(process.execPath, [...args], { cwd, encoding: 'utf8', windowsHide: true })
 }
 
 // Node's own condition matching, read in declaration order.
-function resolvePackageTarget(
+/**
+ * Resolves a package target through conditions and fallback arrays.
+ *
+ * @param entry - The exports-map entry.
+ * @param conditions - The active resolution conditions.
+ * @returns The selected target, or undefined when no branch resolves.
+ */
+export function resolveDistributionPackageTarget(
 	entry: unknown,
 	conditions: readonly string[],
-): TargetResolution | undefined {
+): DistributionTargetResult | undefined {
 	if (typeof entry === 'string') return { target: entry }
-	if (isList(entry)) {
+	if (isDistributionList(entry)) {
 		for (const member of entry) {
-			const resolved = resolvePackageTarget(member, conditions)
-			if (resolved !== undefined && isPackageTarget(resolved.target)) return resolved
+			const resolved = resolveDistributionPackageTarget(member, conditions)
+			if (resolved !== undefined && matchesDistributionPackageTarget(resolved.target))
+				return resolved
 		}
 		return undefined
 	}
-	if (!isRecord(entry)) return undefined
+	if (!isDistributionRecord(entry)) return undefined
 	for (const [condition, nested] of Object.entries(entry)) {
 		if (condition !== 'default' && !conditions.includes(condition)) continue
-		const resolved = resolvePackageTarget(nested, conditions)
+		const resolved = resolveDistributionPackageTarget(nested, conditions)
 		if (resolved !== undefined) return resolved
 	}
 	return undefined
@@ -2902,13 +2964,29 @@ function resolvePackageTarget(
 // one walker. An entry may declare \`types\` beside \`default\` at its top level
 // rather than inside \`import\`, so a fixed \`entry.import.types\` lookup is not
 // equivalent to condition resolution.
-function resolveTarget(entry: unknown, conditions: readonly string[]): string | undefined {
-	return resolvePackageTarget(entry, conditions)?.target
+/**
+ * Resolves the path selected by an exports-map entry.
+ *
+ * @param entry - The exports-map entry.
+ * @param conditions - The active resolution conditions.
+ * @returns The selected path, or undefined when no branch resolves.
+ */
+export function resolveDistributionTarget(
+	entry: unknown,
+	conditions: readonly string[],
+): string | undefined {
+	return resolveDistributionPackageTarget(entry, conditions)?.target
 }
 
 // Whether a path is a physical file. TypeScript's file-existence check refuses a
 // directory at the same spelling and continues to the outer package scope.
-function matchesFile(path: string): boolean {
+/**
+ * Checks whether a path names a physical file.
+ *
+ * @param path - The filesystem path.
+ * @returns True if the path names a file; false otherwise.
+ */
+export function matchesDistributionFile(path: string): boolean {
 	try {
 		return statSync(path).isFile()
 	} catch {
@@ -2919,8 +2997,18 @@ function matchesFile(path: string): boolean {
 // TypeScript resolves a declaration target by accepting an existing declaration
 // directly or by substituting beside a JavaScript target. A missing target leaves
 // the containing condition or fallback list unresolved, so the walk continues.
-function targetToDeclaration(target: string, installed: string): string | undefined {
-	if (!isPackageTarget(target)) return undefined
+/**
+ * Resolves an existing declaration beside a package target.
+ *
+ * @param target - The package-relative target.
+ * @param installed - The installed package root.
+ * @returns The declaration target, or undefined when no declaration exists.
+ */
+export function targetToDistributionDeclaration(
+	target: string,
+	installed: string,
+): string | undefined {
+	if (!matchesDistributionPackageTarget(target)) return undefined
 	const declaration = target.endsWith('.cjs')
 		? \`\${target.slice(0, -4)}.d.cts\`
 		: target.endsWith('.mjs')
@@ -2928,29 +3016,37 @@ function targetToDeclaration(target: string, installed: string): string | undefi
 			: target.endsWith('.js')
 				? \`\${target.slice(0, -3)}.d.ts\`
 				: target
-	if (declaration === target && !isDeclaration(target)) return undefined
-	return matchesFile(join(installed, declaration)) ? declaration : undefined
+	if (declaration === target && !matchesDistributionDeclaration(target)) return undefined
+	return matchesDistributionFile(join(installed, declaration)) ? declaration : undefined
 }
 
 // The declaration TypeScript resolves through one importing format's conditions.
 // Condition objects keep manifest order, and arrays keep fallback order.
-function resolveDeclaration(
+/**
+ * Resolves an existing declaration through consumer conditions.
+ *
+ * @param entry - The exports-map entry.
+ * @param conditions - The active declaration conditions.
+ * @param installed - The installed package root.
+ * @returns The declaration target, or undefined when no branch resolves.
+ */
+export function resolveDistributionDeclaration(
 	entry: unknown,
 	conditions: readonly string[],
 	installed: string,
 ): string | undefined {
-	if (typeof entry === 'string') return targetToDeclaration(entry, installed)
-	if (isList(entry)) {
+	if (typeof entry === 'string') return targetToDistributionDeclaration(entry, installed)
+	if (isDistributionList(entry)) {
 		for (const member of entry) {
-			const resolved = resolveDeclaration(member, conditions, installed)
+			const resolved = resolveDistributionDeclaration(member, conditions, installed)
 			if (resolved !== undefined) return resolved
 		}
 		return undefined
 	}
-	if (!isRecord(entry)) return undefined
+	if (!isDistributionRecord(entry)) return undefined
 	for (const [condition, nested] of Object.entries(entry)) {
 		if (condition !== 'default' && !conditions.includes(condition)) continue
-		const resolved = resolveDeclaration(nested, conditions, installed)
+		const resolved = resolveDistributionDeclaration(nested, conditions, installed)
 		if (resolved !== undefined) return resolved
 	}
 	return undefined
@@ -2959,7 +3055,14 @@ function resolveDeclaration(
 // The nearest package scope that decides a \`.d.ts\` declaration's module format. A
 // physical nested manifest starts a scope even when it omits \`type\` or cannot be
 // parsed. A directory at that spelling is not a manifest, so the walk continues.
-function readPackageType(installed: string, target: string): unknown {
+/**
+ * Reads the nearest package scope for a target inside an installed package.
+ *
+ * @param installed - The installed package root.
+ * @param target - The package-relative target.
+ * @returns The manifest type, or undefined when the nearest scope omits it or cannot be read.
+ */
+export function readDistributionPackageType(installed: string, target: string): unknown {
 	// One \`dirname\` per path segment reaches the root from any path. The walk ends at the
 	// installed package, so no scope above it is consulted.
 	const start = dirname(join(installed, target))
@@ -2969,57 +3072,91 @@ function readPackageType(installed: string, target: string): unknown {
 	const end = chain.indexOf(installed)
 	const scope = chain
 		.slice(0, end === -1 ? chain.length : end + 1)
-		.find((directory) => matchesFile(join(directory, 'package.json')))
+		.find((directory) => matchesDistributionFile(join(directory, 'package.json')))
 	if (scope === undefined) return undefined
 	try {
-		const manifest = readJson(join(scope, 'package.json'))
-		return isRecord(manifest) ? manifest.type : undefined
+		const manifest = readDistributionJSON(join(scope, 'package.json'))
+		return isDistributionRecord(manifest) ? manifest.type : undefined
 	} catch {
 		return undefined
 	}
 }
 
-function resolvesBrowser(entry: unknown): boolean {
-	const module = resolveTarget(entry, RUNTIME_CONDITIONS.browser)
-	if (module !== undefined && module.startsWith(BROWSER_OUTPUT)) return true
+/**
+ * Checks whether an entry publishes a distinct or conventional browser target.
+ *
+ * @param entry - The exports-map entry.
+ * @returns True if the entry requires a browser drive; false otherwise.
+ */
+export function resolvesDistributionBrowser(entry: unknown): boolean {
+	const module = resolveDistributionTarget(entry, DISTRIBUTION_RUNTIME_CONDITIONS.browser)
+	if (module !== undefined && module.startsWith(DISTRIBUTION_BROWSER_OUTPUT)) return true
 	if (module === undefined) return false
-	const imported = resolveTarget(entry, RUNTIME_CONDITIONS.module)
-	const required = resolveTarget(entry, RUNTIME_CONDITIONS.commonjs)
+	const imported = resolveDistributionTarget(entry, DISTRIBUTION_RUNTIME_CONDITIONS.module)
+	const required = resolveDistributionTarget(entry, DISTRIBUTION_RUNTIME_CONDITIONS.commonjs)
 	return module !== imported && module !== required
 }
 
 // Whether the target selected by Node's CommonJS conditions is a module require can
 // load. A JavaScript target takes its own nearest package scope. Native addons and
 // extensionless targets have their own CommonJS handlers.
-function resolvesCommonJS(entry: unknown, installed: string): boolean {
-	const target = resolveTarget(entry, RUNTIME_CONDITIONS.commonjs)
+/**
+ * Checks whether Node require can load an entry selected by its conditions.
+ *
+ * @param entry - The exports-map entry.
+ * @param installed - The installed package root.
+ * @returns True if the target has a CommonJS-compatible format; false otherwise.
+ */
+export function resolvesDistributionCommonJS(entry: unknown, installed: string): boolean {
+	const target = resolveDistributionTarget(entry, DISTRIBUTION_RUNTIME_CONDITIONS.commonjs)
 	if (target === undefined) return false
 	const name = target.slice(target.lastIndexOf('/') + 1)
 	if (name.endsWith('.cjs')) return true
 	if (name.endsWith('.mjs')) return false
 	if (name.endsWith('.node')) return true
 	if (!name.includes('.')) return true
-	return name.endsWith('.js') && readPackageType(installed, target) !== 'module'
+	return name.endsWith('.js') && readDistributionPackageType(installed, target) !== 'module'
 }
 
 // Whether the declaration selected by a typed CommonJS consumer admits that entry.
 // A \`.d.cts\` declaration admits and a \`.d.mts\` declaration refuses. A \`.d.ts\`
 // declaration takes its own nearest package scope.
-function declaresCommonJS(entry: unknown, installed: string): boolean {
-	const declaration = resolveDeclaration(entry, DECLARATION_CONDITIONS.commonjs, installed)
+/**
+ * Checks whether an entry resolves a CommonJS-compatible declaration.
+ *
+ * @param entry - The exports-map entry.
+ * @param installed - The installed package root.
+ * @returns True if the selected declaration admits CommonJS consumption; false otherwise.
+ */
+export function declaresDistributionCommonJS(entry: unknown, installed: string): boolean {
+	const declaration = resolveDistributionDeclaration(
+		entry,
+		DISTRIBUTION_DECLARATION_CONDITIONS.commonjs,
+		installed,
+	)
 	if (declaration === undefined) return false
 	if (declaration.endsWith('.d.cts')) return true
 	if (declaration.endsWith('.d.mts')) return false
-	return declaration.endsWith('.d.ts') && readPackageType(installed, declaration) !== 'module'
+	return (
+		declaration.endsWith('.d.ts') &&
+		readDistributionPackageType(installed, declaration) !== 'module'
+	)
 }
 
 // Every target an entry names under any condition. A fallback list omits members
 // Node rejects during package-target validation, because no reader can take them.
-function collectTargets(entry: unknown): readonly string[] {
+/**
+ * Collects the targets an entry publishes under every condition.
+ *
+ * @param entry - The exports-map entry.
+ * @returns The targets, excluding invalid members of fallback arrays.
+ */
+export function collectDistributionTargets(entry: unknown): readonly string[] {
 	if (typeof entry === 'string') return [entry]
-	if (isList(entry)) return entry.flatMap(collectTargets).filter(isPackageTarget)
-	if (!isRecord(entry)) return []
-	return Object.values(entry).flatMap((nested) => collectTargets(nested))
+	if (isDistributionList(entry))
+		return entry.flatMap(collectDistributionTargets).filter(matchesDistributionPackageTarget)
+	if (!isDistributionRecord(entry)) return []
+	return Object.values(entry).flatMap((nested) => collectDistributionTargets(nested))
 }
 
 // Whether a target is a file a runtime loads for its names, which is what a
@@ -3031,24 +3168,43 @@ function collectTargets(entry: unknown): readonly string[] {
 // \`"./package.json"\` manifest pointer, and a declaration alike.
 // The cost is an extensionless file published for a reader, such as a \`LICENSE\`:
 // that target reports undeclared until it is given an extension or a declaration.
-function isModule(target: string): boolean {
+/**
+ * Checks whether a target names a runtime module rather than an asset.
+ *
+ * @param target - The package-relative target.
+ * @returns True if the target has a module extension or no extension; false otherwise.
+ */
+export function matchesDistributionModule(target: string): boolean {
 	const name = target.slice(target.lastIndexOf('/') + 1)
 	const dot = name.lastIndexOf('.')
-	if (name.endsWith(ADDON_EXTENSION)) return true
-	return dot === -1 || MODULE_EXTENSIONS.includes(name.slice(dot))
+	if (name.endsWith(DISTRIBUTION_ADDON_EXTENSION)) return true
+	return dot === -1 || DISTRIBUTION_MODULE_EXTENSIONS.includes(name.slice(dot))
 }
 
 // Whether a resolved target is a declaration rather than the JavaScript a
 // \`default\` branch answers with when the entry declares no \`types\` condition.
-function isDeclaration(target: string): boolean {
-	return DECLARATION_EXTENSIONS.some((extension) => target.endsWith(extension))
+/**
+ * Checks whether a target names a TypeScript declaration.
+ *
+ * @param target - The package-relative target.
+ * @returns True if the target has a declaration extension; false otherwise.
+ */
+export function matchesDistributionDeclaration(target: string): boolean {
+	return DISTRIBUTION_DECLARATION_EXTENSIONS.some((extension) => target.endsWith(extension))
 }
 
 // The declarations the Node module, Node CommonJS, and browser drives compare
 // against. Each field uses the conditions of the TypeScript consumer paired with
 // that runtime. A JavaScript target resolves through TypeScript's adjacent
 // declaration substitution rather than standing in for the declaration itself.
-function readDeclaration(
+/**
+ * Reads the declarations paired with Node and browser consumers.
+ *
+ * @param entry - The exports-map entry.
+ * @param installed - The installed package root.
+ * @returns The declaration selected by each consumer format.
+ */
+export function readDistributionDeclaration(
 	entry: unknown,
 	installed: string,
 ): {
@@ -3057,17 +3213,39 @@ function readDeclaration(
 	readonly browser: string | undefined
 } {
 	return {
-		module: resolveDeclaration(entry, DECLARATION_CONDITIONS.module, installed),
-		commonjs: resolveDeclaration(entry, DECLARATION_CONDITIONS.commonjs, installed),
-		browser: resolveDeclaration(entry, DECLARATION_CONDITIONS.browser, installed),
+		module: resolveDistributionDeclaration(
+			entry,
+			DISTRIBUTION_DECLARATION_CONDITIONS.module,
+			installed,
+		),
+		commonjs: resolveDistributionDeclaration(
+			entry,
+			DISTRIBUTION_DECLARATION_CONDITIONS.commonjs,
+			installed,
+		),
+		browser: resolveDistributionDeclaration(
+			entry,
+			DISTRIBUTION_DECLARATION_CONDITIONS.browser,
+			installed,
+		),
 	}
 }
 
 // The entries one compile driver can resolve under its own conditions.
-function selectEntries(entries: readonly Entry[], conditions: readonly string[]): readonly Entry[] {
+/**
+ * Filters entries to those a consumer can resolve.
+ *
+ * @param entries - The installed entries.
+ * @param conditions - The active consumer conditions.
+ * @returns The matching entries in their original order.
+ */
+export function filterDistributionEntries(
+	entries: readonly DistributionEntry[],
+	conditions: readonly string[],
+): readonly DistributionEntry[] {
 	return entries.filter(
 		(entry) =>
-			resolveTarget(entry.mapping, conditions) !== undefined &&
+			resolveDistributionTarget(entry.mapping, conditions) !== undefined &&
 			(!conditions.includes('require') || entry.loadable),
 	)
 }
@@ -3075,22 +3253,42 @@ function selectEntries(entries: readonly Entry[], conditions: readonly string[])
 // The compile drivers whose conditions reach one entry under one importing format.
 // A driver that resolves no target for that entry compiles nothing, so a consumer
 // written under it would report a resolution failure this package never made.
-function selectDrivers(entry: Entry, format: Format): readonly Resolution[] {
-	return RESOLUTIONS.filter(
-		(driver) => selectEntries([entry], driver.conditions[format]).length > 0,
+/**
+ * Filters compiler resolutions to those that can read an entry.
+ *
+ * @param entry - The installed entry.
+ * @param format - The consumer module format.
+ * @returns The matching compiler resolutions.
+ */
+export function filterDistributionResolutions(
+	entry: DistributionEntry,
+	format: DistributionFormat,
+): readonly DistributionResolution[] {
+	return DISTRIBUTION_RESOLUTIONS.filter(
+		(driver) => filterDistributionEntries([entry], driver.conditions[format]).length > 0,
 	)
 }
 
 // Requirable entries that declare CommonJS support but a typed CommonJS consumer
 // cannot compile against. A default branch resolving under the require condition
 // set makes no CommonJS claim.
-function selectUntypable(entries: readonly Entry[], installed: string): readonly Entry[] {
+/**
+ * Filters entries whose require target lacks a compatible declaration.
+ *
+ * @param entries - The installed entries.
+ * @param installed - The installed package root.
+ * @returns The entries a CommonJS consumer cannot typecheck.
+ */
+export function filterDistributionUntypable(
+	entries: readonly DistributionEntry[],
+	installed: string,
+): readonly DistributionEntry[] {
 	return entries.filter(
 		(entry) =>
 			entry.requirable &&
-			isRecord(entry.mapping) &&
+			isDistributionRecord(entry.mapping) &&
 			Object.hasOwn(entry.mapping, 'require') &&
-			!declaresCommonJS(entry.mapping, installed),
+			!declaresDistributionCommonJS(entry.mapping, installed),
 	)
 }
 
@@ -3098,20 +3296,30 @@ function selectUntypable(entries: readonly Entry[], installed: string): readonly
 // installed entry that consumer imports, the file extension fixing its importing
 // format, the names a real runtime published off it, and the driver whose scratch
 // project compiles it.
-interface Surface {
-	readonly entry: Entry
+/** Describes the runtime names and declaration resolution compared for one entry. */
+export interface DistributionSurface {
+	readonly entry: DistributionEntry
 	readonly extension: string
 	readonly published: readonly string[]
-	readonly driver: Resolution
+	readonly driver: DistributionResolution
 }
 
 // A scratch project over named consumer modules, written beside them so their own
 // resolution reaches the installed package. Nothing is emitted and no ambient types
 // are pulled in, so what the check reads is the installed declarations alone.
-function writeProject(
-	stage: Stage,
+/**
+ * Writes a compiler project for a consumer probe.
+ *
+ * @param stage - The installed consumer.
+ * @param name - The project filename suffix.
+ * @param driver - The compiler resolution.
+ * @param files - The consumer source files.
+ * @returns The absolute project path.
+ */
+export function writeDistributionProject(
+	stage: DistributionStage,
 	name: string,
-	driver: Resolution,
+	driver: DistributionResolution,
 	files: readonly string[],
 ): string {
 	const path = join(stage.consumer, \`tsconfig.\${name}.json\`)
@@ -3127,7 +3335,7 @@ function writeProject(
 		},
 		files: [...files],
 	}
-	writeFile(path, \`\${JSON.stringify(project, undefined, '\\t')}\\n\`)
+	writeDistributionFile(path, \`\${JSON.stringify(project, undefined, '\\t')}\\n\`)
 	return path
 }
 
@@ -3138,8 +3346,21 @@ function writeProject(
 // naming the scratch project rather than a consumer module, and anything at all on
 // the error stream are faults of this proof rather than of the package under proof,
 // so each is raised where it happens instead of counted against the package.
-function checkProject(stage: Stage, project: string): readonly string[] {
-	const result = runNode([TSC, '--noEmit', '--pretty', 'false', '-p', project], stage.consumer)
+/**
+ * Checks a consumer project with the installed TypeScript compiler.
+ *
+ * @param stage - The installed consumer.
+ * @param project - The compiler project path.
+ * @returns The located compiler diagnostics. Throws on a tool or project failure.
+ */
+export function checkDistributionProject(
+	stage: DistributionStage,
+	project: string,
+): readonly string[] {
+	const result = runDistributionNode(
+		[DISTRIBUTION_COMPILER, '--noEmit', '--pretty', 'false', '-p', project],
+		stage.consumer,
+	)
 	const refused = \`\${result.stderr ?? ''}\`.trim()
 	if (refused.length > 0) {
 		throw new Error(\`The consumer compiler wrote \${refused} to its error stream\`)
@@ -3151,7 +3372,7 @@ function checkProject(stage: Stage, project: string): readonly string[] {
 	const heads = lines.flatMap((line, index) => (index === 0 || !/^\\s/u.test(line) ? [index] : []))
 	const reported = heads.map((head, position) => {
 		const line = lines[head] ?? ''
-		const located = DIAGNOSTIC_PATTERN.exec(line)?.[1]
+		const located = DISTRIBUTION_DIAGNOSTIC_PATTERN.exec(line)?.[1]
 		if (located === undefined) {
 			throw new Error(\`The consumer compiler reported \${line}, which names no location\`)
 		}
@@ -3164,7 +3385,7 @@ function checkProject(stage: Stage, project: string): readonly string[] {
 		].join(' ')
 	})
 	if (reported.length === 0 && result.status !== 0) {
-		throw new Error(\`The consumer compiler refused the project: \${readOutput(result)}\`)
+		throw new Error(\`The consumer compiler refused the project: \${readDistributionOutput(result)}\`)
 	}
 	return reported
 }
@@ -3179,26 +3400,47 @@ function checkProject(stage: Stage, project: string): readonly string[] {
 // as a type alone, land on \`surfaced\`: a variable widens into the type
 // \`declared\` annotates, and only \`surfaced\` reads the literal's own keys back.
 // Each names the member it is about, so the failure says which export moved.
-function checkSurface(stage: Stage, surface: Surface): readonly string[] {
+/**
+ * Checks runtime export names against their installed declarations.
+ *
+ * @param stage - The installed consumer.
+ * @param surface - The publication and declaration pair.
+ * @returns The diagnostics labelled by compiler resolution.
+ */
+export function checkDistributionSurface(
+	stage: DistributionStage,
+	surface: DistributionSurface,
+): readonly string[] {
 	const slug = surface.entry.subpath.replaceAll(/[^\\w]+/gu, '-')
 	const name = \`surface.\${surface.driver.label}\${slug}.\${surface.extension}\`
 	const module = \`\${name}\`
 	const keys = surface.published.map((key) => \`\${JSON.stringify(key)}: true\`).join(', ')
-	writeFile(
+	writeDistributionFile(
 		join(stage.consumer, module),
 		\`import * as entry from \${JSON.stringify(surface.entry.specifier)}
-const published = {\${keys.length === 0 ? '' : \` \${keys} \`}} as const
-const declared: Record<keyof typeof entry, true> = published
-const surfaced: Record<keyof typeof published, true> = declared
+export const published = {\${keys.length === 0 ? '' : \` \${keys} \`}} as const
+export const declared: Record<keyof typeof entry, true> = published
+export const surfaced: Record<keyof typeof published, true> = declared
 \`,
 	)
-	const project = writeProject(stage, name, surface.driver, [\`./\${module}\`])
-	return checkProject(stage, project).map((line) => \`\${surface.driver.label}: \${line}\`)
+	const project = writeDistributionProject(stage, name, surface.driver, [\`./\${module}\`])
+	return checkDistributionProject(stage, project).map((line) => \`\${surface.driver.label}: \${line}\`)
 }
 
 // One consumer module importing every installed entry, written where its own
 // resolution finds the installed package.
-function writeConsumerProbe(stage: Stage, path: string, specifiers: readonly string[]): void {
+/**
+ * Writes a consumer importing the requested public specifiers.
+ *
+ * @param stage - The installed consumer.
+ * @param path - The consumer-relative source path.
+ * @param specifiers - The public imports to resolve.
+ */
+export function writeDistributionConsumerProbe(
+	stage: DistributionStage,
+	path: string,
+	specifiers: readonly string[],
+): void {
 	const modules = specifiers.map((specifier, index) => ({
 		binding: \`entry\${String(index)}\`,
 		specifier,
@@ -3208,112 +3450,94 @@ function writeConsumerProbe(stage: Stage, path: string, specifiers: readonly str
 	)
 	const names = modules.map(({ binding }) => binding)
 	const source = \`\${bindings.join('\\n')}\\nexport const surface = [\${names.join(', ')}]\\n\`
-	writeFile(join(stage.consumer, path), source)
+	writeDistributionFile(join(stage.consumer, path), source)
 }
 
 // The runtime key set a real process reads off one installed entry under one
 // condition. The driver is a file rather than an \`--eval\` string, so the specifier
 // travels as an argument and nothing needs escaping.
-function driveRuntime(stage: Stage, specifier: string, driver: string): readonly string[] {
-	const result = runNode([join(stage.consumer, driver), specifier], stage.consumer)
+/**
+ * Reads the names a real Node process loads from an installed entry.
+ *
+ * @param stage - The installed consumer.
+ * @param specifier - The public package specifier.
+ * @param driver - The consumer driver filename.
+ * @returns The exported names. Throws when loading or decoding fails.
+ */
+export function driveDistributionRuntime(
+	stage: DistributionStage,
+	specifier: string,
+	driver: string,
+): readonly string[] {
+	const result = runDistributionNode([join(stage.consumer, driver), specifier], stage.consumer)
 	if (result.status !== 0) {
-		throw new Error(\`Loading \${specifier} from the consumer failed: \${readOutput(result)}\`)
+		throw new Error(
+			\`Loading \${specifier} from the consumer failed: \${readDistributionOutput(result)}\`,
+		)
 	}
 	const published: unknown = JSON.parse(result.stdout)
-	if (!isNames(published)) throw new Error(\`The driver printed no name list for \${specifier}\`)
+	if (!isDistributionNames(published))
+		throw new Error(\`The driver printed no name list for \${specifier}\`)
 	return published
 }
 {{helpers}}
 // Pack this workspace, install the archive into an isolated consumer, and read the
 // published surface back off the installed tree. Every later claim reads this
 // result, so a failure here is raised where it happens rather than once per entry.
-function buildStage(scratch: string): Stage {
+/**
+ * Packs the workspace and installs its archive into an isolated consumer.
+ *
+ * @param scratch - The owned scratch root.
+ * @returns The installed consumer and classified exports.
+ * @throws Thrown when packing or installation fails.
+ */
+export function buildDistributionStage(scratch: string): DistributionStage {
 	const packed = join(scratch, 'packed')
 	const consumer = join(scratch, 'consumer')
 	mkdirSync(packed, { recursive: true })
-	const pack = runNpm(['pack', '--ignore-scripts', '--pack-destination', packed], ROOT, scratch)
-	if (pack.status !== 0) throw new Error(\`npm pack refused this workspace: \${readOutput(pack)}\`)
+	const pack = runDistributionNpm(
+		['pack', '--ignore-scripts', '--pack-destination', packed],
+		DISTRIBUTION_ROOT,
+		scratch,
+	)
+	if (pack.status !== 0)
+		throw new Error(\`npm pack refused this workspace: \${readDistributionOutput(pack)}\`)
 	const archives = readdirSync(packed).filter((name) => name.endsWith('.tgz'))
 	const archive = archives[0]
 	if (archives.length !== 1 || archive === undefined) {
 		throw new Error(\`npm pack wrote no single archive: \${archives.join(', ')}\`)
 	}
-	writeFile(join(consumer, 'package.json'), CONSUMER_MANIFEST)
-	writeFile(join(consumer, ESM_DRIVER), ESM_DRIVER_SOURCE)
-	writeFile(join(consumer, CJS_DRIVER), CJS_DRIVER_SOURCE)
-	const install = runNpm(
+	writeDistributionFile(join(consumer, 'package.json'), DISTRIBUTION_CONSUMER_MANIFEST)
+	writeDistributionFile(join(consumer, DISTRIBUTION_ESM_DRIVER), DISTRIBUTION_ESM_DRIVER_SOURCE)
+	writeDistributionFile(join(consumer, DISTRIBUTION_CJS_DRIVER), DISTRIBUTION_CJS_DRIVER_SOURCE)
+	const install = runDistributionNpm(
 		['install', '--ignore-scripts', '--no-audit', '--no-fund', join(packed, archive)],
 		consumer,
 		scratch,
 	)
 	if (install.status !== 0) {
-		throw new Error(\`Installing the packed archive failed: \${readOutput(install)}\`)
+		throw new Error(\`Installing the packed archive failed: \${readDistributionOutput(install)}\`)
 	}
-	const name = readManifestName(join(ROOT, 'package.json'))
+	const name = readDistributionManifestName(join(DISTRIBUTION_ROOT, 'package.json'))
 	const installed = join(consumer, 'node_modules', ...name.split('/'))
-	const manifest = readJson(join(installed, 'package.json'))
-	if (!isRecord(manifest) || !isRecord(manifest.exports)) {
+	const manifest = readDistributionJSON(join(installed, 'package.json'))
+	if (!isDistributionRecord(manifest) || !isDistributionRecord(manifest.exports)) {
 		throw new Error('The installed manifest publishes no exports map')
 	}
-	const readings = Object.entries(manifest.exports).map(([subpath, mapping]) => {
-		const files = collectTargets(mapping)
-		const declaration = readDeclaration(mapping, installed)
-		// A subpath resolving no declaration is partitioned rather than dropped. It is a
-		// defect when a runtime loads one of its targets for names, because a consumer
-		// importing it compiles against nothing under \`node16\`. It is an excluded
-		// publication otherwise: the \`"./package.json"\` manifest pointer and a stylesheet
-		// are published for a reader rather than an importer.
-		if (
-			declaration.module === undefined &&
-			declaration.commonjs === undefined &&
-			declaration.browser === undefined
-		) {
-			return { subpath, files, entry: undefined }
-		}
-		const importTarget = resolveTarget(mapping, RUNTIME_CONDITIONS.module)
-		const requireTarget = resolveTarget(mapping, RUNTIME_CONDITIONS.commonjs)
-		const browserTarget = resolveTarget(mapping, RUNTIME_CONDITIONS.browser)
-		const browsable = resolvesBrowser(mapping)
-		const shadowed = browsable && requireTarget === browserTarget
-		const requirable = requireTarget !== undefined && !shadowed
-		const loadable = requirable && resolvesCommonJS(mapping, installed)
-		const entry: Entry = {
-			subpath,
-			specifier: subpath === '.' ? name : \`\${name}\${subpath.slice(1)}\`,
-			mapping,
-			declaration: {
-				importable: declaration.module !== undefined,
-				requirable: declaration.commonjs !== undefined,
-				browsable: declaration.browser !== undefined,
-			},
-			browsable,
-			importable: importTarget !== undefined && !(browsable && importTarget === browserTarget),
-			requirable,
-			loadable,
-		}
-		return { subpath, files, entry }
-	})
-	const entries = readings.flatMap(({ entry }) => (entry === undefined ? [] : [entry]))
-	const targets = readings.flatMap(({ files }) => files)
-	const subpaths = readings.map(({ subpath }) => subpath)
-	const undeclared = readings
-		.filter(({ entry, files }) => entry === undefined && files.some(isModule))
-		.map(({ subpath }) => subpath)
-	const excluded = readings
-		.filter(({ entry, files }) => entry === undefined && !files.some(isModule))
-		.map(({ subpath }) => subpath)
-	return { consumer, installed, archives, entries, subpaths, undeclared, excluded, targets }
+	return { consumer, installed, archives, ...classifyDistributionStage(manifest, installed, name) }
 }
 
 // One file's run: the scratch directory and the staged consumer, which is absent when the
 // registry could not be reached.
-interface DistributionRun {
+/** Binds an owned scratch directory to its optional installed consumer. */
+export interface DistributionRun {
 	readonly scratch: string
-	readonly stage: Stage | undefined
+	readonly stage: DistributionStage | undefined
 }
 
 // The run the start hook binds once for this file and the stop hook releases.
-class DistributionSuite {
+/** Owns the staged consumer shared by one distribution proof. */
+export class DistributionSuite implements DistributionSuiteInterface {
 	#run: DistributionRun | undefined
 
 	get scratch(): string {
@@ -3323,8 +3547,12 @@ class DistributionSuite {
 		return this.#run.scratch
 	}
 
-	get stage(): Stage | undefined {
-		return this.#run?.stage
+	read(context: TestContext): DistributionStage {
+		const stage = this.#run?.stage
+		if (stage === undefined) {
+			return context.skip('\`npm ping\` did not answer, so nothing was packed or installed')
+		}
+		return stage
 	}
 
 	start(): void {
@@ -3332,7 +3560,7 @@ class DistributionSuite {
 			throw new Error('The distribution setup has already allocated its scratch directory')
 		}
 		const scratch = mkdtempSync(join(tmpdir(), 'distribution-'))
-		this.#run = { scratch, stage: openStage(scratch) }
+		this.#run = { scratch, stage: openDistributionStage(scratch) }
 	}
 
 	destroy(): void {
@@ -3343,25 +3571,26 @@ class DistributionSuite {
 	}
 }
 
-const DISTRIBUTION_SUITE = new DistributionSuite()
-
-beforeAll(() => DISTRIBUTION_SUITE.start())
-
-afterAll(() => DISTRIBUTION_SUITE.destroy())
-
 // Installing the packed archive resolves its own runtime dependencies, so an
 // unreachable registry leaves nothing to measure. Under release that is the gate
 // failing; anywhere else the suite skips and names the mechanism it wanted.
-function openStage(scratch: string): Stage | undefined {
+/**
+ * Opens an installed consumer after checking registry readiness.
+ *
+ * @param scratch - The owned scratch root.
+ * @returns The installed consumer, or undefined when an ordinary run cannot reach the registry.
+ * @throws Thrown in release mode or when staging fails, after removing scratch.
+ */
+export function openDistributionStage(scratch: string): DistributionStage | undefined {
 	try {
 		mkdirSync(join(scratch, 'cache'), { recursive: true })
-		if (runNpm(PING, ROOT, scratch).status !== 0) {
-			if (!RELEASE) return undefined
+		if (runDistributionNpm(DISTRIBUTION_PING, DISTRIBUTION_ROOT, scratch).status !== 0) {
+			if (!DISTRIBUTION_RELEASE) return undefined
 			throw new Error(
 				'The release gate requires a reachable npm registry, and npm ping did not answer',
 			)
 		}
-		return buildStage(scratch)
+		return buildDistributionStage(scratch)
 	} catch (error) {
 		rmSync(scratch, {
 			force: true,
@@ -3373,200 +3602,690 @@ function openStage(scratch: string): Stage | undefined {
 	}
 }
 
-describe('distribution classifiers', () => {
-	it('classifies synthetic export mappings without a registry stage', () => {
-		const root = join(DISTRIBUTION_SUITE.scratch, 'classifiers')
-		writeFile(
-			join(root, 'package.json'),
-			JSON.stringify({
-				type: 'commonjs',
-				exports: {
-					condition: { browser: './b.js', default: './n.js' },
-					convention: { default: './dist/src/browser/index.js' },
-					universal: { default: './shared.js' },
-					'import-shared': {
-						browser: './shared.mjs',
-						import: './shared.mjs',
-						default: './node.js',
-					},
-					'require-shared': {
-						browser: './shared.cjs',
-						require: './shared.cjs',
-						default: './node.js',
-					},
-					node: { node: './node.js', default: './node.js' },
-					silent: { 'module-sync': './x.cjs', import: './x.mjs' },
-					module: { require: './x.mjs' },
-					'nested-module': { require: './module/x.js' },
-					'nested-commonjs': { require: './commonjs/x.js' },
-					esm: { import: './x.mjs' },
-				},
-			}),
+/**
+ * Partitions an installed exports map into driven, undeclared, and excluded subpaths.
+ *
+ * @param manifest - The installed package manifest.
+ * @param installed - The installed package root.
+ * @param name - The published package name.
+ * @returns The classified entries and complete target population.
+ * @throws Thrown when the exports map is absent.
+ */
+export function classifyDistributionStage(
+	manifest: Readonly<Record<string, unknown>>,
+	installed: string,
+	name: string,
+): DistributionClassification {
+	if (!isDistributionRecord(manifest.exports))
+		throw new Error('The installed manifest publishes no exports map')
+	const readings = Object.entries(manifest.exports).map(([subpath, mapping]) => {
+		const files = collectDistributionTargets(mapping)
+		const declaration = readDistributionDeclaration(mapping, installed)
+		// A subpath resolving no declaration is partitioned rather than dropped. It is a
+		// defect when a runtime loads one of its targets for names, because a consumer
+		// importing it compiles against nothing under \`node16\`. It is an excluded
+		// publication otherwise: the \`"./package.json"\` manifest pointer and a stylesheet
+		// are published for a reader rather than an importer.
+		if (
+			declaration.module === undefined &&
+			declaration.commonjs === undefined &&
+			declaration.browser === undefined
+		) {
+			return { subpath, files, entry: undefined }
+		}
+		const importTarget = resolveDistributionTarget(mapping, DISTRIBUTION_RUNTIME_CONDITIONS.module)
+		const requireTarget = resolveDistributionTarget(
+			mapping,
+			DISTRIBUTION_RUNTIME_CONDITIONS.commonjs,
 		)
-		writeFile(join(root, 'module/package.json'), '{ "type": "module" }\\n')
-		writeFile(join(root, 'commonjs/package.json'), '{ "type": "commonjs" }\\n')
-		const manifest = readJson(join(root, 'package.json'))
-		if (!isRecord(manifest) || !isRecord(manifest.exports)) {
-			throw new Error('The classifier fixture declares no exports map')
+		const browserTarget = resolveDistributionTarget(
+			mapping,
+			DISTRIBUTION_RUNTIME_CONDITIONS.browser,
+		)
+		const browsable = resolvesDistributionBrowser(mapping)
+		const shadowed = browsable && requireTarget === browserTarget
+		const requirable = requireTarget !== undefined && !shadowed
+		const loadable = requirable && resolvesDistributionCommonJS(mapping, installed)
+		const entry: DistributionEntry = {
+			subpath,
+			specifier: subpath === '.' ? name : \`\${name}\${subpath.slice(1)}\`,
+			mapping,
+			declaration: {
+				importable: declaration.module !== undefined,
+				requirable: declaration.commonjs !== undefined,
+				browsable: declaration.browser !== undefined,
+			},
+			browsable,
+			importable: importTarget !== undefined && !(browsable && importTarget === browserTarget),
+			requirable,
+			loadable,
 		}
-		const mappings = manifest.exports
-		expect({
-			condition: resolvesBrowser(mappings.condition),
-			convention: resolvesBrowser(mappings.convention),
-			universal: resolvesBrowser(mappings.universal),
-			import: resolvesBrowser(mappings['import-shared']),
-			require: resolvesBrowser(mappings['require-shared']),
-			node: resolvesBrowser(mappings.node),
-		}).toStrictEqual({
-			condition: true,
-			convention: true,
-			universal: false,
-			import: false,
-			require: false,
-			node: false,
-		})
-		expect({
-			silent: resolvesCommonJS(mappings.silent, root),
-			module: resolvesCommonJS(mappings.module, root),
-			nestedModule: resolvesCommonJS(mappings['nested-module'], root),
-			nestedCommonJS: resolvesCommonJS(mappings['nested-commonjs'], root),
-			esm: resolvesCommonJS(mappings.esm, root),
-		}).toStrictEqual({
-			silent: true,
-			module: false,
-			nestedModule: false,
-			nestedCommonJS: true,
-			esm: false,
-		})
+		return { subpath, files, entry }
 	})
-})
+	const entries = readings.flatMap(({ entry }) => (entry === undefined ? [] : [entry]))
+	const targets = readings.flatMap(({ files }) => files)
+	const subpaths = readings.map(({ subpath }) => subpath)
+	const undeclared = readings
+		.filter(({ entry, files }) => entry === undefined && files.some(matchesDistributionModule))
+		.map(({ subpath }) => subpath)
+	const excluded = readings
+		.filter(({ entry, files }) => entry === undefined && !files.some(matchesDistributionModule))
+		.map(({ subpath }) => subpath)
+	return { entries, subpaths, undeclared, excluded, targets }
+}
 
-// The staged consumer, or a skip naming what the run could not reach. \`it.skipIf\`
-// carries no reason, so the gate sits here where the test context can state one.
-function requireStage(context: TestContext): Stage {
-	const staged = DISTRIBUTION_SUITE.stage
-	if (staged === undefined) {
-		return context.skip('\`npm ping\` did not answer, so nothing was packed or installed')
-	}
-	return staged
+/**
+ * Creates the lifecycle boundary used by generated distribution proofs.
+ * @returns The suite interface backed by an owned run.
+ */
+export function createDistributionSuite(): DistributionSuiteInterface {
+	return new DistributionSuite()
 }
 
-describe('installed package consumer', () => {
-	it('packs one archive and installs it in isolation [requires the registry]', (context) => {
-		const stage = requireStage(context)
-		expect(stage.archives).toHaveLength(1)
-		expect(existsSync(join(stage.installed, 'package.json'))).toBe(true)
-		expect(stage.entries.length).toBeGreaterThan(0)
+/**
+ * Collects physical files beneath an installed output directory.
+ * @param directory - The output directory to walk.
+ * @returns The installed files, or an empty list when the directory is absent.
+ */
+export function collectDistributionFiles(directory: string): readonly string[] {
+	if (!existsSync(directory)) return []
+	return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+		const path = join(directory, entry.name)
+		return entry.isDirectory() ? collectDistributionFiles(path) : entry.isFile() ? [path] : []
 	})
+}
 
-	it('ships every relative target its exports map names [requires the registry]', (context) => {
-		const stage = requireStage(context)
-		const relative = stage.targets.filter((target) => target.startsWith('./'))
-		expect(relative).not.toStrictEqual([])
-		expect(relative.filter((target) => !existsSync(join(stage.installed, target)))).toStrictEqual(
-			[],
-		)
+/**
+ * Reads the source environment owning an installed output path.
+ * @param installed - The installed package root.
+ * @param path - The output file.
+ * @returns The source environment, or undefined outside a JavaScript face.
+ */
+export function readDistributionFace(installed: string, path: string): string | undefined {
+	const [output, axis, face] = relativePath(installed, path).split(sep)
+	return output === 'dist'
+		? axis === 'src'
+			? face
+			: axis === 'bin'
+				? 'bin'
+				: undefined
+		: undefined
+}
+
+/**
+ * Scans installed JavaScript maps for sources copied from another environment.
+ * @param installed - The installed package root.
+ * @returns The copied sources and unreadable maps.
+ * @throws Thrown when a code-bearing output has no readable map of its own.
+ */
+export function scanDistributionSourceMaps(installed: string): readonly string[] {
+	const files = collectDistributionFiles(join(installed, 'dist')).filter(
+		(path) => readDistributionFace(installed, path) !== undefined,
+	)
+	const outputs = files
+		.filter((path) => /\\.(?:js|cjs|mjs)$/u.test(path))
+		.map((path) => {
+			const parsed = parseSync(path, readFileSync(path, 'utf8'))
+			const code = parsed.program.body.some(
+				(statement) =>
+					statement.type !== 'EmptyStatement' &&
+					!(
+						statement.type === 'ExportNamedDeclaration' &&
+						statement.declaration === null &&
+						statement.specifiers.length === 0 &&
+						statement.source === null
+					),
+			)
+			const reference = parsed.comments
+				.flatMap((comment) => {
+					const match = /^[@#]\\s*sourceMappingURL=(\\S+)\\s*$/u.exec(comment.value)
+					return match?.[1] === undefined ? [] : [match[1]]
+				})
+				.at(-1)
+			try {
+				const inline = reference?.startsWith('data:') === true
+				const target = inline
+					? path
+					: reference === undefined
+						? \`\${path}.map\`
+						: fileURLToPath(new URL(reference.replaceAll('\\\\', '/'), pathToFileURL(path)))
+				return {
+					path: target,
+					face: readDistributionFace(installed, path),
+					code,
+					reference: inline ? reference : undefined,
+				}
+			} catch {
+				throw new Error(\`Unreadable source maps for \${path}\`)
+			}
+		})
+	const maps = [
+		...outputs.filter(
+			({ path, code, reference }) => code || reference !== undefined || existsSync(path),
+		),
+		...files
+			.filter(
+				(path) =>
+					/\\.(?:js|cjs|mjs)\\.map$/u.test(path) && !outputs.some((output) => output.path === path),
+			)
+			.map((path) => ({
+				path,
+				face: readDistributionFace(installed, path),
+				code: false,
+				reference: undefined,
+			})),
+	]
+	if (maps.length === 0)
+		console.info('No built JavaScript face holds code, so no source map is required')
+	return maps.flatMap(({ path, face, code, reference }) => {
+		const label = relativePath(installed, path).split(sep).join('/')
+		try {
+			const payload =
+				reference === undefined
+					? undefined
+					: /^data:application\\/json(?:;charset=[^;,]+)?(;base64)?,(.*)$/iu.exec(reference)
+			const map: unknown =
+				reference === undefined
+					? readDistributionJSON(path)
+					: payload?.[2] === undefined
+						? undefined
+						: JSON.parse(
+								payload[1] === undefined
+									? decodeURIComponent(payload[2])
+									: Buffer.from(payload[2], 'base64').toString('utf8'),
+							)
+			if (
+				!isDistributionRecord(map) ||
+				!isDistributionNames(map.sources) ||
+				(map.sourceRoot !== undefined && typeof map.sourceRoot !== 'string')
+			) {
+				throw new Error('Unreadable source map')
+			}
+			const root = typeof map.sourceRoot === 'string' ? map.sourceRoot : ''
+			const directory = root.startsWith('file:')
+				? fileURLToPath(new URL(root))
+				: resolve(dirname(path), root.replaceAll('\\\\', '/'))
+			const sources = map.sources.map((source) =>
+				relativePath(
+					resolve(installed),
+					source.startsWith('file:')
+						? fileURLToPath(new URL(source))
+						: resolve(directory, source.replaceAll('\\\\', '/')),
+				)
+					.split(sep)
+					.join('/'),
+			)
+			const copied = sources.filter(
+				(source) => source.startsWith('src/') && !source.startsWith(\`src/\${face}/\`),
+			)
+			return [
+				...copied.map((source) => \`\${label}: \${source}\`),
+				...(sources.some((source) => source.startsWith(\`src/\${face}/\`))
+					? []
+					: [\`\${label}: unreadable source map (no src/\${face}/ source)\`]),
+			]
+		} catch {
+			if (code) throw new Error(\`Unreadable source maps for \${path}\`)
+			return [\`\${label}: unreadable source map\`]
+		}
 	})
+}
 
-	// Every published subpath is driven, excluded by name, or reported here. A dropped
-	// one leaves no trace: no runtime test, no declaration comparison, and no place in
-	// the resolution compile, so the run reports success for a subpath it never
-	// measured.
-	it('declares types for every module it publishes [requires the registry]', (context) => {
-		const stage = requireStage(context)
-		const partitioned = [
-			...stage.entries.map((entry) => entry.subpath),
-			...stage.undeclared,
-			...stage.excluded,
-		]
-		expect(stage.undeclared).toStrictEqual([])
-		expect(partitioned.sort()).toStrictEqual([...stage.subpaths].sort())
-		// A driven subpath answers a runtime condition. One resolving a declaration and
-		// no Node or browser target compiles for a consumer and throws when that consumer
-		// loads it. Each later drive retires itself for that entry, so this assertion names
-		// the subpath rather than counting it as driven.
-		const unreachable = stage.entries.filter(
-			(entry) => !entry.importable && !entry.requirable && !entry.browsable,
-		)
-		expect(unreachable.map((entry) => entry.subpath)).toStrictEqual([])
-		const untypable = selectUntypable(stage.entries, stage.installed)
-		expect(untypable.map((entry) => entry.subpath)).toStrictEqual([])
+/**
+ * Reads top-level names declared by a roll-up, including unexported declarations.
+ * @param path - The installed declaration file.
+ * @returns The declared names. Refuses syntax errors and unreadable binding patterns.
+ */
+export function readDistributionNames(path: string): readonly string[] {
+	const source = parseSync(path, readFileSync(path, 'utf8'))
+	if (source.errors.length > 0) throw new Error(\`Unreadable declarations at \${path}\`)
+	return source.program.body.flatMap((statement) => {
+		const declaration =
+			statement.type === 'ExportNamedDeclaration' || statement.type === 'ExportDefaultDeclaration'
+				? statement.declaration
+				: statement
+		if (declaration === null) return []
+		if (declaration.type === 'VariableDeclaration') {
+			return declaration.declarations.map((binding) => {
+				if (binding.id.type !== 'Identifier')
+					throw new Error(\`Unreadable declaration binding at \${path}\`)
+				return binding.id.name
+			})
+		}
+		if (
+			declaration.type === 'ClassDeclaration' ||
+			declaration.type === 'FunctionDeclaration' ||
+			declaration.type === 'TSDeclareFunction' ||
+			declaration.type === 'TSInterfaceDeclaration' ||
+			declaration.type === 'TSTypeAliasDeclaration' ||
+			declaration.type === 'TSEnumDeclaration' ||
+			declaration.type === 'TSModuleDeclaration'
+		) {
+			return declaration.id?.type === 'Identifier' ? [declaration.id.name] : []
+		}
+		return []
 	})
+}
 
-	it('refuses a subpath its exports map does not name [requires the registry]', (context) => {
-		const stage = requireStage(context)
-		const name = readManifestName(join(stage.installed, 'package.json'))
-		const driver = join(stage.consumer, ESM_DRIVER)
-		const result = runNode([driver, \`\${name}\${ABSENT_SUBPATH}\`], stage.consumer)
-		expect(result.status).not.toBe(0)
-		expect(readOutput(result)).toContain('ERR_PACKAGE_PATH_NOT_EXPORTED')
+/**
+ * Checks whether a source entry exports names, following local star exports.
+ * @param path - The source entry to inspect.
+ * @param ancestors - The entries already visited on this export path.
+ * @returns True if the entry exports a name; false otherwise.
+ */
+export function matchesDistributionSourceExports(
+	path: string,
+	ancestors: readonly string[] = [],
+): boolean {
+	if (ancestors.includes(path)) return false
+	const source = parseSync(path, readFileSync(path, 'utf8'))
+	if (source.errors.length > 0) throw new Error(\`Unreadable source exports at \${path}\`)
+	return source.program.body.some((statement) => {
+		if (statement.type === 'ExportDefaultDeclaration') return ancestors.length === 0
+		if (statement.type === 'ExportNamedDeclaration')
+			return (
+				statement.declaration !== null ||
+				statement.specifiers.some((specifier) => {
+					const name =
+						specifier.exported.type === 'Identifier'
+							? specifier.exported.name
+							: specifier.exported.value
+					return ancestors.length === 0 || name !== 'default'
+				})
+			)
+		if (statement.type !== 'ExportAllDeclaration') return false
+		if (statement.exported !== null || !statement.source.value.startsWith('.')) return true
+		const target = resolve(dirname(path), statement.source.value.replace(/\\.js$/u, '.ts'))
+		return matchesDistributionSourceExports(target, [...ancestors, path])
 	})
+}
 
-	// The absent subpath is the firing control: a resolution that reports nothing
-	// for every published entry has not been shown to resolve anything at all. Each
-	// module format carries its own control, because a format that resolves nothing
-	// is silent for the same reason a resolution that resolves nothing is.
-	it('compiles a consumer under every module resolution [requires the registry]', (context) => {
-		const stage = requireStage(context)
-		const name = readManifestName(join(stage.installed, 'package.json'))
-		const readings = RESOLUTIONS.flatMap((driver) =>
-			FORMATS.flatMap(([extension, format]) => {
-				const written = selectEntries(stage.entries, driver.conditions[format])
-				if (written.length === 0) return []
-				const label = \`\${driver.label}.\${extension}\`
-				const probe = \`probe.\${label}\`
-				const specifiers = written.map((entry) => entry.specifier)
-				writeConsumerProbe(stage, probe, specifiers)
-				const project = writeProject(stage, probe, driver, [\`./\${probe}\`])
-				const messages = checkProject(stage, project).map((message) => \`\${label}: \${message}\`)
-				const control = \`control.\${label}\`
-				writeConsumerProbe(stage, control, [\`\${name}\${ABSENT_SUBPATH}\`])
-				const refused = writeProject(stage, control, driver, [\`./\${control}\`])
-				return [{ messages, silent: checkProject(stage, refused).length === 0 ? [label] : [] }]
-			}),
-		)
-		expect(readings.flatMap(({ messages }) => messages)).toStrictEqual([])
-		expect(readings.flatMap(({ silent }) => silent)).toStrictEqual([])
+/**
+ * Scans installed declaration faces for names declared by multiple environments.
+ * @param installed - The installed package root.
+ * @param source - The workspace holding the source entries being published.
+ * @returns The repeated names with their declaring faces.
+ * @throws Thrown when a source entry exports names but its roll-up declares none.
+ */
+export function scanDistributionDeclarations(
+	installed: string,
+	source: string = DISTRIBUTION_ROOT,
+): readonly string[] {
+	const declarations = collectDistributionFiles(join(installed, 'dist'))
+		.filter(matchesDistributionDeclaration)
+		.map((path) => ({
+			path,
+			face: readDistributionFace(installed, path),
+			names: readDistributionNames(path),
+		}))
+	const entries = collectDistributionFiles(join(source, 'src')).filter((path) => {
+		const parts = relativePath(source, path).split(sep)
+		return parts.length === 3 && parts[2] === 'index.ts'
 	})
-{{guard}}})
-
-describe('installed entries', () => {
-	it('publishes what it declares to a Node import, and no more', (context) => {
-		const stage = requireStage(context)
-		const entries = stage.entries.filter((entry) => entry.importable)
-		if (entries.length === 0) return context.skip('No installed entry supports Node import')
-		for (const entry of entries) {
-			if (!entry.declaration.importable) {
-				throw new Error(\`\${entry.subpath} publishes no import declaration\`)
-			}
-			const published = driveRuntime(stage, entry.specifier, ESM_DRIVER)
-			const drivers = selectDrivers(entry, 'module')
-			expect(drivers).not.toStrictEqual([])
-			const reported = drivers.flatMap((driver) =>
-				checkSurface(stage, { entry, extension: 'ts', published, driver }),
+	const published = entries.filter((path) => matchesDistributionSourceExports(path))
+	for (const path of published) {
+		const face = relativePath(source, path).split(sep)[1]
+		if (!declarations.some((entry) => entry.face === face && entry.names.length > 0))
+			throw new Error(
+				\`The \${face} source entry exports names but its declaration roll-up declares none\`,
 			)
-			expect(reported).toStrictEqual([])
-		}
+	}
+	if (published.length === 0)
+		console.info('No source entry exports names, so no declaration names are required')
+	const names = [...new Set(declarations.flatMap((entry) => entry.names))].sort()
+	return names.flatMap((name) => {
+		const faces = [
+			...new Set(
+				declarations
+					.filter((entry) => entry.names.includes(name))
+					.map((entry) => entry.face)
+					.filter((face) => face !== undefined),
+			),
+		].sort()
+		return faces.length > 1 ? [\`\${name}: \${faces.join(', ')}\`] : []
 	})
+}
 
-	it('publishes what it declares to a Node require, and no more', (context) => {
-		const stage = requireStage(context)
-		const entries = stage.entries.filter((entry) => entry.requirable)
-		if (entries.length === 0) return context.skip('No installed entry supports Node require')
-		for (const entry of entries) {
-			if (!entry.declaration.requirable) {
-				throw new Error(\`\${entry.subpath} publishes no require declaration\`)
-			}
-			const published = driveRuntime(stage, entry.specifier, CJS_DRIVER)
-			const drivers = selectDrivers(entry, 'commonjs')
-			expect(drivers).not.toStrictEqual([])
-			const reported = drivers.flatMap((driver) =>
-				checkSurface(stage, { entry, extension: 'cts', published, driver }),
-			)
-			expect(reported).toStrictEqual([])
-		}
-	})
-{{drive}}})
+/**
+ * Checks the installed manifest against npm's normalization in an owned scratch copy.
+ * @param installed - The installed package root, read only.
+ * @param scratch - The suite's owned scratch root and npm cache parent.
+ * @returns The top-level keys changed by npm. Refuses an unsuccessful npm command.
+ */
+export function checkDistributionManifest(installed: string, scratch: string): readonly string[] {
+	const directory = mkdtempSync(join(scratch, 'manifest-'))
+	try {
+		const path = join(directory, 'package.json')
+		writeFileSync(path, readFileSync(join(installed, 'package.json')))
+		const before = readDistributionJSON(path)
+		const result = runDistributionNpm(['pkg', 'fix'], directory, scratch)
+		if (result.status !== 0)
+			throw new Error(\`npm pkg fix failed: \${readDistributionOutput(result)}\`)
+		const after = readDistributionJSON(path)
+		if (!isDistributionRecord(before) || !isDistributionRecord(after))
+			throw new Error('Unreadable manifest')
+		return [...new Set([...Object.keys(before), ...Object.keys(after)])]
+			.filter((key) => !isDeepStrictEqual(before[key], after[key]))
+			.sort()
+	} finally {
+		rmSync(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 })
+	}
+}
+
+/**
+ * Builds independently registered observations over the suite's installed consumer.
+ * @param suite - The lifecycle shared by the proof's hooks and observations.
+ * @returns The case rows whose observations each require one assertion.
+ */
+export function buildDistributionCases(
+	suite: DistributionSuiteInterface,
+): readonly DistributionCase[] {
+	return [
+		{
+			label: 'classifies synthetic export mappings without a registry stage',
+			observe: () => {
+				const root = join(suite.scratch, 'classifiers')
+				writeDistributionFile(
+					join(root, 'package.json'),
+					JSON.stringify({
+						type: 'commonjs',
+						exports: {
+							condition: { browser: './b.js', default: './n.js' },
+							convention: { default: './dist/src/browser/index.js' },
+							universal: { default: './shared.js' },
+							'import-shared': {
+								browser: './shared.mjs',
+								import: './shared.mjs',
+								default: './node.js',
+							},
+							'require-shared': {
+								browser: './shared.cjs',
+								require: './shared.cjs',
+								default: './node.js',
+							},
+							node: { node: './node.js', default: './node.js' },
+							silent: { 'module-sync': './x.cjs', import: './x.mjs' },
+							module: { require: './x.mjs' },
+							'nested-module': { require: './module/x.js' },
+							'nested-commonjs': { require: './commonjs/x.js' },
+							esm: { import: './x.mjs' },
+						},
+					}),
+				)
+				writeDistributionFile(join(root, 'module/package.json'), '{ "type": "module" }\\n')
+				writeDistributionFile(join(root, 'commonjs/package.json'), '{ "type": "commonjs" }\\n')
+				const manifest = readDistributionJSON(join(root, 'package.json'))
+				if (!isDistributionRecord(manifest) || !isDistributionRecord(manifest.exports)) {
+					throw new Error('The classifier fixture declares no exports map')
+				}
+				const mappings = manifest.exports
+
+				return {
+					actual: {
+						browser: {
+							condition: resolvesDistributionBrowser(mappings.condition),
+							convention: resolvesDistributionBrowser(mappings.convention),
+							universal: resolvesDistributionBrowser(mappings.universal),
+							import: resolvesDistributionBrowser(mappings['import-shared']),
+							require: resolvesDistributionBrowser(mappings['require-shared']),
+							node: resolvesDistributionBrowser(mappings.node),
+						},
+						commonjs: {
+							silent: resolvesDistributionCommonJS(mappings.silent, root),
+							module: resolvesDistributionCommonJS(mappings.module, root),
+							nestedModule: resolvesDistributionCommonJS(mappings['nested-module'], root),
+							nestedCommonJS: resolvesDistributionCommonJS(mappings['nested-commonjs'], root),
+							esm: resolvesDistributionCommonJS(mappings.esm, root),
+						},
+					},
+					expected: {
+						browser: {
+							condition: true,
+							convention: true,
+							universal: false,
+							import: false,
+							require: false,
+							node: false,
+						},
+						commonjs: {
+							silent: true,
+							module: false,
+							nestedModule: false,
+							nestedCommonJS: true,
+							esm: false,
+						},
+					},
+				}
+			},
+		},
+		{
+			label: 'keeps installed JavaScript sources in their own environment [requires the registry]',
+			observe: (context) => {
+				const stage = suite.read(context)
+				return { actual: scanDistributionSourceMaps(stage.installed), expected: [] }
+			},
+		},
+		{
+			label: 'declares each installed name in one environment [requires the registry]',
+			observe: (context) => {
+				const stage = suite.read(context)
+				const faces = new Set(
+					collectDistributionFiles(join(stage.installed, 'dist'))
+						.filter(matchesDistributionDeclaration)
+						.map((path) => readDistributionFace(stage.installed, path))
+						.filter((face) => face !== undefined),
+				)
+				const findings = scanDistributionDeclarations(stage.installed)
+				if (faces.size <= 1)
+					console.info(
+						'Fewer than two declaration faces are installed, so no cross-face copy exists',
+					)
+				return { actual: findings, expected: [] }
+			},
+		},
+		{
+			label: 'keeps the installed manifest fixed under npm pkg fix [requires the registry]',
+			observe: (context) => ({
+				actual: checkDistributionManifest(suite.read(context).installed, suite.scratch),
+				expected: [],
+			}),
+		},
+		{
+			label: 'packs one archive and installs it in isolation [requires the registry]',
+			observe: (context) => {
+				const stage = suite.read(context)
+				return {
+					actual: {
+						archives: stage.archives.length,
+						installed: existsSync(join(stage.installed, 'package.json')),
+						entries: stage.entries.length > 0,
+					},
+					expected: { archives: 1, installed: true, entries: true },
+				}
+			},
+		},
+		{
+			label: 'ships every relative target its exports map names [requires the registry]',
+			observe: (context) => {
+				const stage = suite.read(context)
+				const relative = stage.targets.filter((target) => target.startsWith('./'))
+				return {
+					actual: {
+						populated: relative.length > 0,
+						missing: relative.filter((target) => !existsSync(join(stage.installed, target))),
+					},
+					expected: { populated: true, missing: [] },
+				}
+			},
+		},
+		{
+			label: 'declares types for every module it publishes [requires the registry]',
+			observe: (context) => {
+				const stage = suite.read(context)
+				const partitioned = [
+					...stage.entries.map((entry) => entry.subpath),
+					...stage.undeclared,
+					...stage.excluded,
+				]
+				return {
+					actual: {
+						undeclared: stage.undeclared,
+						partitioned: partitioned.sort(),
+						unreachable: stage.entries
+							.filter((entry) => !entry.importable && !entry.requirable && !entry.browsable)
+							.map((entry) => entry.subpath),
+						untypable: filterDistributionUntypable(stage.entries, stage.installed).map(
+							(entry) => entry.subpath,
+						),
+					},
+					expected: {
+						undeclared: [],
+						partitioned: [...stage.subpaths].sort(),
+						unreachable: [],
+						untypable: [],
+					},
+				}
+			},
+		},
+		{
+			label: 'refuses a subpath its exports map does not name [requires the registry]',
+			observe: (context) => {
+				const stage = suite.read(context)
+				const name = readDistributionManifestName(join(stage.installed, 'package.json'))
+				const result = runDistributionNode(
+					[join(stage.consumer, DISTRIBUTION_ESM_DRIVER), \`\${name}\${DISTRIBUTION_ABSENT_SUBPATH}\`],
+					stage.consumer,
+				)
+				return {
+					actual: {
+						refused: result.status !== 0,
+						coded: readDistributionOutput(result).includes('ERR_PACKAGE_PATH_NOT_EXPORTED'),
+					},
+					expected: { refused: true, coded: true },
+				}
+			},
+		},
+		{
+			label: 'compiles a consumer under every module resolution [requires the registry]',
+			observe: (context) => {
+				const stage = suite.read(context)
+				const name = readDistributionManifestName(join(stage.installed, 'package.json'))
+				const readings = DISTRIBUTION_RESOLUTIONS.flatMap((driver) =>
+					DISTRIBUTION_FORMATS.flatMap(([extension, format]) => {
+						const written = filterDistributionEntries(stage.entries, driver.conditions[format])
+						if (written.length === 0) return []
+						const label = \`\${driver.label}.\${extension}\`
+						const probe = \`probe.\${label}\`
+						const specifiers = written.map((entry) => entry.specifier)
+						writeDistributionConsumerProbe(stage, probe, specifiers)
+						const project = writeDistributionProject(stage, probe, driver, [\`./\${probe}\`])
+						const messages = checkDistributionProject(stage, project).map(
+							(message) => \`\${label}: \${message}\`,
+						)
+						const control = \`control.\${label}\`
+						writeDistributionConsumerProbe(stage, control, [
+							\`\${name}\${DISTRIBUTION_ABSENT_SUBPATH}\`,
+						])
+						const refused = writeDistributionProject(stage, control, driver, [\`./\${control}\`])
+						return [
+							{
+								messages,
+								silent: checkDistributionProject(stage, refused).length === 0 ? [label] : [],
+							},
+						]
+					}),
+				)
+				return {
+					actual: {
+						messages: readings.flatMap(({ messages }) => messages),
+						silent: readings.flatMap(({ silent }) => silent),
+					},
+					expected: { messages: [], silent: [] },
+				}
+			},
+		},
+		{
+			label: 'publishes what it declares to a Node import, and no more',
+			observe: (context) => {
+				const stage = suite.read(context)
+				const entries = stage.entries.filter((entry) => entry.importable)
+				if (entries.length === 0) return context.skip('No installed entry supports Node import')
+				const readings = entries.map((entry) => {
+					if (!entry.declaration.importable)
+						throw new Error(\`\${entry.subpath} publishes no import declaration\`)
+					const published = driveDistributionRuntime(
+						stage,
+						entry.specifier,
+						DISTRIBUTION_ESM_DRIVER,
+					)
+					const drivers = filterDistributionResolutions(entry, 'module')
+					return {
+						entry: entry.subpath,
+						driven: drivers.length > 0,
+						reported: drivers.flatMap((driver) =>
+							checkDistributionSurface(stage, { entry, extension: 'ts', published, driver }),
+						),
+					}
+				})
+				return {
+					actual: readings,
+					expected: entries.map((entry) => ({ entry: entry.subpath, driven: true, reported: [] })),
+				}
+			},
+		},
+		{
+			label: 'publishes what it declares to a Node require, and no more',
+			observe: (context) => {
+				const stage = suite.read(context)
+				const entries = stage.entries.filter((entry) => entry.requirable)
+				if (entries.length === 0) return context.skip('No installed entry supports Node require')
+				const readings = entries.map((entry) => {
+					if (!entry.declaration.requirable)
+						throw new Error(\`\${entry.subpath} publishes no require declaration\`)
+					const published = driveDistributionRuntime(
+						stage,
+						entry.specifier,
+						DISTRIBUTION_CJS_DRIVER,
+					)
+					const drivers = filterDistributionResolutions(entry, 'commonjs')
+					return {
+						entry: entry.subpath,
+						driven: drivers.length > 0,
+						reported: drivers.flatMap((driver) =>
+							checkDistributionSurface(stage, { entry, extension: 'cts', published, driver }),
+						),
+					}
+				})
+				return {
+					actual: readings,
+					expected: entries.map((entry) => ({ entry: entry.subpath, driven: true, reported: [] })),
+				}
+			},
+		},
+	]
+}
+`,
+			proof: `import {
+	// These exports remain available to proofs emitted by earlier scaffold releases.
+	buildDistributionCases,
+	{{import}}createDistributionSuite,
+} from './setupDistribution.js'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+const DISTRIBUTION_SUITE = createDistributionSuite()
+
+beforeAll(() => DISTRIBUTION_SUITE.start())
+
+afterAll(() => DISTRIBUTION_SUITE.destroy())
+
+describe('installed package consumer', () => {
+	for (const row of buildDistributionCases(DISTRIBUTION_SUITE)) {
+		it(\`\${row.label}\`, async (context) => {
+			const observation = await row.observe(context)
+			expect(observation.actual).toStrictEqual(observation.expected)
+		})
+	}
+{{guard}}{{drive}}})
 `,
 			transport: `import { createServer } from 'node:http'
 `,
@@ -3577,8 +4296,9 @@ import type { Browser } from 'playwright'
 import { build } from 'vite'
 import { resolveBrowser, resolvePinnedBrowser } from '../configs/browsers.js'
 `,
-			helpers: `
-const BROWSER_PAGE = \`<!doctype html>
+			import: "checkDistributionBrowser,\n	",
+			helpers: `/** Defines the page that loads a bundled browser consumer. */
+export const DISTRIBUTION_BROWSER_PAGE = \`<!doctype html>
 <html lang="en">
 	<head>
 		<meta charset="UTF-8" />
@@ -3590,7 +4310,13 @@ const BROWSER_PAGE = \`<!doctype html>
 </html>
 \`
 
-function readContentType(path: string): string {
+/**
+ * Infers the response media type from a bundle filename.
+ *
+ * @param path - The requested bundle path.
+ * @returns The media type, defaulting to application/octet-stream.
+ */
+export function inferDistributionContentType(path: string): string {
 	if (path.endsWith('.html')) return 'text/html'
 	if (path.endsWith('.js')) return 'text/javascript'
 	if (path.endsWith('.css')) return 'text/css'
@@ -3601,7 +4327,13 @@ function readContentType(path: string): string {
 // \`resolveBrowser\` answers with provider options and never reports absence: its
 // last resort is a channel nothing verified. So the launch is attempted and its
 // rejection classified, rather than probed for and ruled on.
-function describeBrowser(options: PlaywrightProviderOptions): string {
+/**
+ * Renders the browser endpoint selected by provider options.
+ *
+ * @param options - The browser provider options.
+ * @returns The endpoint, executable, channel, or bundled-browser description.
+ */
+export function renderDistributionBrowser(options: PlaywrightProviderOptions): string {
 	const endpoint = options.connectOptions?.wsEndpoint
 	if (endpoint !== undefined) return \`the browser server at \${endpoint}\`
 	const executable = options.launchOptions?.executablePath
@@ -3611,7 +4343,15 @@ function describeBrowser(options: PlaywrightProviderOptions): string {
 	return 'the Chromium Playwright installed for itself'
 }
 
-async function launchBrowser(options: PlaywrightProviderOptions): Promise<Browser> {
+/**
+ * Launches or connects to the selected Chromium browser.
+ *
+ * @param options - The browser provider options.
+ * @returns The real browser. Rejects when the selected browser is unavailable.
+ */
+export async function launchDistributionBrowser(
+	options: PlaywrightProviderOptions,
+): Promise<Browser> {
 	const endpoint = options.connectOptions?.wsEndpoint
 	if (endpoint !== undefined) return chromium.connect(endpoint)
 	return chromium.launch({ ...options.launchOptions, headless: true })
@@ -3620,11 +4360,21 @@ async function launchBrowser(options: PlaywrightProviderOptions): Promise<Browse
 // A consumer of one installed browser entry, bundled by the Vite toolchain this
 // workspace already declares. Nothing is stubbed: the bundle resolves the installed
 // package and its whole transitive graph as an application consuming it would.
-async function bundleEntry(stage: Stage, entry: Entry): Promise<string> {
+/**
+ * Bundles a browser consumer against an installed public entry.
+ *
+ * @param stage - The installed consumer.
+ * @param entry - The browser publication.
+ * @returns The bundle directory. Rejects when Vite cannot build the consumer.
+ */
+export async function bundleDistributionEntry(
+	stage: DistributionStage,
+	entry: DistributionEntry,
+): Promise<string> {
 	const page = join(stage.consumer, 'pages', entry.subpath.replaceAll(/[^\\w]+/gu, '-'))
 	const specifier = JSON.stringify(entry.specifier)
-	writeFile(join(page, 'index.html'), BROWSER_PAGE)
-	writeFile(
+	writeDistributionFile(join(page, 'index.html'), DISTRIBUTION_BROWSER_PAGE)
+	writeDistributionFile(
 		join(page, 'main.js'),
 		\`import * as entry from \${specifier}\\nglobalThis.subject = Object.keys(entry).sort()\\n\`,
 	)
@@ -3641,7 +4391,17 @@ async function bundleEntry(stage: Stage, entry: Entry): Promise<string> {
 // The key set the bundled module publishes in a real browser, read off the page
 // once it has loaded over a loopback server. A module that never evaluated
 // publishes nothing, and a page error is raised rather than compared away.
-async function readBrowserExports(browser: Browser, bundle: string): Promise<readonly string[]> {
+/**
+ * Reads the names a real browser publishes from a served bundle.
+ *
+ * @param browser - The browser to drive.
+ * @param bundle - The built consumer directory.
+ * @returns The exported names. Rejects on a page error or an invalid name list.
+ */
+export async function readDistributionBrowserExports(
+	browser: Browser,
+	bundle: string,
+): Promise<readonly string[]> {
 	const server = createServer((request, response) => {
 		const asked = request.url === undefined || request.url === '/' ? '/index.html' : request.url
 		const path = join(bundle, decodeURIComponent(asked))
@@ -3650,7 +4410,7 @@ async function readBrowserExports(browser: Browser, bundle: string): Promise<rea
 			response.end()
 			return
 		}
-		response.writeHead(200, { 'content-type': readContentType(path) })
+		response.writeHead(200, { 'content-type': inferDistributionContentType(path) })
 		response.end(readFileSync(path))
 	})
 	try {
@@ -3667,63 +4427,65 @@ async function readBrowserExports(browser: Browser, bundle: string): Promise<rea
 		await page.goto(\`http://127.0.0.1:\${String(address.port)}/\`, { waitUntil: 'load' })
 		const published: unknown = await page.evaluate('globalThis.subject')
 		if (failures.length > 0) throw new Error(\`The bundle raised \${failures.join(' | ')}\`)
-		if (!isNames(published)) throw new Error('The bundled module published no name list')
+		if (!isDistributionNames(published))
+			throw new Error('The bundled module published no name list')
 		return published
 	} finally {
 		server.close()
 	}
 }
-`,
-			drive: `
-	it('publishes what it declares to a real browser [requires a browser]', async (context) => {
-		const stage = requireStage(context)
-		const entries = stage.entries.filter((entry) => entry.browsable)
-		if (entries.length === 0) return context.skip('No installed entry supports a browser')
-		for (const entry of entries) {
-			if (!entry.declaration.browsable) {
-				throw new Error(\`\${entry.subpath} publishes no browser declaration\`)
-			}
-			const options = resolveBrowser(resolvePinnedBrowser(), process.platform, process.env)
-			const browser = await launchBrowser(options).catch((error: unknown) => {
-				const cause = \`\${describeBrowser(options)} was rejected: \${String(error)}\`
-				if (RELEASE) throw new Error(\`The release gate requires a browser, and \${cause}\`)
-				return context.skip(\`No browser launched. \${cause}\`)
+/**
+ * Checks each browser publication against its installed declarations in a real browser.
+ * @param stage - The installed consumer to drive.
+ * @param context - The proof context that reports unavailable browser prerequisites.
+ * @returns The compiler diagnostics each browser publication reports.
+ */
+export async function checkDistributionBrowser(
+	stage: DistributionStage,
+	context: TestContext,
+): Promise<readonly string[]> {
+	const driver = DISTRIBUTION_BROWSER_RESOLUTION
+	if (driver === undefined) throw new Error("DISTRIBUTION_RESOLUTIONS carries no 'bundler' row")
+	const entries = stage.entries.filter((entry) => entry.browsable)
+	if (entries.length === 0) return context.skip('No installed entry supports a browser')
+	const readings: Array<readonly string[]> = []
+	for (const entry of entries) {
+		if (!entry.declaration.browsable) {
+			throw new Error(\`\${entry.subpath} publishes no browser declaration\`)
+		}
+		const options = resolveBrowser(resolvePinnedBrowser(), process.platform, process.env)
+		const browser = await launchDistributionBrowser(options).catch((error: unknown) => {
+			const cause = \`\${renderDistributionBrowser(options)} was rejected: \${String(error)}\`
+			if (DISTRIBUTION_RELEASE) throw new Error(\`The release gate requires a browser, and \${cause}\`)
+			return context.skip(\`No browser launched. \${cause}\`)
+		})
+		try {
+			const bundle = await bundleDistributionEntry(stage, entry)
+			const published = await readDistributionBrowserExports(browser, bundle)
+			// A browser consumer reads the installed declarations through a bundler, so
+			// that is the one driver this face answers under.
+			const reported = checkDistributionSurface(stage, {
+				entry,
+				extension: 'ts',
+				published,
+				driver,
 			})
-			try {
-				const bundle = await bundleEntry(stage, entry)
-				const published = await readBrowserExports(browser, bundle)
-				// A browser consumer reads the installed declarations through a bundler, so
-				// that is the one driver this face answers under.
-				const reported = checkSurface(stage, {
-					entry,
-					extension: 'ts',
-					published,
-					driver: BROWSER_DRIVER,
-				})
-				expect(reported).toStrictEqual([])
-			} finally {
-				await browser.close()
-			}
+			readings.push(reported)
+		} finally {
+			await browser.close()
 		}
+	}
+	return readings.flat()
+}
+`,
+			drive: `	it('publishes what it declares to a real browser [requires a browser]', async (context) => {
+		expect(await checkDistributionBrowser(DISTRIBUTION_SUITE.read(context), context)).toStrictEqual(
+			[],
+		)
 	})
 `,
-			guard: `
-	// This proof drives a Node import and a Node require and carries no browser
-	// branch: the workspace published no browser face when it was written, and the
-	// browser drive measures the packed artifact, so only a published face is owed
-	// one. A private browser application does not select this branch. It declares the
-	// browser launcher and its Vitest browser provider and gets the generated browser
-	// configuration module beside it, but installed browser tooling does not stand for
-	// a published browser face. \`vite\` selects nothing either, though the branch
-	// imports it: scaffold puts \`vite\` in every workspace's base development
-	// dependencies, whatever that workspace publishes. The later Node
-	// entry filters retire each matching Node drive for a face published
-	// later, which leaves nothing measuring it. So it reddens here and names the
-	// subpath a browser branch is owed for. A workspace that gains one deletes this
-	// file and runs the \`repair\` verb, which writes the variant carrying that branch.
-	it('publishes no browser face this proof cannot drive [requires the registry]', (context) => {
-		const stage = requireStage(context)
-		const faces = stage.entries.filter((entry) => entry.browsable)
+			guard: `	it('publishes no browser face this proof cannot drive [requires the registry]', (context) => {
+		const faces = DISTRIBUTION_SUITE.read(context).entries.filter((entry) => entry.browsable)
 		expect(faces.map((entry) => entry.subpath)).toStrictEqual([])
 	})
 `
@@ -3973,7 +4735,7 @@ var isContent = (0, _orkestrel_contract.stringOf)({ max: MAX_ARTIFACT_BYTES });
 *
 * @remarks
 * Compose this ahead of an element guard so the item count is settled before
-* anything walks the items. A hostile `length` accessor answers `false` here
+* anything walks the items. A throwing `length` accessor answers `false` here
 * rather than escaping as a thrown error.
 *
 * @example
@@ -4224,6 +4986,7 @@ var isBlueprint = (0, _orkestrel_contract.recordOf)({
 	guides: _orkestrel_contract.isBoolean,
 	integration: _orkestrel_contract.isBoolean,
 	conformance: _orkestrel_contract.isBoolean,
+	tree: _orkestrel_contract.isBoolean,
 	service: _orkestrel_contract.isBoolean,
 	vendors: (0, _orkestrel_contract.andOf)(isCollection, (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString)),
 	studies: _orkestrel_contract.isBoolean,
@@ -4405,7 +5168,7 @@ var isCatalogEntry = (0, _orkestrel_contract.unionOf)((0, _orkestrel_contract.re
 * whose every value is exact lowercase hexadecimal bytes; false otherwise.
 *
 * @remarks
-* Read through the shared total key lens, so a hostile `ownKeys` trap and a
+* Read through the shared total key lens, so an `ownKeys` trap that throws and a
 * throwing accessor both answer `false` rather than escaping. There is no
 * dictionary combinator upstream to compose this from: the key law and the
 * value law are both this package's own.
@@ -6126,10 +6889,11 @@ function blueprintToScripts(blueprint) {
 			"npm run test:policy",
 			"npm run test:config",
 			...blueprint.setup.includes("node") || blueprint.global ? ["npm run test:setup"] : [],
-			...blueprint.setup.includes("browser") || targets.length > 0 ? ["npm run test:setup:browser"] : [],
+			...blueprint.setup.includes("browser") ? ["npm run test:setup:browser"] : [],
 			...blueprint.skills ? ["npm run test:skills"] : [],
 			...blueprint.guides ? ["npm run test:guides"] : [],
 			...blueprint.conformance ? ["npm run test:conformance"] : [],
+			...blueprint.tree ? ["npm run test:tree"] : [],
 			...integrates ? ["npm run test:integration"] : [],
 			...!publishes && blueprint.studies ? ["npm run test:studies"] : [],
 			...!publishes && blueprint.service ? ["npm run test:service"] : []
@@ -6158,7 +6922,7 @@ function blueprintToScripts(blueprint) {
 		"test:policy": `${vitest} --project policy`,
 		"test:config": `${vitest} --project config`,
 		...blueprint.setup.includes("node") || blueprint.global ? { "test:setup": `${vitest} --project setup` } : {},
-		...blueprint.setup.includes("browser") || targets.length > 0 ? { "test:setup:browser": `${vitest} --project setup:browser` } : {},
+		...blueprint.setup.includes("browser") ? { "test:setup:browser": `${vitest} --project setup:browser` } : {},
 		...blueprint.journey && blueprint.app.includes("browser") ? {
 			"test:journey": journey,
 			...Object.fromEntries(application.map((name) => [`test:journey:${name}`, `${journey} --mode ${name}`]))
@@ -6166,6 +6930,7 @@ function blueprintToScripts(blueprint) {
 		...blueprint.skills ? { "test:skills": `${vitest} --project skills` } : {},
 		...blueprint.guides ? { "test:guides": `node --experimental-strip-types ${GUIDES_TEST_PATH}` } : {},
 		...blueprint.conformance ? { "test:conformance": `${vitest} --project conformance` } : {},
+		...blueprint.tree ? { "test:tree": `${vitest} --project tree` } : {},
 		"test:probe": "vitest run --config vite.config.ts --no-cache --reporter=verbose --project probe",
 		"test:bench": "vitest bench --config vite.config.ts --no-cache --project probe",
 		...publishes ? { "test:distribution": `${vitest} --project distribution` } : {},
@@ -6351,7 +7116,7 @@ function blueprintToManifest(blueprint) {
 			type: "git",
 			url: `git+https://github.com/orkestrel/${blueprint.name}.git`
 		} } : {},
-		...blueprint.bin ? { bin: { [blueprint.name]: "./dist/bin/main.js" } } : {},
+		...blueprint.bin ? { bin: { [blueprint.name]: BIN_OUTPUT_PATH } } : {},
 		files: [
 			blueprint.bin || publishes ? "dist/src" : "dist/app",
 			...blueprint.bin ? ["dist/bin"] : [],
@@ -6362,7 +7127,7 @@ function blueprintToManifest(blueprint) {
 		],
 		type: "module",
 		...publishes ? {
-			sideEffects: targets.length > 0 || blueprint.bin ? [...targets.length > 0 ? ["**/*.css", "**/*.scss"] : [], ...blueprint.bin ? [`./${BIN_ENTRY_PATH}`, "./dist/bin/main.js"] : []] : false,
+			sideEffects: targets.length > 0 || blueprint.bin ? [...targets.length > 0 ? ["**/*.css", "**/*.scss"] : [], ...blueprint.bin ? [`./${BIN_ENTRY_PATH}`, `./${BIN_OUTPUT_PATH}`] : []] : false,
 			...blueprint.src.length > 0 ? entry : {},
 			exports: blueprintToExports(blueprint),
 			publishConfig: { access: "public" }
@@ -6513,10 +7278,11 @@ function blueprintToProjects(blueprint) {
 		"policy",
 		"config",
 		...blueprint.setup.includes("node") || blueprint.global ? ["setup"] : [],
-		...blueprint.setup.includes("browser") || styled ? ["setup:browser"] : [],
+		...blueprint.setup.includes("browser") ? ["setup:browser"] : [],
 		...blueprint.guides ? ["guides"] : [],
 		...blueprint.skills ? ["skills"] : [],
 		...blueprint.conformance ? ["conformance"] : [],
+		...blueprint.tree ? ["tree"] : [],
 		...blueprint.service ? ["service"] : [],
 		...blueprint.studies ? ["studies"] : [],
 		...blueprint.src.length > 0 || styled ? ["distribution"] : [],
@@ -6582,13 +7348,10 @@ function blueprintToRootVite(blueprint) {
 	const styled = sheets.length > 0 || blueprint.themes;
 	const global = blueprint.global ? "			globalSetup: ['./tests/setupGlobal.ts'],\n" : "";
 	const imports = [
+		...styled || machinery.showcase ? [`import { ${[...styled ? ["existsSync"] : [], ...machinery.showcase ? ["renameSync"] : []].join(", ")} } from 'node:fs'`] : [],
 		...machinery.browser ? ["import { playwright } from '@vitest/browser-playwright'"] : [],
 		...machinery.frameworks.includes("vue") ? ["import vue from '@vitejs/plugin-vue'"] : [],
-		...machinery.showcase ? [
-			"import { viteSingleFile } from 'vite-plugin-singlefile'",
-			"import { renameSync } from 'node:fs'",
-			"import { resolve as resolvePath } from 'node:path'"
-		] : []
+		...machinery.showcase ? ["import { viteSingleFile } from 'vite-plugin-singlefile'", "import { resolve as resolvePath } from 'node:path'"] : []
 	];
 	const external = "external: resolveSourceExternal,";
 	const factories = [
@@ -6651,6 +7414,7 @@ function blueprintToRootVite(blueprint) {
 		...planned.has("guides") ? [CONFIG_TEMPLATES.factories.guides] : [],
 		...planned.has("skills") ? [CONFIG_TEMPLATES.factories.skills] : [],
 		...planned.has("conformance") ? [CONFIG_TEMPLATES.factories.conformance] : [],
+		...planned.has("tree") ? [CONFIG_TEMPLATES.factories.tree] : [],
 		...planned.has("service") ? [CONFIG_TEMPLATES.factories.service] : [],
 		...planned.has("studies") ? [CONFIG_TEMPLATES.factories.studies] : [],
 		...planned.has("distribution") ? [CONFIG_TEMPLATES.factories.distribution] : [],
@@ -6675,6 +7439,7 @@ function blueprintToRootVite(blueprint) {
 		...planned.has("guides") ? ["guides"] : [],
 		...planned.has("skills") ? ["skills"] : [],
 		...planned.has("conformance") ? ["conformance"] : [],
+		...planned.has("tree") ? ["tree"] : [],
 		...planned.has("service") ? ["service"] : [],
 		...planned.has("studies") ? ["studies"] : [],
 		...planned.has("distribution") ? ["distribution"] : [],
@@ -7040,12 +7805,12 @@ function blueprintToSourceArtifacts(blueprint) {
 * path. `studies` emits nothing: the root configuration names no study harness,
 * so `tests/setupStudy.ts` is the package's own module.
 *
-* The distribution proof is emitted, and the same test separates it from those
-* two: its subject is the packed tarball rather than anything only the package
-* knows, so every assertion derives from the installed tree at run time and
-* nothing has to be named. It follows the published source it packs, and it is
-* the one artifact here claimed by presence: a target lacking it reports as
-* drift, and a package that replaced it with a better proof keeps that proof.
+* The content-owned distribution harness `tests/setupDistribution.ts` and the presence-owned
+* proof `tests/distribution.test.ts` are emitted because the proof measures the packed tarball
+* rather than anything only the package knows. Every assertion derives from the installed tree
+* at run time, so nothing has to be named. The proof follows the published source it packs and
+* alone is claimed by presence: a target lacking the proof reports as drift, and a package that
+* replaced the proof with a better one keeps that proof.
 *
 * @example
 * ```ts
@@ -7091,8 +7856,7 @@ function blueprintToTestArtifacts(blueprint) {
 			origin: "template",
 			content: (0, _orkestrel_template.fillTemplate)(ARTIFACT_TEMPLATES.tests.sheet, {
 				name,
-				root: `${tests}../`,
-				setup: `${tests}setupStyles.js`
+				root: `${tests}../`
 			})
 		};
 	});
@@ -7104,7 +7868,7 @@ function blueprintToTestArtifacts(blueprint) {
 		environment: "browser",
 		content: blueprint.journey ? ARTIFACT_TEMPLATES.tests.browser : ARTIFACT_TEMPLATES.tests.setup
 	}] : [];
-	const servers = blueprint.src.includes("server") || blueprint.app.includes("server") || blueprint.bin || blueprint.conformance ? [{
+	const servers = blueprint.src.includes("server") || blueprint.app.includes("server") || blueprint.bin || blueprint.conformance || blueprint.tree ? [{
 		path: "tests/setupServer.ts",
 		group: "tests",
 		ownership: "birth",
@@ -7179,20 +7943,28 @@ function blueprintToTestArtifacts(blueprint) {
 		})
 	})).toArray();
 	const distribution = ARTIFACT_TEMPLATES.tests.distribution;
-	const distributions = blueprint.src.length > 0 || blueprintToSheets(blueprint).length > 0 || blueprint.themes ? [blueprint.src.includes("browser")].map((browser) => ({
-		path: DISTRIBUTION_TEST_PATH,
+	const distributions = blueprint.src.length > 0 || blueprintToSheets(blueprint).length > 0 || blueprint.themes ? [blueprint.src.includes("browser")].flatMap((browser) => [{
+		path: DISTRIBUTION_SETUP_PATH,
 		group: "tests",
-		ownership: "presence",
+		ownership: "content",
 		origin: "template",
-		content: (0, _orkestrel_template.fillTemplate)(distribution.proof, {
+		content: (0, _orkestrel_template.fillTemplate)(distribution.module, {
 			types: browser ? distribution.types : "",
 			transport: browser ? distribution.transport : "",
 			launcher: browser ? distribution.launcher : "",
-			helpers: browser ? distribution.helpers : "",
+			helpers: browser ? distribution.helpers : ""
+		})
+	}, {
+		path: DISTRIBUTION_TEST_PATH,
+		group: "tests",
+		ownership: "presence",
+		origin: "template",
+		content: (0, _orkestrel_template.fillTemplate)(distribution.proof, {
+			import: browser ? distribution.import : "",
 			drive: browser ? distribution.drive : "",
 			guard: browser ? "" : distribution.guard
 		})
-	})) : [];
+	}]) : [];
 	const integrations = blueprint.integration ? [[...Iterator.from(blueprint.src).map((environment) => ({
 		entry: environment === "core" ? "srcCore" : environment === "browser" ? "srcBrowser" : "srcServer",
 		specifier: `@src/${environment}`
@@ -7227,7 +7999,7 @@ function blueprintToTestArtifacts(blueprint) {
 			content: ARTIFACT_TEMPLATES.tests.setup
 		},
 		...faces,
-		...styles,
+		...styles.filter(({ content }) => content.length > 0),
 		...sheetTests,
 		...browsers,
 		...servers,
@@ -8385,13 +9157,14 @@ function createBlueprint(name, input) {
 		peers: input?.peers ?? [],
 		extras: input?.extras ?? [],
 		version: input?.version ?? "0.0.1",
-		engines: input?.engines ?? DEFAULT_ENGINES,
+		engines: input?.engines ?? ">=22.18.0",
 		overrides: input?.overrides ?? [],
 		bin: input?.bin ?? false,
 		setup: input?.setup ?? [],
 		guides: input?.guides ?? false,
 		integration: input?.integration ?? false,
 		conformance: input?.conformance ?? false,
+		tree: input?.tree ?? false,
 		service: input?.service ?? false,
 		vendors: input?.vendors ?? [],
 		studies: input?.studies ?? false,
@@ -8714,6 +9487,7 @@ exports.AXES = AXES;
 exports.BASE_DEV_DEPENDENCIES = BASE_DEV_DEPENDENCIES;
 exports.BIN_CONFIGS = BIN_CONFIGS;
 exports.BIN_ENTRY_PATH = BIN_ENTRY_PATH;
+exports.BIN_OUTPUT_PATH = BIN_OUTPUT_PATH;
 exports.BROWSE_DEV_DEPENDENCIES = BROWSE_DEV_DEPENDENCIES;
 exports.BROWSE_UPSTREAM = BROWSE_UPSTREAM;
 exports.CANON_PATHS = CANON_PATHS;
@@ -8728,6 +9502,7 @@ exports.DECLARATION_DEV_DEPENDENCIES = DECLARATION_DEV_DEPENDENCIES;
 exports.DEFAULT_ENGINES = DEFAULT_ENGINES;
 exports.DEFAULT_VERSION = DEFAULT_VERSION;
 exports.DEPENDENCY_NAME_PATTERN = DEPENDENCY_NAME_PATTERN;
+exports.DISTRIBUTION_SETUP_PATH = DISTRIBUTION_SETUP_PATH;
 exports.DISTRIBUTION_TEST_PATH = DISTRIBUTION_TEST_PATH;
 exports.ENGINES_PATTERN = ENGINES_PATTERN;
 exports.ENVIRONMENTS = ENVIRONMENTS;
@@ -8791,6 +9566,7 @@ exports.TAB_WIDTH = TAB_WIDTH;
 exports.TARGET_SKILL_NAMES = TARGET_SKILL_NAMES;
 exports.THEMES_BARREL_PATH = THEMES_BARREL_PATH;
 exports.THEMES_ENTRY_PATH = THEMES_ENTRY_PATH;
+exports.TREE_TEST_PATH = TREE_TEST_PATH;
 exports.VERSION_PATTERN = VERSION_PATTERN;
 exports.WORKSPACE_DEV_ENGINES = WORKSPACE_DEV_ENGINES;
 exports.WORKSPACE_OWNED_PATHS = WORKSPACE_OWNED_PATHS;