@janga/norna 0.7.10 → 0.7.12

package/scripts/test-content-model-v2.mjs

@@ -51,17 +51,9 @@ const createTempSite = async ({ underRepoCache = false } = {}) => {
 	const root = await mkdtemp(path.join(tempParent, 'norna-content-model-v2-'));
 	const siteDir = path.join(root, 'site');
 	await mkdir(siteDir, { recursive: true });
-	await writeFile(path.join(siteDir, 'config.mjs'), `export default {
-  site: {
-    url: 'https://example.com',
-    basePath: '/',
-  },
-  github: {
-    branch: 'main',
-    repo: 'owner/repo',
-    pagesWorkflow: 'Deploy to GitHub Pages',
-  },
-};
+	await writeFile(path.join(siteDir, 'config.md'), `---
+url: https://example.com/
+---
 `);
 	await writeFile(path.join(siteDir, 'theme.md'), `---
 typography:
@@ -294,11 +286,15 @@ description: Fixture
 
 The first paragraph points to an explanation.{note-ref}
 
-{note: This explanation names \`sitewide-content.md\` and stays beside the paragraph on wide screens.}
+{note: This explanation names \`sitewide-content.md\` and stays beside the
+paragraph on wide screens.}
 
 The second paragraph has its own explanation.{note-ref}
 
-{note: This is the second explanation.}
+{note:
+  This is the second
+  explanation.
+}
 `);
 
 		await runNorna(['--site-dir', siteDir, 'build']);

package/scripts/test-documentation.mjs

@@ -0,0 +1,116 @@
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const repoRoot = path.resolve(import.meta.dirname, '..');
+const cliPath = path.join(repoRoot, 'bin', 'norna.mjs');
+const tutorialPath = path.join(repoRoot, 'docs', 'getting-started.md');
+const scratchRoot = path.join(repoRoot, 'todos');
+await mkdir(scratchRoot, { recursive: true });
+const tempRoot = await mkdtemp(path.join(scratchRoot, 'norna-documentation-'));
+const tutorialSiteRoot = path.join(tempRoot, 'my-site');
+
+const runCli = (args) => spawnSync(process.execPath, [cliPath, ...args], {
+	cwd: repoRoot,
+	encoding: 'utf8',
+});
+
+const assertSuccess = (result, label) => {
+	assert.equal(result.status, 0, `${label} failed:\n${result.stderr || result.stdout}`);
+};
+
+const extractTutorialFile = (source, label, language) => {
+	const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+	const pattern = new RegExp(`${escapedLabel}\\n\\n\\x60{3}${language}\\n([\\s\\S]*?)\\n\\x60{3}`);
+	const match = source.match(pattern);
+	assert.ok(match, `Could not find the ${label} code block in docs/getting-started.md.`);
+	return `${match[1]}\n`;
+};
+
+const collectMarkdownFiles = async (directory) => {
+	const files = [];
+	for (const entry of await readdir(directory, { withFileTypes: true })) {
+		const entryPath = path.join(directory, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...await collectMarkdownFiles(entryPath));
+		} else if (entry.name.endsWith('.md')) {
+			files.push(entryPath);
+		}
+	}
+	return files;
+};
+
+const checkLocalMarkdownLinks = async () => {
+	const markdownFiles = [
+		path.join(repoRoot, 'README.md'),
+		...await collectMarkdownFiles(path.join(repoRoot, 'docs')),
+		...await collectMarkdownFiles(path.join(repoRoot, 'examples')),
+	];
+	const missing = [];
+
+	for (const markdownPath of markdownFiles) {
+		const source = await readFile(markdownPath, 'utf8');
+		const prose = source
+			.replace(/(```+|~~~+)[\s\S]*?\1/g, '')
+			.replace(/`[^`\n]*`/g, '');
+		for (const match of prose.matchAll(/!?\[[^\]]*\]\(([^)]+)\)/g)) {
+			const target = match[1].trim().replace(/^<|>$/g, '');
+			if (/^(?:[a-z]+:|#|\/)/i.test(target)) continue;
+
+			const targetPath = decodeURIComponent(target.split('#', 1)[0].split('?', 1)[0]);
+			if (!targetPath) continue;
+			const resolved = path.resolve(path.dirname(markdownPath), targetPath);
+			if (!existsSync(resolved)) {
+				missing.push(`${path.relative(repoRoot, markdownPath)} -> ${target}`);
+			}
+		}
+	}
+
+	assert.deepEqual(missing, [], `Broken local Markdown links:\n${missing.join('\n')}`);
+};
+
+try {
+	const tutorial = await readFile(tutorialPath, 'utf8');
+	const initResult = runCli(['init', tutorialSiteRoot]);
+	assertSuccess(initResult, 'Tutorial init');
+	await rm(path.join(tutorialSiteRoot, 'node_modules'), { force: true, recursive: true });
+	await symlink(path.join(repoRoot, 'node_modules'), path.join(tutorialSiteRoot, 'node_modules'), 'dir');
+
+	await Promise.all([
+		writeFile(
+			path.join(tutorialSiteRoot, 'site', 'content.md'),
+			extractTutorialFile(tutorial, 'Replace `site/content.md` with:', 'md'),
+		),
+		writeFile(
+			path.join(tutorialSiteRoot, 'site', 'sitewide-content.md'),
+			extractTutorialFile(tutorial, 'Replace `site/sitewide-content.md` with:', 'yaml'),
+		),
+		writeFile(
+			path.join(tutorialSiteRoot, 'site', 'theme.md'),
+			extractTutorialFile(tutorial, 'Replace `site/theme.md` with:', 'yaml'),
+		),
+	]);
+
+	const siteDirectory = path.join(tutorialSiteRoot, 'site');
+	assertSuccess(runCli(['--site-dir', siteDirectory, 'config:check']), 'Tutorial config:check');
+	assertSuccess(runCli(['--site-dir', siteDirectory, 'content:check']), 'Tutorial content:check');
+	assertSuccess(runCli(['--site-dir', siteDirectory, 'build']), 'Tutorial build');
+
+	const html = await readFile(path.join(tutorialSiteRoot, 'dist', 'index.html'), 'utf8');
+	assert.match(html, /My first Norna site/);
+	assert.match(html, /Welcome/);
+	assert.match(html, /Next/);
+
+	await checkLocalMarkdownLinks();
+
+	const llms = await readFile(path.join(repoRoot, 'site', 'public', 'llms.txt'), 'utf8');
+	for (const match of llms.matchAll(/https:\/\/raw\.githubusercontent\.com\/janga\/norna\/main\/([^\s)]+)/g)) {
+		assert.ok(existsSync(path.join(repoRoot, decodeURIComponent(match[1]))), `llms.txt target is missing: ${match[1]}`);
+	}
+
+	console.log('ok - tutorial source builds and documentation links resolve');
+} finally {
+	await rm(tempRoot, { force: true, recursive: true });
+}

package/scripts/test-engine-commands.mjs

@@ -24,9 +24,18 @@ try {
 	assert.match(versionResult.stdout, new RegExp(`Installed norna: ${packageJson.version.replaceAll('.', '\\.')}`));
 	assert.match(versionResult.stdout, /Installed Astro: /);
 
+	const deployHelpResult = runCli(['deploy', '--help']);
+	assert.equal(deployHelpResult.status, 0, deployHelpResult.stderr || deployHelpResult.stdout);
+	assert.match(deployHelpResult.stdout, /already committed default branch/);
+	const deployWatchHelpResult = runCli(['deploy:watch', '--help']);
+	assert.equal(deployWatchHelpResult.status, 0, deployWatchHelpResult.stderr || deployWatchHelpResult.stdout);
+	assert.match(deployWatchHelpResult.stdout, /Default: current repository/);
+	assert.match(deployWatchHelpResult.stdout, /Default: repository default branch/);
+	assert.match(deployWatchHelpResult.stdout, /Default: deploy\.yml/);
+
 	const directSiteRoot = path.join(tempRoot, 'current-directory-site');
 	await mkdir(directSiteRoot, { recursive: true });
-	await writeFile(path.join(directSiteRoot, 'config.mjs'), 'export default { site: { url: "https://example.com/" } };\n');
+	await writeFile(path.join(directSiteRoot, 'config.md'), '---\nurl: https://example.com/\n---\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'], {
@@ -45,6 +54,7 @@ try {
 	assert.equal(initializedPackageJson.dependencies['@janga/norna'], packageJson.version);
 	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:export'], 'norna theme:export');
 	assert.equal(initializedPackageJson.scripts['engine:update'], undefined);
 	assert.equal(initializedPackageJson.scripts['engine:version'], undefined);
 
@@ -94,7 +104,7 @@ try {
 	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.mjs'));
+	await readFile(path.join(customPureSiteRoot, 'presentation', 'config.md'));
 	await readFile(path.join(customPureSiteRoot, 'presentation', 'theme.md'));
 
 	const mixedProjectRoot = path.join(tempRoot, 'mixed-project');
@@ -120,7 +130,7 @@ try {
 	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.mjs'));
+	await readFile(path.join(mixedProjectRoot, 'presentation', 'config.md'));
 	await readFile(path.join(mixedProjectRoot, 'presentation', 'theme.md'));
 
 	const conflictProjectRoot = path.join(tempRoot, 'conflict-project');

package/scripts/test-examples.mjs

@@ -0,0 +1,24 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getExampleSites } from './lib/example-sites.mjs';
+import { runInherit } from './lib/run-command.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const cliPath = path.join(root, 'bin', 'norna.mjs');
+const examples = await getExampleSites(root);
+
+for (const example of examples) {
+	console.log(`\nBuilding ${example.siteLabel}`);
+	await runInherit(process.execPath, [cliPath, '--site-dir', example.siteLabel, 'build'], { cwd: root });
+
+	if (['svg', 'png', 'jpg', 'jpeg'].some((extension) => existsSync(path.join(example.siteDirectory, 'public', `logo.${extension}`)))) {
+		const homepageHtml = await readFile(path.join(root, 'dist', 'index.html'), 'utf8');
+		if (!homepageHtml.includes('class="site-brand-logo"')) {
+			throw new Error(`Example ${example.siteLabel} has a logo file that is not rendered on its homepage.`);
+		}
+	}
+}
+
+console.log(`\nok - built ${examples.length} example sites`);

package/scripts/test-navigation.mjs

@@ -1,15 +1,12 @@
-import { execFile, spawn } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFile);
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const cliPath = path.join(root, 'bin', 'norna.mjs');
-const dogGallerySiteDir = path.join(root, 'examples', 'dog-gallery', 'site');
-const url = 'http://localhost:4321/';
-const probeUrls = [url, 'http://127.0.0.1:4321/', 'http://[::1]:4321/'];
+const navigationDemoSiteDir = path.join(root, 'examples', 'feature-demos', 'media-and-surfaces', 'site');
+const host = '127.0.0.1';
 const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 const testTargets = process.argv.slice(2);
 const playwrightTargets = testTargets.length > 0 ? testTargets : ['tests/navigation.spec.ts'];
@@ -18,33 +15,46 @@ const sleep = (milliseconds) => new Promise((resolve) => {
 	setTimeout(resolve, milliseconds);
 });
 
-const isReachable = async () => {
-	for (const probeUrl of probeUrls) {
-		try {
-			const response = await fetch(probeUrl, { signal: AbortSignal.timeout(1_000) });
-			await response.arrayBuffer();
-			return response.ok;
-		} catch {
-			// Try the next loopback address.
-		}
-	}
+const getAvailablePort = () => new Promise((resolve, reject) => {
+	const server = net.createServer();
+	server.unref();
+	server.once('error', reject);
+	server.listen(0, host, () => {
+		const address = server.address();
+		const port = typeof address === 'object' && address ? address.port : null;
+		server.close((error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve(port);
+		});
+	});
+});
+
+const port = await getAvailablePort();
+if (!port) throw new Error('Could not reserve a port for the navigation test server.');
+const url = `http://${host}:${port}/`;
 
+const isReachable = async () => {
 	try {
-		await execFileAsync('curl', ['-fsI', url], {
-			cwd: root,
-			maxBuffer: 1024 * 1024,
-		});
-		return true;
+		const response = await fetch(url, { signal: AbortSignal.timeout(1_000) });
+		await response.arrayBuffer();
+		return response.ok;
 	} catch {
 		return false;
 	}
 };
 
-const waitForServer = async () => {
+const waitForServer = async (serverProcess) => {
 	const startedAt = Date.now();
 	const timeoutMs = 30_000;
 
 	while (Date.now() - startedAt < timeoutMs) {
+		if (serverProcess.exitCode !== null) {
+			throw new Error(`Navigation test server exited before ${url} became reachable.`);
+		}
+
 		if (await isReachable()) {
 			return;
 		}
@@ -55,12 +65,6 @@ const waitForServer = async () => {
 	throw new Error(`Timed out waiting for ${url}`);
 };
 
-const runCapture = async (command, args, options = {}) => execFileAsync(command, args, {
-	cwd: root,
-	maxBuffer: 1024 * 1024 * 10,
-	...options,
-});
-
 const runInherit = (command, args, options = {}) => new Promise((resolve, reject) => {
 	const child = spawn(command, args, {
 		cwd: root,
@@ -82,31 +86,57 @@ const runInherit = (command, args, options = {}) => new Promise((resolve, reject
 	});
 });
 
-const ensureServer = async () => {
-	await stopServer();
+const startServer = async () => {
+	await runInherit(process.execPath, [cliPath, 'site:public'], {
+		cwd: navigationDemoSiteDir,
+	});
+	await runInherit(process.execPath, [cliPath, 'images'], {
+		cwd: navigationDemoSiteDir,
+	});
 
-	await runInherit(process.execPath, [cliPath, 'dev:local'], {
-		cwd: dogGallerySiteDir,
+	const serverProcess = spawn(process.execPath, [
+		cliPath,
+		'astro',
+		'dev',
+		'--ignore-lock',
+		'--host',
+		host,
+		'--port',
+		String(port),
+	], {
+		cwd: navigationDemoSiteDir,
+		stdio: 'inherit',
 		env: {
 			...process.env,
-			WALDE_NO_OPEN: '1',
+			ASTRO_DEV_BACKGROUND: '0',
 		},
 	});
-	await waitForServer();
+	serverProcess.once('error', (error) => {
+		throw error;
+	});
+	await waitForServer(serverProcess);
 
-	return true;
+	return serverProcess;
 };
 
-const stopServer = async () => {
-	await runCapture(process.execPath, [cliPath, 'dev:stop'], {
-		cwd: dogGallerySiteDir,
-	}).catch(() => {});
+const stopServer = async (serverProcess) => {
+	if (!serverProcess || serverProcess.exitCode !== null) return;
+
+	serverProcess.kill('SIGTERM');
+	const stopped = await Promise.race([
+		new Promise((resolve) => serverProcess.once('exit', () => resolve(true))),
+		sleep(5_000).then(() => false),
+	]);
+
+	if (!stopped && serverProcess.exitCode === null) {
+		serverProcess.kill('SIGKILL');
+	}
 };
 
-let startedServer = false;
+let serverProcess;
 
 try {
-	startedServer = await ensureServer();
+	serverProcess = await startServer();
 	await runInherit(npmBin, ['exec', '--', 'playwright', 'test', ...playwrightTargets], {
 		env: {
 			...process.env,
@@ -114,7 +144,5 @@ try {
 		},
 	});
 } finally {
-	if (startedServer) {
-		await stopServer();
-	}
+	await stopServer(serverProcess);
 }

package/scripts/test-package-check.mjs

@@ -158,12 +158,13 @@ try {
 		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.mjs')),
+		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', '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'),
@@ -177,13 +178,11 @@ try {
 	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.mjs');
+	const packageCheckConfigPath = path.join(siteProjectRoot, 'site', 'config.md');
 	const packageCheckConfig = await readFile(packageCheckConfigPath, 'utf8');
 	await writeFile(
 		packageCheckConfigPath,
-		packageCheckConfig
-			.replace("url: 'https://example.com/'", "url: 'https://example.com/site/'")
-			.replace("basePath: '/'", "basePath: '/site/'"),
+		packageCheckConfig.replace('url: https://example.com/', 'url: https://example.com/site/'),
 	);
 	const packageCheckSitewidePath = path.join(siteProjectRoot, 'site', 'sitewide-content.md');
 	const packageCheckSitewide = await readFile(packageCheckSitewidePath, 'utf8');
@@ -241,10 +240,11 @@ 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.mjs')),
+		assertFileExists(path.join(initializedSiteRoot, 'site', 'config.md')),
 		assertFileExists(path.join(initializedSiteRoot, 'site', 'theme.md')),
 		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 });
@@ -287,6 +287,14 @@ This route verifies that packaged norna sites can build route pages.
 		path.join(siteProjectRoot, 'dist', 'index.html'),
 		'<meta name="format-detection" content="telephone=no">',
 	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'style="scroll-behavior: auto;',
+	);
+	await assertFileExcludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'data-smooth-scroll=',
+	);
 	await assertFileIncludes(
 		path.join(siteProjectRoot, 'dist', 'about', 'index.html'),
 		'<link rel="canonical" href="https://example.com/site/about/">',
@@ -506,17 +514,17 @@ This route verifies that packaged norna sites can build route pages.
 		'typography.fontFamily',
 	);
 	await writeFile(siteThemePath, siteTheme);
-	const siteConfigPath = path.join(siteProjectRoot, 'site', 'config.mjs');
+	const siteConfigPath = path.join(siteProjectRoot, 'site', 'config.md');
 	const siteConfig = await readFile(siteConfigPath, 'utf8');
 	await writeFile(
 		siteConfigPath,
-		siteConfig.replace("basePath: '/site/'", "basePath: 'site'"),
+		siteConfig.replace('url: https://example.com/site/', 'url: example.com/site/'),
 	);
 	await runExpectFailure(
 		npxBin,
 		['norna', 'config:check'],
 		{ cwd: siteProjectRoot, env: npmEnv },
-		'site.basePath',
+		'url must be an absolute URL',
 	);
 
 	console.log('Package check passed.');

package/scripts/test-project-config.mjs

@@ -0,0 +1,130 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const repoRoot = path.resolve(import.meta.dirname, '..');
+const projectConfigUrl = pathToFileURL(path.join(repoRoot, 'scripts', 'lib', 'project-config.mjs')).href;
+const tempRoot = await mkdtemp(path.join(tmpdir(), 'norna-project-config-'));
+const importScript = `
+	const { projectConfig } = await import(${JSON.stringify(projectConfigUrl)});
+	console.log(JSON.stringify({
+		basePath: projectConfig.site.basePath,
+		language: projectConfig.locale.lang,
+		labels: projectConfig.locale.labels,
+		scrollBehavior: projectConfig.navigation.scrollBehavior,
+		url: projectConfig.site.url,
+	}));
+`;
+
+const createSite = async (name, config, { legacy = false } = {}) => {
+	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, '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');
+	return { projectRoot, siteDir };
+};
+
+const loadConfig = ({ projectRoot, siteDir }, env = {}) => spawnSync(
+	process.execPath,
+	['--input-type=module', '--eval', importScript],
+	{
+		cwd: projectRoot,
+		encoding: 'utf8',
+		env: {
+			...process.env,
+			NORNA_INVOCATION_ROOT: projectRoot,
+			NORNA_SITE_DIR: siteDir,
+			...env,
+		},
+	},
+);
+
+const assertFailure = (result, expectedPattern) => {
+	assert.notEqual(result.status, 0, result.stdout);
+	assert.match(`${result.stdout}\n${result.stderr}`, expectedPattern);
+};
+
+try {
+	const minimalSite = await createSite('minimal', '---\nurl: https://example.com/docs\n---\n');
+	const minimalResult = loadConfig(minimalSite);
+	assert.equal(minimalResult.status, 0, minimalResult.stderr);
+	assert.deepEqual(JSON.parse(minimalResult.stdout), {
+		basePath: '/docs/',
+		language: 'en',
+		labels: {
+			dismissBanner: 'Dismiss notice',
+			gallery: 'Images',
+			note: 'Note',
+			pageNavigation: 'On this page',
+			siteBanners: 'Site notices',
+			siteNavigation: 'Pages',
+			skipToContent: 'Skip to content',
+		},
+		scrollBehavior: 'instant',
+		url: 'https://example.com/docs/',
+	});
+
+	const localizedSite = await createSite('localized', '---\nurl: https://example.com/\nlanguage: sv-SE\nscrollBehavior: browser-smooth\n---\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');
+
+	const nornaSmoothSite = await createSite('norna-smooth', '---\nurl: https://example.com/\nscrollBehavior: norna-smooth\n---\n');
+	const nornaSmoothResult = loadConfig(nornaSmoothSite);
+	assert.equal(nornaSmoothResult.status, 0, nornaSmoothResult.stderr);
+	assert.equal(JSON.parse(nornaSmoothResult.stdout).scrollBehavior, 'norna-smooth');
+
+	const overrideResult = loadConfig(minimalSite, {
+		NORNA_SITE_URL: 'http://127.0.0.1:4567/preview',
+	});
+	assert.equal(overrideResult.status, 0, overrideResult.stderr);
+	assert.deepEqual(
+		JSON.parse(overrideResult.stdout),
+		{
+			...JSON.parse(minimalResult.stdout),
+			basePath: '/preview/',
+			url: 'http://127.0.0.1:4567/preview/',
+		},
+	);
+
+	assertFailure(
+		loadConfig(await createSite('unknown-field', '---\nurl: https://example.com/\nbasePath: /docs/\n---\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/,
+	);
+	assertFailure(
+		loadConfig(await createSite('unsupported-language', '---\nurl: https://example.com/\nlanguage: de\n---\n')),
+		/has no built-in Norna UI text/,
+	);
+	assertFailure(
+		loadConfig(await createSite('invalid-url', '---\nurl: example.com\n---\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, norna-smooth/,
+	);
+	assertFailure(
+		loadConfig(await createSite('obsolete-smooth-scroll', '---\nurl: https://example.com/\nsmoothScroll: true\n---\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-temporary-visibility.mjs

@@ -37,16 +37,9 @@ 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.mjs'), `export default {
-	site: {
-		url: 'https://example.com/',
-	},
-	github: {
-		repo: 'owner/example',
-		branch: 'main',
-		pagesWorkflow: 'Deploy to GitHub Pages',
-	},
-};
+	await writeFile(path.join(siteDir, 'config.md'), `---
+url: https://example.com/
+---
 `);
 	await writeFile(path.join(siteDir, 'theme.md'), `---
 typography: