@barefootjs/go-template 0.18.3 → 0.18.5

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

@@ -66,9 +66,10 @@ import {
   prepareLoweringMatchers,
   envSignalReaderFor,
   computeSsrSeedPlan,
+  isStringConcatBinary,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
-import { BF_REGION } from '@barefootjs/shared'
+import { BF_REGION, escapeHtml } from '@barefootjs/shared'
 
 import {
   GO_IDENTIFIER,
@@ -126,6 +127,7 @@ import { resolveBlockBodyMemoModuleConst } from "./memo/memo-value.ts"
 import { computeMemoInitialValue, computeMemoInitialValueOrNull, filterArmEarlierSiblingRefs } from "./memo/memo-compute.ts"
 import { collectSpreadSlots, buildSpreadInitializer } from "./spread/spread-codegen.ts"
 import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames } from "./props/prop-types.ts"
+import { collectStringValueNames } from "./props/prop-classes.ts"
 
 export type { GoTemplateAdapterOptions } from "./lib/types.ts"
 
@@ -225,6 +227,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
   private inLoop: boolean = false
   private loopParamStack: string[] = []
+  /**
+   * Stack of `IRLoop.depth` values (innermost last), pushed/popped around
+   * `renderChildren(loop.children)` in `renderLoop`. `renderAttributes`
+   * reads the top of this stack to derive the `key` → `data-key`/
+   * `data-key-N` suffix — the depth is IR-computed (jsx-to-ir.ts), not
+   * re-derived here; this stack only threads that value down to the
+   * loop body's root element (#2168 nested-loop-outer-binding).
+   */
+  private loopKeyDepthStack: number[] = []
   /**
    * Per-loop: true when the body renders the bare range value (scalar-item
    * inline-literal loop), so the `bf_tmpl` companion is fed `.BfLoopItem` (the
@@ -331,6 +342,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.state.pendingChildrenDefines = []
     this.primeCompileState(ir)
     this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir)
+    this.state.stringValueNames = collectStringValueNames(ir)
 
     // Surface loop-body usages of sibling-imported components (see
     // `checkImportedLoopChildComponents`). The barefoot CLI compiles a
@@ -1369,6 +1381,35 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
                 break
               }
             }
+            // A number/boolean JSX-EXPRESSION literal (`count={5}`,
+            // `active={true}`) — as opposed to a plain quoted string attr
+            // (`label="mail"`, which is `case 'literal':` above, an entirely
+            // different `AttrValue` kind) — is still `kind: 'expression'`
+            // here, since curly braces always parse to an expression
+            // container regardless of what's inside them. #2168
+            // child-primitive-props: `resolveDynamicPropValue` below only
+            // recognizes a getter call or a comparison against one; a bare
+            // `5`/`true` matches neither, so the field was silently OMITTED
+            // and the Badge's `Count`/`Active` fields defaulted to Go's zero
+            // value (`0`/`false`) regardless of the actual literal.
+            //
+            // Route through `parsedLiteralToGo` rather than hand-rolling a
+            // switch on `.value`/`.literalType`: a numeric literal needs its
+            // exact source `raw` token (Copilot review — `String(value)` can
+            // change spelling/precision, e.g. a large integer or `-0`), and
+            // `parsedLiteralToGo` also covers the LEADING-UNARY-MINUS shape
+            // (`count={-5}` parses as `kind: 'unary'` wrapping the literal,
+            // not `kind: 'literal'` itself — a case this branch's earlier
+            // `parsedValue?.kind === 'literal'` gate missed entirely and
+            // would have silently reintroduced the same omitted-field bug
+            // for a negative numeric literal).
+            if (parsedValue) {
+              const goVal = parsedLiteralToGo(this.emitCtx, parsedValue)
+              if (goVal !== null) {
+                emitChildField(prop.name, goVal)
+                break
+              }
+            }
             const resolvedValue = this.resolveDynamicPropValue(
               exprText,
               ir.metadata.signals,
@@ -1381,7 +1422,40 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             break
           }
           case 'jsx-children':
-            // Handled below via `child.childrenText` / `child.childrenHtml`.
+            // The RESERVED children slot (`comp.children.length > 0 ? comp.children
+            // : jsxChildrenPropNodes(...)`) is handled below via
+            // `child.childrenText` / `child.childrenHtml` and must not be
+            // re-emitted here. A JSX-valued prop under any OTHER name
+            // (`header={<strong>Title</strong>}`, #2168 jsx-element-prop) is a
+            // named slot — bake it the same way real children are baked
+            // (`extractTextChildren` / `extractHtmlChildren`) and emit it as
+            // its own struct field, mirroring the `Children` field's
+            // text-vs-HTML branching just below.
+            if (prop.name !== 'children') {
+              const text = this.extractTextChildren(prop.value.children)
+              if (text !== null) {
+                emitChildField(prop.name, JSON.stringify(text))
+              } else {
+                const html = this.extractHtmlChildren(prop.value.children)
+                if (html !== null) {
+                  this.state.usesHtmlTemplate = true
+                  emitChildField(prop.name, `template.HTML(${JSON.stringify(html)})`)
+                } else {
+                  // The value's root needs the PARENT's runtime scope id
+                  // (`<strong>` hoisted from the call site inherits the
+                  // caller's `bf-s`, not a bake-time constant) — same
+                  // needsScope case `childrenScopedHtmlExpr` handles for
+                  // the reserved children slot. The returned string is
+                  // already a Go concatenation expression (`"..." +
+                  // scopeID + "..."`), not a literal to re-quote.
+                  const scopedHtml = this.extractScopedHtmlChildren(prop.value.children)
+                  if (scopedHtml !== null) {
+                    this.state.usesHtmlTemplate = true
+                    emitChildField(prop.name, `template.HTML(${scopedHtml})`)
+                  }
+                }
+              }
+            }
             break
         }
       }
@@ -2371,6 +2445,66 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
+    // A bare passthrough of the CALLER's own prop — `text={props.label}`
+    // forwarding into a nested child-component invocation (or the
+    // destructured form, `text={label}`) — #2168 grandchild-composition: a
+    // prop re-forwarded through a second component layer matched neither
+    // pattern above (not a getter call, not a literal — that's `case
+    // 'literal'` above this function entirely) and fell through to `null`,
+    // silently OMITTING the field so Go's zero value applied instead of the
+    // threaded value. Only an EXACT `props.<name>` / bare `<name>` — no `??`
+    // /`||` suffix — qualifies; a fallback-bearing expression isn't a pure
+    // passthrough and must keep falling through to `null` rather than
+    // silently dropping the fallback.
+    //
+    // Guarded against a LOCAL const/helper shadowing a propsParam's name
+    // (`const label = compute(); ... text={label}` inside a component whose
+    // OWN prop is also called `label`) — that bare `label` means the local,
+    // not the prop, and must keep falling through to `null` rather than
+    // being misresolved to `in.Label`.
+    const propsObjectName = this.state.propsObjectName
+    // `$` is a valid JS/TS identifier character (Copilot review, #2198) —
+    // without it, a passthrough like `text={$label}` or `text={props.$label}`
+    // never matches either shape below and silently falls through to `null`.
+    const identifierPattern = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
+    const bareIdentifier = identifierPattern.test(expr) ? expr : null
+    // Plain prefix/suffix check rather than an `expr`-interpolated `RegExp`:
+    // `propsObjectName` is an arbitrary identifier and could itself contain
+    // regex metacharacters (e.g. `$props`), which would silently build a
+    // malformed pattern instead of erroring.
+    const barePropAccess =
+      propsObjectName &&
+      expr.startsWith(`${propsObjectName}.`) &&
+      identifierPattern.test(expr.slice(propsObjectName.length + 1))
+        ? expr.slice(propsObjectName.length + 1)
+        : null
+    const passthroughName = bareIdentifier ?? barePropAccess
+    // A `localConstants` entry sharing this name is a genuine SHADOW only
+    // when it's an independent local — NOT when it's the analyzer's own
+    // body-level destructure alias (`const { label } = props`, expanded to
+    // a `localConstants` entry named `label` valued exactly `props.label`,
+    // #1138/analyzer.ts `collectConstant`). That alias IS the same prop
+    // value, so a bare `label` reference is still a pure passthrough
+    // (Copilot review, #2198 — the earlier blanket "any `localConstants`
+    // match blocks it" check wrongly reintroduced the omitted-field bug for
+    // exactly this common destructured-body pattern). A `?? default`-bearing
+    // alias value does NOT match the exact-string check below, so it's
+    // correctly still treated as a shadow (a fallback-bearing local isn't a
+    // pure passthrough either — same reasoning as the outer `??`/`||` guard
+    // above).
+    const localConst = this.state.localConstants.find(c => c.name === passthroughName)
+    const isPropsDestructureAlias =
+      localConst !== undefined &&
+      propsObjectName !== null &&
+      localConst.value === `${propsObjectName}.${passthroughName}`
+    const shadowedByLocal =
+      passthroughName !== null &&
+      ((localConst !== undefined && !isPropsDestructureAlias) ||
+        this.state.localHelperNames.has(passthroughName))
+    if (passthroughName && !shadowedByLocal && propsParams.some(p => p.name === passthroughName)) {
+      return `in.${capitalizeFieldName(passthroughName)}`
+    }
+
     return null
   }
 
@@ -2579,7 +2713,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   emitText(node: IRText): string {
-    return node.value
+    // IRText carries the entity-DECODED value (Phase 1 decodes JSX
+    // character references); re-escape for direct HTML emission.
+    return escapeHtml(node.value)
   }
 
   emitExpression(node: IRExpression): string {
@@ -3026,6 +3162,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     object: ParsedExpr,
     property: string,
     _computed: boolean,
+    optional: boolean,
     emit: (e: ParsedExpr) => string,
   ): string {
     // .length on a `.filter(...)` callback call → len (bf_filter ...)
@@ -3116,6 +3253,21 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     const obj = emit(object)
     if (property === 'length') return `len ${obj}`
+    // A `?.`-written access (`user?.name`, #2168 optional-chaining-prop):
+    // a plain `.Field` dot-chain panics evaluating a field on a nil
+    // interface/pointer (`nil pointer evaluating interface {}.Name`), so
+    // route through the runtime's existing nil-safe reflection-based
+    // getter instead — `bf_get`/`getFieldValue` (bf.go), already used for
+    // map-rooted context chains above, guards the nil case and returns Go
+    // `nil` (which `or`/`bf.truthy?`-style fallbacks treat as falsy) —
+    // unlike that map-rooted call site, this passes the Go-cased field
+    // name (`goFieldNameForKey`), matching `getFieldValue`'s struct-branch
+    // exact-match fast path. Only guards the single written `?.` hop, not
+    // a JS-style whole-chain short-circuit — see the `ParsedExpr` `member`
+    // variant's docstring for the multi-hop caveat.
+    if (optional) {
+      return `bf_get ${wrapIfMultiToken(obj)} ${JSON.stringify(goFieldNameForKey(property))}`
+    }
     return `${obj}.${goFieldNameForKey(property)}`
   }
 
@@ -3158,7 +3310,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       case '<=':
         return `le ${wl} ${wr}`
       case '+':
-        return `bf_add ${wl} ${wr}`
+        return this._emitPlus(left, right, wl, wr)
       case '-':
         return `bf_sub ${wl} ${wr}`
       case '*':
@@ -3172,6 +3324,45 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
   }
 
+  /**
+   * JS `+` with a string-typed operand is CONCATENATION, not addition — Go's
+   * `bf_add` coerces both sides through `toFloat64` (#2168
+   * string-concat-plus: `'Hello, ' + name` rendered "0", since a string
+   * operand's `toFloat64` is 0). `html/template` has no infix `+` at all, so
+   * both directions are a runtime call; route through `bf_concat_str` when
+   * either operand is string-typed.
+   *
+   * Shared by all THREE `case '+':` sites in this file (`binary()` here, the
+   * filter-predicate emitter's own `binary` case, and the condition-
+   * expression emitter's own `binary` case) — each recurses over its own
+   * `ParsedExpr` tree with its own rendered-operand strings, but the
+   * string-vs-numeric decision itself must stay identical everywhere so the
+   * three never drift out of sync (a Copilot review comment on #2197 flagged
+   * exactly this risk when they were three independent inline checks).
+   * Callers pass their own `leftExpr`/`rightExpr` (the raw `ParsedExpr` nodes
+   * `isStringConcatBinary` inspects) and `leftRendered`/`rightRendered` (the
+   * already-emitted, already-wrapped/parenthesised operand text for THIS
+   * call site's Go form).
+   */
+  private _emitPlus(
+    leftExpr: ParsedExpr,
+    rightExpr: ParsedExpr,
+    leftRendered: string,
+    rightRendered: string,
+  ): string {
+    if (isStringConcatBinary('+', leftExpr, rightExpr, n => this._isStringValueName(n))) {
+      return `bf_concat_str ${leftRendered} ${rightRendered}`
+    }
+    return `bf_add ${leftRendered} ${rightRendered}`
+  }
+
+  /** Whether `name` (a signal getter or prop) holds a string value — drives
+   *  `isStringConcatBinary`'s string-vs-numeric `+` decision (#2168
+   *  string-concat-plus). */
+  private _isStringValueName(name: string): boolean {
+    return this.state.stringValueNames.has(name)
+  }
+
   unary(op: string, argument: ParsedExpr, emit: (e: ParsedExpr) => string): string {
     const arg = emit(argument)
     if (op === '!') return `not ${arg}`
@@ -3509,6 +3700,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const recv = emit(object)
         return `bf_trim ${wrapIfMultiToken(recv)}`
       }
+      case 'trimStart':
+      case 'trimEnd': {
+        // `.trimStart()` / `.trimEnd()` — the one-sided siblings of `.trim()`
+        // (#2183 follow-up). Dedicated `bf_trim_start` / `bf_trim_end`
+        // helpers, not `bf_trim` with a flag.
+        const fn = method === 'trimStart' ? 'bf_trim_start' : 'bf_trim_end'
+        const recv = emit(object)
+        return `${fn} ${wrapIfMultiToken(recv)}`
+      }
       case 'toFixed': {
         // `.toFixed(digits?)` → `bf_to_fixed` (`fmt.Sprintf("%.*f", …)`); default
         // 0 digits when the argument is omitted.
@@ -3555,6 +3755,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const newS = emit(args[1])
         return `bf_replace ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(oldS)} ${wrapIfMultiToken(newS)}`
       }
+      case 'replaceAll': {
+        // `.replaceAll(old, new)` — string-pattern form, EVERY occurrence, via
+        // `bf_replace_all` (`strings.ReplaceAll`). A dedicated helper, not
+        // `bf_replace` with a different n — the regex-pattern form is refused
+        // upstream at the parser, same as `.replace`.
+        const recv = emit(object)
+        const oldS = emit(args[0])
+        const newS = emit(args[1])
+        return `bf_replace_all ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(oldS)} ${wrapIfMultiToken(newS)}`
+      }
       case 'repeat': {
         // `.repeat(n)` — string repeated `n` times. `bf_repeat` clamps a negative
         // count to "" instead of letting `strings.Repeat` panic. No argument is
@@ -4063,7 +4273,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           case '<=':
             return `le ${left} ${right}`
           case '+':
-            return `bf_add ${left} ${right}`
+            return this._emitPlus(expr.left, expr.right, left, right)
           case '-':
             return `bf_sub ${left} ${right}`
           case '*':
@@ -4627,7 +4837,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           case '<=':
             result = `le ${left} ${right}`; break
           case '+':
-            result = `bf_add ${left} ${right}`; break
+            result = this._emitPlus(expr.left, expr.right, left, right); break
           case '-':
             result = `bf_sub ${left} ${right}`; break
           case '*':
@@ -4920,7 +5130,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null,
     )
     this.loopWrapperStack.push(!!loop.childComponent)
+    this.loopKeyDepthStack.push(loop.depth)
     const children = this.renderChildren(loop.children)
+    this.loopKeyDepthStack.pop()
     this.loopWrapperStack.pop()
     this.loopScalarItemStack.pop()
     // Build the per-item anchor marker while the loop param is still on the
@@ -5181,7 +5393,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * doesn't share a contract with the intrinsic-attribute one.
    */
   private readonly elementAttrEmitter: AttrValueEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       // `style={{ … }}` object literal → a CSS string with dynamic values
       // interpolated, instead of refusing the bare object with BF101.
@@ -5365,10 +5577,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // Rewrite JSX special-prop names to their HTML-attribute counterparts. The
       // Go template adapter has no JSX runtime to strip `key` / emit `data-key`,
       // so the rewrite happens at attribute-emit time. Mirror of the `key`
-      // branch in `ir-to-client-js/html-template.ts`.
+      // branch in `ir-to-client-js/html-template.ts`. The depth-suffix (plain
+      // `data-key` at the outermost loop, `data-key-N` N levels deep) comes
+      // from `IRLoop.depth` via `loopKeyDepthStack`, not re-derived here.
       let attrName: string
       if (attr.name === 'className') attrName = 'class'
-      else if (attr.name === 'key') attrName = 'data-key'
+      else if (attr.name === 'key') {
+        const depth = this.loopKeyDepthStack.at(-1) ?? 0
+        attrName = depth > 0 ? `data-key-${depth}` : 'data-key'
+      }
       else attrName = attr.name
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName)
       if (lowered) parts.push(lowered)

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

