@barefootjs/go-template 0.29.0 → 0.30.2

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

@@ -133,7 +133,7 @@ import { typeInfoToGo } from "./type/type-codegen.ts"
 import { isBooleanMemo, isListFilterMemo, isStringTernaryMemo } from "./memo/memo-type.ts"
 import { lowerCtorExpr } from "./memo/ctor-lowering.ts"
 import { resolveBlockBodyMemoModuleConst } from "./memo/memo-value.ts"
-import { computeMemoInitialValue, computeMemoInitialValueOrNull, filterArmEarlierSiblingRefs } from "./memo/memo-compute.ts"
+import { computeMemoInitialValue, computeMemoInitialValueOrNull, filterArmEarlierSiblingRefs, collectPropsReadByCtorInit } from "./memo/memo-compute.ts"
 import { collectSpreadSlots, buildSpreadInitializer } from "./spread/spread-codegen.ts"
 import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames, collectNullishConsumedPropNames, collectOmittableAttrConsumedPropNames, collectTextConsumedPropNames, collectPresenceCheckedPropNames, NULLISH_SCALAR_GO_TYPES } from "./props/prop-types.ts"
 import { collectStringValueNames } from "./props/prop-classes.ts"
@@ -155,6 +155,23 @@ type HigherOrderShape = {
   predicate: ParsedExpr
 }
 
+/**
+ * Everything needed to emit a component's #2448 props rebuilder, captured when
+ * its own types are generated so a PARENT can emit the registration into its
+ * own type block (`emitOwnedReprops`). `params` are this component's own
+ * Input fields — since #2457, the PARENT (`loopRowChildPropOverrides`, via
+ * `childPropFieldNames`) already resolves the JSX attribute name to the
+ * child's own field name before emitting the call, so the switch this spec
+ * drives is keyed by that one name on both sides; there is no longer a
+ * separate "wire" name to carry (an aliased destructure used to make the
+ * parent's JSX-attribute name and the child's field name differ — `"N"` vs
+ * `Count` — and this spec used to carry both).
+ */
+type RepropsSpec = {
+  params: string[]
+  usesSearchParams: boolean
+}
+
 /**
  * String-returning array/string methods. `.get(...)` stays a generic `call`;
  * the rest fold into `array-method`. Module-level so `isStringExpr` (which
@@ -441,6 +458,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.state.pendingChildrenDefines = []
     this.primeCompileState(ir)
     this.state.stringValueNames = collectStringValueNames(ir)
+    // #2448: self-register this component's derived-memo dependencies, so a
+    // SAME-FILE child (generated before its parent in the same run) is
+    // visible to `loopRowChildPropOverrides`. The cross-file pre-pass door is
+    // `registerChildComponentShape`; `compileJSX` only goes through here.
+    this.recordDerivedFieldDeps(ir, new Set((ir.metadata.propsParams ?? []).map(p => p.name)))
 
     // Surface loop-body usages of sibling-imported components (see
     // `checkImportedLoopChildComponents`). The barefoot CLI compiles a
@@ -618,10 +640,178 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * (the CLI's cross-file shape pre-pass, #2131) can register from a bare
    * analyzer pass — a full `ComponentIR` still satisfies it structurally.
    */
