@barefootjs/go-template 0.31.9 → 0.32.0

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

@@ -119,7 +119,7 @@ import type {
 } from "./lib/types.ts"
 import { collectRootScopeNodes } from "./lib/ir-scope.ts"
 import { GO_TEMPLATE_PRIMITIVES } from "./lib/constants.ts"
-import { CompileState } from "./lib/compile-state.ts"
+import { CompileState, resolveSignalParsedThroughSeedPlan } from "./lib/compile-state.ts"
 import { hasClientInteractivity, findNestedComponents } from "./analysis/component-tree.ts"
 import { analyzeBakeableStaticChildLoop, scalarToGoLiteral, type BakedStaticChildLoop } from "./analysis/static-child-loop-bake.ts"
 import { analyzeBakeableStaticElementLoop } from "./analysis/static-element-loop-bake.ts"
@@ -255,6 +255,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     extractPropNameFromInitialValue: (initialValue, preParsed) =>
       this.extractPropNameFromInitialValue(initialValue, preParsed),
     extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
+    extractCollisionDerivation: (parsed) => this.extractCollisionDerivation(parsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
   }
 
@@ -1873,6 +1874,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push('')
     }
 
+    this.emitCallerPropsInit(lines, ir, nestedComponents, staticWithoutBody, staticWithBody, dynamicWithBody, emittedWrapperVars, propTypeOverrides)
+
     lines.push(`\treturn ${propsTypeName}{`)
     lines.push('\t\tScopeID: scopeID,')
     // Host context, for when *this* component is itself a slot-attached child.
@@ -1881,6 +1884,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (this.usesSearchParams(ir)) {
       lines.push('\t\tSearchParams: in.SearchParams,')
     }
+    lines.push('\t\tBfCallerProps: bfCallerProps,')
 
     const nestedArrayFields = this.propDerivedNestedArrayFields(nestedComponents)
 
