@barefootjs/go-template 0.18.5 → 0.19.0

package/src/adapter/go-template-adapter.ts

@@ -67,6 +67,13 @@ import {
   envSignalReaderFor,
   computeSsrSeedPlan,
   isStringConcatBinary,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  resolveStaticLoopSource,
+  collectLoopBoundNames,
+  evaluateStaticLiteral,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
 import { BF_REGION, escapeHtml } from '@barefootjs/shared'
@@ -111,6 +118,8 @@ import { collectRootScopeNodes } from "./lib/ir-scope.ts"
 import { GO_TEMPLATE_PRIMITIVES } from "./lib/constants.ts"
 import { CompileState } from "./lib/compile-state.ts"
 import { hasClientInteractivity, findNestedComponents } from "./analysis/component-tree.ts"
+import { analyzeBakeableStaticChildLoop, scalarToGoLiteral, type BakedStaticChildLoop } from "./analysis/static-child-loop-bake.ts"
+import { analyzeBakeableStaticElementLoop } from "./analysis/static-element-loop-bake.ts"
 import type { GoEmitContext } from "./emit-context.ts"
 import { inlineLocalHelperCall } from "./expr/helper-inline.ts"
 import { lowerRegisteredCall } from "./expr/url-builder.ts"
@@ -126,7 +135,7 @@ import { lowerCtorExpr } from "./memo/ctor-lowering.ts"
 import { resolveBlockBodyMemoModuleConst } from "./memo/memo-value.ts"
 import { computeMemoInitialValue, computeMemoInitialValueOrNull, filterArmEarlierSiblingRefs } from "./memo/memo-compute.ts"
 import { collectSpreadSlots, buildSpreadInitializer } from "./spread/spread-codegen.ts"
-import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames } from "./props/prop-types.ts"
+import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames, collectNullishConsumedPropNames, collectOmittableAttrConsumedPropNames, NULLISH_SCALAR_GO_TYPES } from "./props/prop-types.ts"
 import { collectStringValueNames } from "./props/prop-classes.ts"
 
 export type { GoTemplateAdapterOptions } from "./lib/types.ts"
@@ -215,8 +224,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       this.convertExpressionToGo(jsExpr, out, preParsed),
     convertConditionToGo: (jsCondition, preParsed) =>
       this.convertConditionToGo(jsCondition, preParsed),
-    extractPropNameFromInitialValue: (initialValue) => this.extractPropNameFromInitialValue(initialValue),
-    extractPropFallback: (initialValue) => this.extractPropFallback(initialValue),
+    extractPropNameFromInitialValue: (initialValue, preParsed) =>
+      this.extractPropNameFromInitialValue(initialValue, preParsed),
+    extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
   }
 
@@ -226,6 +236,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   private inLoop: boolean = false
+  /**
+   * Memoized `analyzeBakeableStaticChildLoop` result per loop marker id
+   * (#2208). Consulted from three sites that all need the SAME verdict for
+   * the SAME loop — the `renderLoop` gate, the Input struct's field list,
+   * and the constructor's per-item construction. `renderLoop`'s gate runs
+   * during `generate()`'s render pass; the other two run during
+   * `generateTypes()`'s constructor-generation pass, which `generate()`
+   * also invokes internally partway through — so this cache is reset (in
+   * `primeCompileState`, not here) between those two passes too. Agreement
+   * across all three sites is therefore guaranteed by `analyzeBakeable-
+   * StaticChildLoop` being a deterministic pure function of the (re-primed)
+   * per-compile state, not by one shared memo spanning every read; the
+   * cache's value is avoiding redundant recomputation WITHIN the pass that
+   * populated it, not correctness across passes.
+   */
+  private bakedStaticChildLoopCache = new Map<string, BakedStaticChildLoop | null>()
   private loopParamStack: string[] = []
   /**
    * Stack of `IRLoop.depth` values (innermost last), pushed/popped around
@@ -272,6 +298,30 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * alone (#2087 Phase B).
    */
   private loopRestExcludeStack: Array<Map<string, { parent: string; excludeKeys: string[] }>> = []
