@barefootjs/go-template 0.29.0 → 0.30.2

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

@@ -1461,15 +1461,15 @@ function C({ rows }: { rows?: number }) {
 
     test('leaves a concrete/defaulted attr unconditional (scope did not widen)', () => {
       const source = `
-function C({ value = '' }: { value?: string }) {
-  return <textarea value={value} />
+function C({ placeholder = '' }: { placeholder?: string }) {
+  return <textarea placeholder={placeholder} />
 }
 `
       const { template } = compileAndGenerate(source)
-      // `value` has a destructure default → concrete `string` field →
-      // never nil → emitted unconditionally, exactly like Hono's value="".
-      expect(template).toContain('value="{{.Value}}"')
-      expect(template).not.toContain('if ne .Value nil')
+      // `placeholder` has a destructure default → concrete `string` field →
+      // never nil → emitted unconditionally, exactly like Hono's placeholder="".
+      expect(template).toContain('placeholder="{{.Placeholder}}"')
+      expect(template).not.toContain('if ne .Placeholder nil')
     })
   })
 
@@ -4166,6 +4166,626 @@ export function TodoList(props: { todos?: Todo[] }) {
   })
 })
 
+// #2445: a child component nested inside a composite loop row (row root is a
+// plain element, #2130's shape) gets ONE hoisted `.{Name}SlotN` props value
+// built outside `{{range}}` (see the describe block above) — correct for a
+// prop that doesn't depend on the row, but stale for one that does
+// (`text={row.label}` read the same value on every row, always the zero
+// value, since the constructor has no per-row data to give it). Fixed by
+// reapplying the row-dependent prop per row, at template-execution time,
+// via `bf_with_props` — the props-argument sibling of `bf_with_children`.
+describe('GoTemplateAdapter - #2445 composite loop row: per-row child prop', () => {
+  // These compile through `compileJSX` directly (not the `compileToIR` +
+  // `adapter.generate(ir)` two-step other tests in this file use) because
+  // the fixture's child (`Badge`) is a SAME-FILE sibling of the parent
+  // (a sibling-MODULE child inside a loop is refused by BF103) — the debug
+  // `ir.json` `compileToIR` reads back only carries one component's IR, and
+  // `IRProp.freeIdentifiers` (a `Set`) doesn't survive that JSON round trip
+  // anyway. `compileJSX`'s own `types`/`markedTemplate` outputs already
+  // combine both components' generated code in one pass, matching how the
+  // real pipeline (and the `composite-row-child-component` fixture) compiles
+  // this shape.
+  test('a prop reading the row is reapplied per row via bf_with_props', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string }
+function Badge(props: { text: string }) {
+  return <span class="badge">{props.text}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const types = result.files.find(f => f.type === 'types')!.content
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+
+    // Range still iterates the real collection — this is the #2130 shape,
+    // not the wrapper-slice one — and the shared base instance is still
+    // built once, carrying the (correct) constructor-derived scope id.
+    expect(template).toContain(':= .Rows}}')
+    expect(types).toContain('BadgeSlot0 BadgeProps')
+    expect(types).toContain('BadgeSlot0: NewBadgeProps(BadgeInput{')
+
+    // The row-dependent prop is reapplied per row, inside `{{range}}`.
+    expect(template).toContain('{{template "Badge" (bf_with_props $.BadgeSlot0 "Text" .Label)}}')
+  })
+
+  // Negative pin — the whole point of the loop-dependence gate: a prop that
+  // does NOT read the row is left on the constructor-only path, so this
+  // fix doesn't touch (and can't regress) the corpus of composite-loop
+  // fixtures whose nested-child props are static/prop-derived.
+  test('a prop NOT reading the row stays on the constructor-only path', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string }
+function Badge(props: { text: string }) {
+  return <span class="badge">{props.text}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[]; title: string }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={props.title} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).toContain('{{template "Badge" $.BadgeSlot0}}')
+    expect(template).not.toContain('bf_with_props')
+  })
+
+  // Composition pin: a nested child with both a per-row prop AND JSX
+  // children nests `bf_with_props` inside `bf_with_children` — the shared
+  // base instance is overridden with the row's prop value first, then that
+  // result has its per-row children injected.
+  test('a per-row prop composes with per-row JSX children', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string; hint: string }
+function Badge(props: { title: string; children?: any }) {
+  return <span class="badge" title={props.title}>{props.children}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge title={row.hint}>{row.label}</Badge>
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).toContain(
+      '(bf_with_children (bf_with_props $.BadgeSlot1 "Title" .Hint) (bf_tmpl "',
+    )
+  })
+
+  // End-to-end on real Go: each row's Badge must render that row's OWN
+  // label, not the same (previously always-empty) value for every row.
+  test('each row renders its own label on real Go', async () => {
+    let html: string
+    try {
+      html = await renderGoTemplateComponent({
+        source: `
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string }
+function Badge(props: { text: string }) {
+  return <span class="badge">{props.text}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(),
+        adapter: new GoTemplateAdapter(),
+        props: { items: [{ id: 1, label: 'one' }, { id: 2, label: 'two' }] },
+      })
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) return
+      throw err
+    }
+    expect(html).toContain('>one<')
+    expect(html).toContain('>two<')
+    expect(html).toContain('class="badge"')
+  })
+
+  // A per-row prop shaped as a ternary (`row.on ? "yes" : "no"`) parses to a
+  // ParsedExpr `template-literal` whose sole part is the ternary — the
+  // shared `templateLiteral()` emitter wraps that single dynamic part's
+  // already-bare `(bf_ternary ...)` pipeline value in a `{{...}}` shell for
+  // TEXT-position embedding (#2335). `loopRowChildPropOverrides` needs the
+  // BARE value (a function-argument position, not text), so it must unwrap
+  // this specific single-part shape rather than refuse it as a fragment.
+  test('a ternary per-row prop unwraps to a bare bf_ternary pipeline argument', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; on: boolean }
+function Badge(props: { text: string }) {
+  return <span class="badge">{props.text}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.on ? "yes" : "no"} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect(result.errors ?? []).toEqual([])
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).toContain(
+      '{{template "Badge" (bf_with_props $.BadgeSlot0 "Text" (bf_ternary (bf_truthy .On) "yes" "no"))}}',
+    )
+  })
+
+  // A multi-part template literal (mixed literal text and interpolation,
+  // `` `#${row.id} ${row.label}` ``) has no single-pipeline-value reduction
+  // the way a single-part ternary does — refuse it loudly (BF101) instead
+  // of silently emitting the stale constructor-only value (the #2445 bug
+  // this whole fix exists to close).
+  test('a multi-part template-literal per-row prop is refused with BF101, not silently stale', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string }
+function Badge(props: { text: string }) {
+  return <span class="badge">{props.text}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={\`#\${row.id} \${row.label}\`} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).some(e => e.code === 'BF101')).toBe(true)
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).not.toContain('bf_with_props')
+  })
+
+  // A prop whose expression `convertExpressionToGo` itself refuses (an
+  // inline object literal isn't a supported value shape) must not ALSO
+  // clobber the child with a bad `bf_with_props` pipeline argument built
+  // from the `""` error sentinel — that would either silently blank a
+  // string field or fail at template EXECUTE time for a non-string one.
+  // The existing BF101 from the unsupported expression is enough; the prop
+  // simply stays on the (already-existing, unchanged) constructor path.
+  test('an unsupported per-row prop expression does not also emit a bad pipeline argument', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string }
+function Badge(props: { opts: any }) {
+  return <span class="badge">{JSON.stringify(props.opts)}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge opts={{ align: row.label }} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const bf101s = (result.errors ?? []).filter(e => e.code === 'BF101')
+    expect(bf101s).toHaveLength(1)
+    // Copilot review (PR #2451): the error must point at the prop's own
+    // source location, not `convertExpressionToGo`'s internal `makeLoc()`
+    // placeholder (always line 1, column 0) — the loop-dependence gate
+    // repoints it before continuing.
+    expect(bf101s[0]!.loc.start.line).toBeGreaterThan(1)
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).toContain('{{template "Badge" $.BadgeSlot0}}')
+    expect(template).not.toContain('bf_with_props')
+  })
+
+  // A prop that routes into the child's rest bag (not a declared param) has
+  // no named Go field for `bf_with_props` to override — it must stay on the
+  // constructor path rather than emit a pipeline argument that can only
+  // ever no-op at the runtime helper's unknown-field passthrough. Requires
+  // `registerChildComponentShape` (normally the CLI's cross-file pre-pass,
+  // #2131) so the adapter actually knows `Badge`'s rest-bag shape.
+  test('a rest-bag-routed per-row prop stays on the constructor path', () => {
+    // Mirrors the `registerChildComponentShape` pattern the `#2087` test
+    // above uses: a bare `compileJSX` never calls that hook (only the CLI's
+    // cross-file pre-pass, #2131, does), so this builds each component's IR
+    // directly and registers `Badge`'s rest-bag shape before generating the
+    // parent — the real order `renderGoTemplateComponent` / `bf build` use.
+    const source = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string }
+function Badge({ text, ...rest }: { text: string; [key: string]: unknown }) {
+  return <span class="badge" {...rest}>{text}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text="static" tone={row.label} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart()
+
+    const badgeCtx = analyzeComponent(source, 'test.tsx', 'Badge')
+    const badgeIR: ComponentIR = {
+      version: '0.1',
+      metadata: buildMetadata(badgeCtx),
+      root: jsxToIR(badgeCtx)!,
+      errors: [],
+    }
+    const rootCtx = analyzeComponent(source, 'test.tsx', 'CompositeRowChildComponent')
+    const rootIR: ComponentIR = {
+      version: '0.1',
+      metadata: buildMetadata(rootCtx),
+      root: jsxToIR(rootCtx)!,
+      errors: [],
+    }
+
+    const adapter = new GoTemplateAdapter()
+    adapter.registerChildComponentShape(badgeIR)
+    adapter.generateTypes(badgeIR)
+    adapter.generateTypes(rootIR)
+    const template = adapter.generate(rootIR, { skipScriptRegistration: true }).template
+
+    // `tone` isn't a declared `Badge` param, so it routes into the rest bag
+    // (`emitChildField`'s rule) — no named Go field for `bf_with_props` to
+    // override, so the call stays the bare shared-instance reference.
+    expect(template).toContain('{{template "Badge" $.BadgeSlot0}}')
+    expect(template).not.toContain('bf_with_props')
+  })
+})
+
+// #2448: `bf_with_props` (#2445, above) overrides fields on the ALREADY-
+// CONSTRUCTED shared instance — it does not re-run `New<Child>Props`. When
+// the overridden prop feeds a child field the constructor DERIVES at
+// construction time (a `createMemo` body or a `createSignal` initial value —
+// `New<Child>Props` bakes both), patching fields would leave that field
+// holding the shared instance's one-shot value on every row.
+//
+// The child therefore gets a generated props REBUILDER, registered from the
+// generated package's `init()`, and the call site emits `bf_reprops` — which
+// re-runs the real constructor per row so every derived field recomputes.
+// BF101 remains only for shapes the rebuilder declines.
+const DERIVED_PROP_SOURCE = `
+'use client'
+import { createSignal, createMemo } from '@barefootjs/client'
+type Row = { id: number; label: string; n: number }
+function Badge(props: { text: string; n: number }) {
+  const dbl = createMemo(() => props.n * 2)
+  return <span class="badge">{props.text}:{dbl()}</span>
+}
+export function CompositeRowChildDerivedProp(props: { rows: Row[] }) {
+  const [rows] = createSignal<Row[]>(props.rows)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} n={row.n} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart()
+
+describe('GoTemplateAdapter - #2448 per-row override of a prop feeding a derived child field', () => {
+  // Two-phase build (mirrors the rest-bag test's pattern above): the adapter
+  // instance here never compiles `Badge` through `generate()`, so the explicit
+  // `generateTypes(badgeIR)` is what emits its rebuilder and marks it ready.
+  // (Under `compileJSX` — the tests below — the same-file child is generated
+  // first and self-registers, so both doors are exercised.)
+  test('a per-row-overridden prop feeding a memo field rebuilds the child per row', () => {
+    const badgeCtx = analyzeComponent(DERIVED_PROP_SOURCE, 'test.tsx', 'Badge')
+    const badgeIR: ComponentIR = {
+      version: '0.1',
+      metadata: buildMetadata(badgeCtx),
+      root: jsxToIR(badgeCtx)!,
+      errors: [],
+    }
+    const rootCtx = analyzeComponent(DERIVED_PROP_SOURCE, 'test.tsx', 'CompositeRowChildDerivedProp')
+    const rootIR: ComponentIR = {
+      version: '0.1',
+      metadata: buildMetadata(rootCtx),
+      root: jsxToIR(rootCtx)!,
+      errors: [],
+    }
+
+    const adapter = new GoTemplateAdapter()
+    adapter.registerChildComponentShape(badgeIR)
+    // Generating `Badge`'s types RECORDS that a rebuilder is possible; it does
+    // not emit one. Only a parent knows whether the child is actually
+    // overridden per row, so the registration rides the PARENT's type block.
+    const badgeTypes = adapter.generateTypes(badgeIR)
+    expect(badgeTypes).not.toContain('RegisterReprops')
+
+    const { template, types } = adapter.generate(rootIR, { skipScriptRegistration: true })
+
+    expect(rootIR.errors.filter(e => e.code === 'BF101')).toHaveLength(0)
+    // BOTH per-row props ride the rebuild — `n` is no longer dropped.
+    expect(template).toContain('{{template "Badge" (bf_reprops "Badge" $.BadgeSlot0 "Text" .Label "N" .N)}}')
+
+    // The rebuilder reconstructs the Input from the base Props, applies the
+    // row's overrides, and re-runs the real constructor. `Badge`'s own types
+    // are in the same Go package (`combineGoTypes`), so they're in scope here.
+    expect(types).toContain('bf.RegisterReprops("Badge"')
+    expect(types).toContain('p := NewBadgeProps(in)')
+    expect(types).toContain('err = bf.RepropsAssign("Badge", "N", &in.N, kv[i+1])')
+    // Identity is carried over, never re-derived: NewBadgeProps mints a random
+    // ScopeID when handed an empty one, so re-running it without this would
+    // give every row its own scope and break hydration.
+    expect(types).toContain('ScopeID: b.ScopeID,')
+    expect(types).toContain('p.Scripts = b.Scripts')
+  })
+
+  // A `createSignal` INITIAL VALUE is baked into `New<Child>Props` exactly
+  // like a memo body is (`const [dbl] = createSignal(props.n)` emits
+  // `Dbl: in.N`), so it takes the same rebuild path. Compiled through
+  // `compileJSX` so this also pins `generate()`'s self-registration door.
+  test("a per-row-overridden prop feeding a signal's initial value rebuilds too", () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Row = { id: number; label: string; n: number }
+function Badge(props: { text: string; n: number }) {
+  const [dbl] = createSignal(props.n)
+  return <span class="badge">{props.text}:{dbl()}</span>
+}
+export function SignalRowChildDerivedProp(props: { rows: Row[] }) {
+  const [rows] = createSignal<Row[]>(props.rows)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} n={row.n} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).toContain('(bf_reprops "Badge" $.BadgeSlot0 "Text" .Label "N" .N)')
+  })
+
+  // An ALIASED destructure (`{ n: count }`) is where the JSX attribute name
+  // (`n` → `"N"`) and the child's own Go field (`Count`) diverge. #2457: the
+  // reconciliation now happens ONCE, at the PARENT's emission site
+  // (`loopRowChildPropOverrides`, via `childPropFieldNames`) — the parent
+  // emits the child's own field name directly, so the rebuilder's switch
+  // (`recordRepropsSpec` / `emitRepropsRegistration`) needs no separate
+  // "wire" name and is keyed uniformly by that one field on both sides.
+  test('an aliased destructured prop maps the parent name onto the child field', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal, createMemo } from '@barefootjs/client'
+type Row = { id: number; label: string; n: number }
+function Badge({ text, n: count }: { text: string; n: number }) {
+  const dbl = createMemo(() => count * 2)
+  return <span class="badge">{text}:{dbl()}</span>
+}
+export function AliasedRowChildDerivedProp(props: { rows: Row[] }) {
+  const [rows] = createSignal<Row[]>(props.rows)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} n={row.n} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    // The parent now writes the child's OWN field name ("Count"), not the
+    // JSX attribute ("N").
+    expect(template).toContain('(bf_reprops "Badge" $.BadgeSlot0 "Text" .Label "Count" .N)')
+    const types = result.files.find(f => f.type === 'types')!.content
+    expect(types).toContain('case "Count":')
+    expect(types).toContain('&in.Count,')
+    // "N" — the JSX attribute name — is never a case label: the switch is
+    // keyed by the child's field on both sides, and the parent already
+    // resolved the name before emitting the call.
+    expect(types).not.toContain('case "N":')
+  })
+
+  // #2457: the SAME aliased destructure, but with NO derived field — the
+  // shape `bf_with_props` mishandled even before #2448's rebuilder existed.
+  // `bf.WithProps` documents an unknown-field pair as a silent passthrough,
+  // so emitting the JSX attribute name ("N") against a child whose field is
+  // "Count" used to drop the override with no diagnostic on every row. No
+  // rebuilder is needed here — resolving the field name at the parent's
+  // emission site is enough on its own.
+  test('an aliased destructured prop with no derived field still lands on the child field', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Row = { id: number; label: string; n: number }
+function Badge({ text, n: count }: { text: string; n: number }) {
+  return <span class="badge">{text}:{count}</span>
+}
+export function AliasedRowChildNoDerivedProp(props: { rows: Row[] }) {
+  const [rows] = createSignal<Row[]>(props.rows)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} n={row.n} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    // Still bf_with_props (no derived field, so no rebuilder needed) — but
+    // the pair now names a field the child actually has.
+    expect(template).toContain('(bf_with_props $.BadgeSlot0 "Text" .Label "Count" .N)')
+    expect(template).not.toContain('bf_reprops')
+    const types = result.files.find(f => f.type === 'types')!.content
+    expect(types).not.toContain('RegisterReprops')
+  })
+
+  // Copilot review on #2462: `ChildComponentShape.paramNames` is looked up by
+  // the PARENT against the name it wrote at the JSX call site, so it has to be
+  // keyed the same way `childPropFieldNames` is. Keyed by the local binding,
+  // an aliased prop on a child that ALSO has a rest bag looked undeclared —
+  // `loopRowChildPropOverrides`' rest-bag guard skipped it outright, so the
+  // override never reached the template at all. Same wrong-name-at-a-
+  // parent-side-lookup bug as #2457, one guard earlier.
+  test('an aliased prop on a rest-bag child is not mistaken for a rest-bag prop', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Row = { id: number; label: string; n: number }
+function Badge({ text, n: count, ...rest }: { text: string; n: number; [k: string]: unknown }) {
+  return <span class="badge" {...rest}>{text}:{count}</span>
+}
+export function AliasedRestBagRowChild(props: { rows: Row[] }) {
+  const [rows] = createSignal<Row[]>(props.rows)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} n={row.n} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    // `n` is a DECLARED prop, so it rides the override under the child's own
+    // field name — not silently routed into the rest bag and not dropped.
+    expect(template).toContain('(bf_with_props $.BadgeSlot0 "Text" .Label "Count" .N)')
+  })
+
+  // Sound-or-loud fallback: a shape whose Input can NOT be reconstructed from
+  // Props gets no rebuilder, and the refusal has to stay. A `...rest` bag adds
+  // an Input field with no Props counterpart, so it is declined — and because
+  // `Badge` still derives `dbl` from `n`, emitting `bf_with_props` here would
+  // be the silently-stale output all of this exists to prevent.
+  test('a child whose Input cannot be rebuilt still refuses with BF101', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal, createMemo } from '@barefootjs/client'
+type Row = { id: number; label: string; n: number }
+function Badge({ text, n, ...rest }: { text: string; n: number; [k: string]: unknown }) {
+  const dbl = createMemo(() => n * 2)
+  return <span class="badge" {...rest}>{text}:{dbl()}</span>
+}
+export function RestBagRowChildDerivedProp(props: { rows: Row[] }) {
+  const [rows] = createSignal<Row[]>(props.rows)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} n={row.n} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const bf101s = (result.errors ?? []).filter(e => e.code === 'BF101')
+    expect(bf101s).toHaveLength(1)
+    expect(bf101s[0]!.message).toContain("'n'")
+    expect(bf101s[0]!.message).toContain('dbl')
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).not.toContain('bf_reprops')
+    expect(template).not.toContain('"N"')
+    // No rebuilder was emitted, so nothing registers a "Badge" entry that
+    // `bf_reprops` could have resolved at runtime.
+    expect(result.files.find(f => f.type === 'types')!.content).not.toContain('RegisterReprops')
+  })
+
+  // Regression pin for #2445: a nested child with NO derived field (no
+  // `createMemo`/`createSignal` reading the overridden prop) must still
+  // compile clean and still emit `bf_with_props` — this refusal must not fire
+  // on the shape #2445 already fixed.
+  test('a per-row-overridden prop with no derived field still emits bf_with_props', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number; label: string }
+function Badge(props: { text: string }) {
+  return <span class="badge">{props.text}</span>
+}
+export function CompositeRowChildComponent(props: { items: Item[] }) {
+  const [rows] = createSignal<Item[]>(props.items)
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}>
+          <Badge text={row.label} />
+        </li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const template = result.files.find(f => f.type === 'markedTemplate')!.content
+    expect(template).toContain('{{template "Badge" (bf_with_props $.BadgeSlot0 "Text" .Label)}}')
+  })
+})
+
 // #2228: a `.filter(t => …).map(todo => <Child todo={todo} .../>)` loop whose
 // body is a single child component ranges the WRAPPER slice (`.TodoItems`,
 // `.{ChildName}s` — see #2130 above), so `{{if}}`'s dot context for the