+  /**
+   * #2448: component name -> (memo field -> the INPUT prop Go field names its
+   * initializer reads). Deliberately SEPARATE from `childComponentShapes`,
+   * which only the CLI's cross-file pre-pass
+   * (`registerChildComponentShape`) populates — `compileJSX` never calls that
+   * hook, so a SAME-FILE child (the only kind a loop row may contain: a
+   * sibling-module child is BF103-refused there) would never have an entry
+   * and the #2448 refusal would never fire. That is exactly how the first cut
+   * of this fix shipped a conformance pin for a diagnostic that was never
+   * emitted.
+   *
+   * Populated from BOTH doors: `registerChildComponentShape` for the
+   * cross-file pre-pass, and `generate()` for every component compiled in
+   * this run — a same-file child is generated before its parent, so its entry
+   * is present by the time `loopRowChildPropOverrides` looks. Kept out of
+   * `ChildComponentShape` on purpose: that struct's presence/absence already
+   * drives rest-bag routing and map-typed-param baking, and widening WHEN it
+   * exists would change emission for every same-file child in the corpus.
+   * This map has exactly one reader.
+   */
+  private childDerivedFieldDeps: Map<string, Map<string, ReadonlySet<string>>> = new Map()
+
+  /**
+   * component name -> (the prop name as WRITTEN AT THE JSX CALL SITE -> that
+   * component's own Go field name). #2457.
+   *
+   * `generateInputStruct` / `emitPropsDataFields` name a child's Go field from
+   * its LOCAL binding (`capitalizeFieldName(param.name)`), but a parent
+   * emitting a per-row override
+   * (`loopRowChildPropOverrides`) only knows the JSX attribute it wrote. For
+   * an un-aliased prop those are the same string, so this map is an identity
+   * for every existing shape and every currently-passing fixture stays
+   * byte-identical. For an ALIASED destructure (`{ n: count }`) they differ
+   * (`"N"` vs `Count`) — `bf.WithProps` documents unknown-field pairs as a
+   * silent passthrough, so emitting the JSX name against a struct that has no
+   * such field drops the override with no diagnostic. Resolving through this
+   * map once, at the parent's emission site (the only place that has both
+   * the JSX name and the child's shape), replaces that silent drop with the
+   * correct field.
+   *
+   * Key = `p.sourceName ?? p.name` (identity for an un-aliased param, the JSX
+   * attribute name for an aliased one). Value = `capitalizeFieldName(p.name)`
+   * — the child's own field, from its LOCAL binding, same as
+   * `generateInputStruct` uses.
+   *
+   * Populated from the same two doors as `childDerivedFieldDeps` — inside
+   * `recordDerivedFieldDeps`, unconditionally (before that method's own
+   * `deps.size > 0` gate), so every component gets an entry here regardless
+   * of whether it has a derived field. `recordRepropsSpec` (the other nearby
+   * populator) returns early for components with no derived field or an
+   * ineligible shape — this map must NOT inherit either gate, since an
+   * aliased child with no derived field at all is exactly the #2457 shape.
+   */
+  private childPropFieldNames: Map<string, Map<string, string>> = new Map()
+
+  /**
+   * Components a `bf.RegisterReprops` rebuilder CAN be emitted for
+   * (`recordRepropsSpec`, #2448), with everything needed to emit it. A parent
+   * overriding a prop that feeds one of the child's derived fields emits
+   * `bf_reprops` when the child is in here, and falls back to the BF101
+   * refusal when it is not — the rebuilder is declined for shapes whose Input
+   * can't be reconstructed from Props, and emitting the call anyway would fail
+   * at template execute time with "no props rebuilder registered".
+   *
+   * Populated from `generateTypes`, so a same-file child (the only kind a loop
+   * row may contain) is recorded before its parent renders.
+   */
+  private childRepropsReady: Map<string, RepropsSpec> = new Map()
+
+  /**
+   * child component name -> the component whose type block carries its
+   * rebuilder registration. First parent to need the child wins, so two
+   * parents overriding the same child don't both emit an `init()` for it.
+   *
+   * An assignment, not a queue: `generateTypes` is called more than once for
+   * the same component (the conformance harness re-generates the entry's types
+   * after `compileJSX` already did), and a queue drained by the first call
+   * would leave the second call's output — the one that actually gets used —
+   * missing the registration.
+   */
+  private repropsOwner: Map<string, string> = new Map()
+
+  /**
+   * Record which of `ir`'s constructor-computed fields derive from one of its
+   * own input props (#2448). See `childDerivedFieldDeps`.
+   *
+   * BOTH constructor-evaluated declaration forms count, because
+   * `generateNewPropsFunction` bakes both into the struct once:
+   * a `createMemo` BODY (`createMemo(() => props.n * 2)` → `Dbl: in.N * 2`)
+   * and a `createSignal` INITIAL VALUE (`createSignal(props.n)` → `Dbl: in.N`).
+   * `bf_with_props` re-runs neither, so a per-row override of `n` leaves
+   * either one holding the shared instance's one-shot value.
+   *
+   * A declaration whose Go field name collides with a prop's own field name is
+   * a same-named "shadow" (`size = createMemo(() => props.size ?? 'icon')`) —
+   * `generateNewPropsFunction` folds it into the PROP's passthrough field
+   * rather than emitting a separate derived one, so a per-row override of
+   * that prop lands on the same field and nothing goes stale. A declaration
+   * with no structurally-resolvable `parsed` initializer is skipped too: this
+   * map is best-effort, and its absence costs a missed refusal (today's
+   * behaviour), never a wrong one.
+   *
+   * Dependencies are keyed by the prop's CANONICAL source name
+   * (`ParamInfo.sourceName ?? name`), not the child's local binding. An
+   * ALIASED destructure (`function Badge({ n: count }: { n: number })`) reads
+   * `count` in the memo body, but the only name the parent knows is the JSX
+   * attribute `n` — `loopRowChildPropOverrides` looks THAT up in
+   * `childPropFieldNames` before checking this map. Keying on the local name
+   * would file the dependency under `Count`, the lookup would miss, and the
+   * refusal would silently not fire on exactly the shape it exists for.
+   *
+   * This canonicalization used to cover the DERIVED case only — an aliased
+   * prop with no derived field still had the parent emitting `"N" .N`
+   * against a child whose field is `Count`, silently passed over by
+   * `bf.WithProps` (#2457). `childPropFieldNames`, populated a few lines
+   * below in this same method, closes that residual gap by resolving every
+   * prop's field name at the parent's emission site, not just the ones a
+   * derived field depends on.
+   */
+  private recordDerivedFieldDeps(
+    ir: Pick<ComponentIR, 'metadata'>,
+    paramNames: ReadonlySet<string>,
+  ): void {
+    const name = ir.metadata.componentName
+    if (!name) return
+    // Local binding → the prop name the PARENT writes at the call site.
+    // Identity for every un-aliased param (`sourceName` is set only on a
+    // renaming destructure).
+    const sourceOf = new Map(
+      (ir.metadata.propsParams ?? []).map(p => [p.name, p.sourceName ?? p.name]),
+    )
+    const canonical = (local: string): string => capitalizeFieldName(sourceOf.get(local) ?? local)
+    const propFieldNames = new Set([...paramNames].map(canonical))
+    // #2457: record the JSX-attribute-name -> child's-own-field-name map for
+    // EVERY component, unconditionally — see `childPropFieldNames`'s
+    // docstring for why this can't share `recordRepropsSpec`'s gates.
+    const fieldNames = new Map<string, string>()
+    for (const p of ir.metadata.propsParams ?? []) {
+      fieldNames.set(p.sourceName ?? p.name, capitalizeFieldName(p.name))
+    }
+    this.childPropFieldNames.set(name, fieldNames)
+    const deps = new Map<string, ReadonlySet<string>>()
+    const ctorInits: { field: string; init: ParsedExpr | undefined }[] = [
+      ...(ir.metadata.memos ?? []).map(m => ({ field: m.name, init: m.parsed })),
+      ...(ir.metadata.signals ?? []).map(s => ({ field: s.getter, init: s.parsed })),
+    ]
+    for (const { field, init } of ctorInits) {
+      if (propFieldNames.has(capitalizeFieldName(field))) continue
+      if (!init) continue
+      const read = collectPropsReadByCtorInit(
+        init,
+        ir.metadata.propsObjectName ?? null,
+        paramNames,
+      )
+      if (read.size === 0) continue
+      deps.set(field, new Set([...read].map(canonical)))
+    }
+    if (deps.size > 0) this.childDerivedFieldDeps.set(name, deps)
+  }
+
   registerChildComponentShape(ir: Pick<ComponentIR, 'metadata'>): void {
     const name = ir.metadata.componentName
     if (!name) return
-    const paramNames = new Set((ir.metadata.propsParams ?? []).map(p => p.name))
+    // Both sets on `ChildComponentShape` are looked up by a PARENT against the
+    // name it wrote at the JSX call site, so they are keyed by
+    // `sourceName ?? name` — identity for an un-aliased param, the original
+    // property name for an aliased destructure (`{ n: count }` → `n`). Keying
+    // them by the local binding meant an aliased prop looked undeclared to
+    // `emitChildField` (misrouted into the rest bag) and to
+    // `loopRowChildPropOverrides` (skipped as rest-bag-only) — the same
+    // wrong-name-at-a-parent-side-lookup bug as #2457, one function over.
+    const paramNames = new Set((ir.metadata.propsParams ?? []).map(p => p.sourceName ?? p.name))
     const restPropsName = ir.metadata.restPropsName ?? null
     const restBagField = restPropsName ? capitalizeFieldName(restPropsName) : null
     // Optional object/named-interface params lower to `map[string]interface{}`
@@ -635,9 +825,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             (p.type.kind === 'object' ||
               (p.type.kind === 'interface' && !!p.type.raw)),
         )
