@rm-industries/create-forge 0.3.0-alpha.0 → 0.4.0-beta.1

package/dist/template/package.json

@@ -7,9 +7,11 @@
     "dev": "astro dev",
     "build": "astro build",
     "preview": "astro preview",
+    "validate:build": "node scripts/validate-build.ts",
     "astro": "astro",
     "astro:check": "astro check",
-    "audit": "npm audit --audit-level=high",
+    "audit": "audit-ci --config audit-ci.jsonc",
+    "audit:unused": "knip",
     "format": "oxfmt --check",
     "format:fix": "oxfmt",
     "lint": "npm run lint:code && npm run lint:css && npm run lint:markdown && npm run spellcheck",
@@ -19,19 +21,26 @@
     "lint:css:fix": "stylelint --fix \"**/*.css\" --ignore-path .gitignore",
     "lint:markdown": "markdownlint \"**/*.md\" --ignore-path .gitignore",
     "lint:markdown:fix": "markdownlint --fix \"**/*.md\" --ignore-path .gitignore",
+    "lighthouse:ci": "npm run build && lhci autorun",
     "spellcheck": "cspell \"**\"",
     "typecheck": "astro sync && tsc --noEmit",
-    "test": "vitest run",
+    "test": "npm run test:unit",
+    "test:a11y": "playwright test tests/accessibility.spec.ts",
+    "test:coverage": "vitest run --coverage",
     "test:e2e": "playwright test",
-    "quality": "npm run format && npm run lint && npm run typecheck && npm run astro:check && npm test && npm run build"
+    "test:unit": "vitest run",
+    "quality": "npm run quality:core && npm run test:e2e && npm run lighthouse:ci",
+    "quality:core": "npm run quality:static && npm run test:coverage && npm run build && npm run validate:build",
+    "quality:static": "npm run format && npm run lint && npm run audit:unused && npm run typecheck && npm run astro:check && npm run audit",
+    "quality:static:ci": "npm run lint:code && npm run lint:css && npm run lint:markdown && npm run audit:unused && npm run typecheck && npm run astro:check && npm run audit"
   },
   "dependencies": {
     "@astrojs/rss": "^4.0.19",
     "@astrojs/sitemap": "^3.7.3",
     "@fontsource/fira-code": "^5.3.0",
     "@fontsource/fira-sans": "^5.3.0",
-    "@rm-industries/content-model": "0.1.0-alpha.0",
-    "@sveltia/cms": "0.193.2",
+    "@rm-industries/content-model": "0.2.0-alpha.0",
+    "@sveltia/cms": "0.203.2",
     "astro": "^7.2.3"
   },
   "devDependencies": {
@@ -39,11 +48,15 @@
     "@axe-core/playwright": "^4.13.0",
     "@catppuccin/daisyui": "^2.1.1",
     "@catppuccin/palette": "^1.8.0",
+    "@lhci/cli": "0.15.1",
     "@playwright/test": "^1.62.1",
     "@tailwindcss/typography": "^0.5.20",
     "@tailwindcss/vite": "^4.3.3",
+    "@vitest/coverage-v8": "^4.1.11",
+    "audit-ci": "7.1.0",
     "cspell": "^10.0.1",
     "daisyui": "^5.7.18",
+    "knip": "^6.33.0",
     "markdownlint-cli": "^0.49.0",
     "oxfmt": "^0.63.0",
     "oxlint": "^1.72.0",
@@ -57,5 +70,5 @@
     "node": "^22.22.2 || ^24.0.0 || ^26.0.0",
     "npm": "^10.9.0 || ^11.0.0"
   },
-  "packageManager": "npm@11.18.0"
+  "packageManager": "npm@11.19.0"
 }

package/dist/template/playwright.config.ts

