@barefootjs/erb 0.18.5 → 0.19.0

package/dist/index.js

@@ -187308,7 +187308,12 @@ import {
   prepareLoweringMatchers,
   queryHrefArgs,
   isValidHelperId,
-  sortComparatorFromArrow as sortComparatorFromArrow2
+  sortComparatorFromArrow as sortComparatorFromArrow2,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  resolveStaticLoopSource
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -187693,6 +187698,39 @@ function renderFlatMethod(recv, depth, emit) {
   return `bf.flat(${recv}, ${d})`;
 }
 
+// src/adapter/lib/static-value.ts
+function staticValueToRuby(value) {
+  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 = [];
+    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 = [];
+    for (const [key, val] of Object.entries(value)) {
+      const serialized = staticValueToRuby(val);
+      if (serialized === null)
+        return null;
+      entries.push(`${rubySymbolKey(key)} ${serialized}`);
+    }
+    return `{ ${entries.join(", ")} }`;
+  }
+  return null;
+}
+
 // src/adapter/expr/emitters.ts
 import {
   emitParsedExpr,
@@ -187738,16 +187776,18 @@ class ErbFilterEmitter {
   isLoopBoundOuter;
   isStringName;
   onUnsupported;
-  constructor(param, localVarMap, isLoopBoundOuter = () => false, isStringName = unusedIsStringName, onUnsupported) {
+  renderParamAs;
+  constructor(param, localVarMap, isLoopBoundOuter = () => false, isStringName = unusedIsStringName, onUnsupported, renderParamAs = rubyLocal(param)) {
     this.param = param;
     this.localVarMap = localVarMap;
     this.isLoopBoundOuter = isLoopBoundOuter;
     this.isStringName = isStringName;
     this.onUnsupported = onUnsupported;
+    this.renderParamAs = renderParamAs;
   }
   identifier(name) {
     if (name === this.param)
-      return rubyLocal(this.param);
+      return this.renderParamAs;
     const signal = this.localVarMap.get(name);
     if (signal)
       return `v[${rubySymbolLiteral(signal)}]`;
@@ -188299,7 +188339,7 @@ function collectBooleanTypedProps(ir) {
   return new Set(ir.metadata.propsParams.filter((prop) => prop.type?.primitive === "boolean" || prop.type?.raw === "boolean").map((prop) => prop.name));
 }
 function collectNullableOptionalProps(ir) {
-  return new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && p.type?.kind !== "primitive").map((p) => p.name));
+  return new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && (p.type?.kind !== "primitive" || p.optional)).map((p) => p.name));
 }
 function collectStringValueNames(ir) {
   const names = new Set;
@@ -188547,7 +188587,8 @@ class ErbAdapter extends BaseAdapter {
   renderElement(element) {
     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) {
       hydrationAttrs += ` ${this.renderScopeMarker("")}`;
@@ -188582,6 +188623,22 @@ class ErbAdapter extends BaseAdapter {
     }
     return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
   }
+  renderDangerousInnerHtml(element) {
+    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;
+  }
   renderExpression(expr) {
     if (expr.clientOnly) {
       if (expr.slotId) {
@@ -188589,7 +188646,7 @@ class ErbAdapter extends BaseAdapter {
       }
       return "";
     }
-    const rubyExpr = this.convertExpressionToRuby(expr.expr);
+    const rubyExpr = this.convertExpressionToRuby(expr.expr, expr.parsed);
     const wrapped = this.isChildrenValueExpr(expr) ? rubyExpr : `bf.h(${rubyExpr})`;
     if (expr.slotId) {
       return `<%= bf.text_start("${expr.slotId}") %><%= ${wrapped} %><%= bf.text_end %>`;
@@ -188698,7 +188755,11 @@ ${whenTrue}
         }
       });
     }
-    if (loop.arrayParsed?.kind === "identifier") {
+    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) && this.resolveModuleStringConst(arrayName) === null && this.resolveLiteralConst(arrayName) === null && this.localConstants.some((c) => c.name === arrayName && !c.isModule);
       if (isUnresolvableLocalConst) {
@@ -188708,7 +188769,7 @@ ${whenTrue}
 3. Precompute the value server-side and pass it in as a prop.`);
       }
     }
-    const rawArray = this.convertExpressionToRuby(loop.array);
+    const rawArray = staticArray ?? this.convertExpressionToRuby(loop.array);
     let sortedHoist = null;
     let array = rawArray;
     if (loop.sortComparator) {
@@ -188788,7 +188849,9 @@ ${renderedChildren}` : renderedChildren;
     if (loop.filterPredicate) {
       let filterCond;
       if (loop.filterPredicate.predicate) {
-        filterCond = this.renderRubyFilterExpr(loop.filterPredicate.predicate, param);
+        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";
       }
@@ -189009,6 +189072,8 @@ ${children}`;
     for (const attr of element.attrs) {
       if (attr.clientOnly)
         continue;
+      if (isDangerousInnerHtmlAttr(attr))
+        continue;
       let attrName;
       if (attr.name === "className")
         attrName = "class";
@@ -189032,8 +189097,8 @@ ${children}`;
   renderCondMarker(condId) {
     return `${BF_COND}="${condId}"`;
   }
-  renderRubyFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr2(expr, new ErbFilterEmitter(param, localVarMap, (n) => this.isLoopBoundName(n), (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason)));
+  renderRubyFilterExpr(expr, param, localVarMap = new Map, renderParamAs) {
+    return emitParsedExpr2(expr, new ErbFilterEmitter(param, localVarMap, (n) => this.isLoopBoundName(n), (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason), renderParamAs));
   }
   convertTemplateLiteralPartsToRuby(literalParts) {
     const parts = [];
@@ -189194,21 +189259,16 @@ Options:
 var erbAdapter = new ErbAdapter;
 // src/conformance-pins.ts
 var conformancePins = {
-  "static-array-children": [{ code: "BF103", severity: "error" }],
-  "todo-app": [{ code: "BF103", severity: "error" }],
-  "todo-app-ssr": [{ code: "BF103", severity: "error" }],
   "static-array-from-props": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2087" }
   ],
   "static-array-from-props-with-component": [
-    { code: "BF103", severity: "error" },
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2087" }
   ],
   "filter-nested-find-predicate": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
-  "array-map-function-reference": [{ code: "BF101", severity: "error" }],
-  "dangerous-inner-html": [{ code: "BF101", severity: "error" }]
+  "dangerous-inner-html-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2215" }]
 };
 // src/render-divergences.ts
 var renderDivergences = {};

package/dist/render-divergences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAAsB,CAAA"}
+{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAK/B,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/erb",
-  "version": "0.18.5",
+  "version": "0.19.0",
   "description": "ERB (Embedded Ruby) adapter for BarefootJS — compiles IR to .erb templates and ships the Ruby rendering backend; runs under any Rack app (Sinatra, Rails)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,14 +54,14 @@
     "directory": "packages/adapter-erb"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.18.5"
+    "@barefootjs/shared": "0.19.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.18.5",
+    "@barefootjs/jsx": "0.19.0",
     "typescript": "^5.0.0"
   }
 }

