@barefootjs/go-template 0.6.1 → 0.8.0

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

@@ -34,6 +34,7 @@ import type {
   IRIfStatement,
   IRProvider,
   IRAsync,
+  IRMetadata,
   TemplatePrimitiveRegistry,
 } from '@barefootjs/jsx'
 import {
@@ -418,6 +419,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    *  `template.HTML(...)`; toggles the `"html/template"` import. */
   private usesHtmlTemplate: boolean = false
 
+  /**
+   * Module-scope pure string-literal constants (`const X = 'literal'` at
+   * file top-level), keyed by name → resolved literal value. Populated at
+   * `generate()` entry from `ir.metadata.localConstants`. When an identifier
+   * in an expression resolves to one of these, the adapter inlines the
+   * literal value instead of emitting a struct-field reference
+   * (`{{.X}}`) — the field never exists on the Props struct, so without
+   * inlining Go's template engine fails with `can't evaluate field X`.
+   * Hono inlines it for free (it evaluates real JS); this restores parity.
+   * Only module-scope, pure string literals qualify — function-scope
+   * locals legitimately become template vars/props, and `Record<T,string>`
+   * indexed lookups / memos / signals are deliberately excluded.
+   */
+  private moduleStringConsts: Map<string, string> = new Map()
+
+  /**
+   * Set of prop NAMES whose resolved Go struct-field type is exactly
+   * `interface{}` — i.e. nillable. Populated at `generate()` entry from
+   * the SAME per-prop Go-type computation `generatePropsStruct` /
+   * `generateInputStruct` use (`propTypeOverrides` + `typeInfoToGo`), so
+   * it can't drift from the actual field types. Used by
+   * `elementAttrEmitter.emitExpression` to omit a dynamic attribute whose
+   * value is a bare reference to a nillable prop when that prop is nil
+   * (Hono-style nullish-attribute omission: an `undefined`-valued
+   * attribute is dropped rather than rendered as `attr=""`). Concrete
+   * (`string`/`int`/`bool`) fields are never in this set and always emit
+   * unconditionally, matching Hono's `value=""` / `data-count="0"`.
+   */
+  private nillablePropNames: Set<string> = new Set()
+
   constructor(options: GoTemplateAdapterOptions = {}) {
     super()
     this.options = {
@@ -438,6 +469,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.templateVarCounter = 0
     this.propsObjectName = ir.metadata.propsObjectName
     this.restPropsName = ir.metadata.restPropsName ?? null
+    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
+    this.nillablePropNames = this.collectNillablePropNames(ir)
 
     // Surface loop-body usages of components imported from sibling
     // .tsx files. The adapter emits `{{template "X" .}}` for these,
@@ -1048,6 +1081,40 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return overrides
   }
 
+  /**
+   * Resolve a prop param's Go struct-field type using the SAME logic
+   * `generatePropsStruct` / `generateInputStruct` use for the field
+   * declaration: a `propTypeOverrides` entry (signal-inferred override)
+   * wins, otherwise `typeInfoToGo(param.type, param.defaultValue)`.
+   * Factored out so the nillable-field set (`collectNillablePropNames`)
+   * can't drift from the actual emitted field types.
+   */
+  private resolvePropGoType(
+    param: IRMetadata['propsParams'][number],
+    propTypeOverrides: Map<string, string>,
+  ): string {
+    return propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue)
+  }
+
+  /**
+   * Build the set of prop NAMES whose resolved Go field type is exactly
+   * `interface{}` (nillable). Uses the same `propTypeOverrides` +
+   * `resolvePropGoType` pipeline as the struct generators, so a prop
+   * that ends up `interface{}` on the Props struct — and only such a
+   * prop — is treated as nillable for Hono-style attribute omission.
+   * Concrete (`string`/`int`/`bool`/`[]T`/struct) types are excluded.
+   */
+  private collectNillablePropNames(ir: ComponentIR): Set<string> {
+    const propTypeOverrides = this.buildPropTypeOverrides(ir)
+    const nillable = new Set<string>()
+    for (const param of ir.metadata.propsParams) {
+      if (this.resolvePropGoType(param, propTypeOverrides) === 'interface{}') {
+        nillable.add(param.name)
+      }
+    }
+    return nillable
+  }
+
   /**
    * Generate Input struct for a component
    */
@@ -1079,7 +1146,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     for (const param of ir.metadata.propsParams) {
       const fieldName = this.capitalizeFieldName(param.name)
       if (nestedArrayFields.has(fieldName)) continue
-      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue)
+      const goType = this.resolvePropGoType(param, propTypeOverrides)
       lines.push(`\t${fieldName} ${goType}`)
     }
 
