@barefootjs/go-template 0.17.0 → 0.17.1

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

@@ -58,6 +58,13 @@ runAdapterConformanceTests({
   // a `SearchParams bf.SearchParams` binding (zero value → empty query → the
   // author's default). See #1922; Mojo / Xslate stay skipped pending their own
   // env-signal lowering + per-request Perl reader.
+  //
+  // `search-params-derived-filter` (#2075) is no longer skipped: a LIST-
+  // valued memo derived from the searchParams() env signal (the blog
+  // `visible` filter shape) now SSR-computes via `bf.FilterEval` — the
+  // memo's field type is `[]any` and its constructor init serializes the
+  // `.filter` predicate to the runtime evaluator. See the #2075 constructor
+  // pins below.
   skipJsx: [],
   // Per-fixture build-time contracts for shapes the Go template
   // adapter intentionally refuses to lower. Lives here (not on the
@@ -98,6 +105,17 @@ runAdapterConformanceTests({
     // (`cn\`base \${tone()}\``) likewise can't lower into Go template
     // syntax — same BF101 refusal.
     'tagged-template-classname': [{ code: 'BF101', severity: 'error' }],
+    // #2038: a filter predicate whose body contains a NESTED callback call
+    // (`t => !picked().some(p => …)` / `t => picked().find(p => …)`). The
+    // evaluator refuses nested arrows and `renderFilterExpr` has no faithful
+    // Go form for the inner call (its `call` arm used to silently drop the
+    // arrow argument and render only the callee) — the compiler is loud
+    // instead of lossy. The `/* @client */` twin
+    // (`filter-nested-callback-predicate-client`) has no pin here: it must
+    // render clean on every adapter, which asserts the suppression contract.
+    // https://github.com/piconic-ai/barefootjs/issues/2038
+    'filter-nested-callback-predicate': [{ code: 'BF101', severity: 'error' }],
+    'filter-nested-find-predicate': [{ code: 'BF101', severity: 'error' }],
     // #1310: rest destructure in .map() callback. The object-rest shape read
     // via member access (`rest-destructure-object-in-map`) now lowers — each
     // binding resolves to a field on a synthetic `$__bf_item0` range var (the
@@ -154,6 +172,11 @@ runAdapterConformanceTests({
     // `string-trim` no longer pinned — pre-existing `bf_trim`
     // (wraps `strings.TrimSpace`) handles the strip (#1448 Tier A
     // ninth PR, closing out Tier A).
+    // #2073 follow-up: a function-reference `.map(format)` callback has no
+    // arrow body to serialize — not a CALLBACK_METHODS shape — so the
+    // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
+    // a broken template.
+    'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
   },
   // `JSON_STRINGIFY_VIA_CONST` and `MATH_FLOOR_VIA_CONST` now pass
   // via `GoTemplateAdapter.templatePrimitives` (#1188). The two
@@ -1830,6 +1853,31 @@ export function TodoList() {
       const bf101 = adapter.errors.filter(e => e.code === 'BF101')
       expect(bf101).toEqual([])
     })
+
+    test('nested-callback refusal keeps the emitted template syntactically valid (#2038)', () => {
+      // The BF101 contract itself is pinned at the shared conformance layer
+      // (`filter-nested-callback-predicate` / `filter-nested-find-predicate`
+      // expectedDiagnostics; the `/* @client */` suppression twin renders
+      // clean). This test pins the GO-SPECIFIC half: the refusal must emit
+      // the `false` sentinel — not a half-rendered predicate like `.Some` —
+      // so `text/template` parsing doesn't cascade into secondary errors.
+      const adapter = new GoTemplateAdapter()
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { id: number }
+
+export function Picker() {
+  const [items, setItems] = createSignal<Item[]>([])
+  const [picked, setPicked] = createSignal<Item[]>([])
+  return <ul>{items().filter(t => !picked().some(p => p.id === t.id)).map(t => <li key={t.id}>{t.id}</li>)}</ul>
+}
+`, adapter)
+      expect(adapter.errors.some(e => e.code === 'BF101')).toBe(true)
+      expect(result.template).not.toContain('.Some')
+      expect(result.template).toContain('{{if false}}')
+    })
   })
 
   describe('find/findIndex - adapter specific', () => {
@@ -2991,6 +3039,238 @@ export { C }
   })
 })
 
+describe('GoTemplateAdapter - #2075 searchParams()-derived memo constructor', () => {
+  // A memo derived from the createSearchParams() env signal SSR-computes in
+  // the generated constructor from the canonical `in.SearchParams` reader —
+  // including under a local alias. `Get` returns "" for an absent key, so
+  // the `??` default fires on "" — the same documented `?? → or` divergence
+  // as the template-position lowering.
+  test('computes an aliased `?? default` derived memo from in.SearchParams', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function SortStatus() {
+  const [sp] = createSearchParams()
+  const sort = createMemo(() => sp().get('sort') ?? 'date')
+  return <p>sort: {sort()}</p>
+}
+`, adapter)
+    const { types } = adapter.generate(ir)
+    expect(types).toContain(
+      'Sort: func() string { if v := in.SearchParams.Get("sort"); v != "" { return v }; return "date" }(),',
+    )
+  })
+
+  test('computes a bare env read memo from in.SearchParams', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function QueryEcho() {
+  const [searchParams] = createSearchParams()
+  const q = createMemo(() => searchParams().get('q'))
+  return <p>{q()}</p>
+}
+`, adapter)
+    const { types } = adapter.generate(ir)
+    expect(types).toContain('Q: in.SearchParams.Get("q"),')
+  })
+
+  // #2075 residual: a LIST-valued memo (`.filter(arrow)` over a props array)
+  // chained off the env-derived `tag` memo — the `search-params-derived-filter`
+  // shared fixture's shape. The field is `[]any` (not the misclassified `bool`
+  // the `/=>\s*!/` heuristic used to produce from the predicate's `!tag()`),
+  // and the constructor seeds it via `bf.FilterEval`, whose serialized
+  // predicate JSON is embedded (escaped) in the Go string literal.
+  test('computes a list-filter memo chained off a searchParams()-derived memo via bf.FilterEval', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  const [searchParams] = createSearchParams()
+  const tag = createMemo(() => searchParams().get('tag') ?? '')
+  const visible = createMemo(() => props.items.filter((p) => !tag() || p.tags.includes(tag())))
+  return <ul>{visible().map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+`, adapter)
+    const { types } = adapter.generate(ir)
+    expect(types).toContain('Visible []any')
+    expect(types).toContain('Visible: bf.FilterEval(in.Items,')
+    // The predicate JSON is escaped inside a Go double-quoted string literal,
+    // so assert on the substring that survives escaping (backslash-escaped
+    // quotes around the JSON keys/values).
+    expect(types).toContain('\\"method\\":\\"includes\\"')
+  })
+
+  // #2077 review finding 3: `tag` (an earlier sibling the `visible` filter's
+  // predicate closes over) used to be recomputed verbatim a second time
+  // inline in `visible`'s `bf.FilterEval` env map — the same
+  // `in.SearchParams.Get("tag")` expression emitted twice in the constructor.
+  // It's now hoisted to a shared local before the `return`, referenced by
+  // BOTH the `Tag:` field and the env-map entry.
+  test('hoists the earlier sibling memo instead of duplicating its expression', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  const [searchParams] = createSearchParams()
+  const tag = createMemo(() => searchParams().get('tag') ?? '')
+  const visible = createMemo(() => props.items.filter((p) => !tag() || p.tags.includes(tag())))
+  return <ul>{visible().map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+`, adapter)
+    const { types } = adapter.generate(ir)
+    expect(types).toContain('var memoTag string =')
+    expect(types).toContain('Tag: memoTag,')
+    expect(types).toContain('"tag": memoTag')
+    // The multi-token `Get("tag")` expression appears exactly once in the
+    // whole constructor — the hoisted local, not a second inline copy.
+    expect(types.split('in.SearchParams.Get("tag")').length).toBe(2)
+  })
+})
+
+describe('GoTemplateAdapter - env-derived memo sourced from the SSR seed plan (Package I)', () => {
+  // `CompileState.ssrSeedPlan` (and `envSignalReadersByLocal` derived from it)
+  // is now the single authority for env-reader recognition. `compileToIR`
+  // already JSON-round-trips the IR (mirrors the adapter conformance
+  // harness), so each `env-reader` step's `reader.methods` — a ReadonlySet —
+  // arrives serialized to `{}`; `primeCompileState` re-resolves a live reader
+  // via `envSignalReaderFor(step.reader.key)` before trusting `.methods`.
+  // Pins that the env-derived memo constructor still SSR-computes through
+  // that re-resolution instead of silently falling back to a zero value.
+  test('computes an env-derived memo constructor through the JSON-round-tripped ssrSeedPlan', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function QueryEcho() {
+  const [searchParams] = createSearchParams()
+  const q = createMemo(() => searchParams().get('q'))
+  return <p>{q()}</p>
+}
+`, adapter)
+    const { types } = adapter.generate(ir)
+    expect(types).toContain('Q: in.SearchParams.Get("q"),')
+  })
+})
+
+describe('GoTemplateAdapter - #2077 review sibling-memo recursion guard', () => {
+  // Finding 1: mutually-referencing memos (each resolving the other as a
+  // filter-arm free var, or as a bare-getter ternary condition) used to
+  // recurse without bound and blow the compiler's call stack
+  // (`RangeError: Maximum call stack size exceeded`, verified by probe before
+  // the fix). The cycle/declaration-order guard makes both directions fall
+  // back to the field's Go zero value instead of throwing.
+  test('mutual filter-arm memos compile without throwing and fall back to zero values', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C(props: { items: { title: string }[] }) {
+  const a = createMemo(() => props.items.filter((x) => Boolean(b())))
+  const b = createMemo(() => props.items.filter((x) => Boolean(a())))
+  return <ul>{a().map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+`, adapter)
+    let types = ''
+    expect(() => { types = adapter.generate(ir).types }).not.toThrow()
+    expect(types).toContain('A []any')
+    expect(types).toContain('B []any')
+    // Neither memo can resolve the OTHER as a free var (order rules out both
+    // directions at once — `a` can't see `b` because `b` is declared later,
+    // and vice versa), so `a`'s own computation falls back to the `[]any`
+    // zero value (hoisted since `b` references it), and `b`'s free-var
+    // resolution of `a` reuses that hoisted zero-valued local.
+    expect(types).toContain('var memoA []any = nil')
+    expect(types).toContain('A: memoA,')
+    expect(types).toContain('B: bf.FilterEval(in.Items,')
+    expect(types).toContain('map[string]any{"a": memoA}')
+  })
+
+  test('mutual ternary memos (bare-getter condition) compile without throwing and fall back to zero values', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C() {
+  const a = createMemo(() => (b() ? 'A' : 'Z'))
+  const b = createMemo(() => (a() ? 'B' : 'Y'))
+  return <p>{a()}{b()}</p>
+}
+`, adapter)
+    let types = ''
+    expect(() => { types = adapter.generate(ir).types }).not.toThrow()
+    expect(types).toContain('A: "",')
+    expect(types).toContain('B: "",')
+  })
+
+  test('self-referencing filter-arm memo compiles without throwing', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C(props: { items: { title: string }[] }) {
+  const a = createMemo(() => props.items.filter((x) => Boolean(a())))
+  return <ul>{a().map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+`, adapter)
+    let types = ''
+    expect(() => { types = adapter.generate(ir).types }).not.toThrow()
+    expect(types).toContain('A: nil,')
+  })
+
+  test('self-referencing ternary memo compiles without throwing', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C() {
+  const a = createMemo(() => (a() ? 'A' : 'Z'))
+  return <p>{a()}</p>
+}
+`, adapter)
+    let types = ''
+    expect(() => { types = adapter.generate(ir).types }).not.toThrow()
+    expect(types).toContain('A: "",')
+  })
+})
+
+describe('GoTemplateAdapter - #2073 value-producing .map(cb)', () => {
+  function emitMap(expr: string): string {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function C({ tags, users }: { tags: string[]; users: { name: string }[] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, adapter)
+    return adapter.generate(ir).template ?? ''
+  }
+
+  // The blog-showcase shape (#1938/#1939): a value-returning `.map` (string
+  // projection, not JSX) lowers through the evaluator — `bf_map_eval` projects
+  // each element (no flatten) and composes through `bf_join`. (Like the
+  // flatMap pins below, the projection JSON's quotes are backslash-escaped in
+  // the Go-template string; the JSON itself is verified by the render
+  // conformance fixtures + the runtime TestMapEval.)
+  test('.map(t => `#${t}`).join(" ") emits bf_map_eval composed into bf_join', () => {
+    const t = emitMap("tags.map(t => `#${t}`).join(' ')")
+    expect(t).toContain('bf_join (bf_map_eval .Tags')
+  })
+
+  test('.map(u => u.name) emits bf_map_eval with the receiver', () => {
+    const t = emitMap("users.map(u => u.name).join(', ')")
+    expect(t).toContain('bf_map_eval .Users')
+  })
+
+  // The function-reference `.map(format)` BF101 refusal is now covered
+  // cross-adapter by the `array-map-function-reference` shared fixture's
+  // `expectedDiagnostics` entry above.
+})
+
 describe('GoTemplateAdapter - #1448 Tier C .flatMap(field projection)', () => {
   function emitFlatMap(expr: string): string {
     const adapter = new GoTemplateAdapter()

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

@@ -62,8 +62,9 @@ import {
   isLowerableObjectRestDestructure,
   type ContextConsumer,
   collectModuleStringConsts as collectModuleStringConstsShared,
-  searchParamsLocalNames,
-  prepareLoweringMatchers
+  prepareLoweringMatchers,
+  envSignalReaderFor,
+  computeSsrSeedPlan,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
 import { BF_REGION } from '@barefootjs/shared'
@@ -85,6 +86,7 @@ import {
   emitReduceEval,
   emitPredicateEval,
   emitFlatMapEval,
+  emitMapEval,
   stringTolerantEqOperands,
   buildUnsupportedSuggestion,
   GO_REMEDIATION_OPTIONS,
@@ -115,10 +117,10 @@ import {
   objectLiteralToGoMap,
 } from "./value/value-lowering.ts"
 import { typeInfoToGo } from "./type/type-codegen.ts"
-import { isBooleanMemo, isStringTernaryMemo } from "./memo/memo-type.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 } from "./memo/memo-compute.ts"
+import { computeMemoInitialValue, computeMemoInitialValueOrNull, filterArmEarlierSiblingRefs } from "./memo/memo-compute.ts"
 import { collectSpreadSlots, buildSpreadInitializer } from "./spread/spread-codegen.ts"
 import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames } from "./props/prop-types.ts"
 
@@ -272,7 +274,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.state.currentMemos = ir.metadata.memos ?? []
     this.state.currentTypeDefinitions = ir.metadata.typeDefinitions ?? []
     this.state.contextConsumers = collectContextConsumers(ir.metadata)
-    this.state.searchParamsLocals = searchParamsLocalNames(ir.metadata)
+    // Single authority (Package G): the plan already decided which signals are
+    // per-request env readers, in declaration order. `ir.metadata.ssrSeedPlan`
+    // may be absent for hand-built metadata (tests), hence the fallback to the
+    // same shared computation rather than a second, divergent derivation.
+    this.state.ssrSeedPlan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata)
+    this.state.envSignalReadersByLocal = new Map()
+    this.state.searchParamsLocals = new Set()
+    for (const step of this.state.ssrSeedPlan.steps) {
+      if (step.kind !== 'env-reader') continue
+      // `reader.methods` is a ReadonlySet — JSON round-tripping (adapter
+      // conformance harness) serializes it to `{}`, so re-resolve a live
+      // reader from the registry by key instead of trusting `step.reader`.
+      const reader = envSignalReaderFor(step.reader.key)
+      if (reader) this.state.envSignalReadersByLocal.set(step.name, reader)
+      if (step.reader.key === 'search') this.state.searchParamsLocals.add(step.name)
+    }
     this.state.loweringMatchers = prepareLoweringMatchers(ir.metadata)
     augmentInheritedPropAccesses(ir)
   }
@@ -1000,6 +1017,38 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     this.emitDynamicBodyWrappers(lines, ir, componentName, dynamicWithBody, propFallbackVars, emittedWrapperVars)
 
+    // Sibling-memo hoisting (#2075/#2077 review finding 3): a filter-arm memo
+    // whose predicate free vars reference an EARLIER sibling memo would
+    // otherwise recompute that sibling's whole expression a second time
+    // inline in its `bf.FilterEval` env map, duplicating it against the
+    // sibling's own field. Two-pass: first collect which memos are
+    // referenced this way, then hoist each into a local emitted once before
+    // the `return`; the memo-field loop below (and the referencing memo's own
+    // env-map entry, via `ctx.state.hoistedMemoLocals`) both reuse the local
+    // instead of re-emitting the expression. Declared `var name Type = value`
+    // (not `:=`) because an unresolved computation can fall back to the bare
+    // `nil` literal, which `:=` can't type-infer.
+    const memoPropsParamMap = new Map(ir.metadata.propsParams.map(p => [p.name, p]))
+    this.state.hoistedMemoLocals = new Map()
+    const hoistNames = new Set<string>()
+    for (const memo of ir.metadata.memos) {
+      for (const name of filterArmEarlierSiblingRefs(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams)) {
+        hoistNames.add(name)
+      }
+    }
+    if (hoistNames.size > 0) {
+      for (const memo of ir.metadata.memos) {
+        if (!hoistNames.has(memo.name)) continue
+        const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap)
+        const value = computeMemoInitialValue(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType)
+        let localName = `memo${capitalizeFieldName(memo.name)}`
+        while (GO_KEYWORDS.has(localName)) localName += '_'
+        lines.push(`\tvar ${localName} ${goType} = ${value}`)
+        this.state.hoistedMemoLocals.set(memo.name, localName)
+      }
+      lines.push('')
+    }
+
     lines.push(`\treturn ${propsTypeName}{`)
     lines.push('\t\tScopeID: scopeID,')
     // Host context, for when *this* component is itself a slot-attached child.
@@ -1097,11 +1146,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
 
     // Memo initial values (from signal initials). Prop-shadowing memos were
-    // folded into the prop field above.
-    const memoPropsParamMap = new Map(ir.metadata.propsParams.map(p => [p.name, p]))
+    // folded into the prop field above; a memo the pre-pass already hoisted
+    // (above) reuses that local instead of recomputing its expression.
     for (const memo of ir.metadata.memos) {
       const fieldName = capitalizeFieldName(memo.name)
       if (propFieldNames.has(fieldName)) continue
+      const hoistedLocal = this.state.hoistedMemoLocals.get(memo.name)
+      if (hoistedLocal) {
+        lines.push(`\t\t${fieldName}: ${hoistedLocal},`)
+        continue
+      }
       // Pass the inferred Go type so an unresolved computation zeroes to that
       // type (`false` for a boolean memo), not the int `0`.
       const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap)
@@ -2095,10 +2149,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
 
       // A memo: when no pattern applies, return null so the caller OMITS the
-      // field and Go's typed zero value applies.
+      // field and Go's typed zero value applies. Seed the resolution stack
+      // with this memo's own name — a fresh top-level computation, so
+      // self-reference must be caught on the first recursion.
       const memo = memos.find(m => m.name === getterName)
       if (memo) {
-        return computeMemoInitialValueOrNull(this.emitCtx, memo, signals, propsParams)
+        return computeMemoInitialValueOrNull(
+          this.emitCtx, memo, signals, propsParams, undefined, new Set([memo.name]),
+        )
       }
     }
 
@@ -2111,6 +2169,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     signals: { getter: string; initialValue: string; type: TypeInfo }[],
     propsParamMap: Map<string, { name: string; type: TypeInfo; defaultValue?: string }>
   ): string {
+    // A LIST-valued `.filter(arrow)` memo (#2075 — the blog PostList `visible`
+    // shape) is a slice of the receiver's boxed elements, not a scalar.
+    // Decided FIRST, ahead of the memo's declared `type` and every other
+    // heuristic below: the analyzer's simple per-memo type inference doesn't
+    // model `.filter`'s predicate shape and can land on a bogus primitive
+    // (observed: `boolean`, from the predicate's own `!`/`||` structure),
+    // which would otherwise sail through the `typeInfoToGo(memo.type) ===
+    // 'interface{}'` gates below unchallenged. `bf.FilterEval` (the SSR
+    // constructor lowering, memo-compute.ts) returns `[]any`; the template's
+    // `range` / reflective field access handle the boxed elements the same
+    // way it already handles other `interface{}`-typed slices.
+    if (isListFilterMemo(memo)) return '[]any'
+
     // A template-literal memo always produces a string. Decide this first so a
     // class-string `/` (e.g. `ring-ring/50`) doesn't trip the arithmetic
     // heuristic below into `int`. The analyzer classified the body shape from
@@ -3077,6 +3148,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return this.pushCallbackBF101(method, true)
     }
 