@@ -137,6 +137,14 @@ export class CompileState {
    */
   nillablePropNames: Set<string> = new Set()
 
+  /**
+   * String-typed signal getter / prop names (#2168 string-concat-plus).
+   * Feeds `isStringName` for `isStringConcatBinary`, which decides whether a
+   * JS `+` operand chain is string concatenation rather than numeric
+   * addition — see `collectStringValueNames` (`props/prop-classes.ts`).
+   */
+  stringValueNames: Set<string> = new Set()
+
   /** Component root scope element(s) — each carries `data-key` for a keyed loop
    *  item. */
   rootScopeNodes: Set<IRNode> = new Set()

package/src/adapter/lib/constants.ts

@@ -17,6 +17,7 @@ export const GO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'Math.floor':     { arity: 1, emit: (args) => `bf_floor ${wrapGoArg(args[0])}` },
   'Math.ceil':      { arity: 1, emit: (args) => `bf_ceil ${wrapGoArg(args[0])}` },
   'Math.round':     { arity: 1, emit: (args) => `bf_round ${wrapGoArg(args[0])}` },
+  'Math.abs':       { arity: 1, emit: (args) => `bf_abs ${wrapGoArg(args[0])}` },
   // Two-arg forms only; an N-arg `Math.min(a, b, c)` falls through to the
   // standard BF101 unsupported-call diagnostic via the arity gate.
   'Math.min':       { arity: 2, emit: (args) => `bf_min ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` },

package/src/adapter/memo/memo-compute.ts

@@ -366,13 +366,40 @@ export function memoInitialFromParsedBody(
     const operator = body.op
     const operand = String(body.right.value)
 
-    // getter() * N — return the signal's Go initial value times N.
+    // getter() * N — return the signal's (or, #2168 memo-chain, another
+    // memo's) Go initial value times N. `resolveGetterValueAsGo` checks
+    // `signals` first (unchanged behavior for a signal-derived memo like
+    // `doubled = createMemo(() => count() * 2)`), then falls back to
+    // `ctx.state.currentMemos` and recurses — needed for a memo derived from
+    // ANOTHER memo (`label = createMemo(() => doubled() + 1)`), which this
+    // branch previously couldn't recognize at all (a signals-only lookup),
+    // silently folding to the Go zero value instead of "7".
     const depName = getterCallName(body.left)
     if (depName) {
-      const signal = signals.find(s => s.getter === depName)
-      if (signal) {
-        const signalInitial = getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars)
-        return `${signalInitial} ${operator} ${operand}`
+      const depInitial = resolveGetterValueAsGo(ctx, depName, signals, propsParams, propFallbackVars, resolving)
+      // `resolveGetterValueAsGo` can return an IIFE (`func() string { ... }()`
+      // / `func() interface{} { ... }()`, e.g. a memo that shadows `props.X
+      // ?? <lit>`, #2075) rather than a plain atom — none of those return
+      // types support Go's `<op>` arithmetic operators, so splicing one in
+      // bare would emit invalid Go (Copilot review, #2200: e.g. `operator
+      // is not defined on interface{}`/`string`). Bail (fall through to the
+      // caller's zero-value default) rather than emit broken arithmetic.
+      const isArithmeticSafe = depInitial !== null && !depInitial.startsWith('func(')
+      if (isArithmeticSafe) {
+        // A signal's own initial value is always a simple atom (a literal,
+        // `in.Field`, a hoisted var) — never needs grouping. A MEMO's initial
+        // value can itself be a compound expression from this exact branch
+        // one level up (`"3 * 2"`), and splicing that in bare under a
+        // DIFFERENT outer operator can silently invert precedence (a memo
+        // chain shaped `inner = () => count() + 1` then `outer = () =>
+        // inner() * 2` would fold to `3 + 1 * 2` = 5 in Go, vs JS's `(3+1)*2`
+        // = 8). Parenthesize whenever `depInitial` is compound (contains
+        // whitespace — a simple atom never does) so precedence is
+        // preserved regardless of which operator combination a memo chain
+        // uses. A simple atom is left bare so existing exact-text
+        // expectations (`Doubled: 3 * 2,`) don't gain a no-op paren.
+        const wrapped = /\s/.test(depInitial) ? `(${depInitial})` : depInitial
+        return `${wrapped} ${operator} ${operand}`
       }
     }
 
@@ -408,12 +435,13 @@ export function memoInitialFromParsedBody(
     }
   }
 
-  // () => getter() — just return the signal's Go initial value.
+  // () => getter() — just return the signal's (or another memo's, #2168
+  // memo-chain) Go initial value.
   const simpleDep = getterCallName(body)
   if (simpleDep) {
-    const signal = signals.find(s => s.getter === simpleDep)
-    if (signal) {
-      return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars)
+    const depInitial = resolveGetterValueAsGo(ctx, simpleDep, signals, propsParams, propFallbackVars, resolving)
+    if (depInitial !== null) {
+      return depInitial
     }
   }
 

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

@@ -0,0 +1,45 @@
+/**
+ * Prop classification for the Go template adapter.
+ *
+ * Ported from `packages/adapter-blade/src/adapter/props/prop-classes.ts` (itself
+ * ported from Jinja) — ONE function: string-typed signal/prop names, needed to
+ * decide `+` string-concat vs numeric addition (#2168 string-concat-plus). Pure
+ * function over `ir.metadata`; no adapter instance state.
+ */
+
+import type { ComponentIR, TypeInfo } from '@barefootjs/jsx'
+
+/** True when `type` is the `string` primitive. */
+function isStringTypeInfo(type: TypeInfo): boolean {
+  return type.kind === 'primitive' && type.primitive === 'string'
+}
+
+/** True when `initialValue` is a bare string-literal expression. */
+function isBareStringLiteral(initialValue: string | undefined): boolean {
+  if (!initialValue) return false
+  const v = initialValue.trim()
+  return (v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))
+}
+
+/**
+ * String-typed signals and props. A signal is string-typed when its inferred
+ * type is `string` (or, defensively, when its initial value is a bare string
+ * literal); a prop when its annotated type is `string`. Drives `isStringName`
+ * for `isStringConcatBinary` — the shared helper (`@barefootjs/jsx`) that
+ * decides whether a JS `+` is string concatenation rather than numeric
+ * addition (Go's `html/template` has no native `+` at all; `binary()` always
+ * emits a runtime call, `bf_add` for addition or `bf_concat_str` for
+ * concatenation — see `go-template-adapter.ts`'s `binary()`).
+ */
+export function collectStringValueNames(ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  for (const s of ir.metadata.signals) {
+    if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+      names.add(s.getter)
+    }
+  }
+  for (const p of ir.metadata.propsParams) {
+    if (isStringTypeInfo(p.type)) names.add(p.name)
+  }
+  return names
+}

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