+  /**
+   * Active per-item static bindings for a #2224 unrolled plain-element loop
+   * (`renderUnrolledStaticElementLoop`) — innermost last, so a nested static
+   * unroll inside another one resolves against its own item, not an outer
+   * one's. When non-empty, `convertExpressionToGo`'s top-of-function check
+   * resolves EVERY expression against the innermost entry's item via
+   * `evaluateStaticLiteral` and returns a literal Go value instead of
+   * descending into the normal `.Field`-style dot-context lowering — there
+   * is no real `{{range}}` establishing that context during an unroll, so
+   * `identifier()`'s `currentLoopParam → '.'` branch would otherwise resolve
+   * against the WRONG (enclosing) dot context. `analyzeBakeableStaticElementLoop`
+   * has already verified every expression in the body resolves this way for
+   * every item, so the fallback failure branch below is a defensive
+   * invariant check, not a real code path.
+   */
+  private staticLoopItemStack: Array<{ param: string; item: unknown }> = []
+  /**
+   * Set by the `convertExpressionToGo` override above when a
+   * `staticLoopItemStack` entry is active but the current expression fails
+   * to resolve against it — should never happen (see that check's comment),
+   * but `renderUnrolledStaticElementLoop` asserts this stays `false` after
+   * every item render rather than silently shipping a `""` sentinel.
+   */
+  private staticLoopBakeFailed = false
 
   /**
    * Cross-component child shapes, keyed by child component name. Populated via
@@ -307,6 +357,32 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.state.restPropsName = ir.metadata.restPropsName ?? null
     this.state.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
     this.state.localConstants = ir.metadata.localConstants ?? []
+    // #2208 fable review: every name a `.map()`/`.filter()` loop callback
+    // binds as its item/index parameter anywhere in the component. Static
+    // loop-source resolution (`getBakedStaticChildLoop` /
+    // `analyzeBakeableStaticChildLoop`) must never resolve a const whose
+    // name a DIFFERENT, enclosing loop's own callback param shadows.
+    // Computed here (not from live render-time stack state) because this
+    // must agree across THREE call sites, two of which (`generateTypes`'s
+    // Input-struct + constructor generation) run OUTSIDE the live
+    // `renderLoop` tree-walk that would otherwise track shadowing via
+    // stack push/pop — same coarse-but-safe mitigation as #2212.
+    this.state.staticLoopSourceBoundNames = collectLoopBoundNames(ir)
+    // #2208 fable re-review: the adapter instance is a reused singleton —
+    // `generate()` calls this once per component, but `generateTypes()` is
+    // ALSO a standalone public entry point (the Go conformance harness in
+    // `test-render.ts` calls it directly on an already-`generate()`d
+    // adapter for a sibling/child IR). Resetting the bake cache HERE, not
+    // just in `generate()`, closes that door too: a stale entry keyed by a
+    // marker id that collides with a PREVIOUS component (marker ids
+    // restart at `l0` per component) would otherwise either silently
+    // suppress this fix or leak that other component's baked data into
+    // this one's constructor. `generate()` itself calls `generateTypes()`
+    // partway through — re-priming (and so re-clearing the cache) there is
+    // harmless: `analyzeBakeableStaticChildLoop` is deterministic over
+    // identically-primed state, so a cache miss on the second pass just
+    // recomputes the same answer.
+    this.bakedStaticChildLoopCache = new Map()
     this.state.localHelperNames = new Set(
       this.state.localConstants.filter(c => !c.isModule && c.containsArrow).map(c => c.name),
     )
@@ -331,6 +407,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
     this.state.loweringMatchers = prepareLoweringMatchers(ir.metadata)
     augmentInheritedPropAccesses(ir)
+    // The consumed-prop sets feed `resolvePropGoType`'s interface{} flips
+    // (#2248/#2259) and `collectNillablePropNames` is derived from
+    // `resolvePropGoType`, which also consults the local type tables — so
+    // build the tables first and populate all three HERE, where both entry
+    // points share them. Computing them only in `generate()` left the
+    // standalone `generateTypes()` entry (sibling IRs in the conformance
+    // harness) resolving structs against another component's sets, and
+    // `generate()` itself computing nillability against the PREVIOUS
+    // compile's type tables.
+    this.buildLocalTypeTables(ir, ir.metadata.componentName)
+    this.state.nullishConsumedPropNames = collectNullishConsumedPropNames(this.emitCtx, ir)
+    this.state.omittableAttrConsumedPropNames = collectOmittableAttrConsumedPropNames(this.emitCtx, ir)
+    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir)
   }
 
   /** Generate template output for a component. */
@@ -341,7 +430,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.state.templateVarCounter = 0
     this.state.pendingChildrenDefines = []
     this.primeCompileState(ir)
-    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir)
     this.state.stringValueNames = collectStringValueNames(ir)
 
     // Surface loop-body usages of sibling-imported components (see
@@ -856,6 +944,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
 
     for (const nested of inputNested) {
+      // #2208: a static loop whose array source is itself fully-static
+      // (baked directly in the constructor — see `generateNewPropsFunction`)
+      // has no caller-supplied data to accept; the Input struct carries no
+      // field for it at all (there was never a working `in.<Name>s` path
+      // for this shape before this fix — it refused with BF101).
+      if (nested.loopMarkerId && this.getBakedStaticChildLoop(
+        nested.loopMarkerId,
+        nested,
+        nested.loopArrayParsed,
+        nested.loopParam,
+        nested.loopKey,
+      )) continue
       lines.push(`\t${nested.name}s []${nested.name}Input`)
     }
 
