npm - @voltro/cli - Versions diffs - 0.1.0 - Mend

@voltro/cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (626) hide show

package/templates/apps/api-webhooks/tsconfig.json ADDED Viewed

@@ -0,0 +1,5 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/apps/api-webhooks/webhooks/orders.webhook.tsx ADDED Viewed

@@ -0,0 +1,35 @@
+// INCOMING webhook — a public endpoint a partner POSTs to. Mounts at
+// `/webhooks/orders` (the `id`). The framework's incoming middleware runs
+// BEFORE your handler:
+//
+//   1. verifies the `X-Webhook-Signature: t=<ts>,v1=<hmac>` HMAC over
+//      `<ts>.<rawBody>` with VOLTRO_WEBHOOK_SECRET_ORDERS  → 401 on mismatch
+//   2. rejects a `t` older than the replay window                → 401
+//   3. decodes the body against `payload`                        → 422 on bad shape
+//   4. claims the `Idempotency-Key` (dedup)            → 200 {duplicate:true} on replay
+//
+// Only a request that passes ALL of that reaches `handler`. That's the whole
+// point: you never hand-roll signature checks, and forged traffic never runs
+// your code.
+import { defineIncomingWebhook } from '@voltro/plugin-webhooks'
+import { genericProvider } from '@voltro/plugin-webhooks/providers'
+import { Schema } from 'effect'
+export default defineIncomingWebhook({
+  id:       'orders',
+  provider: genericProvider(),   // HMAC `<ts>.<body>` → X-Webhook-Signature; idempotency via Idempotency-Key
+  payload:  Schema.Struct({
+    event:    Schema.String,
+    orderId:  Schema.String,
+    sku:      Schema.String,
+    totalCents: Schema.Number,
+  }),
+  // ctx.body is validated; ctx.idempotencyKey + ctx.headers are also available.
+  // No ctx.store here — a webhook handler is app glue; for DB writes, enqueue a
+  // workflow or call your own service. We log to prove receipt (the dev console
+  // bridge surfaces it in the terminal).
+  handler: async (ctx) => {
+    console.log(`[webhook:orders] verified ${ctx.body.event} for ${ctx.body.orderId} (idempotency=${ctx.idempotencyKey})`)
+  },
+})

package/templates/apps/changelog/README.md ADDED Viewed

