rip-lang 3.13.92 → 3.13.94

package/src/typecheck.js

@@ -33,14 +33,55 @@ export function countLines(str) {
 export function toVirtual(p) { return p + '.ts'; }
 export function fromVirtual(p) { return p.endsWith('.rip.ts') ? p.slice(0, -3) : p; }
 
+// Patch uninitialized, untyped variables with inferred types from their
+// first assignment. This makes `let total; total = count + ratio;` behave
+// like `let total: number;` — so a later `total = "string"` is caught.
+// Called by both the LSP and the CLI type-checker to keep them aligned.
+export function patchUninitializedTypes(ts, service, compiledEntries) {
+  const program = service.getProgram();
+  if (!program) return;
+  const checker = program.getTypeChecker();
+  for (const [filePath] of compiledEntries) {
+    const sf = program.getSourceFile(toVirtual(filePath));
+    if (!sf) continue;
+    const uninitialized = new Map();
+    for (const stmt of sf.statements) {
+      if (ts.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations) {
+          if (!decl.initializer && !decl.type && ts.isIdentifier(decl.name)) {
+            const sym = checker.getSymbolAtLocation(decl.name);
+            if (sym) uninitialized.set(decl.name.text, sym);
+          }
+        }
+      }
+      if (ts.isExpressionStatement(stmt) && ts.isBinaryExpression(stmt.expression) &&
+          stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+          ts.isIdentifier(stmt.expression.left)) {
+        const name = stmt.expression.left.text;
+        const sym = uninitialized.get(name);
+        if (sym) {
+          const rhsType = checker.getTypeAtLocation(stmt.expression.right);
+          sym.flags |= ts.SymbolFlags.Transient;
+          sym.links = { type: rhsType };
+          uninitialized.delete(name);
+        }
+      }
+    }
+  }
+}
+
 // TS error codes to skip — Rip resolves modules differently and
 // treats async return types transparently.
 export const SKIP_CODES = new Set([
   2300, // Duplicate identifier (DTS declarations coexist with compiled class bodies)
   2304, // Cannot find name
   2307, // Cannot find module
+  2389, // Function implementation name must match overload (DTS + compiled body)
+  2391, // Function implementation is missing (DTS overload sigs separated from implementations)
   2393, // Duplicate function implementation
+  2394, // Overload signature not compatible with implementation (untyped compiled params)
   2451, // Cannot redeclare block-scoped variable
+  2567, // Enum declarations can only merge with namespace or other enum (DTS + compiled body)
   1064, // Return type of async function must be Promise
   2582, // Cannot find name 'test' (test runner globals)
   2593, // Cannot find name 'describe' (test runner globals)
@@ -94,26 +135,120 @@ export function compileForCheck(filePath, source, compiler) {
   // Ensure every file is treated as a module (not a global script)
   if (!/\bexport\b/.test(code) && !/\bimport\b/.test(code)) code += '\nexport {};\n';
 
-  const tsContent = (hasTypes ? dts + '\n' : '') + code;
-  const headerLines = hasTypes ? countLines(dts + '\n') : 1;
+  // Interleave function overload signatures from DTS header into the code
+  // section, immediately before their implementations. TypeScript requires
+  // overload signatures adjacent to the implementation — without this, TS
+  // reports error 2391 ("Function implementation is missing or not immediately
+  // following the declaration"). Moving signatures into the code also enables
+  // proper call-site type checking of function parameters.
+  let headerDts = dts;
+  if (hasTypes && dts && code) {
+    const dl = dts.split('\n');
+    const cl = code.split('\n');
+    const fnSigs = [];
+    for (let i = 0; i < dl.length; i++) {
+      const m = dl[i].match(/^(?:export\s+)?(?:declare\s+)?function\s+(\w+)/);
+      if (m) fnSigs.push({ name: m[1], sig: dl[i], idx: i });
+    }
+    if (fnSigs.length > 0) {
+      const injections = [];
+      const moved = new Set();
+      for (const fn of fnSigs) {
+        const pat = new RegExp(`^(?:export\\s+)?(?:async\\s+)?function\\s+${fn.name}\\s*[(<]`);
+        for (let j = 0; j < cl.length; j++) {
+          if (pat.test(cl[j])) {
+            injections.push({ codeLine: j, sig: fn.sig });
+            moved.add(fn.idx);
+            break;
+          }
+        }
+      }
+      if (injections.length > 0) {
+        injections.sort((a, b) => a.codeLine - b.codeLine);
+        // Adjust reverseMap: each injection shifts subsequent code lines down by 1
+        if (result.reverseMap) {
+          for (const [, entry] of result.reverseMap) {
+            let offset = 0;
+            for (const inj of injections) {
+              if (inj.codeLine <= entry.genLine + offset) offset++;
+            }
+            entry.genLine += offset;
+          }
+        }
+        // Insert signatures bottom-up to preserve indices.
+        // Strip 'declare ' — signatures must be non-ambient to match implementations.
+        for (let k = injections.length - 1; k >= 0; k--) {
+          cl.splice(injections[k].codeLine, 0, injections[k].sig.replace(/^declare /, ''));
+        }
+        code = cl.join('\n');
+        // Rebuild header DTS without the moved function signatures
+        headerDts = dl.filter((_, i) => !moved.has(i)).join('\n').trimEnd() + '\n';
+      }
+    }
+  }
+
+  // Annotate reactive/readonly/computed const assignments with their declared
+  // types from the DTS header, and remove the corresponding `declare const`
+  // from the header. This enables TypeScript to check initializer values
+  // against type annotations: `const x: Signal<number> = __state("oops")`
+  // produces a real type error, whereas two separate declarations
+  // (`declare const x: Signal<number>` + `const x = __state("oops")`)
+  // only produce a duplicate-identifier error (2451), which is suppressed.
+  if (hasTypes && headerDts && code) {
+    const dl = headerDts.split('\n');
+    const cl = code.split('\n');
+    const constTypes = new Map();
+
+    for (let i = 0; i < dl.length; i++) {
+      const m = dl[i].match(/^(?:export\s+)?declare\s+const\s+(\w+):\s+(.+);$/);
+      if (m) constTypes.set(m[1], { type: m[2], idx: i });
+    }
+
+    if (constTypes.size > 0) {
+      const movedDts = new Set();
+
+      for (let j = 0; j < cl.length; j++) {
+        const cm = cl[j].match(/^((?:export\s+)?const\s+)(\w+)(\s*=\s*)/);
+        if (cm && constTypes.has(cm[2])) {
+          const entry = constTypes.get(cm[2]);
+          cl[j] = cm[1] + cm[2] + ': ' + entry.type + cm[3] + cl[j].slice(cm[0].length);
+          movedDts.add(entry.idx);
+        }
+      }
+
+      if (movedDts.size > 0) {
+        code = cl.join('\n');
+        headerDts = dl.filter((_, i) => !movedDts.has(i)).join('\n').trimEnd() + '\n';
+      }
+    }
+  }
+
+  let tsContent = (hasTypes ? headerDts + '\n' : '') + code;
+  const headerLines = hasTypes ? countLines(headerDts + '\n') : 1;
 
   // Build bidirectional line maps
   const { srcToGen, genToSrc } = buildLineMap(result.reverseMap, result.map, headerLines);
 
+  // Snapshot code-section mappings before DTS mapping can overwrite them.
+  // Needed by @ts-expect-error injection which must target code lines, not DTS.
+  const codeSrcToGen = new Map(srcToGen);
+
   // Map DTS declaration lines back to source lines (bidirectional).
-  // Covers: let/var declarations, type aliases, interfaces, enums, classes.
+  // Covers: imports, let/var declarations, type aliases, interfaces, enums, classes.
   // This enables hover, go-to-definition, and diagnostics for type-only code.
-  if (hasTypes && dts) {
-    const dtsLines = dts.split('\n');
+  if (hasTypes && headerDts) {
+    const dtsLines = headerDts.split('\n');
     const srcLines = source.split('\n');
     for (let i = 0; i < dtsLines.length; i++) {
       const line = dtsLines[i];
+
       const m = line.match(/^(?:export\s+)?(?:declare\s+)?(?:let|var|type|interface|enum|class)\s+(\w+)/);
       if (!m) continue;
       const name = m[1];
       for (let s = 0; s < srcLines.length; s++) {
         const src = srcLines[s];
-        if (new RegExp('\\b' + name + '\\s*(?:::=|::)').test(src) ||
+        if (new RegExp('\\b' + name + '\\s*::').test(src) ||
+            new RegExp('^(?:export\\s+)?type\\s+' + name + '\\b').test(src) ||
             new RegExp('^(?:export\\s+)?interface\\s+' + name + '\\b').test(src) ||
             new RegExp('^(?:export\\s+)?enum\\s+' + name + '\\b').test(src) ||
             new RegExp('^(?:export\\s+)?' + name + '\\s*=\\s*component\\b').test(src)) {
@@ -144,6 +279,50 @@ export function compileForCheck(filePath, source, compiler) {
     }
   }
 
+  // Inject @ts-expect-error directives from Rip source into the generated
+  // TypeScript.  This lets TypeScript natively suppress expected errors and
+  // report TS2578 for unused directives — works in both CLI and LSP.
+  if (hasTypes) {
+    const srcLines = source.split('\n');
+    const injects = [];
+    for (let s = 0; s < srcLines.length; s++) {
+      const m = srcLines[s].match(/^\s*#\s*(@ts-expect-error\b.*)/);
+      if (m) {
+        const nextSrc = s + 1;
+        // Prefer code-section line (where the assignment lives and TS reports
+        // the error) over the DTS declaration line.
+        let genLine = codeSrcToGen.get(nextSrc);
+        if (genLine === undefined) {
+          genLine = srcToGen.get(nextSrc);
+          if (genLine !== undefined && genLine < headerLines) genLine = undefined;
+        }
+        if (genLine !== undefined) {
+          injects.push({ genLine, srcLine: s, comment: `// ${m[1]}` });
+        }
+      }
+    }
+    if (injects.length > 0) {
+      // Sort descending so bottom-up insertion doesn't shift earlier positions
+      injects.sort((a, b) => b.genLine - a.genLine);
+      const tsLines = tsContent.split('\n');
+      for (const { genLine, srcLine, comment } of injects) {
+        tsLines.splice(genLine, 0, comment);
+        // Shift existing gen→src mappings at or after the insertion point
+        const shifted = new Map();
+        for (const [g, s] of genToSrc) shifted.set(g >= genLine ? g + 1 : g, s);
+        shifted.set(genLine, srcLine);
+        genToSrc.clear();
+        for (const [g, s] of shifted) genToSrc.set(g, s);
+        // Shift existing src→gen mappings that pointed at or past the insertion
+        for (const [s, g] of srcToGen) {
+          if (g >= genLine) srcToGen.set(s, g + 1);
+        }
+        srcToGen.set(srcLine, genLine);
+      }
+      tsContent = tsLines.join('\n');
+    }
+  }
+
   return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, source, dts };
 }
 
@@ -288,6 +467,9 @@ export async function runCheck(targetDir, opts = {}) {
 
   const service = ts.createLanguageService(host, ts.createDocumentRegistry());
 
+  // Patch uninitialized variables with inferred types (same as LSP)
+  patchUninitializedTypes(ts, service, compiled);
+
   // Collect diagnostics
   let totalErrors = 0;
   let totalWarnings = 0;

package/src/types.js

@@ -26,7 +26,7 @@ export function installTypeSupport(Lexer) {
   //
   // Scans the token stream for:
   //   :: (TYPE_ANNOTATION) — collects type string, stores on surviving token
-  //   ::= (TYPE_ALIAS) — collects type body, replaces with TYPE_DECL marker
+  //   type Name = (contextual keyword) — collects type body, replaces with TYPE_DECL marker
   //   INTERFACE — collects body, replaces with TYPE_DECL marker
   //   DEF IDENTIFIER<...> — collects generic params via .spaced detection
   //
@@ -50,29 +50,27 @@ export function installTypeSupport(Lexer) {
     this.scanTokens((token, i, tokens) => {
       let tag = token[0];
 
-      // ── Generic type parameters: DEF name<T>(...) or Name<T> ::= ───────
+      // ── Generic type parameters: DEF name<T>(...) ──────────────────────
+      // (Generic params on type aliases are handled by the `type` keyword handler below)
       if (tag === 'IDENTIFIER') {
         let next = tokens[i + 1];
         if (next && next[0] === 'COMPARE' && next[1] === '<' && !next.spaced) {
           let isDef = tokens[i - 1]?.[0] === 'DEF';
           let genTokens = collectBalancedAngles(tokens, i + 1);
-          if (genTokens) {
-            let isAlias = !isDef && tokens[i + 1 + genTokens.length]?.[0] === 'TYPE_ALIAS';
-            if (isDef || isAlias) {
-              if (!token.data) token.data = {};
-              token.data.typeParams = buildTypeString(genTokens);
-              tokens.splice(i + 1, genTokens.length);
-              // After removing <T>, retag ( as CALL_START if it follows DEF IDENTIFIER
-              if (isDef && tokens[i + 1]?.[0] === '(') {
-                tokens[i + 1][0] = 'CALL_START';
-                // Find matching ) and retag as CALL_END
-                let d = 1, m = i + 2;
-                while (m < tokens.length && d > 0) {
-                  if (tokens[m][0] === '(' || tokens[m][0] === 'CALL_START') d++;
-                  if (tokens[m][0] === ')' || tokens[m][0] === 'CALL_END') d--;
-                  if (d === 0) tokens[m][0] = 'CALL_END';
-                  m++;
-                }
+          if (genTokens && isDef) {
+            if (!token.data) token.data = {};
+            token.data.typeParams = buildTypeString(genTokens);
+            tokens.splice(i + 1, genTokens.length);
+            // After removing <T>, retag ( as CALL_START if it follows DEF IDENTIFIER
+            if (tokens[i + 1]?.[0] === '(') {
+              tokens[i + 1][0] = 'CALL_START';
+              // Find matching ) and retag as CALL_END
+              let d = 1, m = i + 2;
+              while (m < tokens.length && d > 0) {
+                if (tokens[m][0] === '(' || tokens[m][0] === 'CALL_START') d++;
+                if (tokens[m][0] === ')' || tokens[m][0] === 'CALL_END') d--;
+                if (d === 0) tokens[m][0] = 'CALL_END';
+                m++;
               }
             }
           }
@@ -125,14 +123,33 @@ export function installTypeSupport(Lexer) {
         return 0;
       }
 
-      // ── TYPE_ALIAS (::=) — collect type body, create TYPE_DECL marker ───
-      if (tag === 'TYPE_ALIAS') {
-        let nameToken = tokens[i - 1];
-        if (!nameToken) return 1;
+      // ── type Name = ... — contextual type keyword ──────────────────────
+      if (tag === 'IDENTIFIER' && token[1] === 'type') {
+        let prevTag = tokens[i - 1]?.[0];
+        let atStatement = !prevTag || prevTag === 'TERMINATOR' || prevTag === 'INDENT' || prevTag === 'EXPORT';
+        if (!atStatement) return 1;
+
+        let nameIdx = i + 1;
+        let nameToken = tokens[nameIdx];
+        if (!nameToken || nameToken[0] !== 'IDENTIFIER') return 1;
         let name = nameToken[1];
-        let exported = i >= 2 && tokens[i - 2]?.[0] === 'EXPORT';
-        let removeFrom = exported ? i - 2 : i - 1;
-        let next = tokens[i + 1];
+
+        let exported = prevTag === 'EXPORT';
+        let removeFrom = exported ? i - 1 : i;
+
+        // Handle generic type parameters: type Name<T> = ...
+        let eqIdx = nameIdx + 1;
+        if (tokens[eqIdx]?.[0] === 'COMPARE' && tokens[eqIdx]?.[1] === '<' && !tokens[eqIdx].spaced) {
+          let genTokens = collectBalancedAngles(tokens, eqIdx);
+          if (genTokens) {
+            if (!nameToken.data) nameToken.data = {};
+            nameToken.data.typeParams = buildTypeString(genTokens);
+            tokens.splice(eqIdx, genTokens.length);
+          }
+        }
+
+        // Must have = after name (or after stripped generics)
+        if (tokens[eqIdx]?.[0] !== '=') return 1;
 
         let makeDecl = (typeText) => {
           let dt = gen('TYPE_DECL', name, nameToken);
@@ -141,26 +158,29 @@ export function installTypeSupport(Lexer) {
           return dt;
         };
 
-        // Structural type: Name ::= type INDENT ... OUTDENT
-        if (next && next[0] === 'IDENTIFIER' && next[1] === 'type' &&
-            tokens[i + 2]?.[0] === 'INDENT') {
-          let endIdx = findMatchingOutdent(tokens, i + 2);
-          tokens.splice(removeFrom, endIdx - removeFrom + 1, makeDecl(collectStructuralType(tokens, i + 2)));
-          return 0;
-        }
+        let afterEq = eqIdx + 1;
+        let next = tokens[afterEq];
 
-        // Block union: Name ::= TERMINATOR INDENT | "a" | "b" ... OUTDENT
+        // Block union: type Name = (TERMINATOR?) INDENT | "a" | "b" ... OUTDENT
+        // Must check before structural — `=` suppresses TERMINATOR so INDENT follows directly
         if (next && (next[0] === 'TERMINATOR' || next[0] === 'INDENT')) {
-          let result = collectBlockUnion(tokens, i + 1);
+          let result = collectBlockUnion(tokens, afterEq);
           if (result) {
             tokens.splice(removeFrom, result.endIdx - removeFrom + 1, makeDecl(result.typeText));
             return 0;
           }
         }
 
-        // Simple alias: Name ::= type-expression
-        let typeTokens = collectTypeExpression(tokens, i + 1);
-        tokens.splice(removeFrom, i + 1 + typeTokens.length - removeFrom, makeDecl(buildTypeString(typeTokens)));
+        // Structural type: type Name = INDENT ... OUTDENT
+        if (next && next[0] === 'INDENT') {
+          let endIdx = findMatchingOutdent(tokens, afterEq);
+          tokens.splice(removeFrom, endIdx - removeFrom + 1, makeDecl(collectStructuralType(tokens, afterEq)));
+          return 0;
+        }
+
+        // Simple alias: type Name = type-expression
+        let typeTokens = collectTypeExpression(tokens, afterEq);
+        tokens.splice(removeFrom, afterEq + typeTokens.length - removeFrom, makeDecl(buildTypeString(typeTokens)));
         return 0;
       }
 
@@ -932,9 +952,14 @@ export function emitTypes(tokens, sexpr = null) {
   let preamble = [];
   if (usesSignal) {
     preamble.push('interface Signal<T> { value: T; read(): T; lock(): Signal<T>; free(): Signal<T>; kill(): T; }');
+    preamble.push('declare function __state<T>(value: T): Signal<T>;');
   }
   if (usesComputed) {
     preamble.push('interface Computed<T> { readonly value: T; read(): T; lock(): Computed<T>; free(): Computed<T>; kill(): T; }');
+    preamble.push('declare function __computed<T>(fn: () => T): Computed<T>;');
+  }
+  if (usesSignal || usesComputed) {
+    preamble.push('declare function __effect(fn: () => void | (() => void)): () => void;');
   }
   if (preamble.length > 0) {
     preamble.push('');

package/src/ui.rip

@@ -1013,3 +1013,68 @@ export launch = (appBase = '', opts = {}) ->
       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) — close on outside click or scroll
+#
+# Both nav handlers:
+#   - Guard against IME composition events (e.which === 229, 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()
+
+_ariaListNav = (e, h) ->
+  return if e.which is 229              # IME guard: suppress CJK composition events
+  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 = []) ->
+  return unless open
+  inside   = [popup, ...els]
+  onDown   = (e) => close() unless inside.some (el) -> el?.contains(e.target)
+  onScroll = (e) => close() unless popup?.contains(e.target)
+  document.addEventListener 'mousedown', onDown
+  window.addEventListener   'scroll',    onScroll, true
+  ->
+    document.removeEventListener 'mousedown', onDown
+    window.removeEventListener   'scroll',    onScroll, true
+
+_ariaRovingNav = (e, h, orientation = 'vertical') ->
+  return if e.which is 229              # 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
+
+globalThis.__aria ??= { listNav: _ariaListNav, rovingNav: _ariaRovingNav, popupDismiss: _ariaPopupDismiss }
+globalThis.ARIA   ??= globalThis.__aria

package/docs/ui/accordion.rip

@@ -1,113 +0,0 @@
-# Accordion — accessible headless expand/collapse widget
-#
-# Supports single or multiple expanded sections. Keyboard: Enter/Space to
-# toggle, ArrowDown/Up to move between triggers. Exposes $open on items.
-# Ships zero CSS.
-#
-# Usage:
-#   Accordion multiple: false
-#     div $item: "a"
-#       button $trigger: true, "Section A"
-#       div $content: true
-#         p "Content A"
-#     div $item: "b"
-#       button $trigger: true, "Section B"
-#       div $content: true
-#         p "Content B"
-
-export Accordion = component
-  @multiple := false
-
-  openItems := new Set()
-  _ready    := false
-  _id =! "acc-#{Math.random().toString(36).slice(2, 8)}"
-
-  mounted: ->
-    _ready = true
-    @_content?.querySelectorAll('[data-trigger]').forEach (trigger) =>
-      item = trigger.closest('[data-item]')
-      return unless item
-      id = item.dataset.item
-      trigger.addEventListener 'click', =>
-        return if item.hasAttribute('data-disabled')
-        @toggle(id)
-      trigger.addEventListener 'keydown', (e) => @onTriggerKeydown(e, id)
-
-  ~>
-    return unless _ready
-    @_content?.querySelectorAll('[data-item]').forEach (item) =>
-      id = item.dataset.item
-      isOpen = openItems.has(id)
-      item.toggleAttribute 'data-open', isOpen
-      trigger = item.querySelector('[data-trigger]')
-      content = item.querySelector('[data-content]')
-      triggerId = "#{_id}-trigger-#{id}"
-      panelId   = "#{_id}-panel-#{id}"
-      if trigger
-        isDisabled = item.hasAttribute('data-disabled')
-        trigger.id = triggerId
-        trigger.setAttribute 'aria-expanded', isOpen
-        trigger.setAttribute 'aria-controls', panelId
-        trigger.setAttribute 'aria-disabled', isDisabled if isDisabled
-        trigger.tabIndex = if isDisabled then -1 else 0
-      if content
-        content.id = panelId
-        content.hidden = if isOpen then false else 'until-found'
-        content.setAttribute 'role', 'region'
-        content.setAttribute 'aria-labelledby', triggerId
-        if isOpen
-          rect = content.getBoundingClientRect()
-          content.style.setProperty '--accordion-panel-height', "#{rect.height}px"
-          content.style.setProperty '--accordion-panel-width', "#{rect.width}px"
-
-  toggle: (id) ->
-    if openItems.has(id)
-      openItems.delete(id)
-    else
-      openItems.clear() unless @multiple
-      openItems.add(id)
-    openItems = new Set(openItems)
-    @emit 'change', Array.from(openItems)
-
-  isOpen: (id) ->
-    openItems.has(id)
-
-  onTriggerKeydown: (e, id) ->
-    item = e.currentTarget.closest('[data-item]')
-    return if item?.hasAttribute('data-disabled') and e.key in ['Enter', ' ']
-    switch e.key
-      when 'Enter', ' '
-        e.preventDefault()
-        @toggle(id)
-      when 'ArrowDown'
-        e.preventDefault()
-        @_focusNext(1)
-      when 'ArrowUp'
-        e.preventDefault()
-        @_focusNext(-1)
-      when 'Home'
-        e.preventDefault()
-        @_focusTrigger(0)
-      when 'End'
-        e.preventDefault()
-        @_focusTrigger(-1)
-
-  _triggers: ->
-    return [] unless @_content
-    Array.from(@_content.querySelectorAll('[data-trigger]'))
-
-  _focusNext: (dir) ->
-    triggers = @_triggers()
-    idx = triggers.indexOf(document.activeElement)
-    return if idx is -1
-    next = (idx + dir) %% triggers.length
-    triggers[next]?.focus()
-
-  _focusTrigger: (idx) ->
-    triggers = @_triggers()
-    target = if idx < 0 then triggers[triggers.length - 1] else triggers[idx]
-    target?.focus()
-
-  render
-    div ref: "_content"
-      slot

package/docs/ui/alert-dialog.rip

@@ -1,96 +0,0 @@
-# AlertDialog — accessible headless non-dismissable modal
-#
-# A Dialog variant that requires explicit user action to close.
-# Cannot be dismissed by clicking outside or pressing Escape.
-# Use for destructive confirmations, unsaved changes, etc.
-# Ships zero CSS.
-#
-# Usage:
-#   AlertDialog open <=> showConfirm
-#     h2 "Delete account?"
-#     p "This action cannot be undone."
-#     button @click: (=> showConfirm = false), "Cancel"
-#     button @click: handleDelete, "Delete"
-
-alertDialogStack = []
-
-export AlertDialog = component
-  @open := false
-  @initialFocus := null
-
-  _prevFocus = null
-  _cleanupTrap = null
-  _scrollY = 0
-  _id =! "adlg-#{Math.random().toString(36).slice(2, 8)}"
-
-  _wireAria: ->
-    panel = @_panel
-    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
-
-  ~>
-    if @open
-      _prevFocus = document.activeElement
-      _scrollY = window.scrollY
-      alertDialogStack.push this
-      document.body.style.position = 'fixed'
-      document.body.style.top = "-#{_scrollY}px"
-      document.body.style.width = '100%'
-
-      setTimeout =>
-        panel = @_panel
-        if panel
-          @_wireAria()
-          if @initialFocus
-            target = if typeof @initialFocus is 'string' then panel.querySelector(@initialFocus) else @initialFocus
-            target?.focus()
-          else
-            focusable = panel.querySelectorAll 'a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex="-1"])'
-            focusable[0]?.focus()
-          _cleanupTrap = (e) ->
-            return unless e.key is 'Tab'
-            list = Array.from(panel.querySelectorAll('a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex="-1"])')).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', _cleanupTrap
-      , 0
-
-      return ->
-        idx = alertDialogStack.indexOf this
-        alertDialogStack.splice(idx, 1) if idx >= 0
-        document.body.style.position = '' unless alertDialogStack.length
-        document.body.style.top = '' unless alertDialogStack.length
-        document.body.style.width = '' unless alertDialogStack.length
-        window.scrollTo 0, _scrollY unless alertDialogStack.length
-        _prevFocus?.focus()
-    else
-      idx = alertDialogStack.indexOf this
-      alertDialogStack.splice(idx, 1) if idx >= 0
-      unless alertDialogStack.length
-        document.body.style.position = ''
-        document.body.style.top = ''
-        document.body.style.width = ''
-        window.scrollTo 0, _scrollY
-      _prevFocus?.focus()
-
-  close: ->
-    @open = false
-    @emit 'close'
-
-  render
-    if @open
-      div ref: "_backdrop", $open: true
-        div ref: "_panel", role: "alertdialog", aria-modal: "true", tabindex: "-1"
-          slot