@barefootjs/erb 0.18.4 → 0.18.7

package/src/adapter/erb-adapter.ts

@@ -88,10 +88,15 @@ import {
   queryHrefArgs,
   isValidHelperId,
   sortComparatorFromArrow,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  resolveStaticLoopSource,
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr, isExplicitStringCall } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher, LoopBindingPathSegment } from '@barefootjs/jsx'
-import { BF_SLOT, BF_COND, BF_REGION } from '@barefootjs/shared'
+import { BF_SLOT, BF_COND, BF_REGION, escapeHtml } from '@barefootjs/shared'
 
 import type { ErbRenderCtx } from './lib/types.ts'
 import { ERB_PRIMITIVE_EMIT_MAP } from './lib/constants.ts'
@@ -107,6 +112,7 @@ import {
   collectRootScopeNodes,
 } from './lib/ir-scope.ts'
 import { renderSortMethod, renderSortEval } from './expr/array-method.ts'
+import { staticValueToRuby } from './lib/static-value.ts'
 import { ErbFilterEmitter, ErbTopLevelEmitter } from './expr/emitters.ts'
 import type { ErbEmitContext, ErbSpreadContext, ErbMemoContext } from './emit-context.ts'
 import {
@@ -177,6 +183,14 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
   private options: Required<ErbAdapterOptions>
   private errors: CompilerError[] = []
   private inLoop: boolean = false
+  /**
+   * `IRLoop.depth` of the loop currently being rendered (save/restore
+   * around `renderChildren(loop.children)`, mirroring `inLoop` above).
+   * `renderAttributes` reads this to derive the `key` → `data-key`/
+   * `data-key-N` suffix — the depth is IR-computed (jsx-to-ir.ts), not
+   * re-derived here (#2168 nested-loop-outer-binding).
+   */
+  private currentLoopKeyDepth = 0
   /**
    * SolidJS-style props identifier (`function(props: P)`) and the
    * analyzer-extracted prop names. Stashed at `generate()` entry so the
@@ -499,7 +513,9 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
   }
 
   emitText(node: IRText): string {
-    return node.value
+    // IRText carries the entity-DECODED value (Phase 1 decodes JSX
+    // character references); re-escape for direct HTML emission.
+    return escapeHtml(node.value)
   }
 
   emitExpression(node: IRExpression): string {
@@ -626,7 +642,8 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
   renderElement(element: IRElement): string {
     const tag = element.tag
     const attrs = this.renderAttributes(element)
-    const children = this.renderChildren(element.children)
+    const dangerousHtml = this.renderDangerousInnerHtml(element)
+    const children = dangerousHtml !== null ? dangerousHtml : this.renderChildren(element.children)
 
     let hydrationAttrs = ''
     if (element.needsScope) {
@@ -663,6 +680,28 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`
   }
 
+  /**
+   * `dangerouslySetInnerHTML={{ __html: '...' }}` (#2207) — see the Blade
+   * adapter's identical helper for the full rationale. `null` means the
+   * attribute is absent (caller falls through to normal `renderChildren`);
+   * a non-`null` string (possibly `''`) replaces the children outright.
+   */
+  private renderDangerousInnerHtml(element: IRElement): string | null {
+    const resolution = resolveDangerousInnerHtml(element)
+    if (!resolution) return null
+    if (resolution.kind === 'dynamic') {
+      this.errors.push(dangerousInnerHtmlDiagnostic(resolution.expr, resolution.loc))
+      return ''
+    }
+    const violation = dangerousInnerHtmlMetacharViolation(resolution.html, this.name)
+    if (violation) {
+      const attr = element.attrs.find(isDangerousInnerHtmlAttr)!
+      this.errors.push(dangerousInnerHtmlDiagnostic(`{ __html: ${JSON.stringify(resolution.html)} }`, attr.loc, violation))
+      return ''
+    }
+    return resolution.html
+  }
+
   // ===========================================================================
   // Expression Rendering
   // ===========================================================================
@@ -675,7 +714,12 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       return ''
     }
 
