@barefootjs/go-template 0.31.7 → 0.31.9

package/dist/vite.js

@@ -3095,6 +3095,34 @@ var SVG_ROOT_TAGS = new Set([
   "animateTransform",
   "animateMotion"
 ]);
+var MATHML_ROOT_TAGS = new Set([
+  "math",
+  "mrow",
+  "mfrac",
+  "msup",
+  "msub",
+  "msubsup",
+  "mn",
+  "mi",
+  "mo",
+  "mtext",
+  "munder",
+  "mover",
+  "munderover",
+  "mtable",
+  "mtr",
+  "mtd",
+  "msqrt",
+  "mroot",
+  "mstyle",
+  "merror",
+  "mpadded",
+  "mphantom",
+  "menclose",
+  "semantics",
+  "annotation",
+  "annotation-xml"
+]);
 
 // ../jsx/src/ir-to-client-js/collect-elements.ts
 var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
@@ -5427,6 +5455,7 @@ class CompileState {
   localTypeAliases = new Map;
   localStructFields = new Map;
   synthStructTypes = new Map;
+  synthObjectStructNames = new Map;
   needsStringsImport = false;
 }
 
@@ -6075,8 +6104,10 @@ function typeInfoToGo(ctx, _typeInfo, defaultValue, preParsed) {
         return `[]${typeInfoToGo(ctx, typeInfo.elementType)}`;
       }
       return "[]interface{}";
-    case "object":
-      return "map[string]interface{}";
+    case "object": {
+      const synthName = ctx.state.synthObjectStructNames.get(typeInfo);
+      return synthName ?? "map[string]interface{}";
+    }
     case "interface":
       if (typeInfo.raw && (ctx.state.localStructFields.has(typeInfo.raw) || ctx.state.localTypeAliases.has(typeInfo.raw))) {
         return typeInfo.raw;
@@ -7622,11 +7653,11 @@ function buildPropTypeOverrides(ctx, ir) {
       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;
+      if (propGoType.includes("interface{}") || signalGoType !== propGoType) {
+        overrides.set(propName, signalGoType);
       }
     }
   }
@@ -7856,6 +7887,11 @@ function collectStringValueNames(ir) {
 }
 
 // src/adapter/go-template-adapter.ts
