@barefootjs/go-template 0.16.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
@@ -226,8 +249,9 @@ describe('GoTemplateAdapter - searchParams() env-signal lowering (#1922)', () =>
   test('lowers searchParams().get(k) to .SearchParams.Get and emits the struct binding', () => {
     const adapter = new GoTemplateAdapter()
     const ir = compileToIR(`
-import { searchParams } from '@barefootjs/client'
+import { createSearchParams } from '@barefootjs/client'
 export function SortLabel() {
+  const [searchParams] = createSearchParams()
   return <p>{searchParams().get('sort') ?? 'none'}</p>
 }
 `, adapter)
@@ -237,14 +261,15 @@ export function SortLabel() {
     expect(types).toContain('SearchParams: in.SearchParams')
   })
 
-  // An aliased import binds the env signal to a different local name; the
-  // call `sp()` still resolves to the canonical `.SearchParams` field (the
-  // generated struct field name is fixed, not derived from the JS alias).
-  test('aliased import (`searchParams as sp`) resolves sp() to canonical .SearchParams', () => {
+  // An aliased destructured getter binds the env signal to a different local
+  // name; the call `sp()` still resolves to the canonical `.SearchParams` field
+  // (the generated struct field name is fixed, not derived from the JS name).
+  test('aliased env-signal getter (`const [sp] = createSearchParams()`) resolves sp() to canonical .SearchParams', () => {
     const adapter = new GoTemplateAdapter()
     const ir = compileToIR(`
-import { searchParams as sp } from '@barefootjs/client'
+import { createSearchParams } from '@barefootjs/client'
 export function SortLabel() {
+  const [sp] = createSearchParams()
   return <p>{sp().get('sort') ?? 'none'}</p>
 }
 `, adapter)
@@ -267,8 +292,9 @@ describe('GoTemplateAdapter - template-literal text lowering (#1933)', () => {
     const adapter = new GoTemplateAdapter()
     const ir = compileToIR(`
 'use client'
-import { createMemo, searchParams } from '@barefootjs/client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
 export function StatusLine() {
+  const [searchParams] = createSearchParams()
   const tag = createMemo(() => searchParams().get('tag') ?? '')
   return (
     <div className="status">
@@ -735,6 +761,28 @@ export function Tags() {
       )
     })
 
+    test('bakes a numeric scalar array from the carried tree (Roadmap A-3)', () => {
+      // The analyzer carries `SignalInfo.parsed`, so the scalar-array bake
+      // reads the structured tree (`parsedLiteralToGo`) instead of re-parsing
+      // the value string with `ts.createSourceFile`. Each numeric element uses
+      // the carried raw token (= `NumericLiteral.text`), so the bake matches
+      // the fallback byte-for-byte — including TS's `.text` normalisation of
+      // `1e3` → `1000` and `0x10` → `16`.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Nums() {
+  const [ns] = createSignal<number[]>([1, 2, 1e3, 0x10])
+  return <ul>{ns().map((n) => <li key={n}>{n}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(ir).types!).toContain(
+        'Ns: []int{1, 2, 1000, 16},',
+      )
+    })
+
     test('synthesises a struct for an untyped object array and bakes it (#1680)', () => {
       // An untyped object array has no element type to bake against. Rather
       // than leave it nil (empty SSR loop), infer a struct from the literal's
@@ -1715,7 +1763,9 @@ export function TodoStatus() {
   return <div>{todos().every(t => t.done)}</div>
 }
 `)
-      expect(result.template).toContain('bf_every .Todos "Done"')
+      // #2018 P2: `.every(t => t.done)` now lowers through the evaluator —
+      // the predicate body travels as serialized ParsedExpr JSON.
+      expect(result.template).toContain('bf_every_eval .Todos')
     })
 
     test('nested .filter(...).length in filter predicate lowers via len (bf_filter ...) (#1443 PR4)', () => {
@@ -1745,7 +1795,7 @@ export function TodoList() {
 }
 `, adapter)
       expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
-      expect(result.template).toContain('gt (len (bf_filter .Tags "Active" true)) 0')
+      expect(result.template).toContain('gt (len (bf_filter_eval .Tags')
       // No degenerate fallbacks
       expect(result.template).not.toContain('{{if false}}')
       expect(result.template).not.toContain('[UNSUPPORTED-FILTER-EXPR]')
@@ -1776,7 +1826,7 @@ export function TodoList() {
   )
 }
 `, adapter)
-      expect(result.template).toContain('gt (len (bf_filter .Tags "Active" true)) 0')
+      expect(result.template).toContain('gt (len (bf_filter_eval .Tags')
       expect(result.template).toContain('{{if not .Done}}')
     })
 
@@ -1803,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', () => {
@@ -1837,7 +1912,10 @@ export function ItemChecker() {
   return <div>{items().find(t => t.done) ? 'Found' : 'Not found'}</div>
 }
 `)
-      expect(result.template).toContain('bf_find .Items "Done" true')
+      // #2018 P2: `.find(t => t.done)` lowers through the evaluator; the
+      // trailing `true` is the forward-search flag (find / findIndex).
+      expect(result.template).toContain('bf_find_eval .Items')
+      expect(result.template).toContain('true bf_env')
       expect(result.template).toContain('Found')
     })
   })
@@ -1855,7 +1933,10 @@ export function ItemChecker() {
   return <div>{items().findLast(t => t.done) ? 'Found' : 'Not found'}</div>
 }
 `)
-      expect(result.template).toContain('bf_find_last .Items "Done" true')
+      // #2018 P2: `.findLast(t => t.done)` shares `bf_find_eval` with `.find`,
+      // distinguished by the `false` (backward) forward-flag.
+      expect(result.template).toContain('bf_find_eval .Items')
+      expect(result.template).toContain('false bf_env')
       expect(result.template).toContain('Found')
     })
 
@@ -1889,10 +1970,20 @@ export function ItemChecker() {
   return <div>idx: {items().findLastIndex(t => t.done)}</div>
 }
 `)
-      expect(result.template).toContain('bf_find_last_index .Items "Done" true')
-    })
-
-    test('renders findLastIndex() with complex predicate via range', () => {
+      // #2018 P2: `.findLastIndex` lowers via `bf_find_index_eval` with the
+      // `false` (backward) forward-flag.
+      expect(result.template).toContain('bf_find_index_eval .Items')
+      expect(result.template).toContain('false bf_env')
+    })
+
+    test('renders findLastIndex() with a pure complex predicate via the evaluator', () => {
+      // #2018 P2: a pure (call-free) complex predicate like
+      // `t.price > 50 && t.active` is no longer confined to the
+      // field-equality catalogue — it serializes to a ParsedExpr and lowers
+      // through `bf_find_index_eval` (backward `false` flag), replacing the
+      // old `{{range}}` $bf_r accumulator. The range fallback is now reserved
+      // for predicates the evaluator can't model (e.g. a signal-getter call,
+      // covered by the findLast test above).
       const result = compileAndGenerate(`
 "use client"
 import { createSignal } from "@barefootjs/client"
@@ -1904,10 +1995,9 @@ export function ItemFinder() {
   return <div>{items().findLastIndex(t => t.price > 50 && t.active)}</div>
 }
 `)
-      const varMatch = result.template.match(/(\$bf_r\d+) := -1/)
-      expect(varMatch).not.toBeNull()
-      expect(result.template).toContain(`${varMatch![1]} = $i`)
-      expect(result.template).not.toContain('{{break}}')
+      expect(result.template).toContain('bf_find_index_eval .Items')
+      expect(result.template).toContain('false bf_env')
+      expect(result.template).not.toContain('$bf_r')
     })
 
     test('findLast() complex predicate in IR-level ternary works via preamble splitting', () => {
@@ -2428,7 +2518,9 @@ export function C() {
   return <ul>{items().filter(({done}) => done).map(t => <li key={t.id}>{t.name}</li>)}</ul>
 }`)
       expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
-      expect(result.template).toContain('bf_filter .Items "Done" true')
+      // #2018 P2: the normalised `_t => _t.done` predicate lowers through the
+      // evaluator (`bf_filter_eval`).
+      expect(result.template).toContain('bf_filter_eval .Items')
     })
 
     test('.filter(function (x) { return x.done }).map(...) lowers cleanly', () => {
@@ -2441,7 +2533,9 @@ export function C() {
   return <ul>{items().filter(function (x) { return x.done }).map(t => <li key={t.id}>{t.name}</li>)}</ul>
 }`)
       expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
-      expect(result.template).toContain('bf_filter .Items "Done" true')
+      // #2018 P2: the normalised `_t => _t.done` predicate lowers through the
+      // evaluator (`bf_filter_eval`).
+      expect(result.template).toContain('bf_filter_eval .Items')
     })
   })
 
@@ -2837,19 +2931,23 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
     // #1448 Tier B — string → string, padded to a target width.
     { fixture: stringPadStartFixture,   expect: 'bf_pad_start .Value 5 "0"' },
     { fixture: stringPadEndFixture,     expect: 'bf_pad_end .Value 5 "."' },
-    // #1448 Tier B — sort / toSorted. Loop-chained shapes wrap the
-    // iterable in `bf_sort .Items <kind> <key> <type> <dir>`;
-    // standalone shapes inline the helper at the call site.
-    { fixture: arraySortFieldAscFixture,  expect: 'bf_sort .Items "field" "Price" "numeric" "asc"' },
-    { fixture: arraySortFieldDescFixture, expect: 'bf_sort .Items "field" "Price" "numeric" "desc"' },
-    { fixture: arraySortPrimitiveFixture, expect: 'bf_sort .Nums "self" "" "numeric" "asc"' },
+    // #1448 Tier B — sort / toSorted. Both the standalone shapes and the
+    // `.sort().map()` loop-hoist now lower through the evaluator (#2018 P1/P3):
+    // the comparator body travels as serialized ParsedExpr to `bf_sort_eval`.
+    { fixture: arraySortFieldAscFixture,  expect: 'bf_sort_eval .Items' },
+    { fixture: arraySortFieldDescFixture, expect: 'bf_sort_eval .Items' },
+    { fixture: arraySortPrimitiveFixture, expect: 'bf_sort_eval .Nums' },
+    // localeCompare can't be evaluated, so it keeps the legacy `bf_sort` path
+    // (both standalone and loop-hoist fall back).
     { fixture: arraySortLocaleFixture,    expect: 'bf_sort .Names "self" "" "string" "asc"' },
-    // Multi-key (`||`-chain): one 4-string group per comparison key,
-    // applied in priority order as tie-breakers.
+    // Multi-key (`||`-chain) here ends in a `localeCompare`, so the whole
+    // comparator falls back to the structured `bf_sort` (one 4-string group
+    // per comparison key, applied in priority order as tie-breakers).
     { fixture: arraySortMultiKeyFixture,  expect: 'bf_sort .Items "field" "Price" "numeric" "asc" "field" "Name" "string" "asc"' },
-    // Relational-ternary comparator lowers to a single `auto` key.
-    { fixture: arraySortTernaryFixture,   expect: 'bf_sort .Items "field" "Rank" "auto" "asc"' },
-    { fixture: arrayToSortedFixture,      expect: 'bf_sort .Nums "self" "" "numeric" "asc"' },
+    // Relational-ternary comparator — a pure body, so it lowers via the
+    // evaluator like the other field sorts.
+    { fixture: arraySortTernaryFixture,   expect: 'bf_sort_eval .Items' },
+    { fixture: arrayToSortedFixture,      expect: 'bf_sort_eval .Nums' },
     // #1448 Tier B — iteration shapes. These are loop-level
     // patterns (range binding order), not helper function calls.
     { fixture: arrayEntriesFixture,       expect: '{{range $i, $v := .Items}}' },
@@ -2894,14 +2992,14 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
 // now listed in `UNSUPPORTED_METHODS`, so `isSupported` refuses them
 // and `convertExpressionToGo` records BF101 — the same treatment the
 // unsupported array methods already got. These tests pin that parity.
-describe('GoTemplateAdapter - #1448 Tier C reduce field capitalisation', () => {
-  // #1728 review: `bf_reduce`'s projected field name must use the same
-  // initialism-aware capitalisation the adapter applies when generating
-  // struct fields (`capitalizeFieldName`), or the runtime reflect lookup
-  // misses the exported field (`id` → struct `ID`, not `Id`) and folds a
-  // zero value. Pin the emitted key so a regression to plain
-  // first-letter capitalisation fails here.
-  test('reduce over an initialism field emits the Go-initialism key (ID, not Id)', () => {
+describe('GoTemplateAdapter - #2018 reduce via the evaluator', () => {
+  // A standalone `.reduce(fn, init)` now lowers through the evaluator: the
+  // reducer body is serialized to ParsedExpr JSON and folded by `bf_reduce_eval`.
+  // The body carries the JS field name (`x.id`); the runtime field reader
+  // (`getFieldValue`) resolves it case-variantly against the Go struct field
+  // (`ID`) at render time, so no compile-time capitalisation is needed (the
+  // former #1728 initialism gotcha is moot on this path).
+  test('reduce over a field lowers to bf_reduce_eval with the serialized body', () => {
     const adapter = new GoTemplateAdapter()
     const ir = compileToIR(`
 function C({ items }: { items: { id: number }[] }) {
@@ -2910,8 +3008,9 @@ function C({ items }: { items: { id: number }[] }) {
 export { C }
 `, adapter)
     const template = adapter.generate(ir).template ?? ''
-    expect(template).toContain('bf_reduce .Items "+" "field" "ID" "numeric" "0"')
-    expect(template).not.toContain('"Id"')
+    expect(template).toContain('bf_reduce_eval .Items')
+    // The seed is threaded through bf_number; the body is the serialized tree.
+    expect(template).toContain('(bf_number "0")')
   })
 })
 
@@ -2940,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()
@@ -2952,20 +3283,32 @@ export { C }
     return adapter.generate(ir).template ?? ''
   }
 
-  test('.flatMap(i => i.field) emits bf_flat_map with the Go-capitalised field', () => {
-    expect(emitFlatMap('rows.flatMap(i => i.tags).join(" ")')).toContain('bf_flat_map .Rows "field" "Tags"')
+  // #2018 P3: `.flatMap(proj)` lowers through the evaluator — the projection
+  // body serializes to ParsedExpr JSON and `bf_flat_map_eval` flattens the
+  // results one level. The raw (lowercase) field name travels in the JSON; the
+  // runtime field reader resolves it case-insensitively against Go data.
+  // (The serialized projection JSON is embedded in a Go-template double-quoted
+  // string — its quotes are backslash-escaped — so these pins assert the helper
+  // + receiver; the projection JSON itself is verified by the render
+  // conformance fixtures + the runtime TestFlatMapEval.)
+  test('.flatMap(i => i.field) emits bf_flat_map_eval', () => {
+    expect(emitFlatMap('rows.flatMap(i => i.tags).join(" ")')).toContain('bf_flat_map_eval .Rows')
   })
 
-  test('.flatMap(i => i) emits the self projection', () => {
-    expect(emitFlatMap('rows.flatMap(i => i).join(" ")')).toContain('bf_flat_map .Rows "self" ""')
+  test('.flatMap(i => i) emits bf_flat_map_eval (self projection)', () => {
+    expect(emitFlatMap('rows.flatMap(i => i).join(" ")')).toContain('bf_flat_map_eval .Rows')
   })
 
-  test('.flatMap(i => [i.a, i.b]) emits bf_flat_map_tuple with capitalised leaves', () => {
-    expect(emitFlatMap('rows.flatMap(i => [i.a, i.b]).join(" ")')).toContain('bf_flat_map_tuple .Rows "field" "A" "field" "B"')
+  test('.flatMap(i => [i.a, i.b]) emits bf_flat_map_eval (array-literal projection)', () => {
+    expect(emitFlatMap('rows.flatMap(i => [i.a, i.b]).join(" ")')).toContain('bf_flat_map_eval .Rows')
   })
 
-  test('tuple self + field leaves', () => {
-    expect(emitFlatMap('rows.flatMap(i => [i, i.a]).join(" ")')).toContain('bf_flat_map_tuple .Rows "self" "" "field" "A"')
+  // (#2018 P5) A tuple with a string-literal element lowers the same way: the
+  // whole array-literal body serializes and `bf_flat_map_eval` evaluates it per
+  // item, so a non-member element no longer refuses (it did under the structured
+  // `bf_flat_map_tuple` catalogue).
+  test('.flatMap(i => [i.name, "x"]) emits bf_flat_map_eval (literal element)', () => {
+    expect(emitFlatMap('rows.flatMap(i => [i.name, "x"]).join(" ")')).toContain('bf_flat_map_eval .Rows')
   })
 })
 
@@ -3019,9 +3362,10 @@ export function C() {
     // the no-initial-value form stays refused — JS throws on an empty
     // array there, which a template can't mirror.
     { name: 'reduce (no init)', expr: `items().reduce((a, b) => a + b.n)`, badEmit: '.Reduce' },
-    // Self / field / field-tuple `.flatMap` now lowers (#1448 Tier C); a
-    // tuple with a non-leaf element (here a string literal) stays refused.
-    { name: 'flatMap (literal element)', expr: `items().flatMap(i => [i.name, "x"])`, badEmit: '.FlatMap' },
+    // (#2018 P5) The literal-element tuple `.flatMap(i => [i.name, "x"])` now
+    // lowers through the evaluator (`bf_flat_map_eval` serializes the array-
+    // literal body and flattens), so it is no longer refused — pinned positively
+    // in the `.flatMap` describe block alongside the `[i.a, i.b]` form.
     // Lowered methods whose MEANINGFUL extra argument isn't lowered yet
     // (#1448): the `fromIndex` of `.includes`/`.indexOf`/`.lastIndexOf`
     // and the variadic `.concat`. The parser refuses these (silently