@@ -1152,7 +1219,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       const fieldName = this.capitalizeFieldName(param.name)
       // Skip if this field will be replaced by a typed array for nested components
       if (nestedArrayFields.has(fieldName)) continue
-      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue)
+      const goType = this.resolvePropGoType(param, propTypeOverrides)
       const jsonTag = this.toJsonTag(param.name)
       lines.push(`\t${fieldName} ${goType} \`json:"${jsonTag}"\``)
       propFieldNames.add(fieldName)
@@ -1624,6 +1691,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   ): void {
     if (node.type === 'component') {
       const comp = node as IRComponent
+      // Dynamic-tag locals (`const Tag = children.tag`) have no registrable
+      // template, so they get no `.<Name>SlotN` struct field. Recurse into
+      // their children (which lower as a passthrough) so any real static
+      // child components nested inside still get their slot fields.
+      if (comp.dynamicTag) {
+        for (const child of comp.children) {
+          this.collectStaticChildInstancesRecursive(child, result, inLoop)
+        }
+        return
+      }
       // Skip Portal components (handled separately via PortalCollector)
       // Skip components inside loops (handled by nestedComponents)
       if (comp.name !== 'Portal' && !inLoop && comp.slotId) {
@@ -1895,6 +1972,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     ir: ComponentIR,
   ): string | null {
     const trimmed = spreadExpr.trim()
+    // Conditional inline-object spread:
+    //   `{...(COND ? { 'k': v } : {})}` (either branch possibly `{}`).
+    // Lower to an immediately-invoked func literal that conditionally
+    // builds the bag, so the falsy branch yields an empty map (the key
+    // is OMITTED rather than rendered as `k=""` — `SpreadAttrs` does
+    // NOT filter empty strings). Returns null for any shape it can't
+    // faithfully convert so the caller falls back to BF101 (#textarea).
+    const conditional = this.buildConditionalSpreadInitializer(trimmed, ir)
+    if (conditional !== undefined) return conditional
     // Signal-getter call: `attrs()` — pluck the signal's initialValue
     // and translate the JS object literal to a Go map literal.
     const callMatch = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*\(\s*\)$/.exec(trimmed)
@@ -1947,6 +2033,152 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return null
   }
 
+  /**
+   * Lower a conditional inline-object spread bag value:
+   *   `(COND ? { 'aria-describedby': describedBy } : {})`
+   * into an immediately-invoked Go func literal that conditionally
+   * builds the map (so the falsy branch OMITS the key rather than
+   * rendering it as an empty string, which `SpreadAttrs` does not
+   * filter):
+   *
+   *   func() map[string]any {
+   *     if in.DescribedBy != nil && in.DescribedBy != "" {
+   *       return map[string]any{"aria-describedby": in.DescribedBy}
+   *     }
+   *     return map[string]any{}
+   *   }()
+   *
+   * Returns:
+   *   - `undefined` when the expression is NOT a parenthesized ternary
+   *     of object literals — the caller falls through to other shapes.
+   *   - `null` when it IS that shape but a part can't be faithfully
+   *     converted (non-static key, unsupported condition, …) — the
+   *     caller raises BF101.
+   *   - the Go IIFE string when fully convertible.
+   */
+  private buildConditionalSpreadInitializer(
+    spreadExpr: string,
+    ir: ComponentIR,
+  ): string | null | undefined {
+    const expr = this.parseLiteralExpression(spreadExpr)
+    if (!expr || !ts.isConditionalExpression(expr)) return undefined
+    const whenTrue = this.unwrapParens(expr.whenTrue)
+    const whenFalse = this.unwrapParens(expr.whenFalse)
+    if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
+      return undefined
+    }
+    // Condition → Go bool against `in.`, type-aware on the prop.
+    const goCond = this.conditionToGoBool(expr.condition, ir)
+    if (goCond === null) return null
+    const trueMap = this.objectLiteralToGoSpreadMap(whenTrue, ir)
+    const falseMap = this.objectLiteralToGoSpreadMap(whenFalse, ir)
+    if (trueMap === null || falseMap === null) return null
+    return (
+      `func() map[string]any {\n` +
+      `\t\tif ${goCond} {\n` +
+      `\t\t\treturn ${trueMap}\n` +
+      `\t\t}\n` +
+      `\t\treturn ${falseMap}\n` +
+      `\t}()`
+    )
+  }
+
+  /** Strip redundant parenthesised wrappers off a TS expression. */
+  private unwrapParens(node: ts.Expression): ts.Expression {
+    let e = node
+    while (ts.isParenthesizedExpression(e)) e = e.expression
+    return e
+  }
+
+  /**
+   * Convert a conditional-spread condition expression to a Go bool in
+   * the `in.` context. Supports a bare prop identifier (`describedBy`)
+   * and its negation (`!describedBy`), type-aware on the prop:
+   *   string  → `in.X != ""`
+   *   boolean → `in.X`
+   *   number  → `in.X != 0`
+   *   unknown / interface{} → `in.X != nil && in.X != ""`
+   *     (faithful JS string-truthiness for an interface holding a
+   *     string — textarea's `describedBy` resolves to interface{}).
+   * Returns null for any other shape (caller → BF101).
+   */
+  private conditionToGoBool(
+    condition: ts.Expression,
+    ir: ComponentIR,
+  ): string | null {
+    let node = this.unwrapParens(condition)
+    let negate = false
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
+      negate = true
+      node = this.unwrapParens(node.operand)
+    }
+    if (!ts.isIdentifier(node)) return null
+    const param = ir.metadata.propsParams.find(p => p.name === node.text)
+    if (!param) return null
+    const field = `in.${this.capitalizeFieldName(param.name)}`
+    const prim = param.type.kind === 'primitive' ? param.type.primitive : undefined
+    let truthy: string
+    if (prim === 'boolean') {
+      truthy = field
+    } else if (prim === 'number') {
+      truthy = `${field} != 0`
+    } else if (prim === 'string') {
+      truthy = `${field} != ""`
+    } else {
+      // unknown / interface{}: the runtime value may be a string, number,
+      // bool, etc., so a string-biased `!= ""` test would diverge from JS
+      // truthiness (e.g. an `interface{}` holding `0` or `false` is falsy in
+      // JS but `!= ""` reads true). Route through `bf.Truthy`, the exported
+      // `Boolean(x)` equivalent, for a faithful check (Copilot review #1752).
+      truthy = `bf.Truthy(${field})`
+    }
+    if (!negate) return truthy
+    // Negation: wrap so `!` applies to the whole truthiness test.
+    if (prim === 'boolean') return `!${field}`
+    if (prim === 'number') return `${field} == 0`
+    if (prim === 'string') return `${field} == ""`
+    return `!bf.Truthy(${field})`
+  }
+
+  /**
+   * Convert a static object literal (`{ 'aria-describedby': describedBy }`)
+   * into a Go `map[string]any{...}` literal for a conditional spread.
+   * Only static string/identifier keys are allowed; values resolve
+   * prop-identifier references to `in.FieldName` and string literals to
+   * Go string literals. Returns null for any computed/spread/dynamic
+   * key or unsupported value (caller → BF101). Empty object → `map[string]any{}`.
+   */
+  private objectLiteralToGoSpreadMap(
+    obj: ts.ObjectLiteralExpression,
+    ir: ComponentIR,
+  ): string | null {
+    const entries: string[] = []
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop)) return null
+      let key: string
+      if (ts.isIdentifier(prop.name)) {
+        key = prop.name.text
+      } else if (ts.isStringLiteral(prop.name) || ts.isNoSubstitutionTemplateLiteral(prop.name)) {
+        key = prop.name.text
+      } else {
+        return null
+      }
+      const val = this.unwrapParens(prop.initializer)
+      let goVal: string
+      if (ts.isStringLiteral(val) || ts.isNoSubstitutionTemplateLiteral(val)) {
+        goVal = JSON.stringify(val.text)
+      } else if (ts.isIdentifier(val)) {
+        const param = ir.metadata.propsParams.find(p => p.name === val.text)
+        if (!param) return null
+        goVal = `in.${this.capitalizeFieldName(param.name)}`
+      } else {
+        return null
+      }
+      entries.push(`${JSON.stringify(key)}: ${goVal}`)
+    }
+    return `map[string]any{${entries.join(', ')}}`
+  }
+
   /**
    * Convert JavaScript initial value to Go value for NewXxxProps function.
    * References to props params are converted to in.FieldName format.
@@ -2891,6 +3123,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   // ===========================================================================
 
   identifier(name: string): string {
+    // Module pure-string const (e.g. `const baseClasses = '...'` used in a
+    // className template literal): inline the literal value rather than
+    // emit `{{.BaseClasses}}` against a Props field that never exists.
+    const inlined = this.resolveModuleStringConst(name)
+    if (inlined !== null) return inlined
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1]
     if (currentLoopParam && name === currentLoopParam) return '.'
     // An *outer* loop's value variable (we're in a nested loop) is in scope as
@@ -2927,6 +3164,72 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `${prefix}${this.capitalizeFieldName(name)}`
   }
 
+  /**
+   * Build the module pure-string-const map from the IR's localConstants.
+   * A const qualifies only when it is module-scope (`isModule`) and its
+   * initializer parses to a single string literal (`ts.StringLiteral` or
+   * `ts.NoSubstitutionTemplateLiteral` — a backtick string with no `${}`).
+   * Template literals *with* interpolations, numeric/object initializers,
+   * `Record<T,string>` maps, memos, and signals are all excluded: only a
+   * pure compile-time string can be safely inlined byte-for-byte.
+   */
+  private collectModuleStringConsts(constants: IRMetadata['localConstants']): Map<string, string> {
+    const map = new Map<string, string>()
+    for (const c of constants ?? []) {
+      if (!c.isModule) continue
+      if (c.value === undefined) continue
+      const literal = this.parsePureStringLiteral(c.value)
+      if (literal !== null) map.set(c.name, literal)
+    }
+    return map
+  }
+
+  /**
+   * Parse a const initializer's source text. Returns the unescaped string
+   * value when the whole initializer is a single string literal (or a
+   * no-substitution template literal), else `null`. Uses the TS parser so
+   * escapes/quotes are resolved exactly as JS would, matching the value
+   * the Hono reference inlines at runtime.
+   */
+  private parsePureStringLiteral(source: string): string | null {
+    const sf = ts.createSourceFile(
+      '__const.ts',
+      `const __x = (${source});`,
+      ts.ScriptTarget.Latest,
+      /*setParentNodes*/ false,
+    )
+    const stmt = sf.statements[0]
+    if (!stmt || !ts.isVariableStatement(stmt)) return null
+    const decl = stmt.declarationList.declarations[0]
+    let init = decl?.initializer
+    while (init && ts.isParenthesizedExpression(init)) init = init.expression
+    if (!init) return null
+    if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+      return init.text
+    }
+    return null
+  }
+
+  /**
+   * Resolve an identifier to its inlined Go string literal when it names a
+   * module pure-string const. Returns the Go template literal form
+   * (`"<escaped>"`) so callers can drop it straight into a `{{...}}` action,
+   * or `null` when the name is not such a const (the caller then falls back
+   * to its normal field-ref lowering). The value is escaped for a Go
+   * double-quoted string literal — Go's `html/template` then applies the
+   * same contextual auto-escaping it applies to any literal, matching Hono.
+   */
+  private resolveModuleStringConst(name: string): string | null {
+    if (this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name) {
+      return null
+    }
+    if (this.loopVarRefCount.has(name)) return null
+    if (this.isOuterLoopParam(name)) return null
+    const value = this.moduleStringConsts.get(name)
+    if (value === undefined) return null
+    return `"${this.escapeGoString(value)}"`
+  }
+
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
     if (literalType === 'string') return `"${value}"`
     if (literalType === 'null') return 'nil'