@@ -1074,6 +1174,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Static nested WITHOUT body children.
     for (const nested of staticWithoutBody) {
       const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      // #2208: a static loop whose ARRAY SOURCE is itself fully-static
+      // (`const items = [{ label: 'Alpha' }, ...]`) has no caller input to
+      // wait for — every item's props/data-key are already known at
+      // compile time. Bake them directly instead of ranging over
+      // `in.<Name>s` (which stays empty forever for this shape, since the
+      // loop-source gate above only lets this fixture through BECAUSE it's
+      // baked here).
+      const baked = nested.loopMarkerId
+        ? this.getBakedStaticChildLoop(
+            nested.loopMarkerId,
+            nested,
+            nested.loopArrayParsed,
+            nested.loopParam,
+            nested.loopKey,
+          )
+        : null
+      if (baked) {
+        lines.push(`\t${varName} := make([]${nested.name}Props, ${baked.items.length})`)
+        baked.items.forEach((item, i) => {
+          const fields = item.inputFields.map(f => `${f.goField}: ${f.goValue}`).join(', ')
+          lines.push(`\t${varName}[${i}] = New${nested.name}Props(${nested.name}Input{${fields}})`)
+          lines.push(`\t${varName}[${i}].BfParent = scopeID`)
+          lines.push(`\t${varName}[${i}].BfMount = "${nested.slotId}"`)
+          if (item.dataKey !== null) {
+            lines.push(`\t${varName}[${i}].BfDataKey = ${JSON.stringify(item.dataKey)}`)
+          }
+        })
+        lines.push('')
+        continue
+      }
       lines.push(`\t${varName} := make([]${nested.name}Props, len(in.${nested.name}s))`)
       lines.push(`\tfor i, item := range in.${nested.name}s {`)
       lines.push(`\t\t${varName}[i] = New${nested.name}Props(item)`)
@@ -1096,10 +1226,26 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // from an omitted field, so it also fires on the type's zero value.
     const propFallbackVars = this.collectPropFallbackVars(ir)
     for (const [, info] of propFallbackVars) {
-      lines.push(`\t${info.varName} := in.${info.fieldName}`)
-      lines.push(`\tif ${info.varName} == ${info.zeroLiteral} {`)
-      lines.push(`\t\t${info.varName} = ${info.goFallback}`)
-      lines.push(`\t}`)
+      if (info.assertType) {
+        // Nillable-lowered prop (#2248): the `interface{}` field makes
+        // "absent" (nil) distinguishable from an explicit `''`/`0`/`false`,
+        // so the fallback applies ONLY on nil — JS `??` semantics. Numbers
+        // coerce through the runtime (an untyped `Size: 3` literal boxes as
+        // int even into a float64-shaped prop); string/bool assert directly.
+        const deref =
+          info.assertType === 'int' ? `bf.ToInt(in.${info.fieldName})`
+          : info.assertType === 'float64' ? `bf.ToFloat64(in.${info.fieldName})`
+          : `in.${info.fieldName}.(${info.assertType})`
+        lines.push(`\tvar ${info.varName} ${info.assertType} = ${info.goFallback}`)
+        lines.push(`\tif in.${info.fieldName} != nil {`)
+        lines.push(`\t\t${info.varName} = ${deref}`)
+        lines.push(`\t}`)
+      } else {
+        lines.push(`\t${info.varName} := in.${info.fieldName}`)
+        lines.push(`\tif ${info.varName} == ${info.zeroLiteral} {`)
+        lines.push(`\t\t${info.varName} = ${info.goFallback}`)
+        lines.push(`\t}`)
+      }
     }
     if (propFallbackVars.size > 0) lines.push('')
 
@@ -1208,7 +1354,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (propFieldNames.has(fieldName)) continue
       // `props.X ?? N` reuses the hoisted fallback var so signal and memo share
       // one value.
-      const fallbackMatch = this.extractPropFallback(signal.initialValue)
+      const fallbackMatch = this.extractPropFallback(signal.initialValue, signal.parsed)
       const hoisted = fallbackMatch ? propFallbackVars.get(fallbackMatch.propName) : undefined
       if (hoisted) {
         lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
@@ -2598,8 +2744,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       localTaken.add(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`)
     }
 
+    const propTypeOverrides = buildPropTypeOverrides(this.emitCtx, ir)
     for (const signal of ir.metadata.signals) {
-      const match = this.extractPropFallback(signal.initialValue)
+      const match = this.extractPropFallback(signal.initialValue, signal.parsed)
       if (!match) continue
       if (result.has(match.propName)) continue
       const param = ir.metadata.propsParams.find(p => p.name === match.propName)
@@ -2607,6 +2754,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // A destructure default already wins via applyGoFallback below.
       if (goPropDefault(param.defaultValue) !== null) continue
       const fieldName = capitalizeFieldName(match.propName)
+      // A `??`-consumed optional scalar lowered to `interface{}` (#2248) —
+      // detected off the SAME `resolvePropGoType` pipeline the struct
+      // generators use, so this can't drift from the emitted field type. The
+      // concrete pre-flip type is what the hoisted local materializes as.
+      const concreteType = propTypeOverrides.get(param.name) ?? typeInfoToGo(this.emitCtx, param.type, param.defaultValue)
+      const nullishLowered =
+        NULLISH_SCALAR_GO_TYPES.has(concreteType) &&
+        resolvePropGoType(this.emitCtx, param, propTypeOverrides) === 'interface{}'
       // Pick the zero literal based on the fallback's literal shape. Bool
       // fallbacks (`?? true`) hoist against the `false` zero — the same Go-zero
       // conflation the int / string cases accept: the caller can't distinguish
@@ -2625,8 +2780,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // (`?? 0`, `?? ''`, `?? false`, `?? 0.0`). Compare against the computed
       // zeroLiteral so spelling variants like `0.0` collapse to the same skip
       // as `0`.
-      if (match.goFallback === zeroLiteral) continue
-      if (zeroLiteral === '0' && Number(match.goFallback) === 0) continue
+      //
+      // NOT a no-op for a nillable-lowered prop (#2248): its `interface{}`
+      // field can be nil, and the typed hoisted local is what downstream
+      // consumers (`Count: size`, memo env maps) assign from — a nil
+      // interface into a concrete field is a compile error, so the local
+      // must exist even when the fallback equals the zero value.
+      if (!nullishLowered) {
+        if (match.goFallback === zeroLiteral) continue
+        if (zeroLiteral === '0' && Number(match.goFallback) === 0) continue
+      }
       // The JSX-side identifier is the natural local name; suffix with `_` if it
       // collides with a Go keyword or a local we already emit.
       let varName = match.propName
@@ -2634,21 +2797,43 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         varName += '_'
       }
       localTaken.add(varName)
-      result.set(match.propName, { varName, fieldName, goFallback: match.goFallback, zeroLiteral })
+      result.set(match.propName, {
+        varName,
+        fieldName,
+        goFallback: match.goFallback,
+        zeroLiteral,
+        ...(nullishLowered ? { assertType: concreteType } : {}),
+      })
     }
     return result
   }
 
   /**
-   * Parse a signal-time initial value of the form `props.X ?? <literal>` into
-   * the source prop name and the Go-formatted fallback. Returns null when the
-   * expression isn't a `??` against a property access on `propsObjectName`, or
-   * the fallback isn't a simple literal `goPropDefault` can translate.
+   * Parse a signal-time initial value of the form `props.X ?? <literal>` —
+   * or, for destructured components, `x ?? <literal>` — into the source prop
+   * name and the Go-formatted fallback. Returns null when the expression
+   * isn't that shape or the fallback isn't a simple literal `goPropDefault`
+   * can translate.
+   *
+   * `preParsed` (the signal's best-effort `ParsedExpr`) is matched
+   * structurally when available; the regex handles only the props-object
+   * member form for callers without a tree (memo computations). A bare
+   * identifier can shadow a same-named prop (loop/callback params — the
+   * `collectNullishConsumedPropNames` limitation class), so every caller
+   * validates the returned name against `ir.metadata.propsParams`.
    *
    * Keeps the original prop reference (not just the resolved value) so
    * caller-supplied non-zero inputs are honoured.
    */
-  private extractPropFallback(initialValue: string): { propName: string; goFallback: string } | null {
+  private extractPropFallback(
+    initialValue: string,
+    preParsed?: ParsedExpr,
+  ): { propName: string; goFallback: string } | null {
+    const structural = preParsed ? this.extractPropFallbackFromParsed(preParsed) : null
+    if (structural) return structural
+
+    // Regex fallback for callers without a tree (memo computation strings)
+    // and for props-object shapes the structural match doesn't model.
     if (!this.state.propsObjectName) return null
     const trimmed = initialValue.trim()
     const name = this.state.propsObjectName
@@ -2662,12 +2847,64 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return { propName: m[1], goFallback }
   }
 
+  /** Structural half of {@link extractPropFallback}. */
+  private extractPropFallbackFromParsed(
+    preParsed: ParsedExpr,
+  ): { propName: string; goFallback: string } | null {
+    if (preParsed.kind !== 'logical' || preParsed.op !== '??') return null
+    const left = preParsed.left
+    const propName =
+      left.kind === 'identifier' && !this.state.propsObjectName
+        ? left.name
+        : left.kind === 'member' &&
+            !left.computed &&
+            left.object.kind === 'identifier' &&
+            left.object.name === this.state.propsObjectName
+          ? left.property
+          : null
+    if (!propName) return null
+    // A negative fallback (`?? -1`) parses as unary minus around a number
+    // literal, not a literal.
+    let right = preParsed.right
+    let negate = ''
+    if (right.kind === 'unary' && right.op === '-') {
+      negate = '-'
+      right = right.argument
+    }
+    if (right.kind !== 'literal') return null
+    if (negate && right.literalType !== 'number') return null
+    // A string fallback is already the decoded value — quote it directly;
+    // routing it through `goPropDefault` would strip JSON.stringify's outer
+    // quotes and escape the body a second time (`"` → `\\\"`).
+    if (right.literalType === 'string') {
+      return { propName, goFallback: JSON.stringify(right.value) }
+    }
+    // Numbers keep their source spelling when available (`raw` is only
+    // populated for numbers); booleans/null stringify losslessly.
+    const goFallback = goPropDefault(negate + (right.raw ?? String(right.value)))
+    if (goFallback === null) return null
+    return { propName, goFallback }
+  }
+
   /**
    * Extract the prop name from a signal's `props.xxx`-pattern initialValue,
    * e.g. `"props.initial ?? 0"` → `"initial"`, `"props.checked"` → `"checked"`.
+   * For destructured components (`propsObjectName` null) the same shapes are
+   * matched structurally on `preParsed` with an identifier left operand
+   * (`size ?? 0` → `"size"`); callers validate the name against
+   * `propsParams`, which filters shadowing locals.
    */
-  private extractPropNameFromInitialValue(initialValue: string): string | null {
-    if (!this.state.propsObjectName) return null
+  private extractPropNameFromInitialValue(initialValue: string, preParsed?: ParsedExpr): string | null {
+    if (!this.state.propsObjectName) {
+      if (
+        preParsed?.kind === 'logical' &&
+        (preParsed.op === '??' || preParsed.op === '||') &&
+        preParsed.left.kind === 'identifier'
+      ) {
+        return preParsed.left.name
+      }
+      return null
+    }
     const trimmed = initialValue.trim()
     const name = this.state.propsObjectName
 
@@ -2757,7 +2994,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   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) {
@@ -2792,6 +3030,28 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     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
+  }
+
   renderExpression(expr: IRExpression): string {
     // @client directive: render a comment marker; ClientJS evaluates the
     // expression via updateClientMarker().
@@ -3386,9 +3646,54 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const wrapLeft = wrapIfMultiToken(emit(left))
     const wrapRight = wrapIfMultiToken(emit(right))
     if (op === '&&') return `and ${wrapLeft} ${wrapRight}`
+    // `??` on a nillable prop needs true JS nullish semantics (#2248): Go's
+    // `or` is truthiness-based, so `{{or .Label "Default"}}` falls back on a
+    // present-but-empty `""` — JS `??` keeps it. `bf_nullish` tests nil-ness
+    // only. Non-nillable operands keep `or`: their concrete Go type can't
+    // represent "absent" at all, so `or` and `??` are indistinguishable there.
+    if (op === '??' && this.nillablePropNameOf(left) !== null) {
+      return `bf_nullish ${wrapLeft} ${wrapRight}`
+    }
     return `or ${wrapLeft} ${wrapRight}`
   }
 
+  /**
+   * The nillable-prop name a `??` left operand refers to, or null. Matches
+   * the two prop-reference shapes (`label` destructured, `props.label`
+   * object-style) against `nullishConsumedPropNames ∩ nillablePropNames`.
+   *
+   * The intersection matters: `nillablePropNames` alone OVERAPPROXIMATES —
+   * it is collected before local type aliases are registered, so an
+   * alias-typed prop (`placement?: TooltipPlacement`) can sit in the set
+   * while its emitted struct field is the concrete alias type. On such a
+   * concrete field "absent" is invisible (the zero value), so the
+   * truthiness-based `or` is the correct approximation and `bf_nullish`
+   * would wrongly KEEP the zero value (e.g. Tooltip's
+   * `placementClasses[props.placement ?? 'top']` would resolve to no
+   * class for an omitted placement). Requiring `nullishConsumedPropNames`
+   * membership pins the
+   * gate to props the `??` analysis actually saw — the same set that drives
+   * the `interface{}` flip in `resolvePropGoType`.
+   */
+  private nillablePropNameOf(expr: ParsedExpr): string | null {
+    let name: string | null = null
+    if (expr.kind === 'identifier') {
+      name = expr.name
+    } else if (
+      expr.kind === 'member' &&
+      !expr.computed &&
+      expr.object.kind === 'identifier' &&
+      expr.object.name === this.state.propsObjectName
+    ) {
+      name = expr.property
+    }
+    return name !== null &&
+      this.state.nullishConsumedPropNames.has(name) &&
+      this.state.nillablePropNames.has(name)
+      ? name
+      : null
+  }
+
   // JSX-level ternaries (`{expr ? a : b}`) are handled at the IR level as
   // IRConditional (via convertConditionToGo → renderConditionExpr). This method
   // is only reached for ternaries nested inside other ParsedExpr trees (e.g.
@@ -4101,10 +4406,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
   /**
    * Render a predicate for use in Go template `{{if}}` conditions, substituting
-   * the loop parameter (e.g. `t` in `t.done`) with dot notation.
+   * the loop parameter (e.g. `t` in `t.done`) with dot notation. `datumField`
+   * (#2228) is the wrapper struct's datum-carrying field name (e.g. `"Todo"`)
+   * for a loop whose body is a child component — see `wrapperDatumField` — so
+   * `t.done` qualifies through it (`.Todo.Done`) instead of the bare `.Done`
+   * `html/template` can't resolve on the wrapper Props struct. `undefined` for
+   * a non-wrapper (plain-element-body) loop, where `.` already IS the datum.
    */
-  private renderPredicateCondition(pred: ParsedExpr, param: string): string {
-    return this.renderFilterExpr(pred, param)
+  private renderPredicateCondition(pred: ParsedExpr, param: string, datumField?: string | null): string {
+    return this.renderFilterExpr(pred, param, new Map(), datumField ?? undefined)
   }
 
   /** Whether an expression needs parentheses when used in and/or. */
@@ -4138,12 +4448,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * Render a filter predicate expression (`t => !t.done`, or a block body
    * normalized to one — #2040). `localVarMap` is a vestigial empty default kept
    * on the recursion; block-body locals are now inlined upstream, so no caller
-   * populates it.
+   * populates it. `datumField` (#2228) qualifies a bare `param` reference (and
+   * `param.xxx` member/call access) through the wrapper struct's
+   * datum-carrying field — see `wrapperDatumField` — for a loop whose `.` is a
+   * child-component wrapper Props struct rather than the raw datum itself.
+   * `undefined` for every other caller (non-loop `.filter()`/`.find()`/etc.,
+   * or a plain-element-body loop), which keeps emitting the bare `.`/`.Field`
+   * this method always has.
    */
   private renderFilterExpr(
     expr: ParsedExpr,
     param: string,
-    localVarMap: Map<string, string> = new Map()
+    localVarMap: Map<string, string> = new Map(),
+    datumField?: string
   ): string {
     // Top-of-recursion: clear the unsupported sentinel so a previous filter
     // expression's failure doesn't poison this one. Parents (`member` /
@@ -4153,7 +4470,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (this.filterExprDepth === 0) this.filterExprUnsupported = false
     this.filterExprDepth++
     try {
-      return this.renderFilterExprNode(expr, param, localVarMap)
+      return this.renderFilterExprNode(expr, param, localVarMap, datumField)
     } finally {
       this.filterExprDepth--
     }
@@ -4162,12 +4479,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private renderFilterExprNode(
     expr: ParsedExpr,
     param: string,
-    localVarMap: Map<string, string>
+    localVarMap: Map<string, string>,
+    datumField?: string
   ): string {
+    // #2228: `paramPrefix` prepends the wrapper's datum-carrying field to a
+    // loop-param access (`.Todo` under a wrapper, `''` otherwise). Two derived
+    // forms because Go template spells "the dot itself" as `.` but "field on
+    // the dot" as `.Field` — a naive shared `'.'` prefix would emit `..Done`
+    // for the non-wrapper member case:
+    //   bare `t`     → `paramDot`             (`.Todo` / `.`)
+    //   `t.done`     → `${paramPrefix}.Done`  (`.Todo.Done` / `.Done`)
+    const paramPrefix = datumField ? `.${datumField}` : ''
+    const paramDot = paramPrefix || '.'
     switch (expr.kind) {
       case 'identifier': {
         if (expr.name === param) {
-          return '.'
+          return paramDot
         }
         // A local variable mapped to a signal.
         const signal = localVarMap.get(expr.name)
@@ -4187,9 +4514,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         return String(expr.value)
 
       case 'member': {
-        // t.done -> .Done
+        // t.done -> .Done (or .Todo.Done under a wrapper struct, #2228)
         if (expr.object.kind === 'identifier' && expr.object.name === param) {
-          return `.${capitalizeFieldName(expr.property)}`
+          return `${paramPrefix}.${capitalizeFieldName(expr.property)}`
         }
         // `.length` on a higher-order filter result (e.g.
         // `x.tags.filter(t => t.active).length > 0`). Reuse
@@ -4202,21 +4529,21 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           const innerHO = this.higherOrderShapeOf(expr.object)
           if (innerHO && innerHO.method === 'filter') {
             const lenExpr = this.renderFilterLengthExpr(innerHO, e =>
-              this.renderFilterExpr(e, param, localVarMap),
+              this.renderFilterExpr(e, param, localVarMap, datumField),
             )
             if (lenExpr) return `(${lenExpr})`
           }
         }
         // Nested member access or local var.prop.
-        const obj = this.renderFilterExpr(expr.object, param, localVarMap)
+        const obj = this.renderFilterExpr(expr.object, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
         return `${obj}.${capitalizeFieldName(expr.property)}`
       }
 
       case 'call': {
-        // `t.isDone()` -> `.IsDone`
+        // `t.isDone()` -> `.IsDone` (or `.Todo.IsDone` under a wrapper, #2228)
         if (expr.callee.kind === 'member' && expr.callee.object.kind === 'identifier' && expr.callee.object.name === param) {
-          return `.${capitalizeFieldName(expr.callee.property)}`
+          return `${paramPrefix}.${capitalizeFieldName(expr.callee.property)}`
         }
         // Signal calls: `filter()` -> `$.Filter`
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
@@ -4232,13 +4559,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (asCallbackMethodCall(expr) !== null) {
           return this.refuseFilterExprNode(expr)
         }
-        const result = this.renderFilterExpr(expr.callee, param, localVarMap)
+        const result = this.renderFilterExpr(expr.callee, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
         return result
       }
 
       case 'unary': {
-        const arg = this.renderFilterExpr(expr.argument, param, localVarMap)
+        const arg = this.renderFilterExpr(expr.argument, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
         if (expr.op === '!') {
           // Wrap in parens if arg is a function call (eq, ne, gt, …).
@@ -4252,9 +4579,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
 
       case 'binary': {
-        const left = this.renderFilterExpr(expr.left, param, localVarMap)
+        const left = this.renderFilterExpr(expr.left, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
-        const right = this.renderFilterExpr(expr.right, param, localVarMap)
+        const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
 
         switch (expr.op) {
@@ -4286,9 +4613,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
 
       case 'logical': {
-        const left = this.renderFilterExpr(expr.left, param, localVarMap)
+        const left = this.renderFilterExpr(expr.left, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
-        const right = this.renderFilterExpr(expr.right, param, localVarMap)
+        const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
         if (expr.op === '&&') {
           return `and (${left}) (${right})`
@@ -4409,6 +4736,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return '""'
     }
 
+    // #2224: inside a `renderUnrolledStaticElementLoop` pass, there is no
+    // real `{{range}}` establishing a per-item dot context — every
+    // expression in the body must instead resolve directly against the
+    // active item via `evaluateStaticLiteral` and lower to a literal Go
+    // value. Highest priority (even over the static-record-index / inlined-
+    // const early returns below): those string-keyed checks were never
+    // designed to reason about a loop item and could otherwise misfire on
+    // text that merely happens to match their shape. `analyzeBakeable-
+    // StaticElementLoop` has already verified every expression in this body
+    // resolves for every item, so the `staticLoopBakeFailed` branch is a
+    // defensive invariant, not a real code path — if it ever fires, the two
+    // passes disagreed and the safest move is a sentinel, not a `.Field`
+    // reference with no range context behind it.
+    if (this.staticLoopItemStack.length > 0) {
+      const top = this.staticLoopItemStack[this.staticLoopItemStack.length - 1]
+      const parsedForBake = preParsed ?? parseExpression(trimmed)
+      const resolved = evaluateStaticLiteral(parsedForBake, new Map([[top.param, top.item]]))
+      const literal = resolved !== null ? scalarToGoLiteral(resolved.value) : null
+      if (literal !== null) {
+        // Deliberately leave `out.parsed` unset — a `template-literal`-kind
+        // source (`` `Hi ${item.label}` ``) must NOT be treated as
+        // already-fragment text by `renderExpression`'s `isTemplateFragment`
+        // check (it would skip the `{{...}}` wrap and print the Go literal's
+        // quote characters raw into the HTML).
+        return literal
+      }
+      this.staticLoopBakeFailed = true
+      return '""'
+    }
+
     // `IDENT['key']` over a module object-literal const with a STRING-LITERAL key
     // is a fully static lookup — resolve it at compile time. The generic member
     // lowering below would otherwise capitalize the bracket access into a field
@@ -4424,7 +4781,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // the generic lowering would reference a nonexistent `.TotalPages` field).
     // Only pure numeric / single-quoted-string initializers qualify; anything
     // else may be runtime-dependent.
-    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+    //
+    // #2236: this is a string-keyed fast path over `jsExpr` reached directly
+    // by call sites like attribute emission (`key={count}` → `data-key`) that
+    // never go through `identifier()`'s loop-shadow guards below — so it must
+    // carry its OWN guard. When `.map((count) => ...)` shadows the outer
+    // `const count = 7`, the occurrence inside the loop body must resolve to
+    // the range value (via the normal parse-and-lower fallthrough), not the
+    // outer literal.
+    if (!this.isLoopShadowedName(trimmed) && /^[A-Za-z_$][\w$]*$/.test(trimmed)) {
       const litConst = (this.state.localConstants ?? []).find(c => c.name === trimmed)
       if (litConst?.value !== undefined) {
         const v = litConst.value.trim()
@@ -4495,6 +4860,26 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return this.renderParsedExpr(parsed)
   }
 
+  /**
+   * Whether `name` at the CURRENT emission position is bound by an enclosing
+   * loop callback — its item param (`loopParamStack` top), an outer loop's
+   * range variable, a hoisted loop var, or a destructured binding name
+   * (`loopBindingStack`, which is the ONLY place destructured callbacks
+   * record their names; they push `''` onto `loopParamStack`). Shared by the
+   * string-keyed fast paths (#2236, #2242 Copilot review) that resolve raw
+   * `jsExpr` text before `identifier()`'s own guards can see it. Mirrors the
+   * checks in `resolveModuleStringConst` / `resolveModuleNumericConst`.
+   */
+  private isLoopShadowedName(name: string): boolean {
+    return (
+      (this.loopParamStack.length > 0 &&
+        this.loopParamStack[this.loopParamStack.length - 1] === name) ||
+      this.loopVarRefCount.has(name) ||
+      this.isOuterLoopParam(name) ||
+      this.loopBindingStack.some(bindings => bindings.has(name))
+    )
+  }
+
   /**
    * Resolve `IDENT['key']` / `IDENT["key"]` where `IDENT` is a module-scope
    * object-literal const and the key is a string literal — a compile-time-static
@@ -4512,6 +4897,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // ordinary props/locals never match.
       /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(jsExpr)
     if (!m) return null
+    // The base name may be an enclosing loop callback's own (shadowing)
+    // param (`rows.map((cfg) => cfg.x)` under a module `const cfg = {...}`)
+    // — the record-member sibling of the #2236 bare-identifier gap, found
+    // by the loop-param-shadows-record-const fixture. Fall through to the
+    // generic lowering, which resolves the member through the loop binding.
+    if (this.isLoopShadowedName(m[1])) return null
     const key = m[2] ?? m[3]
     const constInfo = (this.state.localConstants ?? []).find(
       c => c.name === m[1] && c.isModule,
@@ -4974,6 +5365,68 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return undefined
   }
 
+  /**
+   * #2228: the Go field name on the wrapper Props struct that carries the
+   * loop datum, for a loop whose body IS a child component (`loop.childComponent`,
+   * e.g. `.TodoItems` ranging over `TodoItemProps`). `{{range}}`'s dot context
+   * for such a loop is the WHOLE wrapper struct (`TodoItemProps{ Todo Todo,
+   * OnToggle ..., ... }`), not the raw per-item datum — so a filter predicate
+   * (`t => !t.done`) referencing the loop param can't lower `t.done` straight
+   * to `.Done` (no such top-level field; `html/template` fails at execute time
+   * with `can't evaluate field Done in type TodoItemProps`). The datum lives
+   * nested under whichever child prop was PASSED the loop param verbatim
+   * (`todo={todo}` → field `Todo`, from `capitalizeFieldName('todo')` — the
+   * SAME derivation `generateInputStruct`/`generatePropsStruct` use for every
+   * other prop-to-field mapping, so this never invents a field name the
+   * generated struct doesn't actually have). Returns `null` for a non-wrapper
+   * loop, or when no prop's value is a bare reference to the loop param (the
+   * datum isn't forwarded at all — nothing to qualify through).
+   */
+  private wrapperDatumField(loop: {
+    childComponent?: IRLoopChildComponent
+    param: string
+  }): string | null {
+    if (!loop.childComponent) return null
+    for (const prop of loop.childComponent.props) {
+      if (prop.isEventHandler) continue
+      if (prop.value.kind !== 'expression') continue
+      const parsed = prop.value.parsed
+      const isBareParamRef = parsed
+        ? parsed.kind === 'identifier' && parsed.name === loop.param
+        : prop.value.expr.trim() === loop.param
+      if (isBareParamRef) return capitalizeFieldName(prop.name)
+    }
+    return null
+  }
+
+  /**
+   * Memoized bakeability check for a static-array loop whose body is a
+   * single child component (#2208) — see `analyzeBakeableStaticChildLoop`'s
+   * docstring. Accepts either an `IRLoop` (the `renderLoop` gate) or a
+   * `NestedComponentInfo` (`generateNewPropsFunction`/Input-struct sites) —
+   * both carry the same `loopArrayParsed`/`loopParam`/`loopKey`/props data,
+   * just under different field names, so this normalizes to one shape and
+   * caches by marker id so all three call sites agree.
+   */
+  private getBakedStaticChildLoop(
+    markerId: string,
+    childComponent: { props: IRLoopChildComponent['props'] },
+    arrayParsed: ParsedExpr | undefined,
+    param: string | undefined,
+    key: string | undefined,
+  ): BakedStaticChildLoop | null {
+    if (this.bakedStaticChildLoopCache.has(markerId)) {
+      return this.bakedStaticChildLoopCache.get(markerId) ?? null
+    }
+    const result = analyzeBakeableStaticChildLoop(
+      { props: childComponent.props, loopArrayParsed: arrayParsed, loopParam: param, loopKey: key },
+      this.state.localConstants,
+      { isNameShadowed: name => this.state.staticLoopSourceBoundNames.has(name) },
+    )
+    this.bakedStaticChildLoopCache.set(markerId, result)
+    return result
+  }
+
   renderLoop(loop: IRLoop): string {
     // clientOnly loops: emit SSR markers so the client can insert DOM nodes. The
     // marker id disambiguates sibling `.map()` calls under the same parent.
@@ -5036,8 +5489,44 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Phase A/B) no longer refuses `static-array-from-props`'s `([emoji,
     // users]) => ...` param first. Cross-adapter policy: Jinja / ERB apply the
     // same narrow check in their own `renderLoop` (see `jinja-adapter.ts`).
+    // #2208: a static-array loop whose body is a single child component
+    // (`loop.childComponent`) with a plain-value prop set can be BAKED —
+    // every per-item prop and data-key resolves to a compile-time-known Go
+    // literal (see `analyzeBakeableStaticChildLoop`), so the constructor
+    // (`generateNewPropsFunction`'s `staticWithoutBody` path) can emit the
+    // child instances directly instead of requiring the loop array bind as
+    // a template variable at all. Memoized by marker id so this gate and
+    // the constructor's later baking agree. A plain-ELEMENT body (no
+    // `childComponent`) is NOT handled by baking and keeps refusing below —
+    // see the go-only follow-up issue for that narrower gap.
+    const bakedChildLoop = loop.childComponent
+      ? this.getBakedStaticChildLoop(loop.markerId, loop.childComponent, loop.arrayParsed, loop.param, loop.key ?? undefined)
+      : null
+
+    // #2224 shape 1: a static-array loop whose body is a plain ELEMENT tree
+    // (no child component) has no `.{Name}s`-shaped template target for
+    // #2208's baking to feed — there's nothing for `{{range}}` to iterate at
+    // all once the array itself can't bind as a template variable. Rather
+    // than synthesizing a Go struct type for the item shape (see the #2224
+    // issue body), unroll the body once per item at template-generation
+    // time instead, substituting each item's statically-known field values
+    // directly — see `analyzeBakeableStaticElementLoop`'s docstring for the
+    // exact (conservative) acceptance gate. `null` here means the shape
+    // isn't (yet) bakeable this way; the existing gates below keep firing
+    // exactly as before.
+    const bakedElementLoop = loop.childComponent
+      ? null
+      : analyzeBakeableStaticElementLoop(
+          loop,
+          this.state.localConstants,
+          { isNameShadowed: name => this.state.staticLoopSourceBoundNames.has(name) },
+        )
+    if (bakedElementLoop) {
+      return this.renderUnrolledStaticElementLoop(loop, bakedElementLoop.items)
+    }
+
     const arrayName = loop.array.trim()
-    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+    if (bakedChildLoop === null && /^[A-Za-z_$][\w$]*$/.test(arrayName)) {
       const arrayConst = this.state.localConstants.find(c => c.name === arrayName)
       if (arrayConst && !arrayConst.isModule && arrayConst.parsed && !this.isStringExpr(arrayConst.parsed, new Set())) {
         this.state.errors.push({
@@ -5053,7 +5542,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
-    let goArray = this.convertExpressionToGo(loop.array)
+    // #2224 shape 2: when the body IS a child component, `goArray` gets
+    // unconditionally overwritten to `.${componentName}s` below regardless
+    // of what this call returns — so for an INLINE array-literal source
+    // (`[{ label: 'Alpha' }, ...].map(item => <ListItem .../>)`), calling
+    // `convertExpressionToGo` on the raw literal text here is pure waste at
+    // best. At worst it's actively harmful: an array-literal-of-objects
+    // fails the shared `isSupported` gate (`object-literal` is refused
+    // standalone — expression-parser.ts), so this call would push a BF101
+    // as a side effect even though `bakedChildLoop` above (via
+    // `resolveStaticLoopSource`, which evaluates the literal directly
+    // instead of going through `isSupported`) already resolved the SAME
+    // loop just fine. Skip the call entirely for a child-component body —
+    // baked or not, dynamic `.map()` over a real prop/signal array included
+    // — so no spurious diagnostic is ever recorded for a value nothing ends
+    // up consuming.
+    let goArray = loop.childComponent ? '' : this.convertExpressionToGo(loop.array)
     const param = loop.param
     let index = loop.index || '_'
 
@@ -5174,9 +5678,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       let filterCond: string
 
       if (loop.filterPredicate.predicate) {
+        // #2228: for a wrapper-slice loop (`.TodoItems` ranging over
+        // TodoItemProps), `.` in the predicate is the WHOLE wrapper struct —
+        // qualify `loop.filterPredicate.param` references through the
+        // datum-carrying field (`.Todo.Done`, not `.Done`) so the emitted
+        // `{{if}}` only ever dereferences fields the wrapper struct actually
+        // has. `wrapperDatumField` returns `null` for a plain-element-body
+        // loop, where `.` already IS the datum — `renderPredicateCondition`
+        // then keeps emitting the bare `.`/`.Field` form unchanged.
+        const datumField = this.wrapperDatumField(loop)
         filterCond = this.renderPredicateCondition(
           loop.filterPredicate.predicate,
-          loop.filterPredicate.param
+          loop.filterPredicate.param,
+          datumField
         )
       } else {
         filterCond = 'true'
@@ -5188,6 +5702,61 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`
   }
 
+  /**
+   * #2224 shape 1: render a static-array, plain-element-body loop's per-item
+   * markup ONCE PER ITEM at template-generation time instead of a Go
+   * `{{range}}` — `analyzeBakeableStaticElementLoop` has already verified
+   * every expression in `loop.children` resolves against each item. Keeps
+   * the SAME `<!--bf-loop:id--> ... <!--/bf-loop:id-->` marker pair a
+   * dynamic loop emits (so the CSR-side static `forEach` wiring, compiled by
+   * the separate `ir-to-client-js.ts` pass and untouched by this change,
+   * still finds the same DOM range), and pushes `loop.param` /
+   * `loop.depth` onto the SAME stacks `renderLoop`'s `{{range}}` path uses,
+   * so `data-key`/`data-key-N` attribute-name derivation
+   * (`renderAttributes`) is unaffected by which path rendered the loop. No
+   * `itemMarker` (`loopItemMarker`) call: the analysis gate already refused
+   * `bodyIsMultiRoot` / `bodyIsItemConditional` bodies, so it would always
+   * return `''` here anyway.
+   */
+  private renderUnrolledStaticElementLoop(loop: IRLoop, items: readonly unknown[]): string {
+    this.inLoop = true
+    this.loopWrapperStack.push(false)
+    this.loopKeyDepthStack.push(loop.depth)
+    this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null)
+    this.loopParamStack.push(loop.param)
+
+    let body = ''
+    for (const item of items) {
+      this.staticLoopItemStack.push({ param: loop.param, item })
+      body += this.renderChildren(loop.children)
+      this.staticLoopItemStack.pop()
+      if (this.staticLoopBakeFailed) {
+        // Invariant violation (see `staticLoopBakeFailed`'s docstring): the
+        // gate and this render pass disagreed. Surface it loudly instead of
+        // shipping a template with `""` sentinels silently spliced in.
+        this.staticLoopBakeFailed = false
+        this.state.errors.push({
+          code: 'BF101',
+          severity: 'error',
+          message: `Loop array \`${loop.array.trim()}\` could not be fully unrolled — an expression in the loop body did not resolve against every item as the compile-time analysis expected.`,
+          loc: loop.loc ?? this.makeLoc(),
+          suggestion: {
+            message: 'This indicates a bug in the Go adapter\'s static-loop unrolling (#2224) rather than an unsupported source pattern; please file a bug with a reproduction.',
+          },
+        })
+        break
+      }
+    }
+
+    this.loopParamStack.pop()
+    this.loopScalarItemStack.pop()
+    this.loopKeyDepthStack.pop()
+    this.loopWrapperStack.pop()
+    this.inLoop = false
+
+    return `{{bfComment "loop:${loop.markerId}"}}${body}{{bfComment "/loop:${loop.markerId}"}}`
+  }
+
   /**
    * Per-item `<!--bf-loop-i-->` / `<!--bf-loop-i:KEY-->` start marker emitted
    * inside a `{{range}}` body. Multi-root Fragment items get the bare anchor;
@@ -5574,6 +6143,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // predicate (no BF101 / BF102). This keeps the BF102 remediation ("defer
       // it with /* @client */") accurate for attribute-only state.
       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. The
       // Go template adapter has no JSX runtime to strip `key` / emit `data-key`,
       // so the rewrite happens at attribute-emit time. Mirror of the `key`