@christianirack/brainllm-runtime 0.8.12 → 0.10.0

package/brain-analytics.js

@@ -37,7 +37,8 @@ export function start(config = {}, env = globalThis) {
   const win = env.window || env
   const nav = env.navigator || {}
   const loc = () => env.location || { pathname: '/', search: '', href: '/', origin: '' }
-  const store = env.localStorage
+  let store
+  try { store = env.localStorage } catch {} // some browsers block access to the storage object itself
   const now = () => (env.performance ? env.performance.now() : Date.now())
   if (!doc || config.enabled === false) return null
   if (nav.globalPrivacyControl === true || nav.doNotTrack === '1' || win.doNotTrack === '1' || nav.webdriver) return null
@@ -45,7 +46,9 @@ export function start(config = {}, env = globalThis) {
   const consented = () => {
     if (config.consent !== 'required') return true
     try {
-      return !!(JSON.parse(store.getItem('brain:consent')) || {}).analytics
+      const memory = env[Symbol.for('brain:consent-state')]
+      if (memory && Object.hasOwn(memory, 'analytics')) return memory.analytics === true
+      return (JSON.parse(store.getItem('brain:consent')) || {}).analytics === true
     } catch {
       return false
     }
@@ -193,9 +196,11 @@ export function start(config = {}, env = globalThis) {
   let maxScroll = 0
   let path = loc().pathname
   let stopped = false
+  let consentEpoch = 0
   const send = () => {
     clearTimeout(timer)
     timer = null
+    if (!consented()) { discardDenied(); return }
     if (!queue.length) return
     const vid = ids()
     while (queue.length) {
@@ -267,9 +272,25 @@ export function start(config = {}, env = globalThis) {
   const listen = (t, f, target = doc) => {
     if (!target.addEventListener) return
     const o = { capture: true, passive: true }
-    target.addEventListener(t, f, o)
-    off.push(() => target.removeEventListener(t, f, o))
+    const listener = /^(brain:consent|storage|popstate|visibilitychange|pagehide)$/.test(t) ? f : event => { if (consented()) f(event) }
+    target.addEventListener(t, listener, o)
+    off.push(() => target.removeEventListener(t, listener, o))
   }
+  const discardDenied = () => {
+    if (!consented()) {
+      queue.length = 0; clearTimeout(timer); timer = null; pv = 0; consentEpoch++
+      clicks.length = 0; focused.clear(); typed.clear()
+      if (hover) clearTimeout(hover.t)
+      hover = null
+    }
+  }
+  listen('brain:consent', discardDenied, win)
+  listen('storage', event => {
+    if (event.key === 'brain:consent' || event.key === null) {
+      delete env[Symbol.for('brain:consent-state')]
+      discardDenied()
+    }
+  }, win)
   const clicks = []
   let mutations = 0
   const Observer = env.MutationObserver
@@ -291,7 +312,9 @@ export function start(config = {}, env = globalThis) {
       const seen = changes()
       const href = loc().href
       const active = doc.activeElement
+      const epoch = consentEpoch
       setTimeout(() => {
+        if (epoch !== consentEpoch) return
         if (changes() === seen && loc().href === href && doc.activeElement === active) record('dead', el)
       }, DEAD_MS)
     }
@@ -357,7 +380,8 @@ export function start(config = {}, env = globalThis) {
     const el = actionable(e.target)
     if (!el || hovered.has(el) || (hover && hover.el === el)) return
     if (hover) clearTimeout(hover.t)
-    hover = { el, t: setTimeout(() => (hovered.add(el), (hover = null), record('hover', el, HOVER_MS)), HOVER_MS) }
+    const epoch = consentEpoch
+    hover = { el, t: setTimeout(() => { if (epoch === consentEpoch) { hovered.add(el); hover = null; record('hover', el, HOVER_MS) } }, HOVER_MS) }
   })
   listen('pointerout', e => {
     if (hover && actionable(e.target) === hover.el) clearTimeout(hover.t), (hover = null)

package/brain-consent.js

@@ -10,29 +10,90 @@ const TYPES = {
   functional: ['functionality_storage'],
   personal: ['personalization_storage'],
 }
-const read = () => {
+const MEMORY = Symbol.for('brain:consent-state')
+const read = (env = G) => {
+  const state = {}
   try {
-    return JSON.parse(G.localStorage.getItem(KEY)) || {}
-  } catch {
-    return {}
-  }
+    const stored = JSON.parse(env.localStorage.getItem(KEY))
+    for (const kind of Object.keys(TYPES)) if (typeof stored?.[kind] === 'boolean') state[kind] = stored[kind]
+  } catch {}
+  const memory = env[MEMORY]
+  for (const kind of Object.keys(TYPES)) if (typeof memory?.[kind] === 'boolean') state[kind] = memory[kind]
+  return state
 }
-const apply = state => {
+const apply = (state, env = G) => {
   const u = {}
-  for (const k in state) for (const t of TYPES[k] || []) u[t] = state[k] ? 'granted' : 'denied'
+  for (const k in state) for (const t of TYPES[k] || []) if (typeof state[k] === 'boolean') u[t] = state[k] ? 'granted' : 'denied'
   if (!Object.keys(u).length) return
-  if (typeof G.gtag === 'function') G.gtag('consent', 'update', u)
-  else if (G.dataLayer) G.dataLayer.push(['consent', 'update', u]) // gtag not loaded yet: queued the way gtag reads it
+  try {
+    if (typeof env.gtag === 'function') env.gtag('consent', 'update', u)
+    else if (Array.isArray(env.dataLayer)) env.dataLayer.push((function () { return arguments })('consent', 'update', u))
+  } catch {} // a blocked or broken external tag must not prevent a local privacy decision
 }
-
-export function consent(kind, granted = true) {
+const notify = env => {
+  const target = env.window || env
+  const EventType = env.Event || G.Event
+  if (target.dispatchEvent && EventType) target.dispatchEvent(new EventType('brain:consent'))
+}
+export function consent(kind, granted = true, env = G) {
   if (!TYPES[kind]) throw Error(`consent: unknown kind "${kind}" (${Object.keys(TYPES).join(', ')})`)
-  const s = { ...read(), [kind]: !!granted }
-  try {
-    G.localStorage.setItem(KEY, JSON.stringify(s))
-  } catch {}
-  apply({ [kind]: !!granted })
+  if (typeof granted !== 'boolean') throw Error('consent: granted must be true or false')
+  if (env.__brainSSR || env.__brainRoute) return
+  const s = { ...read(env), [kind]: granted }
+  env[MEMORY] = s // a current-page decision still works when browser storage is blocked
+  try { env.localStorage.setItem(KEY, JSON.stringify(s)) } catch {}
+  // Disable the bridge/Google tag before a denied update can be processed by an already-loaded tag.
+  if (!granted) notify(env)
+  apply({ [kind]: granted }, env)
+  if (granted) notify(env)
+}
+export const consented = (kind, env = G) => !env.__brainSSR && !env.__brainRoute && read(env)[kind] === true
+
+// Opt-in, non-modal controls: native buttons work with keyboard and screen readers; no custom key trap.
+// App policy wording and any additional jurisdiction-specific requirements remain the site's responsibility.
+export function consentBanner(options = {}, env = G) {
+  const doc = env.document
+  if (env.__brainSSR || env.__brainRoute || !doc?.body || options.enabled === false) return null
+  const region = doc.createElement('section'), choices = doc.createElement('div')
+  region.setAttribute('role', 'region'); region.setAttribute('aria-label', 'Privacy preferences')
+  region.setAttribute('data-brain-consent', '')
+  const message = doc.createElement('p')
+  message.textContent = 'Optional Google analytics stays off until you accept. You can change your choice here.'
+  choices.appendChild(message)
+  const button = (label, fn, parent) => {
+    const el = doc.createElement('button'); el.setAttribute('type', 'button'); el.textContent = label
+    el.addEventListener('click', fn); parent.appendChild(el); return el
+  }
+  const refresh = () => { choices.hidden = Object.hasOwn(read(env), 'analytics'); revoke.hidden = !consented('analytics', env) }
+  const choose = value => { consent('analytics', value, env); refresh(); manage.focus?.() }
+  button('Deny analytics', () => choose(false), choices)
+  button('Accept analytics', () => choose(true), choices)
+  region.appendChild(choices)
+  const manage = button('Manage privacy preferences', () => { choices.hidden = false; choices.querySelector('button')?.focus?.() }, region)
+  const revoke = button('Revoke analytics consent', () => choose(false), region)
+  const target = env.window || env
+  const storageChanged = event => { if (event.key === KEY || event.key === null) { delete env[MEMORY]; notify(env); refresh() } }
+  target.addEventListener?.('brain:consent', refresh)
+  target.addEventListener?.('storage', storageChanged)
+  refresh(); doc.body.appendChild(region)
+  return { element: region, stop() { target.removeEventListener?.('brain:consent', refresh); target.removeEventListener?.('storage', storageChanged); region.parentNode?.removeChild(region) } }
 }
-export const consented = kind => !!read()[kind]
 
 apply(read()) // a returning visitor: their earlier answer, before any tag reads the defaults
+
+// The public consent API also invalidates page-local decisions across tabs when no collector or banner is mounted.
+// One page-lifetime listener is shared by the generated bridge and separately imported consent module.
+const STORAGE_SYNC = Symbol.for('brain:consent-storage-sync')
+const consentWindow = G.window || G
+if (!G.__brainSSR && !G.__brainRoute && consentWindow.addEventListener && !G[STORAGE_SYNC]) {
+  G[STORAGE_SYNC] = true
+  consentWindow.addEventListener('storage', event => {
+    if (event.key !== KEY && event.key !== null) return
+    delete G[MEMORY]
+    notify(G)
+    const state = read()
+    const deniedMissing = {}
+    for (const kind of Object.keys(TYPES)) deniedMissing[kind] = state[kind] === true
+    apply(deniedMissing)
+  })
+}

package/brain-google.js

@@ -0,0 +1,113 @@
+const TOKEN = /^[\w.:-]{1,64}$/
+
+// Explicit basic-mode Google bridge. It runs without the first-party collector or a native backend.
+// Only declared event names cross the boundary: props, DOM text, field values, URLs and visitor ids never do.
+export function startGoogle(config = {}, env = globalThis) {
+  const doc = env.document, win = env.window || env, nav = env.navigator || {}
+  const id = config.analytics || config.tagManager
+  if (env.__brainSSR || env.__brainRoute || !doc || config.mode !== 'basic' || !id || (config.analytics && config.tagManager)) return null
+  if (config.analytics ? !/^G-[A-Z0-9]{1,32}$/.test(id) : !/^GTM-[A-Z0-9]{1,32}$/.test(id)) return null
+  if (nav.globalPrivacyControl === true || nav.doNotTrack === '1' || win.doNotTrack === '1' || nav.webdriver) return null
+  const eventName = name => typeof name === 'string' && /^[A-Za-z][A-Za-z0-9_]{0,39}$/.test(name) && !/^(google_|ga_|firebase_)/i.test(name)
+  const events = Object.create(null)
+  for (const [source, name] of Object.entries(config.events || {}).slice(0, 100)) if (TOKEN.test(source) && eventName(name)) events[source] = name
+  const funnels = Object.entries(config.funnels || {}).slice(0, 20).filter(([name, steps]) => eventName(name) && Array.isArray(steps) && steps.length >= 2 && steps.length <= 20)
+  let stopped = false, initialized = false, loaded = false, lastGranted = false, loader = null
+  const pending = new Set(), off = []
+  const allowed = () => {
+    if (stopped || nav.globalPrivacyControl === true || nav.doNotTrack === '1' || win.doNotTrack === '1') return false
+    try {
+      const memory = env[Symbol.for('brain:consent-state')]
+      if (memory && Object.hasOwn(memory, 'analytics')) return memory.analytics === true
+      return JSON.parse(env.localStorage.getItem('brain:consent'))?.analytics === true
+    } catch { return false }
+  }
+  const listen = (target, type, fn) => {
+    if (!target?.addEventListener) return
+    target.addEventListener(type, fn, true)
+    off.push(() => target.removeEventListener(type, fn, true))
+  }
+  const clearPending = () => {
+    if (Array.isArray(env.dataLayer)) for (let i = env.dataLayer.length - 1; i >= 0; i--) if (pending.has(env.dataLayer[i])) env.dataLayer.splice(i, 1)
+    pending.clear()
+  }
+  const privacy = () => {
+    let origin = 'https://example.invalid/'
+    try { const url = new URL(env.location?.origin); if (/^https?:$/.test(url.protocol)) origin = url.origin + '/' } catch {}
+    return { page_location: origin, page_referrer: '', page_title: '[redacted]', send_page_view: false, allow_google_signals: false, allow_ad_personalization_signals: false }
+  }
+  const sync = () => {
+    try {
+    const granted = allowed()
+    if (config.analytics) env['ga-disable-' + id] = !granted
+    if (!granted) {
+      clearPending()
+      if (initialized && lastGranted) env.gtag('consent', 'update', { analytics_storage: 'denied' })
+      lastGranted = false
+      return false
+    }
+    if (initialized) {
+      if (!lastGranted) env.gtag('consent', 'update', { analytics_storage: 'granted' })
+      lastGranted = true
+      return true
+    }
+    // Do not adopt a malformed/preconfigured data layer. Never overwrite another integration's queue.
+    if (env.dataLayer !== undefined && !Array.isArray(env.dataLayer)) return false
+    env.dataLayer ||= []
+    if (env.gtag !== undefined && typeof env.gtag !== 'function') return false
+    env.gtag ||= function () { env.dataLayer.push(arguments) }
+    env.gtag('consent', 'default', { analytics_storage: 'denied', ad_storage: 'denied', ad_user_data: 'denied', ad_personalization: 'denied' })
+    env.gtag('consent', 'update', { analytics_storage: 'granted', ad_storage: 'denied', ad_user_data: 'denied', ad_personalization: 'denied' })
+    if (config.analytics) { env.gtag('js', new Date()); env.gtag('config', id, privacy()) }
+    else env.dataLayer.push({ 'gtm.start': Date.now(), event: 'gtm.js' })
+    loader = doc.createElement('script')
+    loader.async = true
+    loader.onload = () => { loaded = true; pending.clear() }
+    loader.src = 'https://www.googletagmanager.com/' + (config.analytics ? 'gtag/js' : 'gtm.js') + '?id=' + id
+    const parent = doc.head || doc.documentElement
+    if (!parent) return false
+    parent.appendChild(loader)
+    initialized = lastGranted = true
+    return true
+    } catch { return false }
+  }
+  const track = source => {
+    if (typeof source !== 'string' || !Object.hasOwn(events, source) || !sync() || (!loaded && pending.size >= 128)) return false
+    const name = events[source], params = privacy()
+    delete params.send_page_view
+    // A declared funnel is a list of named steps, not an inferred conversion or a separate extra event.
+    for (const [funnel, steps] of funnels) {
+      const step = Array.isArray(steps) ? steps.indexOf(name) : -1
+      if (eventName(funnel) && step >= 0 && step < 20) { params.brain_funnel = funnel; params.brain_step = step + 1; break }
+    }
+    let message
+    if (config.analytics) {
+      params.send_to = id
+      // Arguments objects are the official gtag queue shape. Keep references so revocation drops our pending events.
+      message = (function () { return arguments })('event', name, params)
+    } else message = { event: name, ...params }
+    if (!loaded) pending.add(message)
+    try { env.dataLayer.push(message); return true } catch { pending.delete(message); return false }
+  }
+  const tracked = target => {
+    let found = null
+    for (let el = target; el?.nodeType === 1; el = el.parentNode) {
+      if (el.hasAttribute('data-private')) return null
+      if (!found && el.hasAttribute('data-track')) found = el
+    }
+    return found
+  }
+  listen(doc, 'click', e => {
+    const el = tracked(e.target)
+    if (el && el.tagName !== 'FORM') track(el.getAttribute('data-track'))
+  })
+  listen(doc, 'submit', e => {
+    const el = e.target
+    if (el?.tagName === 'FORM' && tracked(el) === el) track(el.getAttribute('data-track'))
+  })
+  listen(win, 'brain:track', e => { if (e.detail && typeof e.detail.name === 'string') track(e.detail.name) })
+  listen(win, 'brain:consent', sync)
+  listen(win, 'storage', e => { if (e.key === 'brain:consent' || e.key === null) { delete env[Symbol.for('brain:consent-state')]; sync() } })
+  sync()
+  return { track, stop() { stopped = true; clearPending(); if (config.analytics) env['ga-disable-' + id] = true; for (const fn of off) fn(); if (loader?.parentNode) loader.parentNode.removeChild(loader) } }
+}

package/brain-lazy.js

@@ -29,8 +29,11 @@ function reloadOnce() {
 function visible(el, go) {
   const box = { go }
   const io = new IntersectionObserver(es => es.some(e => e.isIntersecting) && box.go?.(), { rootMargin: '200px' })
+  const doc = el.ownerDocument || G.document
+  const hidden = () => { if (doc?.visibilityState === 'hidden') box.go?.() }
+  doc?.addEventListener('visibilitychange', hidden)
   io.observe(el)
-  return () => { box.go = null; io.disconnect() }
+  return () => { box.go = null; io.disconnect(); doc?.removeEventListener('visibilitychange', hidden) }
 }
 
 export function lazy(el, imp, mode, props = {}) {

package/brain-links.js

@@ -14,8 +14,10 @@ export default function links(lang, b, p, re, s) {
     const t = tables[document.documentElement.getAttribute('lang')]
     if (!t || !h || h[0] !== '/' || h[1] === '/') return h
     const a = t.b && (h + '/').startsWith(t.b + '/') ? h.slice(t.b.length) || '/' : h
-    const m = /^[^?#]*/.exec(a)[0]
-    const n = t.s[m] || (t.re.test(m) && (m === '/' ? t.p : t.p + m))
+    const m = /^[^?#]*/.exec(a)[0], key = m.replace(/\/+$/, '') || '/'
+    if (key === t.p || key.startsWith(t.p + '/')) return h
+    let n = t.s[key] || (t.re.test(key) && (key === '/' ? t.p : t.p + key))
+    if (n && key !== '/' && m.endsWith('/') && !n.endsWith('/')) n += '/'
     return n ? t.b + n + a.slice(m.length) : h
   }
   G.__brainHref = to

package/brain-list.js

@@ -0,0 +1,9 @@
+// Pure bounded integer iteration, outside the runtime core.
+export function range(from, to) {
+  if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to)) throw new RangeError('range requires two safe integer endpoints')
+  const length = Math.max(0, to - from)
+  if (length > 10000) throw new RangeError('range cannot emit more than 10000 integers')
+  const values = new Array(length)
+  for (let i = 0; i < length; i++) values[i] = from + i
+  return values
+}

package/brain-native-vitals.js

@@ -0,0 +1,78 @@
+// Optional initial-document performance estimates. Only declared patterns leave the browser.
+import { consented } from './brain-consent.js'
+import { vitals } from './brain-vitals.js'
+const STATE = Symbol.for('brain:native-vitals')
+const ROUTE = /^(?:\/|(?:\/(?:[A-Za-z0-9_-]+|:[a-z][a-z0-9_]*))+)$/
+const MAX = { LCP: 3600000, CLS: 1000, INP: 3600000, FCP: 3600000, TTFB: 3600000 }
+export function startNativeVitals(config, env = globalThis) {
+  if (env.__brainSSR || env.__brainRoute || !env.window || !env.document || !env.location || env[STATE]) return env[STATE]
+  if (!config || typeof config.base !== 'string' || !/^(?:\/[A-Za-z0-9_.-]+)*$/.test(config.base) || config.base.split('/').some(p => p === '.' || p === '..') || !Array.isArray(config.routes) || !config.routes.length || config.routes.length > 512 || config.routes.some(p => typeof p !== 'string' || p.length > 160 || !ROUTE.test(p)) || new Set(config.routes).size !== config.routes.length) return
+  let origin
+  try { const url = new URL(env.location.href); if (!/^https?:$/.test(url.protocol)) return; origin = url.origin } catch { return }
+  const initialPath = env.location.pathname
+  if (config.base && !initialPath.startsWith(config.base + '/')) return
+  const local = config.base ? initialPath.slice(config.base.length) : initialPath
+  const pathname = local.length > 1 && local.endsWith('/') ? local.slice(0, -1) : local
+  const parts = pathname.split('/')
+  let route, score = -1
+  for (const pattern of config.routes) {
+    const wanted = pattern.split('/')
+    if (wanted.length !== parts.length) continue
+    let matches = true, literal = 0
+    for (let i = 0; i < wanted.length; i++) {
+      if (wanted[i].startsWith(':')) { if (!parts[i]) { matches = false; break } }
+      else if (wanted[i] !== parts[i]) { matches = false; break }
+      else literal++
+    }
+    if (matches && literal > score) { route = pattern; score = literal }
+  }
+  if (!route) return
+  const target = env.window, doc = env.document, fresh = new Map()
+  let active = false, disposed = false, navigated = false, off, pending, timer, generation = 0
+  const dnt = value => value === '1' || value === 'yes' || value === true
+  const permitted = () => consented('analytics', env) && !dnt(env.navigator?.doNotTrack) && !dnt(env.navigator?.msDoNotTrack) && !dnt(env.doNotTrack) && env.navigator?.globalPrivacyControl !== true
+  const deactivate = () => {
+    active = false; generation++; off?.(); off = undefined; fresh.clear()
+    doc.removeEventListener('visibilitychange', flush); target.removeEventListener('pagehide', flush)
+    pending?.abort(); pending = undefined; env.clearTimeout?.(timer); timer = undefined
+  }
+  const navigation = () => { navigated = true; deactivate() }
+  const flush = event => {
+    if (!active || !permitted()) return deactivate()
+    if (env.location.pathname !== initialPath) return navigation()
+    if (event?.type !== 'pagehide' && doc.visibilityState !== 'hidden' || !fresh.size || pending) return
+    const body = JSON.stringify({ route, consent: true, metrics: [...fresh.values()] })
+    fresh.clear()
+    if (body.length > 4096) return
+    const controller = new env.AbortController(), epoch = generation
+    pending = controller
+    timer = env.setTimeout(() => controller.abort(), 3000)
+    Promise.resolve().then(() => active && epoch === generation && permitted() ? env.fetch(origin + config.base + '/_brain/vitals', {
+      method: 'POST', headers: { 'content-type': 'application/json' }, body,
+      mode: 'same-origin', credentials: 'omit', referrerPolicy: 'no-referrer', redirect: 'error', cache: 'no-store', keepalive: true, signal: controller.signal,
+    }) : undefined).then(response => { if (response?.status === 404) state.stop() }).catch(() => {}).finally(() => {
+      if (pending === controller) { pending = undefined; env.clearTimeout(timer); timer = undefined }
+    })
+  }
+  const update = () => {
+    if (disposed) return
+    if (!permitted()) return deactivate()
+    if (active || navigated || env.location.pathname !== initialPath || typeof env.fetch !== 'function' || !env.AbortController) return
+    active = true
+    const epoch = generation
+    off = vitals(metric => {
+      if (!active || epoch !== generation || !permitted()) return
+      if (Object.hasOwn(MAX, metric.name) && Number.isFinite(metric.value) && metric.value >= 0 && metric.value <= MAX[metric.name]) fresh.set(metric.name, { name: metric.name, value: metric.value })
+    }, env)
+    doc.addEventListener('visibilitychange', flush); target.addEventListener('pagehide', flush)
+  }
+  const storage = event => { if (event.key === 'brain:consent' || event.key === null) { delete env[Symbol.for('brain:consent-state')]; update() } }
+  const state = { stop() { disposed = true; deactivate(); target.removeEventListener('brain:navigate', navigation); target.removeEventListener('popstate', navigation); target.removeEventListener('brain:consent', update); target.removeEventListener('storage', storage); delete env[STATE] } }
+  env[STATE] = state
+  target.addEventListener('brain:consent', update); target.addEventListener('storage', storage)
+  // Lifetime events only: no performance access or collection occurs before consent. Revocation must not
+  // erase knowledge that the original document has navigated away and returned to the same pathname.
+  target.addEventListener('brain:navigate', navigation); target.addEventListener('popstate', navigation)
+  update()
+  return state
+}

package/brain-prefetch-shared.js

@@ -29,7 +29,7 @@ export async function prefetchPage(url, signal) {
     let hit
     while ((hit = pattern.exec(text)) && assets.length < 16) {
       const asset = new URL(hit[1] || hit[2] || hit[3], base)
-      if (asset.origin === base.origin && asset.pathname.includes('/_b/')) assets.push(asset.href)
+      if (asset.origin === base.origin && (asset.pathname.includes('/_b/') || /\/[a-z0-9]{8}\.(?:js|mjs|jsbrain|css|cssbrain)$/.test(asset.pathname))) assets.push(asset.href)
     }
     return { ok: true, status: r.status, url: r.url, headers: r.headers, text, bytes, assets }
   } catch { return null }

package/brain-router.js

@@ -96,6 +96,10 @@ export function router(o = {}) {
   const region = o.region || 'main'
   const parse = o.parse || (h => new DOMParser().parseFromString(h, 'text/html'))
   const fullLoad = new Set((o.fullLoad || []).map(p => new URL(p, location.href).pathname.replace(/\/+$/, '') || '/'))
+  // COOP belongs to the document, not the swapped view. Only real head markers opt into provider popups.
+  const popup = d => [...((d.head || d.querySelector('head'))?.querySelectorAll('meta') || [])].some(m =>
+    /^(brain-google-signin|brain-apple-signin)$/i.test(m.getAttribute('name') || '') && m.getAttribute('content') === '1')
+  const popupDocument = popup(document)
   let seq = 0, through = null, stale = false
   const ahead = predict(o, (u, p = true) => same(u, p))
   // Build signature (§35.7): the page's <meta name="brain-build">. A navigation response from another build, or the
@@ -205,6 +209,7 @@ export function router(o = {}) {
       if (!r.ok || !/html/.test(hd('content-type') || 'html')) throw Error(r.status)
       const doc = parse(await r.text())
       if (my !== seq) return // a newer navigation won
+      if (popup(doc) !== popupDocument) return hard(url) // entering or leaving a popup page needs fresh HTTP headers
       // another language (§37): a full load brings its own dictionaries, `lang` and `dir`; locales never mix in memory
       const lang = d => d?.documentElement?.getAttribute('lang')
       if (lang(doc) && lang(document) && lang(doc) !== lang(document)) return hard(url)
@@ -308,7 +313,7 @@ export function router(o = {}) {
     const h = e => {
       if (through && e.destination.url === through) return void (through = null)
       if (e.navigationType === 'reload') return // a reload is always a real full load (e.g. after a deploy deleted a chunk)
-      if (!e.canIntercept || e.hashChange || e.downloadRequest || e.formData || !same(e.destination.url)) return
+      if (!e.canIntercept || e.hashChange || e.downloadRequest || e.formData || externalLink(e.sourceElement) || !same(e.destination.url)) return
       if (e.cancelable && !leave()) return e.preventDefault()
       const to = e.destination.url, from = nav.currentEntry?.url
       if (G.__brainURLOnly?.(from || location.href, to)) return e.intercept({ focusReset: 'manual', handler: () => G.__brainURLRestore?.() })
@@ -362,7 +367,7 @@ export function router(o = {}) {
     if (e.defaultPrevented || e.button || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return
     let a = e.target
     while (a && a.tagName !== 'A') a = a.parentNode
-    if (!a || !a.getAttribute('href') || a.getAttribute('target') || a.hasAttribute('download') || !same(a.href || a.getAttribute('href'))) return
+    if (!a || !a.getAttribute('href') || a.getAttribute('target') || a.hasAttribute('download') || externalLink(a) || !same(a.href || a.getAttribute('href'))) return
     const u = new URL(a.href || a.getAttribute('href'), location.href)
     if (u.pathname === location.pathname && u.hash) return // in-page anchor: native
     e.preventDefault()
@@ -416,7 +421,7 @@ export function predict(o = {}, same = () => false) {
     return !NOPE.test(u.pathname) && !FILE.test(u.pathname) && !SECRET.test(u.search)
   }
   const ok = a => {
-    if (!a?.getAttribute?.('href') || a.getAttribute('target') || a.hasAttribute('download')) return null
+    if (!a?.getAttribute?.('href') || a.getAttribute('target') || a.hasAttribute('download') || externalLink(a)) return null
     for (let n = a; n?.getAttribute; n = n.parentNode) if (n.getAttribute('data-prefetch') === 'false') return null
     const k = key(a.href || a.getAttribute('href'))
     return safe(k) ? k : null
@@ -426,7 +431,7 @@ export function predict(o = {}, same = () => false) {
     let n = 0
     for (const href of list) {
       const u = key(href)
-      if (!u || pre.has(u) || pre.size > 47 || !same(u) || !new URL(u).pathname.includes('/_b/') || ++n > 8) continue
+      if (!u || pre.has(u) || pre.size > 47 || !same(u) || !(new URL(u).pathname.includes('/_b/') || /\/[a-z0-9]{8}\.(?:js|mjs|jsbrain|css|cssbrain)$/.test(new URL(u).pathname)) || ++n > 8) continue
       const l = document.createElement('link')
       l.setAttribute('rel', /\.(js|jsbrain)(\?|$)/.test(u) ? 'modulepreload' : 'prefetch')
       l.setAttribute('href', u)
@@ -619,3 +624,5 @@ function hold(el) {
     },
   })
 }
+// An absolute navigation can intentionally belong to another site on the same origin.
+const externalLink = a => (a?.getAttribute?.('rel') || '').split(/\s+/).some(token => token.toLowerCase() === 'external') && /^https?:\/\//i.test((a?.getAttribute?.('href') || '').trim())

package/brain-sentry.js

@@ -0,0 +1,71 @@
+// Optional error reporting. Consent owns the entire capture lifetime; raw values never leave this function.
+import { _rt } from './brain.js'
+import { consented } from './brain-consent.js'
+
+const TYPES = new Set(['Error', 'TypeError', 'RangeError', 'ReferenceError', 'SyntaxError', 'URIError', 'EvalError', 'AggregateError'])
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+const STATE = Symbol.for('brain:sentry')
+export function startSentry(config, env = globalThis, subscribe) {
+  if (env.__brainSSR || env.__brainRoute || !env.window || !env.location || env[STATE]) return env[STATE]
+  if (!config || !config.assets || typeof config.base !== 'string' || !/^(?:\/[a-zA-Z0-9_.-]+)*$/.test(config.base) || config.base.split('/').some(p => p === '.' || p === '..')) return
+  const assets = new Map()
+  for (const [path, id] of Object.entries(config.assets)) if (path.length <= 511 && /^(?:[a-zA-Z0-9_.-]+\/)*[a-z0-9]{8}\.(?:js|jsbrain)$/.test(path) && UUID.test(id)) assets.set('/' + path, id)
+  const target = env.window, pending = new Set(), seen = new Set()
+  let active = false, disposed = false, off, windowStart = 0, count = 0, generation = 0
+  const dnt = value => value === '1' || value === 'yes' || value === true
+  const permitted = () => consented('analytics', env) && !dnt(env.navigator?.doNotTrack) && !dnt(env.navigator?.msDoNotTrack) && !dnt(env.doNotTrack) && env.navigator?.globalPrivacyControl !== true
+  const capture = error => {
+    try {
+      if (!active || !permitted() || pending.size >= 4 || !error) return
+      const stack = error.stack
+      if (typeof stack !== 'string') return
+      const frames = []
+      for (const line of stack.slice(0, 8192).split('\n').slice(0, 41)) {
+        const m = /^\s+at (?:[^\r\n()]{1,160} \()?(https?:\/\/[^\s()]+):(\d{1,7}):(\d{1,7})\)?$/.exec(line) || /^[^\s@()]{0,160}@(https?:\/\/[^\s()]+):(\d{1,7}):(\d{1,7})$/.exec(line)
+        if (!m) continue
+        const url = new URL(m[1]), id = assets.get(url.pathname)
+        if (url.origin !== env.location.origin || url.search || url.hash || !id || +m[2] < 1 || +m[3] < 1) continue
+        frames.push({ asset: url.pathname, line: +m[2], column: +m[3], debugId: id })
+        if (frames.length >= 20) break
+      }
+      if (!frames.length) return
+      const name = error.name
+      const type = TYPES.has(name) ? name : 'Error'
+      const payload = JSON.stringify({ schemaVersion: 1, type, frames })
+      const now = Date.now()
+      if (now - windowStart >= 60000) { windowStart = now; count = 0; seen.clear() }
+      if (count >= 8 || seen.has(payload) || seen.size >= 32) return
+      count++; seen.add(payload)
+      const controller = new env.AbortController()
+      const epoch = generation
+      pending.add(controller)
+      const timer = env.setTimeout(() => controller.abort(), 3000)
+      Promise.resolve().then(() => active && epoch === generation && permitted() ? env.fetch(env.location.origin + config.base + '/_brain/sentry', {
+        method: 'POST', headers: { 'content-type': 'application/json' }, body: payload,
+        mode: 'same-origin', credentials: 'omit', referrerPolicy: 'no-referrer', redirect: 'error', cache: 'no-store', signal: controller.signal,
+      }) : undefined).catch(() => {}).finally(() => { env.clearTimeout(timer); pending.delete(controller) })
+    } catch {} // reporting, including hostile accessors, never enters the app's error routing
+  }
+  const onError = event => capture(event.error)
+  const onRejection = event => capture(event.reason)
+  const deactivate = () => {
+    active = false; generation++; off?.(); off = undefined
+    target.removeEventListener('error', onError); target.removeEventListener('unhandledrejection', onRejection)
+    for (const request of pending) request.abort()
+    pending.clear(); seen.clear(); count = 0; windowStart = 0
+  }
+  const update = () => {
+    if (disposed) return
+    if (!permitted()) return deactivate()
+    if (active || typeof env.fetch !== 'function' || !env.AbortController) return
+    active = true
+    off = (subscribe || _rt().listenErrors)(capture)
+    target.addEventListener('error', onError); target.addEventListener('unhandledrejection', onRejection)
+  }
+  const storage = event => { if (event.key === 'brain:consent' || event.key === null) update() }
+  target.addEventListener('brain:consent', update); target.addEventListener('storage', storage)
+  const state = { stop() { disposed = true; deactivate(); target.removeEventListener('brain:consent', update); target.removeEventListener('storage', storage); delete env[STATE] } }
+  env[STATE] = state
+  update()
+  return state
+}

package/brain-text.js

@@ -0,0 +1,56 @@
+// Pure bounded Unicode matching; no locale, network, DOM or persistent state.
+const letters = value => {
+  if (typeof value !== 'string' || value.length > 8192) throw new RangeError('text helpers require strings of at most 4096 Unicode characters')
+  const result = Array.from(value)
+  if (result.length > 4096) throw new RangeError('text helpers require strings of at most 4096 Unicode characters')
+  return result
+}
+const fold = value => {
+  letters(value)
+  const result = value.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase()
+  letters(result)
+  return result
+}
+// Optimal string alignment: adjacent transpositions count as one edit; the band and row minimum bound work.
+const distance = (left, right, max = 2) => {
+  if (!Number.isInteger(max) || max < 0 || max > 64) throw new RangeError('text.distance max must be an integer from 0 to 64')
+  const a = letters(left), b = letters(right), n = a.length, m = b.length, cap = max + 1
+  if (Math.abs(n - m) > max) return cap
+  if (!n) return Math.min(m, cap)
+  if (!m) return Math.min(n, cap)
+  let before = new Uint16Array(m + 1).fill(cap)
+  let previous = new Uint16Array(m + 1).fill(cap)
+  let current = new Uint16Array(m + 1).fill(cap)
+  for (let j = 0; j <= Math.min(m, max); j++) previous[j] = j
+  for (let i = 1; i <= n; i++) {
+    const low = Math.max(1, i - max), high = Math.min(m, i + max)
+    current[0] = Math.min(i, cap)
+    if (low > 1) current[low - 1] = cap
+    if (high < m) current[high + 1] = cap
+    let minimum = current[0]
+    for (let j = low; j <= high; j++) {
+      let value = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1), cap)
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) value = Math.min(value, before[j - 2] + 1)
+      current[j] = value
+      minimum = Math.min(minimum, value)
+    }
+    if (minimum > max) return cap
+    const spare = before; before = previous; previous = current; current = spare
+  }
+  return Math.min(previous[m], cap)
+}
+const fuzzy = (word, list) => {
+  const needle = fold(word), size = letters(needle).length
+  if (!Array.isArray(list) || list.length > 10000) throw new RangeError('text.fuzzy requires at most 10000 candidate strings')
+  const count = list.length, max = size < 4 ? 0 : size < 8 ? 1 : 2
+  const found = []
+  let units = 0
+  for (let i = 0; i < count; i++) {
+    const candidate = list[i]
+    if (typeof candidate !== 'string' || candidate.length > 1048576 - units) throw new RangeError('text.fuzzy candidate text exceeds 1048576 UTF-16 code units or contains a non-string')
+    units += candidate.length
+    if (distance(needle, fold(candidate), max) <= max) found.push(candidate)
+  }
+  return found
+}
+export const text = Object.freeze({ fold, distance, fuzzy })