@@ -1918,7 +1922,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (this.isNestedArrayShadowed(param, nestedArrayFields)) continue
       const hoisted = propFallbackVars.get(param.name)
       if (hoisted) {
-        lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
+        // #2683: a `collisionWrap` entry means this field is ALSO a
+        // colliding signal's shared field — `hoisted.varName` alone only
+        // carries the coalesced `props.X ?? <lit>` value, so the surrounding
+        // arithmetic (`* 2`, etc.) is composed back on here, giving the
+        // FULLY DERIVED value the signal's own initializer computes. Without
+        // this the field would silently carry just the coalesce result (the
+        // same class of bug this fix addresses, one operator short).
+        const value = hoisted.collisionWrap
+          ? `${hoisted.varName} ${hoisted.collisionWrap.operator} ${hoisted.collisionWrap.operand}`
+          : hoisted.varName
+        lines.push(`\t\t${fieldName}: ${value},`)
       } else {
         const paramDefault = goPropDefault(param.defaultValue)
         const memoFold = memoFallbacks.get(fieldName)
@@ -1948,7 +1962,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (propFieldNames.has(fieldName)) continue
       // `props.X ?? N` reuses the hoisted fallback var so signal and memo share
       // one value.
-      const fallbackMatch = this.extractPropFallback(signal.initialValue, signal.parsed)
+      const fallbackMatch = this.extractPropFallback(signal.initialValue, this.resolvedSignalParsed(signal))
       const hoisted = fallbackMatch ? propFallbackVars.get(fallbackMatch.propName) : undefined
       if (hoisted) {
         lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
@@ -2038,6 +2052,139 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     lines.push('}')
   }
 
+  /**
+   * Build the `bfCallerProps` local (assigned to `BfCallerProps` in the
+   * returned struct) — the hydration-only, caller-supplied-keys-only view
+   * of this component's props (#2684). See the field's doc comment
+   * (`emitPropsStructHeader`) for the two-consumers rationale.
+   *
+   * Three classes, mirroring the issue's taxonomy — gated on `param.optional`
+   * (NOT on the resolved Go type's nillability alone, even though that reads
+   * as the more "obvious" test): a REQUIRED prop must stay unconditional
+   * even when its resolved type happens to be nillable (`ctx: unknown`, the
+   * `array-flatmap-thisarg` fixture passes `ctx: null` explicitly) — Go's
+   * `interface{}` cannot tell "explicit null" from "omitted" once
+   * unmarshaled (both are the nil zero value), so nil-checking a required
+   * field would silently turn an intentional `null` into a dropped key.
+   *   1. Required prop → always included, raw `in.<InputField>` (never the
+   *      defaulted Props-field value — a caller who passes the same value
+   *      as the author's default is indistinguishable from one who didn't,
+   *      but that's inherent to a required prop having no "omitted" state).
+   *   2. Optional prop whose resolved Go type is nillable (`interface{}`,
+   *      `map[string]interface{}`, or any slice `[]T`) → included only
+   *      when `in.<InputField> != nil`, i.e. only when the caller actually
+   *      passed something.
+   *   3. Optional prop that nonetheless resolved to a CONCRETE type (a
+   *      string-union alias like `placement?: 'top' | 'bottom'`, a bare
+   *      scalar never consumed nullish/attr/text/presence-wise, OR a type
+   *      that resolves to `interface{}` some OTHER way — e.g. an inherited
+   *      `extends` clause the analyzer can't fully resolve — while
+   *      `param.optional` itself is, possibly inaccurately, `false`) —
+   *      presence is unknowable from Input alone, so it's included
+   *      unconditionally, same as class 1. A documented residual, not
+   *      silently dropped; see the PR that introduced this method for named
+   *      instances found in the corpus (e.g. `textarea`'s `rows`, inherited
+   *      through `TextareaHTMLAttributes`). Do NOT widen these props' types
+   *      to "fix" this — that's `resolvePropGoType`'s call, not this
+   *      method's, and doing so would risk the same `ctx`-style regression.
+   *
+   * `children` is excluded outright (#1952 — a separately-declared
+   * position, not relitigated here). Rest-props bags are never added to
+   * the Props struct's JSON at all (checked: no field exists for them
+   * outside Input), so nothing to exclude here either — already at parity
+   * with the reference, which never serializes rest keys.
+   *
+   * A prop shadowed by its own driving nested-array field (`isNestedArrayShadowed`
+   * — e.g. `toggleItems` colliding with a `<ToggleItem>` loop's derived
+   * `ToggleItems` field, #2672/#2525) has NO Props/Input field of its own;
+   * the reshaped nested-array local (`varName`, already built above by the
+   * static/dynamic body-wrapper emission) is its only remaining carrier, so
+   * that's what gets keyed in here instead of `in.<InputField>`. KNOWN
+   * RESIDUAL: each item within that array is still the OLD whole-struct
+   * marshal (baked author defaults / null-for-absent / zero-for-required
+   * inside every item) — recursing the sidecar into embedded Props-struct
+   * arrays needs either a generated `MarshalJSON` per Props type or a
+   * runtime array-flattening helper, a bigger surface this method's design
+   * doesn't cover. Reported, not chased (see PR description).
+   */
+  private emitCallerPropsInit(
+    lines: string[],
+    ir: ComponentIR,
+    nestedComponents: NestedComponentInfo[],
+    staticWithoutBody: NestedComponentInfo[],
+    staticWithBody: NestedComponentInfo[],
+    dynamicWithBody: NestedComponentInfo[],
+    emittedWrapperVars: Set<string>,
+    propTypeOverrides: Map<string, string>,
+  ): void {
+    lines.push('\tbfCallerProps := map[string]interface{}{}')
+    const bfCallerPropsTakenTags = new Set<string>()
+    const nestedArrayFields = this.propDerivedNestedArrayFields(nestedComponents)
+
+    for (const param of ir.metadata.propsParams) {
+      // Children are DOM content, not hydration data (#1952) — excluded the
+      // same way `emitPropsDataFields` excludes them from the Props struct.
+      if (param.name === 'children') continue
+      // Shadowed by its own driving nested-array field (#2672/#2525) — no
+      // Input field exists for it at all; handled below via the array local.
+      if (this.isNestedArrayShadowed(param, nestedArrayFields)) continue
+      // Same tag algorithm `emitPropsDataFields` uses for the Props field's
+      // own `json:"…"` tag, re-derived against a FRESH set: props are always
+      // processed first, in the same order, over an empty set in BOTH
+      // places, so the two computations can't disagree.
+      const callerKey = this.claimJsonTag(this.toJsonTag(param.sourceName ?? param.name), bfCallerPropsTakenTags)
+      if (callerKey === '-') continue // tag collision — dropped from the wire, same as the Props field itself would be
+      const inputField = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
+      const goType = resolvePropGoType(this.emitCtx, param, propTypeOverrides)
+      const isNillable = goType === 'interface{}' || goType === 'map[string]interface{}' || goType.startsWith('[]')
+      // `param.optional` gates the branch (not "isNillable alone") because a
+      // REQUIRED prop must stay unconditional even when its resolved type
+      // happens to be nillable (`ctx: unknown`, #2094's array-flatmap-thisarg
+      // fixture passes `ctx: null` explicitly) — Go's `interface{}` cannot
+      // tell "explicit null" from "omitted" once unmarshaled (both are the
+      // nil zero value), so a nil-check here would silently turn an
+      // intentional `null` into a dropped key, regressing a fixture that
+      // matched the reference before this method existed. `resolvePropGoType`
+      // never applies its nillable flip to a required prop, so this ONLY
+      // affects the rare case where a type resolves to `interface{}` some
+      // OTHER way (e.g. `unknown`, or a type inherited through an
+      // unresolved external `extends` clause) while `param.optional` is
+      // (accurately or not) false — see the method docstring's residual list.
+      if (param.optional && isNillable) {
+        lines.push(`\tif ${inputField} != nil {`)
+        lines.push(`\t\tbfCallerProps["${callerKey}"] = ${inputField}`)
+        lines.push(`\t}`)
+      } else {
+        // Required (class 1), or optional-but-concrete residual (class 3),
+        // or optional-but-misresolved-required residual — see docstring.
+        lines.push(`\tbfCallerProps["${callerKey}"] = ${inputField}`)
+      }
+    }
+
+    // Shadowed nested-array props — see method docstring.
+    for (const nested of [...staticWithoutBody, ...staticWithBody, ...dynamicWithBody]) {
+      if (!nested.isPropDerived) continue
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      const isBuilt = staticWithoutBody.includes(nested) || emittedWrapperVars.has(varName)
+      if (!isBuilt) continue
+      const arrayFieldName = capitalizeFieldName(`${nested.name}s`)
+      const param = ir.metadata.propsParams.find(
+        p => capitalizeFieldName(p.name) === arrayFieldName || capitalizeFieldName(p.sourceName ?? p.name) === arrayFieldName,
+      )
+      if (!param || !this.isNestedArrayShadowed(param, nestedArrayFields)) continue
+      const callerKey = this.claimJsonTag(this.toJsonTag(param.sourceName ?? param.name), bfCallerPropsTakenTags)
+      if (callerKey === '-') continue
+      if (param.optional) {
+        lines.push(`\tif in.${nested.name}s != nil {`)
+        lines.push(`\t\tbfCallerProps["${callerKey}"] = ${varName}`)
+        lines.push(`\t}`)
+      } else {
+        lines.push(`\tbfCallerProps["${callerKey}"] = ${varName}`)
+      }
+    }
+    lines.push('')
+  }
+
   private emitStaticChildInstances(lines: string[], ir: ComponentIR): void {
     const staticChildren = this.collectStaticChildInstances(ir.root, ir.metadata.propsParams)
     for (const child of staticChildren) {
@@ -2741,6 +2888,24 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (this.usesSearchParams(ir)) {
       lines.push('\tSearchParams bf.SearchParams `json:"-"`')
     }
+
+    // #2684: the raw, CALLER-SUPPLIED view of this component's props —
+    // populated by `NewXxxProps` with exactly the keys the caller passed
+    // (required props always; optional ones only when not nil), holding
+    // the UNDEFAULTED value. This exists because every prop field above
+    // (e.g. `X`) serves TWO different consumers that want two different
+    // values: the Go TEMPLATE wants the DEFAULTED value so `{{.X}}` renders
+    // the author's fallback, while the HYDRATION PAYLOAD wants to know only
+    // what the caller actually supplied — baking the author's default into
+    // it makes an omitted prop indistinguishable from one explicitly passed
+    // with that value, and a Go zero value indistinguishable from an
+    // explicit zero/empty/false (the reference, Hono, only ever serializes
+    // caller-passed keys). One field can't answer both questions at once,
+    // so this sidecar gives the hydration payload its own carrier;
+    // `BfPropsAttr` (runtime/bf.go) marshals THIS map instead of the whole
+    // struct when it's present. `json:"-"` — never marshaled as an ordinary
+    // struct field; `BfPropsAttr` reads it directly by name via reflection.
+    lines.push('\tBfCallerProps map[string]interface{} `json:"-"`')
   }
 
   private emitPropsDataFields(
@@ -2782,7 +2947,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (signal.envReader) continue
       const fieldName = capitalizeFieldName(signal.getter)
       if (propFieldNames.has(fieldName)) continue
-      const jsonTag = this.claimJsonTag(this.toJsonTag(signal.getter), takenJsonTags)
+      // Signal fields are component-internal state, not caller input (#2672):
+      // the client never reads `_p.<signalGetter>` — it re-derives the value
+      // from `createSignal(...)`'s own initial expression (which itself reads
+      // whatever PROP field seeded it, already emitted above with a real tag
+      // by the propsParams loop). Excluding the signal field from JSON stops
+      // it from co-boarding into `bf-p` while leaving `{{.Field}}` SSR access
+      // untouched — Go template field access doesn't consult json tags.
+      const jsonTag = '-'
       // A synthesised struct type wins outright — the signal is an untyped
       // object array we gave a concrete element type.
       const synthType = this.state.synthStructTypes.get(signal.getter)
@@ -2832,7 +3004,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     for (const memo of ir.metadata.memos) {
       const fieldName = capitalizeFieldName(memo.name)
       if (propFieldNames.has(fieldName)) continue
-      const jsonTag = this.claimJsonTag(this.toJsonTag(memo.name), takenJsonTags)
+      // Memo fields are derived, re-computed client-side from the same prop
+      // reads the memo body itself performs — never read as `_p.<memoName>`
+      // (#2672). Same rationale as the signal fields above.
+      const jsonTag = '-'
       const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap)
       lines.push(`\t${fieldName} ${goType} \`json:"${jsonTag}"\``)
     }
@@ -2868,10 +3043,27 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       ...ir.metadata.memos.map(m => capitalizeFieldName(m.name)),
     ])
     for (const c of this.nonCollidingContextConsumers(takenProps)) {
-      const jsonTag = this.claimJsonTag(this.toJsonTag(c.localName), takenJsonTags)
+      // Context-consumer fields are resolved server-side from the enclosing
+      // `Provider` and read via `{{.Field}}` in SSR only — the client's own
+      // `useContext` re-reads the DOM-scoped provider value at hydration
+      // time, never `_p.<contextField>` (#2672).
+      const jsonTag = '-'
       lines.push(`\t${this.contextFieldName(c)} ${this.contextConsumerGoType(c)} \`json:"${jsonTag}"\``)
     }
 
