@barefootjs/go-template 0.31.10 → 0.33.0

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

@@ -58,6 +58,7 @@ import {
   asCallbackMethodCall,
   sortComparatorFromArrow,
   emitParsedExpr,
+  groupObjectLiteralSegments,
   emitIRNode,
   emitAttrValue,
   augmentInheritedPropAccesses,
@@ -255,6 +256,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),
   }
 
@@ -1369,6 +1371,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (el.kind !== 'object-literal') return null
       const seen = new Set<string>()
       for (const prop of el.properties) {
+        // A spread (`{ ...t, a: 1 }`, #2696 Step 2) isn't a plain per-key
+        // scalar shape this fast path bakes — fall back (the caller's
+        // `ts.createSourceFile` path, or refusal) rather than mis-baking.
+        if (prop.kind === 'spread') return null
         if (prop.shorthand) return null
         const key = prop.key
         if (!GO_IDENTIFIER.test(key)) return null
@@ -1873,6 +1879,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 +1889,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 +1927,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)
@@ -2038,6 +2057,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 +2893,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(
@@ -3236,6 +3406,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (parsed.kind !== 'object-literal') return null
     const entries: string[] = []
     for (const prop of parsed.properties) {
+      // A spread (`{ ...t }`, #2696 Step 2) isn't a per-key member this Go
+      // struct-literal lowering can express — fail the whole value, same as
+      // any other unsupported member (the consumer keeps its default).
+      if (prop.kind === 'spread') return null
       if (prop.shorthand) return null
       const goVal = this.lowerProviderMapMemberValue(prop.value, propsParams)
       if (goVal === null) return null
@@ -3588,7 +3762,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, this.resolvedSignalParsed(signal))
+      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)
@@ -3648,6 +3847,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         goFallback: match.goFallback,
         zeroLiteral,
         ...(nullishLowered ? { assertType: concreteType } : {}),
+        ...(collisionWrap ? { collisionWrap } : {}),
       })
     }
     return result
@@ -3742,6 +3942,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"`.
@@ -4739,12 +5000,33 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `bf_arr ${parts.join(' ')}`
   }
 