@@ -2,13 +2,15 @@ import { defineConfig, devices } from '@playwright/test';
 
 export default defineConfig({
   testDir: './tests',
+  outputDir: 'test-results',
   fullyParallel: true,
   forbidOnly: Boolean(process.env.CI),
   retries: process.env.CI ? 2 : 0,
-  reporter: process.env.CI ? 'github' : 'list',
+  reporter: process.env.CI ? [['github'], ['html', { open: 'never' }]] : 'list',
   use: {
     baseURL: 'http://127.0.0.1:4321',
-    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    trace: 'retain-on-failure',
   },
   projects: [
     {
@@ -17,7 +19,11 @@ export default defineConfig({
     },
   ],
   webServer: {
-    command: 'npm run dev -- --host 127.0.0.1',
+    command: 'npm run build && npm run preview -- --host 127.0.0.1',
+    env: {
+      ...process.env,
+      ASTRO_PREVIEW_BACKGROUND: '0',
+    },
     url: 'http://127.0.0.1:4321',
     reuseExistingServer: !process.env.CI,
   },

package/dist/template/scripts/validate-build.test.ts

@@ -0,0 +1,58 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { afterEach, describe, expect, test } from 'vitest';
+
+import { validateBuild } from './validate-build';
+
+const requiredPaths = [
+  '404.html',
+  'about/index.html',
+  'admin/index.html',
+  'articles/accessible-by-default/index.html',
+  'articles/content-that-travels-well/index.html',
+  'articles/designing-a-calm-starting-point/index.html',
+  'articles/index.html',
+  'index.html',
+  'robots.txt',
+  'rss.xml',
+  'site.webmanifest',
+  'sitemap-index.xml',
+] as const;
+
+const fixtures: string[] = [];
+
+const createFixture = async () => {
+  const fixture = await mkdtemp(join(tmpdir(), 'forge-build-output-'));
+  fixtures.push(fixture);
+  for (const path of requiredPaths) {
+    const output = join(fixture, path);
+    await mkdir(dirname(output), { recursive: true });
+    await writeFile(output, path.endsWith('.html') ? '<!doctype html><main>Forge</main>' : 'Forge\n');
+  }
+  return fixture;
+};
+
+afterEach(async () => {
+  await Promise.all(fixtures.splice(0).map((fixture) => rm(fixture, { recursive: true, force: true })));
+});
+
+describe('generated build validation', () => {
+  test('accepts the complete neutral output fixture', async () => {
+    await expect(validateBuild(await createFixture())).resolves.toBeUndefined();
+  });
+
+  test('reports a missing required output path', async () => {
+    const fixture = await createFixture();
+    await rm(join(fixture, 'rss.xml'));
+    await expect(validateBuild(fixture)).rejects.toThrow('rss.xml');
+  });
+
+  test('rejects unresolved generator tokens', async () => {
+    const fixture = await createFixture();
+    const unresolvedToken = '__FORGE_' + 'SITE_NAME__';
+    await writeFile(join(fixture, 'index.html'), `<p>${unresolvedToken}</p>`);
+    await expect(validateBuild(fixture)).rejects.toThrow(unresolvedToken);
+  });
+});

package/dist/template/scripts/validate-build.ts

@@ -0,0 +1,64 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const requiredOutputPaths = [
+  '404.html',
+  'about/index.html',
+  'admin/index.html',
+  'articles/accessible-by-default/index.html',
+  'articles/content-that-travels-well/index.html',
+  'articles/designing-a-calm-starting-point/index.html',
+  'articles/index.html',
+  'index.html',
+  'robots.txt',
+  'rss.xml',
+  'site.webmanifest',
+  'sitemap-index.xml',
+] as const;
+
+const forbiddenOutputPatterns = [/__FORGE_[A-Z0-9_]+__/u, /FORGE_[A-Z0-9_]+_PLACEHOLDER/u] as const;
+
+const listFiles = async (directory: string, root = directory): Promise<string[]> => {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files: string[] = [];
+
+  for (const entry of entries) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...(await listFiles(path, root)));
+    if (entry.isFile()) files.push(relative(root, path));
+  }
+
+  return files;
+};
+
+export const validateBuild = async (outputDirectory: string) => {
+  const output = resolve(outputDirectory);
+  if (!(await stat(output).catch(() => undefined))?.isDirectory()) {
+    throw new Error(`Build output directory does not exist: ${output}`);
+  }
+
+  const files = await listFiles(output);
+  const missingPaths = requiredOutputPaths.filter((path) => !files.includes(path));
+  if (missingPaths.length > 0) {
+    throw new Error(`Build output is missing required paths:\n${missingPaths.join('\n')}`);
+  }
+
+  for (const path of files) {
+    const content = await readFile(join(output, path), 'utf8').catch(() => undefined);
+    if (content === undefined || content.includes('\0')) continue;
+
+    for (const pattern of forbiddenOutputPatterns) {
+      const match = content.match(pattern);
+      if (match) throw new Error(`Build output contains forbidden text in ${path}: ${match[0]}`);
+    }
+  }
+};
+
+const isEntryPoint = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isEntryPoint) {
+  const projectDirectory = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+  await validateBuild(join(projectDirectory, 'dist'));
+  console.log(`Validated ${requiredOutputPaths.length} required build outputs and scanned generated text.`);
+}

package/dist/template/src/config/content-models/registry.test.ts

@@ -0,0 +1,14 @@
+import { defineModels } from '@rm-industries/content-model';
+import { expect, test } from 'vitest';
+
+import { articleContentModel } from './articles.ts';
+import { contentModels } from './registry.ts';
+
+test('registers the shared article model', () => {
+  expect(contentModels).toEqual([articleContentModel]);
+  expect(contentModels[0]?.fields.tags).toMatchObject({ kind: 'list', default: [] });
+});
+
+test('rejects duplicate model names', () => {
+  expect(() => defineModels([articleContentModel, articleContentModel])).toThrow(/duplicate collection name/i);
+});

package/dist/template/src/config/site.test.ts

@@ -32,6 +32,19 @@ test('rejects a non-HTTP canonical URL', () => {
   );
 });
 
