@voltro/cli 0.1.0

package/templates/apps/frontend-i18n/src/pages/index.test.tsx

@@ -0,0 +1,102 @@
+// @vitest-environment jsdom
+//
+// Home page (`/` = en, `/de` = de). Two things worth testing:
+//   1. `meta({ locale })` is localized — it reads the REAL catalog via
+//      getCatalog, so we assert en vs de titles/descriptions directly (no mock).
+//   2. the rendered body shows localized message text. The page pulls copy from
+//      @voltro/i18n (<T>, useT, useLocale); we mock those to resolve against the
+//      real catalog for a controllable "current locale", so the assertions are
+//      genuine localized strings, not placeholder ids.
+
+import { afterEach, describe, expect, test, vi } from 'vitest'
+import { act, createElement, type ReactNode } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import en from '../locales/en'
+import de from '../locales/de'
+
+// Controllable "active locale" for the i18n mock.
+const catalogs: Record<string, Record<string, string>> = { en, de }
+let currentLocale = 'en'
+
+// Minimal ICU-ish interpolation: replace {key} with values[key]. Enough to
+// assert the page threaded the right values into the right message.
+const fill = (msg: string, values?: Record<string, unknown>): string =>
+  values ? msg.replace(/\{(\w+)\}/g, (_, k: string) => String(values[k] ?? `{${k}}`)) : msg
+
+vi.mock('@voltro/i18n', () => ({
+  // The locale catalogs call these at module top-level; identity mirrors the
+  // real (compile-time-only) implementations so importing them doesn't throw.
+  defineCatalog: <T,>(c: T): T => c,
+  defineLocale:
+    () =>
+    <T,>(c: T): T =>
+      c,
+  useLocale: () => currentLocale,
+  useT: (id: string, values?: Record<string, unknown>) =>
+    fill(catalogs[currentLocale]?.[id] ?? id, values),
+  T: ({ id, values }: { id: string; values?: Record<string, unknown> }) =>
+    fill(catalogs[currentLocale]?.[id] ?? id, values),
+}))
+
+const { default: Index, meta, renderMode } = await import('./index')
+
+;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+
+let container: HTMLDivElement
+let root: Root
+
+const render = (node: ReactNode): void => {
+  container = document.createElement('div')
+  document.body.appendChild(container)
+  act(() => {
+    root = createRoot(container)
+    root.render(node)
+  })
+}
+
+afterEach(() => {
+  currentLocale = 'en'
+  if (root) act(() => root.unmount())
+  container?.remove()
+  document.body.innerHTML = ''
+})
+
+describe('home — config + localized meta', () => {
+  test('is a static page', () => {
+    expect(renderMode).toBe('static')
+  })
+
+  test('meta() returns the English catalog title/description for locale en', () => {
+    const m = meta({ locale: 'en' })
+    expect(m.title).toBe('Home — Voltro i18n')
+    expect(m.description).toContain('bilingual')
+  })
+
+  test('meta() returns the German catalog title/description for locale de', () => {
+    const m = meta({ locale: 'de' })
+    expect(m.title).toBe('Start — Voltro i18n')
+    expect(m.description).toContain('zweisprachige')
+  })
+
+  test('meta() falls back to the default (en) catalog for an unknown locale', () => {
+    expect(meta({ locale: 'zz' }).title).toBe('Home — Voltro i18n')
+  })
+})
+
+describe('home — localized render', () => {
+  test('renders the English greeting + tagline when the active locale is en', () => {
+    currentLocale = 'en'
+    render(createElement(Index))
+    expect(container.querySelector('h1')!.textContent).toBe('Hello, Voltro')
+    expect(container.textContent).toContain('bilingual static site')
+    expect(container.textContent).toContain('You are reading the EN version.')
+  })
+
+  test('renders the German greeting + tagline when the active locale is de', () => {
+    currentLocale = 'de'
+    render(createElement(Index))
+    expect(container.querySelector('h1')!.textContent).toBe('Hallo, Voltro')
+    expect(container.textContent).toContain('zweisprachige statische Website')
+    expect(container.textContent).toContain('Du liest die DE-Version.')
+  })
+})

