@orkestrel/scaffold 0.0.27 → 0.0.29

package/dist/src/core/index.cjs

@@ -201,6 +201,12 @@ var GLOBAL_SETUP_PATH = "tests/setupGlobal.ts";
 var GUIDES_TEST_PATH = "tests/guides.test.ts";
 /** The installed-package proof whose presence makes a workspace `integration`. */
 var INTEGRATION_TEST_PATH = "tests/integration.test.ts";
+/** The official-tooling drift proof whose presence makes a workspace `conformance`. */
+var CONFORMANCE_TEST_PATH = "tests/conformance.test.ts";
+/** The live-service readiness module whose presence makes a workspace `service`. */
+var SERVICE_SETUP_PATH = "tests/setupService.ts";
+/** The include the live-service project covers, which is a directory rather than one proof. */
+var SERVICE_TEST_INCLUDE = "tests/service/**/*.test.ts";
 /** The Vite wrapper whose presence makes a workspace `showcase`. */
 var SHOWCASE_CONFIG_PATH = "configs/app/vite.showcase.config.ts";
 /** The bare workspace name syntax: lowercase alphanumeric with hyphens, letter first. */
@@ -284,7 +290,7 @@ var DEFAULT_ENGINES = `>=${MINIMUM_NODE_VERSION}`;
 var BASE_DEV_DEPENDENCIES = Object.freeze({
 	"@microsoft/api-extractor": "^7.58.12",
 	"@orkestrel/guide": "^0.0.10",
-	"@orkestrel/scaffold": "^0.0.27",
+	"@orkestrel/scaffold": "^0.0.29",
 	"@types/node": "^26.2.0",
 	oxfmt: "^0.62.0",
 	oxlint: "^1.77.0",
@@ -380,11 +386,11 @@ var CONFIG_TEMPLATES = Object.freeze({
 		vite: `import type { {{viteTypes}} } from 'vite'
 {{imports}}import { defineConfig, mergeConfig } from 'vitest/config'
 import tsconfig from './tsconfig.json' with { type: 'json' }
-{{helpers}}import { lstatSync, readdirSync, realpathSync } from 'node:fs'
+{{helpers}}{{browsers}}import { lstatSync, readdirSync, realpathSync } from 'node:fs'
 import { basename, join, parse, relative, resolve as resolvePath, sep } from 'node:path'
 import { fileURLToPath, URL } from 'node:url'
 
-export function resolveWorkspacePath(relativePath: string): string {
+{{options}}export function resolveWorkspacePath(relativePath: string): string {
 	return fileURLToPath(new URL(relativePath, import.meta.url))
 }
 
@@ -478,7 +484,7 @@ const resolve = {
 {{exclude}}				setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
 				browser: {
 					enabled: true,
-					provider: playwright(),
+					provider: playwright(browserOptions),
 					instances: [{ browser: 'chromium', headless: true }],
 				},
 				fileParallelism: false,
@@ -589,7 +595,7 @@ const resolve = {
 			setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
 			browser: {
 				enabled: true,
-				provider: playwright(),
+				provider: playwright(browserOptions),
 				instances: [{ browser: 'chromium', headless: true }],
 			},
 			fileParallelism: false,
@@ -676,6 +682,44 @@ export function appBrowser(...options: never[]): UserConfig {
 		},
 		options ?? {},
 	)
+`,
+		conformance: `// Where this package drifts from the official tooling it stays compatible with.
+// The subject is this package, so the proof is hermetic and stays in \`npm test\`.
+export const conformance = (options?: UserConfig): UserConfig =>
+	mergeConfig(
+		{
+			resolve,
+			test: {
+				name: { label: 'conformance', color: 'magenta' },
+				include: ['${CONFORMANCE_TEST_PATH}'],
+				setupFiles: ['./tests/setup.ts'],
+				environment: 'node',
+				browser: { enabled: false },
+			},
+		},
+		options ?? {},
+	)
+`,
+		service: `// The live external services this package drives. It starts nothing itself:
+// \`scripts/service.sh\` provisions, \`tests/setupService.ts\` proves readiness, and
+// the project stays out of \`npm test\` because a real service answers it.
+export const service = (options?: UserConfig): UserConfig =>
+	mergeConfig(
+		{
+			resolve,
+			test: {
+				name: { label: 'service', color: 'red' },
+				include: ['${SERVICE_TEST_INCLUDE}'],
+				setupFiles: ['./tests/setup.ts', './tests/setupService.ts'],
+				environment: 'node',
+				browser: { enabled: false },
+				testTimeout: 120_000,
+				hookTimeout: 120_000,
+				fileParallelism: false,
+			},
+		},
+		options ?? {},
+	)
 `,
 		probe: `// A workbench, not a proof. No gate selects this project.
 export const probe = (options?: UserConfig): UserConfig =>
@@ -876,12 +920,22 @@ export default defineConfig(
 import dts from 'vite-plugin-dts'
 import { srcBrowser, resolveWorkspacePath } from '../../vite.config.ts'
 
+// vite-plugin-dts rolls this face into one declaration, and the roll-up reaches
+// src/core through a relative source path the tarball does not carry. The path
+// keeps each source module's own depth, so a module in a browser subfolder emits
+// one that leaves dist/src entirely. The rewrite below externalizes core through
+// the package's own published root export, on the final roll-up only.
 export default defineConfig(
 	srcBrowser({
 		plugins: [
 			dts({
 				tsconfigPath: resolveWorkspacePath('configs/src/tsconfig.browser.json'),
 				bundleTypes: true,
+				beforeWriteFile: (path, content) => ({
+					content: /[\\\\/]dist[\\\\/]src[\\\\/]browser[\\\\/]index\\.d\\.ts$/.test(path)
+{{replacement}}
+						: content,
+				}),
 			}),
 		],
 	}),
@@ -950,7 +1004,319 @@ import { appShowcase } from '../../vite.config.ts'
 export default defineConfig(appShowcase())
 `
 		})
-	})
+	}),
+	browsers: `// A generated browser workspace resolves its own Chromium here rather than in
+// \`configs/helpers.ts\`, because that leaf is vendored byte-identical to every
+// workspace and most of them declare no \`playwright\` to import.
+
+import type { PlaywrightProviderOptions } from '@vitest/browser-playwright'
+import { chromium } from 'playwright'
+import { accessSync, constants as FS_CONSTANTS, globSync, readdirSync, statSync } from 'node:fs'
+import { basename, dirname, join, resolve as resolvePath } from 'node:path'
+
+/**
+ * Chromium executable layouts inside a \`chromium-<revision>\` browsers-directory entry, per
+ * platform.
+ *
+ * @remarks
+ * The current Playwright build ships Chrome for Testing on macOS. The trailing \`Chromium.app\`
+ * layouts are what earlier builds shipped, so the list spans Playwright versions instead of
+ * pinning to the installed one.
+ */
+export const CHROMIUM_LAYOUTS = Object.freeze([
+	'chrome-linux/chrome',
+	'chrome-linux64/chrome',
+	'chrome-win/chrome.exe',
+	'chrome-win64/chrome.exe',
+	'chrome-mac-x64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+	'chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+	'chrome-mac/Chromium.app/Contents/MacOS/Chromium',
+	'chrome-mac-arm64/Chromium.app/Contents/MacOS/Chromium',
+])
+
+/** The \`chromium-<revision>\` entry name Playwright installs one managed build into. */
+export const CHROMIUM_ENTRY_PATTERN = /^chromium-\\d+$/
+
+/** The revision number carried by any path containing a \`chromium-<revision>\` segment. */
+export const CHROMIUM_REVISION_PATTERN = /chromium-(\\d+)/
+
+/** The directory a managed Linux container installs its bundled Playwright browsers into. */
+export const BUNDLED_BROWSERS_ROOT = '/opt/pw-browsers'
+
+/**
+ * Bundled Chromium layouts under the managed-container browsers root, as glob patterns.
+ *
+ * @remarks
+ * The revision directory and its inner layout both drift across Playwright builds, and the
+ * container also carries a top-level \`chromium\` alias, so every known shape is globbed.
+ */
+export const BUNDLED_CHROMIUM_LAYOUTS = Object.freeze([
+	'chromium',
+	'chromium-*/chrome-linux64/chrome',
+	'chromium-*/chrome-linux/chrome',
+])
+
+/** Stable Playwright Chromium channels and their standard executable layouts. */
+export const SYSTEM_BROWSER_CHANNELS = Object.freeze([
+	Object.freeze({
+		channel: 'chrome',
+		layouts: Object.freeze({
+			linux: '/opt/google/chrome/chrome',
+			darwin: '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+			win32: Object.freeze(['Google', 'Chrome', 'Application', 'chrome.exe']),
+		}),
+	}),
+	Object.freeze({
+		channel: 'msedge',
+		layouts: Object.freeze({
+			linux: '/opt/microsoft/msedge/msedge',
+			darwin: '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+			win32: Object.freeze(['Microsoft', 'Edge', 'Application', 'msedge.exe']),
+		}),
+	}),
+])
+
+/**
+ * Determine whether a path identifies an executable regular file.
+ *
+ * @param path - The filesystem path to inspect.
+ * @returns Whether the path is a regular file with execute access.
+ *
+ * @example
+ * \`\`\`ts
+ * isBrowserExecutable('/opt/google/chrome/chrome')
+ * \`\`\`
+ */
+export function isBrowserExecutable(path: string): boolean {
+	try {
+		if (!statSync(path).isFile()) return false
+		accessSync(path, FS_CONSTANTS.X_OK)
+		return true
+	} catch {
+		return false
+	}
+}
+
+/**
+ * Order two Chromium paths so the highest revision sorts first.
+ *
+ * @param left - The first path or directory entry to compare.
+ * @param right - The second path or directory entry to compare.
+ * @returns A negative number when \`left\` sorts first, positive when \`right\` does.
+ *
+ * @remarks
+ * Revisions are numbers, so \`chromium-1200\` outranks \`chromium-999\` despite sorting below it
+ * lexically. A path carrying no revision falls back to descending name order.
+ *
+ * @example
+ * \`\`\`ts
+ * ['chromium-999', 'chromium-1200'].sort(compareRevisions)
+ * \`\`\`
+ */
+export function compareRevisions(left: string, right: string): number {
+	const leftRevision = CHROMIUM_REVISION_PATTERN.exec(left)?.[1]
+	const rightRevision = CHROMIUM_REVISION_PATTERN.exec(right)?.[1]
+	if (leftRevision === undefined || rightRevision === undefined) return right.localeCompare(left)
+	return Number(rightRevision) - Number(leftRevision)
+}
+
+/**
+ * Read the executable path of Playwright's pinned Chromium revision.
+ *
+ * @returns The pinned executable path, or \`undefined\` when this platform has none.
+ *
+ * @remarks
+ * Playwright throws rather than returning a path when the current platform carries no initialized
+ * executable, and an unguarded call would fail configuration evaluation for every project.
+ *
+ * @example
+ * \`\`\`ts
+ * resolvePinnedBrowser()
+ * \`\`\`
+ */
+export function resolvePinnedBrowser(): string | undefined {
+	try {
+		const pinned = chromium.executablePath()
+		return pinned.length === 0 ? undefined : pinned
+	} catch {
+		return undefined
+	}
+}
+
+/**
+ * Resolve a launchable Playwright-managed Chromium executable: the pinned revision when installed,
+ * otherwise a \`chromium\` / \`chromium.exe\` alias or any other \`chromium-*\` revision under the same
+ * Playwright browsers directory. A pinned-revision miss is not Chromium absence — managed
+ * containers ship one usable build, often behind a revision-agnostic alias, for many Playwright
+ * versions.
+ *
+ * @param pinned - The executable path for Playwright's pinned Chromium revision.
+ * @returns The managed executable path, or \`undefined\` when none is executable.
+ *
+ * @example
+ * \`\`\`ts
+ * resolveManagedBrowser('/root/.cache/ms-playwright/chromium-1234/chrome-linux64/chrome')
+ * \`\`\`
+ */
+export function resolveManagedBrowser(pinned: string): string | undefined {
+	if (isBrowserExecutable(pinned)) return pinned
+	let revisionRoot = dirname(pinned)
+	for (;;) {
+		if (CHROMIUM_ENTRY_PATTERN.test(basename(revisionRoot))) break
+		const parent = dirname(revisionRoot)
+		if (parent === revisionRoot) return undefined
+		revisionRoot = parent
+	}
+	const browsersRoot = dirname(revisionRoot)
+	for (const alias of ['chromium', 'chromium.exe']) {
+		const candidate = resolvePath(browsersRoot, alias)
+		if (isBrowserExecutable(candidate)) return candidate
+	}
+	let entries: readonly string[]
+	try {
+		entries = readdirSync(browsersRoot)
+	} catch {
+		return undefined
+	}
+	const revisions = entries
+		.filter((entry) => CHROMIUM_ENTRY_PATTERN.test(entry))
+		.sort(compareRevisions)
+	for (const revision of revisions) {
+		for (const layout of CHROMIUM_LAYOUTS) {
+			const candidate = resolvePath(browsersRoot, revision, layout)
+			if (isBrowserExecutable(candidate)) return candidate
+		}
+	}
+	return undefined
+}
+
+/**
+ * Resolve the Chromium a managed Linux container bundles outside the Playwright cache.
+ *
+ * @param platform - The Node platform the container runs on.
+ * @param root - The bundled browsers directory to search.
+ * @returns The highest matching executable path, or \`undefined\` when none is executable.
+ *
+ * @example
+ * \`\`\`ts
+ * resolveBundledBrowser('linux', BUNDLED_BROWSERS_ROOT)
+ * \`\`\`
+ */
+export function resolveBundledBrowser(platform: NodeJS.Platform, root: string): string | undefined {
+	if (platform !== 'linux') return undefined
+	for (const layout of BUNDLED_CHROMIUM_LAYOUTS) {
+		let matches: readonly string[]
+		try {
+			matches = globSync(layout, { cwd: root })
+		} catch {
+			return undefined
+		}
+		for (const match of [...matches].sort(compareRevisions)) {
+			const candidate = resolvePath(root, match)
+			if (isBrowserExecutable(candidate)) return candidate
+		}
+	}
+	return undefined
+}
+
+/**
+ * Resolve the first installed stable system Chromium channel.
+ *
+ * @param platform - The Node platform whose standard layouts should be probed.
+ * @param environment - The process environment supplying Windows installation roots.
+ * @returns \`chrome\`, then \`msedge\`, or \`undefined\` when neither is executable.
+ *
+ * @example
+ * \`\`\`ts
+ * resolveSystemBrowser(process.platform, process.env)
+ * \`\`\`
+ */
+export function resolveSystemBrowser(
+	platform: NodeJS.Platform,
+	environment: NodeJS.ProcessEnv,
+): string | undefined {
+	if (platform !== 'linux' && platform !== 'darwin' && platform !== 'win32') return undefined
+	const roots = new Set<string>()
+	if (platform === 'win32') {
+		for (const root of [
+			environment.LOCALAPPDATA,
+			environment.PROGRAMFILES,
+			environment['PROGRAMFILES(X86)'],
+		]) {
+			if (root !== undefined && root.length > 0) roots.add(root)
+		}
+		const homeDrive = environment.HOMEDRIVE
+		if (homeDrive !== undefined && homeDrive.length > 0) {
+			roots.add(join(homeDrive, 'Program Files'))
+			roots.add(join(homeDrive, 'Program Files (x86)'))
+		}
+	}
+	for (const browser of SYSTEM_BROWSER_CHANNELS) {
+		if (platform === 'win32') {
+			for (const root of roots) {
+				if (isBrowserExecutable(join(root, ...browser.layouts.win32))) return browser.channel
+			}
+			continue
+		}
+		if (isBrowserExecutable(browser.layouts[platform])) return browser.channel
+	}
+	return undefined
+}
+
+/**
+ * Resolve Playwright provider options for whatever browser this host can actually launch.
+ *
+ * @param pinned - The executable path for Playwright's pinned Chromium revision, when it has one.
+ * @param platform - The Node platform whose standard layouts should be probed.
+ * @param environment - The process environment supplying operator overrides and Windows roots.
+ * @param root - The managed-container bundled browsers directory to search.
+ * @returns Provider options naming an executable, a WebSocket endpoint, or a channel.
+ *
+ * @remarks
+ * Precedence, most important first: \`PLAYWRIGHT_EXECUTABLE_PATH\`, \`PLAYWRIGHT_WS_ENDPOINT\`,
+ * \`PLAYWRIGHT_CHANNEL\`, the managed Playwright Chromium, the container's bundled Chromium, a
+ * verified system channel, then the platform default channel. An operator override outranks
+ * discovery and is returned exactly as given: none of those three environment values is checked
+ * against the filesystem, because verifying an override would defeat the override. The pinned
+ * managed revision outranks anything found on the host because it is deterministic. The installed
+ * pinned revision returns empty options so Playwright keeps its own default launch semantics. Only
+ * a discovered system channel is verified before it is named. The platform default is unverified
+ * as well and exists only as a last resort: Windows takes \`msedge\`, which ships with the OS and
+ * never collides with a foreground Chrome.
+ *
+ * @example
+ * \`\`\`ts
+ * resolveBrowser(resolvePinnedBrowser(), process.platform, process.env)
+ * \`\`\`
+ */
+export function resolveBrowser(
+	pinned: string | undefined,
+	platform: NodeJS.Platform,
+	environment: NodeJS.ProcessEnv,
+	root: string = BUNDLED_BROWSERS_ROOT,
+): PlaywrightProviderOptions {
+	const executable = environment.PLAYWRIGHT_EXECUTABLE_PATH
+	if (executable !== undefined && executable.length > 0) {
+		return { launchOptions: { executablePath: executable } }
+	}
+	const endpoint = environment.PLAYWRIGHT_WS_ENDPOINT
+	if (endpoint !== undefined && endpoint.length > 0) {
+		return { connectOptions: { wsEndpoint: endpoint } }
+	}
+	const requested = environment.PLAYWRIGHT_CHANNEL
+	if (requested !== undefined && requested.length > 0) {
+		return { launchOptions: { channel: requested } }
+	}
+	const managed = pinned === undefined ? undefined : resolveManagedBrowser(pinned)
+	if (managed !== undefined) {
+		return managed === pinned ? {} : { launchOptions: { executablePath: managed } }
+	}
+	const bundled = resolveBundledBrowser(platform, root)
+	if (bundled !== undefined) return { launchOptions: { executablePath: bundled } }
+	const fallback = platform === 'win32' ? 'msedge' : 'chrome'
+	return { launchOptions: { channel: resolveSystemBrowser(platform, environment) ?? fallback } }
+}
+`
 });
 /**
 * Formatter-stable template text for source, test, document, guide, and service artifacts.
@@ -1150,7 +1516,7 @@ npm test
 set -eu
 
 printf '%s\\n' \\
-{{services}}
+{{vendors}}
 ` })
 });
 //#endregion
@@ -1437,7 +1803,9 @@ var isBlueprint = (0, _orkestrel_contract.recordOf)({
 	overrides: (0, _orkestrel_contract.andOf)(isCollection, (0, _orkestrel_contract.arrayOf)(isOverride)),
 	bin: _orkestrel_contract.isBoolean,
 	integration: _orkestrel_contract.isBoolean,
-	services: (0, _orkestrel_contract.andOf)(isCollection, (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString)),
+	conformance: _orkestrel_contract.isBoolean,
+	service: _orkestrel_contract.isBoolean,
+	vendors: (0, _orkestrel_contract.andOf)(isCollection, (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString)),
 	global: _orkestrel_contract.isBoolean,
 	showcase: _orkestrel_contract.isBoolean
 }, ["description"]);
@@ -2029,6 +2397,46 @@ function nameToGuide(name) {
 	return `guides/${name.slice(name.lastIndexOf("/") + 1)}.md`;
 }
 /**
+* Derive the declaration rewrite a published face's `beforeWriteFile` applies.
+*
+* @param name - The workspace's own bare package name.
+* @returns The ternary consequent an emitted `vite.{browser,server}.config.ts`
+* fills its `{{replacement}}` span with, indented for that span.
+*
+* @remarks
+* `vite-plugin-dts` rolls a face into one declaration and keeps each source
+* module's own relative depth, so a nested module emits a path that escapes
+* `dist/src` and a flat one resolves only by luck. Both faces rewrite the same
+* relative core path to the package's published root export, so the branch is
+* derived once here. The extension alternation is what the two permitted import
+* spellings produce: an `@src/core` alias resolves to the core source module and
+* prints `.ts`, while a relative import prints the `.js` specifier it was
+* written with. The formatter keeps the call on one line only while the line it
+* prints measures inside the vendored width, and the workspace name is what
+* varies, so the shape is chosen by measuring the candidate: a tab prints as the
+* vendored two columns, and the gate admits a name long enough to push the
+* joined call past 100.
+*
+* @example
+* ```ts
+* import { nameToRewrite } from '@orkestrel/scaffold'
+*
+* nameToRewrite('router').includes("'@orkestrel/router'") // true
+* ```
+*/
+function nameToRewrite(name) {
+	const specifier = serializeTypeScriptString(`@orkestrel/${name}`);
+	const pattern = "/(?:\\.\\.\\/)+core\\/index\\.[jt]s/g";
+	const joined = `\t\t\t\t\t\t? content.replaceAll(${pattern}, ${specifier})`;
+	if (joined.replaceAll("	", "  ").length <= 100) return joined;
+	return [
+		"						? content.replaceAll(",
+		`\t\t\t\t\t\t\t\t${pattern},`,
+		`\t\t\t\t\t\t\t\t${specifier},`,
+		"							)"
+	].join("\n");
+}
+/**
 * Select the host paths a named workspace vendors.
 *
 * @param paths - The candidate host paths, in their declared order.
@@ -2673,8 +3081,14 @@ function blueprintToDevDependencies(blueprint) {
 * to the axes the blueprint declares: a check and a test script per declared
 * environment, an aggregate over each axis, the policy and configuration
 * proofs every workspace can pass before it has a public API, and one build per
-* target that actually builds. The isolated installed-package integration
-* proof stays out of `test` and runs from `prepublishOnly` instead.
+* target that actually builds.
+*
+* A proof leaves `test` when a real service or a real install answers it. The
+* installed-package integration proof and the live-service proof therefore run
+* from `prepublishOnly` instead. The conformance proof stays in `test`, because
+* it measures this package against official tooling and drives nothing external:
+* a conformance run may start a server, but it starts its own and reaches it
+* over loopback, so the run stays hermetic.
 *
 * The configuration paths interpolated here are the same ones `SRC_MATRIX` and
 * `APP_MATRIX` list as each environment's configuration files, so a rename in
@@ -2721,7 +3135,8 @@ function blueprintToScripts(blueprint) {
 		...compiles ? ["npm run test:src"] : [],
 		...blueprint.app.length > 0 ? ["npm run test:app"] : [],
 		"npm run test:policy",
-		"npm run test:config"
+		"npm run test:config",
+		...blueprint.conformance ? ["npm run test:conformance"] : []
 	].join(" && ");
 	if (compiles) {
 		scripts["test:src"] = [
@@ -2738,8 +3153,10 @@ function blueprintToScripts(blueprint) {
 	}
 	scripts["test:policy"] = `${vitest} --project policy`;
 	scripts["test:config"] = `${vitest} --project config`;
+	if (blueprint.conformance) scripts["test:conformance"] = `${vitest} --project conformance`;
 	scripts["test:probe"] = "vitest run --config vite.config.ts --no-cache --reporter=verbose --project probe";
 	if (integrates) scripts["test:integration"] = `${vitest} --project integration`;
+	if (blueprint.service) scripts["test:service"] = `${vitest} --project service`;
 	scripts.build = [
 		"npm run clean",
 		...compiles ? ["npm run build:src"] : [],
@@ -2769,7 +3186,11 @@ function blueprintToScripts(blueprint) {
 		scripts.serve = "node dist/app/server/main.cjs";
 		scripts["serve:build"] = "npm run build:app:server && npm run serve";
 	}
-	scripts.prepublishOnly = ["npm run format:check && npm run lint:check && npm run check && npm run build && npm test", ...integrates ? ["npm run test:integration"] : []].join(" && ");
+	scripts.prepublishOnly = [
+		"npm run format:check && npm run lint:check && npm run check && npm run build && npm test",
+		...integrates ? ["npm run test:integration"] : [],
+		...blueprint.service ? ["npm run test:service"] : []
+	].join(" && ");
 	return scripts;
 }
 /**
@@ -3051,6 +3472,14 @@ export function appShowcase(...options: never[]): UserConfig {
 	projects.push("config");
 	factories.push(CONFIG_TEMPLATES.factories.guides);
 	projects.push(`...(isExactCaseFile(resolveWorkspacePath('${GUIDES_TEST_PATH}')) ? [guides] : [])`);
+	if (blueprint.conformance) {
+		factories.push(CONFIG_TEMPLATES.factories.conformance);
+		projects.push("conformance");
+	}
+	if (blueprint.service) {
+		factories.push(CONFIG_TEMPLATES.factories.service);
+		projects.push("service");
+	}
 	if (blueprint.src.length > 0 && blueprint.integration) {
 		factories.push((0, _orkestrel_template.fillTemplate)(CONFIG_TEMPLATES.factories.integration, { global: blueprint.global ? "				globalSetup: ['./tests/setupGlobal.ts'],\n" : "" }));
 		projects.push("integration");
@@ -3066,6 +3495,8 @@ ${projects.map((project) => `\t\t\t${project},`).join("\n")}
 		viteTypes: machinery.showcase ? "PluginOption, UserConfig" : "UserConfig",
 		imports: imports.length === 0 ? "" : `${imports.join("\n")}\n`,
 		helpers: boundaries.length === 0 ? "" : `import { ${boundaries.join(", ")} } from './configs/helpers.js'\n`,
+		browsers: machinery.browser ? "import { resolveBrowser, resolvePinnedBrowser } from './configs/browsers.js'\n" : "",
+		options: machinery.browser ? "const browserOptions = resolveBrowser(resolvePinnedBrowser(), process.platform, process.env)\n\n" : "",
 		factories: body,
 		projects: projectRows
 	});
@@ -3099,22 +3530,20 @@ function blueprintToConfigArtifacts(blueprint) {
 		origin: "template",
 		content: blueprintToRootVite(blueprint)
 	}];
+	if (blueprintToMachinery(blueprint).browser) artifacts.push({
+		path: "configs/browsers.ts",
+		group: "configs",
+		ownership: "content",
+		origin: "template",
+		content: CONFIG_TEMPLATES.browsers
+	});
 	for (const environment of blueprint.src) for (const path of SRC_MATRIX[environment].configs) {
 		let content = CONFIG_TEMPLATES.vites.src.core;
 		if (path === "configs/src/tsconfig.core.json") content = CONFIG_TEMPLATES.tsconfigs.src.core;
-		else if (path === "configs/src/vite.browser.config.ts") content = CONFIG_TEMPLATES.vites.src.browser;
+		else if (path === "configs/src/vite.browser.config.ts") content = (0, _orkestrel_template.fillTemplate)(CONFIG_TEMPLATES.vites.src.browser, { replacement: nameToRewrite(blueprint.name) });
 		else if (path === "configs/src/tsconfig.browser.json") content = CONFIG_TEMPLATES.tsconfigs.src.browser;
-		else if (path === "configs/src/vite.server.config.ts") {
-			const packageName = serializeTypeScriptString(`@orkestrel/${blueprint.name}`);
-			const joined = `\t\t\t\t\t\t? content.replaceAll(/(?:\\.\\.\\/)+core\\/index\\.ts/g, ${packageName})`;
-			const replacement = joined.replaceAll("	", "  ").length <= 100 ? joined : [
-				"						? content.replaceAll(",
-				"								/(?:\\.\\.\\/)+core\\/index\\.ts/g,",
-				`\t\t\t\t\t\t\t\t${packageName},`,
-				"							)"
-			].join("\n");
-			content = (0, _orkestrel_template.fillTemplate)(CONFIG_TEMPLATES.vites.src.server, { replacement });
-		} else if (path === "configs/src/tsconfig.server.json") content = CONFIG_TEMPLATES.tsconfigs.src.server;
+		else if (path === "configs/src/vite.server.config.ts") content = (0, _orkestrel_template.fillTemplate)(CONFIG_TEMPLATES.vites.src.server, { replacement: nameToRewrite(blueprint.name) });
+		else if (path === "configs/src/tsconfig.server.json") content = CONFIG_TEMPLATES.tsconfigs.src.server;
 		artifacts.push({
 			path,
 			group: "configs",
@@ -3271,6 +3700,12 @@ function blueprintToSourceArtifacts(blueprint) {
 * workspace and therefore follows the `src` axis as well as its structural
 * flag.
 *
+* The conformance proof is not emitted either, for the reason the guide proof
+* is not: it names an official artifact only the package knows, so a generated
+* placeholder would read as a proof while measuring nothing. `service` emits its
+* readiness setup alone, because the root configuration names that module by
+* path.
+*
 * @example
 * ```ts
 * import { blueprintToTestArtifacts, createBlueprint } from '@orkestrel/scaffold'
@@ -3304,6 +3739,13 @@ function blueprintToTestArtifacts(blueprint) {
 		environment: "server",
 		content: ARTIFACT_TEMPLATES.tests.setup
 	});
+	if (blueprint.service) artifacts.push({
+		path: SERVICE_SETUP_PATH,
+		group: "tests",
+		ownership: "birth",
+		origin: "template",
+		content: ARTIFACT_TEMPLATES.tests.setup
+	});
 	if (blueprint.global) artifacts.push({
 		path: GLOBAL_SETUP_PATH,
 		group: "tests",
@@ -3417,22 +3859,22 @@ function blueprintToDocumentArtifacts(blueprint) {
 * Compile the blueprint-dependent orchestration artifacts.
 *
 * @param blueprint - The workspace specification.
-* @returns A service inventory script when services are declared, otherwise none.
+* @returns A vendor inventory script when vendors are declared, otherwise none.
 *
 * @remarks
-* A service name does not describe startup, readiness, or cleanup. The script
+* A vendor name does not describe startup, readiness, or cleanup. The script
 * therefore records only the declared inventory and does not invent a service
 * runner or test project.
 */
 function blueprintToOrchestrationArtifacts(blueprint) {
-	if (blueprint.services.length === 0) return [];
-	const services = blueprint.services.map((service, index) => `\t'${service}'${index === blueprint.services.length - 1 ? "" : " \\"}`).join("\n");
+	if (blueprint.vendors.length === 0) return [];
+	const vendors = blueprint.vendors.map((vendor, index) => `\t'${vendor}'${index === blueprint.vendors.length - 1 ? "" : " \\"}`).join("\n");
 	return [{
 		path: SERVICE_SCRIPT_PATH,
 		group: "orchestration",
 		ownership: "birth",
 		origin: "template",
-		content: (0, _orkestrel_template.fillTemplate)(ARTIFACT_TEMPLATES.orchestration.service, { services })
+		content: (0, _orkestrel_template.fillTemplate)(ARTIFACT_TEMPLATES.orchestration.service, { vendors })
 	}];
 }
 /**
@@ -3788,19 +4230,19 @@ function blueprintToQuestions(blueprint) {
 		message: "integration projects a published src, and this workspace declares none, so it emits nothing.",
 		blocking: false
 	});
-	const services = /* @__PURE__ */ new Set();
-	for (const service of blueprint.services) {
-		if (!NAME_PATTERN.test(service)) questions.push({
-			field: "services",
-			message: `${service} is not a lowercase alphanumeric service name starting with a letter.`,
+	const vendors = /* @__PURE__ */ new Set();
+	for (const vendor of blueprint.vendors) {
+		if (!NAME_PATTERN.test(vendor)) questions.push({
+			field: "vendors",
+			message: `${vendor} is not a lowercase alphanumeric vendor name starting with a letter.`,
 			blocking: true
 		});
-		else if (services.has(service)) questions.push({
-			field: "services",
-			message: `${service} is declared more than once on services.`,
+		else if (vendors.has(vendor)) questions.push({
+			field: "vendors",
+			message: `${vendor} is declared more than once on vendors.`,
 			blocking: true
 		});
-		services.add(service);
+		vendors.add(vendor);
 	}
 	if (blueprint.showcase && !blueprint.app.includes("browser")) questions.push({
 		field: "showcase",
@@ -4268,8 +4710,8 @@ var Compiler = class {
 * blueprint.
 *
 * @remarks
-* A blueprint is a closed record of sixteen fields, and most of them have one
-* sensible starting value: an empty list, a cleared flag, `DEFAULT_VERSION`, and
+* A blueprint is a closed record, and most of its fields have one sensible
+* starting value: an empty list, a cleared flag, `DEFAULT_VERSION`, and
 * `DEFAULT_ENGINES`. Filling them here is what lets a caller state only what its
 * workspace actually declares.
 *
@@ -4310,7 +4752,9 @@ function createBlueprint(name, input) {
 		overrides: input?.overrides ?? [],
 		bin: input?.bin ?? false,
 		integration: input?.integration ?? false,
-		services: input?.services ?? [],
+		conformance: input?.conformance ?? false,
+		service: input?.service ?? false,
+		vendors: input?.vendors ?? [],
 		global: input?.global ?? false,
 		showcase: input?.showcase ?? false
 	}));
@@ -4347,6 +4791,7 @@ exports.BIN_CONFIGS = BIN_CONFIGS;
 exports.BIN_ENTRY_PATH = BIN_ENTRY_PATH;
 exports.CATALOG_AGENT_PATH = CATALOG_AGENT_PATH;
 exports.CONFIG_TEMPLATES = CONFIG_TEMPLATES;
+exports.CONFORMANCE_TEST_PATH = CONFORMANCE_TEST_PATH;
 exports.CONTROL_CHARACTER_PATTERN = CONTROL_CHARACTER_PATTERN;
 exports.Compiler = Compiler;
 exports.DEFAULT_ENGINES = DEFAULT_ENGINES;
@@ -4380,6 +4825,8 @@ exports.ORCHESTRATION_PATH_NAMES = ORCHESTRATION_PATH_NAMES;
 exports.ORCHESTRATION_PATH_PREFIXES = ORCHESTRATION_PATH_PREFIXES;
 exports.ORKESTREL_RANGE_PATTERN = ORKESTREL_RANGE_PATTERN;
 exports.SERVICE_SCRIPT_PATH = SERVICE_SCRIPT_PATH;
+exports.SERVICE_SETUP_PATH = SERVICE_SETUP_PATH;
+exports.SERVICE_TEST_INCLUDE = SERVICE_TEST_INCLUDE;
 exports.SHOWCASE_CONFIG_PATH = SHOWCASE_CONFIG_PATH;
 exports.SHOWCASE_DEV_DEPENDENCIES = SHOWCASE_DEV_DEPENDENCIES;
 exports.SOURCE_BROWSER_DEV_DEPENDENCIES = SOURCE_BROWSER_DEV_DEPENDENCIES;
@@ -4446,6 +4893,7 @@ exports.matchesOrchestrationPath = matchesOrchestrationPath;
 exports.matchesRange = matchesRange;
 exports.nameToGuide = nameToGuide;
 exports.nameToHostArtifacts = nameToHostArtifacts;
+exports.nameToRewrite = nameToRewrite;
 exports.overridesToQuestions = overridesToQuestions;
 exports.parseBlueprint = parseBlueprint;
 exports.parseCompilerOptions = parseCompilerOptions;