@michaelthielemann/kestrel 3.0.0 → 4.0.0

package/layers/public/server/api/publish.post.ts

@@ -1,84 +0,0 @@
-import { inArray, getTableColumns } from 'drizzle-orm'
-import type { AnySQLiteTable } from 'drizzle-orm/sqlite-core'
-import { MAX_BULK_IDS } from '../../../core/app/utils/list-limits'
-import { classifyWrite, planInvalidation } from '../utils/publish/invalidation'
-import { staleRoutes } from '../utils/publish/deps'
-import { usePublishRuntime } from '../utils/publish/publish-runtime'
-import { allPublishedRoutes } from '../utils/publish/publisher'
-
-/**
- * Publish records: write their static files (and everything whose baked output embeds them) to the
- * configured output — the deliberate second half of the split ADR-0008 introduced. Saving persists to the
- * DB and leaves the live site alone; THIS is what changes what visitors see.
- *
- *   body: { collection: string, ids?: number[], id?: number }
- *   200:  { queued, generates, routes, pruned, drafts }
- *
- * The record's publish INTENT (`status`) is not touched here — that is a field the editor saves like any
- * other, so a page goes live by being published while published. A draft is therefore reported back
- * (`drafts`) rather than silently promoted: it has no public output to write.
- *
- * All-or-nothing on lookup (an unknown id 404s before anything is enqueued), like the bulk write actions.
- */
-export default defineEventHandler(async (event) => {
-  requireAdmin(event) // write-authorization backstop (defense-in-depth; see require-admin.ts)
-  const body = await readBody(event)
-  const name = typeof (body as { collection?: unknown })?.collection === 'string' ? (body as { collection: string }).collection : ''
-  const c = getCollection(name)
-  if (!c) throw createError({ statusCode: 404, statusMessage: `Unknown collection: ${name}` })
-
-  const raw = (body as { ids?: unknown; id?: unknown })?.ids ?? [(body as { id?: unknown })?.id]
-  const ids = parseIdList(raw, MAX_BULK_IDS)
-
-  const db = useDb()
-  const table = c.table as AnySQLiteTable
-  const cols = getTableColumns(table) as Record<string, never>
-  const rows = db.select().from(table).where(inArray(cols.id, ids)).all() as Record<string, unknown>[]
-  const found = new Set(rows.map((r) => r.id as number))
-  const missing = ids.filter((id) => !found.has(id))
-  if (missing.length) throw createError({ statusCode: 404, statusMessage: `${c.def.name} not found: ${missing.join(', ')}` })
-
-  // Where the next publish would go, and whether one happens here at all: in dev (or with `output.auto`
-  // off) there is no runtime publisher, and saying so is more useful than a queued run that never runs.
-  const output = (useRuntimeConfig().kestrel as { output?: { auto?: boolean } }).output
-  const runtime = usePublishRuntime()
-  const generates = !import.meta.dev && !!output?.auto && !!runtime
-
-  // The live route set answers "is this tracked route still somebody's page?" — the question a rename
-  // leaves open. `failed` means the enumeration was incomplete, and an incomplete read must never drive a
-  // delete (the standing rule from the 2026-07-25 audit), so the prune is skipped wholesale.
-  const liveNow = runtime ? allPublishedRoutes() : { routes: [], failed: ['*'] }
-  const prunable = liveNow.failed.length === 0
-
-  const primary = primaryLocale()
-  const prefixPrimary = prefixPrimaryLocale()
-  const routes: string[] = []
-  const pruned: string[] = []
-  const drafts: number[] = []
-  let queued = false
-
-  for (const row of rows) {
-    // before === after: nothing about the record is changing, this is a re-render of its current state.
-    // A draft classifies as not-published, so `planInvalidation` returns a noop for it — reported below.
-    const ev = classifyWrite(c.def, row, row, primary, prefixPrimary)
-    const inv = planInvalidation(ev)
-    if (inv.type !== 'tags') {
-      drafts.push(row.id as number)
-      continue
-    }
-    // Abandoned URLs: routes the publisher baked FROM this record (tagged with its id) that no live page
-    // claims any more — in practice the old file a published rename left behind. Same rule a full publish
-    // applies globally, scoped to this record's tag; a referrer or listing carrying the tag is a live route
-    // and therefore never in this set.
-    const tagged = ev.id != null ? (runtime?.deps.routesForTags([`${c.def.name}:${ev.id}`]) ?? []) : []
-    const stale = prunable ? staleRoutes(tagged, liveNow.routes) : []
-    routes.push(...inv.render)
-    pruned.push(...stale)
-    if (runtime) {
-      runtime.queue.enqueue({ ...inv, prune: [...inv.prune, ...stale] })
-      queued = true
-    }
-  }
-
-  return { queued, generates, routes, pruned, drafts }
-})

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

