@barefootjs/go-template 0.5.0 → 0.5.2

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

@@ -21,6 +21,7 @@ import type {
   IRTemplatePart,
   IRProp,
   TypeInfo,
+  TypeDefinition,
   CompilerError,
   SourceLocation,
   ParsedExpr,
@@ -329,6 +330,21 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private localTypeNames: Set<string> = new Set()
   /** Local type aliases mapping type name to base type (e.g., Filter → 'string') */
   private localTypeAliases: Map<string, string> = new Map()
+  /**
+   * Per-struct field map (type name → source TS key → Go field name), populated
+   * during generateTypes. The object-literal baker consults this so a baked
+   * struct literal only names fields the generated struct actually declares.
+   */
+  private localStructFields: Map<string, Map<string, string>> = new Map()
+  /**
+   * Synthesised array types for untyped object-array signals (signal getter →
+   * `[]SynthStruct` TypeInfo), populated during generateTypes (#1680). An
+   * untyped `createSignal([{ id: "a" }])` has no element type to bake against;
+   * we infer a struct from the literal's shape so the field can be typed and
+   * the items baked. Consulted by both the signal field-type emitter and the
+   * initial-value baker.
+   */
+  private synthStructTypes: Map<string, TypeInfo> = new Map()
 
   /** Set during type generation when any emit references
    *  `template.HTML(...)`; toggles the `"html/template"` import. */
@@ -654,6 +670,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Build set of locally-defined type names and aliases so typeInfoToGo can resolve them
     this.localTypeNames = new Set<string>()
     this.localTypeAliases = new Map<string, string>()
+    this.localStructFields = new Map<string, Map<string, string>>()
     for (const td of ir.metadata.typeDefinitions) {
       // Skip the Props type itself (it's the component's own props, not a reusable type)
       if (td.name === 'Props' || td.name === `${componentName}Props`) continue
@@ -663,6 +680,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // Track string literal union aliases (e.g., type Filter = 'all' | 'active')
       if (td.definition.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
         this.localTypeAliases.set(td.name, 'string')
+      } else {
+        // Record the struct's source-key → Go-field-name map for the baker,
+        // from the same field derivation the struct emitter uses.
+        const fields = this.structFieldsFor(td)
+        if (fields.length > 0) {
+          this.localStructFields.set(td.name, new Map(fields.map(f => [f.tsName, f.goName])))
+        }
       }
     }
 
@@ -677,6 +701,29 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
+    // Synthesise a struct for each untyped object-array signal (#1680) and emit
+    // it, so the signal field can be typed `[]Synth` and its inline items baked
+    // (the loop body reaches each item via struct field access). Registered in
+    // localTypeNames/localStructFields so the baker resolves the element type.
+    this.synthStructTypes = new Map<string, TypeInfo>()
+    for (const signal of ir.metadata.signals) {
+      const synth = this.synthesizeStructFromSignal(signal, componentName)
+      if (!synth) continue
+      this.localTypeNames.add(synth.name)
+      this.localStructFields.set(synth.name, new Map(synth.fields.map(f => [f.tsName, f.goName])))
+      this.synthStructTypes.set(signal.getter, {
+        kind: 'array',
+        raw: `${synth.name}[]`,
+        elementType: { kind: 'interface', raw: synth.name },
+      })
+      const goFields = synth.fields.map(
+        f => `\t${f.goName} ${f.goType} \`json:"${this.toJsonTag(f.tsName)}"\``,
+      )
+      lines.push(`// ${synth.name} is a synthesised element type for the ${signal.getter} signal.`)
+      lines.push(`type ${synth.name} struct {\n${goFields.join('\n')}\n}`)
+      lines.push('')
+    }
+
     // Find nested components (loops with childComponent)
     const nestedComponents = this.findNestedComponents(ir.root)
 
@@ -722,38 +769,166 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * Convert a TypeScript type definition to a Go type.
    * Handles object types → Go structs, and union string literals → string alias.
    */
-  private typeDefinitionToGo(td: { kind: string; name: string; definition: string }): string | null {
-    const def = td.definition
-
-    // String literal union: type Filter = 'all' | 'active' | 'completed'
-    if (def.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
+  private typeDefinitionToGo(td: TypeDefinition): string | null {
+    // String literal union: type Filter = 'all' | 'active' | 'completed'.
+    // These carry no `properties`, so the analyzer leaves the field set empty;
+    // detect the alias from the definition and map it to a Go string.
+    if (td.definition.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
       // Map to Go string (union of string literals → just string in Go)
       return `// ${td.name} is a string type.\ntype ${td.name} = string`
     }
 
     // Object/interface type: type Todo = { id: number; text: string; ... }
-    const bodyMatch = def.match(/(?:type \w+ = |interface \w+ )\{([\s\S]*)\}/)
-    if (!bodyMatch) return null
+    const fields = this.structFieldsFor(td)
+    if (fields.length === 0) return null
+
+    const goFields = fields.map(
+      f => `\t${f.goName} ${f.goType} \`json:"${this.toJsonTag(f.tsName)}"\``,
+    )
+    return `// ${td.name} represents a ${td.name.toLowerCase()}.\ntype ${td.name} struct {\n${goFields.join('\n')}\n}`
+  }
+
+  /**
+   * Derive a struct's Go fields from the analyzer-provided structured
+   * properties — no string parsing of the definition. This is the single
+   * source of truth for which fields a generated struct has and each field's Go
+   * name/type; both the struct emitter ({@link typeDefinitionToGo}) and the
+   * object-literal baker ({@link tsLiteralToGo}) consume it, so a baked literal
+   * can never name a field the struct doesn't declare.
+   *
+   * A property whose source key isn't a valid Go identifier (`"data-id"`, a
+   * numeric key, …) can't become a struct field, so it's dropped here — and is
+   * therefore absent from the baker's field map too, which bails to nil for any
+   * literal that uses such a key.
+   */
+  private structFieldsFor(td: TypeDefinition): Array<{ tsName: string; goName: string; goType: string }> {
+    const fields: Array<{ tsName: string; goName: string; goType: string }> = []
+    for (const prop of td.properties ?? []) {
+      if (!GoTemplateAdapter.GO_IDENTIFIER.test(prop.name)) continue
+      fields.push({
+        tsName: prop.name,
+        goName: this.capitalizeFieldName(prop.name),
+        goType: this.typeInfoToGo(prop.type),
+      })
+    }
+    return fields
+  }
+
+  /**
+   * Synthesise a Go struct from an untyped object-array signal's inline initial
+   * value (#1680). Returns the struct name + fields, or `null` when synthesis
+   * isn't possible so the caller keeps the field `[]interface{}`/`nil`.
+   *
+   * Synthesis applies only when:
+   *   - the signal's type is an array with no usable element type (untyped),
+   *   - the initial value is a non-empty array literal of object literals,
+   *   - every element shares the same set of Go-identifier keys, and
+   *   - every value is a scalar literal whose Go type is consistent per key
+   *     (numeric keys widen int→float64 when mixed).
+   *
+   * Any deviation (heterogeneous shape, a nested object/array value, a
+   * non-literal value, a non-identifier key, or a name collision with an
+   * existing type) returns `null`.
+   */
+  private synthesizeStructFromSignal(
+    signal: { getter: string; type: TypeInfo; initialValue: string },
+    componentName: string,
+  ): { name: string; fields: Array<{ tsName: string; goName: string; goType: string }> } | null {
+    // Only untyped arrays: a typed (`Item[]`) or scalar (`string[]`) element
+    // already bakes through the normal path.
+    if (signal.type.kind !== 'array') return null
+    const elem = signal.type.elementType
+    if (elem && elem.kind !== 'unknown') return null
+
+    const node = this.parseLiteralExpression(signal.initialValue)
+    if (!node || !ts.isArrayLiteralExpression(node) || node.elements.length === 0) return null
+
+    // Collect the field order + per-key Go types from the first element, then
+    // require every other element to match exactly.
+    const order: string[] = []
+    const goTypes = new Map<string, string>()
+    for (let i = 0; i < node.elements.length; i++) {
+      const el = node.elements[i]
+      if (!ts.isObjectLiteralExpression(el)) return null
+      const seen = new Set<string>()
+      for (const prop of el.properties) {
+        if (!ts.isPropertyAssignment(prop)) return null
+        if (
+          !ts.isIdentifier(prop.name) &&
+          !ts.isStringLiteral(prop.name) &&
+          !ts.isNumericLiteral(prop.name)
+        ) {
+          return null
+        }
+        const key = prop.name.text
+        if (!GoTemplateAdapter.GO_IDENTIFIER.test(key)) return null
+        const goType = this.scalarLiteralGoType(prop.initializer)
+        if (!goType) return null
+        seen.add(key)
+        const prev = goTypes.get(key)
+        if (prev === undefined) {
+          if (i !== 0) return null // key absent from the first element → shape differs
+          order.push(key)
+          goTypes.set(key, goType)
+        } else {
+          const merged = this.mergeScalarGoType(prev, goType)
+          if (!merged) return null
+          goTypes.set(key, merged)
+        }
+      }
+      // Every key from the first element must be present in this element too.
+      if (seen.size !== order.length) return null
+    }
 
-    const body = bodyMatch[1]
-    const goFields: string[] = []
+    const name = `${componentName}${this.capitalizeFieldName(signal.getter)}Item`
+    // Don't shadow a user-defined or already-synthesised type.
+    if (this.localTypeNames.has(name)) return null
 
-    // Parse each field: "fieldName: type" or "fieldName?: type"
-    // Handle both semicolon-separated and newline-separated
-    const fieldEntries = body.split(/[;\n]/).map(s => s.trim()).filter(Boolean)
-    for (const entry of fieldEntries) {
-      const fieldMatch = entry.match(/^(\w+)\??\s*:\s*(.+)$/)
-      if (!fieldMatch) continue
-      const [, fieldName, tsType] = fieldMatch
-      const goFieldName = this.capitalizeFieldName(fieldName)
-      const goType = this.tsTypeStringToGo(tsType.trim())
-      const jsonTag = this.toJsonTag(fieldName)
-      goFields.push(`\t${goFieldName} ${goType} \`json:"${jsonTag}"\``)
+    return {
+      name,
+      fields: order.map(key => ({
+        tsName: key,
+        goName: this.capitalizeFieldName(key),
+        goType: goTypes.get(key)!,
+      })),
     }
+  }
 
-    if (goFields.length === 0) return null
+  /**
+   * The Go type for a scalar JS literal used as a synthesised struct field
+   * value, or `null` for anything non-scalar (objects, arrays, identifiers,
+   * calls, interpolated templates) so the caller bails out of synthesis.
+   */
+  private scalarLiteralGoType(node: ts.Expression): string | null {
+    if (
+      ts.isPrefixUnaryExpression(node) &&
+      node.operator === ts.SyntaxKind.MinusToken &&
+      ts.isNumericLiteral(node.operand)
+    ) {
+      return this.numericLiteralGoType(node.operand.text)
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return 'string'
+    if (ts.isNumericLiteral(node)) return this.numericLiteralGoType(node.text)
+    if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
+      return 'bool'
+    }
+    return null
+  }
 
-    return `// ${td.name} represents a ${td.name.toLowerCase()}.\ntype ${td.name} struct {\n${goFields.join('\n')}\n}`
+  /** `int` for an integer literal, `float64` when the literal has a fraction
+   *  or exponent. */
+  private numericLiteralGoType(text: string): string {
+    return /[.eE]/.test(text) && !text.startsWith('0x') ? 'float64' : 'int'
+  }
+
+  /** Reconcile two inferred Go types for the same key across elements: equal
+   *  types stay; mixed numeric (int/float64) widens to float64; otherwise null
+   *  (incompatible → bail). */
+  private mergeScalarGoType(a: string, b: string): string | null {
+    if (a === b) return a
+    const numeric = new Set(['int', 'float64'])
+    if (numeric.has(a) && numeric.has(b)) return 'float64'
+    return null
   }
 
   /**
@@ -923,6 +1098,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // Skip if a prop field with the same name was already emitted
       if (propFieldNames.has(fieldName)) continue
       const jsonTag = this.toJsonTag(signal.getter)
+      // A synthesised struct type (#1680) wins outright — the signal is an
+      // untyped object array we gave a concrete element type.
+      const synthType = this.synthStructTypes.get(signal.getter)
+      if (synthType) {
+        lines.push(`\t${fieldName} ${this.typeInfoToGo(synthType)} \`json:"${jsonTag}"\``)
+        continue
+      }
       // Infer type from initial value or referenced prop's type
       let goType: string
       let referencedProp = propsParamMap.get(signal.initialValue)
@@ -1134,7 +1316,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (hoisted) {
         lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
       } else {
-        const initialValue = this.convertInitialValue(signal.initialValue, signal.type, ir.metadata.propsParams)
+        // Bake against the synthesised struct type when one was inferred for
+        // this untyped object-array signal (#1680), else the signal's own type.
+        const bakeType = this.synthStructTypes.get(signal.getter) ?? signal.type
+        const initialValue = this.convertInitialValue(signal.initialValue, bakeType, ir.metadata.propsParams)
         lines.push(`\t\t${fieldName}: ${initialValue},`)
       }
     }
@@ -1735,14 +1920,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
-    // For arrays, use nil for complex JS expressions
+    // For arrays, bake a fully-literal initial value into a Go slice literal
+    // so the SSR data context carries the items (#1672). Empty / nullish
+    // literals collapse to nil, and any non-literal element (a call, a
+    // variable reference, …) falls back to nil so the handler populates it.
+    //
+    // The baked literal is element-type-aware so it both compiles and renders:
+    //   - scalar elements →  `[]string{…}` / `[]interface{}{…}`  (template `{{.}}`)
+    //   - struct elements →  `[]Item{Item{ID: …}}`               (template `.ID`)
+    // An untyped object array would land in a `[]interface{}` field whose
+    // `map[string]interface{}` items the template can't reach via field access
+    // (`.ID` → <nil>), so `jsLiteralToGo` returns null there and we keep nil.
     if (typeInfo.kind === 'array') {
-      // Simple array literal or empty
-      if (value === '[]' || value === 'null' || value === 'undefined') {
-        return 'nil'
-      }
-      // Complex expression - use nil as placeholder
-      return 'nil'
+      // Bake a fully-literal initial value into a Go slice literal; anything
+      // the parser can't reduce to a literal — a call, an identifier, `null` /
+      // `undefined`, or an empty array — yields null and we keep `nil`.
+      return this.jsLiteralToGo(value, typeInfo) ?? 'nil'
     }
 
     // String alias (e.g., Filter = string) — return string value instead of nil
@@ -1760,6 +1953,137 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return 'nil'
   }
 
+  /**
+   * Convert a fully-literal JS expression string into an equivalent Go literal
+   * whose Go type matches `typeInfo` (#1672), used to bake a signal's inline
+   * initial value into the SSR data context:
+   *
+   *   `["x", "y"]`             (string[])  → `[]string{"x", "y"}`
+   *   `["x", "y"]`             (unknown[]) → `[]interface{}{"x", "y"}`
+   *   `[{ id: "a" }]`          (Item[])    → `[]Item{Item{ID: "a"}}`
+   *
+   * Returns `null` — so the caller keeps `nil` — when the expression (or any
+   * nested element) is not a pure literal (a call, identifier, template with
+   * interpolation, …) or cannot be expressed in the target Go type without a
+   * render/compile mismatch (e.g. an object element in a `[]interface{}` field,
+   * which the SSR template reaches via struct field access the map lacks).
+   */
+  private jsLiteralToGo(value: string, typeInfo: TypeInfo): string | null {
+    const expr = this.parseLiteralExpression(value)
+    if (!expr) return null
+    return this.tsLiteralToGo(expr, typeInfo)
+  }
+
+  /**
+   * Parse a JS expression string into its TS AST node (parentheses unwrapped),
+   * or `null` when it isn't a single expression. Shared by the literal baker
+   * and the struct-shape synthesiser.
+   */
+  private parseLiteralExpression(value: string): ts.Expression | null {
+    const sf = ts.createSourceFile(
+      '__lit.ts', `(${value})`, ts.ScriptTarget.Latest, /* setParentNodes */ true,
+    )
+    // Require exactly one expression statement. A value that error-recovers
+    // into multiple statements (e.g. `1; 2`) isn't a single literal — bail
+    // rather than silently baking only the first.
+    if (sf.statements.length !== 1) return null
+    const stmt = sf.statements[0]
+    if (!ts.isExpressionStatement(stmt)) return null
+    let expr: ts.Expression = stmt.expression
+    while (ts.isParenthesizedExpression(expr)) expr = expr.expression
+    return expr
+  }
+
+  /**
+   * Recursively convert a TS literal AST node to a Go literal typed as
+   * `typeInfo`, or null when the node is not a pure literal / cannot be
+   * represented in that Go type.
+   */
+  private tsLiteralToGo(node: ts.Expression, typeInfo?: TypeInfo): string | null {
+    // Unwrap a leading unary minus on a numeric literal (`-1`).
+    if (
+      ts.isPrefixUnaryExpression(node) &&
+      node.operator === ts.SyntaxKind.MinusToken &&
+      ts.isNumericLiteral(node.operand)
+    ) {
+      return `-${node.operand.text}`
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      return JSON.stringify(node.text)
+    }
+    // Pass the numeric literal's source spelling through verbatim. Every form
+    // the TS parser accepts here (`1`, `1.5`, `1e3`, `0x10`, `1_000`) is also a
+    // valid Go numeric literal, so no re-formatting is needed.
+    if (ts.isNumericLiteral(node)) return node.text
+    if (node.kind === ts.SyntaxKind.TrueKeyword) return 'true'
+    if (node.kind === ts.SyntaxKind.FalseKeyword) return 'false'
+    if (node.kind === ts.SyntaxKind.NullKeyword) return 'nil'
+
+    if (ts.isArrayLiteralExpression(node)) {
+      // An empty array literal (`[]`, and — since the TS parser tolerates
+      // whitespace/comments — `[ ]`, `[/* */]`) carries no items, so there's
+      // nothing to bake. Returning null keeps the field `nil`, which JSON-
+      // marshals as `null` rather than the `[]` an empty slice would produce.
+      if (node.elements.length === 0) return null
+
+      // Slice header mirrors the field's Go type (`[]string`, `[]Item`,
+      // `[]interface{}`); elements are converted against the element type.
+      const elemType = typeInfo?.kind === 'array' ? typeInfo.elementType : undefined
+      const sliceHeader = typeInfo?.kind === 'array'
+        ? this.typeInfoToGo(typeInfo)
+        : '[]interface{}'
+      const elems: string[] = []
+      for (const el of node.elements) {
+        const go = this.tsLiteralToGo(el, elemType)
+        if (go === null) return null
+        elems.push(go)
+      }
+      return `${sliceHeader}{${elems.join(', ')}}`
+    }
+
+    if (ts.isObjectLiteralExpression(node)) {
+      // An object can only be baked when the target Go type is a concrete
+      // struct — otherwise it would land in `interface{}` / a map the SSR
+      // template can't reach via field access. The struct's field map is the
+      // source of truth: it tells us the exact Go field name for each source
+      // key and, by omission, which keys the struct doesn't declare. Bail
+      // (→ nil) when the type isn't a known struct.
+      const goType = typeInfo ? this.typeInfoToGo(typeInfo) : 'interface{}'
+      const structFields = this.localStructFields.get(goType)
+      if (!structFields) return null
+      const entries: string[] = []
+      for (const prop of node.properties) {
+        // Only plain `key: scalar` pairs are baked; spreads, methods,
+        // shorthand, computed/accessor members, and nested object/array
+        // values (whose struct field types we don't track here) bail to nil.
+        if (!ts.isPropertyAssignment(prop)) return null
+        if (
+          !ts.isIdentifier(prop.name) &&
+          !ts.isStringLiteral(prop.name) &&
+          !ts.isNumericLiteral(prop.name)
+        ) {
+          return null
+        }
+        // Resolve the Go field name from the struct's own field map rather
+        // than re-deriving it. A key the struct doesn't declare (a typo, or a
+        // non-identifier key like `"data-id"` that never became a field) is
+        // absent here, so we bail to nil instead of emitting a literal that
+        // names a nonexistent field and won't compile.
+        const goField = structFields.get(prop.name.text)
+        if (!goField) return null
+        const init = prop.initializer
+        if (ts.isObjectLiteralExpression(init) || ts.isArrayLiteralExpression(init)) {
+          return null
+        }
+        const go = this.tsLiteralToGo(init)
+        if (go === null) return null
+        entries.push(`${goField}: ${go}`)
+      }
+      return `${goType}{${entries.join(', ')}}`
+    }
+    return null
+  }
+
   /**
    * Convert TypeInfo to Go type string.
    * If type is unknown, tries to infer from defaultValue.
@@ -2246,6 +2570,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return null
   }
 
+  /**
+   * A source key that can become a Go struct field — i.e. a valid Go
+   * identifier. TS object keys that aren't (e.g. `"data-id"`, numeric keys)
+   * can't be exported struct fields, so they're excluded from struct generation
+   * and from the baker's field map.
+   */
+  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([
     'id', 'url', 'http', 'https', 'api', 'json', 'xml', 'html', 'css', 'sql',
@@ -2491,8 +2823,38 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   identifier(name: string): string {
     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
+    // the Go range variable `$name` declared by that loop's `{{range … := …}}`;
+    // the inner dot no longer refers to it, and it's not a root field. (#1677)
+    if (this.isOuterLoopParam(name)) return `$${name}`
     if (this.loopVarRefCount.has(name)) return `$${name}`
-    return `.${this.capitalizeFieldName(name)}`
+    return this.rootFieldRef(name)
+  }
+
+  /**
+   * True when `name` is a loop value variable from an enclosing (not the
+   * current) loop — i.e. it sits on `loopParamStack` below the top. Such a
+   * reference resolves to the Go range variable `$name`, not the inner dot or
+   * the root data.
+   */
+  private isOuterLoopParam(name: string): boolean {
+    const top = this.loopParamStack.length - 1
+    for (let i = 0; i < top; i++) {
+      if (this.loopParamStack[i] === name) return true
+    }
+    return false
+  }
+
+  /**
+   * A reference to a root-scope field — a signal, a prop, or a derived value
+   * that lives on the component's top-level data struct. Inside a `{{range}}`
+   * the dot is rebound to the iteration element, so root data must be reached
+   * through Go template's `$` (the top-level argument to Execute), which never
+   * rebinds. Outside any loop the root *is* the dot, so we emit `.Field` (#1677).
+   */
+  private rootFieldRef(name: string): string {
+    const prefix = this.loopParamStack.length > 0 ? '$.' : '.'
+    return `${prefix}${this.capitalizeFieldName(name)}`
   }
 
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
@@ -2502,9 +2864,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string {
-    // Signal call: count() -> .Count
+    // Signal call: count() -> .Count (or $.Count inside a loop, #1677)
     if (callee.kind === 'identifier' && args.length === 0) {
-      return `.${this.capitalizeFieldName(callee.name)}`
+      return this.rootFieldRef(callee.name)
     }
     // Array methods (`.join` and any others added to ArrayMethod, #1443)
     // are lifted into the `array-method` IR kind at parse time, so
@@ -2568,9 +2930,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (templateBlock) return templateBlock
     }
 
-    // SolidJS-style props pattern: props.xxx -> .Xxx
+    // SolidJS-style props pattern: props.xxx -> .Xxx (or $.Xxx inside a loop,
+    // since props live on the root data struct, not the iteration element #1677)
     if (object.kind === 'identifier' && this.propsObjectName && object.name === this.propsObjectName) {
-      return `.${this.capitalizeFieldName(property)}`
+      return this.rootFieldRef(property)
     }
 
     // Inside a loop, the loop param variable refers to the current item
@@ -3763,11 +4126,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           if (currentLoopParam && expr.name === currentLoopParam) {
             return plain('.')
           }
+          // Outer loop value variable (nested loop) → its range var `$name`.
+          if (this.isOuterLoopParam(expr.name)) {
+            return plain(`$${expr.name}`)
+          }
           if (this.loopVarRefCount.has(expr.name)) {
             return plain(`$${expr.name}`)
           }
         }
-        return plain(`.${this.capitalizeFieldName(expr.name)}`)
+        return plain(this.rootFieldRef(expr.name))
 
       case 'literal':
         if (expr.literalType === 'string') return plain(`"${expr.value}"`)
@@ -3776,7 +4143,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
       case 'call': {
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
-          return plain(`.${this.capitalizeFieldName(expr.callee.name)}`)
+          return plain(this.rootFieldRef(expr.callee.name))
         }
         return plain(this.renderParsedExpr(expr))
       }
@@ -3792,7 +4159,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         }
 
         if (expr.object.kind === 'identifier' && this.propsObjectName && expr.object.name === this.propsObjectName) {
-          return plain(`.${this.capitalizeFieldName(expr.property)}`)
+          return plain(this.rootFieldRef(expr.property))
         }
 
         {
@@ -3983,6 +4350,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
     const children = this.renderChildren(loop.children)
+    // Build the per-item anchor marker while the loop param is still on the
+    // stack, so a `bodyIsItemConditional` key expression (#1665) resolves
+    // against the range item (`.` context) like `data-key` does — popping
+    // first would rewrite `t.id` to `.T.ID` instead of `.ID`.
+    const itemMarker = this.loopItemMarker(loop)
     for (const v of addedLoopVars) {
       const rc = (this.loopVarRefCount.get(v) ?? 1) - 1
       if (rc <= 0) this.loopVarRefCount.delete(v)
@@ -4020,15 +4392,29 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         filterCond = 'true'
       }
 
-      // Per-item start marker for multi-root Fragment items (#1212).
-      const itemMarker = loop.bodyIsMultiRoot ? `{{bfComment "bf-loop-i"}}` : ''
       return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}{{if ${filterCond}}}${itemMarker}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`
     }
 
-    const itemMarker = loop.bodyIsMultiRoot ? `{{bfComment "bf-loop-i"}}` : ''
     return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`
   }
 
+  /**
+   * Per-item `<!--bf-loop-i-->` / `<!--bf-loop-i:KEY-->` start marker emitted
+   * inside a `{{range}}` body. Multi-root Fragment items (#1212) get the bare
+   * anchor; whole-item conditional items (#1665) get the key-bearing anchor so
+   * the client's `mapArrayAnchored` can hydrate items that render no element.
+   */
+  private loopItemMarker(loop: { bodyIsMultiRoot?: boolean; bodyIsItemConditional?: boolean; key?: string | null }): string {
+    if (loop.bodyIsMultiRoot) return `{{bfComment "bf-loop-i"}}`
+    if (loop.bodyIsItemConditional && loop.key) {
+      // `bfComment` prepends `bf-`, so `printf "loop-i:%v"` yields
+      // `<!--bf-loop-i:KEY-->`. The key expression resolves against the
+      // current range item (`.` context), matching `data-key`'s emission.
+      return `{{bfComment (printf "loop-i:%v" ${this.convertExpressionToGo(loop.key)})}}`
+    }
+    return ''
+  }
+
   /**
    * Find the first component child in a list of nodes
    */