@christianirack/brainllm-runtime 0.3.1 → 0.5.0

package/brain-dev.js

@@ -1,12 +1,13 @@
 // BRAINLLM dev (SPEC §6.2): HMR that keeps sig state by name. Development only.
 // Served next to the core under /@brain/ and imports ./brain.js relatively: a single instance of the signal graph.
 // The dev codegen wraps each component: `export default dev(Counter)` and emits `sig(v, 'name')`.
-// v0 limit: if after an hmr a parent removes that row or branch, it removes the old nodes; then do a full reload.
+// Static proof retains node identity; incompatible nested updates rebuild a proven owner boundary before parent ranges can become stale.
 // Registry for brain-inspect (§9): `live` (hash → instances), `inst` (root node N → instance) and the event `bus`.
-import { _dev, fx } from './brain.js'
+import { _dev, fx, tpl } from './brain.js'
 
 let cur = null // instance under construction: { m: Map name→sig, r: Map name→value to restore | null }
 let quiet = 0 // >0 during hmr: the bus emits `hmr` instead of mount/dispose
+const definitions = new Map() // bounded current implementations for future mounts through an older import
 export const live = new Map()
 export const inst = new WeakMap()
 export const bus = new Set() // fn(kind, data): 'mount' | 'dispose' | 'hmr' | 'hydrate'