@@ -1,54 +0,0 @@
-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 db = useDb()
-  const { page: resolved, failed } = resolvePage(db, allCollections(), path, locale, publishedOnly)
-  // The site-wide head tier rides along on the fetch the page already awaits, so it reaches SSR and the
-  // prerender on a path that is known to work. Looked up through the registry, not imported, so an
-  // installation whose registry never received the built-in simply has the tier off (`null`) instead of
-  // querying a table the schema never created. `depth: 1` resolves the sharing image into `$media`;
-  // `getSingleton` captures the read, so an edit re-publishes every route that embedded it.
-  const siteCollection = getCollection('site')
-  let site: ReturnType<typeof getSingleton> = null
-  let siteUnreadable = false
-  if (siteCollection) {
-    try { site = getSingleton(db, siteCollection, locale, false, 1) }
-    catch (error) {
-      // Registered but unreadable (its migration hasn't been run) — indistinguishable in the response from
-      // the off state above, so it joins the incomplete-read channel rather than degrading silently.
-      siteUnreadable = true
-      console.error('[kestrel] route: the site singleton could not be read:', (error as Error)?.message ?? error)
-    }
-  }
-  // One rule for every incomplete read: never answer 200. The publisher classifies a 200-with-body as a
-  // successful render, writes it over the live file and records success — so an unreadable page collection
-  // would bake the catch-all's empty document over a real page (the record may well live in the collection
-  // that failed, which is why this is not a 404), and an unreadable head tier would strip the composed
-  // title, default description and sharing image from every route it touches. Both are unrecoverable
-  // without a full re-publish and neither leaves a mark. A 5xx keeps the existing artifact and turns the
-  // editor's status red. The head tier is site-wide, so it fails the request even when a page did resolve.
-  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 ?? [],
-    // 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

@@ -1,75 +0,0 @@
-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/collections/site.ts

@@ -1,44 +0,0 @@
-import { buildCollection } from '../../../fields/server/utils/buildCollection'
-import { defineCollection } from '../../../core/server/utils/defineCollection'
-
-// `siteUrl`/`siteName` stay in `kestrel.config` on purpose: the build needs them for canonical URLs, the
-// sitemap and robots.txt, so they cannot live in the DB. What is here is editorial instead — and a write
-// re-publishes the routes that embed it, which a config value frozen at module setup can never do.
-const built = buildCollection(defineCollection({
-  name: 'site',
-  mode: 'single',
-  translatable: true,
-  builtin: true,
-  label: { singular: { en: 'Site', de: 'Website' }, plural: { en: 'Site', de: 'Website' } },
-  icon: 'globe',
-  fields: {
-    baseTitle: { type: 'text', label: { en: 'Base title', de: 'Basis-Titel' } },
-    titleSeparator: { type: 'text', label: { en: 'Title separator', de: 'Titel-Trenner' }, default: '|' },
-    titlePosition: {
-      type: 'choice',
-      label: { en: 'Base title position', de: 'Position des Basis-Titels' },
-      options: {
-        choices: [
-          { label: { en: 'After the page title', de: 'Nach dem Seitentitel' }, value: 'after' },
-          { label: { en: 'Before the page title', de: 'Vor dem Seitentitel' }, value: 'before' },
-        ],
-        display: 'buttons',
-      },
-      default: 'after',
-    },
-    description: {
-      type: 'text',
-      label: { en: 'Default meta description', de: 'Standard-Meta-Beschreibung' },
-      options: { multiline: true },
-    },
-    image: {
-      type: 'media',
-      label: { en: 'Default sharing image', de: 'Standard-Sharing-Bild' },
-      options: { accept: 'image' },
-    },
-  },
-  fieldLayout: [['baseTitle|2', 'titleSeparator|1'], 'titlePosition', 'description', 'image'],
-}))
-
-export const site = built.table
-export default built

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

