@orkestrel/scaffold 0.0.31 → 0.0.32

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

@@ -42,7 +42,7 @@ describe('root configuration', () => {
 			for (const key of required.keys()) {
 				if (!absent.has(key)) throw new Error('The alias population carries no required entry')
 			}
-		}).toThrowError('The alias population carries no required entry')
+		}).toThrow('The alias population carries no required entry')
 		for (const [key, expected] of required) {
 			const values = declared.get(key)
 			if (values === undefined) throw new Error(`${key} is not declared`)
@@ -102,7 +102,14 @@ describe('root configuration', () => {
 				setup: ['./tests/setup.ts', './tests/setupServer.ts'],
 			})
 		}
-		for (const label of ['policy', 'config', 'guides', 'conformance', 'integration']) {
+		for (const label of [
+			'policy',
+			'config',
+			'guides',
+			'conformance',
+			'distribution',
+			'integration',
+		]) {
 			if (!existsSync(resolve(root, `tests/${label}.test.ts`))) continue
 			expected.set(label, {
 				include: `tests/${label}.test.ts`,
@@ -218,7 +225,7 @@ describe('root configuration', () => {
 		expect(missing.delete('probe')).toBe(true)
 		expect(() => {
 			for (const [label, project] of expected) expect(missing.get(label)).toStrictEqual(project)
-		}).toThrowError(/strictly equal/u)
+		}).toThrow(/strictly equal/u)
 
 		const misconfigured = new Map(configured)
 		const probe = misconfigured.get('probe')
@@ -227,7 +234,7 @@ describe('root configuration', () => {
 		expect(() => {
 			for (const [label, project] of expected)
 				expect(misconfigured.get(label)).toStrictEqual(project)
-		}).toThrowError(/strictly equal/u)
+		}).toThrow(/strictly equal/u)
 	})
 
 	it('requires and validates every selected target wrapper', async () => {
@@ -344,10 +351,10 @@ describe('root configuration', () => {
 		const controlFound = ['configs/app/vite.server.config.ts']
 		expect(() => {
 			for (const wrapper of controlRequired) expect(controlFound).toContain(wrapper)
-		}).toThrowError(/vite\.browser/u)
-		expect(() =>
-			expect(resolve(root, 'dist/actual')).toBe(resolve(root, 'dist/control')),
-		).toThrowError(/expected/u)
+		}).toThrow(/vite\.browser/u)
+		expect(() => expect(resolve(root, 'dist/actual')).toBe(resolve(root, 'dist/control'))).toThrow(
+			/expected/u,
+		)
 	})
 
 	it('registers proof scripts in the correct gate', () => {
@@ -359,8 +366,10 @@ 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 test = Object.getOwnPropertyDescriptor(scripts, 'test')?.value
 		const config = Object.getOwnPropertyDescriptor(scripts, 'test:config')?.value
+		const distribution = Object.getOwnPropertyDescriptor(scripts, 'test:distribution')?.value
 		const integration = Object.getOwnPropertyDescriptor(scripts, 'test:integration')?.value
 		const conformance = Object.getOwnPropertyDescriptor(scripts, 'test:conformance')?.value
 		const service = Object.getOwnPropertyDescriptor(scripts, 'test:service')?.value
@@ -390,24 +399,39 @@ describe('root configuration', () => {
 		expect(registered.has('config')).toBe(true)
 		expect(registered.has('control')).toBe(false)
 		const hasConformance = registered.has('conformance')
+		const hasDistribution = registered.has('distribution')
 		const hasService = registered.has('service')
 		expect(config).toBe(
 			'vitest run --config vite.config.ts --no-cache --reporter=dot --project config',
 		)
 		expect(typeof test === 'string' && test.includes('npm run test:config')).toBe(true)
+		expect(distribution).toBe(
+			hasDistribution
+				? 'vitest run --config vite.config.ts --no-cache --reporter=dot --project distribution'
+				: undefined,
+		)
+		expect(typeof test === 'string' && test.includes('test:distribution')).toBe(false)
+		expect(typeof publish === 'string' && publish.includes('npm run test:distribution')).toBe(
+			hasDistribution && publishes,
+		)
+		expect(typeof publish === 'string').toBe(publishes)
 		expect(integration).toBe(
 			hasIntegration
 				? 'vitest run --config vite.config.ts --no-cache --reporter=dot --project integration'
 				: undefined,
 		)
-		expect(typeof test === 'string' && test.includes('test:integration')).toBe(false)
-		expect(typeof publish === 'string' && publish.includes('npm run test:integration')).toBe(
+		// The integration seed composes barrels and starts no process, so it runs in
+		// `test` like any other hermetic proof. `prepublishOnly` reaches it through
+		// `npm test` rather than through a second direct invocation.
+		expect(typeof test === 'string' && test.includes('npm run test:integration')).toBe(
 			hasIntegration,
 		)
+		expect(typeof publish === 'string' && publish.includes('npm run test:integration')).toBe(false)
 		// A registered project no gate runs is a proof that never executes, and it
 		// never fails, so the suite reports green while carrying it. Conformance is
-		// hermetic and belongs to `test`; the live-service project drives a real
-		// service and belongs to `prepublishOnly` alone.
+		// hermetic and belongs to `test`. A publishing workspace isolates the
+		// live-service project in `prepublishOnly`; a private workspace reaches it
+		// from `test`, because npm never runs a private package's publish lifecycle.
 		expect(conformance).toBe(
 			hasConformance
 				? 'vitest run --config vite.config.ts --no-cache --reporter=dot --project conformance'
@@ -421,8 +445,12 @@ describe('root configuration', () => {
 				? 'vitest run --config vite.config.ts --no-cache --reporter=dot --project service'
 				: undefined,
 		)
-		expect(typeof test === 'string' && test.includes('test:service')).toBe(false)
-		expect(typeof publish === 'string' && publish.includes('npm run test:service')).toBe(hasService)
+		expect(typeof test === 'string' && test.includes('npm run test:service')).toBe(
+			hasService && !publishes,
+		)
+		expect(typeof publish === 'string' && publish.includes('npm run test:service')).toBe(
+			hasService && publishes,
+		)
 	})
 })
 
@@ -562,9 +590,9 @@ describe('configuration helpers', () => {
 		expect(() => configHelpers.enforceOutputPath(expected, expected)).not.toThrow()
 		expect(() =>
 			configHelpers.enforceOutputPath(resolve(root, 'dist/outside-control'), expected),
-		).toThrowError('Build output must use its exact configured workspace directory')
+		).toThrow('Build output must use its exact configured workspace directory')
 		const outside = resolve(dirname(root), 'outside-config-control')
-		expect(() => configHelpers.enforceOutputPath(outside, outside)).toThrowError(
+		expect(() => configHelpers.enforceOutputPath(outside, outside)).toThrow(
 			'Build output must remain inside the workspace',
 		)
 	})
@@ -611,7 +639,7 @@ describe('configuration helpers', () => {
 				error: expect.unreachable,
 				resolve: Promise.resolve.bind(Promise, { id: source }),
 			}
-			await expect(Reflect.apply(hook, context, ['@src/server', source])).rejects.toThrowError(
+			await expect(Reflect.apply(hook, context, ['@src/server', source])).rejects.toThrow(
 				'Browser modules cannot depend on Node or server-only modules',
 			)
 			await expect(Reflect.apply(hook, context, ['@src/core', source])).resolves.toBeNull()

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

@@ -7,6 +7,8 @@ import {
 	inspectPolicySources,
 	inspectPolicyWorkspace,
 	POLICY_CONTROLS,
+	stemToPolicyCandidates,
+	testToPolicyStem,
 } from './setupPolicy.js'
 
 describe('fleet policy register', () => {
@@ -25,8 +27,258 @@ describe('fleet policy register', () => {
 			'tests/app/browser/routes.test.ts',
 			'tests/app/edge/deep/integration.test.ts',
 		]
-		const sources = new Set(['src/worker/Worker.ts', 'app/browser/routes.ts'])
-		expect(inspectPolicyMirrorPaths(tests, sources)).toEqual([])
+		const modules = new Set(['src/worker/Worker.ts', 'app/browser/routes.ts'])
+		expect(inspectPolicyMirrorPaths(tests, modules)).toEqual([])
+	})
+
+	it('derives mirror candidates in module resolution order', () => {
+		const stem = testToPolicyStem('tests/app/core/setupBrowser.test.ts')
+		expect(stem).toBe('app/core/setupBrowser')
+		expect(stemToPolicyCandidates('app/core/setupBrowser')).toEqual([
+			'app/core/setupBrowser.cts',
+			'app/core/setupBrowser.mts',
+			'app/core/setupBrowser.ts',
+			'app/core/setupBrowser.tsx',
+			'app/core/setupBrowser.vue',
+			'app/core/setupBrowser.scss',
+			'app/core/setupBrowser.css',
+			'app/core/_setupBrowser.scss',
+			'app/core/_setupBrowser.css',
+			'tests/app/core/setupBrowser.ts',
+		])
+		expect(testToPolicyStem('tests/app/core/integration.test.ts')).toBeUndefined()
+	})
+})
+
+describe('policy population controls', () => {
+	it('accepts a Vue module mirror', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a Vue module mirror',
+				membership: 'registered module extensions with an exact test stem',
+				rule: 'mirror',
+				files: [
+					{ path: 'app/browser/Widget.vue', content: '<template></template>\n' },
+					{ path: 'tests/app/browser/Widget.test.ts', content: '' },
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a TSX module mirror', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a TSX module mirror',
+				membership: 'registered module extensions with an exact test stem',
+				rule: 'mirror',
+				files: [
+					{ path: 'app/browser/Widget.tsx', content: '' },
+					{ path: 'tests/app/browser/Widget.test.ts', content: '' },
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts an MTS module mirror', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts an MTS module mirror',
+				membership: 'registered module extensions with an exact test stem',
+				rule: 'mirror',
+				files: [
+					{ path: 'app/browser/Widget.mts', content: '' },
+					{ path: 'tests/app/browser/Widget.test.ts', content: '' },
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a CTS module mirror', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a CTS module mirror',
+				membership: 'registered module extensions with an exact test stem',
+				rule: 'mirror',
+				files: [
+					{ path: 'app/browser/Widget.cts', content: '' },
+					{ path: 'tests/app/browser/Widget.test.ts', content: '' },
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a Sass partial module mirror', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a Sass partial module mirror',
+				membership: 'registered partial extensions with an exact underscore-free test stem',
+				rule: 'mirror',
+				files: [
+					{ path: 'app/browser/styles/_tokens.scss', content: '' },
+					{ path: 'tests/app/browser/styles/tokens.test.ts', content: '' },
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a setup module mirror inside tests', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a setup module mirror inside tests',
+				membership: 'tests-axis setup modules with an exact test stem',
+				rule: 'mirror',
+				files: [
+					{ path: 'tests/app/core/setup.ts', content: '' },
+					{ path: 'tests/app/core/setup.test.ts', content: '' },
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('excludes a .d.ts ambient declaration from placement', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'excludes a .d.ts ambient declaration from placement',
+				membership: 'ambient TypeScript declarations',
+				rule: 'type',
+				files: [
+					{
+						path: 'app/browser/env.d.ts',
+						content: 'export interface EnvironmentInterface {}\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('excludes a .d.mts ambient declaration from placement', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'excludes a .d.mts ambient declaration from placement',
+				membership: 'ambient TypeScript declarations',
+				rule: 'type',
+				files: [
+					{
+						path: 'app/browser/env.d.mts',
+						content: 'export interface EnvironmentInterface {}\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('excludes a .d.cts ambient declaration from placement', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'excludes a .d.cts ambient declaration from placement',
+				membership: 'ambient TypeScript declarations',
+				rule: 'type',
+				files: [
+					{
+						path: 'app/browser/env.d.cts',
+						content: 'export interface EnvironmentInterface {}\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a direct callback argument in constants.ts', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a direct callback argument in constants.ts',
+				membership: 'anonymous callbacks passed directly as call arguments',
+				rule: 'function',
+				files: [
+					{
+						path: 'app/edge/constants.ts',
+						content: 'export const LABELS = Object.freeze(COLUMNS.map((column) => column.label))\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a helper namespace in helpers.ts', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a helper namespace in helpers.ts',
+				membership: 'camelCase helper namespaces containing function behavior',
+				rule: 'data',
+				files: [
+					{
+						path: 'app/edge/helpers.ts',
+						content: 'export const formatters = Object.freeze({ money: build(fmt) })\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a concise-body direct return in constants.ts', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a concise-body direct return in constants.ts',
+				membership: 'anonymous functions returned directly through a concise arrow body',
+				rule: 'function',
+				files: [
+					{
+						path: 'app/edge/constants.ts',
+						content: 'export const WRAPPED = wrap(() => () => 1)\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts a returned function inside a direct callback', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts a returned function inside a direct callback',
+				membership: 'anonymous functions returned directly by a return statement',
+				rule: 'function',
+				files: [
+					{
+						path: 'app/edge/constants.ts',
+						content:
+							'export const LABELS = Object.freeze(COLUMNS.map((column) => { return () => column.label }))\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('accepts directly returned functions through callback control flow', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'accepts directly returned functions through callback control flow',
+				membership: 'anonymous functions returned directly through control-flow branches',
+				rule: 'function',
+				files: [
+					{
+						path: 'app/edge/constants.ts',
+						content:
+							'export const VALUES = Object.freeze(C.map((c) => { if (c) return () => 1; return () => 2 }))\n',
+					},
+				],
+			}),
+		).toEqual([])
+	})
+
+	it('excludes Vue text from the placement population', () => {
+		expect(
+			inspectPolicyControl({
+				label: 'excludes Vue text from the placement population',
+				membership: 'files outside the declared TypeScript source extensions',
+				rule: 'type',
+				files: [
+					{
+						path: 'app/browser/Panel.vue',
+						content: '<script setup lang="ts">\nexport interface PanelInterface {}\n</script>\n',
+					},
+				],
+			}),
+		).toEqual([])
 	})
 })