@michaelthielemann/kestrel 1.2.1

package/layers/public/modules/prune-media/prune-media.ts

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+
+function escapeRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+// Prefix-relative keys referenced in `text`. The charset stops at ?/#/quote/space, so query strings,
+// fragments and srcset descriptors (320w, 2x) fall outside the key; the leading `/` keeps `/uploads` from
+// matching `/myuploads`.
+export function referencedKeys(text: string, prefix: string): Set<string> {
+  const out = new Set<string>()
+  const re = new RegExp(`${escapeRe(prefix)}/([A-Za-z0-9._/-]+)`, 'g')
+  for (const m of text.matchAll(re)) out.add(m[1])
+  return out
+}
+
+// The prunable candidates: unreferenced files that the media library OWNS. When `ownedKeys` is given, a
+// file not in it (gallery ciphertext / index, or any consumer blob written via useStorageDriver) is NEVER
+// a candidate — those are baked deliberately and their URLs are built at runtime, so they never appear as
+// literal keys in the output. Without `ownedKeys` the legacy "prune any unreferenced key" behaviour holds.
+export function planMediaPrune(files: string[], referenced: Set<string>, ownedKeys?: Set<string>): string[] {
+  return files.filter((f) => !referenced.has(f) && (!ownedKeys || ownedKeys.has(f)))
+}
+
+// The storage keys the media library owns: every original + every derivative object it tracks. Used to
+// scope the bake prune so it can only ever delete media-library artifacts, never extension/consumer blobs.
+export function mediaOwnedKeys(rows: { storageKey?: string | null; derivatives?: Record<string, { key?: string }> | null }[]): Set<string> {
+  const out = new Set<string>()
+  for (const r of rows) {
+    if (r.storageKey) out.add(r.storageKey)
+    for (const e of Object.values(r.derivatives ?? {})) if (e?.key) out.add(e.key)
+  }
+  return out
+}
+
+function walkFiles(dir: string): string[] {
+  return readdirSync(dir, { recursive: true, withFileTypes: true })
+    .filter((e) => e.isFile())
+    .map((e) => join(e.parentPath, e.name))
+}
+
+export interface PruneResult {
+  kept: number
+  pruned: number
+}
+
+export interface PruneOptions {
+  /** Report what would be deleted without touching the filesystem. */
+  dryRun?: boolean
+  /** Restrict deletion to these media-library-owned keys; anything else baked under the root is kept. */
+  ownedKeys?: Set<string>
+  log?: (msg: string) => void
+}
+
+// Delete every baked upload under `publicDir/<baseUrl>` that no generated .html/.css/.json references.
+// Over-scanning those files is keep-on-doubt (a key seen anywhere is kept). No-op when the dir is absent
+// (S3 media / nothing baked). Touches only the bake — the library upload dir is elsewhere.
+export function pruneUnreferencedMedia(publicDir: string, baseUrl: string, opts: PruneOptions = {}): PruneResult {
+  const prefix = baseUrl.replace(/\/+$/, '')
+  if (!prefix) return { kept: 0, pruned: 0 } // an empty baseUrl would target the whole output — refuse
+  const uploadsDir = join(publicDir, prefix)
+  if (!existsSync(uploadsDir)) return { kept: 0, pruned: 0 }
+
+  const referenced = new Set<string>()
+  for (const abs of walkFiles(publicDir)) {
+    // Also scan JS chunks: a media URL can be emitted only from client JS (a background image, a config
+    // object), never as literal HTML/CSS — pruning it would 404 the live reference.
+    if (!/\.(?:html|css|json|m?js)$/i.test(abs)) continue
+    for (const k of referencedKeys(readFileSync(abs, 'utf8'), prefix)) referenced.add(k)
+  }
+
+  const files = walkFiles(uploadsDir).map((abs) => ({ abs, key: relative(uploadsDir, abs).split(sep).join('/') }))
+  const prune = new Set(planMediaPrune(files.map((f) => f.key), referenced, opts.ownedKeys))
+  const toDelete = files.filter((f) => prune.has(f.key))
+  if (!opts.dryRun) for (const f of toDelete) rmSync(f.abs, { force: true })
+
+  const kept = files.length - toDelete.length
+  opts.log?.(`media prune${opts.dryRun ? ' (dry-run)' : ''}: kept ${kept}, ${opts.dryRun ? 'would prune' : 'pruned'} ${toDelete.length} unreferenced file(s)`)
+  return { kept, pruned: toDelete.length }
+}