@@ -5,7 +5,7 @@
  * generators and the nillable-field set so they can't drift.
  */
 
-import type { ComponentIR, IRMetadata } from '@barefootjs/jsx'
+import type { ComponentIR, IRMetadata, IRNode, ParsedExpr } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
@@ -35,9 +35,77 @@ export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map
       }
     }
   }
+
+  // A bare `number`-typed prop with no other evidence resolves to Go `int`
+  // (`typeInfoToGo`'s blind default) — but `.toFixed()` can only be called on
+  // a real JS number, and the runtime value it formats (e.g. a price, 19.5)
+  // may be fractional, which a Go `int` struct field can't hold (assigning a
+  // fractional untyped constant to it is a compile error: #2168
+  // number-tofixed). Unlike a signal's fractional LITERAL initial value
+  // (rescued by `typeInfoToGo`'s own `defaultValue` consultation — the
+  // math-methods half of the same divergence), a prop with no default has no
+  // literal to read the fraction off of; the usage of `.toFixed()` itself is
+  // the only available evidence, so it's collected by walking the JSX tree.
+  for (const propName of collectToFixedPropNames(ir.root)) {
+    const param = ir.metadata.propsParams.find(p => p.name === propName)
+    if (!param) continue
+    const resolved = overrides.get(propName) ?? typeInfoToGo(ctx, param.type, param.defaultValue)
+    if (resolved === 'int') {
+      overrides.set(propName, 'float64')
+    }
+  }
+
   return overrides
 }
 