-    const rubyExpr = this.convertExpressionToRuby(expr.expr)
+    // Thread the IR-carried `.parsed` tree through (mirrors go-template's
+    // `convertExpressionToGo(expr.expr, classify, expr.parsed)`) so a
+    // resolved bare-identifier `.map`/`.filter`/… callback
+    // (`resolveCallbackMethodFunctionReferences`, #2206) isn't lost to a
+    // fresh, unresolved re-parse of the raw string.
+    const rubyExpr = this.convertExpressionToRuby(expr.expr, expr.parsed)
 
     // A bare read of the `children` prop (`{children}` / `{props.children}`,
     // optionally `?? fallback`) is pre-rendered HTML — captured via the
@@ -859,7 +903,23 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     // reproduces identically with a non-destructured param, so it is NOT a
     // destructure-lowering limitation. Surface BF101 honestly instead of
     // emitting a loop bound that silently crashes / renders empty.
-    if (loop.arrayParsed?.kind === 'identifier') {
+    // #2208: a loop source that is a fully-static array literal — either
+    // inline (`[{ label: 'Alpha' }, ...].map(...)`) or a bare identifier
+    // bound to a FUNCTION-scope local const whose initializer has no
+    // prop/signal/function-call dependency — inlines as a native Ruby
+    // array/hash literal below, the same way a module-scope const's value
+    // is already seeded. Previously the INLINE shape wasn't gated here at
+    // all (this check only ever inspected an `identifier` array source) —
+    // it still ended up refusing via `convertExpressionToRuby`'s generic
+    // `unsupported` object-literal path (BF101, "Expression not
+    // supported"), which is what this loop-specific check now also does
+    // deliberately, up front, for both shapes.
+    const staticItems = resolveStaticLoopSource(loop.arrayParsed, this.localConstants, {
+      isNameShadowed: name => this.loopBoundNames.has(name),
+    })
+    const staticArray = staticItems !== null ? staticValueToRuby(staticItems) : null
+
+    if (staticArray === null && loop.arrayParsed?.kind === 'identifier') {
       const arrayName = loop.arrayParsed.name
       const isUnresolvableLocalConst =
         !this.loopBoundNames.has(arrayName) &&
@@ -874,7 +934,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       }
     }
 
-    const rawArray = this.convertExpressionToRuby(loop.array)
+    const rawArray = staticArray ?? this.convertExpressionToRuby(loop.array)
     // Apply sort if present: hoist the (possibly sorted) array into a Ruby
     // local BEFORE the index loop, so both the loop bound and the per-item
     // lookup reference the same materialised array — otherwise a sort
@@ -896,17 +956,22 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     // whole body (children + key + filter) so a same-named loop variable
     // isn't replaced by the const literal / a vars-Hash read. Ref-counted
     // for nested loops; released after the body lines are assembled below.
-    const loopBound = loop.iterationShape === 'keys'
-      ? [param]
-      : supportableDestructure
-        ? ['__bf_item', ...(loop.paramBindings ?? []).map(b => b.name), loop.index ?? '_i']
-        : [param, loop.index ?? '_i']
+    const loopBound = loop.objectIteration === 'entries'
+      ? [param, loop.index ?? '_k']
+      : loop.objectIteration === 'keys' || loop.objectIteration === 'values' || loop.iterationShape === 'keys'
+        ? [param]
+        : supportableDestructure
+          ? ['__bf_item', ...(loop.paramBindings ?? []).map(b => b.name), loop.index ?? '_i']
+          : [param, loop.index ?? '_i']
     for (const n of loopBound) {
       this.loopBoundNames.set(n, (this.loopBoundNames.get(n) ?? 0) + 1)
     }
     const prevInLoop = this.inLoop
     this.inLoop = true
+    const prevLoopKeyDepth = this.currentLoopKeyDepth
+    this.currentLoopKeyDepth = loop.depth
     const renderedChildren = this.renderChildren(loop.children)