+    // Capitalized Go field names of every declared prop — BOTH the LOCAL
+    // binding and the caller-facing (`sourceName`) spelling, unioned the
+    // same way `isNestedArrayShadowed` does for the propsParams loop above
+    // (an aliased destructure like `{ rows: items }` can collide under
+    // either naming depending on alias direction — see the #2525 collision
+    // tests). Used below to detect when a nested-array field's name
+    // collides with (and shadows) an actual prop field.
+    const propDrivingFieldNames = new Set<string>()
+    for (const p of ir.metadata.propsParams) {
+      propDrivingFieldNames.add(capitalizeFieldName(p.name))
+      propDrivingFieldNames.add(capitalizeFieldName(p.sourceName ?? p.name))
+    }
+
     for (const nested of nestedComponents) {
       // An orphaned clientOnly nested loop (#2627 — see
       // `isOrphanedClientOnlyNested`) gets NO Props field at all, not even
@@ -2889,8 +3081,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (nested.isDynamic && !nested.isPropDerived) {
         // Dynamic signal-array loops are template-only.
         lines.push(`\t${nested.name}s []${elemType} \`json:"-"\``)
+      } else if (
+        nested.isDynamic &&
+        nested.isPropDerived &&
+        !propDrivingFieldNames.has(`${nested.name}s`)
+      ) {
+        // Prop-derived dynamic loops (`props.items.map(item => <Child/>)`,
+        // #2672): this field is USUALLY a RE-SHAPED COPY of the driving prop,
+        // built for SSR's `{{range}}` — not the prop itself. The client's own
+        // `mapArray` re-derives every row straight from the real prop field
+        // (`_p.items`, emitted with a real tag by the propsParams loop
+        // above), never from `_p.<Name>s`, so co-boarding this copy into
+        // `bf-p` is redundant component-internal derivation, same as a memo.
+        //
+        // EXCEPT when the two Go field names collide (`propDrivingFieldNames`
+        // — mirrors `isNestedArrayShadowed`'s check the propsParams loop
+        // itself runs): a prop named `toggleItems` driving a `<ToggleItem>`
+        // loop capitalizes to the SAME Go field name as the nested-array
+        // field (`ToggleItems`), so `emitPropsDataFields` shadows the prop's
+        // OWN field entirely and this array field is the ONLY carrier of
+        // that prop's data. Flipping it there would silently drop caller
+        // input from `bf-p` instead of merely trimming a redundant copy —
+        // the `else` branch below keeps a real tag for exactly that case.
+        lines.push(`\t${nested.name}s []${elemType} \`json:"-"\``)
       } else {
-        // Static + prop-derived arrays go in JSON so the client can hydrate.
+        // Static arrays go in JSON so the client can hydrate (that data can
+        // be non-literal, request-time Input the caller supplies with no
+        // prop-field twin to fall back on) — and so does a prop-derived
+        // dynamic array whose field name shadows its own driving prop's
+        // field (the `propDrivingFieldNames` case above): this field is
+        // that prop's ONLY remaining carrier in the struct.
         const jsonTag = this.claimJsonTag(
           this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`),
           takenJsonTags,
@@ -2906,9 +3126,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     // Top-level intrinsic-element spreads: each gets a `Spread_<slotId>
     // map[string]any` field the template reads via `{{bf_spread_attrs}}`.
-    // Loop-internal spreads emit inline and don't appear here.
+    // Loop-internal spreads emit inline and don't appear here. SSR-only —
+    // the resolved attrs are already baked into the rendered HTML, and no
+    // client runtime reads `_p.Spread_<slotId>` back out of `bf-p` (#2672).
     for (const slot of spreadSlots) {
-      const jsonTag = this.claimJsonTag(this.toJsonTag(slot.slotId), takenJsonTags)
+      const jsonTag = '-'
       lines.push(`\t${slot.slotId} map[string]any \`json:"${jsonTag}"\``)
     }
   }
@@ -3531,7 +3753,32 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     const propTypeOverrides = buildPropTypeOverrides(this.emitCtx, ir)
     for (const signal of ir.metadata.signals) {
-      const match = this.extractPropFallback(signal.initialValue, signal.parsed)
+      let match = this.extractPropFallback(signal.initialValue, this.resolvedSignalParsed(signal))
+      // #2683: the idempotent fold above declines a non-idempotent
+      // derivation (`(props.count ?? 1) * 2`) at the top level. When that
+      // signal's Go field name COLLIDES with the prop's own field — the
+      // exact condition under which the props-field loop below would
+      // otherwise silently drop the derivation and emit the raw prop
+      // instead — fall back to the collision-derivation matcher so the
+      // coalesced value still gets hoisted; the props-field loop composes
+      // the surrounding arithmetic back on top of it (`collisionWrap`).
+      // Gated strictly on the collision so a differently-named signal
+      // deriving from the same prop (not colliding) is untouched — that
+      // path's own dedicated field keeps today's behavior byte-for-byte.
+      let collisionWrap: { operator: string; operand: string } | undefined
+      if (!match) {
+        const collision = this.extractCollisionDerivation(this.resolvedSignalParsed(signal))
+        if (collision) {
+          const collisionParam = ir.metadata.propsParams.find(p => p.name === collision.propName)
+          const collisionField = collisionParam
+            ? capitalizeFieldName(collisionParam.sourceName ?? collision.propName)
+            : null
+          if (collisionField && capitalizeFieldName(signal.getter) === collisionField) {
+            match = { propName: collision.propName, goFallback: collision.goFallback }
+            collisionWrap = { operator: collision.operator, operand: collision.operand }
+          }
+        }
+      }
       if (!match) continue
       if (result.has(match.propName)) continue
       const param = ir.metadata.propsParams.find(p => p.name === match.propName)
@@ -3591,11 +3838,23 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         goFallback: match.goFallback,
         zeroLiteral,
         ...(nullishLowered ? { assertType: concreteType } : {}),
+        ...(collisionWrap ? { collisionWrap } : {}),
       })
     }
     return result
   }
 