+/**
+ * Names of identifiers used as the receiver of `.toFixed(...)` anywhere in
+ * the component's JSX tree (text expressions, conditions, and attribute
+ * values). Deliberately narrow — `.toFixed()` is the one number-shape usage
+ * that needs this rescue (see `buildPropTypeOverrides` above); it isn't a
+ * general "infer number-ness from usage" walker.
+ *
+ * KNOWN LIMITATION: only a DIRECT identifier receiver in the JSX tree is
+ * caught (`{price.toFixed(2)}`). A bare `number` prop with no default is
+ * still silently typed `int` — and hits the exact same `go run` compile
+ * failure (#2168 number-tofixed) on a fractional runtime value — if the
+ * fraction only surfaces indirectly (`.toFixed()` inside a signal's
+ * initial value or a memo's computation, reached via `ir.metadata` rather
+ * than `ir.root`) or via any OTHER fraction-producing operation on the
+ * same bare prop (division, `Math.round`/`Math.floor`, etc. — none of
+ * which carry the same unambiguous "this must be a real JS number" signal
+ * `.toFixed()` does). Widening this walker to those cases is a real,
+ * currently-unaddressed gap, not a hypothetical one — flag it rather than
+ * treating a future occurrence as a fresh regression.
+ */
+function collectToFixedPropNames(root: IRNode): Set<string> {
+  const names = new Set<string>()
+  const checkExpr = (expr: ParsedExpr | undefined) => {
+    if (expr?.kind === 'array-method' && expr.method === 'toFixed' && expr.object.kind === 'identifier') {
+      names.add(expr.object.name)
+    }
+  }
+  const walk = (node: IRNode | null | undefined) => {
+    if (!node) return
+    if (node.type === 'expression') checkExpr(node.parsed)
+    if (node.type === 'conditional') {
+      checkExpr(node.parsedCondition)
+      walk(node.whenTrue)
+      walk(node.whenFalse)
+    }
+    if (node.type === 'element') {
+      for (const attr of node.attrs) {
+        if (attr.value.kind === 'expression') checkExpr(attr.value.parsed)
+      }
+    }
+    if ('children' in node && Array.isArray(node.children)) {
+      node.children.forEach(walk)
+    }
+  }
+  walk(root)
+  return names
+}
+
 /**
  * Resolve a prop param's Go struct-field type using the SAME logic
  * `generatePropsStruct` / `generateInputStruct` use: a `propTypeOverrides` entry

package/src/adapter/type/type-codegen.ts

@@ -18,7 +18,11 @@ import type { GoEmitContext } from '../emit-context.ts'
 /**
  * Convert a `TypeInfo` to a Go type string.
  *
- * @param defaultValue used to infer the type when `typeInfo.kind` is `unknown`
+ * @param defaultValue used to infer the type when `typeInfo.kind` is
+ *   `unknown`, and to distinguish `int` vs `float64` when `kind` is
+ *   `primitive`/`number` (#2168 math-methods/number-tofixed — a bare TS
+ *   `number` blindly mapped to Go `int`, so a fractional signal initial
+ *   value like `-7.6` silently truncated to the Go zero value)
  * @returns the Go type, falling back to `interface{}` when unresolvable
  */
 export function typeInfoToGo(
@@ -32,7 +36,7 @@ export function typeInfoToGo(
         case 'string':
           return 'string'
         case 'number':
-          return 'int'
+          return defaultValue !== undefined ? numberPrimitiveGoType(defaultValue) : 'int'
         case 'boolean':
           return 'bool'
         default:
@@ -99,6 +103,19 @@ export function tsTypeStringToGo(ctx: GoEmitContext, tsType: string): string {
   return 'interface{}'
 }
 
+/**
+ * Distinguish Go `int` vs `float64` for a `number`-typed field from the
+ * literal source text of its default/initial value. Falls back to `int`
+ * when `value` isn't recognizably a bare numeric literal (e.g. a
+ * destructured default that's itself an expression, `props.initial ?? 0`)
+ * — `int` remains the blind fallback for `kind: 'primitive'`; only a
+ * literal fractional value (`-7.6`) is positive enough evidence to widen
+ * to `float64`.
+ */
+function numberPrimitiveGoType(value: string): string {
+  return /^-?\d+\.\d+$/.test(value) ? 'float64' : 'int'
+}
+
 /** Infer a Go type from a JS value literal; `interface{}` when unrecognized. */
 export function inferTypeFromValue(value: string): string {
   if (value === 'true' || value === 'false') return 'bool'