package/layers/public/nuxt.config.ts

@@ -0,0 +1,11 @@
+import { fileURLToPath } from 'node:url'
+
+export default defineNuxtConfig({
+  modules: [
+    fileURLToPath(new URL('./modules/prerender-routes/index.ts', import.meta.url)),
+    fileURLToPath(new URL('./modules/prune-media/index.ts', import.meta.url)),
+    // AFTER prune-media so the bake is pruned before it ships. Self-gates to output.driver:'s3' + a real
+    // `nuxt generate`; a no-op otherwise. Without it, output.driver:'s3' + output.auto:false shipped nothing.
+    fileURLToPath(new URL('./modules/deploy-output/index.ts', import.meta.url)),
+  ],
+})

package/layers/public/server/api/links/resolve.get.ts

@@ -0,0 +1,19 @@
+import { resolveInternalHref } from '../../utils/link-resolve'
+
+// Batch-resolve internal link refs (`?refs=collection:id,collection:id`) to public hrefs for the admin
+// block preview. Mirrors the read-path populator, status gate included; only resolved refs are returned,
+// so the client renders '#' for a target that is missing or still a draft — same as the generated site.
+export default defineEventHandler((event) => {
+  const refs = String(getQuery(event).refs ?? '').split(',').map((s) => s.trim()).filter(Boolean)
+  const data: { collection: string; id: number; href: string }[] = []
+  for (const ref of refs) {
+    const sep = ref.lastIndexOf(':')
+    if (sep <= 0) continue
+    const collection = ref.slice(0, sep)
+    const id = Number(ref.slice(sep + 1))
+    if (!Number.isInteger(id) || id <= 0) continue
+    const href = resolveInternalHref(collection, id)
+    if (href != null) data.push({ collection, id, href })
+  }
+  return { data }
+})

package/layers/public/server/api/publish-status.get.ts

@@ -0,0 +1,44 @@
+import { eq, getTableColumns } from 'drizzle-orm'
+import type { AnySQLiteTable } from 'drizzle-orm/sqlite-core'
+import { publishStatus } from '../database/publish-status'
+import { routeForRecord } from '../utils/publish/route-for-record'
+
+/**
+ * Admin-only read of the LIVE publish state of a record's static page (`?collection=&id=`). Admin-only by
+ * construction: `/api/*` is default-deny for anonymous and `publish-status` is not a public pageLike
+ * resource, so the access guard rejects an unauthenticated request before this runs. Resolves the record's
+ * route, then looks up its `publish_status` row. Returns `{ route, status }` (+ error/updatedAt on a row),
+ * or `{ route: null, status: null }` when the record has no route (non-pageLike / blank slug / missing),
+ * or `{ route, status: null }` when there is no status row yet (never published — dev, a draft, or a
+ * republish still in flight). The editor's live-ampel reads this and refetches after each save.
+ */
+export default defineEventHandler((event) => {
+  // Environment-level facts the right lamp needs beyond the per-route row: where the NEXT publish would go
+  // (`driver`) and whether the runtime publisher actually produces files HERE (prod + `output.auto`). In dev
+  // (or with auto off) nothing is ever generated, so the lamp shows a calm "Not built" instead of a stuck
+  // "Generating". Read straight from runtimeConfig — no need to pull in the whole publisher module.
+  const output = (useRuntimeConfig().kestrel as { output?: { driver?: 'local' | 's3'; auto?: boolean } }).output
+  const env = { driver: (output?.driver ?? 'local') as 'local' | 's3', generates: !import.meta.dev && !!output?.auto }
+
+  const q = getQuery(event)
+  const name = typeof q.collection === 'string' ? q.collection : ''
+  const id = Number(typeof q.id === 'string' ? q.id : NaN)
+  const c = getCollection(name)
+  if (!c || !c.def.pageLike || !Number.isInteger(id) || id <= 0) return { route: null, status: null, ...env }
+
+  const db = useDb()
+  const table = c.table as AnySQLiteTable
+  const cols = getTableColumns(table) as Record<string, never>
+  const row = db.select().from(table).where(eq(cols.id, id)).get() as { path?: unknown; locale?: unknown } | undefined
+  const route = routeForRecord(row, true, primaryLocale(), prefixPrimaryLocale())
+  if (!route) return { route: null, status: null, ...env }
+
+  try {
+    const st = db.select().from(publishStatus).where(eq(publishStatus.route, route)).get()
+    if (!st) return { route, status: null, ...env }
+    return { route, status: st.status, error: st.error, updatedAt: st.updatedAt, target: st.target, ...env }
+  } catch {
+    // publish_status not migrated yet → treat as "no status" rather than a 500.
+    return { route, status: null, ...env }
+  }
+})

