@orkestrel/scaffold 0.0.19 → 0.0.21

package/dist/src/core/index.cjs

@@ -229,15 +229,15 @@ var DEFAULT_VERSION = "0.0.1";
 /** The `engines.node` range the `blueprint` builder fills. */
 var DEFAULT_ENGINES = `>=${MINIMUM_NODE_VERSION}`;
 /** The devDependency range generated packages pin `@orkestrel/scaffold` at. */
-var SCAFFOLD_RANGE = "^0.0.19";
+var SCAFFOLD_RANGE = "^0.0.21";
 /** Tooling versions shared by scaffold and every generated workspace. */
 var BASE_DEV_DEPENDENCIES = Object.freeze({
 	"@microsoft/api-extractor": "^7.58.12",
 	"@orkestrel/guide": "^0.0.8",
 	"@orkestrel/scaffold": SCAFFOLD_RANGE,
 	"@types/node": "^26.1.2",
-	oxfmt: "^0.61.0",
-	oxlint: "^1.76.0",
+	oxfmt: "^0.62.0",
+	oxlint: "^1.77.0",
 	typescript: "^6.0.3",
 	vite: "~8.2.0",
 	"vite-plugin-dts": "^5.0.3",
@@ -248,13 +248,23 @@ var SOURCE_BROWSER_DEV_DEPENDENCIES = Object.freeze({
 	"@vitest/browser-playwright": "^4.1.10",
 	playwright: "^1.62.1"
 });
+/** Baseline development dependency required by every private application environment. */
+var APP_DEV_DEPENDENCIES = Object.freeze({ "@orkestrel/contract": "^0.0.9" });
 /** Additional development dependencies required by a private Vue browser application. */
 var APP_BROWSER_DEV_DEPENDENCIES = Object.freeze({
 	...SOURCE_BROWSER_DEV_DEPENDENCIES,
+	"@orkestrel/html": "^0.0.2",
 	"@vitejs/plugin-vue": "^6.0.8",
 	vue: "^3.5.40",
 	"vue-tsc": "^3.3.7"
 });
+/** Additional development dependencies required by a private server application. */
+var APP_SERVER_DEV_DEPENDENCIES = Object.freeze({
+	"@orkestrel/emitter": "^0.0.5",
+	"@orkestrel/middleware": "^0.0.9",
+	"@orkestrel/router": "^0.0.8",
+	"@orkestrel/server": "^0.0.10"
+});
 /** Immutable official actions/checkout v6.0.2 commit used by generated CI. */
 var CHECKOUT_ACTION_SHA = "de0fac2e4500dabe0009e67214ff5f5447ce83dd";
 /** Immutable official actions/setup-node v6.4.0 commit used by generated CI. */
@@ -528,13 +538,45 @@ function serializeTypeScriptString(value) {
 	return `${output}'`;
 }
 /**
+* Determine whether an application blueprint spans the shared browser/server boundary.
+*
+* @param spec - The blueprint to inspect.
+* @returns True only when app/core, app/browser, and app/server are all selected.
+*
+* @example
+* ```ts
+* hasApplicationBoundary(blueprint('application', { app: ['core', 'browser', 'server'] }))
+* ```
+*/
+function hasApplicationBoundary(spec) {
+	return spec.app.includes("core") && spec.app.includes("browser") && spec.app.includes("server");
+}
+/**
+* Determine whether an application blueprint emits its browser showcase.
+*
+* @param spec - The blueprint to inspect.
+* @returns True only when showcase intent accompanies app/browser.
+*
+* @example
+* ```ts
+* hasApplicationShowcase(blueprint('application', { app: ['browser'], showcase: true }))
+* ```
+*/
+function hasApplicationShowcase(spec) {
+	return spec.showcase && spec.app.includes("browser");
+}
+/**
 * Derive the declared public `Member[]` from a blueprint.
 *
 * @param spec - The blueprint to derive members from.
 * @remarks
 * Published source environments receive the canonical entity/type/factory/constant
 * inventory. Application environments receive their exact public declaration kinds,
-* including parsers, guards, handlers, errors, and runners where present.
+* including parsers, guards, handlers, errors, and runners where present. Two groups
+* move rather than duplicate: the health contract is declared against `app/server`
+* while the server alone reads it and against `app/core` once the browser reads it
+* too, and the showcase seed, factory, and root-view identity appear only for a
+* blueprint whose showcase accompanies `app/browser`.
 * @returns The declared `Member[]`, one set per environment.
 *
 * @example
@@ -547,6 +589,8 @@ function serializeTypeScriptString(value) {
 function blueprintToMembers(spec) {
 	const pascal = pascalCase(spec.name);
 	const members = [];
+	const hasBoundary = hasApplicationBoundary(spec);
+	const hasShowcase = hasApplicationShowcase(spec);
 	for (const environment of spec.src) {
 		members.push(member(pascal, "entity", `The ${pascal} entity.`, environment));
 		members.push(member(`${pascal}Options`, "type", `Options for creating a ${pascal}.`, environment));
@@ -564,15 +608,21 @@ function blueprintToMembers(spec) {
 		members.push(member("isApplicationError", "guard", "Narrow a caught value to ApplicationError.", "core"));
 		members.push(member("parseApplicationName", "parser", "Parse an application name.", "core"));
 		members.push(member("createApplication", "factory", "Create an application identity.", "core"));
+		if (hasBoundary) members.push(member("ApplicationRecord", "type", "The shared application health record.", "core"), member("APP_HEALTH_METHOD", "constant", "The owned health request method.", "core"), member("APP_HEALTH_PATH", "constant", "The owned health request path.", "core"), member("APP_HEALTH_TIMEOUT", "constant", "The shared health read timeout.", "core"), member("isApplicationRecord", "guard", "Narrow a transport value to the shared record.", "core"), member("readApplicationHealth", "handler", "Read the shared health boundary as the application identity.", "core"));
 	}
 	if (spec.app.includes("browser")) {
 		members.push(member("BrowserApplicationErrorCode", "alias", "A browser application configuration error reason.", "browser"), member("BrowserApplicationErrorContext", "type", "Browser application boundary-failure context.", "browser"), member("BrowserApplicationOptions", "type", "Options for creating the browser application.", "browser"));
 		members.push(member("MAX_BROWSER_APPLICATION_NAME_LENGTH", "constant", "The maximum browser application-name length.", "browser"), member("MAX_BROWSER_APPLICATION_NAME_INPUT_LENGTH", "constant", "The maximum raw browser application-name input length.", "browser"), member("BrowserApplicationError", "error", "A browser application configuration error.", "browser"), member("isBrowserApplicationError", "guard", "Narrow a caught value to BrowserApplicationError.", "browser"), member("parseBrowserApplicationOptions", "parser", "Parse browser application options.", "browser"));
 		if (!spec.app.includes("core")) members.push(member("APP_NAME", "constant", "The browser application name.", "browser"));
+		if (hasShowcase && !spec.app.includes("core")) members.push(member("Application", "type", "The identity the root view renders.", "browser"));
+		if (hasShowcase) members.push(member("seedApplication", "factory", "Seed the inert showcase identity.", "browser"));
 		members.push(member("createBrowserApplication", "factory", "Create an unmounted Vue application.", "browser"));
+		if (hasShowcase) members.push(member("mountShowcaseApplication", "factory", "Mount the seeded showcase.", "browser"));
+		if (hasBoundary) members.push(member("mountBrowserApplication", "factory", "Mount the application over its server boundary.", "browser"));
 	}
 	if (spec.app.includes("server")) {
-		members.push(member("ApplicationServerErrorCode", "alias", "An application server error reason.", "server"), member("ApplicationServerErrorContext", "type", "Application server boundary-failure context.", "server"), member("ApplicationServerOptions", "type", "Options for creating an application server.", "server"), member("ApplicationServerInterface", "type", "The application server lifecycle contract.", "server"), member("ApplicationServerRunnerInterface", "type", "The application server process lifecycle contract.", "server"), member("DEFAULT_APP_HOST", "constant", "The loopback host default.", "server"), member("DEFAULT_APP_PORT", "constant", "The application port default.", "server"), member("DEFAULT_APP_START_TIMEOUT", "constant", "The application startup timeout default.", "server"), member("MAX_APP_START_TIMEOUT", "constant", "The maximum application startup timeout.", "server"), member("MAX_APP_HOST_INPUT_LENGTH", "constant", "The maximum raw application-host input length.", "server"), member("MAX_APP_NUMBER_INPUT_LENGTH", "constant", "The maximum raw application numeric input length.", "server"), member("APP_MAX_CONNECTIONS", "constant", "The simultaneous connection limit.", "server"), member("APP_MAX_HEADERS", "constant", "The request-header count limit.", "server"), member("APP_HEADERS_TIMEOUT", "constant", "The request-header timeout.", "server"), member("APP_REQUEST_TIMEOUT", "constant", "The complete-request timeout.", "server"), member("APP_KEEP_ALIVE_TIMEOUT", "constant", "The idle keep-alive timeout.", "server"), member("APP_MAX_REQUESTS_PER_SOCKET", "constant", "The keep-alive request limit.", "server"), member("APP_PORT_PATTERN", "constant", "The decimal application-port syntax.", "server"), member("APP_HOST_LABEL_PATTERN", "constant", "The DNS application-host label syntax.", "server"), member("APP_NUMERIC_HOST_PATTERN", "constant", "The ambiguous numeric-host rejection syntax.", "server"), member("APP_HEALTH_METHOD", "constant", "The owned health request method.", "server"), member("APP_HEALTH_PATH", "constant", "The owned health request path.", "server"), member("ApplicationServer", "entity", "The Node HTTP application server.", "server"), member("ApplicationServerRunner", "entity", "The application server process lifecycle owner.", "server"), member("ApplicationServerError", "error", "A server configuration or lifecycle error.", "server"), member("isApplicationServerError", "guard", "Narrow a caught value to ApplicationServerError.", "server"), member("parseApplicationHost", "parser", "Parse an application host.", "server"), member("parseApplicationPort", "parser", "Parse an application port.", "server"), member("parseApplicationStartTimeout", "parser", "Parse an application startup timeout.", "server"), member("parseApplicationServerOptions", "parser", "Parse application server options.", "server"), member("handleApplicationRequest", "handler", "Handle an application HTTP request.", "server"), member("reportApplicationServerError", "handler", "Report a process-owned failure without exposing diagnostic context.", "server"), member("createApplicationServer", "factory", "Create a stopped application server.", "server"), member("startApplicationServer", "factory", "Start the process-owned application server.", "server"));
+		if (!hasBoundary) members.push(member("ApplicationRecord", "type", "The application health record.", "server"));
+		members.push(member("ApplicationState", "type", "Per-request application state.", "server"), member("ApplicationServerErrorCode", "alias", "An application server error reason.", "server"), member("ApplicationServerErrorContext", "type", "Application server boundary-failure context.", "server"), member("ApplicationServerOptions", "type", "Options for creating an application server.", "server"), member("ApplicationServerInterface", "type", "The application server lifecycle contract.", "server"), member("ApplicationServerRunnerInterface", "type", "The application server process lifecycle contract.", "server"), member("ApplicationServerRunnerEventMap", "alias", "Observable application server runner outcomes.", "server"), member("ApplicationServerRunnerOptions", "type", "Options for observing an application server runner.", "server"), member("DEFAULT_APP_HOST", "constant", "The loopback host default.", "server"), member("DEFAULT_APP_PORT", "constant", "The application port default.", "server"), member("DEFAULT_APP_START_TIMEOUT", "constant", "The application startup timeout default.", "server"), member("MAX_APP_START_TIMEOUT", "constant", "The maximum application startup timeout.", "server"), member("MAX_APP_HOST_INPUT_LENGTH", "constant", "The maximum raw application-host input length.", "server"), member("MAX_APP_NUMBER_INPUT_LENGTH", "constant", "The maximum raw application numeric input length.", "server"), member("APP_PORT_PATTERN", "constant", "The decimal application-port syntax.", "server"), member("APP_HOST_LABEL_PATTERN", "constant", "The DNS application-host label syntax.", "server"), member("APP_NUMERIC_HOST_PATTERN", "constant", "The ambiguous numeric-host rejection syntax.", "server"), ...hasBoundary ? [] : [member("APP_HEALTH_METHOD", "constant", "The owned health request method.", "server"), member("APP_HEALTH_PATH", "constant", "The owned health request path.", "server")], member("createApplicationDispatcher", "factory", "Create a standalone application route dispatcher.", "server"), member("ApplicationServer", "entity", "The composed application server.", "server"), member("ApplicationServerRunner", "entity", "The application server process lifecycle owner.", "server"), member("ApplicationServerError", "error", "A server configuration or lifecycle error.", "server"), member("isApplicationServerError", "guard", "Narrow a caught value to ApplicationServerError.", "server"), member("parseApplicationHost", "parser", "Parse an application host.", "server"), member("parseApplicationPort", "parser", "Parse an application port.", "server"), member("parseApplicationStartTimeout", "parser", "Parse an application startup timeout.", "server"), member("parseApplicationServerOptions", "parser", "Parse application server options.", "server"), member("handleApplicationHealth", "handler", "Return the application health record.", "server"), member("reportApplicationServerError", "handler", "Report a process-owned failure without exposing diagnostic context.", "server"), member("createApplicationServer", "factory", "Create a stopped application server.", "server"), member("startApplicationServer", "factory", "Start the process-owned application server.", "server"));
 		if (!spec.app.includes("core")) members.push(member("APP_NAME", "constant", "The server application name.", "server"));
 	}
 	return members;
@@ -1653,6 +1703,34 @@ function renderArray(entries, indent, prefix, suffix) {
 	return `[\n${items.map((item) => `${childIndent}${item}`).join(",\n")}\n${indent}]`;
 }
 /**
+* Render a single-quoted TypeScript string array literal through `oxfmt`'s
+* inline-or-broken rule — inline when the rendered width fits
+* `JSON_PRINT_WIDTH`, one item per line with a trailing comma on every line
+* (including the last) otherwise, matching `.oxfmtrc.json`'s
+* `trailingComma: "all"` for non-JSON files.
+*
+* @param entries - The array's string elements, in order.
+* @param indent - The current indentation prefix.
+* @param prefix - The text already emitted on this line before the array.
+* @param suffix - The text that will follow the array on this line.
+* @returns The rendered array fragment (no trailing newline).
+*
+* @example
+* ```ts
+* import { renderStringArray } from '@orkestrel/scaffold'
+*
+* renderStringArray(['app', 'guides', 'tests'], '', '', '') // "['app', 'guides', 'tests']"
+* ```
+*/
+function renderStringArray(entries, indent, prefix, suffix) {
+	if (entries.length === 0) return "[]";
+	const items = entries.map((entry) => serializeTypeScriptString(entry));
+	const inline = `[${items.join(", ")}]`;
+	if (fitsPrintWidth(`${prefix}${inline}${suffix}`)) return inline;
+	const childIndent = `${indent}\t`;
+	return `[\n${items.map((item) => `${childIndent}${item},`).join("\n")}\n${indent}]`;
+}
+/**
 * Render a JSON object through `formatJson`'s one-key-per-line rule.
 *
 * @param entry - The object to render.
@@ -2895,7 +2973,10 @@ export * from './factories.js'
 		name: "appCoreTypes",
 		summary: "The host-independent application contract.",
 		category: "source",
-		placeholders: Object.freeze([]),
+		placeholders: Object.freeze([Object.freeze({
+			name: "record",
+			description: "The shared health record declared once both hosts read it."
+		})]),
 		content: `/** A rejected shared application boundary. */
 ${EXPORT_KEYWORD} type ApplicationErrorCode = 'CONFIG'
 
@@ -2909,7 +2990,7 @@ ${EXPORT_KEYWORD} interface ApplicationErrorContext {
 ${EXPORT_KEYWORD} interface Application {
 	readonly name: string
 }
-`
+{{record}}`
 	}),
 	appCoreConstants: Object.freeze({
 		id: "appCoreConstants",
@@ -2919,6 +3000,9 @@ ${EXPORT_KEYWORD} interface Application {
 		placeholders: Object.freeze([Object.freeze({
 			name: "nameLiteral",
 			description: "The JSON-serialized application name."
+		}), Object.freeze({
+			name: "health",
+			description: "The shared health route constants declared once both hosts read them."
 		})]),
 		content: `/** The application name shared by every host environment. */
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_NAME = {{nameLiteral}}
@@ -2928,7 +3012,7 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} MAX_APPLICATION_NAME_LENGTH = 203
 
 /** Maximum raw Unicode code units inspected before trimming an application name. */
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} MAX_APPLICATION_NAME_INPUT_LENGTH = 255
-`
+{{health}}`
 	}),
 	appCoreErrors: Object.freeze({
 		id: "appCoreErrors",
@@ -2937,6 +3021,7 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} MAX_APPLICATION_NAME_INPUT_LENGTH = 255
 		category: "source",
 		placeholders: Object.freeze([]),
 		content: `import type { ApplicationErrorCode, ApplicationErrorContext } from './types.js'
+import { holds } from '@orkestrel/contract'
 
 /** A rejected shared application configuration value. */
 ${EXPORT_KEYWORD} class ApplicationError extends Error {
@@ -2965,11 +3050,34 @@ ${EXPORT_KEYWORD} class ApplicationError extends Error {
  * \`\`\`
  */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isApplicationError(value: unknown): value is ApplicationError {
-	try {
-		return value instanceof ApplicationError
-	} catch {
-		return false
-	}
+	return holds(() => value instanceof ApplicationError)
+}
+`
+	}),
+	appCoreValidators: Object.freeze({
+		id: "appCoreValidators",
+		name: "appCoreValidators",
+		summary: "The host-independent guard over the shared health record.",
+		category: "source",
+		placeholders: Object.freeze([]),
+		content: `import type { ApplicationRecord } from './types.js'
+import { holds, isNonEmptyString, isRecord } from '@orkestrel/contract'
+
+/**
+ * Narrow one unvalidated transport value to the shared application record.
+ *
+ * @param value - The value read from the health route, before validation.
+ * @returns True only for the exact record both hosts agreed on.
+ *
+ * @example
+ * \`\`\`ts
+ * import { isApplicationRecord } from '@app/core'
+ *
+ * isApplicationRecord({ name: 'example', status: 'ok' }) // true
+ * \`\`\`
+ */
+${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isApplicationRecord(value: unknown): value is ApplicationRecord {
+	return holds(() => isRecord(value) && isNonEmptyString(value.name) && value.status === 'ok')
 }
 `
 	}),
@@ -2979,7 +3087,8 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isApplicationError(value: unknown): value
 		summary: "The host-independent application value parsers.",
 		category: "source",
 		placeholders: Object.freeze([]),
-		content: `import { MAX_APPLICATION_NAME_INPUT_LENGTH, MAX_APPLICATION_NAME_LENGTH } from './constants.js'
+		content: `import { isNonEmptyString } from '@orkestrel/contract'
+import { MAX_APPLICATION_NAME_INPUT_LENGTH, MAX_APPLICATION_NAME_LENGTH } from './constants.js'
 import { ApplicationError } from './errors.js'
 
 /**
@@ -3001,7 +3110,7 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationName(value: unknown): stri
 		throw new ApplicationError('CONFIG', 'Application name must be a string', { value })
 	}
 	const name = value.trim()
-	if (name.length === 0 || name.length > MAX_APPLICATION_NAME_LENGTH) {
+	if (!isNonEmptyString(name) || name.length > MAX_APPLICATION_NAME_LENGTH) {
 		throw new ApplicationError(
 			'CONFIG',
 			\`Application name must contain 1 through \${MAX_APPLICATION_NAME_LENGTH} characters\`,
@@ -3010,6 +3119,52 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationName(value: unknown): stri
 	}
 	return name
 }
+`
+	}),
+	appCoreHandlers: Object.freeze({
+		id: "appCoreHandlers",
+		name: "appCoreHandlers",
+		summary: "The host-independent read of the shared health boundary.",
+		category: "source",
+		placeholders: Object.freeze([]),
+		content: `import type { Application } from './types.js'
+import { APP_HEALTH_PATH, APP_HEALTH_TIMEOUT } from './constants.js'
+import { isApplicationRecord } from './validators.js'
+
+/**
+ * Read the application server's health route and translate its unvalidated JSON
+ * into the shared application identity.
+ *
+ * @param origin - The absolute origin serving the application health route.
+ * @returns The identity the running server reported, or undefined when the boundary
+ * is unreachable, too slow, or off-contract.
+ *
+ * @remarks
+ * The single translation point between the two hosts: the response body is read as
+ * \`unknown\` and narrowed by {@link isApplicationRecord} before any field is consumed,
+ * so a missing, slow, or foreign server degrades to \`undefined\` instead of leaking an
+ * unvalidated value into the application. The record's \`status\` proves liveness; the
+ * identity is what the caller renders.
+ *
+ * @example
+ * \`\`\`ts
+ * import { readApplicationHealth } from '@app/core'
+ *
+ * await readApplicationHealth('http://127.0.0.1:3000') // { name: 'example' }
+ * \`\`\`
+ */
+${EXPORT_KEYWORD} async ${FUNCTION_KEYWORD} readApplicationHealth(origin: string): Promise<Application | undefined> {
+	try {
+		const response = await fetch(new URL(APP_HEALTH_PATH, origin), {
+			signal: AbortSignal.timeout(APP_HEALTH_TIMEOUT),
+		})
+		if (!response.ok) return undefined
+		const record: unknown = await response.json()
+		return isApplicationRecord(record) ? Object.freeze({ name: record.name }) : undefined
+	} catch {
+		return undefined
+	}
+}
 `
 	}),
 	appCoreFactories: Object.freeze({
@@ -3045,12 +3200,18 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} createApplication(name: string = APP_NAME)
 		name: "appCoreIndex",
 		summary: "The application core barrel.",
 		category: "source",
-		placeholders: Object.freeze([]),
+		placeholders: Object.freeze([Object.freeze({
+			name: "validators",
+			description: "The optional shared-record guard barrel row."
+		}), Object.freeze({
+			name: "handlers",
+			description: "The optional shared health-boundary barrel row."
+		})]),
 		content: `export * from './types.js'
 export * from './constants.js'
 export * from './errors.js'
-export * from './parsers.js'
-export * from './factories.js'
+{{validators}}export * from './parsers.js'
+{{handlers}}export * from './factories.js'
 `
 	}),
 	appBrowserTypes: Object.freeze({
@@ -3058,7 +3219,10 @@ export * from './factories.js'
 		name: "appBrowserTypes",
 		summary: "The browser application options.",
 		category: "source",
-		placeholders: Object.freeze([]),
+		placeholders: Object.freeze([Object.freeze({
+			name: "application",
+			description: "The browser-owned root-view identity declared without application core."
+		})]),
 		content: `/** A rejected browser application boundary. */
 ${EXPORT_KEYWORD} type BrowserApplicationErrorCode = 'CONFIG'
 
@@ -3072,7 +3236,7 @@ ${EXPORT_KEYWORD} interface BrowserApplicationErrorContext {
 ${EXPORT_KEYWORD} interface BrowserApplicationOptions {
 	readonly name?: string
 }
-`
+{{application}}`
 	}),
 	appBrowserConstants: Object.freeze({
 		id: "appBrowserConstants",
@@ -3097,6 +3261,7 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} MAX_BROWSER_APPLICATION_NAME_INPUT_LENGTH = 2
 		category: "source",
 		placeholders: Object.freeze([]),
 		content: `import type { BrowserApplicationErrorCode, BrowserApplicationErrorContext } from './types.js'
+import { holds } from '@orkestrel/contract'
 
 /** A rejected browser application configuration value. */
 ${EXPORT_KEYWORD} class BrowserApplicationError extends Error {
@@ -3129,11 +3294,7 @@ ${EXPORT_KEYWORD} class BrowserApplicationError extends Error {
  * \`\`\`
  */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isBrowserApplicationError(value: unknown): value is BrowserApplicationError {
-	try {
-		return value instanceof BrowserApplicationError
-	} catch {
-		return false
-	}
+	return holds(() => value instanceof BrowserApplicationError)
 }
 `
 	}),
@@ -3144,6 +3305,7 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isBrowserApplicationError(value: unknown):
 		category: "source",
 		placeholders: Object.freeze([]),
 		content: `import type { BrowserApplicationOptions } from './types.js'
+import { isNonEmptyString } from '@orkestrel/contract'
 import {
 	MAX_BROWSER_APPLICATION_NAME_INPUT_LENGTH,
 	MAX_BROWSER_APPLICATION_NAME_LENGTH,
@@ -3180,6 +3342,7 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseBrowserApplicationOptions(value: unkn
 				{ value },
 			)
 		}
+		// Walk own descriptors directly: reading values through a getter would run caller code.
 		const keys = Reflect.ownKeys(value)
 		if (keys.some((key) => key !== 'name')) {
 			throw new BrowserApplicationError('CONFIG', 'Unknown browser application option', {
@@ -3204,7 +3367,7 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseBrowserApplicationOptions(value: unkn
 			})
 		}
 		const name = descriptor.value.trim()
-		if (name.length === 0 || name.length > MAX_BROWSER_APPLICATION_NAME_LENGTH) {
+		if (!isNonEmptyString(name) || name.length > MAX_BROWSER_APPLICATION_NAME_LENGTH) {
 			throw new BrowserApplicationError(
 				'CONFIG',
 				\`Browser application name must contain 1 through \${MAX_BROWSER_APPLICATION_NAME_LENGTH} characters\`,
@@ -3221,22 +3384,73 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseBrowserApplicationOptions(value: unkn
 }
 `
 	}),