@@ -1,12 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/schema-tables/publish-deps.ts

@@ -1,4 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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/utils/link-resolve.ts

@@ -1,38 +0,0 @@
-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 (error) {
-    // Still null (a throw would 500 every page holding an internal link on a bare prerender DB), but the
-    // memo caches that null run-wide as "not linkable", so the dead link needs a trace to be diagnosable.
-    console.error(`[kestrel] resolveInternalHref: ${collection}:${id} unreadable:`, (error as Error)?.message ?? error)
-    return null
-  }
-  if (!isPubliclyLinkable(row, Object.hasOwn(cols, 'status'))) return null
-  return pageRowHref(row, primaryLocale(), prefixPrimaryLocale())
-}

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

@@ -1,125 +0,0 @@
-import type { CollectionDef, FieldDef } from '../../../core/server/utils/defineCollection'
-import { fieldIs } from '../../../core/server/utils/defineCollection'
-import { getBlock } from '../../../fields/server/utils/defineBlock'
-import { resolveRichtextLinks } from '../../../fields/app/utils/richtext-links'
-import { escapeMarkdownBlock, richtextToMarkdown } from './richtext-markdown'
-
-/** One published page rendered in full: what `llms.txt` links to, plus the body it links to. */
-export interface LlmsFullPage {
-  title: string
-  url: string
-  description?: string
-  /** Markdown; already heading-shifted to nest under the page's own `###`. */
-  body: string
-}
-
-/** A titled group of pages — one `## heading` block, mirroring `llms.txt`'s sections. */
-export interface LlmsFullSection {
-  heading: string
-  pages: LlmsFullPage[]
-}
-
-/** Pages sit at `###`, so a body's own `<h1>` has to start at `####` to keep the outline valid. */
-export const LLMS_FULL_HEADING_OFFSET = 3
-
-// Same defence as `llms.txt`: a title, heading or description is editor-authored text, and a newline in
-// it would forge a second document line — here, a heading that invents a page.
-const oneLine = (s: string): string => s.replace(/\s+/g, ' ').trim()
-
-/**
- * Render an `llms-full.txt` (the long form of https://llmstxt.org): the site header, then every
- * published, indexable page's full Markdown body under its own `###` heading, grouped by collection.
- * Where `llms.txt` is a map, this is the territory — one document an answer engine can retrieve without
- * crawling. Pure + deterministic; the route feeds it published, indexable pages only.
- */
-export function buildLlmsFullTxt(opts: { siteName: string; siteDescription?: string; sections: LlmsFullSection[] }): string {
-  const blocks: string[] = [`# ${oneLine(opts.siteName)}`]
-  // A description is a whole block of its own, so flattening its newlines is not enough — a leading `##`
-  // would still open a section beside the ones this generator writes.
-  if (opts.siteDescription) blocks.push(`> ${escapeMarkdownBlock(oneLine(opts.siteDescription))}`)
-  for (const section of opts.sections) {
-    if (!section.pages.length) continue
-    blocks.push(`## ${oneLine(section.heading)}`)
-    for (const page of section.pages) {
-      blocks.push(`### ${oneLine(page.title)}`)
-      blocks.push(`Source: ${page.url}`)
-      if (page.description) blocks.push(escapeMarkdownBlock(oneLine(page.description)))
-      if (page.body) blocks.push(page.body)
-    }
-  }
-  return `${blocks.join('\n\n')}\n`
-}
-
-export interface RecordMarkdownOptions {
-  /** Push every body heading down by this many levels — see `LLMS_FULL_HEADING_OFFSET`. */
-  headingOffset?: number
-  /** Top-level field keys the caller already rendered (the title it used as the heading). */
-  skipFields?: string[]
-  /** `kestrel:<collection>:<id>` → absolute URL, or null for a target that must not be linked (a draft,
-   *  a noindexed page, a non-routable record). Unresolved links keep their text and lose the anchor. */
-  resolveLink?: (collection: string, id: number) => string | null
-}
-
-/** The prose in one flat value bag (record columns | block props | a repeater entry), in field order.
- *  Only `text` and `richtext` carry prose; `repeater` recurses. Everything else is data, not content —
- *  a consumer's own field type is skipped rather than guessed at. */
-function bagMarkdown(fields: Record<string, FieldDef>, bag: Record<string, unknown>, opts: RecordMarkdownOptions, skip?: Set<string>): string[] {
-  const out: string[] = []
-  for (const [key, field] of Object.entries(fields)) {
-    if (skip?.has(key)) continue
-    const value = bag[key]
-    if (field.type === 'text') {
-      // `fieldIs` rather than a switch: the open consumer-type arm makes `type` a non-discriminant, so a
-      // switch would not narrow (the same reason `extract-refs` walks this way).
-      // A text field is raw editor input with no markup to constrain it, so it is the one value that
-      // reaches the document verbatim — it needs the same block-marker escaping converted prose gets.
-      const text = typeof value === 'string' ? value.trim() : ''
-      if (text) out.push(escapeMarkdownBlock(text))
-    } else if (field.type === 'richtext') {
-      // Always run the marker rewrite, resolver or not: an unrewritten `kestrel:<coll>:<id>` href would
-      // ship a private storage token as a link target. With no resolver every marker declines to `#`,
-      // which the converter renders as plain text.
-      const html = typeof value === 'string' ? resolveRichtextLinks(value, opts.resolveLink ?? (() => null)) : ''
-      const md = richtextToMarkdown(html, { headingOffset: opts.headingOffset })
-      if (md) out.push(md)
-    } else if (fieldIs(field, 'repeater')) {
-      if (Array.isArray(value)) {
-        for (const entry of value) {
-          if (entry && typeof entry === 'object') out.push(...bagMarkdown(field.options.fields, entry as Record<string, unknown>, opts))
-        }
-      }
-    }
-  }
-  return out
-}
-
-/** The prose in a block `content` array, recursing slots — the same walk `extract-refs` does for refs. */
-function blockMarkdown(content: unknown, opts: RecordMarkdownOptions): string[] {
-  const out: string[] = []
-  const walk = (nodes: unknown): void => {
-    if (!Array.isArray(nodes)) return
-    for (const node of nodes) {
-      if (!node || typeof node !== 'object') continue
-      const n = node as { type?: string; props?: Record<string, unknown>; slots?: Record<string, unknown> }
-      // An unregistered block type has no field defs, so there is no way to tell its prose from its
-      // configuration — emitting every string prop would put layout tokens into the document.
-      const def = n.type ? getBlock(n.type) : undefined
-      if (def && n.props && typeof n.props === 'object') out.push(...bagMarkdown(def.fields, n.props, opts))
-      if (n.slots && typeof n.slots === 'object') for (const slotNodes of Object.values(n.slots)) walk(slotNodes)
-    }
-  }
-  walk(content)
-  return out
-}
-
-/**
- * A record's readable content as Markdown: its own text/richtext fields (in declaration order), then its
- * block tree if the collection enables blocks. Pure apart from the block registry — the same dependency
- * `extractRecordRefs` has, and for the same reason: a block's prose is only identifiable through its
- * registered field defs.
- */
-export function recordMarkdown(def: CollectionDef, row: Record<string, unknown>, opts: RecordMarkdownOptions = {}): string {
-  const blocks = bagMarkdown(def.fields, row, opts, opts.skipFields?.length ? new Set(opts.skipFields) : undefined)
-  if (def.blocks?.enabled) blocks.push(...blockMarkdown(row.content, opts))
-  return blocks.join('\n\n')
-}

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

@@ -1,52 +0,0 @@
-/** 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, '\\$&')
-
-/** The `## heading` for a collection's section: its plural label in the primary locale, else any locale's,
- *  else its capitalised name. Shared by `llms.txt` and `llms-full.txt` so the two never disagree. */
-export function collectionHeading(def: { name: string; label?: { plural?: unknown } }, primaryLocale: string): string {
-  const cap = (s: string) => (s ? s[0]!.toUpperCase() + s.slice(1) : s)
-  const plural = def.label?.plural
-  if (typeof plural === 'string') return plural
-  if (plural && typeof plural === 'object') {
-    const byLocale = plural as Record<string, string>
-    return byLocale[primaryLocale] ?? Object.values(byLocale)[0] ?? cap(def.name)
-  }
-  return cap(def.name)
-}
-
-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`
-}