@@ -0,0 +1,77 @@
+# {{projectName}} / {{appName}}
+A bilingual (en/de) changelog / release-notes site (template: **changelog**),
+powered by [`@voltro/changelog`](https://www.npmjs.com/package/@voltro/changelog).
+The chrome (nav, footer, empty state, page titles) is translated; release
+entries are content and stay as authored. English lives at the bare path,
+German under `/de` — each pre-rendered as its own crawlable URL.
+## What's here
+```
+content/releases/*.mdx     ← one file per release (frontmatter + markdown)
+src/lib/releases.ts        ← loads + sorts them via `loadReleases` (Vite raw glob)
+src/lib/locale.ts          ← URL-prefix i18n helpers (SUPPORTED_LOCALES, withLocalePrefix, …)
+src/locales/{en,de}.ts     ← typed, key-parity chrome catalogs
+src/pages/index.tsx        ← the release list
+src/pages/[slug].tsx       ← one page per release (code fences highlighted by `highlightRelease`)
+src/pages/[locale]/**      ← per-locale mirrors (getStaticPaths → /de, /de/<slug>)
+src/pages/layout.tsx       ← BlogLayout shell + URL <I18nProvider> + language switcher (headerRight)
+scripts/generate-rss.mjs   ← writes public/rss.xml via `renderReleaseRss` (build step)
+```
+```bash
+pnpm install
+pnpm --filter @{{projectName}}/{{appName}} dev
+# → http://localhost:{{port}}            the release list
+# → http://localhost:{{port}}/v0-2-0     a single release
+```
+## Add a release
+Drop a new file in `content/releases/`. Required frontmatter is `version`
++ `releasedAt`; everything else is optional:
+```mdx
+---
+version: 0.3.0
+releasedAt: 2026-07-01
+slug: v0-3-0          # URL segment; defaults to a slugified version
+title: My release
+summary: One-line summary (shown in the list + RSS).
+tags: [feature, fix]  # feature | fix | breaking | security | performance
+---
+## What changed
+Markdown body — code fences get syntax-highlighted at build time.
+```
+Files missing `version`/`releasedAt` are skipped; the list is sorted
+newest-first automatically.
+## RSS feed
+`pnpm build` runs `scripts/generate-rss.mjs` (which calls
+`renderReleaseRss`) before the static build, emitting `public/rss.xml`
+→ served at `/rss.xml`. Set `SITE_URL` so the feed's links are absolute:
+```bash
+SITE_URL=https://changelog.example.com pnpm build && pnpm start
+```
+## "What's new" badge in another app
+The other half of `@voltro/changelog` lives on the browser-only
+`/web` subpath: `useChangelogBadge` polls this site's `rss.xml` and tells
+a PRODUCT app's nav when there's an unread release. Add it to that app
+(not this one):
+```tsx
+import { useChangelogBadge } from '@voltro/changelog/web'
+const { hasUnread, latest, markRead } = useChangelogBadge({
+  url: 'https://changelog.example.com/rss.xml',
+})
+// render a dot when `hasUnread`; call `markRead()` when the user opens it.
+```

package/templates/apps/changelog/app.config.ts ADDED Viewed

@@ -0,0 +1,27 @@
+// `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. `VOLTRO_PUBLIC_SITE_NAME` titles the changelog
+// (header brand + RSS feed). Public vars are validated at boot and baked
+// into the browser bundle — NEVER put a secret here. Run `voltro env` for
+// the manifest. The RSS generator (scripts/generate-rss.mjs) reads the same
+// value from process.env at build time.
+export const env = defineEnv({
+  VOLTRO_PUBLIC_SITE_NAME: envVar.string({ access: 'public', default: '{{capProjectName}}' }),
+})
+export default {
+  type: 'web' as const,
+  name: '{{capProjectName}}{{capAppName}}',
+  port: {{port}},
+  // A BILINGUAL (en/de) changelog — Strategy B (URL-prefix i18n). English
+  // lives at the bare path (`/`, `/<slug>`); German is prefixed (`/de`,
+  // `/de/<slug>`). `locales` tells `voltro build` to pre-render a per-locale
+  // HTML variant for every `[locale]/…` mirror page. Keep in sync with
+  // SUPPORTED_LOCALES / DEFAULT_LOCALE in src/lib/locale.ts; every code MUST
+  // have a matching `src/locales/<code>.ts`.
+  locales:       ['en', 'de'] as const,
+  defaultLocale: 'en'         as const,
+  env,
+}

package/templates/apps/changelog/content/releases/0.1.0.mdx ADDED Viewed

@@ -0,0 +1,19 @@
+---
+version: 0.1.0
+releasedAt: 2026-01-15
+slug: v0-1-0
+title: First release
+summary: The initial cut — projects, file-based pages, and the reactive query layer.
+tags: [feature]
+---
+## Highlights
+The first public release. Spin up an app and subscribe to live data — no
+`refetch`, the subscription stays live for the component's lifetime:
+```ts
+const { data } = useSubscription('app', 'todos.list')
+```
+Welcome aboard.

package/templates/apps/changelog/content/releases/0.2.0.mdx ADDED Viewed

@@ -0,0 +1,28 @@
+---
+version: 0.2.0
+releasedAt: 2026-06-21
+slug: v0-2-0
+title: Typed env + faster boot
+summary: Declare your environment once; it's validated at startup with a hard public/secret boundary.
+tags: [feature, performance]
+---
+## Typed environment
+`defineEnv` validates every variable at boot (fail-fast, all problems
+listed) and hands back typed, coerced accessors instead of
+`string | undefined`:
+```ts
+export const env = defineEnv({
+  MAX_BATCH:  envVar.number({ access: 'public', default: '50' }),
+  STRIPE_KEY: envVar.string({ access: 'secret' }),   // never reaches the browser
+})
+```
+A `secret` is unrepresentable in the browser bundle — enforced by the
+compiler and the bundler, not by discipline.
+## Faster cold boot
+Roughly **30% faster** startup on a warm schema cache.

package/templates/apps/changelog/package.json ADDED Viewed

@@ -0,0 +1,30 @@
+{
+  "name": "@{{projectName}}/{{appName}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "voltro dev .",
+    "build": "tsx scripts/generate-rss.mjs && voltro build .",
+    "start": "voltro start .",
+    "typecheck": "tsc --noEmit",
+    "test": "voltro test"
+  },
+  "dependencies": {
+    "@voltro/changelog": "0.1.0",
+    "@voltro/cli": "0.1.0",
+    "@voltro/client": "0.1.0",
+    "@voltro/env": "0.1.0",
+    "@voltro/i18n": "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",
+    "tsx": "^4.22.4",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/templates/apps/changelog/scripts/generate-rss.mjs ADDED Viewed

@@ -0,0 +1,38 @@
+// Generate public/rss.xml from content/releases/*.mdx using the SAME
+// @voltro/changelog primitives the pages use (`loadReleases` +
+// `renderReleaseRss`). Runs BEFORE `voltro build` so Vite copies the file
+// into the build output (publicDir = <app>/public) and `voltro start`
+// serves it as application/xml.
+//
+// Why a separate Node script and not a page route: the web SSG renders
+// HTML pages only — a feed is a non-HTML artifact, so it's emitted as a
+// static file rather than an `rss.xml.tsx` route. Run via `tsx` so the
+// import resolves whether @voltro/changelog points at its TS source
+// (in-workspace dev) or its built dist (a normal install).
+import { readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { loadReleases, renderReleaseRss } from '@voltro/changelog'
+const appRoot = join(dirname(fileURLToPath(import.meta.url)), '..')
+const releasesDir = join(appRoot, 'content', 'releases')
+// Read each .mdx file into the { path: contents } map loadReleases expects.
+const sources = {}
+for (const file of readdirSync(releasesDir)) {
+  if (file.endsWith('.mdx')) sources[file] = readFileSync(join(releasesDir, file), 'utf8')
+}
+const releases = loadReleases(sources)
+// The base URL each release links under (<siteUrl>/<slug>). Set SITE_URL in
+// your deploy env; localhost is the dev default.
+const siteUrl = process.env.SITE_URL ?? 'http://localhost:{{port}}'
+const xml = renderReleaseRss(releases, siteUrl, {
+  title: '{{capProjectName}} Changelog',
+  description: 'Product updates and release notes.',
+})
+const publicDir = join(appRoot, 'public')
+mkdirSync(publicDir, { recursive: true })
+writeFileSync(join(publicDir, 'rss.xml'), xml)
+console.log(`rss.xml — ${releases.length} release(s) → public/rss.xml`)

package/templates/apps/changelog/src/globals.css ADDED Viewed

@@ -0,0 +1,66 @@
+/* Changelog template — self-contained styling, no Tailwind / kit dependency.
+ * `BlogLayout` (from @voltro/web) ships its own layout styles; this file
+ * styles the changelog LIST and the rendered markdown body (release.html).
+ * Want Tailwind + the shadcn palette instead? Swap this file for
+ * `@import "@voltro/ui-shadcn/tokens.css";` + an `@source` (see frontend-docs). */
+:root {
+  --cl-fg: #18181b;
+  --cl-muted: #71717a;
+  --cl-border: rgba(127, 127, 127, 0.2);
+  --cl-accent: #4f46e5;
+  --cl-code-bg: #f4f4f5;
+  --cl-tag-bg: rgba(79, 70, 229, 0.12);
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --cl-fg: #fafafa;
+    --cl-muted: #a1a1aa;
+    --cl-code-bg: #18181b;
+    --cl-accent: #818cf8;
+    --cl-tag-bg: rgba(129, 140, 248, 0.16);
+  }
+}
+body {
+  margin: 0;
+  color: var(--cl-fg);
+  font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+  line-height: 1.6;
+}
+a { color: var(--cl-accent); }
+/* Language switcher pinned in BlogLayout's headerRight slot. */
+.cl-lang { display: inline-flex; gap: 0.5rem; align-items: center; font-size: 0.85rem; }
+.cl-lang-label { color: var(--cl-muted); }
+.cl-lang a[aria-current='true'] { font-weight: 600; }
+/* Release meta + tags (list + detail). */
+.changelog-meta { font-size: 0.85rem; color: var(--cl-muted); margin: 0 0 0.5rem; }
+.changelog-tag {
+  display: inline-block;
+  margin-left: 0.4rem;
+  padding: 0.05rem 0.45rem;
+  border-radius: 999px;
+  font-size: 0.72rem;
+  background: var(--cl-tag-bg);
+  color: var(--cl-accent);
+}
+/* List entries. */
+.changelog-entry { padding: 1.25rem 0; border-bottom: 1px solid var(--cl-border); }
+.changelog-entry h2 { margin: 0.25rem 0; font-size: 1.25rem; }
+.changelog-entry h2 a { text-decoration: none; }
+.changelog-entry p:last-child { color: var(--cl-muted); margin: 0.25rem 0 0; }
+/* Rendered markdown body (release.html from marked / shiki). */
+.changelog-prose h1 { font-size: 1.9rem; font-weight: 700; letter-spacing: -0.02em; margin: 0 0 0.5rem; }
+.changelog-prose h2 { font-size: 1.3rem; font-weight: 600; margin: 1.75rem 0 0.5rem; }
+.changelog-prose h3 { font-size: 1.05rem; font-weight: 600; margin: 1.25rem 0 0.4rem; }
+.changelog-prose p, .changelog-prose li { color: var(--cl-fg); }
+.changelog-prose ul { padding-left: 1.4rem; }
+.changelog-prose code { background: var(--cl-code-bg); padding: 2px 5px; border-radius: 4px; font-size: 0.85em; }
+/* `shiki` sets its own inline background on <pre class="shiki">; this is the
+ * fallback for plain (un-highlighted) marked output. */
+.changelog-prose pre { background: var(--cl-code-bg); padding: 1rem; border-radius: 8px; overflow-x: auto; }
+.changelog-prose pre code { background: transparent; padding: 0; }

package/templates/apps/changelog/src/globals.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+// Ambient declarations.
+//
+// `declare module '*.css'`: TypeScript 6 with `moduleResolution: Bundler`
+// rejects a bare `import './globals.css'` unless the asset module is
+// declared. Vite resolves it at build time; the declaration is type-only.
+declare module '*.css'
+// Minimal typing for Vite's `import.meta.glob` (used by src/lib/releases.ts)
+// so the app typechecks without depending on `vite/client` types being
+// resolvable. Vite provides the real implementation at build time.
+interface ImportMeta {
+  readonly glob: <T = unknown>(
+    pattern: string | ReadonlyArray<string>,
+    options?: { query?: string; import?: string; eager?: boolean },
+  ) => Record<string, T>
+}

package/templates/apps/changelog/src/lib/locale.test.ts ADDED Viewed

@@ -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.releases']).toBe('Versionen')
+    expect(getCatalog('en')['nav.releases']).toBe('Releases')
+  })
+  test('falls back to the default catalog for an unsupported locale', () => {
+    expect(getCatalog('zz')['nav.releases']).toBe('Releases')
+  })
+})
+describe('localeFromPathname', () => {
+  test('extracts a prefixed locale', () => {
+    expect(localeFromPathname('/de')).toBe('de')
+    expect(localeFromPathname('/de/about')).toBe('de')
+  })
+  test('defaults to en for the bare path or an unknown prefix', () => {
+    expect(localeFromPathname('/')).toBe('en')
+    expect(localeFromPathname('/about')).toBe('en')
+    expect(localeFromPathname('/fr/about')).toBe('en')
+  })
+})
+describe('withLocalePrefix', () => {
+  test('leaves default-locale paths bare', () => {
+    expect(withLocalePrefix('/about', 'en')).toBe('/about')
+    expect(withLocalePrefix('/', 'en')).toBe('/')
+  })
+  test('prefixes non-default locales, mapping / to /<locale>', () => {
+    expect(withLocalePrefix('/about', 'de')).toBe('/de/about')
+    expect(withLocalePrefix('/', 'de')).toBe('/de')
+  })
+})
+describe('stripLocalePrefix', () => {
+  test('removes a locale prefix, mapping /<locale> back to /', () => {
+    expect(stripLocalePrefix('/de/about')).toBe('/about')
+    expect(stripLocalePrefix('/de')).toBe('/')
+  })
+  test('leaves an unprefixed path unchanged', () => {
+    expect(stripLocalePrefix('/about')).toBe('/about')
+  })
+  test('round-trips with withLocalePrefix', () => {
+    expect(stripLocalePrefix(withLocalePrefix('/about', 'de'))).toBe('/about')
+  })
+})