package/templates/apps/frontend-i18n/src/pages/index.tsx

@@ -0,0 +1,43 @@
+// Home, mounted at `/` (default locale) and mirrored at `/de` by
+// src/pages/[locale]/index.tsx. `renderMode = 'static'` pre-renders one
+// HTML file per locale at build time.
+//
+// `meta` is a FUNCTION of `{ locale }` — that's what makes each variant's
+// <title> / <description> localised in the pre-rendered HTML. A plain
+// `meta` object would leave the head English on /de. `locale` is driven
+// by params.locale on the [locale] route, defaultLocale on the bare path.
+
+import type { ReactNode } from 'react'
+import type { PageMeta } from '@voltro/web'
+import { T, useT, useLocale } from '@voltro/i18n'
+import { getCatalog } from '../lib/locale'
+
+export const renderMode = 'static' as const
+
+export const meta = ({ locale }: { locale: string }): PageMeta => {
+  const c = getCatalog(locale)
+  return {
+    title: c['meta.home.title'],
+    description: c['meta.home.description'],
+  }
+}
+
+export default function Index(): ReactNode {
+  const locale = useLocale()
+  // Imperative form for an attribute-ish string; <T> for JSX.
+  const greeting = useT('home.title', { name: 'Voltro' })
+  return (
+    <article>
+      <h1>{greeting}</h1>
+      <p className="muted">
+        <T id="home.tagline" />
+      </p>
+      <p>
+        <T id="home.body" />
+      </p>
+      <p>
+        <T id="home.activeLocale" values={{ locale: locale.toUpperCase() }} />
+      </p>
+    </article>
+  )
+}

package/templates/apps/frontend-i18n/src/pages/layout.test.tsx

@@ -0,0 +1,86 @@
+// @vitest-environment jsdom
+//
+// Root layout — renders the top nav whose Home/About links + language switcher
+// are locale-prefixed off the CURRENT url (useUrlLocale → useLocation). We mock
+// useLocation (@voltro/web) to drive the active locale, and mock @voltro/i18n so
+// <I18nProvider> is a pass-through and <T> resolves against the real catalogs.
+
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { act, createElement, type ReactNode } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import en from '../locales/en'
+import de from '../locales/de'
+
+const location = vi.fn<() => string>()
+vi.mock('@voltro/web', () => ({ useLocation: () => location() }))
+
+const catalogs: Record<string, Record<string, string>> = { en, de }
+const localeFor = (path: string): string => (/^\/de(?:\/|$)/.test(path) ? 'de' : 'en')
+
+vi.mock('@voltro/i18n', () => ({
+  // The locale catalogs call these at module top-level; identity mirrors the
+  // real (compile-time-only) implementations so importing them doesn't throw.
+  defineCatalog: <T,>(c: T): T => c,
+  defineLocale:
+    () =>
+    <T,>(c: T): T =>
+      c,
+  I18nProvider: ({ children }: { children?: ReactNode }) => children,
+  // The nav uses <T> for link labels; resolve against the catalog of the
+  // locale implied by the current path (matches what useUrlLocale computes).
+  T: ({ id }: { id: string }) => catalogs[localeFor(location())]?.[id] ?? id,
+}))
+
+const { default: Layout } = await import('./layout')
+
+;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+
+let container: HTMLDivElement
+let root: Root
+
+const render = (node: ReactNode): void => {
+  container = document.createElement('div')
+  document.body.appendChild(container)
+  act(() => {
+    root = createRoot(container)
+    root.render(node)
+  })
+}
+
+const hrefs = (): Array<string | null> =>
+  Array.from(container.querySelectorAll('a')).map((a) => a.getAttribute('href'))
+
+beforeEach(() => location.mockReset())
+
+afterEach(() => {
+  if (root) act(() => root.unmount())
+  container?.remove()
+  document.body.innerHTML = ''
+})
+
+describe('i18n layout — English (bare path)', () => {
+  test('renders bare Home/About links and an English nav label', () => {
+    location.mockReturnValue('/about')
+    render(createElement(Layout, { children: createElement('p', null, 'page') }))
+    const h = hrefs()
+    expect(h).toContain('/')
+    expect(h).toContain('/about')
+    // language switcher keeps you on the same bare page, re-prefixed per locale
+    expect(h).toContain('/de/about')
+    expect(container.textContent).toContain('Home')
+    expect(container.querySelector('main')!.textContent).toContain('page')
+  })
+})
+
+describe('i18n layout — German (/de prefix)', () => {
+  test('prefixes the nav links with /de and renders German labels', () => {
+    location.mockReturnValue('/de/about')
+    render(createElement(Layout, { children: null }))
+    const h = hrefs()
+    expect(h).toContain('/de')
+    expect(h).toContain('/de/about')
+    // switching back to en strips the prefix
+    expect(h).toContain('/about')
+    expect(container.textContent).toContain('Start')
+  })
+})

