@janga/norna 0.7.0

package/scripts/test-ci-lockfile.mjs

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { normalizeCiLockfile, verifyCiLockfile } from './lib/ci-lockfile.mjs';
+
+const execFileAsync = promisify(execFile);
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const tempRoot = await mkdtemp(path.join(tmpdir(), 'norna-ci-lockfile-'));
+const npmCachePath = path.join(repoRoot, 'node_modules', '.cache', 'norna-npm');
+const npmEnv = {
+	...process.env,
+	npm_config_cache: npmCachePath,
+};
+
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+try {
+	await writeFile(path.join(tempRoot, 'package.json'), `${JSON.stringify({
+		name: 'norna-ci-lockfile-test',
+		private: true,
+		dependencies: {
+			astro: '^7.1.3',
+		},
+	}, null, 2)}\n`);
+
+	const quietOptions = { env: npmEnv, stdio: 'ignore' };
+	await normalizeCiLockfile(tempRoot, quietOptions);
+	const lockfilePath = path.join(tempRoot, 'package-lock.json');
+	const corruptedLockfile = JSON.parse(await readFile(lockfilePath, 'utf8'));
+	const emnapiCoreVersion = corruptedLockfile.packages['node_modules/@emnapi/core']?.version;
+	assert.ok(emnapiCoreVersion, 'expected npm to include @emnapi/core in the normalized lockfile');
+	delete corruptedLockfile.packages['node_modules/@emnapi/core'];
+	await writeFile(lockfilePath, `${JSON.stringify(corruptedLockfile, null, 2)}\n`);
+
+	await assert.rejects(
+		execFileAsync(process.platform === 'win32' ? 'npx.cmd' : 'npx', [
+			'--yes',
+			'npm@11.16.0',
+			'ci',
+			'--dry-run',
+			'--ignore-scripts',
+			'--no-audit',
+			'--no-fund',
+			'--os=linux',
+			'--cpu=x64',
+			'--libc=glibc',
+		], { cwd: tempRoot, env: npmEnv }),
+		new RegExp(`Missing: @emnapi\\/core@${escapeRegExp(emnapiCoreVersion)} from lock file`),
+	);
+
+	await normalizeCiLockfile(tempRoot, quietOptions);
+	await verifyCiLockfile(tempRoot, quietOptions);
+
+	const repairedLockfile = JSON.parse(await readFile(lockfilePath, 'utf8'));
+	assert.equal(repairedLockfile.packages['node_modules/@emnapi/core']?.version, emnapiCoreVersion);
+	console.log('ok - CI lockfile normalization repairs missing optional npm peers');
+} finally {
+	await rm(tempRoot, { force: true, recursive: true });
+}

package/scripts/test-content-check.mjs