+    // Value-producing `.map(cb)` (#2073): eval-only. (The JSX-returning
+    // `.map` is an IRLoop upstream and never reaches this dispatch.)
+    if (method === 'map') {
+      const evalForm = emitMapEval(recv, body, params[0] ?? '_', emit)
+      if (evalForm !== null) return evalForm
+      return this.pushCallbackBF101(method, true)
+    }
+
     return this.pushCallbackBF101(method, true)
   }
 
@@ -3657,6 +3736,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
           return `$.${capitalizeFieldName(expr.callee.name)}`
         }
+        // A nested callback method call (`other.some(r => …)`) reaching this
+        // arm has no Go template form in filter context — the fallthrough
+        // below renders only the callee and silently DROPS the arrow argument,
+        // changing predicate semantics (#2038). The one faithful nested shape
+        // (`.filter(cb).length` → `len (bf_filter_eval …)`) is intercepted at
+        // the `member` arm before this node is visited; everything else must
+        // be loud.
+        if (asCallbackMethodCall(expr) !== null) {
+          return this.refuseFilterExprNode(expr)
+        }
         const result = this.renderFilterExpr(expr.callee, param, localVarMap)
         if (this.filterExprUnsupported) return 'false'
         return result
@@ -3721,31 +3810,37 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         return `or (${left}) (${right})`
       }
 