+  /**
+   * Resolve a signal's initializer through the SSR seed plan's const-hop
+   * inlining (#2685) before prop-fallback extraction — see
+   * {@link resolveSignalParsedThroughSeedPlan} (shared with
+   * `collectNullishConsumedPropNames`'s signal-seed loop, the single door
+   * both consumers of this resolution go through).
+   */
+  private resolvedSignalParsed(signal: { getter: string; parsed?: ParsedExpr }): ParsedExpr | undefined {
+    return resolveSignalParsedThroughSeedPlan(this.state, signal)
+  }
+
   /**
    * Parse a signal-time initial value of the form `props.X ?? <literal>` —
    * or, for destructured components, `x ?? <literal>` — into the source prop
@@ -3674,6 +3933,67 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return { propName, goFallback }
   }
 
+  /**
+   * #2683: match a signal's collision-derivation shape — `(props.X ?? <lit>)
+   * <op> <int>` — the ONE non-idempotent shape this adapter faithfully lowers
+   * when a signal's Go field name collides with its own prop's field (see the
+   * collision-override loop in `collectPropFallbackVars` / the props-field
+   * loop in `generateNewPropsFunction`). Composes two ALREADY-EXISTING
+   * lowerings instead of adding a third: `extractPropFallbackFromParsed`
+   * recognizes the embedded `props.X ?? <lit>` presence check exactly as it
+   * does for the idempotent fold, and the wrap mirrors the SAME `<ref> <op>
+   * <int>` arithmetic shape `memoInitialFromParsedBody`'s multiply-family
+   * branch already supports for a bare `props.X <op> N` (non-negative
+   * integer operand only, matching that branch's own restriction).
+   *
+   * Returns null for any other shape — the caller then keeps today's
+   * raw-passthrough behavior (sound-or-loud; the remaining #2683 pin, if
+   * any, covers whatever this doesn't reach).
+   */
+  private extractCollisionDerivation(
+    parsed: ParsedExpr | undefined,
+  ): { propName: string; goFallback: string; operator: string; operand: string } | null {
+    if (!parsed || parsed.kind !== 'binary') return null
+    if (!['*', '+', '-', '/'].includes(parsed.op)) return null
+    const { right } = parsed
+    if (
+      right.kind !== 'literal' ||
+      right.literalType !== 'number' ||
+      typeof right.value !== 'number' ||
+      !Number.isInteger(right.value) ||
+      right.value < 0
+    ) {
+      return null
+    }
+    // Constant division by zero is a Go COMPILE error (`invalid operation:
+    // division by zero`), unlike JS's Infinity — declining keeps that shape
+    // on the raw-passthrough path instead of breaking the build.
+    if (parsed.op === '/' && right.value === 0) return null
+    // The `??` fallback itself must be a NUMERIC literal before delegating
+    // to the fold: `extractPropFallbackFromParsed` happily matches a string
+    // fallback (`(props.label ?? 'x') + 2`), which would hoist
+    // `var label string = "x"` and emit `Label: label + 2,` — invalid Go
+    // (string + int), a compile break where the pre-existing behavior at
+    // least built (Copilot review on #2694). JS's `'x' + 2` is string
+    // concatenation besides, so a numeric compose could never be faithful
+    // for it — the shape belongs on the raw-passthrough path until someone
+    // lowers it through ConcatStr deliberately. Gating on `??` (not `||`)
+    // also keeps JS nullish semantics exact for numeric props, where a
+    // caller's explicit `0` must NOT trigger the fallback.
+    const coalesce = parsed.left
+    if (
+      coalesce.kind !== 'logical' ||
+      coalesce.op !== '??' ||
+      coalesce.right.kind !== 'literal' ||
+      coalesce.right.literalType !== 'number'
+    ) {
+      return null
+    }
+    const inner = this.extractPropFallbackFromParsed(parsed.left)
+    if (!inner) return null
+    return { ...inner, operator: parsed.op, operand: String(right.value) }
+  }
+
   /**
    * Extract the prop name from a signal's `props.xxx`-pattern initialValue,
    * e.g. `"props.initial ?? 0"` → `"initial"`, `"props.checked"` → `"checked"`.

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

@@ -22,6 +22,7 @@ import type {
   IRNode,
   LoweringMatcher,
   MemoInfo,
+  ParsedExpr,
   SsrSeedPlan,
   TypeDefinition,
   TypeInfo,
@@ -262,3 +263,36 @@ export class CompileState {
    *  `strings` is added to the generated types file's import block. */
   needsStringsImport = false
 }
