@barefootjs/go-template 0.31.7 → 0.31.9

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

@@ -14,8 +14,31 @@ 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 +51,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)
       }
     }
   }

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,16 @@
  * 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.
+ *
+ * Empty — #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)',
-}
+export const renderDivergences: RenderDivergences = {}

package/src/test-render.ts

@@ -382,6 +382,12 @@ func main() {
 		ScopeID: ${JSON.stringify(rootScopeId)},
 ${propsInit}
 	})
+	// Mirrors production's Renderer.renderComponentInto (bf.go), which marks
+	// the top-level component so BfPropsAttr emits bf-p: this harness calls
+	// tmpl.ExecuteTemplate directly instead of going through Renderer, so
+	// nothing else sets this flag. Without it every fixture's bf-p attribute
+	// is silently absent regardless of what the adapter itself does.
+	props.BfIsRoot = true
 ${dynamicSeedingLines.length > 0 ? dynamicSeedingLines.join('\n') + '\n' : ''}	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
 		os.Stderr.WriteString("template error: " + err.Error() + "\\n")
 		os.Exit(1)
@@ -587,57 +593,148 @@ function findBaseSignalGetter(expr: ParsedExpr | undefined, signalGetters: Reado
 }
 
 /**
- * (#2209 part 2) Replicate, in the generated `main.go`, the documented
- * "the route handler populates the loop-body child-component slice at
- * request time" contract for a signal-backed dynamic loop —
- * `generateNewPropsFunction`'s doc comment on `<Name>s []<Name>Props`
- * in `adapter/go-template-adapter.ts`. The constructor only ever seeds
- * the loop's DATUM slice (e.g. `.Todos`, straight from the caller's
- * Input); the child-component Props slice the template actually
- * ranges over (`.TodoItems`) has no server-side population path in
- * this harness — the Hono reference materializes it by literally
- * executing the component, so this closes the gap the same way:
- * derive each item's child Props from the datum slice, exactly as a
- * real route handler is documented to.
+ * (#2630) Resolve a `isPropDerived` loop's `arrayParsed` to the JS-level
+ * prop name it reads. `isArrayExprDirectPropRef` (`jsx-to-ir.ts`) is what
+ * sets `isPropDerivedArray` in the first place, and it only recognizes two
+ * shapes — a bare destructured-prop identifier (`entries.map(...)` inside
+ * `function({ entries })`) or a direct `props.<name>` member access — so
+ * unlike `findBaseSignalGetter` there is no `call`/chain walking to do; the
+ * compiler already restricted the shape. Returns the prop's LOCAL binding
+ * name; the caller resolves it to the CALLER-FACING field
+ * (`sourceName ?? name`) via `propsParams`, matching how
+ * `generateInputStruct`/`generateNewPropsFunction` key the Go field and how
+ * `buildGoPropsInit` keys the harness's own prop initializer (both by the
+ * JS `props` object's key, not the local destructure binding).
+ */
+function findLoopPropField(expr: ParsedExpr | undefined): string | null {
+  if (!expr) return null
+  if (expr.kind === 'identifier') return expr.name
+  if (expr.kind === 'member' && expr.object.kind === 'identifier') return expr.property
+  return null
+}
+
+/**
+ * Resolve a loop-body child prop's VALUE expression to the Go expression
+ * that reads it off the per-row `item` local: a bare pass-through of the
+ * loop param (`todo={todo}` → `item`) or a member access on it
+ * (`variant={entry.variant}` → `item.Variant`, #2630 — the
+ * `static-array-from-props-with-component-precomputed` fixture's `<Tag
+ * id={entry.id} variant={entry.variant} />`). `null` for anything else (a
+ * prop that doesn't derive from the loop row at all).
+ */
+function goItemExprForLoopProp(parsed: ParsedExpr, loopParam: string): string | null {
+  if (parsed.kind === 'identifier' && parsed.name === loopParam) return 'item'
+  if (
+    parsed.kind === 'member' &&
+    !parsed.computed &&
+    parsed.object.kind === 'identifier' &&
+    parsed.object.name === loopParam
+  ) {
+    return `item.${capitalizeFieldName(parsed.property)}`
+  }
+  return null
+}
+
+/**
+ * (#2209 part 2, extended by #2630) Replicate, in the generated `main.go`,
+ * the documented "the route handler populates the loop-body child-component
+ * slice at request time" contract from `generateNewPropsFunction`'s doc
+ * comment on `<Name>s []<Name>Props` in `adapter/go-template-adapter.ts`.
+ * Covers TWO loop shapes that both leave `.<Name>s` unpopulated in this
+ * harness, for different reasons:
+ *
+ *  - **Signal-backed dynamic** (`isDynamic && !isPropDerived`, e.g.
+ *    `todos().map(...)`): the constructor only ever seeds the loop's DATUM
+ *    slice (`.Todos`, straight from the caller's Input) — the child Props
+ *    slice the template ranges over (`.TodoItems`) is documented as
+ *    handler-populated and never touched by `NewXxxProps` at all.
+ *  - **Prop-backed static** (`isPropDerived`, e.g. `props.entries.map(...)`,
+ *    #2630): `NewXxxProps` DOES try to build `.Tags` from `in.Tags` — but
+ *    `in.Tags` is a SEPARATE Input field from the driving prop (`Entries`)
+ *    whenever the child's plural name doesn't literally coincide with the
+ *    prop's own name (`propDerivedNestedArrayFields`/`isNestedArrayShadowed`
+ *    in the real adapter), and this harness's `buildGoPropsInit` only ever
+ *    populates fields from the JS `props` object's own keys — `tags` isn't
+ *    one. `in.Tags` stays a nil slice, so the constructor's own range over
+ *    it produces zero rows. Both shapes are closed the same way: derive
+ *    each item's child Props from the resolved datum slice AFTER
+ *    construction, overwriting whatever (empty, for the prop-backed case)
+ *    slice the constructor built — exactly as a real route handler is
+ *    documented to.
+ *
+ * The Hono reference needs none of this because it materializes children by
+ * literally executing the component.
  *
  * Deliberately narrow: only fires for a loop whose (a) array source
- * resolves, through `call`/`member` chains, to a component signal
- * getter, (b) generated Go TEMPLATE text actually ranges over
+ * resolves to a signal getter (dynamic) or a direct prop reference
+ * (prop-derived) — never a `call`/member chain beyond what each shape's own
+ * resolver recognizes, (b) generated Go TEMPLATE text actually ranges over
  * `.<Name>s` (a plain substring check on GENERATED GO OUTPUT — not JS
- * parsing — so a `/* @client *\/`-marked loop, whose SSR template has
- * no such range, is untouched by construction), and (c) at least one
- * child prop is a bare pass-through of the loop item (`todo={todo}`).
- * Returns the Go statements to splice into `main()` plus whether `fmt`
- * needs importing.
+ * parsing — so a `/* @client *\/`-marked loop, whose SSR template has no
+ * such range, is untouched by construction), and (c) every resolved child
+ * prop is either a bare pass-through of the loop item (`todo={todo}`) or a
+ * member access on it (`variant={entry.variant}`). Returns the Go
+ * statements to splice into `main()` plus whether `fmt` needs importing.
  */
 function buildDynamicChildLoopSeeding(
   ir: ComponentIR,
   template: string,
 ): { lines: string[]; needsFmt: boolean } {
   const signalGetters = new Set(ir.metadata.signals.map(s => s.getter))
+  const propsParams = ir.metadata.propsParams
   const lines: string[] = []
   let needsFmt = false
   for (const nested of findNestedComponents(ir.root) as NestedComponentInfo[]) {
-    if (!nested.isDynamic || nested.isPropDerived) continue
     if (nested.bodyChildren && nested.bodyChildren.length > 0) continue
     if (!nested.loopParam) continue
     if (!template.includes(`:= .${nested.name}s}}`)) continue
-    const datumField = findBaseSignalGetter(nested.loopArrayParsed, signalGetters)
+
+    let datumField: string | null
+    if (nested.isPropDerived) {
+      const localName = findLoopPropField(nested.loopArrayParsed)
+      const param = localName ? propsParams.find(p => p.name === localName) : undefined
+      datumField = param ? (param.sourceName ?? param.name) : null
+      // (#2627/#2628 shadowing) When the driving prop's Go field name
+      // coincides with the child's own plural (`tags` prop → `Tag`
+      // component), the REAL adapter's `isNestedArrayShadowed` drops the
+      // prop's separate field entirely — `props.Tags` IS the only field,
+      // pre-shaped `TagInput` rows and all, already populated straight from
+      // the harness's own `buildGoPropsInit` (which types the literal
+      // against the Input struct's declared `[]TagInput` field). Seeding
+      // here would `range` the very slice it just emptied with `make` on
+      // the line above it — skip so that already-correct path stays
+      // untouched.
+      if (datumField && capitalizeFieldName(datumField) === capitalizeFieldName(`${nested.name}s`)) continue
+    } else if (nested.isDynamic) {
+      datumField = findBaseSignalGetter(nested.loopArrayParsed, signalGetters)
+    } else {
+      continue
+    }
     if (!datumField) continue
 
+    // All-or-nothing (Copilot review on #2630's PR): a prop that is
+    // legitimately SSR-irrelevant (event handler, `key`, dashed debug
+    // attrs) is exempt, but any OTHER prop this resolver can't express as
+    // an `item` read means the seeded `<Name>Input{...}` would carry Go
+    // zero values for it — silently wrong SSR instead of the loudly-empty
+    // host the unseeded path produces. Bail on the whole component in
+    // that case rather than seed an incomplete slice.
     const inputFields: string[] = []
+    let unresolvableProp = false
     for (const prop of nested.props) {
       if (prop.isEventHandler) continue
       if (prop.name === 'key' || prop.name.includes('-')) continue
-      if (
-        prop.value.kind === 'expression' &&
-        prop.value.parsed?.kind === 'identifier' &&
-        prop.value.parsed.name === nested.loopParam
-      ) {
-        inputFields.push(`${capitalizeFieldName(prop.name)}: item`)
+      const itemExpr =
+        prop.value.kind === 'expression' && prop.value.parsed
+          ? goItemExprForLoopProp(prop.value.parsed, nested.loopParam)
+          : null
+      if (itemExpr === null) {
+        unresolvableProp = true
+        break
       }
+      inputFields.push(`${capitalizeFieldName(prop.name)}: ${itemExpr}`)
     }
-    if (inputFields.length === 0) continue
+    if (unresolvableProp || inputFields.length === 0) continue
 
     lines.push(`\tprops.${nested.name}s = make([]${nested.name}Props, len(props.${capitalizeFieldName(datumField)}))`)
     lines.push(`\tfor i, item := range props.${capitalizeFieldName(datumField)} {`)
@@ -734,27 +831,37 @@ function buildGoPropsInit(
       let sliceLiteral: string
       if (elemType && elemType.startsWith('map[')) {
         // An untyped object-array Input field (an inline prop object type
-        // that didn't synthesize a named struct, e.g. `items: { title:
-        // string; tags: string[] }[]` — `typeInfoToGo`'s 'object' case,
-        // type-codegen.ts) resolves to `[]map[string]interface{}`, not a
-        // named struct. `goTypedSliceLiteralFromArray`'s `goStructLiteral`
-        // emits bare `Field: value` entries, which is struct-literal syntax
-        // and doesn't compile as a map literal's keys — route these through
+        // that didn't synthesize a named struct — a synthesized-name
+        // collision, #2674's graceful fallback) resolves to
+        // `[]map[string]interface{}`, not a named struct.
+        // `goTypedSliceLiteralFromArray`'s `goStructLiteral` emits bare
+        // `Field: value` entries, which is struct-literal syntax and
+        // doesn't compile as a map literal's keys — route these through
         // the map-literal builder instead (#2075, search-params-derived-filter).
         sliceLiteral = goTypedMapSliceLiteralFromArray(value, elemType)
       } else if (elemType) {
-        sliceLiteral = goTypedSliceLiteralFromArray(value, elemType)
+        sliceLiteral = goTypedSliceLiteralFromArray(value, elemType, goTypes)
       } else {
         sliceLiteral = goArrayLiteralFromArray(value)
       }
       lines.push(`\t\t${goField}: ${sliceLiteral},`)
     } else if (value && typeof value === 'object') {
-      // Plain object → Go `map[string]any` literal (#1407 follow-up).
-      // Used by `jsx-spread-rest-prop` to populate the input-bag
-      // Spread_<N> field that carries the destructured-rest payload.
-      // The same harness change is needed when any future fixture
-      // passes a `Record<string, unknown>`-shaped prop through.
-      lines.push(`\t\t${goField}: ${goMapLiteralFromObject(value as Record<string, unknown>)},`)
+      // Plain object → Go `map[string]any` literal (#1407 follow-up), UNLESS
+      // the Input field is itself a synthesized named struct (#2674 — an
+      // inline object-typed prop, e.g. `cfg: { id: number; label?: string
+      // }`, now resolves its OWN concrete struct instead of falling to
+      // `map[string]interface{}`) — a `map[string]any{…}` literal doesn't
+      // compile against a concretely-typed struct field.
+      const fieldGoType = parseGoStructFields(goTypes, `${componentName}Input`)?.get(goField)
+      if (fieldGoType && fieldGoType !== 'interface{}' && fieldGoType !== 'any' && !fieldGoType.startsWith('map[')) {
+        lines.push(`\t\t${goField}: ${goStructLiteral(value as Record<string, unknown>, fieldGoType, goTypes)},`)
+      } else {
+        // Used by `jsx-spread-rest-prop` to populate the input-bag
+        // Spread_<N> field that carries the destructured-rest payload.
+        // The same harness change is needed when any future fixture
+        // passes a `Record<string, unknown>`-shaped prop through.
+        lines.push(`\t\t${goField}: ${goMapLiteralFromObject(value as Record<string, unknown>)},`)
+      }
     }
   }
   // Emit the collected rest-bag entries as the open-ended bag field. Skip
@@ -799,12 +906,20 @@ function goSliceElemType(
  * Emit a typed Go slice literal (`[]Elem{Elem{…}, …}`). Object elements become
  * keyed struct literals with PascalCase field names; scalar elements (for an
  * `[]string` / `[]int` field) are emitted bare. (#1297, toggle-shared)
+ *
+ * `goTypes` (when supplied) threads through to `goStructLiteral` so it can
+ * look up each of ITS OWN fields' declared Go types — needed since #2674:
+ * `elemType` may now be a synthesized struct (`TaggedListItemsItem`) with a
+ * concretely-typed slice/nested-struct field (`Tags []string`), and a blind
+ * `[]any{…}`/`map[string]interface{}{…}` for that field no longer compiles
+ * against it the way it always did against the old `map[string]interface{}`
+ * element type.
  */
-function goTypedSliceLiteralFromArray(arr: unknown[], elemType: string): string {
+function goTypedSliceLiteralFromArray(arr: unknown[], elemType: string, goTypes?: string): string {
   const entries = arr.map(v => {
     if (v instanceof Date) return goStringLit(v.toISOString())
     if (v && typeof v === 'object' && !Array.isArray(v)) {
-      return goStructLiteral(v as Record<string, unknown>, elemType)
+      return goStructLiteral(v as Record<string, unknown>, elemType, goTypes)
     }
     if (typeof v === 'string') return `"${v.replace(/"/g, '\\"')}"`
     if (typeof v === 'number' || typeof v === 'boolean') return String(v)
@@ -839,11 +954,6 @@ function goTypedMapSliceLiteralFromArray(arr: unknown[], elemType: string): stri
   return `[]${elemType}{${entries.join(', ')}}`
 }
 
-/**
- * Emit a keyed Go struct literal (`Elem{Field: val, …}`) with PascalCase field
- * names. Only the keys the caller supplied are set, so an omitted optional prop
- * (e.g. `defaultOn` on the third toggle item) takes the Go zero value. (#1297)
- */
 /**
  * Emit a JS string as a Go interpreted string literal. JSON string
  * escaping is a subset of Go's (`\"`, `\\`, `\n`, `\uXXXX` are all valid
@@ -858,7 +968,71 @@ function goStringLit(v: string): string {
   return JSON.stringify(v)
 }
 
-function goStructLiteral(obj: Record<string, unknown>, typeName: string): string {
+/**
+ * #2674: parse a named Go struct's OWN field → declared-type map out of
+ * `goTypes` (the generated `types.go` text), by struct name — the SAME
+ * text-scrape strategy `goSliceElemType` uses for `<Component>Input`,
+ * generalized to ANY struct name (a synthesized element type, `Row`, a
+ * loop-body wrapper, …) so `goStructLiteral` can bake each of ITS fields
+ * against what the struct ACTUALLY declares instead of guessing generically.
+ * Returns `null` when `goTypes` is absent or the struct isn't found — callers
+ * degrade to the pre-#2674 generic (`[]any` / `map[string]interface{}`)
+ * baking for every field, same as before this existed.
+ */
+function parseGoStructFields(goTypes: string | undefined, typeName: string): Map<string, string> | null {
+  if (!goTypes) return null
+  const struct = goTypes.match(new RegExp(`type ${typeName} struct \\{([\\s\\S]*?)\\n\\}`))
+  if (!struct) return null
+  const fields = new Map<string, string>()
+  // Field lines are always `\t<GoName> <GoType>[ \`json:"..."\`][ // comment]`
+  // — GoType is one whitespace-free token in every shape this harness bakes
+  // (`string`, `[]string`, `map[string]interface{}`, `[]TaggedListItemsItem`,
+  // `interface{}`); a pointer-typed framework field (`*bf.ScriptCollector`)
+  // doesn't match this class and is skipped — this harness never bakes a
+  // VALUE for one of those.
+  const fieldRe = /\n[ \t]*(\w+)[ \t]+([\w.[\]{}]+)/g
+  let m: RegExpExecArray | null
+  while ((m = fieldRe.exec(struct[1])) !== null) {
+    fields.set(m[1], m[2])
+  }
+  return fields
+}
+
+/**
+ * Emit a typed Go scalar slice literal (`[]string{"a", "b"}`) for a struct
+ * field whose declared element type is a Go scalar (#2674 — `Tags []string`
+ * on a synthesized element struct). Falls back to `nil` for a shape that
+ * shouldn't reach a scalar-typed field (an object/array value) — dead in
+ * practice since the caller only routes here for an `Array.isArray(v)` prop
+ * value.
+ */
+function goScalarSliceLiteral(arr: unknown[], elemGoType: string): string {
+  const entries = arr.map(v => {
+    if (typeof v === 'string') return goStringLit(v)
+    if (typeof v === 'number' || typeof v === 'boolean') return String(v)
+    if (v === null) return 'nil'
+    if (v instanceof Date) return goStringLit(v.toISOString())
+    return 'nil'
+  })
+  return `[]${elemGoType}{${entries.join(', ')}}`
+}
+
+/**
+ * Emit a keyed Go struct literal (`Elem{Field: val, …}`) with PascalCase field
+ * names. Only the keys the caller supplied are set, so an omitted optional prop
+ * (e.g. `defaultOn` on the third toggle item) takes the Go zero value. (#1297)
+ *
+ * #2674: when `goTypes` is supplied, each field's VALUE bakes against what
+ * `typeName` ACTUALLY declares for that field (via `parseGoStructFields`) —
+ * a synthesized element struct can now carry a concretely-typed nested slice
+ * (`Tags []string`) or nested struct (`RowUser`), not just scalars, and a
+ * blind `[]any{…}` / `map[string]interface{}{…}` (this function's pre-#2674
+ * behavior, still the fallback when `goTypes` is absent or the field is
+ * unresolved/genuinely `interface{}`/`map[string]interface{}`-typed) no
+ * longer compiles against those.
+ */
+function goStructLiteral(obj: Record<string, unknown>, typeName: string, goTypes?: string): string {
+  const fieldTypes = parseGoStructFields(goTypes, typeName)
   const fields: string[] = []
   for (const [k, v] of Object.entries(obj)) {
     // `goFieldNameForKey`, not the bare `capitalizeFieldName` — a data-driven
@@ -866,12 +1040,42 @@ function goStructLiteral(obj: Record<string, unknown>, typeName: string): string
     // adapter's own struct-literal baking (`parsed-literal-to-go.ts`)
     // sanitizes those to `DataX`, not `Data-x` (Copilot review, #2202).
     const goField = goFieldNameForKey(k)
+    const fieldGoType = fieldTypes?.get(goField)
     if (typeof v === 'string') fields.push(`${goField}: ${goStringLit(v)}`)
     else if (typeof v === 'number' || typeof v === 'boolean') fields.push(`${goField}: ${v}`)
     else if (v === null) fields.push(`${goField}: nil`)
     else if (v instanceof Date) fields.push(`${goField}: ${goStringLit(v.toISOString())}`)
-    else if (Array.isArray(v)) fields.push(`${goField}: ${goArrayLiteralFromArray(v)}`)
-    else if (v && typeof v === 'object') fields.push(`${goField}: ${goMapLiteralFromObject(v as Record<string, unknown>, true)}`)
+    else if (Array.isArray(v)) {
+      const elemGoType = fieldGoType?.startsWith('[]') ? fieldGoType.slice(2) : null
+      if (elemGoType === 'interface{}' || elemGoType === 'any') {
+        fields.push(`${goField}: ${goArrayLiteralFromArray(v)}`)
+      } else if (elemGoType?.startsWith('map[')) {
+        fields.push(`${goField}: ${goTypedMapSliceLiteralFromArray(v, elemGoType)}`)
+      } else if (elemGoType && (v.length === 0 || typeof v[0] !== 'object')) {
+        // A scalar-element slice field (`Tags []string`) — bake a typed
+        // scalar literal, not the generic `[]any` `goArrayLiteralFromArray`
+        // would emit (doesn't compile against a concrete `[]string` field).
+        fields.push(`${goField}: ${goScalarSliceLiteral(v, elemGoType)}`)
+      } else if (elemGoType) {
+        // A struct-element slice field — recurse with the SAME `goTypes` so
+        // nesting keeps resolving (a synthesized type nested inside another
+        // synthesized type, #2674's `RowUserAddress`-style chaining).
+        fields.push(`${goField}: ${goTypedSliceLiteralFromArray(v, elemGoType, goTypes)}`)
+      } else {
+        fields.push(`${goField}: ${goArrayLiteralFromArray(v)}`)
+      }
+    }
+    else if (v && typeof v === 'object') {
+      if (fieldGoType && fieldGoType !== 'interface{}' && !fieldGoType.startsWith('map[')) {
+        // A nested named-struct field (#2674 — `RowUser`, `Row.user`'s
+        // synthesized type): recurse as a struct literal, not a map — a
+        // `map[string]interface{}{…}` literal doesn't compile against a
+        // concretely-typed struct field.
+        fields.push(`${goField}: ${goStructLiteral(v as Record<string, unknown>, fieldGoType, goTypes)}`)
+      } else {
+        fields.push(`${goField}: ${goMapLiteralFromObject(v as Record<string, unknown>, true)}`)
+      }
+    }
   }
   return `${typeName}{${fields.join(', ')}}`
 }