@beatzball/create-litro 0.1.0

package/recipes/fullstack/template/pages/blog/index.ts

@@ -0,0 +1,22 @@
+import { LitElement, html } from 'lit';
+import { customElement } from 'lit/decorators.js';
+
+@customElement('page-blog')
+export class BlogPage extends LitElement {
+  render() {
+    return html`
+      <main>
+        <h1>Blog</h1>
+        <p>Choose a post:</p>
+        <ul>
+          <li><litro-link href="/blog/hello-world">Hello World</litro-link></li>
+          <li><litro-link href="/blog/getting-started">Getting Started</litro-link></li>
+          <li><litro-link href="/blog/about-litro">About Litro</litro-link></li>
+        </ul>
+        <litro-link href="/">← Back Home</litro-link>
+      </main>
+    `;
+  }
+}
+
+export default BlogPage;

package/recipes/fullstack/template/pages/index.ts

@@ -0,0 +1,43 @@
+import { html } from 'lit';
+import { customElement, state } from 'lit/decorators.js';
+import { LitroPage } from '@beatzball/litro/runtime';
+import { definePageData } from '@beatzball/litro';
+
+export interface HomeData {
+  message: string;
+  timestamp: string;
+}
+
+// Runs on the server before SSR — result injected as JSON into the HTML shell.
+export const pageData = definePageData(async (_event) => {
+  return {
+    message: 'Hello from {{projectName}}!',
+    timestamp: new Date().toISOString(),
+  } satisfies HomeData;
+});
+
+@customElement('page-home')
+export class HomePage extends LitroPage {
+  @state() declare serverData: HomeData | null;
+
+  // Called on client-side navigation (not on the initial SSR load).
+  override async fetchData() {
+    const res = await fetch('/api/hello');
+    return res.json() as Promise<HomeData>;
+  }
+
+  render() {
+    if (this.loading) return html`<p>Loading…</p>`;
+    return html`
+      <main>
+        <h1>${this.serverData?.message ?? 'Welcome to {{projectName}}'}</h1>
+        <p><small>Rendered at: ${this.serverData?.timestamp ?? '—'}</small></p>
+        <nav>
+          <litro-link href="/blog">Go to Blog →</litro-link>
+        </nav>
+      </main>
+    `;
+  }
+}
+
+export default HomePage;

package/recipes/fullstack/template/server/api/hello.ts

@@ -0,0 +1,6 @@
+import { defineEventHandler } from 'h3';
+
+export default defineEventHandler(() => ({
+  message: 'Hello from {{projectName}}!',
+  timestamp: new Date().toISOString(),
+}));

package/recipes/fullstack/template/server/middleware/vite-dev.ts

@@ -0,0 +1,31 @@
+import { defineEventHandler, fromNodeMiddleware } from 'h3';
+
+let viteHandlerPromise: Promise<ReturnType<typeof fromNodeMiddleware>> | null = null;
+
+export default defineEventHandler(async (event) => {
+  if (!process.dev || !process.env.NITRO_DEV_WORKER_ID) return;
+
+  if (!viteHandlerPromise) {
+    const httpServer = (event.node.req.socket as import('node:net').Socket & {
+      server?: import('node:http').Server;
+    }).server;
+
+    viteHandlerPromise = import('vite')
+      .then(({ createServer }) =>
+        createServer({
+          server: {
+            middlewareMode: true,
+            // Attach Vite HMR WebSocket to Nitro's existing HTTP server so
+            // both share a single port with no conflicts.
+            hmr: httpServer ? { server: httpServer } : true,
+          },
+          appType: 'custom',
+          root: process.cwd(),
+        }),
+      )
+      .then((server) => fromNodeMiddleware(server.middlewares));
+  }
+
+  const viteHandler = await viteHandlerPromise;
+  return viteHandler(event);
+});

package/recipes/fullstack/template/server/routes/[...].ts

