@barefootjs/jsx 0.1.1 → 0.1.3

package/src/__tests__/type-inference-failed.audit.test.ts

@@ -0,0 +1,48 @@
+/**
+ * BF030 `TYPE_INFERENCE_FAILED` deletion audit.
+ *
+ * BF030 was reserved for "Failed to infer type" — intended as a
+ * fallback when the compiler's `ts.Program`-based type detection
+ * fails. In practice, the compiler gracefully degrades (treats
+ * unknown types as non-reactive) and TypeScript itself reports
+ * type errors to the developer. No silent bug exists.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { analyzeComponent } from '../analyzer'
+import { jsxToIR } from '../jsx-to-ir'
+import { ErrorCodes } from '../errors'
+
+function compileToIR(source: string) {
+  const ctx = analyzeComponent(source, '/tmp/Test.tsx')
+  const ir = jsxToIR(ctx)
+  return { ctx, ir, errors: ctx.errors }
+}
+
+describe('BF030 TYPE_INFERENCE_FAILED — deletion audit', () => {
+  test('component with typed props compiles without errors', () => {
+    const src = `
+interface Props { count: number; label: string }
+export function Display(props: Props) {
+  return <div>{props.label}: {props.count}</div>
+}
+`
+    const { errors } = compileToIR(src)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('component with generic props compiles without errors', () => {
+    const src = `
+export function List<T extends { id: string }>(props: { items: T[] }) {
+  return <ul>{props.items.map((item) => <li key={item.id}>{item.id}</li>)}</ul>
+}
+`
+    const { errors } = compileToIR(src)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('BF030 code no longer exists in ErrorCodes', () => {
+    const allCodes = Object.values(ErrorCodes)
+    expect(allCodes).not.toContain('BF030')
+  })
+})

package/src/__tests__/unknown-signal.audit.test.ts

@@ -0,0 +1,111 @@
+/**
+ * BF010 `UNKNOWN_SIGNAL` deletion audit.
+ *
+ * BF010 was reserved for "Unknown signal reference" — a component that
+ * references a signal binding which was never declared. TypeScript's own
+ * `ts(2304) Cannot find name '...'` already catches this at the language
+ * level, so the barefoot compiler never needed a dedicated diagnostic.
+ *
+ * This file proves both claims:
+ *   1. TS semantic diagnostics report `ts(2304)` for the undeclared name.
+ *   2. The barefoot analyzer does not silently produce broken output —
+ *      it either errors via a different code or the TS guard fires first.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import ts from 'typescript'
+import path from 'path'
+import { analyzeComponent } from '../analyzer'
+
+// ---------------------------------------------------------------------------
+// Helpers — virtual TS program (mirrors reactive-type-detection.test.ts)
+// ---------------------------------------------------------------------------
+
+function getSemanticDiagnostics(source: string) {
+  const baseDir = path.resolve(__dirname)
+  const filePath = path.join(baseDir, '_unknown-signal-virtual.tsx')
+
+  const virtualFiles = new Map<string, string>()
+  virtualFiles.set(filePath, source)
+
+  const compilerOptions: ts.CompilerOptions = {
+    target: ts.ScriptTarget.Latest,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.ReactJSX,
+    jsxImportSource: 'react',
+    strict: true,
+    noEmit: true,
+    skipLibCheck: true,
+  }
+
+  const defaultHost = ts.createCompilerHost(compilerOptions)
+
+  const host: ts.CompilerHost = {
+    ...defaultHost,
+    getSourceFile(fileName, languageVersion) {
+      const resolved = path.resolve(fileName)
+      const content = virtualFiles.get(resolved)
+      if (content !== undefined) {
+        return ts.createSourceFile(fileName, content, languageVersion, true)
+      }
+      return defaultHost.getSourceFile(fileName, languageVersion)
+    },
+    fileExists(fileName) {
+      const resolved = path.resolve(fileName)
+      if (virtualFiles.has(resolved)) return true
+      return defaultHost.fileExists(fileName)
+    },
+    readFile(fileName) {
+      const resolved = path.resolve(fileName)
+      const content = virtualFiles.get(resolved)
+      if (content !== undefined) return content
+      return defaultHost.readFile(fileName)
+    },
+  }
+
+  const program = ts.createProgram([filePath], compilerOptions, host)
+  return program.getSemanticDiagnostics(program.getSourceFile(filePath)!)
+}
+
+// ---------------------------------------------------------------------------
+// Test cases
+// ---------------------------------------------------------------------------
+
+describe('BF010 UNKNOWN_SIGNAL — deletion audit', () => {
+  const undeclaredSignalSource = `
+export function Counter() {
+  return <button onClick={() => setCount(count() + 1)}>{count()}</button>
+}
+`
+
+  test('TypeScript reports undeclared-name error for signal getter', () => {
+    const diagnostics = getSemanticDiagnostics(undeclaredSignalSource)
+    // ts(2304) "Cannot find name" or ts(2552) "Cannot find name … Did you mean?"
+    const undeclared = diagnostics.filter(d => d.code === 2304 || d.code === 2552)
+    // Match on the primary identifier, not a "Did you mean?" suggestion
+    expect(undeclared.some(d =>
+      ts.flattenDiagnosticMessageText(d.messageText, '\n').startsWith("Cannot find name 'count'")
+    )).toBe(true)
+  })
+
+  test('TypeScript reports undeclared-name error for signal setter', () => {
+    const diagnostics = getSemanticDiagnostics(undeclaredSignalSource)
+    const undeclared = diagnostics.filter(d => d.code === 2304 || d.code === 2552)
+    expect(undeclared.some(d =>
+      ts.flattenDiagnosticMessageText(d.messageText, '\n').startsWith("Cannot find name 'setCount'")
+    )).toBe(true)
+  })
+
+  test('barefoot analyzer produces no errors for a valid component', () => {
+    const src = `'use client'
+import { createSignal } from '@barefootjs/client'
+export function Counter() {
+  const [count, setCount] = createSignal(0)
+  return <button onClick={() => setCount(count() + 1)}>{count()}</button>
+}
+`
+    const ctx = analyzeComponent(src, '/tmp/Counter.tsx', 'Counter')
+    expect(ctx.errors).toHaveLength(0)
+  })
+})

package/src/adapters/parsed-expr-emitter.ts

@@ -35,7 +35,7 @@
 
 import type { ParsedExpr, SortComparator, TemplatePart } from '../expression-parser'
 
-export type HigherOrderMethod = 'filter' | 'every' | 'some' | 'find' | 'findIndex'
+export type HigherOrderMethod = 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'
 
 /**
  * Non-higher-order array methods (#1443). One discriminator for the

package/src/analyzer-context.ts

@@ -52,6 +52,28 @@ export interface PendingSignalTuple {
   initialFreeIdentifiers: ReadonlySet<string>
 }
 
+/**
+ * One branch of a multi-return JSX helper function's if/else chain.
+ * `jsxReturn` is null for guard clauses that `return null`.
+ */
+export interface MultiReturnJsxBranch {
+  condition: ts.Expression
+  jsxReturn: ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment | null
+}
+
+/**
+ * Extracted control flow from a multi-return JSX helper function.
+ * Represents `if (c1) return <A/>; if (c2) return <B/>; return <C/>`
+ * as a chain of condition→JSX pairs plus an optional fallback.
+ */
+export interface MultiReturnJsxInfo {
+  branches: MultiReturnJsxBranch[]
+  fallback: ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment | null
+  params: string[]
+  /** For switch-sourced branches, the discriminant expression (e.g. `name` in `switch(name)`) */
+  switchDiscriminant?: ts.Expression
+}
+
 /**
  * Represents an if statement with a JSX return in a component function.
  */
