@barefootjs/go-template 0.18.5 → 0.19.0

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

@@ -66,6 +66,15 @@ export class CompileState {
    */
   localConstants: IRMetadata['localConstants'] = []
 
+  /**
+   * Every name a `.map()`/`.filter()` loop callback binds as its item/index
+   * parameter anywhere in the component (#2208 fable review). Consulted by
+   * static loop-source resolution (`getBakedStaticChildLoop`) so a const
+   * whose name a DIFFERENT, enclosing loop's own callback param shadows is
+   * never resolved as that const's static value.
+   */
+  staticLoopSourceBoundNames: Set<string> = new Set()
+
   /**
    * Names of component-scope arrow-const helpers (`const sortClass = …`),
    * eligible for call-site inlining.
@@ -137,6 +146,24 @@ export class CompileState {
    */
   nillablePropNames: Set<string> = new Set()
 
+  /**
+   * OPTIONAL prop names consumed nullish-sensitively (`??` left operand in a
+   * parsed expression tree, or a signal's `props.X ?? <literal>` seed) —
+   * #2248. Consulted by `resolvePropGoType` to flip an optional scalar to the
+   * nillable `interface{}` representation, so it MUST be populated before the
+   * first `resolvePropGoType` call of a compile (see `generate()`'s ordering
+   * against `collectNillablePropNames`).
+   */
+  nullishConsumedPropNames: Set<string> = new Set()
+
+  /**
+   * OPTIONAL no-default prop names consumed as a BARE omittable-attribute
+   * value (`rows={rows}`) — #2259. Same `resolvePropGoType` flip and same
+   * populate-before-first-resolve ordering as `nullishConsumedPropNames`:
+   * the attribute-omission guard (`{{if ne .X nil}}`) needs a nillable field.
+   */
+  omittableAttrConsumedPropNames: Set<string> = new Set()
+
   /**
    * String-typed signal getter / prop names (#2168 string-concat-plus).
    * Feeds `isStringName` for `isStringConcatBinary`, which decides whether a

package/src/adapter/lib/types.ts

@@ -140,6 +140,15 @@ export interface PropFallbackVar {
   goFallback: string
   /** Go zero literal for the prop's type (`0`, `""`, etc.). */
   zeroLiteral: string
+  /**
+   * Set when the prop lowered to the nillable `interface{}` representation
+   * (#2248): the concrete scalar Go type (`string`/`int`/`float64`/`bool`)
+   * the constructor materializes the hoisted local as. Presence switches
+   * the emission from the zero-value check (`if v == 0`) to a nil check
+   * (`if in.X != nil`), which is what makes an explicit `''`/`0` input
+   * distinguishable from an absent one.
+   */
+  assertType?: string
 }
 
 /**

package/src/adapter/props/prop-classes.ts

@@ -7,7 +7,7 @@
  * function over `ir.metadata`; no adapter instance state.
  */
 