package/templates/apps/changelog/src/lib/locale.ts ADDED Viewed

@@ -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/changelog/src/lib/releases.ts ADDED Viewed

@@ -0,0 +1,21 @@
+// The single source of releases for every page. The MDX files under
+// content/releases/ are read at build time via Vite's raw glob (works in
+// dev, SSR, and the static build). `import: 'default'` yields each file's
+// contents as a string — exactly the shape `loadReleases()` expects. The
+// loader parses the frontmatter, renders the markdown body, sorts newest-
+// first, and skips any file missing `version` / `releasedAt`.
+import { loadReleases, type Release } from '@voltro/changelog'
+const sources = import.meta.glob('../../content/releases/*.mdx', {
+  query: '?raw',
+  import: 'default',
+  eager: true,
+}) as Record<string, string>
+/** All releases, newest first. */
+export const releases: ReadonlyArray<Release> = loadReleases(sources)
+export const releaseBySlug = (slug: string): Release | undefined =>
+  releases.find((r) => r.slug === slug)
+export type { Release }

package/templates/apps/changelog/src/locales/de.ts ADDED Viewed

@@ -0,0 +1,22 @@
+// 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.changelog': 'Changelog',
+  'nav.releases':  'Versionen',
+  'nav.rss':       'RSS',
+  'nav.language':  'Sprache',
+  'footer.builtWith': 'Gebaut mit @voltro/changelog',
+  'empty.body':
+    'Noch keine Releases — lege eine <code>.mdx</code>-Datei unter <code>content/releases/</code> mit <code>version</code>- und <code>releasedAt</code>-Frontmatter an.',
+  'post.backToList': '← Alle Versionen',
+  'meta.home.title':       '{{capProjectName}} — Changelog',
+  'meta.home.description': 'Produkt-Updates und Release-Notes.',
+})