package/layers/public/server/api/route.get.ts

@@ -0,0 +1,18 @@
+import { resolvePage } from '../utils/page-resolve'
+
+// Resolves a public path to the first matching page-like record across ALL pageLike collections (the
+// generic render entry point). Published-only EXCEPT for an authenticated admin's live preview:
+//   - a static render (build prerender OR the runtime publisher) is always published-only, so a draft
+//     never reaches the static site (the renderer principal is itself published-only at the policy
+//     level; this explicit `isStaticRender` clause is belt-and-suspenders defense-in-depth);
+//   - an anonymous live request carries readScope 'published';
+//   - an authenticated admin carries readScope 'all', so a draft renders at its real URL (the preview).
+export default defineEventHandler((event) => {
+  const q = getQuery(event)
+  const path = typeof q.path === 'string' && q.path ? q.path : '/'
+  const locale = typeof q.locale === 'string' ? q.locale : undefined
+  const isStaticRender = import.meta.prerender === true || isRendererContext()
+  const publishedOnly = isStaticRender || event.context.readScope !== 'all'
+  const resolved = resolvePage(useDb(), allCollections(), path, locale, publishedOnly)
+  return { collection: resolved?.collection ?? null, page: resolved?.page ?? null, alternates: resolved?.alternates ?? [] }
+})

package/layers/public/server/database/publish-deps.ts

@@ -0,0 +1,12 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+// Durable `route -> data tags` index backing the runtime publisher's DepsStore. Persists what each
+// published route read while rendering (its `<coll>` / `<coll>:<id>` tags) so a write maps back to exactly
+// the routes that embed that data, AND so a boot full-publish can prune routes that left the published set
+// while the server was down. `route` is the natural primary key; `tags` is the JSON-encoded tag set.
+// Hand-authored system table (not a collection) — registered in the desired schema via bootstrap.ts +
+// re-exported from collections/schema.ts, mirroring `folders`.
+export const publishDeps = sqliteTable('publish_deps', {
+  route: text('route').primaryKey(),
+  tags: text('tags').notNull(),
+})

package/layers/public/server/database/publish-status.ts

@@ -0,0 +1,19 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
+
+// Durable per-route record of the LAST static-publish outcome: did this route's file get written to the
+// output target (local dir or S3) successfully, or did the last attempt error? `route` is the natural
+// primary key (one latest-state row per route — not a history). The runtime publisher upserts a `success`
+// row after each render+put and an `error` row (with the failure message, incl. S3) when one throws; a
+// prune (unpublish / delete / slug change) clears the row so the route reads as "not live". The admin
+// editor's live-ampel reads it through `/api/publish-status` to show whether THIS record's page is live.
+// `updatedAt` via `$defaultFn` (no SQL default → it won't perpetually diff as a rebuild; UNIX seconds via
+// `mode:'timestamp'`, matching every other table). Hand-authored system table (not a collection) —
+// registered in the desired schema via bootstrap.ts + re-exported from collections/schema.ts, mirroring
+// `publish_deps` / `record_refs` / `folders`.
+export const publishStatus = sqliteTable('publish_status', {
+  route: text('route').primaryKey(),
+  status: text('status').notNull(), // 'success' | 'error'
+  error: text('error'), // nullable — the failure message (render / write / S3) on an 'error' row
+  target: text('target').notNull(), // 'local' | 's3' — which output the attempt wrote to
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+})