-      default: {
-        // The filter predicate body contains a node kind we can't lower to a Go
-        // template action — most commonly a nested higher-order
-        // (`x => x.tags.filter(...).length > 0`). Surface BF101 with the
-        // offending expression. Set the recursion-wide `filterExprUnsupported`
-        // flag so parent branches return `false` instead of wrapping the
-        // sentinel into `false.Length` / `gt false.Length 0` etc.: the build
-        // fails on BF101 anyway, but the emitted template must stay
-        // syntactically valid so `text/template` parsing doesn't cascade into
-        // confusing secondary errors.
-        this.filterExprUnsupported = true
-        this.state.errors.push({
-          code: 'BF101',
-          severity: 'error',
-          message: `Filter predicate contains an expression that cannot be lowered to a Go template action: ${exprToString(expr)}`,
-          loc: this.makeLoc(),
-          suggestion: {
-            message: 'Options:\n1. Use /* @client */ for client-side evaluation\n2. Rewrite the predicate to avoid nested higher-order methods (`.filter()` / `.map()` / etc. inside the predicate body)',
-          },
-        })
-        return 'false'
-      }
+      default:
+        // The filter predicate body contains a node kind we can't lower to a
+        // Go template action. Shared refusal with the nested-callback guard in
+        // the `call` arm (#2038).
+        return this.refuseFilterExprNode(expr)
     }
   }
 