package/templates/apps/frontend-i18n/src/pages/layout.tsx

@@ -0,0 +1,70 @@
+// Root layout. The framework's auto-wired <I18nProvider> is COOKIE-driven
+// (Strategy A). For URL-prefix routing (Strategy B) we add an INNER provider
+// that reads the locale FROM THE URL, so client-side navigation between
+// /about and /de/about swaps the catalog without a full reload. At build
+// time it resolves to the same locale the SSG pipeline pre-rendered.
+//
+// `<html>`/`<head>`/`<body>` are owned by the framework shell — don't render
+// them here. Page <title> + meta come from each page's `meta` export.
+
+import type { ReactNode } from 'react'
+import { I18nProvider, T } from '@voltro/i18n'
+import { useLocation } from '@voltro/web'
+import {
+  CATALOGS,
+  DEFAULT_LOCALE,
+  SUPPORTED_LOCALES,
+  stripLocalePrefix,
+  useUrlLocale,
+  withLocalePrefix,
+} from '../lib/locale'
+import '../globals.css'
+
+function TopNav(): ReactNode {
+  const locale = useUrlLocale()
+  // The path WITHOUT its locale prefix — so the language switch keeps you
+  // on the same page (e.g. /de/about → /about, then re-prefix per locale).
+  const barePath = stripLocalePrefix(useLocation())
+
+  // Plain <a> (not <Link>): these hrefs are COMPUTED per locale, and
+  // <Link to> wants a statically-known `VoltroUrl` literal. The Router's
+  // global click interceptor SPA-navigates internal <a> anyway, so the
+  // inner provider still swaps catalogs without a full reload.
+  return (
+    <nav className="topnav">
+      <a href={withLocalePrefix('/', locale)}>
+        <T id="nav.home" />
+      </a>
+      <a href={withLocalePrefix('/about', locale)}>
+        <T id="nav.about" />
+      </a>
+      <span className="spacer" />
+      <span className="lang">
+        <span className="label">
+          <T id="nav.language" />:
+        </span>
+        {SUPPORTED_LOCALES.map((code) => (
+          <a
+            key={code}
+            href={withLocalePrefix(barePath, code)}
+            aria-current={code === locale ? 'true' : undefined}
+          >
+            {code.toUpperCase()}
+          </a>
+        ))}
+      </span>
+    </nav>
+  )
+}
+
+export default function Layout({ children }: { readonly children: ReactNode }): ReactNode {
+  const locale = useUrlLocale()
+  return (
+    <I18nProvider locale={locale} messages={CATALOGS[locale]} defaultLocale={DEFAULT_LOCALE}>
+      <div className="shell">
+        <TopNav />
+        <main>{children}</main>
+      </div>
+    </I18nProvider>
+  )
+}