+test('rejects malformed canonical URLs and URL metadata', () => {
+  expect(() => defineSiteConfig({ ...validConfig, url: 'relative' })).toThrow(/absolute URL/);
+  expect(() => defineSiteConfig({ ...validConfig, url: 'https://user@example.test' })).toThrow(/credentials/);
+  expect(() => defineSiteConfig({ ...validConfig, url: 'https://example.test?query=true' })).toThrow(/query/);
+});
+
+test('rejects control characters in optional text and invalid links', () => {
+  expect(() => defineSiteConfig({ ...validConfig, author: 'Example\u0000Author' })).toThrow(/control characters/);
+  expect(() => defineSiteConfig({ ...validConfig, navigation: [{ label: ' ', href: '/' }] })).toThrow(
+    /navigation\[0\]\.label must not be empty/,
+  );
+});
+
 test('derives CMS branding from the site name', () => {
   expect(cmsBranding.appTitle).toBe(`${site.name} Content Manager`);
 });

package/dist/template/src/content.config.test.ts

@@ -0,0 +1,8 @@
+import { expect, test } from 'vitest';
+
+import { contentModels } from './config/content-models/registry.ts';
+import { collections } from './content.config.ts';
+
+test('registers every shared model with the Astro adapter', () => {
+  expect(Object.keys(collections)).toEqual(contentModels.map((model) => model.name));
+});

package/dist/template/src/integrations/sveltia/previews.test.ts

@@ -0,0 +1,23 @@
+import { expect, test, vi } from 'vitest';
+
+vi.mock('@sveltia/cms', () => ({
+  registerPreviewTemplate: vi.fn<(name: string, render: unknown) => void>(),
+}));
+
+import { registerSveltiaPreviews } from './previews.ts';
+
+test('registers and renders the article preview', () => {
+  const register = vi.fn<NonNullable<Parameters<typeof registerSveltiaPreviews>[0]>>();
+  registerSveltiaPreviews(register);
+
+  expect(register).toHaveBeenCalledOnce();
+  const [name, render] = register.mock.calls[0] ?? [];
+  const add = vi.fn<(first: string, second: string) => void>();
+  const widgetFor = vi.fn<(name: string) => string>(() => 'rendered body');
+  const result = render({ document: { body: { classList: { add } } }, widgetFor } as never);
+
+  expect(name).toBe('articles');
+  expect(add).toHaveBeenCalledWith('prose', 'mx-auto');
+  expect(widgetFor).toHaveBeenCalledWith('body');
+  expect(result).toBe('rendered body');
+});