package/layers/public/server/plugins/02.register-links.ts

@@ -0,0 +1,17 @@
+import { registerFieldPopulator } from '../../../core/server/utils/populate'
+import { buildLinkFieldPopulators } from '../utils/populate-links'
+import { resolveInternalHref } from '../utils/link-resolve'
+
+// Resolve internal links to the target record's localized public path at read time (page-like targets;
+// external/email/tel pass through). NOTE: the resolver does NOT status-gate the target — a link to a DRAFT
+// emits the draft's real (not-yet-generated) path, disclosing its slug and shipping a 404 until publish. This
+// is deliberate: it keeps links stable without re-rendering every referrer when a target's status flips, and
+// the editor warns about draft/dead links instead. (See link-resolve.ts for the rationale.)
+//
+// Registered as `link` + `richtext` per-type populators; the shared field-tree walker dispatches them over
+// top-level fields, block props, slots, and repeater entries.
+export default defineNitroPlugin(() => {
+  const { link, richtext } = buildLinkFieldPopulators(resolveInternalHref)
+  registerFieldPopulator('link', link)
+  registerFieldPopulator('richtext', richtext)
+})

package/layers/public/server/plugins/zz.publish.ts

@@ -0,0 +1,63 @@
+import { createPublishQueue } from '../utils/publish/queue'
+import { DepsStore } from '../utils/publish/deps'
+import { createSqlitePersistence } from '../utils/publish/deps-persistence'
+import { outputDriver, publishInvalidation } from '../utils/publish/publisher'
+import { classifyWrite, planInvalidation } from '../utils/publish/invalidation'
+import { registerWriteListener } from '../../../core/server/utils/write-events'
+
+/**
+ * The in-server publish runtime (the production operation model). Wires three things, gated on
+ * `output.auto` and skipped in dev (a dev publish would write Vite-dev HTML without hashed `_nuxt`):
+ *
+ *  1. AUTO-TRIGGER — every content write classifies into an invalidation and enqueues an incremental
+ *     republish (a debounced/coalesced/single-flight queue; precise routes via the captured deps index).
+ *  2. BOOT PUBLISH — a full publish on startup resyncs this build's `_nuxt` + records every route's deps.
+ *     DETACHED (`runNitroPlugins` is synchronous + unawaited; `localFetch` is already wired before plugins
+ *     run + before the server listens), so it never blocks boot.
+ *  3. RECONCILER — an optional periodic full publish (`output.reconcileMinutes`) self-heals any missed
+ *     invalidation and picks up time-based `publishDate` publishing that no write event would trigger.
+ */
+export default defineNitroPlugin(() => {
+  if (import.meta.dev) return
+  const output = (useRuntimeConfig().kestrel as { output?: { auto?: boolean; reconcileMinutes?: number; verbose?: boolean } }).output
+  if (!output?.auto) return
+
+  // `output.verbose`: on top of the one-line summary, itemise each incremental republish with a
+  // timestamped per-route line (rendered / pruned) for traceability. Off by default. (A queued FULL run
+  // — boot / reconciler — is a bulk resync and stays a summary; publishInvalidation returns no per-route
+  // list for it.)
+  const verbose = output.verbose ?? false
+  const stamp = () => new Date().toISOString()
+
+  const driver = outputDriver()
+  // Durable deps: rehydrate `route → tags` from SQLite so the boot full-publish below can prune routes
+  // that were unpublished/deleted while the server was down (staleRoutes over a non-empty tracked set).
+  const deps = new DepsStore(createSqlitePersistence(useDb()))
+  const queue = createPublishQueue({
+    run: async (inv) => {
+      const { rendered, pruned, counts } = await publishInvalidation(inv, driver, deps)
+      if (counts.rendered === 0 && counts.pruned === 0) return
+      // Incremental runs name the routes; a queued full run (the reconciler) prints counts only.
+      const list = rendered.length ? `: ${rendered.join(', ')}` : ''
+      console.info(`[kestrel] published ${counts.rendered} route(s)${list} (pruned ${counts.pruned})`)
+      if (verbose) {
+        for (const route of rendered) console.info(`[kestrel] ${stamp()} rendered ${route}`)
+        for (const route of pruned) console.info(`[kestrel] ${stamp()} pruned ${route}`)
+      }
+    },
+    onError: (error) => console.error('[kestrel] publish run failed:', error),
+  })
+
+  registerWriteListener(({ def, before, after }) => {
+    queue.enqueue(planInvalidation(classifyWrite(def, before, after, primaryLocale(), prefixPrimaryLocale())))
+  })
+
+  // Boot publish goes THROUGH the queue (not a direct publishFull) so it shares the single-flight guard:
+  // otherwise a boot full-publish could overlap a write-triggered incremental or the reconciler, and both
+  // runs share the module-level variant accumulator (corrupting the registry) and can interleave
+  // render/prune (leaving an unpublished page live). The queue serializes them.
+  queue.enqueue({ type: 'full' })
+
+  const mins = output.reconcileMinutes ?? 0
+  if (mins > 0) setInterval(() => queue.enqueue({ type: 'full' }), mins * 60_000).unref?.()
+})