+    this.currentLoopKeyDepth = prevLoopKeyDepth
     this.inLoop = prevInLoop
 
     // Whole-item conditional: prepend an always-present
@@ -966,6 +1031,21 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       }
       lines.push(`<%- ${sortedHoist} = ${sorted} -%>`)
     }
+    if (loop.objectIteration) {
+      // `objectIteration` (#2168 object-entries-map): Ruby's `Hash`
+      // preserves the source object's insertion order natively (unlike
+      // Go's `map`/Perl's hash), so this bypasses the index-range form
+      // above entirely and uses Ruby's own native block-param binding
+      // (`each_pair`/`each_key`/`each_value`) — no `array[index]` lookup
+      // needed, since the block directly yields the key/value.
+      const method = loop.objectIteration === 'entries'
+        ? 'each_pair'
+        : loop.objectIteration === 'keys' ? 'each_key' : 'each_value'
+      const blockParams = loop.objectIteration === 'entries'
+        ? `${rubyLocal(loop.index ?? param)}, ${rubyLocal(param)}`
+        : rubyLocal(param)
+      lines.push(`<%- ${array}.${method} do |${blockParams}| -%>`)
+    } else {
     lines.push(`<%- (0...${array}.length).each do |${indexVar}| -%>`)
     if (loop.iterationShape !== 'keys') {
       if (supportableDestructure) {
@@ -1004,19 +1084,37 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
         lines.push(`<%- ${rubyLocal(param)} = ${array}[${indexVar}] -%>`)
       }
     }
+    }
 
     // Handle filter().map() pattern by wrapping children in if-condition
     if (loop.filterPredicate) {
       let filterCond: string
       if (loop.filterPredicate.predicate) {
-        // The loop's own (possibly destructure-adjusted) param name IS the
-        // filter predicate's parameter for rendering purposes — pass it
-        // straight through as the filter emitter's bound param. Ruby's
-        // named-block-param model makes the Mojo original's regex
-        // `$filterParam → $loopParam` rename unnecessary here: the emitter
-        // just renders every reference to the predicate's own arrow
-        // parameter AS `param` from the start.
-        filterCond = this.renderRubyFilterExpr(loop.filterPredicate.predicate, param)
+        // The filter predicate's identifiers were parsed against the
+        // FILTER callback's own param (`loop.filterPredicate.param`), which
+        // can differ from the loop's rendered Ruby local (`param`, the MAP
+        // callback's param) whenever the two are named differently —
+        // `todos.filter(t => t.done).map(todo => ...)` (#2245). Ruby's
+        // named-block-param model means there's no Mojo-style regex
+        // `$filterParam → $loopParam` TEXT rewrite to do, but the
+        // DISTINCTION it encoded still matters: match identifiers against
+        // the filter's own param, while EMITTING the loop's actual bound
+        // local — `ErbFilterEmitter`'s `renderParamAs` carries that split.
+        // `filterPredicate.param` is only ever a bare identifier in
+        // practice (`extractFilterPredicate` in jsx-to-ir.ts refuses a
+        // destructured filter param outright, leaving `filterPredicate`
+        // unset entirely rather than populating it with pattern text — see
+        // its docstring), but guard defensively instead of relying on that
+        // invariant: a pattern-text param (leading `[`/`{` — the same
+        // prefix check `destructureLoopParam`/#2238 use, NOT an identifier
+        // regex, which would misclassify a Unicode param name) falls back
+        // to `param`, matching pre-#2245 behavior byte-for-byte.
+        const filterOwnParam = loop.filterPredicate.param
+        const matchParam =
+          filterOwnParam && !filterOwnParam.startsWith('[') && !filterOwnParam.startsWith('{')
+            ? filterOwnParam
+            : param
+        filterCond = this.renderRubyFilterExpr(loop.filterPredicate.predicate, matchParam, undefined, rubyLocal(param))
       } else {
         filterCond = 'true'
       }
@@ -1095,10 +1193,46 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
 
   renderComponent(comp: IRComponent): string {
     const propParts: string[] = []
+    // Named JSX-valued props OTHER than the reserved `children`
+    // (`header={<strong>Title</strong>}`, #2168 jsx-element-prop) each get
+    // their own buffer-slice capture, prepended to the final returned
+    // string below — same mechanism as the reserved children capture,
+    // just keyed by the prop's own name instead of `children`. Unlike the
+    // reserved `children` value (which the child template reads back
+    // through a structural bypass, `isChildrenValueExpr`), a named slot
+    // is read by the child through the GENERIC `bf.h(v[:name])`
+    // text-expression path — there's no name to special-case there, since
+    // any prop name is possible. So the captured HTML is wrapped in
+    // `bf.backend.mark_raw(...)` here (`BarefootJS::SafeString`,
+    // `barefoot_js.rb`) and `Context#h` unwraps it to skip re-escaping —
+    // giving ERB the same "value carries its own safety" bypass Twig's
+    // `Markup` / Kolon's `mark_raw` get from their auto-escaping `{{ }}`.
+    const namedSlotCaptures: string[] = []
     for (const p of comp.props) {
       // Skip callback props (onXxx) and `ref` — both are client-only for
       // SSR (Hono renders neither; the client JS wires them at hydration).
       if ((p.name.match(/^on[A-Z]/) || p.name === 'ref') && p.value.kind === 'expression') continue
+      if (p.value.kind === 'jsx-children' && p.name !== 'children') {
+        const prevInLoop = this.inLoop
+        this.inLoop = false
+        const slotBody = this.renderChildren(p.value.children)
+        this.inLoop = prevInLoop
+        // Purely counter-based — NOT derived from `p.name` or `comp.slotId`.
+        // A JSX prop name can contain characters (`data-slot`) that aren't
+        // valid in a Ruby local variable name, and `comp.slotId` alone
+        // would collide across two named-slot props on the same component
+        // invocation (unlike the reserved children slot, there's only ever
+        // one of those per invocation).
+        const suffix = `${this.childrenCaptureCounter++}`
+        const lenVar = `__bf_len_${suffix}`
+        const rawVar = `__bf_praw_${suffix}`
+        const capVar = `__bf_prop_${suffix}`
+        namedSlotCaptures.push(
+          `<% ${lenVar} = _erbout.length %>${slotBody}<% ${rawVar} = _erbout.slice!(${lenVar}..); ${capVar} = bf.backend.mark_raw(${rawVar}) %>`,
+        )
+        propParts.push(`${rubySymbolKey(p.name)} ${capVar}`)
+        continue
+      }
       const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name)
       if (lowered) propParts.push(lowered)
     }
@@ -1138,10 +1272,10 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       const lenVar = `__bf_len_${suffix}`
       const capVar = `__bf_children_${suffix}`
       const propsHash = `{ ${[...propParts, `children: ${capVar}`].join(', ')} }`
-      return `<% ${lenVar} = _erbout.length %>${childrenBody}<% ${capVar} = _erbout.slice!(${lenVar}..) %><%= bf.render_child('${tplName}', ${propsHash}) %>`
+      return `${namedSlotCaptures.join('')}<% ${lenVar} = _erbout.length %>${childrenBody}<% ${capVar} = _erbout.slice!(${lenVar}..) %><%= bf.render_child('${tplName}', ${propsHash}) %>`
     }
     const propsHash = propParts.length > 0 ? `{ ${propParts.join(', ')} }` : '{}'