+
+/**
+ * Resolve a signal's initializer through the SSR seed plan's const-hop
+ * inlining (#2685, `resolveThroughLocalConsts` in
+ * `packages/jsx/src/ssr-seed-plan.ts`) before prop-fallback shape matching,
+ * so a component-scope `const` sitting between a `props.X` read and
+ * `createSignal` (`const mid = props.label; createSignal(mid ?? 'Default')`)
+ * doesn't hide the `props.X ?? <literal>` shape from
+ * `extractPropFallbackFromParsed` / `collectNullishConsumedPropNames`'s
+ * signal-seed loop — both need the SAME resolved tree (single door, not two
+ * divergent walks: a mismatch between them is exactly what let the field-type
+ * flip and the fallback-var construction disagree on nullish handling for
+ * the const-hop shape).
+ *
+ * Falls back to the signal's own `parsed` when the plan didn't classify this
+ * signal `derived` (opaque for an unrelated reason, e.g. a free identifier
+ * genuinely out of scope) — never invents a substitution the plan itself
+ * didn't make.
+ *
+ * `signal` takes the minimal structural shape (not the internal `SignalInfo`
+ * type, which `@barefootjs/jsx`'s public index doesn't export — the same
+ * inline-shape convention `memo-compute.ts`'s extracted helpers already use
+ * for signal params).
+ */
+export function resolveSignalParsedThroughSeedPlan(
+  state: CompileState,
+  signal: { getter: string; parsed?: ParsedExpr },
+): ParsedExpr | undefined {
+  const step = state.ssrSeedPlan.steps.find(
+    s => s.kind === 'derived' && s.origin === 'signal' && s.name === signal.getter,
+  )
+  return step?.kind === 'derived' ? step.parsed : signal.parsed
+}