package/layers/public/server/routes/llms.txt.get.ts

@@ -0,0 +1,72 @@
+import { getTableColumns } from 'drizzle-orm'
+import { localePath } from '../../../core/app/utils/locale-path'
+import type { LlmsSection, LlmsEntry } from '../utils/llms'
+
+// Generates an `llms.txt` (llmstxt.org): the site name + description, then one section per pageLike
+// collection listing its published, indexable records — the SAME registry-driven public set the sitemap
+// advertises (single source: the auth policy). Safe to serve publicly and to prerender.
+export default defineEventHandler((event) => {
+  const db = useDb()
+  const base = siteBaseUrl()
+  const primary = primaryLocale()
+  const prefixPrimary = prefixPrimaryLocale()
+
+  const cap = (s: string) => (s ? s[0].toUpperCase() + s.slice(1) : s)
+  const headingFor = (def: { name: string; label?: { plural?: unknown } }): string => {
+    const pl = def.label?.plural
+    if (typeof pl === 'string') return pl
+    if (pl && typeof pl === 'object') {
+      const m = pl as Record<string, string>
+      return m[primary] ?? Object.values(m)[0] ?? cap(def.name)
+    }
+    return cap(def.name)
+  }
+
+  const pub = publicReadableResources()
+  const sections: LlmsSection[] = []
+  // Without an absolute origin, every resource URL would be a relative path — omit the page sections (keep
+  // the site name + description) rather than emit a link list that resolves against the wrong host.
+  if (!base) console.warn('[kestrel] llms.txt: siteUrl is unset — omitting page links (they would be relative)')
+  for (const c of base ? allCollections() : []) {
+    if (!c.def.pageLike) continue
+    if (!isPubliclyReadable(c.def.name, pub)) continue
+    // Project ONLY the columns this listing reads — never SELECT *, which would pull every row's
+    // block-content JSON into memory just to emit a link; the runtime publisher re-renders this route on
+    // every incremental publish. Optional columns exist only when the def declares them (buildTable adds no
+    // locale/status/seo column otherwise), and a `cols.<missing>` would be undefined and make the select
+    // throw — gate on the same flags, as the sitemap does. `title` is a plain field, so probe the table.
+    const cols = getTableColumns(c.table) as Record<string, never>
+    const proj: Record<string, unknown> = { path: cols.path }
+    if (c.def.translatable) proj.locale = cols.locale
+    if (c.def.status) proj.status = cols.status
+    if (c.def.seo) proj.seo = cols.seo
+    if (Object.hasOwn(cols, 'title')) proj.title = cols.title
+    let rows: Record<string, unknown>[]
+    try {
+      rows = db.select(proj as never).from(c.table).all() as Record<string, unknown>[]
+    } catch {
+      continue // table not migrated yet (e.g. a bare prerender DB)
+    }
+    const entries: LlmsEntry[] = []
+    for (const row of rows) {
+      if (c.def.status && row.status !== 'published') continue
+      const path = row.path as string | null
+      if (!path) continue
+      const seo = (row.seo ?? {}) as { title?: string; description?: string; noindex?: boolean }
+      if (seo.noindex) continue
+      const locale = (row.locale as string | undefined) ?? primary
+      entries.push({
+        title: seo.title || (row.title as string | undefined) || path,
+        url: base + localePath(path, locale, primary, prefixPrimary),
+        description: seo.description || undefined,
+      })
+    }
+    if (entries.length) {
+      entries.sort((a, b) => a.url.localeCompare(b.url))
+      sections.push({ heading: headingFor(c.def), entries })
+    }
+  }
+
+  setHeader(event, 'content-type', 'text/plain; charset=utf-8')
+  return buildLlmsTxt({ siteName: siteName(), siteDescription: siteDescription() || undefined, sections })
+})

