@barefootjs/jsx 0.13.0 → 0.15.0

package/src/augment-inherited-props.ts

@@ -164,7 +164,31 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
     if (!node) return
     const el = node as unknown as IRElement
     for (const attr of el.attrs ?? []) {
-      const v = attr.value as { kind?: string; expr?: string; presenceOrUndefined?: boolean }
+      const v = attr.value as {
+        kind?: string
+        expr?: string
+        presenceOrUndefined?: boolean
+        parts?: Array<
+          | { type: 'string'; value: string }
+          | { type: 'ternary'; condition: string; whenTrue: string; whenFalse: string }
+          | { type: 'lookup'; key: string }
+        >
+      }
+      // Template-literal attr values (`className={\`… \${props.className ??
+      // ''}\`}`) carry their `props.X` reads inside the parts structure,
+      // not a flat expr string (#1896 — TabsContent's template referenced
+      // `.ClassName` while the Props struct never declared it). Scan every
+      // textual field of every part shape.
+      if (v?.parts) {
+        for (const part of v.parts) {
+          if (part.type === 'string') scan(part.value)
+          else if (part.type === 'ternary') {
+            scan(part.condition)
+            scan(part.whenTrue)
+            scan(part.whenFalse)
+          } else if (part.type === 'lookup') scan(part.key)
+        }
+      }
       if (v?.kind === 'expression' && typeof v.expr === 'string') {
         scan(v.expr)
         const expr = v.expr.trim()
@@ -186,6 +210,20 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
       const c = child as { element?: IRNode }
       walk((c.element ?? child) as IRNode)
     }
+    // Conditional / if-statement nodes keep their subtrees in branch
+    // fields, not `children` (#1896 — DialogTrigger's asChild
+    // if-statement hid the button branch's `id={props.id}` from this
+    // scan, so the template referenced `.ID` without a Props field).
+    const branchy = node as unknown as {
+      whenTrue?: IRNode
+      whenFalse?: IRNode
+      consequent?: IRNode
+      alternate?: IRNode
+    }
+    walk(branchy.whenTrue)
+    walk(branchy.whenFalse)
+    walk(branchy.consequent)
+    walk(branchy.alternate)
   }
   walk(ir.root)
 
@@ -206,6 +244,134 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
   }
 }
 