@@ -0,0 +1,59 @@
+import { defineEventHandler, setResponseHeader, getRequestURL } from 'h3';
+import { createPageHandler } from '@beatzball/litro/runtime/create-page-handler.js';
+import type { LitroRoute } from '@beatzball/litro';
+import { routes, pageModules } from '#litro/page-manifest';
+
+function matchRoute(
+  pathname: string,
+): { route: LitroRoute; params: Record<string, string> } | undefined {
+  for (const route of routes) {
+    if (route.isCatchAll) return { route, params: {} };
+
+    if (!route.isDynamic) {
+      if (pathname === route.path) return { route, params: {} };
+      continue;
+    }
+
+    // Use named capture groups so param values are automatically mapped to names.
+    const regexStr =
+      '^' +
+      route.path
+        .replace(/:([^/]+)\(\.\*\)\*/g, '(?<$1>.+)')
+        .replace(/:([^/?]+)\?/g, '(?<$1>[^/]*)?')
+        .replace(/:([^/]+)/g, '(?<$1>[^/]+)') +
+      '$';
+
+    try {
+      const match = pathname.match(new RegExp(regexStr));
+      if (match) return { route, params: (match.groups ?? {}) as Record<string, string> };
+    } catch {
+      // malformed pattern — skip
+    }
+  }
+  return undefined;
+}
+
+export default defineEventHandler(async (event) => {
+  const pathname = getRequestURL(event).pathname;
+  const result = matchRoute(pathname);
+
+  if (!result) {
+    setResponseHeader(event, 'content-type', 'text/html; charset=utf-8');
+    return `<!DOCTYPE html>
+<html lang="en"><head><meta charset="UTF-8" /><title>404</title></head>
+<body><h1>404 — Not Found</h1><p>No page matched <code>${pathname}</code>.</p></body>
+</html>`;
+  }
+
+  const { route: matched, params } = result;
+
+  // Populate route params (e.g. slug from /blog/:slug) on the event context
+  // so pageData fetchers can access them via event.context.params.
+  event.context.params = { ...event.context.params, ...params };
+
+  const handler = createPageHandler({
+    route: matched,
+    pageModule: pageModules[matched.filePath],
+  });
+  return handler(event);
+});

package/recipes/fullstack/template/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules", "dist", ".nitro"]
+}

package/recipes/fullstack/template/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  build: {
+    outDir: 'dist/client',
+    rollupOptions: {
+      input: 'app.ts',
+      output: {
+        // Stable (non-hashed) entry filename so the HTML shell can always
+        // reference /_litro/app.js without knowing the content hash.
+        entryFileNames: '[name].js',
+      },
+    },
+  },
+});