package/templates/apps/changelog/src/locales/en.ts ADDED Viewed

@@ -0,0 +1,30 @@
+// Base catalog — the source of truth. Every other locale (de.ts) mirrors
+// these keys EXACTLY; `defineLocale<typeof en>()` enforces that at `tsc`.
+//
+// CHROME ONLY: the header brand/nav, the footer, the empty state + page meta
+// live here. Release titles / summaries / bodies / dates / tags are CONTENT
+// (the .mdx files under content/releases/) and are NOT translated.
+//
+// `<code>…</code>` in `empty.body` is react-intl rich text — the render site
+// supplies a `code` tag function. Identifiers inside it (`.mdx`,
+// `content/releases/`, `version`, `releasedAt`) are literal, kept in both
+// locales. `{{capProjectName}}` is a scaffold token, only read from `meta`
+// (plain property access, never parsed as ICU) — leave it verbatim.
+import { defineCatalog } from '@voltro/i18n'
+export default defineCatalog({
+  'nav.changelog': 'Changelog',
+  'nav.releases':  'Releases',
+  'nav.rss':       'RSS',
+  'nav.language':  'Language',
+  'footer.builtWith': 'Built with @voltro/changelog',
+  'empty.body':
+    'No releases yet — add an <code>.mdx</code> file under <code>content/releases/</code> with <code>version</code> + <code>releasedAt</code> frontmatter.',
+  'post.backToList': '← All releases',
+  'meta.home.title':       '{{capProjectName}} — Changelog',
+  'meta.home.description': 'Product updates and release notes.',
+} as const)

