@barefootjs/go-template 0.31.8 → 0.31.10

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

@@ -18,6 +18,7 @@ import type {
   IRProp,
   TypeInfo,
   TypeDefinition,
+  PropertyInfo,
   CompilerError,
   SourceLocation,
   ParsedExpr,
@@ -118,7 +119,7 @@ import type {
 } from "./lib/types.ts"
 import { collectRootScopeNodes } from "./lib/ir-scope.ts"
 import { GO_TEMPLATE_PRIMITIVES } from "./lib/constants.ts"
-import { CompileState } from "./lib/compile-state.ts"
+import { CompileState, resolveSignalParsedThroughSeedPlan } from "./lib/compile-state.ts"
 import { hasClientInteractivity, findNestedComponents } from "./analysis/component-tree.ts"
 import { analyzeBakeableStaticChildLoop, scalarToGoLiteral, type BakedStaticChildLoop } from "./analysis/static-child-loop-bake.ts"
 import { analyzeBakeableStaticElementLoop } from "./analysis/static-element-loop-bake.ts"
@@ -142,6 +143,20 @@ import { collectStringValueNames } from "./props/prop-classes.ts"
 
 export type { GoTemplateAdapterOptions } from "./lib/types.ts"
 
+/**
+ * Placeholder `SourceLocation` for a `TypeDefinition` `emitSynthPropStructs`
+ * (#2674) pushes onto `ctx.state.currentTypeDefinitions` for a synthesized
+ * anonymous-object struct. Never rendered or used for diagnostics — the
+ * synthesized entry exists only so `parsed-literal-to-go.ts`'s
+ * `structPropertyType` can look its properties up BY NAME the same way it
+ * looks up a real user type.
+ */
+const SYNTH_TYPE_LOC: SourceLocation = {
+  file: '<synthesized>',
+  start: { line: 0, column: 0 },
+  end: { line: 0, column: 0 },
+}
+
 /**
  * Local re-materialisation of the (removed) `higher-order` ParsedExpr variant
  * (#2018 P5). Predicate callback methods (`.filter`/`.find`/`.every`/…) now
@@ -1076,6 +1091,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     this.buildLocalTypeTables(ir, componentName)
 
+    // #2674 Plan A: synthesize named structs for anonymous object types
+    // BEFORE emitting named-type structs — a nested anonymous property
+    // inside a named type (`Row.user`) needs its synthesized name registered
+    // before `emitLocalTypeStructs` computes `Row`'s own struct fields.
+    this.emitSynthPropStructs(lines, ir, componentName)
+
     this.emitLocalTypeStructs(lines, ir, componentName)
 
     this.emitSynthStructs(lines, ir, componentName)
@@ -1295,8 +1316,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * needs a real field to bake into, or the whole literal defers to nil); a
    * dedup guard drops a later key that sanitizes to a Go name already taken
    * (rare, but two fields can't share one Go identifier).
+   *
+   * Accepts anything carrying a `PropertyInfo[]` — a `TypeDefinition` (a
+   * user-named type) OR a bare `TypeInfo` of `kind: 'object'` (an anonymous
+   * type `emitSynthPropStructs` is synthesizing a struct for, #2674) — so
+   * both the named-type struct emitter and the anonymous-type synthesis
+   * pre-pass share one field-derivation path.
    */
-  private structFieldsFor(td: TypeDefinition): Array<{ tsName: string; goName: string; goType: string }> {
+  private structFieldsFor(td: { properties?: PropertyInfo[] }): Array<{ tsName: string; goName: string; goType: string }> {
     const fields: Array<{ tsName: string; goName: string; goType: string }> = []
     const seenGoNames = new Set<string>()
     for (const prop of td.properties ?? []) {
@@ -1921,7 +1948,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (propFieldNames.has(fieldName)) continue
       // `props.X ?? N` reuses the hoisted fallback var so signal and memo share
       // one value.
-      const fallbackMatch = this.extractPropFallback(signal.initialValue, signal.parsed)
+      const fallbackMatch = this.extractPropFallback(signal.initialValue, this.resolvedSignalParsed(signal))
       const hoisted = fallbackMatch ? propFallbackVars.get(fallbackMatch.propName) : undefined
       if (hoisted) {
         lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
@@ -2450,6 +2477,142 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
   }
 
+  /**
+   * #2674 Plan A: synthesize a deterministically-named, json-tagged struct
+   * for every ANONYMOUS (`kind: 'object'`) type reachable from the
+   * component's type surface, so `typeInfoToGo`'s `'object'` case (consulted
+   * by `emitLocalTypeStructs`/`generateInputStruct` right after this runs)
+   * resolves a real struct instead of falling to `map[string]interface{}` —
+   * the map `bakeInlineObjectAsGoMap` (`parsed-literal-to-go.ts`) bakes with
+   * DELIBERATELY PascalCased keys for `html/template`'s exact-case
+   * `MapIndex` (#2087/#1487), which `BfPropsAttr`'s `json.Marshal` then
+   * ships verbatim — the source of the hydration-payload Go-casing leak
+   * this pass closes.
+   *
+   * Two independent walk roots, because a NAMED type reference
+   * (`{kind:'interface', raw:'Row'}`) carries no inline `properties` — only
+   * `ir.metadata.typeDefinitions` has `Row`'s own property list:
+   *
+   *   1. Every user `TypeDefinition`'s properties (closes a nested anonymous
+   *      property inside a named type — `type Row = { id: string; user: {
+   *      name: string } }` → `Row.user`). MUST run before
+   *      `emitLocalTypeStructs`: `Row`'s own struct-field computation
+   *      (`typeDefinitionToGo` → `structFieldsFor` → `typeInfoToGo`) needs
+   *      the synthesized name for its `user` field already registered.
+   *   2. Every props param's own `TypeInfo` tree (closes an inline
+   *      array-element type with no backing `TypeDefinition` at all —
+   *      `items: { id: number; tags: string[] }[]`).
+   *
+   * Naming is deterministic on STRUCTURAL POSITION (matching
+   * `synthesizeStructFromSignal`'s `<component><Getter>Item` convention, not
+   * shape/content — two anonymous types shaped identically at different
+   * positions get different names, and the same position always yields the
+   * same name run-to-run): an array-element object gets
+   * `<parent><Prop>Item`; a direct nested object property gets
+   * `<parent><Prop>`. `<parent>` is the enclosing struct's OWN Go name for a
+   * walk-root-1 type (or the newly-synthesized name of an enclosing
+   * anonymous type, for a doubly-nested object — `RowUserAddress`), or
+   * `componentName` for a walk-root-2 (top-level props) type — threaded
+   * through the recursion so nesting chains correctly regardless of which
+   * root reached it.
+   *
+   * A synthesized name colliding with an EXISTING local type (rare: two
+   * structurally-unrelated anonymous types resolving to the same
+   * deterministic name) skips synthesis for that ONE type — and its own
+   * subtree, since there is no struct to attach nested field names to —
+   * gracefully, not as a regression: `typeInfoToGo` keeps returning the
+   * pre-#2674 map fallback for exactly that type, so the corpus never
+   * breaks, it just doesn't graduate for that one shape (see the
+   * `synthObjectStructNames` docstring on `CompileState`).
+   *
+   * A synthesized struct is ALSO pushed onto `ctx.state.currentTypeDefinitions`
+   * as a `TypeDefinition` (empty `definition`, a dummy `loc` — never
+   * rendered or used for diagnostics, only looked up by name) so
+   * `parsed-literal-to-go.ts`'s `structPropertyType` — which resolves a
+   * struct literal's nested-property TYPE by struct name against that same
+   * list — finds a synthesized parent's properties exactly like it finds a
+   * real named type's, with no separate lookup path to keep in sync.
+   */
+  private emitSynthPropStructs(lines: string[], ir: ComponentIR, componentName: string): void {
+    this.state.synthObjectStructNames = new Map<TypeInfo, string>()
+    // `primeCompileState` assigns `currentTypeDefinitions` the SAME array
+    // reference as `ir.metadata.typeDefinitions` (no clone) — copy before
+    // pushing synthesized entries onto it below, so this per-compile
+    // scratch state never mutates the IR's own metadata (which could be
+    // compiled again, or read by another consumer sharing the same IR).
+    this.state.currentTypeDefinitions = [...this.state.currentTypeDefinitions]
+
+    const visitObject = (typeInfo: TypeInfo, desiredName: string): void => {
+      // Identity guard: the exact same anonymous TypeInfo object reached via
+      // both walk roots (defensive — not expected given how the analyzer
+      // builds distinct TypeInfo instances per source occurrence).
+      if (this.state.synthObjectStructNames.has(typeInfo)) return
+      // Name-collision guard: graceful fallback to the map convention for
+      // just this type (see docstring above).
+      if (this.state.localTypeNames.has(desiredName)) return
+      this.state.localTypeNames.add(desiredName)
+      this.state.synthObjectStructNames.set(typeInfo, desiredName)
+      // Register nested children FIRST (depth-first) so this struct's OWN
+      // field-type resolution below (`structFieldsFor` → `typeInfoToGo`)
+      // sees synthesized names for any of ITS OWN nested object /
+      // array-of-object properties instead of racing ahead of them.
+      for (const prop of typeInfo.properties ?? []) {
+        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)}"\``,
+      )
+      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 => {
+      if (!elemType) return
+      if (elemType.kind === 'array') {
+        // Array-of-array (`matrix: {id:number}[][]`): keep the same
+        // parent/prop naming context at every depth — rare shape, not one
+        // the two documented #2674 cases exercise, so this just needs to
+        // stay deterministic and non-colliding, not maximally descriptive.
+        visitArrayElem(elemType.elementType, parentName, propName)
+      } else if (elemType.kind === 'object') {
+        visitObject(elemType, `${parentName}${goFieldNameForKey(propName)}Item`)
+      }
+    }
+
+    const visit = (typeInfo: TypeInfo, parentName: string, propName: string): void => {
+      if (typeInfo.kind === 'array') {
+        visitArrayElem(typeInfo.elementType, parentName, propName)
+      } else if (typeInfo.kind === 'object') {
+        visitObject(typeInfo, `${parentName}${goFieldNameForKey(propName)}`)
+      }
+    }
+
+    // Walk root 1: named types' own properties (closes `Row.user`).
+    for (const td of ir.metadata.typeDefinitions) {
+      if (td.name === 'Props' || td.name === `${componentName}Props`) continue
+      if (td.name.endsWith('Props')) continue
+      for (const prop of td.properties ?? []) {
+        visit(prop.type, td.name, prop.name)
+      }
+    }
+
+    // Walk root 2: inline prop types with no backing TypeDefinition (closes
+    // `items: { id: number; tags: string[] }[]`).
+    for (const param of ir.metadata.propsParams) {
+      visit(param.type, componentName, param.name)
+    }
+  }
+
   private emitLocalTypeStructs(lines: string[], ir: ComponentIR, componentName: string): void {
     for (const td of ir.metadata.typeDefinitions) {
       if (td.name === 'Props' || td.name === `${componentName}Props`) continue
@@ -2552,7 +2715,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private emitPropsStructHeader(lines: string[], ir: ComponentIR, propsTypeName: string, componentName: string): void {
     lines.push(`// ${propsTypeName} is the props type for the ${componentName} component.`)
     lines.push(`type ${propsTypeName} struct {`)
-    lines.push('\tScopeID string `json:"scopeID"`')
+    // Internal scope id: used by the Go template (`{{.ScopeID}}`) to render bf-s
+    // markers, but no client runtime consumer ever reads it back out of the
+    // hydration bf-p JSON (audited: the only bf-p parser is
+    // packages/client/src/runtime/hydrate.ts's parseProps/runInit, and nothing
+    // downstream of it reads scopeID). Excluded from Marshal via `json:"-"` — Go's
+    // json tag only affects (un)marshalling, not template field access, so
+    // `{{.ScopeID}}` keeps working unchanged.
+    lines.push('\tScopeID string `json:"-"`')
     lines.push('\tBfIsRoot bool `json:"-"`')
     lines.push('\tBfIsChild bool `json:"-"`')
     // Slot identity for child scopes: host scope id + slot id. Emitted as bf-h /
@@ -2612,7 +2782,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (signal.envReader) continue
       const fieldName = capitalizeFieldName(signal.getter)
       if (propFieldNames.has(fieldName)) continue
-      const jsonTag = this.claimJsonTag(this.toJsonTag(signal.getter), takenJsonTags)
+      // Signal fields are component-internal state, not caller input (#2672):
+      // the client never reads `_p.<signalGetter>` — it re-derives the value
+      // from `createSignal(...)`'s own initial expression (which itself reads
+      // whatever PROP field seeded it, already emitted above with a real tag
+      // by the propsParams loop). Excluding the signal field from JSON stops
+      // it from co-boarding into `bf-p` while leaving `{{.Field}}` SSR access
+      // untouched — Go template field access doesn't consult json tags.
+      const jsonTag = '-'
       // A synthesised struct type wins outright — the signal is an untyped
       // object array we gave a concrete element type.
       const synthType = this.state.synthStructTypes.get(signal.getter)
@@ -2662,7 +2839,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     for (const memo of ir.metadata.memos) {
       const fieldName = capitalizeFieldName(memo.name)
       if (propFieldNames.has(fieldName)) continue
-      const jsonTag = this.claimJsonTag(this.toJsonTag(memo.name), takenJsonTags)
+      // Memo fields are derived, re-computed client-side from the same prop
+      // reads the memo body itself performs — never read as `_p.<memoName>`
+      // (#2672). Same rationale as the signal fields above.
+      const jsonTag = '-'
       const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap)
       lines.push(`\t${fieldName} ${goType} \`json:"${jsonTag}"\``)
     }
@@ -2698,10 +2878,27 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       ...ir.metadata.memos.map(m => capitalizeFieldName(m.name)),
     ])
     for (const c of this.nonCollidingContextConsumers(takenProps)) {
-      const jsonTag = this.claimJsonTag(this.toJsonTag(c.localName), takenJsonTags)
+      // Context-consumer fields are resolved server-side from the enclosing
+      // `Provider` and read via `{{.Field}}` in SSR only — the client's own
+      // `useContext` re-reads the DOM-scoped provider value at hydration
+      // time, never `_p.<contextField>` (#2672).
+      const jsonTag = '-'
       lines.push(`\t${this.contextFieldName(c)} ${this.contextConsumerGoType(c)} \`json:"${jsonTag}"\``)
     }
 
+    // Capitalized Go field names of every declared prop — BOTH the LOCAL
+    // binding and the caller-facing (`sourceName`) spelling, unioned the
+    // same way `isNestedArrayShadowed` does for the propsParams loop above
+    // (an aliased destructure like `{ rows: items }` can collide under
+    // either naming depending on alias direction — see the #2525 collision
+    // tests). Used below to detect when a nested-array field's name
+    // collides with (and shadows) an actual prop field.
+    const propDrivingFieldNames = new Set<string>()
+    for (const p of ir.metadata.propsParams) {
+      propDrivingFieldNames.add(capitalizeFieldName(p.name))
+      propDrivingFieldNames.add(capitalizeFieldName(p.sourceName ?? p.name))
+    }
+
     for (const nested of nestedComponents) {
       // An orphaned clientOnly nested loop (#2627 — see
       // `isOrphanedClientOnlyNested`) gets NO Props field at all, not even
@@ -2719,8 +2916,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (nested.isDynamic && !nested.isPropDerived) {
         // Dynamic signal-array loops are template-only.
         lines.push(`\t${nested.name}s []${elemType} \`json:"-"\``)
+      } else if (
+        nested.isDynamic &&
+        nested.isPropDerived &&
+        !propDrivingFieldNames.has(`${nested.name}s`)
+      ) {
+        // Prop-derived dynamic loops (`props.items.map(item => <Child/>)`,
+        // #2672): this field is USUALLY a RE-SHAPED COPY of the driving prop,
+        // built for SSR's `{{range}}` — not the prop itself. The client's own
+        // `mapArray` re-derives every row straight from the real prop field
+        // (`_p.items`, emitted with a real tag by the propsParams loop
+        // above), never from `_p.<Name>s`, so co-boarding this copy into
+        // `bf-p` is redundant component-internal derivation, same as a memo.
+        //
+        // EXCEPT when the two Go field names collide (`propDrivingFieldNames`
+        // — mirrors `isNestedArrayShadowed`'s check the propsParams loop
+        // itself runs): a prop named `toggleItems` driving a `<ToggleItem>`
+        // loop capitalizes to the SAME Go field name as the nested-array
+        // field (`ToggleItems`), so `emitPropsDataFields` shadows the prop's
+        // OWN field entirely and this array field is the ONLY carrier of
+        // that prop's data. Flipping it there would silently drop caller
+        // input from `bf-p` instead of merely trimming a redundant copy —
+        // the `else` branch below keeps a real tag for exactly that case.
+        lines.push(`\t${nested.name}s []${elemType} \`json:"-"\``)
       } else {
-        // Static + prop-derived arrays go in JSON so the client can hydrate.
+        // Static arrays go in JSON so the client can hydrate (that data can
+        // be non-literal, request-time Input the caller supplies with no
+        // prop-field twin to fall back on) — and so does a prop-derived
+        // dynamic array whose field name shadows its own driving prop's
+        // field (the `propDrivingFieldNames` case above): this field is
+        // that prop's ONLY remaining carrier in the struct.
         const jsonTag = this.claimJsonTag(
           this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`),
           takenJsonTags,
@@ -2736,9 +2961,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     // Top-level intrinsic-element spreads: each gets a `Spread_<slotId>
     // map[string]any` field the template reads via `{{bf_spread_attrs}}`.
-    // Loop-internal spreads emit inline and don't appear here.
+    // Loop-internal spreads emit inline and don't appear here. SSR-only —
+    // the resolved attrs are already baked into the rendered HTML, and no
+    // client runtime reads `_p.Spread_<slotId>` back out of `bf-p` (#2672).
     for (const slot of spreadSlots) {
-      const jsonTag = this.claimJsonTag(this.toJsonTag(slot.slotId), takenJsonTags)
+      const jsonTag = '-'
       lines.push(`\t${slot.slotId} map[string]any \`json:"${jsonTag}"\``)
     }
   }
@@ -3361,7 +3588,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     const propTypeOverrides = buildPropTypeOverrides(this.emitCtx, ir)
     for (const signal of ir.metadata.signals) {
-      const match = this.extractPropFallback(signal.initialValue, signal.parsed)
+      const match = this.extractPropFallback(signal.initialValue, this.resolvedSignalParsed(signal))
       if (!match) continue
       if (result.has(match.propName)) continue
       const param = ir.metadata.propsParams.find(p => p.name === match.propName)
@@ -3426,6 +3653,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return result
   }
 
+  /**
+   * Resolve a signal's initializer through the SSR seed plan's const-hop
+   * inlining (#2685) before prop-fallback extraction — see
+   * {@link resolveSignalParsedThroughSeedPlan} (shared with
+   * `collectNullishConsumedPropNames`'s signal-seed loop, the single door
+   * both consumers of this resolution go through).
+   */
+  private resolvedSignalParsed(signal: { getter: string; parsed?: ParsedExpr }): ParsedExpr | undefined {
+    return resolveSignalParsedThroughSeedPlan(this.state, signal)
+  }
+
   /**
    * Parse a signal-time initial value of the form `props.X ?? <literal>` —
    * or, for destructured components, `x ?? <literal>` — into the source prop

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

@@ -22,6 +22,7 @@ import type {
   IRNode,
   LoweringMatcher,
   MemoInfo,
+  ParsedExpr,
   SsrSeedPlan,
   TypeDefinition,
   TypeInfo,
@@ -242,7 +243,56 @@ export class CompileState {
    */
   synthStructTypes: Map<string, TypeInfo> = new Map()
 
+  /**
+   * #2674 Plan A: ANONYMOUS (`kind: 'object'`) `TypeInfo` instance → the
+   * deterministically-named json-tagged struct `emitSynthPropStructs`
+   * synthesized for it, populated during generateTypes. Keyed by object
+   * IDENTITY, not name/shape: two anonymous object types at different
+   * structural positions (an inline array-element type vs. a nested
+   * property inside a named type) get different synthesized names even
+   * when shaped identically, so a content/shape key would wrongly unify
+   * them. `typeInfoToGo`'s `'object'` case consults this before falling
+   * back to `map[string]interface{}` — the map fallback stays reachable
+   * for the ONE case this pass declines: a synthesized name colliding with
+   * an existing local type (graceful, not a regression — see
+   * `emitSynthPropStructs`'s docstring).
+   */
+  synthObjectStructNames: Map<TypeInfo, string> = new Map()
+
   /** Set when a constructor-context lowering emits a `strings.` call, so
    *  `strings` is added to the generated types file's import block. */
   needsStringsImport = false
 }
+
+/**
+ * Resolve a signal's initializer through the SSR seed plan's const-hop
+ * inlining (#2685, `resolveThroughLocalConsts` in
+ * `packages/jsx/src/ssr-seed-plan.ts`) before prop-fallback shape matching,
+ * so a component-scope `const` sitting between a `props.X` read and
+ * `createSignal` (`const mid = props.label; createSignal(mid ?? 'Default')`)
+ * doesn't hide the `props.X ?? <literal>` shape from
+ * `extractPropFallbackFromParsed` / `collectNullishConsumedPropNames`'s
+ * signal-seed loop — both need the SAME resolved tree (single door, not two
+ * divergent walks: a mismatch between them is exactly what let the field-type
+ * flip and the fallback-var construction disagree on nullish handling for
+ * the const-hop shape).
+ *
+ * Falls back to the signal's own `parsed` when the plan didn't classify this
+ * signal `derived` (opaque for an unrelated reason, e.g. a free identifier
+ * genuinely out of scope) — never invents a substitution the plan itself
+ * didn't make.
+ *
+ * `signal` takes the minimal structural shape (not the internal `SignalInfo`
+ * type, which `@barefootjs/jsx`'s public index doesn't export — the same
+ * inline-shape convention `memo-compute.ts`'s extracted helpers already use
+ * for signal params).
+ */
+export function resolveSignalParsedThroughSeedPlan(
+  state: CompileState,
+  signal: { getter: string; parsed?: ParsedExpr },
+): ParsedExpr | undefined {
+  const step = state.ssrSeedPlan.steps.find(
+    s => s.kind === 'derived' && s.origin === 'signal' && s.name === signal.getter,
+  )
+  return step?.kind === 'derived' ? step.parsed : signal.parsed
+}

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

@@ -9,13 +9,37 @@ import type { ComponentIR, IRMetadata, IRNode, ParsedExpr } from '@barefootjs/js
 import { isBooleanAttr } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
+import { resolveSignalParsedThroughSeedPlan } from '../lib/compile-state.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 
 /**
  * Build a map from prop name to a better Go type inferred from signals. When a
  * signal is initialized from a prop (`createSignal(props.initial ?? 0)`), the
- * signal's type annotation may be more specific than the prop's `TypeInfo`. Only
- * generic prop types (containing `interface{}`) are overridden.
+ * signal's type annotation may be more specific than the prop's `TypeInfo`.
+ *
+ * Two trigger conditions, mirroring `emitPropsDataFields`'s identical
+ * signal-vs-prop reconciliation for the PROPS struct field (`generate - Go
+ * struct types` — "Let a specific signal type override a less-specific prop
+ * type in either direction"), so the Input/Props field type this override
+ * feeds (via `resolvePropGoType`) and the constructor's baked VALUE
+ * (`convertInitialValue`'s `extractPropNameFromInitialValue` prop-passthrough
+ * shortcut) never disagree about which type is authoritative:
+ *
+ *   1. A generic prop type (containing `interface{}`) — the historical case.
+ *   2. #2674: BOTH sides resolve to a CONCRETE type that DISAGREES — e.g. an
+ *      inline array-element prop type (`initialTodos: Array<{ id, text,
+ *      done }>`) now independently synthesizes its OWN named struct
+ *      (`TodoAppInitialTodosItem`) rather than falling to `interface{}`, but
+ *      a signal seeded from it via a shape-widening transform
+ *      (`createSignal<Todo[]>((props.initialTodos ?? []).map(t => ({...t,
+ *      editing: false})))`, `Todo` carrying an EXTRA `editing` field) still
+ *      wants the signal's own `Todo` element type. Before #2674 this case
+ *      was unreachable — every inline object/array prop type WAS
+ *      `interface{}`-containing, so case 1 always fired — leaving the
+ *      passthrough shortcut safe by accident (prop and signal Go types were
+ *      always forced equal). Widening to case 2 restores that same
+ *      equality now that a prop's own type can independently resolve to
+ *      something concrete but narrower.
  */
 export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map<string, string> {
   const overrides = new Map<string, string>()
@@ -28,11 +52,10 @@ export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map
       const param = ir.metadata.propsParams.find(p => p.name === propName)
       if (!param) continue
       const propGoType = typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed)
-      if (propGoType.includes('interface{}')) {
-        const signalGoType = typeInfoToGo(ctx, signal.type, signal.initialValue, signal.parsed)
-        if (!signalGoType.includes('interface{}')) {
-          overrides.set(propName, signalGoType)
-        }
+      const signalGoType = typeInfoToGo(ctx, signal.type, signal.initialValue, signal.parsed)
+      if (signalGoType.includes('interface{}')) continue // never widen TO something less resolved
+      if (propGoType.includes('interface{}') || signalGoType !== propGoType) {
+        overrides.set(propName, signalGoType)
       }
     }
   }
@@ -196,7 +219,12 @@ export function collectNullishConsumedPropNames(ctx: GoEmitContext, ir: Componen
   // 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)
+    // Resolved through the seed plan's const-hop inlining (#2685) — see
+    // `resolveSignalParsedThroughSeedPlan` — so a component-scope `const`
+    // between `props.X` and `createSignal` doesn't leave this loop and
+    // `collectPropFallbackVars`'s identical extraction disagreeing on
+    // whether the prop needs the nillable flip.
+    const match = ctx.extractPropFallback(signal.initialValue, resolveSignalParsedThroughSeedPlan(ctx.state, signal))
     if (!match || !optionalParams.has(match.propName)) continue
     const f = match.goFallback
     if (f === '""' || f === 'false' || f === 'nil' || Number(f) === 0) continue

package/src/adapter/type/type-codegen.ts

@@ -141,8 +141,25 @@ export function typeInfoToGo(
         return `[]${typeInfoToGo(ctx, typeInfo.elementType)}`
       }
       return '[]interface{}'
-    case 'object':
-      return 'map[string]interface{}'
+    case 'object': {
+      // #2674 Plan A: an ANONYMOUS object type — an inline array-element
+      // type (`items: { id: number }[]`) or a nested anonymous property
+      // inside a named type (`Row.user`) — synthesizes a deterministically-
+      // named, json-tagged struct in `emitSynthPropStructs`, registered here
+      // by the exact `TypeInfo` object's IDENTITY (not name/shape — two
+      // anonymous types at different structural positions get different
+      // synthesized names even when shaped identically). That pre-pass runs
+      // before this function is ever consulted for the current compile (see
+      // `generateTypes()`'s ordering), so a hit here means a real struct was
+      // emitted; a miss (no pre-pass ran, or the pre-pass skipped this exact
+      // type on a synthesized-name collision) falls back to the historical
+      // `map[string]interface{}` — the same PascalCase-baked map
+      // `bakeInlineObjectAsGoMap` (`parsed-literal-to-go.ts`) still targets,
+      // so SSR stays correct and only the hydration-payload leak the
+      // synthesis closes remains open for that one skipped type.
+      const synthName = ctx.state.synthObjectStructNames.get(typeInfo)
+      return synthName ?? 'map[string]interface{}'
+    }
     case 'interface':
       // Gate on an ACTUAL backing (a generated struct — `localStructFields` —
       // or a string-union alias — `localTypeAliases`, which emits `type X =

package/src/render-divergences.ts

@@ -5,14 +5,40 @@
  * one object, so the skip list and the declaration can't drift. Keep the
  * file even when the set is empty — the next divergence lands here, not in
  * a re-created file.
+ *
+ * (#2630's `static-array-from-props-with-component-precomputed` divergence
+ * graduated once the harness (`test-render.ts`'s
+ * `buildDynamicChildLoopSeeding`, despite the name — see its doc comment)
+ * learned to seed a prop-backed static child-component loop's Props slice
+ * the same way it already seeded a signal-backed dynamic one: the adapter's
+ * own `emission` was never the bug, only this harness's route-handler
+ * stand-in was missing the prop-derived case.)
  */
 
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
-  // #2630: the exact shape BF101's pass-as-prop suggestion (#2321) steers
-  // go-template users into — compiles clean, runs clean, silently renders the
-  // loop host empty. Full analysis in the issue.
-  'static-array-from-props-with-component-precomputed':
-    'prop-backed child-component loop renders the loop host empty at SSR (https://github.com/piconic-ai/barefootjs/issues/2630)',
+  // #2683: the props-struct emitter (`go-template-adapter.ts`) skips a
+  // signal whose Go field name collides with a prop field, keyed purely on
+  // the NAME collision — never on whether `extractPropFallback` actually
+  // matched a supported `props.x ?? <default>` shape. For a non-idempotent
+  // derivation (`createSignal((props.count ?? 1) * 2)`) the fallback
+  // extractor correctly declines to fold `* 2` into the struct default, but
+  // the `continue` fires anyway on the name match alone, so the emitted
+  // struct field silently drops the `* 2` and the signal's initial value
+  // renders as the raw prop instead of its derived value. Not a one-liner:
+  // two Go struct fields can't share an identifier, so simply removing the
+  // skip emits a duplicate field — the real fix needs its own PR.
+  'signal-prop-same-name-derived':
+    'self-derived signal collides with its prop field name in the generated Go props struct — the non-idempotent `* 2` derivation is dropped and the signal renders the raw prop value instead (https://github.com/piconic-ai/barefootjs/issues/2683)',
+  // #2685 review: same #2683 bug, one hop of const indirection removed —
+  // the props-struct field-name collision is keyed on the SIGNAL's name,
+  // not on how its initializer reaches the prop, so
+  // `const mid = props.count; createSignal((mid ?? 1) * 2)` collides
+  // exactly like the direct-access form above. This is go's PRE-EXISTING
+  // #2683 defect surfacing through a new fixture, not a regression from
+  // the #2685 review fix (which lands correctly on every other
+  // template-stash adapter — see those adapters' conformance runs).
+  'signal-prop-same-name-via-const-derived':
+    'self-derived signal (reached through a component-scope const) collides with its prop field name in the generated Go props struct — the non-idempotent `* 2` derivation is dropped and the signal renders the raw prop value instead (https://github.com/piconic-ai/barefootjs/issues/2683)',
 }