-    return `<%= bf.render_child('${tplName}', ${propsHash}) %>`
+    return `${namedSlotCaptures.join('')}<%= bf.render_child('${tplName}', ${propsHash}) %>`
   }
 
   private childrenCaptureCounter = 0
@@ -1227,7 +1361,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
    * Routed through the shared dispatcher.
    */
   private readonly elementAttrEmitter: AttrValueEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       // `style={{ … }}` object literal → a CSS string with dynamic values
       // interpolated, instead of refusing the bare object with BF101.
@@ -1442,6 +1576,12 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       // the unsupported-expression lowering is never reached for a
       // deferred predicate (no BF101 / BF102).
       if (attr.clientOnly) continue
+      // `dangerouslySetInnerHTML` never renders as an HTML attribute — it's
+      // handled by `renderDangerousInnerHtml` instead, which replaces the
+      // element's children. Skip it here so its `{ __html: ... }` object
+      // literal never reaches the generic object-literal BF101 refusal
+      // (which would double-report alongside the purpose-built one).
+      if (isDangerousInnerHtmlAttr(attr)) continue
       // Rewrite JSX special-prop names to their HTML-attribute
       // counterparts. `className` → `class`; `key` → `data-key` matches
       // the canonical Hono attribute name the client runtime reconciles
