@christianirack/brainllm-runtime 0.0.0-stage → 0.1.0

package/shim/dom.js

@@ -0,0 +1,448 @@
+// Minimal DOM to test the runtime in Node with no dependencies. Covers only what brain.js uses.
+// Installs `document`, `Event` and `MouseEvent` on globalThis. `stats.moves` counts insertions of already-connected nodes.
+
+export const stats = { moves: 0 }
+const VOID = new Set(['area', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr'])
+const esc = s => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+const unesc = s => s.replace(/&(amp|lt|gt|quot|#39);/g, (_, e) => ({ amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'" })[e])
+
+export class Event {
+  constructor(type, init = {}) {
+    this.type = type
+    this.bubbles = !!init.bubbles
+    this.cancelable = !!init.cancelable
+    this.target = null
+    this.currentTarget = null
+    this.cancelBubble = false
+    this.defaultPrevented = false
+    this._p = []
+  }
+  composedPath() {
+    return this._p
+  }
+  stopImmediatePropagation() {
+    this.cancelBubble = this._stop = true
+  }
+  stopPropagation() {
+    this.cancelBubble = true
+  }
+  preventDefault() {
+    this.defaultPrevented = true
+  }
+}
+export class MouseEvent extends Event {}
+
+// Minimal MutationObserver: only records for nodes connected to the document, plus takeRecords() (used by brain-inspect).
+const MOS = new Set()
+const rec = (type, target) => {
+  if (MOS.size && target.isConnected) for (const o of MOS) o._q.push({ type, target })
+}
+export class MutationObserver {
+  constructor(f) {
+    this._f = f
+    this._q = []
+  }
+  observe() {
+    MOS.add(this)
+  }
+  disconnect() {
+    MOS.delete(this)
+    this._q = []
+  }
+  takeRecords() {
+    const q = this._q
+    this._q = []
+    return q
+  }
+}
+
+class Node {
+  constructor(type, doc) {
+    this.nodeType = type
+    this.ownerDocument = doc
+    this.parentNode = null
+    this.childNodes = []
+    this._l = { cap: {}, bub: {} }
+  }
+  get firstChild() {
+    return this.childNodes[0] || null
+  }
+  get lastChild() {
+    return this.childNodes[this.childNodes.length - 1] || null
+  }
+  get nextSibling() {
+    const p = this.parentNode
+    return p ? p.childNodes[p.childNodes.indexOf(this) + 1] || null : null
+  }
+  get previousSibling() {
+    const p = this.parentNode
+    return p ? p.childNodes[p.childNodes.indexOf(this) - 1] || null : null
+  }
+  get isConnected() {
+    let n = this
+    while (n.parentNode) n = n.parentNode
+    return n.nodeType === 9
+  }
+  insertBefore(n, ref) {
+    if (n.nodeType === 11) {
+      for (const c of [...n.childNodes]) this.insertBefore(c, ref)
+      return n
+    }
+    if (n.parentNode) {
+      if (n.isConnected) stats.moves++
+      n.parentNode.removeChild(n)
+    }
+    const i = ref ? this.childNodes.indexOf(ref) : -1
+    if (ref && i < 0) throw Error('ref is not a child')
+    i < 0 ? this.childNodes.push(n) : this.childNodes.splice(i, 0, n)
+    n.parentNode = this
+    rec('childList', this)
+    return n
+  }
+  appendChild(n) {
+    return this.insertBefore(n, null)
+  }
+  removeChild(n) {
+    const i = this.childNodes.indexOf(n)
+    if (i < 0) throw Error('not a child')
+    this.childNodes.splice(i, 1)
+    n.parentNode = null
+    rec('childList', this)
+    return n
+  }
+  remove() {
+    if (this.parentNode) this.parentNode.removeChild(this)
+  }
+  replaceWith(...ns) {
+    const p = this.parentNode
+    for (const n of ns) p.insertBefore(n, this)
+    this.remove()
+  }
+  get textContent() {
+    return this.nodeType === 3 ? this.data : this.childNodes.filter(c => c.nodeType !== 8).map(c => c.textContent).join('')
+  }
+  set textContent(v) {
+    for (const c of this.childNodes) c.parentNode = null
+    this.childNodes = []
+    if (v !== '') this.appendChild(this.ownerDocument.createTextNode(v))
+  }
+  addEventListener(t, f, cap) {
+    const a = (this._l[cap ? 'cap' : 'bub'][t] ||= [])
+    if (!a.includes(f)) a.push(f) // the same listener twice is one listener (DOM spec)
+  }
+  removeEventListener(t, f, cap) {
+    const a = this._l[cap ? 'cap' : 'bub'][t] || []
+    const i = a.indexOf(f)
+    if (i >= 0) a.splice(i, 1)
+  }
+  dispatchEvent(e) {
+    e.target = this
+    const path = []
+    for (let n = this; n; n = n.parentNode || n.host) path.push(n)
+    if (path[path.length - 1].nodeType === 9 && path[path.length - 1].defaultView) path.push(path[path.length - 1].defaultView)
+    e._p = path
+    const fire = (n, k) => {
+      for (const f of [...(n._l[k][e.type] || [])]) {
+        if (e._stop) return
+        Object.defineProperty(e, 'currentTarget', { configurable: true, writable: true, value: n })
+        f.call(n, e)
+      }
+    }
+    for (let i = path.length - 1; i >= 0 && !e.cancelBubble; i--) fire(path[i], 'cap')
+    for (let i = 0; i < path.length && !e.cancelBubble; i++) {
+      fire(path[i], 'bub')
+      if (!e.bubbles) break
+    }
+    if (!e.defaultPrevented && e.type === 'click' && this.tagName === 'INPUT' && this.type === 'checkbox') this.checked = !this.checked
+    return !e.defaultPrevented
+  }
+  contains(n) {
+    for (; n; n = n.parentNode) if (n === this) return true
+    return false
+  }
+  // Supported selectors: lists (`a, b`), descendant (`a b`), compounds of `tag`, `.class`, `#id`, `[attr]`,
+  // `[attr=v]` (quoted or not) and `:not(<compound>)`. Enough for the runtime and the ui kit.
+  querySelectorAll(sel) {
+    const alts = sel.split(',').map(a => a.trim().split(/\s+/).map(compound))
+    const out = []
+    const walk = n => {
+      for (const c of n.childNodes) {
+        if (c.nodeType === 1 && alts.some(chain => matchChain(c, chain, this))) out.push(c)
+        walk(c)
+      }
+    }
+    walk(this)
+    return out
+  }
+  querySelector(sel) {
+    return this.querySelectorAll(sel)[0] || null
+  }
+  get innerHTML() {
+    return this.childNodes.map(ser).join('')
+  }
+  set innerHTML(h) {
+    this.textContent = ''
+    parse(h, this.nodeName === 'TEMPLATE' ? this.content : this, this.ownerDocument)
+  }
+}
+
+class Text extends Node {
+  constructor(d, doc) {
+    super(3, doc)
+    this._d = String(d)
+  }
+  get data() {
+    return this._d
+  }
+  set data(v) {
+    this._d = String(v)
+    rec('characterData', this)
+  }
+  get nodeValue() {
+    return this._d
+  }
+  set nodeValue(v) {
+    this.data = v
+  }
+  cloneNode() {
+    return new Text(this.data, this.ownerDocument)
+  }
+}
+class Comment extends Node {
+  constructor(d, doc) {
+    super(8, doc)
+    this._d = String(d)
+  }
+  get data() {
+    return this._d
+  }
+  set data(v) {
+    this._d = String(v)
+    rec('characterData', this)
+  }
+  get nodeValue() {
+    return this._d
+  }
+  set nodeValue(v) {
+    this.data = v
+  }
+  cloneNode() {
+    return new Comment(this.data, this.ownerDocument)
+  }
+}
+class Fragment extends Node {
+  constructor(doc) {
+    super(11, doc)
+  }
+  cloneNode(deep) {
+    const f = new Fragment(this.ownerDocument)
+    if (deep) for (const c of this.childNodes) f.appendChild(c.cloneNode(true))
+    return f
+  }
+}
+
+class Element extends Node {
+  constructor(tag, doc) {
+    super(1, doc)
+    this.tagName = this.nodeName = tag.toUpperCase()
+    this.attrs = new Map()
+    this.value = ''
+    this.checked = false
+    this.selected = false
+    const el = this
+    this.style = {
+      _p: new Map(),
+      setProperty(k, v) {
+        this._p.set(k, String(v))
+      },
+      removeProperty(k) {
+        this._p.delete(k)
+      },
+      getPropertyValue(k) {
+        return this._p.get(k) || ''
+      },
+    }
+    this.classList = {
+      _l: () => (el.getAttribute('class') || '').split(/\s+/).filter(Boolean),
+      contains: c => el.classList._l().includes(c),
+      toggle(c, on) {
+        const l = this._l().filter(x => x !== c)
+        if (on) l.push(c)
+        l.length ? el.setAttribute('class', l.join(' ')) : el.removeAttribute('class')
+        return on
+      },
+    }
+    this.dataset = new Proxy({}, { get: (_, k) => el.getAttribute('data-' + String(k).replace(/[A-Z]/g, c => '-' + c.toLowerCase())) ?? undefined })
+    if (this.tagName === 'TEMPLATE') this.content = new Fragment(doc)
+  }
+  get type() {
+    return this.getAttribute('type') || ''
+  }
+  setAttribute(k, v) {
+    this.attrs.set(k, String(v))
+    rec('attributes', this)
+    if (k === 'value') this.value = String(v)
+    if (k === 'checked') this.checked = true
+  }
+  get attributes() {
+    return [...this.attrs].map(([name, value]) => ({ name, value }))
+  }
+  replaceChildren(...ns) {
+    this.textContent = ''
+    for (const n of ns) this.appendChild(n)
+  }
+  getAttribute(k) {
+    return this.attrs.has(k) ? this.attrs.get(k) : null
+  }
+  hasAttribute(k) {
+    return this.attrs.has(k)
+  }
+  removeAttribute(k) {
+    if (this.attrs.delete(k)) rec('attributes', this)
+  }
+  // reflected attributes the runtime and the ui kit read
+  get id() {
+    return this.getAttribute('id') || ''
+  }
+  set id(v) {
+    this.setAttribute('id', v)
+  }
+  // HTMLFormElement.elements (namedItem only)
+  get elements() {
+    if (this.tagName !== 'FORM') return undefined
+    const all = this.querySelectorAll('[name]')
+    return { namedItem: n => all.find(e => e.getAttribute('name') === n) || null }
+  }
+  focus() {
+    this.ownerDocument.activeElement = this
+  }
+  cloneNode(deep) {
+    const e = new Element(this.tagName.toLowerCase(), this.ownerDocument)
+    for (const [k, v] of this.attrs) e.setAttribute(k, v)
+    if (deep) {
+      for (const c of this.childNodes) e.appendChild(c.cloneNode(true))
+      if (this.content) for (const c of this.content.childNodes) e.content.appendChild(c.cloneNode(true))
+    }
+    return e
+  }
+  get outerHTML() {
+    return ser(this)
+  }
+}
+
+function ser(n) {
+  if (n.nodeType === 3) return esc(n.data)
+  if (n.nodeType === 8) return `<!--${n.data}-->`
+  if (n.nodeType === 11) return n.childNodes.map(ser).join('')
+  const t = n.tagName.toLowerCase()
+  const a = [...n.attrs].map(([k, v]) => (v === '' ? ` ${k}` : ` ${k}="${esc(v).replace(/"/g, '&quot;')}"`)).join('')
+  return VOID.has(t) ? `<${t}${a}>` : `<${t}${a}>${n.childNodes.map(ser).join('')}</${t}>`
+}
+
+// Minimal HTML parser: tags, attributes, text, comments (including `<!>`), void elements and script raw text.
+function parse(h, root, doc) {
+  const stack = [root]
+  const top = () => stack[stack.length - 1]
+  const re = /<!--([\s\S]*?)-->|<!>|<\/([\w-]+)\s*>|<([\w-]+)((?:\s+[^\s=\/>]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?)*)\s*(\/?)>|([^<]+|<)/g
+  let m
+  while ((m = re.exec(h))) {
+    if (m[0] === '<!>') top().appendChild(new Comment('', doc))
+    else if (m[1] != null) top().appendChild(new Comment(m[1], doc))
+    else if (m[2]) {
+      const t = m[2].toUpperCase()
+      for (let i = stack.length - 1; i > 0; i--)
+        if (stack[i].tagName === t) {
+          stack.length = i
+          break
+        }
+    } else if (m[3]) {
+      const el = new Element(m[3], doc)
+      for (const a of m[4].matchAll(/([^\s=\/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g)) el.setAttribute(a[1], unesc(a[2] ?? a[3] ?? a[4] ?? ''))
+      top().appendChild(el)
+      const t = m[3].toLowerCase()
+      if (t === 'script') {
+        const end = h.indexOf('</script>', re.lastIndex)
+        el.appendChild(new Text(h.slice(re.lastIndex, end), doc))
+        re.lastIndex = end + 9
+      } else if (!VOID.has(t) && !m[5]) stack.push(t === 'template' ? Object.assign(el.content, { tagName: 'TEMPLATE' }) : el)
+    } else top().appendChild(new Text(unesc(m[6]), doc))
+  }
+}
+
+class Document extends Node {
+  constructor() {
+    super(9, null)
+    this.ownerDocument = this
+    this.baseURI = 'http://localhost/'
+    this.activeElement = null
+    // <html><head></head><body></body></html>, as in a browser
+    this.documentElement = this.appendChild(new Element('html', this))
+    this.head = this.documentElement.appendChild(new Element('head', this))
+    this.body = this.documentElement.appendChild(new Element('body', this))
+  }
+  createElement(t) {
+    return new Element(t, this)
+  }
+  createTextNode(d) {
+    return new Text(d, this)
+  }
+  createComment(d) {
+    return new Comment(d, this)
+  }
+  createDocumentFragment() {
+    return new Fragment(this)
+  }
+  getElementById(id) {
+    const walk = n => {
+      for (const c of n.childNodes) {
+        if (c.nodeType !== 1) continue
+        if (c.getAttribute('id') === id) return c
+        const r = walk(c)
+        if (r) return r
+      }
+      return null
+    }
+    return walk(this)
+  }
+}
+
+// Selector helpers for querySelectorAll: a compound is a list of tests on one element.
+function compound(str) {
+  const tests = []
+  const rx = /^(?:([\w-]+)|\.([\w-]+)|#([\w-]+)|\[([\w-]+)(?:=["']?([^"'\]]*)["']?)?\]|:not\(([^)]*)\))/
+  let rest = str
+  while (rest) {
+    const m = rx.exec(rest)
+    if (!m) throw Error('unsupported selector: ' + str)
+    rest = rest.slice(m[0].length)
+    if (m[1]) tests.push(e => e.tagName === m[1].toUpperCase())
+    else if (m[2]) tests.push(e => (e.getAttribute('class') || '').split(/\s+/).includes(m[2]))
+    else if (m[3]) tests.push(e => e.getAttribute('id') === m[3])
+    else if (m[4]) tests.push(e => e.hasAttribute(m[4]) && (m[5] == null || e.getAttribute(m[4]) === m[5]))
+    else {
+      const inner = compound(m[6])
+      tests.push(e => !inner(e))
+    }
+  }
+  return e => tests.every(t => t(e))
+}
+// chain = [c0, c1, …, cn]: the element matches cn and has ancestors (below root) matching the rest, in order.
+function matchChain(el, chain, root) {
+  if (!chain[chain.length - 1](el)) return false
+  let i = chain.length - 2
+  for (let a = el.parentNode; i >= 0 && a && a !== root; a = a.parentNode) if (a.nodeType === 1 && chain[i](a)) i--
+  return i < 0
+}
+
+export function install() {
+  const doc = new Document()
+  // real window at the end of the event path (after document), as in the browser
+  const win = new Node(0, doc)
+  doc.defaultView = win
+  globalThis.window = win
+  globalThis.document = doc
+  globalThis.Event = Event
+  globalThis.MouseEvent = MouseEvent
+  globalThis.MutationObserver = MutationObserver
+  return doc
+}

package/shim/probe.js

@@ -0,0 +1,111 @@
+// BRAINLLM runaway probe (INTERNALS §30.2, #91). Runs after the prerender, in Node on the DOM shim: each view or island
+// is mounted with fake timers and stepped for N seconds of virtual time (default 30 s, ~200 ms real) with no user
+// input. It samples, per component (`data-b` hash): DOM nodes; per signal: the length of the lists it holds; and the
+// animation frames requested. Sustained growth with no input, or a requestAnimationFrame loop re-armed in every frame
+// for the whole run, is a runaway: B0907 findings with what grew and how fast. Repeated bounded work (a clock or a
+// stopwatch updating its text) is not: it does not grow and it is what such a component is for. brain-pack (BUILD) calls it and fails the
+// build, doctor and test on any finding.
+//   const findings = await probe({ core, mount: root => core.mount(View, root, props), seconds: 30 })
+//   → [{ code: 'B0907', comp: '<hash>' | null, what: 'nodes' | 'list' | 'raf', growth: '+40 nodes/s', msg, fix }]
+const TICK = 100 // ms of virtual time per step
+const FIX = 'bound the growth (slice the list, stop the interval, clean up the timer in the fx) or move the work behind a user action'
+
+export async function probe({ core, mount, seconds = 30, document: doc = globalThis.document }) {
+  const G = globalThis, N = core.sig(0).constructor, P = N.prototype
+  // ---- fake clock: timers, animation frames and Date.now move only when the probe steps ----
+  let now = 0, seq = 0
+  const timers = new Map() // id → { at, f, every }
+  const saved = { st: G.setTimeout, ct: G.clearTimeout, si: G.setInterval, ci: G.clearInterval, raf: G.requestAnimationFrame, caf: G.cancelAnimationFrame, dn: Date.now }
+  const add = (f, ms, every) => (timers.set(++seq, { at: now + Math.max(0, +ms || 0), f, every: every ? Math.max(1, +ms || 1) : 0 }), seq)
+  G.setTimeout = (f, ms, ...a) => add(() => f(...a), ms, false)
+  G.setInterval = (f, ms, ...a) => add(() => f(...a), ms, true)
+  G.clearTimeout = G.clearInterval = id => timers.delete(id)
+  G.requestAnimationFrame = f => add(() => (rafTicks.add(tickNo), f(now)), 16, false)
+  G.cancelAnimationFrame = id => timers.delete(id)
+  const t0 = saved.dn.call(Date)
+  Date.now = () => t0 + now
+  // ---- instrumentation: list lengths per signal, ticks with an animation frame ----
+  const lists = new Map() // signal → { last: length }
+  const rafTicks = new Set()
+  let tickNo = 0
+  const vd = Object.getOwnPropertyDescriptor(P, 'v')
+  Object.defineProperty(P, 'v', {
+    configurable: true,
+    get: vd.get,
+    set(x) {
+      vd.set.call(this, x)
+      if (Array.isArray(x)) (lists.get(this) || lists.set(this, []).get(this)).last = x.length
+    },
+  })
+  const flush = async () => {
+    for (let i = 0; i < 3; i++) await new Promise(r => queueMicrotask(r))
+  }
+  // nodes per component: each `data-b` root counts its elements, nested components count apart
+  const perComp = () => {
+    const out = {}
+    const walk = (el, h) => {
+      const own = el.getAttribute && el.getAttribute('data-b')
+      const at = own || h
+      if (at) out[at] = (out[at] || 0) + 1
+      for (const c of el.childNodes || []) if (c.nodeType === 1) walk(c, at)
+    }
+    walk(root, null)
+    return out
+  }
+
+  const root = doc.createElement('div')
+  doc.body.appendChild(root)
+  const findings = []
+  let stop = null
+  try {
+    stop = mount(root)
+    await flush()
+    const samples = [] // per virtual second: { nodes: {hash: n}, lists: Map(signal → length) }
+    const steps = Math.round((seconds * 1000) / TICK)
+    for (let s = 0; s <= steps; s++) {
+      tickNo = s
+      now = s * TICK
+      // run every timer due by now, in time order (an interval re-arms itself)
+      for (;;) {
+        let next = null
+        for (const [id, t] of timers) if (t.at <= now && (!next || t.at < next[1].at)) next = [id, t]
+        if (!next) break
+        const [id, t] = next
+        if (t.every) t.at += t.every
+        else timers.delete(id)
+        try {
+          t.f()
+        } catch {} // a timer that throws is the error capture's business, not the probe's
+      }
+      await flush()
+      if (s % Math.round(1000 / TICK) === 0) samples.push({ nodes: perComp(), lists: new Map([...lists].map(([k, v]) => [k, v.last])) })
+    }
+    // ---- verdicts: growth in every second of the second half, and well above the start ----
+    const half = samples.slice(Math.floor(samples.length / 2))
+    const rising = vals => vals.length > 3 && vals.every((v, i) => i === 0 || v > vals[i - 1])
+    const hashes = new Set(samples.flatMap(x => Object.keys(x.nodes)))
+    for (const h of hashes) {
+      const v = half.map(x => x.nodes[h] || 0)
+      const all = samples.map(x => x.nodes[h] || 0)
+      if (rising(v) && all.at(-1) - all[0] >= 20) {
+        const rate = Math.round((all.at(-1) - all[0]) / seconds)
+        findings.push({ code: 'B0907', comp: h, what: 'nodes', growth: `+${rate} nodes/s`, msg: `component ${h} grows with no input: +${rate} nodes/s over ${seconds} s of virtual time`, fix: FIX })
+      }
+    }
+    for (const sig of lists.keys()) {
+      const v = half.map(x => x.lists.get(sig) ?? 0), all = samples.map(x => x.lists.get(sig) ?? 0)
+      if (rising(v) && all.at(-1) - all[0] >= 10) {
+        const rate = +((all.at(-1) - all[0]) / steps).toFixed(2)
+        findings.push({ code: 'B0907', comp: null, what: 'list', growth: `+${rate} item/tick`, msg: `a list grows with no input: +${rate} item/tick (${all[0]} → ${all.at(-1)} items) over ${seconds} s of virtual time`, fix: FIX })
+      }
+    }
+    if (rafTicks.size >= 0.95 * steps) findings.push({ code: 'B0907', comp: null, what: 'raf', growth: 'a frame every tick', msg: `a requestAnimationFrame loop re-arms itself in every frame with no input for ${seconds} s of virtual time`, fix: 'stop the loop when there is nothing to animate (or use a CSS / Web Animations transition)' })
+  } finally {
+    if (stop) stop()
+    root.remove()
+    Object.defineProperty(P, 'v', vd)
+    Object.assign(G, { setTimeout: saved.st, clearTimeout: saved.ct, setInterval: saved.si, clearInterval: saved.ci, requestAnimationFrame: saved.raf, cancelAnimationFrame: saved.caf })
+    Date.now = saved.dn
+  }
+  return findings
+}

package/sw/brain-sw.js

@@ -0,0 +1,103 @@
+// BRAINLLM service worker (INTERNALS §35.2). `brain build` emits dist/sw.js as one line
+// `self.BRAIN_BUILD = { hash, precache: [...], offline: '/_offline.html' | null }` followed by this file unchanged.
+// Strategies: /_b/* cache-first (hashed, immutable) · navigations network-first with a 3 s timeout, then the cached
+// page, then the offline page · other same-origin GETs (unhashed public/ files) stale-while-revalidate · /_r/, non-GET
+// and other origins are never touched. Every build has one cache, `brain-<sig>`, holding its chunks, pages and public
+// files (§35.7). A new worker takes over at once and keeps only the previous build's cache, and only for the chunks an
+// open tab still asks for: navigations are answered from the current build alone, so nothing old is shown by mistake.
+// After taking over it tells every tab `brain:build <sig>` (the router then does full loads). Caches that are not per
+// build are named `brain:*`. (`sw: false` is a separate kill worker emitted by the build.)
+const B = self.BRAIN_BUILD || { hash: 'dev', precache: [], offline: null }
+const BASE = B.base || '/' // app served under a base path (§23 #148); precache/offline URLs already carry it
+const BUILD = 'brain-' + B.hash, META = 'brain:meta'
+const NAV_TIMEOUT = 3000
+// responses marked personal or uncacheable are never stored
+const storable = r => r.ok && !/no-store|private/i.test(r.headers.get('cache-control') || '')
+const OFFLINE =
+  '<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">' +
+  '<title>Offline</title><main style="font:16px/1.5 system-ui;max-width:32rem;margin:15vh auto;padding:0 16px">' +
+  '<h1>You are offline</h1><p>This page has not been visited yet on this device. Reconnect and try again.</p></main></html>'
+
+self.addEventListener('install', e => {
+  e.waitUntil(
+    (async () => {
+      const c = await caches.open(BUILD)
+      // one failing URL must not abort the install: cache what answers, the rest is cached on first use
+      // default cache mode: the page just filled the HTTP cache with these immutable files, so this costs no bytes
+      await Promise.allSettled(B.precache.map(u => fetch(u).then(r => r.ok && c.put(u, r))))
+      await self.skipWaiting()
+    })()
+  )
+})
+
+self.addEventListener('activate', e => {
+  e.waitUntil(
+    (async () => {
+      if (self.registration.navigationPreload) await self.registration.navigationPreload.enable()
+      // generations: [previous, current]; every other build cache is deleted
+      const meta = await caches.open(META)
+      const r = await meta.match('/__brain_generations')
+      const gens = r ? await r.json() : []
+      const keep = [...gens.filter(g => g !== BUILD).slice(-1), BUILD]
+      await meta.put('/__brain_generations', new Response(JSON.stringify(keep)))
+      for (const k of await caches.keys()) if (k.startsWith('brain-') && !keep.includes(k)) await caches.delete(k)
+      await self.clients.claim()
+      for (const c of await self.clients.matchAll({ type: 'window', includeUncontrolled: true })) c.postMessage('brain:build ' + B.hash)
+    })()
+  )
+})
+
+self.addEventListener('fetch', e => {
+  const req = e.request
+  if (req.method !== 'GET') return
+  const url = new URL(req.url)
+  if (url.origin !== self.location.origin || url.pathname.startsWith(BASE + '_r/') || url.pathname === BASE + 'sw.js') return
+  // offline: false (B.offline null) → navigations go straight to the network: no page cache, no offline page
+  if (req.mode === 'navigate') return B.offline ? e.respondWith(navigate(e)) : undefined
+  if (url.pathname.startsWith(BASE + '_b/')) return e.respondWith(hashed(req))
+  // only files the page itself loads (img, style, script, font, manifest…); fetch()/XHR data is never touched (§35:
+  // data is not cached by default)
+  if (req.destination) e.respondWith(revalidate(e))
+})
+
+// cache-first: any generation may hold it (an old tab asks for old chunks); misses are stored in the current build
+async function hashed(req) {
+  const hit = await caches.match(req)
+  if (hit) return hit
+  const r = await fetch(req)
+  if (storable(r)) (await caches.open(BUILD)).put(req, r.clone())
+  return r
+}
+
+async function navigate(e) {
+  const net = (async () => {
+    const r = (await e.preloadResponse) || (await fetch(e.request))
+    if (storable(r) && (r.headers.get('content-type') || '').includes('text/html')) {
+      const copy = r.clone()
+      e.waitUntil(caches.open(BUILD).then(c => c.put(e.request, copy)))
+    }
+    return r
+  })()
+  e.waitUntil(net.catch(() => {}))
+  const timeout = new Promise(ok => setTimeout(() => ok(null), NAV_TIMEOUT))
+  const first = await Promise.race([net, timeout]).catch(() => null)
+  if (first) return first
+  const cached = await caches.match(e.request, { cacheName: BUILD }) // never a page of the previous build
+  if (cached) return cached
+  // nothing cached: a slow network is still better than the offline page
+  try {
+    return await net
+  } catch {
+    const off = B.offline && (await caches.match(B.offline, { cacheName: BUILD }))
+    return off || new Response(OFFLINE, { status: 503, headers: { 'content-type': 'text/html; charset=utf-8' } })
+  }
+}
+
+// stale-while-revalidate for unhashed same-origin files
+async function revalidate(e) {
+  const c = await caches.open(BUILD)
+  const hit = await c.match(e.request)
+  const net = fetch(e.request).then(r => (storable(r) && c.put(e.request, r.clone()), r))
+  e.waitUntil(net.catch(() => {}))
+  return hit || net
+}