npm - @michaelthielemann/kestrel - Versions diffs - 2.0.0 → 2.1.0 - Mend

@michaelthielemann/kestrel 2.0.0 → 2.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 (55) hide show

package/README.md +15 -8
package/layers/admin/app/components/CollectionList.vue +5 -1
package/layers/admin/app/components/PageFields.vue +5 -0
package/layers/admin/app/components/SeoFields.vue +42 -0
package/layers/admin/app/composables/useEditForm.ts +9 -3
package/layers/admin/app/utils/edit-form.ts +9 -2
package/layers/core/modules/kestrel/index.ts +11 -0
package/layers/core/server/api/[collection]/index.put.test.ts +76 -0
package/layers/core/server/api/[collection]/index.put.ts +18 -1
package/layers/core/server/utils/collection-types.ts +4 -3
package/layers/core/server/utils/defineCollection.ts +8 -1
package/layers/core/server/utils/kestrel-config.ts +35 -1
package/layers/core/server/utils/seo.ts +18 -0
package/layers/core/server/utils/write-effects.ts +40 -0
package/layers/fields/server/utils/buildCollection.ts +9 -7
package/layers/media/app/components/KestrelImg.vue +29 -0
package/layers/media/app/components/MediaLibrary.vue +7 -5
package/layers/media/app/components/MediaViewer.vue +56 -7
package/layers/media/app/utils/ai-disclosure.ts +19 -0
package/layers/media/app/utils/library.ts +2 -0
package/layers/media/server/api/media/[id].patch.test.ts +66 -0
package/layers/media/server/api/media/[id].patch.ts +25 -1
package/layers/media/server/api/media/index.post.ts +19 -3
package/layers/media/server/collections/media.ts +14 -0
package/layers/media/server/utils/ai-disclosure-enabled.ts +16 -0
package/layers/media/server/utils/ai-signal-detect.ts +155 -0
package/layers/media/server/utils/library.ts +2 -1
package/layers/media/server/utils/record.ts +8 -0
package/layers/media/server/utils/resolve.ts +12 -0
package/layers/public/app/pages/[...slug].vue +30 -1
package/layers/public/app/utils/json-ld.ts +139 -0
package/layers/public/modules/deploy-output/deploy-output.ts +19 -5
package/layers/public/modules/prerender-routes/index.ts +5 -2
package/layers/public/server/api/route.get.ts +9 -1
package/layers/public/server/collections/redirects.ts +75 -0
package/layers/public/server/plugins/03.redirects.ts +37 -0
package/layers/public/server/routes/llms-full.txt.get.ts +99 -0
package/layers/public/server/routes/llms.txt.get.ts +1 -12
package/layers/public/server/routes/redirects.json.get.ts +58 -0
package/layers/public/server/routes/robots.txt.get.ts +1 -0
package/layers/public/server/utils/llms-full.ts +125 -0
package/layers/public/server/utils/llms.ts +13 -0
package/layers/public/server/utils/page-resolve.ts +112 -4
package/layers/public/server/utils/publish/invalidation.ts +48 -3
package/layers/public/server/utils/publish/publisher.ts +11 -5
package/layers/public/server/utils/publish/redirect-rules.ts +221 -0
package/layers/public/server/utils/publish/redirects-artifact.ts +20 -0
package/layers/public/server/utils/richtext-markdown.ts +260 -0
package/layers/public/server/utils/site-url.ts +8 -0
package/layers/public/server/utils/sitemap.ts +5 -3
package/layers/ui/app/components/field/Choice.vue +6 -1
package/layers/ui/app/i18n/de.ts +13 -0
package/layers/ui/app/i18n/en.ts +13 -0
package/package.json +2 -1
package/templates/starter/nuxt.config.ts +3 -0

package/layers/public/app/pages/[...slug].vue CHANGED Viewed

@@ -15,6 +15,9 @@ interface RenderedPage {
     description?: string
     noindex?: boolean
     $media?: { image?: { src: string; width: number | null; height: number | null } | null }
+    author?: string
+    publishedDate?: string
+    keywords?: string
   }
   content?: unknown[]
   status?: string