-  objectLiteral(_properties: ObjectLiteralProperty[], raw: string, _emit: (e: ParsedExpr) => string): string {
-    // The shared `isSupported` gate now admits an EMPTY object literal
-    // (`?? {}`) as `??`'s right operand (expression-parser.ts, `logical`
-    // case) — every other adapter has a native `{}` dict/hashref literal to
-    // emit here, but `text/template` has none, so this dispatcher is the
-    // one place left to refuse the shape. Unlike the sibling adapters, Go
+  objectLiteral(properties: ObjectLiteralProperty[], raw: string, emit: (e: ParsedExpr) => string): string {
+    // A POPULATED literal is reachable here only in VALUE position (a
+    // `.map()` receiver/callback body, an array-literal element, …) —
+    // `isSupportedValue` admits it when every property value is itself
+    // supported (expression-parser.ts, `checkSupport`'s `pos` parameter).
+    // `text/template` has no map-literal syntax, so lower through the
+    // variadic `bf_map` runtime helper (the object counterpart of
+    // `arrayLiteral`'s `bf_arr`) instead of trying to spell a literal.
+    if (properties.length > 0) {
+      const wrap = (rendered: string) => (rendered.includes(' ') ? `(${rendered})` : rendered)
+      const literalOf = (run: readonly Extract<ObjectLiteralProperty, { kind: 'prop' }>[]) =>
+        `bf_map ${run.map(p => `"${escapeGoString(p.key)}" ${wrap(emit(p.value))}`).join(' ')}`
+      if (!properties.some(p => p.kind === 'spread')) {
+        return literalOf(properties as Extract<ObjectLiteralProperty, { kind: 'prop' }>[])
+      }
+      // Spread (`{ ...t, editing: false }`, #2696 Step 2): `bf_merge`
+      // (runtime/eval.go, a `bf_map` sibling) is a variadic, null-safe map
+      // merge — a non-map argument (nil included) is skipped rather than
+      // panicking, matching JS's null/undefined-spread no-op — folding
+      // every segment (a `bf_map` run, or a spread's own emitted value) in
+      // ONE call, later segments winning, exactly JS spread's semantics.
+      const segments = groupObjectLiteralSegments(properties, literalOf, e => wrap(emit(e)))
+      return `bf_merge ${segments.join(' ')}`
+    }
+    // The EMPTY object literal (`?? {}`) reaches here as `??`'s right
+    // operand (expression-parser.ts, `logical` case) — a RENDERED-position
+    // admission, not a value-position one. Unlike the sibling adapters, Go
     // can't silently fall back to a safe sentinel text: `this.unsupported`'s
     // `[UNSUPPORTED: …]` marker would be spliced into a Go template action
     // (e.g. as an `or`/`and` operand) and break template parsing, and the
@@ -6054,7 +6336,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // (icon registries, variant/size class maps), so this fully covers them.
     const carried = constInfo.parsed
     if (carried?.kind === 'object-literal') {
-      const hit = carried.properties.find(prop => prop.key === key)
+      // A spread entry (`{ ...t }`, #2696 Step 2) has no static key to match
+      // against — skip it, same as before this kind existed (a record const
+      // containing spread already couldn't reach here as a whole).
+      const hit = carried.properties.find(
+        (prop): prop is Extract<ObjectLiteralProperty, { kind: 'prop' }> => prop.kind === 'prop' && prop.key === key,
+      )
       if (hit && hit.value.kind === 'literal') {
         if (hit.value.literalType === 'string') return JSON.stringify(hit.value.value)
         if (hit.value.literalType === 'number') return hit.value.raw ?? String(hit.value.value)

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/memo/memo-compute.ts

@@ -592,6 +592,17 @@ export function memoInitialFromParsedBody(
     if (concatGo !== null) return concatGo
   }
 
+  // () => <object>.map(cb).join(sep) as the memo's WHOLE body (no `+`
+  // concatenation) — `map-object-literal-body`'s `ids` memo: `rows().map(t
+  // => ({ id: t.id, done: false })).map(r => r.id).join(',')`. The `+`-chain
+  // arm above only reaches `matchMapJoinChain` as ONE leaf of a
+  // concatenation; a bare chain memo never entered it (#2696 review).
+  const bareChain = matchMapJoinChain(body)
+  if (bareChain) {
+    const chainGo = mapJoinChainToGo(ctx, bareChain, signals, propsParams, propFallbackVars)
+    if (chainGo !== null) return chainGo
+  }
+
   return null
 }
 
@@ -954,7 +965,7 @@ export function collectPropsReadByCtorInit(
         e.elements.forEach(el => visit(el, bound))
         return
       case 'object-literal':
-        for (const p of e.properties) visit(p.value, bound)
+        for (const p of e.properties) visit(p.kind === 'spread' ? p.expr : p.value, bound)
         return
       case 'array-method':
         visit(e.object, bound)

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

@@ -181,6 +181,9 @@ export function computeObjectMemoInitialValue(
   const env: CtorLowerEnv = { searchParamsVars: new Set(), params: new Map() }
   const entries: string[] = []
   for (const prop of retObj.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no per-key `.Params.<Field>`
+    // accessor to match against — bail, same as any other unsupported shape.
+    if (prop.kind === 'spread') return null
     // Bail on a shorthand property (`return { tag }`): its value is a bare
     // identifier whose name need not match a `.Params.<Field>` accessor.
     if (prop.shorthand) return null

package/src/adapter/memo/template-interp.ts

@@ -200,6 +200,11 @@ function recordIndexInterpolationToGo(
 
   const entries: { key: string; value: { kind: 'number' | 'string'; text: string } }[] = []
   for (const prop of parsedConst.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key/value pair this
+    // record-index lowering can bake — bail, same as any other unsupported
+    // member (a record const containing spread already couldn't reach here
+    // as a whole before this kind existed).
+    if (prop.kind === 'spread') return null
     const v = prop.value
     if (v.kind === 'literal' && v.literalType === 'number') {
       entries.push({ key: prop.key, value: { kind: 'number', text: v.raw ?? String(v.value) } })

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

@@ -10,6 +10,7 @@ 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'
 
 /**
@@ -224,7 +225,31 @@ export function collectNullishConsumedPropNames(ctx: GoEmitContext, ir: Componen
     // 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 match = ctx.extractPropFallback(signal.initialValue, resolveSignalParsedThroughSeedPlan(ctx.state, signal))
+    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/adapter/spread/spread-codegen.ts

@@ -143,6 +143,10 @@ function parsedObjectLiteralToGoMap(parsed: ParsedExpr | undefined): string | nu
   if (!parsed || parsed.kind !== 'object-literal') return null
   const entries: string[] = []
   for (const prop of parsed.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key/value pair this
+    // conservative Go-map bake can express — bail, same as any other
+    // unsupported shape.
+    if (prop.kind === 'spread') return null
     // Reject a numeric key (`{ 1: 'a' }`); `keyKind` distinguishes it from a
     // string `'1'` key.
     if (prop.keyKind === 'numeric') return null
@@ -386,6 +390,10 @@ function objectLiteralToGoSpreadMap(
 ): string | null {
   const entries: string[] = []
   for (const prop of obj.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) isn't a per-key entry this
+    // conditional-spread inline lowering can express — bail (the docstring
+    // already declares spread out-of-scope for this function).
+    if (prop.kind === 'spread') return null
     // Shorthand (`{ describedBy }`) is unsupported.
     if (prop.shorthand) return null
     // Reject a numeric key (`{ 1: x }`); `keyKind` distinguishes it from a

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

@@ -63,6 +63,9 @@ function bakeInlineObjectAsGoMap(ctx: GoEmitContext, expr: ParsedExpr): string |
   if (expr.kind !== 'object-literal') return null
   const entries: string[] = []
   for (const prop of expr.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key to bake as a Go
+    // map entry — bail, same as any other unsupported shape.
+    if (prop.kind === 'spread') return null
     if (prop.shorthand) return null
     const go =
       prop.value.kind === 'object-literal'
@@ -150,6 +153,10 @@ export function parsedLiteralToGo(
     if (!structFields) return null
     const entries: string[] = []
     for (const prop of expr.properties) {
+      // A spread (`{ ...t }`, #2696 Step 2) has no static key to match a
+      // struct field against — defer the whole object, same as any other
+      // unsupported shape.
+      if (prop.kind === 'spread') return null
       // A shorthand `{ a }` carries an identifier value → lowers to null below
       // and defers the whole object.
       const goField = structFields.get(prop.key)