@@ -0,0 +1,364 @@
+import assert from 'node:assert/strict';
+import { access, mkdir, mkdtemp, 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 contentScript = path.join(repoRoot, 'scripts', 'sync-content-sections.mjs');
+const tests = [];
+
+const test = (name, run) => {
+	tests.push({ name, run });
+};
+
+const fileExists = async (filePath) => access(filePath).then(() => true, () => false);
+
+const runContentScript = (root, args, env = {}) => spawnSync(process.execPath, [contentScript, ...args], {
+	cwd: root,
+	encoding: 'utf8',
+	env: {
+		...process.env,
+		...env,
+	},
+});
+
+const getOutput = (result) => `${result.stdout}${result.stderr}`;
+
+const writeFixtureFile = async (root, relativePath, contents = 'fixture image') => {
+	const filePath = path.join(root, relativePath);
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, contents);
+};
+
+const makePngHeader = ({ width, height }) => {
+	const buffer = Buffer.alloc(24);
+	Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]).copy(buffer, 0);
+	buffer.writeUInt32BE(13, 8);
+	buffer.write('IHDR', 12, 'ascii');
+	buffer.writeUInt32BE(width, 16);
+	buffer.writeUInt32BE(height, 20);
+	return buffer;
+};
+
+const defaultTheme = `---
+presentation:
+  typography:
+    preset: quiet-gallery
+frame:
+  colors: presentation
+---
+`;
+
+const withTempProject = async ({ site, theme = defaultTheme, files, siteDirectory = 'site' }, run) => {
+	const root = await mkdtemp(path.join(tmpdir(), 'walde-content-check-'));
+
+	try {
+		await writeFixtureFile(root, `${siteDirectory}/content.md`, site);
+		await writeFixtureFile(root, `${siteDirectory}/theme.md`, theme);
+
+		for (const file of files) {
+			if (typeof file === 'string') {
+				await writeFixtureFile(root, file);
+			} else {
+				await writeFixtureFile(root, file.path, file.contents);
+			}
+		}
+
+		await run(root);
+	} finally {
+		await rm(root, { force: true, recursive: true });
+	}
+};
+
+const brokenSite = `---
+sections:
+  - id: karin-walde
+    gallery:
+      - image: karin.jpg
+  - id: min-konst
+    gallery:
+      - image: vav.jpeg
+      - image: missing.jpeg
+      - image: duplicate.jpg
+      - image: duplicate.jpg
+  - id: mitt-hem
+    gallery:
+      - image: home.jpg
+
+---
+## Karin Walde {#karin-walde}
+Text.
+## Min konst {#min-konst}
+Text.
+## Extra {#extra}
+Text.
+## Mitt hem {#mitt-hem}
+Text.
+`;
+
+test('content:check groups section issues, global issues, and unreferenced images', async () => {
+	await withTempProject({
+		site: brokenSite,
+		files: [
+			'site/images/karin-walde/karin.jpg',
+			'site/images/karin-walde/unreferenced.jpg',
+			'site/images/min-konst/duplicate.jpg',
+			'site/images/mitt-hem/home.jpg',
+			'site/images/mitt-hem/vav.jpeg',
+		],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 1, output);
+		assert.match(output, /^Content check failed\./m);
+		assert.match(output, /Section and Gallery Issues\n\n\[min-konst\]\n  Errors:/);
+		assert.match(output, /Image "vav\.jpeg" is used here but is located in site\/images\/mitt-hem\/\./);
+		assert.match(output, /Image "missing\.jpeg" does not exist anywhere under site\/images\/\./);
+		assert.match(output, /Image "duplicate\.jpg" is referenced more than once in this section\./);
+		assert.match(output, /\[extra\]\n  Warnings:/);
+		assert.match(output, /Global Content Issues\n\nWarnings:\n- Markdown section order differs from frontmatter\./);
+		assert.match(output, /Unreferenced Images\nThese files are kept in site\/images\/ but are not mounted on the site:/);
+		assert.match(output, /site\/images\/karin-walde\/unreferenced\.jpg/);
+	});
+});
+
+const carouselAspectRatioSite = `---
+sections:
+  - id: puppies
+    gallery:
+      - carousel:
+          - image: wide.png
+          - image: wider.png
+
+---
+## Puppies {#puppies}
+Text.
+`;
+
+test('content:check warns when carousel images use different aspect ratios', async () => {
+	await withTempProject({
+		site: carouselAspectRatioSite,
+		files: [
+			{
+				path: 'site/images/puppies/wide.png',
+				contents: makePngHeader({ width: 400, height: 300 }),
+			},
+			{
+				path: 'site/images/puppies/wider.png',
+				contents: makePngHeader({ width: 600, height: 300 }),
+			},
+		],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 0, output);
+		assert.match(output, /^Content check completed with warnings\./m);
+		assert.match(output, /Carousel on line 5 uses images with different aspect ratios: wide\.png \(4:3\), wider\.png \(2:1\)\./);
+		assert.match(output, /Use images with exactly matching proportions in the same carousel/);
+	});
+});
+
+const inlineStyleTheme = `---
+presentation:
+  inlineStyles:
+    highlight:
+      color: "#ffd84d"
+---
+`;
+
+const inlineStyleSite = `---
+sections:
+  - id: intro
+    gallery: []
+
+---
+## Intro {#intro}
+This has [known text]{.highlight} and [unknown text]{.missing}.
+`;
+
+test('content:check fails when Markdown uses undefined inline styles', async () => {
+	await withTempProject({
+		site: inlineStyleSite,
+		theme: inlineStyleTheme,
+		files: [],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 1, output);
+		assert.match(output, /^Content check failed\./m);
+		assert.match(output, /Inline style "\.missing" is used in Markdown but is not defined in site\/theme\.md presentation\.inlineStyles\./);
+		assert.doesNotMatch(output, /"\.highlight" is used in Markdown/);
+	});
+});
+
+const badWhitespaceSite = `---
+presentation:
+  typography:
+    preset: quiet-gallery
+\u00a0\u00a0\u00a0\u00a0overrides:
+      body:
+        paragraphSpacing: 0.3em
+sections:
+  - id: intro
+    gallery: []
+
+---
+## Intro {#intro}
+Text.
+`;
+
+test('content:check explains invalid frontmatter indentation whitespace', async () => {
+	await withTempProject({
+		site: badWhitespaceSite,
+		files: [],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 1, output);
+		assert.match(output, /^Content check failed\./m);
+		assert.match(output, /Frontmatter line 5 uses tabs, non-breaking spaces, or invalid whitespace for indentation\./);
+		assert.match(output, /Replace the indentation on that line with ordinary spaces\./);
+	});
+});
+
+const badNestedValueSite = `---
+presentation:
+  typography:
+    preset: quiet-gallery
+      overrides:
+        body:
+          paragraphSpacing: 0.3em
+sections:
+  - id: intro
+    gallery: []
+
+---
+## Intro {#intro}
+Text.
+`;
+
+test('content:check explains frontmatter indentation below scalar values', async () => {
+	await withTempProject({
+		site: badNestedValueSite,
+		files: [],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 1, output);
+		assert.match(output, /^Content check failed\./m);
+		assert.match(output, /Frontmatter line 5 is indented under line 4, but line 4 already has a value\./);
+		assert.match(output, /Move the later line to the same indentation level as its sibling/);
+	});
+});
+
+const topLevelGallerySite = `---
+title: Example
+description: Example site.
+sections:
+  - id: intro
+gallery:
+      - image: intro.jpg
+
+---
+## Intro {#intro}
+Text.
+`;
+
+test('content:check explains likely misindented frontmatter keys', async () => {
+	await withTempProject({
+		site: topLevelGallerySite,
+		files: ['site/images/intro/intro.jpg'],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 1, output);
+		assert.match(output, /^Content check failed\./m);
+		assert.match(output, /Frontmatter line 6 defines "gallery" at the top level, but it is not a valid top-level content field\./);
+		assert.match(output, /Indent "gallery:" under the section or object it belongs to\./);
+	});
+});
+
+test('content:check respects NORNA_SITE_DIR', async () => {
+	await withTempProject({
+		site: movableSite,
+		siteDirectory: 'custom-site',
+		files: [
+			'custom-site/images/min-konst/move-me.jpg',
+			'custom-site/images/mitt-hem/home.jpg',
+		],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check'], { NORNA_SITE_DIR: 'custom-site' });
+		const output = getOutput(result);
+
+		assert.equal(result.status, 0, output);
+		assert.match(output, /Content check passed\./);
+	});
+});
+
+const movableSite = `---
+sections:
+  - id: min-konst
+    gallery:
+      - image: move-me.jpg
+  - id: mitt-hem
+    gallery:
+      - image: home.jpg
+
+---
+## Min konst {#min-konst}
+Text.
+## Mitt hem {#mitt-hem}
+Text.
+`;
+
+test('content:sync moves referenced images and keeps unreferenced images in place', async () => {
+	await withTempProject({
+		site: movableSite,
+		files: [
+			'site/images/mitt-hem/home.jpg',
+			'site/images/mitt-hem/move-me.jpg',
+			'site/images/mitt-hem/unreferenced.jpg',
+		],
+	}, async (root) => {
+		const syncResult = runContentScript(root, ['--write', '--yes']);
+		const syncOutput = getOutput(syncResult);
+
+		assert.equal(syncResult.status, 0, syncOutput);
+		assert.match(syncOutput, /Moved image "move-me\.jpg" to site\/images\/min-konst\/\./);
+		assert.equal(await fileExists(path.join(root, 'site/images/min-konst/move-me.jpg')), true);
+		assert.equal(await fileExists(path.join(root, 'site/images/mitt-hem/move-me.jpg')), false);
+		assert.equal(await fileExists(path.join(root, 'site/images/mitt-hem/unreferenced.jpg')), true);
+
+		const checkResult = runContentScript(root, ['--check']);
+		const checkOutput = getOutput(checkResult);
+
+		assert.equal(checkResult.status, 0, checkOutput);
+		assert.match(checkOutput, /Content check passed\./);
+		assert.match(checkOutput, /site\/images\/mitt-hem\/unreferenced\.jpg/);
+	});
+});
+
+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-engine-commands.mjs

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+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 cliPath = path.join(repoRoot, 'bin', 'norna.mjs');
+const packageJson = JSON.parse(await readFile(path.join(repoRoot, 'package.json'), 'utf8'));
+const tempRoot = await mkdtemp(path.join(tmpdir(), 'norna-engine-commands-'));
+
+const runCli = (args, options = {}) => spawnSync(process.execPath, [cliPath, ...args], {
+	cwd: repoRoot,
+	encoding: 'utf8',
+	...options,
+});
+
+try {
+	const versionResult = runCli(['engine:version']);
+	assert.equal(versionResult.status, 0, versionResult.stderr || versionResult.stdout);
+	assert.match(versionResult.stdout, /norna engine:version/);
+	assert.match(versionResult.stdout, new RegExp(`Installed norna: ${packageJson.version.replaceAll('.', '\\.')}`));
+	assert.match(versionResult.stdout, /Installed Astro: /);
+
+	const initializedSiteRoot = path.join(tempRoot, 'initialized-site');
+	const initResult = runCli(['init', initializedSiteRoot]);
+	assert.equal(initResult.status, 0, initResult.stderr || initResult.stdout);
+	assert.match(initResult.stdout, /Created norna site at /);
+
+	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:engine:update'], 'norna engine:update');
+	assert.equal(initializedPackageJson.scripts['norna:engine:version'], 'norna engine:version');
+	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:/);
+
+	const showResult = runCli(['--site-dir', path.join(initializedSiteRoot, 'site'), 'typography:show']);
+	assert.equal(showResult.status, 0, showResult.stderr || showResult.stdout);
+	assert.match(showResult.stdout, /theme:/);
+	assert.match(showResult.stdout, /page:/);
+	assert.match(showResult.stdout, /preset: quiet-gallery/);
+	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.mjs'));
+	await readFile(path.join(customPureSiteRoot, 'presentation', 'theme.md'));
+
+	const mixedProjectRoot = path.join(tempRoot, 'mixed-project');
+	await mkdir(mixedProjectRoot, { recursive: true });
+	await writeFile(path.join(mixedProjectRoot, 'package.json'), `${JSON.stringify({
+		name: 'mixed-project',
+		private: true,
+		type: 'module',
+		scripts: {
+			build: 'node build-app.mjs',
+		},
+	}, null, 2)}\n`);
+	const embeddedInitResult = runCli(['init', '.', '--type', 'embedded', '--site-dir', 'presentation'], {
+		cwd: mixedProjectRoot,
+	});
+	assert.equal(embeddedInitResult.status, 0, embeddedInitResult.stderr || embeddedInitResult.stdout);
+	assert.match(embeddedInitResult.stdout, /Added norna site directory at /);
+	const mixedPackageJson = JSON.parse(await readFile(path.join(mixedProjectRoot, 'package.json'), 'utf8'));
+	assert.equal(mixedPackageJson.dependencies['@janga/norna'], packageJson.version);
+	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: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', 'theme.md'));
+
+	const conflictProjectRoot = path.join(tempRoot, 'conflict-project');
+	await mkdir(conflictProjectRoot, { recursive: true });
+	await writeFile(path.join(conflictProjectRoot, 'package.json'), `${JSON.stringify({
+		name: 'conflict-project',
+		private: true,
+		scripts: {
+			'norna:dev': 'vite --host 0.0.0.0',
+		},
+	}, null, 2)}\n`);
+	const conflictInitResult = runCli(['init', '.', '--type', 'embedded', '--site-dir', 'presentation'], {
+		cwd: conflictProjectRoot,
+	});
+	assert.notEqual(conflictInitResult.status, 0);
+	assert.match(conflictInitResult.stderr, /Refusing to overwrite existing npm scripts/);
+	assert.match(conflictInitResult.stderr, /norna:dev/);
+
+	const pureIntoExistingProjectResult = runCli(['init', '.', '--type', 'pure'], {
+		cwd: mixedProjectRoot,
+	});
+	assert.notEqual(pureIntoExistingProjectResult.status, 0);
+	assert.match(pureIntoExistingProjectResult.stderr, /use --type embedded/);
+
+	const updateFromEngineResult = runCli(['engine:update', '--skip-checks']);
+	assert.notEqual(updateFromEngineResult.status, 0);
+	assert.match(updateFromEngineResult.stderr, /must be run from a site repository/);
+
+	const releaseHelpResult = spawnSync(process.execPath, [path.join(repoRoot, 'scripts', 'release.mjs'), 'patch', '--help'], {
+		cwd: repoRoot,
+		encoding: 'utf8',
+	});
+	assert.equal(releaseHelpResult.status, 0, releaseHelpResult.stderr || releaseHelpResult.stdout);
+	assert.match(releaseHelpResult.stdout, /Usage: node scripts\/release\.mjs/);
+
+	console.log('ok - engine commands report versions, initialize sites, guard engine self-updates, and document release usage');
+} finally {
+	await rm(tempRoot, { force: true, recursive: true });
+}