@@ -1450,7 +1590,10 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       // attribute-emit time.
       let attrName: string
       if (attr.name === 'className') attrName = 'class'
-      else if (attr.name === 'key') attrName = 'data-key'
+      else if (attr.name === 'key') {
+        const depth = this.currentLoopKeyDepth
+        attrName = depth > 0 ? `data-key-${depth}` : 'data-key'
+      }
       else attrName = attr.name
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName)
       if (lowered) parts.push(lowered)
@@ -1493,6 +1636,14 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     expr: ParsedExpr,
     param: string,
     localVarMap: Map<string, string> = new Map(),
+    // See `ErbFilterEmitter`'s constructor docstring (#2245): the Ruby
+    // local to EMIT for a reference to `param`, when it differs from
+    // `param` itself (the loop-gating call site passes the filter
+    // callback's own param as `param` — the name to MATCH — and this as
+    // the loop's actual bound local). Every other caller omits it, so
+    // `ErbFilterEmitter`'s own default (`rubyLocal(param)`) applies and
+    // match/render stay the same value, unchanged from before #2245.
+    renderParamAs?: string,
   ): string {
     return emitParsedExpr(
       expr,
@@ -1502,6 +1653,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
         n => this.isLoopBoundName(n),
         n => this._isStringValueName(n),
         (message, reason) => this._recordExprBF101(message, reason),
+        renderParamAs,
       ),
     )
   }

package/src/adapter/expr/array-method.ts

@@ -125,6 +125,15 @@ export function renderArrayMethod(
       const recv = emit(object)
       return `bf.trim(${recv})`
     }