package/templates/apps/frontend-i18n/template.json

@@ -0,0 +1,6 @@
+{
+  "id": "frontend-i18n",
+  "kind": "web",
+  "summary": "Bilingual (en/de) static site with URL-prefix i18n — per-locale SSG, [locale] mirror pages, and type-checked translation catalogs. `voltro build` emits /… and /de/… HTML.",
+  "tags": ["web", "frontend", "i18n", "intl", "localization", "ssg", "static"]
+}

package/templates/apps/frontend-i18n/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", ".framework"]
+}

package/templates/apps/frontend-landing/README.md

@@ -0,0 +1,17 @@
+# {{projectName}} / {{appName}}
+
+Marketing landing page (template: **frontend-landing**).
+
+The page exports `renderMode = 'static'` + `interactive = 'none'`, so
+`voltro build` pre-renders it to HTML and `voltro start` serves the
+file directly — zero framework JS on the wire.
+
+```bash
+pnpm install
+pnpm --filter @{{projectName}}/{{appName}} dev
+# → http://localhost:5173
+```
+
+When you need a contact form / sign-up flow, switch
+`interactive: 'islands'` on the page and mark the interactive
+component with the `*.island.tsx` suffix so only that bundle ships.

package/templates/apps/frontend-landing/app.config.ts

@@ -0,0 +1,25 @@
+// `port` is allocated by `voltro create-project` / `voltro add-app` from
+// the project's portRange (in project.json).
+import { defineEnv, envVar } from '@voltro/env'
+
+// Typed PUBLIC environment — public vars are validated + baked into the browser
+// bundle at build time and read via `publicEnv` from '@voltro/env/public'
+// (typed, autocompleted). NEVER put a secret here (it would ship to every
+// visitor) — declare secrets on the api instead. Run `voltro env` for the manifest.
+export const env = defineEnv({
+  VOLTRO_PUBLIC_APP_NAME: envVar.string({ access: 'public', default: '{{capProjectName}}' }),
+})
+
+export default {
+  type: 'web' as const,
+  name: '{{capProjectName}}{{capAppName}}',
+  port: {{port}},
+  // The shipped catalogs (Strategy B: URL-prefix i18n). `defaultLocale`
+  // lives at the bare path (`/`); every other locale is prefixed (`/de`).
+  // `voltro build` pre-renders one HTML file per locale. Keep this in sync
+  // with SUPPORTED_LOCALES / DEFAULT_LOCALE in src/lib/locale.ts — that file
+  // drives the [locale] mirror routing + the language switcher.
+  locales:       ['en', 'de'] as const,
+  defaultLocale: 'en'         as const,
+  env,
+}