package/src/adapter/lib/types.ts

@@ -167,6 +167,16 @@ export interface PropFallbackVar {
    * distinguishable from an absent one.
    */
   assertType?: string
+  /**
+   * #2683: set when this fallback var was hoisted from a signal's
+   * COLLISION-DERIVATION initializer (`(props.X ?? <lit>) <op> <int>`, where
+   * the signal's Go field name collides with prop X's) rather than a plain
+   * `props.X ?? <lit>`. `varName` above still holds only the coalesced RAW
+   * value (the presence-check declaration is unchanged) — this records the
+   * arithmetic wrap the props-field loop applies ON TOP of it so the shared
+   * field carries the FULLY DERIVED value, not just the coalesce result.
+   */
+  collisionWrap?: { operator: string; operand: string }
 }
 
 /**

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

@@ -9,6 +9,8 @@ import type { ComponentIR, IRMetadata, IRNode, ParsedExpr } from '@barefootjs/js
 import { isBooleanAttr } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
+import { resolveSignalParsedThroughSeedPlan } from '../lib/compile-state.ts'
+import { capitalizeFieldName } from '../lib/go-naming.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 
 /**
@@ -218,7 +220,36 @@ export function collectNullishConsumedPropNames(ctx: GoEmitContext, ir: Componen
   // tree — reuse the seam's existing `props.X ?? <literal>` recognizer. The
   // zero-equivalent exclusion matches on the Go-formatted fallback literal.
   for (const signal of ir.metadata.signals) {
-    const match = ctx.extractPropFallback(signal.initialValue, signal.parsed)
+    // Resolved through the seed plan's const-hop inlining (#2685) — see
+    // `resolveSignalParsedThroughSeedPlan` — so a component-scope `const`
+    // between `props.X` and `createSignal` doesn't leave this loop and
+    // `collectPropFallbackVars`'s identical extraction disagreeing on
+    // whether the prop needs the nillable flip.
+    const resolvedParsed = resolveSignalParsedThroughSeedPlan(ctx.state, signal)
+    let match = ctx.extractPropFallback(signal.initialValue, resolvedParsed)
+    // #2683: the idempotent fold above declines a non-idempotent derivation
+    // (`(props.count ?? 1) * 2`) at the top level. When that signal's Go
+    // field name COLLIDES with the prop's own field, the props-struct
+    // emitter composes the derivation onto the SHARED field (see
+    // `collectPropFallbackVars`'s identical collision gate) — which needs
+    // the SAME nillable flip an ordinary `??` fallback gets, so an absent
+    // prop (nil) stays distinguishable from an explicit zero-equivalent
+    // value. Gated strictly on the collision, matching that other site, so
+    // a differently-named signal deriving from the same prop (not
+    // colliding — its own dedicated field, untouched by this fix) doesn't
+    // spuriously flip the prop's type.
+    if (!match) {
+      const collision = ctx.extractCollisionDerivation(resolvedParsed)
+      if (collision) {
+        const collisionParam = ir.metadata.propsParams.find(p => p.name === collision.propName)
+        const collisionField = collisionParam
+          ? capitalizeFieldName(collisionParam.sourceName ?? collision.propName)
+          : null
+        if (collisionField && capitalizeFieldName(signal.getter) === collisionField) {
+          match = { propName: collision.propName, goFallback: collision.goFallback }
+        }
+      }
+    }
     if (!match || !optionalParams.has(match.propName)) continue
     const f = match.goFallback
     if (f === '""' || f === 'false' || f === 'nil' || Number(f) === 0) continue

package/src/render-divergences.ts

@@ -6,13 +6,13 @@
  * file even when the set is empty — the next divergence lands here, not in
  * a re-created file.
  *
- * Empty — #2630's `static-array-from-props-with-component-precomputed`
- * divergence graduated once the harness (`test-render.ts`'s
+ * (#2630's `static-array-from-props-with-component-precomputed` divergence
+ * graduated once the harness (`test-render.ts`'s
  * `buildDynamicChildLoopSeeding`, despite the name — see its doc comment)
  * learned to seed a prop-backed static child-component loop's Props slice
  * the same way it already seeded a signal-backed dynamic one: the adapter's
  * own `emission` was never the bug, only this harness's route-handler
- * stand-in was missing the prop-derived case.
+ * stand-in was missing the prop-derived case.)
  */
 
 import type { RenderDivergences } from '@barefootjs/jsx'

