@janga/norna 0.7.11 → 0.7.13

package/scripts/test-client-javascript.mjs

@@ -0,0 +1,221 @@
+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-client-javascript-'));
+const siteDir = path.join(tempRoot, 'site');
+const routeDir = path.join(siteDir, 'routes', '010-details');
+const configPath = path.join(siteDir, 'config.md');
+
+const runBuild = () => {
+	const result = spawnSync(process.execPath, [nornaBin, 'build'], {
+		cwd: tempRoot,
+		encoding: 'utf8',
+		env: {
+			...process.env,
+			NORNA_SITE_DIR: siteDir,
+		},
+	});
+
+	if (result.status !== 0) {
+		throw new Error([
+			`norna build exited with code ${result.status}.`,
+			result.stdout.trim(),
+			result.stderr.trim(),
+		].filter(Boolean).join('\n'));
+	}
+};
+
+const readPage = (pathname = 'index.html') => readFile(path.join(tempRoot, 'dist', pathname), 'utf8');
+const getScripts = (html) => html.match(/<script\b[^>]*>[\s\S]*?<\/script>/gi) ?? [];
+const assertNoClientJavaScript = (html, label) => {
+	assert.deepEqual(getScripts(html), [], `${label} should not require client-side JavaScript.`);
+};
+const assertScrollBehavior = (html, behavior, label) => {
+	assert.match(
+		html,
+		new RegExp(`<html\\b[^>]*style="[^"]*scroll-behavior: ${behavior}(?:;|&quot;|\")`),
+		`${label} should render scroll-behavior: ${behavior}.`,
+	);
+};
+const writeConfig = (scrollBehavior) => writeFile(configPath, `---
+url: https://example.com/
+${scrollBehavior ? `scrollBehavior: ${scrollBehavior}\n` : ''}---
+`);
+const writeSvg = (filePath, color) => writeFile(filePath, [
+	'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 160 90">',
+	`  <rect width="160" height="90" fill="${color}"/>`,
+	'</svg>',
+	'',
+].join('\n'));
+
+try {
+	await mkdir(path.join(siteDir, 'public'), { recursive: true });
+	await writeConfig();
+	await writeFile(path.join(siteDir, 'theme.md'), `---
+typography:
+  preset: text-forward
+presentation:
+  palette: paper
+---
+`);
+	await writeFile(path.join(siteDir, 'sitewide-content.md'), `---
+navigation:
+  brand: Test site
+---
+`);
+	await writeFile(path.join(siteDir, 'content.md'), `---
+title: Static single page
+description: A single page without interactive features.
+sections:
+  intro: {}
+  more: {}
+---
+## Intro {#intro}
+
+Ordinary Markdown needs no client-side JavaScript.
+
+## More {#more}
+
+Additional sections do not make the page interactive.
+`);
+
+	runBuild();
+	const instantHtml = await readPage();
+	assertNoClientJavaScript(instantHtml, 'The default instant scroll mode');
+	assertScrollBehavior(instantHtml, 'auto', 'The default instant scroll mode');
+	assert.match(instantHtml, /<nav class="page-nav"/);
+	assert.match(instantHtml, /href="#intro"/);
+	assert.match(instantHtml, /href="#more"/);
+
+	await writeConfig('browser-smooth');
+	runBuild();
+	const browserSmoothHtml = await readPage();
+	assertNoClientJavaScript(browserSmoothHtml, 'The browser smooth scroll mode');
+	assertScrollBehavior(browserSmoothHtml, 'smooth', 'The browser smooth scroll mode');
+
+	await writeConfig();
+
+	await mkdir(path.join(routeDir, 'images', 'details'), { recursive: true });
+	await writeSvg(path.join(routeDir, 'images', 'details', 'first.svg'), '#7b8f78');
+	await writeSvg(path.join(routeDir, 'images', 'details', 'second.svg'), '#a7664b');
+	await writeFile(path.join(siteDir, 'content.md'), `---
+title: Static baseline
+description: A page without interactive features.
+sections:
+  intro: {}
+---
+## Intro {#intro}
+
+Ordinary Markdown needs no client-side JavaScript.
+`);
+	await writeFile(path.join(routeDir, 'route-content.md'), `---
+title: Details
+description: Static managed images.
+sections:
+  details: {}
+---
+## Details {#details}
+
+Static image stacks remain static.
+
+\`\`\`norna-image-stack
+- image: first.svg
+  caption: First image.
+- image: second.svg
+  caption: Second image.
+\`\`\`
+
+\`\`\`norna-card-list
+- title: Static card
+  text: Cards do not require client-side behaviour.
+\`\`\`
+`);
+
+	runBuild();
+	assertNoClientJavaScript(await readPage(), 'A plain homepage in a multi-page site');
+	assertNoClientJavaScript(
+		await readPage(path.join('details', 'index.html')),
+		'A page with managed image stacks and cards',
+	);
+
+	await writeFile(path.join(siteDir, 'content.md'), `---
+title: Notes
+description: A page with an enhanced sidenote.
+sections:
+  intro: {}
+---
+## Intro {#intro}
+
+This sentence has additional context.{note-ref}
+
+{note: The note remains readable without JavaScript, while alignment is enhanced when JavaScript runs.}
+`);
+	await writeFile(path.join(routeDir, 'route-content.md'), `---
+title: Carousel
+description: An interactive image carousel.
+sections:
+  details: {}
+---
+## Details {#details}
+
+\`\`\`norna-image-carousel
+- image: first.svg
+  caption: First slide.
+- image: second.svg
+  caption: Second slide.
+\`\`\`
+`);
+
+	runBuild();
+	const noteHtml = await readPage();
+	const carouselHtml = await readPage(path.join('details', 'index.html'));
+	assert.equal(getScripts(noteHtml).length, 1, 'A page with notes should load only the note enhancement.');
+	assert.match(noteHtml, /data-note-id=/);
+	assert.equal(getScripts(carouselHtml).length, 1, 'A carousel page should load only the carousel implementation.');
+	assert.match(carouselHtml, /data-carousel/);
+	assert.match(getScripts(carouselHtml)[0], /\ssrc=/, 'Carousel JavaScript should be emitted as a module asset.');
+
+	await writeFile(path.join(siteDir, 'content.md'), `---
+title: Banner
+description: A page with a dismissible banner.
+sections:
+  intro: {}
+---
+## Intro {#intro}
+
+The only interactive feature is the banner.
+`);
+	await writeFile(path.join(routeDir, 'route-content.md'), `---
+title: Details
+description: A second plain page.
+sections:
+  details: {}
+---
+## Details {#details}
+
+Plain route content.
+`);
+	await writeFile(path.join(siteDir, 'sitewide-content.md'), `---
+banners:
+  - id: test-banner
+    title: Test banner
+    text: This banner can be dismissed.
+---
+`);
+
+	runBuild();
+	const bannerHtml = await readPage();
+	assert.equal(getScripts(bannerHtml).length, 1, 'A dismissible banner should load only its dismissal script.');
+	assert.match(getScripts(bannerHtml)[0], /norna-banner:/);
+
+	console.log('Client JavaScript boundaries test passed.');
+} finally {
+	await rm(tempRoot, { force: true, recursive: true });
+}