package/layers/public/server/routes/robots.txt.get.ts

@@ -0,0 +1,8 @@
+export default defineEventHandler((event) => {
+  const base = siteBaseUrl()
+  setHeader(event, 'content-type', 'text/plain; charset=utf-8')
+  return buildRobots({
+    sitemapUrl: base ? `${base}/sitemap.xml` : undefined,
+    llmsUrl: base ? `${base}/llms.txt` : undefined,
+  })
+})

package/layers/public/server/routes/sitemap.xml.get.ts

@@ -0,0 +1,66 @@
+import { getTableColumns } from 'drizzle-orm'
+import { localePath } from '../../../core/app/utils/locale-path'
+
+// Lists every published, indexable page-like record (across all pageLike collections) as a
+// sitemap. Filters status/noindex itself, so it is safe to serve publicly and to prerender.
+export default defineEventHandler((event) => {
+  const db = useDb()
+  const base = siteBaseUrl()
+  // Without an absolute origin (kestrel.siteUrl / KESTREL_SITE_URL) every <loc> would be a RELATIVE path,
+  // which the sitemaps.org schema rejects outright — a worse result than an empty sitemap. Emit a valid
+  // empty one + warn, mirroring robots.txt omitting its `Sitemap:` directive when the base is unset.
+  if (!base) {
+    console.warn('[kestrel] sitemap.xml: siteUrl is unset — emitting an empty sitemap (relative <loc> URLs would be invalid)')
+    setHeader(event, 'content-type', 'application/xml; charset=utf-8')
+    return buildSitemap([])
+  }
+  const primary = primaryLocale()
+  const prefixPrimary = prefixPrimaryLocale()
+  const candidates: SitemapCandidate[] = []
+
+  // A sitemap must only advertise publicly-reachable URLs. The public render path (anonymous access
+  // policy, prerender seed, catch-all) now renders every pageLike collection, so the sitemap tracks the
+  // SAME registry-driven public set (single source: the auth policy) rather than diverging from it.
+  const pub = publicReadableResources()
+  for (const c of allCollections()) {
+    if (!c.def.pageLike) continue
+    if (!isPubliclyReadable(c.def.name, pub)) continue
+    // Project ONLY the columns the sitemap reads — never SELECT *, which would pull every row's
+    // block-content JSON (and every other field) into memory just to emit a URL; the runtime publisher
+    // re-renders this route on every incremental publish. Optional columns exist only when the def
+    // declares them (buildTable adds no locale/status/seo column otherwise), and a `cols.<missing>` would
+    // be undefined and make the select throw — gate on the same flags, as allPublishedRoutes does.
+    const cols = getTableColumns(c.table) as Record<string, never>
+    const proj: Record<string, unknown> = { path: cols.path, updatedAt: cols.updatedAt }
+    if (c.def.translatable) proj.locale = cols.locale
+    if (c.def.translatable && c.def.mode !== 'single') proj.translationGroup = cols.translationGroup
+    if (c.def.status) proj.status = cols.status
+    if (c.def.seo) proj.seo = cols.seo
+    let rows: Record<string, unknown>[]
+    try {
+      rows = db.select(proj as never).from(c.table).all() as Record<string, unknown>[]
+    } catch {
+      continue // table not migrated yet (e.g. a bare prerender DB)
+    }
+    for (const row of rows) {
+      if (c.def.status && row.status !== 'published') continue
+      const path = row.path as string | null
+      if (!path) continue
+      const seo = (row.seo ?? {}) as { noindex?: boolean }
+      if (seo.noindex) continue
+      const locale = (row.locale as string | undefined) ?? primary
+      candidates.push({
+        loc: base + localePath(path, locale, primary, prefixPrimary),
+        lastmod: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : undefined,
+        locale,
+        group: (row.translationGroup as string | undefined) ?? null,
+      })
+    }
+  }
+
+  // Link each page's published, indexable locale variants via hreflang alternates before serializing.
+  const entries = withHreflang(candidates, primary)
+  entries.sort((a, b) => a.loc.localeCompare(b.loc))
+  setHeader(event, 'content-type', 'application/xml; charset=utf-8')
+  return buildSitemap(entries)
+})