package/src/test-render.ts

@@ -914,11 +914,28 @@ function goSliceElemType(
  * `[]any{…}`/`map[string]interface{}{…}` for that field no longer compiles
  * against it the way it always did against the old `map[string]interface{}`
  * element type.
+ *
+ * An ARRAY element (`elemType` itself starting with `[]`, i.e. the field is
+ * doubly-nested — `Rows [][]int`) recurses with the INNER element type
+ * (`int`) instead of falling to `goArrayLiteralFromArray`'s generic
+ * `[]any{…}` — #2677 widened the analyzer's destructured-parameter gate to
+ * resolve a nested-array prop (`{ rows }: { rows: number[][] }`) to a real
+ * `[][]int` field (previously `unknown` → `interface{}` → `[]any`, which
+ * `goArrayLiteralFromArray`'s untyped literal always compiled against fine).
+ * Without this, the harness's OWN convenience literal-builder — not the
+ * production adapter's `typeInfoToGo`, which already recurses correctly —
+ * bakes `[]any{1, 2}` for a `[1, 2]` row, and `[][]int{[]any{1, 2}, …}`
+ * fails to compile against the now-concrete field.
  */
 function goTypedSliceLiteralFromArray(arr: unknown[], elemType: string, goTypes?: string): string {
   const entries = arr.map(v => {
     if (v instanceof Date) return goStringLit(v.toISOString())
-    if (v && typeof v === 'object' && !Array.isArray(v)) {
+    if (Array.isArray(v)) {
+      return elemType.startsWith('[]')
+        ? goTypedSliceLiteralFromArray(v, elemType.slice(2), goTypes)
+        : goArrayLiteralFromArray(v)
+    }
+    if (v && typeof v === 'object') {
       return goStructLiteral(v as Record<string, unknown>, elemType, goTypes)
     }
     if (typeof v === 'string') return `"${v.replace(/"/g, '\\"')}"`