package/scripts/test-content-check.mjs

@@ -239,6 +239,109 @@ test('content:check accepts valid inline notes and ignores note syntax in code f
 	});
 });
 
+test('content:check accepts wrapped and explicit multiline inline notes', async () => {
+	await withTempProject({
+		site: `---
+title: Multiline inline notes
+description: Fixture
+---
+## Wrapped {#wrapped}
+This paragraph has a formatter-wrapped note.{note-ref}
+
+{note: This note was wrapped by
+an editor before its closing brace.}
+
+## Explicit {#explicit}
+This paragraph has an explicit multiline note.{note-ref}
+
+{note:
+  This note uses the explicit
+  multiline form.
+}
+`,
+		files: [],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 0, output);
+		assert.match(output, /Content check passed\./);
+	});
+});
+
+test('content:check reports an unclosed multiline inline note', async () => {
+	await withTempProject({
+		site: `---
+title: Unclosed inline note
+description: Fixture
+---
+## Intro {#intro}
+This paragraph has a note reference.{note-ref}
+
+{note: This note never closes
+and continues to the end of the file.
+`,
+		files: [],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 1, output);
+		assert.match(output, /The note starting on line \d+ is not closed\./);
+		assert.match(output, /End it with "\}" on its own line or at the end of the note text\./);
+	});
+});
+
+test('content:check rejects nested note syntax before a multiline note is closed', async () => {
+	await withTempProject({
+		site: `---
+title: Nested inline note syntax
+description: Fixture
+---
+## Nested note {#nested-note}
+This paragraph has a note reference.{note-ref}
+
+{note: The first note is still open
+{note: A second note starts here.}
+
+## Nested reference {#nested-reference}
+This paragraph has another note reference.{note-ref}
+
+{note: This note is still open
+and contains {note-ref} before closing.}
+`,
+		files: [],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 1, output);
+		assert.match(output, /is not closed before another note starts on line \d+\./);
+		assert.match(output, /contains "\{note-ref\}" on line \d+\./);
+	});
+});
+
+test('content:check allows escaped and inline-code note syntax inside notes', async () => {
+	await withTempProject({
+		site: `---
+title: Literal inline note syntax
+description: Fixture
+---
+## Intro {#intro}
+This paragraph has a note reference.{note-ref}
+
+{note: Write \\{note: ... to show escaped text, or use \`{note-ref}\` as inline code.}
+`,
+		files: [],
+	}, async (root) => {
+		const result = runContentScript(root, ['--check']);
+		const output = getOutput(result);
+
+		assert.equal(result.status, 0, output);
+		assert.match(output, /Content check passed\./);
+	});
+});
+
 test('content:check rejects unpaired and repeated inline notes', async () => {
 	await withTempProject({
 		site: `---

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'], {
@@ -95,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');
@@ -121,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

@@ -1,3 +1,5 @@
+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';
@@ -10,6 +12,13 @@ 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-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.');