@orkestrel/scaffold 0.0.50 → 0.0.52

package/dist/src/core/index.js

@@ -3,7 +3,7 @@ import { fillTemplate } from "@orkestrel/template";
 import { Emitter } from "@orkestrel/emitter";
 var package_default = {
 	name: "@orkestrel/scaffold",
-	version: "0.0.50",
+	version: "0.0.52",
 	description: "Scaffold workspaces with five commands: new, audit, repair, catalog, and overwrite.",
 	keywords: [
 		"audit",
@@ -99,7 +99,7 @@ var package_default = {
 		"@microsoft/api-extractor": "^7.59.0",
 		"@orkestrel/guide": "^0.0.13",
 		"@orkestrel/html": "^0.0.5",
-		"@orkestrel/probe": "^0.0.3",
+		"@orkestrel/probe": "^0.0.4",
 		"@orkestrel/test": "^0.0.11",
 		"@types/node": "^26.2.0",
 		"@vitest/browser-playwright": "^4.1.11",
@@ -224,6 +224,8 @@ var HOST_PATHS = Object.freeze([
 	"LICENSE",
 	".agents/orchestration.md",
 	".agents/skills",
+	".agents/templates",
+	".agents/transports",
 	".claude/agents",
 	".claude/rules",
 	".claude/skills",
@@ -560,7 +562,7 @@ var CONFIG_TEMPLATES = Object.freeze({
 }
 `,
 		vite: `import type { {{viteTypes}} } from 'vite'
-{{imports}}import { defineConfig, mergeConfig } from 'vitest/config'
+{{imports}}import { defineConfig } from 'vitest/config'
 import manifest from './package.json' with { type: 'json' }
 import tsconfig from './tsconfig.json' with { type: 'json' }
 {{helpers}}{{browsers}}import { fileURLToPath, URL } from 'node:url'
@@ -599,160 +601,140 @@ const resolve = {
 	}),
 	factories: Object.freeze({
 		src: Object.freeze({
-			core: `export const srcCore = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			publicDir: false,
-			build: {
-				emptyOutDir: true,
-				sourcemap: true,
-				minify: false,
-				rolldownOptions: { onLog: enforceBuildLog },
-			},
-			test: {
-				name: { label: 'src:core', color: 'magenta' },
-				include: ['tests/src/core/**/*.test.ts'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
-		},
-		options ?? {},
-	)
+			core: `export const srcCore = (): UserConfig => ({
+	resolve,
+	publicDir: false,
+	build: {
+		emptyOutDir: true,
+		sourcemap: true,
+		minify: false,
+		rolldownOptions: { onLog: enforceBuildLog },
+	},
+	test: {
+		name: { label: 'src:core', color: 'magenta' },
+		include: ['tests/src/core/**/*.test.ts'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `,
-			browser: `export const srcBrowser = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			publicDir: false,
-			plugins: [outputBoundary('dist/src/browser'), environmentBoundary('src/browser')],
-			build: {
-				emptyOutDir: true,
-				sourcemap: true,
-				minify: false,
-				lib: {
-					entry: resolveWorkspacePath('src/browser/index.ts'),
-					formats: ['es'],
-					fileName: () => 'index.js',
-				},
-				outDir: 'dist/src/browser',
-				rolldownOptions: {
-					onLog: enforceBuildLog,
-					{{external}}
+			browser: `export const srcBrowser = (): UserConfig => ({
+	resolve,
+	publicDir: false,
+	plugins: [outputBoundary('dist/src/browser'), environmentBoundary('src/browser')],
+	build: {
+		emptyOutDir: true,
+		sourcemap: true,
+		minify: false,
+		lib: {
+			entry: resolveWorkspacePath('src/browser/index.ts'),
+			formats: ['es'],
+			fileName: () => 'index.js',
+		},
+		outDir: 'dist/src/browser',
+		rolldownOptions: {
+			onLog: enforceBuildLog,
+			{{external}}
 {{output}}
-				},
-			},
-			test: {
-				name: { label: 'src:browser', color: 'yellow' },
-				include: ['tests/src/browser/**/*.test.ts'],
-{{exclude}}				setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
+		},
+	},
+	test: {
+		name: { label: 'src:browser', color: 'yellow' },
+		include: ['tests/src/browser/**/*.test.ts'],
+{{exclude}}		setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
 {{global}}
-				browser: {
-					enabled: true,
-					provider: playwright(browserOptions),
-					instances: [{ browser: 'chromium', headless: true }],
-				},
-				fileParallelism: false,
-			},
+		browser: {
+			enabled: true,
+			provider: playwright(browserOptions),
+			instances: [{ browser: 'chromium', headless: true }],
 		},
-		options ?? {},
-	)
+		fileParallelism: false,
+	},
+})
 `,
-			server: `export const srcServer = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			publicDir: false,
-			plugins: [outputBoundary('dist/src/server'), environmentBoundary('src/server')],
-			build: {
-				emptyOutDir: true,
-				sourcemap: true,
-				minify: false,
-				lib: {
-					entry: resolveWorkspacePath('src/server/index.ts'),
-					formats: ['es', 'cjs'],
-					fileName: (format: string) => (format === 'es' ? 'index.js' : 'index.cjs'),
-				},
-				outDir: 'dist/src/server',
-				target: 'node22',
-				rolldownOptions: {
-					onLog: enforceBuildLog,
-					platform: 'node',
-					{{external}}
+			server: `export const srcServer = (): UserConfig => ({
+	resolve,
+	publicDir: false,
+	plugins: [outputBoundary('dist/src/server'), environmentBoundary('src/server')],
+	build: {
+		emptyOutDir: true,
+		sourcemap: true,
+		minify: false,
+		lib: {
+			entry: resolveWorkspacePath('src/server/index.ts'),
+			formats: ['es', 'cjs'],
+			fileName: (format: string) => (format === 'es' ? 'index.js' : 'index.cjs'),
+		},
+		outDir: 'dist/src/server',
+		target: 'node22',
+		rolldownOptions: {
+			onLog: enforceBuildLog,
+			platform: 'node',
+			{{external}}
 {{output}}
-				},
-			},
-			test: {
-				name: { label: 'src:server', color: 'red' },
-				include: ['tests/src/server/**/*.test.ts'],
-{{exclude}}				setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
 		},
-		options ?? {},
-	)
+	},
+	test: {
+		name: { label: 'src:server', color: 'red' },
+		include: ['tests/src/server/**/*.test.ts'],
+{{exclude}}		setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `,
-			bin: `export const srcBin = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			publicDir: false,
-			plugins: [outputBoundary('dist/bin')],
-			build: {
-				emptyOutDir: true,
-				sourcemap: true,
-				minify: false,
-				lib: {
-					entry: resolveWorkspacePath('${BIN_ENTRY_PATH}'),
-					formats: ['es'],
-					fileName: () => 'main.js',
-				},
-				outDir: 'dist/bin',
-				target: 'node22',
-				rolldownOptions: {
-					onLog: enforceBuildLog,
-					external: (id: string) =>
-						id.startsWith('node:') ||
-						id.startsWith('@orkestrel/') ||
-						id.startsWith('@src/') ||
-						peers.some((peer) => id === peer || id.startsWith(peer + '/')),
-				},
-			},
-			test: {
-				name: { label: 'src:bin', color: 'yellow' },
-				include: ['tests/src/bin/**/*.test.ts'],
-				setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-				// A bin test drives the real executable over a real temporary repository, so it
-				// spends seconds in process startup and filesystem work rather than milliseconds.
-				// Vitest's five-second default clears one alone and times out under a full suite.
-				testTimeout: 15_000,
-			},
+			bin: `export const srcBin = (): UserConfig => ({
+	resolve,
+	publicDir: false,
+	plugins: [outputBoundary('dist/bin')],
+	build: {
+		emptyOutDir: true,
+		sourcemap: true,
+		minify: false,
+		lib: {
+			entry: resolveWorkspacePath('${BIN_ENTRY_PATH}'),
+			formats: ['es'],
+			fileName: () => 'main.js',
 		},
-		options ?? {},
-	)
+		outDir: 'dist/bin',
+		target: 'node22',
+		rolldownOptions: {
+			onLog: enforceBuildLog,
+			external: (id: string) =>
+				id.startsWith('node:') ||
+				id.startsWith('@orkestrel/') ||
+				id.startsWith('@src/') ||
+				peers.some((peer) => id === peer || id.startsWith(peer + '/')),
+		},
+	},
+	test: {
+		name: { label: 'src:bin', color: 'yellow' },
+		include: ['tests/src/bin/**/*.test.ts'],
+		setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+		// A bin test drives the real executable over a real temporary repository, so it
+		// spends seconds in process startup and filesystem work rather than milliseconds.
+		// Vitest's five-second default clears one alone and times out under a full suite.
+		testTimeout: 15_000,
+	},
+})
 `
 		}),
 		app: Object.freeze({
-			core: `export const appCore = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			publicDir: false,
-			plugins: [environmentBoundary('app/core')],
-			test: {
-				name: { label: 'app:core', color: 'cyan' },
-				include: ['tests/app/core/**/*.test.ts'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
-		},
-		options ?? {},
-	)
+			core: `export const appCore = (): UserConfig => ({
+	resolve,
+	publicDir: false,
+	plugins: [environmentBoundary('app/core')],
+	test: {
+		name: { label: 'app:core', color: 'cyan' },
+		include: ['tests/app/core/**/*.test.ts'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `,
 			browser: `function applicationBrowser(showcase: boolean): UserConfig {
 	const output = showcase ? 'dist/showcase' : 'dist/app/browser'
@@ -784,197 +766,157 @@ const resolve = {
 	}
 }
 
-export function appBrowser(options?: UserConfig): UserConfig {
-	return mergeConfig(applicationBrowser(false), options ?? {})
+export function appBrowser(): UserConfig {
+	return applicationBrowser(false)
 }
 {{showcaseFactory}}`,
-			server: `export const appServer = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			publicDir: false,
-			plugins: [outputBoundary('dist/app/server'), environmentBoundary('app/server')],
-			build: {
-				emptyOutDir: true,
-				lib: {
-					entry: resolveWorkspacePath('app/server/main.ts'),
-					formats: ['cjs'],
-					fileName: () => 'main.cjs',
-				},
-				outDir: resolveWorkspacePath('dist/app/server'),
-				target: 'node22',
-				rolldownOptions: {
-					onLog: enforceBuildLog,
-					external: (id: string) => id.startsWith('node:'),
-				},
-			},
-			test: {
-				name: { label: 'app:server', color: 'green' },
-				include: ['tests/app/server/**/*.test.ts'],
-				setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
+			server: `export const appServer = (): UserConfig => ({
+	resolve,
+	publicDir: false,
+	plugins: [outputBoundary('dist/app/server'), environmentBoundary('app/server')],
+	build: {
+		emptyOutDir: true,
+		lib: {
+			entry: resolveWorkspacePath('app/server/main.ts'),
+			formats: ['cjs'],
+			fileName: () => 'main.cjs',
 		},
-		options ?? {},
-	)
+		outDir: resolveWorkspacePath('dist/app/server'),
+		target: 'node22',
+		rolldownOptions: {
+			onLog: enforceBuildLog,
+			external: (id: string) => id.startsWith('node:'),
+		},
+	},
+	test: {
+		name: { label: 'app:server', color: 'green' },
+		include: ['tests/app/server/**/*.test.ts'],
+		setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `
 		}),
-		policy: `export const policy = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'policy', color: 'white' },
-				include: ['tests/policy.test.ts'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
-		},
-		options ?? {},
-	)
+		policy: `export const policy = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'policy', color: 'white' },
+		include: ['tests/policy.test.ts'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `,
-		config: `export const config = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'config', color: 'yellow' },
-				include: ['tests/config.test.ts'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-				// A config test validates every target wrapper and runs the real linter twice with
-				// 15-second child caps, so this budget clears both caps and reports their diagnostics.
-				testTimeout: 45_000,
-			},
-		},
-		options ?? {},
-	)
+		config: `export const config = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'config', color: 'yellow' },
+		include: ['tests/config.test.ts'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+		// A config test validates every target wrapper and runs the real linter twice with
+		// 15-second child caps, so this budget clears both caps and reports their diagnostics.
+		testTimeout: 45_000,
+	},
+})
 `,
-		setup: `export const setup = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'setup', color: 'white' },
-				include: ['tests/setup*.test.ts'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
-		},
-		options ?? {},
-	)
+		setup: `export const setup = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'setup', color: 'white' },
+		include: ['tests/setup*.test.ts'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `,
-		guides: `export const guides = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'guides', color: 'green' },
-				include: ['${GUIDES_TEST_PATH}'],
-				exclude: ['tests/src/**/*.test.ts', 'tests/app/**/*.test.ts', 'tests/setup.test.ts'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
-		},
-		options ?? {},
-	)
+		guides: `export const guides = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'guides', color: 'green' },
+		include: ['${GUIDES_TEST_PATH}'],
+		exclude: ['tests/src/**/*.test.ts', 'tests/app/**/*.test.ts', 'tests/setup.test.ts'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `,
 		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\`.
-export const conformance = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'conformance', color: 'magenta' },
-				include: ['${CONFORMANCE_TEST_PATH}'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-			},
-		},
-		options ?? {},
-	)
+export const conformance = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'conformance', color: 'magenta' },
+		include: ['${CONFORMANCE_TEST_PATH}'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+	},
+})
 `,
 		service: `// The live external services this package drives. It starts nothing itself:
 // \`scripts/service.sh\` provisions, \`tests/setupService.ts\` proves readiness, and
 // the project stays out of \`npm test\` because a real service answers it.
-export const service = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'service', color: 'red' },
-				include: ['${SERVICE_TEST_INCLUDE}'],
-				setupFiles: ['./tests/setup.ts', './tests/setupService.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-				testTimeout: 120_000,
-				hookTimeout: 120_000,
-				fileParallelism: false,
-			},
-		},
-		options ?? {},
-	)
+export const service = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'service', color: 'red' },
+		include: ['${SERVICE_TEST_INCLUDE}'],
+		setupFiles: ['./tests/setup.ts', './tests/setupService.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+		testTimeout: 120_000,
+		hookTimeout: 120_000,
+		fileParallelism: false,
+	},
+})
 `,
-		distribution: `export const distribution = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'distribution', color: 'cyan' },
-				include: ['${DISTRIBUTION_TEST_PATH}'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				testTimeout: 120_000,
-				hookTimeout: 120_000,
-				fileParallelism: false,
-			},
-		},
-		options ?? {},
-	)
+		distribution: `export const distribution = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'distribution', color: 'cyan' },
+		include: ['${DISTRIBUTION_TEST_PATH}'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		testTimeout: 120_000,
+		hookTimeout: 120_000,
+		fileParallelism: false,
+	},
+})
 `,
 		probe: `// A workbench, not a proof. No gate selects this project. Run in test mode by the
 // \`test:probe\` script, it collects \`tmp/probe/**/*.test.ts\`. Run in benchmark mode by the
 // \`test:bench\` script, the same workbench also collects \`tests/**/*.test.ts\` for a \`bench\` block,
 // so a suite may carry a bench beside its ordinary tests without a second project. The mode
 // guard around each \`bench\` call keeps it out of test mode, so it never executes there.
-export const probe = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'probe', color: 'gray' },
-				include: ['tmp/probe/**/*.test.ts'],
-				setupFiles: ['./tests/setup.ts'],
-				environment: 'node',
-				browser: { enabled: false },
-				fileParallelism: false,
-				pool: 'threads',
-				benchmark: { include: ['tmp/probe/**/*.test.ts', 'tests/**/*.test.ts'] },
-			},
-		},
-		options ?? {},
-	)
+export const probe = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'probe', color: 'black' },
+		include: ['tmp/probe/**/*.test.ts'],
+		setupFiles: ['./tests/setup.ts'],
+		environment: 'node',
+		browser: { enabled: false },
+		fileParallelism: false,
+		pool: 'threads',
+		benchmark: { include: ['tmp/probe/**/*.test.ts', 'tests/**/*.test.ts'] },
+	},
+})
 `,
-		integration: `export const integration = (options?: UserConfig): UserConfig =>
-	mergeConfig(
-		{
-			resolve,
-			test: {
-				name: { label: 'integration', color: 'blue' },
-				include: ['${INTEGRATION_TEST_PATH}'],
-				setupFiles: ['./tests/setup.ts'],
-{{global}}				environment: 'node',
-			},
-		},
-		options ?? {},
-	)
+		integration: `export const integration = (): UserConfig => ({
+	resolve,
+	test: {
+		name: { label: 'integration', color: 'blue' },
+		include: ['${INTEGRATION_TEST_PATH}'],
+		setupFiles: ['./tests/setup.ts'],
+{{global}}		environment: 'node',
+	},
+})
 `
 	}),
 	tsconfigs: Object.freeze({
@@ -1102,13 +1044,13 @@ export const probe = (options?: UserConfig): UserConfig =>
 	}),
 	vites: Object.freeze({
 		src: Object.freeze({
-			core: `import { defineConfig } from 'vite'
+			core: `import { defineConfig, mergeConfig } from 'vite'
 import dts from 'vite-plugin-dts'
 import { environmentBoundary, outputBoundary } from '../helpers.js'
 import { peers, srcCore, resolveWorkspacePath } from '../../vite.config.ts'
 
 export default defineConfig(
-	srcCore({
+	mergeConfig(srcCore(), {
 		publicDir: false,
 		plugins: [
 			outputBoundary('dist/src/core'),
@@ -1130,7 +1072,7 @@ export default defineConfig(
 			lib: {
 				entry: resolveWorkspacePath('src/core/index.ts'),
 				formats: ['es', 'cjs'],
-				fileName: (format) => (format === 'es' ? 'index.js' : 'index.cjs'),
+				fileName: (format: string) => (format === 'es' ? 'index.js' : 'index.cjs'),
 			},
 			outDir: 'dist/src/core',
 			rolldownOptions: {
@@ -1143,17 +1085,17 @@ export default defineConfig(
 	}),
 )
 `,
-			browser: `import { defineConfig } from 'vite'
+			browser: `import { defineConfig, mergeConfig } from 'vite'
 import dts from 'vite-plugin-dts'
 import { srcBrowser, resolveWorkspacePath } from '../../vite.config.ts'
 
 // vite-plugin-dts rolls this face into one declaration, and the roll-up reaches
 // src/core through a relative source path the tarball does not carry. The path
 // keeps each source module's own depth, so a module in a browser subfolder emits
-// one that leaves dist/src entirely. The rewrite below externalizes core through
-// the package's own published root export, on the final roll-up only.
+// one that leaves dist/src entirely. The following rewrite externalizes core
+// through the package's own published root export, on the final roll-up only.
 export default defineConfig(
-	srcBrowser({
+	mergeConfig(srcBrowser(), {
 		plugins: [
 			dts({
 				tsconfigPath: resolveWorkspacePath('configs/src/tsconfig.browser.json'),
@@ -1168,16 +1110,16 @@ export default defineConfig(
 	}),
 )
 `,
-			server: `import { defineConfig } from 'vite'
+			server: `import { defineConfig, mergeConfig } from 'vite'
 import dts from 'vite-plugin-dts'
 import { srcServer, resolveWorkspacePath } from '../../vite.config.ts'
 
 // vite-plugin-dts rolls this face into one declaration, and the roll-up reaches
-// src/core through a relative source path the tarball does not carry. The rewrite
-// below externalizes core through the package's own published root export, on the
-// final roll-up only.
+// src/core through a relative source path the tarball does not carry. The
+// following rewrite externalizes core through the package's own published root
+// export, on the final roll-up only.
 export default defineConfig(
-	srcServer({
+	mergeConfig(srcServer(), {
 		plugins: [
 			dts({
 				tsconfigPath: resolveWorkspacePath('configs/src/tsconfig.server.json'),
@@ -1193,7 +1135,7 @@ export default defineConfig(
 )
 `
 		}),
-		bin: `import { defineConfig } from 'vite'
+		bin: `import { defineConfig, mergeConfig } from 'vite'
 import { srcBin } from '../../vite.config.ts'
 
 // The \`scaffold\` executable build — a single ESM lib file, no declarations (an
@@ -1202,7 +1144,7 @@ import { srcBin } from '../../vite.config.ts'
 // \`output.paths\` rewriting the externalized \`@src/*\` specifiers to the built sibling
 // src environments (relative to \`dist/bin/\`), so the emitted bin resolves at runtime.
 export default defineConfig(
-	srcBin({
+	mergeConfig(srcBin(), {
 		build: {
 			rolldownOptions: {
 				output: {
@@ -1640,8 +1582,8 @@ const SHELL = process.platform === 'win32'
 // 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'
-// The built output directory a browser face is published from. Every selection here
-// reads this prefix off the export TARGET and never off the subpath name. A
+// 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.
@@ -1929,11 +1871,33 @@ function readPackageType(installed: string, target: string): unknown {
 	}
 }
 
-// Whether the declaration selected by a typed CommonJS consumer admits that entry
-// to its compile probe. A \`.d.cts\` declaration admits and a \`.d.mts\`
-// declaration refuses. A \`.d.ts\` declaration takes its own nearest package scope.
-// Runtime target format remains the runtime drive's separate question.
+function resolvesBrowser(entry: unknown): boolean {
+	const module = resolveTarget(entry, RUNTIME_CONDITIONS.browser)
+	if (module !== undefined && module.startsWith(BROWSER_OUTPUT)) return true
+	if (module === undefined) return false
+	const imported = resolveTarget(entry, RUNTIME_CONDITIONS.module)
+	const required = resolveTarget(entry, 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)
+	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'
+}
+
+// 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)
 	if (declaration === undefined) return false
 	if (declaration.endsWith('.d.cts')) return true
@@ -1996,13 +1960,13 @@ function selectEntries(entries: readonly Entry[], conditions: readonly string[])
 // Require-loadable 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[]): readonly Entry[] {
+function selectUntypable(entries: readonly Entry[], installed: string): readonly Entry[] {
 	return entries.filter(
 		(entry) =>
 			entry.required &&
 			isRecord(entry.mapping) &&
 			Object.hasOwn(entry.mapping, 'require') &&
-			!entry.commonjs,
+			!declaresCommonJS(entry.mapping, installed),
 	)
 }
 
@@ -2135,9 +2099,11 @@ function buildStage(): Stage {
 			continue
 		}
 		const imported = resolveTarget(entry, RUNTIME_CONDITIONS.module)
-		const commonjs = resolvesCommonJS(entry, installed)
-		const required = resolveTarget(entry, RUNTIME_CONDITIONS.commonjs) !== undefined
-		const module = resolveTarget(entry, RUNTIME_CONDITIONS.browser)
+		const requiredTarget = resolveTarget(entry, RUNTIME_CONDITIONS.commonjs)
+		const browserTarget = resolveTarget(entry, RUNTIME_CONDITIONS.browser)
+		const browser = resolvesBrowser(entry)
+		const required = requiredTarget !== undefined && !(browser && requiredTarget === browserTarget)
+		const commonjs = required && resolvesCommonJS(entry, installed)
 		entries.push({
 			subpath,
 			specifier: subpath === '.' ? name : \`\${name}\${subpath.slice(1)}\`,
@@ -2149,8 +2115,8 @@ function buildStage(): Stage {
 				browser:
 					declaration.browser === undefined ? undefined : join(installed, declaration.browser),
 			},
-			browser: module !== undefined && module.startsWith(BROWSER_OUTPUT),
-			module: imported !== undefined,
+			browser,
+			module: imported !== undefined && !(browser && imported === browserTarget),
 			commonjs,
 			required,
 		})
@@ -2191,6 +2157,74 @@ function openStage(): Stage | undefined {
 const STAGE = openStage()
 const STAGED = STAGE !== undefined
 
+describe('distribution classifiers', () => {
+	it('classifies synthetic export mappings without a registry stage', () => {
+		const root = join(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' },
+				},
+			}),
+		)
+		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 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,
+		})
+	})
+})
+
 // 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 {
@@ -2238,7 +2272,7 @@ describe('installed package consumer', () => {
 			(entry) => !entry.module && !entry.required && !entry.browser,
 		)
 		expect(unreachable.map((entry) => entry.subpath)).toStrictEqual([])
-		const untypable = selectUntypable(stage.entries)
+		const untypable = selectUntypable(stage.entries, stage.installed)
 		expect(untypable.map((entry) => entry.subpath)).toStrictEqual([])
 	})
 
@@ -2283,7 +2317,7 @@ describe('installed package consumer', () => {
 
 for (const entry of STAGE?.entries ?? []) {
 	describe(\`installed entry \${entry.subpath}\`, () => {
-		it.runIf(entry.module && !entry.browser)(
+		it.runIf(entry.module)(
 			'publishes what it declares to a Node import, and no more',
 			(context) => {
 				const declaration = entry.declaration.module
@@ -2295,7 +2329,7 @@ for (const entry of STAGE?.entries ?? []) {
 			},
 		)
 
-		it.runIf(!entry.browser && entry.required)(
+		it.runIf(entry.required)(
 			'publishes what it declares to a Node require, and no more',
 			(context) => {
 				const declaration = entry.declaration.commonjs
@@ -4317,7 +4351,7 @@ function blueprintToScripts(blueprint) {
 		scripts["serve:build"] = "npm run build:app:server && npm run serve";
 	}
 	if (publishes) {
-		scripts.prepack = scripts.build;
+		scripts.prepack = "npm run build";
 		scripts.prepublishOnly = [
 			"npm run format:check && npm run lint:check && npm run check && npm run build && npm test",
 			RELEASE_PROOF_COMMAND,
@@ -4330,19 +4364,21 @@ function blueprintToScripts(blueprint) {
 * Project a blueprint into the manifest scripts a region write may replace.
 *
 * @param blueprint - The workspace specification.
-* @returns One entry per writable script, or none when the workspace publishes
-* nothing and therefore declares neither script.
+* @returns One entry per writable script.
 *
 * @remarks
-* Publishing is what selects these scripts, so a private workspace answers an
-* empty region and the write leaves its manifest alone.
-*
-* `accepted` carries the predecessor a target can hold before this package
-* generated the packed-package proof: the same gate chain without
+* Every direct `test:<project>` script is writable, together with the probe and
+* benchmark workbench scripts. Publishing adds the pack and publication
+* lifecycle scripts. Aggregate test scripts and maintainer-owned gate chains
+* stay outside the region.
+*
+* `accepted` carries each generated predecessor the region can replace. The
+* pack hook accepts the build chain emitted before it delegated to `build`. The
+* publication hook accepts the same gate chain without
 * {@link RELEASE_PROOF_COMMAND}. The value being written is always writable, so
-* it is not repeated there. Any other value is a chain the workspace author
-* customized, and {@link replaceManifestScripts} refuses the whole region
-* rather than taking it.
+* it is not repeated there. Any other value is a script the workspace author
+* customized, and {@link replaceManifestScripts} retains it while writing the
+* other named scripts independently.
 *
 * @example
 * ```ts
@@ -4350,23 +4386,36 @@ function blueprintToScripts(blueprint) {
 *
 * const blueprint = createBlueprint('router', { src: ['core'] })
 *
-* blueprintToWritableScripts(blueprint)[0]?.name // 'test:distribution'
+* blueprintToWritableScripts(blueprint)[0]?.name // 'test:src:core'
 * ```
 */
 function blueprintToWritableScripts(blueprint) {
 	const scripts = blueprintToScripts(blueprint);
-	const distribution = scripts["test:distribution"];
+	const writable = [];
+	for (const [name, command] of Object.entries(scripts)) {
+		if (!name.startsWith("test:") || name === "test:src" || name === "test:app") continue;
+		writable.push({
+			name,
+			command,
+			accepted: []
+		});
+	}
+	const prepack = scripts.prepack;
+	if (prepack !== void 0) {
+		const predecessor = scripts.build;
+		writable.push({
+			name: "prepack",
+			command: prepack,
+			accepted: predecessor === void 0 ? [] : [predecessor]
+		});
+	}
 	const prepublish = scripts.prepublishOnly;
-	if (distribution === void 0 || prepublish === void 0) return [];
-	return [{
-		name: "test:distribution",
-		command: distribution,
-		accepted: []
-	}, {
+	if (prepublish !== void 0) writable.push({
 		name: "prepublishOnly",
 		command: prepublish,
 		accepted: [prepublish.replace(` && ${RELEASE_PROOF_COMMAND}`, "")]
-	}];
+	});
+	return writable;
 }
 /**
 * Compile a blueprint into its `package.json` content.
@@ -4549,14 +4598,14 @@ function blueprintToRootVite(blueprint) {
 		const core = blueprint.src.includes("core");
 		factories.push(fillTemplate(CONFIG_TEMPLATES.factories.src.browser, {
 			external: core ? `external: (id: string) =>
-						id === '@src/core' ||
-						id.startsWith('@orkestrel/') ||
-						peers.some((peer) => id === peer || id.startsWith(peer + '/')),` : `external: (id: string) =>
-						id.startsWith('@orkestrel/') ||
-						peers.some((peer) => id === peer || id.startsWith(peer + '/')),`,
-			output: core ? "					output: { paths: { '@src/core': '../core/index.js' } }," : "					output: {},",
-			exclude: core ? "				exclude: ['tests/src/core/**/*.test.ts'],\n" : "",
-			global: blueprint.global ? "				globalSetup: ['./tests/setupGlobal.ts'],\n" : ""
+				id === '@src/core' ||
+				id.startsWith('@orkestrel/') ||
+				peers.some((peer) => id === peer || id.startsWith(peer + '/')),` : `external: (id: string) =>
+				id.startsWith('@orkestrel/') ||
+				peers.some((peer) => id === peer || id.startsWith(peer + '/')),`,
+			output: core ? "			output: { paths: { '@src/core': '../core/index.js' } }," : "			output: {},",
+			exclude: core ? "		exclude: ['tests/src/core/**/*.test.ts'],\n" : "",
+			global: blueprint.global ? "		globalSetup: ['./tests/setupGlobal.ts'],\n" : ""
 		}));
 		projects.push("srcBrowser");
 	}
@@ -4564,26 +4613,26 @@ function blueprintToRootVite(blueprint) {
 		const core = blueprint.src.includes("core");
 		factories.push(fillTemplate(CONFIG_TEMPLATES.factories.src.server, {
 			external: core ? `external: (id: string) =>
-						id === '@src/core' ||
-						id.startsWith('node:') ||
-						id.startsWith('@orkestrel/') ||
-						peers.some((peer) => id === peer || id.startsWith(peer + '/')),` : `external: (id: string) =>
-						id.startsWith('node:') ||
-						id.startsWith('@orkestrel/') ||
-						peers.some((peer) => id === peer || id.startsWith(peer + '/')),`,
-			output: core ? `\t\t\t\t\toutput: [
-						{
-							format: 'es',
-							entryFileNames: 'index.js',
-							paths: { '@src/core': '../core/index.js' },
-						},
-						{
-							format: 'cjs',
-							entryFileNames: 'index.cjs',
-							paths: { '@src/core': '../core/index.cjs' },
-						},
-					],` : "					output: {},",
-			exclude: core ? "				exclude: ['tests/src/core/**/*.test.ts'],\n" : ""
+				id === '@src/core' ||
+				id.startsWith('node:') ||
+				id.startsWith('@orkestrel/') ||
+				peers.some((peer) => id === peer || id.startsWith(peer + '/')),` : `external: (id: string) =>
+				id.startsWith('node:') ||
+				id.startsWith('@orkestrel/') ||
+				peers.some((peer) => id === peer || id.startsWith(peer + '/')),`,
+			output: core ? `\t\t\toutput: [
+				{
+					format: 'es',
+					entryFileNames: 'index.js',
+					paths: { '@src/core': '../core/index.js' },
+				},
+				{
+					format: 'cjs',
+					entryFileNames: 'index.cjs',
+					paths: { '@src/core': '../core/index.cjs' },
+				},
+			],` : "			output: {},",
+			exclude: core ? "		exclude: ['tests/src/core/**/*.test.ts'],\n" : ""
 		}));
 		projects.push("srcServer");
 	}
@@ -4678,7 +4727,7 @@ export function appShowcase(): UserConfig {
 		projects.push("distribution");
 	}
 	if (blueprint.integration) {
-		factories.push(fillTemplate(CONFIG_TEMPLATES.factories.integration, { global: blueprint.global ? "				globalSetup: ['./tests/setupGlobal.ts'],\n" : "" }));
+		factories.push(fillTemplate(CONFIG_TEMPLATES.factories.integration, { global: blueprint.global ? "		globalSetup: ['./tests/setupGlobal.ts'],\n" : "" }));
 		projects.push("integration");
 	}
 	factories.push(CONFIG_TEMPLATES.factories.probe);
@@ -5381,24 +5430,23 @@ function replaceManifestRanges(manifest, pins) {
 *
 * @param manifest - The manifest text to compile.
 * @param scripts - The scripts to write, each with the predecessors it accepts.
-* @returns The manifest carrying every named script, or `undefined` when a
-* named script holds a value outside what it accepts, or when the text carries
-* no readable `scripts` object to write into.
+* @returns The manifest carrying every absent or accepted named script and
+* retaining every differing string value, or `undefined` when a planned key
+* holds a non-string value or the text carries no readable `scripts` object to
+* write into.
 *
 * @remarks
 * The compiler replaces values in place instead of serializing the manifest, so
 * description, keywords, dependencies, key order, indentation, and every byte
 * outside the replaced ranges survive. A named script the manifest already
-* declares is overwritten only when its value is the one being written or one
-* of its {@link ManifestScript.accepted} predecessors; anything else is a chain
-* the workspace author customized, and the whole region is refused without a
-* byte moving. A named script the manifest does not declare is appended after
-* the last declared script, copying that section's indentation. A region
-* declaring nothing takes every named script as its first entries, indented
-* from the line its own opening brace sits on.
-*
-* The refusal is whole rather than per script, so a manifest never ends up
-* holding one written script beside one refused one.
+* declares is overwritten only when its value is one of its
+* {@link ManifestScript.accepted} predecessors. The planned value stands. Any
+* other string is a chain the workspace author customized, so it stays
+* byte-identical while the other named scripts are written independently. A
+* named script the manifest does not declare is appended after the last
+* declared script, copying that section's indentation. A region declaring
+* nothing takes every named script as its first entries, indented from the line
+* its own opening brace sits on.
 *
 * @example
 * ```ts
@@ -5420,7 +5468,6 @@ function replaceManifestScripts(manifest, scripts) {
 		if (!Object.hasOwn(declared, script.name)) continue;
 		const value = declared[script.name];
 		if (!isString(value)) return void 0;
-		if (value !== script.command && !script.accepted.includes(value)) return void 0;
 	}
 	let depth = 0;
 	let cursor = 0;
@@ -5548,6 +5595,8 @@ function replaceManifestScripts(manifest, scripts) {
 		const script = scripts.find((entry) => entry.name === key);
 		if (script === void 0) continue;
 		written.add(script.name);
+		const value = declared[script.name];
+		if (value === script.command || !isString(value) || !script.accepted.includes(value)) continue;
 		edits.push({
 			start: valueStart,
 			end: valueEnd + 1,