@michaelthielemann/kestrel 1.7.0 → 2.1.0

package/layers/public/server/utils/richtext-markdown.ts

@@ -0,0 +1,260 @@
+/**
+ * Richtext HTML → Markdown, for the agent-facing `llms-full.txt`. Answer engines consume Markdown, not
+ * markup, and a stripped-tags dump would lose exactly the structure they retrieve on (headings, lists,
+ * links).
+ *
+ * A hand-rolled parser rather than a DOM library because the input dialect is CLOSED and already
+ * well-formed: every stored richtext value passed `sanitizeRichtext` on write, so it is sanitize-html's
+ * own re-serialization of a parsed tree, restricted to `RICHTEXT_ALLOWLIST`. That keeps this pure — no
+ * DOM, no Nuxt, no new dependency in the public layer's server bundle — so it unit-tests hard.
+ *
+ * Deliberately minimal escaping: only link text (whose brackets would break the link syntax) and a
+ * leading block marker (which would silently turn a paragraph into a list item or heading). Escaping
+ * every markdown metacharacter would make the output markedly harder to read for the model that reads it.
+ */
+
+export interface RichtextMarkdownOptions {
+  /** Push every heading down by this many levels (clamped at h6), so a body nests under the document
+   *  headings the caller already emitted. */
+  headingOffset?: number
+}
+
+type MdNode =
+  | { kind: 'text'; value: string }
+  | { kind: 'el'; tag: string; attrs: Record<string, string>; children: MdNode[] }
+
+const VOID_TAGS = new Set(['br', 'hr', 'img', 'input', 'meta', 'link'])
+const HEADINGS: Record<string, number> = { h1: 1, h2: 2, h3: 3, h4: 4, h5: 5, h6: 6 }
+const BLOCK_TAGS = new Set(['p', 'blockquote', 'pre', 'ul', 'ol', 'hr', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'])
+
+const TAG = /<(\/)?([a-zA-Z][a-zA-Z0-9]*)((?:\s+[^\s"'>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*(\/)?>/g
+const ATTR = /([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g
+
+const NAMED_ENTITIES: Record<string, string> = {
+  amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ',
+}
+
+/** Decode the entity set sanitize-html emits, plus numeric references. `&nbsp;` becomes an ordinary
+ *  space on purpose: a U+00A0 survives whitespace collapsing and shows up as a stray gap. */
+function decodeEntities(raw: string): string {
+  return raw.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (match, body: string) => {
+    if (body[0] === '#') {
+      const code = body[1] === 'x' || body[1] === 'X' ? Number.parseInt(body.slice(2), 16) : Number(body.slice(1))
+      return Number.isFinite(code) && code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : match
+    }
+    return NAMED_ENTITIES[body.toLowerCase()] ?? match
+  })
+}
+
+function parseAttrs(raw: string): Record<string, string> {
+  const attrs: Record<string, string> = {}
+  if (!raw.trim()) return attrs
+  ATTR.lastIndex = 0
+  let m: RegExpExecArray | null
+  while ((m = ATTR.exec(raw))) {
+    attrs[m[1]!.toLowerCase()] = decodeEntities(m[2] ?? m[3] ?? m[4] ?? '')
+  }
+  return attrs
+}
+
+/** Tag soup → a node tree. A stray close tag with no matching open is dropped; anything still open at
+ *  the end is closed implicitly, so a truncated value degrades to the content it did carry. */
+function parse(html: string): MdNode[] {
+  const root: MdNode[] = []
+  const stack: Array<{ tag: string; children: MdNode[] }> = []
+  const top = (): MdNode[] => (stack.length ? stack[stack.length - 1]!.children : root)
+  const pushText = (raw: string): void => {
+    if (raw) top().push({ kind: 'text', value: decodeEntities(raw) })
+  }
+
+  TAG.lastIndex = 0
+  let cursor = 0
+  let m: RegExpExecArray | null
+  while ((m = TAG.exec(html))) {
+    pushText(html.slice(cursor, m.index))
+    cursor = TAG.lastIndex
+    const tag = m[2]!.toLowerCase()
+    if (m[1]) {
+      // Close the innermost matching element; an unmatched close tag is ignored rather than unwinding
+      // the whole stack, which would drop every sibling that followed it.
+      const at = stack.map((s) => s.tag).lastIndexOf(tag)
+      if (at >= 0) stack.length = at
+      continue
+    }
+    const node: MdNode = { kind: 'el', tag, attrs: parseAttrs(m[3] ?? ''), children: [] }
+    top().push(node)
+    if (!m[4] && !VOID_TAGS.has(tag)) stack.push({ tag, children: node.children })
+  }
+  pushText(html.slice(cursor))
+  return root
+}
+
+/** Raw text of a subtree, entities already decoded and whitespace untouched (code blocks). */
+function rawText(nodes: MdNode[]): string {
+  return nodes.map((n) => (n.kind === 'text' ? n.value : rawText(n.children))).join('')
+}
+
+const escapeLinkText = (s: string): string => s.replace(/[[\]]/g, '\\$&')
+
+const INLINE_WRAP: Record<string, string> = { strong: '**', b: '**', em: '*', i: '*', s: '~~' }
+
+/** The longest run of `char` anywhere in `text` — the width a fence/delimiter has to beat to contain it. */
+function longestRun(text: string, char: string): number {
+  let longest = 0
+  let run = 0
+  for (const c of text) {
+    run = c === char ? run + 1 : 0
+    if (run > longest) longest = run
+  }
+  return longest
+}
+
+/** `` `code` `` with a delimiter wider than any backtick run inside it (CommonMark's own escape hatch),
+ *  padded with a space when the content would otherwise fuse with the delimiter. */
+function inlineCode(text: string): string {
+  const delimiter = '`'.repeat(longestRun(text, '`') + 1)
+  const pad = text.startsWith('`') || text.endsWith('`') ? ' ' : ''
+  return `${delimiter}${pad}${text}${pad}${delimiter}`
+}
+
+function renderInline(nodes: MdNode[]): string {
+  let out = ''
+  for (const node of nodes) {
+    if (node.kind === 'text') { out += node.value.replace(/\s+/g, ' '); continue }
+    if (node.tag === 'br') { out += '\n'; continue }
+    if (node.tag === 'a') {
+      const text = renderInline(node.children).trim()
+      const href = node.attrs.href
+      // `#` is what the internal-link resolver writes for a target it declined (missing or unpublished) —
+      // a dead anchor is worth less than the words it wraps, so keep the words and drop the link.
+      out += !href || href === '#' ? text : `[${escapeLinkText(text)}](${href})`
+      continue
+    }
+    const inner = renderInline(node.children)
+    if (node.tag === 'code') { out += inner.trim() ? inlineCode(inner.trim()) : inner; continue }
+    const wrap = INLINE_WRAP[node.tag]
+    if (!wrap || !inner.trim()) { out += inner; continue }
+    // CommonMark will not open emphasis on `** bold **` — whitespace immediately inside the delimiter
+    // makes it literal asterisks. Editors leave it there routinely (selecting a word plus its space), so
+    // move it outside rather than emitting markup that does not parse.
+    const [, lead = '', body = '', trail = ''] = /^(\s*)([\s\S]*?)(\s*)$/.exec(inner) ?? []
+    out += `${lead}${wrap}${body}${wrap}${trail}`
+  }
+  return out
+}
+
+const prefixLines = (text: string, first: string, rest: string): string =>
+  text.split('\n').map((line, i) => (i === 0 ? first + line : (line ? rest + line : rest.trimEnd()))).join('\n')
+
+/** Escape a line that would otherwise open a Markdown block: a heading, a list item, a quote, a code
+ *  fence or a thematic break. One backslash on the first marker character defuses all of them (every one
+ *  is ASCII punctuation, so the escape is valid CommonMark and renders as the literal character). */
+function escapeMarkerLine(line: string): string {
+  // CommonMark allows a block marker up to three spaces in; deeper is an indented code block, which no
+  // backslash can defuse — and which whitespace collapsing has already removed from converted text.
+  const [, indent = '', rest = ''] = /^(\s{0,3})([\s\S]*)$/.exec(line) ?? []
+  const ordered = /^(\d{1,9})[.)](\s|$)/.exec(rest)
+  if (ordered) return `${indent}${ordered[1]}\\${rest.slice(ordered[1]!.length)}`
+  const opensBlock = /^#{1,6}(\s|$)/.test(rest)          // heading, any level
+    || /^[-+*](\s|$)/.test(rest)                          // bullet list
+    || rest.startsWith('>')                               // block quote
+    || /^(`{3,}|~{3,})/.test(rest)                        // fenced code
+    || /^([-*_])[\s]*(\1[\s]*){2,}$/.test(rest)           // thematic break (and the setext h2 underline)
+    || /^=+\s*$/.test(rest)                               // setext h1 underline
+  return opensBlock ? `${indent}\\${rest}` : line
+}
+
+/**
+ * Escape every line of a text block that would open a Markdown construct. Applied per LINE, not once per
+ * block: a `<br>` becomes a real newline, so an anchored first-line-only check guards nothing after it.
+ *
+ * This is the whole defence between editor-authored prose and the structure of `llms-full.txt`, whose own
+ * document uses `##` for collection sections and `###` for pages — an unescaped `## …` in a body would
+ * not merely add a heading, it would forge a sibling of the generator's own and re-parent every page
+ * after it.
+ */
+export function escapeMarkdownBlock(text: string): string {
+  return text.split('\n').map(escapeMarkerLine).join('\n')
+}
+
+function renderList(node: MdNode & { kind: 'el' }, opts: RichtextMarkdownOptions): string {
+  const ordered = node.tag === 'ol'
+  const items = node.children.filter((c): c is MdNode & { kind: 'el' } => c.kind === 'el' && c.tag === 'li')
+  const lines: string[] = []
+  let n = 0
+  for (const item of items) {
+    const blocks = renderBlocks(item.children, opts)
+    n += 1
+    const marker = ordered ? `${n}. ` : '- '
+    const indent = ' '.repeat(marker.length)
+    // The first block is the item's own text; anything after it (a nested list, a second paragraph)
+    // continues the item and must be indented to the marker's width to stay inside it.
+    const [head = '', ...rest] = blocks
+    lines.push(prefixLines(head, marker, indent))
+    for (const block of rest) lines.push(prefixLines(block, indent, indent))
+  }
+  return lines.join('\n')
+}
+
+/** Render a node list as block-level markdown: an array of blocks, joined by a blank line by the caller. */
+function renderBlocks(nodes: MdNode[], opts: RichtextMarkdownOptions): string[] {
+  const blocks: string[] = []
+  let run: MdNode[] = []
+  const flushRun = (): void => {
+    if (!run.length) return
+    const text = renderInline(run).trim()
+    run = []
+    if (text) blocks.push(escapeMarkdownBlock(text))
+  }
+
+  for (const node of nodes) {
+    // An unrecognised wrapper is transparent: splice its children into this level rather than dropping
+    // the content or forcing it inline, so a consumer's stray <div>/<section> keeps its structure.
+    if (node.kind === 'el' && !BLOCK_TAGS.has(node.tag) && !VOID_TAGS.has(node.tag) && !INLINE_WRAP[node.tag]
+      && node.tag !== 'a' && node.tag !== 'li' && node.children.some(isBlockNode)) {
+      flushRun()
+      blocks.push(...renderBlocks(node.children, opts))
+      continue
+    }
+    if (node.kind !== 'el' || !BLOCK_TAGS.has(node.tag)) { run.push(node); continue }
+    flushRun()
+
+    const level = HEADINGS[node.tag]
+    if (level !== undefined) {
+      // A heading is one line by definition: a `<br>` inside it would end the heading and leave the rest
+      // as a bare paragraph, silently splitting the text an editor wrote as one title.
+      const text = renderInline(node.children).replace(/\s+/g, ' ').trim()
+      if (text) blocks.push(`${'#'.repeat(Math.min(6, level + (opts.headingOffset ?? 0)))} ${text}`)
+    } else if (node.tag === 'hr') {
+      blocks.push('---')
+    } else if (node.tag === 'pre') {
+      const code = rawText(node.children).replace(/^\n+|\n+$/g, '')
+      // Fence wider than any backtick run in the code, or the code closes the fence it sits in and
+      // everything after it — the rest of the page, and the pages after that — reparses as prose.
+      const fence = '`'.repeat(Math.max(3, longestRun(code, '`') + 1))
+      if (code) blocks.push(`${fence}\n${code}\n${fence}`)
+    } else if (node.tag === 'blockquote') {
+      const inner = renderBlocks(node.children, opts).join('\n\n')
+      if (inner) blocks.push(prefixLines(inner, '> ', '> '))
+    } else if (node.tag === 'ul' || node.tag === 'ol') {
+      const list = renderList(node, opts)
+      if (list) blocks.push(list)
+    } else {
+      const text = renderInline(node.children).trim()
+      if (text) blocks.push(escapeMarkdownBlock(text))
+    }
+  }
+  flushRun()
+  return blocks
+}
+
+function isBlockNode(node: MdNode): boolean {
+  return node.kind === 'el' && (BLOCK_TAGS.has(node.tag) || node.tag === 'li')
+}
+
+/** Sanitized richtext HTML → Markdown. Non-string / empty input, and markup that carries no words at
+ *  all, both yield `''` so a caller can drop the field without a second emptiness test. */
+export function richtextToMarkdown(html: string | null | undefined, opts: RichtextMarkdownOptions = {}): string {
+  if (typeof html !== 'string' || !html.trim()) return ''
+  return renderBlocks(parse(html), opts).join('\n\n')
+}

package/layers/public/server/utils/site-url.ts

@@ -30,3 +30,11 @@ export function siteDescription(): string {
   const fromRc = serverRuntimeConfig()?.kestrel as { siteDescription?: string } | undefined
   return (fromRc?.siteDescription ?? resolveServerKestrel().siteDescription ?? '').trim()
 }
+
+/** Whether `/llms-full.txt` is served, prerendered and published (`kestrel.seo.llmsFull`, default off).
+ *  Read the same two-tier way as every other server setting, so a consumed layer sees the CONSUMER's
+ *  config rather than Kestrel's own. */
+export function llmsFullEnabled(): boolean {
+  const fromRc = serverRuntimeConfig()?.kestrel as { seo?: { llmsFull?: boolean } } | undefined
+  return (fromRc?.seo?.llmsFull ?? resolveServerKestrel().seo.llmsFull) === true
+}

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

@@ -87,11 +87,13 @@ export function buildSitemap(entries: SitemapEntry[]): string {
   return `<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${xhtmlNs}>${urls}</urlset>`
 }
 
-export function buildRobots(opts: { sitemapUrl?: string; llmsUrl?: string } = {}): string {
+export function buildRobots(opts: { sitemapUrl?: string; llmsUrl?: string; llmsFullUrl?: string } = {}): string {
   const lines = ['User-agent: *', 'Allow: /']
-  // A comment (robots.txt has no standard llms directive) so crawlers that read robots also find the
-  // agent-oriented site map at /llms.txt. Kept above the blank-line-separated Sitemap directive.
+  // Comments (robots.txt has no standard llms directive) so crawlers that read robots also find the
+  // agent-oriented site map at /llms.txt — and its full-text long form when that is switched on.
+  // Kept above the blank-line-separated Sitemap directive.
   if (opts.llmsUrl) lines.push(`# llms.txt: ${opts.llmsUrl}`)
+  if (opts.llmsFullUrl) lines.push(`# llms-full.txt: ${opts.llmsFullUrl}`)
   if (opts.sitemapUrl) lines.push('', `Sitemap: ${opts.sitemapUrl}`)
   return `${lines.join('\n')}\n`
 }

package/layers/ui/app/components/field/Choice.vue

@@ -5,17 +5,22 @@ import UiFieldset from '../ui/Fieldset.vue'
 import UiSelect from '../ui/Select.vue'
 import UiButtonGroup from '../ui/ButtonGroup.vue'
 import UiCheckboxGroup from '../ui/CheckboxGroup.vue'
+import { resolveLocalized } from '../../utils/localized'
 import type { FieldComponentProps } from '../../utils/field-component'
 import type { FieldOf } from '../../../../core/server/utils/defineCollection'
 
 const props = defineProps<FieldComponentProps>()
 const model = defineModel<string | string[] | null>()
 
+const { lang } = useT()
+
 const cfg = computed(() => {
   if (props.field.type !== 'choice') return { choices: [] as { label: string; value: string }[], multiple: false, buttons: false }
   const o = (props.field as FieldOf<'choice'>).options
   return {
-    choices: o.choices,
+    // A choice label is `Localized` like every other author-supplied label. Resolving it HERE (not in the
+    // controls) is what keeps it out of the markup as a JSON blob — `{{ o.label }}` would stringify the map.
+    choices: o.choices.map((c) => ({ ...c, label: resolveLocalized(c.label, lang.value) ?? c.value })),
     multiple: !!o.multiple,
     buttons: o.display === 'buttons',
   }

package/layers/ui/app/components/field/Datetime.vue

@@ -59,10 +59,12 @@ const rangeEnd = computed<string | null>({
   <UiFieldset v-else :id="id" :label="name" :error="error" :required="required">
     <template #default="f">
       <template v-if="isTime">
+        <!-- eslint-disable-next-line vuejs-accessibility/label-has-for -- native wrapping label around a custom UiTimeInput; no `for`/`id` pair needed, invisible to static analysis -->
         <label class="field-datetime__sub">
           <span class="field-datetime__sublabel">{{ t('field.datetime.range_start') }}</span>
           <UiTimeInput v-model="rangeStart" :disabled="disabled" v-bind="f" />
         </label>
+        <!-- eslint-disable-next-line vuejs-accessibility/label-has-for -- native wrapping label around a custom UiTimeInput; no `for`/`id` pair needed, invisible to static analysis -->
         <label class="field-datetime__sub">
           <span class="field-datetime__sublabel">{{ t('field.datetime.range_end') }}</span>
           <UiTimeInput v-model="rangeEnd" :disabled="disabled" v-bind="f" />

package/layers/ui/app/components/field/Repeater.vue

@@ -126,6 +126,7 @@ function insertRowAt(at: number) {
       {{ name }}<span v-if="required" aria-hidden="true">*</span>
     </legend>
 
+    <!-- eslint-disable-next-line vuejs-accessibility/no-static-element-interactions -- @dragleave is a mouse-only progressive enhancement; the move-up/move-down buttons below give the same reorder fully keyboard access -->
     <div ref="rowsEl" class="ui-repeater__rows" @dragleave="onDragLeave">
       <template v-for="(row, i) in rows" :key="keys[i]">
         <div class="ui-repeater__insert-zone">
@@ -140,6 +141,7 @@ function insertRowAt(at: number) {
           </button>
         </div>
 
+        <!-- eslint-disable-next-line vuejs-accessibility/no-static-element-interactions -- drag handlers are a mouse-only progressive enhancement; the move-up/move-down buttons below give the same reorder fully keyboard access -->
         <div
           class="ui-repeater__row-wrap"
           :class="{ 'ui-repeater__row-wrap--over': overIndex === i && dragIndex !== i }"

package/layers/ui/app/components/ui/Checkbox.vue

@@ -25,6 +25,7 @@ watch(() => props.indeterminate, syncIndeterminate)
 </script>
 
 <template>
+  <!-- eslint-disable-next-line vuejs-accessibility/form-control-has-label -- id/label land via UiField's attrs fallthrough (single root element), invisible to static analysis -->
   <input
     ref="input"
     v-model="model"

package/layers/ui/app/components/ui/CheckboxGroup.vue

@@ -23,6 +23,7 @@ function toggle(value: string, checked: boolean) {
 
 <template>
   <div class="ui-checkbox-group" role="group">
+    <!-- eslint-disable-next-line vuejs-accessibility/label-has-for -- native wrapping label around a custom UiCheckbox; no `for`/`id` pair needed, invisible to static analysis -->
     <label v-for="o in options" :key="o.value" class="ui-checkbox-group__item">
       <UiCheckbox
         :model-value="selected.includes(o.value)"

package/layers/ui/app/components/ui/Combobox.vue

@@ -117,7 +117,9 @@ function moveChip(from: number, to: number) {
     class="ui-combobox"
   >
     <ComboboxAnchor class="ui-combobox__anchor" :data-multiple="multiple || undefined" :aria-invalid="invalid || undefined">
+      <!-- eslint-disable-next-line vuejs-accessibility/no-static-element-interactions, vuejs-accessibility/no-redundant-roles -- @dragleave is a mouse-only progressive enhancement (the chip-move buttons below give the same reorder fully keyboard access); role="list" is NOT redundant here, `list-style: none` below strips the implicit list semantics in WebKit, see the "WebKit list-semantics fix" test -->
       <ul v-if="multiple && selected.length" ref="chips" class="ui-combobox__chips" role="list" @dragleave="onDragLeave">
+        <!-- eslint-disable-next-line vuejs-accessibility/no-static-element-interactions -- drag handlers are a mouse-only progressive enhancement; the chip-move buttons below give the same reorder fully keyboard access -->
         <li
           v-for="(s, i) in selected"
           :key="s.value"

package/layers/ui/app/components/ui/Field.vue

@@ -22,6 +22,7 @@ const slotProps = computed(() => ({
 
 <template>
   <div class="ui-field" :data-invalid="error ? 'true' : undefined">
+    <!-- eslint-disable-next-line vuejs-accessibility/label-has-for -- the matching control is the default slot's content, invisible to static analysis across the slot boundary -->
     <label v-if="label" :for="fieldId" class="ui-field__label">
       {{ label }}<span v-if="required" class="ui-field__required" aria-hidden="true">*</span>
     </label>

package/layers/ui/app/components/ui/Fieldset.vue

@@ -10,7 +10,8 @@ const props = defineProps<{
   id?: string
 }>()
 
-const { fieldId, hintId, errId, describedby, ariaInvalid, ariaRequired } = useFieldA11y(props)
+// No `fieldId`: a group has no single control to point a label `for` at (see below).
+const { hintId, errId, describedby, ariaInvalid, ariaRequired } = useFieldA11y(props)
 
 // No `id` — a group has no single control to point a label `for` at; the
 // <legend> labels the group natively. Consumers spread these onto the group root.

package/layers/ui/app/components/ui/Icon.vue

@@ -17,7 +17,8 @@ const hasA11yName = computed(() => props.label != null || attrs.role != null ||
 <template>
   <!-- v-html body is either a static registry icon or developer-supplied SVG allowlist-sanitised by
        resolveIconBody → sanitizeIconSvg (no script-capable elements/attributes survive). -->
-  <svg
+  <!-- eslint-disable-next-line vue/no-v-html -- sanitized via resolveIconBody -> sanitizeIconSvg (allowlist-only tags/attrs) -->
+  <svg v-html="body"
     class="ui-icon"
     :data-icon="dataIcon"
     :width="dim"
@@ -31,7 +32,6 @@ const hasA11yName = computed(() => props.label != null || attrs.role != null ||
     :role="label ? 'img' : undefined"
     :aria-label="label || undefined"
     :aria-hidden="hasA11yName ? undefined : 'true'"
-    v-html="body"
   />
 </template>
 

package/layers/ui/app/components/ui/NumberInput.vue

@@ -55,6 +55,7 @@ function onKeydown(e: KeyboardEvent) {
 
 <template>
   <div v-if="suffix" class="ui-number-wrap" :class="{ 'ui-number-wrap--slim': slim }" :data-disabled="disabled || undefined">
+    <!-- eslint-disable-next-line vuejs-accessibility/form-control-has-label -- id/label land via v-bind="$attrs" from the wrapping UiField, invisible to static analysis -->
     <input
       v-model="text"
       type="number"
@@ -70,6 +71,7 @@ function onKeydown(e: KeyboardEvent) {
     >
     <span class="ui-number-wrap__suffix" aria-hidden="true">{{ suffix }}</span>
   </div>
+  <!-- eslint-disable-next-line vuejs-accessibility/form-control-has-label -- id/label land via v-bind="$attrs" from the wrapping UiField, invisible to static analysis -->
   <input
     v-else
     v-model="text"

package/layers/ui/app/components/ui/Richtext.vue

@@ -8,6 +8,7 @@ import { Superscript } from '@tiptap/extension-superscript'
 import { TextAlign } from '@tiptap/extension-text-align'
 import RichtextToolbar from './RichtextToolbar.vue'
 import { RichtextSpanClass, RichtextBlockClass } from '../../utils/richtext-preserve-class'
+import { RICHTEXT_LINK_SCHEME } from '../../../../fields/app/utils/richtext-links'
 
 const props = withDefaults(
   defineProps<{
@@ -24,6 +25,11 @@ const props = withDefaults(
 )
 const model = defineModel<string | null>()
 
+// TipTap emits `update` for non-content changes too — `setEditable`/`setOptions` emit directly, past the
+// transaction pipeline and its docChanged guard — and that echo reaches the edit form as a user edit.
+// Only a changed doc is one, so every emit is checked against the doc it last saw.
+let lastDoc: unknown = null
+
 // StarterKit (v3) already bundles Link + Underline; only the rest are added here.
 const editor = useEditor({
   content: model.value ?? '',
@@ -33,7 +39,13 @@ const editor = useEditor({
   extensions: [
     StarterKit.configure({
       heading: { levels: [1, 2, 3, 4, 5, 6] },
-      link: { openOnClick: false },
+      // `protocols`: the Link mark validates every href against its own scheme allowlist, which has no
+      // `kestrel:`. Without this it drops the whole anchor when stored content is loaded and makes the
+      // toolbar's `setLink` a silent no-op — opening and saving a record would destroy its internal links.
+      // `target`/`rel` null: the sanitizer owns that policy — it decorates absolute http(s) links and
+      // strips the attributes from every other kind. The mark's own defaults would stamp them on ANY
+      // anchor, so a stored internal/relative/mailto link came back changed and read as an unsaved edit.
+      link: { openOnClick: false, protocols: [RICHTEXT_LINK_SCHEME], HTMLAttributes: { target: null, rel: null } },
     }),
     Highlight,
     Subscript,
@@ -41,7 +53,12 @@ const editor = useEditor({
     TextAlign.configure({ types: ['heading', 'paragraph'] }),
     RichtextSpanClass, RichtextBlockClass, // preserve consumer presentational classes on round-trip
   ],
+  onCreate: ({ editor }) => {
+    lastDoc = editor.state.doc
+  },
   onUpdate: ({ editor }) => {
+    if (editor.state.doc === lastDoc) return
+    lastDoc = editor.state.doc
     model.value = editor.isEmpty ? '' : editor.getHTML()
   },
 })
@@ -53,10 +70,15 @@ watch(model, (value) => {
   const current = e.isEmpty ? '' : e.getHTML()
   // `emitUpdate: false`: this value came FROM the model, so re-emitting it would reach the edit form as
   // a user edit — clearing the redo stack and turning a restored null back into ''.
-  if (next !== current) e.commands.setContent(next, { emitUpdate: false })
+  if (next !== current) {
+    e.commands.setContent(next, { emitUpdate: false })
+    lastDoc = e.state.doc
+  }
 })
 
-watch(() => props.disabled, (d) => editor.value?.setEditable(!d))
+// `false` — the second arg suppresses the update event; `disabled` tracks the form's `saving` flag, so
+// the post-save toggle would otherwise re-dirty the form that was just rebaselined.
+watch(() => props.disabled, (d) => editor.value?.setEditable(!d, false))
 
 // Apply the accessible name + textbox semantics directly to the ProseMirror surface, reactively (the
 // error-driven describedby/invalid arrive after mount). `editor.view.dom` is the contenteditable element.

package/layers/ui/app/components/ui/Select.vue

@@ -17,6 +17,7 @@ const model = defineModel<string | null>()
 
 <template>
   <span class="ui-select">
+    <!-- eslint-disable-next-line vuejs-accessibility/form-control-has-label -- id/label land via v-bind="$attrs" from the wrapping UiField, invisible to static analysis -->
     <select v-model="model" :disabled="disabled" class="ui-select__field" v-bind="$attrs">
       <option v-if="placeholder" value="" disabled>{{ placeholder }}</option>
       <option v-for="o in options" :key="o.value" :value="o.value">{{ o.label }}</option>

package/layers/ui/app/components/ui/TextInput.vue

@@ -31,6 +31,7 @@ const inputType = computed(() => (revealable.value && revealed.value ? 'text' :
 
 <template>
   <div class="ui-input-wrap">
+    <!-- eslint-disable-next-line vuejs-accessibility/form-control-has-label -- id/label land via v-bind="$attrs" from the wrapping UiField, invisible to static analysis -->
     <input
       v-model="model"
       :type="inputType"

package/layers/ui/app/components/ui/Textarea.vue

@@ -12,6 +12,7 @@ const model = defineModel<string | null>()
 </script>
 
 <template>
+  <!-- eslint-disable-next-line vuejs-accessibility/form-control-has-label -- id/label land via Vue's default attrs fallthrough (single root element) from the wrapping UiField -->
   <textarea
     v-model="model"
     :rows="rows"

package/layers/ui/app/components/ui/TimeInput.vue

@@ -5,6 +5,7 @@ const model = defineModel<string | null>()
 </script>
 
 <template>
+  <!-- eslint-disable-next-line vuejs-accessibility/form-control-has-label -- id/label land via Vue's default attrs fallthrough (single root element) from the wrapping UiField -->
   <input v-model="model" type="time" :disabled="disabled" class="ui-time">
 </template>
 

package/layers/ui/app/i18n/de.ts

@@ -4,6 +4,7 @@ import type { Catalog } from '../composables/useT'
 export const de: Catalog = {
   'common.new': '{label} anlegen',
   'common.save': 'Speichern',
+  'common.publish': 'Veröffentlichen',
   'common.cancel': 'Abbrechen',
   'common.create': 'Erstellen',
   'common.delete': 'Löschen',
@@ -142,6 +143,11 @@ export const de: Catalog = {
   'pageSettings.statusPublished': 'Veröffentlicht',
 
   'editor.openInNewTab': 'In neuem Tab öffnen',
+  'editor.previewUnsaved': 'Ungespeicherte Änderungen in neuem Tab ansehen',
+  'editor.previewFailed': 'Vorschau konnte nicht geöffnet werden.',
+  'editor.publishFailed': 'Veröffentlichen fehlgeschlagen.',
+  'editor.publishNotGenerated': 'Statischer Output ist in dieser Umgebung aus — es wurde nichts geschrieben.',
+  'editor.publishDraft': 'Ein Entwurf hat keine öffentliche Seite. Zum Veröffentlichen den Status auf Veröffentlicht setzen.',
   // editor status light — LEFT lamp: ONE word + details tooltip (save/publish status)
   'editorStatus.word.saving': 'Speichert…',
   'editorStatus.word.unsaved': 'Ungespeichert',
@@ -156,12 +162,16 @@ export const de: Catalog = {
   // editor status light — RIGHT lamp: ONE word + details tooltip (static-page generation status)
   'editorStatus.word.live': 'Live',
   'editorStatus.word.generating': 'Generiert…',
+  'editorStatus.word.notPublished': 'Nicht veröffentlicht',
   'editorStatus.word.notBuilt': 'Nicht gebaut',
   'editorStatus.word.notLive': 'Nicht live',
   'editorStatus.word.error': 'Fehler',
+  'editorStatus.word.outdated': 'Veraltet',
   'editorStatus.live.liveS3': 'Live — Seite auf S3 abgelegt.',
   'editorStatus.live.liveLocal': 'Live — Seite in den statischen Output geschrieben.',
   'editorStatus.live.pending': 'Wird veröffentlicht…',
+  'editorStatus.live.outdated': 'Gespeichert, aber nicht veröffentlicht — live steht noch die zuletzt veröffentlichte Fassung.',
+  'editorStatus.live.notPublished': 'Nie veröffentlicht — mit Veröffentlichen kommt die Seite auf die Live-Site.',
   'editorStatus.live.notBuilt': 'In dieser Umgebung nicht generiert — die statische Seite wird beim Deploy gebaut.',
   'editorStatus.live.error': 'Generieren der statischen Seite fehlgeschlagen.',
   'editorStatus.live.draft': 'Entwurf — nicht generiert. Erscheint erst nach Veröffentlichung auf der Live-Seite.',
@@ -178,6 +188,12 @@ export const de: Catalog = {
   'editor.unsupported': 'Für den Typ „{type}“ ist kein Editor registriert.',
   'seo.socialImage': 'Social-Share-Bild',
   'seo.socialImageHint': 'Wird als Vorschaubild beim Teilen der Seite angezeigt (og:image).',
+  'seo.author': 'Autor/in',
+  'seo.authorHint': 'Wird in den strukturierten Daten der Seite als Verfasser/in veröffentlicht.',
+  'seo.publishedDate': 'Veröffentlichungsdatum',
+  'seo.publishedDateHint': 'Zeigt Such- und Antwortmaschinen, wie aktuell diese Seite ist.',
+  'seo.keywords': 'Schlagwörter',
+  'seo.keywordsHint': 'Themen dieser Seite, durch Kommas getrennt.',
 
   'localeBar.fieldLabel': 'Sprache',
   'localeBar.groupLabel': 'Inhaltssprache',
@@ -303,6 +319,13 @@ export const de: Catalog = {
   'mediaViewer.alt': 'Alt-Text',
   'mediaViewer.altHint': 'Beschreibt das Bild für Screenreader und SEO.',
   'mediaViewer.saveFailed': 'Alt-Text konnte nicht gespeichert werden.',
+  'mediaViewer.aiSourceTypeLabel': 'KI-Kennzeichnung',
+  'mediaViewer.aiSourceTypeHint': 'Wie diese Datei entstanden ist (EU-KI-Verordnung Art. 50). Leer lassen, wenn nichts zu kennzeichnen ist.',
+  'mediaViewer.aiSourceType.trainedAlgorithmicMedia': 'Vollständig KI-generiert',
+  'mediaViewer.aiSourceType.compositeWithTrainedAlgorithmicMedia': 'KI-Inhalt in echtes Material montiert',
+  'mediaViewer.aiSourceType.algorithmicallyEnhanced': 'KI-bearbeitet / algorithmisch verändert',
+  'mediaViewer.aiNote': 'Hinweis zur Kennzeichnung',
+  'mediaViewer.aiNoteHint': 'Freitext, z. B. das verwendete Werkzeug. Beim Upload gefundene KI-Signale werden vorausgefüllt — nur Indizien, kein geprüfter Nachweis.',
 
   // richtext toolbar
   'richtext.bold': 'Fett',