+  /**
+   * Refuse a filter-predicate node that has no Go template lowering. Surfaces
+   * BF101 with the offending expression and sets the recursion-wide
+   * `filterExprUnsupported` flag so parent branches return `false` instead of
+   * wrapping the sentinel into `false.Length` / `gt false.Length 0` etc.: the
+   * build fails on BF101 anyway, but the emitted template must stay
+   * syntactically valid so `text/template` parsing doesn't cascade into
+   * confusing secondary errors.
+   */
+  private refuseFilterExprNode(expr: ParsedExpr): string {
+    this.filterExprUnsupported = true
+    this.state.errors.push({
+      code: 'BF101',
+      severity: 'error',
+      message: `Filter predicate contains an expression that cannot be lowered to a Go template action: ${exprToString(expr)}`,
+      loc: this.makeLoc(),
+      suggestion: {
+        message: 'Options:\n1. Use /* @client */ for client-side evaluation\n2. Rewrite the predicate to avoid nested higher-order methods (`.filter()` / `.map()` / etc. inside the predicate body)',
+      },
+    })
+    return 'false'
+  }
+
   /**
    * Whether a ParsedExpr renders as a Go template function call (so it needs
    * parentheses around it).

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

@@ -13,10 +13,12 @@
 import type {
   CompilerError,
   ContextConsumer,
+  EnvSignalReader,
   IRMetadata,
   IRNode,
   LoweringMatcher,
   MemoInfo,
+  SsrSeedPlan,
   TypeDefinition,
   TypeInfo,
 } from '@barefootjs/jsx'
@@ -90,6 +92,35 @@ export class CompileState {
    */
   searchParamsLocals: Set<string> = new Set()
 