+    case 'trimStart':
+    case 'trimEnd': {
+      // `.trimStart()` / `.trimEnd()` — the one-sided siblings of
+      // `.trim()` (#2183 follow-up). Dedicated `bf.trim_start` /
+      // `bf.trim_end` helpers, not `bf.trim` with a flag.
+      const fn = method === 'trimStart' ? 'trim_start' : 'trim_end'
+      const recv = emit(object)
+      return `bf.${fn}(${recv})`
+    }
     case 'toFixed': {
       // `.toFixed(digits?)` — Number → fixed-decimal string. `bf.to_fixed`
       // mirrors JS rounding + zero-padding (default 0 digits).
@@ -178,6 +187,19 @@ export function renderArrayMethod(
       const newS = emit(args[1])
       return `bf.replace(${recv}, ${oldS}, ${newS})`
     }
+    case 'replaceAll': {
+      // `.replaceAll(old, new)` — string-pattern form, EVERY occurrence,
+      // via the dedicated `bf.replace_all` helper (NOT Ruby's `gsub`,
+      // which interprets `\1` / `\&` backreference syntax in the
+      // replacement even for a literal string pattern — that would
+      // diverge from `.replace`'s literal splice above). The
+      // regex-pattern form is refused upstream at the parser, same as
+      // `.replace`. See #2182.
+      const recv = emit(object)
+      const oldS = emit(args[0])
+      const newS = emit(args[1])
+      return `bf.replace_all(${recv}, ${oldS}, ${newS})`
+    }
     case 'repeat': {
       // `.repeat(n)` — string repeated `n` times. The `bf.repeat` helper
       // wraps Ruby's `*` string-repeat operator with the same

package/src/adapter/expr/emitters.ts

@@ -106,10 +106,23 @@ export class ErbFilterEmitter implements ParsedExprEmitter {
     // construction stays possible without an adapter; a missing hook keeps
     // the old silent-degrade emit.
     private readonly onUnsupported?: (message: string, reason?: string) => void,
+    // The Ruby local to EMIT for a reference matching `this.param` — as
+    // opposed to `this.param` itself, which is only the name to MATCH.
+    // These two are the SAME value everywhere in this file except the
+    // `filter().map()` loop-gating `<if>` (erb-adapter.ts's `renderLoop`,
+    // #2245): `todos.filter(t => t.done).map(todo => ...)` parses the
+    // predicate against the filter callback's OWN param (`t`), but the
+    // Ruby local actually bound by the loop is the MAP callback's param
+    // (`todo`) — Ruby has no per-callback block scope there (unlike the
+    // real nested `.select { |t| ... }` block `callbackMethod` below
+    // builds, where match and render are naturally the same param).
+    // Defaults to `rubyLocal(this.param)`, i.e. every other construction
+    // site is unaffected.
+    private readonly renderParamAs: string = rubyLocal(param),
   ) {}
 
   identifier(name: string): string {
-    if (name === this.param) return rubyLocal(this.param)
+    if (name === this.param) return this.renderParamAs
     const signal = this.localVarMap.get(name)
     if (signal) return `v[${rubySymbolLiteral(signal)}]`
     if (this.isLoopBoundOuter(name)) return rubyLocal(name)
@@ -123,11 +136,19 @@ export class ErbFilterEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `.length` needs no special higher-order form here — see the file
     // docstring's simplification (2): `.select { ... }.length` just works
     // in Ruby, unlike Perl's anonymous-arrayref `scalar(@{...})` detour.
     if (property === 'length') return `${emit(object)}.length`
+    // A `?.`-written access (`user?.name`, #2168 optional-chaining-prop):
+    // Ruby's own `nil[:key]` raises `NoMethodError` (unlike Hash#[] on a
+    // present Hash) — `&.` is Ruby's native safe-navigation operator, and
+    // `&.[](...)` is its explicit-method form for indexing rather than a
+    // dotted method call. Only guards the single written `?.` hop, not a
+    // JS-style whole-chain short-circuit — see the `ParsedExpr` `member`
+    // variant's docstring for the multi-hop caveat.
+    if (optional) return `${emit(object)}&.[](${rubySymbolLiteral(property)})`
     return `${emit(object)}[${rubySymbolLiteral(property)}]`
   }
 
@@ -323,7 +344,7 @@ export class ErbTopLevelEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `props.x` flattens to the `v[:x]` the ERB SSR caller seeds each prop
     // under (props arrive as vars-Hash entries, not a nested `props` Hash).
     if (object.kind === 'identifier' && object.name === 'props') {
@@ -339,6 +360,11 @@ export class ErbTopLevelEmitter implements ParsedExprEmitter {
     }
     const obj = emit(object)
     if (property === 'length') return `${obj}.length`
+    // A `?.`-written access (`user?.name`, #2168 optional-chaining-prop):
+    // see `ErbFilterEmitter.member()`'s comment above for why `&.[](...)`
+    // (not a dotted `&.name`) is the right safe-nav form for a Hash-keyed
+    // prop, and for the single-hop caveat.
+    if (optional) return `${obj}&.[](${rubySymbolLiteral(property)})`
     return `${obj}[${rubySymbolLiteral(property)}]`
   }
 

package/src/adapter/lib/constants.ts

@@ -24,6 +24,9 @@ export const ERB_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'Math.floor':     { arity: 1, emit: (args) => `bf.floor(${args[0]})` },
   'Math.ceil':      { arity: 1, emit: (args) => `bf.ceil(${args[0]})` },
   'Math.round':     { arity: 1, emit: (args) => `bf.round(${args[0]})` },
+  'Math.min':       { arity: 2, emit: (args) => `bf.min(${args[0]}, ${args[1]})` },
+  'Math.max':       { arity: 2, emit: (args) => `bf.max(${args[0]}, ${args[1]})` },
+  'Math.abs':       { arity: 1, emit: (args) => `bf.abs(${args[0]})` },
 }
 
 /**

package/src/adapter/lib/static-value.ts

@@ -0,0 +1,43 @@
+/**
+ * Serialize a compile-time-evaluated JS value (`@barefootjs/jsx`'s
+ * `evaluateStaticLiteral`/`resolveStaticLoopSource`, #2208) into a native
+ * Ruby literal. Used to inline a fully-static loop source (an inline array
+ * literal, or a function-scope local const with a static initializer)
+ * directly in the loop-bound expression, rather than requiring a bound
+ * template variable.
+ *
+ * Hash keys render as symbols (`label: 'Alpha'`) to match `item[:label]`,
+ * this adapter's existing member-access convention (`rubyLocal`'s
+ * companion, `rubySymbolKey`/`rubySymbolLiteral`).
+ *
+ * Returns `null` for a value this adapter can't represent as a literal —
+ * the caller falls back to its existing BF101 refusal instead of guessing.
+ */
+
+import { rubyStringLiteral, rubySymbolKey } from './ruby-naming.ts'
+
+export function staticValueToRuby(value: unknown): string | null {
+  if (value === null || value === undefined) return 'nil'
+  if (typeof value === 'boolean') return value ? 'true' : 'false'
+  if (typeof value === 'number') return String(value)
+  if (typeof value === 'string') return rubyStringLiteral(value)
+  if (Array.isArray(value)) {
+    const items: string[] = []
+    for (const el of value) {
+      const serialized = staticValueToRuby(el)
+      if (serialized === null) return null
+      items.push(serialized)
+    }
+    return `[${items.join(', ')}]`
+  }
+  if (typeof value === 'object') {
+    const entries: string[] = []
+    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+      const serialized = staticValueToRuby(val)
+      if (serialized === null) return null
+      entries.push(`${rubySymbolKey(key)} ${serialized}`)
+    }
+    return `{ ${entries.join(', ')} }`
+  }
+  return null
+}

