rip-lang 3.15.4 → 3.16.1

package/src/app.rip

@@ -1,1571 +0,0 @@
-# ==============================================================================
-# Rip App — application framework for Rip
-#
-# Provides the runtime infrastructure for building reactive web applications:
-#
-#   Stash      — deep reactive proxy with path navigation
-#   Resource   — async data loading with reactive states
-#   Timing     — delay, debounce, throttle, hold
-#   Components — in-memory component store with file watchers
-#   Router     — file-based URL routing with layouts and params
-#   Renderer   — compile-import-mount pipeline with error boundaries
-#   Launch     — orchestrator that wires everything together
-#
-# The reactive primitives (__state, __effect, __batch) are provided by the
-# Rip compiler runtime and registered on globalThis when the bundle loads.
-#
-# Author: Steve Shreeve <steve.shreeve@gmail.com>
-#   Date: February 2026
-# ==============================================================================
-
-# Rip's reactive primitives (registered on globalThis by rip.js)
-{ __state, __effect, __batch } = globalThis.__rip
-
-# Re-export context functions from the component runtime
-{ setContext, getContext, hasContext } = globalThis.__ripComponent or {}
-export { setContext, getContext, hasContext }
-
-# ==============================================================================
-# Stash — deep reactive proxy with path navigation
-#
-# Wraps a plain object in a Proxy that lazily creates fine-grained signals
-# for each property. Nested objects are wrapped recursively. Supports path-
-# based bracket access (e.g., app['data/theme/title']) and 7 reserved methods
-# for atomic/structural operations: inc, dec, flip, join, keys, has, del.
-# ==============================================================================
-
-PROXIES   = new WeakMap()
-METHODS   = new WeakMap()
-
-_keysVersion = 0
-_writeVersion = __state(0)
-_depth = 0
-
-isPathKey = (prop) -> typeof prop is 'string' and (prop.indexOf('.') isnt -1 or prop.indexOf('/') isnt -1 or prop.indexOf('[') isnt -1)
-
-isNum = (val) -> /^-?\d+$/.test val
-
-getSignal = (target, prop) ->
-  unless target[:signals]
-    Object.defineProperty target, :signals, { value: new Map(), enumerable: false }
-  sig = target[:signals].get(prop)
-  unless sig
-    sig = __state(target[prop])
-    target[:signals].set(prop, sig)
-  sig
-
-keysSignal = (target) -> getSignal(target, :keys)
-
-wrapDeep = (value) ->
-  return value unless value? and typeof value is 'object'
-  return value if value[:stash]
-  return value if value instanceof Date or value instanceof RegExp or value instanceof Map or value instanceof Set or value instanceof Promise
-  existing = PROXIES.get(value)
-  return existing if existing
-  makeProxy(value)
-
-makeProxy = (target) ->
-  proxy = null
-  handler =
-    get: (target, prop) ->
-      return true if prop is :stash
-      return target if prop is :raw
-      return Reflect.get(target, prop) if typeof prop is 'symbol'
-
-      if prop is 'length' and Array.isArray(target)
-        keysSignal(target).value
-        return target.length
-
-      if not _depth and isPathKey(prop)
-        return stashGet(proxy, prop)
-
-      fn = stashMethodFn(proxy, prop)
-      return fn if fn
-
-      sig = getSignal(target, prop)
-      val = sig.value
-
-      return wrapDeep(val) if val? and typeof val is 'object'
-      val
-
-    set: (target, prop, value) ->
-      if not _depth and isPathKey(prop)
-        stashSet(proxy, prop, value)
-        return true
-
-      old = target[prop]
-      r = if value?[:raw] then value[:raw] else value
-      return true if r is old
-      target[prop] = r
-
-      if target[:signals]?.has(prop)
-        target[:signals].get(prop).value = r
-      if old is undefined and r isnt undefined
-        keysSignal(target).value = ++_keysVersion
-      _writeVersion.value++
-
-      true
-
-    deleteProperty: (target, prop) ->
-      delete target[prop]
-      sig = target[:signals]?.get(prop)
-      sig?.value = undefined
-      keysSignal(target).value = ++_keysVersion
-      _writeVersion.value++
-      true
-
-    ownKeys: (target) ->
-      keysSignal(target).value
-      Reflect.ownKeys(target)
-
-  proxy = new Proxy(target, handler)
-  PROXIES.set(target, proxy)
-  proxy
-
-# Path navigation
-PATH_RE = /([./][^./\[\s]+|\[[-+]?\d+\]|\[(?:"[^"]+"|'[^']+')\])/
-
-walk = (path) ->
-  list = ('.' + path).split(PATH_RE)
-  list.shift()
-  result = []
-  i = 0
-  while i < list.length
-    part = list[i]
-    chr = part[0]
-    if chr is '.' or chr is '/'
-      result.push part.slice(1)
-    else if chr is '['
-      if part[1] is '"' or part[1] is "'"
-        result.push part.slice(2, -2)
-      else
-        result.push +(part.slice(1, -1))
-    i += 2
-  result
-
-resolveIndex = (seg, obj) ->
-  if typeof seg is 'number' and seg < 0
-    t = raw(obj)
-    return t.length + seg if Array.isArray(t)
-  seg
-
-stashGet = (proxy, path) ->
-  segs = walk(path)
-  obj = proxy
-  _depth++
-  try
-    for seg in segs
-      return undefined unless obj?
-      obj = obj[resolveIndex(seg, obj)]
-    obj
-  finally
-    _depth--
-
-stashSet = (proxy, path, value) ->
-  segs = walk(path)
-  obj = proxy
-  _depth++
-  try
-    for seg, i in segs
-      key = resolveIndex(seg, obj)
-      if i is segs.length - 1
-        obj[key] = value
-      else
-        unless obj[key]?
-          nextSeg = segs[i + 1]
-          obj[key] = if typeof nextSeg is 'number' or isNum(nextSeg) then [] else {}
-        obj = obj[key]
-    value
-  finally
-    _depth--
-
-# Stash methods — reserved names for atomic/structural operations
-STASH_METHOD_NAMES = { inc: true, dec: true, flip: true, join: true, keys: true, has: true, del: true }
-
-stashMethodFn = (proxy, prop) ->
-  return undefined unless STASH_METHOD_NAMES[prop]
-  cache = METHODS.get(proxy)
-  unless cache
-    cache = {}
-    METHODS.set(proxy, cache)
-  return cache[prop] if cache[prop]
-  fn = switch prop
-    when 'inc'  then (path, step = 1) -> cur = stashGet(proxy, path) ?? 0; stashSet(proxy, path, cur + step)
-    when 'dec'  then (path, step = 1) -> cur = stashGet(proxy, path) ?? 0; stashSet(proxy, path, cur - step)
-    when 'flip' then (path) -> cur = stashGet(proxy, path) ?? false; stashSet(proxy, path, not cur)
-    when 'join' then (path, obj) ->
-      __batch ->
-        target = stashGet(proxy, path)
-        unless target? and typeof target is 'object'
-          stashSet(proxy, path, {})
-          target = stashGet(proxy, path)
-        _depth++
-        try
-          target[k] = v for k, v of obj
-        finally
-          _depth--
-    when 'keys' then (path) ->
-      _depth++
-      try
-        segs = walk(path)
-        obj = proxy
-        for seg in segs
-          return [] unless obj?
-          obj = obj[resolveIndex(seg, obj)]
-        return [] unless obj? and typeof obj is 'object'
-        t = raw(obj)
-        keysSignal(t).value
-        Object.keys(t)
-      finally
-        _depth--
-    when 'has' then (path) ->
-      _depth++
-      try
-        segs = walk(path)
-        return false unless segs.length > 0
-        obj = proxy
-        for seg, i in segs
-          key = resolveIndex(seg, obj)
-          if i is segs.length - 1
-            t = raw(obj)
-            keysSignal(t).value
-            return Object.prototype.hasOwnProperty.call(t, key)
-          return false unless obj?
-          obj = obj[key]
-        false
-      finally
-        _depth--
-    when 'del' then (path) ->
-      _depth++
-      try
-        segs = walk(path)
-        return unless segs.length > 0
-        obj = proxy
-        for seg, i in segs
-          key = resolveIndex(seg, obj)
-          if i is segs.length - 1
-            delete obj[key]
-            return
-          return unless obj?
-          obj = obj[key]
-      finally
-        _depth--
-  cache[prop] = fn
-  fn
-
-export stash = (data = {}) -> makeProxy(data)
-
-export raw = (proxy) -> if proxy?[:raw] then proxy[:raw] else proxy
-
-export isStash = (obj) -> obj?[:stash] is true
-
-export persistStash = (app, opts = {}) ->
-  target = raw(app) or app
-  return if target[:persisted]
-  target[:persisted] = true
-  storage = if opts.local then localStorage else sessionStorage
-  storageKey = opts.key or '__rip_app'
-  try
-    saved = storage.getItem(storageKey)
-    if saved
-      savedData = JSON.parse(saved)
-      app.data[k] = v for k, v of savedData
-  catch
-    null
-  _save = ->
-    try storage.setItem storageKey, JSON.stringify(raw(app.data))
-    catch then null
-  __effect ->
-    _writeVersion.value
-    t = setTimeout _save, 2000
-    -> clearTimeout t
-  window.addEventListener 'beforeunload', _save
-
-# ==============================================================================
-# Resource — async data loading with reactive loading/error/data states
-#
-# Wraps an async function and exposes reactive .data, .loading, and .error
-# properties. Calls the function immediately unless opts.lazy is set.
-# Call .refetch() to reload.
-# ==============================================================================
-
-export createResource = (fn, opts = {}) ->
-  _data    = __state(opts.initial or null)
-  _loading = __state(false)
-  _error   = __state(null)
-
-  load = ->
-    _loading.value = true
-    _error.value = null
-    try
-      result = await fn()
-      _data.value = result
-    catch err
-      _error.value = err
-    finally
-      _loading.value = false
-
-  resource =
-    data:    undefined
-    loading: undefined
-    error:   undefined
-    refetch: load
-
-  Object.defineProperty resource, 'data', get: -> _data.value
-  Object.defineProperty resource, 'loading', get: -> _loading.value
-  Object.defineProperty resource, 'error', get: -> _error.value
-
-  load() unless opts.lazy
-  resource
-
-# ==============================================================================
-# Timing — reactive timing primitives
-#
-# Each takes a duration (ms) and a reactive source (signal or function).
-# Returns a new signal whose value is derived from the source with a
-# time-based transformation. Cleanup is automatic via effect disposal.
-# ==============================================================================
-
-_toFn = (source) ->
-  if typeof source is 'function' then source else -> source.value
-
-_proxy = (out, source) ->
-  obj = read: -> out.read()
-  Object.defineProperty obj, 'value',
-    get: -> out.value
-    set: (v) -> source.value = v
-  obj
-
-# delay(ms, source) — truthy waits ms, falsy immediate
-# Usage: showLoading := delay 200 -> loading
-#        navigating = delay 100, __state(false)
-export delay = (ms, source) ->
-  fn = _toFn(source)
-  out = __state(!!fn())
-  __effect ->
-    if fn()
-      t = setTimeout (-> out.value = true), ms
-      -> clearTimeout t
-    else
-      out.value = false
-  if typeof source isnt 'function' then _proxy(out, source) else out
-
-# debounce(ms, source) — waits ms after last change, then propagates
-# Usage: debouncedQuery := debounce 300 -> query
-export debounce = (ms, source) ->
-  fn = _toFn(source)
-  out = __state(fn())
-  __effect ->
-    val = fn()
-    t = setTimeout (-> out.value = val), ms
-    -> clearTimeout t
-  if typeof source isnt 'function' then _proxy(out, source) else out
-
-# throttle(ms, source) — propagates at most once per ms
-# Usage: smoothScroll := throttle 100 -> scrollY
-export throttle = (ms, source) ->
-  fn = _toFn(source)
-  out = __state(fn())
-  last = 0
-  __effect ->
-    val = fn()
-    now = Date.now()
-    remaining = ms - (now - last)
-    if remaining <= 0
-      out.value = val
-      last = now
-    else
-      t = setTimeout (->
-        out.value = fn()
-        last = Date.now()
-      ), remaining
-      -> clearTimeout t
-  if typeof source isnt 'function' then _proxy(out, source) else out
-
-# hold(ms, source) — once truthy, stays true for at least ms
-# Usage: showSaved := hold 2000 -> saved
-export hold = (ms, source) ->
-  fn = _toFn(source)
-  out = __state(!!fn())
-  __effect ->
-    if fn()
-      out.value = true
-    else
-      t = setTimeout (-> out.value = false), ms
-      -> clearTimeout t
-  if typeof source isnt 'function' then _proxy(out, source) else out
-
-# ==============================================================================
-# Components — in-memory file store with watchers
-#
-# A virtual filesystem for .rip component sources. Supports read, write,
-# delete, listing, and glob-style operations. Watchers are notified on
-# create/change/delete. Compiled modules are cached alongside sources.
-# ==============================================================================
-
-export createComponents = ->
-  files = new Map()
-  watchers = []
-  compiled = new Map()
-
-  notify = (event, path) ->
-    for watcher in watchers
-      watcher(event, path)
-
-  read:    (path) -> files.get(path)
-  write:   (path, content) ->
-    isNew = not files.has(path)
-    files.set(path, content)
-    compiled.delete(path)
-    notify (if isNew then 'create' else 'change'), path
-
-  del:     (path) ->
-    files.delete(path)
-    compiled.delete(path)
-    notify 'delete', path
-
-  exists:  (path) -> files.has(path)
-  size:    -> files.size
-
-  list: (dir = '') ->
-    result = []
-    prefix = if dir then dir + '/' else ''
-    for [path] in files
-      if path.startsWith(prefix)
-        rest = path.slice(prefix.length)
-        continue if rest.includes('/')
-        result.push path
-    result
-
-  listAll: (dir = '') ->
-    result = []
-    prefix = if dir then dir + '/' else ''
-    for [path] in files
-      result.push path if path.startsWith(prefix)
-    result
-
-  load: (obj) ->
-    for key, content of obj
-      files.set(key, content)
-
-  watch: (fn) ->
-    watchers.push fn
-    -> watchers.splice(watchers.indexOf(fn), 1)
-
-  getCompiled: (path) -> compiled.get(path)
-  setCompiled: (path, result) -> compiled.set(path, result)
-
-# ==============================================================================
-# Router — file-based URL routing with reactive state
-#
-# Maps URL paths to component files using a file-system convention:
-#   components/index.rip       → /
-#   components/about.rip       → /about
-#   components/users/[id].rip  → /users/:id
-#   components/[...rest].rip   → /* (catch-all)
-#
-# Supports nested layouts via _layout.rip files, hash-mode routing,
-# base path prefixes, and query/hash tracking.
-# ==============================================================================
-
-fileToPattern = (rel) ->
-  pattern = rel.replace(/\.rip$/, '')
-  pattern = pattern.replace(/\[\.\.\.(\w+)\]/g, '*$1')
-  pattern = pattern.replace(/\[(\w+)\]/g, ':$1')
-  return '/' if pattern is 'index'
-  pattern = pattern.replace(/\/index$/, '')
-  '/' + pattern
-
-patternToRegex = (pattern) ->
-  names = []
-  str = pattern
-    .replace /\*(\w+)/g, (_, name) -> names.push(name); '(.+)'
-    .replace /:(\w+)/g, (_, name) -> names.push(name); '([^/]+)'
-  { regex: new RegExp('^' + str + '$'), names }
-
-matchRoute = (path, routes) ->
-  for route in routes
-    match = path.match(route.regex.regex)
-    if match
-      params = {}
-      for name, i in route.regex.names
-        params[name] = decodeURIComponent(match[i + 1])
-      return { route, params }
-  null
-
-buildRoutes = (components, root = 'components') ->
-  routes = []
-  layouts = new Map()
-  allFiles = components.listAll(root)
-
-  for filePath in allFiles
-    rel = filePath.slice(root.length + 1)
-    continue unless rel.endsWith('.rip')
-    name = rel.split('/').pop()
-
-    if name is '_layout.rip'
-      dir = if rel is '_layout.rip' then '' else rel.slice(0, -'/_layout.rip'.length)
-      layouts.set dir, filePath
-      continue
-
-    continue if name.startsWith('_')
-
-    # Skip files in _-prefixed directories (shared components, not pages)
-    segs = rel.split('/')
-    continue if segs.length > 1 and segs.some((s, i) -> i < segs.length - 1 and s.startsWith('_'))
-
-    urlPattern = fileToPattern(rel)
-    regex = patternToRegex(urlPattern)
-    routes.push { pattern: urlPattern, regex, file: filePath, rel }
-
-  # Sort: static first, then fewest dynamic segments, catch-all last
-  routes.sort (a, b) ->
-    aDyn = (a.pattern.match(/:/g) or []).length
-    bDyn = (b.pattern.match(/:/g) or []).length
-    aCatch = if a.pattern.includes('*') then 1 else 0
-    bCatch = if b.pattern.includes('*') then 1 else 0
-    return aCatch - bCatch if aCatch isnt bCatch
-    return aDyn - bDyn if aDyn isnt bDyn
-    a.pattern.localeCompare(b.pattern)
-
-  { routes, layouts }
-
-getLayoutChain = (routeFile, root, layouts) ->
-  chain = []
-  rel = routeFile.slice(root.length + 1)
-  segments = rel.split('/')
-  dir = ''
-
-  chain.push layouts.get('') if layouts.has('')
-  for seg, i in segments
-    break if i is segments.length - 1
-    dir = if dir then dir + '/' + seg else seg
-    chain.push layouts.get(dir) if layouts.has(dir)
-  chain
-
-export createRouter = (components, opts = {}) ->
-  root = opts.root or 'components'
-  base = opts.base or ''
-  hashMode = opts.hash or false
-  onError = opts.onError or null
-
-  stripBase = (url) ->
-    if base and url.startsWith(base) then url.slice(base.length) or '/' else url
-
-  addBase = (path) ->
-    if base then base + path else path
-
-  readUrl = ->
-    if hashMode
-      h = location.hash.slice(1)
-      return '/' unless h
-      if h[0] is '/' then h else '/' + h
-    else
-      location.pathname + location.search + location.hash
-
-  writeUrl = (path) ->
-    if hashMode
-      if path is '/' then location.pathname else '#' + path.slice(1)
-    else
-      addBase(path)
-
-  _path       = __state(stripBase(if hashMode then readUrl() else location.pathname))
-  _params     = __state({})
-  _route      = __state(null)
-  _layouts    = __state([])
-  _query      = __state({})
-  _hash       = __state('')
-  _navigating = delay 100, __state(false)
-
-  tree = buildRoutes(components, root)
-  navCallbacks = new Set()
-
-  components.watch (event, path) ->
-    return unless path.startsWith(root + '/')
-    tree = buildRoutes(components, root)
-
-  resolve = (url) ->
-    rawPath = url.split('?')[0].split('#')[0]
-    path = stripBase(rawPath)
-    path = if path[0] is '/' then path else '/' + path
-    queryStr = url.split('?')[1]?.split('#')[0] or ''
-    hash = if url.includes('#') then url.split('#')[1] else ''
-
-    result = matchRoute(path, tree.routes)
-    if result
-      __batch ->
-        _path.value = path
-        _params.value = result.params
-        _route.value = result.route
-        _layouts.value = getLayoutChain(result.route.file, root, tree.layouts)
-        _query.value = Object.fromEntries(new URLSearchParams(queryStr))
-        _hash.value = hash
-      cb(router.current) for cb in navCallbacks
-      return true
-
-    onError({ status: 404, path }) if onError
-    false
-
-  onPopState = -> resolve(readUrl())
-  window.addEventListener 'popstate', onPopState if typeof window isnt 'undefined'
-
-  onClick = (e) ->
-    return if e.button isnt 0 or e.metaKey or e.ctrlKey or e.shiftKey or e.altKey
-    target = e.target
-    target = target.parentElement while target and target.tagName isnt 'A'
-    return unless target?.href
-    url = new URL(target.href, location.origin)
-    return if url.origin isnt location.origin
-    return if target.target is '_blank' or target.hasAttribute('data-external')
-    e.preventDefault()
-    dest = if hashMode and url.hash then (url.hash.slice(1) or '/') else (url.pathname + url.search + url.hash)
-    router.push dest
-
-  document.addEventListener 'click', onClick if typeof document isnt 'undefined'
-
-  router =
-    push: (url) ->
-      if resolve(url)
-        history.pushState null, '', writeUrl(_path.read())
-
-    replace: (url) ->
-      if resolve(url)
-        history.replaceState null, '', writeUrl(_path.read())
-
-    back: -> history.back()
-    forward: -> history.forward()
-
-    current:    undefined
-    path:       undefined
-    params:     undefined
-    route:      undefined
-    layouts:    undefined
-    query:      undefined
-    hash:       undefined
-    navigating: undefined
-
-    onNavigate: (cb) ->
-      navCallbacks.add cb
-      -> navCallbacks.delete cb
-
-    rebuild: -> tree = buildRoutes(components, root)
-
-    routes: undefined
-
-    init: ->
-      resolve readUrl()
-      router
-
-    destroy: ->
-      window.removeEventListener 'popstate', onPopState if typeof window isnt 'undefined'
-      document.removeEventListener 'click', onClick if typeof document isnt 'undefined'
-      navCallbacks.clear()
-
-  Object.defineProperty router, 'current', get: ->
-    { path: _path.value, params: _params.value, route: _route.value, layouts: _layouts.value, query: _query.value, hash: _hash.value }
-
-  Object.defineProperty router, 'path', get: -> _path.value
-  Object.defineProperty router, 'params', get: -> _params.value
-  Object.defineProperty router, 'route', get: -> _route.value
-  Object.defineProperty router, 'layouts', get: -> _layouts.value
-  Object.defineProperty router, 'query', get: -> _query.value
-  Object.defineProperty router, 'hash', get: -> _hash.value
-  Object.defineProperty router, 'navigating',
-    get: -> _navigating.value
-    set: (v) -> _navigating.value = v
-  Object.defineProperty router, 'routes', get: -> tree.routes
-
-  router
-
-# ==============================================================================
-# Renderer — compile, import, mount, unmount, and manage components
-#
-# Handles the full lifecycle: compile Rip source to JS, import as an ES
-# module, instantiate, mount into the DOM. Supports nested layouts with
-# slot-based composition, component caching for back/forward navigation,
-# generation tracking to prevent stale mounts, and error boundaries.
-# ==============================================================================
-
-arraysEqual = (a, b) ->
-  return false if a.length isnt b.length
-  for item, i in a
-    return false if item isnt b[i]
-  true
-
-findComponent = (mod) ->
-  for key, val of mod
-    return val if typeof val is 'function' and (val.prototype?.mount or val.prototype?._create)
-  mod.default if typeof mod.default is 'function'
-
-# --------------------------------------------------------------------------
-# Component resolution — name discovery, lazy compilation, class registry
-# --------------------------------------------------------------------------
-
-findAllComponents = (mod) ->
-  result = {}
-  for key, val of mod
-    if typeof val is 'function' and (val.prototype?.mount or val.prototype?._create)
-      result[key] = val
-  result
-
-# Convert file path to PascalCase component name
-# components/card.rip → Card, components/todo-item.rip → TodoItem
-fileToComponentName = (filePath) ->
-  name = filePath.split('/').pop().replace(/\.rip$/, '')
-  name.replace /(^|[-_])([a-z])/g, (_, sep, ch) -> ch.toUpperCase()
-
-# Build name-to-path map from component store
-buildComponentMap = (components, root = 'components') ->
-  map = {}
-  for path in components.listAll(root)
-    continue unless path.endsWith('.rip')
-    fileName = path.split('/').pop()
-    continue if fileName.startsWith('_')
-    name = fileToComponentName(path)
-    if map[name]
-      console.warn "[Rip] Component name collision: #{name} (#{map[name]} vs #{path})"
-    map[name] = path
-  map
-
-# Resolve a .rip import specifier to a path in the component store
-resolveStorePath = (specifier, currentPath, components) ->
-  clean = specifier.replace(/^(\.\.\/|\.\/)+/, '')
-  basename = clean.split('/').pop()
-  # Direct resolution relative to current file in the store
-  if currentPath
-    parts = currentPath.split('/')
-    parts.pop()
-    for seg in specifier.split('/')
-      if seg is '..'
-        parts.pop()
-      else unless seg is '.'
-        parts.push seg
-    candidate = parts.join('/')
-    return candidate if components.exists(candidate)
-  # Try common store prefixes
-  return "components/_lib/#{clean}" if components.exists("components/_lib/#{clean}")
-  return "components/#{clean}" if components.exists("components/#{clean}")
-  # Basename search as last resort
-  for p in components.listAll('components')
-    return p if p.endsWith("/#{basename}")
-  null
-
-compileAndImport = (source, compile, components = null, path = null, resolver = null) ->
-  # Check compilation cache
-  if components and path
-    cached = components.getCompiled(path)
-    return cached if cached
-
-  # Mark as in-progress to prevent circular dependency loops
-  if resolver and path
-    resolver.compiling ?= {}
-    resolver.compiling[path] = true
-
-  # Browser-debugger support — when enabled, compile with an inline source
-  # map keyed to the component's logical path. We still need to compensate
-  # for line shifts introduced by the header + preamble we prepend below;
-  # `prefixLines` tracks that and we apply `offsetSourceMap` once at the end.
-  debug = globalThis?.__ripDebug?.enabled and path
-  prefixLines = 0
-  js = if debug
-    compile(source, sourceMap: 'inline', filename: path)
-  else
-    compile(source)
-
-  if resolver
-    importedNames = new Set()
-
-    # Step 1: Rewrite .rip imports to blob URLs
-    if components
-      ripImportRe = /^(\s*import\s+(?:\{([^}]+)\}\s+from\s+|.*?\s+from\s+)?['"])([^'"]*\.rip)(['"];?\s*)$/gm
-      matches = Array.from(js.matchAll(ripImportRe))
-      # Walk matches in reverse so string indices stay valid after each splice
-      for m in matches by -1
-        [full, pre, namedImports, specifier, post] = m
-        storePath = resolveStorePath(specifier, path, components)
-        continue if storePath is path
-        unless storePath
-          msg = "[Rip] Could not resolve import: #{specifier}"
-          msg += " (from #{path})" if path
-          console.warn msg
-          continue
-        # Guard against circular imports — skip if already being compiled
-        unless resolver.blobUrls?[storePath]
-          continue if resolver.compiling?[storePath]
-          depSource = components.read(storePath)
-          if depSource
-            compileAndImport! depSource, compile, components, storePath, resolver
-        blobUrl = resolver.blobUrls?[storePath]
-        if blobUrl
-          replacement = "#{pre}#{blobUrl}#{post}"
-          js = js.slice(0, m.index) + replacement + js.slice(m.index + full.length)
-          if namedImports
-            for n in namedImports.split(',')
-              importedNames.add(n.trim().split(/\s+as\s+/).pop().trim())
-
-    # Step 2: Implicit component resolution — for template-used components not explicitly imported
-    needed = {}
-    for name, depPath of resolver.map
-      continue if importedNames.has(name)
-      if depPath isnt path and js.includes("new #{name}(")
-        unless resolver.classes[name]
-          depSource = components.read(depPath)
-          if depSource
-            depMod = compileAndImport! depSource, compile, components, depPath, resolver
-            found = findAllComponents(depMod)
-            resolver.classes[k] = v for k, v of found
-        needed[name] = true if resolver.classes[name]
-
-    # Inject resolved components into scope via preamble
-    names = Object.keys(needed)
-    if names.length > 0
-      preamble = "const {#{names.join(', ')}} = globalThis['#{resolver.key}'];\n"
-      js = preamble + js
-      prefixLines += 1
-
-  header = if path then "// #{path}\n" else ''
-  prefixLines += 1 if header
-  finalJs = header + js
-
-  # Source-map post-processing: prepend N semicolons to map.mappings so
-  # generated lines line up with `header + preamble + js`. The Blob URL
-  # itself becomes the source identity in DevTools, so an explicit
-  # //# sourceURL pragma isn't needed here (only for eval'd code).
-  if debug and prefixLines > 0
-    offset = globalThis?.__ripDebug?.offsetSourceMap
-    finalJs = offset(finalJs, prefixLines) if offset
-
-  blob = new Blob([finalJs], { type: 'application/javascript' })
-  url = URL.createObjectURL(blob)
-
-  # Cache blob URL so other files can rewrite imports to point here
-  if resolver and path
-    resolver.blobUrls ?= {}
-    resolver.blobUrls[path] = url
-    delete resolver.compiling[path] if resolver.compiling
-
-  mod = await import(url)
-
-  # Register any components from this module
-  if resolver
-    found = findAllComponents(mod)
-    resolver.classes[k] = v for k, v of found
-
-  # Store in cache
-  components.setCompiled(path, mod) if components and path
-  mod
-
-export createRenderer = (opts = {}) ->
-  { router, app, components, resolver, compile, target, onError } = opts
-
-  container = if typeof target is 'string'
-    document.querySelector(target)
-  else
-    target or document.getElementById('app')
-
-  unless container
-    container = document.createElement('div')
-    container.id = 'app'
-    document.body.appendChild container
-
-  currentComponent = null
-  currentRoute = null
-  currentParams = null
-  currentLayouts = []
-  layoutInstances = []
-  mountPoint = container
-  generation = 0
-  disposeEffect = null
-  componentCache = new Map()
-  maxCacheSize = opts.cacheSize or 10
-
-  cacheComponent = ->
-    if currentComponent and currentRoute
-      currentComponent.beforeUnmount() if currentComponent.beforeUnmount
-      componentCache.set currentRoute, currentComponent
-      # Evict oldest if over limit
-      if componentCache.size > maxCacheSize
-        oldest = componentCache.keys().next().value
-        evicted = componentCache.get(oldest)
-        evicted.unmounted() if evicted.unmounted
-        componentCache.delete oldest
-      # Don't remove _root here — leave visible until new content is ready
-      currentComponent = null
-      currentRoute = null
-
-  unmount = ->
-    cacheComponent()
-    for inst in layoutInstances by -1
-      inst.beforeUnmount() if inst.beforeUnmount
-      inst.unmounted() if inst.unmounted
-      inst._target?.remove()
-    layoutInstances = []
-    mountPoint = container
-
-  # Invalidate cached components when their source changes (HMR)
-  components.watch (event, path) ->
-    if componentCache.has(path)
-      evicted = componentCache.get(path)
-      evicted.unmounted() if evicted.unmounted
-      componentCache.delete path
-
-  mountRoute = (info) ->
-    { route, params, layouts: layoutFiles, query } = info
-    return unless route
-    if route.file is currentRoute and JSON.stringify(params) is JSON.stringify(currentParams)
-      return
-    currentParams = params
-
-    gen = ++generation
-    router.navigating = true
-
-    try
-      source = components.read(route.file)
-      unless source
-        onError({ status: 404, message: "File not found: #{route.file}" }) if onError
-        router.navigating = false
-        return
-
-      mod = compileAndImport! source, compile, components, route.file, resolver
-      if gen isnt generation then router.navigating = false; return
-
-      Component = findComponent(mod)
-      unless Component
-        onError({ status: 500, message: "No component found in #{route.file}" }) if onError
-        router.navigating = false
-        return
-
-      layoutsChanged = not arraysEqual(layoutFiles, currentLayouts)
-      oldTarget = currentComponent?._target
-
-      if layoutsChanged
-        unmount()
-      else
-        cacheComponent()
-
-      mp = if layoutsChanged then container else mountPoint
-
-      if layoutsChanged and layoutFiles.length > 0
-        container.innerHTML = ''
-        mp = container
-
-        for layoutFile in layoutFiles
-          layoutSource = components.read(layoutFile)
-          continue unless layoutSource
-          layoutMod = compileAndImport! layoutSource, compile, components, layoutFile, resolver
-          if gen isnt generation then router.navigating = false; return
-
-          LayoutClass = findComponent(layoutMod)
-          continue unless LayoutClass
-
-          inst = new LayoutClass { app, params, router }
-          inst.beforeMount() if inst.beforeMount
-          wrapper = document.createElement('div')
-          wrapper.setAttribute 'data-layout', layoutFile
-          mp.appendChild wrapper
-          inst.mount wrapper
-          layoutInstances.push inst
-
-          slot = wrapper.querySelector('#content') or wrapper
-          mp = slot
-
-        currentLayouts = [...layoutFiles]
-        mountPoint = mp
-      else if layoutsChanged
-        container.innerHTML = ''
-        currentLayouts = []
-        mountPoint = container
-
-      # Check component cache for a preserved instance
-      cached = componentCache.get(route.file)
-      if cached
-        componentCache.delete route.file
-        mp.appendChild cached._target
-        currentComponent = cached
-        currentRoute = route.file
-        cached.params = params if params
-        cached.query = query if query
-        cached.mounted() if cached.mounted
-        cached.load!(params, query) if cached.load
-      else
-        pageWrapper = document.createElement('div')
-        pageWrapper.setAttribute 'data-component', route.file
-        mp.appendChild pageWrapper
-
-        instance = new Component { app, params, query, router }
-        instance.beforeMount() if instance.beforeMount
-        instance.mount pageWrapper
-        currentComponent = instance
-        currentRoute = route.file
-
-        instance.load!(params, query) if instance.load
-      oldTarget?.remove()
-      router.navigating = false
-
-    catch err
-      router.navigating = false
-      console.error "Renderer: error mounting #{route.file}:", err
-      onError({ status: 500, message: err.message, error: err }) if onError
-
-      # Walk layout chain for an error boundary (component with onError method)
-      handled = false
-      for inst in layoutInstances by -1
-        if inst.onError
-          try
-            inst.onError(err)
-            handled = true
-            break
-          catch boundaryErr
-            console.error "Renderer: error boundary failed:", boundaryErr
-
-      unless handled
-        pre = document.createElement('pre')
-        pre.style.cssText = 'color:red;padding:1em'
-        pre.textContent = err.stack or err.message
-        container.innerHTML = ''
-        container.appendChild pre
-
-  renderer =
-    start: ->
-      disposeEffect = __effect ->
-        current = router.current
-        mountRoute(current) if current.route
-      router.init()
-      renderer
-
-    stop: ->
-      unmount()
-      if disposeEffect
-        disposeEffect()
-        disposeEffect = null
-      container.innerHTML = ''
-
-    remount: ->
-      current = router.current
-      mountRoute(current) if current.route
-
-    cache: componentCache
-
-  renderer
-
-# ==============================================================================
-# SSE Watch — hot-reload connection with exponential backoff
-# ==============================================================================
-
-connectWatch = (url) ->
-  retryDelay = 1000
-  maxDelay = 30000
-
-  connect = ->
-    es = new EventSource(url)
-
-    es.addEventListener 'connected', ->
-      retryDelay = 1000
-      console.log '[Rip] Hot reload connected'
-
-    es.addEventListener 'reload', ->
-      console.log '[Rip] Reloading...'
-      location.reload()
-
-    es.addEventListener 'css', ->
-      for link as document.querySelectorAll('link[rel="stylesheet"]')
-        url = new URL(link.href)
-        url.searchParams.set('_t', Date.now())
-        link.href = url.toString()
-
-    es.onerror = ->
-      es.close()
-      setTimeout connect, retryDelay
-      retryDelay = Math.min(retryDelay * 2, maxDelay)
-
-  connect()
-
-# ==============================================================================
-# Launch — fetch bundle, create stash, wire router + renderer, start app
-#
-# Entry point for Rip applications. Handles two bundle sources:
-#   1. Explicit bundle object (opts.bundle)
-#   2. Fetch from URL (opts.bundleUrl) — used by serve middleware's data-launch
-#
-# Creates the app stash, sets up persistence if configured, builds the
-# component resolver, initializes the router and renderer, and optionally
-# connects SSE hot-reload.
-# ==============================================================================
-
-export launch = (appBase = '', opts = {}) ->
-  globalThis.__ripLaunched = true
-  if typeof appBase is 'object'
-    opts = appBase
-    appBase = ''
-  appBase = appBase.replace(/\/+$/, '')  # strip trailing slashes
-  target = opts.target or '#app'
-  compile = opts.compile or null
-  persist = opts.persist or false
-  hash = opts.hash or false
-
-  # Auto-detect compile function from the global rip.js module
-  unless compile
-    compile = globalThis?.compileToJS or null
-
-  # Auto-create target element
-  if typeof document isnt 'undefined' and not document.querySelector(target)
-    el = document.createElement('div')
-    el.id = target.replace(/^#/, '')
-    document.body.prepend el
-
-  # Get the app bundle — explicit object or fetch from URL
-  if opts.bundle
-    bundle = opts.bundle
-  else if opts.bundleUrl
-    headers = {}
-    etagKey = "__rip_etag_#{opts.bundleUrl}"
-    cached = sessionStorage.getItem(etagKey)
-    headers['If-None-Match'] = cached if cached
-    res = await fetch(opts.bundleUrl, { headers })
-    if res.status is 304
-      bundle = JSON.parse(sessionStorage.getItem("#{etagKey}_data"))
-    else if res.ok
-      bundle = res.json!
-      etag = res.headers.get('etag')
-      if etag
-        sessionStorage.setItem(etagKey, etag)
-        sessionStorage.setItem("#{etagKey}_data", JSON.stringify(bundle))
-    else
-      throw new Error "launch: #{opts.bundleUrl} (#{res.status})"
-  else
-    throw new Error "launch: no bundle or bundleUrl provided"
-
-  # Create the unified stash
-  app = stash { components: {}, routes: {}, data: {} }
-  globalThis.__ripApp = app
-
-  # Hydrate from bundle — any keys populate the stash
-  app.data = bundle.data if bundle.data
-  if bundle.routes
-    app.routes = bundle.routes
-
-  # Restore persisted state (overrides bundle defaults with saved user state)
-  if persist and typeof sessionStorage isnt 'undefined'
-    persistStash app, local: persist is 'local', key: "__rip_#{appBase}"
-
-  # Create components store and load component sources
-  appComponents = createComponents()
-  appComponents.load(bundle.components) if bundle.components
-
-  # Build component resolver — name-to-path map + app-scoped class registry
-  classesKey = "__rip_#{appBase.replace(/\//g, '_') or 'app'}"
-  resolver = { map: buildComponentMap(appComponents), classes: {}, key: classesKey }
-  globalThis[classesKey] = resolver.classes if typeof globalThis isnt 'undefined'
-
-  # Set document title
-  document.title = app.data.title if app.data.title and typeof document isnt 'undefined'
-
-  # Create router
-  router = createRouter appComponents,
-    root: 'components'
-    base: appBase
-    hash: hash
-    onError: (err) -> console.error "[Rip] Error #{err.status}: #{err.message or err.path}"
-
-  # Create renderer
-  renderer = createRenderer
-    router: router
-    app: app
-    components: appComponents
-    resolver: resolver
-    compile: compile
-    target: target
-    onError: (err) -> console.error "[Rip] #{err.message}", err.error
-
-  # Start
-  renderer.start()
-
-  # Connect SSE watch if enabled
-  if bundle.data?.watch
-    connectWatch "#{appBase}/watch"
-
-  # Expose for console and dev tools
-  if typeof window isnt 'undefined'
-    window.app = app
-    window.__RIP__ =
-      app: app
-      components: appComponents
-      router: router
-      renderer: renderer
-      resolver: resolver
-      cache: renderer.cache
-      version: '0.3.0'
-
-  { app, components: appComponents, router, renderer }
-
-# ==============================================================================
-# ARIA — keyboard navigation and popup lifecycle utilities for UI components
-#
-# Provides the WAI-ARIA keyboard interaction patterns used by headless widgets.
-# Registered on globalThis so any component can use them without explicit imports.
-#
-#   ARIA.listNav(e, handlers)              — popup lists (listbox, menu, combobox)
-#   ARIA.rovingNav(e, handlers, orient)    — inline composites (radiogroup, tabs, toolbar)
-#   ARIA.popupDismiss(open, popup, close, els, repos) — dismiss on outside click; reposition or close on scroll
-#
-# Both nav handlers support an optional `char:` handler for typeahead search.
-# APG gaps handled per-component (not in ARIA helpers):
-#   - Submenu ArrowRight/Left: belongs in the Menu component (menu.rip)
-#   - Grid 2D navigation: belongs in the Grid component (grid.rip)
-#   - F2 cell edit mode: belongs in the Grid component (grid.rip)
-#
-# Both nav handlers:
-#   - Guard against IME composition events (e.isComposing, CJK input)
-#   - Call e.preventDefault() + e.stopPropagation() for handled keys
-#   - Only invoke a handler if it is provided (all keys are optional)
-#   - Alias PageUp/PageDown to first/last (fn+Up/Down on macOS)
-#
-# ARIA: https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/
-# ==============================================================================
-
-_ariaNAV = (e, fn) ->
-  return unless fn
-  e.preventDefault()
-  e.stopPropagation()
-  fn()
-
-globalThis.__ariaLastFocusedEl ?= null
-if typeof document isnt 'undefined' and not globalThis.__ariaFocusTrackerBound
-  document.addEventListener 'focusin', (e) -> globalThis.__ariaLastFocusedEl = e.target, true
-  globalThis.__ariaFocusTrackerBound = true
-
-_ariaListNav = (e, h) ->
-  return if e.isComposing               # IME guard: ignore events during CJK composition
-  switch e.key
-    when 'ArrowDown'          then _ariaNAV e, h.next
-    when 'ArrowUp'            then _ariaNAV e, h.prev
-    when 'Home', 'PageUp'     then _ariaNAV e, h.first
-    when 'End',  'PageDown'   then _ariaNAV e, h.last
-    when 'Enter', ' '         then _ariaNAV e, h.select
-    when 'Escape'             then _ariaNAV e, h.dismiss
-    when 'Tab'                then h.tab?()           # no preventDefault: allow natural focus movement
-    else h.char?(e.key) if e.key.length is 1          # printable chars: typeahead
-
-_ariaPopupDismiss = (open, popup, close, els = [], repos = null) ->
-  return unless open
-  get      = (x) -> if typeof x is 'function' then x() else x
-  onDown   = (e) => close() unless [get(popup), ...els.map(get)].some (el) -> el?.contains(e.target)
-  onScroll = (e) =>
-    return if get(popup)?.contains(e.target)
-    if repos then repos() else close()
-  document.addEventListener 'mousedown', onDown
-  window.addEventListener   'scroll',    onScroll, true
-  ->
-    document.removeEventListener 'mousedown', onDown
-    window.removeEventListener   'scroll',    onScroll, true
-
-# popupGuard — per-component reopen suppression for pointer-driven popup closes.
-# Use when the same gesture that closes a popup can otherwise refocus/reclick a
-# trigger and reopen it immediately on the tail end of that sequence.
-_ariaPopupGuard = (delay = 250) ->
-  blockedUntil = 0
-  {
-    block: (ms = delay) ->
-      blockedUntil = Date.now() + ms
-    canOpen: ->
-      Date.now() >= blockedUntil
-  }
-
-# bindPopover — sync reactive open state with native Popover API
-# open: reactive boolean
-# popover: element or lazy getter (=> el)
-# setOpen: callback that receives actual native open state (true/false)
-# source: optional control element or lazy getter used as popover invoker
-_ariaBindPopover = (open, popover, setOpen, source = null) ->
-  get = (x) -> if typeof x is 'function' then x() else x
-  currentFocus = ->
-    active = document.activeElement
-    return active if active and active isnt document.body
-    last = globalThis.__ariaLastFocusedEl
-    return last if last?.isConnected isnt false
-    null
-  el = get(popover)
-  return unless el
-  return unless Object.hasOwn(HTMLElement.prototype, 'togglePopover')
-  restoreEl = null
-
-  syncState = (isOpen) ->
-    if isOpen
-      el.hidden = false
-      try el.inert = false
-      catch then null
-      el.removeAttribute 'aria-hidden'
-    else
-      try el.inert = true
-      catch then null
-      el.setAttribute 'aria-hidden', 'true'
-      el.hidden = true
-
-  restoreFocus = ->
-    target = restoreEl
-    restoreEl = null
-    return unless target?.focus?
-    focusAttempt = (tries = 6) ->
-      return unless target.isConnected isnt false
-      try target.focus preventScroll: true
-      catch then target.focus()
-      return if document.activeElement is target or tries <= 1
-      setTimeout (-> focusAttempt(tries - 1)), 16
-    requestAnimationFrame -> focusAttempt()
-
-  onToggle = (e) ->
-    isOpen = e.newState is 'open'
-    if isOpen
-      restoreEl = get(source) or currentFocus()
-      syncState(true)
-    else
-      syncState(false)
-      restoreFocus()
-    setOpen?(isOpen)
-  el.addEventListener 'toggle', onToggle
-
-  shown = el.matches(':popover-open')
-  desired = !!open
-  if shown isnt desired
-    src = get(source)
-    if desired
-      restoreEl = src or currentFocus()
-      syncState(true)
-    opts = if src and desired then { force: desired, source: src } else { force: desired }
-    try
-      el.togglePopover(opts)
-    catch
-      # If the element cannot be toggled right now (for example detached),
-      # keep runtime stable; effect will retry on the next reactive pass.
-      null
-  else
-    syncState(desired)
-
-  -> el.removeEventListener 'toggle', onToggle
-
-# bindDialog — sync reactive open state with native <dialog>
-# open: reactive boolean
-# dialog: dialog element or lazy getter (=> el)
-# setOpen: callback invoked when native state changes
-# dismissable: false prevents Esc/cancel close
-_ariaBindDialog = (open, dialog, setOpen, dismissable = true) ->
-  get = (x) -> if typeof x is 'function' then x() else x
-  currentFocus = ->
-    active = document.activeElement
-    return active if active and active isnt document.body
-    last = globalThis.__ariaLastFocusedEl
-    return last if last?.isConnected isnt false
-    null
-  el = get(dialog)
-  return unless el?.showModal?
-  restoreEl = null
-
-  syncState = (isOpen) ->
-    if isOpen
-      el.hidden = false
-      try el.inert = false
-      catch then null
-      el.removeAttribute 'aria-hidden'
-    else
-      try el.inert = true
-      catch then null
-      el.setAttribute 'aria-hidden', 'true'
-      el.hidden = true
-
-  restoreFocus = ->
-    target = restoreEl
-    restoreEl = null
-    return unless target?.focus?
-    focusAttempt = (tries = 6) ->
-      return unless target.isConnected isnt false
-      try target.focus preventScroll: true
-      catch then target.focus()
-      return if document.activeElement is target or tries <= 1
-      setTimeout (-> focusAttempt(tries - 1)), 16
-    requestAnimationFrame -> focusAttempt()
-
-  onCancel = (e) ->
-    unless dismissable
-      e.preventDefault()
-      return
-    setOpen?(false)
-
-  onClose = ->
-    setOpen?(false)
-    syncState(false)
-    restoreFocus()
-  el.addEventListener 'cancel', onCancel
-  el.addEventListener 'close', onClose
-
-  if open and not el.open
-    restoreEl = currentFocus() unless restoreEl
-    syncState(true)
-    try el.showModal()
-    catch then null
-  else if not open and el.open
-    el.close()
-  else
-    syncState(!!open)
-
-  ->
-    el.removeEventListener 'cancel', onCancel
-    el.removeEventListener 'close', onClose
-
-_ariaRovingNav = (e, h, orientation = 'vertical') ->
-  return if e.isComposing               # IME guard
-  vert = orientation isnt 'horizontal'
-  horz = orientation isnt 'vertical'
-  switch e.key
-    when 'ArrowDown'          then _ariaNAV e, h.next   if vert
-    when 'ArrowUp'            then _ariaNAV e, h.prev   if vert
-    when 'ArrowRight'         then _ariaNAV e, h.next   if horz
-    when 'ArrowLeft'          then _ariaNAV e, h.prev   if horz
-    when 'Home', 'PageUp'     then _ariaNAV e, h.first
-    when 'End',  'PageDown'   then _ariaNAV e, h.last
-    when 'Enter', ' '         then _ariaNAV e, h.select
-    when 'Escape'             then _ariaNAV e, h.dismiss
-    else h.char?(e.key) if e.key.length is 1          # printable chars: typeahead (e.g. tabs)
-
-# positionBelow — position a fixed popup below its trigger with viewport flip
-# gap: pixels between trigger bottom and popup top (default 4)
-# setVisible: call visibility:visible after positioning (default true)
-_ariaPositionBelow = (trigger, popup, gap = 4, setVisible = true) ->
-  return unless trigger and popup
-  tr = trigger.getBoundingClientRect()
-  popup.style.position = 'fixed'
-  popup.style.left = "#{tr.left}px"
-  popup.style.top = "#{tr.bottom + gap}px"
-  popup.style.minWidth = "#{tr.width}px"
-  fl = popup.getBoundingClientRect()
-  popup.style.top = "#{tr.top - fl.height - gap}px" if fl.bottom > window.innerHeight
-  popup.style.left = "#{window.innerWidth - fl.width - gap}px" if fl.right > window.innerWidth
-  popup.style.visibility = 'visible' if setVisible
-
-# trapFocus — trap Tab key inside a panel (focus wraps first↔last)
-# Returns a cleanup function; call it when the panel closes
-_FOCUSABLE =! 'a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex="-1"])'
-_ariaTrapFocus = (panel) ->
-  handler = (e) ->
-    return unless e.key is 'Tab'
-    list = Array.from(panel.querySelectorAll(_FOCUSABLE)).filter (f) -> f.offsetParent isnt null
-    return unless list.length
-    first = list[0]; last = list[list.length - 1]
-    if e.shiftKey
-      if document.activeElement is first then (e.preventDefault(); last.focus())
-    else
-      if document.activeElement is last then (e.preventDefault(); first.focus())
-  panel.addEventListener 'keydown', handler
-  -> panel.removeEventListener 'keydown', handler
-
-# wireAria — auto-label a panel from its first heading and first paragraph
-_ariaWireAria = (panel, id) ->
-  return unless panel
-  heading = panel.querySelector('h1,h2,h3,h4,h5,h6')
-  if heading
-    heading.id ?= "#{id}-title"
-    panel.setAttribute 'aria-labelledby', heading.id
-  desc = panel.querySelector('p')
-  if desc
-    desc.id ?= "#{id}-desc"
-    panel.setAttribute 'aria-describedby', desc.id
-
-# Shared modal scroll-lock stack — fixes race when Dialog + AlertDialog both open
-# lockScroll(instance): locks body scroll
-# unlockScroll(instance): removes from stack, restores scroll if stack empty
-_ariaModalStack = []
-_ariaLockScroll = (instance) ->
-  scrollY = window.scrollY
-  _ariaModalStack.push { instance, scrollY }
-  if _ariaModalStack.length is 1
-    document.body.style.position = 'fixed'
-    document.body.style.top = "-#{scrollY}px"
-    document.body.style.width = '100%'
-
-_ariaUnlockScroll = (instance) ->
-  idx = _ariaModalStack.findIndex (m) -> m.instance is instance
-  return if idx < 0
-  { scrollY } = _ariaModalStack.splice(idx, 1)[0]
-  unless _ariaModalStack.length
-    document.body.style.position = ''
-    document.body.style.top = ''
-    document.body.style.width = ''
-    window.scrollTo 0, scrollY
-
-_ariaHasAnchor = do ->
-  try
-    return false unless document?.createElement
-    anchor = document.createElement('div')
-    floating = document.createElement('div')
-    anchor.style.cssText = 'position:fixed;top:100px;left:100px;width:10px;height:10px;anchor-name:--probe'
-    floating.style.cssText = 'position:fixed;inset:auto;margin:0;position-anchor:--probe;position-area:bottom start;width:10px;height:10px'
-    document.body.appendChild(anchor)
-    document.body.appendChild(floating)
-    rect = floating.getBoundingClientRect()
-    anchor.remove()
-    floating.remove()
-    rect.top > 50
-  catch
-    false
-
-_ariaPosition = (trigger, floating, opts = {}) ->
-  return unless trigger and floating
-  placement = opts.placement ?? 'bottom start'
-  offset = opts.offset ?? 4
-  matchWidth = opts.matchWidth ?? false
-  if _ariaHasAnchor
-    name = "--anchor-#{floating.id or Math.random().toString(36).slice(2, 8)}"
-    trigger.style.anchorName = name
-    floating.style.positionAnchor = name
-    floating.style.position = 'fixed'
-    floating.style.inset = 'auto'
-    floating.style.margin = '0'
-    floating.style.positionArea = placement
-    floating.style.positionTry = 'flip-block, flip-inline, flip-block flip-inline'
-    floating.style.positionVisibility = 'anchors-visible'
-    [side] = placement.split(' ')
-    floating.style.marginTop = ''
-    floating.style.marginBottom = ''
-    floating.style.marginLeft = ''
-    floating.style.marginRight = ''
-    switch side
-      when 'bottom' then floating.style.marginTop = "#{offset}px"
-      when 'top' then floating.style.marginBottom = "#{offset}px"
-      when 'left' then floating.style.marginRight = "#{offset}px"
-      when 'right' then floating.style.marginLeft = "#{offset}px"
-    floating.style.minWidth = 'anchor-size(width)' if matchWidth
-  else
-    rect = trigger.getBoundingClientRect()
-    floating.style.position = 'fixed'
-    floating.style.inset = 'auto'
-    floating.style.margin = '0'
-    [side, align] = placement.split(' ')
-    align ??= 'start'
-    switch side
-      when 'bottom'
-        floating.style.top = "#{rect.bottom + offset}px"
-      when 'top'
-        floating.style.bottom = "#{window.innerHeight - rect.top + offset}px"
-      when 'left'
-        floating.style.right = "#{window.innerWidth - rect.left + offset}px"
-      when 'right'
-        floating.style.left = "#{rect.right + offset}px"
-    if side in ['bottom', 'top']
-      switch align
-        when 'start' then floating.style.left = "#{rect.left}px"
-        when 'center' then floating.style.left = "#{rect.left + rect.width / 2}px"; floating.style.transform = 'translateX(-50%)'
-        when 'end' then floating.style.right = "#{window.innerWidth - rect.right}px"
-    else
-      switch align
-        when 'start' then floating.style.top = "#{rect.top}px"
-        when 'center' then floating.style.top = "#{rect.top + rect.height / 2}px"; floating.style.transform = 'translateY(-50%)'
-        when 'end' then floating.style.bottom = "#{window.innerHeight - rect.bottom}px"
-    floating.style.minWidth = "#{rect.width}px" if matchWidth
-
-globalThis.__aria ??= {
-  listNav: _ariaListNav, rovingNav: _ariaRovingNav, popupDismiss: _ariaPopupDismiss, popupGuard: _ariaPopupGuard,
-  bindPopover: _ariaBindPopover, bindDialog: _ariaBindDialog,
-  positionBelow: _ariaPositionBelow, trapFocus: _ariaTrapFocus, wireAria: _ariaWireAria,
-  lockScroll: _ariaLockScroll, unlockScroll: _ariaUnlockScroll,
-  position: _ariaPosition, hasAnchor: _ariaHasAnchor,
-}
-globalThis.ARIA ??= globalThis.__aria