+var SYNTH_TYPE_LOC = {
+  file: "<synthesized>",
+  start: { line: 0, column: 0 },
+  end: { line: 0, column: 0 }
+};
 var STRING_METHODS = new Set([
   "replace",
   "trim",
@@ -8217,6 +8253,7 @@ ${scriptRegistrations}${templateBody}
     const lines = [];
     const componentName = ir.metadata.componentName;
     this.buildLocalTypeTables(ir, componentName);
+    this.emitSynthPropStructs(lines, ir, componentName);
     this.emitLocalTypeStructs(lines, ir, componentName);
     this.emitSynthStructs(lines, ir, componentName);
     const nestedComponents = findNestedComponents(ir.root);
@@ -9076,6 +9113,65 @@ ${goFields.join(`
       }
     }
   }
+  emitSynthPropStructs(lines, ir, componentName) {
+    this.state.synthObjectStructNames = new Map;
+    this.state.currentTypeDefinitions = [...this.state.currentTypeDefinitions];
+    const visitObject = (typeInfo, desiredName) => {
+      if (this.state.synthObjectStructNames.has(typeInfo))
+        return;
+      if (this.state.localTypeNames.has(desiredName))
+        return;
+      this.state.localTypeNames.add(desiredName);
+      this.state.synthObjectStructNames.set(typeInfo, desiredName);
+      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) => `	${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 {
+${goFields.join(`
+`)}
+}`);
+      lines.push("");
+    };
+    const visitArrayElem = (elemType, parentName, propName) => {
+      if (!elemType)
+        return;
+      if (elemType.kind === "array") {
+        visitArrayElem(elemType.elementType, parentName, propName);
+      } else if (elemType.kind === "object") {
+        visitObject(elemType, `${parentName}${goFieldNameForKey(propName)}Item`);
+      }
+    };
+    const visit = (typeInfo, parentName, propName) => {
+      if (typeInfo.kind === "array") {
+        visitArrayElem(typeInfo.elementType, parentName, propName);
+      } else if (typeInfo.kind === "object") {
+        visitObject(typeInfo, `${parentName}${goFieldNameForKey(propName)}`);
+      }
+    };
+    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);
+      }
+    }
+    for (const param of ir.metadata.propsParams) {
+      visit(param.type, componentName, param.name);
+    }
+  }
   emitLocalTypeStructs(lines, ir, componentName) {
     for (const td of ir.metadata.typeDefinitions) {
       if (td.name === "Props" || td.name === `${componentName}Props`)
@@ -9159,7 +9255,7 @@ ${goFields.join(`
   emitPropsStructHeader(lines, ir, propsTypeName, componentName) {
     lines.push(`// ${propsTypeName} is the props type for the ${componentName} component.`);
     lines.push(`type ${propsTypeName} struct {`);
-    lines.push('\tScopeID string `json:"scopeID"`');
+    lines.push('\tScopeID string `json:"-"`');
     lines.push('\tBfIsRoot bool `json:"-"`');
     lines.push('\tBfIsChild bool `json:"-"`');
     lines.push('\tBfParent string `json:"-"`');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.31.7",
+  "version": "0.31.9",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/adapter-go-template"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.7"
+    "@barefootjs/shared": "0.31.9"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -67,9 +67,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/client": "0.31.7",
-    "@barefootjs/jsx": "0.31.7",
-    "@barefootjs/vite": "0.31.7",
+    "@barefootjs/client": "0.31.9",
+    "@barefootjs/jsx": "0.31.9",
+    "@barefootjs/vite": "0.31.9",
     "vite": "^6.0.0"
   }
 }

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

@@ -1092,15 +1092,18 @@ export function Rows() {
       expect(types).toContain('Rows: []Row{Row{DataID: "a"}},')
     })
 
-    test('bakes a non-Go-identifier key inside a nested INLINE object with the same sanitizer as the accessor side (#2089 review)', () => {
-      // A nested inline-object property (`meta: { 'data-x': string }` — no
-      // named Go struct, lowered to map[string]interface{}) bakes as a Go map
-      // literal. The map KEY must be produced by `goFieldNameForKey` — the
-      // same function `buildSegmentAccessor`/`structFieldsFor` use — so the
-      // emitted accessor (`.Meta.DataX`, an exact-string MapIndex on maps)
-      // actually finds the value. `capitalizeFieldName` alone would bake
-      // `"Data-x"`, a key no emitted accessor can reach, silently rendering
-      // empty (flagged by Copilot on PR #2089).
+    test('bakes a non-Go-identifier key inside a nested INLINE object via the sanitizer-named synthesized struct (#2089 review, superseded by #2674)', () => {
+      // A nested inline-object property (`meta: { 'data-x': string }`) used
+      // to have no named Go struct and lower to `map[string]interface{}`,
+      // baked as a Go map literal with a `goFieldNameForKey`-sanitized key
+      // (`"DataX"`, not the invalid-accessor `"Data-x"` — #2089). #2674's
+      // struct-synthesis pre-pass now gives it a real struct (`RowMeta`)
+      // instead — the FIELD name still comes from the same sanitizer
+      // (`goFieldNameForKey`), so the accessor (`.Meta.DataX`) and the json
+      // tag (the ORIGINAL unsanitized source key, `"data-x"` — the struct
+      // field's json tag, not the map-baking convention's capitalized key)
+      // both still resolve correctly; only the container changed from a map
+      // to a struct.
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`
 "use client"
@@ -1113,8 +1116,11 @@ export function Rows() {
 }
 `)
       const types = adapter.generate(ir).types!
-      expect(types).toContain('map[string]interface{}{"DataX": "v"}')
+      expect(types).toContain('type RowMeta struct {')
+      expect(types).toContain('DataX string `json:"data-x"`')
       expect(types).not.toContain('"Data-x"')
+      expect(types).toContain('Row{ID: "r1", Meta: RowMeta{DataX: "v"}}')
+      expect(types).not.toContain('map[string]interface{}')
     })
 
     test('snake_case keys keep their underscore in the generated field name (#2089 review)', () => {
@@ -5029,11 +5035,14 @@ export function TodoItem(props: Props) {
     // field Done in type TodoItemProps`) or — since `bf_sort_eval`-style
     // evaluators are untouched by this fix, only the html/template dot-path
     // is — renders wrong. Post-fix: only the not-done todo (id 2) survives
-    // the 'active' filter.
-    expect(html).not.toContain('Eat breakfast')
-    expect(html).toContain('Write tests')
-    expect(html).toContain('data-key="2"')
-    expect(html).not.toContain('data-key="1"')
+    // the 'active' filter. The bf-p hydration payload legitimately carries
+    // the full unfiltered `initialTodos` (both quote styles, mirroring
+    // `normalizeHTML`), so the assertions target the rendered list only.
+    const rendered = html.replace(/\s*bf-p=(?:"[^"]*"|'[^']*')/g, '')
+    expect(rendered).not.toContain('Eat breakfast')
+    expect(rendered).toContain('Write tests')
+    expect(rendered).toContain('data-key="2"')
+    expect(rendered).not.toContain('data-key="1"')
   })
 })
 
@@ -5909,3 +5918,157 @@ export function Counter() {
     expect(template).not.toContain('<link')
   })
 })
+
+describe('GoTemplateAdapter - #2674 anonymous object types synthesize named structs', () => {
+  // Plan A: a type with no name — an inline array-element type or a nested
+  // anonymous property inside a named type — used to lower to
+  // `map[string]interface{}` with DELIBERATELY PascalCased keys
+  // (`bakeInlineObjectAsGoMap`, #2087/#1487: `html/template`'s dot access on
+  // a map does an exact-string `MapIndex`). SSR rendered fine off that
+  // convention, but `BfPropsAttr`'s `json.Marshal` ships the SAME map, so
+  // the hydration payload leaked Go casing (`{"Name":"Ada"}` instead of
+  // `{"name":"Ada"}`). `emitSynthPropStructs` now synthesizes a
+  // deterministically-named, json-tagged struct for these types instead, so
+  // the SAME value bakes as a typed struct literal and `json.Marshal`
+  // produces the correct camelCase payload without changing SSR at all.
+
+  test('inline array-element type synthesizes a named json-tagged struct (case i)', () => {
+    // `items: { id: number; tags: string[] }[]` has no backing
+    // `TypeDefinition` at all — only `ir.metadata.propsParams`' own
+    // `TypeInfo` tree carries its shape.
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  return <ul>{props.items.map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+export { TaggedList }
+`)
+    const types = adapter.generateTypes(ir)!
+    expect(types).toContain('type TaggedListItemsItem struct {')
+    expect(types).toContain('Title string `json:"title"`')
+    expect(types).toContain('Tags []string `json:"tags"`')
+    // The Input/Props field is a typed struct slice, not the old
+    // `[]map[string]interface{}` fallback.
+    expect(types).toMatch(/Items \[\]TaggedListItemsItem/)
+    expect(types).not.toContain('map[string]interface{}')
+  })
+
+  test('nested anonymous property inside a NAMED type synthesizes a named struct (case ii, Row.user)', () => {
+    // `Row` is a real `TypeDefinition`; its `user` property has no name of
+    // its own — only `ir.metadata.typeDefinitions` carries `Row`'s property
+    // list (a `{kind:'interface', raw:'Row'}` prop reference does not).
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Row = { id: string; user: { name: string } }
+export function NestedNames() {
+  const [rows, setRows] = createSignal<Row[]>([
+    { id: "r1", user: { name: "Ada" } },
+    { id: "r2", user: { name: "Grace" } },
+  ])
+  return (
+    <ul onClick={() => setRows((r) => r)}>
+      {rows().map(({ id, user: { name } }) => (
+        <li key={id}>{name}</li>
+      ))}
+    </ul>
+  )
+}
+`)
+    const types = adapter.generateTypes(ir)!
+    expect(types).toContain('type RowUser struct {')
+    expect(types).toContain('Name string `json:"name"`')
+    expect(types).toContain('User RowUser `json:"user"`')
+    // The signal's inline initial value bakes through the STRUCT literal
+    // path, not `bakeInlineObjectAsGoMap`'s capitalized-key map convention.
+    expect(types).toContain('Row{ID: "r1", User: RowUser{Name: "Ada"}}')
+    expect(types).not.toContain('map[string]interface{}')
+  })
+
+  test('a synthesized-name collision gracefully falls back to the pre-#2674 map convention, not a regression', () => {
+    // `synthesizeStructFromSignal`'s existing collision precedent
+    // (#1680, `keeps nil when the synthesised name collides with a user
+    // type`), mirrored for `emitSynthPropStructs`: when the deterministic
+    // name (`Row><Prop>`) is already taken by a real user type, synthesis
+    // is declined for that ONE type and it keeps the historical map
+    // fallback — SSR stays correct (`bakeInlineObjectAsGoMap` still bakes
+    // it), only the hydration-payload casing fix doesn't apply to it.
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type RowUser = { handle: string }
+type Row = { id: string; user: { name: string } }
+export function NestedNames() {
+  const [rows] = createSignal<Row[]>([{ id: "r1", user: { name: "Ada" } }])
+  return <ul>{rows().map(({ id, user: { name } }) => <li key={id}>{name}</li>)}</ul>
+}
+`)
+    const types = adapter.generateTypes(ir)!
+    // The user's own `RowUser` struct is emitted, untouched...
+    expect(types).toContain('type RowUser struct {')
+    expect(types).toContain('Handle string `json:"handle"`')
+    // ...and `Row.user` — whose synthesized name collides with it — falls
+    // back to the map convention rather than being silently mistyped as
+    // the unrelated user type.
+    expect(types).toMatch(/User map\[string\]interface\{\}/)
+    expect(types).toContain('map[string]interface{}{"Name": "Ada"}')
+  })
+
+  test('real go-run render: bf-p carries camelCase keys for an inline array-element prop (case i)', async () => {
+    const source = `
+function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  return <ul>{props.items.map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+export { TaggedList }
+`
+    let html: string
+    try {
+      html = await renderGoTemplateComponent({
+        source,
+        adapter: new GoTemplateAdapter(),
+        props: { items: [{ title: 'Alpha', tags: ['a', 'b'] }] },
+      })
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) return // Go toolchain not installed on this host
+      throw err
+    }
+    const bfPMatch = html.match(/bf-p="([^"]*)"/)
+    expect(bfPMatch).not.toBeNull()
+    const decoded = bfPMatch![1]
+      .replace(/&#34;/g, '"')
+      .replace(/&quot;/g, '"')
+    const payload = JSON.parse(decoded)
+    expect(payload).toEqual({ items: [{ title: 'Alpha', tags: ['a', 'b'] }] })
+  })
+
+  test('real go-run render: bf-p carries camelCase keys for a nested anonymous object inside a named type (case ii)', async () => {
+    const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Row = { id: string; user: { name: string } }
+export function NestedNames() {
+  const [rows] = createSignal<Row[]>([{ id: "r1", user: { name: "Ada" } }])
+  return <ul>{rows().map(({ id, user: { name } }) => <li key={id}>{name}</li>)}</ul>
+}
+`
+    let html: string
+    try {
+      html = await renderGoTemplateComponent({ source, adapter: new GoTemplateAdapter() })
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) return // Go toolchain not installed on this host
+      throw err
+    }
+    const bfPMatch = html.match(/bf-p="([^"]*)"/)
+    expect(bfPMatch).not.toBeNull()
+    const decoded = bfPMatch![1]
+      .replace(/&#34;/g, '"')
+      .replace(/&quot;/g, '"')
+    const payload = JSON.parse(decoded)
+    expect(payload).toEqual({ rows: [{ id: 'r1', user: { name: 'Ada' } }] })
+  })
+})

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

@@ -18,6 +18,7 @@ import type {
   IRProp,
   TypeInfo,
   TypeDefinition,
+  PropertyInfo,
   CompilerError,
   SourceLocation,
   ParsedExpr,
@@ -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 ?? []) {
@@ -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 /

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

@@ -242,6 +242,22 @@ 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