@orkestrel/scaffold 0.0.72 → 0.0.74

package/dist/host/tests/config.test.ts

@@ -5,6 +5,7 @@ import { spawnSync } from 'node:child_process'
 import {
 	existsSync,
 	globSync,
+	lstatSync,
 	mkdtempSync,
 	mkdirSync,
 	readdirSync,
@@ -63,6 +64,33 @@ import { describe, expect, it } from 'vitest'
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
 
+// The `src` axis a declaration roll-up reads, derived from a recognized source environment that is
+// a physical directory rather than from a `src` entry of any shape. A regular file, an empty
+// directory, a directory holding no recognized environment, a symbolic link, and an entry this host
+// refuses to inspect each leave a workspace publishing nothing, and reading the entry alone would
+// put every one of them under the face proof. The inspection is caught rather than excused by
+// option: `throwIfNoEntry` excuses an absent path alone and rethrows a permission refusal, and a
+// throw on this line is a collection error that takes this whole file down in that target rather
+// than failing one case. `isPhysicalDirectory` reads the same two facts off an `lstat` and returns
+// false for every inspection error, and this reads them the same way. This is the derivation
+// `targetToEnvironments` uses, which filters the environment names by a contained physical
+// directory, and it answers the same question `blueprintToScripts`
+// answers from a blueprint's own `src` list. A workspace declaring app environments alone publishes
+// no library, so it vendors no `configs/src/` face wrapper and has no roll-up to measure. A face
+// proof is conditioned on this axis rather than on a face wrapper: a workspace that declares the
+// axis and vendors no wrapper carries the defect such a proof reports, so that workspace must still
+// fail the proof. The manifest cases read the same fact from their own `private` flag and name it
+// `manifestPublishes` for the source that decides it there; this reads the axis on disk, so a
+// workspace whose manifest and shape disagree fails one of the two rather than neither.
+const publishes = ['core', 'browser', 'server'].some((environment) => {
+	try {
+		const entry = lstatSync(resolve(root, 'src', environment))
+		return entry.isDirectory() && !entry.isSymbolicLink()
+	} catch {
+		return false
+	}
+})
+
 // A declaration roll-up loads the extractor package, which only a workspace publishing source from
 // `src` installs. The resolution below is the mechanism its proof is conditioned on.
 let extractorPath: string | undefined
@@ -199,8 +227,8 @@ describe('root configuration', () => {
 			setup: ['./tests/setup.ts'],
 		})
 		// A row that is a configuration rather than a factory. Every generated
-		// workspace registers the factory itself, so this shape is required here
-		// rather than observed: the proof exercises that resolution wherever it runs
+		// workspace registers the factory itself, so this shape is required by the
+		// expectation rather than observed: the proof exercises that resolution wherever it runs
 		// instead of only where a hand-written configuration happens to produce it.
 		expected.set('concrete', { include: 'tests/concrete.test.ts', setup: ['./tests/setup.ts'] })
 
@@ -418,6 +446,9 @@ describe('root configuration', () => {
 		if (existsSync(resolve(root, 'configs/app/vite.showcase.config.ts'))) {
 			required.push('configs/app/vite.showcase.config.ts')
 		}
+		if (existsSync(resolve(root, 'configs/app/vite.journey.config.ts'))) {
+			required.push('configs/app/vite.journey.config.ts')
+		}
 		if (required[0] === undefined) {
 			throw new Error('The workspace selects no configuration target')
 		}
@@ -432,80 +463,172 @@ describe('root configuration', () => {
 		).map((path) => path.replaceAll('\\', '/'))
 		const extra = 'configs/app/vite.core.config.ts'
 		const controlled = found.concat(extra)
+		const planted = createPolicyScratch({ prefix: 'config-journey-' })
+		const journey = 'configs/app/vite.journey.config.ts'
+		planted.write(
+			journey,
+			`export default {
+	test: { projects: [() => ({
+		test: {
+			name: { label: 'journey:desktop' },
+			include: ['tests/app/browser/integration.test.ts'],
+			exclude: [],
+			setupFiles: ['./tests/setup.ts', './tests/setupBrowser.ts'],
+			provide: { variant: 'desktop', variants: [{ name: 'desktop', width: 1280, height: 800 }], capture: false },
+			browser: { enabled: true, instances: [{ browser: 'chromium', headless: true }] },
+		},
+	})] },
+}\n`,
+		)
+		const journeys: object[][] = []
+		const targets = required.map((wrapper) => ({ wrapper, directory: root }))
+		targets.push({ wrapper: journey, directory: planted.path })
+		controlled.push(journey)
 
 		// Required wrappers come from selected src/app targets. Only that set is loaded and validated.
 		// Extra wrappers remain in the found population but are ignored before their content is read.
 		expect(controlled).toContain(extra)
 		expect(required).not.toContain(extra)
-		for (const wrapper of required) {
-			expect(controlled).toContain(wrapper)
-			const viteMatch =
-				/^configs\/(src|app)\/vite\.(core|browser|server|bin|showcase)\.config\.ts$/u.exec(wrapper)
-			if (viteMatch !== null) {
-				const [, axis, environment] = viteMatch
+		try {
+			for (const { wrapper, directory } of targets) {
+				expect(controlled).toContain(wrapper)
+				const viteMatch =
+					/^configs\/(src|app)\/vite\.(core|browser|server|bin|showcase|journey)\.config\.ts$/u.exec(
+						wrapper,
+					)
+				if (viteMatch !== null) {
+					const [, axis, environment] = viteMatch
+					if (axis === undefined || environment === undefined) {
+						throw new Error(`${wrapper} carries no target`)
+					}
+					const loaded = await loadConfigFromFile(
+						{ command: 'build', mode: 'test', isSsrBuild: false, isPreview: false },
+						resolve(directory, wrapper),
+						directory,
+						'silent',
+					)
+					if (loaded === null) throw new Error(`${wrapper} did not load`)
+					if (environment === 'journey') {
+						const projects = loaded.config.test?.projects
+						if (!Array.isArray(projects) || projects.length === 0) {
+							throw new Error(`${wrapper} carries no journey projects`)
+						}
+						const tests: object[] = []
+						for (const factory of projects) {
+							if (typeof factory !== 'function')
+								throw new Error(`${wrapper} carries no project factory`)
+							const project: unknown = await Reflect.apply(factory, undefined, [
+								{ command: 'serve', mode: 'test' },
+							])
+							if (typeof project !== 'object' || project === null)
+								throw new Error('A journey project is not a configuration')
+							const test: unknown = Object.getOwnPropertyDescriptor(project, 'test')?.value
+							if (typeof test !== 'object' || test === null)
+								throw new Error('A journey project carries no test block')
+							tests.push(test)
+						}
+						journeys.push(tests)
+						continue
+					}
+					const output = loaded.config.build?.outDir
+					if (output === undefined) throw new Error(`${wrapper} carries no output`)
+					const expected =
+						environment === 'bin'
+							? 'dist/bin'
+							: environment === 'showcase'
+								? 'dist/showcase'
+								: `dist/${axis}/${environment}`
+					if (resolve(root, output) !== resolve(root, expected)) {
+						throw new Error(`${wrapper} resolves to the wrong output`)
+					}
+					continue
+				}
+
+				const tsconfigMatch =
+					/^configs\/(src|app)\/tsconfig\.(core|browser|server|bin)\.json$/u.exec(wrapper)
+				if (tsconfigMatch === null) {
+					throw new Error(`${wrapper} is not a required target wrapper`)
+				}
+				const [, axis, environment] = tsconfigMatch
 				if (axis === undefined || environment === undefined) {
-					throw new Error(`${wrapper} carries no target`)
+					throw new Error(`${wrapper} carries no TypeScript scope`)
 				}
-				const loaded = await loadConfigFromFile(
-					{ command: 'build', mode: 'test', isSsrBuild: false, isPreview: false },
-					resolve(root, wrapper),
-					root,
-					'silent',
-				)
-				if (loaded === null) throw new Error(`${wrapper} did not load`)
-				const output = loaded.config.build?.outDir
-				if (output === undefined) throw new Error(`${wrapper} carries no output`)
-				const expected =
-					environment === 'bin'
-						? 'dist/bin'
-						: environment === 'showcase'
-							? 'dist/showcase'
-							: `dist/${axis}/${environment}`
-				if (resolve(root, output) !== resolve(root, expected)) {
-					throw new Error(`${wrapper} resolves to the wrong output`)
+				const parsed: unknown = JSON.parse(readFileSync(resolve(root, wrapper), 'utf8'))
+				if (typeof parsed !== 'object' || parsed === null) {
+					throw new Error(`${wrapper} is not a TypeScript configuration record`)
 				}
-				continue
-			}
-
-			const tsconfigMatch = /^configs\/(src|app)\/tsconfig\.(core|browser|server|bin)\.json$/u.exec(
-				wrapper,
-			)
-			if (tsconfigMatch === null) {
-				throw new Error(`${wrapper} is not a required target wrapper`)
-			}
-			const [, axis, environment] = tsconfigMatch
-			if (axis === undefined || environment === undefined) {
-				throw new Error(`${wrapper} carries no TypeScript scope`)
-			}
-			const parsed: unknown = JSON.parse(readFileSync(resolve(root, wrapper), 'utf8'))
-			if (typeof parsed !== 'object' || parsed === null) {
-				throw new Error(`${wrapper} is not a TypeScript configuration record`)
+				const compilerOptions: unknown = Object.getOwnPropertyDescriptor(
+					parsed,
+					'compilerOptions',
+				)?.value
+				if (typeof compilerOptions !== 'object' || compilerOptions === null) {
+					throw new Error(`${wrapper} carries no compiler options`)
+				}
+				const lib: unknown = Object.getOwnPropertyDescriptor(compilerOptions, 'lib')?.value
+				const types: unknown = Object.getOwnPropertyDescriptor(compilerOptions, 'types')?.value
+				const expectedLib =
+					environment === 'core'
+						? ['ESNext', 'WebWorker']
+						: environment === 'browser'
+							? ['ESNext', 'DOM', 'DOM.Iterable']
+							: ['ESNext']
+				const expectedTypes =
+					environment === 'core'
+						? []
+						: environment === 'browser'
+							? axis === 'app'
+								? ['vite/client', 'vue']
+								: ['vite/client']
+							: ['node']
+				expect(lib).toStrictEqual(expectedLib)
+				expect(types).toStrictEqual(expectedTypes)
 			}
-			const compilerOptions: unknown = Object.getOwnPropertyDescriptor(
-				parsed,
-				'compilerOptions',
-			)?.value
-			if (typeof compilerOptions !== 'object' || compilerOptions === null) {
-				throw new Error(`${wrapper} carries no compiler options`)
+			for (const tests of journeys) {
+				const names: string[] = []
+				for (const test of tests) {
+					expect(Object.getOwnPropertyDescriptor(test, 'include')?.value).toStrictEqual([
+						'tests/app/browser/integration.test.ts',
+					])
+					expect(Object.getOwnPropertyDescriptor(test, 'exclude')?.value).toStrictEqual([])
+					expect(Object.getOwnPropertyDescriptor(test, 'setupFiles')?.value).toStrictEqual([
+						'./tests/setup.ts',
+						'./tests/setupBrowser.ts',
+					])
+					const name: unknown = Object.getOwnPropertyDescriptor(test, 'name')?.value
+					const provide: unknown = Object.getOwnPropertyDescriptor(test, 'provide')?.value
+					const browser: unknown = Object.getOwnPropertyDescriptor(test, 'browser')?.value
+					if (
+						typeof name !== 'object' ||
+						name === null ||
+						typeof provide !== 'object' ||
+						provide === null ||
+						typeof browser !== 'object' ||
+						browser === null
+					)
+						throw new Error('A journey project carries no name, provide, or browser block')
+					const variant: unknown = Object.getOwnPropertyDescriptor(provide, 'variant')?.value
+					if (typeof variant !== 'string' || variant.length === 0)
+						throw new Error('A journey project carries no variant name')
+					expect(Object.getOwnPropertyDescriptor(name, 'label')?.value).toBe(`journey:${variant}`)
+					expect(typeof Object.getOwnPropertyDescriptor(provide, 'capture')?.value).toBe('boolean')
+					expect(Object.getOwnPropertyDescriptor(browser, 'enabled')?.value).toBe(true)
+					const variants: unknown = Object.getOwnPropertyDescriptor(provide, 'variants')?.value
+					if (
+						!Array.isArray(variants) ||
+						!variants.some(
+							(candidate: unknown) =>
+								typeof candidate === 'object' &&
+								candidate !== null &&
+								Object.getOwnPropertyDescriptor(candidate, 'name')?.value === variant,
+						)
+					)
+						throw new Error('A journey variant is absent from its declared set')
+					expect(names).not.toContain(variant)
+					names.push(variant)
+				}
 			}
-			const lib: unknown = Object.getOwnPropertyDescriptor(compilerOptions, 'lib')?.value
-			const types: unknown = Object.getOwnPropertyDescriptor(compilerOptions, 'types')?.value
-			const expectedLib =
-				environment === 'core'
-					? ['ESNext', 'WebWorker']
-					: environment === 'browser'
-						? ['ESNext', 'DOM', 'DOM.Iterable']
-						: ['ESNext']
-			const expectedTypes =
-				environment === 'core'
-					? []
-					: environment === 'browser'
-						? axis === 'app'
-							? ['vite/client', 'vue']
-							: ['vite/client']
-						: ['node']
-			expect(lib).toStrictEqual(expectedLib)
-			expect(types).toStrictEqual(expectedTypes)
+		} finally {
+			planted.destroy()
 		}
 
 		const controlRequired = [
@@ -530,7 +653,7 @@ describe('root configuration', () => {
 		if (typeof scripts !== 'object' || scripts === null) {
 			throw new Error('The package manifest carries no scripts')
 		}
-		const publishes = Object.getOwnPropertyDescriptor(manifest, 'private')?.value !== true
+		const manifestPublishes = Object.getOwnPropertyDescriptor(manifest, 'private')?.value !== true
 		const test = Object.getOwnPropertyDescriptor(scripts, 'test')?.value
 		const config = Object.getOwnPropertyDescriptor(scripts, 'test:config')?.value
 		const distribution = Object.getOwnPropertyDescriptor(scripts, 'test:distribution')?.value
@@ -576,9 +699,9 @@ describe('root configuration', () => {
 		)
 		expect(typeof test === 'string' && test.includes('test:distribution')).toBe(false)
 		expect(typeof publish === 'string' && publish.includes('npm run test:distribution')).toBe(
-			hasDistribution && publishes,
+			hasDistribution && manifestPublishes,
 		)
-		expect(typeof publish === 'string').toBe(publishes)
+		expect(typeof publish === 'string').toBe(manifestPublishes)
 		expect(integration).toBe(
 			hasIntegration
 				? 'vitest run --config vite.config.ts --no-cache --reporter=dot --project integration'
@@ -610,10 +733,10 @@ describe('root configuration', () => {
 				: undefined,
 		)
 		expect(typeof test === 'string' && test.includes('npm run test:service')).toBe(
-			hasService && !publishes,
+			hasService && !manifestPublishes,
 		)
 		expect(typeof publish === 'string' && publish.includes('npm run test:service')).toBe(
-			hasService && publishes,
+			hasService && manifestPublishes,
 		)
 	})
 
@@ -626,14 +749,14 @@ describe('root configuration', () => {
 		if (typeof scripts !== 'object' || scripts === null) {
 			throw new Error('The package manifest carries no scripts')
 		}
-		const publishes = Object.getOwnPropertyDescriptor(manifest, 'private')?.value !== true
+		const manifestPublishes = Object.getOwnPropertyDescriptor(manifest, 'private')?.value !== true
 		const prepack = Object.getOwnPropertyDescriptor(scripts, 'prepack')?.value
-		expect(prepack).toBe(publishes ? 'npm run build' : undefined)
+		expect(prepack).toBe(manifestPublishes ? 'npm run build' : undefined)
 
 		const controlled = { ...scripts, prepack: 'npm run control' }
 		expect(() => {
 			const control = Object.getOwnPropertyDescriptor(controlled, 'prepack')?.value
-			expect(control).toBe(publishes ? 'npm run build' : undefined)
+			expect(control).toBe(manifestPublishes ? 'npm run build' : undefined)
 		}).toThrow(/expected/u)
 	})
 
@@ -2150,54 +2273,81 @@ describe('configuration helpers', () => {
 		}
 	})
 
-	it('reads the compiler scope and fixed extractor override a declaration roll-up requires', () => {
-		const compiler = createRequire(import.meta.url).resolve('typescript/bin/tsc')
-		// The order mirrors ENVIRONMENTS in src/core/constants.ts; a server-only workspace vendors
-		// no core project, so this walks to the first face the workspace actually carries.
-		const faces = ['core', 'browser', 'server']
-		const face = faces.find((candidate) =>
-			existsSync(resolve(root, `configs/src/tsconfig.${candidate}.json`)),
-		)
-		if (face === undefined) throw new Error('The workspace declares no face project')
-		const project = resolve(root, `configs/src/tsconfig.${face}.json`)
-		const declared: unknown = JSON.parse(readFileSync(project, 'utf8'))
-		if (typeof declared !== 'object' || declared === null) {
-			throw new Error(`The ${face} project is not a TypeScript configuration record`)
-		}
-		const declaredOptions: unknown = Object.getOwnPropertyDescriptor(
-			declared,
-			'compilerOptions',
-		)?.value
-		if (typeof declaredOptions !== 'object' || declaredOptions === null) {
-			throw new Error(`The ${face} project carries no compiler options`)
-		}
-		const declaredLib: unknown = Object.getOwnPropertyDescriptor(declaredOptions, 'lib')?.value
-		const declaredTypes: unknown = Object.getOwnPropertyDescriptor(declaredOptions, 'types')?.value
-		if (!configHelpers.isStringList(declaredLib) || !configHelpers.isStringList(declaredTypes)) {
-			throw new Error(`The ${face} project declares no lib or types`)
-		}
-		const declaredRootDir: unknown = Object.getOwnPropertyDescriptor(
-			declaredOptions,
-			'rootDir',
-		)?.value
-		if (typeof declaredRootDir !== 'string') {
-			throw new Error(`The ${face} project declares no rootDir`)
-		}
-		const expectedRoot = resolve(dirname(project), declaredRootDir)
+	// The scope reading applies only where the workspace publishes source from `src`, which is what
+	// `publishes` reads, and the name ends at that mechanism. An absent face project is the defect
+	// this case exists to report rather than a second reason to excuse it, so a workspace holding
+	// the axis and vendoring no `configs/src/` wrapper reaches the throw inside the body.
+	// A skip raises the run's skipped count where a guard inside the case would
+	// raise its passed count with nothing measured. Every generated workspace runs its projects
+	// under `--reporter=dot`, which prints a skip as an unnamed `-`, so the case name and the
+	// condition in it are read by re-running the project with a reporter that names skipped cases.
+	it.skipIf(!publishes)(
+		'reads the compiler scope a declaration roll-up requires [inapplicable where src holds no recognized environment directory]',
+		() => {
+			const compiler = createRequire(import.meta.url).resolve('typescript/bin/tsc')
+			// The order mirrors ENVIRONMENTS in src/core/constants.ts; a server-only workspace vendors
+			// no core project, so this walks to the first face the workspace actually carries.
+			const faces = ['core', 'browser', 'server']
+			const face = faces.find((candidate) =>
+				existsSync(resolve(root, `configs/src/tsconfig.${candidate}.json`)),
+			)
+			if (face === undefined) throw new Error('The workspace declares no face project')
+			const project = resolve(root, `configs/src/tsconfig.${face}.json`)
+			const declared: unknown = JSON.parse(readFileSync(project, 'utf8'))
+			if (typeof declared !== 'object' || declared === null) {
+				throw new Error(`The ${face} project is not a TypeScript configuration record`)
+			}
+			const declaredOptions: unknown = Object.getOwnPropertyDescriptor(
+				declared,
+				'compilerOptions',
+			)?.value
+			if (typeof declaredOptions !== 'object' || declaredOptions === null) {
+				throw new Error(`The ${face} project carries no compiler options`)
+			}
+			const declaredLib: unknown = Object.getOwnPropertyDescriptor(declaredOptions, 'lib')?.value
+			const declaredTypes: unknown = Object.getOwnPropertyDescriptor(
+				declaredOptions,
+				'types',
+			)?.value
+			if (!configHelpers.isStringList(declaredLib) || !configHelpers.isStringList(declaredTypes)) {
+				throw new Error(`The ${face} project declares no lib or types`)
+			}
+			const declaredRootDir: unknown = Object.getOwnPropertyDescriptor(
+				declaredOptions,
+				'rootDir',
+			)?.value
+			if (typeof declaredRootDir !== 'string') {
+				throw new Error(`The ${face} project declares no rootDir`)
+			}
+			const expectedRoot = resolve(dirname(project), declaredRootDir)
 
-		const scope = configHelpers.parseProjectScope(
-			configHelpers.readCompilerOutput(compiler, ['--showConfig', '-p', project]),
-			project,
-		)
-		if (scope === undefined) throw new Error(`The ${face} project resolved no compiler scope`)
-		// The compiler lowercases every resolved library name, so the committed project is the
-		// second mechanism this reading is compared against rather than the reading itself.
-		expect(scope.lib.map((entry) => entry.toLowerCase())).toStrictEqual(
-			declaredLib.map((entry) => entry.toLowerCase()),
-		)
-		expect(scope.types).toStrictEqual(declaredTypes)
-		expect(scope.root).toBe(expectedRoot)
+			const scope = configHelpers.parseProjectScope(
+				configHelpers.readCompilerOutput(compiler, ['--showConfig', '-p', project]),
+				project,
+			)
+			if (scope === undefined) throw new Error(`The ${face} project resolved no compiler scope`)
+			// The compiler lowercases every resolved library name, so the committed project is the
+			// second mechanism this reading is compared against rather than the reading itself.
+			expect(scope.lib.map((entry) => entry.toLowerCase())).toStrictEqual(
+				declaredLib.map((entry) => entry.toLowerCase()),
+			)
+			expect(scope.types).toStrictEqual(declaredTypes)
+			expect(scope.root).toBe(expectedRoot)
+		},
+	)
 
+	// No reading in this case reads anything under `configs/src/`, so each one applies to a workspace
+	// on either axis. The refusals are decided by the text handed to them; the compiler refusal by a
+	// path no workspace shape carries; the manifest name, the module resolution, and the extractor
+	// guard by files and packages a workspace carries on either axis. They sit apart from the
+	// preceding scope reading for that reason: the skip that excuses an app-only workspace from
+	// reading a face project must not excuse it from the helpers behind the roll-up, which it
+	// vendors whether or not it publishes.
+	it('reads the refusals, guards, overrides, and rewrites a declaration roll-up requires from every workspace', () => {
+		const compiler = createRequire(import.meta.url).resolve('typescript/bin/tsc')
+		// Any project path resolves these, because each reading is refused by the text before the
+		// path is read. The root project is the one file every workspace carries.
+		const project = resolve(root, 'tsconfig.json')
 		expect(configHelpers.parseProjectScope('not a configuration', project)).toBeUndefined()
 		expect(
 			configHelpers.parseProjectScope('{"compilerOptions":{"lib":[],"types":[]}}', project),
@@ -2205,11 +2355,12 @@ describe('configuration helpers', () => {
 		expect(
 			configHelpers.parseProjectScope('{"compilerOptions":{"lib":[1],"rootDir":"."}}', project),
 		).toBeUndefined()
+		// The compiler's own refusal, read from a path no workspace shape carries.
 		expect(() =>
 			configHelpers.readCompilerOutput(compiler, [
 				'--showConfig',
 				'-p',
-				resolve(root, 'configs/src/tsconfig.absent.json'),
+				resolve(root, 'configs/tsconfig.absent.json'),
 			]),
 		).toThrow('The declaration compiler failed')
 

package/dist/host/tests/policy.test.ts

@@ -524,7 +524,17 @@ describe('skill family policy', () => {
 		expect(frontmatter?.description).toBe('Use this skill when a continuation contains: a colon.')
 	})
 
-	for (const control of SKILL_POLICY_CONTROLS) {
+	for (const control of SKILL_POLICY_CONTROLS.filter(
+		(candidate) => candidate.violations !== undefined,
+	)) {
+		it(`${control.label} [membership: ${control.membership}]`, () => {
+			expect(inspectPolicyControl(control)).toEqual(control.violations)
+		})
+	}
+
+	for (const control of SKILL_POLICY_CONTROLS.filter(
+		(candidate) => candidate.violations === undefined,
+	)) {
 		it(`${control.label} [membership: ${control.membership}]`, () => {
 			const violations = inspectPolicyControl(control)
 			expect(violations).toHaveLength(1)