package/layers/public/server/schema-tables/publish-deps.ts

@@ -0,0 +1,4 @@
+import { publishDeps } from '../database/publish-deps'
+
+// Registers the standalone publish_deps table with the schema engine (the `#kestrel/schema-tables` virtual).
+export default publishDeps

package/layers/public/server/schema-tables/publish-status.ts

@@ -0,0 +1,4 @@
+import { publishStatus } from '../database/publish-status'
+
+// Registers the standalone publish_status table with the schema engine (the `#kestrel/schema-tables` virtual).
+export default publishStatus

package/layers/public/server/tasks/publish/run.ts

@@ -0,0 +1,26 @@
+import { publishFull, outputDriver } from '../../utils/publish/publisher'
+import { DepsStore } from '../../utils/publish/deps'
+import { createSqlitePersistence } from '../../utils/publish/deps-persistence'
+
+/**
+ * The shared publish engine, exposed as a Nitro task. Renders every published page (+ sitemap/robots)
+ * via the live server, mirrors `_nuxt`/assets, and always prunes the routes that left the published set
+ * (output ≡ DB).
+ *
+ * Triggering (Nuxt 4.4 / Nitro 2.13 — there is NO `nuxi task run`):
+ *   - dev:  GET http://localhost:3000/_nitro/tasks/publish:run   (the dev-only task route; plumbing smoke test)
+ *   - prod: the boot-publish plugin (`zz.publish.ts`) runs this on startup; for an on-demand prod trigger,
+ *           expose your own authenticated route that calls `runTask('publish:run')` (the built node-server
+ *           has no task endpoint/CLI — only `runTask()` from inside the process + cron `scheduledTasks`).
+ */
+export default defineTask({
+  meta: { name: 'publish:run', description: 'Render all published pages to the configured static output (HTML + _nuxt + assets)' },
+  async run() {
+    // The same durable store the boot-publish plugin uses, so a manually-triggered run also prunes
+    // routes that left the published set and records deps for later incremental publishes.
+    const deps = new DepsStore(createSqlitePersistence(useDb()))
+    const result = await publishFull(outputDriver(), deps)
+    console.info(`[kestrel] publish:run rendered ${result.rendered} route(s), pruned ${result.pruned}`)
+    return { result }
+  },
+})

package/layers/public/server/utils/link-resolve.ts