@@ -4313,6 +4616,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     switch (expr.kind) {
       case 'identifier':
         {
+          const inlined = this.resolveModuleStringConst(expr.name)
+          if (inlined !== null) return plain(inlined)
           const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1]
           if (currentLoopParam && expr.name === currentLoopParam) {
             return plain('.')
@@ -4336,6 +4641,46 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
           return plain(this.rootFieldRef(expr.callee.name))
         }
+        // `isValidElement(x)` — the framework "is this a renderable element?"
+        // predicate. In the Go SSR children model an element is represented by
+        // its already-rendered markup, so this evaluates faithfully as a
+        // truthiness check on the argument (an element is "valid" when there is
+        // something to render). Lowering it as a real, evaluatable expression —
+        // rather than a fabricated `.IsValidElement` field access — is what lets
+        // the `Slot` dynamic-tag guard register and run cleanly on Go.
+        if (
+          expr.callee.kind === 'identifier' &&
+          (identifierPath(expr.callee) ?? expr.callee.name) === 'isValidElement' &&
+          expr.args.length === 1
+        ) {
+          return this.renderConditionExpr(expr.args[0])
+        }
+        // Any other user-defined predicate call with arguments (e.g.
+        // `isAdmin(user)`) has no server-side evaluator and is not a registered
+        // template primitive. There is no honest way to evaluate it at SSR time,
+        // and silently forcing it (to true OR false) is a correctness hazard —
+        // a forced-true could expose auth-gated content, a forced-false could
+        // hide required content, and a warning is too easily ignored. Refuse
+        // with a hard BF102 error so the author must move the predicate to a
+        // supported primitive or defer it with `/* @client */`.
+        if (
+          expr.callee.kind === 'identifier' &&
+          !this.templatePrimitives[identifierPath(expr.callee) ?? '']
+        ) {
+          const path = identifierPath(expr.callee) ?? expr.callee.name
+          this.errors.push({
+            code: 'BF102',
+            severity: 'error',
+            message:
+              `Predicate '${path}(...)' cannot be evaluated in a Go template. ` +
+              `A server-side template cannot call user-defined JavaScript predicates.`,
+            loc: this.makeLoc(),
+            suggestion: { message: GO_REMEDIATION_OPTIONS },
+          })
+          // Go template actions must be self-contained; emit a literal so the
+          // partial still parses while the build fails on the BF102 error.
+          return plain('false')
+        }
         return plain(this.renderParsedExpr(expr))
       }
 