@@ -42,6 +45,7 @@ const { data: resolved, error: resolveError } = await useAsyncData(`page:${local
     collection: string | null
     page: (RenderedPage & Record<string, unknown>) | null
     alternates?: Array<{ locale: string; path: string }>
+    ancestors?: Array<{ path: string; title?: string; locale?: string }>
     site?: SiteHead | null
   }),
 )
@@ -113,7 +117,7 @@ if (!page.value && path !== '/') throw createError({ statusCode: 404, statusMess
 // Canonical / Open Graph / twitter card / hreflang: pure model (`buildPageHead`) fed from the resolved
 // page + the public runtime config. Absolute-URL emissions (canonical, og:url, hreflang, relative
 // og:image) require a configured siteUrl and degrade away without one.
-const publicRc = useRuntimeConfig().public as { siteUrl?: string; siteName?: string }
+const publicRc = useRuntimeConfig().public as { siteUrl?: string; siteName?: string; seoArticleMeta?: boolean }
 const seo = page.value?.seo ?? {}
 const siteHead = resolved.value?.site ?? null
 const fallbacks = siteHeadFallbacks(seo, siteHead)
@@ -133,11 +137,36 @@ const head = buildPageHead({
   alternates: resolved.value?.alternates ?? [],
 })
+// schema.org JSON-LD — the one grounding signal every major answer engine documents. Same inputs as the
+// head above, so the two can never disagree; it degrades away without a siteUrl and is suppressed for a
+// noindex page or an unsaved ticket preview. Article metadata is published ONLY with `seo.articleMeta`
+// on: the fields may hold values (the column always round-trips them) that this installation must not
+// disclose, so the flag gates emission, not storage.
+const jsonLd = buildJsonLd({
+  siteUrl: typeof publicRc.siteUrl === 'string' ? publicRc.siteUrl : '',
+  siteName: typeof publicRc.siteName === 'string' ? publicRc.siteName : '',
+  canonical: head.canonical,
+  locale,
+  primary,
+  prefixPrimary,
+  title: pageTitle,
+  description: fallbacks.description,
+  imageUrl: head.meta.ogImage,
+  noindex: previewingTicket.value || seo.noindex,
+  ancestors: resolved.value?.ancestors ?? [],
+  article: publicRc.seoArticleMeta === true
+    ? { author: seo.author, publishedDate: seo.publishedDate, keywords: seo.keywords }
+    : null,
+})
 // Set the document language from the resolved locale so prerendered /de pages ship <html lang="de">
 // (WCAG 2.2 SC 3.1.1); without this every page would carry the build-default language.
 // Point AI agents at the generated llms.txt (alongside the robots.txt comment + sitemap) on every page.
 useHead({
   htmlAttrs: { lang: locale },
+  // `textContent` (not innerHTML) is unhead's XSS-safe arm for a data script: it takes the object and
+  // serializes it itself, so editor-authored strings can never close the <script>.
+  script: jsonLd ? [{ type: 'application/ld+json' as const, textContent: jsonLd }] : [],
   link: [
     // `rel` needs the literal type: unhead keys its link union on it, and inside an array literal that
     // reaches `link:` through a spread there is no contextual type to stop TS widening it to `string`.

package/layers/public/app/utils/json-ld.ts ADDED Viewed

@@ -0,0 +1,139 @@
+import { localePath } from '../../../core/app/utils/locale-path'
+/** One published ancestor of the rendered page, outermost first — the breadcrumb trail. */
+export interface JsonLdAncestor {
+  /** The ancestor's own path, unprefixed (the emitter locale-prefixes it, as `buildPageHead` does). */
+  path: string
+  title?: string
+  /** The ancestor's OWN locale. Absent for a record in a non-translatable collection, whose single
+   *  published URL is the primary-locale one — the same `row.locale ?? primary` rule the sitemap uses. */
+  locale?: string
+}
+/** The opt-in article metadata (`kestrel.seo.articleMeta`). Absent ⇒ the page stays a plain `WebPage`
+ *  and no authorship or date is published — the default, and the only behaviour a consumer who never
+ *  turns the flag on can get. */
+export interface JsonLdArticle {
+  author?: string
+  /** ISO date (`YYYY-MM-DD`) or ISO datetime; anything else is dropped rather than emitted invalid. */
+  publishedDate?: string
+  /** Free-form comma-separated list — schema.org accepts that spelling for `keywords` verbatim. */
+  keywords?: string
+}
+export interface JsonLdInput {
+  /** Absolute site origin ('' when unconfigured). */
+  siteUrl: string
+  siteName?: string
+  /** The page's absolute canonical URL (from `buildPageHead`); absent ⇒ nothing is emitted. */
+  canonical?: string
+  locale: string
+  primary: string
+  prefixPrimary: boolean
+  title?: string
+  description?: string
+  /** The already-absolute og:image URL, so the image-resolution rules live in one place. */
+  imageUrl?: string
+  /** Excluded from the graph entirely — see `buildJsonLd`. */
+  noindex?: boolean
+  ancestors?: JsonLdAncestor[]
+  article?: JsonLdArticle | null
+}
+/** A type alias, not an interface, for the same reason as `PageHeadLink`: unhead's `script` entry types
+ *  `textContent` as `string | Record<string, unknown>`, and TS derives the implicit index signature that
+ *  needs for an alias but never for an interface. */
+export type JsonLd = {
+  '@context': 'https://schema.org'
+  '@graph': Record<string, unknown>[]
+}
+const trimmed = (v: unknown): string | undefined => {
+  const s = typeof v === 'string' ? v.trim() : ''
+  return s || undefined
+}
+// schema.org dates are ISO 8601; an editor free-text value that is not one would be published as a
+// broken `datePublished`, which is worse for a consuming engine than no date at all.
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ]|$)/
+/**
+ * The JSON-LD graph for a rendered public page: a site-wide `WebSite`, the page itself as a `WebPage`
+ * (or an `Article`, when the consumer opted into article metadata AND the record carries some), and a
+ * `BreadcrumbList` built from the page's real published ancestors. Pure, like `buildPageHead`, and fed
+ * the same already-resolved values — the precedence chain stays outside (ADR-0007).
+ *
+ * Two whole-graph veto rules, both because the alternative is a false signal rather than a missing one:
+ * without an absolute canonical every `@id`/`url` would be a relative path that resolves against
+ * whatever host fetched it, and a `noindex` page asking to be excluded from search has no business
+ * shipping structured data that exists to be indexed.
+ *
+ * Breadcrumb items are REAL pages only (the resolver hands over the published ancestors it found), so a
+ * trail never advertises an intermediate URL that 404s; a trail of one is dropped, since "you are here"
+ * carries no information.
+ */
+export function buildJsonLd(input: JsonLdInput): JsonLd | null {
+  const canonical = trimmed(input.canonical)
+  if (!canonical || input.noindex) return null
+  const base = input.siteUrl.replace(/\/+$/, '')
+  const abs = (path: string, locale: string) => `${base}${localePath(path, locale, input.primary, input.prefixPrimary)}`
+  const graph: Record<string, unknown>[] = []
+  const siteName = trimmed(input.siteName)
+  // A nameless WebSite node is an empty assertion — omit it, and with it the isPartOf edge that would
+  // otherwise dangle at an @id nothing defines.
+  const websiteId = siteName ? `${base}/#website` : undefined
+  if (websiteId) graph.push({ '@type': 'WebSite', '@id': websiteId, url: `${base}/`, name: siteName })
+  const article = usableArticle(input.article)
+  const page: Record<string, unknown> = {
+    '@type': article ? 'Article' : 'WebPage',
+    '@id': `${canonical}#webpage`,
+    url: canonical,
+  }
+  const title = trimmed(input.title)
+  // `headline` is the Article spelling of the same value; keeping them apart avoids a node that claims
+  // both and matches what validators expect per type.
+  if (title) page[article ? 'headline' : 'name'] = title
+  const description = trimmed(input.description)
+  if (description) page.description = description
+  page.inLanguage = input.locale
+  if (websiteId) page.isPartOf = { '@id': websiteId }
+  const imageUrl = trimmed(input.imageUrl)
+  if (imageUrl) page.image = imageUrl
+  if (article) {
+    if (article.author) page.author = { '@type': 'Person', name: article.author }
+    if (article.publishedDate) page.datePublished = article.publishedDate
+    if (article.keywords) page.keywords = article.keywords
+  }
+  const crumbs = [
+    ...(input.ancestors ?? []).map((a) => ({ name: trimmed(a.title) ?? a.path, item: abs(a.path, a.locale ?? input.primary) })),
+    { name: title ?? canonical, item: canonical },
+  ]
+  if (crumbs.length >= 2) {
+    const breadcrumbId = `${canonical}#breadcrumb`
+    page.breadcrumb = { '@id': breadcrumbId }
+    graph.push(page, {
+      '@type': 'BreadcrumbList',
+      '@id': breadcrumbId,
+      itemListElement: crumbs.map((c, i) => ({ '@type': 'ListItem', position: i + 1, name: c.name, item: c.item })),
+    })
+  } else {
+    graph.push(page)
+  }
+  return { '@context': 'https://schema.org', '@graph': graph }
+}
+/** The article bag reduced to the values worth publishing, or null — which keeps the node a `WebPage`.
+ *  A bag of blanks (an editor who opened the fields and typed nothing) must not upgrade the type. */
+function usableArticle(article: JsonLdArticle | null | undefined): Required<JsonLdArticle> | null {
+  if (!article) return null
+  const author = trimmed(article.author) ?? ''
+  const rawDate = trimmed(article.publishedDate) ?? ''
+  const publishedDate = ISO_DATE.test(rawDate) ? rawDate : ''
+  const keywords = trimmed(article.keywords) ?? ''
+  // An unparseable date alone must not upgrade the type either — nothing would be emitted from it.
+  return author || publishedDate || keywords ? { author, publishedDate, keywords } : null
+}