package/src/index.ts

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+/**
+ * create-litro — Scaffolding CLI for Litro
+ *
+ * Usage:
+ *   npm create litro
+ *   npx create-litro
+ *   npx create-litro <project-name> [--recipe <recipe>] [--mode <ssg|ssr>]
+ *   npx create-litro --list-recipes
+ *
+ * Prompts for project name, recipe, and mode, then scaffolds a complete
+ * Litro project from the selected recipe template.
+ *
+ * No external dependencies — uses Node.js built-ins only.
+ */
+
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import { listRecipes, loadRecipe, scaffold } from './scaffold.js';
+import type { LitroRecipe } from './types.js';
+import type { ScaffoldOptions } from './scaffold.js';
+
+// ---------------------------------------------------------------------------
+// Prompt helpers
+// ---------------------------------------------------------------------------
+
+async function prompt(question: string, defaultVal = ''): Promise<string> {
+  // If stdin is not a TTY (piped/redirected), use the default immediately.
+  if (!process.stdin.isTTY) return defaultVal;
+
+  const rl = createInterface({ input, output });
+  const answer = await rl.question(
+    defaultVal ? `${question} (${defaultVal}): ` : `${question}: `,
+  );
+  rl.close();
+  return answer.trim() || defaultVal;
+}
+
+async function promptSelect(question: string, choices: string[], defaultVal?: string): Promise<string> {
+  if (!process.stdin.isTTY) return defaultVal ?? choices[0];
+
+  const lines = choices.map((c, i) => `  ${i + 1}. ${c}`).join('\n');
+  const defaultIdx = defaultVal ? choices.indexOf(defaultVal) + 1 : 1;
+  const rl = createInterface({ input, output });
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const answer = await rl.question(`${question}\n${lines}\n  Choice (${defaultIdx}): `);
+    const trimmed = answer.trim();
+    if (trimmed === '') {
+      rl.close();
+      return choices[defaultIdx - 1];
+    }
+    const n = parseInt(trimmed, 10);
+    if (!isNaN(n) && n >= 1 && n <= choices.length) {
+      rl.close();
+      return choices[n - 1];
+    }
+    // Allow typing the value directly.
+    if (choices.includes(trimmed)) {
+      rl.close();
+      return trimmed;
+    }
+    process.stdout.write(`  Please enter a number between 1 and ${choices.length}.\n`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+
+interface ParsedArgs {
+  projectName: string | undefined;
+  recipe: string | undefined;
+  mode: 'ssg' | 'ssr' | undefined;
+  listRecipes: boolean;
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  // argv = process.argv.slice(2)
+  let projectName: string | undefined;
+  let recipe: string | undefined;
+  let mode: 'ssg' | 'ssr' | undefined;
+  let listRecipesFlag = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--list-recipes') {
+      listRecipesFlag = true;
+    } else if (arg === '--recipe' || arg === '-r') {
+      recipe = argv[++i];
+    } else if (arg === '--mode' || arg === '-m') {
+      const val = argv[++i];
+      if (val === 'ssg' || val === 'ssr') mode = val;
+    } else if (!arg.startsWith('-') && projectName === undefined) {
+      projectName = arg;
+    }
+  }
+
+  return { projectName, recipe, mode, listRecipes: listRecipesFlag };
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  // --list-recipes: print available recipes and exit.
+  if (args.listRecipes) {
+    const recipes = await listRecipes();
+    if (recipes.length === 0) {
+      console.log('\n  No recipes found.\n');
+    } else {
+      console.log('\n  Available recipes:\n');
+      for (const r of recipes) {
+        console.log(`    ${r.name.padEnd(20)} ${r.displayName} — ${r.description}`);
+      }
+      console.log('');
+    }
+    return;
+  }
+
+  console.log('\n  Welcome to Litro!\n');
+
+  // 1. Project name
+  const projectName = args.projectName ?? await prompt('Project name', 'my-litro-app');
+
+  // 2. Recipe selection
+  const recipes = await listRecipes();
+  let chosenRecipe: LitroRecipe;
+
+  if (args.recipe) {
+    const found = await loadRecipe(args.recipe);
+    if (!found) {
+      console.error(`\n  Error: recipe "${args.recipe}" not found.\n`);
+      process.exit(1);
+    }
+    chosenRecipe = found;
+  } else if (recipes.length === 0) {
+    console.error('\n  Error: no recipes available.\n');
+    process.exit(1);
+  } else if (recipes.length === 1) {
+    chosenRecipe = recipes[0];
+  } else {
+    const displayNames = recipes.map((r) => `${r.name} — ${r.description}`);
+    const selected = await promptSelect('Select a recipe:', displayNames);
+    // Match back to the recipe by index in displayNames.
+    const idx = displayNames.indexOf(selected);
+    chosenRecipe = recipes[idx !== -1 ? idx : 0];
+  }
+
+  // 3. Mode selection (only if recipe supports both)
+  let mode: 'ssg' | 'ssr';
+  if (chosenRecipe.mode === 'both') {
+    if (args.mode) {
+      mode = args.mode;
+    } else {
+      const selected = await promptSelect(
+        'Deployment mode:',
+        ['ssr — Server-side rendering (Node.js / edge)', 'ssg — Static site generation (CDN)'],
+        'ssr — Server-side rendering (Node.js / edge)',
+      );
+      mode = selected.startsWith('ssg') ? 'ssg' : 'ssr';
+    }
+  } else {
+    mode = chosenRecipe.mode as 'ssg' | 'ssr';
+  }
+
+  // 4. Recipe-specific options (prompt for any that are defined on the recipe)
+  const recipeOptions: Record<string, unknown> = {};
+  if (chosenRecipe.options && chosenRecipe.options.length > 0) {
+    for (const opt of chosenRecipe.options) {
+      if (opt.type === 'select' && opt.choices) {
+        const selected = await promptSelect(opt.prompt, opt.choices, opt.default as string | undefined);
+        recipeOptions[opt.key] = selected;
+      } else if (opt.type === 'confirm') {
+        const answer = await prompt(`${opt.prompt} (y/n)`, opt.default ? 'y' : 'n');
+        recipeOptions[opt.key] = answer.toLowerCase().startsWith('y');
+      } else {
+        // text
+        const answer = await prompt(opt.prompt, String(opt.default ?? ''));
+        recipeOptions[opt.key] = answer;
+      }
+    }
+  }
+
+  // 5. Validate target directory
+  const projectDir = join(process.cwd(), projectName);
+
+  if (existsSync(projectDir)) {
+    console.error(`\n  Error: directory "${projectName}" already exists.\n`);
+    process.exit(1);
+  }
+
+  // 6. Scaffold
+  const options: ScaffoldOptions = {
+    projectName,
+    mode,
+    recipeOptions,
+    recipeVersion: '0.0.1',
+  };
+
+  await scaffold(chosenRecipe.name, options, projectDir);
+
+  console.log(`
+  Created ${projectName}
+
+  Next steps:
+
+    cd ${projectName}
+    npm install          # or: pnpm install / yarn install
+    npm run dev          # start dev server on http://localhost:3030
+
+  Commands:
+    npm run dev          start development server
+    npm run build        production build (Vite + Nitro)
+    npm run preview      preview the production build
+`);
+}
+
+main().catch((err: unknown) => {
+  console.error('[create-litro] Fatal error:', err);
+  process.exit(1);
+});