package/templates/apps/frontend-landing/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@{{projectName}}/{{appName}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "voltro dev .",
+    "build": "voltro build .",
+    "start": "voltro start .",
+    "test": "voltro test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@voltro/cli": "0.1.0",
+    "@voltro/client": "0.1.0",
+    "@voltro/env": "0.1.0",
+    "@voltro/i18n": "0.1.0",
+    "@voltro/ui-shadcn": "0.1.0",
+    "@voltro/web": "0.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/templates/apps/frontend-landing/src/globals.css

@@ -0,0 +1,23 @@
+/* Landing template — design tokens + Tailwind. `@voltro/ui-shadcn/tokens.css`
+ * is the kit's entry point: imports tailwindcss, tw-animate-css, declares
+ * the shadcn palette, and registers the @theme mapping. Brand-specific
+ * overrides go below. */
+
+@import "@voltro/ui-shadcn/tokens.css";
+
+/* Scan THIS app's source so utility classes used only here (not in
+ * the kit) get generated. Every consumer of @voltro/ui-shadcn needs
+ * its own @source — once the kit declares one, Tailwind v4's
+ * vite-plugin auto-detect stops firing. */
+@source "./**/*.{tsx,ts,jsx,js}";
+
+html, body { min-height: 100vh; }
+
+/* Gradient title — use on hero <h1> via `className="gradient-title"`. */
+.gradient-title {
+  background: linear-gradient(180deg, var(--foreground) 0%, oklch(0.7 0.18 290) 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  color: transparent;
+}

package/templates/apps/frontend-landing/src/lib/locale.test.ts

@@ -0,0 +1,72 @@
+// The URL-prefix i18n helpers — the load-bearing pure functions that drive the
+// [locale] mirror routing + the language switcher. `useUrlLocale` (the one hook
+// in this module) reads useLocation from @voltro/web; the rest are pure string
+// functions we can exercise directly.
+
+import { describe, expect, test } from 'vitest'
+import {
+  SUPPORTED_LOCALES,
+  DEFAULT_LOCALE,
+  getCatalog,
+  localeFromPathname,
+  withLocalePrefix,
+  stripLocalePrefix,
+} from './locale'
+
+describe('locale constants', () => {
+  test('supports en + de with en as the default', () => {
+    expect(SUPPORTED_LOCALES).toEqual(['en', 'de'])
+    expect(DEFAULT_LOCALE).toBe('en')
+  })
+})
+
+describe('getCatalog', () => {
+  test('returns the matching catalog for a supported locale', () => {
+    expect(getCatalog('de')['nav.home']).toBe('Start')
+    expect(getCatalog('en')['nav.home']).toBe('Home')
+  })
+
+  test('falls back to the default catalog for an unsupported locale', () => {
+    expect(getCatalog('zz')['nav.home']).toBe('Home')
+  })
+})
+
+describe('localeFromPathname', () => {
+  test('extracts a prefixed locale', () => {
+    expect(localeFromPathname('/de')).toBe('de')
+    expect(localeFromPathname('/de/pricing')).toBe('de')
+  })
+
+  test('defaults to en for the bare path or an unknown prefix', () => {
+    expect(localeFromPathname('/')).toBe('en')
+    expect(localeFromPathname('/pricing')).toBe('en')
+    expect(localeFromPathname('/fr/pricing')).toBe('en')
+  })
+})
+
+describe('withLocalePrefix', () => {
+  test('leaves default-locale paths bare', () => {
+    expect(withLocalePrefix('/pricing', 'en')).toBe('/pricing')
+    expect(withLocalePrefix('/', 'en')).toBe('/')
+  })
+
+  test('prefixes non-default locales, mapping / to /<locale>', () => {
+    expect(withLocalePrefix('/pricing', 'de')).toBe('/de/pricing')
+    expect(withLocalePrefix('/', 'de')).toBe('/de')
+  })
+})
+
+describe('stripLocalePrefix', () => {
+  test('removes a locale prefix, mapping /<locale> back to /', () => {
+    expect(stripLocalePrefix('/de/pricing')).toBe('/pricing')
+    expect(stripLocalePrefix('/de')).toBe('/')
+  })
+
+  test('leaves an unprefixed path unchanged', () => {
+    expect(stripLocalePrefix('/pricing')).toBe('/pricing')
+  })
+
+  test('round-trips with withLocalePrefix', () => {
+    expect(stripLocalePrefix(withLocalePrefix('/pricing', 'de'))).toBe('/pricing')
+  })
+})

package/templates/apps/frontend-landing/src/lib/locale.ts

@@ -0,0 +1,55 @@
+// The single source of truth for this app's locales + the URL-prefix
+// helpers. `app.config.ts` lists the same codes for the build pipeline;
+// the [locale] mirror pages + the layout's <I18nProvider> read THIS file.
+//
+// Keep SUPPORTED_LOCALES / DEFAULT_LOCALE in sync with `locales` /
+// `defaultLocale` in app.config.ts.
+
+import { useLocation } from '@voltro/web'
+import en from '../locales/en'
+import de from '../locales/de'
+
+export const SUPPORTED_LOCALES = ['en', 'de'] as const
+export const DEFAULT_LOCALE = 'en'
+
+export type Locale = (typeof SUPPORTED_LOCALES)[number]
+
+// The catalogs, keyed by code. The layout picks one to feed the inner
+// <I18nProvider>; `meta` (build-time, per locale) reads one via getCatalog.
+export const CATALOGS = { en, de } as const
+
+// Every catalog mirrors `en`'s keys (defineLocale enforces it), so a
+// plain string-record over en's keys is the common type both satisfy —
+// what `meta` reads at build time (`c['meta.home.title']` → string).
+export type Messages = Record<keyof typeof en, string>
+
+const isSupported = (v: string): v is Locale =>
+  (SUPPORTED_LOCALES as ReadonlyArray<string>).includes(v)
+
+export const getCatalog = (locale: string): Messages =>
+  isSupported(locale) ? CATALOGS[locale] : CATALOGS[DEFAULT_LOCALE]
+
+// `/de/about` → 'de'; `/about` → 'en' (default lives at the bare path).
+export const localeFromPathname = (pathname: string): Locale => {
+  const match = /^\/([a-z]{2})(?:\/|$)/.exec(pathname)
+  return match && isSupported(match[1]!) ? (match[1] as Locale) : DEFAULT_LOCALE
+}
+
+// Reactive: useLocation re-renders on client-side nav, so the layout's
+// provider swaps catalogs when you move between /about and /de/about
+// without a full reload.
+export const useUrlLocale = (): Locale => localeFromPathname(useLocation())
+
+// '/about' + 'de' → '/de/about'; the default locale stays bare ('/about').
+export const withLocalePrefix = (path: string, locale: string): string => {
+  if (locale === DEFAULT_LOCALE) return path
+  const p = path.startsWith('/') ? path : `/${path}`
+  return p === '/' ? `/${locale}` : `/${locale}${p}`
+}
+
+// '/de/about' → '/about'; '/about' → '/about'. The inverse of the above,
+// used to keep the active path when switching language.
+export const stripLocalePrefix = (pathname: string): string => {
+  const match = /^\/([a-z]{2})(\/.*|$)/.exec(pathname)
+  return match && isSupported(match[1]!) ? match[2] || '/' : pathname
+}

package/templates/apps/frontend-landing/src/locales/de.ts

@@ -0,0 +1,24 @@
+// German catalog. MUST mirror en.ts key-for-key — `defineLocale<typeof en>()`
+// returns a curried function that fails `tsc --noEmit` on a missing or extra
+// key, so translations can never silently drift out of sync.
+import { defineLocale } from '@voltro/i18n'
+import en from './en'
+
+export default defineLocale<typeof en>()({
+  'nav.home':     'Start',
+  'nav.language': 'Sprache',
+
+  'hero.tagline': 'Ersetze diesen Hero-Text durch dein Nutzenversprechen.',
+  'hero.cta':     'Mehr erfahren →',
+
+  'features.heading':     'Funktionen',
+  'features.reactive':    '<strong>Reaktive Subscriptions.</strong> Server-Status streamt per WebSocket zu den Clients.',
+  'features.tenant':      '<strong>Mandantengetrennt per Voreinstellung.</strong> Die Runtime verhindert mandantenübergreifende Lese- und Schreibzugriffe automatisch.',
+  'features.conventions': '<strong>Dateikonventionen statt Konfiguration.</strong> Lege eine <code>*.route.tsx</code> an und erhalte eine streamende Query.',
+
+  'cta.heading': 'Bereit loszulegen?',
+  'cta.body':    'Bearbeite <code>src/pages/index.tsx</code>, um sie anzupassen.',
+
+  'meta.home.title':       'Start',
+  'meta.home.description': 'Eine Marketing-Landingpage, gebaut mit Voltro — vorgerendertes statisches HTML, kein JavaScript auf der Leitung.',
+})

package/templates/apps/frontend-landing/src/locales/en.ts

@@ -0,0 +1,26 @@
+// Base catalog — the source of truth. Every other locale (de.ts) mirrors
+// these keys EXACTLY; `defineLocale<typeof en>()` enforces that at `tsc`.
+//
+// Keep ICU placeholders + rich-text tags (`<strong>`, `<code>`) identical
+// across locales — react-intl validates them at render time, and every tag
+// needs a matching value function where the message is rendered with <T>.
+import { defineCatalog } from '@voltro/i18n'
+
+export default defineCatalog({
+  'nav.home':     'Home',
+  'nav.language': 'Language',
+
+  'hero.tagline': 'Replace this hero copy with your value prop.',
+  'hero.cta':     'Learn more →',
+
+  'features.heading':     'Features',
+  'features.reactive':    '<strong>Reactive subscriptions.</strong> Server state streams to clients via WebSocket.',
+  'features.tenant':      '<strong>Tenant-scoped by default.</strong> The runtime guards cross-tenant reads + writes automatically.',
+  'features.conventions': '<strong>File conventions, not config.</strong> Drop a <code>*.route.tsx</code>, get a streaming query.',
+
+  'cta.heading': 'Ready to start?',
+  'cta.body':    'Edit <code>src/pages/index.tsx</code> to make it yours.',
+
+  'meta.home.title':       'Home',
+  'meta.home.description': 'A marketing landing page built with Voltro — pre-rendered static HTML, zero JavaScript on the wire.',
+} as const)

package/templates/apps/frontend-landing/src/pages/[locale]/index.tsx

@@ -0,0 +1,13 @@
+// Locale mirror of `/` → renders `/de`. Re-exports the bare page verbatim
+// (the component reads its locale from the URL via the layout's provider);
+// `getStaticPaths` tells `voltro build` which locale-prefixed paths to emit.
+// The default locale is NOT listed here — it lives at the bare `/`.
+import { SUPPORTED_LOCALES, DEFAULT_LOCALE } from '../../lib/locale'
+
+export { default } from '../index'
+export { renderMode, interactive, meta } from '../index'
+
+export const getStaticPaths = async (): Promise<Array<{ params: { locale: string } }>> =>
+  SUPPORTED_LOCALES
+    .filter((l) => l !== DEFAULT_LOCALE)
+    .map((locale) => ({ params: { locale } }))

package/templates/apps/frontend-landing/src/pages/[locale]/mirrors.test.tsx

@@ -0,0 +1,37 @@
+// @vitest-environment jsdom
+//
+// The [locale] mirror page re-exports the bare page and adds getStaticPaths,
+// which tells `voltro build` which locale-prefixed paths to emit. The default
+// locale (en) is NOT listed — it lives at the bare path — so only /de is
+// produced. We also confirm the mirror re-exports the base page + its meta.
+
+import { describe, expect, test, vi } from 'vitest'
+
+// The mirror transitively imports the base page, which imports @voltro/i18n.
+// Stub it so importing the module doesn't require the real i18n runtime.
+vi.mock('@voltro/i18n', () => ({
+  // The locale catalogs call these at module top-level; identity mirrors the
+  // real (compile-time-only) implementations so importing them doesn't throw.
+  defineCatalog: <T,>(c: T): T => c,
+  defineLocale:
+    () =>
+    <T,>(c: T): T =>
+      c,
+  T: ({ id }: { id: string }) => id,
+}))
+
+const indexMirror = await import('./index')
+
+describe('home mirror — getStaticPaths', () => {
+  test('emits only non-default locales (just /de)', async () => {
+    const paths = await indexMirror.getStaticPaths()
+    expect(paths).toEqual([{ params: { locale: 'de' } }])
+  })
+
+  test('re-exports the base page component + its meta function', () => {
+    expect(typeof indexMirror.default).toBe('function')
+    expect(indexMirror.meta({ locale: 'de' }).title).toBe('Start')
+    expect(indexMirror.renderMode).toBe('static')
+    expect(indexMirror.interactive).toBe('none')
+  })
+})