package/dist/template/src/lib/articles.test.ts

@@ -0,0 +1,43 @@
+import { beforeEach, expect, test, vi } from 'vitest';
+
+const { getCollection } = vi.hoisted(() => ({
+  getCollection: vi.fn<(name: string, filter: (entry: Article) => boolean) => Promise<Article[]>>(),
+}));
+
+vi.mock('astro:content', () => ({ getCollection }));
+
+import { getArticleNeighbors, getArticles, type Article } from './articles.ts';
+
+const article = (id: string, publishedAt: string, draft = false) =>
+  ({ id, data: { publishedAt: new Date(publishedAt), draft } }) as Article;
+
+beforeEach(() => {
+  getCollection.mockReset();
+});
+
+test('filters drafts and sorts published articles newest first', async () => {
+  const entries = [
+    article('older', '2025-01-01'),
+    article('draft', '2026-01-01', true),
+    article('newer', '2025-06-01'),
+  ];
+  getCollection.mockImplementation(async (_name, filter: (entry: Article) => boolean) => entries.filter(filter));
+
+  await expect(getArticles()).resolves.toEqual([entries[2], entries[0]]);
+  expect(getCollection).toHaveBeenCalledWith('articles', expect.any(Function));
+});
+
+test('can include drafts', async () => {
+  const entries = [article('published', '2025-01-01'), article('draft', '2026-01-01', true)];
+  getCollection.mockImplementation(async (_name, filter: (entry: Article) => boolean) => entries.filter(filter));
+
+  await expect(getArticles({ includeDrafts: true })).resolves.toEqual([entries[1], entries[0]]);
+});
+
+test('returns previous and next neighbors without wrapping', () => {
+  const entries = [article('newest', '2026-01-01'), article('middle', '2025-01-01'), article('oldest', '2024-01-01')];
+
+  expect(getArticleNeighbors('middle', entries)).toEqual({ previous: entries[2], next: entries[0] });
+  expect(getArticleNeighbors('newest', entries)).toEqual({ previous: entries[1], next: undefined });
+  expect(getArticleNeighbors('missing', entries)).toEqual({});
+});

package/dist/template/src/lib/articles.ts

@@ -2,7 +2,7 @@ import { getCollection, type CollectionEntry } from 'astro:content';
 
 export type Article = CollectionEntry<'articles'>;
 
-export const sortArticles = (entries: readonly Article[]): Article[] =>
+const sortArticles = (entries: readonly Article[]): Article[] =>
   [...entries].sort((left, right) => right.data.publishedAt.getTime() - left.data.publishedAt.getTime());
 
 export const getArticles = async ({ includeDrafts = false }: { includeDrafts?: boolean } = {}): Promise<Article[]> =>

package/dist/template/src/lib/navigation.test.ts

@@ -4,12 +4,14 @@ import { isCurrentPath, isExternalHref } from './navigation.ts';
 
 test('matches exact and nested navigation paths at segment boundaries', () => {
   expect(isCurrentPath('/articles/', '/articles')).toBe(true);
+  expect(isCurrentPath('articles/?page=2', '/articles/#content')).toBe(true);
   expect(isCurrentPath('/articles/example/', '/articles/')).toBe(true);
   expect(isCurrentPath('/articles-summary/', '/articles')).toBe(false);
 });
 
 test('matches the home route only at the site root', () => {
   expect(isCurrentPath('/', '/')).toBe(true);
+  expect(isCurrentPath('', '/')).toBe(true);
   expect(isCurrentPath('/articles/', '/')).toBe(false);
 });
 