@@ -30,18 +31,22 @@ export { owner }
 
 function build(i, restore) {
   const pc = cur
-  cur = { m: new Map(), r: restore, f: i.C.f || i.h || null }
+  cur = { m: new Map(), r: restore, f: i.C.f || i.h || null, i }
   try {
     return root(d => {
       i.r = owner() // register before C(): fx from the first run already have an owner (inspector)
       inst.set(i.r, i)
       const t = performance.now()
-      const out = i.C(i.$p)
+      i.fragments = new Set()
+      i.fragmentRefs = 0
+      i.fragmentOverflow = false
+      let out = i.C(i.$p)
       i.$mt = performance.now() - t
       mounts.unshift({ comp: i.C.f || i.h || null, ms: Math.round(i.$mt * 100) / 100, at: Date.now(), hmr: quiet > 0 })
       if (mounts.length > 50) mounts.length = 50
       // a component may return a node, a fragment or an array (guard() returns its nodes plus an anchor)
-      i.n = Array.isArray(out) ? out.flat(Infinity) : out.nodeType === 11 ? [...out.childNodes] : [out]
+      i.n = out == null ? [] : Array.isArray(out) ? out.flat(Infinity) : out.nodeType === 11 ? [...out.childNodes] : [out]
+      if (!i.n.length) { out = document.createComment(''); i.n = [out] }
       for (const x of i.n) if (x.nodeType === 1) x.$i = i
       i.d = d
       i.m = cur.m
@@ -51,7 +56,9 @@ function build(i, restore) {
       // (last hovered or focused element, accessibility tree) and must not keep the whole instance with it
       fx(() => () => {
         set.delete(i)
+        if (!set.size) live.delete(i.h)
         for (const x of i.n || []) if (x.nodeType === 1 && x.$i === i) x.$i = null
+        if (!quiet) for (const node of i.n || []) node.remove()
         quiet || emit('dispose', i)
       })
       if (!quiet) emit('mount', i)
@@ -63,38 +70,194 @@ function build(i, restore) {
 }
 
 export function dev(C) {
-  const W = $p => build({ C, $p, h: C.h, p: owner(), n: null, d: null, m: null, r: null }, null)
+  const registered = typeof C.h === 'string' && (definitions.has(C.h) || definitions.size < 1024)
+  if (registered) definitions.set(C.h, C)
+  const W = $p => build({ C: definitions.get(C.h) || C, $p, h: C.h, p: owner(), n: null, d: null, m: null, r: null }, null)
   Object.assign(W, C) // h, p, form, seo, head… whatever the compiler (or guard) put on it
   W.C = C
+  if (typeof C.h === 'string' && !registered) W.$hmrUnsupportedReason = 'definition-registry-budget'
   return W
 }
 
-// Remounts in place every live instance of `hash` with the new component from `mod`.
+// Compiler-only fragment factories record pristine references before dynamic holes insert/move siblings.
+// Per-owner cleanup prevents inactive branches/rows from retaining detached nodes.
+export function fragment(create, hash, index) {
+  let cached = null, factory = create
+  return () => {
+    let i = cur?.i?.h === hash ? cur.i : null
+    for (let o = owner(); !i && o; o = o.p) { const found = inst.get(o); if (found?.h === hash) i = found }
+    const html = i?.C?.$hmr?.templates?.[index]
+    if (typeof html === 'string' && html !== cached) { cached = html; factory = tpl(html) }
+    const out = factory()
+    if (!i || i.fragmentOverflow) return out
+    const nodes = [], roots = out.nodeType === 11 ? [...out.childNodes] : [out]
+    const rootSet = new Set(roots)
+    const visit = (node, depth) => {
+      if (depth > 64 || nodes.length >= 4096) return false
+      nodes.push({ node, parent: node.parentNode, root: rootSet.has(node) })
+      for (const child of node.childNodes || []) if (!visit(child, depth + 1)) return false
+      return true
+    }
+    if (!roots.every(node => visit(node, 0)) || i.fragmentRefs + nodes.length > 8192 || i.fragments.size >= 2048) { i.fragmentOverflow = true; return out }
+    const record = { index, nodes, owner: owner() }
+    i.fragments.add(record)
+    i.fragmentRefs += nodes.length
+    fx(() => () => { if (i.fragments.delete(record)) i.fragmentRefs -= nodes.length })
+    return out
+  }
+}
+
+export let lastUpdate = { mode: 'none', patched: 0, remounted: 0, reason: 'not-run' }
+const safeAttribute = name => ['class', 'title', 'alt', 'placeholder', 'style'].includes(name) || name.startsWith('aria-') || name.startsWith('data-') && !['data-b', 'data-cv-ref'].includes(name)
+const attributes = node => new Map([...node.attributes].map(attribute => [attribute.name, attribute.value]))
+function metadata(value) {
+  return value?.version === 1 && typeof value.wiring === 'string' && value.wiring.length <= 65536 && Array.isArray(value.templates) && value.templates.length <= 64 && value.templates.every(html => typeof html === 'string') && value.templates.reduce((n, html) => n + html.length, 0) <= 65536
+}
+function templateChanges(before, after) {
+  const changes = [], shapes = []
+  let visits = 0
+  for (let index = 0; index < before.length; index++) {
+    const old = tpl(before[index])(), next = tpl(after[index])(), flat = []
+    const walk = (a, b, depth) => {
+      if (++visits > 8192 || depth > 64) throw Error('template-budget')
+      if (!a || !b || a.nodeType !== b.nodeType || a.nodeName !== b.nodeName || a.namespaceURI !== b.namespaceURI) throw Error('template-topology')
+      const position = flat.length
+      flat.push(a)
+      if (a.nodeType === 3 && a.data !== b.data) changes.push({ index, position, kind: 'text', before: a.data, after: b.data })
+      else if (a.nodeType === 8 && a.data !== b.data) throw Error('anchor-topology')
+      if (a.nodeType === 1) {
+        const previous = attributes(a), current = attributes(b)
+        for (const name of new Set([...previous.keys(), ...current.keys()])) if (previous.get(name) !== current.get(name)) {
+          if (!safeAttribute(name)) throw Error('stateful-or-unsupported-attribute')
+          changes.push({ index, position, kind: 'attribute', name, before: previous.get(name) ?? null, after: current.get(name) ?? null })
+        }
+      }
+      if (a.childNodes.length !== b.childNodes.length) throw Error('template-topology')
+      for (let n = 0; n < a.childNodes.length; n++) walk(a.childNodes[n], b.childNodes[n], depth + 1)
+    }
+    const a = old.nodeType === 11 ? [...old.childNodes] : [old], b = next.nodeType === 11 ? [...next.childNodes] : [next]
+    if (a.length !== b.length) throw Error('template-topology')
+    for (let n = 0; n < a.length; n++) walk(a[n], b[n], 0)
+    shapes.push(flat)
+  }
+  return { changes, shapes }
+}
+function staticPlan(i, C) {
+  const before = i.C.$hmr, after = C.$hmr
+  if (!metadata(before) || !metadata(after)) return 'metadata-unavailable-or-budget'
+  if (before.wiring !== after.wiring) return 'compiled-wiring-changed'
+  if (before.templates.length !== after.templates.length) return 'template-topology'
+  if (i.fragmentOverflow) return 'instance-reference-budget'
+  let analysis
+  try { analysis = templateChanges(before.templates, after.templates) } catch (error) { return ['template-budget', 'template-topology', 'anchor-topology', 'stateful-or-unsupported-attribute'].includes(error.message) ? error.message : 'template-proof-failed' }
+  const operations = []
+  for (const record of i.fragments || []) {
+    const shape = analysis.shapes[record.index]
+    if (!shape || shape.length !== record.nodes.length) return 'instance-shape-conflict'
+    for (const change of analysis.changes) if (change.index === record.index) {
+      const entry = record.nodes[change.position], node = entry?.node
+      if (!node || node.nodeType !== shape[change.position].nodeType || !entry.root && node.parentNode !== entry.parent) return 'instance-node-conflict'
+      if (change.kind === 'text' ? node.data !== change.before : node.getAttribute(change.name) !== change.before) return 'runtime-owned-content-conflict'
+      operations.push({ node, ...change })
+      if (operations.length > 8192) return 'instance-operation-budget'
+    }
+  }
+  return { i, C, operations }
+}
+function applyStaticPlan({ i, C, operations }) {
+  // Plan first; preserve live handlers/effects/owners and target the original nodes only.
+  const selection = document.getSelection?.()
+  const saved = selection?.rangeCount ? { anchor: selection.anchorNode, anchorOffset: selection.anchorOffset, focus: selection.focusNode, focusOffset: selection.focusOffset } : null
+  try {
+    for (const operation of operations) {
+      if (operation.kind === 'text') operation.node.data = operation.after
+      else if (operation.after === null) operation.node.removeAttribute(operation.name)
+      else operation.node.setAttribute(operation.name, operation.after)
+    }
+  } catch { return 'native-dom-patch-failed' }
+  if (saved && selection.setBaseAndExtent) {
+    const length = node => node?.nodeType === 3 ? node.data.length : node?.childNodes.length || 0
+    try { selection.setBaseAndExtent(saved.anchor, Math.min(saved.anchorOffset, length(saved.anchor)), saved.focus, Math.min(saved.focusOffset, length(saved.focus))) } catch {}
+  }
+  i.C = C
+  return null
+}
+
+// A parent list/branch keeps its own node range. Replacing a child range directly would leave those
+// captured roots stale, so incompatible nested updates rebuild the outermost owned component once.
+function boundary(i) {
+  let target = i, count = 0
+  for (let owner = i.p; owner; owner = owner.p) {
+    if (++count > 256) return null
+    const ancestor = inst.get(owner)
+    if (ancestor) target = ancestor
+  }
+  return !target.p || !target.p.f && !target.p.p ? target : null
+}
+function under(i, ancestor) {
+  if (i === ancestor) return true
+  let count = 0
+  for (let owner = i.p; owner && ++count <= 256; owner = owner.p) if (owner === ancestor.r) return true
+  return false
+}
+function remount(i, C) {
+  const old = i.n, parent = old[0]?.parentNode
+  const anchor = document.createComment('')
+  if (parent) parent.insertBefore(anchor, old[0])
+  const values = new Map([...i.m].map(([name, node]) => [name, node._]))
+  i.d()
+  emit('dispose', { h: i.h, C: i.C, n: old, r: null, hmr: 1 })
+  i.C = C
+  build(i, values)
+  if (parent) for (const node of i.n) parent.insertBefore(node, anchor)
+  for (const node of old) node.remove()
+  anchor.remove()
+}
+// Safe static fragments retain node identity. Other updates rebuild a proven owner boundary.
 export function hmr(hash, mod) {
-  const W = Object.values(mod).find(c => c && c.h === hash)
+  const W = Object.values(mod).find(component => component && component.h === hash)
   if (!W) return 0
   const C = W.C || W
-  let k = 0
+  if (W.$hmrUnsupportedReason) { lastUpdate = { mode: 'reload-required', patched: 0, remounted: 0, reason: W.$hmrUnsupportedReason }; return 0 }
+  const instances = [...(live.get(hash) || [])].filter(i => i.r?.s !== 3)
+  const plans = [], rebuild = new Map(), reasons = new Set(), patched = new Set()
+  for (const i of instances) {
+    let plan
+    try { plan = staticPlan(i, C) } catch { plan = 'native-proof-operation-failed' }
+    if (typeof plan !== 'string') { plans.push(plan); continue }
+    const target = boundary(i)
+    if (!target) { lastUpdate = { mode: 'reload-required', patched: 0, remounted: 0, reason: 'parent-range-owner-unavailable' }; return 0 }
+    reasons.add(plan)
+    if (target !== i) reasons.add('ancestor-remount-for-parent-owned-range')
+    rebuild.set(target, definitions.get(target.h) || target.C)
+  }
+  let affected = 0, remounted = 0, ancestors = 0
   quiet++
   try {
-    for (const i of [...(live.get(hash) || [])]) {
-      const old = i.n, pa = old[0].parentNode
-      // an anchor that survives the dispose (guard() removes its own nodes when its owner is disposed)
-      const first = document.createComment('')
-      if (pa) pa.insertBefore(first, old[0])
-      const vals = new Map([...i.m].map(([name, n]) => [name, n._]))
-      i.d()
-      emit('dispose', { h: i.h, C: i.C, n: old, r: null, hmr: 1 })
-      i.C = C
-      build(i, vals)
-      if (pa) for (const x of i.n) pa.insertBefore(x, first)
-      for (const x of old) x.remove()
-      first.remove()
-      k++
+    for (const plan of plans) {
+      if ([...rebuild.keys()].some(target => under(plan.i, target))) continue
+      const failure = applyStaticPlan(plan)
+      if (!failure) patched.add(plan.i)
+      else {
+        const target = boundary(plan.i)
+        if (!target) { lastUpdate = { mode: 'reload-required', patched: patched.size, remounted, reason: 'native-patch-failed-without-owned-range' }; return 0 }
+        rebuild.set(target, definitions.get(target.h) || target.C)
+        reasons.add(failure)
+        if (target !== plan.i) reasons.add('ancestor-remount-for-parent-owned-range')
+      }
     }
-  } finally {
-    quiet--
-  }
-  emit('hmr', { h: hash, n: k })
-  return k
+    for (const [target, implementation] of rebuild) {
+      if (target.r?.s === 3) continue
+      const covered = instances.filter(i => under(i, target)).length
+      for (const i of patched) if (under(i, target)) patched.delete(i)
+      if (target.h !== hash) ancestors++
+      remount(target, implementation)
+      affected += covered
+      remounted++
+    }
+  } finally { quiet-- }
+  const count = patched.size + affected
+  lastUpdate = { mode: !count ? 'future-mount-updated' : remounted ? patched.size ? 'mixed' : ancestors ? 'ancestor-remount' : 'component-remount' : 'static-fragment', patched: patched.size, remounted, ancestorRemounted: ancestors, reason: [...reasons].join(',') || (!count ? 'no-live-instance; current-definition-retained' : 'exact-compiled-wiring-and-template-shape'), stateRestoration: ancestors ? 'ancestor-named-state; descendant-instances-recreated' : 'named-state-or-static-identity' }
+  emit('hmr', { h: hash, n: count, ...lastUpdate })
+  return count
 }

package/brain-err.js

@@ -12,7 +12,7 @@ const RT = new URL('.', import.meta.url).href
 // Core hook: records (capture active) or console.error, and falls back to the nearest boundary's fallback (not for
 // event handlers).
 const I = _err((e, x, w) => {
-  on ? record(e, x, w) : G.console && console.error(e)
+  on ? record(e, x, w) : print(e)
   // §42: a failing event handler never destroys its component (it is reported; brain-guard shows the toast)
   if (String(w).startsWith('on:')) return
   for (; x; x = x.p || x.parentNode) {
@@ -20,6 +20,7 @@ const I = _err((e, x, w) => {
     if (b) return fall(b)
   }
 })
+const print = (e, ref) => G.console && console.error(I.development?.() ? e : `BRAIN_ERROR: Operation failed. Reference: ${ref || 'unavailable'}`)
 // Boundaries: owner N and its root elements → { fb, n: nodes, r: owner, f: already fell }.
 const BW = new WeakMap()
 const fbn = fb => {
@@ -50,7 +51,7 @@ export const fallback = (C, fb) =>
         try {
           a = I.nodes(C($p))
         } catch (e) {
-          on ? record(e, r, 'render') : G.console && console.error(e)
+          on ? record(e, r, 'render') : print(e)
           r.q()
           ;(b.f = 1), (a = fbn(fb))
         }
@@ -67,6 +68,7 @@ const crumbs = []
 let opts = {}, on = false, sent = 0, F0 = null
 
 export function crumb(k, d) {
+  k = clean(k, 40); d = clean(d, 200)
   const l = crumbs[crumbs.length - 1]
   if (l && l.k === k && l.d === d) return void l.n++ // the same repeated action is counted, not stacked
   crumbs.push({ k, d, n: 1, at: Date.now() })
@@ -82,22 +84,49 @@ const path = u => {
   try {
     return new URL(u, G.location && G.location.href).pathname // no query: it may carry sensitive data
   } catch {
-    return String(u).split('?')[0]
+    return String(u).split(/[?#]/)[0]
   }
 }
-// "url:line:col" of each frame; the first one outside the runtime is the app line.
+const LIMIT = { frames: 24, causes: 6, stackBytes: 16384, stackLines: 256, maps: 64, sourceBytes: 1048576, mapLines: 65536, loads: 2, pending: 64, deadline: 2000 }
+const get = (o, k) => { try { return o && o[k] } catch { return null } }
+const clean = (s, max = 500) => String(s == null ? '' : s).slice(0, max).replace(/(?:https?|file):\/\/[^\s)]+/g, u => u.split(/[?#]/)[0]).replace(/([/\w.:%-]+)[?#][^\s)'"]*/g, '$1')
+// Only structural stack locations are retained, never argument lists or the raw stack header.
 function frames(e) {
-  const out = []
-  for (const l of String((e && e.stack) || '').split('\n')) {
+  const raw = String(get(e, 'stack') || ''), out = []
+  let omitted = raw.length > LIMIT.stackBytes
+  const lines = raw.slice(0, LIMIT.stackBytes).split('\n')
+  if (lines.length > LIMIT.stackLines) omitted = true
+  for (const l of lines.slice(0, LIMIT.stackLines)) {
     const m = l.match(/((?:https?|file):\/\/[^\s)]+):(\d+):(\d+)/)
-    if (m) out.push({ url: m[1], line: +m[2], col: +m[3], rt: m[1].startsWith(RT) && !m[1].slice(RT.length).includes('/') })
+    if (!m) continue
+    if (![+m[2], +m[3]].every(n => Number.isSafeInteger(n) && n > 0)) { omitted = true; continue }
+    if (out.length >= LIMIT.frames) { omitted = true; break }
+    out.push({ url: m[1], line: +m[2], col: +m[3], rt: m[1].startsWith(RT) && !m[1].slice(RT.length).includes('/') })
   }
-  return out
+  return { frames: out, truncated: omitted }
+}
+const generated = t => t ? { file: path(t.url).slice(-1024), line: t.line, column: t.col } : null
+const location = (t, c) => ({ component: c ? clean(c.name || c.h || '', 120) || null : null, file: t ? path(t.url).slice(-1024) : c && c.file ? c.file : null, line: t ? t.line : null, column: t ? t.col : null, precision: t ? 'generated' : 'component-only' })
+function trace(e, c) {
+  const f = frames(e), top = f.frames.find(t => !t.rt) || null
+  return { rawFrames: f.frames, location: location(top, c), generatedLocation: generated(top), frames: f.frames.map(t => ({ generated: generated(t), source: null, runtime: t.rt })), truncated: { stack: f.truncated, frames: f.truncated, locations: f.frames.some(t => path(t.url).length > 1024) } }
+}
+function causes(e, c) {
+  const seen = new Set([e]), out = []
+  let next = get(e, 'cause'), truncated = false
+  while (next != null) {
+    if (seen.has(next) || out.length >= LIMIT.causes) { truncated = true; break }
+    seen.add(next)
+    const t = trace(next, c)
+    out.push({ depth: out.length + 1, type: clean(get(next, 'name') || typeof next, 80), code: clean(get(next, 'code') || '', 80) || null, msg: clean(get(next, 'message') || (typeof next === 'string' ? next : ''), 300), ...t })
+    next = get(next, 'cause')
+  }
+  return { entries: out, truncated }
 }
 // Component via the DOM: roots with data-b="<hash>" (prod) → parent chain via ancestors with data-b.
 function byDom(el) {
   const chain = []
-  for (; el; el = el.parentNode) if (el.getAttribute && el.getAttribute('data-b')) chain.push({ h: el.getAttribute('data-b') })
+  for (; el && chain.length < 33; el = el.parentNode) if (el.getAttribute && el.getAttribute('data-b')) chain.push({ h: el.getAttribute('data-b') })
   return chain.length ? { ...chain[0], chain: chain.map(c => c.h) } : null
 }
 // Prod chunk /_b/<hash>.brain → component hash.
@@ -110,18 +139,21 @@ const byStack = f => {
 // line to its .brain line. With `maps`, a recorded error is enriched asynchronously: `src` ('views/home.brain:12', the
 // first app frame) and `brainStack`; subscribers (brain_errors, overlay, doctor) are notified again. The file path
 // comes from the module URL (two `index.brain` in different folders never mix); prod chunks carry no map: no-op.
-const MAPS = new Map()
+const MAPS = new Map(), pending = []
+let loading = 0, enriching = 0
 const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
 export function decode(m) {
+  if (typeof m !== 'string' || m.length > LIMIT.sourceBytes) return []
   const lines = []
   let src = 0
-  for (const seg of m.split(';')) {
+  for (const seg of m.split(';').slice(0, LIMIT.mapLines)) {
     let line = null
     for (const part of seg.split(',')) {
       if (!part) continue
       const v = []
       for (let i = 0, n = 0, sh = 0; i < part.length; i++) {
         const d = B64.indexOf(part[i])
+        if (d < 0 || sh > 30) return []
         n += (d & 31) << sh
         if (d & 32) sh += 5
         else (v.push(n & 1 ? -(n >> 1) : n >> 1), (n = 0), (sh = 0))
@@ -132,54 +164,147 @@ export function decode(m) {
   }
   return lines
 }
-const mapOf = url => {
-  if (!MAPS.has(url))
-    MAPS.set(
-      url,
-      Promise.resolve(opts.load ? opts.load(url) : F0(url).then(r => r.text()))
-        .then(t => {
-          const m = /sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)/.exec(t)
-          return m ? decode(JSON.parse(atob(m[1])).mappings) : null
-        })
-        .catch(() => null)
-    )
-  return MAPS.get(url)
-}
-async function toBrain(r, f) {
-  const out = []
-  for (const t of f.slice(0, 12)) {
-    const lines = t.rt ? null : await mapOf(t.url)
-    const l = lines && lines[t.line - 1]
-    if (l) out.push(`${path(t.url).replace(/^\//, '')}:${l}`)
+async function source(url, signal) {
+  if (opts.load) {
+    const text = await opts.load(url, { signal })
+    return typeof text === 'string' && text.length <= LIMIT.sourceBytes && new TextEncoder().encode(text).byteLength <= LIMIT.sourceBytes ? text : null
   }
-  if (!out.length) return
-  r.src = out[0]
-  r.brainStack = out
+  if (!F0) return null
+  const r = await F0(url, { signal, credentials: 'same-origin' })
+  if (r.ok === false || +(r.headers && r.headers.get('content-length')) > LIMIT.sourceBytes) return null
+  if (!r.body || !r.body.getReader) { const text = await r.text(); return text.length <= LIMIT.sourceBytes && new TextEncoder().encode(text).byteLength <= LIMIT.sourceBytes ? text : null }
+  const reader = r.body.getReader(), decoder = new TextDecoder()
+  let text = '', bytes = 0
+  try {
+    for (;;) {
+      const part = await reader.read()
+      if (part.done) break
+      bytes += part.value.byteLength
+      if (bytes > LIMIT.sourceBytes) { await reader.cancel(); return null }
+      text += decoder.decode(part.value, { stream: true })
+    }
+    return text + decoder.decode()
+  } finally { reader.releaseLock() }
+}
+function pump() {
+  while (loading < LIMIT.loads && pending.length) {
+    const task = pending.shift()
+    if (task.done) continue
+    loading++
+    Promise.resolve().then(() => source(task.url, task.controller.signal)).then(text => {
+      const m = text && /sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)/.exec(text)
+      const map = m && JSON.parse(atob(m[1]))
+      const lines = map && map.version === 3 && decode(map.mappings)
+      task.finish({ lines: lines && lines.length ? lines : null, status: lines && lines.length ? 'mapped' : 'unavailable' })
+    }).catch(() => task.finish({ lines: null, status: 'unavailable' })).finally(() => { loading--; pump() })
+  }
+}
+function mapOf(input) {
+  let url
+  try {
+    const u = new URL(input), origin = G.location && G.location.origin
+    if (!['http:', 'https:', 'file:'].includes(u.protocol) || (u.protocol !== 'file:' && origin && origin !== 'null' && u.origin !== origin)) return Promise.resolve({ lines: null, status: 'unavailable' })
+    u.hash = ''; url = u.href
+  } catch { return Promise.resolve({ lines: null, status: 'unavailable' }) }
+  const hit = MAPS.get(url)
+  if (hit) { MAPS.delete(url); MAPS.set(url, hit); return hit.promise }
+  if (pending.length >= LIMIT.pending) return Promise.resolve({ lines: null, status: 'limited' })
+  if (MAPS.size >= LIMIT.maps) {
+    const old = [...MAPS].find(([, e]) => e.done)
+    if (!old) return Promise.resolve({ lines: null, status: 'limited' })
+    MAPS.delete(old[0])
+  }
+  const entry = { done: false }
+  entry.promise = new Promise(resolve => {
+    const task = { url, done: false, controller: new AbortController(), finish(result) {
+      if (task.done) return
+      task.done = entry.done = true
+      clearTimeout(timer)
+      const at = pending.indexOf(task)
+      if (at >= 0) pending.splice(at, 1)
+      if (result.status !== 'mapped' && MAPS.get(url) === entry) MAPS.delete(url)
+      resolve(result)
+    } }
+    const timer = setTimeout(() => { task.controller.abort(); task.finish({ lines: null, status: 'timeout' }) }, LIMIT.deadline)
+    pending.push(task)
+  })
+  MAPS.set(url, entry)
+  pump()
+  return entry.promise
+}
+async function toBrain(r, traces) {
+  const jobs = []
+  for (const item of traces) for (const [index, t] of item.rawFrames.entries()) {
+    if (t.rt) continue
+    jobs.push(mapOf(t.url).then(result => {
+      const line = result.lines && result.lines[t.line - 1]
+      if (Number.isSafeInteger(line) && line > 0 && item.frames[index]) item.frames[index].source = { file: path(t.url).replace(/^\//, '').slice(-1024), line, column: null }
+      return result.status
+    }))
+  }
+  const status = await Promise.all(jobs)
+  for (const item of traces) {
+    const first = item.frames.find(t => t.source)
+    if (first) item.location = { component: item.location.component, ...first.source, precision: 'source-line' }
+    delete item.rawFrames
+  }
+  for (let i = 1; i < traces.length; i++) r.causes[i - 1].location = traces[i].location
+  r.location = traces[0].location
+  r.frames = traces[0].frames
+  const out = r.frames.filter(t => t.source).map(t => `${t.source.file}:${t.source.line}`)
+  if (out.length) { r.src = out[0]; r.brainStack = out }
+  r.mapping = { status: status.includes('timeout') ? 'timeout' : status.includes('limited') ? 'limited' : out.length ? 'mapped' : 'unavailable' }
+  r.truncated.mapping = status.some(s => s === 'timeout' || s === 'limited')
+  boundRecord(r)
   for (const s of sub) s(r)
 }
 
+// Bound the serialized notification too, including mapped locations and nested causes.
+function boundRecord(r) {
+  const size = () => new TextEncoder().encode(JSON.stringify(r)).byteLength
+  r.truncated.output ||= false
+  while (size() > 65536) {
+    r.truncated.output = true
+    const nested = [...r.causes].reverse().find(c => c.frames.length)
+    if (nested) { nested.frames.pop(); nested.truncated.frames = true; continue }
+    if (r.frames.length > 1) { r.frames.pop(); r.stack.pop(); if (r.brainStack) r.brainStack.pop(); r.truncated.frames = true; continue }
+    if (r.causes.length) { r.causes.pop(); r.truncated.causes = true; continue }
+    break
+  }
+}
 function record(e, x, w) {
   if (e && e.kind === 'aborted') return // a cancelled request (brain-data ApiError): not an error
-  const f = frames(e), top = f.find(t => !t.rt) || null
-  const c = (opts.who && opts.who(x)) || (x && x.nodeType ? byDom(x) : null) || byStack(top)
-  const type = (e && e.code) || (e && e.name) || typeof e
-  const line = top ? `${path(top.url)}:${top.line}` : null
+  const extracted = frames(e), f = extracted.frames, top = f.find(t => !t.rt) || null
+  const owner = (opts.who && opts.who(x)) || (x && x.nodeType ? byDom(x) : null) || byStack(top)
+  const c = owner ? { id: typeof owner.id === 'number' ? owner.id : null, h: clean(owner.h || '', 120) || null, name: clean(owner.name || '', 120) || null, file: owner.file ? clean(owner.file, 500).split(/[?#]/)[0] : null, chain: Array.isArray(owner.chain) ? owner.chain.slice(0, 32).map(n => clean(n, 120)) : [] } : null
+  const type = clean(get(e, 'code') || get(e, 'name') || typeof e, 80)
+  const line = top ? `${path(top.url).slice(-1024)}:${top.line}` : null
   const fp = hash([type, c && c.h, line, w].join('|'))
   let r = errors.find(r => r.fp === fp)
   if (r) (r.n++, (r.last = Date.now()))
   else {
+    const t = trace(e, c), chain = causes(e, c)
     r = {
-      fp, code: (e && e.code) || null, type, msg: MSG[e && e.code] || String((e && e.message) || e).slice(0, 500), where: w || null, comp: c, line,
-      stack: f.slice(0, 12).map(t => `${path(t.url)}:${t.line}:${t.col}`), crumbs: crumbs.map(c => ({ ...c })),
-      build: opts.build || null, ua: G.navigator ? navigator.userAgent : null, at: Date.now(), last: Date.now(), n: 1,
+      fp, code: clean(get(e, 'code') || '', 80) || null, type, msg: MSG[get(e, 'code')] || clean(get(e, 'message') || e), where: clean(w || '', 120) || null, comp: c, line,
+      stack: f.slice(0, LIMIT.frames).map(t => `${path(t.url).slice(-1024)}:${t.line}:${t.col}`), location: t.location, generatedLocation: t.generatedLocation, frames: t.frames, causes: chain.entries.map(({ rawFrames, ...item }) => item), truncated: { ...t.truncated, causes: chain.truncated, componentChain: !!(owner && owner.chain && owner.chain.length > 32), breadcrumbs: crumbs.length >= 30, locations: f.some(t => path(t.url).length > 1024), mapping: false }, mapping: { status: opts.maps ? 'pending' : 'disabled' }, crumbs: crumbs.map(c => ({ ...c })),
+      build: clean(opts.build || '', 200) || null, ua: G.navigator ? clean(navigator.userAgent, 300) : null, at: Date.now(), last: Date.now(), n: 1,
     }
+    boundRecord(r)
     errors.push(r)
     if (errors.length > 100) errors.shift()
-    if (opts.maps) toBrain(r, f)
+    if (opts.maps && enriching < 100) {
+      enriching++
+      const traces = [t, ...chain.entries.slice(0, r.causes.length)]
+      for (let i = 0; i < r.causes.length; i++) chain.entries[i].frames = r.causes[i].frames
+      toBrain(r, traces).finally(() => { enriching-- })
+    } else {
+      if (opts.maps) { r.mapping.status = 'limited'; r.truncated.mapping = true }
+      for (const item of chain.entries) delete item.rawFrames
+    }
     if (opts.report && G.navigator && navigator.sendBeacon && sent < (opts.max || 20)) sent++, navigator.sendBeacon(opts.report, JSON.stringify(r))
   }
   for (const s of sub) s(r)
-  if (opts.log !== false && G.console) console.error(e)
+  if (opts.log !== false) print(e, r.fp)
   return r
 }
 
@@ -200,7 +325,7 @@ export function capture(o = {}) {
     G.addEventListener('error', ev => record(ev.error || ev.message, null, 'onerror'))
     G.addEventListener('unhandledrejection', ev => record(ev.reason, null, 'promise'))
     G.addEventListener('popstate', () => crumb('nav', path(location.href)))
-    G.addEventListener('hashchange', () => crumb('nav', path(location.href) + location.hash))
+    G.addEventListener('hashchange', () => crumb('nav', path(location.href)))
   }
   const d = G.document
   if (d && d.addEventListener) {