package/src/__tests__/erb-adapter.test.ts

@@ -70,6 +70,23 @@ runAdapterConformanceTests({
     // #1467 Phase 2e: same `/* @client */` keyed-map elision (data-table).
     'data-table',
   ]),
+  skipDataPoints: new Set<string>([
+    // #2255 — Ruby String#length counts codepoints; JS counts UTF-16
+    // code units, so a surrogate-pair character is 2 in JS, 1 here.
+    'string-length-text:astral',
+    // #2260 — controlled boolean props: the SSR seed evaluates only the
+    // static fallback of `props.X ?? internal()` chains.
+    'toggle:gen:pressed:true',
+    'switch:gen:checked:true',
+    'checkbox:gen:checked:true',
+    // #2261 — invalid dynamic CSS value kept (escaped) where the oracle
+    // drops the property.
+    'style-object-dynamic:gen:color:markup',
+    // #2262 — dynamic `.flat` depth 0/negative: the unflattened nested
+    // result stringifies Ruby-style instead of the JS join.
+    'array-flat-dynamic-depth:gen:depth:zero',
+    'array-flat-dynamic-depth:gen:depth:negative',
+  ]),
   onRenderError: (err, id) => {
     if (err instanceof ErbNotAvailableError) {
       console.log(`Skipping [${id}]: ${err.message}`)
@@ -305,6 +322,127 @@ export { Slot }
   })
 })
 