package/src/scaffold.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { scaffold } from './scaffold.js';
+import { mkdtemp, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+async function withTmpDir(fn: (dir: string) => Promise<void>): Promise<void> {
+  const dir = await mkdtemp(join(tmpdir(), 'litro-scaffold-test-'));
+  try {
+    await fn(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+describe('scaffold', () => {
+  it('fullstack recipe writes package.json with projectName interpolated', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'my-app');
+      await scaffold('fullstack', { projectName: 'my-app', mode: 'ssr' }, targetDir);
+
+      const pkg = JSON.parse(await readFile(join(targetDir, 'package.json'), 'utf-8')) as Record<string, unknown>;
+      expect(pkg.name).toBe('my-app');
+    });
+  });
+
+  it('fullstack recipe writes all expected files', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'test-app');
+      await scaffold('fullstack', { projectName: 'test-app', mode: 'ssr' }, targetDir);
+
+      const { existsSync } = await import('node:fs');
+      expect(existsSync(join(targetDir, 'package.json'))).toBe(true);
+      expect(existsSync(join(targetDir, 'tsconfig.json'))).toBe(true);
+      expect(existsSync(join(targetDir, 'nitro.config.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'vite.config.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'app.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'pages/index.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'pages/blog/index.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'pages/blog/[slug].ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'server/api/hello.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'server/routes/[...].ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'server/stubs/page-manifest.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, '.gitignore'))).toBe(true);
+    });
+  });
+
+  it('interpolates {{projectName}} in multiple files', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'cool-blog');
+      await scaffold('fullstack', { projectName: 'cool-blog', mode: 'ssr' }, targetDir);
+
+      const pkg = await readFile(join(targetDir, 'package.json'), 'utf-8');
+      expect(pkg).toContain('cool-blog');
+
+      const hello = await readFile(join(targetDir, 'server/api/hello.ts'), 'utf-8');
+      expect(hello).toContain('cool-blog');
+
+      const index = await readFile(join(targetDir, 'pages/index.ts'), 'utf-8');
+      expect(index).toContain('cool-blog');
+    });
+  });
+
+  it('no un-interpolated {{ }} remain in any output file', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'my-project');
+      await scaffold('fullstack', { projectName: 'my-project', mode: 'ssr' }, targetDir);
+
+      const binaryExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.svg',
+        '.woff', '.woff2', '.ttf', '.eot', '.otf', '.pdf', '.zip', '.gz', '.tar', '.gitkeep']);
+
+      async function collectFiles(d: string): Promise<string[]> {
+        const { readdir: rd } = await import('node:fs/promises');
+        const entries = await rd(d, { withFileTypes: true });
+        const results: string[] = [];
+        for (const e of entries) {
+          const p = join(d, e.name);
+          if (e.isDirectory()) {
+            results.push(...(await collectFiles(p)));
+          } else {
+            results.push(p);
+          }
+        }
+        return results;
+      }
+
+      const files = await collectFiles(targetDir);
+
+      for (const file of files) {
+        const extPart = file.includes('.') ? `.${file.split('.').pop()}` : '';
+        if (binaryExts.has(extPart.toLowerCase())) continue;
+        const content = await readFile(file, 'utf-8');
+        const matches = content.match(/\{\{[^}]+\}\}/g);
+        if (matches) {
+          throw new Error(`Un-interpolated placeholder in ${file}: ${matches.join(', ')}`);
+        }
+      }
+    });
+  });
+
+  it('11ty-blog recipe with mode=ssg writes litro.recipe.json', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'my-blog');
+      await scaffold('11ty-blog', { projectName: 'my-blog', mode: 'ssg' }, targetDir);
+
+      const { existsSync } = await import('node:fs');
+      expect(existsSync(join(targetDir, 'litro.recipe.json'))).toBe(true);
+
+      const manifest = JSON.parse(await readFile(join(targetDir, 'litro.recipe.json'), 'utf-8')) as Record<string, unknown>;
+      expect(manifest.recipe).toBe('11ty-blog');
+      expect(manifest.mode).toBe('ssg');
+      expect(manifest.contentDir).toBe('content/blog');
+    });
+  });
+
+  it('11ty-blog recipe writes content directory structure', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'my-blog');
+      await scaffold('11ty-blog', { projectName: 'my-blog', mode: 'ssr' }, targetDir);
+
+      const { existsSync } = await import('node:fs');
+      expect(existsSync(join(targetDir, 'content/blog/hello-world.md'))).toBe(true);
+      expect(existsSync(join(targetDir, 'content/blog/blog.11tydata.json'))).toBe(true);
+      expect(existsSync(join(targetDir, 'content/_data/metadata.js'))).toBe(true);
+    });
+  });
+
+  it('11ty-blog recipe interpolates {{projectName}} in metadata.js', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'awesome-blog');
+      await scaffold('11ty-blog', { projectName: 'awesome-blog', mode: 'ssr' }, targetDir);
+
+      const metadata = await readFile(join(targetDir, 'content/_data/metadata.js'), 'utf-8');
+      expect(metadata).toContain('awesome-blog');
+      expect(metadata).not.toContain('{{projectName}}');
+    });
+  });
+
+  it('11ty-blog recipe writes all expected files', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'my-blog');
+      await scaffold('11ty-blog', { projectName: 'my-blog', mode: 'ssg' }, targetDir);
+
+      const { existsSync } = await import('node:fs');
+      // Core config
+      expect(existsSync(join(targetDir, 'package.json'))).toBe(true);
+      expect(existsSync(join(targetDir, 'tsconfig.json'))).toBe(true);
+      expect(existsSync(join(targetDir, 'nitro.config.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'vite.config.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'app.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, '.gitignore'))).toBe(true);
+      expect(existsSync(join(targetDir, 'litro.recipe.json'))).toBe(true);
+      // Pages — including tags page
+      expect(existsSync(join(targetDir, 'pages/index.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'pages/blog/index.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'pages/blog/[slug].ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'pages/tags/[tag].ts'))).toBe(true);
+      // Server
+      expect(existsSync(join(targetDir, 'server/routes/[...].ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'server/middleware/vite-dev.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'server/api/posts.ts'))).toBe(true);
+      expect(existsSync(join(targetDir, 'server/stubs/page-manifest.ts'))).toBe(true);
+    });
+  });
+
+  it('11ty-blog recipe has no un-interpolated {{ }} in any output file', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'my-blog');
+      await scaffold('11ty-blog', { projectName: 'my-blog', mode: 'ssg' }, targetDir);
+
+      const binaryExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.svg',
+        '.woff', '.woff2', '.ttf', '.eot', '.otf', '.pdf', '.zip', '.gz', '.tar', '.gitkeep']);
+
+      async function collectFiles(d: string): Promise<string[]> {
+        const { readdir: rd } = await import('node:fs/promises');
+        const entries = await rd(d, { withFileTypes: true });
+        const results: string[] = [];
+        for (const e of entries) {
+          const p = join(d, e.name);
+          if (e.isDirectory()) results.push(...(await collectFiles(p)));
+          else results.push(p);
+        }
+        return results;
+      }
+
+      const files = await collectFiles(targetDir);
+      for (const file of files) {
+        const extPart = file.includes('.') ? `.${file.split('.').pop()}` : '';
+        if (binaryExts.has(extPart.toLowerCase())) continue;
+        const content = await readFile(file, 'utf-8');
+        const matches = content.match(/\{\{[^}]+\}\}/g);
+        if (matches) {
+          throw new Error(`Un-interpolated placeholder in ${file}: ${matches.join(', ')}`);
+        }
+      }
+    });
+  });
+
+  it('11ty-blog page files use plain <a> tags, not <litro-link>', async () => {
+    // SSG pages must use <a> for full-page-reload navigation so each pre-rendered
+    // page loads its own __litro_data__. <litro-link> triggers SPA navigation which
+    // leaves serverData=null on the navigated page (no __litro_data__ in DOM).
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'my-blog');
+      await scaffold('11ty-blog', { projectName: 'my-blog', mode: 'ssg' }, targetDir);
+
+      const pageFiles = [
+        join(targetDir, 'pages/index.ts'),
+        join(targetDir, 'pages/blog/index.ts'),
+        join(targetDir, 'pages/blog/[slug].ts'),
+        join(targetDir, 'pages/tags/[tag].ts'),
+      ];
+
+      for (const file of pageFiles) {
+        const content = await readFile(file, 'utf-8');
+        expect(content, `${file} should not contain <litro-link>`).not.toContain('litro-link');
+      }
+    });
+  });
+
+  it('throws for unknown recipe', async () => {
+    await withTmpDir(async (dir) => {
+      const targetDir = join(dir, 'unknown');
+      await expect(scaffold('does-not-exist', { projectName: 'test', mode: 'ssr' }, targetDir))
+        .rejects.toThrow();
+    });
+  });
+});