-	appBrowserFactories: Object.freeze({
-		id: "appBrowserFactories",
-		name: "appBrowserFactories",
-		summary: "The Vue browser application factory.",
+	appBrowserSeeders: Object.freeze({
+		id: "appBrowserSeeders",
+		name: "appBrowserSeeders",
+		summary: "The frozen, inert identity the showcase renders.",
 		category: "source",
 		placeholders: Object.freeze([Object.freeze({
+			name: "applicationImport",
+			description: "The selected layer type import for the root-view identity."
+		}), Object.freeze({
 			name: "nameImport",
 			description: "The selected layer import for APP_NAME."
 		})]),
+		content: `{{applicationImport}}
+{{nameImport}}
+
+/**
+ * Seed the inert identity the showcase renders.
+ *
+ * @returns A fresh frozen identity, identical on every call.
+ *
+ * @remarks
+ * The showcase's only data. It is exactly the value the shipped root view receives from
+ * the running application, so the showcase exercises the shipped view rather than a
+ * parallel copy of it.
+ *
+ * @example
+ * \`\`\`ts
+ * import { seedApplication } from '@app/browser'
+ *
+ * seedApplication().name // the seeded showcase identity
+ * \`\`\`
+ */
+${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} seedApplication(): Application {
+	return Object.freeze({ name: \`\${APP_NAME} showcase\` })
+}
+`
+	}),
+	appBrowserFactories: Object.freeze({
+		id: "appBrowserFactories",
+		name: "appBrowserFactories",
+		summary: "The Vue browser application factory.",
+		category: "source",
+		placeholders: Object.freeze([
+			Object.freeze({
+				name: "nameImport",
+				description: "The selected layer import for APP_NAME."
+			}),
+			Object.freeze({
+				name: "seedImport",
+				description: "The optional showcase seeder import."
+			}),
+			Object.freeze({
+				name: "showcase",
+				description: "The optional seeded showcase factory."
+			}),
+			Object.freeze({
+				name: "boundary",
+				description: "The optional server-boundary startup factory."
+			})
+		]),
 		content: `import type { App } from 'vue'
 import type { BrowserApplicationOptions } from './types.js'
 import { createApp } from 'vue'
 import ApplicationView from './ApplicationView.vue'
 {{nameImport}}
 import { parseBrowserApplicationOptions } from './parsers.js'
-
+{{seedImport}}
 /**
  * Create an unmounted Vue application.
  *
@@ -3254,19 +3468,22 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} createBrowserApplication(options: BrowserA
 	const parsed = parseBrowserApplicationOptions(options)
 	return createApp(ApplicationView, { name: parsed.name ?? APP_NAME })
 }
-`
+{{showcase}}{{boundary}}`
 	}),
 	appBrowserIndex: Object.freeze({
 		id: "appBrowserIndex",
 		name: "appBrowserIndex",
 		summary: "The browser application barrel.",
 		category: "source",
-		placeholders: Object.freeze([]),
+		placeholders: Object.freeze([Object.freeze({
+			name: "seeders",
+			description: "The optional showcase seeder barrel row."
+		})]),
 		content: `export * from './types.js'
 export * from './constants.js'
 export * from './errors.js'
 export * from './parsers.js'
-export * from './factories.js'
+{{seeders}}export * from './factories.js'
 `
 	}),
 	appBrowserMain: Object.freeze({
@@ -3274,10 +3491,27 @@ export * from './factories.js'
 		name: "appBrowserMain",
 		summary: "The browser executable entry.",
 		category: "source",
+		placeholders: Object.freeze([Object.freeze({
+			name: "factory",
+			description: "The factory the shipped entry mounts through."
+		}), Object.freeze({
+			name: "mount",
+			description: "The mounting statement."
+		})]),
+		content: `import { {{factory}} } from './index.js'
+
+{{mount}}
+`
+	}),
+	appBrowserShowcase: Object.freeze({
+		id: "appBrowserShowcase",
+		name: "appBrowserShowcase",
+		summary: "The showcase executable entry.",
+		category: "source",
 		placeholders: Object.freeze([]),
-		content: `import { createBrowserApplication } from './index.js'
+		content: `import { mountShowcaseApplication } from './index.js'
 
-createBrowserApplication().mount('#app')
+mountShowcaseApplication('#app')
 `
 	}),
 	appBrowserView: Object.freeze({
@@ -3322,6 +3556,33 @@ defineProps<{ readonly name: string }>()
 		<script type="module" src="/main.ts"><\/script>
 	</body>
 </html>
+`
+	}),
+	appBrowserShowcaseHtml: Object.freeze({
+		id: "appBrowserShowcaseHtml",
+		name: "appBrowserShowcaseHtml",
+		summary: "The showcase HTML entry with its development security policy.",
+		category: "source",
+		placeholders: Object.freeze([Object.freeze({
+			name: "name",
+			description: "The application name."
+		})]),
+		content: `<!doctype html>
+<html lang="en">
+	<head>
+		<meta
+			http-equiv="Content-Security-Policy"
+			content="default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'self'; style-src 'unsafe-inline'; img-src data:; font-src data:; script-src-attr 'none'"
+		/>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>{{name}} showcase</title>
+	</head>
+	<body>
+		<div id="app"></div>
+		<script type="module" src="/showcase.ts"><\/script>
+	</body>
+</html>
 `
 	}),
 	appBrowserEnv: Object.freeze({
@@ -3345,8 +3606,20 @@ declare module '*.vue' {
 		name: "appServerTypes",
 		summary: "The application server contract.",
 		category: "source",
-		placeholders: Object.freeze([]),
-		content: `/** A rejected application server boundary. */
+		placeholders: Object.freeze([Object.freeze({
+			name: "record",
+			description: "The health record, declared here only while the server alone reads it."
+		})]),
+		content: `import type { EmitterErrorHandler, EmitterHooks, EmitterInterface } from '@orkestrel/emitter'
+import type { IdentifierState } from '@orkestrel/middleware'
+import type { ConnectionInfo, ServerStatus } from '@orkestrel/server'
+
+{{record}}/** Per-request application state derived from connection facts. */
+${EXPORT_KEYWORD} interface ApplicationState extends IdentifierState {
+	readonly connection: ConnectionInfo
+}
+
+/** A rejected application server boundary. */
 ${EXPORT_KEYWORD} type ApplicationServerErrorCode = 'CONFIG' | 'LIFECYCLE'
 
 /** Diagnostic context attached to an application server boundary error. */
@@ -3357,26 +3630,49 @@ ${EXPORT_KEYWORD} interface ApplicationServerErrorContext {
 
 /** Options for creating an application server. */
 ${EXPORT_KEYWORD} interface ApplicationServerOptions {
-	readonly host?: string
-	readonly port?: number
-	readonly timeout?: number
+	readonly server?: {
+		readonly host?: string
+		readonly port?: number
+		readonly timeout?: number
+	}
 }
 
 /** A lifecycle-safe application server. */
 ${EXPORT_KEYWORD} interface ApplicationServerInterface {
 	readonly host: string
-	readonly port: number
-	readonly listening: boolean
-	readonly url: string
+	readonly port: number | undefined
+	readonly status: ServerStatus
+	readonly url: string | undefined
 	start(signal?: AbortSignal): Promise<void>
 	stop(): Promise<void>
+	destroy(): Promise<void>
+}
+
+/** Observable process-lifecycle outcomes for an application server runner. */
+${EXPORT_KEYWORD} type ApplicationServerRunnerEventMap = {
+	readonly ready: readonly [url: string]
+	readonly fail: readonly [error: unknown]
 }
 
 /** The process lifecycle owner for an application server. */
 ${EXPORT_KEYWORD} interface ApplicationServerRunnerInterface {
+	readonly emitter: EmitterInterface<ApplicationServerRunnerEventMap>
 	start(): void
 	stop(): Promise<void>
 }
+
+/**
+ * Options for observing an application server runner.
+ *
+ * @remarks
+ * Initial \`on\` hooks run before the runner's own readiness and failure effects. When no earlier
+ * failure set an exit code, a synchronous fail hook therefore observes \`process.exitCode\` as
+ * \`undefined\` before the default reporter sets it to \`1\`.
+ */
+${EXPORT_KEYWORD} interface ApplicationServerRunnerOptions {
+	readonly on?: EmitterHooks<ApplicationServerRunnerEventMap>
+	readonly error?: EmitterErrorHandler
+}
 `
 	}),
 	appServerConstants: Object.freeze({
@@ -3387,6 +3683,9 @@ ${EXPORT_KEYWORD} interface ApplicationServerRunnerInterface {
 		placeholders: Object.freeze([Object.freeze({
 			name: "nameConstant",
 			description: "The optional server-only APP_NAME declaration."
+		}), Object.freeze({
+			name: "health",
+			description: "The health route constants, declared here only while the server alone reads them."
 		})]),
 		content: `{{nameConstant}}/** The fail-closed loopback host default. */
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} DEFAULT_APP_HOST = '127.0.0.1'
@@ -3406,24 +3705,6 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} MAX_APP_HOST_INPUT_LENGTH = 255
 /** Maximum raw characters inspected at an application numeric boundary. */
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} MAX_APP_NUMBER_INPUT_LENGTH = 32
 
-/** Maximum simultaneous connections accepted by the generated server. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_MAX_CONNECTIONS = 16
-
-/** Maximum request headers accepted before Node rejects the request. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_MAX_HEADERS = 100
-
-/** Maximum milliseconds allowed to receive complete request headers. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HEADERS_TIMEOUT = 10_000
-
-/** Maximum milliseconds allowed for one complete request. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_REQUEST_TIMEOUT = 30_000
-
-/** Idle keep-alive milliseconds before a connection is closed. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_KEEP_ALIVE_TIMEOUT = 5_000
-
-/** Maximum requests served through one keep-alive connection. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_MAX_REQUESTS_PER_SOCKET = 100
-
 /** The decimal-only syntax accepted at the APP_PORT string boundary. */
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_PORT_PATTERN = /^\\d+$/
 
@@ -3432,13 +3713,7 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HOST_LABEL_PATTERN = /^[A-Za-z0-9](?:[A-Z
 
 /** Numeric-looking non-IP hosts rejected before platform DNS interpretation. */
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_NUMERIC_HOST_PATTERN = /^[0-9.]+$/
-
-/** The only HTTP method owned by the application health route. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HEALTH_METHOD = 'GET'
-
-/** The only HTTP path owned by the generated application server. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HEALTH_PATH = '/'
-`
+{{health}}`
 	}),
 	appServerErrors: Object.freeze({
 		id: "appServerErrors",
@@ -3447,6 +3722,7 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HEALTH_PATH = '/'
 		category: "source",
 		placeholders: Object.freeze([]),
 		content: `import type { ApplicationServerErrorCode, ApplicationServerErrorContext } from './types.js'
+import { holds } from '@orkestrel/contract'
 
 /** A rejected application server configuration or lifecycle operation. */
 ${EXPORT_KEYWORD} class ApplicationServerError extends Error {
@@ -3479,11 +3755,7 @@ ${EXPORT_KEYWORD} class ApplicationServerError extends Error {
  * \`\`\`
  */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isApplicationServerError(value: unknown): value is ApplicationServerError {
-	try {
-		return value instanceof ApplicationServerError
-	} catch {
-		return false
-	}
+	return holds(() => value instanceof ApplicationServerError)
 }
 `
 	}),
@@ -3494,6 +3766,7 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isApplicationServerError(value: unknown):
 		category: "source",
 		placeholders: Object.freeze([]),
 		content: `import type { ApplicationServerOptions } from './types.js'
+import { isNonEmptyString, parseString } from '@orkestrel/contract'
 import { isIP } from 'node:net'
 import {
 	APP_HOST_LABEL_PATTERN,
@@ -3523,7 +3796,7 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationHost(value: unknown): stri
 	const host = value.trim()
 	const family = isIP(host)
 	if (
-		host.length === 0 ||
+		!isNonEmptyString(host) ||
 		host.length > 253 ||
 		(family === 0 &&
 			(APP_NUMERIC_HOST_PATTERN.test(host) ||
@@ -3545,18 +3818,14 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationHost(value: unknown): stri
  */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationPort(value: unknown): number {
 	if (value === undefined) return DEFAULT_APP_PORT
-	if (typeof value !== 'string' && typeof value !== 'number') {
-		throw new ApplicationServerError('CONFIG', 'APP_PORT must be an integer from 0 through 65535', {
-			value,
-		})
-	}
-	if (typeof value === 'string' && value.length > MAX_APP_NUMBER_INPUT_LENGTH) {
+	const text = parseString(value)
+	if (text === undefined || text.length > MAX_APP_NUMBER_INPUT_LENGTH) {
 		throw new ApplicationServerError('CONFIG', 'APP_PORT must be an integer from 0 through 65535', {
 			value,
 		})
 	}
-	const text = typeof value === 'string' ? value.trim() : String(value)
-	const port = APP_PORT_PATTERN.test(text) ? Number(text) : Number.NaN
+	const normalized = text.trim()
+	const port = APP_PORT_PATTERN.test(normalized) ? Number(normalized) : Number.NaN
 	if (!Number.isInteger(port) || port < 0 || port > 65_535) {
 		throw new ApplicationServerError('CONFIG', 'APP_PORT must be an integer from 0 through 65535', {
 			value,
@@ -3574,22 +3843,16 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationPort(value: unknown): numb
  */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationStartTimeout(value: unknown): number {
 	if (value === undefined) return DEFAULT_APP_START_TIMEOUT
-	if (typeof value !== 'string' && typeof value !== 'number') {
-		throw new ApplicationServerError(
-			'CONFIG',
-			\`APP_START_TIMEOUT must be an integer from 1 through \${MAX_APP_START_TIMEOUT}\`,
-			{ value },
-		)
-	}
-	if (typeof value === 'string' && value.length > MAX_APP_NUMBER_INPUT_LENGTH) {
+	const text = parseString(value)
+	if (text === undefined || text.length > MAX_APP_NUMBER_INPUT_LENGTH) {
 		throw new ApplicationServerError(
 			'CONFIG',
 			\`APP_START_TIMEOUT must be an integer from 1 through \${MAX_APP_START_TIMEOUT}\`,
 			{ value },
 		)
 	}
-	const text = typeof value === 'string' ? value.trim() : String(value)
-	const timeout = APP_PORT_PATTERN.test(text) ? Number(text) : Number.NaN
+	const normalized = text.trim()
+	const timeout = APP_PORT_PATTERN.test(normalized) ? Number(normalized) : Number.NaN
 	if (!Number.isInteger(timeout) || timeout < 1 || timeout > MAX_APP_START_TIMEOUT) {
 		throw new ApplicationServerError(
 			'CONFIG',
@@ -3625,24 +3888,58 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationServerOptions(value: unkno
 			)
 		}
 		const keys = Reflect.ownKeys(value)
-		const unknown = keys.filter((key) => key !== 'host' && key !== 'port' && key !== 'timeout')
+		const unknown = keys.filter((key) => key !== 'server')
 		if (unknown.length > 0) {
 			throw new ApplicationServerError('CONFIG', 'Unknown application server option', { value })
 		}
-		const hostDescriptor = Reflect.getOwnPropertyDescriptor(value, 'host')
-		const portDescriptor = Reflect.getOwnPropertyDescriptor(value, 'port')
-		const timeoutDescriptor = Reflect.getOwnPropertyDescriptor(value, 'timeout')
+		const serverDescriptor = Reflect.getOwnPropertyDescriptor(value, 'server')
+		if (
+			keys.includes('server') &&
+			(serverDescriptor === undefined || !Reflect.has(serverDescriptor, 'value'))
+		) {
+			throw new ApplicationServerError(
+				'CONFIG',
+				'Application server options must use data properties',
+				{ value },
+			)
+		}
+		const server = serverDescriptor?.value
+		if (server === undefined) return {}
+		if (typeof server !== 'object' || server === null || Array.isArray(server)) {
+			throw new ApplicationServerError('CONFIG', 'Application server settings must be an object', {
+				value,
+			})
+		}
+		const serverPrototype = Reflect.getPrototypeOf(server)
+		if (serverPrototype !== Object.prototype && serverPrototype !== null) {
+			throw new ApplicationServerError(
+				'CONFIG',
+				'Application server settings must be a plain record',
+				{ value },
+			)
+		}
+		// Walk own descriptors directly: reading values through a getter would run caller code.
+		const serverKeys = Reflect.ownKeys(server)
+		const serverUnknown = serverKeys.filter(
+			(key) => key !== 'host' && key !== 'port' && key !== 'timeout',
+		)
+		if (serverUnknown.length > 0) {
+			throw new ApplicationServerError('CONFIG', 'Unknown application server setting', { value })
+		}
+		const hostDescriptor = Reflect.getOwnPropertyDescriptor(server, 'host')
+		const portDescriptor = Reflect.getOwnPropertyDescriptor(server, 'port')
+		const timeoutDescriptor = Reflect.getOwnPropertyDescriptor(server, 'timeout')
 		if (
-			(keys.includes('host') &&
+			(serverKeys.includes('host') &&
 				(hostDescriptor === undefined || !Reflect.has(hostDescriptor, 'value'))) ||
-			(keys.includes('port') &&
+			(serverKeys.includes('port') &&
 				(portDescriptor === undefined || !Reflect.has(portDescriptor, 'value'))) ||
-			(keys.includes('timeout') &&
+			(serverKeys.includes('timeout') &&
 				(timeoutDescriptor === undefined || !Reflect.has(timeoutDescriptor, 'value')))
 		) {
 			throw new ApplicationServerError(
 				'CONFIG',
-				'Application server options must use data properties',
+				'Application server settings must use data properties',
 				{ value },
 			)
 		}
@@ -3650,9 +3947,11 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationServerOptions(value: unkno
 		const port = portDescriptor?.value
 		const timeout = timeoutDescriptor?.value
 		return {
-			...(host === undefined ? {} : { host: parseApplicationHost(host) }),
-			...(port === undefined ? {} : { port: parseApplicationPort(port) }),
-			...(timeout === undefined ? {} : { timeout: parseApplicationStartTimeout(timeout) }),
+			server: {
+				...(host === undefined ? {} : { host: parseApplicationHost(host) }),
+				...(port === undefined ? {} : { port: parseApplicationPort(port) }),
+				...(timeout === undefined ? {} : { timeout: parseApplicationStartTimeout(timeout) }),
+			},
 		}
 	} catch (error) {
 		if (isApplicationServerError(error)) throw error
@@ -3661,47 +3960,56 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} parseApplicationServerOptions(value: unkno
 		})
 	}
 }
+`
+	}),
+	appServerRoutes: Object.freeze({
+		id: "appServerRoutes",
+		name: "appServerRoutes",
+		summary: "The standalone application route dispatcher factory.",
+		category: "source",
+		placeholders: Object.freeze([Object.freeze({
+			name: "healthImport",
+			description: "The selected layer import for the health route constants."
+		})]),
+		content: `import type { DispatcherInterface } from '@orkestrel/router'
+import type { ApplicationState } from './types.js'
+import { createDispatcher } from '@orkestrel/router'
+{{healthImport}}
+import { handleApplicationHealth } from './handlers.js'
+
+/** Create a fresh dispatcher for the generated application's fetch-standard health boundary. */
+${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} createApplicationDispatcher(): DispatcherInterface<ApplicationState> {
+	return createDispatcher<ApplicationState>({
+		routes: [
+			{
+				method: APP_HEALTH_METHOD,
+				path: APP_HEALTH_PATH,
+				handler: handleApplicationHealth,
+			},
+		],
+	})
+}
 `
 	}),
 	appServerHandlers: Object.freeze({
 		id: "appServerHandlers",
 		name: "appServerHandlers",
-		summary: "The server HTTP request handler.",
+		summary: "The application server diagnostic reporter.",
 		category: "source",
 		placeholders: Object.freeze([Object.freeze({
+			name: "recordImport",
+			description: "The selected layer type import for the health record."
+		}), Object.freeze({
 			name: "nameImport",
 			description: "The selected layer import for APP_NAME."
 		})]),
-		content: `import type { IncomingMessage, ServerResponse } from 'node:http'
+		content: `{{recordImport}}
 {{nameImport}}
-import { APP_HEALTH_METHOD, APP_HEALTH_PATH } from './constants.js'
 import { isApplicationServerError } from './errors.js'
 
-/**
- * Respond to the application health endpoint and reject every other route.
- *
- * @param request - The incoming Node request.
- * @param response - The Node response to complete exactly once.
- */
-${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} handleApplicationRequest(request: IncomingMessage, response: ServerResponse): void {
-	if (request.method !== APP_HEALTH_METHOD) {
-		response.writeHead(405, {
-			allow: APP_HEALTH_METHOD,
-			'content-type': 'text/plain; charset=utf-8',
-		})
-		response.end('Method Not Allowed')
-		return
-	}
-	if (request.url !== APP_HEALTH_PATH) {
-		response.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' })
-		response.end('Not Found')
-		return
-	}
-	response.writeHead(200, {
-		'cache-control': 'no-store',
-		'content-type': 'application/json; charset=utf-8',
-	})
-	response.end(JSON.stringify({ name: APP_NAME, status: 'ok' }))
+/** Return the generated application's shared health record. */
+${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} handleApplicationHealth(): Response {
+	return Response.json({ name: APP_NAME, status: 'ok' } satisfies ApplicationRecord)
 }
 
 /**
@@ -3729,8 +4037,8 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} reportApplicationServerError(error: unknow
 	} catch {
 		message = '[ERROR] Application server failed'
 	}
-	process.stderr.write(\`\${message}\\n\`)
 	process.exitCode = 1
+	process.stderr.write(\`\${message}\\n\`)
 }
 `
 	}),
@@ -3740,176 +4048,106 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} reportApplicationServerError(error: unknow
 		summary: "The application server implementation.",
 		category: "source",
 		placeholders: Object.freeze([]),
-		content: `import type { Server } from 'node:http'
-import type { ApplicationServerInterface, ApplicationServerOptions } from './types.js'
-import { once } from 'node:events'
-import { createServer } from 'node:http'
-import { promisify } from 'node:util'
-import {
-	APP_HEADERS_TIMEOUT,
-	APP_KEEP_ALIVE_TIMEOUT,
-	APP_MAX_CONNECTIONS,
-	APP_MAX_HEADERS,
-	APP_MAX_REQUESTS_PER_SOCKET,
-	APP_REQUEST_TIMEOUT,
-} from './constants.js'
-import { ApplicationServerError, isApplicationServerError } from './errors.js'
-import { handleApplicationRequest } from './handlers.js'
+		content: `import type { DispatcherInterface } from '@orkestrel/router'
+import type { ConnectionInfo, ServerInterface } from '@orkestrel/server'
+import type {
+	ApplicationServerInterface,
+	ApplicationServerOptions,
+	ApplicationState,
+} from './types.js'
+import { createBoundary, createDeadline, createSecurity } from '@orkestrel/middleware'
+import { createServer } from '@orkestrel/server'
+import { ApplicationServerError } from './errors.js'
 import {
 	parseApplicationHost,
 	parseApplicationPort,
 	parseApplicationServerOptions,
 	parseApplicationStartTimeout,
 } from './parsers.js'
+import { createApplicationDispatcher } from './routes.js'
 
-/** A repeat-safe Node HTTP application server. */
+/** A repeat-safe application server composed from the installed server substrate. */
 ${EXPORT_KEYWORD} class ApplicationServer implements ApplicationServerInterface {
 	readonly host: string
-	readonly #requestedPort: number
-	readonly #timeout: number
-	#port: number
-	readonly #server: Server
-	#transition: Promise<void> = Promise.resolve()
-	readonly #starts = new Set<AbortController>()
-	readonly #stopped = new WeakSet<AbortController>()
+	readonly #dispatcher: DispatcherInterface<ApplicationState>
+	readonly #server: ServerInterface<ApplicationState>
 
 	constructor(options: ApplicationServerOptions = {}) {
 		const parsed = parseApplicationServerOptions(options)
-		this.host = parseApplicationHost(parsed.host === undefined ? process.env.APP_HOST : parsed.host)
-		this.#requestedPort = parseApplicationPort(
-			parsed.port === undefined ? process.env.APP_PORT : parsed.port,
+		const server = parsed.server
+		const host = parseApplicationHost(
+			server?.host === undefined ? process.env.APP_HOST : server.host,
 		)
-		this.#port = this.#requestedPort
-		this.#timeout = parseApplicationStartTimeout(
-			parsed.timeout === undefined ? process.env.APP_START_TIMEOUT : parsed.timeout,
+		const port = parseApplicationPort(
+			server?.port === undefined ? process.env.APP_PORT : server.port,
 		)
-		this.#server = createServer(handleApplicationRequest)
-		this.#server.maxConnections = APP_MAX_CONNECTIONS
-		this.#server.maxHeadersCount = APP_MAX_HEADERS
-		this.#server.headersTimeout = APP_HEADERS_TIMEOUT
-		this.#server.requestTimeout = APP_REQUEST_TIMEOUT
-		this.#server.keepAliveTimeout = APP_KEEP_ALIVE_TIMEOUT
-		this.#server.maxRequestsPerSocket = APP_MAX_REQUESTS_PER_SOCKET
+		const timeout = parseApplicationStartTimeout(
+			server?.timeout === undefined ? process.env.APP_START_TIMEOUT : server.timeout,
+		)
+		this.host = host
+		this.#dispatcher = createApplicationDispatcher()
+		this.#server = createServer<ApplicationState>({
+			dispatcher: this.#dispatcher,
+			state: ApplicationServer.#state,
+			middleware: [
+				createBoundary<ApplicationState>(),
+				createSecurity<ApplicationState>(),
+				createDeadline<ApplicationState>({ ms: timeout }),
+			],
+			host,
+			port,
+			timeouts: { start: timeout },
+		})
 	}
 
-	get port(): number {
-		return this.#port
+	static #state(connection: ConnectionInfo): ApplicationState {
+		return { connection }
 	}
 
-	get listening(): boolean {
-		return this.#server.listening
+	get port(): number | undefined {
+		return this.#server.port
 	}
 
-	get url(): string {
-		const hostname = this.host.includes(':') ? \`[\${this.host}]\` : this.host
-		return \`http://\${hostname}:\${this.port}\`
+	get status(): ApplicationServerInterface['status'] {
+		return this.#server.status
 	}
 
-	start(signal?: AbortSignal): Promise<void> {
-		const controller = new AbortController()
-		this.#starts.add(controller)
-		const queued = this.#queue(this.#start.bind(this, controller, signal))
-		void queued.then(this.#settle.bind(this, controller), this.#settle.bind(this, controller))
-		return queued
+	get url(): string | undefined {
+		const port = this.port
+		if (port === undefined) return undefined
+		const hostname = this.host.includes(':') ? \`[\${this.host}]\` : this.host
+		return \`http://\${hostname}:\${port}\`
 	}
 
-	stop(): Promise<void> {
-		for (const controller of this.#starts) {
-			this.#stopped.add(controller)
-			controller.abort()
-		}
-		return this.#queue(this.#stop.bind(this))
-	}
-
-	#queue(operation: () => Promise<void>): Promise<void> {
-		const queued = this.#transition.then(operation, operation)
-		this.#transition = queued.then(
-			() => undefined,
-			() => undefined,
-		)
-		return queued
-	}
-
-	async #start(controller: AbortController, signal?: AbortSignal): Promise<void> {
-		if (this.listening) return
-		if (controller.signal.aborted) {
-			if (this.#stopped.has(controller)) return
-			throw new ApplicationServerError('LIFECYCLE', 'Application server startup was cancelled')
-		}
+	async start(signal?: AbortSignal): Promise<void> {
 		try {
-			if (signal?.aborted === true) {
-				throw new ApplicationServerError('LIFECYCLE', 'Application server startup was cancelled', {
-					cause: signal.reason,
-				})
-			}
-			await this.#listen(controller, signal)
+			await this.#server.start(signal)
 		} catch (error) {
-			if (this.#stopped.has(controller)) return
-			if (isApplicationServerError(error)) throw error
-			throw new ApplicationServerError('LIFECYCLE', 'Failed to inspect startup signal', {
+			throw new ApplicationServerError('LIFECYCLE', 'Failed to start application server', {
 				cause: error,
 			})
 		}
 	}
 
-	async #stop(): Promise<void> {
-		if (!this.listening) return
-		await this.#close()
-	}
-
-	async #listen(controller: AbortController, signal?: AbortSignal): Promise<void> {
-		const relay = signal === undefined ? undefined : this.#abort.bind(this, controller, signal)
-		const timer = setTimeout(this.#expire.bind(this, controller), this.#timeout)
+	async stop(): Promise<void> {
 		try {
-			if (signal !== undefined && relay !== undefined) {
-				signal.addEventListener('abort', relay, { once: true })
-			}
-			this.#server.listen({
-				port: this.#requestedPort,
-				host: this.host,
-				signal: controller.signal,
-			})
-			await once(this.#server, 'listening', { signal: controller.signal })
+			await this.#server.stop()
 		} catch (error) {
-			throw new ApplicationServerError('LIFECYCLE', 'Failed to start application server', {
+			throw new ApplicationServerError('LIFECYCLE', 'Failed to stop application server', {
 				cause: error,
 			})
-		} finally {
-			clearTimeout(timer)
-			if (relay !== undefined && signal !== undefined) {
-				signal.removeEventListener('abort', relay)
-			}
-		}
-		const address = this.#server.address()
-		if (address === null || typeof address === 'string') {
-			await this.#close()
-			throw new ApplicationServerError('LIFECYCLE', 'Server did not expose a TCP address')
 		}
-		this.#port = address.port
 	}
 
-	#abort(controller: AbortController, signal: AbortSignal): void {
-		controller.abort(signal.reason)
-	}
-
-	#expire(controller: AbortController): void {
-		controller.abort(new Error(\`Application server startup exceeded \${this.#timeout} milliseconds\`))
-	}
-
-	#settle(controller: AbortController): void {
-		this.#starts.delete(controller)
-	}
-
-	async #close(): Promise<void> {
+	async destroy(): Promise<void> {
 		try {
-			const closed = promisify(this.#server.close.bind(this.#server))()
-			this.#server.closeIdleConnections()
-			this.#server.closeAllConnections()
-			await closed
+			await this.#server.destroy()
 		} catch (error) {
-			throw new ApplicationServerError('LIFECYCLE', 'Failed to stop application server', {
+			throw new ApplicationServerError('LIFECYCLE', 'Failed to destroy application server', {
 				cause: error,
 			})
+		} finally {
+			this.#dispatcher.destroy()
 		}
 	}
 }
@@ -3932,16 +4170,17 @@ import { ApplicationServerRunner } from './ApplicationServerRunner.js'
 /**
  * Create a stopped application server.
  *
- * @param options - Optional host and port overrides.
+ * @param options - Optional grouped server overrides.
  * @returns A lifecycle-safe application server.
  *
  * @example
  * \`\`\`ts
  * import { createApplicationServer } from '@app/server'
  *
- * ${CONST_KEYWORD} server = createApplicationServer({ port: 0 })
+ * ${CONST_KEYWORD} server = createApplicationServer({ server: { port: 0 } })
  * await server.start()
  * await server.stop()
+ * await server.destroy()
  * \`\`\`
  */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} createApplicationServer(
@@ -3953,21 +4192,21 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} createApplicationServer(
 /**
  * Start a process-owned application server.
  *
- * @param options - Optional host and port overrides.
+ * @param options - Optional grouped server overrides.
  * @returns The runner that owns signals and provides explicit asynchronous cleanup.
  *
  * @example
  * \`\`\`ts
  * import { startApplicationServer } from '@app/server'
  *
- * ${CONST_KEYWORD} runner = startApplicationServer({ port: 0 })
+ * ${CONST_KEYWORD} runner = startApplicationServer({ server: { port: 0 } })
  * await runner.stop()
  * \`\`\`
  */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} startApplicationServer(
 	options: ApplicationServerOptions = {},
 ): ApplicationServerRunnerInterface {
-	const runner = new ApplicationServerRunner(options)
+	const runner = new ApplicationServerRunner(new ApplicationServer(options))
 	runner.start()
 	return runner
 }
@@ -3978,57 +4217,144 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} startApplicationServer(
 		name: "appServerRunner",
 		summary: "The application server process lifecycle owner.",
 		category: "source",
-		placeholders: Object.freeze([]),
-		content: `import type {
+		placeholders: Object.freeze([Object.freeze({
+			name: "nameImport",
+			description: "The selected layer import for APP_NAME."
+		})]),
+		content: `import type { EmitterInterface } from '@orkestrel/emitter'
+import type {
 	ApplicationServerInterface,
-	ApplicationServerOptions,
+	ApplicationServerRunnerEventMap,
 	ApplicationServerRunnerInterface,
+	ApplicationServerRunnerOptions,
 } from './types.js'
-import { ApplicationServer } from './ApplicationServer.js'
+import { Emitter } from '@orkestrel/emitter'
+{{nameImport}}
+import { ApplicationServerError } from './errors.js'
 import { reportApplicationServerError } from './handlers.js'
 
 /** Own process signals and startup failure handling for one application server. */
 ${EXPORT_KEYWORD} class ApplicationServerRunner implements ApplicationServerRunnerInterface {
+	readonly #emitter: Emitter<ApplicationServerRunnerEventMap>
 	readonly #server: ApplicationServerInterface
-	readonly #signal: () => void
+	readonly #handler: () => void
+	#controller: AbortController | undefined
+	#queue: Promise<void> = Promise.resolve()
+	#stopping: Promise<void> | undefined
+	#announcement: number | undefined
 	#generation = 0
 	#started = false
 
-	constructor(options: ApplicationServerOptions = {}) {
-		this.#server = new ApplicationServer(options)
-		this.#signal = this.#shutdown.bind(this)
+	constructor(server: ApplicationServerInterface, options: ApplicationServerRunnerOptions = {}) {
+		this.#emitter = new Emitter({
+			...(options.on === undefined ? {} : { on: options.on }),
+			...(options.error === undefined ? {} : { error: options.error }),
+		})
+		this.#server = server
+		this.#handler = this.#shutdown.bind(this)
+		this.#emitter.on('ready', this.#announce.bind(this))
+		this.#emitter.on('fail', reportApplicationServerError)
+	}
+
+	get emitter(): EmitterInterface<ApplicationServerRunnerEventMap> {
+		return this.#emitter
 	}
 
 	start(): void {
 		if (this.#started) return
 		this.#started = true
+		this.#stopping = undefined
 		const generation = ++this.#generation
-		process.once('SIGINT', this.#signal)
-		process.once('SIGTERM', this.#signal)
-		void this.#server.start().catch(this.#fail.bind(this, generation))
+		const controller = new AbortController()
+		this.#controller = controller
+		process.once('SIGINT', this.#handler)
+		process.once('SIGTERM', this.#handler)
+		this.#queue = this.#queue.then(this.#begin.bind(this, generation, controller))
 	}
 
 	stop(): Promise<void> {
-		this.#generation += 1
+		if (this.#stopping !== undefined) return this.#stopping
+		// Aborting first lets an in-flight substrate startup settle before stop inspects its state,
+		// and the generation bump is what discards that abort's rejection while leaving a genuine
+		// stop failure reportable. The shared queue then keeps a subsequent restart behind this complete
+		// shutdown; concurrent callers join one substrate stop through #stopping, and the trailing catch
+		// discards nothing — it only keeps one failed stop from wedging every later one.
+		++this.#generation
+		this.#controller?.abort()
 		this.#release()
-		return this.#server.stop()
+		const stopping = this.#queue.then(() => this.#server.stop())
+		this.#stopping = stopping
+		this.#queue = stopping.catch(() => undefined)
+		void stopping.then(this.#finishStop.bind(this, stopping), this.#rejectStop.bind(this, stopping))
+		return stopping
+	}
+
+	async #begin(generation: number, controller: AbortController): Promise<void> {
+		if (generation !== this.#generation || !this.#started) return
+		try {
+			await this.#server.start(controller.signal)
+			await this.#ready(generation)
+		} catch (error) {
+			this.#fail(generation, error)
+		}
 	}
 
 	#fail(generation: number, error: unknown): void {
 		if (generation !== this.#generation) return
 		this.#release()
-		reportApplicationServerError(error)
+		this.#emitter.emit('fail', error)
+	}
+
+	#finishStop(stopping: Promise<void>): void {
+		if (this.#stopping === stopping) this.#stopping = undefined
+	}
+
+	#rejectStop(stopping: Promise<void>, error: unknown): void {
+		this.#finishStop(stopping)
+		this.#emitter.emit('fail', error)
+	}
+
+	async #ready(generation: number): Promise<void> {
+		if (generation !== this.#generation || !this.#started) return
+		const url = this.#server.url
+		if (url === undefined) {
+			const failure = new ApplicationServerError(
+				'LIFECYCLE',
+				'Application server did not expose a URL after successful startup',
+			)
+			try {
+				await this.#server.stop()
+			} catch (error) {
+				this.#fail(generation, error)
+				return
+			}
+			this.#fail(generation, failure)
+			return
+		}
+		this.#announcement = generation
+		this.#emitter.emit('ready', url)
+		this.#announcement = undefined
+	}
+
+	#announce(url: string): void {
+		if (this.#announcement !== this.#generation) return
+		try {
+			process.stderr.write(\`[READY] \${APP_NAME} \${url}\\n\`)
+		} catch (error) {
+			const stopped = this.stop()
+			const generation = this.#generation
+			void stopped.then(this.#fail.bind(this, generation, error), () => undefined)
+		}
 	}
 
 	#shutdown(): void {
 		const stopped = this.stop()
-		const generation = this.#generation
-		void stopped.catch(this.#fail.bind(this, generation))
+		void stopped.catch(() => undefined)
 	}
 
 	#release(): void {
-		process.off('SIGINT', this.#signal)
-		process.off('SIGTERM', this.#signal)
+		process.off('SIGINT', this.#handler)
+		process.off('SIGTERM', this.#handler)
 		this.#started = false
 	}
 }
@@ -4044,6 +4370,7 @@ ${EXPORT_KEYWORD} class ApplicationServerRunner implements ApplicationServerRunn
 export * from './constants.js'
 export * from './errors.js'
 export * from './parsers.js'
+export * from './routes.js'
 export * from './handlers.js'
 export * from './ApplicationServer.js'
 export * from './ApplicationServerRunner.js'
@@ -4068,10 +4395,16 @@ try {
 	setup: Object.freeze({
 		id: "setup",
 		name: "setup",
-		summary: "The generated-minimal `tests/setup.ts` recorder helper — no placeholders.",
+		summary: "The generated-minimal `tests/setup.ts` shared test helpers.",
 		category: "tests",
-		placeholders: Object.freeze([]),
-		content: `// ── Call recorder (a real callback, not a mock) ──────────────────────────────
+		placeholders: Object.freeze([Object.freeze({
+			name: "eventImport",
+			description: "The optional emitter types used by application server tests."
+		}), Object.freeze({
+			name: "eventHelper",
+			description: "The optional typed event waiter used by application server tests."
+		})]),
+		content: `{{eventImport}}// ── Call recorder (a real callback, not a mock) ──────────────────────────────
 //
 // The test rules require a recording callback when a test only needs to count calls or inspect arguments:
 // recorder — a real listener that records every invocation — rather than a test-
@@ -4111,12 +4444,64 @@ ${EXPORT_KEYWORD} function createRecorder<TArgs extends readonly unknown[]>(): T
 		},
 	}
 }
-
+{{eventHelper}}
 /** Whether a repository-relative Vue SFC belongs to the private browser application. */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isBrowserVuePath(path: string): boolean {
 	const normalized = path.replaceAll('\\\\', '/')
 	return normalized.startsWith('app/browser/')
 }
+`
+	}),
+	configTest: Object.freeze({
+		id: "configTest",
+		name: "configTest",
+		summary: "The generated root Vite configuration behavior test.",
+		category: "tests",
+		placeholders: Object.freeze([Object.freeze({
+			name: "imports",
+			description: "The machinery-aware root configuration imports."
+		}), Object.freeze({
+			name: "cases",
+			description: "The machinery-aware root configuration cases."
+		})]),
+		content: `{{imports}}
+
+describe('root Vite configuration', () => {
+	it('keeps workspace paths physically contained', () => {
+		const root = resolveWorkspacePath('.')
+		const source = resolveWorkspacePath('src')
+		const parent = resolveWorkspacePath('..')
+
+		expect(workspacePath(root)).toBe('')
+		expect(workspacePath(source)).toBe('src')
+		expect(workspacePath(parent)).toBeUndefined()
+		expect(containedPath(root, source)).toBe(true)
+		expect(containedPath(root, parent)).toBe(false)
+	})
+
+	it('enforces environment direction for paths and module sources', () => {
+		expect(environmentPathError('src/core', 'app/core/index.ts')).toBe(
+			'Published modules cannot depend on private application modules',
+		)
+		expect(environmentPathError('app/core', 'src/browser/index.ts')).toBe(
+			'Core modules must remain host-independent',
+		)
+		expect(environmentPathError('app/browser', 'src/server/index.ts')).toBe(
+			'Browser modules cannot depend on Node or server-only modules',
+		)
+		expect(environmentPathError('app/server', 'src/browser/index.ts')).toBe(
+			'Server modules cannot depend on Vue or browser-only modules',
+		)
+		expect(environmentPathError('app/browser', 'src/core/index.ts')).toBeUndefined()
+		expect(environmentSourceError('src/core', 'node:path')).toBe(
+			'Core modules must remain host-independent',
+		)
+		expect(environmentSourceError('app/server', 'vue')).toBe(
+			'Server modules cannot depend on Vue or browser-only modules',
+		)
+		expect(environmentSourceError('app/browser', '@app/core')).toBeUndefined()
+	}){{cases}}
+})
 `
 	}),
 	policyTest: Object.freeze({
@@ -4124,32 +4509,17 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} isBrowserVuePath(path: string): boolean {
 		name: "policyTest",
 		summary: "The generated repository filename-policy test.",
 		category: "tests",
-		placeholders: Object.freeze([
-			Object.freeze({
-				name: "browserPolicySpecifier",
-				description: "The optional real Chromium filesystem-probe import."
-			}),
-			Object.freeze({
-				name: "browserPolicyImport",
-				description: "The optional real Chromium package import."
-			}),
-			Object.freeze({
-				name: "browserPolicyTest",
-				description: "The optional capability-gated Chromium policy test."
-			}),
-			Object.freeze({
-				name: "vuePolicyImport",
-				description: "The optional official Vue SFC compiler import."
-			}),
-			Object.freeze({
-				name: "workspacePolicyAssertion",
-				description: "The formatter-stable workspace policy assertion."
-			})
-		]),
-		content: `import { globSync{{browserPolicySpecifier}} } from 'node:fs'
+		placeholders: Object.freeze([Object.freeze({
+			name: "vuePolicyImport",
+			description: "The optional official Vue SFC compiler import."
+		}), Object.freeze({
+			name: "workspacePolicyAssertion",
+			description: "The formatter-stable workspace policy assertion."
+		})]),
+		content: `import { globSync } from 'node:fs'
 import { describe, expect, it } from 'vitest'
 import { isBrowserVuePath } from './setup.js'
-import { inspectCodingWorkspace } from './setupPolicy.js'{{browserPolicyImport}}{{vuePolicyImport}}
+import { inspectCodingWorkspace } from './setupPolicy.js'{{vuePolicyImport}}
 
 describe('repository coding law', () => {
 	it('keeps Vue single-file components exclusively in browser environments', () => {
@@ -4160,7 +4530,7 @@ describe('repository coding law', () => {
 
 	it('enforces source placement, exports, readonly contracts, and syntax law', () => {
 		{{workspacePolicyAssertion}}
-	}){{browserPolicyTest}}
+	})
 })
 `
 	}),
@@ -4180,6 +4550,7 @@ ${IMPORT_KEYWORD} { createServer } from 'node:http'
 /** One real application child process plus its captured diagnostic output. */
 ${EXPORT_KEYWORD} interface ApplicationProcessInterface {
 	readonly child: ChildProcess
+	readonly ready: Promise<void>
 	output(): string
 }
 
@@ -4219,11 +4590,17 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} buildApplicationServer(): void {
 	}
 }
 
-/** Reserve and release a real loopback port for an immediate child-process bind. */
-${EXPORT_KEYWORD} async ${FUNCTION_KEYWORD} reserveLoopbackPort(): Promise<number> {
+/** Start a real Node server bound to one loopback port, or 0 for an ephemeral one. */
+${EXPORT_KEYWORD} async ${FUNCTION_KEYWORD} startLoopbackServer(port: number): Promise<Server> {
 	const server = createServer()
-	server.listen(0, '127.0.0.1')
+	server.listen(port, '127.0.0.1')
 	await once(server, 'listening')
+	return server
+}
+
+/** Reserve and release a real loopback port for an immediate child-process bind. */
+${EXPORT_KEYWORD} async ${FUNCTION_KEYWORD} reserveLoopbackPort(): Promise<number> {
+	const server = await startLoopbackServer(0)
 	const address = server.address()
 	if (address === null || typeof address === 'string') {
 		await stopNodeServer(server)
@@ -4233,23 +4610,6 @@ ${EXPORT_KEYWORD} async ${FUNCTION_KEYWORD} reserveLoopbackPort(): Promise<numbe
 	return address.port
 }
 
-/** Wait until one in-process application server responds on loopback. */
-${EXPORT_KEYWORD} async ${FUNCTION_KEYWORD} waitForLoopbackResponse(port: number): Promise<Response> {
-	const deadline = Date.now() + 10_000
-	let failure: unknown
-	while (Date.now() < deadline) {
-		try {
-			return await fetch(\`http://127.0.0.1:\${port}\`, {
-				signal: AbortSignal.timeout(250),
-			})
-		} catch (error) {
-			failure = error
-			await new Promise<void>((resolvePromise) => setTimeout(resolvePromise, 25))
-		}
-	}
-	throw new Error(\`application server did not become ready: \${String(failure)}\`)
-}
-
 /** Start the built application entry as a real child process. */
 ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} startApplicationProcess(
 	port: number,
@@ -4266,16 +4626,20 @@ ${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} startApplicationProcess(
 		stdio: ['ignore', 'pipe', 'pipe'],
 	})
 	const output: string[] = []
+	const readiness = Promise.withResolvers<void>()
 	child.stdout?.setEncoding('utf8')
 	child.stderr?.setEncoding('utf8')
 	child.stdout?.on('data', (chunk: unknown) => {
 		if (typeof chunk === 'string') output.push(chunk)
 	})
 	child.stderr?.on('data', (chunk: unknown) => {
-		if (typeof chunk === 'string') output.push(chunk)
+		if (typeof chunk !== 'string') return
+		output.push(chunk)
+		if (output.join('').includes('[READY] ')) readiness.resolve()
 	})
 	return {
 		child,
+		ready: readiness.promise,
 		output() {
 			return output.join('')
 		},
@@ -4440,15 +4804,28 @@ describe('create{{pascal}}', () => {
 		name: "appCoreTest",
 		summary: "The host-independent application test.",
 		category: "tests",
-		placeholders: Object.freeze([]),
+		placeholders: Object.freeze([
+			Object.freeze({
+				name: "guardImport",
+				description: "The optional shared-record guard test import."
+			}),
+			Object.freeze({
+				name: "readImport",
+				description: "The optional shared health-boundary read test import."
+			}),
+			Object.freeze({
+				name: "boundary",
+				description: "The optional shared health-boundary contract test."
+			})
+		]),
 		content: `import {
 	APP_NAME,
 	ApplicationError,
 	createApplication,
 	isApplicationError,
-	MAX_APPLICATION_NAME_INPUT_LENGTH,
+{{guardImport}}	MAX_APPLICATION_NAME_INPUT_LENGTH,
 	parseApplicationName,
-} from '@app/core'
+{{readImport}}} from '@app/core'
 import { describe, expect, it } from 'vitest'
 
 describe('createApplication', () => {
@@ -4485,7 +4862,14 @@ describe('createApplication', () => {
 		revocable.revoke()
 		expect(isApplicationError(revocable.proxy)).toBe(false)
 	})
-})
+
+	it('refuses a foreign application error', () => {
+		const foreign = new Error('foreign')
+		foreign.name = 'ApplicationError'
+
+		expect(isApplicationError(foreign)).toBe(false)
+	})
+}){{boundary}}
 `
 	}),
 	appBrowserTest: Object.freeze({
@@ -4493,18 +4877,36 @@ describe('createApplication', () => {
 		name: "appBrowserTest",
 		summary: "The real-browser application mount test.",
 		category: "tests",
-		placeholders: Object.freeze([Object.freeze({
-			name: "browserTestNameImport",
-			description: "The layer-correct browser APP_NAME test import."
-		})]),
+		placeholders: Object.freeze([
+			Object.freeze({
+				name: "browserTestNameImport",
+				description: "The layer-correct browser APP_NAME test import."
+			}),
+			Object.freeze({
+				name: "showcaseImport",
+				description: "The optional showcase factory test import."
+			}),
+			Object.freeze({
+				name: "entryImport",
+				description: "The optional seeder and boundary-entry test imports."
+			}),
+			Object.freeze({
+				name: "showcase",
+				description: "The optional real-browser showcase mount test."
+			}),
+			Object.freeze({
+				name: "boundary",
+				description: "The optional real-browser boundary degradation test."
+			})
+		]),
 		content: `{{browserTestNameImport}}
 import {
 	BrowserApplicationError,
 	createBrowserApplication,
-	isBrowserApplicationError,
+{{showcaseImport}}	isBrowserApplicationError,
 	MAX_BROWSER_APPLICATION_NAME_INPUT_LENGTH,
 	parseBrowserApplicationOptions,
-} from '@app/browser'
+{{entryImport}}} from '@app/browser'
 import { buildElement } from '../../setupBrowser.js'
 import { describe, expect, it } from 'vitest'
 
@@ -4588,313 +4990,205 @@ describe('createBrowserApplication', () => {
 		expect(isBrowserApplicationError(new Error('plain'))).toBe(false)
 		expect(isBrowserApplicationError(revocable.proxy)).toBe(false)
 	})
-})
+}){{showcase}}{{boundary}}
 `
 	}),
 	appServerTest: Object.freeze({
 		id: "appServerTest",
 		name: "appServerTest",
-		summary: "The real loopback application server lifecycle test.",
+		summary: "The real dispatcher, server-substrate, and runner integration test.",
 		category: "tests",
-		placeholders: Object.freeze([Object.freeze({
-			name: "testNameImport",
-			description: "The layer-correct APP_NAME test import."
-		})]),
+		placeholders: Object.freeze([
+			Object.freeze({
+				name: "testNameImport",
+				description: "The layer-correct APP_NAME and health-contract test import."
+			}),
+			Object.freeze({
+				name: "serverImport",
+				description: "The application server test import, minus any relocated health contract."
+			}),
+			Object.freeze({
+				name: "boundary",
+				description: "The optional real-server shared-boundary test."
+			})
+		]),
 		content: `{{testNameImport}}
-import {
-	APP_HEALTH_METHOD,
-	APP_HEALTH_PATH,
-	APP_MAX_CONNECTIONS,
-	ApplicationServerRunner,
-	createApplicationServer,
-	startApplicationServer,
-} from '@app/server'
-import { once } from 'node:events'
-import { createServer } from 'node:http'
-import { connect } from 'node:net'
+{{serverImport}}
 import { beforeAll, describe, expect, it } from 'vitest'
 import {
 	buildApplicationServer,
 	reserveLoopbackPort,
 	startApplicationProcess,
+	startLoopbackServer,
 	stopNodeServer,
 	waitForApplicationProcess,
-	waitForApplicationResponse,
-	waitForLoopbackResponse,
-	waitForSocketClose,
 } from '../../setupServer.js'
+import { createRecorder, waitForEvent } from '../../setup.js'
 
 beforeAll(() => buildApplicationServer(), 60_000)
 
-describe('ApplicationServer', () => {
-	it('serves a real loopback request and tolerates repeated lifecycle calls', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
+describe('application dispatcher', () => {
+	const state = { connection: { encrypted: false } }
+
+	it('returns the typed shared application record for the health route', async () => {
+		const dispatcher = createApplicationDispatcher()
 		try {
-			await Promise.all([server.start(), server.start(), server.start()])
-			await server.start()
+			const response = await dispatcher.handle(
+				new Request(\`http://application.test\${APP_HEALTH_PATH}\`),
+				state,
+			)
 
-			const response = await fetch(server.url)
 			expect(response.status).toBe(200)
-			expect(response.headers.get('cache-control')).toBe('no-store')
-			expect(response.headers.get('content-type')).toBe('application/json; charset=utf-8')
 			expect(await response.json()).toEqual({ name: APP_NAME, status: 'ok' })
+			expect(APP_HEALTH_PATH).toBe('/health')
 		} finally {
-			await Promise.all([server.stop(), server.stop(), server.stop()])
-			await server.stop()
+			dispatcher.destroy()
 		}
 	})
 
-	it('rejects unsupported methods and unknown routes', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
+	it('distinguishes a wrong method from a missing route', async () => {
+		const dispatcher = createApplicationDispatcher()
 		try {
-			await server.start()
-			const method = await fetch(server.url, { method: 'POST' })
-			expect(method.status).toBe(405)
-			expect(method.headers.get('allow')).toBe(APP_HEALTH_METHOD)
-			expect(method.headers.get('content-type')).toBe('text/plain; charset=utf-8')
-			expect(await method.text()).toBe('Method Not Allowed')
-			const route = await fetch(\`\${server.url}/missing\`)
-			expect(route.status).toBe(404)
-			expect(route.headers.get('content-type')).toBe('text/plain; charset=utf-8')
-			expect(await route.text()).toBe('Not Found')
-			expect(APP_HEALTH_PATH).toBe('/')
-		} finally {
-			await server.stop()
-		}
-	})
-
-	it('serves concurrent loopback requests without cross-request state', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
-		try {
-			await server.start()
-			const responses = await Promise.all(
-				Array.from({ length: 8 }, async () => {
-					const response = await fetch(server.url)
-					return { status: response.status, body: await response.json() }
-				}),
+			const method = await dispatcher.handle(
+				new Request(\`http://application.test\${APP_HEALTH_PATH}\`, { method: 'POST' }),
+				state,
 			)
-			expect(responses).toHaveLength(8)
-			for (const response of responses) {
-				expect(response).toEqual({
-					status: 200,
-					body: { name: APP_NAME, status: 'ok' },
-				})
-			}
-		} finally {
-			await server.stop()
-		}
-	})
-
-	it('validates direct options before allocating a listener', () => {
-		expect(() => createApplicationServer({ host: ' ' })).toThrow(
-			expect.objectContaining({ code: 'CONFIG' }),
-		)
-		expect(() => createApplicationServer({ port: Number.NaN })).toThrow(
-			expect.objectContaining({ code: 'CONFIG' }),
-		)
-		expect(() => createApplicationServer({ port: -1 })).toThrow(
-			expect.objectContaining({ code: 'CONFIG' }),
-		)
-		expect(() => createApplicationServer({ timeout: 0 })).toThrow(
-			expect.objectContaining({ code: 'CONFIG' }),
-		)
-		for (const value of [null, 42, [], { host: 42 }, { port: [42] }]) {
-			expect(() => Reflect.apply(createApplicationServer, undefined, [value])).toThrow(
-				expect.objectContaining({ code: 'CONFIG' }),
-			)
-		}
-		expect(createApplicationServer({ host: '::1' }).url).toBe('http://[::1]:3000')
-	})
+			const missing = await dispatcher.handle(new Request('http://application.test/missing'), state)
 
-	it('parses the real APP_HOST, APP_PORT, and APP_START_TIMEOUT environment boundary and restores it', () => {
-		const previousHost = process.env.APP_HOST
-		const previousPort = process.env.APP_PORT
-		const previousTimeout = process.env.APP_START_TIMEOUT
-		try {
-			process.env.APP_HOST = ' 127.0.0.1 '
-			process.env.APP_PORT = '0'
-			process.env.APP_START_TIMEOUT = '250'
-			const server = createApplicationServer()
-			expect(server.host).toBe('127.0.0.1')
-			expect(server.port).toBe(0)
-
-			process.env.APP_PORT = '1e3'
-			expect(() => createApplicationServer()).toThrow(expect.objectContaining({ code: 'CONFIG' }))
-			process.env.APP_PORT = '0'
-			process.env.APP_START_TIMEOUT = '0'
-			expect(() => createApplicationServer()).toThrow(expect.objectContaining({ code: 'CONFIG' }))
+			expect(method.status).toBe(405)
+			expect(method.headers.get('allow')).toContain(APP_HEALTH_METHOD)
+			expect(missing.status).toBe(404)
 		} finally {
-			if (previousHost === undefined) delete process.env.APP_HOST
-			else process.env.APP_HOST = previousHost
-			if (previousPort === undefined) delete process.env.APP_PORT
-			else process.env.APP_PORT = previousPort
-			if (previousTimeout === undefined) delete process.env.APP_START_TIMEOUT
-			else process.env.APP_START_TIMEOUT = previousTimeout
+			dispatcher.destroy()
 		}
 	})
+})
 
-	it('rejects an aborted startup promptly, cleans up, and remains restartable', async () => {
+describe('ApplicationServer', () => {
+	it('composes the real substrate on loopback with security and repeatable lifecycle', async () => {
 		const server = createApplicationServer({
-			host: '127.0.0.1',
-			port: 0,
-			timeout: 1_000,
+			server: { host: '127.0.0.1', port: 0, timeout: 1_000 },
 		})
-		const controller = new AbortController()
-		controller.abort(new Error('cancelled by test'))
 		try {
-			const started = Date.now()
-			await expect(server.start(controller.signal)).rejects.toMatchObject({ code: 'LIFECYCLE' })
-			expect(Date.now() - started).toBeLessThan(5_000)
-			expect(server.listening).toBe(false)
-
-			await server.stop()
+			expect(server.host).toBe('127.0.0.1')
+			expect(server.port).toBeUndefined()
+			expect(server.url).toBeUndefined()
+			expect(server.status).toBe('idle')
 			await server.start()
-			expect((await fetch(server.url)).status).toBe(200)
-		} finally {
-			await server.stop()
-		}
-	})
-
-	it('contains a revoked startup signal without listening or leaking transition state', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
-		const revocable = Proxy.revocable(new AbortController().signal, {})
-		revocable.revoke()
-		try {
-			await expect(Reflect.apply(server.start, server, [revocable.proxy])).rejects.toMatchObject({
-				code: 'LIFECYCLE',
-			})
-			expect(server.listening).toBe(false)
+			expect(server.status).toBe('listening')
+			expect(server.port).toEqual(expect.any(Number))
+			const firstUrl = server.url
+			if (firstUrl === undefined) throw new Error('Expected a bound application URL')
+
+			const first = await fetch(\`\${firstUrl}\${APP_HEALTH_PATH}\`)
+			expect(first.status).toBe(200)
+			expect(first.headers.get('x-content-type-options')).toBe('nosniff')
+			expect(first.headers.get('x-frame-options')).toBe('DENY')
+			expect(first.headers.get('content-security-policy')).not.toBeNull()
+			expect(first.headers.get('x-request-id')).not.toBeNull()
+			expect(await first.json()).toEqual({ name: APP_NAME, status: 'ok' })
 
-			await server.start()
-			expect((await fetch(server.url)).status).toBe(200)
-		} finally {
 			await server.stop()
-		}
-	})
-
-	it('fails closed on a port collision and preserves the owning server', async () => {
-		const owner = createApplicationServer({ host: '127.0.0.1', port: 0 })
-		let blocked: ReturnType<typeof createApplicationServer> | undefined
-		try {
-			await owner.start()
-			blocked = createApplicationServer({ host: '127.0.0.1', port: owner.port })
-			await expect(blocked.start()).rejects.toMatchObject({ code: 'LIFECYCLE' })
-			expect(blocked.listening).toBe(false)
-			expect((await fetch(owner.url)).status).toBe(200)
-		} finally {
-			await blocked?.stop()
-			await owner.stop()
-		}
-	})
-
-	it('restarts cleanly after a completed stop', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
-		try {
-			await server.start()
 			await server.stop()
-			await Promise.all([server.start(), server.start()])
-			expect((await fetch(server.url)).status).toBe(200)
-		} finally {
-			await server.stop()
-		}
-	})
+			expect(server.port).toBeUndefined()
+			expect(server.url).toBeUndefined()
+			expect(server.status).toBe('stopped')
 
-	it('requests a fresh ephemeral port when the previous port is occupied', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
-		const occupant = createServer()
-		try {
 			await server.start()
-			const previousPort = server.port
+			const secondUrl = server.url
+			if (secondUrl === undefined) throw new Error('Expected a rebound application URL')
+			const second = await fetch(\`\${secondUrl}\${APP_HEALTH_PATH}\`)
+			expect(second.status).toBe(200)
 			await server.stop()
-
-			occupant.listen(previousPort, server.host)
-			await once(occupant, 'listening')
-			await server.start()
-
-			expect(server.port).not.toBe(previousPort)
-			expect((await fetch(server.url)).status).toBe(200)
+			await server.destroy()
+			await server.destroy()
+			expect(server.status).toBe('stopped')
 		} finally {
-			await server.stop()
-			await stopNodeServer(occupant)
+			await server.destroy()
 		}
 	})
 
-	it('honors the latest requested state across opposing concurrent transitions', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
-		try {
-			const firstStart = server.start()
-			const stopping = server.stop()
-			const latestStart = server.start()
-			await Promise.all([firstStart, stopping, latestStart])
-
-			expect(server.listening).toBe(true)
-			expect((await fetch(server.url)).status).toBe(200)
-		} finally {
-			await server.stop()
+	it('rejects invalid grouped host and port options before binding', () => {
+		for (const value of [
+			{ server: { host: ' ' } },
+			{ server: { port: Number.NaN } },
+			{ server: { port: -1 } },
+			{ server: { timeout: 0 } },
+		]) {
+			expect(() => Reflect.apply(createApplicationServer, undefined, [value])).toThrow(
+				expect.objectContaining({ code: 'CONFIG' }),
+			)
 		}
 	})
+})
 
-	it('forces a hostile partial-header connection closed during stop', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
+describe('ApplicationServerRunner', () => {
+	it('serves a real request after a restart queued during shutdown', async () => {
+		const port = await reserveLoopbackPort()
+		const code = process.exitCode
+		const server = createApplicationServer({ server: { host: '127.0.0.1', port } })
+		const runner = new ApplicationServerRunner(server)
 		try {
-			await server.start()
-			const socket = connect({ host: server.host, port: server.port })
-			try {
-				await once(socket, 'connect')
-				socket.write('GET / HTTP/1.1\\r\\nHost: localhost')
-				const closed = waitForSocketClose(socket)
+			process.exitCode = undefined
+			const first = waitForEvent(runner.emitter, 'ready')
+			runner.start()
+			await first
+			const stopped = runner.stop()
+			const second = waitForEvent(runner.emitter, 'ready')
+			runner.start()
+			await stopped
 
-				await server.stop()
-				await closed
-				expect(socket.destroyed).toBe(true)
-			} finally {
-				socket.destroy()
-			}
+			const [url] = await second
+			const response = await fetch(\`\${url}\${APP_HEALTH_PATH}\`)
+			expect(response.status).toBe(200)
+			expect(await response.json()).toEqual({ name: APP_NAME, status: 'ok' })
+			const stopping = runner.stop()
+			expect(runner.stop()).toBe(stopping)
+			await stopping
+			expect(process.exitCode).toBeUndefined()
 		} finally {
-			await server.stop()
+			process.exitCode = code
+			await runner.stop()
 		}
 	})
 
-	it('bounds simultaneous idle connections and recovers after capacity is released', async () => {
-		const server = createApplicationServer({ host: '127.0.0.1', port: 0 })
-		const sockets = []
+	it('cancels a startup still in flight so an immediate stop leaves the port free', async () => {
+		const port = await reserveLoopbackPort()
+		const ready = createRecorder<[url: string]>()
+		const failed = createRecorder<[error: unknown]>()
+		const server = createApplicationServer({ server: { host: '127.0.0.1', port } })
+		const runner = new ApplicationServerRunner(server, {
+			on: { ready: ready.handler, fail: failed.handler },
+		})
 		try {
-			await server.start()
-			for (let index = 0; index < APP_MAX_CONNECTIONS; index += 1) {
-				const socket = connect({ host: server.host, port: server.port })
-				await once(socket, 'connect')
-				socket.write('GET / HTTP/1.1\\r\\nHost: localhost')
-				sockets.push(socket)
-			}
-			const overflow = connect({ host: server.host, port: server.port })
+			runner.start()
+			await runner.stop()
+			expect(ready.count).toBe(0)
+			expect(failed.count).toBe(0)
+
+			const released = await startLoopbackServer(port)
 			try {
-				const closed = waitForSocketClose(overflow)
-				await once(overflow, 'connect')
-				await closed
-				expect(overflow.destroyed).toBe(true)
+				expect(released.listening).toBe(true)
 			} finally {
-				overflow.destroy()
+				await stopNodeServer(released)
 			}
-			const released = sockets.pop()
-			if (released === undefined) throw new Error('expected a held connection')
-			const releasedClose = waitForSocketClose(released)
-			released.destroy()
-			await releasedClose
-			const response = await waitForLoopbackResponse(server.port)
-			expect(response.status).toBe(200)
 		} finally {
-			for (const socket of sockets) socket.destroy()
-			await server.stop()
+			await runner.stop()
 		}
 	})
 
-	it('starts the built executable, serves loopback traffic, terminates on SIGTERM, and releases its port', async () => {
+	it('announces readiness exactly once before the first response and releases on SIGTERM', async () => {
 		const port = await reserveLoopbackPort()
 		const application = startApplicationProcess(port)
 		try {
-			const response = await waitForApplicationResponse(application, port)
+			await application.ready
+			const announcement = \`[READY] \${APP_NAME} http://127.0.0.1:\${port}\\n\`
+			expect(application.output()).toBe(announcement)
+
+			const response = await fetch(\`http://127.0.0.1:\${port}\${APP_HEALTH_PATH}\`)
 			expect(response.status).toBe(200)
 			expect(await response.json()).toEqual({ name: APP_NAME, status: 'ok' })
+			expect(application.output().split('[READY]')).toHaveLength(2)
 
 			expect(application.child.kill('SIGTERM')).toBe(true)
 			const exited = await waitForApplicationProcess(application)
@@ -4904,10 +5198,8 @@ describe('ApplicationServer', () => {
 					: { code: 0, signal: null },
 			)
 
-			const released = createServer()
+			const released = await startLoopbackServer(port)
 			try {
-				released.listen(port, '127.0.0.1')
-				await once(released, 'listening')
 				expect(released.listening).toBe(true)
 			} finally {
 				await stopNodeServer(released)
@@ -4920,105 +5212,81 @@ describe('ApplicationServer', () => {
 		}
 	})
 
-	it('exits nonzero on a real executable port collision without disturbing the owner', async () => {
+	it('never announces readiness when a real bind fails', async () => {
 		const port = await reserveLoopbackPort()
-		const owner = createServer()
-		owner.listen(port, '127.0.0.1')
-		await once(owner, 'listening')
+		const owner = await startLoopbackServer(port)
 		const application = startApplicationProcess(port)
 		try {
 			const exited = await waitForApplicationProcess(application)
 			expect(exited).toEqual({ code: 1, signal: null })
 			expect(application.output()).toBe('[LIFECYCLE] Application server lifecycle failed\\n')
+			expect(application.output()).not.toContain('[READY]')
 			expect(application.output()).not.toContain('EADDRINUSE')
-			expect(application.output()).not.toContain('context')
-			expect(application.output()).not.toContain('cause')
-			expect(application.output()).not.toContain('at ')
 			expect(owner.listening).toBe(true)
 		} finally {
-			if (application.child.exitCode === null && application.child.signalCode === null) {
-				application.child.kill('SIGKILL')
-				await waitForApplicationProcess(application)
-			}
 			await stopNodeServer(owner)
 		}
 	})
 
-	it('redacts malformed environment values from executable diagnostics', async () => {
-		const secret = 'SENTINEL_SECRET/invalid'
-		const application = startApplicationProcess(0, { APP_HOST: secret })
-		const exited = await waitForApplicationProcess(application)
-		expect(exited).toEqual({ code: 1, signal: null })
-		expect(application.output()).toBe('[CONFIG] Application server configuration failed\\n')
-		expect(application.output()).not.toContain(secret)
-		expect(application.output()).not.toContain('context')
-		expect(application.output()).not.toContain('cause')
-		expect(application.output()).not.toContain('at ')
-	})
-
-	it('releases process listeners through explicit, repeated, convenience, and signal cleanup', async () => {
-		const signalCount = process.listenerCount('SIGTERM')
-		const interruptCount = process.listenerCount('SIGINT')
-		const runner = new ApplicationServerRunner({ host: '127.0.0.1', port: 0 })
-		try {
-			expect(runner.start()).toBeUndefined()
-			expect(runner.start()).toBeUndefined()
-			expect(process.listenerCount('SIGTERM')).toBe(signalCount + 1)
-			expect(process.listenerCount('SIGINT')).toBe(interruptCount + 1)
-
-			await runner.stop()
-			await runner.stop()
-			expect(process.listenerCount('SIGTERM')).toBe(signalCount)
-			expect(process.listenerCount('SIGINT')).toBe(interruptCount)
-
-			const convenience = startApplicationServer({ host: '127.0.0.1', port: 0 })
-			expect(process.listenerCount('SIGTERM')).toBe(signalCount + 1)
-			expect(process.listenerCount('SIGINT')).toBe(interruptCount + 1)
-			await convenience.stop()
-			expect(process.listenerCount('SIGTERM')).toBe(signalCount)
-			expect(process.listenerCount('SIGINT')).toBe(interruptCount)
-
-			runner.start()
-			expect(process.listenerCount('SIGTERM')).toBe(signalCount + 1)
-			expect(process.listenerCount('SIGINT')).toBe(interruptCount + 1)
-			process.emit('SIGTERM')
-			await runner.stop()
-			expect(process.listenerCount('SIGTERM')).toBe(signalCount)
-			expect(process.listenerCount('SIGINT')).toBe(interruptCount)
-		} finally {
-			await runner.stop()
-		}
-	})
-
-	it('keeps a newer runner generation owned when an older start fails during restart', async () => {
-		const signalCount = process.listenerCount('SIGTERM')
-		const interruptCount = process.listenerCount('SIGINT')
-		const previousExitCode = process.exitCode
+	it('isolates a throwing fail listener, releases ownership, and starts again', async () => {
 		const port = await reserveLoopbackPort()
-		const owner = createServer()
-		owner.listen(port, '127.0.0.1')
-		await once(owner, 'listening')
-		const runner = new ApplicationServerRunner({ host: '127.0.0.1', port })
+		const owner = await startLoopbackServer(port)
+		const interrupts = process.listenerCount('SIGINT')
+		const terminations = process.listenerCount('SIGTERM')
+		// The reporter owns the process exit code, so this in-process failure records the
+		// code it set and then restores whatever the surrounding run had.
+		const code = process.exitCode
+		const errors = createRecorder<[error: unknown, event: string]>()
+		const server = createApplicationServer({ server: { host: '127.0.0.1', port } })
+		const runner = new ApplicationServerRunner(server, {
+			on: {
+				fail: () => {
+					throw new Error('listener boom')
+				},
+			},
+			error: errors.handler,
+		})
 		try {
+			process.exitCode = undefined
+			const failed = waitForEvent(runner.emitter, 'fail')
 			runner.start()
-			await Promise.resolve()
-			const stopping = runner.stop()
-			runner.start()
-			await stopNodeServer(owner)
-			await stopping
+			expect(process.listenerCount('SIGINT')).toBe(interrupts + 1)
+			expect(process.listenerCount('SIGTERM')).toBe(terminations + 1)
 
-			const response = await waitForLoopbackResponse(port)
+			const [failure] = await failed
+			expect(failure).toEqual(expect.objectContaining({ code: 'LIFECYCLE' }))
+			expect(errors.count).toBe(1)
+			expect(errors.calls[0]?.[1]).toBe('fail')
+			expect(process.listenerCount('SIGINT')).toBe(interrupts)
+			expect(process.listenerCount('SIGTERM')).toBe(terminations)
+			expect(process.exitCode).toBe(1)
+
+			await stopNodeServer(owner)
+			const ready = waitForEvent(runner.emitter, 'ready')
+			runner.start()
+			const [url] = await ready
+			const response = await fetch(\`\${url}\${APP_HEALTH_PATH}\`)
 			expect(response.status).toBe(200)
-			expect(process.exitCode).toBe(previousExitCode)
-			expect(process.listenerCount('SIGTERM')).toBe(signalCount + 1)
-			expect(process.listenerCount('SIGINT')).toBe(interruptCount + 1)
 		} finally {
+			process.exitCode = code
 			await runner.stop()
 			await stopNodeServer(owner)
-			process.exitCode = previousExitCode
 		}
 	})
-})
+
+	it('redacts malformed environment values from executable diagnostics', async () => {
+		const secret = 'SENTINEL_SECRET/invalid'
+		const application = startApplicationProcess(0, { APP_HOST: secret })
+		const exited = await waitForApplicationProcess(application)
+		expect(exited).toEqual({ code: 1, signal: null })
+		expect(application.output()).toBe('[CONFIG] Application server configuration failed\\n')
+		expect(application.output()).not.toContain(secret)
+		expect(application.output()).not.toContain('[READY]')
+		expect(application.output()).not.toContain('context')
+		expect(application.output()).not.toContain('cause')
+		expect(application.output()).not.toContain('at ')
+	})
+}){{boundary}}
 `
 	}),
 	appServerParsersTest: Object.freeze({
@@ -5042,6 +5310,7 @@ import { describe, expect, it } from 'vitest'
 
 describe('application environment parsers', () => {
 	it('accepts port boundaries and trims a host', () => {
+		expect(parseApplicationPort(3000)).toBe(3000)
 		expect(parseApplicationPort('0')).toBe(0)
 		expect(parseApplicationPort('65535')).toBe(65_535)
 		expect(parseApplicationPort(' 3000 ')).toBe(3000)
@@ -5053,6 +5322,19 @@ describe('application environment parsers', () => {
 		expect(parseApplicationStartTimeout(String(MAX_APP_START_TIMEOUT))).toBe(MAX_APP_START_TIMEOUT)
 	})
 
+	it('never coerces hostile numeric objects through toString', () => {
+		let calls = 0
+		const hostile = {
+			toString() {
+				calls += 1
+				return '3000'
+			},
+		}
+
+		expect(() => parseApplicationPort(hostile)).toThrow(ApplicationServerError)
+		expect(calls).toBe(0)
+	})
+
 	it.each(['', '-1', '65536', '1.5', '+1', '0x10', '1e3', 'NaN', 'Infinity'])(
 		'rejects hostile APP_PORT value %s',
 		(value) => {
@@ -5094,7 +5376,15 @@ describe('application environment parsers', () => {
 		expect(() => parseApplicationHost(value)).toThrow(expect.objectContaining({ code: 'CONFIG' }))
 	})
 
-	it.each([null, 42, [], { port: [42] }, { timeout: 0 }])(
+	it('parses the exact grouped server record including its timeout leaf', () => {
+		expect(
+			parseApplicationServerOptions({
+				server: { host: ' 127.0.0.1 ', port: 0, timeout: 250 },
+			}),
+		).toEqual({ server: { host: '127.0.0.1', port: 0, timeout: 250 } })
+	})
+
+	it.each([null, 42, [], { server: null }, { server: { port: [42] } }, { server: { timeout: 0 } }])(
 		'rejects hostile option container or leaf value %#',
 		(value) => {
 			expect(() => parseApplicationServerOptions(value)).toThrow(
@@ -5104,11 +5394,14 @@ describe('application environment parsers', () => {
 	)
 
 	it.each([
-		Object.create({ host: '0.0.0.0' }),
+		Object.create({ server: { host: '0.0.0.0' } }),
 		{ post: 0 },
 		new Date(),
-		{ [Symbol('host')]: '0.0.0.0' },
-		Object.defineProperty({}, 'host', { get: () => '0.0.0.0' }),
+		{ server: Object.create({ host: '0.0.0.0' }) },
+		{ server: { post: 0 } },
+		{ server: { [Symbol('host')]: '0.0.0.0' } },
+		Object.defineProperty({}, 'server', { get: () => ({ host: '0.0.0.0' }) }),
+		{ server: Object.defineProperty({}, 'host', { get: () => '0.0.0.0' }) },
 		new Proxy(
 			{},
 			{
@@ -5117,6 +5410,16 @@ describe('application environment parsers', () => {
 				},
 			},
 		),
+		{
+			server: new Proxy(
+				{},
+				{
+					ownKeys: () => {
+						throw new Error('hostile nested ownKeys trap')
+					},
+				},
+			),
+		},
 	])(
 		'rejects inherited, unknown, symbolic, accessor, instance, and hostile proxy options %#',
 		(value) => {
@@ -5126,6 +5429,19 @@ describe('application environment parsers', () => {
 		},
 	)
 
+	it('does not invoke grouped option accessors', () => {
+		let reads = 0
+		const server = Object.defineProperty({}, 'timeout', {
+			get() {
+				reads += 1
+				return 250
+			},
+		})
+
+		expect(() => parseApplicationServerOptions({ server })).toThrow(ApplicationServerError)
+		expect(reads).toBe(0)
+	})
+
 	it('never reflects a hostile symbolic option name into diagnostics', () => {
 		let caught: unknown
 		try {
@@ -5175,9 +5491,7 @@ ${IMPORT_KEYWORD} { createSource, parseManifest } from '@orkestrel/guide'
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} GUIDE_ROOT = fileURLToPath(new URL('../', import.meta.url))
 
 /** Repository roots whose TypeScript and Markdown files participate in guide parity. */
-${EXPORT_KEYWORD} ${CONST_KEYWORD} GUIDE_WALK_DIRECTORIES: readonly string[] = Object.freeze([
-{{walkDirs}}
-])
+${EXPORT_KEYWORD} ${CONST_KEYWORD} GUIDE_WALK_DIRECTORIES: readonly string[] = Object.freeze({{walkDirs}})
 
 {{specifiers}}
 
@@ -5569,7 +5883,9 @@ function devDependenciesFor(spec) {
 	return {
 		...dependencies,
 		...spec.src.includes("browser") ? SOURCE_BROWSER_DEV_DEPENDENCIES : {},
+		...spec.app.length > 0 ? APP_DEV_DEPENDENCIES : {},
 		...spec.app.includes("browser") ? APP_BROWSER_DEV_DEPENDENCIES : {},
+		...spec.app.includes("server") ? APP_SERVER_DEV_DEPENDENCIES : {},
 		...spec.showcase ? { "vite-plugin-singlefile": "^2.3.3" } : {},
 		...spec.bin ? { "@vitest/browser-playwright": SOURCE_BROWSER_DEV_DEPENDENCIES["@vitest/browser-playwright"] } : {}
 	};
@@ -5624,6 +5940,7 @@ function packageManifest(spec) {
 		...hasSource || spec.bin ? ["npm run test:src"] : [],
 		...spec.app.length > 0 ? ["npm run test:app"] : [],
 		"npm run test:policy",
+		"npm run test:config",
 		"npm run test:guides"
 	].join(" && ");
 	if (hasSource || spec.bin) {
@@ -5639,6 +5956,7 @@ function packageManifest(spec) {
 		for (const environment of spec.app) scripts[`test:app:${environment}`] = `vitest run --config vite.config.ts --no-cache --reporter=dot --project ${APP_MATRIX[environment].project}`;
 	}
 	scripts["test:policy"] = "vitest run --config vite.config.ts --no-cache --reporter=dot --project policy";
+	scripts["test:config"] = "vitest run --config vite.config.ts --no-cache --reporter=dot --project config";
 	scripts["test:guides"] = "vitest run --config vite.config.ts --reporter=dot --project guides";
 	scripts.build = [
 		"npm run clean",
@@ -5659,7 +5977,7 @@ function packageManifest(spec) {
 			if (spec.showcase) {
 				scripts.showcase = `vite --config ${SHOWCASE_CONFIG_PATH}`;
 				scripts["build:showcase"] = `vite build --config ${SHOWCASE_CONFIG_PATH}`;
-				scripts.show = "npm run build:showcase && npm run copy dist/showcase/index.html demo/showcase.html";
+				scripts.show = "npm run format && npm run build:showcase && npm run copy dist/showcase/index.html demo/showcase.html";
 			}
 		}
 		if (spec.app.includes("server")) {
@@ -5809,7 +6127,7 @@ function viteMachinery(src, app = [], bin = false, showcase = false) {
 * @example
 * ```ts
 * viteProjectRegistrations(['core'], [], { integration: true })
-* // [{ project: 'srcCore' }, { project: 'policy' }, { project: 'guides' }, { project: 'integration' }]
+* // [{ project: 'srcCore' }, { project: 'policy' }, { project: 'config' }, { project: 'guides' }, { project: 'integration' }]
 * ```
 */
 function viteProjectRegistrations(src, app = [], facts = {}) {
@@ -5832,7 +6150,7 @@ function viteProjectRegistrations(src, app = [], facts = {}) {
 		});
 		if (environment === "server") registrations.push({ project: "appServer" });
 	}
-	registrations.push({ project: "policy" }, { project: "guides" });
+	registrations.push({ project: "policy" }, { project: "config" }, { project: "guides" });
 	if (facts.bin === true) registrations.push({ project: "srcBin" });
 	if (facts.integration === true) registrations.push({ project: "integration" });
 	if (facts.service === true) registrations.push({ project: "service" });
@@ -5842,7 +6160,7 @@ function viteProjectRegistrations(src, app = [], facts = {}) {
 * Render the one ordered proof and structural-axis project definition block.
 *
 * @param facts - Optional structural facts.
-* @returns Policy, guides, then selected axis project definitions, separated by one blank line.
+* @returns Policy, config, guides, then selected axis project definitions, separated by one blank line.
 *
 * @example
 * ```ts
@@ -5850,7 +6168,11 @@ function viteProjectRegistrations(src, app = [], facts = {}) {
 * ```
 */
 function viteProjectDefinitions(facts = {}) {
-	const definitions = [policyViteProject(), guidesViteProject()];
+	const definitions = [
+		policyViteProject(),
+		configViteProject(),
+		guidesViteProject()
+	];
 	if (facts.bin === true) definitions.push(binViteProject());
 	if (facts.integration === true) definitions.push(integrationViteProject(facts));
 	if (facts.service === true) definitions.push(serviceViteProject());
@@ -5916,9 +6238,11 @@ import { chromium } from 'playwright'
 ` : "";
 	const vueImports = needsVue ? `import vue from '@vitejs/plugin-vue'
 import { parse as parseVue } from 'vue/compiler-sfc'
+import { parseStartTag } from '@orkestrel/html'
 ` : "";
 	const showcaseImports = needsShowcase ? `import { viteSingleFile } from 'vite-plugin-singlefile'
 ` : "";
+	const showcaseHashImport = needsShowcase ? "import { createHash } from 'node:crypto'\n" : "";
 	const viteTypeImports = needsVue ? `import type {
 	CSSOptions,
 	HtmlAssetSource,
@@ -6880,12 +7204,40 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} HTML_SECURITY_POLICY =
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} HTML_SECURITY_META =
 	'<meta\\n\\t\\t\\thttp-equiv="Content-Security-Policy"\\n\\t\\t\\tcontent="' +
 	HTML_SECURITY_POLICY +
+	'"\\n\\t\\t/>'${needsShowcase ? `
+${EXPORT_KEYWORD} ${CONST_KEYWORD} SHOWCASE_SECURITY_POLICY =
+	"default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'self'; style-src 'unsafe-inline'; img-src data:; font-src data:; script-src-attr 'none'"
+${EXPORT_KEYWORD} ${CONST_KEYWORD} SHOWCASE_SECURITY_META =
+	'<meta\\n\\t\\t\\thttp-equiv="Content-Security-Policy"\\n\\t\\t\\tcontent="' +
+	SHOWCASE_SECURITY_POLICY +
+	'"\\n\\t\\t/>'
+${EXPORT_KEYWORD} ${CONST_KEYWORD} SHOWCASE_BUILD_SECURITY_POLICY =
+	"default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; font-src data:; script-src-attr 'none'"
+${EXPORT_KEYWORD} ${CONST_KEYWORD} SHOWCASE_BUILD_SECURITY_META =
+	'<meta\\n\\t\\t\\thttp-equiv="Content-Security-Policy"\\n\\t\\t\\tcontent="' +
+	SHOWCASE_BUILD_SECURITY_POLICY +
 	'"\\n\\t\\t/>'
-${EXPORT_KEYWORD} ${CONST_KEYWORD} HTML_SECURITY_PREFIX =
-	'<!doctype html>\\n<html lang="en">\\n\\t<head>\\n\\t\\t' + HTML_SECURITY_META + '\\n'
+` : ""}
+
+${EXPORT_KEYWORD} function hasSecurityPrologue(html: string, security: string): boolean {
+	const normalized = html.replaceAll('\\r\\n', '\\n')
+	const doctype = '<!doctype html>\\n'
+	if (!normalized.startsWith(doctype)) return false
+	const root = parseStartTag(normalized, doctype.length)
+	return (
+		root !== undefined &&
+		root.name === 'html' &&
+		!root.slashed &&
+		normalized.startsWith('\\n\\t<head>\\n\\t\\t' + security + '\\n', root.next)
+	)
+}
 
-${EXPORT_KEYWORD} function maskIgnoredHtml(environmentKeys: ReadonlySet<string>, html: string): string {
-	if (!html.replaceAll('\\r\\n', '\\n').startsWith(HTML_SECURITY_PREFIX)) {
+${EXPORT_KEYWORD} function maskIgnoredHtml(
+	environmentKeys: ReadonlySet<string>,
+	html: string,
+	security: string,
+): string {
+	if (!hasSecurityPrologue(html, security)) {
 		throw new Error(
 			'[orkestrel-environment-boundary] Browser HTML must preserve the generated security prologue',
 		)
@@ -6919,12 +7271,27 @@ ${EXPORT_KEYWORD} function maskIgnoredHtml(environmentKeys: ReadonlySet<string>,
 	)
 }
 
-${EXPORT_KEYWORD} function isBrowserHtmlEntry(filename: string): boolean {
+${needsShowcase ? `${EXPORT_KEYWORD} function isShowcaseHtmlEntry(filename: string): boolean {
 	return (
-		physicalPath(filename) === physicalPath(resolvePath(WORKSPACE_ROOT, 'app/browser/index.html'))
+		physicalPath(filename) ===
+		physicalPath(resolvePath(WORKSPACE_ROOT, 'app/browser/showcase.html'))
 	)
 }
 
+` : ""}${EXPORT_KEYWORD} function isBrowserHtmlEntry(filename: string): boolean {
+	${needsShowcase ? `return (
+		isShowcaseHtmlEntry(filename) ||
+		physicalPath(filename) === physicalPath(resolvePath(WORKSPACE_ROOT, 'app/browser/index.html'))
+	)` : `return (
+		physicalPath(filename) === physicalPath(resolvePath(WORKSPACE_ROOT, 'app/browser/index.html'))
+	)`}
+}${needsShowcase ? `
+${EXPORT_KEYWORD} function browserHtmlSecurityMeta(filename: string, built: boolean): string | undefined {
+	if (!isBrowserHtmlEntry(filename)) return undefined
+	if (!isShowcaseHtmlEntry(filename)) return HTML_SECURITY_META
+	return built ? SHOWCASE_BUILD_SECURITY_META : SHOWCASE_SECURITY_META
+}` : ""}
+
 ${EXPORT_KEYWORD} function prepareHtml(): Plugin {
 	const environmentKeys = new Set<string>()
 	return {
@@ -6941,8 +7308,10 @@ ${EXPORT_KEYWORD} function prepareHtml(): Plugin {
 		transformIndexHtml: {
 			order: 'pre',
 			handler(html, context) {
-				if (!isBrowserHtmlEntry(context.filename)) return undefined
-				return maskIgnoredHtml(environmentKeys, html)
+				${needsShowcase ? `const security = browserHtmlSecurityMeta(context.filename, false)
+				if (security === undefined) return undefined
+				return maskIgnoredHtml(environmentKeys, html, security)` : `if (!isBrowserHtmlEntry(context.filename)) return undefined
+				return maskIgnoredHtml(environmentKeys, html, HTML_SECURITY_META)`}
 			},
 		},
 	}
@@ -6966,8 +7335,13 @@ ${EXPORT_KEYWORD} function finalizeHtml(): Plugin {
 		transformIndexHtml: {
 			order: 'post',
 			handler(html, context) {
-				if (!isBrowserHtmlEntry(context.filename)) return undefined
-				if (!html.includes(HTML_SECURITY_META)) {
+				${needsShowcase ? `const security = browserHtmlSecurityMeta(
+					context.filename,
+					context.bundle !== undefined,
+				)
+				if (security === undefined) return undefined
+				if (!html.includes(security)) {` : `if (!isBrowserHtmlEntry(context.filename)) return undefined
+				if (!html.includes(HTML_SECURITY_META)) {`}
 					throw new Error(
 						'[orkestrel-environment-boundary] Browser HTML must retain its security policy',
 					)
@@ -6977,26 +7351,49 @@ ${EXPORT_KEYWORD} function finalizeHtml(): Plugin {
 	}
 }
 
-` : ""}${needsShowcase ? `${EXPORT_KEYWORD} ${CONST_KEYWORD} SHOWCASE_SECURITY_POLICY =
-	"base-uri 'none'; object-src 'none'; script-src 'self' 'unsafe-inline'; script-src-attr 'none'; style-src 'self' 'unsafe-inline'"
-
-${EXPORT_KEYWORD} function showcaseHtml(): Plugin {
+` : ""}${needsShowcase ? `${EXPORT_KEYWORD} function showcaseHtml(): Plugin {
 	return {
 		name: 'orkestrel-showcase-html',
-		enforce: 'post',
 		transformIndexHtml: {
 			order: 'post',
 			handler(html, context) {
-				if (!isBrowserHtmlEntry(context.filename)) return undefined
-				if (!html.includes(HTML_SECURITY_META)) {
-					throw new Error('[orkestrel-showcase] Browser HTML must retain its security policy')
+				if (!isShowcaseHtmlEntry(context.filename) || context.bundle === undefined) {
+					return undefined
+				}
+				if (!html.includes(SHOWCASE_SECURITY_META)) {
+					throw new Error(
+						'[orkestrel-showcase-html] Showcase build did not retain its development security policy',
+					)
+				}
+				const secured = html.replace(SHOWCASE_SECURITY_META, SHOWCASE_BUILD_SECURITY_META)
+				const build = createHash('sha256').update(secured).digest('hex')
+				return {
+					html: secured,
+					tags: [
+						{
+							tag: 'meta',
+							attrs: { name: 'build-id', content: build },
+							injectTo: 'head',
+						},
+					],
 				}
-				const stamp = new Date().toISOString()
-				return html.replace(
-					HTML_SECURITY_META,
-					HTML_SECURITY_META.replace(HTML_SECURITY_POLICY, SHOWCASE_SECURITY_POLICY) +
-						\`\\n\\t\\t<meta name="build-id" content="\${stamp}" />\`,
-				)
+			},
+		},
+		generateBundle: {
+			order: 'post',
+			handler(_options, bundle) {
+				let html: (typeof bundle)[string] | undefined
+				for (const output of Object.values(bundle)) {
+					if (!output.fileName.endsWith('.html')) continue
+					if (html !== undefined) {
+						this.error('[orkestrel-showcase-html] Showcase build emitted multiple HTML entries')
+					}
+					html = output
+				}
+				if (html === undefined) {
+					this.error('[orkestrel-showcase-html] Showcase build did not emit an HTML entry')
+				}
+				html.fileName = 'index.html'
 			},
 		},
 	}
@@ -7293,7 +7690,7 @@ ${needsBrowser ? `import { isCSSRequest, parseSync, preprocessCSS, transformWith
 `}import { defineConfig, mergeConfig } from 'vitest/config'
 import tsconfig from './tsconfig.json' with { type: 'json' }
 import { fileURLToPath, URL } from 'node:url'
-import { isBuiltin } from 'node:module'
+${showcaseHashImport}import { isBuiltin } from 'node:module'
 import {
 ${needsBrowser ? "	accessSync,\n" : ""}	closeSync,
 	constants as FS_CONSTANTS,
@@ -7616,7 +8013,7 @@ ${environmentBoundary}`;
 * ```
 */
 function policyViteProject() {
-	return `${EXPORT_KEYWORD} const policy = (config?: UserConfig): UserConfig =>
+	return `${EXPORT_KEYWORD} const policy = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -7628,7 +8025,34 @@ function policyViteProject() {
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
+	)
+`;
+}
+/**
+* Build the standalone Node-only root-configuration Vitest project.
+*
+* @returns The emitted `config` project definition.
+*
+* @example
+* ```ts
+* configViteProject().includes("label: 'config'") // true
+* ```
+*/
+function configViteProject() {
+	return `${EXPORT_KEYWORD} 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 },
+			},
+		},
+		options ?? {},
 	)
 `;
 }
@@ -7643,7 +8067,7 @@ function policyViteProject() {
 * ```
 */
 function guidesViteProject() {
-	return `${EXPORT_KEYWORD} const guides = (config?: UserConfig): UserConfig =>
+	return `${EXPORT_KEYWORD} const guides = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -7656,7 +8080,7 @@ function guidesViteProject() {
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `;
 }
@@ -7671,7 +8095,7 @@ function guidesViteProject() {
 * ```
 */
 function binViteProject() {
-	return `${EXPORT_KEYWORD} const srcBin = (config?: UserConfig): UserConfig =>
+	return `${EXPORT_KEYWORD} const srcBin = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -7698,7 +8122,7 @@ function binViteProject() {
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `;
 }
@@ -7716,7 +8140,7 @@ function binViteProject() {
 * ```
 */
 function integrationViteProject(facts = {}) {
-	return `${EXPORT_KEYWORD} const integration = (config?: UserConfig): UserConfig =>
+	return `${EXPORT_KEYWORD} const integration = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -7733,7 +8157,7 @@ ${facts.bin === true && facts.integration === true && facts.global === true ? `
 				fileParallelism: false,
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `;
 }
@@ -7748,7 +8172,7 @@ ${facts.bin === true && facts.integration === true && facts.global === true ? `
 * ```
 */
 function serviceViteProject() {
-	return `${EXPORT_KEYWORD} const service = (config?: UserConfig): UserConfig =>
+	return `${EXPORT_KEYWORD} const service = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -7763,7 +8187,7 @@ function serviceViteProject() {
 				fileParallelism: false,
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `;
 }
@@ -7790,7 +8214,7 @@ function singleSrcViteConfig(environment, facts = {}) {
 	const renderedTest = renderViteTest(viteProjectRegistrations([environment], [], facts), machinery.browser);
 	const definitions = viteProjectDefinitions(facts);
 	if (environment === "browser") return `${header}
-${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcBrowser = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -7815,7 +8239,7 @@ ${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
 				name: { label: 'src:browser', color: 'yellow' },
 				include: ['tests/src/browser/**/*.test.ts'],
 				${facts.global === true ? `globalSetup: ['./${GLOBAL_SETUP_PATH}'],\n\t\t\t\t` : ""}setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
-				...(config?.test?.browser?.enabled === false
+				...(options?.test?.browser?.enabled === false
 					? {}
 					: {
 							deps: {
@@ -7835,7 +8259,7 @@ ${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
 				fileParallelism: false,
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 
 ${definitions}
@@ -7845,7 +8269,7 @@ ${renderedTest}
 })
 `;
 	return `${header}
-${EXPORT_KEYWORD} const srcServer = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcServer = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -7875,7 +8299,7 @@ ${EXPORT_KEYWORD} const srcServer = (config?: UserConfig): UserConfig =>
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 
 ${definitions}
@@ -7924,7 +8348,7 @@ function rootViteConfig(src, facts = {}) {
 		if (onlyEnvironment === "browser" || onlyEnvironment === "server") return singleSrcViteConfig(onlyEnvironment, facts);
 	}
 	const browserBlock = `
-${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcBrowser = (options?: UserConfig): UserConfig =>
 	srcCore(
 		mergeConfig(
 			{
@@ -7948,7 +8372,7 @@ ${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
 					include: ['tests/src/browser/**/*.test.ts'],
 					exclude: ['tests/src/core/**/*.test.ts'],
 					${facts.global === true ? `globalSetup: ['./${GLOBAL_SETUP_PATH}'],\n\t\t\t\t\t` : ""}setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
-					...(config?.test?.browser?.enabled === false
+					...(options?.test?.browser?.enabled === false
 						? {}
 						: {
 								deps: {
@@ -7968,12 +8392,12 @@ ${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
 					fileParallelism: false,
 				},
 			},
-			config ?? {},
+			options ?? {},
 		),
 	)
 `;
 	const serverBlock = `
-${EXPORT_KEYWORD} const srcServer = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcServer = (options?: UserConfig): UserConfig =>
 	srcCore(
 		mergeConfig(
 			{
@@ -8011,14 +8435,14 @@ ${EXPORT_KEYWORD} const srcServer = (config?: UserConfig): UserConfig =>
 					setupFiles: ['./tests/setup.ts', './tests/setupServer.ts'],
 				},
 			},
-			config ?? {},
+			options ?? {},
 		),
 	)
 `;
 	const blocks = nonCore.map((environment) => environment === "browser" ? browserBlock : serverBlock).join("");
 	const renderedTest = renderViteTest(viteProjectRegistrations(src, [], facts), machinery.browser);
 	return `${header}
-${EXPORT_KEYWORD} const srcCore = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcCore = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -8036,7 +8460,7 @@ ${EXPORT_KEYWORD} const srcCore = (config?: UserConfig): UserConfig =>
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 ${blocks}
 ${viteProjectDefinitions(facts)}
@@ -8066,7 +8490,7 @@ function applicationViteConfig(src, app, facts = {}) {
 	const header = viteHeader(machinery);
 	const blocks = [];
 	if (src.includes("core")) blocks.push(`
-${EXPORT_KEYWORD} const srcCore = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcCore = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -8081,7 +8505,7 @@ ${EXPORT_KEYWORD} const srcCore = (config?: UserConfig): UserConfig =>
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `);
 	if (src.includes("browser")) {
@@ -8089,7 +8513,7 @@ ${EXPORT_KEYWORD} const srcCore = (config?: UserConfig): UserConfig =>
 					output: { paths: { '@src/core': '../core/index.js' } },` : "";
 		const coreExternal = hasSourceCore ? `id === '@src/core' || ` : "";
 		blocks.push(`
-${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcBrowser = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -8114,7 +8538,7 @@ ${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
 				name: { label: 'src:browser', color: 'yellow' },
 				include: ['tests/src/browser/**/*.test.ts'],
 				${hasSourceCore ? "exclude: ['tests/src/core/**/*.test.ts'],\n				" : ""}${facts.global === true ? `globalSetup: ['./${GLOBAL_SETUP_PATH}'],\n\t\t\t\t` : ""}setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
-				...(config?.test?.browser?.enabled === false
+				...(options?.test?.browser?.enabled === false
 					? {}
 					: {
 							deps: {
@@ -8134,7 +8558,7 @@ ${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
 				fileParallelism: false,
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `);
 	}
@@ -8155,7 +8579,7 @@ ${EXPORT_KEYWORD} const srcBrowser = (config?: UserConfig): UserConfig =>
 		const coreExternal = hasSourceCore ? `id === '@src/core' || ` : "";
 		const formats = hasSourceCore ? "" : "\n					formats: ['es', 'cjs'],";
 		blocks.push(`
-${EXPORT_KEYWORD} const srcServer = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const srcServer = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -8185,12 +8609,12 @@ ${EXPORT_KEYWORD} const srcServer = (config?: UserConfig): UserConfig =>
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `);
 	}
 	if (app.includes("core")) blocks.push(`
-${EXPORT_KEYWORD} const appCore = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const appCore = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -8204,32 +8628,27 @@ ${EXPORT_KEYWORD} const appCore = (config?: UserConfig): UserConfig =>
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `);
 	if (app.includes("browser")) blocks.push(facts.showcase === true ? `
-${FUNCTION_KEYWORD} applicationBrowser(showcase: boolean): UserConfig {
-	const output = showcase ? 'dist/showcase' : 'dist/app/browser'
+${EXPORT_KEYWORD} function appBrowser(...config: never[]): UserConfig {
+	if (config.length > 0) {
+		throw new Error(
+			'[orkestrel-environment-boundary] Browser configuration overrides are not permitted by the generated boundary',
+		)
+	}
 	return {
 		resolve,
 		css: ENVIRONMENT_CSS,
 		html: environmentHtml(),
 		plugins: [
 			restoreHtml(),
-			outputBoundary(output),
+			outputBoundary('dist/app/browser'),
 			environmentBoundary('app/browser'),
 			vue(),
 			prepareHtml(),
 			finalizeHtml(),
-			...(showcase
-				? [
-						viteSingleFile({
-							removeViteModuleLoader: true,
-							useRecommendedBuildConfig: true,
-						}),
-						showcaseHtml(),
-					]
-				: []),
 		],
 		root: resolveWorkspacePath('app/browser'),
 		publicDir: false,
@@ -8240,18 +8659,9 @@ ${FUNCTION_KEYWORD} applicationBrowser(showcase: boolean): UserConfig {
 			},
 		},
 		build: {
-			...(showcase
-				? {
-						cssMinify: 'lightningcss',
-						minify: 'oxc',
-						modulePreload: false,
-						reportCompressedSize: false,
-						sourcemap: false,
-						target: 'esnext',
-					}
-				: { assetsInlineLimit: 0 }),
+			assetsInlineLimit: 0,
 			emptyOutDir: true,
-			outDir: resolveWorkspacePath(output),
+			outDir: resolveWorkspacePath('dist/app/browser'),
 			rolldownOptions: {
 				input: resolveWorkspacePath('${APP_MATRIX.browser.entry}'),
 			},
@@ -8280,22 +8690,54 @@ ${FUNCTION_KEYWORD} applicationBrowser(showcase: boolean): UserConfig {
 	}
 }
 
-${EXPORT_KEYWORD} function appBrowser(...config: never[]): UserConfig {
-	if (config.length > 0) {
-		throw new Error(
-			'[orkestrel-environment-boundary] Browser configuration overrides are not permitted by the generated boundary',
-		)
-	}
-	return applicationBrowser(false)
-}
-
 ${EXPORT_KEYWORD} function appShowcase(...config: never[]): UserConfig {
 	if (config.length > 0) {
 		throw new Error(
 			'[orkestrel-environment-boundary] Showcase configuration overrides are not permitted by the generated boundary',
 		)
 	}
-	return applicationBrowser(true)
+	return {
+		base: './',
+		resolve,
+		css: ENVIRONMENT_CSS,
+		html: environmentHtml(),
+		plugins: [
+			restoreHtml(),
+			outputBoundary('dist/showcase'),
+			environmentBoundary('app/browser'),
+			vue(),
+			prepareHtml(),
+			showcaseHtml(),
+			viteSingleFile({
+				removeViteModuleLoader: true,
+				useRecommendedBuildConfig: true,
+			}),
+			finalizeHtml(),
+		],
+		root: resolveWorkspacePath('app/browser'),
+		publicDir: false,
+		server: {
+			open: '/showcase.html',
+			fs: {
+				strict: true,
+				allow: [...browserServerRoots()],
+			},
+		},
+		build: {
+			assetsInlineLimit: Number.MAX_SAFE_INTEGER,
+			cssMinify: 'lightningcss',
+			emptyOutDir: true,
+			minify: 'oxc',
+			modulePreload: false,
+			outDir: resolveWorkspacePath('dist/showcase'),
+			reportCompressedSize: false,
+			rolldownOptions: {
+				input: resolveWorkspacePath('app/browser/showcase.html'),
+			},
+			sourcemap: false,
+			target: 'esnext',
+		},
+	}
 }
 ` : `
 ${EXPORT_KEYWORD} function appBrowser(...config: never[]): UserConfig {
@@ -8357,7 +8799,7 @@ ${EXPORT_KEYWORD} function appBrowser(...config: never[]): UserConfig {
 }
 `);
 	if (app.includes("server")) blocks.push(`
-${EXPORT_KEYWORD} const appServer = (config?: UserConfig): UserConfig =>
+${EXPORT_KEYWORD} const appServer = (options?: UserConfig): UserConfig =>
 	mergeConfig(
 		{
 			resolve,
@@ -8384,7 +8826,7 @@ ${EXPORT_KEYWORD} const appServer = (config?: UserConfig): UserConfig =>
 				browser: { enabled: false },
 			},
 		},
-		config ?? {},
+		options ?? {},
 	)
 `);
 	const renderedTest = renderViteTest(viteProjectRegistrations(src, app, facts), machinery.browser);
@@ -8619,6 +9061,8 @@ function appTsconfig(environment, hasCore) {
 	const include = TYPESCRIPT_EXTENSIONS.map((extension) => `../../app/${environment}/**/*.${extension}`);
 	if (environment === "browser") include.push(`../../app/${environment}/**/*.vue`);
 	if (environment !== "core" && hasCore) include.push(...TYPESCRIPT_EXTENSIONS.map((extension) => `../../app/core/**/*.${extension}`));
+	include.push(...TYPESCRIPT_EXTENSIONS.map((extension) => `../../tests/app/${environment}/**/*.${extension}`));
+	include.push(environment === "browser" ? "../../tests/setupBrowser.ts" : environment === "server" ? "../../tests/setupServer.ts" : "../../tests/setup.ts");
 	return formatJson({
 		extends: "../../tsconfig.json",
 		compilerOptions: {
@@ -8799,7 +9243,7 @@ export default defineConfig(appShowcase())
 * factory per environment (AGENTS §5's per-environment centralized-file pattern), so
 * every environment gets the same uniform stub shape.
 *
-* @param spec - The `Blueprint` to derive source stubs from.
+* @param spec - The blueprint carrying the declared source environment set.
 * @param pascal - The package's PascalCase entity name.
 * @returns The `source` group's `Artifact[]`.
 *
@@ -8832,20 +9276,129 @@ function sourceArtifacts(spec, pascal) {
 * Draft the application source artifacts for every selected app environment.
 *
 * @param spec - The blueprint carrying the application environment set.
+* @remarks
+* Two conditional shapes layer over the per-environment set. The health contract —
+* record, route constants, guard, and the one unknown-to-typed read — is declared by
+* `app/server` while the server alone reads it and RELOCATES to `app/core` the moment
+* the browser reads it too, because a contract two hosts share belongs to neither of
+* them. The showcase entry pair, its seeder, and its factory appear only for a
+* blueprint that declares the physical showcase wrapper alongside `app/browser`.
 * @returns Complete, runnable app/core, app/browser, and app/server artifacts.
 */
 function applicationArtifacts(spec) {
 	const artifacts = [];
 	const hasCore = spec.app.includes("core");
+	const hasBrowser = spec.app.includes("browser");
+	const hasBoundary = hasApplicationBoundary(spec);
+	const hasShowcase = hasApplicationShowcase(spec);
+	const showcaseSource = hasBoundary ? "its running server" : "its own configuration";
 	const nameLiteral = serializeTypeScriptString(spec.name);
-	if (hasCore) artifacts.push(fillArtifact("app/core/types.ts", "source", "appCoreTypes", {}, "core"), fillArtifact("app/core/constants.ts", "source", "appCoreConstants", { nameLiteral }, "core"), fillArtifact("app/core/errors.ts", "source", "appCoreErrors", {}, "core"), fillArtifact("app/core/parsers.ts", "source", "appCoreParsers", {}, "core"), fillArtifact("app/core/factories.ts", "source", "appCoreFactories", {}, "core"), fillArtifact("app/core/index.ts", "source", "appCoreIndex", {}, "core"));
-	if (spec.app.includes("browser")) {
+	const sharedRecord = `
+/** The application record both hosts read at the health route. */
+${EXPORT_KEYWORD} interface ApplicationRecord {
+	readonly name: string
+	readonly status: 'ok'
+}
+`;
+	const healthConstants = `
+/** The only HTTP method owned by the application health route. */
+${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HEALTH_METHOD = 'GET'
+
+/** The only HTTP path owned by the generated application server. */
+${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HEALTH_PATH = '/health'
+`;
+	if (hasCore) {
+		artifacts.push(fillArtifact("app/core/types.ts", "source", "appCoreTypes", { record: hasBoundary ? sharedRecord : "" }, "core"), fillArtifact("app/core/constants.ts", "source", "appCoreConstants", {
+			nameLiteral,
+			health: hasBoundary ? `${healthConstants}
+/** Milliseconds allowed for one shared application health read. */
+${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_HEALTH_TIMEOUT = 5_000
+` : ""
+		}, "core"), fillArtifact("app/core/errors.ts", "source", "appCoreErrors", {}, "core"), fillArtifact("app/core/parsers.ts", "source", "appCoreParsers", {}, "core"), fillArtifact("app/core/factories.ts", "source", "appCoreFactories", {}, "core"), fillArtifact("app/core/index.ts", "source", "appCoreIndex", {
+			validators: hasBoundary ? "export * from './validators.js'\n" : "",
+			handlers: hasBoundary ? "export * from './handlers.js'\n" : ""
+		}, "core"));
+		if (hasBoundary) artifacts.push(fillArtifact("app/core/validators.ts", "source", "appCoreValidators", {}, "core"), fillArtifact("app/core/handlers.ts", "source", "appCoreHandlers", {}, "core"));
+	}
+	if (hasBrowser) {
 		const nameImport = hasCore ? "import { APP_NAME } from '@app/core'" : "import { APP_NAME } from './constants.js'";
 		const nameConstant = hasCore ? "" : `/** The browser-only application name. */
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_NAME = ${nameLiteral}
 
 `;
-		artifacts.push(fillArtifact("app/browser/types.ts", "source", "appBrowserTypes", {}, "browser"), fillArtifact("app/browser/constants.ts", "source", "appBrowserConstants", { nameConstant }, "browser"), fillArtifact("app/browser/errors.ts", "source", "appBrowserErrors", {}, "browser"), fillArtifact("app/browser/parsers.ts", "source", "appBrowserParsers", {}, "browser"), fillArtifact("app/browser/factories.ts", "source", "appBrowserFactories", { nameImport }, "browser"), fillArtifact("app/browser/index.ts", "source", "appBrowserIndex", {}, "browser"), fillArtifact("app/browser/main.ts", "source", "appBrowserMain", {}, "browser"), fillArtifact("app/browser/ApplicationView.vue", "source", "appBrowserView", {}, "browser"), fillArtifact("app/browser/index.html", "source", "appBrowserHtml", { name: escapeHtmlText(spec.name) }, "browser"), fillArtifact("app/browser/env.d.ts", "source", "appBrowserEnv", {}, "browser"));
+		artifacts.push(fillArtifact("app/browser/types.ts", "source", "appBrowserTypes", { application: hasShowcase && !hasCore ? `
+/** The identity the root view renders. */
+${EXPORT_KEYWORD} interface Application {
+	readonly name: string
+}
+` : "" }, "browser"), fillArtifact("app/browser/constants.ts", "source", "appBrowserConstants", { nameConstant }, "browser"), fillArtifact("app/browser/errors.ts", "source", "appBrowserErrors", {}, "browser"), fillArtifact("app/browser/parsers.ts", "source", "appBrowserParsers", {}, "browser"), fillArtifact("app/browser/factories.ts", "source", "appBrowserFactories", {
+			nameImport: hasBoundary ? "import { APP_NAME, readApplicationHealth } from '@app/core'" : nameImport,
+			seedImport: hasShowcase ? "import { seedApplication } from './seeders.js'\n" : "",
+			showcase: hasShowcase ? `
+/**
+ * Mount the showcase over its seeded, inert identity.
+ *
+ * @param target - The browser element or selector that receives the showcase.
+ * @returns The mounted Vue application.
+ *
+ * @remarks
+ * The showcase mounts the same {@link createBrowserApplication} root the shipped entry
+ * mounts, so the two differ in exactly one expression — where the props come from. This
+ * one reads {@link seedApplication}; the application reads ${showcaseSource}.
+ *
+ * @example
+ * \`\`\`ts
+ * import { mountShowcaseApplication } from '@app/browser'
+ *
+ * mountShowcaseApplication('#app')
+ * \`\`\`
+ */
+${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} mountShowcaseApplication(target: string | Element): App<Element> {
+	const seed = seedApplication()
+	const application = createBrowserApplication({ name: seed.name })
+	application.mount(target)
+	return application
+}
+` : "",
+			boundary: hasBoundary ? `
+/**
+ * Mount the application over its real server boundary.
+ *
+ * @param target - The browser element or selector that receives the application.
+ * @returns The mounted Vue application, after one health read settles.
+ *
+ * @remarks
+ * One health read runs before the mount, so the root view renders the identity the
+ * running server reported. An unreachable or off-contract boundary yields \`undefined\`
+ * and the application falls back to its own configuration rather than failing to mount.
+ *
+ * @example
+ * \`\`\`ts
+ * import { mountBrowserApplication } from '@app/browser'
+ *
+ * await mountBrowserApplication('#app')
+ * \`\`\`
+ */
+${EXPORT_KEYWORD} async ${FUNCTION_KEYWORD} mountBrowserApplication(target: string | Element): Promise<App<Element>> {
+	const seed = (await readApplicationHealth(window.location.origin)) ?? { name: APP_NAME }
+	const application = createBrowserApplication({ name: seed.name })
+	application.mount(target)
+	return application
+}
+` : ""
+		}, "browser"), fillArtifact("app/browser/index.ts", "source", "appBrowserIndex", { seeders: hasShowcase ? "export * from './seeders.js'\n" : "" }, "browser"), fillArtifact("app/browser/main.ts", "source", "appBrowserMain", hasBoundary ? {
+			factory: "mountBrowserApplication",
+			mount: `void mountBrowserApplication('#app').catch(() => {
+	console.error('[ERROR] Browser application failed')
+})`
+		} : {
+			factory: "createBrowserApplication",
+			mount: "createBrowserApplication().mount('#app')"
+		}, "browser"), fillArtifact("app/browser/ApplicationView.vue", "source", "appBrowserView", {}, "browser"), fillArtifact("app/browser/index.html", "source", "appBrowserHtml", { name: escapeHtmlText(spec.name) }, "browser"), fillArtifact("app/browser/env.d.ts", "source", "appBrowserEnv", {}, "browser"));
+		if (hasShowcase) artifacts.push(fillArtifact("app/browser/seeders.ts", "source", "appBrowserSeeders", {
+			applicationImport: hasCore ? "import type { Application } from '@app/core'" : "import type { Application } from './types.js'",
+			nameImport
+		}, "browser"), fillArtifact("app/browser/showcase.ts", "source", "appBrowserShowcase", {}, "browser"), fillArtifact("app/browser/showcase.html", "source", "appBrowserShowcaseHtml", { name: escapeHtmlText(spec.name) }, "browser"));
 	}
 	if (spec.app.includes("server")) {
 		const nameImport = hasCore ? "import { APP_NAME } from '@app/core'" : "import { APP_NAME } from './constants.js'";
@@ -8853,7 +9406,19 @@ ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_NAME = ${nameLiteral}
 ${EXPORT_KEYWORD} ${CONST_KEYWORD} APP_NAME = ${nameLiteral}
 
 `;
-		artifacts.push(fillArtifact("app/server/types.ts", "source", "appServerTypes", {}, "server"), fillArtifact("app/server/constants.ts", "source", "appServerConstants", { nameConstant }, "server"), fillArtifact("app/server/errors.ts", "source", "appServerErrors", {}, "server"), fillArtifact("app/server/parsers.ts", "source", "appServerParsers", {}, "server"), fillArtifact("app/server/handlers.ts", "source", "appServerHandlers", { nameImport }, "server"), fillArtifact("app/server/ApplicationServer.ts", "source", "appServerEntity", {}, "server"), fillArtifact("app/server/factories.ts", "source", "appServerFactories", {}, "server"), fillArtifact("app/server/ApplicationServerRunner.ts", "source", "appServerRunner", {}, "server"), fillArtifact("app/server/index.ts", "source", "appServerIndex", {}, "server"), fillArtifact("app/server/main.ts", "source", "appServerMain", {}, "server"));
+		artifacts.push(fillArtifact("app/server/types.ts", "source", "appServerTypes", { record: hasBoundary ? "" : `/** The application record returned by the health route. */
+${EXPORT_KEYWORD} interface ApplicationRecord {
+	readonly name: string
+	readonly status: 'ok'
+}
+
+` }, "server"), fillArtifact("app/server/constants.ts", "source", "appServerConstants", {
+			nameConstant,
+			health: hasBoundary ? "" : healthConstants
+		}, "server"), fillArtifact("app/server/errors.ts", "source", "appServerErrors", {}, "server"), fillArtifact("app/server/parsers.ts", "source", "appServerParsers", {}, "server"), fillArtifact("app/server/routes.ts", "source", "appServerRoutes", { healthImport: hasBoundary ? "import { APP_HEALTH_METHOD, APP_HEALTH_PATH } from '@app/core'" : "import { APP_HEALTH_METHOD, APP_HEALTH_PATH } from './constants.js'" }, "server"), fillArtifact("app/server/handlers.ts", "source", "appServerHandlers", {
+			recordImport: hasBoundary ? "import type { ApplicationRecord } from '@app/core'" : "import type { ApplicationRecord } from './types.js'",
+			nameImport
+		}, "server"), fillArtifact("app/server/ApplicationServer.ts", "source", "appServerEntity", {}, "server"), fillArtifact("app/server/factories.ts", "source", "appServerFactories", {}, "server"), fillArtifact("app/server/ApplicationServerRunner.ts", "source", "appServerRunner", { nameImport }, "server"), fillArtifact("app/server/index.ts", "source", "appServerIndex", {}, "server"), fillArtifact("app/server/main.ts", "source", "appServerMain", {}, "server"));
 	}
 	return artifacts;
 }
@@ -8926,7 +9491,7 @@ function paritySpecifiers(spec) {
 function testArtifacts(spec, pascal) {
 	const hasBrowser = spec.src.includes("browser") || spec.app.includes("browser");
 	const hasVue = spec.app.includes("browser");
-	const browserPolicyImport = hasBrowser ? "\nimport { chromium } from 'playwright'\nimport { isBrowserExecutable, resolveBrowser, SYSTEM_BROWSER_CHANNELS } from '../vite.config.js'" : "";
+	const machinery = viteMachinery(spec.src, spec.app, spec.bin, spec.showcase);
 	const vuePolicyImport = hasVue ? "\nimport { parse as parseVue } from 'vue/compiler-sfc'" : "";
 	const workspacePolicyAssertion = hasVue ? `expect(
 			inspectCodingWorkspace(process.cwd(), (path, content) => {
@@ -8937,37 +9502,218 @@ function testArtifacts(spec, pascal) {
 				)
 			}),
 		).toEqual([])` : "expect(inspectCodingWorkspace(process.cwd())).toEqual([])";
-	const browserPolicyTest = hasBrowser ? `
+	const configNames = [
+		"containedPath",
+		"environmentPathError",
+		"environmentSourceError",
+		"resolveWorkspacePath",
+		"workspacePath"
+	];
+	if (machinery.output) configNames.push("enforceOutputPath");
+	if (hasBrowser) configNames.push("isBrowserExecutable", "resolveBrowser", "resolveManagedBrowser", "resolveSystemBrowser", "SYSTEM_BROWSER_CHANNELS");
+	if (hasVue) configNames.push("hasSecurityPrologue", "HTML_SECURITY_META", "HTML_SECURITY_POLICY");
+	const configImports = [
+		...hasVue ? ["import { readFileSync } from 'node:fs'"] : [],
+		...hasBrowser ? ["import { chromium } from 'playwright'"] : [],
+		"import { describe, expect, it } from 'vitest'",
+		"import {",
+		...configNames.map((name) => `\t${name},`),
+		"} from '../../vite.config.js'"
+	].join("\n");
+	const configCases = [];
+	if (machinery.output) configCases.push(`
+
+	it('contains build output in its exact workspace directory', () => {
+		const expected = resolveWorkspacePath('dist/config-proof')
+
+		expect(() => enforceOutputPath(expected, expected)).not.toThrow()
+		expect(() => enforceOutputPath(resolveWorkspacePath('dist/other'), expected)).toThrow(
+			'exact configured workspace directory',
+		)
+		expect(() =>
+			enforceOutputPath(
+				resolveWorkspacePath('../config-proof'),
+				resolveWorkspacePath('../config-proof'),
+			),
+		).toThrow('remain inside the workspace')
+	})`);
+	if (hasBrowser) configCases.push(`
 
 	it('resolves only a real managed executable or stable system browser channel', () => {
-		const options = resolveBrowser(chromium.executablePath(), process.platform, process.env)
-		let valid = options === undefined
-		if (options !== undefined) {
-			const channel = options.launchOptions?.channel
-			valid =
-				channel === undefined
-					? isBrowserExecutable(options.launchOptions?.executablePath ?? chromium.executablePath())
-					: SYSTEM_BROWSER_CHANNELS.some((browser) => browser.channel === channel)
-		}
-		expect(valid).toBe(true)
-	})` : "";
-	const artifacts = [fillArtifact("tests/setup.ts", "tests", "setup", {}), fillArtifact("tests/policy.test.ts", "tests", "policyTest", {
-		browserPolicySpecifier: "",
-		browserPolicyImport,
-		browserPolicyTest,
-		vuePolicyImport,
-		workspacePolicyAssertion
-	})];
+		const pinned = chromium.executablePath()
+		const managed = resolveManagedBrowser(pinned)
+		const channel = resolveSystemBrowser(process.platform, process.env)
+		const options = resolveBrowser(pinned, process.platform, process.env)
+		const expected =
+			managed === undefined
+				? channel === undefined
+					? undefined
+					: { launchOptions: { channel } }
+				: managed === pinned
+					? {}
+					: { launchOptions: { executablePath: managed } }
+		const executable = managed === undefined || isBrowserExecutable(managed)
+		const stable =
+			managed !== undefined ||
+			channel === undefined ||
+			SYSTEM_BROWSER_CHANNELS.some((browser) => browser.channel === channel)
+
+		expect(options).toEqual(expected)
+		expect(executable).toBe(true)
+		expect(stable).toBe(true)
+	})`);
+	if (hasVue) configCases.push(`
+
+	it('preserves the generated browser security prologue', () => {
+		const document = readFileSync(resolveWorkspacePath('app/browser/index.html'), 'utf8')
+
+		expect(hasSecurityPrologue(document, HTML_SECURITY_META)).toBe(true)
+		expect(HTML_SECURITY_META).toContain(HTML_SECURITY_POLICY)
+	})`);
+	const artifacts = [
+		fillArtifact("tests/setup.ts", "tests", "setup", {
+			eventImport: spec.app.includes("server") ? "import type { EmitterInterface, EventMap } from '@orkestrel/emitter'\n\n" : "",
+			eventHelper: spec.app.includes("server") ? `
+/** Wait for one typed event occurrence and return its argument tuple. */
+${EXPORT_KEYWORD} ${FUNCTION_KEYWORD} waitForEvent<TMap extends EventMap, K extends keyof TMap>(
+	emitter: EmitterInterface<TMap>,
+	event: K,
+): Promise<TMap[K]> {
+	return new Promise((resolvePromise) => emitter.once(event, (...args) => resolvePromise(args)))
+}
+` : ""
+		}),
+		fillArtifact("tests/policy.test.ts", "tests", "policyTest", {
+			vuePolicyImport,
+			workspacePolicyAssertion
+		}),
+		fillArtifact("tests/config/vite.test.ts", "tests", "configTest", {
+			imports: configImports,
+			cases: configCases.join("")
+		})
+	];
 	if (spec.src.includes("server") || spec.app.includes("server")) artifacts.push(fillArtifact("tests/setupServer.ts", "tests", "setupServer", {}, "server"));
 	if (spec.src.includes("browser") || spec.app.includes("browser")) artifacts.push(fillArtifact("tests/setupBrowser.ts", "tests", "setupBrowser", {}, "browser"));
-	if (spec.app.includes("core")) artifacts.push(fillArtifact("tests/app/core/factories.test.ts", "tests", "appCoreTest", {}, "core"));
+	const hasBoundary = hasApplicationBoundary(spec);
+	const hasShowcase = hasApplicationShowcase(spec);
+	if (spec.app.includes("core")) artifacts.push(fillArtifact("tests/app/core/factories.test.ts", "tests", "appCoreTest", {
+		guardImport: hasBoundary ? "	isApplicationRecord,\n" : "",
+		readImport: hasBoundary ? "	readApplicationHealth,\n" : "",
+		boundary: hasBoundary ? `
+
+describe('shared application health boundary', () => {
+	it('accepts the shared record and refuses every off-contract value', () => {
+		expect(isApplicationRecord({ name: APP_NAME, status: 'ok' })).toBe(true)
+		expect(isApplicationRecord({ name: ' ', status: 'ok' })).toBe(true)
+		for (const value of [
+			null,
+			[],
+			'ok',
+			{ name: APP_NAME },
+			{ name: '', status: 'ok' },
+			{ name: 1, status: 'ok' },
+			{ name: APP_NAME, status: 'down' },
+		]) {
+			expect(isApplicationRecord(value)).toBe(false)
+		}
+		const revocable = Proxy.revocable({}, {})
+		revocable.revoke()
+		expect(isApplicationRecord(revocable.proxy)).toBe(false)
+	})
+
+	it('refuses a malformed origin before reaching the network', async () => {
+		expect(await readApplicationHealth('not-an-origin')).toBeUndefined()
+	})
+})` : ""
+	}, "core"));
 	if (spec.app.includes("browser")) {
 		const browserTestNameImport = spec.app.includes("core") ? "import { APP_NAME } from '@app/core'" : "import { APP_NAME } from '@app/browser'";
-		artifacts.push(fillArtifact("tests/app/browser/factories.test.ts", "tests", "appBrowserTest", { browserTestNameImport }, "browser"));
+		artifacts.push(fillArtifact("tests/app/browser/factories.test.ts", "tests", "appBrowserTest", {
+			browserTestNameImport,
+			showcaseImport: hasShowcase ? "	mountShowcaseApplication,\n" : "",
+			entryImport: `${hasShowcase ? "	seedApplication,\n" : ""}${hasBoundary ? "	mountBrowserApplication,\n" : ""}`,
+			showcase: hasShowcase ? `
+
+describe('mountShowcaseApplication', () => {
+	it('mounts the shipped root view over one frozen, inert seed', () => {
+		const element = buildElement()
+		const seeded = seedApplication()
+		const application = mountShowcaseApplication(element)
+		try {
+			expect(element.textContent).toContain(seeded.name)
+			expect(seeded).toEqual(seedApplication())
+			expect(seeded).not.toBe(seedApplication())
+			expect(Object.isFrozen(seeded)).toBe(true)
+		} finally {
+			application.unmount()
+			element.remove()
+		}
+	})
+})` : "",
+			boundary: hasBoundary ? `
+
+describe('mountBrowserApplication', () => {
+	it('mounts the configured identity when the boundary answers off-contract', async () => {
+		const element = buildElement()
+		const application = await mountBrowserApplication(element)
+		try {
+			expect(element.textContent).toContain(APP_NAME)
+		} finally {
+			application.unmount()
+			element.remove()
+		}
+	})
+})` : ""
+		}, "browser"));
 	}
 	if (spec.app.includes("server")) {
-		const testNameImport = spec.app.includes("core") ? "import { APP_NAME } from '@app/core'" : "import { APP_NAME } from '@app/server'";
-		artifacts.push(fillArtifact("tests/app/server/ApplicationServer.test.ts", "tests", "appServerTest", { testNameImport }, "server"), fillArtifact("tests/app/server/parsers.test.ts", "tests", "appServerParsersTest", {}, "server"));
+		const testNameImport = hasBoundary ? `import {
+	APP_HEALTH_METHOD,
+	APP_HEALTH_PATH,
+	APP_NAME,
+	isApplicationRecord,
+	readApplicationHealth,
+} from '@app/core'` : spec.app.includes("core") ? "import { APP_NAME } from '@app/core'" : "import { APP_NAME } from '@app/server'";
+		const serverImport = hasBoundary ? `import {
+	ApplicationServerRunner,
+	createApplicationDispatcher,
+	createApplicationServer,
+} from '@app/server'` : `import {
+	APP_HEALTH_METHOD,
+	APP_HEALTH_PATH,
+	ApplicationServerRunner,
+	createApplicationDispatcher,
+	createApplicationServer,
+} from '@app/server'`;
+		artifacts.push(fillArtifact("tests/app/server/ApplicationServer.test.ts", "tests", "appServerTest", {
+			testNameImport,
+			serverImport,
+			boundary: hasBoundary ? `
+
+describe('shared application boundary', () => {
+	it('answers the shared record and translates it into the shared identity', async () => {
+		const server = createApplicationServer({ server: { host: '127.0.0.1', port: 0 } })
+		try {
+			await server.start()
+			const url = server.url
+			if (url === undefined) throw new Error('Expected a bound application URL')
+			const response = await fetch(\`\${url}\${APP_HEALTH_PATH}\`)
+			const record: unknown = await response.json()
+
+			expect(isApplicationRecord(record)).toBe(true)
+			expect(await readApplicationHealth(url)).toEqual({ name: APP_NAME })
+		} finally {
+			await server.destroy()
+		}
+	})
+
+	it('reads undefined from a released loopback port', async () => {
+		const port = await reserveLoopbackPort()
+
+		expect(await readApplicationHealth(\`http://127.0.0.1:\${port}\`)).toBeUndefined()
+	})
+})` : ""
+		}, "server"), fillArtifact("tests/app/server/parsers.test.ts", "tests", "appServerParsersTest", {}, "server"));
 	}
 	const inlineExplicitInstance = `instance: ${pascal}Interface = new ${pascal}({ id: 'example' })`;
 	const multilineExplicitInstance = `instance: ${pascal}Interface = new ${pascal}({
@@ -9011,12 +9757,12 @@ function testArtifacts(spec, pascal) {
 	}
 	artifacts.push(fillArtifact("tests/setupGuides.ts", "tests", "setupGuides", {
 		specifiers: paritySpecifiers(spec),
-		walkDirs: [
-			...spec.src.length > 0 ? ["'src'"] : [],
-			...spec.app.length > 0 ? ["'app'"] : [],
-			"'guides'",
-			"'tests'"
-		].map((directory) => `\t${directory},`).join("\n")
+		walkDirs: renderStringArray([
+			...spec.src.length > 0 ? ["src"] : [],
+			...spec.app.length > 0 ? ["app"] : [],
+			"guides",
+			"tests"
+		], "", "export const GUIDE_WALK_DIRECTORIES: readonly string[] = Object.freeze(", ")")
 	}), fillArtifact("tests/guides/src/parity.test.ts", "tests", "parityTest", { name: spec.name }));
 	return artifacts;
 }
@@ -9065,6 +9811,8 @@ function guideMemberTable(category, members) {
 */
 function guideUsage(spec, pascal) {
 	const examples = [];
+	const hasBoundary = hasApplicationBoundary(spec);
+	const hasShowcase = hasApplicationShowcase(spec);
 	if (spec.src.length > 0) examples.push(`\`\`\`ts
 import { create${pascal} } from '@orkestrel/${spec.name}'
 
@@ -9081,6 +9829,24 @@ import {
 ${CONST_KEYWORD} name = parseApplicationName(' ${spec.name} ')
 ${CONST_KEYWORD} application = createApplication(name)
 isApplicationError(new ApplicationError('CONFIG', 'invalid')) // true
+\`\`\``);
+	if (hasBoundary) examples.push(`\`\`\`ts
+import type { ApplicationRecord } from '@app/core'
+import {
+	APP_HEALTH_METHOD,
+	APP_HEALTH_PATH,
+	APP_HEALTH_TIMEOUT,
+	isApplicationRecord,
+	readApplicationHealth,
+} from '@app/core'
+
+APP_HEALTH_METHOD // 'GET'
+APP_HEALTH_PATH // '/health'
+APP_HEALTH_TIMEOUT // 5000
+${CONST_KEYWORD} healthy: ApplicationRecord = { name: '${spec.name}', status: 'ok' }
+isApplicationRecord(healthy) // true
+isApplicationRecord({ name: '${spec.name}', status: 'down' }) // false
+await readApplicationHealth('http://127.0.0.1:3000') // { name: '${spec.name}' } or undefined
 \`\`\``);
 	if (spec.app.includes("browser")) examples.push(`\`\`\`ts
 import {
@@ -9096,27 +9862,36 @@ ${CONST_KEYWORD} browserOptions = parseBrowserApplicationOptions({
 ${CONST_KEYWORD} browser = createBrowserApplication(browserOptions)
 browser.mount('#app')
 isBrowserApplicationError(new BrowserApplicationError('CONFIG', 'invalid')) // true
+\`\`\``);
+	if (hasShowcase) examples.push(`\`\`\`ts
+import { mountShowcaseApplication, seedApplication } from '@app/browser'
+
+${CONST_KEYWORD} seed = seedApplication()
+${CONST_KEYWORD} showcase = mountShowcaseApplication('#app')
+seed.name // '${spec.name} showcase'
+showcase.unmount()
+\`\`\``);
+	if (hasBoundary) examples.push(`\`\`\`ts
+import { mountBrowserApplication } from '@app/browser'
+
+${CONST_KEYWORD} application = await mountBrowserApplication('#app')
+application.unmount()
 \`\`\``);
 	if (spec.app.includes("server")) examples.push(`\`\`\`ts
-import { once } from 'node:events'
-import { createServer } from 'node:http'
+${hasBoundary ? `import type { ApplicationRecord } from '@app/core'
+import type { ApplicationState } from '@app/server'
+import { APP_HEALTH_METHOD, APP_HEALTH_PATH, isApplicationRecord } from '@app/core'` : "import type { ApplicationRecord, ApplicationState } from '@app/server'"}
 import {
-	APP_HEALTH_METHOD,
+${hasBoundary ? "" : `	APP_HEALTH_METHOD,
 	APP_HEALTH_PATH,
-	APP_HEADERS_TIMEOUT,
-	APP_HOST_LABEL_PATTERN,
-	APP_KEEP_ALIVE_TIMEOUT,
-	APP_MAX_CONNECTIONS,
-	APP_MAX_HEADERS,
-	APP_MAX_REQUESTS_PER_SOCKET,
-	APP_REQUEST_TIMEOUT,
+`}	APP_HOST_LABEL_PATTERN,
 	APP_NUMERIC_HOST_PATTERN,
-	ApplicationServer,
 	ApplicationServerError,
 	DEFAULT_APP_START_TIMEOUT,
 	MAX_APP_START_TIMEOUT,
+	createApplicationDispatcher,
 	createApplicationServer,
-	handleApplicationRequest,
+	handleApplicationHealth,
 	isApplicationServerError,
 	parseApplicationHost,
 	parseApplicationPort,
@@ -9128,41 +9903,51 @@ import {
 ${CONST_KEYWORD} host = parseApplicationHost('127.0.0.1')
 ${CONST_KEYWORD} port = parseApplicationPort('0')
 ${CONST_KEYWORD} timeout = parseApplicationStartTimeout('5000')
-${CONST_KEYWORD} options = parseApplicationServerOptions({ host, port, timeout })
+${CONST_KEYWORD} options = parseApplicationServerOptions({ server: { host, port, timeout } })
+parseApplicationStartTimeout(String(DEFAULT_APP_START_TIMEOUT)) // 10000
+MAX_APP_START_TIMEOUT // 300000
 APP_HOST_LABEL_PATTERN.test('api') // true
 APP_NUMERIC_HOST_PATTERN.test('999.999.999.999') // true (and therefore rejected as a host)
-APP_HEALTH_METHOD // 'GET'
-APP_HEALTH_PATH // '/'
-APP_MAX_CONNECTIONS // 16
-APP_MAX_HEADERS // 100
-APP_HEADERS_TIMEOUT // 10000
-APP_REQUEST_TIMEOUT // 30000
-APP_KEEP_ALIVE_TIMEOUT // 5000
-APP_MAX_REQUESTS_PER_SOCKET // 100
-DEFAULT_APP_START_TIMEOUT // 10000
-MAX_APP_START_TIMEOUT // 300000
-${CONST_KEYWORD} handlerServer = createServer(handleApplicationRequest)
-handlerServer.listen(0, host)
-await once(handlerServer, 'listening')
-${CONST_KEYWORD} handlerClosed = once(handlerServer, 'close')
-handlerServer.close()
-await handlerClosed
-
-${CONST_KEYWORD} error = new ApplicationServerError('CONFIG', 'invalid')
-isApplicationServerError(error) // true
-reportApplicationServerError(error) // writes only a stable CONFIG diagnostic
-new ApplicationServer(options) // stopped entity
+${CONST_KEYWORD} state: ApplicationState = { connection: { encrypted: false } }
+${CONST_KEYWORD} record: ApplicationRecord = { name: '${spec.name}', status: 'ok' }
+${CONST_KEYWORD} dispatcher = createApplicationDispatcher()
+try {
+	${CONST_KEYWORD} response = await dispatcher.handle(
+		new Request(\`http://application.test\${APP_HEALTH_PATH}\`, { method: APP_HEALTH_METHOD }),
+		state,
+	)
+	${CONST_KEYWORD} health = handleApplicationHealth()
+	${CONST_KEYWORD} encoded = Response.json(record)
+	${hasBoundary ? `${CONST_KEYWORD} value: unknown = await health.clone().json()
+	isApplicationRecord(value) // true
+	` : ""}if (!response.ok || !health.ok || !encoded.ok) throw new Error('Application health failed')
+} finally {
+	dispatcher.destroy()
+}
+
+${CONST_KEYWORD} failure: unknown = new ApplicationServerError('CONFIG', 'invalid')
+if (isApplicationServerError(failure)) {
+	reportApplicationServerError(failure) // writes only a stable CONFIG diagnostic
+}
 
 ${CONST_KEYWORD} server = createApplicationServer(options)
 ${CONST_KEYWORD} controller = new AbortController()
 await server.start(controller.signal)
 await server.stop()
+await server.destroy()
 \`\`\`
 
 \`\`\`ts
-import { ApplicationServerRunner } from '@app/server'
-
-${CONST_KEYWORD} runner = new ApplicationServerRunner({ port: 0 })
+import type { ApplicationServerRunnerEventMap, ApplicationServerRunnerOptions } from '@app/server'
+import { ApplicationServerRunner, createApplicationServer } from '@app/server'
+
+${CONST_KEYWORD} event: keyof ApplicationServerRunnerEventMap = 'ready'
+${CONST_KEYWORD} observe: ApplicationServerRunnerOptions = { on: { fail: () => undefined } }
+${CONST_KEYWORD} runner = new ApplicationServerRunner(
+	createApplicationServer({ server: { port: 0 } }),
+	observe,
+)
+runner.emitter.once(event, (url) => console.log(url))
 runner.start() // process owns shutdown signals
 await runner.stop()
 \`\`\`
@@ -9170,7 +9955,7 @@ await runner.stop()
 \`\`\`ts
 import { startApplicationServer } from '@app/server'
 
-${CONST_KEYWORD} processRunner = startApplicationServer({ port: 0 })
+${CONST_KEYWORD} processRunner = startApplicationServer({ server: { port: 0 } })
 await processRunner.stop()
 \`\`\``);
 	return examples.join("\n\n");
@@ -9193,15 +9978,23 @@ ${alignTable([
 		"Method",
 		"Returns",
 		"Behavior"
-	], [[
-		"`start`",
-		"`Promise<void>`",
-		"Serialize in call order; start only when stopped, and repeat safely when already listening. The optional `AbortSignal` and bounded startup timeout cancel pending name resolution/listen work. Rejects with `ApplicationServerError` code `LIFECYCLE` when startup fails, times out, or the caller aborts."
 	], [
-		"`stop`",
-		"`Promise<void>`",
-		"Cancel every pending start before its queued stop, force active and idle connections closed, and repeat safely when already stopped. Rejects with `ApplicationServerError` code `LIFECYCLE` when closing fails."
-	]])}
+		[
+			"`start`",
+			"`Promise<void>`",
+			"Bind the installed `@orkestrel/server` substrate when idle or stopped. The optional `AbortSignal` and bounded startup timeout cancel pending binding. Rejects with `ApplicationServerError` code `LIFECYCLE` when startup fails, times out, or the caller aborts."
+		],
+		[
+			"`stop`",
+			"`Promise<void>`",
+			"Drain and stop the installed server; repeated calls while stopped are safe. Rejects with `ApplicationServerError` code `LIFECYCLE` when closing fails."
+		],
+		[
+			"`destroy`",
+			"`Promise<void>`",
+			"Perform terminal idempotent teardown through the installed server lifecycle, then destroy its owned dispatcher. Rejects with `ApplicationServerError` code `LIFECYCLE` when server teardown fails."
+		]
+	])}
 
 #### \`ApplicationServerRunnerInterface\`
 
@@ -9212,17 +10005,18 @@ ${alignTable([
 	], [[
 		"`start`",
 		"`void`",
-		"Register one idempotent set of SIGINT/SIGTERM cleanup listeners, start the server, and translate asynchronous startup failures into a non-zero process exit code."
+		"Register one generation-owned set of SIGINT/SIGTERM cleanup listeners, queue the substrate start behind any shutdown already in flight, emit `ready` after binding, and emit `fail` for a current lifecycle failure."
 	], [
 		"`stop`",
 		"`Promise<void>`",
-		"Release both process listeners before stopping the server; repeated calls are safe and lifecycle failures reject."
+		"Abort a startup still in flight and release both process listeners, then wait for that startup to settle before stopping the server; concurrent calls join one substrate stop, and lifecycle failures emit `fail` and reject."
 	]])}
 
-The constructor validates direct options plus \`APP_HOST\`, \`APP_PORT\`, and
-\`APP_START_TIMEOUT\` before allocating
-a listener. Direct options must be an exact plain own-key data record containing only
-\`host\`, \`port\`, and/or \`timeout\`; inherited properties, accessors, symbols, instances, proxies that
+The runner exposes its readonly \`emitter\`. \`ApplicationServerRunnerEventMap\` emits \`ready\` with the bound URL and \`fail\` with an \`unknown\` error. \`ApplicationServerRunnerOptions\` accepts initial \`on\` hooks and an emitter \`error\` handler; initial hooks run before the runner's own announcement and reporting listeners, so when no earlier failure set an exit code, a synchronous \`fail\` hook sees \`process.exitCode === undefined\` before the default reporter sets it to \`1\`. The default listeners preserve one exact \`[READY] <name> <url>\` stderr line and the stable redacted failure diagnostics. In-process consumers and tests park on runner events; a child process still observes the \`[READY]\` line because that byte stream is its process-boundary channel.
+
+The application server constructor validates grouped direct options plus \`APP_HOST\`, \`APP_PORT\`, and
+\`APP_START_TIMEOUT\` before binding. Direct options must be an exact plain own-key data record containing only a
+\`server\` record with \`host\`, \`port\`, and/or \`timeout\`; inherited properties, accessors, symbols, instances, proxies that
 throw during reflection, and unknown keys fail closed. Invalid values throw
 \`ApplicationServerError\` code \`CONFIG\`; the default host is loopback and port \`0\` is
 supported for collision-free ephemeral allocation. Startup defaults to 10 seconds and accepts
@@ -9230,10 +10024,15 @@ only integer timeouts from 1 through 300,000 milliseconds. Lifecycle failures us
 \`LIFECYCLE\`; both may carry \`context.cause\` or \`context.value\`. Narrow caught values with
 \`isApplicationServerError\` before reading either field.
 
-The generated server owns exactly \`GET /\`. It serializes
-\`{ name: APP_NAME, status: 'ok' }\` as JSON with \`cache-control: no-store\`;
-every other path returns deterministic plain-text \`404 Not Found\`, and every unsupported
-method returns deterministic plain-text \`405 Method Not Allowed\` with \`Allow: GET\`.`;
+Before binding, \`url\` is \`undefined\`; after a successful start it reflects the real bound port,
+and it returns to \`undefined\` after stop or destroy. \`ApplicationState\` extends middleware's
+\`IdentifierState\` and adds only its \`connection\` property; there is no redundant \`listening\` member.
+
+Each \`createApplicationDispatcher()\` call returns a fresh dispatcher that owns exactly \`GET /health\`
+and serializes the shared \`ApplicationRecord\` shape \`{ name: APP_NAME, status: 'ok' }\` as JSON. The
+server composes \`createBoundary()\`, \`createSecurity()\`, then \`createDeadline({ ms: timeout })\`
+around that owned dispatcher; standalone callers destroy theirs after use. Every other path returns
+\`404\`, and every unsupported method returns \`405\` with \`Allow: GET\`.`;
 }
 /**
 * Build links to every generated source and application test file.
@@ -9243,7 +10042,7 @@ method returns deterministic plain-text \`405 Method Not Allowed\` with \`Allow:
 * @returns A newline-separated Markdown test inventory.
 */
 function guideTests(spec, pascal) {
-	const tests = ["- [`tests/policy.test.ts`](../../tests/policy.test.ts) — filename placement and real browser capability probing."];
+	const tests = ["- [`tests/policy.test.ts`](../../tests/policy.test.ts) — repository coding law and filename placement.", "- [`tests/config/vite.test.ts`](../../tests/config/vite.test.ts) — executable root Vite invariants and conditional browser capability."];
 	for (const environment of spec.src) tests.push(`- [\`tests/src/${environment}/${pascal}.test.ts\`](../../tests/src/${environment}/${pascal}.test.ts) — entity boundaries.`, `- [\`tests/src/${environment}/factories.test.ts\`](../../tests/src/${environment}/factories.test.ts) — factory behavior.`);
 	if (spec.app.includes("core")) tests.push("- [`tests/app/core/factories.test.ts`](../../tests/app/core/factories.test.ts) — host-independent identity behavior.");
 	if (spec.app.includes("browser")) tests.push("- [`tests/app/browser/factories.test.ts`](../../tests/app/browser/factories.test.ts) — real-browser mount and cleanup.");
@@ -9924,7 +10723,9 @@ function createBlueprint(data) {
 }
 //#endregion
 exports.APP_BROWSER_DEV_DEPENDENCIES = APP_BROWSER_DEV_DEPENDENCIES;
+exports.APP_DEV_DEPENDENCIES = APP_DEV_DEPENDENCIES;
 exports.APP_MATRIX = APP_MATRIX;
+exports.APP_SERVER_DEV_DEPENDENCIES = APP_SERVER_DEV_DEPENDENCIES;
 exports.BASE_DEV_DEPENDENCIES = BASE_DEV_DEPENDENCIES;
 exports.BIN_CONFIGS = BIN_CONFIGS;
 exports.CATEGORIES = CATEGORIES;
@@ -10003,6 +10804,7 @@ exports.compareCodeUnit = compareCodeUnit;
 exports.computeColumnWidth = computeColumnWidth;
 exports.computeHash = computeHash;
 exports.configArtifacts = configArtifacts;
+exports.configViteProject = configViteProject;
 exports.contentByteLength = contentByteLength;
 exports.contentCodePoint = contentCodePoint;
 exports.contentToBytes = contentToBytes;
@@ -10032,6 +10834,8 @@ exports.guideMethods = guideMethods;
 exports.guideTests = guideTests;
 exports.guideUsage = guideUsage;
 exports.guidesViteProject = guidesViteProject;
+exports.hasApplicationBoundary = hasApplicationBoundary;
+exports.hasApplicationShowcase = hasApplicationShowcase;
 exports.hasBlueprintEnvironment = hasBlueprintEnvironment;
 exports.hasOnlyDataProperties = hasOnlyDataProperties;
 exports.hasValidArtifactBytes = hasValidArtifactBytes;
@@ -10087,6 +10891,7 @@ exports.policyViteProject = policyViteProject;
 exports.rangeToFreshness = rangeToFreshness;
 exports.renderArray = renderArray;
 exports.renderObject = renderObject;
+exports.renderStringArray = renderStringArray;
 exports.renderValue = renderValue;
 exports.renderViteTest = renderViteTest;
 exports.rootTsconfig = rootTsconfig;