-import type { ComponentIR, TypeInfo } from '@barefootjs/jsx'
+import { collectLoopBoundNames, type ComponentIR, type TypeInfo } from '@barefootjs/jsx'
 
 /** True when `type` is the `string` primitive. */
 function isStringTypeInfo(type: TypeInfo): boolean {
@@ -22,14 +22,33 @@ function isBareStringLiteral(initialValue: string | undefined): boolean {
 }
 
 /**
- * String-typed signals and props. A signal is string-typed when its inferred
- * type is `string` (or, defensively, when its initial value is a bare string
- * literal); a prop when its annotated type is `string`. Drives `isStringName`
- * for `isStringConcatBinary` — the shared helper (`@barefootjs/jsx`) that
- * decides whether a JS `+` is string concatenation rather than numeric
- * addition (Go's `html/template` has no native `+` at all; `binary()` always
- * emits a runtime call, `bf_add` for addition or `bf_concat_str` for
- * concatenation — see `go-template-adapter.ts`'s `binary()`).
+ * String-typed signals, props, and same-file local consts (#2212, ported
+ * here for #2236). A signal is string-typed when its inferred type is
+ * `string` (or, defensively, when its initial value is a bare string
+ * literal); a prop when its annotated type is `string`; a local const the
+ * same way. Drives `isStringName` for `isStringConcatBinary` — the shared
+ * helper (`@barefootjs/jsx`) that decides whether a JS `+` is string
+ * concatenation rather than numeric addition (Go's `html/template` has no
+ * native `+` at all; `binary()` always emits a runtime call, `bf_add` for
+ * addition or `bf_concat_str` for concatenation — see
+ * `go-template-adapter.ts`'s `binary()`). Local consts matter for exactly
+ * the shadowing shape this exclusion exists for: with a loop-bound `label`
+ * subtracted, an outer `{label + suffix}` (where `suffix = '!'`) must
+ * still classify as string concat via its OTHER operand, or it would fall
+ * back to `bf_add` and render `0`.
+ *
+ * Excludes any name bound as a `.map()`/`.filter()` loop callback's item or
+ * index parameter ANYWHERE in the component (#2212, ported here for #2236):
+ * this lookup is a flat, scope-blind `Set<string>` with no notion of a loop
+ * param shadowing an outer string-typed binding of the same name
+ * (`values.map((label) => 1 + label)` inside a component that also has a
+ * string `label` prop) — left unguarded, that shadowed `label` would be
+ * misdetected as string-typed and `1 + label` would silently lower to
+ * `bf_concat_str` instead of staying numeric `bf_add`. Subtracting loop-bound
+ * names is coarse (it also suppresses a genuinely non-shadowed same-named
+ * string elsewhere in the component) but safe: the suppressed case just
+ * falls back to today's numeric `bf_add` — the same, already-accepted
+ * residual as an unresolvable operand — never silently-wrong output.
  */
 export function collectStringValueNames(ir: ComponentIR): Set<string> {
   const names = new Set<string>()
@@ -41,5 +60,11 @@ export function collectStringValueNames(ir: ComponentIR): Set<string> {
   for (const p of ir.metadata.propsParams) {
     if (isStringTypeInfo(p.type)) names.add(p.name)
   }
+  for (const c of ir.metadata.localConstants) {
+    if ((c.type !== null && isStringTypeInfo(c.type)) || isBareStringLiteral(c.value)) {
+      names.add(c.name)
+    }
+  }
+  for (const bound of collectLoopBoundNames(ir)) names.delete(bound)
   return names
 }

package/src/adapter/props/prop-types.ts

@@ -6,6 +6,7 @@
  */
 
 import type { ComponentIR, IRMetadata, IRNode, ParsedExpr } from '@barefootjs/jsx'
+import { isBooleanAttr } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
@@ -20,7 +21,7 @@ export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map
   const overrides = new Map<string, string>()
   for (const signal of ir.metadata.signals) {
     const propNames = [signal.initialValue]
-    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue)
+    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue, signal.parsed)
     if (extracted) propNames.push(extracted)
 
     for (const propName of propNames) {
@@ -106,6 +107,151 @@ function collectToFixedPropNames(root: IRNode): Set<string> {
   return names
 }
 
+/**
+ * Concrete scalar Go types eligible for the nullish (`??`) nillable flip in
+ * `resolvePropGoType`. Only these can round-trip through an `interface{}`
+ * field and back via a constructor type assertion / `bf.ToInt`-style
+ * coercion (see the fallback-var emission in `generateNewPropsFunction`).
+ */
+export const NULLISH_SCALAR_GO_TYPES: ReadonlySet<string> = new Set(['string', 'int', 'float64', 'bool'])
+
+/**
+ * Names of OPTIONAL props consumed nullish-sensitively — the left operand of
+ * a `??` anywhere in the component's parsed expression trees, or a signal's
+ * `props.X ?? <literal>` initial value (#2248).
+ *
+ * Why this matters: JS `??` falls back only on `null`/`undefined`, keeping
+ * `''`/`0`/`false`. A Go zero-valued scalar field cannot represent "absent",
+ * so a `??`-consumed optional scalar must lower to the adapter's established
+ * nillable representation (`interface{}`) for the distinction to exist at
+ * render time. `resolvePropGoType` applies that flip using this set.
+ *
+ * The IR walk is generic (any nested object/array is descended, so parsed
+ * trees inside expressions, conditions, attributes, and loops are all seen)
+ * and the match is shape-precise: `identifier` left (destructured props) or
+ * `<propsObject>.<name>` member left. KNOWN LIMITATION (same class as
+ * `collectToFixedPropNames`): an `identifier` left shadowed by a same-named
+ * loop/callback param is misattributed to the prop — the flip is then merely
+ * unnecessary, not incorrect.
+ */
+export function collectNullishConsumedPropNames(ctx: GoEmitContext, ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  // A destructure default (`{ className = '' }`) means the binding is never
+  // nullish in JS — the default already applied — so such props never need
+  // the nillable flip (and `applyGoFallback`'s concrete-typed baking relies
+  // on them staying concrete).
+  const optionalParams = new Set(
+    ir.metadata.propsParams.filter(p => p.optional && p.defaultValue == null).map(p => p.name),
+  )
+  if (optionalParams.size === 0) return names
+
+  const propsObject = ctx.state.propsObjectName
+  const propNameOfLeft = (left: ParsedExpr): string | null => {
+    if (left.kind === 'identifier') return left.name
+    if (
+      left.kind === 'member' &&
+      !left.computed &&
+      left.object.kind === 'identifier' &&
+      left.object.name === propsObject
+    ) {
+      return left.property
+    }
+    return null
+  }
+
+  // `?? <zero-equivalent literal>` (`?? ''`, `?? 0`, `?? false`) is the one
+  // shape where nullish and truthiness semantics coincide — nil and the zero
+  // value both land on the same output — so it earns no flip. Only a
+  // fallback the zero value must NOT collapse into makes the distinction
+  // observable.
+  const isZeroEquivalentLiteral = (right: ParsedExpr): boolean =>
+    right.kind === 'literal' &&
+    (right.value === '' || right.value === false || right.value === null ||
+      (right.literalType === 'number' && Number(right.value) === 0))
+
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item)
+      return
+    }
+    const rec = node as Record<string, unknown>
+    if (rec.kind === 'logical' && rec.op === '??' && rec.left && rec.right) {
+      const propName = propNameOfLeft(rec.left as ParsedExpr)
+      if (propName && optionalParams.has(propName) && !isZeroEquivalentLiteral(rec.right as ParsedExpr)) {
+        names.add(propName)
+      }
+    }
+    for (const value of Object.values(rec)) walk(value)
+  }
+  walk(ir.root)
+
+  // Signal seeds (`createSignal(props.X ?? 1)`) live in metadata, not the
+  // tree — reuse the seam's existing `props.X ?? <literal>` recognizer. The
+  // zero-equivalent exclusion matches on the Go-formatted fallback literal.
+  for (const signal of ir.metadata.signals) {
+    const match = ctx.extractPropFallback(signal.initialValue, signal.parsed)
+    if (!match || !optionalParams.has(match.propName)) continue
+    const f = match.goFallback
+    if (f === '""' || f === 'false' || f === 'nil' || Number(f) === 0) continue
+    names.add(match.propName)
+  }
+  return names
+}
+
+/**
+ * Names of OPTIONAL no-default props consumed as the BARE value of an
+ * omittable attribute (`rows={rows}` / `rows={props.rows}`) anywhere in the
+ * component's element tree.
+ *
+ * Why this matters: Hono omits an attribute whose value is `undefined`, and
+ * the adapter's `emitExpression` mirrors that with a `{{if ne .X nil}}` guard
+ * — which needs a nillable field to test. A concrete scalar field would
+ * render the zero value (`rows="0"`) instead of dropping the attribute, so
+ * these props take the same `interface{}` flip as `??` consumption
+ * (`resolvePropGoType`). The match mirrors `emitExpression`'s guard branch:
+ * bare identifiers / `<propsObject>.<name>` only, skipping `class`/`style`
+ * (own lowerings) and boolean/presence attrs (truthiness-tested, where a nil
+ * and a zero value already coincide). Same shadowing caveat as
+ * `collectNullishConsumedPropNames`: a same-named loop/callback param can
+ * misattribute, making the flip merely unnecessary, not incorrect.
+ */
+export function collectOmittableAttrConsumedPropNames(ctx: GoEmitContext, ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  const optionalParams = new Set(
+    ir.metadata.propsParams.filter(p => p.optional && p.defaultValue == null).map(p => p.name),
+  )
+  if (optionalParams.size === 0) return names
+
+  const propsObject = ctx.state.propsObjectName
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item)
+      return
+    }
+    const rec = node as Record<string, unknown>
+    if (rec.type === 'element' && Array.isArray(rec.attrs)) {
+      for (const attr of rec.attrs as Array<{ name: string; value: Record<string, unknown> }>) {
+        if (attr.name === 'class' || attr.name === 'className' || attr.name === 'style') continue
+        if (isBooleanAttr(attr.name)) continue
+        if (attr.value?.kind !== 'expression' || attr.value.presenceOrUndefined) continue
+        const bareId = String(attr.value.expr ?? '').trim()
+        const propName =
+          propsObject && bareId.startsWith(`${propsObject}.`)
+            ? bareId.slice(propsObject.length + 1)
+            : bareId
+        if (/^[A-Za-z_$][\w$]*$/.test(propName) && optionalParams.has(propName)) {
+          names.add(propName)
+        }
+      }
+    }
+    for (const value of Object.values(rec)) walk(value)
+  }
+  walk(ir.root)
+  return names
+}
+
 /**
  * Resolve a prop param's Go struct-field type using the SAME logic
  * `generatePropsStruct` / `generateInputStruct` use: a `propTypeOverrides` entry
@@ -131,6 +277,37 @@ export function resolvePropGoType(
   if (param.optional && ctx.state.localStructFields.has(base)) {
     return 'map[string]interface{}'
   }
+  // An OPTIONAL scalar prop consumed by `??` lowers to `interface{}` (#2248):
+  // a zero-valued `string`/`int` field cannot distinguish "absent" from
+  // `''`/`0`, so JS nullish semantics (which KEEP `''`/`0`) are unexpressible
+  // on the concrete type. `interface{}` is the adapter's established nillable
+  // representation; the `??` template lowering then tests nil-ness via
+  // `bf_nullish` and the constructor seeds via a nil check + assertion.
+  // Assignment ergonomics are unchanged (plain literals assign into
+  // `interface{}`), and the prop joins the existing nillable behaviours
+  // (bare-attribute omission) by construction.
+  //
+  // Gated to `kind: 'primitive'` — a string-union prop
+  // (`placement?: 'top' | 'bottom'`) must stay its scalar Go type (the same
+  // invariant the struct-map gate above documents): the union-typed
+  // class-composition lowerings key off the concrete type, AND the flip
+  // would buy nothing — the zero value (`""`) is never a legal union
+  // member, so the zero-check already coincides with nullish semantics for
+  // every valid input. (A literal-number union containing 0 would be the
+  // exception; none exists in the corpus and the conflation is the
+  // documented pre-#2248 trade-off there.)
+  // A bare-attribute consumption (`rows={rows}`) takes the same flip (#2259):
+  // attribute omission for an absent optional needs a nil to test — see
+  // `collectOmittableAttrConsumedPropNames`.
+  if (
+    param.optional &&
+    param.type.kind === 'primitive' &&
+    (ctx.state.nullishConsumedPropNames.has(param.name) ||
+      ctx.state.omittableAttrConsumedPropNames.has(param.name)) &&
+    NULLISH_SCALAR_GO_TYPES.has(base)
+  ) {
+    return 'interface{}'
+  }
   return base
 }
 

package/src/adapter/value/value-lowering.ts

@@ -32,7 +32,7 @@ export function convertInitialValue(
     }
   }
 
-  const propName = ctx.extractPropNameFromInitialValue(value)
+  const propName = ctx.extractPropNameFromInitialValue(value, preParsed)
   if (propName && propsParams?.some(p => p.name === propName)) {
     return `in.${capitalizeFieldName(propName)}`
   }

package/src/conformance-pins.ts

@@ -15,19 +15,21 @@ export const conformancePins: ConformancePins = {
   // `style={{ … }}` object literal now lowers to a CSS string with dynamic
   // values interpolated (`background-color:{{.Color}};padding:8px`) via
   // `tryLowerStyleObject` (#1322).
-  // Sibling-imported child component inside a loop body: the adapter
-  // emits `{{template "X" .}}` which only resolves if the user has
-  // compiled the sibling file and registered the template on the
-  // same instance. BF103 makes that requirement loud. (The barefoot
-  // CLI passes `siblingTemplatesRegistered: true` so CLI builds
-  // suppress the diagnostic — see compileJSX `siblingTemplatesRegistered`.)
-  'static-array-children': [{ code: 'BF103', severity: 'error' }],
-  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-  // call it inside a keyed `.map`. Same BF103 surface as
-  // `static-array-children` above — pinned at adapter level so the
-  // shared-component corpus stays adapter-neutral.
-  'todo-app': [{ code: 'BF103', severity: 'error' }],
-  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // `todo-app` / `todo-app-ssr` no longer pinned (#2205) — the conformance
+  // harness now passes `siblingTemplatesRegistered: true` for fixtures with
+  // sibling `components`, matching `bf build`'s real semantics, so the
+  // BF103 loop-body cross-template check no longer fires spuriously.
+  // (`todo-app-ssr` is still skipped on this adapter via
+  // `render-divergences.ts` — #2209 — for an unrelated signal-seeding gap;
+  // `todo-app`'s pre-hydration empty render is unaffected.)
+  // `static-array-children` no longer pinned (#2208) — `items`'s
+  // array-literal initializer is now recognized as fully-static and its
+  // per-item ListItem props/data-key are baked directly into
+  // `NewStaticListProps`'s constructor (`analyzeBakeableStaticChildLoop`),
+  // since the loop body is a single child component with a plain-value
+  // prop set. See #2224 for the narrower remaining gap (a plain-ELEMENT
+  // loop body over a static array, or an inline/unnamed array literal —
+  // still refused).
   // `([emoji, users]) => ...` is an array-index tuple destructure — #2087
   // Phase B's widened gate now admits this shape (`destructure-array-index-in-map`
   // exercises the same `segments`-based lowering). The remaining refusal here
@@ -40,13 +42,11 @@ export const conformancePins: ConformancePins = {
   // array bound to such a const. See the `renderLoop` comment at the check
   // site; Jinja / ERB apply the same narrow check for the same reason.
   'static-array-from-props': [{ code: 'BF101', severity: 'error' }],
-  // Same computed-const array as above, plus the pre-existing BF103 (a
-  // sibling-imported child component used inside the loop body) — the
-  // destructure param itself no longer contributes a diagnostic.
-  'static-array-from-props-with-component': [
-    { code: 'BF103', severity: 'error' },
-    { code: 'BF101', severity: 'error' },
-  ],
+  // Same computed-const array as above — the destructure param itself no
+  // longer contributes a diagnostic, and BF103 (sibling-imported child
+  // component in the loop body) no longer fires either now that the
+  // conformance harness passes `siblingTemplatesRegistered: true` (#2205).
+  'static-array-from-props-with-component': [{ code: 'BF101', severity: 'error' }],
   // (`style-3-signals` graduated alongside `style-object-dynamic` — see note
   // above; the `style={{ … }}` object now lowers to a CSS string.)
   // (`tagged-template-classname` graduated by #2092 — the tag resolves
@@ -127,15 +127,14 @@ export const conformancePins: ConformancePins = {
   // `string-trim` no longer pinned — pre-existing `bf_trim`
   // (wraps `strings.TrimSpace`) handles the strip (#1448 Tier A
   // ninth PR, closing out Tier A).
-  // #2073 follow-up: a function-reference `.map(format)` callback has no
-  // arrow body to serialize — not a CALLBACK_METHODS shape — so the
-  // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
-  // a broken template.
-  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `dangerouslySetInnerHTML` requires a
-  // deliberate raw-HTML (unescaped) output affordance in the target
-  // template language. No lowering exists yet, so the compiler refuses
-  // the shape loudly instead of emitting entity-escaped markup that
-  // silently renders tags as text.
-  'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
+  // `array-map-function-reference` no longer pinned — a bare-identifier
+  // `.map(format)` callback now resolves one hop to its declaration
+  // (`resolveCallbackMethodFunctionReferences`, #2206), the same mechanism
+  // #2090 established for `.sort(fnref)`.
+  // `dangerous-inner-html` no longer pinned — a compile-time string-literal
+  // `dangerouslySetInnerHTML={{ __html: '...' }}` is spliced directly into
+  // the template as trusted raw text (`resolveDangerousInnerHtml`, #2207).
+  // A dynamic/signal-derived value still refuses with BF101 — see the
+  // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2215).
+  'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2215' }],
 }

package/src/render-divergences.ts

@@ -17,4 +17,16 @@
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
+  // `todo-app-ssr` no longer diverges (#2209). Two parts: (1) `.Todos`
+  // (the loop's DATUM slice) is already seeded straight from the caller's
+  // Input — the constructor derives it from `initialTodos`, and `[]Todo`
+  // zero-fills `Editing: false`, so the `.map(t => ({ ...t, editing:
+  // false }))` transform in the signal initializer was never actually the
+  // gap on Go, unlike the 7 template-string adapters. (2) The real gap was
+  // `.TodoItems []TodoItemProps` — the loop-body CHILD COMPONENT slice the
+  // template actually ranges over — which has no server-side population
+  // path in this harness (documented as route-handler-populated in
+  // production). `buildDynamicChildLoopSeeding` (this package's
+  // `test-render.ts`) now replicates that documented contract for a
+  // signal-backed dynamic child-component loop.
 }

package/src/test-render.ts

@@ -6,10 +6,12 @@
  */
 
 import { compileJSX } from '@barefootjs/jsx'
