@barefootjs/go-template 0.33.2 → 0.33.4

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

@@ -80,7 +80,7 @@ import {
   BindingScope,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
-import { BF_REGION, escapeHtml } from '@barefootjs/shared'
+import { BF_REGION, escapeHtml, resolveJsxChildrenProp } from '@barefootjs/shared'
 
 import {
   GO_IDENTIFIER,
@@ -118,7 +118,6 @@ import type {
   CtorLowerEnv,
   GoTemplateAdapterOptions,
 } from "./lib/types.ts"
-import { collectRootScopeNodes } from "./lib/ir-scope.ts"
 import { GO_TEMPLATE_PRIMITIVES } from "./lib/constants.ts"
 import { CompileState, resolveSignalParsedThroughSeedPlan } from "./lib/compile-state.ts"
 import { hasClientInteractivity, findNestedComponents } from "./analysis/component-tree.ts"
@@ -313,15 +312,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * everywhere except the accessor lookup itself.
    */
   private scope: BindingScope = BindingScope.EMPTY
-  /**
-   * Stack of `IRLoop.depth` values (innermost last), pushed/popped around
-   * `renderChildren(loop.children)` in `renderLoop`. `renderAttributes`
-   * reads the top of this stack to derive the `key` → `data-key`/
-   * `data-key-N` suffix — the depth is IR-computed (jsx-to-ir.ts), not
-   * re-derived here; this stack only threads that value down to the
-   * loop body's root element (#2168 nested-loop-outer-binding).
-   */
-  private loopKeyDepthStack: number[] = []
   /**
    * Per-loop: true when the body renders the bare range value (scalar-item
    * inline-literal loop), so the `bf_tmpl` companion is fed `.BfLoopItem` (the
@@ -521,7 +511,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const isRootComponent = ir.root.type === 'component'
     const isIfStatement = ir.root.type === 'if-statement'
 
-    this.state.rootScopeNodes = collectRootScopeNodes(ir.root)
     // Map each array memo backing a loop (`<memo>().map(...)`) to that loop's
     // handler-filled slice field, so `<memo>().length` lowers to the slice's
     // length. Built before rendering — `.length` can precede the loop in source.
@@ -2323,7 +2312,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           }
           case 'jsx-children':
             // The RESERVED children slot (`comp.children.length > 0 ? comp.children
-            // : jsxChildrenPropNodes(...)`) is handled below via
+            // : resolveJsxChildrenProp(...)`) is handled below via
             // `child.childrenText` / `child.childrenHtml` and must not be
             // re-emitted here. A JSX-valued prop under any OTHER name
             // (`header={<strong>Title</strong>}`, #2168 jsx-element-prop) is a
@@ -2353,6 +2342,20 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
                     this.state.usesHtmlTemplate = true
                     emitChildField(prop.name, `template.HTML(${scopedHtml})`)
                   }
+                  // Else: none of the three bake attempts produced a static
+                  // Go string — the value contains a template action that
+                  // survived (#2746) or is otherwise genuinely dynamic
+                  // (#2703). No field is emitted here; `queueDynamicPropDefine`
+                  // (called from `renderComponent`'s static-call-site branch)
+                  // detects the SAME unbakeable shape and delivers it at
+                  // template-execution time via `bf_with_props` + `bf_tmpl`,
+                  // mirroring how the reserved `children` field's null case
+                  // just above is filled in by `bf_with_children`. A
+                  // component nested in a loop row never reaches this
+                  // function (`collectStaticChildInstancesRecursive` only
+                  // collects `!inLoop` components), so there is no dynamic
+                  // named-prop delivery for that shape yet — out of scope
+                  // here, tracked separately if it turns up.
                 }
               }
             }
@@ -3173,17 +3176,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return out
   }
 
-  /**
-   * Pull the IR nodes out of a `children={<…/>}` attribute (a `jsx-children`
-   * prop value). Empty when the component takes no such prop.
-   */
-  private jsxChildrenPropNodes(props: IRProp[]): IRNode[] {
-    for (const p of props) {
-      if (p.value.kind === 'jsx-children') return p.value.children
-    }
-    return []
-  }
-
   private extractHtmlChildren(children: IRNode[]): string | null {
     if (children.length === 0) return null
     if (children.every(c => c.type === 'text')) return null
@@ -3212,7 +3204,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    *
    * `ctx.isRoot` leaks into a JSX-valued prop's subtree, so such a fragment
    * is already tagged `needsScopeComment` as if it were a component root —
-   * which is why `carriesDataKey` reaches this path at all.
+   * which is why a relay `element.keyAttr` (#2753; `carriesDataKey` before
+   * it) reaches this path at all.
    */
   private bakingStaticChildren = false
 
@@ -3274,7 +3267,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // paths below see them.
         const effectiveChildren = comp.children.length > 0
           ? comp.children
-          : this.jsxChildrenPropNodes(comp.props)
+          : resolveJsxChildrenProp(comp.props)
         result.push({
           name: comp.name,
           slotId: comp.slotId,
@@ -4140,21 +4133,34 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker('.ScopeID')}`
     }
-    // A root scope element carries `data-key` for a keyed loop item — the
-    // parent's loop init stamped `.BfDataKey`, so a non-keyed render emits
-    // nothing. Applies to early-return (if-statement) roots too, where every
-    // branch's top element qualifies.
-    // `carriesDataKey` is an INDEPENDENT reason to emit, not a refinement of
-    // the root-scope test above (#2732): a fragment root clears `needsScope` on
-    // its wrapped child and moves the other hydration markers onto the
-    // `<!--bf-scope:-->` comment, but `data-key` must stay a real attribute —
-    // the client's `mapArray` adopt loop reads `primaryEl.dataset.key`, never
-    // the comment. Mirrors the same branch in hono-adapter.ts.
-    if (
-      (this.state.rootScopeNodes.has(element) && element.needsScope) ||
-      (element.carriesDataKey && !this.bakingStaticChildren)
-    ) {
-      hydrationAttrs += `{{if .BfDataKey}} data-key="{{.BfDataKey}}"{{end}}`
+    // #2753: `element.keyAttr` is the ONE IR-resolved decision for this
+    // element's row-key attribute — replacing both the `carriesDataKey`
+    // boolean and this adapter's own `rootScopeNodes`/`needsScope` check
+    // (mechanism 2: a render-root relay, including the #2732 fragment-root
+    // case) and the separate `loopKeyDepthStack`-driven rewrite of a literal
+    // `key` attribute this adapter used to do in `renderAttributes`
+    // (mechanism 1: a `.map()` row root compiled inline here).
+    if (element.keyAttr) {
+      if (element.keyAttr.value !== undefined) {
+        const lowered = emitAttrValue(
+          { kind: 'expression', expr: element.keyAttr.value },
+          this.elementAttrEmitter,
+          element.keyAttr.name,
+        )
+        if (lowered) hydrationAttrs += ` ${lowered}`
+      } else if (!this.bakingStaticChildren) {
+        // Relay: this element is one of THIS component's own render roots,
+        // carrying whatever key its OWN caller supplies at runtime (the
+        // parent's loop init stamped `.BfDataKey`), when this component is
+        // itself invoked as a caller's keyed loop row. Applies to
+        // early-return (if-statement) roots too, where every branch's top
+        // element qualifies, and to #2732's fragment-root case.
+        // `bakingStaticChildren` (see its docstring) excludes a hoisted
+        // children value baked into a static Go string at compile time —
+        // by construction not a loop row, and a surviving `{{if}}` action
+        // there gets silently dropped by the caller rather than rendered.
+        hydrationAttrs += `{{if .BfDataKey}} data-key="{{.BfDataKey}}"{{end}}`
+      }
     }
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`
@@ -7170,7 +7176,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null,
     )
     this.loopWrapperStack.push(!!loop.childComponent)
-    this.loopKeyDepthStack.push(loop.depth)
     // Rendered inside the pushed loop scope so each initializer resolves
     // against the range item (`.Done`), in source order so a later
     // initializer sees an earlier `$` variable — same as the source block.
@@ -7178,7 +7183,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       .map(d => `{{$${d.name} := ${this.renderParsedExpr(d.valueParsed)}}}`)
       .join('')
     const children = this.renderChildren(loop.children)
-    this.loopKeyDepthStack.pop()
     this.loopWrapperStack.pop()
     this.loopScalarItemStack.pop()
     // Build the per-item anchor marker while the row scope is still active,
@@ -7270,7 +7274,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const wasInLoopOuter = this.inLoop
     this.inLoop = true
     this.loopWrapperStack.push(false)
-    this.loopKeyDepthStack.push(loop.depth)
     this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null)
     // The bake gate (`analyzeBakeableStaticElementLoop`) already refused a
     // destructured or `.keys()`-shape param, so `loop` binds via `enterLoopRow`
@@ -7303,7 +7306,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     this.scope = prevScope
     this.loopScalarItemStack.pop()
-    this.loopKeyDepthStack.pop()
     this.loopWrapperStack.pop()
     this.inLoop = wasInLoopOuter
 
@@ -7317,7 +7319,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * `mapArrayAnchored` can hydrate items that render no element.
    */
   private loopItemMarker(loop: { bodyIsMultiRoot?: boolean; bodyIsItemConditional?: boolean; key?: string | null }): string {
-    if (loop.bodyIsMultiRoot) return `{{bfComment "bf-loop-i"}}`
+    // `bfComment` prepends `bf-`, so the argument is `"loop-i"`, not
+    // `"bf-loop-i"` (which would double the prefix to `<!--bf-bf-loop-i-->`
+    // — the same latent bug #2763's fixture caught on the Hono adapter).
+    if (loop.bodyIsMultiRoot) return `{{bfComment "loop-i"}}`
     if (loop.bodyIsItemConditional && loop.key) {
       // `bfComment` prepends `bf-`, so `printf "loop-i:%v"` yields
       // `<!--bf-loop-i:KEY-->`. The key expression resolves against the current
@@ -7339,7 +7344,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private queueDynamicChildrenDefine(comp: IRComponent): string | null {
     const effectiveChildren = comp.children.length > 0
       ? comp.children
-      : this.jsxChildrenPropNodes(comp.props)
+      : resolveJsxChildrenProp(comp.props)
     if (effectiveChildren.length === 0) return null
     if (this.extractTextChildren(effectiveChildren) !== null) return null
     if (this.extractHtmlChildren(effectiveChildren) !== null) return null
@@ -7354,6 +7359,72 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return name
   }
 
+  /**
+   * #2703/B2: extend `queueDynamicChildrenDefine`'s companion-define delivery
+   * from the reserved `children` slot to NAMED jsx-children props (any
+   * JSX-valued prop other than `children`, e.g. `header={<strong>Title</strong>}`).
+   * A named prop whose value can't be baked into a static Go string by
+   * `emitStaticChildInstances`'s bake chain (`extractTextChildren` /
+   * `extractHtmlChildren` / `extractScopedHtmlChildren`, all null) is queued
+   * here instead, the same way; the caller composes the result into
+   * `bf_with_props` + `bf_tmpl` at the STATIC (non-loop) call site — the one
+   * shape `emitStaticChildInstances` bakes for at all (a component nested in
+   * a loop row never reaches `collectStaticChildInstances`).
+   *
+   * Returns the flat `"FieldName" (bf_tmpl "name" .) ...` argument list ready
+   * to splice into `bf_with_props`, or null when no named prop needs it —
+   * batches every prop that needs dynamic delivery into ONE `bf_with_props`
+   * call rather than nesting one per prop.
+   */
+  private queueDynamicPropDefine(comp: IRComponent): string | null {
+    const args: string[] = []
+    const childShape = this.childComponentShapes.get(comp.name)
+    for (const prop of comp.props) {
+      if (prop.value.kind !== 'jsx-children' || prop.name === 'children') continue
+      const children = prop.value.children
+      if (this.extractTextChildren(children) !== null) continue
+      if (this.extractHtmlChildren(children) !== null) continue
+      if (this.extractScopedHtmlChildren(children) !== null) continue
+      // A prop routed into the child's rest bag (no declared param —
+      // `loopRowChildPropOverrides`'s identical guard, above) has no named
+      // Go field for `bf_with_props`/`WithProps` to target at all; `WithProps`
+      // silently no-ops on an unmatched field name. Refuse loudly instead of
+      // delivering the value against a field name that can never land —
+      // this shape had no dynamic-delivery route before this method existed
+      // either (the blanket BF101 this method's caller replaced was
+      // unconditional for any unbakeable named prop), so this keeps it loud
+      // rather than trading that refusal for a silent dropped render.
+      if (childShape?.restBagField && !childShape.paramNames.has(prop.name)) {
+        this.state.errors.push({
+          code: 'BF101',
+          severity: 'error',
+          message: `JSX-valued prop '${prop.name}' on <${comp.name}> is dynamic and routes into the child's rest-bag prop ('${childShape.restBagField}') rather than a declared field — there is no named Go struct field for 'bf_with_props' to target`,
+          loc: prop.loc,
+        })
+        continue
+      }
+      const name = `${this.state.componentName}__prop_${prop.name}_${comp.slotId}`
+      if (!this.state.pendingChildrenDefines.some(d => d.name === name)) {
+        this.state.pendingChildrenDefines.push({
+          name,
+          content: this.renderChildren(children),
+        })
+      }
+      // `bf_with_props`/`WithProps` patches the child's Props struct, keyed
+      // by the child's own LOCAL destructured field name — not necessarily
+      // the caller's JSX attribute name (`function Card({ header: h })`
+      // reads `h`, whose field is `H`, not `Header`). `WithProps` silently
+      // no-ops on an unmatched field name, so skipping this lookup would
+      // turn an aliased prop's dynamic delivery into a silent dropped
+      // render. `childPropFieldNames` resolves this exact hazard for the
+      // sibling `bf_with_props` call site (`loopRowChildPropOverrides`,
+      // below) — mirrored here.
+      const fieldName = this.childPropFieldNames.get(comp.name)?.get(prop.name) ?? capitalizeFieldName(prop.name)
+      args.push(`${JSON.stringify(fieldName)} (bf_tmpl ${JSON.stringify(name)} .)`)
+    }
+    return args.length > 0 ? args.join(' ') : null
+  }
+
   /**
    * Queue a companion define for a loop body component's JSX children. Like
    * `queueDynamicChildrenDefine` but temporarily exits the `inLoop` context so
@@ -7366,7 +7437,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private queueLoopBodyChildrenDefine(comp: IRComponent): string | null {
     const effectiveChildren = comp.children.length > 0
       ? comp.children
-      : this.jsxChildrenPropNodes(comp.props)
+      : resolveJsxChildrenProp(comp.props)
     if (effectiveChildren.length === 0) return null
     if (this.extractTextChildren(effectiveChildren) !== null) return null
     if (this.extractHtmlChildren(effectiveChildren) !== null) return null
@@ -7459,9 +7530,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // Static children with slotId: unique field name based on slotId.
       const suffix = slotIdToFieldSuffix(comp.slotId)
       const childrenDefine = this.queueDynamicChildrenDefine(comp)
+      // #2703/B2: a NAMED jsx-children prop (any JSX-valued prop other than
+      // `children`) that couldn't be baked into the constructor gets the
+      // same treatment `children` already has — delivered at the call site
+      // via a companion define. Props helper stays INNER, same ordering
+      // rule as the loop-nested branch above: `bf_with_children` applies
+      // last, on the props-patched value.
+      const propArgs = this.queueDynamicPropDefine(comp)
+      const base = propArgs
+        ? `(bf_with_props .${comp.name}${suffix} ${propArgs})`
+        : `.${comp.name}${suffix}`
       templateCall = childrenDefine
-        ? `{{template "${comp.name}" (bf_with_children .${comp.name}${suffix} (bf_tmpl "${childrenDefine}" .))}}`
-        : `{{template "${comp.name}" .${comp.name}${suffix}}}`
+        ? `{{template "${comp.name}" (bf_with_children ${base} (bf_tmpl "${childrenDefine}" .))}}`
+        : `{{template "${comp.name}" ${base}}}`
     } else {
       // Static children without slotId: fall back to .ComponentName.
       templateCall = `{{template "${comp.name}" .${comp.name}}}`
@@ -7749,19 +7830,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // 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`
-      // branch in `ir-to-client-js/html-template.ts`. The depth-suffix (plain
-      // `data-key` at the outermost loop, `data-key-N` N levels deep) comes
-      // from `IRLoop.depth` via `loopKeyDepthStack`, not re-derived here.
-      let attrName: string
-      if (attr.name === 'className') attrName = 'class'
-      else if (attr.name === 'key') {
-        const depth = this.loopKeyDepthStack.at(-1) ?? 0
-        attrName = depth > 0 ? `data-key-${depth}` : 'data-key'
-      }
-      else attrName = attr.name
+      // `key` never renders as a literal HTML attribute — #2753 resolves it
+      // onto `element.keyAttr` (name AND value) at IR-build time, emitted
+      // separately in `renderElement`. A stray `key` that jsx-to-ir.ts did
+      // NOT recognize as a loop row root (so `keyAttr` was never set) has no
+      // defined rendering outside a `.map()` anyway; drop it rather than
+      // leak an invalid `key="..."` HTML attribute.
+      if (attr.name === 'key') continue
+      // Rewrite JSX special-prop names to their HTML-attribute counterparts.
+      const attrName = attr.name === 'className' ? 'class' : attr.name
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName)
       if (lowered) parts.push(lowered)
     }

package/src/adapter/lib/compile-state.ts

@@ -19,7 +19,6 @@ import type {
   ContextConsumer,
   EnvSignalReader,
   IRMetadata,
-  IRNode,
   LoweringMatcher,
   MemoInfo,
   ParsedExpr,
@@ -205,10 +204,6 @@ export class CompileState {
    */
   stringValueNames: Set<string> = new Set()
 
-  /** Component root scope element(s) — each carries `data-key` for a keyed loop
-   *  item. */
-  rootScopeNodes: Set<IRNode> = new Set()
-
   /** Array-memo name → the handler-filled loop slice field its `.map()` feeds
    *  (e.g. `visible` → `PostListItems`). Lets `<memo>().length` lower to the
    *  slice's length instead of a nil/unset memo field. */

package/src/conformance-pins.ts

@@ -59,4 +59,21 @@ export const conformancePins: ConformancePins = {
   // `rich-prop-client-read` above.
   'jsx-element-prop-ternary': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
   'jsx-element-prop-array': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
+  // `jsx-element-prop-fragment-conditional` (#2703) is NOT pinned here — it
+  // renders correctly since `queueDynamicPropDefine` (go-template-adapter.ts)
+  // extended the reserved `children` slot's `bf_with_children`/`bf_tmpl`
+  // dynamic-delivery route to named jsx-children props.
+  // #2805: a named jsx-children prop routed into the child's rest bag (no
+  // declared param — only reachable via the child's `...rest` spread) has
+  // no named Go struct field for `bf_with_props`/`WithProps` to target at
+  // all. `queueDynamicPropDefine` refuses loudly with BF101 rather than
+  // silently no-op through `WithProps`'s unmatched-field passthrough.
+  // `unescapable`: the capability gap (a rest-bag delivery route) is #2805
+  // itself, not authored yet, so no `/* @client */` escape twin exists.
+  'jsx-element-prop-rest-bag-dynamic': [{
+    code: 'BF101',
+    severity: 'error',
+    issue: 'https://github.com/piconic-ai/barefootjs/issues/2805',
+    unescapable: { issue: 'https://github.com/piconic-ai/barefootjs/issues/2805' },
+  }],
 }

package/src/render-divergences.ts

@@ -13,13 +13,27 @@
  * the same way it already seeded a signal-backed dynamic one: the adapter's
  * own `emission` was never the bug, only this harness's route-handler
  * stand-in was missing the prop-derived case.)
+ *
+ * (#2703's `jsx-element-prop-fragment-conditional` divergence graduated by
+ * reclassification, not a lowering fix: the underlying gap — a named
+ * jsx-children prop whose value can't be baked into a static Go string
+ * silently got no field at all, no diagnostic — is now a loud `BF101`
+ * refusal (see `conformance-pins.ts`) instead of a silent wrong render.
+ * "Compiles clean but renders divergent" no longer describes this fixture on
+ * Go, so it moved off this table. Dynamic delivery for named jsx-children
+ * props (the actual capability gap) is tracked separately at
+ * https://github.com/piconic-ai/barefootjs/issues/2703.)
  */
 
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
-  'jsx-element-prop-fragment-conditional':
-    'Go-specific half of the fragment-wrapped-conditional prop shape, tracked as https://github.com/piconic-ai/barefootjs/issues/2703 (distinct from #2702, the cross-adapter hydrate-time bug). #2702 is a hydrate-time-only bug (SSR is correct on every adapter, confirmed for Go by direct `adapter.generate()` inspection of the raw template TEXT, which does contain `{{if .Cond}}<a bf-c="^s0">x</a>{{else}}...{{end}}`-shaped markup). But the REAL Go render of this exact fixture (`go-template-adapter.test.ts`, real `go run`) produces an EMPTY `<header>` — `<header bf="s1"><!--bf:s0--><!--/--></header>` instead of the reference `<a>x</a>` — i.e. the `header` prop\'s jsx-children payload never reaches the child (`Card`) component\'s slot construction (`.CardSlot1`) at all for this NAMED-prop shape, even though the same conditional-in-fragment payload renders correctly when passed via `children` instead (`jsx-element-prop-children-escape`). Root cause not yet isolated to a specific emitter function — only the reproducible symptom is pinned here. Every other adapter (Hono, ERB, Jinja, Mojolicious, MiniJinja, Twig, Xslate, Blade) renders this fixture correctly; verified by running each adapter\'s own JSX Conformance Tests for this fixture id.',
+  'children-passthrough-renamed':
+    'A `children` prop destructured under a different name (`const { children: kids } = props`) does not reach the SSR template on Go, tracked as https://github.com/piconic-ai/barefootjs/issues/2788. The same fixture also fails on Mojolicious, where the mechanism IS isolated: the `.html.ep` interpolates the LOCAL alias (`$kids`) while the stash defines only the caller-facing `children`, so the Perl render dies inside `Mojo::Template::process`. Go\'s own failure mode has NOT been read — `go` is not reachable from the local test process (the conformance case prints "go command not found" and skips), so this entry is declared from the CI failure on #2787 alone, not from a local reproduction. Whoever graduates this should read Go\'s actual output first rather than assume it shares Mojo\'s mechanism. Same alias family as `aliased-destructured-prop` (`{ n: count }`), whose Go half graduated in #2525 — worth checking whether the reserved `children` slot bypasses that fix or never had it. `children-passthrough-renamed` asserts the CORRECT (Hono-generated) output, so deleting this entry is the graduation.',
   'signal-object-spread-init':
     'PRE-EXISTING, unrelated to the #2696 Step 2 spread work this fixture pins: a `derived`-classified signal/memo whose value is an OBJECT literal has no live-template-expression lowering on Go — unlike the other six template-stash backends (e.g. minijinja emits `{% set merged = dict(base, done=true) %}`), Go always bakes an object-typed signal/memo field into Go SOURCE at `NewXxxProps` constructor time (`convertInitialValue`/`parsedLiteralToGo`), and that baker is STATIC-only (identifier/call/member operands defer, `parsed-literal-to-go.ts`\'s own docstring) — it cannot reference a live prop at all. Reproduced identically with the spread REMOVED (`createSignal({ id: base.id, done: true })`), confirming the gap predates and is independent of spread: the signal seeds `nil` and every field read (`.Merged.ID`/`.Merged.Done`) reads the Go zero value regardless of `initialTodos`. Graduate by teaching the baker to emit prop-referencing Go expressions (https://github.com/piconic-ai/barefootjs/issues/2700).',
+  'textarea-row-breakout':
+    'A signal seeded from a bare identifier referencing a MODULE-LEVEL const (`const PAYLOAD = \'...\'; createSignal(PAYLOAD)`) bakes to `nil` in the generated `New<Component>Props` constructor instead of the const\'s literal value: `convertInitialValue` (`value-lowering.ts`) only resolves a direct prop reference or a literal expression for a bare identifier, and the analyzer types this signal `{ kind: \'unknown\' }`, so every typed branch falls through to the final `nil` fallback. `resolveModuleStringConst` exists on the adapter for exactly this resolution (used by `template-interp.ts` for live template expressions) but isn\'t wired into this signal-baking path. Unrelated to what this fixture exists to cover (#2765\'s loop-row textarea-escaping fix, verified correct here) — every other adapter renders the fixture\'s controlled `<textarea>` correctly. Tracked at https://github.com/piconic-ai/barefootjs/issues/2794; graduate by wiring `resolveModuleStringConst` into `convertInitialValue`\'s bare-identifier case.',
+  'nested-loop-ref-const':
+    'A signal-backed object array whose elements have a NESTED array-of-objects field (`children: [{...}]`, producing this fixture\'s depth-2 `.map()`) bakes to `nil` in `New<Component>Props`, leaving the whole `{{range .Items}}` body empty on real Go — `synthesizeStructFromSignal` (`go-template-adapter.ts`) only synthesizes a struct when EVERY property value is a scalar literal (`scalarParsedGoType`), so a `children` array property aborts synthesis for the entire signal; `parsedLiteralToGo` then has no named struct to bake an object-literal element against and falls through to `nil`. Reproduced identically with #2750\'s fix reverted, confirming this predates and is independent of #2750 (which only touches client-JS reachability, never SSR baking) — every other adapter (confirmed: Hono) renders the nested loop correctly. Tracked at https://github.com/piconic-ai/barefootjs/issues/2800; graduate by teaching `synthesizeStructFromSignal` to recursively synthesize a nested struct for an array-valued property instead of bailing to `null`.',
 }

package/dist/adapter/lib/ir-scope.d.ts

@@ -1,13 +0,0 @@
-/**
- * IR traversal helpers for the Go html/template adapter. Pure functions over
- * the IR tree — no adapter instance state.
- */
-import type { IRNode } from '@barefootjs/jsx';
-/**
- * Collect the component's root scope element node(s) — the elements that become
- * the rendered root and so carry `data-key` for a keyed loop item. A plain
- * element root is itself; an `if-statement` (early-return) root contributes the
- * top element of each branch, since exactly one renders at runtime.
- */
-export declare function collectRootScopeNodes(node: IRNode): Set<IRNode>;
-//# sourceMappingURL=ir-scope.d.ts.map

package/dist/adapter/lib/ir-scope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ir-scope.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/ir-scope.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAA6B,MAAM,iBAAiB,CAAA;AAExE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAiB/D"}

package/src/adapter/lib/ir-scope.ts

@@ -1,31 +0,0 @@
-/**
- * IR traversal helpers for the Go html/template adapter. Pure functions over
- * the IR tree — no adapter instance state.
- */
-
-import type { IRNode, IRIfStatement, IRFragment } from '@barefootjs/jsx'
-
-/**
- * Collect the component's root scope element node(s) — the elements that become
- * the rendered root and so carry `data-key` for a keyed loop item. A plain
- * element root is itself; an `if-statement` (early-return) root contributes the
- * top element of each branch, since exactly one renders at runtime.
- */
-export function collectRootScopeNodes(node: IRNode): Set<IRNode> {
-  const out = new Set<IRNode>()
-  const visit = (n: IRNode | null): void => {
-    if (!n) return
-    if (n.type === 'element') { out.add(n); return }
-    if (n.type === 'if-statement') {
-      const s = n as IRIfStatement
-      visit(s.consequent)
-      visit(s.alternate)
-      return
-    }
-    if (n.type === 'fragment') {
-      for (const c of (n as IRFragment).children) visit(c)
-    }
-  }
-  visit(node)
-  return out
-}