package/layers/public/modules/deploy-output/deploy-output.ts CHANGED Viewed

@@ -69,12 +69,26 @@ export function precompressedEncoding(filename: string, siblingNames: string[]):
 const IMMUTABLE_CACHE = 'public, max-age=31536000, immutable'
 const REVALIDATE_CACHE = 'public, max-age=0, must-revalidate'
+/** Artifacts served at a LITERAL key (not `<path>/index.html`) and rendered from the live DB rather than
+ *  copied from the build. One list, because each of them has to be handled the same way in four places:
+ *  re-rendered on every publish, excluded from the build-asset mirror (a stale copy must never overwrite
+ *  a fresh one), seeded into the prerender routes, and cached as revalidate-always below.
+ *  `llms-full.txt` is opt-in (`kestrel.seo.llmsFull`) and simply renders to a 404 when off — it stays in
+ *  this list either way, so the rules that are about the FILENAME hold regardless of the flag; only the
+ *  prerender seeding, which asks for the ROUTE, has to consult it. */
+export const META_KEYS = ['sitemap.xml', 'robots.txt', 'llms.txt', 'llms-full.txt', 'redirects.json'] as const
+export function isMetaKey(key: string): boolean {
+  return (META_KEYS as readonly string[]).includes(key)
+}
 /**
  * `Cache-Control` for a static-output key, or `undefined` for no explicit policy. Content-hashed
- * `_nuxt/` assets get a year + `immutable` (the hash is the cache key — new content ⇒ new URL). HTML,
- * the sitemap and `robots.txt` live at *stable* URLs whose content changes on any deploy, so they get
- * `max-age=0, must-revalidate` (cacheable but always revalidated). Everything else (favicons, fonts,
- * un-hashed media) is left to the host default.
+ * `_nuxt/` assets get a year + `immutable` (the hash is the cache key — new content ⇒ new URL). HTML and
+ * the `META_KEYS` artifacts live at *stable* URLs whose content changes on any deploy, so they get
+ * `max-age=0, must-revalidate` (cacheable but always revalidated) — `redirects.json` especially, since a
+ * cached copy keeps serving withdrawn redirects. Everything else (favicons, fonts, un-hashed media) is
+ * left to the host default.
  */
 export function cacheControlFor(key: string): string | undefined {
   // Nuxt's app manifest lives at a STABLE _nuxt URL but its content (the buildId) changes every build, so it
@@ -82,7 +96,7 @@ export function cacheControlFor(key: string): string | undefined {
   if (key === '_nuxt/builds/latest.json') return REVALIDATE_CACHE
   if (key === '_nuxt' || key.startsWith('_nuxt/')) return IMMUTABLE_CACHE
   const base = key.split('/').pop() ?? key
-  if (base.endsWith('.html') || base === 'sitemap.xml' || base === 'robots.txt' || base === 'llms.txt') return REVALIDATE_CACHE
+  if (base.endsWith('.html') || isMetaKey(base)) return REVALIDATE_CACHE
   return undefined
 }

package/layers/public/modules/prerender-routes/index.ts CHANGED Viewed

@@ -4,7 +4,7 @@ import { defineNuxtModule } from '@nuxt/kit'
 import Database from 'better-sqlite3'
 import { collectPageRoutes, pageLikeTables } from './discover'
 import { localePath } from '../../../core/app/utils/locale-path'
-import { recordRouteDiscovery, type RouteDiscovery } from '../deploy-output/deploy-output'
+import { recordRouteDiscovery, META_KEYS, type RouteDiscovery } from '../deploy-output/deploy-output'
 import { resolveKestrel, type KestrelConfig } from '../../../core/server/utils/kestrel-config'
 // Read published paths from EVERY page-like collection straight from the DB at build time so
@@ -73,7 +73,10 @@ export default defineNuxtModule({
       // Hand the deploy module the completeness of THIS enumeration — the only step that knows it.
       recordRouteDiscovery(nuxt, discovery)
       nitro.prerender ||= {}
-      nitro.prerender.routes = [...new Set([...(nitro.prerender.routes ?? []), ...discovery.routes, '/sitemap.xml', '/robots.txt', '/llms.txt'])]
+      // Every meta artifact EXCEPT `llms-full.txt`, which is seeded only when the consumer opted in — the
+      // route 404s otherwise, and a prerender error fails the whole `nuxt generate`.
+      const meta = META_KEYS.filter((k) => k !== 'llms-full.txt' || c.seo.llmsFull).map((k) => `/${k}`)
+      nitro.prerender.routes = [...new Set([...(nitro.prerender.routes ?? []), ...discovery.routes, ...meta])]
       // Render pages in parallel — the dominant lever on `nuxt generate` wall-clock as page count grows.
       // Safe: page reads are synchronous better-sqlite3 (WAL + busy_timeout, can't interleave mid-statement);
       // the one WRITE on this path — the variant-registry capture — is an IMMEDIATE transaction, so

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

@@ -42,5 +42,13 @@ export default defineEventHandler((event) => {
   if (siteUnreadable || (failed.length && !resolved)) {
     throw createError({ statusCode: 503, statusMessage: 'Route lookup incomplete' })
   }
-  return { collection: resolved?.collection ?? null, page: resolved?.page ?? null, alternates: resolved?.alternates ?? [], site }
+  return {
+    collection: resolved?.collection ?? null,
+    page: resolved?.page ?? null,
+    alternates: resolved?.alternates ?? [],
+    // The breadcrumb trail rides the same fetch as the hreflang set, for the same reason: it is resolved
+    // from the DB, and the publish-dep capture only works on a path the renderer actually awaits.
+    ancestors: resolved?.ancestors ?? [],
+    site,
+  }
 })

package/layers/public/server/collections/redirects.ts ADDED Viewed

@@ -0,0 +1,75 @@
+import { buildCollection } from '../../../fields/server/utils/buildCollection'
+import { defineCollection } from '../../../core/server/utils/defineCollection'
+import { compileRedirects } from '../utils/publish/redirect-rules'
+// Editorial SEO redirects, kept in the DB rather than in config because they outlive a deployment and are
+// the editors' to change. Saving compiles them into the `redirects.json` artifact the edge serves — Kestrel
+// itself never redirects at runtime (there is no live public SSR to redirect in).
+const built = buildCollection(defineCollection({
+  name: 'redirects',
+  mode: 'single',
+  builtin: true,
+  label: { singular: { en: 'Redirects', de: 'Weiterleitungen' }, plural: { en: 'Redirects', de: 'Weiterleitungen' } },
+  icon: 'external-link',
+  fields: {
+    rules: {
+      type: 'repeater',
+      // Row order is priority and there is no per-field help text in the editor, so the rule and the
+      // wildcard syntax have to ride along in the labels — this is the only place an editor sees them.
+      label: {
+        en: 'Rules — the first matching rule wins, so put the most specific one first',
+        de: 'Regeln — die erste passende Regel gewinnt, spezifische zuerst',
+      },
+      options: {
+        fields: {
+          from: {
+            type: 'text',
+            required: true,
+            label: {
+              en: 'From — old path, * = one segment, ** = several',
+              de: 'Von — alter Pfad, * = ein Segment, ** = mehrere',
+            },
+          },
+          to: {
+            type: 'text',
+            required: true,
+            label: {
+              en: 'To — new path or full URL, $1/$2 = the wildcards',
+              de: 'Nach — neuer Pfad oder vollständige URL, $1/$2 = die Platzhalter',
+            },
+          },
+          status: {
+            type: 'choice',
+            label: { en: 'Status', de: 'Status' },
+            options: {
+              choices: [
+                { label: { en: '301 — permanent', de: '301 — dauerhaft' }, value: '301' },
+                { label: { en: '302 — temporary', de: '302 — vorübergehend' }, value: '302' },
+                { label: { en: '307 — temporary, keeps the method', de: '307 — vorübergehend, Methode bleibt' }, value: '307' },
+                { label: { en: '308 — permanent, keeps the method', de: '308 — dauerhaft, Methode bleibt' }, value: '308' },
+              ],
+              display: 'select',
+            },
+            default: '301',
+          },
+        },
+        fieldLayout: [['from|2', 'to|2', 'status|1']],
+      },
+    },
+  },
+  // A row that cannot compile must never reach the DB: it would leave the artifact stale on every
+  // subsequent save and fail the prerender of `/redirects.json`. Zod validates one field at a time and
+  // cannot see that `to: '/x/$2'` needs a second wildcard in `from`, so the check lands here — before the
+  // write, as a field-scoped 400 the editor renders on the repeater.
+  validate: (record) => {
+    try {
+      compileRedirects(record.rules)
+      return []
+    } catch (error) {
+      return [{ path: ['rules'], message: (error as Error).message }]
+    }
+  },
+}))
+export const redirects = built.table
+export default built

package/layers/public/server/plugins/03.redirects.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import { registerWriteEffect } from '../../../core/server/utils/write-effects'
+import { outputDriver } from '../utils/publish/publisher'
+import { REDIRECTS_COLLECTION, REDIRECTS_FIELD, writeRedirectsArtifact } from '../utils/publish/redirects-artifact'
+/**
+ * Publish `redirects.json` on every save of the redirects singleton — deliberately decoupled from the
+ * publish cycle, so a redirect goes live without a full republish (and without an editor pressing
+ * Publish, which after ADR-0008 they otherwise would have to).
+ *
+ * A write EFFECT, not a write listener: the bus swallows throws, and a save that reports success while
+ * the edge still serves the old rules is exactly the failure this feature cannot have. Registered in
+ * every environment, unlike the publish plugin — that one is dev-gated because a dev publish would write
+ * Vite-dev HTML with no hashed `_nuxt`, a CONTENT problem this artifact does not have (it is
+ * `JSON.stringify` of DB rows, byte-identical either way).
+ *
+ * Where it lands is `output.dir` / the S3 prefix — the same target the publisher uses. With the classic
+ * `output.auto: false` + `driver: 'local'` build model that is NOT the deployed tree, so there a
+ * redirect goes live with the next `nuxt generate` instead; documented under Redirects in
+ * `docs/static-output.md`.
+ */
+export default defineNitroPlugin(() => {
+  registerWriteEffect(async ({ def, row }) => {
+    if (def.name !== REDIRECTS_COLLECTION) return
+    try {
+      await writeRedirectsArtifact(row[REDIRECTS_FIELD], outputDriver())
+    } catch (error) {
+      // The row is already committed (CRUD holds no transaction), so the only honest message is
+      // "saved, but not live". Short and ASCII on purpose: h3 truncates nothing but the reason phrase is
+      // the wire's, and the cause goes in `data` where nothing can strip it.
+      throw createError({
+        statusCode: 500,
+        statusMessage: 'Redirects saved, but publishing redirects.json failed. Save again to retry.',
+        data: { cause: (error as Error)?.message ?? String(error) },
+      })
+    }
+  })
+})

package/layers/public/server/routes/llms-full.txt.get.ts ADDED Viewed

@@ -0,0 +1,99 @@
+import { getTableColumns } from 'drizzle-orm'
+import { localePath } from '../../../core/app/utils/locale-path'
+import { LLMS_FULL_HEADING_OFFSET } from '../utils/llms-full'
+import type { LlmsFullSection, LlmsFullPage } from '../utils/llms-full'
+import type { BuiltCollection } from '../../../core/server/utils/collection-types'
+// The long form of llms.txt: every published, indexable page's full Markdown body in one document, so an
+// answer engine can ground on the site without crawling it. Same registry-driven public set and the same
+// status/noindex filters as `llms.txt` and the sitemap (single source: the auth policy).
+//
+// OPT-IN (`kestrel.seo.llmsFull`, default off), for two reasons that both matter: it aggregates the whole
+// site into one scrapeable artifact — a disclosure decision that belongs to the consumer, not to an
+// upgrade — and unlike `llms.txt` it must read every row's block content, which the publisher would
+// re-render on every incremental publish.
+export default defineEventHandler((event) => {
+  if (!llmsFullEnabled()) throw createError({ statusCode: 404, statusMessage: 'Not Found' })
+  const db = useDb()
+  const base = siteBaseUrl()
+  const primary = primaryLocale()
+  const prefixPrimary = prefixPrimaryLocale()
+  setHeader(event, 'content-type', 'text/plain; charset=utf-8')
+  // Without an absolute origin every `Source:` line would be a relative path resolving against whatever
+  // host fetched the file — the same rule `llms.txt` applies to its link list.
+  if (!base) {
+    console.warn('[kestrel] llms-full.txt: siteUrl is unset — omitting page bodies (their URLs would be relative)')
+    return buildLlmsFullTxt({ siteName: siteName(), siteDescription: siteDescription() || undefined, sections: [] })
+  }
+  interface Loaded { c: BuiltCollection; rows: Record<string, unknown>[] }
+  const pub = publicReadableResources()
+  const loaded: Loaded[] = []
+  for (const c of allCollections()) {
+    if (!c.def.pageLike) continue
+    if (!isPubliclyReadable(c.def.name, pub)) continue
+    // Project the listing columns plus ONLY the prose-bearing fields — this route does have to read block
+    // content, but a media/relation/json column still has no business being loaded to render text.
+    const cols = getTableColumns(c.table) as Record<string, never>
+    const proj: Record<string, unknown> = { id: cols.id, 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 (c.def.blocks?.enabled) proj.content = cols.content
+    for (const [key, field] of Object.entries(c.def.fields)) {
+      if (field.type === 'text' || field.type === 'richtext' || field.type === 'repeater') proj[key] = cols[key]
+    }
+    try {
+      loaded.push({ c, rows: db.select(proj as never).from(c.table).all() as Record<string, unknown>[] })
+    } catch (error) {
+      // Skipping keeps a bare prerender DB publishable, but a drifted table drops the whole section — a
+      // silent gap the publisher would write straight over the live artifact.
+      console.error(`[kestrel] llms-full.txt: skipped collection ${c.def.name}:`, (error as Error)?.message ?? error)
+    }
+  }
+  const advertisable = (c: BuiltCollection, row: Record<string, unknown>): string | null => {
+    if (c.def.status && row.status !== 'published') return null
+    const path = row.path as string | null
+    if (!path) return null
+    if ((row.seo as { noindex?: boolean } | null)?.noindex) return null
+    return base + localePath(path, (row.locale as string | undefined) ?? primary, primary, prefixPrimary)
+  }
+  // Internal richtext links are stored as `kestrel:<collection>:<id>` markers. Resolve them from the rows
+  // already loaded — the same status/noindex gate, so a marker pointing at a draft or a noindexed page
+  // declines and the link degrades to its own text instead of leaking an unpublished URL.
+  const linkTargets = new Map<string, string>()
+  for (const { c, rows } of loaded) {
+    for (const row of rows) {
+      const url = advertisable(c, row)
+      if (url) linkTargets.set(`${c.def.name}:${row.id as number}`, url)
+    }
+  }
+  const resolveLink = (collection: string, id: number): string | null => linkTargets.get(`${collection}:${id}`) ?? null
+  const sections: LlmsFullSection[] = []
+  for (const { c, rows } of loaded) {
+    const pages: LlmsFullPage[] = []
+    for (const row of rows) {
+      const url = advertisable(c, row)
+      if (!url) continue
+      const seo = (row.seo ?? {}) as { title?: string; description?: string }
+      pages.push({
+        title: seo.title || (row.title as string | undefined) || (row.path as string),
+        url,
+        description: seo.description || undefined,
+        // `title` already IS this page's heading — emitting it again as body text would repeat every
+        // page title twice in the document.
+        body: recordMarkdown(c.def, row, { headingOffset: LLMS_FULL_HEADING_OFFSET, skipFields: ['title'], resolveLink }),
+      })
+    }
+    if (pages.length) {
+      pages.sort((a, b) => a.url.localeCompare(b.url))
+      sections.push({ heading: collectionHeading(c.def, primary), pages })
+    }
+  }
+  return buildLlmsFullTxt({ siteName: siteName(), siteDescription: siteDescription() || undefined, sections })
+})

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

@@ -11,17 +11,6 @@ export default defineEventHandler((event) => {
   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
@@ -66,7 +55,7 @@ export default defineEventHandler((event) => {
     }
     if (entries.length) {
       entries.sort((a, b) => a.url.localeCompare(b.url))
-      sections.push({ heading: headingFor(c.def), entries })
+      sections.push({ heading: collectionHeading(c.def, primary), entries })
     }
   }

package/layers/public/server/routes/redirects.json.get.ts ADDED Viewed

@@ -0,0 +1,58 @@
+import { eq } from 'drizzle-orm'
+import { compilePublishableRedirects, serializeRedirects } from '../utils/publish/redirect-rules'
+import { REDIRECTS_COLLECTION, REDIRECTS_FIELD } from '../utils/publish/redirects-artifact'
+/**
+ * The redirect artifact the edge polls. A save publishes it directly (see `plugins/03.redirects.ts`);
+ * this route is what makes it survive everything else — it is prerendered into `.output/public`, so the
+ * build-time deploy's reconcile keeps it instead of pruning a key it cannot account for, and a full
+ * publish re-renders it from the live DB. Public and cheap: one row, no user input.
+ *
+ * Zero redirects is a supported state, and so is a collection a consumer toggled off — both serve `[]`,
+ * never a 404, because an edge that cannot fetch the file has to keep its last good state and would
+ * otherwise burn its cold-start budget retrying.
+ */
+/** A table that does not exist yet — the release adds one, so a consumer can generate before their
+ *  `db:migrate`. `[]` is the truth there, not a degrade. */
+function tableIsAbsent(error: unknown): boolean {
+  return /no such table/i.test((error as Error)?.message ?? '')
+}
+/**
+ * Render the artifact, or fail loudly. The distinction is deliberate and narrow: only a missing table
+ * yields `[]`, because only then is "no redirects" a FACT. Any other read failure (a drifted column, an
+ * I/O error) throws — at build time an errored route costs the deploy its reconcile, which is the
+ * conservative direction, and at runtime `publishMeta` writes nothing on a non-200, where an empty body
+ * would instead overwrite a good live artifact with "no redirects". A failed read must never be an
+ * authoritative empty result.
+ */
+export function renderRedirects(readRows: () => unknown): string {
+  let rows: unknown
+  try {
+    rows = readRows()
+  } catch (error) {
+    if (!tableIsAbsent(error)) throw error
+    console.warn('[kestrel] redirects.json: the redirects table does not exist yet — serving an empty list. Run `db:migrate`.')
+    return serializeRedirects([])
+  }
+  const { rules, skipped } = compilePublishableRedirects(rows)
+  for (const message of skipped) {
+    console.error(`[kestrel] redirects.json: skipped an unpublishable rule — ${message}`)
+  }
+  return serializeRedirects(rules)
+}
+export default defineEventHandler((event) => {
+  setHeader(event, 'content-type', 'application/json; charset=utf-8')
+  const collection = getCollection(REDIRECTS_COLLECTION)
+  if (!collection) return serializeRedirects([])
+  const cols = collection.table as unknown as Record<string, never>
+  return renderRedirects(() => {
+    const row = useDb().select().from(collection.table).where(eq(cols.singletonKey, REDIRECTS_COLLECTION)).get() as
+      | Record<string, unknown>
+      | undefined
+    return row?.[REDIRECTS_FIELD]
+  })
+})

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

@@ -4,5 +4,6 @@ export default defineEventHandler((event) => {
   return buildRobots({
     sitemapUrl: base ? `${base}/sitemap.xml` : undefined,
     llmsUrl: base ? `${base}/llms.txt` : undefined,
+    llmsFullUrl: base && llmsFullEnabled() ? `${base}/llms-full.txt` : undefined,
   })
 })