@janga/norna 0.7.0

package/scripts/test-navigation.mjs

@@ -0,0 +1,116 @@
+import { execFile, spawn } from 'node:child_process';
+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 url = 'http://localhost:4321/';
+const probeUrls = [url, 'http://127.0.0.1:4321/', 'http://[::1]:4321/'];
+const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const testTargets = process.argv.slice(2);
+const playwrightTargets = testTargets.length > 0 ? testTargets : ['tests/navigation.spec.ts'];
+
+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.
+		}
+	}
+
+	try {
+		await execFileAsync('curl', ['-fsI', url], {
+			cwd: root,
+			maxBuffer: 1024 * 1024,
+		});
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+const waitForServer = async () => {
+	const startedAt = Date.now();
+	const timeoutMs = 30_000;
+
+	while (Date.now() - startedAt < timeoutMs) {
+		if (await isReachable()) {
+			return;
+		}
+
+		await sleep(500);
+	}
+
+	throw new Error(`Timed out waiting for ${url}`);
+};
+
+const runCapture = async (command, args) => execFileAsync(command, args, {
+	cwd: root,
+	maxBuffer: 1024 * 1024 * 10,
+});
+
+const runInherit = (command, args, options = {}) => new Promise((resolve, reject) => {
+	const child = spawn(command, args, {
+		cwd: root,
+		stdio: 'inherit',
+		...options,
+	});
+
+	child.once('error', reject);
+	child.once('exit', (code, signal) => {
+		if (code === 0) {
+			resolve();
+			return;
+		}
+
+		const commandText = [command, ...args].join(' ');
+		reject(new Error(signal
+			? `${commandText} exited with signal ${signal}.`
+			: `${commandText} exited with code ${code}.`));
+	});
+});
+
+const ensureServer = async () => {
+	if (await isReachable()) {
+		return false;
+	}
+
+	await runInherit(npmBin, ['run', 'dev:local'], {
+		env: {
+			...process.env,
+			WALDE_NO_OPEN: '1',
+		},
+	});
+	await waitForServer();
+
+	return true;
+};
+
+const stopServer = async () => {
+	await runCapture(npmBin, ['run', 'dev:stop']).catch(() => {});
+};
+
+let startedServer = false;
+
+try {
+	startedServer = await ensureServer();
+	await runInherit(npmBin, ['exec', '--', 'playwright', 'test', ...playwrightTargets], {
+		env: {
+			...process.env,
+			PLAYWRIGHT_BASE_URL: url,
+		},
+	});
+} finally {
+	if (startedServer) {
+		await stopServer();
+	}
+}

package/scripts/test-package-check.mjs

@@ -0,0 +1,394 @@
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const run = (command, args, options = {}) => new Promise((resolve, reject) => {
+	const child = spawn(command, args, {
+		cwd: repoRoot,
+		stdio: ['ignore', 'pipe', 'pipe'],
+		...options,
+	});
+	let stdout = '';
+	let stderr = '';
+
+	child.stdout?.on('data', (chunk) => {
+		stdout += chunk;
+	});
+	child.stderr?.on('data', (chunk) => {
+		stderr += chunk;
+	});
+	child.once('error', reject);
+	child.once('exit', (code, signal) => {
+		if (code === 0) {
+			resolve({ stdout, stderr });
+			return;
+		}
+
+		const commandText = [command, ...args].join(' ');
+		reject(new Error([
+			signal
+				? `${commandText} exited with signal ${signal}.`
+				: `${commandText} exited with code ${code}.`,
+			stdout.trim(),
+			stderr.trim(),
+		].filter(Boolean).join('\n')));
+	});
+});
+
+const runInherit = (command, args, options = {}) => new Promise((resolve, reject) => {
+	const child = spawn(command, args, {
+		cwd: repoRoot,
+		stdio: 'inherit',
+		...options,
+	});
+
+	child.once('error', reject);
+	child.once('exit', (code, signal) => {
+		if (code === 0) {
+			resolve();
+			return;
+		}
+
+		const commandText = [command, ...args].join(' ');
+		reject(new Error(signal
+			? `${commandText} exited with signal ${signal}.`
+			: `${commandText} exited with code ${code}.`));
+	});
+});
+
+const runExpectFailure = async (command, args, options = {}, expectedText) => {
+	try {
+		await run(command, args, options);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+
+		if (message.includes(expectedText)) {
+			return;
+		}
+
+		throw new Error(`Expected failing command output to include "${expectedText}".\n${message}`);
+	}
+
+	throw new Error(`Expected command to fail: ${[command, ...args].join(' ')}`);
+};
+
+const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const npxBin = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+const tempRoot = await mkdtemp(path.join(tmpdir(), 'norna-package-check-'));
+const packDir = path.join(tempRoot, 'pack');
+const unpackDir = path.join(tempRoot, 'unpack');
+const siteProjectRoot = path.join(tempRoot, 'site-project');
+const initializedSiteRoot = path.join(tempRoot, 'initialized-site');
+const npmCachePath = path.resolve(
+	repoRoot,
+	process.env.NORNA_PACKAGE_CHECK_CACHE
+		?? path.join('node_modules', '.cache', 'norna-package-check-npm'),
+);
+const npmEnv = {
+	...process.env,
+	npm_config_cache: npmCachePath,
+};
+
+const assertFileExists = async (filePath) => {
+	try {
+		await readFile(filePath);
+	} catch (error) {
+		if (error?.code === 'ENOENT') {
+			throw new Error(`Packed package is missing ${path.relative(unpackDir, filePath)}.`);
+		}
+
+		throw error;
+	}
+};
+
+const assertFileMissing = async (filePath) => {
+	try {
+		await readFile(filePath);
+	} catch (error) {
+		if (error?.code === 'ENOENT') {
+			return;
+		}
+
+		throw error;
+	}
+
+	throw new Error(`Unexpected file exists: ${filePath}.`);
+};
+
+const assertFileIncludes = async (filePath, expectedText) => {
+	const fileContent = await readFile(filePath, 'utf8');
+
+	if (!fileContent.includes(expectedText)) {
+		throw new Error(`Expected ${filePath} to include: ${expectedText}`);
+	}
+};
+
+const assertFileExcludes = async (filePath, unexpectedText) => {
+	const fileContent = await readFile(filePath, 'utf8');
+
+	if (fileContent.includes(unexpectedText)) {
+		throw new Error(`Expected ${filePath} not to include: ${unexpectedText}`);
+	}
+};
+
+try {
+	await mkdir(packDir, { recursive: true });
+	await mkdir(npmCachePath, { recursive: true });
+	const packResult = await run(npmBin, ['pack', '--pack-destination', packDir], {
+		env: npmEnv,
+	});
+	const tarballName = packResult.stdout.trim().split('\n').at(-1);
+
+	if (!tarballName?.endsWith('.tgz')) {
+		throw new Error(`npm pack did not report a tarball name.\n${packResult.stdout}${packResult.stderr}`);
+	}
+
+	const tarballPath = path.join(packDir, tarballName);
+	await mkdir(unpackDir, { recursive: true });
+	await runInherit('tar', ['-xzf', tarballPath, '-C', unpackDir]);
+	const packagedStarterRoot = path.join(unpackDir, 'package', 'starters', 'basic');
+	await Promise.all([
+		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(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', 'theme.md')),
+		assertFileExists(path.join(packagedStarterRoot, 'site', 'content.md')),
+		assertFileExists(path.join(packagedStarterRoot, 'site', 'images', 'work', '.gitkeep')),
+		assertFileExists(path.join(packagedStarterRoot, 'site', 'public', 'robots.txt')),
+	]);
+	await assertFileIncludes(
+		path.join(packagedStarterRoot, '.github', 'workflows', 'deploy.yml'),
+		'node-version: 24.18.0',
+	);
+	await cp(packagedStarterRoot, siteProjectRoot, {
+		recursive: true,
+	});
+	const packageJsonPath = path.join(siteProjectRoot, 'package.json');
+	const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+	packageJson.name = 'norna-package-check-site';
+	packageJson.dependencies['@janga/norna'] = tarballPath;
+	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+	await mkdir(path.join(siteProjectRoot, 'site', 'routes', 'about'), { recursive: true });
+	await writeFile(path.join(siteProjectRoot, 'site', 'routes', 'about', 'route-content.md'), `---
+title: About the gallery
+description: Route used by package checks.
+navigation:
+  label: About
+  order: 20
+sections:
+  - id: about
+---
+
+## About {#about}
+
+This route verifies that packaged norna sites can build route pages.
+`);
+
+	await runInherit(npmBin, ['install', '--no-audit', '--no-fund', '--prefer-offline', '--fetch-retries=0'], { cwd: siteProjectRoot, env: npmEnv });
+	const nornaBinPath = path.join(siteProjectRoot, 'node_modules', '.bin', process.platform === 'win32' ? 'norna.cmd' : 'norna');
+	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', 'theme.md')),
+		assertFileMissing(path.join(initializedSiteRoot, '.DS_Store')),
+		assertFileMissing(path.join(initializedSiteRoot, 'site', '.DS_Store')),
+	]);
+	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', 'build'], { cwd: siteProjectRoot, env: npmEnv });
+	await assertFileExists(path.join(siteProjectRoot, 'site', '.norna', 'public', 'robots.txt'));
+	await assertFileExists(path.join(siteProjectRoot, 'dist', 'robots.txt'));
+	await assertFileExists(path.join(siteProjectRoot, 'dist', 'about', 'index.html'));
+	await assertFileMissing(path.join(siteProjectRoot, 'public', 'robots.txt'));
+	await assertFileExcludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'href="/favicon.svg"',
+	);
+	await assertFileExcludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'href="/favicon.ico"',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--section-heading-font-size-desktop: clamp(1.65rem, 4.6vw, 5.65rem)',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		"--font-sans: Arial, 'Helvetica Neue', Helvetica, sans-serif",
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'<meta name="format-detection" content="telephone=no">',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'about', 'index.html'),
+		'<link rel="canonical" href="https://example.com/about/">',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'about', 'index.html'),
+		'href="/about/" aria-current="page"',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--section-body-align-mobile: left',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--section-body-line-height: 1.5',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--section-body-paragraph-spacing: 0.85em',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--section-caption-line-height: 1.35',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'class="inline-style inline-style-highlight" style="--inline-style-color: #ffd84d"',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--section-background-color: #000000',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--site-top-background-color: #000000',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--site-top-text-color: #f7f4ee',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--site-footer-background-color: #000000',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--site-footer-text-color: #f7f4ee',
+	);
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'--section-text-color: #f7f4ee',
+	);
+	await writeFile(path.join(siteProjectRoot, 'site', 'public', 'favicon.ico'), 'fake icon');
+	await runInherit(npxBin, ['norna', 'build'], { cwd: siteProjectRoot, env: npmEnv });
+	await assertFileExists(path.join(siteProjectRoot, 'dist', 'favicon.ico'));
+	await assertFileIncludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'<link rel="icon" sizes="any" href="/favicon.ico">',
+	);
+	await assertFileExcludes(
+		path.join(siteProjectRoot, 'dist', 'index.html'),
+		'href="/favicon.svg"',
+	);
+	const siteContentPath = path.join(siteProjectRoot, 'site', 'content.md');
+	const siteContent = await readFile(siteContentPath, 'utf8');
+	const siteThemePath = path.join(siteProjectRoot, 'site', 'theme.md');
+	const siteTheme = await readFile(siteThemePath, 'utf8');
+	await writeFile(siteThemePath, siteTheme.replace('\n    preset: quiet-gallery', '\n    preset: noisy-gallery'));
+	await runExpectFailure(
+		npxBin,
+		['norna', 'build'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'presentation.typography.preset',
+	);
+	await writeFile(
+		siteThemePath,
+		siteTheme.replace('backgroundColor: "#000000"', 'backgroundColor: blue'),
+	);
+	await runExpectFailure(
+		npxBin,
+		['norna', 'build'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'presentation.backgroundColor',
+	);
+	await writeFile(
+		siteThemePath,
+		siteTheme.replace('textColor: "#f7f4ee"', 'textColor: white'),
+	);
+	await runExpectFailure(
+		npxBin,
+		['norna', 'build'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'presentation.textColor',
+	);
+	await writeFile(
+		siteThemePath,
+		siteTheme.replace('      color: "#ffd84d"', '      color: yellow'),
+	);
+	await runExpectFailure(
+		npxBin,
+		['norna', 'build'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'presentation.inlineStyles.highlight.color',
+	);
+	await writeFile(siteThemePath, siteTheme);
+	await writeFile(
+		siteContentPath,
+		siteContent.replace(
+			'description: Minimal norna starter site.',
+			'description: Minimal norna starter site.\npresentation:\n  typography:\n    overrides:\n      body:\n        lineHeight: tight',
+		),
+	);
+	await runExpectFailure(
+		npxBin,
+		['norna', 'build'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'presentation.typography.overrides.body.lineHeight',
+	);
+	await writeFile(
+		siteContentPath,
+		siteContent.replace(
+			'      typography:\n        preset: statement',
+			'      typography:\n        overrides:\n          caption:\n            spacing: wide',
+		),
+	);
+	await runExpectFailure(
+		npxBin,
+		['norna', 'build'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'sections.0.presentation.typography.overrides.caption.spacing',
+	);
+	await writeFile(
+		siteContentPath,
+		siteContent.replace('        preset: statement', '        preset: dramatic'),
+	);
+	await runExpectFailure(
+		npxBin,
+		['norna', 'build'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'sections.0.presentation.typography.preset',
+	);
+	const siteConfigPath = path.join(siteProjectRoot, 'site', 'config.mjs');
+	const siteConfig = await readFile(siteConfigPath, 'utf8');
+	await writeFile(
+		siteConfigPath,
+		siteConfig.replace(
+			'fontFamily: "Arial, \'Helvetica Neue\', Helvetica, sans-serif"',
+			'fontFamily: "Arial; color: red"',
+		),
+	);
+	await runExpectFailure(
+		npxBin,
+		['norna', 'config:check'],
+		{ cwd: siteProjectRoot, env: npmEnv },
+		'typography.fontFamily',
+	);
+
+	console.log('Package check passed.');
+} finally {
+	await rm(tempRoot, { force: true, recursive: true });
+}

package/scripts/test-site-public.mjs

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const syncScript = path.join(repoRoot, 'scripts', 'sync-site-public.mjs');
+const tests = [];
+
+const test = (name, run) => {
+	tests.push({ name, run });
+};
+
+const fileExists = async (filePath) => access(filePath).then(() => true, () => false);
+
+const runSyncScript = (root, env = {}) => spawnSync(process.execPath, [syncScript], {
+	cwd: root,
+	encoding: 'utf8',
+	env: {
+		...process.env,
+		...env,
+	},
+});
+
+const getOutput = (result) => `${result.stdout}${result.stderr}`;
+
+const writeFixtureFile = async (root, relativePath, contents) => {
+	const filePath = path.join(root, relativePath);
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, contents);
+};
+
+const readFixtureFile = (root, relativePath) => readFile(path.join(root, relativePath), 'utf8');
+
+const withTempProject = async (run) => {
+	const root = await mkdtemp(path.join(tmpdir(), 'walde-site-public-'));
+
+	try {
+		await run(root);
+	} finally {
+		await rm(root, { force: true, recursive: true });
+	}
+};
+
+test('site:public copies configured public files, removes stale generated public files, and keeps images output', async () => {
+	await withTempProject(async (root) => {
+		await writeFixtureFile(root, 'custom-site/public/CNAME', 'example.com\n');
+		await writeFixtureFile(root, 'custom-site/public/robots.txt', 'User-agent: *\nAllow: /\n');
+		await writeFixtureFile(root, 'custom-site/public/nested/source.txt', 'source file\n');
+		await writeFixtureFile(root, 'custom-site/.norna/public/stale.txt', 'stale generated file\n');
+		await writeFixtureFile(root, 'custom-site/.norna/public/nested/old.txt', 'stale nested file\n');
+		await writeFixtureFile(root, 'custom-site/.norna/public/images/generated/keep.webp', 'generated image\n');
+
+		const result = runSyncScript(root, { NORNA_SITE_DIR: 'custom-site' });
+		const output = getOutput(result);
+
+		assert.equal(result.status, 0, output);
+		assert.match(output, /Synced custom-site\/public\/ to custom-site\/\.norna\/public\/\./);
+		assert.equal(await readFixtureFile(root, 'custom-site/.norna/public/CNAME'), 'example.com\n');
+		assert.equal(await readFixtureFile(root, 'custom-site/.norna/public/robots.txt'), 'User-agent: *\nAllow: /\n');
+		assert.equal(await readFixtureFile(root, 'custom-site/.norna/public/nested/source.txt'), 'source file\n');
+		assert.equal(await fileExists(path.join(root, 'custom-site/.norna/public/stale.txt')), false);
+		assert.equal(await fileExists(path.join(root, 'custom-site/.norna/public/nested/old.txt')), false);
+		assert.equal(await readFixtureFile(root, 'custom-site/.norna/public/images/generated/keep.webp'), 'generated image\n');
+	});
+});
+
+let failed = 0;
+
+for (const { name, run } of tests) {
+	try {
+		await run();
+		console.log(`ok - ${name}`);
+	} catch (error) {
+		failed += 1;
+		console.error(`not ok - ${name}`);
+		console.error(error);
+	}
+}
+
+if (failed > 0) {
+	process.exit(1);
+}

package/scripts/test-temporary-visibility.mjs

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const nornaBin = path.join(repoRoot, 'bin', 'norna.mjs');
+const tempParent = path.join(repoRoot, 'node_modules', '.cache');
+await mkdir(tempParent, { recursive: true });
+const tempRoot = await mkdtemp(path.join(tempParent, 'norna-temporary-visibility-'));
+const siteDir = path.join(tempRoot, 'site');
+
+const runCli = (args, env = {}) => {
+	const result = spawnSync(process.execPath, [nornaBin, ...args], {
+		cwd: tempRoot,
+		encoding: 'utf8',
+		env: {
+			...process.env,
+			NORNA_SITE_DIR: siteDir,
+			...env,
+		},
+	});
+
+	if (result.status !== 0) {
+		throw new Error([
+			`norna ${args.join(' ')} exited with code ${result.status}.`,
+			result.stdout.trim(),
+			result.stderr.trim(),
+		].filter(Boolean).join('\n'));
+	}
+
+	return result;
+};
+
+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, 'theme.md'), `---
+presentation:
+  typography:
+    preset: quiet-gallery
+frame:
+  colors: presentation
+---
+`);
+	await writeFile(path.join(siteDir, 'content.md'), `---
+title: Temporary Visibility Test
+description: Test site for temporary sections.
+sections:
+  - id: expired
+    visible:
+      until: "2026-01-01"
+    gallery: []
+  - id: active
+    visible:
+      from: "2026-01-01"
+      until: "2026-12-31"
+    gallery: []
+  - id: always
+    gallery: []
+
+---
+## Expired {#expired}
+
+Expired section text.
+
+## Active {#active}
+
+Active section text.
+
+## Always {#always}
+
+Always visible section text.
+`);
+
+	runCli(['build'], { NORNA_TODAY: '2026-06-15' });
+
+	const html = await readFile(path.join(tempRoot, 'dist', 'index.html'), 'utf8');
+	assert.match(html, /Active section text/);
+	assert.match(html, /Always visible section text/);
+	assert.doesNotMatch(html, /Expired section text/);
+
+	console.log('Temporary visibility test passed.');
+} finally {
+	await rm(tempRoot, { force: true, recursive: true });
+}