@christianirack/brainllm-runtime 0.1.0 → 0.3.1

package/README.md

@@ -1,5 +1,5 @@
 # @christianirack/brainllm-runtime
 
-The BRAINLLM runtime: dependency-free ES modules (signals, DOM, router, data, forms, channels, service worker, server).
+The runtime of [BRAINLLM](https://chrisifm.github.io/BRAINLLM/), the web compiler for LLMs built in Rust: dependency-free ES modules (signals, DOM, router, data, forms, channels, service worker, server).
 The `brain` binary embeds this same version and serves it at `/@brain/*`; install this package only for tooling that
 needs the modules on disk.

package/brain-ai.js

@@ -0,0 +1,129 @@
+// Built-in AI (Chrome's on-device Gemini Nano, INTERNALS §19, docs checked 2026-10-29): `ai` is a primitive, so a view
+// uses it without an import. Every call feature-detects the browser API; on the server or in a browser without it,
+// `ai.ready()` answers 'unavailable' and the other calls throw an Error with `code: 'unavailable'`, so the app decides
+// what to show instead. What the model does is up to the app: the runtime only opens the door.
+//   await ai.ready()                       'available' | 'downloadable' | 'downloading' | 'unavailable' (Prompt API)
+//   await ai.ready('summarizer')           same for summarizer, detector, writer, rewriter, proofreader
+//   await ai.ready('translator', { from: 'en', to: 'es' })   the translator needs its two languages
+//   await ai.prompt('Name three colors', { system, schema, signal, onProgress })   → string (stateless call)
+//   for await (const part of ai.stream('Tell a story')) …                          → text chunks as they arrive
+//   const chat = await ai.session({ system })   native session: chat.prompt(), append(), clone(), destroy()
+//   await ai.summarize(text, { type, format, length, context })                     → string
+//   await ai.translate(text, { from: 'en', to: 'es' })                              → string
+//   await ai.detect(text)                                                           → [{ detectedLanguage, confidence }]
+//   await ai.write(task) · ai.rewrite(text, { tone }) · ai.proofread(text)
+// Status (Chrome 138+ stable): Summarizer, Translator and LanguageDetector on the web; the Prompt API is an origin
+// trial on the web (Chrome 148) and stable in extensions; Writer, Rewriter and Proofreader are trials. The Prompt API
+// runs in the top window and same-origin iframes (`allow="language-model"` for others), not in Web Workers. A model
+// that is 'downloadable' starts downloading on the first create, which Chrome only allows after a user gesture: call
+// these from an event handler the first time; `onProgress(0..1)` follows the download.
+const G = globalThis
+const API = {
+  prompt: 'LanguageModel',
+  summarizer: 'Summarizer',
+  translator: 'Translator',
+  detector: 'LanguageDetector',
+  writer: 'Writer',
+  rewriter: 'Rewriter',
+  proofreader: 'Proofreader',
+}
+const native = kind => {
+  const name = API[kind]
+  if (!name) throw Error(`ai: unknown model \`${kind}\`; use one of ${Object.keys(API).join(', ')}`)
+  return G[name] || null
+}
+const missing = kind => Object.assign(Error(`Built-in AI is not available in this browser (${API[kind]})`), { code: 'unavailable' })
+
+// `{ from, to }` are the translator's languages, as in ai.translate (Translator.availability needs them)
+const langs = ({ from, to, ...o } = {}) => ({ ...o, ...(from ? { sourceLanguage: from } : {}), ...(to ? { targetLanguage: to } : {}) })
+async function ready(kind = 'prompt', options) {
+  const N = native(kind)
+  if (!N || !N.availability) return 'unavailable'
+  try {
+    return await N.availability(langs(options))
+  } catch {
+    return 'unavailable'
+  }
+}
+
+// create(options) with the download progress wired to onProgress (e.loaded is 0..1)
+async function create(kind, o = {}) {
+  const N = native(kind)
+  if (!N || !N.create) throw missing(kind)
+  const { onProgress, ...rest } = o
+  if (onProgress) rest.monitor = m => m.addEventListener('downloadprogress', e => onProgress(e.loaded))
+  return N.create(rest)
+}
+
+// one base session per system prompt; each stateless call works on a clone, so calls never share history
+const bases = new Map()
+async function base(o) {
+  const k = o.system || ''
+  if (!bases.has(k)) {
+    const p = create('prompt', { ...(o.system ? { initialPrompts: [{ role: 'system', content: o.system }] } : {}), ...(o.onProgress ? { onProgress: o.onProgress } : {}) })
+    p.catch(() => bases.delete(k))
+    bases.set(k, p)
+  }
+  return (await bases.get(k)).clone()
+}
+const opts = o => ({ ...(o.signal ? { signal: o.signal } : {}), ...(o.schema ? { responseConstraint: o.schema } : {}) })
+
+async function prompt(text, o = {}) {
+  const s = await base(o)
+  try {
+    const out = await s.prompt(text, opts(o))
+    return o.schema && typeof out === 'string' ? JSON.parse(out) : out
+  } finally {
+    s.destroy && s.destroy()
+  }
+}
+
+async function* stream(text, o = {}) {
+  const s = await base(o)
+  try {
+    for await (const part of s.promptStreaming(text, opts(o))) yield part
+  } finally {
+    s.destroy && s.destroy()
+  }
+}
+
+// a native session that keeps history (a chat); `system` becomes its first prompt
+const session = (o = {}) => {
+  const { system, ...rest } = o
+  return create('prompt', { ...(system ? { initialPrompts: [{ role: 'system', content: system }, ...(rest.initialPrompts || [])] } : {}), ...rest })
+}
+
+// one model per kind and options, created on first use and reused
+const tools = new Map()
+const tool = (kind, o) => {
+  const { onProgress, signal, ...rest } = o || {}
+  const k = kind + JSON.stringify(rest)
+  if (!tools.has(k)) {
+    const p = create(kind, { ...rest, ...(onProgress ? { onProgress } : {}) })
+    p.catch(() => tools.delete(k))
+    tools.set(k, p)
+  }
+  return tools.get(k)
+}
+const call = (kind, method, keys) => async (text, o = {}) => {
+  const make = {}, run = {}
+  for (const [k, v] of Object.entries(o)) (keys.includes(k) ? run : make)[k] = v
+  if (o.signal) run.signal = o.signal
+  return (await tool(kind, make))[method](text, run)
+}
+
+export const ai = {
+  ready,
+  prompt,
+  stream,
+  session,
+  summarize: call('summarizer', 'summarize', ['context']),
+  translate: (text, o = {}) => {
+    const { from, to, ...rest } = o
+    return call('translator', 'translate', ['signal'])(text, { sourceLanguage: from, targetLanguage: to, ...rest })
+  },
+  detect: call('detector', 'detect', []),
+  write: call('writer', 'write', ['context']),
+  rewrite: call('rewriter', 'rewrite', ['context']),
+  proofread: call('proofreader', 'proofread', []),
+}

package/brain-data.js

@@ -355,6 +355,8 @@ async function once(u, M, body, sg, pri, up) {
   } finally {
     release()
     if (low) LOW.delete(low)
+    // a write tells the router's prefetch that pages it fetched may be stale (§19)
+    if (M !== 'GET' && G.dispatchEvent && G.Event) G.dispatchEvent(new Event('brain:write'))
     if (G.__brainDev && G.dispatchEvent && G.CustomEvent) G.dispatchEvent(new CustomEvent('brain:net', { detail: { method: M, url, status: st, ms: Date.now() - t0, size: text.length } }))
   }
   let j

package/brain-form.js

@@ -15,7 +15,7 @@
 // Unsaved changes (§41.5): `f.dirty` is true while values differ from the last saved ones (init, reset() or a successful
 // submit); leaving the page (client navigation or closing the tab) then asks first. No API.
 import { sig, fx, batch, untrack, _rt } from './brain.js'
-import { rule, check } from './brain-schema.js'
+import { rule, check, msg } from './brain-schema.js'
 
 export { rule, check } // server.mjs validates posted forms with the same rules (§38)
 
@@ -23,7 +23,7 @@ const I = _rt()
 
 const D = globalThis.document
 let seq = 0
-const GENERIC = 'Something went wrong. Try again.' // the text callForm (server.mjs) shows without JS
+const GENERIC = 'Something went wrong. Try again.' // the text callForm (server.mjs) shows without JS (key form.error)
 // navigate through the client router when it is loaded (no reload, base path applied), else a normal load
 const go = u => {
   const G = globalThis
@@ -124,7 +124,7 @@ export function form(schema, o = {}) {
     checking.v++
     return Promise.resolve()
       .then(() => c(v))
-      .then(m => m || '', e => (e && e.kind === 'aborted' ? '' : (e && e.message) || 'Could not check this value.'))
+      .then(m => m || '', e => (e && e.kind === 'aborted' ? '' : (e && e.message) || msg('form.check_failed', 'Could not check this value.')))
       .then(m => {
         if (untrack(() => x.s.v) === v) x.e.v = m // a stale answer (the value changed meanwhile) is ignored
         return untrack(() => x.e.v)
@@ -165,9 +165,24 @@ export function form(schema, o = {}) {
     })
   }
 
+  // `f.v` and `f.err` are the form's live fields: replacing the object (`f.v = { … }`) would leave the inputs bound to
+  // signals the form no longer reads (submit then sees every field empty), so it fails loudly instead (§14, B0133)
+  const fixed = k => {
+    throw Error(`form: \`${k}\` cannot be replaced; start from values with form(schema, { init }) or load them later with f.reset(values)`)
+  }
   const f = {
-    v,
-    err,
+    get v() {
+      return v
+    },
+    set v(_) {
+      fixed('f.v')
+    },
+    get err() {
+      return err
+    },
+    set err(_) {
+      fixed('f.err')
+    },
     get busy() {
       return busy.v
     },
@@ -247,7 +262,7 @@ export function form(schema, o = {}) {
         if (x && x.errors) mark(x.errors)
         // a server failure reads the same as without JS: 4xx and the author's own errors keep their message; 5xx and a
         // TypeError (the network dropped, or a bug) get the generic one
-        else if (!(x && x.kind === 'aborted')) error.v = (x && x.message && !(x.status >= 500) && x.name !== 'TypeError' && x.message) || GENERIC
+        else if (!(x && x.kind === 'aborted')) error.v = (x && x.message && !(x.status >= 500) && x.name !== 'TypeError' && x.message) || msg('form.error', GENERIC)
       } finally {
         busy.v = false
         if (fm) fm.removeAttribute('aria-busy')

package/brain-mcp.js

@@ -5,6 +5,8 @@
 // parameters use form()'s mini-language and become a JSON Schema; arguments are validated before `run` is called and
 // a bad call answers with the field's message instead of running. Tools act with the page's permissions only:
 // anything destructive should still ask for confirmation in the UI.
+// Optional 5th argument (WebMCP draft 2026-10-27): { title, readOnly, consequential, untrusted } → `title` and
+// `annotations: { readOnlyHint, consequentialHint, untrustedContentHint }` on the registration; only the keys given.
 import { fx } from './brain.js'
 import { rule, check } from './brain-schema.js'
 
@@ -32,27 +34,40 @@ export function schema(params = {}) {
 
 const text = v => ({ content: [{ type: 'text', text: typeof v === 'string' ? v : JSON.stringify(v ?? null) }] })
 
-export function tool(name, description, params, run) {
+const HINTS = [['readOnly', 'readOnlyHint'], ['consequential', 'consequentialHint'], ['untrusted', 'untrustedContentHint']]
+
+// The registration dictionary: name, description, inputSchema, then title/annotations only when given.
+export function definition(name, description, params, opts) {
+  const def = { name, description, inputSchema: schema(params) }
+  if (!opts) return def
+  if (typeof opts.title === 'string' && opts.title) def.title = opts.title
+  let annotations = null
+  for (let i = 0; i < HINTS.length; i++) {
+    const v = opts[HINTS[i][0]]
+    if (v != null) (annotations || (annotations = {}))[HINTS[i][1]] = !!v
+  }
+  if (annotations) def.annotations = annotations
+  return def
+}
+
+export function tool(name, description, params, run, opts) {
   const mc = context()
   if (!mc || !mc.registerTool || G.__brainSSR || G.__brainRoute) return
   const rules = Object.fromEntries(Object.entries(params || {}).map(([k, s]) => [k, rule(s)]))
   fx(() => {
-    const reg = mc.registerTool({
-      name,
-      description,
-      inputSchema: schema(params),
-      async execute(args = {}) {
-        for (const k in rules) {
-          const m = check(rules[k], args[k])
-          if (m) return text(`${k}: ${m}`)
-        }
-        try {
-          return text(await run(args))
-        } catch (e) {
-          return text(`Error: ${(e && e.message) || e}`)
-        }
-      },
-    })
+    const def = definition(name, description, params, opts)
+    def.execute = async (args = {}) => {
+      for (const k in rules) {
+        const m = check(rules[k], args[k])
+        if (m) return text(`${k}: ${m}`)
+      }
+      try {
+        return text(await run(args))
+      } catch (e) {
+        return text(`Error: ${(e && e.message) || e}`)
+      }
+    }
+    const reg = mc.registerTool(def)
     return () => (reg && reg.unregister ? reg.unregister() : mc.unregisterTool && mc.unregisterTool(name))
   })
 }

package/brain-router.js

@@ -90,6 +90,7 @@ export function router(o = {}) {
   const region = o.region || 'main'
   const parse = o.parse || (h => new DOMParser().parseFromString(h, 'text/html'))
   let seq = 0, through = null, stale = false
+  const ahead = predict(o, u => same(u))
   // Build signature (§35.7): the page's <meta name="brain-build">. A navigation response from another build, or the
   // service worker announcing one, turns client navigation into full loads so old and new code never mix.
   const build = () => {
@@ -110,14 +111,20 @@ export function router(o = {}) {
     const url = new URL(u, location.href), path = strip(url.pathname) // guards see app paths (no base)
     for (const [pre, g] of gs) {
       if (!(path === pre || path.startsWith(pre.endsWith('/') ? pre : pre + '/'))) continue
-      let v
+      // The browser has no session (the cookie is HttpOnly): a guard that reads ctx.user cannot decide here. If it would
+      // stop the navigation, the server decides on a full load instead (F12b: `ctx.user ? true : redirect('/login')`
+      // used to send a signed-in user to /login on every client navigation).
+      let v, asked = false
+      const ctx = { url, path, query: Object.fromEntries(url.searchParams) }
+      Object.defineProperty(ctx, 'user', { enumerable: true, get: () => ((asked = true), undefined) })
       try {
-        v = await g({ url, path, query: Object.fromEntries(url.searchParams) })
+        v = await g(ctx)
       } catch (e) {
+        if (asked) return null
         return e && typeof e === 'object' && (R in e || 'redirect' in e) ? outcome(e) : null
       }
       v = outcome(v)
-      if (v !== true) return v
+      if (v !== true) return asked ? null : v
     }
     return true
   }
@@ -154,7 +161,7 @@ export function router(o = {}) {
       G.dispatchEvent && G.dispatchEvent(new Event('brain:navigate'))
     } catch {}
     try {
-      r = await fetch(url, { headers: { 'x-brain-nav': '1' } })
+      r = (await ahead.take(url)) || (await fetch(url, { headers: { 'x-brain-nav': '1' } }))
       const b = r.headers && r.headers.get && r.headers.get('x-brain-build')
       if (b && build() && b !== build()) return void (my === seq && hard(url)) // a new deploy: load it whole
       const ct = (r.headers && r.headers.get && r.headers.get('content-type')) || 'text/html'
@@ -216,6 +223,7 @@ export function router(o = {}) {
       if (pb && document.head) document.head.appendChild(document.adoptNode ? document.adoptNode(pb) : pb)
       routed()
       current()
+      ahead.scan()
     }
     if (document.startViewTransition) {
       const vt = document.startViewTransition(swap)
@@ -261,10 +269,11 @@ export function router(o = {}) {
       })
     }
     nav.addEventListener('navigate', h)
+    ahead.scan()
     return (active = {
       go: (u, how) => nav.navigate(app(u), how === 'replace' ? { history: 'replace' } : undefined),
       check,
-      stop: () => ((active = null), nav.removeEventListener('navigate', h), sw && sw.removeEventListener && sw.removeEventListener('message', onMsg)),
+      stop: () => ((active = null), ahead.stop(), nav.removeEventListener('navigate', h), sw && sw.removeEventListener && sw.removeEventListener('message', onMsg)),
     })
   }
 
@@ -305,13 +314,154 @@ export function router(o = {}) {
   }
   document.addEventListener('click', click)
   G.addEventListener && G.addEventListener('popstate', pop)
+  ahead.scan()
   return (active = {
     go: (u, push = true) => go(app(u), push),
     check,
-    stop: () => ((active = null), document.removeEventListener('click', click), G.removeEventListener && G.removeEventListener('popstate', pop)),
+    stop: () => ((active = null), ahead.stop(), document.removeEventListener('click', click), G.removeEventListener && G.removeEventListener('popstate', pop)),
   })
 }
 
+// Predictive prefetch (§19, 2026-10-29): no dead time during a visit. Every internal link that scrolls into view is
+// fetched in the background while the browser is idle (at most 2 at a time, 12 per page), and hovering, focusing or
+// touching a link moves it to the front of the queue. The fetched page is kept in memory and the next navigation to it
+// swaps without waiting for the network; its module chunks get `<link rel=modulepreload>` so the view mounts at once.
+// The current view never waits: requests run at low priority and only when idle. Skipped: Save-Data and 2G (only
+// intent prefetches there, and never with Save-Data), `data-prefetch="false"` on the link or an ancestor, download or
+// target links, files (`.pdf`, `.zip`…), `/api/` and `/auth/`, action-style paths (log out, unsubscribe, confirm,
+// verify), URLs carrying a token in the query, and everything with `router({ prefetch: false })` or
+// `<meta name="brain-prefetch" content="off">`. A page served `private`/`no-store` is reused for 30 s, others for 5 min,
+// and any write empties the memory first: a form submit, a `brain:write` (brain-data writes, every server function
+// call, log-out included), so the next view never shows data from before the write or another session. Each fetch says
+// `x-brain-prefetch: 1` (`ctx.prefetch` in the server's `load`), so a server can tell it apart from a click.
+const FRESH = 300000, FRESH_PRIVATE = 30000, MAX_PAGE = 12, MAX_KEPT = 24, PARALLEL = 2
+const NOPE = /(^|\/)(log-?out|sign-?out|logoff|unsubscribe|confirm|verify|api|auth)(\.html?)?(\/|$)/i
+const FILE = /\.(?!html?$)[a-z0-9]{2,5}$/i
+const SECRET = /(^|[?&])(token|code|key|sig|signature|auth|otp|state)=/i
+export function predict(o = {}, same = () => false) {
+  const off = { scan() {}, stop() {}, take: async () => null }
+  const meta = G.document && document.querySelector && document.querySelector('meta[name=brain-prefetch]')
+  if (o.prefetch === false || (meta && /^(off|false|0)$/i.test(meta.getAttribute('content') || '')) || !G.document || !G.fetch) return off
+  const net = G.navigator && navigator.connection
+  const thin = () => !!net && (net.saveData || /(^|-)2g$/.test(net.effectiveType || ''))
+  const cache = new Map(), queue = [], seen = new WeakSet(), pre = new Set()
+  let busy = 0, count = 0, io = null, idle = 0
+  const key = h => {
+    try {
+      const u = new URL(h, location.href)
+      u.hash = ''
+      return u.href
+    } catch {
+      return null
+    }
+  }
+  const ok = a => {
+    if (!a || !a.getAttribute || !a.getAttribute('href') || a.getAttribute('target') || a.hasAttribute('download')) return null
+    for (let n = a; n && n.getAttribute; n = n.parentNode) if (n.getAttribute('data-prefetch') === 'false') return null
+    const k = key(a.href || a.getAttribute('href'))
+    if (!k || !same(k) || k === key(location.href)) return null
+    const u = new URL(k)
+    if (NOPE.test(u.pathname) || FILE.test(u.pathname) || SECRET.test(u.search)) return null
+    return k
+  }
+  // the next page's chunks: module scripts and static imports in its HTML
+  const chunks = html => {
+    if (!document.head) return
+    const re = /<script[^>]+type="module"[^>]+src="([^"]+)"|\bfrom\s*"([^"]+\.js)"|\bimport\(\s*"([^"]+\.js)"\s*\)/g
+    let m, n = 0
+    while ((m = re.exec(html)) && n < 8) {
+      const u = key(m[1] || m[2] || m[3])
+      if (!u || pre.has(u) || !same(u)) continue
+      pre.add(u), n++
+      const l = document.createElement('link')
+      l.setAttribute('rel', 'modulepreload')
+      l.setAttribute('href', u)
+      document.head.appendChild(l)
+    }
+  }
+  // drop what expired, then the oldest past MAX_KEPT (a Map keeps insertion order)
+  const prune = () => {
+    const now = Date.now()
+    for (const [k, c] of cache) if (now - c.at > FRESH) cache.delete(k)
+    for (const k of cache.keys()) if (cache.size >= MAX_KEPT) cache.delete(k)
+  }
+  const get = k => {
+    prune()
+    const at = Date.now()
+    const p = fetch(k, { headers: { 'x-brain-nav': '1', 'x-brain-prefetch': '1' }, priority: 'low', credentials: 'same-origin' })
+      .then(async r => {
+        const ct = (r.headers && r.headers.get && r.headers.get('content-type')) || 'text/html'
+        if (!r.ok || !/html/.test(ct)) return null
+        const text = await r.text()
+        chunks(text)
+        const cc = (r.headers.get && r.headers.get('cache-control')) || ''
+        // a stand-in for the Response that load() reads: headers, status, redirect and the body once per use
+        return { ok: r.ok, status: r.status, redirected: r.redirected, url: r.url, headers: r.headers, text: async () => text, ttl: /private|no-store/i.test(cc) ? FRESH_PRIVATE : FRESH }
+      })
+      .catch(() => null)
+    cache.set(k, { at, p })
+    return p
+  }
+  const pump = () => {
+    while (busy < PARALLEL && queue.length) {
+      const k = queue.shift()
+      if (cache.has(k)) continue
+      busy++
+      get(k).finally(() => (busy--, pump()))
+    }
+  }
+  const later = f => (G.requestIdleCallback ? G.requestIdleCallback(f, { timeout: 2000 }) : setTimeout(f, 200))
+  const want = (k, now) => {
+    if (!k || cache.has(k)) return
+    const i = queue.indexOf(k)
+    if (i >= 0) queue.splice(i, 1)
+    if (now) queue.unshift(k), pump()
+    else if (count < MAX_PAGE) count++, queue.push(k), idle || (idle = 1) && later(() => ((idle = 0), pump()))
+  }
+  const intent = e => {
+    if (net && net.saveData) return
+    let a = e.target
+    while (a && a.tagName !== 'A') a = a.parentNode
+    want(ok(a), true)
+  }
+  const evs = ['pointerover', 'focusin', 'touchstart']
+  for (const t of evs) document.addEventListener(t, intent, { passive: true, capture: true })
+  // a write makes every fetched page possibly stale (or another session's after log-out): forget them all
+  const forget = () => ((queue.length = 0), cache.clear())
+  document.addEventListener('submit', forget, { capture: true })
+  if (G.addEventListener) G.addEventListener('brain:write', forget)
+  if (G.IntersectionObserver)
+    io = new IntersectionObserver(
+      es => {
+        for (const e of es) if (e.isIntersecting) io.unobserve(e.target), thin() || want(ok(e.target), false)
+      },
+      { rootMargin: '200px' }
+    )
+  return {
+    scan() {
+      count = 0
+      queue.length = 0 // the previous view's links are no longer the likely next step
+      if (!io) return
+      for (const a of document.querySelectorAll('a[href]')) if (!seen.has(a)) seen.add(a), io.observe(a)
+    },
+    stop() {
+      io && io.disconnect()
+      for (const t of evs) document.removeEventListener(t, intent, { capture: true })
+      document.removeEventListener('submit', forget, { capture: true })
+      G.removeEventListener && G.removeEventListener('brain:write', forget)
+      cache.clear()
+    },
+    // the prefetched page for this URL when it is still fresh (used once: a later visit fetches again)
+    async take(u) {
+      const k = key(u), c = k && cache.get(k)
+      if (!c) return null
+      cache.delete(k)
+      const r = await c.p
+      return r && Date.now() - c.at < r.ttl ? r : null
+    },
+  }
+}
+
 const HOLD = ['click', 'submit']
 function hold(el) {
   if (el.$hold) el.$hold() // a newer navigation drops what the previous page held

package/brain-rpc.js

@@ -10,6 +10,9 @@ export async function rpc(id, a, oops, base) {
     j = t ? JSON.parse(t) : undefined
   } catch (e) {
     throw (oops(e, null, 'rpc'), e)
+  } finally {
+    // a server function may write or change the session: pages the router prefetched may be stale (§19)
+    if (globalThis.dispatchEvent && globalThis.Event) globalThis.dispatchEvent(new Event('brain:write'))
   }
   if (r.ok) return j
   const e = Object.assign(Error((j && j.error) || 'rpc ' + id + ': ' + r.status), { code: 'rpc', status: r.status, id, errors: j && j.errors })

package/brain-schema.js

@@ -3,6 +3,30 @@
 // Per field: `str num bool email url date` + `!` required + `<=N >=N` (length for str and lists, value for num) + `[T]`
 // list of T, or a nested schema object.
 const RX_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+const G = globalThis
+
+// Validation messages (§14, §37): the app's dictionary wins when it has the key (`"form.required": "Obligatorio"` in
+// i18n/<locale>.json; plural objects allowed for keys with `{n}`), else the English text. The table is read directly
+// (globalThis.__brainDict, filled by brain-i18n.js `add`) so a page that only validates does not load brain-i18n.js.
+// Keys: form.required form.list form.min_items form.max_items form.item form.number form.min form.max form.email
+// form.url form.date form.min_chars form.max_chars.
+export function msg(key, en, vars) {
+  const D = G.__brainDict
+  if (D) {
+    const h = G.document && G.document.documentElement
+    const loc = G.__brainLocale || (h && h.getAttribute('lang')) || 'en'
+    const def = (h && h.getAttribute('data-default-lang')) || 'en'
+    let m = (D[loc] && D[loc][key]) ?? (D[def] && D[def][key])
+    if (m != null) {
+      if (typeof m === 'object') {
+        const n = vars && vars.n
+        m = m['=' + n] ?? m[new Intl.PluralRules(loc).select(+n || 0)] ?? m.other ?? en
+      }
+      return vars ? String(m).replace(/\{(\w+)\}/g, (s, k) => (k in vars ? String(vars[k]) : s)) : String(m)
+    }
+  }
+  return en
+}
 
 // 'str!<=80' → { t: 'str', req: true, min, max, list: false }
 export function rule(s) {
@@ -23,47 +47,47 @@ const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`
 // Message for one value, or '' when valid.
 export function check(r, v) {
   if (r.list) {
-    if (empty(v)) return r.req || r.min > 0 ? (r.req && !r.min ? 'Required' : `Choose at least ${r.min}`) : ''
-    if (!Array.isArray(v)) return 'Must be a list'
-    if (r.min != null && v.length < r.min) return `Choose at least ${r.min}`
-    if (r.max != null && v.length > r.max) return `At most ${plural(r.max, 'item')}`
+    if (empty(v)) return r.req || r.min > 0 ? (r.req && !r.min ? msg('form.required', 'Required') : msg('form.min_items', `Choose at least ${r.min}`, { n: r.min })) : ''
+    if (!Array.isArray(v)) return msg('form.list', 'Must be a list')
+    if (r.min != null && v.length < r.min) return msg('form.min_items', `Choose at least ${r.min}`, { n: r.min })
+    if (r.max != null && v.length > r.max) return msg('form.max_items', `At most ${plural(r.max, 'item')}`, { n: r.max })
     const one = { ...r, list: false, req: true, min: null, max: null }
     for (let i = 0; i < v.length; i++) {
       const e = check(one, v[i])
-      if (e) return `Item ${i + 1}: ${e}`
+      if (e) return msg('form.item', `Item ${i + 1}: ${e}`, { n: i + 1, error: e })
     }
     return ''
   }
-  if (r.t === 'bool') return r.req && v !== true ? 'Required' : ''
-  if (empty(v)) return r.req ? 'Required' : ''
+  if (r.t === 'bool') return r.req && v !== true ? msg('form.required', 'Required') : ''
+  if (empty(v)) return r.req ? msg('form.required', 'Required') : ''
   const s = String(v)
   switch (r.t) {
     case 'num': {
       const n = typeof v === 'number' ? v : s.trim() === '' ? NaN : Number(s)
-      if (!Number.isFinite(n)) return 'Enter a number'
-      if (r.min != null && n < r.min) return `Must be at least ${r.min}`
-      if (r.max != null && n > r.max) return `Must be at most ${r.max}`
+      if (!Number.isFinite(n)) return msg('form.number', 'Enter a number')
+      if (r.min != null && n < r.min) return msg('form.min', `Must be at least ${r.min}`, { n: r.min })
+      if (r.max != null && n > r.max) return msg('form.max', `Must be at most ${r.max}`, { n: r.max })
       return ''
     }
     case 'email':
-      if (!RX_EMAIL.test(s)) return 'Enter a valid email'
+      if (!RX_EMAIL.test(s)) return msg('form.email', 'Enter a valid email')
       break
     case 'url':
       try {
-        if (!/^https?:$/.test(new URL(s).protocol)) return 'Enter a valid URL'
+        if (!/^https?:$/.test(new URL(s).protocol)) return msg('form.url', 'Enter a valid URL')
       } catch {
-        return 'Enter a valid URL'
+        return msg('form.url', 'Enter a valid URL')
       }
       break
     case 'date':
-      if (Number.isNaN(Date.parse(s))) return 'Enter a valid date'
+      if (Number.isNaN(Date.parse(s))) return msg('form.date', 'Enter a valid date')
       return ''
     case 'str':
       break
     default:
       throw Error(`form: unknown type '${r.t}'`)
   }
-  if (r.min != null && s.length < r.min) return `At least ${plural(r.min, 'character')}`
-  if (r.max != null && s.length > r.max) return `At most ${plural(r.max, 'character')}`
+  if (r.min != null && s.length < r.min) return msg('form.min_chars', `At least ${plural(r.min, 'character')}`, { n: r.min })
+  if (r.max != null && s.length > r.max) return msg('form.max_chars', `At most ${plural(r.max, 'character')}`, { n: r.max })
   return ''
 }

package/brain.js

@@ -278,7 +278,7 @@ export function attr(el, k, f) {
     f,
     k.startsWith('style:')
       ? ((k = k.slice(6)), v => (v == null || v === false ? el.style.removeProperty(k) : el.style.setProperty(k, v)))
-      : /^(value|checked|selected)$/.test(k)
+      : /^(value|checked|selected)$/.test(k) && !(k == 'value' && el.tagName == 'OPTION') // an option's value is its attribute (SSR, value="")
         ? v => {
             if (el[k] !== v) el[k] = v
           }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@christianirack/brainllm-runtime",
-  "version": "0.1.0",
-  "description": "The BRAINLLM runtime: dependency-free ES modules (signals, DOM, router, data, forms, channels). The brain binary embeds this same version.",
+  "version": "0.3.1",
+  "description": "The BRAINLLM runtime for the Rust-built web compiler for LLMs: dependency-free ES modules (signals, DOM, router, data, forms, channels). The brain binary embeds this same version.",
   "type": "module",
   "exports": {
     ".": "./brain.js",

package/server/server.mjs

@@ -43,6 +43,8 @@ const SECURITY = {
   'x-frame-options': 'DENY',
   'permissions-policy': 'camera=(), microphone=(), geolocation=(), payment=(), usb=()',
   'cross-origin-opener-policy': 'same-origin',
+  // what serves the app and where it lives, for crawlers and LLMs that read headers (no version: that stays in the HTML)
+  'x-powered-by': 'BRAINLLM (https://chrisifm.github.io/BRAINLLM/)',
 }
 // The build's policy (manifest `csp`, without hashes: the same one static hosting uses) plus this response's nonce in
 // script-src; without it, a default that lets api() reach HTTPS APIs of other origins.
@@ -155,6 +157,8 @@ export function createServer(o = {}) {
     const { user, session: ses } = sessionFrom(cookies, secret)
     return {
       url, query: Object.fromEntries(url.searchParams), cookies, user, session: ses, env,
+      // `prefetch`: the router fetched this page ahead of a click (§19); a `load` with side effects can skip them
+      prefetch: req.headers['x-brain-prefetch'] === '1',
       req: { method: req.method, headers: req.headers, ip: ipOf(req) }, ...extra,
     }
   }
@@ -218,6 +222,10 @@ export function createServer(o = {}) {
     }
     if (!nocache && route.cache > 0 && !forms && !fixed && status === 200 && anonymous(req)) return cached(req, res, route, params, url, rid)
     const ctx = context(req, res, url, { params })
+    // a page rendered for a signed-in user is never stored (§35): after logout, Back must not show the previous
+    // user's page from the HTTP cache or bfcache. Anonymous pages keep `no-cache` + ETag.
+    const own = ctx.user != null || ctx.cookies[COOKIE] !== undefined
+    const keep = h => (own ? { ...h, 'cache-control': 'private, no-store' } : h)
     let props = fixed || {}, extra = {}
     if (!fixed && ((route.guards && route.guards.length) || (route.middleware && route.middleware.length))) {
       let r
@@ -234,7 +242,7 @@ export function createServer(o = {}) {
       if (r.deny !== undefined) return forbidden(req, res, url, rid, r.deny)
       extra = r.headers
     }
-    if (route.stream && route.server && !fixed && !forms && status === 200 && !res.$capture) return streamed(req, res, route, params, url, rid, ctx, extra)
+    if (route.stream && route.server && !fixed && !forms && status === 200 && !res.$capture) return streamed(req, res, route, params, url, rid, ctx, keep(extra || {}))
     try {
       if (!fixed && route.server) {
         const m = await load(route.server)
@@ -242,12 +250,13 @@ export function createServer(o = {}) {
       }
     } catch (e) {
       if (e && e.redirect) return send(res, e.status || 303, '', { location: withBase(e.redirect), ...ctx.session.headers() })
-      if (e instanceof HttpError && e.status === 404) return notFound(req, res)
+      if ((e instanceof HttpError && e.status === 404) || (e && e.notFound === true)) return notFound(req, res) // `throw notFound()` (F11)
       const status = e instanceof HttpError && e.status === 504 ? 504 : 500
       log('error', 'load failed', { rid, path: url.pathname, status, stack: String((e && e.stack) || e) })
       return status === 500 ? errorPage(req, res, route, params, url, rid) : failPage(res, status, rid)
     }
     if (props && props.redirect) return send(res, props.status || 303, '', { location: withBase(props.redirect), ...ctx.session.headers() })
+    if (props && props.notFound === true) return notFound(req, res) // `return notFound()` (F11)
     let body, seo, failed
     try {
       const at = { path: url.pathname, params: params || {}, query: Object.fromEntries(url.searchParams) } // route() (§41.5)
@@ -261,12 +270,12 @@ export function createServer(o = {}) {
     const page = readFileSync(file(route.page), 'utf8')
       .replace('<!--brain:ssr-->', () => body)
       .replace('<!--brain:props-->', () => jsonInHtml(props))
-    let out = head(page, seo)
+    let out = head(page, seo, url.pathname)
     // route params for route() in the browser (the client has no route table)
     if (params && Object.keys(params).length) out = out.replace('</head>', () => `<meta name="brain-params" content="${esc(JSON.stringify(params))}"></head>`)
     if (forms) out = out.replace('</body>', () => `<script type="application/json" id="brain-forms">${jsonInHtml(forms)}</script></body>`)
-    if (res.$capture) return res.$capture(out, { ...extra, ...ctx.session.headers() }, status)
-    html(res, status, out, { ...extra, ...ctx.session.headers() }, 'W/"' + tag(out) + '"')
+    if (res.$capture) return res.$capture(out, keep({ ...extra, ...ctx.session.headers() }), status)
+    html(res, status, out, keep({ ...extra, ...ctx.session.headers() }), own ? undefined : 'W/"' + tag(out) + '"')
   }
   // Streaming SSR (#232, `route.stream`: the build sets it when the view's <meta seo> is static and it has a load()):
   // the page up to the region (head, CSS, layout shell) is sent at once, the view when load() ends. The status and
@@ -293,7 +302,7 @@ export function createServer(o = {}) {
     const loadP = typeof sm.load === 'function' ? withTimeout(Promise.resolve().then(() => sm.load(ctx)), TIMEOUT) : Promise.resolve(null)
     loadP.catch(() => {}) // handled below; never an unhandled rejection while the loading view renders
     const at = { path: url.pathname, params: params || {}, query: Object.fromEntries(url.searchParams) }
-    res.write(n(head(top, seo0)))
+    res.write(n(head(top, seo0, url.pathname)))
     // QA #253: the folder's _loading.brain goes in the region with the first chunk (SPEC: shows while load runs),
     // between two marker comments; the last chunk starts with a script that removes them and what is between
     let clear = ''
@@ -322,9 +331,11 @@ export function createServer(o = {}) {
     let props
     try {
       props = (await loadP) ?? {}
-      if (props.redirect) throw props
+      if (props.redirect || props.notFound === true) throw props
     } catch (e) {
       if (e && e.redirect) return end(`<script>location.replace(${jsonInHtml(withBase(e.redirect))})</script>`)
+      // a streamed page already sent its 200 head: the region gets the not-found notice and the page is noindex
+      if (e && e.notFound === true) return end(`<meta name="robots" content="noindex"><p role="alert" class="brain-fallback">Page not found.</p>`, {}, bottom.replace(/<script type="module">(?:(?!<\/script>)[\s\S])*?brain-view[\s\S]*?<\/script>/g, ''))
       log('error', 'load failed (streamed)', { rid, path: url.pathname, status: 200, stack: String((e && e.stack) || e) }) // headers already out
       return fail()
     }
@@ -483,7 +494,92 @@ export function createServer(o = {}) {
     plain(r.status, r.body.error, r.headers)
   }
 
+  // ---------- dynamic sitemap (§32) ----------
+  // A dynamic view without paths() can export `sitemap()` (manifest route `sitemap: true`): it returns the params of its
+  // pages, plus an optional `lastmod`, at request time. /sitemap.xml is the build's file with those URLs added (a sitemap
+  // index gets one more child, /sitemap-dynamic.xml). A file holds at most 50 000 URLs (sitemaps.org): when the build's
+  // URLs plus the dynamic ones pass that, /sitemap.xml becomes an index of /sitemap-static.xml (the build's file) and
+  // /sitemap-dynamic.xml; dynamic URLs past 50 000 are dropped with a warning. Absolute URLs take the origin of the
+  // build's sitemap (brain.json `site`); a build without a sitemap serves none. The list is kept 5 min (one sitemap() run
+  // at a time when it expires) and the response says max-age=300; a sitemap() that throws is logged and skipped.
+  const DYN = routes.filter(r => r.sitemap && r.server)
+  let dynList = null
+  const fill = (pattern, p) => {
+    let ok = true
+    const out = pattern.replace(/([:*])(\w+)/g, (_, k, n) => {
+      const v = p && p[n]
+      if (v == null || v === '') return (ok = false), ''
+      return k === '*' ? String(v).split('/').map(encodeURIComponent).join('/') : encodeURIComponent(String(v))
+    })
+    return ok ? out : null
+  }
+  const day = v => (v instanceof Date ? v.toISOString().slice(0, 10) : typeof v === 'string' && /^\d{4}-\d{2}-\d{2}/.test(v) ? v : null)
+  const MAX_URLS = 50000
+  let dynRun = null
+  async function collect(origin) {
+    const urls = []
+    let dropped = 0
+    for (const r of DYN) {
+      try {
+        const sm = await load(r.server)
+        const list = typeof sm.sitemap === 'function' ? await withTimeout(Promise.resolve().then(() => sm.sitemap({ env })), TIMEOUT) : []
+        for (const p of Array.isArray(list) ? list : []) {
+          const path = fill(r.path, p)
+          if (!path) continue
+          if (urls.length < MAX_URLS) urls.push({ loc: origin + withBase(path), lastmod: day(p.lastmod) })
+          else dropped++
+        }
+      } catch (e) {
+        log('error', 'sitemap() failed', { view: r.view, stack: String((e && e.stack) || e) })
+      }
+    }
+    if (dropped) log('warn', 'sitemap(): more than 50000 URLs, the rest are not listed', { dropped })
+    dynList = { at: Date.now(), urls }
+    return urls
+  }
+  async function dynamicUrls(origin) {
+    if (dynList && Date.now() - dynList.at < 300000) return dynList.urls
+    // concurrent requests after expiry share one run of every sitemap()
+    if (!dynRun) dynRun = collect(origin).finally(() => (dynRun = null))
+    return dynRun
+  }
+  async function serveSitemap(req, res, url) {
+    const f = file('/sitemap.xml')
+    if (!f) return false
+    const text = readFileSync(f, 'utf8')
+    const origin = [...text.matchAll(/<loc>(https?:\/\/[^<]+)<\/loc>/g)].map(m => URL.canParse(m[1]) && new URL(m[1]).origin).find(Boolean)
+    if (!origin) return false
+    const index = text.includes('<sitemapindex')
+    const urls = await dynamicUrls(origin)
+    // a urlset that would pass 50 000 URLs with the dynamic ones is split: index → static file + dynamic file
+    const split = !index && (text.match(/<url>/g) || []).length + urls.length > MAX_URLS
+    const xml = body => send(res, 200, req.method === 'HEAD' ? '' : body, { 'content-type': MIME['.xml'], 'cache-control': 'public, max-age=300' })
+    if (url.pathname === '/sitemap-static.xml') return split ? (xml(text), true) : false
+    if (url.pathname === '/sitemap-dynamic.xml' && !index && !split) return false
+    const child = p => `  <sitemap><loc>${esc(origin + withBase(p))}</loc></sitemap>\n`
+    const set = urls.map(u => `  <url><loc>${esc(u.loc)}</loc>${u.lastmod ? `<lastmod>${esc(u.lastmod)}</lastmod>` : ''}</url>\n`).join('')
+    xml(
+      url.pathname === '/sitemap-dynamic.xml'
+        ? `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${set}</urlset>\n`
+        : index
+          ? text.replace('</sitemapindex>', `${child('/sitemap-dynamic.xml')}</sitemapindex>`)
+          : split
+            ? `<?xml version="1.0" encoding="UTF-8"?>\n<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${child('/sitemap-static.xml')}${child('/sitemap-dynamic.xml')}</sitemapindex>\n`
+            : text.replace('</urlset>', set + '</urlset>'),
+    )
+    return true
+  }
+
   // ---------- static ----------
+  // §33 content negotiation: `Accept` preferring text/markdown gets the page's Markdown twin (`/pricing` → pricing.md,
+  // `/` → index.md) when the build published one (`seo.markdown`, default true; never for noindex pages).
+  function serveTwin(req, res, url) {
+    if (!prefersMarkdown(req.headers.accept)) return false
+    const md = file(mdPath(decodeURIComponent(url.pathname)))
+    if (!md) return false
+    send(res, 200, req.method === 'HEAD' ? '' : readFileSync(md), { 'content-type': MIME['.md'], 'cache-control': 'public, max-age=3600', vary: 'accept' })
+    return true
+  }
   function serveStatic(req, res, url) {
     let p = decodeURIComponent(url.pathname)
     const candidates = p.endsWith('/') ? [p + 'index.html'] : [p, p + '.html', p + '/index.html']
@@ -492,9 +588,12 @@ export function createServer(o = {}) {
       if (!f) continue
       const ext = extname(f), type = FEEDS[basename(f)] || MIME[ext] || 'application/octet-stream'
       if (ext === '.html') {
+        // §33: the page's Markdown twin (`/pricing` → pricing.md) when the client prefers text/markdown
+        if (serveTwin(req, res, url)) return true
+        const md = file(mdPath(p))
         const page = readFileSync(f, 'utf8')
         // static HTML changes only with a deploy: its ETag is the build signature (content hash without a manifest)
-        return html(res, 200, page, {}, '"' + (mf.build || tag(page)) + '"'), true
+        return html(res, 200, page, md ? { vary: 'accept' } : {}, '"' + (mf.build || tag(page)) + '"'), true
       }
       const headers = {
         'content-type': type,
@@ -552,9 +651,11 @@ export function createServer(o = {}) {
         if (!m) continue
         // a form page without load is prerendered: GET serves that file (build ETag); only its POST needs the server
         if (!post && route.forms && serveStatic(req, res, url)) return
+        if (!post && serveTwin(req, res, url)) return
         return await (post ? formPost : ssr)(req, res, route, m.groups ? { ...m.groups } : {}, url, rid)
       }
       if (post) return send(res, 405, 'Method not allowed', { allow: 'GET, HEAD' })
+      if (DYN.length && (url.pathname === '/sitemap.xml' || url.pathname === '/sitemap-dynamic.xml' || url.pathname === '/sitemap-static.xml') && (await serveSitemap(req, res, url))) return
       if (serveStatic(req, res, url)) return
       notFound(req, res)
     } catch (e) {
@@ -604,8 +705,11 @@ export function sessionFrom(cookies, secret) {
         set.push(cookie('', 0))
         cleared = true
       },
-      // logout wipes this origin's HTTP cache and storage on the device (§35: the next user sees nothing)
-      headers: () => ({ ...(set.length ? { 'set-cookie': set } : {}), ...(cleared ? { 'clear-site-data': '"cache", "storage"' } : {}) }),
+      // logout wipes this origin's storage on the device: localStorage, IndexedDB, the Cache API and service workers
+      // (§35: the next user sees nothing). Not "cache": Chrome clears the whole HTTP cache before it finishes the
+      // response, so the logout call took ~18 s (F16). Nothing private is in that cache: RPC is no-store and SSR
+      // HTML rendered with a session cookie is `private, no-store` (ssr() → keep).
+      headers: () => ({ ...(set.length ? { 'set-cookie': set } : {}), ...(cleared ? { 'clear-site-data': '"storage"' } : {}) }),
     },
   }
 }
@@ -798,30 +902,90 @@ function fillValues(n) {
     else if (t === 'input' && c.type !== 'password') {
       if (c.value != null && c.value !== '') c.setAttribute('value', String(c.value))
       if (c.checked === true) c.setAttribute('checked', '')
+    } else if (t === 'option' && c.selected === true) c.setAttribute('selected', '')
+    // <select value={x}>: the option with that value starts selected (an option's value is its attribute or text)
+    else if (t === 'select' && c.value != null && c.value !== '') {
+      const pick = o => {
+        for (const x of o.childNodes || []) {
+          if (x.nodeType !== 1) continue
+          if (x.tagName === 'OPTION' && (x.getAttribute('value') ?? x.textContent) === String(c.value)) x.setAttribute('selected', '')
+          else pick(x)
+        }
+      }
+      pick(c)
     }
     fillValues(c)
   }
 }
+// `/` → index.md, `/docs/setup/` → docs/setup.md (brain-seo files::md_path)
+const mdPath = p => (p.replace(/^\/+|\/+$/g, '') || 'index') + '.md'
+// true when `Accept` ranks text/markdown above text/html (an equal weight goes to whichever is listed first);
+// wildcards alone never select Markdown, so browsers keep getting HTML
+export function prefersMarkdown(accept) {
+  if (!accept) return false
+  let md = -1, html = -1, mdAt = 0, htmlAt = 0, any = -1
+  accept.split(',').forEach((part, i) => {
+    const [type, ...params] = part.trim().toLowerCase().split(';')
+    const qp = params.map(x => x.trim()).find(x => x.startsWith('q='))
+    const q = qp ? Number(qp.slice(2)) : 1
+    if (!(q >= 0)) return
+    if (type === 'text/markdown' || type === 'text/x-markdown') (md = Math.max(md, q)), (mdAt = mdAt || i + 1)
+    else if (type === 'text/html' || type === 'application/xhtml+xml') (html = Math.max(html, q)), (htmlAt = htmlAt || i + 1)
+    else if (type === 'text/*' || type === '*/*') any = Math.max(any, q)
+  })
+  if (html < 0) (html = any), (htmlAt = Infinity) // an explicit type beats a wildcard of the same weight
+  return md > 0 && (md > html || (md === html && mdAt < htmlAt))
+}
 // SEO head from View.seo(props): title, description, canonical, og:*/twitter:*, JSON-LD and the view's <head> block
-function head(page, seo) {
-  if (!seo) return page
+// F5: the build writes an SSR route's canonical/og:url from its pattern (/jobs/:slug); the request has the real path.
+// A view's own <head> tags replace the generated ones with the same name/property (one tag per key, SPEC «SEO»).
+function head(page, seo, path) {
   let h = page
+  if (path) {
+    // the attribute is already escaped HTML: only the request path that replaces a pattern is escaped
+    const real = v => v.replace(/^(https?:\/\/[^/]+)?(\/[^"]*)$/, (m, o = '', p) => (/\/[:*]/.test(p) ? o + esc(path) : m))
+    h = h.replace(/(<link[^>]*rel=["']canonical["'][^>]*href=")([^"]*)(")/i, (m, a, v, b) => a + real(v) + b)
+    h = h.replace(/(<meta[^>]*property=["']og:url["'][^>]*content=")([^"]*)(")/i, (m, a, v, b) => a + real(v) + b)
+  }
+  if (!seo) return h
   const meta = (attr, key, val) => {
     const tag = `<meta ${attr}="${esc(key)}" content="${esc(val)}">`
     const rx = new RegExp(`<meta[^>]*\\b${attr}=["']${key.replace(/[.*+?^${}()|[\]\\:]/g, '\\$&')}["'][^>]*>`, 'i')
     h = rx.test(h) ? h.replace(rx, () => tag) : h.replace('</head>', () => tag + '</head>')
   }
   for (const [k, v] of Object.entries(seo)) {
-    if (v == null || k === '$head') continue
+    // `schema` becomes JSON-LD below and `lastmod` feeds it: neither is a meta tag (prerender seo_head does the same)
+    if (v == null || k === '$head' || k === 'schema' || k === 'lastmod') continue
     if (k === 'title') h = /<title>[\s\S]*?<\/title>/i.test(h) ? h.replace(/<title>[\s\S]*?<\/title>/i, () => `<title>${esc(v)}</title>`) : h.replace('</head>', () => `<title>${esc(v)}</title></head>`)
     else if (k === 'canonical') {
       const tag = `<link rel="canonical" href="${esc(v)}">`
       h = /<link[^>]*rel=["']canonical["'][^>]*>/i.test(h) ? h.replace(/<link[^>]*rel=["']canonical["'][^>]*>/i, () => tag) : h.replace('</head>', () => tag + '</head>')
+      if (seo['og:url'] == null) meta('property', 'og:url', v) // og:url follows the canonical unless the view sets its own
     } else if (k === 'jsonld') h = h.replace('</head>', () => `<script type="application/ld+json">${jsonInHtml(v)}</script></head>`)
     else if (/^(og|twitter|article):/.test(k)) meta('property', k, v)
     else if (typeof v === 'string') meta('name', k, v)
   }
-  if (seo.$head) h = h.replace('</head>', () => seo.$head + '</head>')
+  // `<meta seo schema="Article">` without `jsonld` (§32): one node with this request's values. It replaces the node
+  // the build wrote into the template from the static attributes (same @type), so the page carries exactly one.
+  if (typeof seo.schema === 'string' && seo.jsonld == null && /^[A-Za-z]+$/.test(seo.schema)) {
+    const T = seo.schema
+    const canon = /<link[^>]*rel=["']canonical["'][^>]*href="([^"]*)"/i.exec(h)
+    const node = { '@context': 'https://schema.org', '@type': T }
+    if (seo.title != null) node[/^(Article|BlogPosting|NewsArticle|TechArticle|Report)$/.test(T) ? 'headline' : 'name'] = String(seo.title).slice(0, 110)
+    if (seo.description != null) node.description = String(seo.description)
+    if (canon) node.url = canon[1].replace(/&amp;/g, '&')
+    if (seo['og:image'] != null) node.image = String(seo['og:image']).replace(/^\/(?!\/)/, () => (canon && /^https?:\/\/[^/]+/.exec(node.url) || [''])[0] + '/')
+    if (seo.lastmod != null) node.dateModified = String(seo.lastmod)
+    const own = new RegExp(`<script[^>]*type=["']application/ld\\+json["'][^>]*>\\s*\\{"@context":"https://schema\\.org","@type":"${T}"[\\s\\S]*?</script>`, 'i')
+    const tag = `<script type="application/ld+json">${jsonInHtml(node)}</script>`
+    h = own.test(h) ? h.replace(own, () => tag) : h.replace('</head>', () => tag + '</head>')
+  }
+  if (seo.$head) {
+    for (const [, attr, key] of seo.$head.matchAll(/<meta[^>]*\b(property|name)=["']([^"']+)["'][^>]*>/gi))
+      h = h.replace(new RegExp(`<meta[^>]*\\b${attr}=["']${key.replace(/[.*+?^${}()|[\]\\:]/g, '\\$&')}["'][^>]*>`, 'gi'), '')
+    if (/<link[^>]*rel=["']canonical["']/i.test(seo.$head)) h = h.replace(/<link[^>]*rel=["']canonical["'][^>]*>/gi, '')
+    h = h.replace('</head>', () => seo.$head + '</head>')
+  }
   return h
 }
 // `/_b/<hash>.js` imports inside the chunks resolve to files in dist/ (same hook as the build's prerender)