@barefootjs/go-template 0.33.3 → 0.33.6

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

@@ -34,6 +34,7 @@ import type {
   TemplatePrimitiveRegistry,
   LoopBindingPathSegment,
   LoopBindingSource,
+  ConstantInfo,
 } from '@barefootjs/jsx'
 import {
   BaseAdapter,
@@ -78,6 +79,7 @@ import {
   collectLoopBoundNames,
   evaluateStaticLiteral,
   BindingScope,
+  buildImportAliasMap,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
 import { BF_REGION, escapeHtml, resolveJsxChildrenProp } from '@barefootjs/shared'
@@ -257,6 +259,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     extractCollisionDerivation: (parsed) => this.extractCollisionDerivation(parsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
+    resolveModuleNumericConst: (name) => this.resolveModuleNumericConst(name),
+    resolveModuleBooleanConst: (name) => this.resolveModuleBooleanConst(name),
   }
 
   /** Diagnostics from the current compile (backed by `CompileState`); `generate()` also merges these into `ir.errors`. */
@@ -386,6 +390,44 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   /** Child component name → the contexts it consumes (cross-component, for provider wiring). */
   private childContextConsumers: Map<string, ContextConsumer[]> = new Map()
 
+  /**
+   * Local alias -> declared/exported name for imported components (#2822,
+   * the SSR-side counterpart of #2777's client-JS registry-key fix). A
+   * child referenced under an import alias (`import { Foo as Bar }`,
+   * `<Bar/>`) has an `IRComponent.name` of `Bar` (the caller-local JSX tag
+   * name), but every cross-file lookup this adapter does against the
+   * child's OWN registered identity — `childComponentShapes` /
+   * `childContextConsumers` / `childDerivedFieldDeps` / `childPropFieldNames`
+   * / `childRepropsReady` (all populated from the CHILD's own
+   * `ir.metadata.componentName` via `registerChildComponentShape` or the
+   * child's own `generate()`/`generateTypes()` pass), the `New<Name>Props`
+   * constructor + `<Name>Input`/`<Name>Props` TYPE names, and the
+   * `{{template "<Name>" ...}}` cross-template call — must resolve through
+   * to `Foo`, the declared name, or they silently miss (a Go compile error
+   * for the constructor/type case, a `no such template` render error for
+   * the `{{template}}` case). Built once per compile from
+   * `ir.metadata.imports` via the shared `buildImportAliasMap`
+   * (`@barefootjs/jsx`) and read through `resolveChildName`.
+   *
+   * Deliberately NOT applied to a component's own PARENT-PRIVATE struct
+   * field name (`${comp.name}${suffix}`, `.${comp.name}` field access) —
+   * that field is declared and read using the SAME `comp.name` expression
+   * within this one parent's own generated code, so it stays internally
+   * consistent under the caller-local alias with no cross-file identity to
+   * match.
+   */
+  private importAliases: Map<string, string> = new Map()
+
+  /**
+   * Resolve a component reference's `IRComponent.name` (the caller-local
+   * JSX tag / import alias) to the name the referenced child's OWN module
+   * registers its Go template/type/constructor under. Identity for an
+   * un-aliased reference. See `importAliases`.
+   */
+  private resolveChildName(name: string): string {
+    return this.importAliases.get(name) ?? name
+  }
+
 
   constructor(options: GoTemplateAdapterOptions = {}) {
     super()
@@ -405,6 +447,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private primeCompileState(ir: ComponentIR): void {
     this.state.propsObjectName = ir.metadata.propsObjectName
     this.state.restPropsName = ir.metadata.restPropsName ?? null
+    // #2822: this component's OWN import-alias map (local alias -> declared
+    // name), read by `resolveChildName` at every cross-file lookup/codegen
+    // site below. Re-primed on every `generate()`/`generateTypes()` call —
+    // harmless per this method's own docstring, since what matters is that
+    // the LAST prime before a given `ir`'s template body actually renders is
+    // that same `ir`'s own imports (true here: `generate(ir)` primes then
+    // renders `ir`'s body synchronously before any other IR is primed).
+    this.importAliases = buildImportAliasMap(ir.metadata.imports ?? [])
     // Inline-object-typed props (`cfg: { id: number }`) bake as
     // `map[string]interface{}`; `member()` routes a nested access on them
     // through `bf_get` rather than an exact-case dot path (#2299).
@@ -487,6 +537,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.state.componentName = ir.metadata.componentName
     this.state.errors = []
     this.state.referencedDerivedConsts = new Set()
+    this.state.templateReadRootFields = new Set()
     this.state.templateVarCounter = 0
     this.state.pendingChildrenDefines = []
     this.scope = BindingScope.EMPTY
@@ -532,7 +583,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     for (const d of this.state.pendingChildrenDefines) {
       template += `{{define "${d.name}"}}${d.content}{{end}}\n`
     }
-    const types = this.generateTypes(ir)
+    const types = this.generateTypes(ir, true)
 
     if (this.state.errors.length > 0) {
       ir.errors.push(...this.state.errors)
@@ -1070,9 +1121,25 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return desired
   }
 
-  generateTypes(ir: ComponentIR): string | null {
+  /**
+   * `preserveTemplateReadRootFields` is set ONLY by `generate()`'s own
+   * internal call below — `templateReadRootFields` is an observation log
+   * `renderNode` populated moments ago while rendering THIS SAME
+   * component's template body, and this call needs to read that log back,
+   * not a freshly emptied one. Every other caller (the standalone public
+   * entry point `test-render.ts` calls directly on an already-`generate()`d
+   * adapter for a sibling/child IR, and this file's own unit tests) omits
+   * it and gets the set reset fresh — otherwise a stale log left over from
+   * whichever OTHER component `generate()` rendered last would silently
+   * narrow #2700's BF101 refusal to a false negative (pullfrog review, PR
+   * #2818).
+   */
+  generateTypes(ir: ComponentIR, preserveTemplateReadRootFields = false): string | null {
     this.state.usesHtmlTemplate = false
     this.state.usesFmt = false
+    if (!preserveTemplateReadRootFields) {
+      this.state.templateReadRootFields = new Set()
+    }
     // Prime identically to `generate()` so the standalone `generateTypes` entry
     // can't drift the structs (e.g. a `{...props}` bag field in one entry only).
     this.primeCompileState(ir)
@@ -1331,17 +1398,29 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   /**
-   * Synthesise a Go struct from an untyped object-array signal's inline initial
-   * value, or `null` (caller keeps `[]interface{}`/`nil`). Requires: untyped
-   * array type; a non-empty array literal of object literals; every element
-   * sharing the same Go-identifier key set; every value a scalar literal with a
-   * per-key-consistent Go type (mixed int/float64 widens to float64). Any
-   * deviation, or a name collision with an existing type, returns `null`.
+   * Synthesise a Go struct (plus, per #2800, one nested struct for each
+   * array-of-objects field, recursively) from an untyped object-array
+   * signal's inline initial value, or `null` (caller keeps
+   * `[]interface{}`/`nil`). Requires: untyped array type; a non-empty array
+   * literal of object literals; every element sharing the same
+   * Go-identifier key set; every value EITHER a scalar literal with a
+   * per-key-consistent Go type (mixed int/float64 widens to float64) OR an
+   * array of object literals (recursed the same way). Any deviation, or a
+   * name collision with an existing type, returns `null` for the WHOLE
+   * signal — `parsedLiteralToGo` (`value-lowering.ts`) already defers the
+   * whole array the moment one element fails to bake, so a partial struct
+   * (e.g. only the scalar fields) would synthesize a type nothing could
+   * ever fully populate; not worth a second, more permissive code path.
+   *
+   * Returns the synthesized structs in DEPENDENCY ORDER — nested structs
+   * before the struct(s) that reference them by name — so a caller
+   * registering them in list order never references an undeclared Go type.
+   * The signal's own top-level struct is always the LAST entry.
    */
   private synthesizeStructFromSignal(
     signal: { getter: string; type: TypeInfo; initialValue: string; parsed?: ParsedExpr },
     componentName: string,
-  ): { name: string; fields: Array<{ tsName: string; goName: string; goType: string }> } | null {
+  ): Array<{ name: string; fields: Array<{ tsName: string; goName: string; goType: string }>; properties: PropertyInfo[] }> | null {
     // Only untyped arrays: typed (`Item[]`) / scalar (`string[]`) elements bake
     // through the normal path.
     if (signal.type.kind !== 'array') return null
@@ -1351,12 +1430,40 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const node = signal.parsed
     if (!node || node.kind !== 'array-literal' || node.elements.length === 0) return null
 
-    // Field order + per-key Go types from the first element; every other element
-    // must match exactly.
+    const name = `${componentName}${capitalizeFieldName(signal.getter)}Item`
+    return this.synthesizeStructsFromElements(node.elements, name)
+  }
+
+  /**
+   * The recursive core of `synthesizeStructFromSignal`: given a list of
+   * object-literal elements known to share ONE shape, and the Go struct
+   * name to assign that shape, returns the synthesized struct(s) — this
+   * shape's own struct last, any nested array-of-objects field's struct(s)
+   * before it — or `null` on any shape this fast path doesn't bake.
+   *
+   * A nested array-of-objects field is validated and shaped from the FLAT
+   * concatenation of that key's elements across every row (not just the
+   * first row) — a later row's own object shape for that key must still
+   * agree, but the nested struct's field set is inferred from every row's
+   * contribution so no row's data is silently dropped from the type.
+   */
+  private synthesizeStructsFromElements(
+    elements: ParsedExpr[],
+    name: string,
+  ): Array<{ name: string; fields: Array<{ tsName: string; goName: string; goType: string }>; properties: PropertyInfo[] }> | null {
+    // Don't shadow an existing (user-defined or already-synthesised) type.
+    if (this.state.localTypeNames.has(name)) return null
+
+    type PropShape = { kind: 'scalar'; goType: string } | { kind: 'nested-array' }
+
+    // Field order + per-key shape from the first element; every other
+    // element must match exactly (same keys, same shape KIND per key).
     const order: string[] = []
-    const goTypes = new Map<string, string>()
-    for (let i = 0; i < node.elements.length; i++) {
-      const el = node.elements[i]
+    const shapes = new Map<string, PropShape>()
+    const nestedElements = new Map<string, ParsedExpr[]>()
+
+    for (let i = 0; i < elements.length; i++) {
+      const el = elements[i]
       if (el.kind !== 'object-literal') return null
       const seen = new Set<string>()
       for (const prop of el.properties) {
@@ -1367,36 +1474,124 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (prop.shorthand) return null
         const key = prop.key
         if (!GO_IDENTIFIER.test(key)) return null
+        seen.add(key)
+
+        const isNestedArray =
+          prop.value.kind === 'array-literal' &&
+          prop.value.elements.every(e => e.kind === 'object-literal')
+
+        if (isNestedArray) {
+          const prevShape = shapes.get(key)
+          if (prevShape === undefined) {
+            if (i !== 0) return null // key absent from the first element → shape differs
+            order.push(key)
+            shapes.set(key, { kind: 'nested-array' })
+            nestedElements.set(key, [])
+          } else if (prevShape.kind !== 'nested-array') {
+            return null // this key is a scalar in some rows, a nested array in others
+          }
+          nestedElements.get(key)!.push(...(prop.value as { elements: ParsedExpr[] }).elements)
+          continue
+        }
+
         const goType = this.scalarParsedGoType(prop.value)
         if (!goType) return null
-        seen.add(key)
-        const prev = goTypes.get(key)
-        if (prev === undefined) {
-          if (i !== 0) return null // key absent from the first element → shape differs
+        const prevShape = shapes.get(key)
+        if (prevShape === undefined) {
+          if (i !== 0) return null
           order.push(key)
-          goTypes.set(key, goType)
+          shapes.set(key, { kind: 'scalar', goType })
+        } else if (prevShape.kind !== 'scalar') {
+          return null
         } else {
-          const merged = this.mergeScalarGoType(prev, goType)
+          const merged = this.mergeScalarGoType(prevShape.goType, goType)
           if (!merged) return null
-          goTypes.set(key, merged)
+          shapes.set(key, { kind: 'scalar', goType: merged })
         }
       }
       // A first-element key missing here → shape differs.
       if (seen.size !== order.length) return null
     }
 
-    const name = `${componentName}${capitalizeFieldName(signal.getter)}Item`
-    // Don't shadow an existing (user-defined or already-synthesised) type.
-    if (this.state.localTypeNames.has(name)) return null
+    const nestedStructs: Array<{ name: string; fields: Array<{ tsName: string; goName: string; goType: string }>; properties: PropertyInfo[] }> = []
+    const fields: Array<{ tsName: string; goName: string; goType: string }> = []
+    const properties: PropertyInfo[] = []
 
-    return {
-      name,
-      fields: order.map(key => ({
-        tsName: key,
-        goName: capitalizeFieldName(key),
-        goType: goTypes.get(key)!,
-      })),
+    for (const key of order) {
+      const shape = shapes.get(key)!
+      if (shape.kind === 'scalar') {
+        fields.push({ tsName: key, goName: capitalizeFieldName(key), goType: shape.goType })
+        properties.push({ name: key, type: this.scalarGoTypeToTypeInfo(shape.goType), optional: false, readonly: false })
+        continue
+      }
+      const nestedList = nestedElements.get(key)!
+      // Every row's array for this key was empty — no row's data to infer
+      // a shape from (distinct from a MISSING key, already ruled out
+      // above); matches the top-level empty-array rule this function
+      // already applies to the signal's own outer array.
+      if (nestedList.length === 0) return null
+      const nestedName = `${name}${capitalizeFieldName(key)}Item`
+      const nested = this.synthesizeStructsFromElements(nestedList, nestedName)
+      if (!nested) return null
+      nestedStructs.push(...nested)
+      fields.push({ tsName: key, goName: capitalizeFieldName(key), goType: `[]${nestedName}` })
+      properties.push({ name: key, type: this.synthSliceTypeInfo(nestedName), optional: false, readonly: false })
     }
+
+    return [...nestedStructs, { name, fields, properties }]
+  }
+
+  /** `PropertyInfo.type` for a scalar Go field type — consumed only as a
+   * defensive/consistent fill; `parsedLiteralToGo`'s object branch never
+   * looks up a SCALAR property's declared type (only array/object ones),
+   * so this never actually gates a bake, unlike `synthSliceTypeInfo`. */
+  private scalarGoTypeToTypeInfo(goType: string): TypeInfo {
+    if (goType === 'string') return { kind: 'primitive', raw: 'string', primitive: 'string' }
+    if (goType === 'bool') return { kind: 'primitive', raw: 'boolean', primitive: 'boolean' }
+    return { kind: 'primitive', raw: 'number', primitive: 'number' }
+  }
+
+  /**
+   * `TypeInfo` for "an array of the named synthesized struct" — the exact
+   * shape both `emitSynthStructs`'s `synthStructTypes` entry (the signal's
+   * OWN field type) and a nested array-of-objects field's `PropertyInfo`
+   * need, so `parsed-literal-to-go.ts`'s `structPropertyType` resolves a
+   * nested array property the identical way it resolves the signal's own
+   * top-level type.
+   */
+  private synthSliceTypeInfo(name: string): TypeInfo {
+    return { kind: 'array', raw: `${name}[]`, elementType: { kind: 'interface', raw: name } }
+  }
+
+  /**
+   * Register a synthesized struct (fields as Go source lines, `properties`
+   * for `structPropertyType`'s nested-type lookups) and emit its
+   * declaration — the one register+emit sequence shared by
+   * `emitSynthPropStructs.visitObject` (anonymous TS object types, #2674)
+   * and `emitSynthStructs` (untyped object-array signals, #2800), so
+   * localTypeNames/localStructFields/currentTypeDefinitions registration
+   * can't drift between the two synthesis call sites.
+   */
+  private registerSynthStruct(
+    lines: string[],
+    name: string,
+    fields: Array<{ tsName: string; goName: string; goType: string }>,
+    properties: PropertyInfo[],
+    comment: string,
+  ): void {
+    this.state.localTypeNames.add(name)
+    this.state.localStructFields.set(name, new Map(fields.map(f => [f.tsName, f.goName])))
+    this.state.currentTypeDefinitions.push({
+      kind: 'type',
+      name,
+      definition: '',
+      properties,
+      loc: SYNTH_TYPE_LOC,
+    })
+    const goFields = fields.map(f => `\t${f.goName} ${f.goType} \`json:"${this.toJsonTag(f.tsName)}"\``)
+    lines.push(comment)
+    lines.push(`type ${name} struct {\n${goFields.join('\n')}\n}`)
+    lines.push('')
   }
 
   /**
@@ -1524,7 +1719,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         nested.loopParam,
         nested.loopKey,
       )) continue
-      lines.push(`\t${nested.name}s []${nested.name}Input`)
+      // #2822 follow-up: field NAME stays alias-keyed (parent-private, this
+      // Input struct's own field — read as `in.${nested.name}s` throughout
+      // this file), but the element TYPE is the child's own cross-file
+      // `<Name>Input` struct — see `importAliases`.
+      lines.push(`\t${nested.name}s []${this.resolveChildName(nested.name)}Input`)
     }
 
     // `useContext` consumer fields — settable by an enclosing provider; default
@@ -1595,11 +1794,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const wrapperName = this.loopBodyWrapperName(parentComponentName, nested)
     const datumFields = this.resolveLoopDatumFields(nested.loopItemType)
     const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren!)
-
-    lines.push(`// ${wrapperName} wraps ${nested.name}Props with per-row loop datum`)
+    // #2822 follow-up: this is a Go EMBEDDED (anonymous) field — its field
+    // name IS its type name, so unlike `child.fieldName` the alias-keyed
+    // field name can't be kept separate from the type here. The whole
+    // token must be the child's own cross-file DECLARED name everywhere
+    // this embedded field is declared or literal-initialized (below, and
+    // every `${declaredName}Props: New${declaredName}Props(...)` composite
+    // literal site) — see `importAliases`.
+    const declaredName = this.resolveChildName(nested.name)
+
+    lines.push(`// ${wrapperName} wraps ${declaredName}Props with per-row loop datum`)
     lines.push(`// fields and child component slots for the loop body children. (#1897)`)
     lines.push(`type ${wrapperName} struct {`)
-    lines.push(`\t${nested.name}Props`)
+    lines.push(`\t${declaredName}Props`)
     for (const f of datumFields) {
       lines.push(`\t${f.goName} ${f.goType} \`json:"-"\``)
     }
@@ -1610,7 +1817,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\tBfLoopItem ${scalarLoopType} \`json:"-"\``)
     }
     for (const child of bodyChildInstances) {
-      lines.push(`\t${child.fieldName} ${child.name}Props \`json:"-"\``)
+      // #2822: field NAME stays alias-keyed (parent-private); the TYPE must
+      // name the child's own declared Go type — see `importAliases`.
+      lines.push(`\t${child.fieldName} ${this.resolveChildName(child.name)}Props \`json:"-"\``)
     }
     lines.push('}')
     lines.push('')
@@ -1759,6 +1968,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Static nested WITHOUT body children.
     for (const nested of staticWithoutBody) {
       const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      // #2822 follow-up: the constructor/type names below are cross-file
+      // (the child's own `New<Name>Props`/`<Name>Props`/`<Name>Input`) and
+      // must resolve to the child's declared name; `varName` (this local)
+      // and `in.${nested.name}s` (this parent's own Input field, read
+      // below) stay alias-keyed — see `importAliases`.
+      const declaredName = this.resolveChildName(nested.name)
       // #2208: a static loop whose ARRAY SOURCE is itself fully-static
       // (`const items = [{ label: 'Alpha' }, ...]`) has no caller input to
       // wait for — every item's props/data-key are already known at
@@ -1776,10 +1991,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           )
         : null
       if (baked) {
-        lines.push(`\t${varName} := make([]${nested.name}Props, ${baked.items.length})`)
+        lines.push(`\t${varName} := make([]${declaredName}Props, ${baked.items.length})`)
         baked.items.forEach((item, i) => {
           const fields = item.inputFields.map(f => `${f.goField}: ${f.goValue}`).join(', ')
-          lines.push(`\t${varName}[${i}] = New${nested.name}Props(${nested.name}Input{${fields}})`)
+          lines.push(`\t${varName}[${i}] = New${declaredName}Props(${declaredName}Input{${fields}})`)
           lines.push(`\t${varName}[${i}].BfParent = scopeID`)
           lines.push(`\t${varName}[${i}].BfMount = "${nested.slotId}"`)
           if (item.dataKey !== null) {
@@ -1789,9 +2004,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         lines.push('')
         continue
       }
-      lines.push(`\t${varName} := make([]${nested.name}Props, len(in.${nested.name}s))`)
+      lines.push(`\t${varName} := make([]${declaredName}Props, len(in.${nested.name}s))`)
       lines.push(`\tfor i, item := range in.${nested.name}s {`)
-      lines.push(`\t\t${varName}[i] = New${nested.name}Props(item)`)
+      lines.push(`\t\t${varName}[i] = New${declaredName}Props(item)`)
       lines.push(`\t\t${varName}[i].BfParent = scopeID`)
       lines.push(`\t\t${varName}[i].BfMount = "${nested.slotId}"`)
       const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
@@ -1964,8 +2179,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // Bake against the synthesised struct type if one was inferred for this
         // untyped object-array signal, else the signal's own type.
         const bakeType = this.state.synthStructTypes.get(signal.getter) ?? signal.type
+        const resolvedParsed = this.resolvedSignalParsed(signal)
         const initialValue = convertInitialValue(this.emitCtx, signal.initialValue, bakeType, ir.metadata.propsParams, signal.parsed)
         lines.push(`\t\t${fieldName}: ${initialValue},`)
+        if (resolvedParsed?.kind === 'object-literal' && jsLiteralToGo(this.emitCtx, bakeType, resolvedParsed) === null) {
+          const step = this.state.ssrSeedPlan.steps.find(s => s.kind === 'derived' && s.origin === 'signal' && s.name === signal.getter)
+          if (step?.kind === 'derived') this.refuseUnbakeableDerivedObjectLiteral(signal.getter, signal.loc, step.frees)
+        }
       }
     }
 
@@ -1997,6 +2217,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap)
       const memoValue = computeMemoInitialValue(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType)
       lines.push(`\t\t${fieldName}: ${memoValue},`)
+      // No #2700 refusal check here (unlike the signal loop above): the
+      // analyzer deliberately never sets `MemoInfo.parsed` to an
+      // `object-literal` for an object-returning memo body (`() => ({…})`,
+      // `analyzer.ts`'s own docstring — "isn't lowered from the parsed tree
+      // yet") — a pre-existing, unrelated exclusion this fix doesn't touch.
+      // Detecting the shape without `parsed` would mean re-parsing
+      // `memo.computation` as text, which the repo's own convention (see
+      // CLAUDE.md, "Never parse imports... with regex or string matching")
+      // rules out. #2700's own reproduction and fixture are signal-only;
+      // a memo-side refusal is left for whoever lands the "Roadmap A" memo
+      // object-literal `parsed` support this comment references.
     }
 
     // Computed derived-const fields (`Root: func() string { … }()`), matching
@@ -2182,7 +2413,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private emitStaticChildInstances(lines: string[], ir: ComponentIR): void {
     const staticChildren = this.collectStaticChildInstances(ir.root, ir.metadata.propsParams)
     for (const child of staticChildren) {
-      lines.push(`\t\t${child.fieldName}: New${child.name}Props(${child.name}Input{`)
+      // #2822: the constructor/type names and every cross-file shape lookup
+      // below must resolve to the child's own DECLARED name — `New<Name>Props`
+      // / `<Name>Input` are types/functions the child's OWN generated Go file
+      // defines under that name, not the caller-local alias. `child.fieldName`
+      // (this PARENT's own struct field) stays keyed by the alias — declared
+      // and read consistently within this one parent's generated code.
+      const declaredName = this.resolveChildName(child.name)
+      lines.push(`\t\t${child.fieldName}: New${declaredName}Props(${declaredName}Input{`)
       lines.push(`\t\t\tScopeID: scopeID + "_${child.slotId}",`)
       lines.push(`\t\t\tBfParent: scopeID,`)
       lines.push(`\t\t\tBfMount: "${child.slotId}",`)
@@ -2190,7 +2428,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // consumes gets the provider value set on its consumer field (else its own
       // NewProps applies the `createContext` default).
       if (child.contextBindings) {
-        for (const consumer of this.childContextConsumers.get(child.name) ?? []) {
+        for (const consumer of this.childContextConsumers.get(declaredName) ?? []) {
           const goVal = child.contextBindings.get(consumer.contextName)
           if (goVal !== undefined) {
             lines.push(`\t\t\t${this.contextFieldName(consumer)}: ${goVal},`)
@@ -2200,7 +2438,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // Non-param attrs route into the child's rest bag (see
       // `childComponentShapes`); `restBagEntries` collects `"jsx-attr-name":
       // goValue` pairs for that map.
-      const childShape = this.childComponentShapes.get(child.name)
+      const childShape = this.childComponentShapes.get(declaredName)
       const restBagEntries: string[] = []
       const emitChildField = (jsxName: string, goValue: string): void => {
         if (
@@ -2342,6 +2580,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.
                 }
               }
             }
@@ -2384,6 +2636,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     lines.push(`// New${componentName}Props creates ${propsTypeName} from ${inputTypeName}.`)
     for (const nested of signalDynamicNested) {
       const arrayField = `${nested.name}s`
+      // #2822 follow-up: `arrayField` names THIS parent's own field
+      // (alias-keyed, stays as-is); the constructor/type names in the
+      // example below are the child's own cross-file symbols — resolve
+      // for doc accuracy (cosmetic; not compiled) — see `importAliases`.
+      const declaredName = this.resolveChildName(nested.name)
       lines.push(`//`)
       lines.push(`// NOTE: \`${arrayField}\` is populated by the route handler, not by`)
       lines.push(`// New${componentName}Props — the SSR template iterates over it`)
@@ -2391,9 +2648,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`// assign it before passing the props to your renderer. Example:`)
       lines.push(`//`)
       lines.push(`//   props := New${componentName}Props(${inputTypeName}{ /* ... */ })`)
-      lines.push(`//   props.${arrayField} = make([]${nested.name}Props, len(items))`)
+      lines.push(`//   props.${arrayField} = make([]${declaredName}Props, len(items))`)
       lines.push(`//   for i, item := range items {`)
-      lines.push(`//     props.${arrayField}[i] = New${nested.name}Props(${nested.name}Input{ /* fields */ })`)
+      lines.push(`//     props.${arrayField}[i] = New${declaredName}Props(${declaredName}Input{ /* fields */ })`)
       lines.push(`//     props.${arrayField}[i].BfParent = props.ScopeID`)
       lines.push(`//     props.${arrayField}[i].BfMount = "${nested.slotId}"`)
       lines.push(`//   }`)
@@ -2456,10 +2713,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       const wrapperType = this.loopBodyWrapperName(componentName, nested)
       const datumFields = this.resolveLoopDatumFields(nested.loopItemType)
       const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren!, ir.metadata.propsParams)
+      // #2822 follow-up: matches `generateLoopBodyWrapperStruct`'s embedded
+      // field — the composite-literal key here must be the SAME declared
+      // name the wrapper struct's embedded field was declared under.
+      const declaredName = this.resolveChildName(nested.name)
 
       for (const child of bodyChildInstances) {
         const childVar = `child_${child.fieldName}`
-        lines.push(`\t${childVar} := New${child.name}Props(${child.name}Input{`)
+        const childDeclaredName = this.resolveChildName(child.name)
+        lines.push(`\t${childVar} := New${childDeclaredName}Props(${childDeclaredName}Input{`)
         lines.push(`\t\tScopeID: scopeID + "_${child.slotId}",`)
         lines.push(`\t\tBfParent: scopeID,`)
         lines.push(`\t\tBfMount: "${child.slotId}",`)
@@ -2479,7 +2741,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\t${varName} := make([]${wrapperType}, len(${dataVar}))`)
       lines.push(`\tfor i, item := range ${dataVar} {`)
       lines.push(`\t\t${varName}[i] = ${wrapperType}{`)
-      lines.push(`\t\t\t${nested.name}Props: New${nested.name}Props(${nested.name}Input{`)
+      lines.push(`\t\t\t${declaredName}Props: New${declaredName}Props(${declaredName}Input{`)
       lines.push(`\t\t\t\tBfParent: scopeID,`)
       lines.push(`\t\t\t\tBfMount: "${nested.slotId}",`)
       // Loop-body component's own static props. `key` → BfDataKey below; children
@@ -2550,11 +2812,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
       const datumFields = this.resolveLoopDatumFields(nested.loopItemType)
       const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren!, ir.metadata.propsParams)
+      // #2822 follow-up: matches `generateLoopBodyWrapperStruct`'s embedded
+      // field — see the identical comment in `emitStaticBodyWrappers`.
+      const declaredName = this.resolveChildName(nested.name)
 
       // Child sub-component instances created once (identical scope IDs per row).
       for (const child of bodyChildInstances) {
         const childVar = `child_${child.fieldName}`
-        lines.push(`\t${childVar} := New${child.name}Props(${child.name}Input{`)
+        const childDeclaredName = this.resolveChildName(child.name)
+        lines.push(`\t${childVar} := New${childDeclaredName}Props(${childDeclaredName}Input{`)
         lines.push(`\t\tScopeID: scopeID + "_${child.slotId}",`)
         lines.push(`\t\tBfParent: scopeID,`)
         lines.push(`\t\tBfMount: "${child.slotId}",`)
@@ -2573,7 +2839,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\t${varName} := make([]${wrapperType}, len(bakedData))`)
       lines.push(`\tfor i, item := range bakedData {`)
       lines.push(`\t\t${varName}[i] = ${wrapperType}{`)
-      lines.push(`\t\t\t${nested.name}Props: New${nested.name}Props(${nested.name}Input{`)
+      lines.push(`\t\t\t${declaredName}Props: New${declaredName}Props(${declaredName}Input{`)
       lines.push(`\t\t\t\tBfParent: scopeID,`)
       lines.push(`\t\t\t\tBfMount: "${nested.slotId}",`)
       lines.push(`\t\t\t}),`)
@@ -2701,20 +2967,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         visit(prop.type, desiredName, prop.name)
       }
       const fields = this.structFieldsFor(typeInfo)
-      this.state.localStructFields.set(desiredName, new Map(fields.map(f => [f.tsName, f.goName])))
-      this.state.currentTypeDefinitions.push({
-        kind: 'type',
-        name: desiredName,
-        definition: '',
-        properties: typeInfo.properties ?? [],
-        loc: SYNTH_TYPE_LOC,
-      })
-      const goFields = fields.map(
-        f => `\t${f.goName} ${f.goType} \`json:"${this.toJsonTag(f.tsName)}"\``,
+      this.registerSynthStruct(
+        lines,
+        desiredName,
+        fields,
+        typeInfo.properties ?? [],
+        `// ${desiredName} is a synthesised type for an anonymous object type (#2674).`,
       )
-      lines.push(`// ${desiredName} is a synthesised type for an anonymous object type (#2674).`)
-      lines.push(`type ${desiredName} struct {\n${goFields.join('\n')}\n}`)
-      lines.push('')
     }
 
     const visitArrayElem = (elemType: TypeInfo | undefined, parentName: string, propName: string): void => {
@@ -2767,28 +3026,33 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   private emitSynthStructs(lines: string[], ir: ComponentIR, componentName: string): void {
-    // Synthesise a struct for each untyped object-array signal and emit it, so
-    // the signal field can be typed `[]Synth` and its inline items baked (the
-    // loop body reaches each item via struct field access). Registered in
-    // localTypeNames/localStructFields so the baker resolves the element type.
+    // Synthesise a struct for each untyped object-array signal (plus, per
+    // #2800, one nested struct per array-of-objects field, recursively) and
+    // emit them, so the signal field can be typed `[]Synth` and its inline
+    // items baked (the loop body reaches each item via struct field
+    // access). Registered via `registerSynthStruct` so the baker resolves
+    // every level's element type the same way it resolves a #2674
+    // anonymous-type struct.
     this.state.synthStructTypes = new Map<string, TypeInfo>()
     for (const signal of ir.metadata.signals) {
       if (signal.envReader) continue // env signal has no bakeable initial shape (#2057)
       const synth = this.synthesizeStructFromSignal(signal, componentName)
       if (!synth) continue
-      this.state.localTypeNames.add(synth.name)
-      this.state.localStructFields.set(synth.name, new Map(synth.fields.map(f => [f.tsName, f.goName])))
-      this.state.synthStructTypes.set(signal.getter, {
-        kind: 'array',
-        raw: `${synth.name}[]`,
-        elementType: { kind: 'interface', raw: synth.name },
-      })
-      const goFields = synth.fields.map(
-        f => `\t${f.goName} ${f.goType} \`json:"${this.toJsonTag(f.tsName)}"\``,
-      )
-      lines.push(`// ${synth.name} is a synthesised element type for the ${signal.getter} signal.`)
-      lines.push(`type ${synth.name} struct {\n${goFields.join('\n')}\n}`)
-      lines.push('')
+      // Nested-first order (`synthesizeStructFromSignal`'s contract): a
+      // struct referencing an earlier entry by name is always registered
+      // after it, so no declaration ever forward-references an
+      // undeclared Go type.
+      for (const s of synth) {
+        this.registerSynthStruct(
+          lines,
+          s.name,
+          s.fields,
+          s.properties,
+          `// ${s.name} is a synthesised element type for the ${signal.getter} signal.`,
+        )
+      }
+      const top = synth[synth.length - 1]
+      this.state.synthStructTypes.set(signal.getter, this.synthSliceTypeInfo(top.name))
     }
   }
 
@@ -3068,10 +3332,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // real — a second same-named field here is a Go compile error
       // ("redeclared"), not just dead code.
       if (this.isOrphanedClientOnlyNested(nested)) continue
-      // Loop body with JSX children → use the wrapper struct type.
+      // Loop body with JSX children → use the wrapper struct type (a
+      // parent-private name — the child's own Props type only appears
+      // INSIDE it as the embedded field, already resolved in
+      // `generateLoopBodyWrapperStruct`). Loop body IS just the bare child
+      // component → this element type IS the child's own cross-file Props
+      // type directly — #2822 follow-up: resolve to the declared name.
       const elemType = nested.bodyChildren?.length
         ? this.loopBodyWrapperName(componentName, nested)
-        : `${nested.name}Props`
+        : `${this.resolveChildName(nested.name)}Props`
       if (nested.isDynamic && !nested.isPropDerived) {
         // Dynamic signal-array loops are template-only.
         lines.push(`\t${nested.name}s []${elemType} \`json:"-"\``)
@@ -3115,7 +3384,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     const staticChildren = this.collectStaticChildInstances(ir.root, ir.metadata.propsParams)
     for (const child of staticChildren) {
-      lines.push(`\t${child.fieldName} ${child.name}Props \`json:"-"\``)
+      // #2822: the field's NAME stays keyed by the caller-local alias
+      // (`child.fieldName`, declared and read consistently within this
+      // parent's own generated code — see `importAliases`'s docstring), but
+      // its TYPE is a real Go type only the child's own file defines, under
+      // the child's DECLARED name.
+      lines.push(`\t${child.fieldName} ${this.resolveChildName(child.name)}Props \`json:"-"\``)
     }
 
     // Top-level intrinsic-element spreads: each gets a `Spread_<slotId>
@@ -3865,6 +4139,55 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return resolveSignalParsedThroughSeedPlan(this.state, signal)
   }
 
+  /**
+   * #2700: a `derived`-classified signal (`SsrSeedPlan`'s classification —
+   * an object literal whose free identifiers ALL resolve in scope, e.g.
+   * `createSignal({ ...base, done: true })`) whose value the
+   * constructor-time baker (`convertInitialValue`) can't reproduce silently
+   * keeps the field's Go zero value — that baker is static-only
+   * (identifier/member/call operands defer, `parsed-literal-to-go.ts`'s own
+   * docstring). Signal-only: the analyzer deliberately never sets
+   * `MemoInfo.parsed` to an `object-literal` for an object-returning memo
+   * body (`analyzer.ts`'s own docstring — "isn't lowered from the parsed
+   * tree yet"), so there is no structural way to reach this check for a
+   * memo without re-parsing `computation` as text, which the repo's own
+   * convention rules out.
+   *
+   * Deferring silently is harmless UNLESS the SSR template actually reads
+   * the field: a signal that only feeds a spread-attrs bag never reaches
+   * here as a false positive because spread bags bake through their own
+   * `.Spread_<slot>` route (`emitSpreadBagInits`), never `rootFieldRef` —
+   * so `templateReadRootFields` (populated while `generate()` rendered the
+   * template, which always precedes `generateTypes`'s call into this
+   * method) is the exact structural proxy for "the zero value would
+   * actually surface," not merely "the bake failed."
+   *
+   * Scoped to a NON-EMPTY free set on purpose, not every deferred bake: a
+   * fully-static object literal (`createSignal({ id: 'row-1' })`) hits the
+   * same `nil` fallback today but is a separate, untracked silent-divergence
+   * shape with no fixture of its own — loud-ifying it here would silently
+   * widen this fix beyond #2700's actual reproduction (a literal that
+   * references a live prop/signal), so it's left for its own issue instead.
+   */
+  private refuseUnbakeableDerivedObjectLiteral(
+    name: string,
+    loc: SourceLocation,
+    frees: readonly string[],
+  ): void {
+    if (frees.length === 0) return
+    if (!this.state.templateReadRootFields.has(name)) return
+    this.state.errors.push({
+      code: 'BF101',
+      severity: 'error',
+      message: `Signal '${name}' is seeded from an object literal that references live value(s) (${frees.join(', ')}) — the Go template adapter bakes object-typed signal values into Go source at New${this.state.componentName}Props time, and that baker is static-only (identifier/member/call operands defer), so the SSR template's read of it would see the Go zero value instead of the derived object.`,
+      loc,
+      suggestion: {
+        message: `Wrap each SSR read of '${name}()' in /* @client */ so it renders on the client instead, or pass the already-derived object in as a prop.`,
+        escape: [{ kind: 'client-directive' }],
+      },
+    })
+  }
+
   /**
    * Parse a signal-time initial value of the form `props.X ?? <literal>` —
    * or, for destructured components, `x ?? <literal>` — into the source prop
@@ -4523,6 +4846,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * rebinds. Outside any loop the root *is* the dot, so we emit `.Field`.
    */
   private rootFieldRef(name: string): string {
+    this.state.templateReadRootFields.add(name)
     const prefix = this.inLoop ? '$.' : '.'
     return `${prefix}${capitalizeFieldName(name)}`
   }
@@ -4573,6 +4897,21 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `"${escapeGoString(value)}"`
   }
 
+  /**
+   * The single module-const lookup shared by `resolveModuleNumericConst`
+   * and `resolveModuleBooleanConst` — they differ only in which literal
+   * SHAPE they accept from the same "plain module-level const" search, not
+   * in how that search is performed. A second inline lookup per resolver
+   * would grow `binding-scope-ratchet.test.ts`'s shrink-only floor for this
+   * file (already at 5) for a shape variance the callers can express
+   * themselves instead.
+   */
+  private findModuleConst(name: string): ConstantInfo | undefined {
+    return this.state.localConstants.find(
+      (k) => k.name === name && k.isModule && !k.containsArrow,
+    )
+  }
+
   /**
    * Inline a module-level numeric const (`const TRACK = 8`) as its literal
    * value. Only a plain numeric initializer qualifies — anything computed or
@@ -4584,9 +4923,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (this.isCurrentLoopItem(name)) return null
     if (this.loopVarRefCount.has(name)) return null
     if (this.isOuterLoopParam(name)) return null
-    const c = this.state.localConstants.find(
-      (k) => k.name === name && k.isModule && !k.containsArrow,
-    )
+    const c = this.findModuleConst(name)
     if (!c || c.value === undefined) return null
     // `value` is reconstructed from source text, so a valid TS literal may carry
     // numeric separators (`100_000`). Strip them between digits, then accept a
@@ -4595,6 +4932,23 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return /^-?\d+(\.\d+)?$/.test(v) ? v : null
   }
 
+  /**
+   * Inline a module-level boolean const (`const OPEN = true`) as its Go
+   * literal (`true`/`false`). Only a plain `true`/`false` initializer
+   * qualifies (#2815) — mirrors `resolveModuleNumericConst`'s shape, sharing
+   * its lookup rather than adding a second `.find(` (see
+   * `findModuleConst`'s docstring).
+   */
+  private resolveModuleBooleanConst(name: string): string | null {
+    if (this.isCurrentLoopItem(name)) return null
+    if (this.loopVarRefCount.has(name)) return null
+    if (this.isOuterLoopParam(name)) return null
+    const c = this.findModuleConst(name)
+    if (!c || c.value === undefined) return null
+    const v = c.value.trim()
+    return v === 'true' || v === 'false' ? v : null
+  }
+
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
     if (literalType === 'string') return `"${value}"`
     if (literalType === 'null') return 'nil'
@@ -5780,8 +6134,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // A local variable mapped to a signal.
         const signal = localVarMap.get(expr.name)
         if (signal) {
+          // Root-scope read (#2700's BF101 gate needs it in
+          // `templateReadRootFields`) — `$.` is hardcoded rather than
+          // routed through `rootFieldRef`'s `this.inLoop`-conditional
+          // prefix because a filter predicate must always escape back to
+          // root regardless of loop nesting; call it only for its
+          // registration side effect and keep the prefix here (pullfrog
+          // review, PR #2818).
+          this.rootFieldRef(signal)
           return `$.${capitalizeFieldName(signal)}`
         }
+        this.rootFieldRef(expr.name)
         return `.${capitalizeFieldName(expr.name)}`
       }
 
@@ -5826,8 +6189,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (expr.callee.kind === 'member' && expr.callee.object.kind === 'identifier' && expr.callee.object.name === param) {
           return `${paramPrefix}.${capitalizeFieldName(expr.callee.property)}`
         }
-        // Signal calls: `filter()` -> `$.Filter`
+        // Signal calls: `filter()` -> `$.Filter`. Same registration-only
+        // `rootFieldRef` call as the `identifier` case above, for the same
+        // reason (#2700's BF101 gate; pullfrog review, PR #2818).
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
+          this.rootFieldRef(expr.callee.name)
           return `$.${capitalizeFieldName(expr.callee.name)}`
         }
         // A nested callback method call (`other.some(r => …)`) reaching this
@@ -6190,7 +6556,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private loopRowChildPropOverrides(
     comp: IRComponent,
   ): { args: string; helper: 'bf_with_props' | 'bf_reprops' } | null {
-    const childShape = this.childComponentShapes.get(comp.name)
+    // #2822: every cross-file map below is keyed by the child's own
+    // declared name, not the caller-local alias — see `importAliases`.
+    // Diagnostics still name `comp.name` (what the user actually wrote in
+    // the JSX) since that's the more useful reference for the reader.
+    const declaredName = this.resolveChildName(comp.name)
+    const childShape = this.childComponentShapes.get(declaredName)
     const args: string[] = []
     // Set by the derived-field check below when at least one overridden prop
     // feeds a constructor-derived field AND the child can rebuild itself.
@@ -6221,12 +6592,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // one-shot value on every row. Re-run the constructor per row when the
       // child has a rebuilder; refuse when it doesn't.
       {
-        const derived = this.childDerivedFieldDeps.get(comp.name)
+        const derived = this.childDerivedFieldDeps.get(declaredName)
         const overriddenField = capitalizeFieldName(prop.name)
         const staleField = derived
           ? [...derived].find(([, deps]) => deps.has(overriddenField))?.[0]
           : undefined
-        if (staleField && !this.childRepropsReady.has(comp.name)) {
+        if (staleField && !this.childRepropsReady.has(declaredName)) {
           this.state.errors.push({
             code: 'BF101',
             severity: 'error',
@@ -6243,9 +6614,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           // The rebuilder is emitted into THIS component's type block, not the
           // child's — only here do we know it is actually needed. First parent
           // to claim a child owns the registration, so two parents overriding
-          // the same child don't both emit an `init()` for it.
-          if (!this.repropsOwner.has(comp.name)) {
-            this.repropsOwner.set(comp.name, this.state.componentName)
+          // the same child don't both emit an `init()` for it. Keyed by the
+          // child's DECLARED name (#2822) — `emitRepropsRegistration` below
+          // builds Go type references (`<Name>Props`/`<Name>Input`) from this
+          // same key, and only the declared name has real types to match.
+          if (!this.repropsOwner.has(declaredName)) {
+            this.repropsOwner.set(declaredName, this.state.componentName)
           }
         }
       }
@@ -6310,7 +6684,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // (#2457). Stays LOCAL even though the child's Input field is
       // caller-facing. Falls back to the capitalized attribute for a
       // cross-file child this run's pre-pass never registered.
-      const fieldName = this.childPropFieldNames.get(comp.name)?.get(prop.name) ?? capitalizeFieldName(prop.name)
+      const fieldName = this.childPropFieldNames.get(declaredName)?.get(prop.name) ?? capitalizeFieldName(prop.name)
       args.push(`${JSON.stringify(fieldName)} ${wrapIfMultiToken(go)}`)
     }
     if (args.length === 0) return null
@@ -7305,7 +7679,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
@@ -7342,6 +7719,75 @@ 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[] = []
+    // #2822: cross-file shapes/field-name maps are keyed by the child's own
+    // declared name, not the caller-local alias — see `importAliases`.
+    const declaredName = this.resolveChildName(comp.name)
+    const childShape = this.childComponentShapes.get(declaredName)
+    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(declaredName)?.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
@@ -7387,6 +7833,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
 
     // In Go templates, components are rendered via {{template "name" data}}.
+    // #2822: the STRING passed to `{{template "..."}}` (and the `bf_reprops`
+    // registry-key argument below) must be the child's own DECLARED name —
+    // that's what the child's own compiled Go file registers its
+    // `{{define "..."}}` block under. A field-access expression like
+    // `.${comp.name}${suffix}` stays keyed by `comp.name` (the caller-local
+    // alias) — it names THIS parent's own struct field, declared and read
+    // consistently within this one parent's generated code, with no
+    // cross-file identity to match.
+    const declaredName = this.resolveChildName(comp.name)
     let templateCall: string
     if (this.inLoop && (this.loopWrapperStack[this.loopWrapperStack.length - 1] ?? false)) {
       // Wrapper-slice loop (body IS this component): `.` is the wrapper struct
@@ -7405,9 +7860,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const bodyData = this.loopScalarItemStack[this.loopScalarItemStack.length - 1]
           ? '.BfLoopItem'
           : '.'
-        templateCall = `{{template "${comp.name}" (bf_with_children . (bf_tmpl "${loopBodyDefine}" ${bodyData}))}}`
+        templateCall = `{{template "${declaredName}" (bf_with_children . (bf_tmpl "${loopBodyDefine}" ${bodyData}))}}`
       } else {
-        templateCall = `{{template "${comp.name}" .}}`
+        templateCall = `{{template "${declaredName}" .}}`
       }
     } else if (this.inLoop && comp.slotId) {
       // Non-wrapper loop (component nested inside an element item, #2130):
@@ -7433,26 +7888,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // the row's children last, on the rebuilt value.
       const base = overrides
         ? overrides.helper === 'bf_reprops'
-          ? `(bf_reprops ${JSON.stringify(comp.name)} $.${comp.name}${suffix} ${overrides.args})`
+          ? `(bf_reprops ${JSON.stringify(declaredName)} $.${comp.name}${suffix} ${overrides.args})`
           : `(bf_with_props $.${comp.name}${suffix} ${overrides.args})`
         : `$.${comp.name}${suffix}`
       templateCall = loopBodyDefine
-        ? `{{template "${comp.name}" (bf_with_children ${base} (bf_tmpl "${loopBodyDefine}" .))}}`
-        : `{{template "${comp.name}" ${base}}}`
+        ? `{{template "${declaredName}" (bf_with_children ${base} (bf_tmpl "${loopBodyDefine}" .))}}`
+        : `{{template "${declaredName}" ${base}}}`
     } else if (this.inLoop) {
       // Loop-nested component without a slotId: no parent field to route
       // through — legacy passthrough of the current dot.
-      templateCall = `{{template "${comp.name}" .}}`
+      templateCall = `{{template "${declaredName}" .}}`
     } else if (comp.slotId) {
       // 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 "${declaredName}" (bf_with_children ${base} (bf_tmpl "${childrenDefine}" .))}}`
+        : `{{template "${declaredName}" ${base}}}`
     } else {
       // Static children without slotId: fall back to .ComponentName.
-      templateCall = `{{template "${comp.name}" .${comp.name}}}`
+      templateCall = `{{template "${declaredName}" .${comp.name}}}`
     }
 
     // A root component in a client component needs a scope comment for the