@barefootjs/go-template 0.31.1 → 0.31.2

package/src/adapter/lib/types.ts

@@ -134,7 +134,10 @@ export interface SpreadSlotInfo {
 export interface PropFallbackVar {
   /** Local variable name (typically the lowercase prop identifier). */
   varName: string
-  /** Capitalised Go field name on the `Input` struct. */
+  /**
+   * Capitalised Go field name on the `Input` struct — caller-facing
+   * (`sourceName ?? name`, #2525), since every reader does `in.${fieldName}`.
+   */
   fieldName: string
   /** Go literal used when the input value equals its zero value. */
   goFallback: string

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

@@ -109,7 +109,7 @@ export function matchFilterArmMemo(
   ctx: GoEmitContext,
   body: ParsedExpr,
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
 ): { propName: string; predJSON: string; paramName: string; freeVars: string[] } | null {
   const cb = asCallbackMethodCall(body)
   if (!cb || cb.method !== 'filter') return null
@@ -146,7 +146,7 @@ export function filterArmEarlierSiblingRefs(
   ctx: GoEmitContext,
   memo: { name: string; parsed?: ParsedExpr },
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
 ): string[] {
   if (!memo.parsed) return []
   const match = matchFilterArmMemo(ctx, memo.parsed, signals, propsParams)
@@ -179,7 +179,7 @@ export function computeMemoInitialValue(
   ctx: GoEmitContext,
   memo: { name: string; computation: string; deps: string[]; parsed?: ParsedExpr },
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
   goType?: string,
 ): string {
@@ -221,7 +221,7 @@ export function memoInitialFromParsedBody(
   ctx: GoEmitContext,
   body: ParsedExpr,
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string; parsed?: ParsedExpr }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   currentMemoName: string,
   resolving: ReadonlySet<string> = new Set(),
@@ -229,7 +229,8 @@ export function memoInitialFromParsedBody(
   const propRef = (propName: string): string => {
     const hoisted = propFallbackVars.get(propName)
     if (hoisted) return hoisted.varName
-    return `in.${capitalizeFieldName(propName)}`
+    const param = propsParams.find(p => p.name === propName)
+    return `in.${capitalizeFieldName(param?.sourceName ?? propName)}`
   }
   // A request-scoped env-signal read (`searchParams().get('k')`, any local
   // alias, #1922) → the literal key and the reader's canonical field name,
@@ -393,7 +394,9 @@ export function memoInitialFromParsedBody(
       // being concretely typed, wouldn't compile against `nil` either).
       if (param && ctx.state.nillablePropNames.has(propName)) {
         const isNe = body.op === '!==' || body.op === '!='
-        return `in.${capitalizeFieldName(propName)} ${isNe ? '!=' : '=='} nil`
+        // `nillablePropNames` stays keyed by the LOCAL name (a source-level
+        // set); the emitted field is caller-facing (#2525).
+        return `in.${capitalizeFieldName(param.sourceName ?? propName)} ${isNe ? '!=' : '=='} nil`
       }
     }
   }
@@ -532,7 +535,7 @@ export function memoInitialFromParsedBody(
         if (hoisted) return `${hoisted.varName} ${operator} ${operand}`
         const fieldName = capitalizeFieldName(propName)
         if (param.type) {
-          const goType = typeInfoToGo(ctx, param.type, param.defaultValue)
+          const goType = typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed)
           if (goType === 'interface{}') return `in.${fieldName}.(int) ${operator} ${operand}`
         }
         return `in.${fieldName} ${operator} ${operand}`
@@ -544,9 +547,9 @@ export function memoInitialFromParsedBody(
       const varName = body.left.name
       const param = propsParams.find(p => p.name === varName)
       if (param) {
-        const fieldName = capitalizeFieldName(varName)
+        const fieldName = capitalizeFieldName(param.sourceName ?? varName)
         if (param.type) {
-          const goType = typeInfoToGo(ctx, param.type, param.defaultValue)
+          const goType = typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed)
           if (goType === 'interface{}') return `in.${fieldName}.(int) ${operator} ${operand}`
         }
         return `in.${fieldName} ${operator} ${operand}`
@@ -574,7 +577,7 @@ export function memoInitialFromParsedBody(
   // () => var — destructured prop, return the input field directly.
   if (body.kind === 'identifier') {
     const param = propsParams.find(p => p.name === body.name)
-    if (param) return `in.${capitalizeFieldName(body.name)}`
+    if (param) return `in.${capitalizeFieldName(param.sourceName ?? body.name)}`
   }
 
   // () => <a> + <b> + … — a string-concatenation chain whose every leaf is a
@@ -607,7 +610,7 @@ function resolveStringConcatChainGo(
   ctx: GoEmitContext,
   expr: ParsedExpr,
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   propRef: (propName: string) => string,
 ): string | null {
@@ -647,7 +650,7 @@ export function computeMemoInitialValueOrNull(
   ctx: GoEmitContext,
   memo: { name: string; computation: string; deps: string[]; parsed?: ParsedExpr; parsedBlock?: ParsedStatement[]; parsedBlockComplete?: boolean },
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
   /**
    * Memo names currently being resolved on this call stack — guards against
@@ -729,7 +732,7 @@ export function resolveGetterValueAsGo(
   ctx: GoEmitContext,
   name: string,
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   resolving: ReadonlySet<string> = new Set(),
 ): string | null {
@@ -745,7 +748,8 @@ export function resolveGetterValueAsGo(
     const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, '')
     const fb = ctx.extractPropFallback(stripped)
     if (fb && capitalizeFieldName(fb.propName) === capitalizeFieldName(memo.name)) {
-      const field = `in.${capitalizeFieldName(fb.propName)}`
+      const fbParam = propsParams.find(p => p.name === fb.propName)
+      const field = `in.${capitalizeFieldName(fbParam?.sourceName ?? fb.propName)}`
       return `func() interface{} { v := interface{}(${field}); if v == nil || v == "" { return ${fb.goFallback} }; return v }()`
     }
     return computeMemoInitialValueOrNull(
@@ -755,7 +759,7 @@ export function resolveGetterValueAsGo(
   const param = propsParams.find(p => p.name === name)
   if (param) {
     const hoisted = propFallbackVars.get(name)
-    return hoisted ? hoisted.varName : `in.${capitalizeFieldName(name)}`
+    return hoisted ? hoisted.varName : `in.${capitalizeFieldName(param.sourceName ?? name)}`
   }
   return null
 }
@@ -772,7 +776,7 @@ export function computeComparisonTernaryGo(
   ctx: GoEmitContext,
   parsed: ParsedExpr | undefined,
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   resolving: ReadonlySet<string> = new Set(),
 ): string | null {
@@ -828,7 +832,7 @@ export function resolveComparisonOperandGo(
   ctx: GoEmitContext,
   node: ParsedExpr,
   signals: { getter: string; initialValue: string; type?: TypeInfo }[],
-  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  propsParams: { name: string; sourceName?: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   resolving: ReadonlySet<string> = new Set(),
 ): string | null {

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

@@ -34,8 +34,8 @@ export function isListFilterMemo(memo: { parsed?: ParsedExpr }): boolean {
 export function isBooleanMemo(
   ctx: GoEmitContext,
   memo: { computation: string; deps: string[]; parsed?: ParsedExpr },
-  signals: { getter: string; initialValue: string; type: TypeInfo }[],
-  propsParamMap: Map<string, { name: string; type: TypeInfo; defaultValue?: string }>,
+  signals: { getter: string; initialValue: string; type: TypeInfo; parsed?: ParsedExpr }[],
+  propsParamMap: Map<string, { name: string; type: TypeInfo; defaultValue?: string; parsed?: ParsedExpr }>,
 ): boolean {
   const c = memo.computation
   // A LIST-valued `.filter(arrow)` memo (#2075) is never boolean, even though
@@ -58,13 +58,13 @@ export function isBooleanMemo(
       if (typeInfoToGo(ctx, sig.type) === 'bool') return true
       // Signal initialised from `props.X ?? false` / a boolean prop.
       if (/\?\?\s*(true|false)\b/.test(sig.initialValue)) return true
-      const propName = ctx.extractPropNameFromInitialValue(sig.initialValue) ?? sig.initialValue
+      const propName = ctx.extractPropNameFromInitialValue(sig.initialValue, sig.parsed) ?? sig.initialValue
       const prop = propsParamMap.get(propName)
-      if (prop && typeInfoToGo(ctx, prop.type, prop.defaultValue) === 'bool') return true
+      if (prop && typeInfoToGo(ctx, prop.type, prop.defaultValue, prop.parsed) === 'bool') return true
       return false
     }
     const prop = propsParamMap.get(name)
-    return !!prop && typeInfoToGo(ctx, prop.type, prop.defaultValue) === 'bool'
+    return !!prop && typeInfoToGo(ctx, prop.type, prop.defaultValue, prop.parsed) === 'bool'
   }
   const ternary = c.match(/=>\s*\w+\(\)\s*\?\s*(\w+)\(\)\s*:\s*(\w+)\(\)/)
   if (ternary) {

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

@@ -27,9 +27,9 @@ export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map
     for (const propName of propNames) {
       const param = ir.metadata.propsParams.find(p => p.name === propName)
       if (!param) continue
-      const propGoType = typeInfoToGo(ctx, param.type, param.defaultValue)
+      const propGoType = typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed)
       if (propGoType.includes('interface{}')) {
-        const signalGoType = typeInfoToGo(ctx, signal.type, signal.initialValue)
+        const signalGoType = typeInfoToGo(ctx, signal.type, signal.initialValue, signal.parsed)
         if (!signalGoType.includes('interface{}')) {
           overrides.set(propName, signalGoType)
         }
@@ -50,7 +50,7 @@ export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map
   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)
+    const resolved = overrides.get(propName) ?? typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed)
     if (resolved === 'int') {
       overrides.set(propName, 'float64')
     }
@@ -381,7 +381,8 @@ export function collectPresenceCheckedPropNames(ctx: GoEmitContext, ir: Componen
 /**
  * Resolve a prop param's Go struct-field type using the SAME logic
  * `generatePropsStruct` / `generateInputStruct` use: a `propTypeOverrides` entry
- * wins, otherwise `typeInfoToGo(param.type, param.defaultValue)`. Factored out so
+ * wins, otherwise `typeInfoToGo(param.type, param.defaultValue, param.parsed)`.
+ * Factored out so
  * the nillable-field set (`collectNillablePropNames`) can't drift from the
  * emitted field types.
  */
@@ -390,7 +391,7 @@ export function resolvePropGoType(
   param: IRMetadata['propsParams'][number],
   propTypeOverrides: Map<string, string>,
 ): string {
-  const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue)
+  const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed)
   // An OPTIONAL prop typed as a named struct (`opts?: EmblaOptionsType`) lowers
   // to `map[string]interface{}`, not the value struct: a value struct is always
   // truthy in Go templates (so a `{{if .Opts}}`-guarded attribute could never be

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

@@ -225,7 +225,7 @@ export function buildSpreadInitializer(
     //    `{...extras}` resolves to `in.Extras`.
     const param = ir.metadata.propsParams.find(p => p.name === trimmed)
     if (param) {
-      return `in.${capitalizeFieldName(param.name)}`
+      return `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
     }
     // 2. SolidJS-style props object: `function(props: P)` → spread
     //    `{...props}` enumerates all propsParams into a `map[string]any`
@@ -235,8 +235,11 @@ export function buildSpreadInitializer(
     //    `applyRestAttrs` hydrate path still applies them — worse than full
     //    enumeration, better than BF101 blocking the build.
     if (ir.metadata.propsObjectName === trimmed) {
+      // Bag key stays the caller-facing prop name (mirrors the spread bag's
+      // external shape); Input field read is caller-facing too (#2525) —
+      // identity here since the `props`-object pattern has no aliasing.
       const entries = ir.metadata.propsParams.map(p =>
-        `${JSON.stringify(p.name)}: in.${capitalizeFieldName(p.name)}`,
+        `${JSON.stringify(p.sourceName ?? p.name)}: in.${capitalizeFieldName(p.sourceName ?? p.name)}`,
       )
       return `map[string]any{${entries.join(', ')}}`
     }
@@ -344,7 +347,7 @@ function conditionToGoBool(
   if (node.kind !== 'identifier') return null
   const param = ir.metadata.propsParams.find(p => p.name === node.name)
   if (!param) return null
-  const field = `in.${capitalizeFieldName(param.name)}`
+  const field = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
   const prim = param.type.kind === 'primitive' ? param.type.primitive : undefined
   let truthy: string
   if (prim === 'boolean') {
@@ -396,7 +399,7 @@ function objectLiteralToGoSpreadMap(
     } else if (val.kind === 'identifier') {
       const param = ir.metadata.propsParams.find(p => p.name === val.name)
       if (!param) return null
-      goVal = `in.${capitalizeFieldName(param.name)}`
+      goVal = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
     } else {
       const indexed = recordIndexAccessToGoMap(ctx, val, ir)
       if (indexed === null) return null
@@ -453,6 +456,10 @@ function recordIndexAccessToGoMap(
     return `${JSON.stringify(e.key)}: ${mapVal}`
   })
   ctx.state.usesFmt = true
-  const field = `in.${capitalizeFieldName(parsed.indexPropName)}`
+  // `parsed.indexPropName` is the LOCAL binding (`parseRecordIndexAccess` is
+  // shared with other adapters and stays name-agnostic); resolve the Input
+  // field caller-facing here (#2525) rather than in the shared parser.
+  const indexParam = ir.metadata.propsParams.find(p => p.name === parsed.indexPropName)
+  const field = `in.${capitalizeFieldName(indexParam?.sourceName ?? parsed.indexPropName)}`
   return `map[string]any{${entries.join(', ')}}[fmt.Sprint(${field})]`
 }

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

@@ -11,7 +11,7 @@
  * pure.
  */
 
-import type { TypeInfo } from '@barefootjs/jsx'
+import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 
@@ -57,6 +57,48 @@ export function collapseLiteralUnion(typeInfo: TypeInfo): TypeInfo {
   return { kind: 'primitive', raw: typeInfo.raw, primitive: first }
 }
 
+/**
+ * A literal number's numeric value, unwrapping a leading unary minus (`-7.6`
+ * parses as `{kind:'unary', op:'-', argument:{literalType:'number', value:7.6}}`
+ * — the same shape `parsedLiteralToGo`'s own unary-minus arm unwraps,
+ * `value-lowering.ts`/`parsed-literal-to-go.ts`). Returns `null` for anything
+ * that isn't (possibly negated) a number literal.
+ */
+function literalNumberValue(expr: ParsedExpr): number | null {
+  if (expr.kind === 'literal' && expr.literalType === 'number' && typeof expr.value === 'number') {
+    return expr.value
+  }
+  if (
+    expr.kind === 'unary' &&
+    expr.op === '-' &&
+    expr.argument.kind === 'literal' &&
+    expr.argument.literalType === 'number' &&
+    typeof expr.argument.value === 'number'
+  ) {
+    return -expr.argument.value
+  }
+  return null
+}
+
+/**
+ * Structural counterpart to {@link inferTypeFromValue}: classify a parsed
+ * literal's Go type from its `ParsedExpr` shape instead of its source text.
+ * Returns `null` for anything not covered here (identifier/call/member,
+ * object-literal — same scope `inferTypeFromValue`'s text scan covers, so a
+ * caller falling back to the text path for those sees identical results).
+ */
+function inferGoTypeFromParsed(expr: ParsedExpr): string | null {
+  const n = literalNumberValue(expr)
+  if (n !== null) return Number.isInteger(n) ? 'int' : 'float64'
+  if (expr.kind === 'literal') {
+    if (expr.literalType === 'boolean') return 'bool'
+    if (expr.literalType === 'string') return 'string'
+    return null
+  }
+  if (expr.kind === 'array-literal') return '[]interface{}'
+  return null
+}
+
 /**
  * Convert a `TypeInfo` to a Go type string.
  *
@@ -65,12 +107,18 @@ export function collapseLiteralUnion(typeInfo: TypeInfo): TypeInfo {
  *   `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)
+ * @param preParsed the SAME default/initial value as `defaultValue`, already
+ *   parsed to structure (`SignalInfo.parsed` / `ParamInfo.parsed`) — preferred
+ *   over regexing `defaultValue`'s text when present. Callers with no
+ *   structural counterpart (a shape `tsNodeToParsedExpr` doesn't support) pass
+ *   nothing and fall through to the text path.
  * @returns the Go type, falling back to `interface{}` when unresolvable
  */
 export function typeInfoToGo(
   ctx: GoEmitContext,
   _typeInfo: TypeInfo,
   defaultValue?: string,
+  preParsed?: ParsedExpr,
 ): string {
   const typeInfo = collapseLiteralUnion(_typeInfo)
   switch (typeInfo.kind) {
@@ -78,8 +126,11 @@ export function typeInfoToGo(
       switch (typeInfo.primitive) {
         case 'string':
           return 'string'
-        case 'number':
+        case 'number': {
+          const n = preParsed ? literalNumberValue(preParsed) : null
+          if (n !== null) return Number.isInteger(n) ? 'int' : 'float64'
           return defaultValue !== undefined ? numberPrimitiveGoType(defaultValue) : 'int'
+        }
         case 'boolean':
           return 'bool'
         default:
@@ -108,58 +159,68 @@ export function typeInfoToGo(
       if (typeInfo.raw && (ctx.state.localStructFields.has(typeInfo.raw) || ctx.state.localTypeAliases.has(typeInfo.raw))) {
         return typeInfo.raw
       }
-      // Resolve a raw type string pattern (e.g. `Array<Todo>`).
+      // A named type with no backing struct/alias — an external/unresolved
+      // reference. `typeNodeToTypeInfo` already normalises every ARRAY spelling
+      // (`T[]`, `Array<T>`, `ReadonlyArray<T>`) to `kind: 'array'` before a
+      // `TypeInfo` ever reaches here (#2480's structural literal-type pass did
+      // the same for literal unions), so `typeInfo.raw` at this point is never
+      // an array shape — `tsTypeStringToGo` is a plain lookup, not a parser.
       if (typeInfo.raw) {
         const resolved = tsTypeStringToGo(ctx, typeInfo.raw)
         if (resolved !== 'interface{}') return resolved
       }
       return 'interface{}'
-    case 'unknown':
+    case 'unknown': {
+      const inferred = preParsed ? inferGoTypeFromParsed(preParsed) : null
+      if (inferred) return inferred
       if (defaultValue !== undefined) {
         return inferTypeFromValue(defaultValue)
       }
       return 'interface{}'
+    }
     default:
       return 'interface{}'
   }
 }
 
 /**
- * Convert a raw TypeScript type string to a Go type string. Handles primitives,
- * `T[]` / `Array<T>` arrays, and known local types; else `interface{}`.
+ * Look up a raw TypeScript type-reference name against the component's own
+ * Go-backed local types. NOT a parser: by the time a `TypeInfo` reaches here
+ * (`typeInfoToGo`'s `'interface'` case, its one caller) `typeNodeToTypeInfo`
+ * has already normalised every array spelling to `kind: 'array'` and every
+ * primitive keyword to `kind: 'primitive'` — `tsType` is always a bare named
+ * reference (a struct, a string-union alias, or an unbacked/external name),
+ * never `T[]` / `Array<T>` / `'number'` text to re-parse. (#2484: this used to
+ * carry `t.endsWith('[]')` / `Array<(.+)>` regex branches as a fallback for
+ * that dead case — unreachable given the analyzer's normalisation, deleted.)
  */
 export function tsTypeStringToGo(ctx: GoEmitContext, tsType: string): string {
   const t = tsType.trim()
-  if (t === 'number') return 'int'
-  if (t === 'string') return 'string'
-  if (t === 'boolean' || t === 'bool') return 'bool'
-  if (t.endsWith('[]')) {
-    const elem = t.slice(0, -2)
-    return `[]${tsTypeStringToGo(ctx, elem)}`
-  }
-  const arrayMatch = t.match(/^Array<(.+)>$/)
-  if (arrayMatch) return `[]${tsTypeStringToGo(ctx, arrayMatch[1])}`
-  // Same backing gate as `typeInfoToGo`'s 'interface' case above — an
-  // unbacked local type name (a tuple alias with no struct fields) must not
-  // be returned bare, or the generated code references an undeclared type.
   if (ctx.state.localStructFields.has(t) || ctx.state.localTypeAliases.has(t)) return t
   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`.
+ * literal source text of its default/initial value. TEXT FALLBACK: used only
+ * when `typeInfoToGo`'s caller has no structural `ParsedExpr` for the same
+ * value to pass as `preParsed` (see `inferGoTypeFromParsed`/`literalNumberValue`
+ * above, which this mirrors on parsed structure). 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. */
+/**
+ * Infer a Go type from a JS value literal's source TEXT; `interface{}` when
+ * unrecognized. TEXT FALLBACK: mirrors `inferGoTypeFromParsed` above on raw
+ * text, used only when `typeInfoToGo`'s caller has no structural `ParsedExpr`
+ * for the same value to pass as `preParsed`.
+ */
 export function inferTypeFromValue(value: string): string {
   if (value === 'true' || value === 'false') return 'bool'
   if (/^-?\d+$/.test(value)) return 'int'

package/src/adapter/value/parsed-literal-to-go.ts

@@ -74,13 +74,18 @@ function bakeInlineObjectAsGoMap(ctx: GoEmitContext, expr: ParsedExpr): string |
   return `map[string]interface{}{${entries.join(', ')}}`
 }
 
-export function parsedLiteralToGo(
-  ctx: GoEmitContext,
-  expr: ParsedExpr,
-  typeInfo?: TypeInfo,
-): string | null {
-  // Leading unary minus on a numeric literal (`-1`), from the carried `raw`
-  // token.
+/**
+ * A literal number's exact Go source text, unwrapping a leading unary minus
+ * (`-1` parses as `{kind:'unary', op:'-', argument:{literalType:'number'}}`).
+ * Needs the exact source token — re-stringifying the parsed numeric VALUE
+ * could change spelling / lose precision — so this defers (`null`) rather
+ * than reconstructing one, same as every other non-literal shape here.
+ *
+ * Shared by `parsedLiteralToGo`'s own number/unary-minus cases below and
+ * `convertInitialValue`'s primitive-number branch (`value-lowering.ts`) —
+ * the SAME literal needs the SAME exact-token handling wherever it's baked.
+ */
+export function numberLiteralRawGo(expr: ParsedExpr): string | null {
   if (
     expr.kind === 'unary' &&
     expr.op === '-' &&
@@ -89,6 +94,19 @@ export function parsedLiteralToGo(
   ) {
     return expr.argument.raw !== undefined ? `-${expr.argument.raw}` : null
   }
+  if (expr.kind === 'literal' && expr.literalType === 'number') {
+    return expr.raw ?? null
+  }
+  return null
+}
+
+export function parsedLiteralToGo(
+  ctx: GoEmitContext,
+  expr: ParsedExpr,
+  typeInfo?: TypeInfo,
+): string | null {
+  const numberGo = numberLiteralRawGo(expr)
+  if (numberGo !== null) return numberGo
 
   if (expr.kind === 'literal') {
     switch (expr.literalType) {
@@ -96,9 +114,9 @@ export function parsedLiteralToGo(
         // `value` is the unquoted text; `JSON.stringify` re-quotes it for Go.
         return JSON.stringify(expr.value)
       case 'number':
-        // Need the exact source token; without it the value could change
-        // spelling / lose precision, so defer.
-        return expr.raw ?? null
+        // A number literal with no `raw` token (`numberLiteralRawGo` already
+        // returned null above) — defer.
+        return null
       case 'boolean':
         return expr.value ? 'true' : 'false'
       case 'null':