-        .map(p => p.name),
+        .map(p => p.sourceName ?? p.name),
     )
     this.childComponentShapes.set(name, { paramNames, restBagField, mapTypedParamNames })
+    // NOT `paramNames`: `recordDerivedFieldDeps` forwards this set to
+    // `collectPropsReadByCtorInit`, which in destructured mode matches BARE
+    // IDENTIFIERS in the memo/signal body — those are the LOCAL bindings
+    // (`count`), not the call-site names. Handing it the canonical set would
+    // make an aliased child's derived field look dependency-free and silently
+    // un-refuse / un-rebuild it.
+    this.recordDerivedFieldDeps(ir, new Set((ir.metadata.propsParams ?? []).map(p => p.name)))
     // Contexts this child consumes, so a parent `<Ctx.Provider value>` wrapping
     // it can set the matching field on the child's slot input.
     this.childContextConsumers.set(name, collectContextConsumers(ir.metadata))
@@ -761,9 +958,172 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     this.generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots, propTypeOverrides)
 
+    this.recordRepropsSpec(ir, componentName, nestedComponents, spreadSlots)
+    this.emitOwnedReprops(lines, componentName)
+
     return this.composeFileHeader(lines)
   }
 
+  /**
+   * #2448: emit a props REBUILDER for a component whose constructor derives a
+   * field from one of its own input props, and register it from `init()`.
+   *
+   * `bf_with_props` patches fields on the child's already-constructed shared
+   * instance; it cannot re-run `New<Child>Props`, where a `createMemo` body and
+   * a `createSignal` initial value are both baked. This closure reconstructs
+   * the Input from the base Props, folds the row's overrides in, and re-runs
+   * the real constructor — so every derived field recomputes per row. The
+   * parent's call site then emits `bf_reprops` instead of `bf_with_props`
+   * (`loopRowChildPropOverrides`).
+   *
+   * Two invariants the emitted code depends on:
+   *
+   * - **Input is recoverable from Props.** `emitPropsDataFields` and
+   *   `generateInputStruct` emit each props param with the SAME field name and
+   *   the SAME `resolvePropGoType`, so `in.<F> = b.<F>` is exact. A prop read
+   *   only by a memo still gets its passthrough field, so nothing is lost.
+   *   Shapes that add Input fields with no Props counterpart (a rest bag, a
+   *   spread slot, context consumers, nested child Inputs) are declined —
+   *   `eligible` below — and the parent falls back to today's BF101.
+   * - **Identity is carried, never re-derived.** `New<Child>Props` mints a
+   *   random ScopeID when handed an empty one, so re-running it naively would
+   *   give every row its own scope and break hydration. ScopeID/BfParent/
+   *   BfMount come from the base, and the Props-only fields (Scripts,
+   *   BfIsRoot/BfIsChild/BfDataKey) are reapplied after the constructor.
+   *
+   * The override switch is keyed by the child's own Input field
+   * (`ParamInfo.name`) on both the case label and the assignment target. That
+   * used to differ under an aliased destructure — the case label carried the
+   * name the PARENT wrote (the JSX attribute, `ParamInfo.sourceName ?? name`)
+   * while the assignment targeted the child's own field, so this switch was
+   * where those two sides were reconciled. #2457 moved that reconciliation to
+   * the PARENT (`loopRowChildPropOverrides`, via `childPropFieldNames`): the
+   * parent now emits the child's own field name at the call site, so by the
+   * time a `bf_reprops` pipeline reaches this switch both sides already agree
+   * and there's exactly one place — the parent's emission — where the naming
+   * gets reconciled, instead of two.
+   */
+  private recordRepropsSpec(
+    ir: ComponentIR,
+    componentName: string,
+    nestedComponents: NestedComponentInfo[],
+    spreadSlots: SpreadSlotInfo[],
+  ): void {
+    if (!this.childDerivedFieldDeps.has(componentName)) return
+
+    const nestedArrayFields = new Set(nestedComponents.map(n => `${n.name}s`))
+    const params = (ir.metadata.propsParams ?? []).filter(
+      p => !nestedArrayFields.has(capitalizeFieldName(p.name)),
+    )
+    const takenInput = new Set((ir.metadata.propsParams ?? []).map(p => capitalizeFieldName(p.name)))
+    const eligible =
+      nestedComponents.every(n => n.isDynamic && !n.isPropDerived) &&
+      spreadSlots.length === 0 &&
+      !ir.metadata.restPropsName &&
+      this.nonCollidingContextConsumers(takenInput).length === 0
+    if (!eligible) return
+
+    this.childRepropsReady.set(componentName, {
+      params: params.map(p => capitalizeFieldName(p.name)),
+      usesSearchParams: this.usesSearchParams(ir),
+    })
+  }
+
+  /**
+   * Emit the rebuilders assigned to `owner` — the children its own render
+   * asked for (`loopRowChildPropOverrides` → `repropsOwner`).
+   *
+   * Emitted from the PARENT rather than the child on purpose. The prop-seeded
+   * signal (`createSignal(props.initial)`) is one of the most common shapes in
+   * the corpus, so emitting a rebuilder for every component that merely HAS a
+   * derived field added ~250 lines of never-called Go to each integration's
+   * generated file. Only a parent knows whether a child is actually overridden
+   * per row inside a composite loop row, and it knows before its own type block
+   * is built — `generate()` renders the template first. Every component's type
+   * block lands in the same package (`combineGoTypes`, `build.ts`), so the
+   * child's Input/Props types are in scope from here.
+   *
+   * Idempotent: driven by the recorded assignment, so re-generating the same
+   * component's types produces the same block.
+   */
+  private emitOwnedReprops(lines: string[], owner: string): void {
+    for (const [childName, ownerName] of this.repropsOwner) {
+      if (ownerName !== owner) continue
+      const spec = this.childRepropsReady.get(childName)
+      if (!spec) continue
+      this.emitRepropsRegistration(lines, childName, spec)
+    }
+  }
+
+  private emitRepropsRegistration(
+    lines: string[],
+    componentName: string,
+    spec: RepropsSpec,
+  ): void {
+    const { params, usesSearchParams } = spec
+    const inputTypeName = `${componentName}Input`
+    const q = JSON.stringify(componentName)
+
+    lines.push(`// ${componentName} computes at least one field from an input prop when its`)
+    lines.push('// props are constructed, so a per-row override inside a composite loop row')
+    lines.push('// cannot be applied by patching fields — the derived field would keep the')
+    lines.push('// shared instance\'s one-shot value on every row (#2448). This rebuilder')
+    lines.push(`// re-runs New${componentName}Props with the row's overrides folded into the`)
+    lines.push('// Input; the parent calls it through bf_reprops.')
+    lines.push('func init() {')
+    lines.push(`\tbf.RegisterReprops(${q}, func(base interface{}, kv ...interface{}) (interface{}, error) {`)
+    lines.push(`\t\tb, ok := base.(${componentName}Props)`)
+    lines.push('\t\tif !ok {')
+    lines.push(`\t\t\treturn nil, bf.RepropsTypeError(${q}, base)`)
+    lines.push('\t\t}')
+    lines.push(`\t\tin := ${inputTypeName}{`)
+    // Identity comes from the base instance — re-deriving it would re-mint the
+    // ScopeID and break hydration.
+    lines.push('\t\t\tScopeID: b.ScopeID,')
+    lines.push('\t\t\tBfParent: b.BfParent,')
+    lines.push('\t\t\tBfMount: b.BfMount,')
+    if (usesSearchParams) lines.push('\t\t\tSearchParams: b.SearchParams,')
+    for (const field of params) {
+      lines.push(`\t\t\t${field}: b.${field},`)
+    }
+    lines.push('\t\t}')
+    lines.push('\t\tfor i := 0; i < len(kv); i += 2 {')
+    lines.push('\t\t\tname, _ := kv[i].(string)')
+    lines.push('\t\t\tvar err error')
+    lines.push('\t\t\tswitch name {')
+    for (const field of params) {
+      // Case label and assignment target are the same name: the child's own
+      // Input field. The parent (`loopRowChildPropOverrides`, via
+      // `childPropFieldNames`, #2457) already resolved the JSX attribute to
+      // this field before emitting the call, so there is nothing left to
+      // reconcile here.
+      lines.push(`\t\t\tcase ${JSON.stringify(field)}:`)
+      lines.push(`\t\t\t\terr = bf.RepropsAssign(${q}, ${JSON.stringify(field)}, &in.${field}, kv[i+1])`)
+    }
+    // No silent drop. `bf_with_props` passes an unknown field through because
+    // a rest-bag prop legitimately has no named field — but a rebuilder is
+    // only emitted for components with no rest bag, and there is a case for
+    // every prop the parent can override, so an unknown name here means the
+    // override would go unapplied.
+    lines.push('\t\t\tdefault:')
+    lines.push(`\t\t\t\terr = bf.RepropsUnknownFieldError(${q}, name)`)
+    lines.push('\t\t\t}')
+    lines.push('\t\t\tif err != nil {')
+    lines.push('\t\t\t\treturn nil, err')
+    lines.push('\t\t\t}')
+    lines.push('\t\t}')
+    lines.push(`\t\tp := New${componentName}Props(in)`)
+    lines.push('\t\t// Props-only state, absent from Input and therefore not rebuilt.')
+    lines.push('\t\tp.Scripts = b.Scripts')
+    lines.push('\t\tp.BfIsRoot = b.BfIsRoot')
+    lines.push('\t\tp.BfIsChild = b.BfIsChild')
+    lines.push('\t\tp.BfDataKey = b.BfDataKey')
+    lines.push('\t\treturn p, nil')
+    lines.push('\t})')
+    lines.push('}')
+    lines.push('')
+  }
+
   /** Convert a TS type definition to Go: object types → structs, string-literal unions → a `string` alias. */
   private typeDefinitionToGo(td: TypeDefinition): string | null {
     // A string-literal union (`type Filter = 'all' | 'active'`) carries no
@@ -1506,7 +1866,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // A hyphenated attr (`aria-label`) can't be a Go field and, with no rest
         // bag to route it into, has nowhere to go — skip over emitting invalid Go.
         if (jsxName.includes('-')) return
-        lines.push(`\t\t\t${capitalizeFieldName(jsxName)}: ${goValue},`)
+        // Same resolution as `loopRowChildPropOverrides` (#2457): the child's
+        // own Go field, which differs from the JSX attribute under an aliased
+        // destructure (`{ n: count }` → field `Count`). Emitting the attribute
+        // name here put an unknown field in a Go struct literal — a build
+        // error rather than a silent drop, but wrong either way. Falls back to
+        // the capitalized attribute for a child this run never registered.
+        const fieldName =
+          this.childPropFieldNames.get(child.name)?.get(jsxName) ?? capitalizeFieldName(jsxName)
+        lines.push(`\t\t\t${fieldName}: ${goValue},`)
       }
       for (const prop of child.props) {
         switch (prop.value.kind) {
@@ -4993,6 +5361,186 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     )
   }
 