package/scripts/test-navigation-preview.mjs

@@ -0,0 +1,108 @@
+import { spawn } from 'node:child_process';
+
+const root = process.cwd();
+const host = 'localhost';
+const port = 4322;
+const url = `http://${host}:${port}/`;
+const probeUrls = [url, `http://127.0.0.1:${port}/`, `http://[::1]:${port}/`];
+const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+
+const sleep = (milliseconds) => new Promise((resolve) => {
+	setTimeout(resolve, milliseconds);
+});
+
+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 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.
+		}
+	}
+
+	return false;
+};
+
+const waitForPreview = async (previewProcess) => {
+	const startedAt = Date.now();
+	const timeoutMs = 30_000;
+
+	while (Date.now() - startedAt < timeoutMs) {
+		if (previewProcess.exitCode !== null) {
+			throw new Error(`astro preview exited before ${url} became reachable.`);
+		}
+
+		if (await isReachable()) {
+			return;
+		}
+
+		await sleep(500);
+	}
+
+	throw new Error(`Timed out waiting for ${url}`);
+};
+
+const stopPreview = async (previewProcess) => {
+	if (!previewProcess || previewProcess.exitCode !== null) return;
+
+	previewProcess.kill('SIGTERM');
+
+	const stopped = await Promise.race([
+		new Promise((resolve) => {
+			previewProcess.once('exit', () => resolve(true));
+		}),
+		sleep(5_000).then(() => false),
+	]);
+
+	if (!stopped && previewProcess.exitCode === null) {
+		previewProcess.kill('SIGKILL');
+	}
+};
+
+let previewProcess;
+
+try {
+	await runInherit(npmBin, ['run', 'build']);
+
+	previewProcess = spawn(npmBin, ['run', 'astro', '--', 'preview', '--host', host, '--port', String(port)], {
+		cwd: root,
+		stdio: 'inherit',
+	});
+
+	previewProcess.once('error', (error) => {
+		throw error;
+	});
+
+	await waitForPreview(previewProcess);
+	await runInherit(npmBin, ['exec', '--', 'playwright', 'test', 'tests/navigation-preview.spec.ts'], {
+		env: {
+			...process.env,
+			PLAYWRIGHT_BASE_URL: url,
+		},
+	});
+} finally {
+	await stopPreview(previewProcess);
+}