@@ -4634,6 +4979,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return this.renderPortalComponent(comp)
     }
 
+    // Dynamic-tag local (`const Tag = children.tag`): there is no template
+    // named `<Tag>` to call — emitting `{{template "Tag" .TagSlot0}}` would
+    // reference a template that can never be registered, and Go's
+    // html/template escape-walks ALL registered templates (even dead
+    // branches), so the whole render fails with `no such template "Tag"`.
+    // Lower it to its children passthrough instead, so the dead branch
+    // renders harmlessly and the Slot template registers cleanly. (Real
+    // server-side asChild prop-merge on Go is a separate, deferred concern.)
+    if (comp.dynamicTag) {
+      return this.renderChildren(comp.children)
+    }
+
     // In Go templates, components are rendered using {{template "name" data}}
     let templateCall: string
     if (this.inLoop) {
@@ -4734,6 +5091,20 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // Inline Go template syntax with embedded `{{...}}` actions.
         return `${name}="${this.renderParsedExpr(parsed)}"`
       }
+      // Hono-style nullish-attribute omission (#textarea rows): when the
+      // attribute value is a BARE reference to a nillable (`interface{}`)
+      // prop field, guard emission on `ne .X nil` so an unset optional
+      // prop drops the attribute entirely instead of rendering `attr=""`.
+      // Hono omits `undefined`/`null`-valued attributes; this restores
+      // parity. Scope is deliberately narrow — bare identifiers only — so
+      // member exprs, calls, ternaries, template literals, and
+      // concrete-typed props (which are never nil) are unaffected and
+      // still emit `attr=""` / `attr="0"` exactly as Hono does.
+      const bareId = value.expr.trim()
+      if (this.nillablePropNames.has(bareId)) {
+        const field = `.${this.capitalizeFieldName(bareId)}`
+        return `{{if ne ${field} nil}}${name}="{{${this.convertExpressionToGo(value.expr)}}}"{{end}}`
+      }
       return `${name}="{{${this.convertExpressionToGo(value.expr)}}}"`
     },
     emitBooleanAttr: (_value, name) => name,
