@barefootjs/go-template 0.9.1 → 0.9.3

package/dist/test-render.d.ts

@@ -17,6 +17,13 @@ export interface RenderOptions {
     props?: Record<string, unknown>;
     /** Additional component files (filename → source) */
     components?: Record<string, string>;
+    /**
+     * Explicit component to render when `source` declares multiple
+     * exports (e.g. `ReactiveProps.tsx` → `PropsReactivityComparison`).
+     * Mirrors the Hono reference's `componentName`; omitted for
+     * single-export fixtures, which fall back to the default/first export.
+     */
+    componentName?: string;
 }
 export declare function renderGoTemplateComponent(options: RenderOptions): Promise<string>;
 //# sourceMappingURL=test-render.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,iBAAiB,CAAA;AAOnE,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAgCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,eAAe,CAAA;IACxB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAsRvF"}
+{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,iBAAiB,CAAA;AAqBnE,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAgCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,eAAe,CAAA;IACxB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA6RvF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,6 +54,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.9.1"
+    "@barefootjs/jsx": "0.9.3"
   }
 }

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

@@ -34,38 +34,10 @@ runAdapterConformanceTests({
   // below, asserting that the adapter emits `BF101` / `BF103` /
   // `BF104` at build time instead of silently emitting invalid
   // template syntax (#1266).
-  skipJsx: [
-    // #1244 stress catalog (#1326): `children={<span/>}` — the IR
-    // hoists the span with `needsScope: true` so the Hono reference
-    // emits `bf-s` on the inner `<span>`. The Go adapter renders the
-    // span up front as a compile-time HTML fragment containing the
-    // `{{bfScopeAttr .}}` action, then passes it via `template.HTML`
-    // through the parent's `{{.Children}}` interpolation — but
-    // `template.HTML` is marked-as-safe-output, not recursively
-    // parsed, so the action survives as literal text in the rendered
-    // HTML. Fixing this requires either (a) re-emitting the inner
-    // span as its own named template definition the outer template
-    // can pass its struct to, or (b) embedding the resolved scope ID
-    // at compile time. Neither lands in this PR; the Mojo sibling
-    // case is handled by routing the hoisted JSX through the same
-    // `begin %>…<% end` capture as nested children (see #1326 fix).
-    'children-jsx-expression',
-    // #1335: fragment-wrapped form of the same shape. Now that the IR
-    // unwraps `<><span/></>` into the bare-element form, the Go adapter
-    // hits the identical `template.HTML` interpolation gap as
-    // `children-jsx-expression` above.
-    'fragment-wrapped-children-jsx-expression',
-    // Shared-component multi-component fixtures (#1466). Boolean
-    // attribute divergence is now collapsed by `normalizeHTML`, so
-    // single-root variants (`conditional-return-*`, `form`, `portal`,
-    // `reactive-props`) participate again. These two still diverge
-    // because the harness's child renderer pins child `bf-s` to a
-    // `test_<sN>` literal rather than `<ChildName>_<id>_<sN>`. Same
-    // class of test-harness scope-id plumbing the `componentName`
-    // option fixed on the Hono side. Separate follow-up.
-    'toggle-shared',
-    'props-reactivity-comparison',
-  ],
+  // No JSX-render skips: every shared conformance fixture renders to Hono
+  // parity on real Go. Shapes the adapter intentionally refuses at build time
+  // are pinned in `expectedDiagnostics` below.
+  skipJsx: [],
   // Per-fixture build-time contracts for shapes the Go template
   // adapter intentionally refuses to lower. Lives here (not on the
   // shared fixtures) so adding a new adapter doesn't require touching
@@ -1212,6 +1184,33 @@ export function Page() {
       expect(types).not.toContain('template.HTML')
     })
 
+    test('bakes hoisted children={<span/>} with the parent scopeID spliced into bf-s (#1326 / #1335)', () => {
+      // `children` passed as an attribute lands as a `jsx-children` prop and
+      // its span carries `needsScope: true`. The root `bf-s` must resolve to
+      // the *parent* scope at render time, so the bake splices `scopeID`
+      // (matching the client `__BF_PARENT_SCOPE__` placeholder) rather than
+      // emitting a static string or dropping the child.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+export function Host() { return <Box children={<span>x</span>} /> }
+function Box({ children }: { children: any }) { return <div>{children}</div> }
+`)
+      const types = adapter.generateTypes(ir)!
+      expect(types).toContain('Children: template.HTML("<span bf-s=\\"" + scopeID + "\\">x</span>")')
+      expect(types).toContain('"html/template"')
+    })
+
+
+    test('fragment-wrapped hoisted children bake to the same scoped shape (#1335)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+export function Host() { return <Box children={<><span>x</span></>} /> }
+function Box({ children }: { children: any }) { return <div>{children}</div> }
+`)
+      const types = adapter.generateTypes(ir)!
+      expect(types).toContain('Children: template.HTML("<span bf-s=\\"" + scopeID + "\\">x</span>")')
+    })
+
     test('drops dynamic children that would emit Go template actions', () => {
       // V1 limitation: a `template.HTML` value isn't re-parsed by the
       // parent's `{{.Children}}` pipeline, so any `{{...}}` inside the
@@ -2489,6 +2488,42 @@ import { fixture as arrayEntriesFixture } from '../../../adapter-tests/fixtures/
 import { fixture as arrayKeysFixture } from '../../../adapter-tests/fixtures/methods/array-keys'
 import { fixture as arrayValuesFixture } from '../../../adapter-tests/fixtures/methods/array-values'
 
+describe('GoTemplateAdapter - keyed loop-child data-key (#1297, toggle-shared)', () => {
+  // A keyed `.map` of a child component stamps each item's `data-key` from the
+  // loop `key` expression, emitted on the child component's scope root —
+  // matching Hono.
+  // `List` is declared first so `compileToIR` (which picks the first IR)
+  // returns the parent that owns the keyed loop.
+  const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+type ItemProps = { label: string; defaultOn?: boolean }
+export function List({ items }: { items: ItemProps[] }) {
+  return <ul>{items.map((item) => <Item key={item.label} label={item.label} defaultOn={item.defaultOn} />)}</ul>
+}
+function Item(props: ItemProps) {
+  const [on] = createSignal(props.defaultOn ?? false)
+  return <div className="item">{on() ? props.label : ''}</div>
+}
+`
+  test('Props carries a BfDataKey field', () => {
+    const { types } = compileAndGenerate(source)
+    expect(types).toContain('BfDataKey string `json:"-"`')
+  })
+
+  test('loop-child init stamps BfDataKey from the loop key (item.Label)', () => {
+    const { types } = compileAndGenerate(source)
+    expect(types).toContain('[i].BfDataKey = fmt.Sprint(item.Label)')
+    expect(types).toContain('\t"fmt"')
+  })
+
+  test('child component root emits data-key from BfDataKey', () => {
+    const { template } = compileAndGenerate(source)
+    // Space is inside the `{{if}}` so a non-keyed render adds nothing.
+    expect(template).toContain('{{if .BfDataKey}} data-key="{{.BfDataKey}}"{{end}}')
+  })
+})
+
 describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
   const cases = [
     // The `.includes` fixtures sit at condition position

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

@@ -82,6 +82,10 @@ type GoRenderCtx = {
 interface NestedComponentInfo extends IRLoopChildComponent {
   isDynamic: boolean
   isPropDerived: boolean
+  /** The enclosing loop's `key` expression (e.g. `item.label`) and map param
+   *  name (`item`), so the loop-child init can stamp `data-key` per item. */
+  loopKey?: string
+  loopParam?: string
 }
 
 interface StaticChildInstance {
@@ -104,6 +108,16 @@ interface StaticChildInstance {
    *  through the parent's `{{.Children}}` read; those cases stay on
    *  the existing drop path. */
   childrenHtml: string | null
+  /** Go string-concat expression for hoisted-JSX children that carry a
+   *  `needsScope` root (`children={<span/>}` — #1326 / #1335). The root's
+   *  `bf-s` resolves to the PARENT scope (mirroring the client
+   *  `__BF_PARENT_SCOPE__` placeholder + Mojo's begin/end capture), so the
+   *  fragment can't bake to a static string — the runtime `scopeID` is
+   *  spliced in (`"<span bf-s=\"" + scopeID + "\">x</span>"`). Null when the
+   *  static `childrenHtml` path already covers the children, or when any
+   *  other template action survives (genuinely dynamic — kept on the drop
+   *  path). */
+  childrenScopedHtmlExpr: string | null
   /**
    * Context values from enclosing `<Ctx.Provider value>` ancestors
    * (`createContext` identifier → Go value literal), wired into this child
@@ -287,6 +301,48 @@ function capitalize(s: string): string {
   return s[0].toUpperCase() + s.slice(1)
 }
 
+/**
+ * Lower a keyed-loop `key` expression to the Go field path on the loop's range
+ * variable (always `item` in the generated `for i, item := range …`), e.g.
+ * `item.label` → `item.Label`. Returns null for a non-simple key (computed
+ * expression, whole-element key, mismatched param) so the loop-child init just
+ * skips `data-key` rather than emitting something that won't compile. (#1297)
+ */
+function loopKeyToGoFieldPath(key: string | undefined, param: string | undefined): string | null {
+  if (!key || !param) return null
+  const segs = key.split('.')
+  if (segs[0] !== param) return null
+  const rest = segs.slice(1)
+  if (rest.length === 0) return null
+  if (!rest.every(s => /^[A-Za-z_]\w*$/.test(s))) return null
+  return 'item.' + rest.map(capitalize).join('.')
+}
+
+/**
+ * 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. (#1297)
+ */
+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
+}
+
 /**
  * Convert a slot ID (e.g., 's6') to a Go struct field suffix (e.g., 'Slot6').
  * Keeps field names human-readable regardless of the internal slot ID format.
@@ -342,6 +398,11 @@ const GO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
 export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter, IRNodeEmitter<GoRenderCtx> {
   name = 'go-template'
   extension = '.tmpl'
+
+  // Sentinel marking a parent-scope `bf-s` slot inside a hoisted-JSX
+  // children bake (see `extractScopedHtmlChildren`). The token can't appear
+  // in real HTML text, so splitting on it is unambiguous.
+  private static readonly SCOPE_SENTINEL = '__BF_SCOPE_SENTINEL__'
   // Template-string target with no component layer: `bf build` emits a static
   // `barefoot-importmap.html` to `{{ template }}` into the page <head> (#1644).
   importMapInjection = 'html-snippet' as const
@@ -440,6 +501,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   /** Set during type generation when any emit references
    *  `template.HTML(...)`; toggles the `"html/template"` import. */
   private usesHtmlTemplate: boolean = false
+  /** Component root scope element(s) — each carries `data-key` for a keyed loop
+   *  item. A plain element root is one node; an `if-statement` (early-return)
+   *  root contributes the top element of every branch. (#1297) */
+  private rootScopeNodes: Set<IRNode> = new Set()
 
   /** Set during type generation when any emit references
    *  `fmt.Sprint(...)` — e.g. a `Record<staticKeys, scalar>[propKey]`
@@ -566,6 +631,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const isRootComponent = ir.root.type === 'component'
     const isIfStatement = ir.root.type === 'if-statement'
 
+    this.rootScopeNodes = collectRootScopeNodes(ir.root)
     const templateBody = isIfStatement
       ? this.renderIfStatement(ir.root as IRIfStatement, { isRootOfClientComponent: hasInteractivity })
       : this.renderNode(ir.root, { isRootOfClientComponent: hasInteractivity && isRootComponent })
@@ -1343,6 +1409,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Emitted as bf-h / bf-m HTML attributes by `bfHydrationAttrs`.
     lines.push('\tBfParent string `json:"-"`')
     lines.push('\tBfMount string `json:"-"`')
+    // (#1297) Keyed-loop reconciliation key, stamped per item by the parent's
+    // loop init and emitted as `data-key` on this component's scope root.
+    lines.push('\tBfDataKey string `json:"-"`')
 
     // Add Scripts field for dynamic script collection
     lines.push('\tScripts *bf.ScriptCollector `json:"-"`')
@@ -1533,6 +1602,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // mark it as a slot-attached child of this scope.
         lines.push(`\t\t${varName}[i].BfParent = scopeID`)
         lines.push(`\t\t${varName}[i].BfMount = "${nested.slotId}"`)
+        // (#1297) Stamp the keyed-loop `data-key` per item from the loop's
+        // `key` expression (`item.label` → `item.Label`), matching Hono.
+        const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
+        if (keyField) {
+          lines.push(`\t\t${varName}[i].BfDataKey = fmt.Sprint(${keyField})`)
+          this.usesFmt = true
+        }
         lines.push('\t}')
         lines.push('')
       }
@@ -1764,6 +1840,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       } else if (child.childrenHtml !== null) {
         this.usesHtmlTemplate = true
         lines.push(`\t\t\tChildren: template.HTML(${JSON.stringify(child.childrenHtml)}),`)
+      } else if (child.childrenScopedHtmlExpr !== null) {
+        // Hoisted-JSX children with a needsScope root (#1326 / #1335): the
+        // root `bf-s` is the runtime parent scopeID, spliced into the bake.
+        this.usesHtmlTemplate = true
+        lines.push(`\t\t\tChildren: template.HTML(${child.childrenScopedHtmlExpr}),`)
       }
       lines.push(`\t\t}),`)
     }
@@ -1823,6 +1904,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             ...loop.childComponent,
             isDynamic: !loop.isStaticArray,
             isPropDerived: !!loop.isPropDerivedArray,
+            loopKey: loop.key ?? undefined,
+            loopParam: loop.param ?? undefined,
           })
         }
       }
@@ -1890,6 +1973,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    *     "drop children" fallback. Dynamic / component-bearing children
    *     stay on the drop path until a re-evaluation hook lands.
    */
+  /**
+   * Pull the IR nodes out of a `children={<…/>}` attribute (a `jsx-children`
+   * prop value). Empty when the component takes no such prop. (#1326 / #1335)
+   */
+  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
@@ -1898,6 +1992,38 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return html
   }
 
+  /**
+   * Build a Go string-concat expression for hoisted-JSX children whose root
+   * carries `needsScope` (`children={<span/>}` — #1326 / #1335). Such roots
+   * render in the PARENT's scope, so their `bf-s` is the runtime parent
+   * `scopeID`, not a bake-time constant. We render the fragment, swap the
+   * parent-scope hydration marker for a sentinel, and splice `scopeID` back
+   * in. Returns null when the plain static `childrenHtml` path already
+   * applies, or when any other template action survives (genuinely dynamic —
+   * those stay on the drop path).
+   */
+  private extractScopedHtmlChildren(children: IRNode[]): string | null {
+    if (children.length === 0) return null
+    if (children.every(c => c.type === 'text')) return null
+    const html = this.renderChildren(children)
+    // The needsScope marker renders parent-scope hydration attrs; in a
+    // hoisted fragment every needsScope root resolves to the parent scopeID,
+    // so collapse the whole marker to a bare `bf-s` sentinel (the empty
+    // bf-h / bf-m attrs are dropped — same shape the client emits).
+    const marker = this.renderScopeMarker('.ScopeID')
+    const withSentinel = html
+      .split(marker)
+      .join(`bf-s="${GoTemplateAdapter.SCOPE_SENTINEL}"`)
+    // No sentinel → no needsScope root → the static childrenHtml path covers it.
+    if (!withSentinel.includes(GoTemplateAdapter.SCOPE_SENTINEL)) return null
+    // Any surviving action means the fragment is genuinely dynamic.
+    if (withSentinel.includes('{{')) return null
+    return withSentinel
+      .split(GoTemplateAdapter.SCOPE_SENTINEL)
+      .map(seg => JSON.stringify(seg))
+      .join(' + scopeID + ')
+  }
+
   private collectStaticChildInstancesRecursive(
     node: IRNode,
     result: StaticChildInstance[],
@@ -1920,13 +2046,21 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // Skip components inside loops (handled by nestedComponents)
       if (comp.name !== 'Portal' && !inLoop && comp.slotId) {
         const suffix = slotIdToFieldSuffix(comp.slotId)
+        // Children handed in as a `children={<…/>}` attribute (#1326 / #1335)
+        // land as a `jsx-children` prop rather than nested between the tags;
+        // treat them as the child's effective children when no nested ones
+        // exist, so the bake paths below see them.
+        const effectiveChildren = comp.children.length > 0
+          ? comp.children
+          : this.jsxChildrenPropNodes(comp.props)
         result.push({
           name: comp.name,
           slotId: comp.slotId,
           props: comp.props,
           fieldName: `${comp.name}${suffix}`,
-          childrenText: this.extractTextChildren(comp.children),
-          childrenHtml: this.extractHtmlChildren(comp.children),
+          childrenText: this.extractTextChildren(effectiveChildren),
+          childrenHtml: this.extractHtmlChildren(effectiveChildren),
+          childrenScopedHtmlExpr: this.extractScopedHtmlChildren(effectiveChildren),
           contextBindings: providerCtx.size > 0 ? providerCtx : undefined,
         })
       }
@@ -3664,6 +3798,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker('.ScopeID')}`
     }
+    // (#1297) 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. Mirrors Hono stamping data-key on each loop item's scope root,
+    // including early-return (if-statement) roots where every branch's top
+    // element qualifies.
+    if (this.rootScopeNodes.has(element) && element.needsScope) {
+      hydrationAttrs += `{{if .BfDataKey}} data-key="{{.BfDataKey}}"{{end}}`
+    }
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`
     }
@@ -5711,7 +5853,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `{{block "${slotName}" .}}{{end}}`
   }
 
-  renderAsync(node: IRAsync): string {
+  override renderAsync(node: IRAsync): string {
     const fallback = this.renderNode(node.fallback)
     const children = this.renderChildren(node.children)
     // Go templates use the OOS protocol: render a placeholder with fallback,

package/src/adapter/index.ts

@@ -2,5 +2,5 @@
  * Go html/template Adapter Exports
  */
 
-export { GoTemplateAdapter, goTemplateAdapter } from './go-template-adapter'
-export type { GoTemplateAdapterOptions } from './go-template-adapter'
+export { GoTemplateAdapter, goTemplateAdapter } from './go-template-adapter.ts'
+export type { GoTemplateAdapterOptions } from './go-template-adapter.ts'

package/src/build.ts

@@ -1,8 +1,8 @@
 // Go template build config factory for barefoot.config.ts
 
 import type { BuildOptions, PostBuildContext } from '@barefootjs/jsx'
-import { GoTemplateAdapter } from './adapter'
-import type { GoTemplateAdapterOptions } from './adapter'
+import { GoTemplateAdapter } from './adapter/index.ts'
+import type { GoTemplateAdapterOptions } from './adapter/index.ts'
 
 export interface GoTemplateBuildOptions extends BuildOptions {
   /** Adapter-specific options passed to GoTemplateAdapter */
@@ -156,13 +156,26 @@ export function combineGoTypes(options: {
     combinedContent = transformTypes(combinedContent)
   }
 
+  // Conditionally pull in stdlib packages the combined component code uses.
+  // Per-component import blocks are stripped above, so the merged file needs
+  // its own block — `fmt` (e.g. `fmt.Sprint` for keyed-loop data-key /
+  // indexed-map spread) and `html/template` (`template.HTML` for forwarded
+  // JSX children) are only imported when actually referenced, so an app that
+  // uses neither doesn't get an "imported and not used" error.
+  const usageScan = combinedContent + '\n' + (manualTypes ?? '')
+  const stdlibImports: string[] = [`\t"math/rand"`]
+  if (/\bfmt\./.test(usageScan)) stdlibImports.push(`\t"fmt"`)
+  if (/\btemplate\.HTML\b/.test(usageScan)) stdlibImports.push(`\t"html/template"`)
+  // gofmt sorts the stdlib group alphabetically by import path.
+  stdlibImports.sort()
+
   // Build final file
   const parts = [
     `// Code generated by BarefootJS. DO NOT EDIT.`,
     `package ${packageName}`,
     '',
     `import (`,
-    `\t"math/rand"`,
+    ...stdlibImports,
     '',
     `\tbf "github.com/barefootjs/runtime/bf"`,
     `)`,

package/src/index.ts

@@ -4,5 +4,5 @@
  * Generates Go html/template files from BarefootJS IR.
  */
 
-export { GoTemplateAdapter, goTemplateAdapter } from './adapter'
-export type { GoTemplateAdapterOptions } from './adapter'
+export { GoTemplateAdapter, goTemplateAdapter } from './adapter/index.ts'
+export type { GoTemplateAdapterOptions } from './adapter/index.ts'

package/src/test-render.ts

@@ -7,6 +7,20 @@
 
 import { compileJSX } from '@barefootjs/jsx'
 import type { TemplateAdapter, ComponentIR } from '@barefootjs/jsx'
+import { GoTemplateAdapter } from './adapter/go-template-adapter.ts'
+
+/**
+ * Capitalize a JSON key to its Go struct field name using the same
+ * initialism rules as the adapter (`capitalizeFieldName`): a whole-word Go
+ * initialism uppercases entirely (`id` → `ID`), otherwise just the first
+ * letter. Keeps harness-emitted struct literals (`ItemInput{ID: …}`) matching
+ * the generated exported field names. (#1297)
+ */
+function capitalizeGoField(name: string): string {
+  if (!name) return name
+  if (GoTemplateAdapter.GO_INITIALISMS.has(name.toLowerCase())) return name.toUpperCase()
+  return name.charAt(0).toUpperCase() + name.slice(1)
+}
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -59,10 +73,17 @@ export interface RenderOptions {
   props?: Record<string, unknown>
   /** Additional component files (filename → source) */
   components?: Record<string, string>
+  /**
+   * Explicit component to render when `source` declares multiple
+   * exports (e.g. `ReactiveProps.tsx` → `PropsReactivityComparison`).
+   * Mirrors the Hono reference's `componentName`; omitted for
+   * single-export fixtures, which fall back to the default/first export.
+   */
+  componentName?: string
 }
 
 export async function renderGoTemplateComponent(options: RenderOptions): Promise<string> {
-  const { source, adapter, props, components } = options
+  const { source, adapter, props, components, componentName: requestedName } = options
 
   if (!adapter.generateTypes) {
     throw new Error('Go Template adapter must implement generateTypes()')
@@ -139,7 +160,13 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
   const irFiles = result.files.filter(f => f.type === 'ir')
   if (irFiles.length === 0) throw new Error('No IR output (set outputIR: true)')
   const irs = irFiles.map(f => JSON.parse(f.content) as ComponentIR)
+  // Explicit `componentName` wins (multi-export sources pin which export
+  // is the render target); otherwise default-export, then first inline-
+  // exported, then first IR. Mirrors the Hono reference's selection so
+  // multi-component fixtures (e.g. `ReactiveProps.tsx`) render the same
+  // export across adapters.
   const ir =
+    (requestedName ? irs.find(i => i.metadata.componentName === requestedName) : undefined) ??
     irs.find(i => i.metadata.hasDefaultExport) ??
     irs.find(i => i.metadata.isExported) ??
     irs[0]
@@ -246,8 +273,9 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     // template content as Go raw string
     const escapedTemplate = template.replace(/`/g, '` + "`" + `')
 
-    // Build props initialization
-    const propsInit = buildGoPropsInit(componentName, props, ir)
+    // Build props initialization (typed against the generated Input struct so
+    // an array-of-objects prop emits e.g. `[]ToggleItemInput{…}`, not `[]any`).
+    const propsInit = buildGoPropsInit(componentName, props, ir, goTypes)
 
     // Honour `__instanceId` from props for the root scope id so
     // shared-component fixtures (which pin `<ComponentName>_test`) match
@@ -457,9 +485,10 @@ function ensureMergedStdlibImports(goTypes: string): string {
  * Build Go struct field initializers from props.
  */
 function buildGoPropsInit(
-  _componentName: string,
+  componentName: string,
   props?: Record<string, unknown>,
   ir?: ComponentIR,
+  goTypes?: string,
 ): string {
   if (!props) return ''
 
@@ -504,16 +533,25 @@ function buildGoPropsInit(
     } else if (typeof value === 'boolean') {
       lines.push(`\t\t${goField}: ${value},`)
     } else if (Array.isArray(value)) {
-      // Array → Go `[]any` literal. Fixtures that exercise
-      // array-receiver methods (`items.every(...)`, `items.join(' - ')`,
-      // etc. — #1448 method catalog) need the prop value to reach
-      // the rendered template as a real slice so `range .Items` /
-      // `bf_join (.Items) ...` see actual elements; without this
-      // branch the prop was silently dropped, the input-struct
-      // field stayed at its zero value, and the template rendered
-      // empty content alongside the expected wrappers (the bug
-      // surfaced as "expected 'idx: 1' / got 'idx:'" on CI).
-      lines.push(`\t\t${goField}: ${goArrayLiteralFromArray(value)},`)
+      // Array → Go slice literal. Fixtures that exercise array-receiver
+      // methods (`items.every(...)`, `items.join(' - ')`, etc. — #1448
+      // method catalog) need the prop value to reach the rendered template
+      // as a real slice so `range .Items` / `bf_join (.Items) ...` see
+      // actual elements.
+      //
+      // When the Input field is a typed slice (`ToggleItems
+      // []ToggleItemInput`, a loop-child array prop), emit a matching
+      // typed literal (`[]ToggleItemInput{ToggleItemInput{Label: …}, …}`);
+      // a bare `[]any{…}` would fail to compile against the typed field.
+      // Fall back to `[]any` when the field type is `[]any` / unknown.
+      const elemType = goSliceElemType(goTypes, componentName, goField)
+      lines.push(
+        `\t\t${goField}: ${
+          elemType
+            ? goTypedSliceLiteralFromArray(value, elemType)
+            : goArrayLiteralFromArray(value)
+        },`,
+      )
     } else if (value && typeof value === 'object') {
       // Plain object → Go `map[string]any` literal (#1407 follow-up).
       // Used by `jsx-spread-rest-prop` to populate the input-bag
@@ -533,6 +571,66 @@ function buildGoPropsInit(
   return lines.join('\n')
 }
 
+/**
+ * Look up the element type of a typed slice field on the entry component's
+ * `<Component>Input` struct (e.g. `ToggleItems []ToggleItemInput` →
+ * `ToggleItemInput`). Returns null when the field is absent, isn't a slice, or
+ * is an untyped `[]any` / `[]interface{}` (those keep the generic `[]any`
+ * harness literal). (#1297, toggle-shared)
+ */
+function goSliceElemType(
+  goTypes: string | undefined,
+  componentName: string,
+  goField: string,
+): string | null {
+  if (!goTypes) return null
+  const struct = goTypes.match(
+    new RegExp(`type ${componentName}Input struct \\{([\\s\\S]*?)\\n\\}`),
+  )
+  if (!struct) return null
+  const field = struct[1].match(new RegExp(`\\n\\s*${goField}\\s+\\[\\]([\\w.]+)`))
+  if (!field) return null
+  const elem = field[1]
+  if (elem === 'any' || elem === 'interface{}') return null
+  return elem
+}
+
+/**
+ * Emit a typed Go slice literal (`[]Elem{Elem{…}, …}`). Object elements become
+ * keyed struct literals with PascalCase field names; scalar elements (for an
+ * `[]string` / `[]int` field) are emitted bare. (#1297, toggle-shared)
+ */
+function goTypedSliceLiteralFromArray(arr: unknown[], elemType: string): string {
+  const entries = arr.map(v => {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      return goStructLiteral(v as Record<string, unknown>, elemType)
+    }
+    if (typeof v === 'string') return `"${v.replace(/"/g, '\\"')}"`
+    if (typeof v === 'number' || typeof v === 'boolean') return String(v)
+    if (v === null) return 'nil'
+    return goArrayLiteralFromArray(v as unknown[])
+  })
+  return `[]${elemType}{${entries.join(', ')}}`
+}
+
+/**
+ * Emit a keyed Go struct literal (`Elem{Field: val, …}`) with PascalCase field
+ * names. Only the keys the caller supplied are set, so an omitted optional prop
+ * (e.g. `defaultOn` on the third toggle item) takes the Go zero value. (#1297)
+ */
+function goStructLiteral(obj: Record<string, unknown>, typeName: string): string {
+  const fields: string[] = []
+  for (const [k, v] of Object.entries(obj)) {
+    const goField = capitalizeGoField(k)
+    if (typeof v === 'string') fields.push(`${goField}: "${v.replace(/"/g, '\\"')}"`)
+    else if (typeof v === 'number' || typeof v === 'boolean') fields.push(`${goField}: ${v}`)
+    else if (v === null) fields.push(`${goField}: nil`)
+    else if (Array.isArray(v)) fields.push(`${goField}: ${goArrayLiteralFromArray(v)}`)
+    else if (v && typeof v === 'object') fields.push(`${goField}: ${goMapLiteralFromObject(v as Record<string, unknown>, true)}`)
+  }
+  return `${typeName}{${fields.join(', ')}}`
+}
+
 function goArrayLiteralFromArray(arr: unknown[]): string {
   const entries: string[] = []
   for (const v of arr) {