package/dist/template/src/styles/global.css

@@ -38,7 +38,7 @@ body {
   --tw-prose-body: var(--color-base-content);
   --tw-prose-headings: var(--color-base-content);
   --tw-prose-lead: var(--color-base-content);
-  --tw-prose-links: var(--color-primary);
+  --tw-prose-links: var(--color-base-content);
   --tw-prose-bold: var(--color-base-content);
   --tw-prose-counters: var(--color-base-content);
   --tw-prose-bullets: var(--color-primary);
@@ -55,6 +55,12 @@ body {
   --tw-prose-td-borders: var(--color-base-300);
 }
 
+.prose a {
+  text-decoration: underline;
+  text-decoration-thickness: 0.125rem;
+  text-underline-offset: 0.1875rem;
+}
+
 :where(a, button, input, select, summary, textarea):focus-visible {
   border-radius: 0.125rem;
   outline: 0.1875rem solid var(--color-primary);

package/dist/template/stylelint.config.ts

@@ -6,12 +6,14 @@ export default {
     'at-rule-no-unknown': [
       true,
       {
+        // These directives are parsed by Tailwind and DaisyUI during the build.
         ignoreAtRules: ['apply', 'plugin', 'theme'],
       },
     ],
     'import-notation': [
       'string',
       {
+        // Tailwind's bare package import is valid input for its Vite plugin.
         ignore: ['tailwindcss'],
       },
     ],

package/dist/template/tests/accessibility.spec.ts

@@ -1,23 +1,50 @@
 import AxeBuilder from '@axe-core/playwright';
 import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
 
-test('has no serious or critical accessibility violations', async ({ page }) => {
-  await page.goto('/');
+const publicRoutes = [
+  { name: 'home', path: '/' },
+  { name: 'about', path: '/about/' },
+  { name: 'article listing', path: '/articles/' },
+  { name: 'article detail', path: '/articles/designing-a-calm-starting-point/' },
+  { name: 'not found', path: '/does-not-exist/' },
+] as const;
 
-  const results = await new AxeBuilder({ page }).withTags(['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa']).analyze();
-  const violations = results.violations.filter(({ impact }) => impact === 'serious' || impact === 'critical');
+const analyzePage = async (page: Page) => {
+  const results = await new AxeBuilder({ page })
+    .withTags(['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa', 'wcag22aa'])
+    .analyze();
 
-  expect(violations).toEqual([]);
-});
+  return results.violations.filter(({ impact }) => impact === 'serious' || impact === 'critical');
+};
+
+for (const colorScheme of ['light', 'dark'] as const) {
+  for (const route of publicRoutes) {
+    test(`${route.name} has no serious or critical violations in ${colorScheme} mode`, async ({ page }) => {
+      await page.emulateMedia({ colorScheme });
+      await page.goto(route.path);
+
+      expect(await analyzePage(page)).toEqual([]);
+    });
+  }
+}
+
+for (const route of publicRoutes) {
+  test(`${route.name} exposes one main landmark and one level-one heading`, async ({ page }) => {
+    await page.goto(route.path);
+
+    await expect(page.getByRole('banner')).toHaveCount(1);
+    await expect(page.getByRole('main')).toHaveCount(1);
+    await expect(page.getByRole('heading', { level: 1 })).toHaveCount(1);
+    await expect(page.getByRole('contentinfo')).toHaveCount(1);
+  });
+}
 
-test('exposes landmarks and identifies the current navigation item', async ({ page }) => {
+test('identifies the current primary navigation item', async ({ page }) => {
   await page.goto('/');
 
-  await expect(page.getByRole('banner')).toBeVisible();
   await expect(page.getByRole('navigation', { name: 'Primary navigation' })).toBeVisible();
   await expect(page.getByRole('link', { name: 'Home' })).toHaveAttribute('aria-current', 'page');
-  await expect(page.getByRole('main')).toBeVisible();
-  await expect(page.getByRole('contentinfo')).toBeVisible();
 });
 
 test('moves keyboard users directly to the main content', async ({ page }) => {
@@ -45,3 +72,22 @@ test('keeps navigation available without horizontal overflow on small screens',
 
   expect(hasHorizontalOverflow).toBe(false);
 });
+
+test('honors reduced-motion preferences', async ({ page }) => {
+  await page.emulateMedia({ reducedMotion: 'reduce' });
+  await page.goto('/');
+
+  const motionStyles = await page.getByRole('link', { name: 'Browse the articles' }).evaluate((element) => {
+    const styles = getComputedStyle(element);
+
+    return {
+      animationDuration: styles.animationDuration,
+      scrollBehavior: getComputedStyle(document.documentElement).scrollBehavior,
+      transitionDuration: styles.transitionDuration,
+    };
+  });
+
+  expect(motionStyles.scrollBehavior).toBe('auto');
+  expect(Number.parseFloat(motionStyles.animationDuration)).toBeLessThanOrEqual(0.001);
+  expect(Number.parseFloat(motionStyles.transitionDuration)).toBeLessThanOrEqual(0.001);
+});

package/dist/template/tests/navigation.spec.ts

@@ -0,0 +1,43 @@
+import { expect, test } from '@playwright/test';
+
+test('uses primary navigation to move between pages and identify the current page', async ({ page }) => {
+  await page.goto('/');
+
+  const navigation = page.getByRole('navigation', { name: 'Primary navigation' });
+  await expect(navigation.getByRole('link', { name: 'Home' })).toHaveAttribute('aria-current', 'page');
+
+  await navigation.getByRole('link', { name: 'Articles' }).click();
+  await expect(page).toHaveURL('/articles/');
+  await expect(page.getByRole('heading', { level: 1, name: 'Articles' })).toBeVisible();
+  await expect(
+    page.getByRole('navigation', { name: 'Primary navigation' }).getByRole('link', { name: 'Articles' }),
+  ).toHaveAttribute('aria-current', 'page');
+});
+
+test('opens mobile navigation and follows a configured link', async ({ page }) => {
+  await page.setViewportSize({ width: 320, height: 640 });
+  await page.goto('/');
+
+  await page.locator('summary').filter({ hasText: 'Menu' }).click();
+  const navigation = page.getByRole('navigation', { name: 'Mobile navigation' });
+  await expect(navigation).toBeVisible();
+  await navigation.getByRole('link', { name: 'About' }).click();
+
+  await expect(page).toHaveURL('/about/');
+  await expect(
+    page.getByRole('heading', { level: 1, name: 'A useful foundation, not a finished identity.' }),
+  ).toBeVisible();
+});
+
+test('moves from the article listing into an article and through article pagination', async ({ page }) => {
+  await page.goto('/articles/');
+
+  await page.getByRole('link', { name: /Designing a calm starting point/u }).click();
+  await expect(page).toHaveURL('/articles/designing-a-calm-starting-point/');
+  await expect(page.getByRole('heading', { level: 1, name: 'Designing a calm starting point' })).toBeVisible();
+
+  const articleNavigation = page.getByRole('navigation', { name: 'Article navigation' });
+  await articleNavigation.getByRole('link', { name: /Content that travels well/u }).click();
+  await expect(page).toHaveURL('/articles/content-that-travels-well/');
+  await expect(page.getByRole('heading', { level: 1, name: 'Content that travels well' })).toBeVisible();
+});

package/dist/template/tests/routes.spec.ts

@@ -1,20 +1,16 @@
 import { expect, test } from '@playwright/test';
 
+import { site } from '../src/config/site';
+
 const routes = ['/', '/about/', '/articles/', '/articles/designing-a-calm-starting-point/', '/admin/', '/404/'];
 
 test('serves every baseline page with configured canonical and social metadata', async ({ page }) => {
   for (const route of routes) {
     await page.goto(route);
 
-    await expect(page.locator('link[rel="canonical"]')).toHaveAttribute(
-      'href',
-      new URL(route, 'https://example.com').href,
-    );
-    await expect(page.locator('meta[property="og:site_name"]')).toHaveAttribute('content', 'Forge');
-    await expect(page.locator('meta[property="og:url"]')).toHaveAttribute(
-      'content',
-      new URL(route, 'https://example.com').href,
-    );
+    await expect(page.locator('link[rel="canonical"]')).toHaveAttribute('href', new URL(route, site.url).href);
+    await expect(page.locator('meta[property="og:site_name"]')).toHaveAttribute('content', site.name);
+    await expect(page.locator('meta[property="og:url"]')).toHaveAttribute('content', new URL(route, site.url).href);
     await expect(page.locator('meta[name="twitter:card"]')).toHaveAttribute('content', 'summary_large_image');
   }
 });
@@ -24,6 +20,7 @@ test('serves the content manager without allowing search indexing', async ({ pag
 
   await expect(page.locator('meta[name="robots"][content="noindex, nofollow"]')).toHaveCount(1);
   await expect(page).toHaveTitle(/Content Manager/u);
+  await expect(page.locator('body')).not.toBeEmpty();
 });
 
 test('renders generic article tags on listings and detail pages', async ({ page }) => {
@@ -69,19 +66,29 @@ test('resolves every internal page link', async ({ page, request }) => {
 test('serves feed, crawler, manifest, and not-found metadata', async ({ request }) => {
   const feed = await request.get('/rss.xml');
   expect(feed.ok()).toBe(true);
-  expect(await feed.text()).toContain('https://example.com/articles/designing-a-calm-starting-point/');
+  expect(await feed.text()).toContain(new URL('articles/designing-a-calm-starting-point/', site.url).href);
   expect(await feed.text()).not.toContain('future-draft');
 
   const robots = await request.get('/robots.txt');
   expect(robots.ok()).toBe(true);
-  expect(await robots.text()).toContain('Sitemap: https://example.com/sitemap-index.xml');
+  expect(await robots.text()).toContain(`Sitemap: ${new URL('sitemap-index.xml', site.url).href}`);
 
   const manifest = await request.get('/site.webmanifest');
   expect(manifest.ok()).toBe(true);
   expect(manifest.headers()['content-type']).toMatch(/application\/manifest\+json/u);
-  expect(await manifest.json()).toMatchObject({ name: 'Forge', start_url: '/' });
+  expect(await manifest.json()).toMatchObject({ name: site.name, start_url: '/' });
 
   const missing = await request.get('/does-not-exist/');
   expect(missing.status()).toBe(404);
   expect(await missing.text()).toContain('That page is not here.');
 });
+
+test('helps visitors recover from a missing page', async ({ page }) => {
+  const response = await page.goto('/does-not-exist/');
+
+  expect(response?.status()).toBe(404);
+  await expect(page.getByRole('heading', { level: 1, name: 'That page is not here.' })).toBeVisible();
+  await page.getByRole('link', { name: 'Return home' }).click();
+  await expect(page).toHaveURL('/');
+  await expect(page.getByRole('heading', { level: 1 })).toBeVisible();
+});

package/dist/template/vitest.config.ts

@@ -3,6 +3,23 @@ import { getViteConfig } from 'astro/config';
 
 export default getViteConfig({
   test: {
-    include: ['src/**/*.test.ts'],
+    include: ['src/**/*.test.ts', 'scripts/**/*.test.ts'],
+    coverage: {
+      include: [
+        'src/config/**/*.ts',
+        'src/content.config.ts',
+        'src/integrations/**/*.ts',
+        'src/lib/**/*.ts',
+        'src/themes/site-theme.ts',
+      ],
+      provider: 'v8',
+      reporter: ['text', 'html'],
+      thresholds: {
+        branches: 100,
+        functions: 100,
+        lines: 100,
+        statements: 100,
+      },
+    },
   },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rm-industries/create-forge",
-  "version": "0.3.0-alpha.0",
+  "version": "0.4.0-beta.1",
   "description": "Create a content-driven Forge website",
   "keywords": [
     "astro",