package/templates/apps/changelog/src/pages/[locale]/[slug].tsx ADDED Viewed

@@ -0,0 +1,24 @@
+// Locale mirror of `/[slug]` → renders `/de/<slug>`. Re-exports the bare
+// release page verbatim; only getStaticPaths differs.
+//
+// This is a DYNAMIC route (`[slug]`) under a DYNAMIC locale segment, so the
+// paths to pre-render are the CROSS-PRODUCT of every non-default locale ×
+// every release slug (the bare page enumerates just the slugs; here each slug
+// is emitted once per non-default locale), e.g. /de/v0-2-0.
+//
+// NOTE: `[locale]` and the bare `[slug]` are both single-segment dynamic
+// routes at the root. `voltro build` only emits the paths getStaticPaths
+// enumerates, so the static output is unambiguous — the bare `[slug]` never
+// enumerates a locale code, and only this mirror emits `/de/…`.
+import { SUPPORTED_LOCALES, DEFAULT_LOCALE } from '../../lib/locale'
+import { releases } from '../../lib/releases'
+export { default } from '../[slug]'
+export { renderMode, interactive, loader, meta } from '../[slug]'
+export const getStaticPaths = async (): Promise<
+  Array<{ params: { locale: string; slug: string } }>
+> =>
+  SUPPORTED_LOCALES
+    .filter((l) => l !== DEFAULT_LOCALE)
+    .flatMap((locale) => releases.map((release) => ({ params: { locale, slug: release.slug } })))

package/templates/apps/changelog/src/pages/[locale]/index.tsx ADDED Viewed

@@ -0,0 +1,13 @@
+// Locale mirror of `/` → renders `/de`. Re-exports the bare index verbatim
+// (it 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 — 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 } }))