@janga/norna 0.7.13 → 0.7.15

package/scripts/test-engine-commands.mjs

@@ -4,7 +4,8 @@ import { mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promi
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { typographyPresets, typographyRhythms } from './lib/typography.mjs';
+import { getShortGitStatusPath, parseShortGitStatus } from './lib/git-status.mjs';
+import { typographyProfiles, typographyRhythms } from './lib/typography.mjs';
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const cliPath = path.join(repoRoot, 'bin', 'norna.mjs');
@@ -18,6 +19,10 @@ const runCli = (args, options = {}) => spawnSync(process.execPath, [cliPath, ...
 });
 
 try {
+	const releaseStatus = parseShortGitStatus(' M package-lock.json\n M schemas/theme.schema.json\n');
+	assert.deepEqual(releaseStatus, [' M package-lock.json', ' M schemas/theme.schema.json']);
+	assert.equal(getShortGitStatusPath(releaseStatus[0]), 'package-lock.json');
+
 	const versionResult = runCli(['engine:version']);
 	assert.equal(versionResult.status, 0, versionResult.stderr || versionResult.stdout);
 	assert.match(versionResult.stdout, /norna engine:version/);
@@ -35,7 +40,7 @@ try {
 
 	const directSiteRoot = path.join(tempRoot, 'current-directory-site');
 	await mkdir(directSiteRoot, { recursive: true });
-	await writeFile(path.join(directSiteRoot, 'config.md'), '---\nurl: https://example.com/\n---\n');
+	await writeFile(path.join(directSiteRoot, 'config.yaml'), 'url: https://example.com/\n');
 	await writeFile(path.join(directSiteRoot, 'content.md'), '---\ntitle: Direct Site\ndescription: Direct site fixture.\n---\n\n## Intro {#intro}\n\nText.\n');
 	const directSiteProjectRoot = await realpath(tempRoot);
 	const directSiteDoctorResult = runCli(['doctor'], {
@@ -49,29 +54,36 @@ try {
 	const initResult = runCli(['init', initializedSiteRoot]);
 	assert.equal(initResult.status, 0, initResult.stderr || initResult.stdout);
 	assert.match(initResult.stdout, /Created norna site at /);
+	assert.match(initResult.stdout, /npm run norna:dev/);
 
 	const initializedPackageJson = JSON.parse(await readFile(path.join(initializedSiteRoot, 'package.json'), 'utf8'));
 	assert.equal(initializedPackageJson.dependencies['@janga/norna'], packageJson.version);
+	assert.equal(initializedPackageJson.scripts['norna:check'], 'norna check');
 	assert.equal(initializedPackageJson.scripts['norna:engine:update'], 'norna engine:update');
 	assert.equal(initializedPackageJson.scripts['norna:engine:version'], 'norna engine:version');
+	assert.equal(initializedPackageJson.scripts['norna:theme:presets'], 'norna theme:presets');
 	assert.equal(initializedPackageJson.scripts['norna:theme:export'], 'norna theme:export');
 	assert.equal(initializedPackageJson.scripts['engine:update'], undefined);
 	assert.equal(initializedPackageJson.scripts['engine:version'], undefined);
-
-	const presetsResult = runCli(['typography', 'presets']);
-	assert.equal(presetsResult.status, 0, presetsResult.stderr || presetsResult.stdout);
-	assert.match(presetsResult.stdout, /quiet-gallery:/);
-	assert.match(presetsResult.stdout, /text-forward:/);
-	assert.match(presetsResult.stdout, /rhythms:/);
-	assert.match(presetsResult.stdout, /normal:/);
-	for (const [presetName, preset] of Object.entries(typographyPresets)) {
-		for (const [level, heading] of Object.entries(preset.headings)) {
-			assert.equal(heading.size, 'medium', `${presetName} ${level} should use medium size`);
-			assert.ok([400, 500, 600, 700].includes(heading.weight), `${presetName} ${level} should use a supported weight`);
+	const checkResult = runCli(['--site-dir', path.join(initializedSiteRoot, 'site'), 'check']);
+	assert.equal(checkResult.status, 0, checkResult.stderr || checkResult.stdout);
+	assert.match(checkResult.stdout, /Config check passed\./);
+	assert.match(checkResult.stdout, /Content check passed\./);
+
+	const profilesResult = runCli(['typography', 'profiles']);
+	assert.equal(profilesResult.status, 0, profilesResult.stderr || profilesResult.stdout);
+	assert.match(profilesResult.stdout, /restrained:/);
+	assert.match(profilesResult.stdout, /reading:/);
+	assert.match(profilesResult.stdout, /rhythms:/);
+	assert.match(profilesResult.stdout, /normal:/);
+	for (const [profileName, profile] of Object.entries(typographyProfiles)) {
+		for (const [level, heading] of Object.entries(profile.headings)) {
+			assert.equal(heading.size, 'medium', `${profileName} ${level} should use medium size`);
+			assert.ok([400, 500, 600, 700].includes(heading.weight), `${profileName} ${level} should use a supported weight`);
 		}
-		assert.equal(preset.body.size, 'medium', `${presetName} body should use medium size`);
-		assert.ok(['narrow', 'normal', 'wide'].includes(preset.body.width), `${presetName} body should use a supported width`);
-		assert.equal(preset.caption.size, 'medium', `${presetName} caption should use medium size`);
+		assert.equal(profile.body.size, 'medium', `${profileName} body should use medium size`);
+		assert.ok(['narrow', 'normal', 'wide'].includes(profile.body.width), `${profileName} body should use a supported width`);
+		assert.equal(profile.caption.size, 'medium', `${profileName} caption should use medium size`);
 	}
 	for (const [rhythmName, rhythm] of Object.entries(typographyRhythms)) {
 		for (const [level, heading] of Object.entries(rhythm.headings)) {
@@ -87,25 +99,26 @@ try {
 	assert.match(showResult.stdout, /theme:/);
 	assert.match(showResult.stdout, /pages:/);
 	assert.match(showResult.stdout, /\s+\/:/);
-	assert.match(showResult.stdout, /value: quiet-gallery/);
-	assert.match(showResult.stdout, /source: "site\/theme\.md"/);
+	assert.match(showResult.stdout, /value: restrained/);
+	assert.match(showResult.stdout, /source: "site\/theme\.yaml"/);
 	assert.match(showResult.stdout, /intro:/);
 
 	const initAgainResult = runCli(['init', initializedSiteRoot]);
 	assert.notEqual(initAgainResult.status, 0);
 	assert.match(initAgainResult.stderr, /Target directory must be empty/);
 
-	const customPureSiteRoot = path.join(tempRoot, 'custom-pure-site');
-	const customPureInitResult = runCli(['init', customPureSiteRoot, '--type', 'pure', '--site-dir', 'presentation']);
-	assert.equal(customPureInitResult.status, 0, customPureInitResult.stderr || customPureInitResult.stdout);
-	const customPurePackageJson = JSON.parse(await readFile(path.join(customPureSiteRoot, 'package.json'), 'utf8'));
-	assert.equal(customPurePackageJson.scripts.dev, 'npm run norna:dev --');
-	assert.equal(customPurePackageJson.scripts.build, 'npm run norna:build');
-	assert.equal(customPurePackageJson.scripts['norna:dev'], 'norna --site-dir presentation dev:local');
-	assert.equal(customPurePackageJson.scripts['norna:build'], 'norna --site-dir presentation build');
-	await readFile(path.join(customPureSiteRoot, 'presentation', 'content.md'));
-	await readFile(path.join(customPureSiteRoot, 'presentation', 'config.md'));
-	await readFile(path.join(customPureSiteRoot, 'presentation', 'theme.md'));
+	const customStandaloneSiteRoot = path.join(tempRoot, 'custom-standalone-site');
+	const customStandaloneInitResult = runCli(['init', customStandaloneSiteRoot, '--type', 'standalone', '--site-dir', 'presentation']);
+	assert.equal(customStandaloneInitResult.status, 0, customStandaloneInitResult.stderr || customStandaloneInitResult.stdout);
+	const customStandalonePackageJson = JSON.parse(await readFile(path.join(customStandaloneSiteRoot, 'package.json'), 'utf8'));
+	assert.equal(customStandalonePackageJson.scripts.dev, 'npm run norna:dev --');
+	assert.equal(customStandalonePackageJson.scripts.build, 'npm run norna:build');
+	assert.equal(customStandalonePackageJson.scripts['norna:dev'], 'norna --site-dir presentation dev:local');
+	assert.equal(customStandalonePackageJson.scripts['norna:check'], 'norna --site-dir presentation check');
+	assert.equal(customStandalonePackageJson.scripts['norna:build'], 'norna --site-dir presentation build');
+	await readFile(path.join(customStandaloneSiteRoot, 'presentation', 'content.md'));
+	await readFile(path.join(customStandaloneSiteRoot, 'presentation', 'config.yaml'));
+	await readFile(path.join(customStandaloneSiteRoot, 'presentation', 'theme.yaml'));
 
 	const mixedProjectRoot = path.join(tempRoot, 'mixed-project');
 	await mkdir(mixedProjectRoot, { recursive: true });
@@ -127,11 +140,12 @@ try {
 	assert.equal(mixedPackageJson.scripts.build, 'node build-app.mjs');
 	assert.equal(mixedPackageJson.scripts.dev, undefined);
 	assert.equal(mixedPackageJson.scripts['norna:dev'], 'norna --site-dir presentation dev:local');
+	assert.equal(mixedPackageJson.scripts['norna:check'], 'norna --site-dir presentation check');
 	assert.equal(mixedPackageJson.scripts['norna:engine:update'], 'norna --site-dir presentation engine:update');
 	assert.equal(mixedPackageJson.scripts['norna:engine:version'], 'norna --site-dir presentation engine:version');
 	await readFile(path.join(mixedProjectRoot, 'presentation', 'content.md'));
-	await readFile(path.join(mixedProjectRoot, 'presentation', 'config.md'));
-	await readFile(path.join(mixedProjectRoot, 'presentation', 'theme.md'));
+	await readFile(path.join(mixedProjectRoot, 'presentation', 'config.yaml'));
+	await readFile(path.join(mixedProjectRoot, 'presentation', 'theme.yaml'));
 
 	const conflictProjectRoot = path.join(tempRoot, 'conflict-project');
 	await mkdir(conflictProjectRoot, { recursive: true });
@@ -149,11 +163,11 @@ try {
 	assert.match(conflictInitResult.stderr, /Refusing to overwrite existing npm scripts/);
 	assert.match(conflictInitResult.stderr, /norna:dev/);
 
-	const pureIntoExistingProjectResult = runCli(['init', '.', '--type', 'pure'], {
+	const standaloneIntoExistingProjectResult = runCli(['init', '.', '--type', 'standalone'], {
 		cwd: mixedProjectRoot,
 	});
-	assert.notEqual(pureIntoExistingProjectResult.status, 0);
-	assert.match(pureIntoExistingProjectResult.stderr, /use --type embedded/);
+	assert.notEqual(standaloneIntoExistingProjectResult.status, 0);
+	assert.match(standaloneIntoExistingProjectResult.stderr, /use --type embedded/);
 
 	const updateFromEngineResult = runCli(['engine:update', '--skip-checks']);
 	assert.notEqual(updateFromEngineResult.status, 0);
@@ -165,6 +179,23 @@ try {
 	});
 	assert.equal(releaseHelpResult.status, 0, releaseHelpResult.stderr || releaseHelpResult.stdout);
 	assert.match(releaseHelpResult.stdout, /Usage: node scripts\/release\.mjs/);
+	const releaseSource = await readFile(path.join(repoRoot, 'scripts', 'release.mjs'), 'utf8');
+	const releaseSteps = [
+		"['version', releaseType, '--no-git-tag-version']",
+		"['run', 'schemas:generate']",
+		"['test']",
+		"['commit', '-m', `Release ${releaseTag}`]",
+		"['run', 'release:publish']",
+		"['push', '--follow-tags']",
+	];
+	for (const step of releaseSteps) assert.ok(releaseSource.includes(step), `Missing release step: ${step}`);
+	for (let index = 1; index < releaseSteps.length; index += 1) {
+		assert.ok(
+			releaseSource.indexOf(releaseSteps[index - 1]) < releaseSource.indexOf(releaseSteps[index]),
+			`Release step is out of order: ${releaseSteps[index]}`,
+		);
+	}
+	assert.match(releaseSource, /rollbackPreparedRelease/);
 
 	console.log('ok - engine commands report versions, initialize sites, guard engine self-updates, and document release usage');
 } finally {

package/scripts/test-package-check.mjs

@@ -1,3 +1,4 @@
+import assert from 'node:assert/strict';
 import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import { tmpdir } from 'node:os';
@@ -155,40 +156,49 @@ try {
 		assertFileExists(path.join(unpackDir, 'package', 'docs', 'README.md')),
 		assertFileExists(path.join(unpackDir, 'package', 'docs', 'configuration.md')),
 		assertFileExists(path.join(unpackDir, 'package', 'docs', 'images-and-metadata.md')),
+		assertFileExists(path.join(unpackDir, 'package', 'schemas', 'manifest.json')),
+		assertFileExists(path.join(unpackDir, 'package', 'schemas', 'config.schema.json')),
+		assertFileExists(path.join(unpackDir, 'package', 'schemas', 'content-frontmatter.schema.json')),
+		assertFileExists(path.join(unpackDir, 'package', 'schemas', 'sitewide-content.schema.json')),
+		assertFileExists(path.join(unpackDir, 'package', 'schemas', 'theme.schema.json')),
 		assertFileExists(path.join(packagedStarterRoot, '.github', 'workflows', 'deploy.yml')),
 		assertFileExists(path.join(packagedStarterRoot, 'package.json')),
 		assertFileExists(path.join(packagedStarterRoot, 'README.md')),
-		assertFileExists(path.join(packagedStarterRoot, 'site', 'config.md')),
-		assertFileExists(path.join(packagedStarterRoot, 'site', 'theme.md')),
-		assertFileExists(path.join(packagedStarterRoot, 'site', 'sitewide-content.md')),
+		assertFileExists(path.join(packagedStarterRoot, 'site', 'config.yaml')),
+		assertFileExists(path.join(packagedStarterRoot, 'site', 'theme.yaml')),
+		assertFileExists(path.join(packagedStarterRoot, 'site', 'sitewide-content.yaml')),
 		assertFileExists(path.join(packagedStarterRoot, 'site', 'content.md')),
 		assertFileExists(path.join(packagedStarterRoot, 'site', 'images', 'work', '.gitkeep')),
 		assertFileExists(path.join(packagedStarterRoot, 'site', 'public', 'robots.txt')),
-		assertFileMissing(path.join(packagedStarterRoot, 'site', 'config.mjs')),
 	]);
 	await assertFileIncludes(
 		path.join(packagedStarterRoot, '.github', 'workflows', 'deploy.yml'),
 		'node-version: 24.18.0',
 	);
+	await assertFileIncludes(
+		path.join(packagedStarterRoot, '.github', 'workflows', 'deploy.yml'),
+		'run: npm run norna:build',
+	);
 	await cp(packagedStarterRoot, siteProjectRoot, {
 		recursive: true,
 	});
 	const packageJsonPath = path.join(siteProjectRoot, 'package.json');
 	const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+	assert.equal(packageJson.scripts['norna:check'], 'norna check');
 	packageJson.name = 'norna-package-check-site';
 	packageJson.dependencies['@janga/norna'] = tarballPath;
 	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
-	const packageCheckConfigPath = path.join(siteProjectRoot, 'site', 'config.md');
+	const packageCheckConfigPath = path.join(siteProjectRoot, 'site', 'config.yaml');
 	const packageCheckConfig = await readFile(packageCheckConfigPath, 'utf8');
 	await writeFile(
 		packageCheckConfigPath,
 		packageCheckConfig.replace('url: https://example.com/', 'url: https://example.com/site/'),
 	);
-	const packageCheckSitewidePath = path.join(siteProjectRoot, 'site', 'sitewide-content.md');
+	const packageCheckSitewidePath = path.join(siteProjectRoot, 'site', 'sitewide-content.yaml');
 	const packageCheckSitewide = await readFile(packageCheckSitewidePath, 'utf8');
 	await writeFile(
 		packageCheckSitewidePath,
-		packageCheckSitewide.replace('brand: Example Site', 'brand: Package Check Brand\n  logo:\n    alt: Package Check Logo\n    height: 2.6rem'),
+		packageCheckSitewide.replace('label: Example Site', 'label: Package Check Logo\n  logo:\n    height: 2.6rem'),
 	);
 	await writeFile(
 		path.join(siteProjectRoot, 'site', 'public', 'logo.svg'),
@@ -221,7 +231,7 @@ This section verifies styled section headings.
 This section keeps the package check independent from user-facing starter copy.
 `);
 	await mkdir(path.join(siteProjectRoot, 'site', 'routes', '010-about'), { recursive: true });
-	await writeFile(path.join(siteProjectRoot, 'site', 'routes', '010-about', 'route-content.md'), `---
+	await writeFile(path.join(siteProjectRoot, 'site', 'routes', '010-about', 'content.md'), `---
 title: About the site
 description: Route used by package checks.
 navigation:
@@ -240,16 +250,16 @@ This route verifies that packaged norna sites can build route pages.
 	await runInherit(nornaBinPath, ['init', initializedSiteRoot], { cwd: tempRoot, env: npmEnv });
 	await Promise.all([
 		assertFileExists(path.join(initializedSiteRoot, 'package.json')),
-		assertFileExists(path.join(initializedSiteRoot, 'site', 'config.md')),
-		assertFileExists(path.join(initializedSiteRoot, 'site', 'theme.md')),
+		assertFileExists(path.join(initializedSiteRoot, 'site', 'config.yaml')),
+		assertFileExists(path.join(initializedSiteRoot, 'site', 'theme.yaml')),
 		assertFileMissing(path.join(initializedSiteRoot, '.DS_Store')),
 		assertFileMissing(path.join(initializedSiteRoot, 'site', '.DS_Store')),
-		assertFileMissing(path.join(initializedSiteRoot, 'site', 'config.mjs')),
 	]);
 	await runInherit(npxBin, ['norna', 'engine:version'], { cwd: path.join(siteProjectRoot, 'site', 'images', 'work'), env: npmEnv });
 	await runInherit(npxBin, ['norna', 'doctor'], { cwd: path.join(siteProjectRoot, 'site', 'images', 'work'), env: npmEnv });
 	await runInherit(npxBin, ['norna', 'config:check'], { cwd: path.join(siteProjectRoot, 'site', 'images', 'work'), env: npmEnv });
 	await runInherit(npxBin, ['norna', 'content:check'], { cwd: siteProjectRoot, env: npmEnv });
+	await runInherit(npxBin, ['norna', 'check'], { cwd: siteProjectRoot, env: npmEnv });
 	await runInherit(npxBin, ['norna', 'build'], { cwd: siteProjectRoot, env: npmEnv });
 	await assertFileExists(path.join(siteProjectRoot, 'site', '.norna', 'public', 'robots.txt'));
 	await assertFileExists(path.join(siteProjectRoot, 'dist', 'robots.txt'));
@@ -404,47 +414,44 @@ This route verifies that packaged norna sites can build route pages.
 	);
 	const siteContentPath = path.join(siteProjectRoot, 'site', 'content.md');
 	const siteContent = await readFile(siteContentPath, 'utf8');
-	const siteThemePath = path.join(siteProjectRoot, 'site', 'theme.md');
+	const siteThemePath = path.join(siteProjectRoot, 'site', 'theme.yaml');
 	const siteTheme = await readFile(siteThemePath, 'utf8');
-	await writeFile(siteThemePath, siteTheme.replace('\n  preset: quiet-gallery', '\n  preset: noisy-gallery'));
+	await writeFile(siteThemePath, siteTheme.replace('\n  profile: restrained', '\n  profile: noisy'));
 	await runExpectFailure(
 		npxBin,
 		['norna', 'build'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'typography.preset',
+		'Unknown typography profile: noisy',
 	);
 	await writeFile(
 		siteThemePath,
-		siteTheme.replace('\n  palette: dark', '\n  palette: neon'),
+		siteTheme.replace('\npalette: dark', '\npalette: neon'),
 	);
 	await runExpectFailure(
 		npxBin,
 		['norna', 'build'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'presentation.palette',
+		'palette',
 	);
 	await writeFile(
 		siteThemePath,
-		siteTheme.replace('  sectionSurfaces:\n    mode: cycle', '  sectionSurfaces:\n    mode: glowing'),
+		siteTheme.replace('\nsectionSurfaces: [base, soft, emphasis]', '\nsectionSurfaces: [base, glowing]'),
 	);
 	await runExpectFailure(
 		npxBin,
 		['norna', 'build'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'presentation.sectionSurfaces.mode',
+		'Unknown section surface "glowing"',
 	);
 	await writeFile(
 		siteThemePath,
-		siteTheme.replace(
-			'  sectionSurfaces:\n    mode: cycle',
-			'  sectionSurfaces:\n    mode: cycle\n    sequence: [base, base]',
-		),
+		siteTheme.replace('\nsectionSurfaces: [base, soft, emphasis]', '\nsectionSurfaces: [base, base]'),
 	);
 	await runExpectFailure(
 		npxBin,
 		['norna', 'build'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'presentation.sectionSurfaces',
+		'Each section surface may appear only once',
 	);
 	await writeFile(siteThemePath, siteTheme);
 	await writeFile(
@@ -465,40 +472,40 @@ This route verifies that packaged norna sites can build route pages.
 		siteContentPath,
 		siteContent.replace(
 			'description: Site used by package checks.',
-			'description: Site used by package checks.\npresentation:\n  typography:\n    overrides:\n      body:\n        lineHeight: tight',
+			'description: Site used by package checks.\ntypography:\n  overrides:\n    body:\n      lineHeight: tight',
 		),
 	);
 	await runExpectFailure(
 		npxBin,
 		['norna', 'build'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'presentation',
+		'typography',
 	);
 	await writeFile(
 		siteContentPath,
 		siteContent.replace(
 			'  intro: {}',
-			'  intro:\n    presentation:\n      typography:\n        overrides:\n          caption:\n            spacingBefore: wide',
+			'  intro:\n    typography:\n      overrides:\n        caption:\n          spacingBefore: wide',
 		),
 	);
 	await runExpectFailure(
 		npxBin,
 		['norna', 'build'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'sections.intro: Unrecognized key: "presentation"',
+		'sections.intro: Unrecognized key: "typography"',
 	);
 	await writeFile(
 		siteContentPath,
 		siteContent.replace(
 			'  intro: {}',
-			'  intro:\n    presentation:\n      typography:\n        preset: dramatic',
+			'  intro:\n    palette: dark',
 		),
 	);
 	await runExpectFailure(
 		npxBin,
 		['norna', 'build'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'sections.intro: Unrecognized key: "presentation"',
+		'sections.intro: Unrecognized key: "palette"',
 	);
 	await writeFile(
 		siteThemePath,
@@ -514,7 +521,7 @@ This route verifies that packaged norna sites can build route pages.
 		'typography.fontFamily',
 	);
 	await writeFile(siteThemePath, siteTheme);
-	const siteConfigPath = path.join(siteProjectRoot, 'site', 'config.md');
+	const siteConfigPath = path.join(siteProjectRoot, 'site', 'config.yaml');
 	const siteConfig = await readFile(siteConfigPath, 'utf8');
 	await writeFile(
 		siteConfigPath,

package/scripts/test-project-config.mjs

@@ -19,13 +19,13 @@ const importScript = `
 	}));
 `;
 
-const createSite = async (name, config, { legacy = false } = {}) => {
+const createSite = async (name, config) => {
 	const projectRoot = path.join(tempRoot, name);
 	const siteDir = path.join(projectRoot, 'site');
 	await mkdir(siteDir, { recursive: true });
-	await writeFile(path.join(siteDir, legacy ? 'config.mjs' : 'config.md'), config);
+	await writeFile(path.join(siteDir, 'config.yaml'), config);
 	await writeFile(path.join(siteDir, 'content.md'), '---\ntitle: Config test\ndescription: Config test.\n---\n\n## Intro {#intro}\n\nText.\n');
-	await writeFile(path.join(siteDir, 'theme.md'), '---\npreset: documentation\n---\n');
+	await writeFile(path.join(siteDir, 'theme.yaml'), 'preset: documentation\n');
 	return { projectRoot, siteDir };
 };
 
@@ -50,7 +50,7 @@ const assertFailure = (result, expectedPattern) => {
 };
 
 try {
-	const minimalSite = await createSite('minimal', '---\nurl: https://example.com/docs\n---\n');
+	const minimalSite = await createSite('minimal', 'url: https://example.com/docs\n');
 	const minimalResult = loadConfig(minimalSite);
 	assert.equal(minimalResult.status, 0, minimalResult.stderr);
 	assert.deepEqual(JSON.parse(minimalResult.stdout), {
@@ -58,7 +58,7 @@ try {
 		language: 'en',
 		labels: {
 			dismissBanner: 'Dismiss notice',
-			gallery: 'Images',
+			images: 'Images',
 			note: 'Note',
 			pageNavigation: 'On this page',
 			siteBanners: 'Site notices',
@@ -69,13 +69,13 @@ try {
 		url: 'https://example.com/docs/',
 	});
 
-	const localizedSite = await createSite('localized', '---\nurl: https://example.com/\nlanguage: sv-SE\nscrollBehavior: browser-smooth\n---\n');
+	const localizedSite = await createSite('localized', 'url: https://example.com/\nlanguage: sv-SE\nscrollBehavior: smooth\n');
 	const localizedResult = loadConfig(localizedSite);
 	assert.equal(localizedResult.status, 0, localizedResult.stderr);
 	const localizedConfig = JSON.parse(localizedResult.stdout);
 	assert.equal(localizedConfig.language, 'sv-SE');
 	assert.equal(localizedConfig.labels.skipToContent, 'Hoppa till innehållet');
-	assert.equal(localizedConfig.scrollBehavior, 'browser-smooth');
+	assert.equal(localizedConfig.scrollBehavior, 'smooth');
 
 	const overrideResult = loadConfig(minimalSite, {
 		NORNA_SITE_URL: 'http://127.0.0.1:4567/preview',
@@ -91,34 +91,29 @@ try {
 	);
 
 	assertFailure(
-		loadConfig(await createSite('unknown-field', '---\nurl: https://example.com/\nbasePath: /docs/\n---\n')),
+		loadConfig(await createSite('unknown-field', 'url: https://example.com/\nbasePath: /docs/\n')),
 		/not a valid top-level config field/,
 	);
 	assertFailure(
-		loadConfig(await createSite('markdown-body', '---\nurl: https://example.com/\n---\n\nConfiguration prose.\n')),
-		/may contain YAML frontmatter only/,
+		loadConfig(await createSite('invalid-yaml', 'url: https://example.com/\nConfiguration prose.\n')),
+		/contains invalid YAML/,
 	);
 	assertFailure(
-		loadConfig(await createSite('unsupported-language', '---\nurl: https://example.com/\nlanguage: de\n---\n')),
+		loadConfig(await createSite('unsupported-language', 'url: https://example.com/\nlanguage: de\n')),
 		/has no built-in Norna UI text/,
 	);
 	assertFailure(
-		loadConfig(await createSite('invalid-url', '---\nurl: example.com\n---\n')),
+		loadConfig(await createSite('invalid-url', 'url: example.com\n')),
 		/url must be an absolute URL/,
 	);
 	assertFailure(
-		loadConfig(await createSite('invalid-scroll-behavior', '---\nurl: https://example.com/\nscrollBehavior: slow\n---\n')),
-		/scrollBehavior must be one of instant, browser-smooth/,
+		loadConfig(await createSite('invalid-scroll-behavior', 'url: https://example.com/\nscrollBehavior: slow\n')),
+		/scrollBehavior must be one of instant, smooth/,
 	);
 	assertFailure(
-		loadConfig(await createSite('obsolete-smooth-scroll', '---\nurl: https://example.com/\nsmoothScroll: true\n---\n')),
+		loadConfig(await createSite('obsolete-smooth-scroll', 'url: https://example.com/\nsmoothScroll: true\n')),
 		/not a valid top-level config field/,
 	);
-	assertFailure(
-		loadConfig(await createSite('legacy', 'export default {};\n', { legacy: true })),
-		/Replace the obsolete config\.mjs with a frontmatter-only config\.md file/,
-	);
-
 	console.log('Project config test passed.');
 } finally {
 	await rm(tempRoot, { force: true, recursive: true });

package/scripts/test-schemas.mjs

@@ -0,0 +1,102 @@
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const packageJson = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
+const expectedDocumentationRef = `v${packageJson.version}`;
+const filenames = [
+	'config.schema.json',
+	'theme.schema.json',
+	'sitewide-content.schema.json',
+	'content-frontmatter.schema.json',
+];
+const requiredRichHelp = {
+	'config.schema.json': ['url', 'language', 'scrollBehavior'],
+	'theme.schema.json': ['preset', 'layout', 'images', 'typography', 'palette', 'sectionSurfaces'],
+	'sitewide-content.schema.json': ['navigation', 'banners', 'footer'],
+	'content-frontmatter.schema.json': ['title', 'description', 'navigation', 'sections'],
+};
+
+const githubHeadingAnchor = (heading) => heading
+	.toLowerCase()
+	.replace(/<[^>]+>/g, '')
+	.replace(/[`*_~]/g, '')
+	.replace(/[^\p{L}\p{N}\s-]/gu, '')
+	.trim()
+	.replace(/\s+/g, '-');
+
+const assertDocumentationLinks = async (markdownDescription, location) => {
+	const links = [...markdownDescription.matchAll(
+		/https:\/\/github\.com\/janga\/norna\/blob\/([^/\s]+)\/docs\/([^\s)#]+)(?:#([^\s)]+))?/g,
+	)];
+	assert.ok(links.length > 0, `${location} has no documentation link.`);
+
+	for (const [, reference, filename, anchor] of links) {
+		assert.equal(reference, expectedDocumentationRef, `${location} uses documentation ref ${reference}.`);
+		const documentationPath = path.join(root, 'docs', decodeURIComponent(filename));
+		assert.ok(existsSync(documentationPath), `${location} links to missing docs/${filename}.`);
+		if (!anchor) continue;
+
+		const source = await readFile(documentationPath, 'utf8');
+		const anchors = source
+			.split('\n')
+			.filter((line) => /^#{1,6}\s/.test(line))
+			.map((line) => githubHeadingAnchor(line.replace(/^#{1,6}\s+/, '')));
+		assert.ok(anchors.includes(anchor), `${location} links to missing anchor docs/${filename}#${anchor}.`);
+	}
+};
+
+const visitSchema = (schema, location) => {
+	assert.equal(schema.enum, undefined, `${location} uses an undescribed enum.`);
+	if (schema.properties) {
+		for (const [name, property] of Object.entries(schema.properties)) {
+			assert.ok(property.description, `${location}.${name} has no description.`);
+			visitSchema(property, `${location}.${name}`);
+		}
+	}
+	if (schema.items) visitSchema(schema.items, `${location}[]`);
+	for (const keyword of ['allOf', 'anyOf', 'oneOf']) {
+		for (const [index, candidate] of (schema[keyword] ?? []).entries()) {
+			if (Object.hasOwn(candidate, 'const')) {
+				assert.ok(candidate.title, `${location}.${keyword}[${index}] has no title.`);
+				assert.ok(candidate.description, `${location}.${keyword}[${index}] has no description.`);
+			}
+			visitSchema(candidate, `${location}.${keyword}[${index}]`);
+		}
+	}
+};
+
+for (const filename of filenames) {
+	const schema = JSON.parse(await readFile(path.join(root, 'schemas', filename), 'utf8'));
+	assert.ok(schema.description, `${filename} has no root description.`);
+	assert.match(schema.markdownDescription, /^```yaml\n/, `${filename} rich help must start with YAML syntax.`);
+	await assertDocumentationLinks(schema.markdownDescription, filename);
+	for (const propertyName of requiredRichHelp[filename]) {
+		const property = schema.properties[propertyName];
+		assert.match(
+			property.markdownDescription,
+			/^```yaml\n/,
+			`${filename}.${propertyName} rich help must start with YAML syntax.`,
+		);
+		await assertDocumentationLinks(property.markdownDescription, `${filename}.${propertyName}`);
+	}
+	visitSchema(schema, filename);
+}
+
+const config = JSON.parse(await readFile(path.join(root, 'schemas', 'config.schema.json'), 'utf8'));
+assert.equal(config.properties.language.default, 'en');
+assert.deepEqual(config.properties.language.examples, ['en', 'sv', 'en-GB', 'sv-SE']);
+assert.equal(config.properties.scrollBehavior.default, 'instant');
+
+const sitewide = JSON.parse(await readFile(path.join(root, 'schemas', 'sitewide-content.schema.json'), 'utf8'));
+assert.deepEqual(Object.keys(sitewide.properties.navigation.properties), ['label', 'logo']);
+assert.deepEqual(Object.keys(sitewide.properties.navigation.properties.logo.properties), ['height']);
+assert.match(sitewide.properties.navigation.properties.logo.markdownDescription, /```yaml\nnavigation:\n  label: Example Site\n  logo:\n    height: 2rem\n```/);
+assert.match(sitewide.properties.navigation.properties.logo.markdownDescription, /does not enable or select the file/);
+assert.match(sitewide.properties.navigation.properties.logo.markdownDescription, /docs\/public-files\.md#navigation-logo/);
+assert.equal(sitewide.properties.navigation.properties.logo.description.length < 100, true);
+
+console.log('Schema metadata tests passed.');

package/scripts/test-temporary-visibility.mjs

@@ -37,19 +37,12 @@ try {
 	await mkdir(path.join(siteDir, 'images', 'work'), { recursive: true });
 	await mkdir(path.join(siteDir, 'public'), { recursive: true });
 	await writeFile(path.join(siteDir, 'public', 'robots.txt'), 'User-agent: *\nAllow: /\n');
-	await writeFile(path.join(siteDir, 'config.md'), `---
-url: https://example.com/
----
-`);
-	await writeFile(path.join(siteDir, 'theme.md'), `---
-typography:
-  preset: quiet-gallery
-presentation:
-  palette: dark
----
+	await writeFile(path.join(siteDir, 'config.yaml'), 'url: https://example.com/\n');
+	await writeFile(path.join(siteDir, 'theme.yaml'), `typography:
+  profile: restrained
+palette: dark
 `);
-	await writeFile(path.join(siteDir, 'sitewide-content.md'), `---
-banners:
+	await writeFile(path.join(siteDir, 'sitewide-content.yaml'), `banners:
   - id: expired-banner
     visible:
       until: "2026-01-01"
@@ -61,7 +54,6 @@ banners:
       until: "2026-12-31"
     title: Active banner
     text: Active banner text.
----
 `);
 	await writeFile(path.join(siteDir, 'content.md'), `---
 title: Temporary Visibility Test