@voltro/cli 0.51.0 → 0.53.0

package/templates/apps/{api-versioning → api-row-history}/tests/documents.create.test.ts

@@ -1,6 +1,6 @@
 // Unit test with `@voltro/testing` — no database, no running server. The base
 // `documents.create` mutation is a plain tenant()-scoped insert, so it's fully
-// unit-runnable. The row-HISTORY / as-of reads are populated by the versioning
+// unit-runnable. The row-HISTORY / as-of reads are populated by the row-history
 // plugin's post-commit tap (not wired into the unit store), so those are
 // integration-tested elsewhere; here we cover the write + tenant isolation that
 // every version-1 snapshot is built from. Run with `voltro test` (vitest).

package/templates/apps/api-saas/app.config.ts

@@ -45,6 +45,7 @@ export default {
   // on the zero-infra memory store. To actually STORE + query events, add a
   // sink AND a SQL store (the postgres-lite sink needs a SqlClient):
   //
+  //   pnpm add @voltro/plugin-analytics-postgres
   //   import { postgresAnalytics } from '@voltro/plugin-analytics-postgres'
   //   store: 'postgres' as const,   // or 'sqlite' (file:./.voltro/db.sqlite)
   //   analytics: postgresAnalytics(),   // events → _voltro_events; aggregate/timeseries/topN

package/templates/apps/api-saas/package.json

@@ -13,20 +13,19 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/database": "0.51.0",
-    "@voltro/plugin-analytics-postgres": "0.51.0",
-    "@voltro/plugin-billing": "0.51.0",
-    "@voltro/plugin-multitenancy": "0.51.0",
-    "@voltro/plugin-notifications": "0.51.0",
-    "@voltro/plugin-presence": "0.51.0",
-    "@voltro/protocol": "0.51.0",
-    "@voltro/runtime": "0.51.0",
-    "@voltro/sql-postgres": "0.51.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/database": "0.53.0",
+    "@voltro/plugin-billing": "0.53.0",
+    "@voltro/plugin-multitenancy": "0.53.0",
+    "@voltro/plugin-notifications": "0.53.0",
+    "@voltro/plugin-presence": "0.53.0",
+    "@voltro/protocol": "0.53.0",
+    "@voltro/runtime": "0.53.0",
+    "@voltro/sql-postgres": "0.53.0",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.51.0",
+    "@voltro/testing": "0.53.0",
     "typescript": "^6.0.3",
     "@vitest/coverage-v8": "^4.1.10",
     "vitest": "^4.1.10"

package/templates/apps/api-saas-starter/package.json

@@ -16,19 +16,19 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/database": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/plugin-auth": "0.51.0",
-    "@voltro/plugin-billing": "0.51.0",
-    "@voltro/plugin-multitenancy": "0.51.0",
-    "@voltro/protocol": "0.51.0",
-    "@voltro/runtime": "0.51.0",
-    "@voltro/sql-postgres": "0.51.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/database": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/plugin-auth": "0.53.0",
+    "@voltro/plugin-billing": "0.53.0",
+    "@voltro/plugin-multitenancy": "0.53.0",
+    "@voltro/protocol": "0.53.0",
+    "@voltro/runtime": "0.53.0",
+    "@voltro/sql-postgres": "0.53.0",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.51.0",
+    "@voltro/testing": "0.53.0",
     "typescript": "^6.0.3",
     "@vitest/coverage-v8": "^4.1.10",
     "vitest": "^4.1.10"

package/templates/apps/api-search/package.json

@@ -13,17 +13,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/database": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/plugin-multitenancy": "0.51.0",
-    "@voltro/plugin-search": "0.51.0",
-    "@voltro/protocol": "0.51.0",
-    "@voltro/runtime": "0.51.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/database": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/plugin-multitenancy": "0.53.0",
+    "@voltro/plugin-search": "0.53.0",
+    "@voltro/protocol": "0.53.0",
+    "@voltro/runtime": "0.53.0",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.51.0",
+    "@voltro/testing": "0.53.0",
     "typescript": "^6.0.3",
     "@vitest/coverage-v8": "^4.1.10",
     "vitest": "^4.1.10"

package/templates/apps/api-status/package.json

@@ -13,17 +13,17 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/database": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/plugin-rbac": "0.51.0",
-    "@voltro/protocol": "0.51.0",
-    "@voltro/runtime": "0.51.0",
-    "@voltro/sql-postgres": "0.51.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/database": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/plugin-rbac": "0.53.0",
+    "@voltro/protocol": "0.53.0",
+    "@voltro/runtime": "0.53.0",
+    "@voltro/sql-postgres": "0.53.0",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.51.0",
+    "@voltro/testing": "0.53.0",
     "typescript": "^6.0.3",
     "@vitest/coverage-v8": "^4.1.10",
     "vitest": "^4.1.10"

package/templates/apps/api-webhooks/package.json

@@ -13,18 +13,18 @@
   "dependencies": {
     "@effect/platform": "^0.97.0",
     "@effect/rpc": "^0.76.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/database": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/plugin-multitenancy": "0.51.0",
-    "@voltro/plugin-webhooks": "0.51.0",
-    "@voltro/protocol": "0.51.0",
-    "@voltro/runtime": "0.51.0",
-    "@voltro/sql-postgres": "0.51.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/database": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/plugin-multitenancy": "0.53.0",
+    "@voltro/plugin-webhooks": "0.53.0",
+    "@voltro/protocol": "0.53.0",
+    "@voltro/runtime": "0.53.0",
+    "@voltro/sql-postgres": "0.53.0",
     "effect": "^3.22.0"
   },
   "devDependencies": {
-    "@voltro/testing": "0.51.0",
+    "@voltro/testing": "0.53.0",
     "typescript": "^6.0.3",
     "@vitest/coverage-v8": "^4.1.10",
     "vitest": "^4.1.10"

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

@@ -1,12 +1,12 @@
 // `port` is allocated by `voltro create-project` / `voltro add-app` from
 // the project's portRange (in project.json).
 import { defineEnv, envVar } from '@voltro/env'
+import { releases, tagsOf, visibleReleases, type ReleaseEntry } from './src/collections/releases.collection'
 
 // 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.
+// the manifest.
 export const env = defineEnv({
   VOLTRO_PUBLIC_SITE_NAME: envVar.string({ access: 'public', default: '{{capProjectName}}' }),
 })
@@ -24,4 +24,28 @@ export default {
   locales:       ['en', 'de'] as const,
   defaultLocale: 'en'         as const,
   env,
+  // The RSS feed is a BUILD ARTIFACT (dist/rss.xml, next to sitemap.xml) and
+  // a live dev route — built from the releases collection by the framework.
+  // Set SITE_URL in your deploy env; feed links must be absolute.
+  seo: {
+    siteUrl: process.env['SITE_URL'] ?? 'http://localhost:{{port}}',
+  },
+  feeds: [
+    {
+      path: '/rss.xml',
+      collection: releases.name,
+      title: '{{capProjectName}} Changelog',
+      description: 'Product updates and release notes.',
+      item: (entry: ReleaseEntry) =>
+        visibleReleases([entry]).length === 0
+          ? null
+          : {
+              title: entry.data.title,
+              link: `/${entry.slug}`,
+              date: entry.data.releasedAt,
+              description: entry.data.summary,
+              categories: tagsOf(entry.data),
+            },
+    },
+  ],
 }

package/templates/apps/changelog/content/releases/{0.1.0.mdx → v0-1-0.mdx}

@@ -1,7 +1,6 @@
 ---
 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]

package/templates/apps/changelog/content/releases/{0.2.0.mdx → v0-2-0.mdx}

@@ -1,7 +1,6 @@
 ---
 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]