+describe('ErbAdapter - filter().map() predicate matches the FILTER param, not the loop param (#2245)', () => {
+  // `todos.filter(t => t.done).map(todo => ...)`: the predicate's own `t`
+  // used to be matched against the LOOP's (map's) param `todo` inside
+  // `ErbFilterEmitter.identifier()`, so every reference to `t` inside the
+  // predicate fell to the `v[:t]` vars-Hash fallback instead of resolving
+  // to the loop-bound `todo` local — `v[:t]` is never seeded, and real
+  // Ruby raises `NoMethodError: undefined method '[]' for nil` on
+  // `v[:t][:done]` at render time (masked in the shipped `todo-app-ssr`
+  // corpus by its `'all'`-default filter short-circuiting the buggy
+  // branch away — see `filter-wrapper-props-reachable`'s docstring).
+  const DIFFERENTLY_NAMED_SOURCE = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+
+type Todo = { id: number; text: string; done: boolean }
+
+export function TodoList(props: { initialTodos?: Todo[] }) {
+  const [todos] = createSignal<Todo[]>(props.initialTodos ?? [])
+  return (
+    <ul>
+      {todos().filter(t => !t.done).map(todo => (
+        <li key={todo.id}>{todo.text}</li>
+      ))}
+    </ul>
+  )
+}
+`
+
+  function compileToIR(source: string): ComponentIR {
+    const result = compileJSX(source.trimStart(), 'test.tsx', {
+      adapter: new ErbAdapter(),
+      outputIR: true,
+    })
+    const irFile = result.files.find(f => f.type === 'ir')
+    if (!irFile) throw new Error('No IR output')
+    return JSON.parse(irFile.content) as ComponentIR
+  }
+
+  test('predicate reference lowers through the loop-bound local, never the filter-param vars-Hash fallback', () => {
+    const ir = compileToIR(DIFFERENTLY_NAMED_SOURCE)
+    const { template } = new ErbAdapter().generate(ir)
+    // The loop-gating `<if>` must reference the loop's actual bound Ruby
+    // local (`todo[:done]`, from the MAP callback's param)...
+    expect(template).toContain('todo[:done]')
+    // ...never the filter callback's own param name resolved as an
+    // (unseeded) vars-Hash key — the literal pre-fix bug.
+    expect(template).not.toContain('v[:t]')
+  })
+
+  test('same-named filter/map params render byte-identically to the pre-#2245 form (regression pin)', () => {
+    const sameNamedSource = DIFFERENTLY_NAMED_SOURCE.replace(
+      'filter(t => !t.done)',
+      'filter(todo => !todo.done)',
+    )
+    const ir = compileToIR(sameNamedSource)
+    const { template } = new ErbAdapter().generate(ir)
+    expect(template).toContain('<%- if bf.truthy?(!bf.truthy?(todo[:done])) -%>')
+  })
+
+  test('real Ruby render: reachable predicate on differently-named params renders correctly (pre-fix NoMethodError pin)', async () => {
+    // `filter` defaults to `'active'` (never `'all'`) so the predicate
+    // branch referencing `t.done` is actually REACHABLE at render time —
+    // an `'all'`-style short-circuiting default is exactly what hid this
+    // bug in the shipped `todo-app-ssr` fixture. Block-body predicate
+    // (folded to one expression by #2040's `foldBlockToExpr` +
+    // `predicateTernaryToLogical`) matches the real `TodoAppSSR.tsx` shape.
+    const source = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+
+type Todo = { id: number; text: string; done: boolean }
+type Filter = 'all' | 'active'
+
+export function TodoList(props: { initialTodos?: Todo[] }) {
+  const [todos] = createSignal<Todo[]>(props.initialTodos ?? [])
+  const [filter] = createSignal<Filter>('active')
+  return (
+    <ul>
+      {todos().filter(t => {
+        const f = filter()
+        if (f === 'active') return !t.done
+        return true
+      }).map(todo => (
+        <li key={todo.id}>{todo.text}</li>
+      ))}
+    </ul>
+  )
+}
+`
+    let html: string
+    try {
+      html = await renderErbComponent({
+        source: source.trimStart(),
+        adapter: new ErbAdapter(),
+        props: {
+          initialTodos: [
+            { id: 1, text: 'Eat breakfast', done: true },
+            { id: 2, text: 'Write tests', done: false },
+          ],
+        },
+      })
+    } catch (err) {
+      if (err instanceof ErbNotAvailableError) {
+        console.log('Skipping #2245 filter-param e2e: ruby/erb not available')
+        return
+      }
+      throw err
+    }
+    // Pre-fix: real Ruby raises `NoMethodError: undefined method '[]' for
+    // nil` evaluating `v[:t][:done]` — `renderErbComponent` surfaces that
+    // as a thrown "ruby render failed" error, so a `NoMethodError` string
+    // anywhere in a caught error would fail this test outright rather than
+    // reaching these assertions. Post-fix: only the not-done todo (id 2)
+    // survives the 'active' filter.
+    expect(html).not.toContain('Eat breakfast')
+    expect(html).toContain('Write tests')
+    expect(html).toContain('data-key="2"')
+    expect(html).not.toContain('data-key="1"')
+  })
+})
+
 describe('ErbAdapter - named-slot capture identifier safety (#2168 jsx-element-prop)', () => {
   // A JSX-valued prop under a hyphenated name (`data-slot`, a valid JSX
   // attribute name) must not leak into the buffer-slice capture's local

package/src/adapter/erb-adapter.ts

@@ -88,6 +88,11 @@ 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'
@@ -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 {
@@ -636,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) {
@@ -673,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
   // ===========================================================================
@@ -685,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
@@ -869,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) &&
@@ -884,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
@@ -1040,14 +1090,31 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     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'
       }
@@ -1509,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
@@ -1563,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,
@@ -1572,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/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)

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/adapter/props/prop-classes.ts