+/**
+ * Parse a const initializer to its static string value: a string literal,
+ * a no-substitution template literal, or a `[<string literals>].join(sep)`
+ * call. Returns `null` for anything else. The TS parser resolves escapes
+ * and quoting exactly as JS would, matching the value the Hono reference
+ * inlines at runtime. Shared by the Go, Mojo, and Xslate adapters.
+ */
+export function parseStaticStringConst(source: string): string | null {
+  const sf = ts.createSourceFile(
+    '__const.ts', `const __x = (${source});`, ts.ScriptTarget.Latest, /*setParentNodes*/ false,
+  )
+  const stmt = sf.statements[0]
+  if (!stmt || !ts.isVariableStatement(stmt)) return null
+  let init = stmt.declarationList.declarations[0]?.initializer
+  while (init && ts.isParenthesizedExpression(init)) init = init.expression
+  if (!init) return null
+  if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+    return init.text
+  }
+  return evalStringArrayJoin(source)
+}
+
+/**
+ * Statically evaluate a template literal whose every interpolation is a
+ * bare identifier present in `resolved` to its flat string, else `null`.
+ * Companion to `parseStaticStringConst` for COMPOSED module consts
+ * (#1896 / #1897 — radio-group's
+ * `itemClasses = \`\${itemBaseClasses} \${itemFocusClasses} …\``).
+ */
+export function evalTemplateOfStringConsts(
+  source: string,
+  resolved: ReadonlyMap<string, string>,
+): string | null {
+  const sf = ts.createSourceFile(
+    '__const.ts', `const __x = (${source});`, ts.ScriptTarget.Latest, /*setParentNodes*/ false,
+  )
+  const stmt = sf.statements[0]
+  if (!stmt || !ts.isVariableStatement(stmt)) return null
+  let init = stmt.declarationList.declarations[0]?.initializer
+  while (init && ts.isParenthesizedExpression(init)) init = init.expression
+  if (!init || !ts.isTemplateExpression(init)) return null
+  let out = init.head.text
+  for (const span of init.templateSpans) {
+    if (!ts.isIdentifier(span.expression)) return null
+    const value = resolved.get(span.expression.text)
+    if (value === undefined) return null
+    out += value + span.literal.text
+  }
+  return out
+}
+
+/**
+ * Build the module string-const map from the IR's localConstants —
+ * the SINGLE SOURCE OF TRUTH for all three SSR template adapters.
+ * A const qualifies when module-scope and statically resolvable as:
+ *   - a pure string / no-substitution-template literal,
+ *   - `[<string literals>].join(sep)`,
+ *   - a template literal COMPOSED of other qualifying module consts
+ *     (resolved to a fixed point, so composition order doesn't matter).
+ */
+export function collectModuleStringConsts(
+  constants: IRMetadata['localConstants'] | undefined,
+): Map<string, string> {
+  const map = new Map<string, string>()
+  const candidates = (constants ?? []).filter(
+    c => c.isModule && c.value !== undefined,
+  )
+  let progressed = true
+  while (progressed) {
+    progressed = false
+    for (const c of candidates) {
+      if (map.has(c.name)) continue
+      const literal =
+        parseStaticStringConst(c.value!) ??
+        evalTemplateOfStringConsts(c.value!, map)
+      if (literal !== null) {
+        map.set(c.name, literal)
+        progressed = true
+      }
+    }
+  }
+  return map
+}
+
+/**
+ * Resolve `IDENT.key` / `IDENT['key']` where `IDENT` is a module-scope
+ * object-literal const and the key/value are static literals — a fully
+ * compile-time lookup (the icon registry's `strokePaths['chevron-down']`,
+ * pagination's `variantClasses.ghost`; #1896 / #1897). Returns the
+ * looked-up scalar, or `null` for any other shape so callers fall back
+ * to their generic lowering. Shared by all three SSR template adapters;
+ * the prop-KEYED variant of the pattern lives in `parseRecordIndexAccess`.
+ */
+export function lookupStaticRecordLiteral(
+  objectName: string,
+  key: string,
+  constants: IRMetadata['localConstants'] | undefined,
+): { kind: 'string' | 'number'; text: string } | null {
+  const constInfo = (constants ?? []).find(c => c.name === objectName && c.isModule)
+  if (constInfo?.value === undefined) return null
+  const sf = ts.createSourceFile(
+    '__rec.ts', `(${constInfo.value})`, ts.ScriptTarget.Latest, /*setParentNodes*/ true,
+  )
+  if (sf.statements.length !== 1) return null
+  const stmt = sf.statements[0]
+  if (!ts.isExpressionStatement(stmt)) return null
+  let parsed: ts.Expression = stmt.expression
+  while (ts.isParenthesizedExpression(parsed)) parsed = parsed.expression
+  if (!ts.isObjectLiteralExpression(parsed)) return null
+  for (const prop of parsed.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue
+    const name = prop.name
+    const propKey =
+      ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)
+        ? name.text
+        : null
+    if (propKey !== key) continue
+    let v: ts.Expression = prop.initializer
+    while (ts.isParenthesizedExpression(v)) v = v.expression
+    if (ts.isNumericLiteral(v)) return { kind: 'number', text: v.text }
+    if (ts.isStringLiteral(v) || ts.isNoSubstitutionTemplateLiteral(v)) {
+      return { kind: 'string', text: v.text }
+    }
+    return null
+  }
+  return null
+}
+
 /**
  * Statically evaluate `[<string literals>].join(<sep?>)` (e.g. a module-scope
  * `const stateClasses = ['…', …].join(' ')`) to its joined string, so SSR
@@ -213,7 +379,9 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
  * instead of referencing a binding that doesn't exist server-side. Default
  * separator `,` matches JS `Array.prototype.join`. Returns `null` for any
  * other shape (non-`.join` call, non-array receiver, non-string-literal element
- * or separator). Shared by the Mojo + Xslate adapters; Go keeps a private copy.
+ * or separator). Shared by the Go, Mojo, and Xslate adapters (all three
+ * resolve module consts through `collectModuleStringConsts` above, which
+ * folds these joins during its fixed-point pass).
  */
 export function evalStringArrayJoin(source: string): string | null {
   const sf = ts.createSourceFile(

package/src/builtins.ts

@@ -0,0 +1,63 @@
+/**
+ * Compiler built-in JSX tags that are import-scoped to `@barefootjs/client`
+ * and compiled away (no runtime value survives in emitted output).
+ *
+ * `<Async>` and `<Region>` are recognised **structurally** — by their
+ * `@barefootjs/client` import in `ir.metadata.imports`, never by a bare
+ * capitalized tag-name match — so a user's own `<Async>` / `<Region>`
+ * component (imported from elsewhere or declared locally) does not collide
+ * with the built-in. The import is elided on emit (both `templateImports`
+ * and the client-JS DOM imports) so it never lingers as a phantom runtime
+ * import.
+ *
+ * Runtime stubs + types ship from `@barefootjs/client` (see
+ * `packages/client/src/builtins.ts`). See piconic-ai/barefootjs#1915.
+ */
+
+import type { ImportInfo } from './types.ts'
+
+/** Package that the built-in tags must be imported from to be recognised. */
+export const CLIENT_BUILTIN_SOURCE = '@barefootjs/client'
+
+export type ClientBuiltinTag = 'Async' | 'Region'
+
+/** The recognised built-in tag (export) names. */
+export const CLIENT_BUILTIN_TAGS: readonly ClientBuiltinTag[] = ['Async', 'Region']
+
+/** True when `name` is one of the compile-away built-in export names. */
+export function isClientBuiltinName(name: string): name is ClientBuiltinTag {
+  return name === 'Async' || name === 'Region'
+}
+
+/**
+ * Elide the compile-away built-ins from an import list for emission (#1915).
+ * `<Async>` / `<Region>` are lowered into the template, so their
+ * `@barefootjs/client` import must not survive as a phantom runtime import in
+ * either the SSR template or the client JS bundle. Drops the `Async` / `Region`
+ * specifiers from `@barefootjs/client` imports, and drops the whole import
+ * statement when it has no remaining specifiers.
+ */
+export function stripClientBuiltinImports(imports: ImportInfo[]): ImportInfo[] {
+  const result: ImportInfo[] = []
+  for (const imp of imports) {
+    // Only a *value* named import of the built-ins can become a phantom runtime
+    // import. Leave everything else untouched: imports from other sources;
+    // `import type { Async }` (erased by TS — never a runtime import, and may be
+    // needed to type-check emitted templates); and side-effect imports (no
+    // specifiers, deliberate). See #1915 review.
+    if (imp.source !== CLIENT_BUILTIN_SOURCE || imp.isTypeOnly || imp.specifiers.length === 0) {
+      result.push(imp)
+      continue
+    }
+    const kept = imp.specifiers.filter(
+      // Keep per-specifier type-only built-ins (`import { type Async }`) — they
+      // are erased by TS and never a runtime phantom.
+      spec => spec.isDefault || spec.isNamespace || spec.isTypeOnly || !isClientBuiltinName(spec.name),
+    )
+    // Drop the import entirely when every specifier was a built-in; otherwise
+    // re-emit without them.
+    if (kept.length === 0) continue
+    result.push(kept.length === imp.specifiers.length ? imp : { ...imp, specifiers: kept })
+  }
+  return result
+}

package/src/compiler.ts

@@ -14,6 +14,7 @@ import type {
 import type { TemplateAdapter } from './adapters/interface.ts'
 import { analyzeComponent, listComponentFunctions, createProgramForFile, needsTypeBasedDetection } from './analyzer.ts'
 import { jsxToIR } from './jsx-to-ir.ts'
+import { stripClientBuiltinImports } from './builtins.ts'
 import { generateClientJs, generateClientJsWithSourceMap, analyzeClientNeeds } from './ir-to-client-js/index.ts'
 import { emitModuleLevelDeclarations } from './ir-to-client-js/emit-module-level.ts'
 import { RUNTIME_MODULE, detectUsedImports as detectUsedImportsFromCode } from './ir-to-client-js/imports.ts'
@@ -502,8 +503,11 @@ export function buildMetadata(
     // re-emission. Adapters that re-emit imports (Hono, test) call
     // `rewriteImportsForTemplate` themselves to apply client-shim rewrite or
     // strip behaviour; adapters whose templates never carry imports (Go,
-    // Mojo) only consult this list for diagnostics like BF103.
-    templateImports: ctx.imports,
+    // Mojo) only consult this list for diagnostics like BF103. The
+    // compile-away built-ins (`<Async>` / `<Region>`) are stripped here so
+    // their `@barefootjs/client` import never reaches any adapter's template
+    // as a phantom (#1915).
+    templateImports: stripClientBuiltinImports(ctx.imports),
     namedExports: ctx.namedExports,
     localFunctions: ctx.localFunctions,
     localConstants: ctx.localConstants,

package/src/errors.ts

@@ -47,6 +47,11 @@ export const ErrorCodes = {
   // Import errors (BF050-BF059)
   SHARED_PROGRAM_REQUIRED: 'BF050',
   WRONG_PACKAGE_IMPORT: 'BF051',
+  // A bare `<Async>` / `<Region>` tag was used without importing it from
+  // `@barefootjs/client`. The built-ins are recognised import-scoped (#1915),
+  // so an unimported tag with the built-in name is either a forgotten import
+  // or an undeclared component — fail loud with the import to add.
+  BUILTIN_REQUIRES_IMPORT: 'BF054',
 
   // Init statement errors (BF052)
   UNDECLARED_INIT_STATEMENT_REFERENCE: 'BF052',
@@ -135,6 +140,11 @@ const errorMessages: Record<ErrorCode, string> = {
   [ErrorCodes.WRONG_PACKAGE_IMPORT]:
     'Import from wrong package.',
 
+  [ErrorCodes.BUILTIN_REQUIRES_IMPORT]:
+    "Built-in <Async> / <Region> must be imported from '@barefootjs/client'. " +
+    'The compiler recognises these tags by their import (not by tag name), ' +
+    'so an unimported tag with this name is treated as an undeclared component.',
+
   [ErrorCodes.UNDECLARED_INIT_STATEMENT_REFERENCE]:
     'Init statement references an undeclared identifier. Declare it at module scope, inside the component, or import it — otherwise ESM strict mode throws ReferenceError at runtime.',
 

package/src/expression-parser.ts

@@ -17,6 +17,14 @@ export type ParsedExpr =
   | { kind: 'literal'; value: string | number | boolean | null; literalType: 'string' | 'number' | 'boolean' | 'null' }
   | { kind: 'call'; callee: ParsedExpr; args: ParsedExpr[] }
   | { kind: 'member'; object: ParsedExpr; property: string; computed: boolean }
+  // Element access with a NON-literal index (`selected()[index]`,
+  // `rows[i + 1]`). A literal-index access (`arr[0]`, `obj['key']`)
+  // stays a `member` (computed) since the key is statically known and
+  // folds into the same property path. The variable case can't, so the
+  // index travels as its own `ParsedExpr` for the adapter to lower
+  // (array `->[$i]` vs hash `->{$k}` in Perl, `[index]` in JS). #1897
+  // (data-table's per-row `selected()[index]`).
+  | { kind: 'index-access'; object: ParsedExpr; index: ParsedExpr }
   | { kind: 'binary'; op: string; left: ParsedExpr; right: ParsedExpr }
   | { kind: 'unary'; op: string; argument: ParsedExpr }
   | { kind: 'conditional'; test: ParsedExpr; consequent: ParsedExpr; alternate: ParsedExpr }
@@ -46,6 +54,7 @@ export type ParsedExpr =
         | 'toLowerCase'
         | 'toUpperCase'
         | 'trim'
+        | 'toFixed'
         | 'split'
         | 'startsWith'
         | 'endsWith'
@@ -476,6 +485,106 @@ export function extractArrowBodyExpression(source: string): string | null {
   return expr.body.getText(sf).trim()
 }
 
+/**
+ * One member of a context-provider object-literal value
+ * (`<Ctx.Provider value={{ open: () => …, onOpenChange: … }}>`), classified
+ * for SSR lowering:
+ *
+ * - `getter` — a ZERO-parameter arrow with an expression body. At SSR time
+ *   the provider value is fixed for the render, so the getter is equivalent
+ *   to its body's value snapshot (`open: () => props.open ?? false` reads as
+ *   `props.open ?? false`). Arrows with parameters are NOT getters — their
+ *   body references the parameter, which has no SSR value.
+ * - `function` — any other function shape (parameterised / block-bodied
+ *   arrow, function expression, or a `??` / `||` chain with a function
+ *   operand). These are behavior, not data: SSR never invokes them, so
+ *   adapters lower them to their nil value (`undef` / `nil`).
+ * - `expression` — everything else; lowers through the adapter's normal
+ *   expression pipeline (so signal getters, props, memo calls keep their
+ *   existing SSR seeding semantics).
+ */
+export type ProviderObjectMember =
+  | { name: string; kind: 'getter'; body: string }
+  | { name: string; kind: 'function' }
+  | { name: string; kind: 'expression'; expr: string }
+
+/**
+ * Structurally parse a `<Ctx.Provider value={{ … }}>` object literal into
+ * per-member SSR lowering classifications (see `ProviderObjectMember`).
+ *
+ * Returns `null` when the source is not a plain object literal, or when it
+ * contains a shape with no per-member story (spread entry, computed key,
+ * get/set accessor) — callers fall back to their existing whole-expression
+ * path (typically a BF101 refusal). Shorthand members (`{ search }`) yield
+ * an `expression` member with the identifier as the expression; method
+ * members (`{ open() {…} }`) classify as `function` like block-bodied
+ * arrows.
+ */
+export function parseProviderObjectLiteral(source: string): ProviderObjectMember[] | null {
+  const sf = ts.createSourceFile(
+    '__provider__.ts',
+    `const __x = (${source});`,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */ true,
+  )
+  const stmt = sf.statements[0]
+  if (!stmt || !ts.isVariableStatement(stmt)) return null
+  let init = stmt.declarationList.declarations[0]?.initializer
+  while (init && ts.isParenthesizedExpression(init)) init = init.expression
+  if (!init || !ts.isObjectLiteralExpression(init)) return null
+
+  const isFunctionShaped = (e: ts.Expression): boolean => {
+    let v: ts.Expression = e
+    while (ts.isParenthesizedExpression(v)) v = v.expression
+    if (ts.isArrowFunction(v) || ts.isFunctionExpression(v)) return true
+    // `props.onX ?? (() => {})` — a fallback chain with a function operand
+    // is function-typed regardless of which side wins at runtime.
+    if (
+      ts.isBinaryExpression(v) &&
+      (v.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+        v.operatorToken.kind === ts.SyntaxKind.BarBarToken)
+    ) {
+      return isFunctionShaped(v.left) || isFunctionShaped(v.right)
+    }
+    return false
+  }
+
+  const members: ProviderObjectMember[] = []
+  for (const prop of init.properties) {
+    if (ts.isShorthandPropertyAssignment(prop)) {
+      members.push({ name: prop.name.text, kind: 'expression', expr: prop.name.text })
+      continue
+    }
+    if (ts.isMethodDeclaration(prop)) {
+      // `{ open() {…} }` — function-shaped behavior, same as a
+      // block-bodied arrow member.
+      const name = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
+        ? prop.name.text
+        : null
+      if (name === null) return null // computed key
+      members.push({ name, kind: 'function' })
+      continue
+    }
+    if (!ts.isPropertyAssignment(prop)) return null // spread / accessor
+    const name = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
+      ? prop.name.text
+      : null
+    if (name === null) return null // computed key
+    let v: ts.Expression = prop.initializer
+    while (ts.isParenthesizedExpression(v)) v = v.expression
+    if (ts.isArrowFunction(v) && v.parameters.length === 0 && !ts.isBlock(v.body)) {
+      members.push({ name, kind: 'getter', body: v.body.getText(sf).trim() })
+      continue
+    }
+    if (isFunctionShaped(v)) {
+      members.push({ name, kind: 'function' })
+      continue
+    }
+    members.push({ name, kind: 'expression', expr: v.getText(sf).trim() })
+  }
+  return members
+}
+
 /**
  * A single entry of a JSX `style={{ … }}` object, lowered for SSR. The key is
  * already CSS-cased (`backgroundColor` → `background-color`); the value is
@@ -757,6 +866,14 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       if (callee.property === 'trim') {
         return { kind: 'array-method', method: 'trim', object: callee.object, args }
       }
+      // `.toFixed(digits?)` — Number → fixed-decimal string. The digit
+      // count (default 0) travels as the single arg; all adapters route
+      // through a `to_fixed` runtime helper (Perl) / `fmt.Sprintf` (Go)
+      // so JS's rounding + zero-padding semantics match. #1897
+      // (data-table's `payment.amount.toFixed(2)`).
+      if (callee.property === 'toFixed') {
+        return { kind: 'array-method', method: 'toFixed', object: callee.object, args }
+      }
       // `.split()` / `.split(sep)` / `.split(sep, limit)` — string →
       // array, full JS arity. `.split()` (no separator) returns the
       // whole string as a single element; `.split(sep)` splits on the
@@ -1028,6 +1145,13 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
   if (ts.isElementAccessExpression(node)) {
     const object = convertNode(node.expression, raw)
     const argNode = node.argumentExpression
+    // `argumentExpression` is non-optional in the TS types but CAN be
+    // undefined on an AST recovered from incomplete source (`arr[`). Guard
+    // so a half-typed expression surfaces a recoverable BF101 instead of
+    // throwing inside `ts.isNumericLiteral(undefined)`.
+    if (!argNode) {
+      return { kind: 'unsupported', raw, reason: 'Element access with no index expression' }
+    }
     // For simple number/string access, store as property
     if (ts.isNumericLiteral(argNode)) {
       return { kind: 'member', object, property: argNode.text, computed: true }
@@ -1035,8 +1159,13 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     if (ts.isStringLiteral(argNode)) {
       return { kind: 'member', object, property: argNode.text, computed: true }
     }
-    // Complex computed access
-    return { kind: 'unsupported', raw, reason: 'Complex computed property access' }
+    // Variable / expression index (`selected()[index]`, `rows[i + 1]`):
+    // carry the index as its own ParsedExpr so the adapter can lower it
+    // (the literal forms above fold into a static property path; this
+    // one can't). #1897 (data-table).
+    const index = convertNode(argNode, raw)
+    if (index.kind === 'unsupported') return index
+    return { kind: 'index-access', object, index }
   }
 
   // Binary expression: a === b, count > 0, a + b
@@ -1988,6 +2117,8 @@ function findImpureDefaultNode(expr: ParsedExpr): string | null {
       return null
     case 'member':
       return findImpureDefaultNode(expr.object)
+    case 'index-access':
+      return findImpureDefaultNode(expr.object) ?? findImpureDefaultNode(expr.index)
     case 'unary':
       return findImpureDefaultNode(expr.argument)
     case 'binary':
@@ -2217,6 +2348,10 @@ function collectIdentifiers(expr: ParsedExpr, out: Set<string>): void {
     case 'member':
       collectIdentifiers(expr.object, out)
       return
+    case 'index-access':
+      collectIdentifiers(expr.object, out)
+      collectIdentifiers(expr.index, out)
+      return
     case 'binary':
     case 'logical':
       collectIdentifiers(expr.left, out)
@@ -2311,6 +2446,8 @@ function substituteDestructuredFields(
           }
         }
         return { kind: 'member', object: walk(e.object), property: e.property, computed: e.computed }
+      case 'index-access':
+        return { kind: 'index-access', object: walk(e.object), index: walk(e.index) }
       case 'binary':
         return { kind: 'binary', op: e.op, left: walk(e.left), right: walk(e.right) }
       case 'logical':
@@ -2559,6 +2696,17 @@ function checkSupport(expr: ParsedExpr): SupportResult {
       return { supported: true, level: 'L2' }
     }
 
+    case 'index-access': {
+      // `arr[index]` — supported when both the receiver and the index
+      // expression are themselves supported (the index is typically a
+      // loop variable or arithmetic over one). #1897 (data-table).
+      const objSupport = checkSupport(expr.object)
+      if (!objSupport.supported) return objSupport
+      const indexSupport = checkSupport(expr.index)
+      if (!indexSupport.supported) return indexSupport
+      return { supported: true, level: 'L2' }
+    }
+
     case 'binary': {
       const leftSupport = checkSupport(expr.left)
       if (!leftSupport.supported) return leftSupport
@@ -2640,6 +2788,8 @@ export function containsHigherOrder(expr: ParsedExpr): boolean {
       return expr.args.some(containsHigherOrder) || containsHigherOrder(expr.callee)
     case 'member':
       return containsHigherOrder(expr.object)
+    case 'index-access':
+      return containsHigherOrder(expr.object) || containsHigherOrder(expr.index)
     case 'binary':
       return containsHigherOrder(expr.left) || containsHigherOrder(expr.right)
     case 'unary':
@@ -2811,6 +2961,8 @@ export function exprToString(expr: ParsedExpr): string {
       return `${exprToString(expr.callee)}(${expr.args.map(exprToString).join(', ')})`
     case 'member':
       return `${exprToString(expr.object)}.${expr.property}`
+    case 'index-access':
+      return `${exprToString(expr.object)}[${exprToString(expr.index)}]`
     case 'binary':
       return `${exprToString(expr.left)} ${expr.op} ${exprToString(expr.right)}`
     case 'unary':
@@ -2892,6 +3044,8 @@ export function stringifyParsedExpr(expr: ParsedExpr): string {
         : JSON.stringify(expr.property)
       return `${obj}[${key}]`
     }
+    case 'index-access':
+      return `${stringifyParsedExpr(expr.object)}[${stringifyParsedExpr(expr.index)}]`
     case 'binary':
       return `${stringifyParsedExpr(expr.left)} ${expr.op} ${stringifyParsedExpr(expr.right)}`
     case 'unary':

package/src/index.ts

@@ -76,6 +76,7 @@ export type { JsxAdapterConfig } from './adapters/jsx-adapter.ts'
 export { rewriteImportsForTemplate } from './adapters/template-imports.ts'
 export { emitParsedExpr } from './adapters/parsed-expr-emitter.ts'
 export type { ParsedExprEmitter, HigherOrderMethod, ArrayMethod, SortMethod, LiteralType } from './adapters/parsed-expr-emitter.ts'
+export { importsSearchParams, searchParamsLocalNames, matchSearchParamsMethodCall } from './adapters/env-signal.ts'
 export { emitIRNode } from './adapters/ir-node-emitter.ts'
 export type { IRNodeEmitter, EmitIRNode } from './adapters/ir-node-emitter.ts'
 export { emitAttrValue } from './adapters/attr-value-emitter.ts'
@@ -247,7 +248,7 @@ export {
 export { ErrorCodes, createError, formatError, generateCodeFrame } from './errors.ts'
 
 // Expression Parser
-export { parseExpression, isSupported, exprToString, stringifyParsedExpr, identifierPath, parseBlockBody, containsHigherOrder, extractArrowBodyExpression, parseStyleObjectEntries } from './expression-parser.ts'
+export { parseExpression, isSupported, exprToString, stringifyParsedExpr, identifierPath, parseBlockBody, containsHigherOrder, extractArrowBodyExpression, parseStyleObjectEntries, parseProviderObjectLiteral, type ProviderObjectMember } from './expression-parser.ts'
 export type { StyleObjectEntry } from './expression-parser.ts'
 export type { ParsedExpr, ParsedStatement, SortComparator, SortKey, ReduceOp, FlatDepth, FlatMapOp, FlatMapLeaf, SupportLevel, SupportResult, TemplatePart } from './expression-parser.ts'
 export { buildLoopChainExpr } from './loop-chain.ts'
@@ -285,6 +286,7 @@ export type { WrapReason } from './ir-to-client-js/reactivity.ts'
 // Reactive performance profiler (#1690). Static half (SR5 budget, SR6 diff) +
 // dynamic half (SR2/SR4 join, SR7 report, v1 analyses).
 export {
+  PROFILE_SCHEMA_VERSION,
   buildStaticBudget,
   formatStaticBudget,
   diffStaticBudget,
@@ -306,6 +308,7 @@ export type {
   StaticBudget,
   StaticBudgetOptions,
   FanOutEntry,
+  BudgetHandler,
   BudgetDiff,
   FanOutChange,
   ProfileReport,
@@ -352,7 +355,7 @@ export type {
 export { BOOLEAN_ATTRS, isBooleanAttr } from './html-constants.ts'
 
 // Shared props-object-pattern helpers for the Go / Mojo template adapters
-export { augmentInheritedPropAccesses, parseRecordIndexAccess, evalStringArrayJoin, collectContextConsumers } from './augment-inherited-props.ts'
+export { augmentInheritedPropAccesses, parseRecordIndexAccess, evalStringArrayJoin, collectModuleStringConsts, lookupStaticRecordLiteral, collectContextConsumers } from './augment-inherited-props.ts'
 export type { RecordIndexAccess, RecordIndexEntry, ContextConsumer } from './augment-inherited-props.ts'
 
 // HTML element attribute types

package/src/ir-to-client-js/imports.ts

@@ -3,6 +3,7 @@
  */
 
 import type { ComponentIR, IRNode } from '../types.ts'
+import { isClientBuiltinName } from '../builtins.ts'
 
 // All exports from @barefootjs/client/runtime that may be used in generated code
 export const RUNTIME_IMPORT_CANDIDATES = [
@@ -62,6 +63,10 @@ export function collectUserDomImports(ir: ComponentIR): string[] {
     if (runtimeSources.has(imp.source) && !imp.isTypeOnly) {
       for (const spec of imp.specifiers) {
         if (!spec.isDefault && !spec.isNamespace) {
+          // Compile-away built-ins (`<Async>` / `<Region>`) are lowered into
+          // the template — never emit their import into the client bundle,
+          // where it would be a phantom runtime import (#1915).
+          if (isClientBuiltinName(spec.name)) continue
           userImports.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name)
         }
       }