package/templates/apps/changelog/package.json

@@ -6,25 +6,25 @@
   "scripts": {
     "dev": "voltro dev .",
     "lint": "voltro doctor .",
-    "build": "tsx scripts/generate-rss.mjs && voltro build .",
+    "build": "voltro build .",
     "start": "voltro start .",
     "typecheck": "tsc --noEmit",
     "test": "voltro test"
   },
   "dependencies": {
-    "@voltro/changelog": "0.51.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/client": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/i18n": "0.51.0",
-    "@voltro/web": "0.51.0",
+    "@voltro/content": "0.53.0",
+    "effect": "^3.22.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/client": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/i18n": "0.53.0",
+    "@voltro/web": "0.53.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",
     "jsdom": "^30.0.0",
     "typescript": "^6.0.3",
     "@vitest/coverage-v8": "^4.1.10",

package/templates/apps/changelog/src/collections/releases.collection.ts

@@ -0,0 +1,48 @@
+// The release notes as a CONTENT COLLECTION — content/releases/*.mdx through
+// the framework's content pipeline (@voltro/content). Frontmatter is
+// schema-checked at build time (a violation FAILS the build naming the file);
+// bodies render to HTML with shiki-highlighted code fences on the server.
+// The `.mdx` extension is a NAMING convention for release-note files — the
+// body is plain markdown, not evaluated MDX.
+//
+// `draft: true` entries and future-dated `releasedAt` values are filtered by
+// the pages + the RSS feed (see visibleReleases / app.config.ts feeds) — so
+// an upcoming release can sit staged in content/releases/ without leaking.
+
+import { Schema } from 'effect'
+import { defineCollection, type ContentEntry } from '@voltro/content'
+
+export const releases = defineCollection({
+  name: 'releases',
+  directory: 'content/releases',
+  schema: Schema.Struct({
+    version: Schema.String,
+    /** ISO date/datetime — ordering + the future-dated staging filter. */
+    releasedAt: Schema.String,
+    title: Schema.String,
+    summary: Schema.String,
+    /** `[feature, fix]`-style inline list in the frontmatter. */
+    tags: Schema.optional(Schema.Union(Schema.Array(Schema.String), Schema.String)),
+    /** `draft: true` keeps the entry out of the list + feed. */
+    draft: Schema.optional(Schema.String),
+  }),
+})
+
+export type ReleaseData = Schema.Schema.Type<typeof releases.schema>
+export type ReleaseEntry = ContentEntry<ReleaseData>
+
+/** The tags as a plain list (a single-tag frontmatter parses as a string). */
+export const tagsOf = (r: ReleaseData): ReadonlyArray<string> =>
+  Array.isArray(r.tags) ? r.tags : typeof r.tags === 'string' && r.tags !== '' ? [r.tags] : []
+
+/** Published releases, newest first — drafts and future-dated entries are
+ *  excluded (staged-but-hidden until the date arrives). */
+export const visibleReleases = (
+  entries: ReadonlyArray<ReleaseEntry>,
+  now: Date = new Date(),
+): ReadonlyArray<ReleaseEntry> => {
+  const nowIso = now.toISOString()
+  return [...entries]
+    .filter((e) => e.data.draft !== 'true' && e.data.releasedAt <= nowIso)
+    .sort((a, b) => b.data.releasedAt.localeCompare(a.data.releasedAt))
+}

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

@@ -5,7 +5,7 @@
 // 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)
+// Minimal typing for Vite's `import.meta.glob`
 // so the app typechecks without depending on `vite/client` types being
 // resolvable. Vite provides the real implementation at build time.
 interface ImportMeta {

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

@@ -10,7 +10,7 @@ export default defineLocale<typeof en>()({
   'nav.rss':       'RSS',
   'nav.language':  'Sprache',
 
-  'footer.builtWith': 'Gebaut mit @voltro/changelog',
+  'footer.builtWith': 'Gebaut mit Voltro Content Collections',
 
   '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.',

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

@@ -18,7 +18,7 @@ export default defineCatalog({
   'nav.rss':       'RSS',
   'nav.language':  'Language',
 
-  'footer.builtWith': 'Built with @voltro/changelog',
+  'footer.builtWith': 'Built with Voltro content collections',
 
   'empty.body':
     'No releases yet — add an <code>.mdx</code> file under <code>content/releases/</code> with <code>version</code> + <code>releasedAt</code> frontmatter.',

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

@@ -10,15 +10,18 @@
 // 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 { getCollection } from '@voltro/content'
 import { SUPPORTED_LOCALES, DEFAULT_LOCALE } from '../../../lib/locale'
-import { releases } from '../../../lib/releases'
+import { releases, visibleReleases, type ReleaseData } from '../../../collections/releases.collection'
 
 export { default } from '../../[slug]/page'
 export { renderMode, interactive, loader, meta } from '../../[slug]/page'
 
 export const getStaticPaths = async (): Promise<
   Array<{ params: { locale: string; slug: string } }>
-> =>
-  SUPPORTED_LOCALES
+> => {
+  const entries = visibleReleases(await getCollection<ReleaseData>(releases.name))
+  return SUPPORTED_LOCALES
     .filter((l) => l !== DEFAULT_LOCALE)
-    .flatMap((locale) => releases.map((release) => ({ params: { locale, slug: release.slug } })))
+    .flatMap((locale) => entries.map((release) => ({ params: { locale, slug: release.slug } })))
+}

package/templates/apps/changelog/src/pages/[locale]/mirrors.test.tsx

@@ -7,48 +7,16 @@
 // locales × release slugs (here: de × every release).
 
 import { describe, expect, test, vi } from 'vitest'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { setContentRoot } from '@voltro/content'
 
-interface Release {
-  version: string
-  releasedAt: string
-  slug: string
-  tags: ReadonlyArray<string>
-  title: string
-  summary: string
-  html: string
-}
+// The mirrors' getStaticPaths read the REAL `releases` content collection —
+// this app's content/releases/*.mdx.
+setContentRoot(join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..'))
 
-const releases: ReadonlyArray<Release> = [
-  {
-    version: '0.2.0',
-    releasedAt: '2026-06-21',
-    slug: 'v0-2-0',
-    tags: ['feature'],
-    title: 'Typed env',
-    summary: 'Declare your environment once.',
-    html: '<p>body</p>',
-  },
-  {
-    version: '0.1.0',
-    releasedAt: '2026-01-15',
-    slug: 'v0-1-0',
-    tags: ['feature'],
-    title: 'First release',
-    summary: 'The initial cut.',
-    html: '<p>body</p>',
-  },
-]
-
-// The real release source reads .mdx via `import.meta.glob` + node-gated shiki;
-// mock it (used by the [slug] mirror's cross-product getStaticPaths and by the
-// transitively-imported base pages).
-const releaseBySlug = (slug: string): Release | undefined => releases.find((r) => r.slug === slug)
-vi.mock('../../lib/releases', () => ({ releases, releaseBySlug }))
-vi.mock('@voltro/changelog', () => ({
-  highlightRelease: async (r: Release) => r,
-}))
 vi.mock('@voltro/web', () => ({
-  useLoaderData: () => ({ release: releases[0] }),
+  useLoaderData: () => null,
   notFound: (detail?: string) => {
     throw new Error(detail)
   },
@@ -81,9 +49,13 @@ describe('index mirror — getStaticPaths', () => {
 })
 
 describe('release mirror — getStaticPaths (locale × slug cross-product)', () => {
-  test('emits one path per non-default locale × release slug', async () => {
+  test('emits one path per non-default locale × published release slug', async () => {
     const paths = await releaseMirror.getStaticPaths()
-    expect(paths).toEqual(releases.map((r) => ({ params: { locale: 'de', slug: r.slug } })))
+    // Newest first, from the real collection.
+    expect(paths).toEqual([
+      { params: { locale: 'de', slug: 'v0-2-0' } },
+      { params: { locale: 'de', slug: 'v0-1-0' } },
+    ])
   })
 
   test('re-exports the base release page + its config exports', () => {

package/templates/apps/changelog/src/pages/[slug]/page.test.tsx

@@ -1,51 +1,22 @@
 // @vitest-environment jsdom
 //
-// `/[slug]` per-release page — `getStaticPaths` (one path per release),
-// `loader` (look up the release, shiki-highlight it, `notFound()` on a miss),
-// `meta(loaderData)`, and the render (which injects the highlighted HTML). We
-// mock `../lib/releases` (avoids the node-only glob) and `@voltro/changelog`
-// (`highlightRelease` pulls in shiki) and `@voltro/web` (`notFound`).
+// `/[slug]` per-release page — `getStaticPaths` (one path per published
+// release), `loader` (entry lookup through the REAL `releases` content
+// collection, `notFound()` on a miss), `meta(loaderData)`, and the render
+// (which injects the collection's server-rendered HTML). The collection reads
+// this app's real content/releases/*.mdx — no canned copies to drift.
 
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 import { act, createElement, type ReactNode } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
-// Type-only import — erased at runtime, so it does NOT pull @voltro/changelog's
-// node-only glob (the value module stays mocked below). Using the real Release
-// type keeps the mock in lockstep with the framework's shape (tags: ReleaseTag[],
-// draft, body, …) so the test typechecks against what the page actually consumes.
-import type { Release } from '@voltro/changelog'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { setContentRoot } from '@voltro/content'
+import type { ReleaseEntry } from '../../collections/releases.collection'
 
-const releases: ReadonlyArray<Release> = [
-  {
-    version: '0.1.0',
-    releasedAt: '2026-01-15',
-    slug: 'v0-1-0',
-    tags: ['feature'],
-    title: 'First release',
-    summary: 'The initial cut.',
-    draft: false,
-    body: 'The initial cut.',
-    html: '<p>plain</p>',
-  },
-]
-
-const releaseBySlug = (slug: string): Release | undefined => releases.find((r) => r.slug === slug)
-
-// `../../lib/releases` — the path the PAGE imports. This read `../lib/releases`,
-// which from `src/pages/[slug]/` resolves to `src/pages/lib/releases`: a module
-// that does not exist, so the mock registered against nothing and the REAL
-// `src/lib/releases.ts` loaded. A wrong `vi.mock` specifier is silent in vitest
-// — it fails later and elsewhere, here as "No `loadReleases` export is defined
-// on the `@voltro/changelog` mock", because the real module calls it at import
-// time. The sibling `[locale]/mirrors.test.tsx`, at the same depth, had it right.
-vi.mock('../../lib/releases', () => ({ releases, releaseBySlug }))
-// `highlightRelease` runs shiki in node; the page only needs it to return a
-// (possibly re-rendered) release — the identity, tagged so we can assert it ran.
-vi.mock('@voltro/changelog', () => ({
-  highlightRelease: async (r: Release) => ({ ...r, html: `<pre>${r.title}</pre>` }),
-}))
+setContentRoot(join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..'))
 
-const loaderData = vi.fn<() => { release: Release }>()
+const loaderData = vi.fn<() => { release: ReleaseEntry }>()
 class NotFoundError extends Error {}
 vi.mock('@voltro/web', () => ({
   useLoaderData: () => loaderData(),
@@ -95,17 +66,19 @@ afterEach(() => {
 })
 
 describe('changelog [slug] — getStaticPaths', () => {
-  test('enumerates one path per release slug', async () => {
+  test('enumerates one path per published release slug, newest first', async () => {
     const paths = await getStaticPaths()
-    expect(paths.map((p) => p.params.slug)).toEqual(['v0-1-0'])
+    expect(paths.map((p) => p.params.slug)).toEqual(['v0-2-0', 'v0-1-0'])
   })
 })
 
 describe('changelog [slug] — loader', () => {
-  test('resolves the release and runs it through highlightRelease', async () => {
+  test('resolves the release with server-rendered, highlighted html', async () => {
     const { release } = await loader({ params: { slug: 'v0-1-0' } } as never)
     expect(release.slug).toBe('v0-1-0')
-    expect(release.html).toBe('<pre>First release</pre>')
+    expect(release.data.version).toBe('0.1.0')
+    // The collection renders code fences with shiki on the server.
+    expect(release.html).toContain('class="shiki')
   })
 
   test('throws notFound for an unknown slug', async () => {
@@ -116,18 +89,20 @@ describe('changelog [slug] — loader', () => {
 })
 
 describe('changelog [slug] — meta', () => {
-  test('builds the per-release title + description from the loader data', () => {
-    const m = meta({ loaderData: { release: releases[0]! } })
-    expect(m.title).toContain('First release')
-    expect(m.description).toBe('The initial cut.')
+  test('builds the per-release title + description from the loader data', async () => {
+    const { release } = await loader({ params: { slug: 'v0-1-0' } } as never)
+    const m = meta({ loaderData: { release } })
+    expect(m.title).toContain(release.data.title)
+    expect(m.description).toBe(release.data.summary)
   })
 })
 
 describe('changelog [slug] — render', () => {
-  test('renders the title, version, and injects the highlighted HTML body', () => {
-    loaderData.mockReturnValue({ release: { ...releases[0]!, html: '<p>the body html</p>' } })
+  test('renders the title, version, tags, and injects the HTML body', async () => {
+    const { release } = await loader({ params: { slug: 'v0-1-0' } } as never)
+    loaderData.mockReturnValue({ release: { ...release, html: '<p>the body html</p>' } })
     render(createElement(ReleasePage))
-    expect(container.querySelector('h1')?.textContent).toBe('First release')
+    expect(container.querySelector('h1')?.textContent).toBe(release.data.title)
     expect(container.textContent).toContain('v0.1.0')
     expect(container.innerHTML).toContain('the body html')
   })

package/templates/apps/changelog/src/pages/[slug]/page.tsx

@@ -1,34 +1,36 @@
-// Per-release page. `getStaticPaths` enumerates every release slug so
-// `voltro build` pre-renders one HTML file per release. The loader runs at
-// build time (Node) where `highlightRelease` shiki-highlights the code
-// fences; in the browser it's a no-op and the plain marked HTML is used.
+// Per-release page. `getStaticPaths` enumerates every published release slug
+// so `voltro build` pre-renders one HTML file per release. The loader reads
+// the entry from the `releases` collection — the body arrives as RENDERED
+// html with shiki-highlighted code fences (server-side; no markdown engine
+// in the browser).
 
 import type { ReactNode } from 'react'
 import { useLoaderData, notFound, type LoaderFn } from '@voltro/web'
-import { highlightRelease } from '@voltro/changelog'
+import { getCollection, getEntry } from '@voltro/content'
 import { T, useLocale } from '@voltro/i18n'
-import { releases, releaseBySlug, type Release } from '../../lib/releases'
+import { releases, tagsOf, visibleReleases, type ReleaseData, type ReleaseEntry } from '../../collections/releases.collection'
 import { withLocalePrefix } from '../../lib/locale'
 
 export const renderMode = 'static' as const
 export const interactive = 'none' as const
 
 export const getStaticPaths = async (): Promise<Array<{ params: { slug: string } }>> =>
-  releases.map((release) => ({ params: { slug: release.slug } }))
+  visibleReleases(await getCollection<ReleaseData>(releases.name))
+    .map((release) => ({ params: { slug: release.slug } }))
 
-export const loader: LoaderFn<{ release: Release }> = async ({ params }) => {
-  const release = params.slug ? releaseBySlug(params.slug) : undefined
-  if (!release) return notFound(`release ${params.slug ?? ''}`)
-  return { release: await highlightRelease(release) }
+export const loader: LoaderFn<{ release: ReleaseEntry }> = async ({ params }) => {
+  const release = params.slug ? await getEntry<ReleaseData>(releases.name, params.slug) : null
+  if (!release || release.data.draft === 'true') return notFound(`release ${params.slug ?? ''}`)
+  return { release }
 }
 
-export const meta = ({ loaderData }: { loaderData: { release: Release } }) => ({
-  title: `${loaderData.release.title} — Changelog`,
-  description: loaderData.release.summary,
+export const meta = ({ loaderData }: { loaderData: { release: ReleaseEntry } }) => ({
+  title: `${loaderData.release.data.title} — Changelog`,
+  description: loaderData.release.data.summary,
 })
 
 export default function ReleasePage(): ReactNode {
-  const { release } = useLoaderData<{ release: Release }>()
+  const { release } = useLoaderData<{ release: ReleaseEntry }>()
   // The active locale (from the layout's URL provider) keeps the back-link on
   // the current language.
   const locale = useLocale()
@@ -39,14 +41,14 @@ export default function ReleasePage(): ReactNode {
           <T id="post.backToList" />
         </a>
       </p>
-      <h1>{release.title}</h1>
+      <h1>{release.data.title}</h1>
       <p className="changelog-meta">
-        <time dateTime={release.releasedAt}>{release.releasedAt}</time> · v{release.version}
-        {release.tags.map((tag) => (
+        <time dateTime={release.data.releasedAt}>{release.data.releasedAt}</time> · v{release.data.version}
+        {tagsOf(release.data).map((tag) => (
           <span key={tag} className="changelog-tag">{tag}</span>
         ))}
       </p>
-      <div dangerouslySetInnerHTML={{ __html: release.html }} />
+      <div dangerouslySetInnerHTML={{ __html: release.html ?? '' }} />
     </article>
   )
 }