@@ -120,6 +142,8 @@ export interface AnalyzerContext {
     jsxReturn: ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment
     params: string[]
   }>
+  /** Maps multi-return JSX helper functions for conditional inlining at call sites. */
+  jsxMultiReturnFunctions: Map<string, MultiReturnJsxInfo>
   /**
    * Maps function names to reactive-factory info (#931). A reactive factory
    * is a same-file helper whose body declares reactive primitives and
@@ -220,6 +244,7 @@ export function createAnalyzerContext(
     jsxConstants: new Map(),
     inlineableJsxConsts: new Map(),
     jsxFunctions: new Map(),
+    jsxMultiReturnFunctions: new Map(),
     reactiveFactories: new Map(),
     signalTupleRefs: new Map(),
 

package/src/analyzer.ts

@@ -1834,6 +1834,194 @@ function extractSingleJsxReturn(
   return jsxReturn
 }
 
+type JsxReturnNode = ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment
+
+/**
+ * Extract conditional branches from a multi-return JSX helper function body.
+ * Supports if/else if chains and switch statements where every branch
+ * returns JSX or null. Returns null for unsupported patterns.
+ */
+function extractMultiReturnJsxBranches(
+  body: ts.Block
+): { branches: Array<{ condition: ts.Expression; jsxReturn: JsxReturnNode | null }>; fallback: JsxReturnNode | null; switchDiscriminant?: ts.Expression } | null {
+  const branches: Array<{ condition: ts.Expression; jsxReturn: JsxReturnNode | null }> = []
+  let fallback: JsxReturnNode | null = null
+
+  const stmts = body.statements
+  for (let i = 0; i < stmts.length; i++) {
+    const stmt = stmts[i]
+
+    // if (cond) return <jsx> — collect as a branch, continue to next statement
+    if (ts.isIfStatement(stmt)) {
+      // Walk this if/else if/else chain
+      let current: ts.Statement = stmt
+      while (ts.isIfStatement(current)) {
+        const ifStmt = current
+        // Reject branches with nested control flow — only accept
+        // direct `return <jsx>` / `return null` (or a block with
+        // exactly that as its only return).
+        if (!isDirectReturnBlock(ifStmt.thenStatement)) return null
+        const jsxReturn = findJsxReturnInBlock(ifStmt.thenStatement)
+        const nullReturn = findNullReturnInBlock(ifStmt.thenStatement)
+        if (!jsxReturn && !nullReturn) return null
+
+        branches.push({ condition: ifStmt.expression, jsxReturn: jsxReturn ?? null })
+
+        if (ifStmt.elseStatement) {
+          if (ts.isIfStatement(ifStmt.elseStatement)) {
+            current = ifStmt.elseStatement
+            continue
+          }
+          // Final else block — chain is complete, return immediately
+          // to prevent subsequent statements from overwriting fallback.
+          if (!isDirectReturnBlock(ifStmt.elseStatement)) return null
+          const elseJsx = findJsxReturnInBlock(ifStmt.elseStatement)
+          if (elseJsx) {
+            fallback = elseJsx
+          } else if (!findNullReturnInBlock(ifStmt.elseStatement)) {
+            return null
+          }
+          if (branches.length === 0) return null
+          return { branches, fallback }
+        }
+        break
+      }
+      continue
+    }
+
+    // switch (expr) { case ...: return <jsx> }
+    if (ts.isSwitchStatement(stmt)) {
+      // Reject mixed if+switch bodies — prior if branches would be
+      // incorrectly treated as switch case expressions.
+      if (branches.length > 0) return null
+
+      // Only inline switches whose discriminant is side-effect-free
+      // (identifier or property access). A call expression like
+      // `switch(getValue())` would be re-evaluated per branch in the
+      // generated nested ternary.
+      if (!ts.isIdentifier(stmt.expression) && !ts.isPropertyAccessExpression(stmt.expression)) {
+        return null
+      }
+
+      // Require an explicit default clause — without one, inlining
+      // adds an implicit `else null` that changes runtime behavior.
+      const hasDefault = stmt.caseBlock.clauses.some(c => ts.isDefaultClause(c))
+      if (!hasDefault) return null
+
+      for (const clause of stmt.caseBlock.clauses) {
+        const jsxReturn = findJsxReturnInCaseClause(clause)
+        const nullReturn = findNullReturnInCaseClause(clause)
+        if (!jsxReturn && !nullReturn) return null
+
+        if (ts.isCaseClause(clause)) {
+          branches.push({
+            condition: clause.expression,
+            jsxReturn: jsxReturn ?? null,
+          })
+        } else {
+          fallback = jsxReturn ?? null
+        }
+      }
+
+      if (branches.length === 0) return null
+      return { branches, fallback, switchDiscriminant: stmt.expression }
+    }
+
+    // Trailing return <jsx> or return null — this is the fallback
+    if (ts.isReturnStatement(stmt) && stmt.expression) {
+      const expr = unwrapJsxTransparent(stmt.expression)
+      if (ts.isJsxElement(expr) || ts.isJsxSelfClosingElement(expr) || ts.isJsxFragment(expr)) {
+        fallback = expr
+      } else if (expr.kind === ts.SyntaxKind.NullKeyword) {
+        // fallback stays null
+      } else {
+        return null
+      }
+      continue
+    }
+
+    // Reject bodies with variable declarations — locals referenced in
+    // conditions or JSX would become undefined after inlining.
+    if (ts.isVariableStatement(stmt)) return null
+
+    // Any other statement type → unsupported pattern
+    return null
+  }
+
+  if (branches.length === 0) return null
+  return { branches, fallback }
+}
+
+/**
+ * Check that a statement is a direct `return ...` or a block whose
+ * only non-variable statements are a single return. Rejects nested
+ * control flow (nested if/switch/for/while) that could cause
+ * `findJsxReturnInBlock` to pick the wrong return.
+ */
+function isDirectReturnBlock(node: ts.Statement): boolean {
+  if (ts.isReturnStatement(node)) return true
+  if (ts.isBlock(node)) {
+    let returnCount = 0
+    for (const stmt of node.statements) {
+      if (ts.isReturnStatement(stmt)) {
+        returnCount++
+      } else if (
+        ts.isIfStatement(stmt) ||
+        ts.isSwitchStatement(stmt) ||
+        ts.isForStatement(stmt) ||
+        ts.isForOfStatement(stmt) ||
+        ts.isForInStatement(stmt) ||
+        ts.isWhileStatement(stmt) ||
+        ts.isDoStatement(stmt) ||
+        ts.isTryStatement(stmt)
+      ) {
+        return false
+      }
+    }
+    return returnCount === 1
+  }
+  return false
+}
+
+function findNullReturnInBlock(node: ts.Statement): boolean {
+  if (ts.isBlock(node)) {
+    for (const stmt of node.statements) {
+      if (ts.isReturnStatement(stmt) && stmt.expression) {
+        const expr = unwrapJsxTransparent(stmt.expression)
+        if (expr.kind === ts.SyntaxKind.NullKeyword) return true
+      }
+    }
+  }
+  if (ts.isReturnStatement(node) && node.expression) {
+    const expr = unwrapJsxTransparent(node.expression)
+    if (expr.kind === ts.SyntaxKind.NullKeyword) return true
+  }
+  return false
+}
+
+function findJsxReturnInCaseClause(
+  clause: ts.CaseClause | ts.DefaultClause
+): JsxReturnNode | null {
+  for (const stmt of clause.statements) {
+    if (ts.isReturnStatement(stmt) && stmt.expression) {
+      return extractJsxFromExpression(stmt.expression)
+    }
+  }
+  return null
+}
+
+function findNullReturnInCaseClause(
+  clause: ts.CaseClause | ts.DefaultClause
+): boolean {
+  for (const stmt of clause.statements) {
+    if (ts.isReturnStatement(stmt) && stmt.expression) {
+      const expr = unwrapJsxTransparent(stmt.expression)
+      if (expr.kind === ts.SyntaxKind.NullKeyword) return true
+    }
+  }
+  return false
+}
+
 /**
  * Detect a multi-return JSX helper: every top-level exit point is a
  * `return <jsx>` or `return null`, and at least one return is JSX. Used
@@ -2002,6 +2190,15 @@ function collectFunction(
         jsxReturn,
         params: node.parameters.map(p => p.name.getText(ctx.sourceFile)),
       })
+    } else {
+      const multi = extractMultiReturnJsxBranches(node.body)
+      if (multi) {
+        isJsxFunction = true
+        ctx.jsxMultiReturnFunctions.set(name, {
+          ...multi,
+          params: node.parameters.map(p => p.name.getText(ctx.sourceFile)),
+        })
+      }
     }
   }
 
@@ -2382,6 +2579,15 @@ function collectConstant(
             jsxReturn,
             params: init.parameters.map(p => p.name.getText(ctx.sourceFile)),
           })
+        } else {
+          const multi = extractMultiReturnJsxBranches(arrowBody)
+          if (multi) {
+            isJsxFunction = true
+            ctx.jsxMultiReturnFunctions.set(name, {
+              ...multi,
+              params: init.parameters.map(p => p.name.getText(ctx.sourceFile)),
+            })
+          }
         }
       } else {
         // Implicit return: () => <div>...</div>
@@ -2784,7 +2990,7 @@ function inferTypeFromValue(value: string): TypeInfo {
   if (/\.(some|every|includes)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
     return { kind: 'primitive', raw: 'boolean', primitive: 'boolean' }
   }
-  if (/\.(indexOf|findIndex|lastIndexOf)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
+  if (/\.(indexOf|findIndex|findLastIndex|lastIndexOf)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
     return { kind: 'primitive', raw: 'number', primitive: 'number' }
   }
 

package/src/errors.ts

@@ -19,27 +19,16 @@ export const ErrorCodes = {
   MISSING_USE_CLIENT: 'BF001',
   CLIENT_IMPORTING_SERVER: 'BF003',
 
-  // Signal/Memo errors (BF010-BF019)
-  UNKNOWN_SIGNAL: 'BF010',
+  // Signal/Memo errors (BF011-BF019)
   SIGNAL_OUTSIDE_COMPONENT: 'BF011',
-  INVALID_SIGNAL_USAGE: 'BF012',
 
-  // JSX errors (BF020-BF029)
-  INVALID_JSX_EXPRESSION: 'BF020',
+  // JSX errors (BF021-BF029)
   UNSUPPORTED_JSX_PATTERN: 'BF021',
-  INVALID_JSX_ATTRIBUTE: 'BF022',
   MISSING_KEY_IN_LIST: 'BF023',
   MISSING_KEY_IN_NESTED_LIST: 'BF024',
   UNSUPPORTED_DESTRUCTURE_REST: 'BF025',
 
-  // Type errors (BF030-BF039)
-  TYPE_INFERENCE_FAILED: 'BF030',
-  PROPS_TYPE_MISMATCH: 'BF031',
-
-  // Component errors (BF040-BF049)
-  COMPONENT_NOT_FOUND: 'BF040',
-  CIRCULAR_DEPENDENCY: 'BF041',
-  INVALID_COMPONENT_NAME: 'BF042',
+  // Component errors (BF043-BF049)
   PROPS_DESTRUCTURING: 'BF043',
   SIGNAL_GETTER_NOT_CALLED: 'BF044',
   JSX_IN_LOCAL_FUNCTION: 'BF045',
@@ -107,16 +96,12 @@ const errorMessages: Record<ErrorCode, string> = {
   [ErrorCodes.CLIENT_IMPORTING_SERVER]:
     'Client component cannot import server component',
 
-  [ErrorCodes.UNKNOWN_SIGNAL]: 'Unknown signal reference',
   [ErrorCodes.SIGNAL_OUTSIDE_COMPONENT]:
     'Module-level reactive declaration (createSignal / createMemo) is not allowed. ' +
     'The downstream codegen drops the declaration silently and every reference becomes a ReferenceError at SSR and at hydrate. ' +
     'Move the declaration inside a component function so each mount gets its own state.',
-  [ErrorCodes.INVALID_SIGNAL_USAGE]: 'Invalid signal usage',
 
-  [ErrorCodes.INVALID_JSX_EXPRESSION]: 'Invalid JSX expression',
   [ErrorCodes.UNSUPPORTED_JSX_PATTERN]: 'Unsupported JSX pattern',
-  [ErrorCodes.INVALID_JSX_ATTRIBUTE]: 'Invalid JSX attribute',
   [ErrorCodes.MISSING_KEY_IN_LIST]:
     'Missing key attribute in list rendering. Add a key prop for efficient updates',
   [ErrorCodes.MISSING_KEY_IN_NESTED_LIST]:
@@ -130,13 +115,6 @@ const errorMessages: Record<ErrorCode, string> = {
     // stable.
     'Computed property key in .map() callback destructure is not supported. Rewrite the callback to destructure explicit bindings (e.g., `({ a, b }) => ...`) so the compiler can rewrite references to per-item signal accessors.',
 
-  [ErrorCodes.TYPE_INFERENCE_FAILED]: 'Failed to infer type',
-  [ErrorCodes.PROPS_TYPE_MISMATCH]: 'Props type mismatch',
-
-  [ErrorCodes.COMPONENT_NOT_FOUND]: 'Component not found',
-  [ErrorCodes.CIRCULAR_DEPENDENCY]: 'Circular dependency detected',
-  [ErrorCodes.INVALID_COMPONENT_NAME]:
-    'Component name must start with uppercase letter',
   [ErrorCodes.PROPS_DESTRUCTURING]:
     'Props destructuring in function parameters breaks reactivity. Use props object directly.',
   [ErrorCodes.SIGNAL_GETTER_NOT_CALLED]:
@@ -170,7 +148,7 @@ const errorMessages: Record<ErrorCode, string> = {
     'Init-scope local referenced from template scope. The template lambda runs at module scope (via render() / renderChild()) and cannot reach init-body locals. Wrap the JSX expression in /* @client */, or lift the value to a prop or module-scope const.',
 
   [ErrorCodes.STAGE_AWAIT_IN_TEMPLATE]:
-    'AwaitExpression in template scope. The hydrate-time template lambda is synchronous; awaiting here would hang first render. Move the await into a server-side handler and pass the resolved value as a prop.',
+    'AwaitExpression in template scope. The generated template and init functions are synchronous — a bare `await` produces a SyntaxError at parse time. Move the await into the component body (before the return) or into an onMount/effect callback, and pass the resolved value to JSX.',
 
   [ErrorCodes.INLINE_JSX_CALLBACK_CAPTURE]:
     "Inline JSX-returning arrow function captures a non-module identifier. Extract the callback into a top-level 'use client' component (e.g. `function MyNode(n) { return <div/> }` then `renderNode={MyNode}`) or pass captured values via component props.",

package/src/expression-parser.ts

@@ -23,7 +23,7 @@ export type ParsedExpr =
   | { kind: 'logical'; op: '&&' | '||' | '??'; left: ParsedExpr; right: ParsedExpr }
   | { kind: 'template-literal'; parts: TemplatePart[] }
   | { kind: 'arrow-fn'; param: string; body: ParsedExpr }
-  | { kind: 'higher-order'; method: 'filter' | 'every' | 'some' | 'find' | 'findIndex'; object: ParsedExpr; param: string; predicate: ParsedExpr }
+  | { kind: 'higher-order'; method: 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'; object: ParsedExpr; param: string; predicate: ParsedExpr }
   | { kind: 'array-literal'; elements: ParsedExpr[] }
   // Non-higher-order array methods. Discriminated by `method` so each
   // adapter handles the full set via one exhaustive switch instead of
@@ -157,13 +157,12 @@ export interface SupportResult {
 // evaluate JS at runtime via hono/jsx) so this set only constrains
 // the template-language adapters.
 const UNSUPPORTED_METHODS = new Set([
-  // Higher-order array methods. Five of these (`filter`, `every`,
-  // `some`, `find`, `findIndex`) are intercepted as `higher-order`
-  // IR before reaching this gate; `map` is intercepted as an
-  // IRLoop. The rest stay refused — see #1448 Tier C for the
-  // design questions.
+  // Higher-order array methods. Seven of these (`filter`, `every`,
+  // `some`, `find`, `findIndex`, `findLast`, `findLastIndex`) are
+  // intercepted as `higher-order` IR before reaching this gate;
+  // `map` is intercepted as an IRLoop. The rest stay refused — see
+  // #1448 Tier C for the design questions.
   'filter', 'map', 'reduce', 'reduceRight', 'every', 'some',
-  'findLast', 'findLastIndex',
   'forEach', 'flatMap', 'flat',
   // #1448 Tier A — Array methods. Each method PR adds the lowering
   // (typically a new `array-method` variant or runtime helper) and
@@ -268,12 +267,12 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     const args = node.arguments.map(arg => convertNode(arg, raw))
 
     // Detect higher-order methods: arr.filter(x => pred), arr.every(x => pred), arr.some(x => pred)
-    if (callee.kind === 'member' && ['filter', 'every', 'some', 'find', 'findIndex'].includes(callee.property)) {
+    if (callee.kind === 'member' && ['filter', 'every', 'some', 'find', 'findIndex', 'findLast', 'findLastIndex'].includes(callee.property)) {
       if (args.length === 1 && args[0].kind === 'arrow-fn') {
         const arrowFn = args[0] as { kind: 'arrow-fn'; param: string; body: ParsedExpr }
         return {
           kind: 'higher-order',
-          method: callee.property as 'filter' | 'every' | 'some' | 'find' | 'findIndex',
+          method: callee.property as 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex',
           object: callee.object,
           param: arrowFn.param,
           predicate: arrowFn.body,

package/src/ir-to-client-js/compute-inlinability.ts

@@ -554,8 +554,8 @@ function collectTemplateRiskyNames(irRoot: IRNode): Set<string> {
  *  - BF061: init-scope local referenced from template scope. Same
  *    fallback shape, different binding kind.
  *
- * BF062 (cross-stage await) belongs at the Phase 1 dispatcher (await
- * is a statement-level concern); not surfaced here.
+ * BF062 (cross-stage await) is emitted at the Phase 1 dispatcher
+ * (jsx-to-ir.ts) for both child and attribute positions; not here.
  *
  * Promoted from warning to error in #1187 phase 6 — the
  * `templateRiskyNames` gate in `toLegacyInlinability` ensures only

package/src/ir-to-client-js/control-flow/plan/build-inner-loop.ts

@@ -23,7 +23,7 @@ import type {
   IRNode,
   LoopParamBinding,
 } from '../../../types'
-import { AttrValueOf } from '../../../types'
+import { AttrValueOf, pickAttrMeta } from '../../../types'
 import {
   wrapLoopParamAsAccessor,
   attrValueToString,
@@ -67,8 +67,6 @@ import type {
   InnerLoopText,
   InnerLoopsPlan,
 } from './inner-loop'
-import { toHtmlAttrName } from '../../utils'
-import { isBooleanAttr } from '../../../html-constants'
 
 export interface BuildInnerLoopsArgs {
   levels: readonly DepthLevel[]
@@ -200,14 +198,11 @@ function buildReactiveEmit(
 
   const reactiveAttrs: InnerLoopReactiveAttr[] = inner.bindings.reactiveAttrs.map(attr => {
     const wrapped = wrapLoopParamAsAccessor(wrapOuter(attr.expression), inner.param, inner.paramBindings)
-    const isStyleObject = attr.attrName === 'style' && /^\s*\{/.test(attr.expression)
     return {
       slotId: attr.childSlotId,
-      attrName: toHtmlAttrName(attr.attrName),
+      attrName: attr.attrName,
       wrappedExpression: wrapped,
-      isStyleObject,
-      isBoolean: isBooleanAttr(attr.attrName),
-      presenceOrUndefined: !!attr.presenceOrUndefined,
+      meta: pickAttrMeta(attr),
     }
   })
 

package/src/ir-to-client-js/control-flow/plan/inner-loop.ts

@@ -12,6 +12,7 @@
 
 import type { LoopChildEvent } from '../../types'
 import type {
+  AttrMeta,
   IRLoopChildComponent,
   LoopParamBinding,
 } from '../../../types'
@@ -48,29 +49,17 @@ export interface InnerLoopText {
  * etc. — every element in the loop body whose attribute reads a signal
  * (or the loop param) gets its own per-item `createEffect`.
  *
- * `attrName` is already in DOM-spelling (kebab for SVG presentation
- * attrs, `class` for `className`) so the stringifier can emit
- * `setAttribute(attrName, ...)` directly.
+ * `attrName` is in JSX form (e.g. `className`, not `class`) — the
+ * stringifier delegates to `emitAttrUpdate` which maps to HTML spelling.
  */
 export interface InnerLoopReactiveAttr {
   slotId: string
-  /** DOM attribute name (already mapped via `toHtmlAttrName`). */
+  /** JSX attribute name (mapped to HTML spelling by `emitAttrUpdate`). */
   attrName: string
   /** Already wrapped via inner+outer loop param accessor. */
   wrappedExpression: string
-  /** True for `style={{...}}` object literals — routed through `styleToCss`. */
-  isStyleObject: boolean
-  /** True for boolean DOM attributes (`disabled`, `checked`, ...). */
-  isBoolean: boolean
-  /**
-   * True for `attr={expr || undefined}` patterns where the compiler
-   * stripped the `|| undefined` and now stores the bare expression.
-   * The emitter must use a truthy check (not `!= null`) — otherwise a
-   * concrete `false` value writes `data-attr="false"` instead of
-   * removing the attribute. Surfaced by the calendar demo's
-   * `data-outside={day.isOutside || undefined}` on a nested map root.
-   */
-  presenceOrUndefined: boolean
+  /** Pre-copied attr metadata used by `emitAttrUpdate`. */
+  meta: AttrMeta
 }
 
 /**