@@ -43,10 +43,11 @@ export function collectBooleanTypedProps(ir: ComponentIR): Set<string> {
  * omission). A prop WITH a destructure default (`value = ''`) is never
  * `nil` in the body and must stay unconditional, so it is excluded. Mirrors
  * the Go adapter's nillable-field guard: there the witness is the resolved
- * `interface{}` field type; here it is the absence of a default. Excludes
- * concrete-primitive types (`string`/`number`/`boolean`) to match the Go
- * adapter's scope, which guards only nillable fields and leaves concrete
- * fields unconditional.
+ * `interface{}` field type; here it is the absence of a default. A REQUIRED
+ * concrete-primitive prop (`string`/`number`/`boolean`) is excluded — the
+ * caller always supplies it, matching the Go adapter's unconditional
+ * concrete fields — but an OPTIONAL primitive is presence-uncertain and
+ * stays guarded (#2259).
  */
 export function collectNullableOptionalProps(ir: ComponentIR): Set<string> {
   return new Set(
@@ -55,7 +56,7 @@ export function collectNullableOptionalProps(ir: ComponentIR): Set<string> {
         p =>
           p.defaultValue === undefined &&
           !p.isRest &&
-          p.type?.kind !== 'primitive',
+          (p.type?.kind !== 'primitive' || p.optional),
       )
       .map(p => p.name),
   )