+  /**
+   * #2445: per-row Go pipeline arguments for a child component nested inside
+   * a COMPOSITE loop row (row root is a plain element — `<li><Badge
+   * text={row.label}/></li>` — as opposed to the wrapper-slice case where the
+   * loop body IS the component). `collectStaticChildInstancesRecursive`
+   * registers such a child as an ordinary once-per-slot instance
+   * (`$.<Name>SlotN`), built ONCE outside `{{range}}` by
+   * `emitStaticChildInstances` — correct for props that don't depend on the
+   * row, but stale for one that does (`text={row.label}` reads the same
+   * value on every row). A loop-dependent prop is therefore re-applied per
+   * row, at template-execution time, via the `bf_with_props` runtime helper
+   * (the props-argument sibling of `bf_with_children`, which already does
+   * this for per-row JSX children on the same shared instance).
+   *
+   * A prop with no loop-bound free identifier (`IRProp.freeIdentifiers`, IR-
+   * build-time computed, #1267) is left on the constructor path — it's
+   * already correct there, and skipping it keeps every currently-passing
+   * fixture's emitted template byte-identical (no fixture in the corpus
+   * reaches this method with a loop-dependent prop today).
+   *
+   * #2448 — `bf_with_props` overrides fields on the ALREADY-CONSTRUCTED
+   * shared instance; it does not re-run `New<Child>Props`. A field the child
+   * derives FROM the overridden prop at construction time (a memo body or a
+   * signal's initial value) would keep whatever the one-shot constructor
+   * computed and never update per row. Two outcomes, decided per child:
+   *
+   * - The child has a generated props rebuilder (`childRepropsReady`): the
+   *   caller emits `bf_reprops` instead, which re-runs the real constructor
+   *   per row so every derived field recomputes. Nothing is refused.
+   * - It does not (its Input can't be reconstructed from Props — see
+   *   `generateRepropsRegistration`'s eligibility gate): BF101 + `continue`,
+   *   exactly like the unsupported-expression refusal a few lines below.
+   *   Refusing beats emitting silently-stale output.
+   *
+   * #2457 — the `"Field"` half of each argument pair is the child's OWN Go
+   * field name (resolved through `childPropFieldNames`), not the JSX
+   * attribute name. For an un-aliased prop those are the same string; for an
+   * aliased destructure (`{ n: count }`) the child's field is `Count` while
+   * the JSX attribute is `n`, and emitting the attribute name left
+   * `bf.WithProps`/`bf.RepropsAssign` with a name the struct has no field
+   * for — silently dropped by the former, an unknown-field error from the
+   * latter. Resolving it here, once, means both helpers only ever see a name
+   * the struct actually has.
+   *
+   * Returns the space-joined `"Field" value …` argument list plus the helper
+   * the caller must wrap it in, or null when nothing needs overriding (caller
+   * keeps the bare `$.<Name>SlotN` reference).
+   */
+  private loopRowChildPropOverrides(
+    comp: IRComponent,
+  ): { args: string; helper: 'bf_with_props' | 'bf_reprops' } | null {
+    const childShape = this.childComponentShapes.get(comp.name)
+    const args: string[] = []
+    // Set by the derived-field check below when at least one overridden prop
+    // feeds a constructor-derived field AND the child can rebuild itself.
+    let needsRebuild = false
+    for (const prop of comp.props) {
+      // Client-only props never reach SSR output; `key`/`children` aren't
+      // Props-struct fields; event handlers have no Go field (same
+      // `isEventHandler` predicate `jsx-to-ir.ts` uses for component props);
+      // a hyphenated name can't be a Go field (same guard as `emitChildField`).
+      if (prop.clientOnly) continue
+      if (prop.name === 'key' || prop.name === 'children') continue
+      if (prop.name.startsWith('on') && prop.name.length > 2) continue
+      if (prop.name.includes('-')) continue
+      // A prop that routes into the child's rest bag (`emitChildField`'s
+      // same routing rule) has no named Go field to override — `bf_with_props`
+      // would silently no-op the pair via its unknown-field passthrough.
+      // Leave it on the constructor-only path (unchanged from before this
+      // fix) rather than emit a pipeline argument that can never land.
+      if (childShape?.restBagField && !childShape.paramNames.has(prop.name)) continue
+      // `literal` / `boolean-shorthand` / `boolean-attr` carry no runtime
+      // expression to re-evaluate per row; `spread` / `jsx-children` are
+      // handled elsewhere (`emitSpreadBagInits`, `queueLoopBodyChildrenDefine`).
+      if (prop.value.kind !== 'expression') continue
+      const free = prop.freeIdentifiers
+      if (!free || ![...free].some(name => this.isLoopShadowedName(name))) continue
+      // #2448: does this prop feed a field the child's CONSTRUCTOR derives?
+      // If so, patching fields on the shared instance leaves that field at the
+      // one-shot value on every row. Re-run the constructor per row when the
+      // child has a rebuilder; refuse when it doesn't.
+      {
+        const derived = this.childDerivedFieldDeps.get(comp.name)
+        const overriddenField = capitalizeFieldName(prop.name)
+        const staleField = derived
+          ? [...derived].find(([, deps]) => deps.has(overriddenField))?.[0]
+          : undefined
+        if (staleField && !this.childRepropsReady.has(comp.name)) {
+          this.state.errors.push({
+            code: 'BF101',
+            severity: 'error',
+            message: `Prop '${prop.name}' on <${comp.name}> nested inside a dynamic loop row is overridden per row, but <${comp.name}>'s '${staleField}' field is computed from '${prop.name}' when the shared instance is first constructed and won't recompute per row — it would keep the first row's value on every row.`,
+            loc: prop.loc,
+            suggestion: {
+              message: `Mark this loop position '@client' to render <${comp.name}> client-side, or compute '${staleField}' in the parent and pass it to <${comp.name}> as a plain prop instead of deriving it inside <${comp.name}>.`,
+            },
+          })
+          continue
+        }
+        if (staleField) {
+          needsRebuild = true
+          // The rebuilder is emitted into THIS component's type block, not the
+          // child's — only here do we know it is actually needed. First parent
+          // to claim a child owns the registration, so two parents overriding
+          // the same child don't both emit an `init()` for it.
+          if (!this.repropsOwner.has(comp.name)) {
+            this.repropsOwner.set(comp.name, this.state.componentName)
+          }
+        }
+      }
+      const exprOut: { parsed?: ParsedExpr } = {}
+      const errorCountBefore = this.state.errors.length
+      let go = this.convertExpressionToGo(prop.value.expr, exprOut, prop.value.parsed)
+      if (this.state.errors.length > errorCountBefore) {
+        // `convertExpressionToGo` already pushed its own BF101 for an
+        // unsupported expression and returned the `""` sentinel — using it
+        // here would silently clobber the field with an empty string (or,
+        // for a non-string field, fail at template EXECUTE time instead of
+        // this compile time). Leave the prop on the constructor path; the
+        // reported error already surfaces the real problem. `loc` defaults
+        // to `convertExpressionToGo`'s own `this.makeLoc()` placeholder —
+        // repoint the newly-pushed error(s) at the prop's real source
+        // location, same as the fragment-refusal error below.
+        for (let i = errorCountBefore; i < this.state.errors.length; i++) {
+          this.state.errors[i].loc = prop.loc
+        }
+        continue
+      }
+      // A ternary / single-interpolation template literal with STRING-typed
+      // branches (`row.on ? "yes" : "no"`, `${row.x}` alone) parses to a
+      // ParsedExpr `template-literal` whose sole part is non-string —
+      // `templateLiteral()` wraps that one dynamic part's already-bare
+      // pipeline value (e.g. `(bf_ternary ...)`, #2335) in a bare `{{...}}`
+      // shell meant for TEXT-position embedding. A multi-part template
+      // literal (mixed literal text and interpolation) has no such reduction
+      // and stays refused below. Unwrap the single-part case back to the
+      // bare pipeline value this call site (a function ARGUMENT position,
+      // not a text position) needs.
+      const singlePartTemplateLiteral =
+        exprOut.parsed?.kind === 'template-literal' &&
+        exprOut.parsed.parts.length === 1 &&
+        exprOut.parsed.parts[0].type !== 'string' &&
+        go.startsWith('{{') &&
+        go.endsWith('}}')
+      if (singlePartTemplateLiteral) {
+        go = go.slice(2, -2)
+      }
+      // Skip the fragment re-check for the just-unwrapped single-part case —
+      // `kind` is still (accurately) `template-literal`, which would
+      // otherwise re-trip `isTemplateFragment`'s `kind === 'template-literal'`
+      // branch on the ALREADY-unwrapped bare value.
+      if (!singlePartTemplateLiteral && this.isTemplateFragment(go, exprOut.parsed?.kind)) {
+        // A genuine multi-part `{{if}}...{{end}}`-shaped fragment can't be a
+        // bare pipeline argument — refuse loudly rather than silently
+        // dropping the prop (the #2445 bug was exactly a silent drop one
+        // level up).
+        this.state.errors.push({
+          code: 'BF101',
+          severity: 'error',
+          message: `Prop '${prop.name}' on <${comp.name}> nested inside a dynamic loop row reads the row but can't be lowered to a Go template pipeline argument`,
+          loc: prop.loc,
+        })
+        continue
+      }
+      // #2457: emit the CHILD's own Go field name, not the JSX attribute name.
+      // They differ under an aliased destructure (`{ n: count }` → attribute
+      // `n`, field `Count`); resolving through `childPropFieldNames` here —
+      // the parent's emission site, the only place that has both the JSX
+      // name and the child's shape — means `bf.WithProps`/`bf.RepropsAssign`
+      // never see a name the struct doesn't have. Falls back to today's
+      // capitalized-attribute behaviour for a cross-file child this run's
+      // pre-pass never registered (`childPropFieldNames` has no entry).
+      const fieldName =
+        this.childPropFieldNames.get(comp.name)?.get(prop.name) ?? capitalizeFieldName(prop.name)
+      args.push(`${JSON.stringify(fieldName)} ${wrapIfMultiToken(go)}`)
+    }
+    if (args.length === 0) return null
+    return { args: args.join(' '), helper: needsRebuild ? 'bf_reprops' : 'bf_with_props' }
+  }
+
   /**
    * Resolve `IDENT['key']` / `IDENT["key"]` where `IDENT` is a module-scope
    * object-literal const and the key is a string literal — a compile-time-static
@@ -5744,6 +6292,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // nested loops with the same index var name from clobbering the outer entry
     // on cleanup.
     const addedLoopVars: string[] = []
+    // A `.map()` callback preamble lowers to one `{{$cls := …}}` per-row
+    // variable per declaration (#2447). Registering the names on
+    // `loopVarRefCount` is what makes `identifier()` resolve each read as
+    // `$cls`; without it the read falls through to `rootFieldRef` and emits
+    // `$.Cls` — a PARENT-struct field, never populated, which rendered the
+    // attribute empty on every row (the same hoisted-to-parent class of
+    // defect as #2445).
+    for (const d of loop.preamble?.declarations ?? []) {
+      this.loopVarRefCount.set(d.name, (this.loopVarRefCount.get(d.name) ?? 0) + 1)
+      addedLoopVars.push(d.name)
+    }
     let pushedBindingMap = false
     if (supportableDestructure) {
       // Bindings resolve against the synthetic `$__bf_item` range var; don't push
@@ -5777,6 +6336,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     )
     this.loopWrapperStack.push(!!loop.childComponent)
     this.loopKeyDepthStack.push(loop.depth)
+    // Rendered inside the pushed loop scope so each initializer resolves
+    // against the range item (`.Done`), in source order so a later
+    // initializer sees an earlier `$` variable — same as the source block.
+    const preambleAssignments = (loop.preamble?.declarations ?? [])
+      .map(d => `{{$${d.name} := ${this.renderParsedExpr(d.valueParsed)}}}`)
+      .join('')
     const children = this.renderChildren(loop.children)
     this.loopKeyDepthStack.pop()
     this.loopWrapperStack.pop()
@@ -5838,10 +6403,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         filterCond = 'true'
       }
 
-      return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}{{if ${filterCond}}}${itemMarker}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`
+      // The preamble assignments sit INSIDE the `{{if}}`, matching JS
+      // evaluation order: a `.filter(p).map(cb)` chain never runs `cb`'s
+      // body for a filtered-out item.
+      return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}{{if ${filterCond}}}${preambleAssignments}${itemMarker}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`
     }
 
-    return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`
+    return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${preambleAssignments}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`
   }
 
   /**
@@ -6013,17 +6581,33 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     } else if (this.inLoop && comp.slotId) {
       // Non-wrapper loop (component nested inside an element item, #2130):
       // the range iterates the REAL collection, so `.` is the raw datum and
-      // carries none of the child's props. Call through the parent's
-      // once-per-slot instance via the root context (`$` — the define's own
-      // data, i.e. the parent's Props), injecting per-item content through a
-      // loop-body children define executed with the datum (`.`). The shared
-      // instance means identical child scope IDs across rows — the same
+      // carries none of the child's props by default. Call through the
+      // parent's once-per-slot instance via the root context (`$` — the
+      // define's own data, i.e. the parent's Props). Two kinds of per-row
+      // content have to reach that shared instance at template-execution
+      // time: JSX children, injected via a loop-body children define
+      // executed with the datum (`bf_with_children`), and any PROP that
+      // reads the row (`text={row.label}`, #2445) — the instance is built
+      // ONCE outside `{{range}}`, so a loop-dependent prop is stale there
+      // and is reapplied per row via `bf_with_props`
+      // (`loopRowChildPropOverrides`). The shared BASE instance (built once)
+      // still carries identical child scope IDs across rows — the same
       // contract the wrapper machinery's `bodyChildInstances` already uses.
       const suffix = slotIdToFieldSuffix(comp.slotId)
+      const overrides = this.loopRowChildPropOverrides(comp)
       const loopBodyDefine = this.queueLoopBodyChildrenDefine(comp)
+      // `bf_reprops` re-runs the child's constructor and so takes the
+      // component name; `bf_with_props` patches fields and doesn't (#2448).
+      // Either way the props helper stays INNER — `bf_with_children` applies
+      // the row's children last, on the rebuilt value.
+      const base = overrides
+        ? overrides.helper === 'bf_reprops'
+          ? `(bf_reprops ${JSON.stringify(comp.name)} $.${comp.name}${suffix} ${overrides.args})`
+          : `(bf_with_props $.${comp.name}${suffix} ${overrides.args})`
+        : `$.${comp.name}${suffix}`
       templateCall = loopBodyDefine
-        ? `{{template "${comp.name}" (bf_with_children $.${comp.name}${suffix} (bf_tmpl "${loopBodyDefine}" .))}}`
-        : `{{template "${comp.name}" $.${comp.name}${suffix}}}`
+        ? `{{template "${comp.name}" (bf_with_children ${base} (bf_tmpl "${loopBodyDefine}" .))}}`
+        : `{{template "${comp.name}" ${base}}}`
     } else if (this.inLoop) {
       // Loop-nested component without a slotId: no parent field to route
       // through — legacy passthrough of the current dot.