@barefootjs/go-template 0.17.0 → 0.18.0

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

@@ -6,12 +6,17 @@
 
 import { describe, test, expect } from 'bun:test'
 import { GoTemplateAdapter } from '../adapter/go-template-adapter'
-import {
-  runAdapterConformanceTests,
-  TemplatePrimitiveCaseId,
-} from '@barefootjs/adapter-tests'
+import { runAdapterConformanceTests } from '@barefootjs/adapter-tests'
 import { renderGoTemplateComponent, GoNotAvailableError } from '@barefootjs/go-template/test-render'
-import { compileJSX, type ComponentIR, type IRExpression } from '@barefootjs/jsx'
+import {
+  compileJSX,
+  analyzeComponent,
+  buildMetadata,
+  jsxToIR,
+  type ComponentIR,
+  type IRExpression,
+} from '@barefootjs/jsx'
+import { conformancePins } from '../conformance-pins'
 
 runAdapterConformanceTests({
   name: 'go-template',
@@ -58,119 +63,45 @@ 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.
-  skipJsx: [],
+  //
+  // `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.
+  //
+  // `context-provider-nullish-object-fallback` (#2087) is no longer skipped:
+  // the Go adapter now models an OBJECT-shaped `createContext` default
+  // (`ContextConsumer.defaultKind === 'object'`, `augment-inherited-props.ts`)
+  // as a real `map[string]interface{}` consumer field instead of falling
+  // through to the scalar `string` default, and `extendProviderContext`
+  // lowers the chart shape's `<Ctx.Provider value={{ config: props.config ??
+  // {} }}>` into a `map[string]interface{}` Go expression bound into the
+  // descendant's constructor call (`providerObjectValueToGoMap` /
+  // `lowerProviderMapMemberValue`). The consumer's `ctx.config.label` read
+  // lowers through the runtime's case-tolerant `bf_get` (`getFieldValue`,
+  // bf.go) instead of a plain `.Ctx.Config.Label` dot-chain, which would
+  // require an exact-cased struct/map field that never exists. See
+  // go-template-adapter.ts's `member()` `isMapRootedContextChain` branch.
   // Per-fixture build-time contracts for shapes the Go template
-  // adapter intentionally refuses to lower. Lives here (not on the
-  // shared fixtures) so adding a new adapter doesn't require touching
-  // any cross-adapter file — every adapter declares its own
+  // adapter intentionally refuses to lower. Lives in `../conformance-pins`
+  // (not on the shared fixtures) so adding a new adapter doesn't require
+  // touching any cross-adapter file — every adapter declares its own
   // refusal set against the canonical fixture corpus.
-  expectedDiagnostics: {
-    // `style-object-dynamic` / `style-3-signals` no longer pinned — a
-    // `style={{ … }}` object literal now lowers to a CSS string with dynamic
-    // values interpolated (`background-color:{{.Color}};padding:8px`) via
-    // `tryLowerStyleObject` (#1322).
-    // Sibling-imported child component inside a loop body: the adapter
-    // emits `{{template "X" .}}` which only resolves if the user has
-    // compiled the sibling file and registered the template on the
-    // same instance. BF103 makes that requirement loud. (The barefoot
-    // CLI passes `siblingTemplatesRegistered: true` so CLI builds
-    // suppress the diagnostic — see compileJSX `siblingTemplatesRegistered`.)
-    'static-array-children': [{ code: 'BF103', severity: 'error' }],
-    // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-    // call it inside a keyed `.map`. Same BF103 surface as
-    // `static-array-children` above — pinned at adapter level so the
-    // shared-component corpus stays adapter-neutral.
-    'todo-app': [{ code: 'BF103', severity: 'error' }],
-    'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
-    // Array-destructure loop param (`([k, v]) => ...`): Go's `{{range
-    // $a, $b := ...}}` only supports single-name bindings, so the
-    // adapter would otherwise emit invalid template syntax.
-    'static-array-from-props': [{ code: 'BF104', severity: 'error' }],
-    // Same destructure shape with a child component body — fires both
-    // BF103 (imported child in loop) and BF104 (destructure param).
-    'static-array-from-props-with-component': [
-      { code: 'BF103', severity: 'error' },
-      { code: 'BF104', severity: 'error' },
-    ],
-    // (`style-3-signals` graduated alongside `style-object-dynamic` — see note
-    // above; the `style={{ … }}` object now lowers to a CSS string.)
-    // #1244 stress catalog: tagged-template-literal callees
-    // (`cn\`base \${tone()}\``) likewise can't lower into Go template
-    // syntax — same BF101 refusal.
-    'tagged-template-classname': [{ 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
-    // reserved `__bf_item` name, depth-suffixed) and `rest.flag` →
-    // `$__bf_item0.Flag` (`destructureBindingsSupportable`). The
-    // other three stay refused: rest SPREAD (`{...rest}`) needs a residual
-    // object, and array-index / nested paths (`[a, ...t]`, `{ cells: [h] }`)
-    // need index/slice machinery Go's `{{range}}` can't express inline.
-    'rest-destructure-object-spread-in-map': [{ code: 'BF104', severity: 'error' }],
-    'rest-destructure-array-in-map': [{ code: 'BF104', severity: 'error' }],
-    'rest-destructure-nested-in-map': [{ code: 'BF104', severity: 'error' }],
-    // #1443: `[a, b].filter(Boolean).join(' ')` (registry Slot) now
-    // lowers to `bf_join (bf_filter_truthy (bf_arr ...)) " "`. No
-    // BF101 expected — pinned positively by the
-    // `branch-local-filter-join-go` template-output test below.
-    //
-    // #1448 Tier A — JS Array / String methods that the Go template
-    // adapter hasn't lowered yet. Each row drops once the
-    // corresponding method PR lands. Hono / CSR pass these out of
-    // the box (they evaluate JS at runtime) so the pin only applies
-    // here.
-    //
-    // `array-includes` / `string-includes` no longer pinned — both
-    // shapes lower via the shared `array-method` IR + the polymorphic
-    // `bf_includes` runtime helper that dispatches on
-    // `reflect.Kind()` (slice/array → element search, string →
-    // substring search). The condition-position lowering picks up
-    // the same emit through the `array-method` arm of
-    // `renderConditionExpr` (#1448 Tier A first PR).
-    //
-    // Remaining fixtures land at expression position and surface BF101
-    // via `convertExpressionToGo`. Distinct codes for the two paths is
-    // pre-existing adapter behaviour, not something this catalog
-    // should paper over — pinned literally here.
-    // `array-indexOf` / `array-lastIndexOf` no longer pinned —
-    // value-equality `bf_index_of` / `bf_last_index_of` Go runtime
-    // helpers handle the shape (#1448 Tier A second PR).
-    // `array-at` no longer pinned — the pre-existing `bf_at` runtime
-    // helper now lowers `.at(i)` (#1448 Tier A third PR).
-    // `array-concat` no longer pinned — the new `bf_concat` runtime
-    // helper merges two arrays into a single `[]any` (#1448 Tier A
-    // fourth PR).
-    // `array-slice` no longer pinned — the new `bf_slice` runtime
-    // helper carves out a sub-range with JS-compat clamping
-    // (#1448 Tier A fifth PR).
-    // `array-reverse` / `array-toReversed` no longer pinned —
-    // both share the `bf_reverse` helper since SSR templates
-    // render a snapshot and the JS mutate-vs-new distinction has
-    // no template-level meaning (#1448 Tier A sixth PR).
-    // `string-toLowerCase` / `string-toUpperCase` no longer pinned —
-    // pre-existing `bf_lower` / `bf_upper` runtime helpers wire to
-    // the JS method names at the adapter layer (#1448 Tier A
-    // seventh + eighth PRs).
-    // `string-trim` no longer pinned — pre-existing `bf_trim`
-    // (wraps `strings.TrimSpace`) handles the strip (#1448 Tier A
-    // ninth PR, closing out Tier A).
-  },
-  // `JSON_STRINGIFY_VIA_CONST` and `MATH_FLOOR_VIA_CONST` now pass
-  // via `GoTemplateAdapter.templatePrimitives` (#1188). The two
-  // remaining cases stay skipped because the V1 registry is
-  // identifier-path-only and explicit:
-  //   - `USER_IMPORT_VIA_CONST` — a bespoke user import isn't in
-  //     the registry and can't be rendered server-side without
-  //     user-supplied template-fn mappings.
-  //   - `NO_DOUBLE_REWRITE_OF_PROPS_OBJECT` — uses `customSerialize`
-  //     too, same reason.
-  // Adding new entries to `templatePrimitives` should narrow this
-  // skip set; see `templatePrimitives` declaration in
-  // `go-template-adapter.ts` for the full V1 surface.
-  skipTemplatePrimitives: new Set([
-    TemplatePrimitiveCaseId.USER_IMPORT_VIA_CONST,
-    TemplatePrimitiveCaseId.NO_DOUBLE_REWRITE_OF_PROPS_OBJECT,
-  ]),
+  expectedDiagnostics: conformancePins,
+  // `JSON_STRINGIFY_VIA_CONST` and `MATH_FLOOR_VIA_CONST` pass via
+  // `GoTemplateAdapter.templatePrimitives` (#1188) — the identifier-path
+  // registry for well-known JS builtins. `USER_IMPORT_VIA_CONST` and
+  // `NO_DOUBLE_REWRITE_OF_PROPS_OBJECT` now ALSO pass (#2069): a bespoke
+  // user import can never be added to the string-keyed registry (the
+  // adapter has no way to know about it ahead of time), but the shared
+  // `RelocateEnv.loweringMatchers` acceptance path recognises it via a
+  // `LoweringPlugin` the case setup registers around the compile (see
+  // `packages/adapter-tests/src/cases/template-primitives.ts`) — the same
+  // seam a real userland plugin author would use. No skips left, so
+  // `skipTemplatePrimitives` is omitted entirely (defaults to "skip
+  // nothing").
   skipMarkerConformance: new Set<string>([
     // Same as Hono / Mojo: `/* @client */` markers on TodoApp's keyed
     // `.map` intentionally elide a slot id from the SSR template that
@@ -899,10 +830,18 @@ export function Dyn() {
       expect(types).toContain('Items: nil,')
     })
 
-    test('keeps nil for object keys that are not Go-identifier-safe (#1675 review)', () => {
-      // A quoted key like "data-id" capitalises to `Data-id`, which is not a
-      // valid Go struct field identifier — baking it would emit a keyed struct
-      // literal that doesn't compile, so the whole array must stay nil.
+    test('bakes a non-Go-identifier object key via a sanitized struct field (#1675 review, revised #2087)', () => {
+      // A quoted key like "data-id" used to capitalise to `Data-id` (not a
+      // valid Go struct field identifier), so the struct field was dropped
+      // entirely and the whole array baked to nil rather than emit invalid
+      // Go — silently losing the data. #2087 Phase B's `goFieldNameForKey`
+      // (packages/adapter-go-template/src/adapter/lib/go-naming.ts) instead
+      // PascalCases each segment split on the hyphen (`data-id` → `DataID`,
+      // matching the `id` whole-word initialism), giving the field a real
+      // Go name — needed so the destructure-rest residual lowering
+      // (`rest-destructure-object-spread-in-map`, #2087) has something to
+      // read a non-identifier sibling key back from. The array now bakes for
+      // real instead of deferring to nil.
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`
 "use client"
@@ -915,7 +854,56 @@ export function Rows() {
 }
 `)
       const types = adapter.generate(ir).types!
-      expect(types).toContain('Rows: nil,')
+      expect(types).toContain('DataID string `json:"data-id"`')
+      expect(types).toContain('Rows: []Row{Row{DataID: "a"}},')
+    })
+
+    test('bakes a non-Go-identifier key inside a nested INLINE object with the same sanitizer as the accessor side (#2089 review)', () => {
+      // A nested inline-object property (`meta: { 'data-x': string }` — no
+      // named Go struct, lowered to map[string]interface{}) bakes as a Go map
+      // literal. The map KEY must be produced by `goFieldNameForKey` — the
+      // same function `buildSegmentAccessor`/`structFieldsFor` use — so the
+      // emitted accessor (`.Meta.DataX`, an exact-string MapIndex on maps)
+      // actually finds the value. `capitalizeFieldName` alone would bake
+      // `"Data-x"`, a key no emitted accessor can reach, silently rendering
+      // empty (flagged by Copilot on PR #2089).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Row = { id: string; meta: { "data-x": string } }
+export function Rows() {
+  const [rows] = createSignal<Row[]>([{ id: "r1", meta: { "data-x": "v" } }])
+  return <ul>{rows().map(({ id, meta }) => <li key={id}>{meta["data-x"]}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('map[string]interface{}{"DataX": "v"}')
+      expect(types).not.toContain('"Data-x"')
+    })
+
+    test('snake_case keys keep their underscore in the generated field name (#2089 review)', () => {
+      // Underscores are VALID Go identifier characters, and `Foo_bar` is the
+      // field name this adapter has always generated for a snake_case key —
+      // `goFieldNameForKey` must NOT split on `_` (that would rename the
+      // generated field to `FooBar`, silently diverging from the `.Foo_bar`
+      // dot access the member emitter produces AND breaking consumers'
+      // hand-written constructors against previously generated types).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Row = { foo_bar: string }
+export function Rows() {
+  const [rows] = createSignal<Row[]>([{ foo_bar: "a" }])
+  return <ul>{rows().map((r) => <li key={r.foo_bar}>{r.foo_bar}</li>)}</ul>
+}
+`)
+      const out = adapter.generate(ir)
+      expect(out.types!).toContain('Foo_bar string `json:"foo_bar"`')
+      expect(out.template).toContain('.Foo_bar')
     })
 
     test('collapses whitespace-padded empty array literal to nil (#1675 review)', () => {
@@ -999,10 +987,10 @@ function Box({ label }: { label: string }) {
 `
       const { types } = compileAndGenerate(source)
       // The condition prop and the value reference resolve to `in.<Field>`,
-      // the static key is preserved. (The analyzer surfaces these
-      // destructured props as `unknown`/`interface{}`, so the condition
-      // routes through `bf.Truthy` for a faithful JS truthiness test.)
-      expect(types).toContain('if bf.Truthy(in.Label) {')
+      // the static key is preserved. `label` is a required primitive, so the
+      // analyzer resolves it to `string` (issue #2150) and the field-typed
+      // condition is a faithful `!= ""` truthiness test rather than reflection.
+      expect(types).toContain('if in.Label != "" {')
       expect(types).toContain('return map[string]any{"data-label": in.Label}')
     })
 
@@ -1830,6 +1818,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 +3004,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()
@@ -3194,7 +3439,6 @@ export { C }
 
   // Tier B `.sort` / `.toSorted` follow-ups still refused with BF021.
   const unsupportedSort: Array<[string, string]> = [
-    ['function-reference comparator', `items().toSorted(myCmp).map(x => <li key={x.name}>{x.name}</li>)`],
     ['localeCompare locale/options arg', `items().toSorted((a, b) => a.name.localeCompare(b.name, "ja", { numeric: true })).map(x => <li key={x.name}>{x.name}</li>)`],
   ]
   for (const [label, chain] of unsupportedSort) {
@@ -3217,6 +3461,17 @@ export function C() {
     })
   }
 
+  // #2090: a function-reference comparator (`.toSorted(myCmp)`, `myCmp` a
+  // same-file const arrow) now resolves through the analyzer's scope
+  // machinery and compiles — no BF021, and the sort lowers exactly like an
+  // inline comparator (`bf_sort` / `bf_sort_eval` group in the template).
+  test('sort follow-up (function-reference comparator): resolves and compiles without BF021', () => {
+    const chain = `items().toSorted(myCmp).map(x => <li key={x.name}>{x.name}</li>)`
+    const result = emitLoop(chain, false)
+    expect(result.errors).toEqual([])
+    expect(result.template).toMatch(/bf_sort/)
+  })
+
   // End-to-end proof via `go run`: the `@client` form renders a
   // `<!--bf-client:sN-->` placeholder. The bare form is now caught at
   // build with BF101 and degrades to an empty, render-safe slot (no
@@ -3309,6 +3564,14 @@ export function C() {
 
   test('@client attribute inside a keyed .map() loop body is also deferred', () => {
     const adapter = new GoTemplateAdapter()
+    // `days` is signal-backed (not a bare function-scope local) so the loop
+    // array itself resolves to a real `.Days []Day` field — a plain
+    // `const days: Day[] = [...]` array-of-objects local has no such backing
+    // (the Go adapter only binds a STRING-derived function-scope const as a
+    // field; #2087's `renderLoop` BF101 check now catches that case loudly
+    // instead of emitting a template that references a nonexistent field).
+    // This test's actual subject is the `/* @client */` attribute deferral
+    // inside a loop body, which is orthogonal to how the array is sourced.
     const result = compileJSX(`
 "use client"
 import { createSignal } from "@barefootjs/client"
@@ -3316,10 +3579,10 @@ type Day = { n: number }
 export function C() {
   const [sel] = createSignal(0)
   const pred = (d: Day) => sel() === d.n
-  const days: Day[] = [{ n: 1 }, { n: 2 }]
+  const [days] = createSignal<Day[]>([{ n: 1 }, { n: 2 }])
   return (
     <div>
-      {days.map((day: Day) => (
+      {days().map((day: Day) => (
         <div key={day.n} data-x={/* @client */ pred(day)}>cell</div>
       ))}
     </div>
@@ -3328,9 +3591,269 @@ export function C() {
 `.trimStart(), 'test.tsx', { adapter })
     const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
     expect(result.errors ?? []).toEqual([])
-    // The loop still renders (the array is a static const) but the deferred
+    // The loop still renders (the array is signal-backed) but the deferred
     // attribute is absent from the emitted `<div>` cell.
     expect(template).toContain('range')
     expect(template).not.toContain('data-x')
   })
 })
+
+// #2087: the shared `isSupported` gate (expression-parser.ts, `logical` case)
+// now admits an EMPTY object-literal fallback (`x ?? {}`) as `??`'s right
+// operand — needed for the chart UI component's `<ChartConfigContext.Provider
+// value={{ config: props.config ?? {} }}>`. Every other template adapter has
+// a native `{}` dict/hashref to emit for this shape; Go's `text/template` has
+// none, so `GoTemplateAdapter.objectLiteral` is the one place left to refuse
+// it — self-reporting BF101 (the shared gate no longer does, since it now
+// considers the expression supported) and falling back to the safe `""`
+// sentinel so the emitted action stays valid Go template syntax rather than
+// splicing the `[UNSUPPORTED: …]` marker into an `or`/`and` operand.
+describe('GoTemplateAdapter - #2087 empty object-literal `?? {}` fallback', () => {
+  test('a value-position `?? {}` (outside a Provider) raises BF101 and still emits a syntactically valid template', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(`
+"use client"
+type Props = { config?: Record<string, string> }
+export function C(props: Props) {
+  return <div>{props.config ?? {}}</div>
+}
+`.trimStart(), 'test.tsx', { adapter })
+    expect(result.errors?.some(e => e.code === 'BF101')).toBe(true)
+    const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
+    // The `{}` fallback lowers to the safe `""` Go string sentinel — never the
+    // `[UNSUPPORTED: …]` marker text, which would break `text/template` parsing
+    // once spliced as an `or` operand.
+    expect(template).toContain('{{or .Config ""}}')
+    expect(template).not.toContain('UNSUPPORTED')
+  })
+
+  test('the chart shape — a Provider value member falling back to `?? {}` — compiles clean with no BF101', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(`
+"use client"
+import { createContext, useContext } from "@barefootjs/client"
+type ChartConfig = Record<string, string>
+const Ctx = createContext<{ config: ChartConfig }>({ config: {} })
+function Consumer() {
+  const ctx = useContext(Ctx)
+  return <span>{ctx.config.label ?? "none"}</span>
+}
+type Props = { config?: ChartConfig }
+export function C(props: Props) {
+  return (
+    <div>
+      <Ctx.Provider value={{ config: props.config ?? {} }}>
+        <Consumer />
+      </Ctx.Provider>
+    </div>
+  )
+}
+`.trimStart(), 'test.tsx', { adapter })
+    // The object-literal provider value never reaches `objectLiteral` (it's
+    // handled structurally by `extendProviderContext` /
+    // `providerObjectValueToGoMap` instead), so no BF101 fires here — matching
+    // the `ui/compat.lock.json` `chart` × `go-template` `ok: true` entry.
+    expect(result.errors ?? []).toEqual([])
+  })
+
+  test('#2087: an object-shaped createContext default lowers the consumer field to a map, and the Provider bakes a matching Go map into the child constructor call', () => {
+    // Mirrors the real cross-component wiring `renderGoTemplateComponent` does
+    // (`registerChildComponentShape` for every sibling before the parent's
+    // types/template are generated) — a bare `compileJSX` multi-component
+    // compile never calls that hook, so it can't show the Provider→consumer
+    // binding this test pins.
+    const source = `
+"use client"
+import { createContext, useContext } from "@barefootjs/client"
+type ChartConfig = Record<string, string>
+const Ctx = createContext<{ config: ChartConfig }>({ config: {} })
+function Consumer() {
+  const ctx = useContext(Ctx)
+  return <span>{ctx.config.label ?? "none"}</span>
+}
+type Props = { config?: ChartConfig }
+export function Root(props: Props) {
+  return (
+    <div>
+      <Ctx.Provider value={{ config: props.config ?? {} }}>
+        <Consumer />
+      </Ctx.Provider>
+    </div>
+  )
+}
+`.trimStart()
+
+    const consumerCtx = analyzeComponent(source, 'test.tsx', 'Consumer')
+    const consumerIR: ComponentIR = {
+      version: '0.1',
+      metadata: buildMetadata(consumerCtx),
+      root: jsxToIR(consumerCtx)!,
+      errors: [],
+    }
+    const rootCtx = analyzeComponent(source, 'test.tsx', 'Root')
+    const rootIR: ComponentIR = {
+      version: '0.1',
+      metadata: buildMetadata(rootCtx),
+      root: jsxToIR(rootCtx)!,
+      errors: [],
+    }
+
+    const adapter = new GoTemplateAdapter()
+    // Order matters: the child's shape (incl. its context consumers) must be
+    // known before the parent's types/constructor are generated.
+    adapter.registerChildComponentShape(consumerIR)
+    const consumerTypes = adapter.generateTypes(consumerIR)!
+    const rootTypes = adapter.generateTypes(rootIR)!
+    const consumerTemplate = adapter.generate(consumerIR, { skipScriptRegistration: true }).template
+    const rootTemplate = adapter.generate(rootIR, { skipScriptRegistration: true }).template
+
+    // Consumer's `Ctx` field is a real map, not the scalar `string` fallback
+    // every other non-literal default used to produce.
+    expect(consumerTypes).toContain('Ctx map[string]interface{}')
+
+    // The Provider's `{ config: props.config ?? {} }` bakes into a
+    // `map[string]interface{}` Go expression, normalising the parent's
+    // `interface{}`-typed `Config` field through `bf.AsMap` — NOT a bare
+    // `.(map[string]interface{})` type assertion, which would silently drop
+    // a caller-supplied typed map like `map[string]string` (the natural Go
+    // shape for a `Record<string, string>` prop — #2111 review) — and
+    // falling back to a real empty map when the value is nil/absent.
+    expect(rootTypes).toContain('ConsumerSlot0: NewConsumerProps(ConsumerInput{')
+    expect(rootTypes).toContain('Ctx: map[string]interface{}{"config": func() map[string]interface{} { if m := bf.AsMap(in.Config); m != nil { return m }; return map[string]interface{}{} }()},')
+
+    // The consumer's `ctx.config.label ?? 'none'` reads through `bf_get`
+    // (case-tolerant `getFieldValue`), not a plain `.Ctx.Config.Label` dot
+    // chain — the latter would require an exact-cased struct/map field that
+    // never exists and crashes real `go run` execution.
+    expect(consumerTemplate).toContain('{{or (bf_get (bf_get .Ctx "config") "label") "none"}}')
+    expect(consumerTemplate).not.toContain('.Ctx.Config')
+  })
+})
+
+describe('GoTemplateAdapter - #2130 loop with element-wrapped child component', () => {
+  // The `.{Name}s` wrapper-slice retarget is ONLY valid when the loop body IS
+  // a single component (`loop.childComponent`) — that's the sole condition
+  // under which `findNestedComponents` generates the slice field. A component
+  // merely nested inside an element item used to retarget the range at a
+  // slice that never exists (`{{range … := .Tags}}` with no `Tags` field →
+  // `can't evaluate field Tags in type *LoopChildProbeProps`, a 500 at
+  // render time).
+  test('element-wrapped child: range iterates the real collection, child renders via the parent slot instance', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+import { Tag } from '@ui/components/ui/tag'
+
+interface Row { id: number; label: string }
+
+export function LoopChildProbe(props: { rows?: Row[] }) {
+  const [rows] = createSignal(props.rows ?? [])
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}><Tag>{row.label}</Tag></li>
+      ))}
+    </ul>
+  )
+}
+`, adapter)
+    const { template, types } = adapter.generate(ir)
+
+    // The range targets the generated collection field, never a
+    // `.{ChildName}s` slice that no struct declares.
+    expect(template).toContain(':= .Rows}}')
+    expect(template).not.toContain('.Tags}}')
+    expect(types).not.toContain('Tags []')
+
+    // The wrapped child calls through the parent's once-per-slot instance
+    // (root context `$`), with per-item children via the loop-body define.
+    expect(template).toContain('{{template "Tag" (bf_with_children $.TagSlot1')
+    expect(types).toContain('TagSlot1 TagProps')
+    expect(types).toContain('TagSlot1: NewTagProps(TagInput{')
+  })
+
+  // End-to-end on real Go: the emitted template + structs must compile AND
+  // execute (`go run`) — the original failure mode was a request-time 500
+  // (`html/template` resolves struct fields at execute time, not at Go
+  // compile time). Cross-adapter note: this stays a Go-package test rather
+  // than a shared conformance fixture because the EP-family adapters
+  // (Mojo / ERB / Jinja / ...) render loop-nested children with per-item
+  // `ComponentName_<random>` scope ids by design (`comp.slotId &&
+  // !this.inLoop` in their renderComponent), while Hono / Go emit the
+  // parent-slot-derived id — same DOM, different id shape, so a single
+  // `expectedHtml` cannot pin both families.
+  test('element-wrapped child renders per-item content on real Go', async () => {
+    const adapter = new GoTemplateAdapter()
+    let html: string
+    try {
+      html = await renderGoTemplateComponent({
+        source: `
+'use client'
+import { createSignal } from '@barefootjs/client'
+import { Tag } from '@ui/components/ui/tag'
+
+interface Row { id: number; label: string }
+
+export function LoopChildProbe(props: { rows?: Row[] }) {
+  const [rows] = createSignal(props.rows ?? [])
+  return (
+    <ul>
+      {rows().map(row => (
+        <li key={row.id}><Tag>{row.label}</Tag></li>
+      ))}
+    </ul>
+  )
+}
+`.trimStart(),
+        adapter,
+        components: {
+          '@ui/components/ui/tag': `
+export function Tag(props: { children?: any }) {
+  return <span class="tag">{props.children}</span>
+}
+`.trimStart(),
+        },
+        props: { rows: [{ id: 1, label: 'one' }, { id: 2, label: 'two' }] },
+      })
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) return
+      throw err
+    }
+    // One <li> per row, each wrapping a rendered Tag with the row's label —
+    // not a template error and not an empty loop.
+    expect(html).toContain('data-key="1"')
+    expect(html).toContain('data-key="2"')
+    expect(html).toContain('>one<')
+    expect(html).toContain('>two<')
+    expect(html).toContain('class="tag"')
+  })
+
+  // Companion guard: the wrapper-slice path is untouched — a loop body that
+  // IS a single component still iterates `.{Name}s` (the todo-app / data-table
+  // machinery this fix must not regress).
+  test('single-component body keeps iterating the wrapper slice', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+import { TodoItem } from '@ui/components/ui/todo-item'
+
+interface Todo { id: number; text: string }
+
+export function TodoList(props: { todos?: Todo[] }) {
+  const [todos] = createSignal(props.todos ?? [])
+  return (
+    <ul>
+      {todos().map(todo => (
+        <TodoItem key={todo.id} text={todo.text} />
+      ))}
+    </ul>
+  )
+}
+`, adapter)
+    const { template, types } = adapter.generate(ir)
+    expect(template).toContain(':= .TodoItems}}')
+    expect(types).toContain('TodoItems []')
+  })
+})