@barefootjs/go-template 0.6.0 → 0.7.0

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

@@ -27,10 +27,14 @@ import type {
   ParsedExpr,
   ParsedStatement,
   SortComparator,
+  ReduceOp,
+  FlatDepth,
+  FlatMapOp,
   TemplatePart,
   IRIfStatement,
   IRProvider,
   IRAsync,
+  IRMetadata,
   TemplatePrimitiveRegistry,
 } from '@barefootjs/jsx'
 import {
@@ -45,6 +49,7 @@ import {
   type IRNodeEmitter,
   type EmitIRNode,
   type AttrValueEmitter,
+  type SupportResult,
   isBooleanAttr,
   parseExpression,
   isSupported,
@@ -208,8 +213,56 @@ function emitBfSort(recv: string, c: SortComparator): string {
   return `bf_sort ${wrapIfMultiToken(recv)} ${groups.join(' ')}`
 }
 
+/**
+ * Emit the `bf_reduce` call for a `.reduce(fn, init)` arithmetic fold
+ * (#1448 Tier C):
+ *
+ *   bf_reduce <recv> "<op>" "<keyKind>" "<keyName>" "<type>" "<init>" "<direction>"
+ *
+ *   op:        "+" | "*"
+ *   keyKind:   "self" | "field"
+ *   keyName:   "" when keyKind=self; capitalised field name otherwise
+ *              (matches the Go struct-field convention, mirroring
+ *              `emitBfSort`)
+ *   type:      "numeric" | "string"
+ *   init:      the fold's start value — the numeric literal's text for a
+ *              numeric fold, or the string literal's contents for a
+ *              concat fold
+ *   direction: "left" (reduce) | "right" (reduceRight)
+ *
+ * The runtime folds `init <op> key(item)` in `direction` order and
+ * returns the accumulated value (float64 for numeric, string for
+ * concat). The order is only observable for string concat — numeric
+ * sum / product commute.
+ */
+function emitBfReduce(recv: string, op: ReduceOp, direction: 'left' | 'right'): string {
+  const keyName = op.key.kind === 'field' ? capitalize(op.key.field) : ''
+  // `op.init` is already the decoded seed value (canonical decimal for
+  // numeric folds — `strconv.ParseFloat`-safe; escape-free contents for
+  // concat folds). Pass it as a quoted operand the runtime interprets
+  // by `type`. `direction` is "left" (reduce) or "right" (reduceRight)
+  // — only observable for string concatenation; numeric folds are
+  // commutative.
+  return `bf_reduce ${wrapIfMultiToken(recv)} "${op.op}" "${op.key.kind}" "${keyName}" "${op.type}" "${escapeGoString(op.init)}" "${direction}"`
+}
+
+/** Escape a value for embedding in a Go-template double-quoted string. */
+function escapeGoString(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+}
+
 function capitalize(s: string): string {
-  return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1)
+  if (s.length === 0) return s
+  // Match the adapter's struct-field naming (`capitalizeFieldName`):
+  // a whole-word Go initialism uppercases entirely (`id` → `ID`,
+  // `url` → `URL`) so the `bf_sort` / `bf_reduce` reflect lookup
+  // resolves the generated exported field instead of silently folding
+  // a zero value. The class is fully initialised by the time any emit
+  // helper runs, so referencing the static set here is safe.
+  if (GoTemplateAdapter.GO_INITIALISMS.has(s.toLowerCase())) {
+    return s.toUpperCase()
+  }
+  return s[0].toUpperCase() + s.slice(1)
 }
 
 /**
@@ -239,6 +292,22 @@ interface PrimitiveSpec {
   emit: (args: string[]) => string
 }
 
+// Generic remediation appended to BF101 / BF102 diagnostics whose reason
+// doesn't already carry actionable next steps.
+const GO_REMEDIATION_OPTIONS =
+  'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code'
+
+// Build the `suggestion.message` for an unsupported expression/condition.
+// A self-contained reason (it already spells out the fix — e.g. the
+// pre-compute / @client hint or the tailored forEach message) is shown
+// as-is; a low-level reason gets the generic options appended; with no
+// reason at all we fall back to the options alone.
+function buildUnsupportedSuggestion(support: SupportResult): string {
+  if (!support.reason) return GO_REMEDIATION_OPTIONS
+  if (support.selfContained) return support.reason
+  return `${support.reason}\n\n${GO_REMEDIATION_OPTIONS}`
+}
+
 const GO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'JSON.stringify': { arity: 1, emit: (args) => `bf_json ${args[0]}` },
   'String':         { arity: 1, emit: (args) => `bf_string ${args[0]}` },
@@ -350,6 +419,21 @@ 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()
+
   constructor(options: GoTemplateAdapterOptions = {}) {
     super()
     this.options = {
@@ -370,6 +454,7 @@ 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)
 
     // Surface loop-body usages of components imported from sibling
     // .tsx files. The adapter emits `{{template "X" .}}` for these,
@@ -1556,6 +1641,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) {
@@ -2579,7 +2674,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private static GO_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/
 
   /** Go common initialisms that should be fully uppercased (https://go.dev/wiki/CodeReviewComments#initialisms) */
-  private static GO_INITIALISMS = new Set([
+  // Not `private`: the module-level `capitalize` helper reads this so
+  // `bf_sort` / `bf_reduce` field projection matches `capitalizeFieldName`.
+  static GO_INITIALISMS = new Set([
     'id', 'url', 'http', 'https', 'api', 'json', 'xml', 'html', 'css', 'sql',
     'ip', 'tcp', 'udp', 'dns', 'ssh', 'tls', 'ssl', 'uri', 'uid', 'uuid',
     'ascii', 'utf8', 'eof', 'grpc', 'rpc', 'cpu', 'gpu', 'ram', 'os',
@@ -2821,6 +2918,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
@@ -2857,6 +2959,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'
@@ -3089,7 +3257,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       message: `Higher-order method '.${method}' shape cannot be lowered to a Go template action`,
       loc: this.makeLoc(),
       suggestion: {
-        message: 'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code',
+        message: GO_REMEDIATION_OPTIONS,
       },
     })
     return `""`
@@ -3311,6 +3479,51 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return emitBfSort(emit(object), comparator)
   }
 
+  reduceMethod(
+    method: 'reduce' | 'reduceRight',
+    object: ParsedExpr,
+    reduceOp: ReduceOp,
+    emit: (e: ParsedExpr) => string,
+  ): string {
+    // `.reduce(fn, init)` / `.reduceRight(fn, init)` arithmetic-fold
+    // lowering (#1448 Tier C). The structured `ReduceOp` (op / key /
+    // type / init) plus the fold direction feed the `bf_reduce` runtime
+    // helper, which folds the receiver into a scalar.
+    const direction = method === 'reduceRight' ? 'right' : 'left'
+    return emitBfReduce(emit(object), reduceOp, direction)
+  }
+
+  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
+    // `.flat(depth?)` → `bf_flat <recv> <depth>`. The `Infinity` form
+    // lowers to the `-1` sentinel (flatten fully); a finite depth flattens
+    // that many levels (`0` = shallow copy). See packages/adapter-go-
+    // template/runtime/bf.go.
+    const d = depth === 'infinity' ? -1 : depth
+    return `bf_flat ${wrapIfMultiToken(emit(object))} ${d}`
+  }
+
+  flatMapMethod(object: ParsedExpr, op: FlatMapOp, emit: (e: ParsedExpr) => string): string {
+    const recv = wrapIfMultiToken(emit(object))
+    const proj = op.projection
+    // Tuple projection `i => [i.a, i.b]` → `bf_flat_map_tuple <recv>
+    // "<kind>" "<name>" ...` (one quoted pair per leaf). flat(1) removes
+    // only the literal's wrapper, so the runtime appends each leaf verbatim.
+    if (proj.kind === 'tuple') {
+      const pairs = proj.elements
+        .map(l => (l.kind === 'self' ? `"self" ""` : `"field" "${capitalize(l.field)}"`))
+        .join(' ')
+      return `bf_flat_map_tuple ${recv} ${pairs}`
+    }
+    // Scalar `.flatMap(i => i)` / `.flatMap(i => i.field)` → `bf_flat_map
+    // <recv> "<kind>" "<name>"`. The runtime projects each item then
+    // flattens one level. The field name uses the Go struct-field
+    // capitalisation, matching `bf_reduce` / `bf_sort`.
+    if (proj.kind === 'self') {
+      return `bf_flat_map ${recv} "self" ""`
+    }
+    return `bf_flat_map ${recv} "field" "${capitalize(proj.field)}"`
+  }
+
   unsupported(raw: string, _reason: string): string {
     // Should not happen if `isSupported` was checked at parse time.
     return `[UNSUPPORTED: ${raw}]`
@@ -4046,9 +4259,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         message: `Expression not supported: ${trimmed}`,
         loc: this.makeLoc(),
         suggestion: {
-          message: support.reason
-            ? `${support.reason}\n\nOptions:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code`
-            : 'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code',
+          message: buildUnsupportedSuggestion(support),
         },
       })
       // Return empty string - Go template comments must be separate actions