+  /**
+   * Env-signal getter (local binding name, e.g. `searchParams` or an alias) →
+   * its registered {@link EnvSignalReader}, keyed by the RECEIVER signal's own
+   * `envReader` registration rather than a hardcoded key — so a memo body's
+   * `<local>().<method>(...)` resolves to whichever reader that particular
+   * local belongs to (open-closed for a future second env signal).
+   */
+  envSignalReadersByLocal: Map<string, EnvSignalReader> = new Map()
+
+  /**
+   * The backend-neutral SSR seed plan (`computeSsrSeedPlan`, Package G) for
+   * the IR currently being compiled — single authority for which signal/memo
+   * getters are value-materializable at SSR time (`env-reader` steps are
+   * per-request readers; everything else is `derived`/`opaque`). Populated in
+   * `primeCompileState`; `envSignalReadersByLocal` and `searchParamsLocals`
+   * derive from it there, and the memo-analysis path in `memo-compute.ts`
+   * reads its `steps` directly instead of re-deriving from `metadata`.
+   */
+  ssrSeedPlan: SsrSeedPlan = { baseScope: [], steps: [] }
+
+  /**
+   * Memo name → the hoisted Go local variable name the constructor assigned
+   * its SSR value to (populated by the sibling-memo hoisting pre-pass before
+   * the main memo-field loop runs). When a later filter-arm memo's free-var
+   * resolution finds an entry here, it reuses the local instead of
+   * recomputing the sibling's expression a second time.
+   */
+  hoistedMemoLocals: Map<string, string> = new Map()
+
   /**
    * Call-lowering matchers active for this component (#2057), bound to its
    * metadata at init via `prepareLoweringMatchers`. Each maps a recognised call

package/src/adapter/lib/go-emit.ts

@@ -192,6 +192,26 @@ export function emitFlatMapEval(
   return `bf_flat_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`
 }
 
+/**
+ * Emit a value-producing `.map(cb)` via the evaluator (#2073): the projection
+ * body is serialized and evaluated per element by `bf_map_eval`, one result
+ * per element (no flatten — the JS `.map` contract). Composes through the
+ * array-method chain (`bf_join (bf_map_eval …) " "`). Returns null when the
+ * projection is outside the evaluator surface (→ caller pushes BF101). The
+ * JSX-returning `.map` is an IRLoop upstream and never reaches this emit.
+ */
+export function emitMapEval(
+  recv: string,
+  body: ParsedExpr,
+  param: string,
+  emit: (e: ParsedExpr) => string,
+): string | null {
+  const json = serializeParsedExpr(body)
+  if (json === null) return null
+  const env = emitEvalEnvArg(body, [param], emit)
+  return `bf_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`
+}
+
 /**
  * Make an equality comparison string-tolerant when exactly one side is a Go
  * string literal: JS `sorted === 'asc'` is loosely false for `sorted = false`,