@@ -4907,7 +5278,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (caseEntries.length === 0) continue
         const branches = caseEntries.map(([k, v], i) => {
           const head = i === 0 ? '{{if' : '{{else if'
-          return `${head} eq ${keyExpr} ${JSON.stringify(k)}}}${v}`
+          // The case value is a static Record<T,string> literal emitted
+          // straight into attribute-value text, so HTML-escape it the same
+          // way `string` parts are (via substituteJsInterpolations →
+          // escapeAttrText). Without this, UnoCSS tokens like
+          // `has-[>svg]:px-2.5` would leak a raw `>` and diverge from the
+          // Hono reference, which escapes it to `&gt;`.
+          return `${head} eq ${keyExpr} ${JSON.stringify(k)}}}${this.escapeAttrText(v)}`
         })
         output += branches.join('') + '{{end}}'
       }

package/src/test-render.ts

@@ -180,7 +180,7 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     const escapedTemplate = template.replace(/`/g, '` + "`" + `')
 
     // Build props initialization
-    const propsInit = buildGoPropsInit(componentName, props)
+    const propsInit = buildGoPropsInit(componentName, props, ir)
 
     // Honour `__instanceId` from props for the root scope id so
     // shared-component fixtures (which pin `<ComponentName>_test`) match
@@ -280,10 +280,26 @@ ${propsInit}
 function buildGoPropsInit(
   _componentName: string,
   props?: Record<string, unknown>,
+  ir?: ComponentIR,
 ): string {
   if (!props) return ''
 
+  // A `{...props}` rest spread on a component means props that are NOT
+  // declared as named params don't get their own top-level Input struct
+  // field — they flow through the open-ended rest bag (`Props map[string]any`,
+  // the `Capitalize(restPropsName)` field). Without routing them there, a
+  // fixture passing e.g. `placeholder` to the `Input` component (whose only
+  // declared params are `className` / `type`) emits a top-level
+  // `Placeholder:` initializer and Go fails with `unknown field Placeholder
+  // in struct literal of type InputInput`. (#1467 Phase 2b)
+  const declaredParams = new Set((ir?.metadata.propsParams ?? []).map(p => p.name))
+  const restPropsName = ir?.metadata.restPropsName ?? null
+  const restBagField = restPropsName
+    ? restPropsName.charAt(0).toUpperCase() + restPropsName.slice(1)
+    : null
+
   const lines: string[] = []
+  const restBagEntries: Array<[string, unknown]> = []
   for (const [key, value] of Object.entries(props)) {
     // Skip internal hydration markers — `__instanceId` / `__bfScope`
     // / `__bfChild` are routed by the framework (consumed via the
@@ -291,6 +307,15 @@ function buildGoPropsInit(
     // appear on the user-facing input struct). Including them produces
     // `unknown field __instanceId in struct literal of type XxxInput`.
     if (key.startsWith('__')) continue
+    // A prop that isn't a declared named param on a rest-spread component
+    // belongs in the rest bag, not a top-level field. A key that literally
+    // matches `restPropsName` already carries a pre-formed bag object and
+    // maps straight onto the `Capitalize(restPropsName)` field, so it falls
+    // through to the normal (object → map literal) emit below.
+    if (restBagField && key !== restPropsName && !declaredParams.has(key)) {
+      restBagEntries.push([key, value])
+      continue
+    }
     // Capitalize first letter for Go field name
     const goField = key.charAt(0).toUpperCase() + key.slice(1)
     if (typeof value === 'string') {
@@ -319,6 +344,13 @@ function buildGoPropsInit(
       lines.push(`\t\t${goField}: ${goMapLiteralFromObject(value as Record<string, unknown>)},`)
     }
   }
+  // Emit the collected rest-bag entries as the open-ended bag field. Skip
+  // when a direct `restPropsName`-keyed prop already populated it above
+  // (merging two sources isn't a shape any fixture needs).
+  if (restBagField && restBagEntries.length > 0 && !(restPropsName! in props)) {
+    const bag = Object.fromEntries(restBagEntries)
+    lines.push(`\t\t${restBagField}: ${goMapLiteralFromObject(bag)},`)
+  }
   return lines.join('\n')
 }