@@ -0,0 +1,35 @@
+import { eq, getTableColumns } from 'drizzle-orm'
+import { getCollection } from '../../../core/server/utils/registry'
+import { primaryLocale, prefixPrimaryLocale } from '../../../core/server/utils/locale'
+import { pageRowHref } from '../../../core/server/utils/page-route'
+
+/** Whether a fetched target row may be linked from PUBLIC output: it must exist and — if its collection has a
+ *  status column — be published. A draft target is NOT linkable, so its slug never leaks into published HTML
+ *  (the caller maps the unresolved link to `'#'`). Pure (no DB) → unit-tested. */
+export function isPubliclyLinkable(row: Record<string, unknown> | undefined, hasStatus: boolean): boolean {
+  if (!row) return false
+  return !hasStatus || row.status === 'published'
+}
+
+/**
+ * Resolve an internal link `{collection, id}` to the target record's localized public path via the DB.
+ * STATUS-GATED: a draft/unpublished target resolves to null → the link renders `'#'`, so its slug never
+ * reaches published HTML (the editor is separately warned about draft/dead links via record-ref-index). The
+ * baked href therefore encodes availability, which is why publishing/unpublishing a target emits the
+ * `<coll>:<id>` tag and re-renders its referrers. Returns null for a non-page-like, missing, or draft target. Shared by the
+ * populate plugin (read path, during `nuxt generate`) and the preview `/api/links/resolve` endpoint, so both
+ * resolve identically. Server-only (`useDb` by default; injectable for tests); tolerates an unmigrated DB → null.
+ */
+export function resolveInternalHref(collection: string, id: number, db = useDb()): string | null {
+  const c = getCollection(collection)
+  if (!c?.def.pageLike) return null
+  const cols = getTableColumns(c.table) as Record<string, never>
+  let row: Record<string, unknown> | undefined
+  try {
+    row = db.select().from(c.table).where(eq(cols.id, id)).get() as Record<string, unknown> | undefined
+  } catch {
+    return null // table not migrated yet (e.g. a bare prerender DB)
+  }
+  if (!isPubliclyLinkable(row, Object.hasOwn(cols, 'status'))) return null
+  return pageRowHref(row, primaryLocale(), prefixPrimaryLocale())
+}

package/layers/public/server/utils/llms.ts

@@ -0,0 +1,39 @@
+/** One linked resource in an llms.txt section. */
+export interface LlmsEntry {
+  title: string
+  url: string
+  /** Optional one-line summary (rendered after the link as `: description`). */
+  description?: string
+}
+
+/** A titled group of resources — one `## heading` block. */
+export interface LlmsSection {
+  heading: string
+  entries: LlmsEntry[]
+}
+
+/**
+ * Render an `llms.txt` (https://llmstxt.org): an H1 site name, an optional `>` blockquote summary, then
+ * one `## heading` per section listing `- [title](url): description` resources. The goal is a compact,
+ * machine-readable map of the site so an AI agent grasps what it is and where the key pages live. Pure +
+ * deterministic (the route feeds it published, indexable pages only); empty sections are omitted.
+ */
+// Collapse any whitespace (incl. newlines) to single spaces so a user-authored title/description/heading —
+// which flows in from an SEO field / textarea — can't inject a spurious line into the one-per-line list.
+const oneLine = (s: string): string => s.replace(/\s+/g, ' ').trim()
+// Additionally escape the brackets that would otherwise break the `[title](url)` markdown link.
+const linkText = (s: string): string => oneLine(s).replace(/[[\]]/g, '\\$&')
+
+export function buildLlmsTxt(opts: { siteName: string; siteDescription?: string; sections: LlmsSection[] }): string {
+  const lines: string[] = [`# ${oneLine(opts.siteName)}`]
+  if (opts.siteDescription) lines.push('', `> ${oneLine(opts.siteDescription)}`)
+  for (const section of opts.sections) {
+    if (!section.entries.length) continue
+    lines.push('', `## ${oneLine(section.heading)}`, '')
+    for (const e of section.entries) {
+      const desc = e.description ? `: ${oneLine(e.description)}` : ''
+      lines.push(`- [${linkText(e.title)}](${e.url})${desc}`)
+    }
+  }
+  return `${lines.join('\n')}\n`
+}