@@ -4086,7 +4297,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             message: `Complex predicate in else-if is not supported: ${altIfStmt.condition}`,
             loc: this.makeLoc(),
             suggestion: {
-              message: 'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code',
+              message: GO_REMEDIATION_OPTIONS,
             },
           })
         }
@@ -4183,9 +4394,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         message: `Condition not supported: ${trimmed}`,
         loc: this.makeLoc(),
         suggestion: {
-          message: support.reason
-            ? `${support.reason}\n\nOptions:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code`
-            : 'Expression contains unsupported syntax',
+          message: buildUnsupportedSuggestion(support),
         },
       })
       // Return false - Go template comments must be separate actions
@@ -4202,6 +4411,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('.')
@@ -4225,6 +4436,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))
       }
 
@@ -4523,6 +4774,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) {
@@ -4796,7 +5059,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')
 }
 
@@ -355,7 +387,14 @@ function goMapLiteralFromObject(
     else if (typeof v === 'number') entries.push(`${key}: ${v}`)
     else if (typeof v === 'boolean') entries.push(`${key}: ${v}`)
     else if (v === null) entries.push(`${key}: nil`)
-    else if (v && typeof v === 'object' && !Array.isArray(v)) {
+    else if (Array.isArray(v)) {
+      // Array-valued field inside an object-in-array (e.g. the `tags`
+      // of `items.flatMap(i => i.tags)`). Without this branch the field
+      // was silently dropped, leaving an empty map so the template
+      // rendered nothing for the projection (#1448 Tier C flatMap).
+      entries.push(`${key}: ${goArrayLiteralFromArray(v)}`)
+    }
+    else if (v && typeof v === 'object') {
       entries.push(`${key}: ${goMapLiteralFromObject(v as Record<string, unknown>, capitalizeKeys)}`)
     }
   }