-import type { TemplateAdapter, ComponentIR } from '@barefootjs/jsx'
+import type { TemplateAdapter, ComponentIR, ParsedExpr } from '@barefootjs/jsx'
 import { GoTemplateAdapter } from './adapter/go-template-adapter.ts'
 import { deduplicateGoTypes } from './build.ts'
-import { capitalizeFieldName, goFieldNameForKey } from './adapter/lib/go-naming.ts'
+import { capitalizeFieldName, goFieldNameForKey, loopKeyToGoFieldPath } from './adapter/lib/go-naming.ts'
+import { findNestedComponents } from './adapter/analysis/component-tree.ts'
+import type { NestedComponentInfo } from './adapter/lib/types.ts'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -157,8 +159,15 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     }
   }
 
-  // Compile parent source
-  const result = compileJSX(source, 'component.tsx', { adapter, outputIR: true })
+  // Compile parent source. `siblingTemplatesRegistered: Boolean(components)`
+  // matches this harness's real behavior — every sibling child template is concatenated
+  // into `tmplContent` and parsed onto one `*template.Template` instance
+  // below, so a loop-body cross-template call resolves at render time (#2205).
+  const result = compileJSX(source, 'component.tsx', {
+    adapter,
+    outputIR: true,
+    siblingTemplatesRegistered: Boolean(components),
+  })
 
   const errors = result.errors.filter(e => e.severity === 'error')
   if (errors.length > 0) {
@@ -319,11 +328,16 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     // cross-adapter; default to 'test' otherwise.
     const rootScopeId = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
 
+    // (#2209 part 2) Route-handler-equivalent seeding for a signal-backed
+    // dynamic child-component loop — see buildDynamicChildLoopSeeding's
+    // docstring.
+    const { lines: dynamicSeedingLines, needsFmt } = buildDynamicChildLoopSeeding(ir, template)
+
     // main.go — render program
     const mainGo = `package main
 
 import (
-	"html/template"
+${needsFmt ? '\t"fmt"\n' : ''}	"html/template"
 	"math/rand"
 	"os"
 
@@ -368,7 +382,7 @@ func main() {
 		ScopeID: ${JSON.stringify(rootScopeId)},
 ${propsInit}
 	})
-	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
+${dynamicSeedingLines.length > 0 ? dynamicSeedingLines.join('\n') + '\n' : ''}	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
 		os.Stderr.WriteString("template error: " + err.Error() + "\\n")
 		os.Exit(1)
 	}
@@ -551,6 +565,95 @@ function ensureMergedStdlibImports(goTypes: string): string {
   return goTypes.replace(/import\s*\([^)]*\)/, newBlock)
 }
 
+/**
+ * Recursively resolve `expr` (a loop's `arrayParsed`) down through
+ * `call`/`member` chains to the base signal getter it reads
+ * (`todos().filter(...)` → `todos`), or `null` when the base isn't a
+ * signal getter call. Structural `ParsedExpr` walk, not string/regex
+ * parsing (see CLAUDE.md's "never parse JS with regex" rule).
+ */
+function findBaseSignalGetter(expr: ParsedExpr | undefined, signalGetters: ReadonlySet<string>): string | null {
+  if (!expr) return null
+  switch (expr.kind) {
+    case 'identifier':
+      return signalGetters.has(expr.name) ? expr.name : null
+    case 'call':
+      return findBaseSignalGetter(expr.callee, signalGetters)
+    case 'member':
+      return findBaseSignalGetter(expr.object, signalGetters)
+    default:
+      return null
+  }
+}
+
+/**
+ * (#2209 part 2) Replicate, in the generated `main.go`, the documented
+ * "the route handler populates the loop-body child-component slice at
+ * request time" contract for a signal-backed dynamic loop —
+ * `generateNewPropsFunction`'s doc comment on `<Name>s []<Name>Props`
+ * in `adapter/go-template-adapter.ts`. The constructor only ever seeds
+ * the loop's DATUM slice (e.g. `.Todos`, straight from the caller's
+ * Input); the child-component Props slice the template actually
+ * ranges over (`.TodoItems`) has no server-side population path in
+ * this harness — the Hono reference materializes it by literally
+ * executing the component, so this closes the gap the same way:
+ * derive each item's child Props from the datum slice, exactly as a
+ * real route handler is documented to.
+ *
+ * Deliberately narrow: only fires for a loop whose (a) array source
+ * resolves, through `call`/`member` chains, to a component signal
+ * getter, (b) generated Go TEMPLATE text actually ranges over
+ * `.<Name>s` (a plain substring check on GENERATED GO OUTPUT — not JS
+ * parsing — so a `/* @client *\/`-marked loop, whose SSR template has
+ * no such range, is untouched by construction), and (c) at least one
+ * child prop is a bare pass-through of the loop item (`todo={todo}`).
+ * Returns the Go statements to splice into `main()` plus whether `fmt`
+ * needs importing.
+ */
+function buildDynamicChildLoopSeeding(
+  ir: ComponentIR,
+  template: string,
+): { lines: string[]; needsFmt: boolean } {
+  const signalGetters = new Set(ir.metadata.signals.map(s => s.getter))
+  const lines: string[] = []
+  let needsFmt = false
+  for (const nested of findNestedComponents(ir.root) as NestedComponentInfo[]) {
+    if (!nested.isDynamic || nested.isPropDerived) continue
+    if (nested.bodyChildren && nested.bodyChildren.length > 0) continue
+    if (!nested.loopParam) continue
+    if (!template.includes(`:= .${nested.name}s}}`)) continue
+    const datumField = findBaseSignalGetter(nested.loopArrayParsed, signalGetters)
+    if (!datumField) continue
+
+    const inputFields: string[] = []
+    for (const prop of nested.props) {
+      if (prop.isEventHandler) continue
+      if (prop.name === 'key' || prop.name.includes('-')) continue
+      if (
+        prop.value.kind === 'expression' &&
+        prop.value.parsed?.kind === 'identifier' &&
+        prop.value.parsed.name === nested.loopParam
+      ) {
+        inputFields.push(`${capitalizeFieldName(prop.name)}: item`)
+      }
+    }
+    if (inputFields.length === 0) continue
+
+    lines.push(`\tprops.${nested.name}s = make([]${nested.name}Props, len(props.${capitalizeFieldName(datumField)}))`)
+    lines.push(`\tfor i, item := range props.${capitalizeFieldName(datumField)} {`)
+    lines.push(`\t\tprops.${nested.name}s[i] = New${nested.name}Props(${nested.name}Input{${inputFields.join(', ')}})`)
+    lines.push(`\t\tprops.${nested.name}s[i].BfParent = props.ScopeID`)
+    lines.push(`\t\tprops.${nested.name}s[i].BfMount = ${JSON.stringify(nested.slotId ?? '')}`)
+    const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
+    if (keyField) {
+      lines.push(`\t\tprops.${nested.name}s[i].BfDataKey = fmt.Sprint(${keyField})`)
+      needsFmt = true
+    }
+    lines.push(`\t}`)
+  }
+  return { lines, needsFmt }
+}
+
 /**
  * Build Go struct field initializers from props.
  */
@@ -596,7 +699,7 @@ function buildGoPropsInit(
     // not the naive `Id`) — see `goMapLiteralFromObject`'s identical fix.
     const goField = capitalizeFieldName(key)
     if (typeof value === 'string') {
-      lines.push(`\t\t${goField}: "${value}",`)
+      lines.push(`\t\t${goField}: ${goStringLit(value)},`)
     } else if (typeof value === 'number') {
       lines.push(`\t\t${goField}: ${value},`)
     } else if (typeof value === 'boolean') {
@@ -725,6 +828,20 @@ function goTypedMapSliceLiteralFromArray(arr: unknown[], elemType: string): stri
  * 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)
  */
+/**
+ * Emit a JS string as a Go interpreted string literal. JSON string
+ * escaping is a subset of Go's (`\"`, `\\`, `\n`, `\uXXXX` are all valid
+ * Go escapes), so `JSON.stringify` is a correct emitter — unlike the
+ * previous quote-only `.replace(/"/g, '\\"')`, it also survives
+ * backslashes, newlines, and control characters (data-point conformance
+ * caught the quote case: a `"` in a string prop broke the generated
+ * `main.go` at compile time). Lone surrogates emit as `\uDXXX`, which Go
+ * rejects — acceptable until a fixture needs malformed-UTF-16 props.
+ */
+function goStringLit(v: string): string {
+  return JSON.stringify(v)
+}
+
 function goStructLiteral(obj: Record<string, unknown>, typeName: string): string {
   const fields: string[] = []
   for (const [k, v] of Object.entries(obj)) {
@@ -733,7 +850,7 @@ function goStructLiteral(obj: Record<string, unknown>, typeName: string): string
     // adapter's own struct-literal baking (`parsed-literal-to-go.ts`)
     // sanitizes those to `DataX`, not `Data-x` (Copilot review, #2202).
     const goField = goFieldNameForKey(k)
-    if (typeof v === 'string') fields.push(`${goField}: "${v.replace(/"/g, '\\"')}"`)
+    if (typeof v === 'string') fields.push(`${goField}: ${goStringLit(v)}`)
     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)}`)
@@ -745,7 +862,7 @@ function goStructLiteral(obj: Record<string, unknown>, typeName: string): string
 function goArrayLiteralFromArray(arr: unknown[]): string {
   const entries: string[] = []
   for (const v of arr) {
-    if (typeof v === 'string') entries.push(`"${v.replace(/"/g, '\\"')}"`)
+    if (typeof v === 'string') entries.push(goStringLit(v))
     else if (typeof v === 'number') entries.push(String(v))
     else if (typeof v === 'boolean') entries.push(String(v))
     else if (v === null) entries.push('nil')
@@ -783,7 +900,7 @@ function goMapLiteralFromObject(
     // uses for exactly this key-to-Go-field sanitization.
     const emittedKey = capitalizeKeys ? goFieldNameForKey(k) : k
     const key = JSON.stringify(emittedKey)
-    if (typeof v === 'string') entries.push(`${key}: "${v.replace(/"/g, '\\"')}"`)
+    if (typeof v === 'string') entries.push(`${key}: ${goStringLit(v)}`)
     else if (typeof v === 'number') entries.push(`${key}: ${v}`)
     else if (typeof v === 'boolean') entries.push(`${key}: ${v}`)
     else if (v === null) entries.push(`${key}: nil`)