package/src/conformance-pins.ts

@@ -12,16 +12,17 @@
 import type { ConformancePins } from '@barefootjs/jsx'
 
 export const conformancePins: ConformancePins = {
-  // Sibling-imported child component in a loop body: emits a
-  // cross-template call needing separate registration. BF103 makes
-  // the requirement loud (same as mojo).
-  'static-array-children': [{ code: 'BF103', severity: 'error' }],
-  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-  // call it inside a keyed `.map`. Same BF103 surface as the
-  // synthetic `static-array-children` above — pinned at adapter
-  // level so the shared-component corpus stays adapter-neutral.
-  'todo-app': [{ code: 'BF103', severity: 'error' }],
-  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // `todo-app` / `todo-app-ssr` no longer pinned (#2205) — the conformance
+  // harness now passes `siblingTemplatesRegistered: true` for fixtures with
+  // sibling `components`, matching `bf build`'s real semantics, so the
+  // BF103 loop-body cross-template check no longer fires spuriously. (Both
+  // fixtures are still skipped on this adapter via `render-divergences.ts`
+  // — #2209 — for an unrelated signal-seeding gap.)
+  // `static-array-children` no longer pinned (#2208) — `items`'s
+  // array-literal initializer is now recognized as fully-static
+  // (`resolveStaticLoopSource`) and inlined as a native Ruby array/hash
+  // literal in the loop-bound expression, the same way a module-scope
+  // const's value is already seeded.
   // `static-array-from-props` / `static-array-from-props-with-component`:
   // the `.map(([emoji, users]) => …)` / `.map(([id, t]) => …)` callback is
   // a plain array-index destructure (the `.filter(...)` runs on a
@@ -45,8 +46,9 @@ export const conformancePins: ConformancePins = {
   'static-array-from-props': [
     { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2087' },
   ],
+  // BF103 (imported child in the loop body) no longer fires now that the
+  // conformance harness passes `siblingTemplatesRegistered: true` (#2205).
   'static-array-from-props-with-component': [
-    { code: 'BF103', severity: 'error' },
     { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2087' },
   ],
   // #2087 Phase B: `isLowerableLoopDestructure` now admits every fixed-
@@ -91,21 +93,14 @@ export const conformancePins: ConformancePins = {
   // `/* @client */` keyed-map slot-id elision contract only (same as
   // `todo-app`), not a render or BF101 gap.
   //
-  // #2073 follow-up: a function-reference `.map(format)` callback has no
-  // arrow body to serialize — not a CALLBACK_METHODS shape — so the
-  // UNSUPPORTED_METHODS gate (shared `@barefootjs/jsx` code) refuses it
-  // with BF101 rather than emitting a broken template. Same pin as
-  // mojo/xslate.
-  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `dangerouslySetInnerHTML` requires a
-  // deliberate raw-HTML (unescaped) output affordance in the target
-  // template language. No lowering exists yet, so the compiler refuses
-  // the shape loudly instead of emitting entity-escaped markup that
-  // silently renders tags as text.
-  'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `.replaceAll` has no lowering yet —
-  // only first-occurrence `.replace` is wired to the runtime helpers.
-  // Refused with BF101 rather than reusing the first-only lowering,
-  // which would silently change semantics.
-  'string-replaceall': [{ code: 'BF101', severity: 'error' }],
+  // `array-map-function-reference` no longer pinned — a bare-identifier
+  // `.map(format)` callback now resolves one hop to its declaration
+  // (`resolveCallbackMethodFunctionReferences`, #2206), the same mechanism
+  // #2090 established for `.sort(fnref)`.
+  // `dangerous-inner-html` no longer pinned — a compile-time string-literal
+  // `dangerouslySetInnerHTML={{ __html: '...' }}` is spliced directly into
+  // the template as trusted raw text (`resolveDangerousInnerHtml`, #2207).
+  // A dynamic/signal-derived value still refuses with BF101 — see the
+  // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2215).
+  'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2215' }],
 }

package/src/render-divergences.ts

@@ -15,22 +15,8 @@
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
-  'html-entity-text':
-    '`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes',
-  'optional-chaining-prop':
-    '`user?.name ?? …` on an object prop: the Ruby render exits 1 (optional chaining into a Hash prop has no lowering)',
-  'math-methods':
-    'Math.min/max/abs over a signal render empty (only Math.floor is in the template-primitive registry)',
-  'static-attr-escape':
-    'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  'object-entries-map':
-    '`Object.entries(prop).map(([k, v]) => …)` renders but its loop item keys diverge from the reference serialisation',
-  'nested-loop-outer-binding':
-    'nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`',
-  'jsx-element-prop':
-    'a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped',
-  'string-slice':
-    '`.slice()` on a STRING lowers through the array slice helper and renders "[]" instead of the substring',
-  'string-trim-sided':
-    '`.trimStart()` / `.trimEnd()` render empty (no lowering; only both-sides `.trim` is wired)',
+  // `todo-app` / `todo-app-ssr` no longer diverge (#2209) — the shared
+  // `evaluateSignalInit` (`@barefootjs/jsx`, sandboxed real-JS evaluation
+  // instead of a fixed regex-shape catalogue) now correctly seeds `todos`
+  // from `(props.initialTodos ?? []).map(t => ({ ...t, editing: false }))`.
 }