@barefootjs/go-template 0.5.1 → 0.5.3

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

@@ -36,18 +36,6 @@ runAdapterConformanceTests({
   // template syntax (#1266).
   skipJsx: [
     'return-map',
-    // #1665 whole-item loop conditional. The Go adapter correctly emits the
-    // per-item `<!--bf-loop-i:KEY-->` anchor, `data-key`, and conditional
-    // markers (verified by template-structure tests), but the array signal's
-    // initial value is not baked into the generated `NewXxxProps` constructor
-    // (`Items: nil`, unlike scalar signals such as `Sel: "b"`), so the Go SSR
-    // renders an empty loop. Populating signal-array initial values into the
-    // SSR data context is a separate pre-existing Go limitation — every other
-    // signal-loop fixture sidesteps it with an empty initial array. The
-    // anchored SSR shape with rendered items is covered by Hono + CSR
-    // conformance and the runtime hydration tests. Remove this skip once the
-    // Go limitation is fixed: https://github.com/piconic-ai/barefootjs/issues/1672
-    'loop-item-conditional',
     // #1297 fixed the harness-side IR emission gate (multi-component
     // sources now emit one `ir` file per component, and the harness
     // picks the entry-point IR). The remaining gap is adapter-side:
@@ -88,6 +76,16 @@ runAdapterConformanceTests({
     // option fixed on the Hono side. Separate follow-up.
     'toggle-shared',
     'props-reactivity-comparison',
+    // #1467 Phase 2a: first `site/ui` source-root fixture. Button
+    // compiles cleanly on the Go adapter (no diagnostic), but its
+    // variant/size class composition (`Record<…>[key]` indexed object
+    // literals) and `applyRestAttrs` spread haven't been validated for
+    // byte-parity against the Hono reference under Go's template
+    // semantics. Cross-adapter parity for the `site/ui` corpus is
+    // explicitly Phase 3 ("cross-adapter parity (Mojo/Go templates)"),
+    // so Button participates only in Hono SSR conformance + the
+    // fixture-hydrate runtime layer for now.
+    'button',
   ],
   // Per-fixture build-time contracts for shapes the Go template
   // adapter intentionally refuses to lower. Lives here (not on the
@@ -530,6 +528,355 @@ export function Score(props: { value?: number }) {
       expect(floatTypes).not.toContain('value := in.Value')
       expect(floatTypes).toContain('Value: in.Value,')
     })
+
+    test('bakes typed struct array-literal initial values into NewXxxProps (#1672)', () => {
+      // A signal typed `Item[]` lands in a `[]Item` field whose template loop
+      // body reaches each element via struct field access (`.ID`). Baking the
+      // inline literal as a Go struct slice — capitalising keys to match the
+      // generated field names — lets the Go SSR render the list. Previously
+      // `convertInitialValue` returned `nil` for any array literal, freezing
+      // SSR loops to empty (the reason whole-item-conditional loop fixtures
+      // had to skip Go render conformance — #1665 / #1672).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { id: string }
+export function List() {
+  const [items] = createSignal<Item[]>([{ id: "a" }, { id: "b" }, { id: "c" }])
+  return <ul>{items().map((t) => <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).not.toContain('Items: nil,')
+      expect(types).toContain('Items: []Item{')
+      expect(types).toContain('Item{ID: "a"}')
+      expect(types).toContain('Item{ID: "b"}')
+      expect(types).toContain('Item{ID: "c"}')
+    })
+
+    test('bakes scalar array-literal initial values into NewXxxProps (#1672)', () => {
+      // Scalar loops render each element via `{{.}}`, so an `[]interface{}`
+      // (untyped) or `[]string` (typed) slice literal both render correctly.
+      const adapter = new GoTemplateAdapter()
+      const untypedIr = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Tags() {
+  const [tags] = createSignal(["x", "y", "z"])
+  return <ul>{tags().map((t) => <li key={t}>{t}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(untypedIr).types!).toContain(
+        'Tags: []interface{}{"x", "y", "z"},',
+      )
+
+      const typedIr = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Tags() {
+  const [tags] = createSignal<string[]>(["x", "y", "z"])
+  return <ul>{tags().map((t) => <li key={t}>{t}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(typedIr).types!).toContain(
+        'Tags: []string{"x", "y", "z"},',
+      )
+    })
+
+    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
+      // shape, emit it, type the signal field as a slice of it, and bake the
+      // items — so the loop body's struct field access (`.ID`) resolves.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function List() {
+  const [items] = createSignal([{ id: "a", n: 1, ok: true }, { id: "b", n: 2, ok: false }])
+  return <ul>{items().map((t) => <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      // A struct is synthesised with one field per inferred key + Go type.
+      expect(types).toMatch(/type \w+ struct \{[\s\S]*ID string[\s\S]*N int[\s\S]*Ok bool[\s\S]*\}/)
+      // The signal field is a slice of the synthesised struct, not []interface{}.
+      expect(types).toMatch(/Items \[\]\w+ `json:"items"`/)
+      expect(types).not.toContain('Items []interface{}')
+      // The initial items are baked, not nil.
+      expect(types).not.toContain('Items: nil,')
+      expect(types).toMatch(/Items: \[\]\w+\{\w+\{ID: "a", N: 1, Ok: true\}, \w+\{ID: "b", N: 2, Ok: false\}\}/)
+    })
+
+    test('keeps nil for an untyped object array with inconsistent shapes (#1680)', () => {
+      // Elements must share one shape to synthesise a struct. A key missing
+      // from some elements (or a type that disagrees across elements) can't map
+      // to a single struct, so we bail to nil rather than guess.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function List() {
+  const [items] = createSignal([{ id: "a" }, { id: "b", extra: 1 }])
+  return <ul>{items().map((t) => <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(ir).types!).toContain('Items: nil,')
+    })
+
+    test('keeps nil for an untyped object array with non-scalar values (#1680)', () => {
+      // A nested object/array value has no scalar Go type to infer, so the
+      // shape can't be synthesised — bail to nil.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function List() {
+  const [items] = createSignal([{ id: "a", tags: ["x"] }])
+  return <ul>{items().map((t) => <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(ir).types!).toContain('Items: nil,')
+    })
+
+    test('widens mixed int/float keys to float64 and keeps negatives (#1680)', () => {
+      // A key seen as both an integer and a fractional literal across elements
+      // can't be `int`; widen it to `float64`. Negative numeric literals keep
+      // their sign in the baked value.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function List() {
+  const [pts] = createSignal([{ x: 1, y: -2 }, { x: 2.5, y: -3 }])
+  return <ul>{pts().map((p) => <li key={p.x}>{p.x}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      // x mixes 1 and 2.5 → float64; y stays int (both integer literals).
+      expect(types).toMatch(/X float64[\s\S]*Y int/)
+      expect(types).toContain('{X: 1, Y: -2}')
+      expect(types).toContain('{X: 2.5, Y: -3}')
+    })
+
+    test('keeps nil when the synthesised name collides with a user type (#1680)', () => {
+      // The struct name is `<Component><Signal>Item`. If the user already
+      // declares that exact type, synthesis bails rather than shadowing it.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type ListItemsItem = { id: string }
+export function List() {
+  const [items] = createSignal([{ id: "a" }])
+  return <ul>{items().map((t) => <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(ir).types!).toContain('Items: nil,')
+    })
+
+    test('synthesises a distinct struct per untyped object-array signal (#1680)', () => {
+      // Two untyped signals get component+getter-prefixed names, so their
+      // synthesised structs and fields don't collide.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function List() {
+  const [rows] = createSignal([{ id: "a" }])
+  const [cols] = createSignal([{ label: "x" }])
+  return <ul>{rows().map((r) => <li key={r.id}>{r.id}</li>)}{cols().map((c) => <li key={c.label}>{c.label}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('type ListRowsItem struct {')
+      expect(types).toContain('type ListColsItem struct {')
+      expect(types).toMatch(/Rows \[\]ListRowsItem/)
+      expect(types).toMatch(/Cols \[\]ListColsItem/)
+      expect(types).toContain('Rows: []ListRowsItem{ListRowsItem{ID: "a"}}')
+      expect(types).toContain('Cols: []ListColsItem{ListColsItem{Label: "x"}}')
+    })
+
+    test('keeps nil for non-literal array initial values (#1672)', () => {
+      // A signal whose array initial value is a function call / variable
+      // reference cannot be evaluated at codegen time — it must stay nil so
+      // the handler populates it (no behaviour change for these cases).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+function build(): string[] { return [] }
+export function Dyn() {
+  const [items] = createSignal(build())
+  return <ul>{items().map((t) => <li key={t}>{t}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      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.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Row = { "data-id": string }
+export function Rows() {
+  const [rows] = createSignal<Row[]>([{ "data-id": "a" }])
+  return <ul>{rows().map((r) => <li key={r["data-id"]}>{r["data-id"]}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('Rows: nil,')
+    })
+
+    test('collapses whitespace-padded empty array literal to nil (#1675 review)', () => {
+      // The empty-literal fast-path must match `[ ]` too, not only the exact
+      // `[]`, so a padded empty initial value still defaults to nil rather than
+      // baking an empty slice literal.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Empty() {
+  const [items] = createSignal<string[]>([ ])
+  return <ul>{items().map((t) => <li key={t}>{t}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('Items: nil,')
+      expect(types).not.toContain('Items: []string{}')
+    })
+
+    test('bakes generic Array<T> / ReadonlyArray<T> initial values like T[] (#1675 review)', () => {
+      // `createSignal<Array<T>>` reaches the analyzer as a generic type
+      // reference, not a `T[]` array node. The analyzer normalises both to the
+      // same array TypeInfo, so baking treats them identically — element typing
+      // (and struct-element baking) is preserved rather than degrading to nil.
+      const adapter = new GoTemplateAdapter()
+      const scalarIr = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Tags() {
+  const [tags] = createSignal<Array<string>>(["x", "y"])
+  return <ul>{tags().map((t) => <li key={t}>{t}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(scalarIr).types!).toContain('Tags: []string{"x", "y"},')
+
+      const structIr = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { id: string }
+export function List() {
+  const [items] = createSignal<ReadonlyArray<Item>>([{ id: "a" }])
+  return <ul>{items().map((t) => <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(structIr).types!).toContain('Items: []Item{Item{ID: "a"}},')
+    })
+  })
+
+  describe('loop body outer-scope references (#1677)', () => {
+    test('references an outer signal inside a loop via $ root scope, not the element', () => {
+      // Inside `{{range $_, $t := .Items}}` the dot is rebound to the loop
+      // element, so a reference to the outer `sel` signal must reach the root
+      // data through Go template's `$` (`$.Sel`), not `.Sel` — which would
+      // resolve against the element struct (no `Sel` field → <nil>).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { id: string }
+export function L() {
+  const [items] = createSignal<Item[]>([{ id: "a" }, { id: "b" }])
+  const [sel] = createSignal("b")
+  return <ul>{items().map((t) => sel() === t.id && <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      const template = adapter.generate(ir).template
+      // The loop element field stays element-scoped; the outer signal is rooted.
+      expect(template).toContain('eq $.Sel .ID')
+      expect(template).not.toContain('eq .Sel .ID')
+    })
+
+    test('references an outer prop inside a loop via $ root scope', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { id: string }
+export function L(props: { active: string }) {
+  const [items] = createSignal<Item[]>([{ id: "a" }])
+  return <ul>{items().map((t) => props.active === t.id && <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+      const template = adapter.generate(ir).template
+      expect(template).toContain('eq $.Active .ID')
+      expect(template).not.toContain('eq .Active .ID')
+    })
+
+    test('references an outer loop variable from a nested loop via its range var, not root', () => {
+      // In nested `{{range}}`s the inner dot is the inner element; the outer
+      // loop value is in scope as the Go range variable `$group` (declared by
+      // the outer `{{range $_, $group := .Groups}}`). A reference to the outer
+      // item from the inner body must use `$group.ID`, not `$.Group.ID` (root)
+      // nor `.ID` (inner element).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { id: string }
+type Group = { id: string; items: Item[] }
+export function L() {
+  const [groups] = createSignal<Group[]>([])
+  return <ul>{groups().map((group) => <li key={group.id}>{group.items.map((item) => <span key={item.id}>{group.id}:{item.id}</span>)}</li>)}</ul>
+}
+`)
+      const template = adapter.generate(ir).template
+      // Outer item referenced from the inner loop body resolves to $group.ID.
+      expect(template).toContain('$group.ID')
+      expect(template).not.toContain('$.Group.ID')
+    })
+
+    test('compares an outer loop variable in a nested loop condition via its range var', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { id: string; groupId: string }
+type Group = { id: string; items: Item[] }
+export function L() {
+  const [groups] = createSignal<Group[]>([])
+  return <ul>{groups().map((group) => <li key={group.id}>{group.items.map((item) => group.id === item.groupId && <span key={item.id}>{item.id}</span>)}</li>)}</ul>
+}
+`)
+      const template = adapter.generate(ir).template
+      expect(template).toContain('eq $group.ID .GroupId')
+      expect(template).not.toContain('eq $.Group.ID')
+    })
   })
 
   describe('JSX children forwarding (#1203)', () => {
@@ -1917,19 +2264,20 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
 // The catalogue in #1448 documents `/* @client */` as the universal
 // workaround for any Array/String method shape the template adapters
 // can't lower. This block pins that contract for the Go adapter: for
-// every remaining unsupported entry, wrapping the expression in
-// `/* @client */` must (a) clear the BF021/BF101 build error the bare
-// form raises and (b) emit a client-only placeholder so the Go SSR
-// pass renders valid template that the client runtime fills at
-// hydration.
+// every remaining unsupported entry, the BARE form must surface a
+// BF021/BF101 build error (so the user is told to act), and wrapping
+// the expression in `/* @client */` must clear that error and emit a
+// client-only placeholder so the Go SSR pass renders valid template
+// the client runtime fills at hydration.
 //
-// Why this matters beyond "no error": the unsupported *string* methods
-// are a silent footgun. Unlike the unsupported array methods (which
-// surface BF101 at build time), bare `.startsWith` / `.repeat` / …
-// lower to a Go method-call expression (`{{.Name.StartsWith "a"}}`)
-// that passes the adapter's gate with NO diagnostic — then explodes at
-// `go run` time with `can't evaluate field StartsWith in type string`.
-// `/* @client */` is the only escape hatch, so these tests pin it.
+// History (#1448 follow-up): the unsupported *string* methods used to
+// be a silent footgun — bare `.startsWith` / `.repeat` / … lowered to
+// a Go method-call expression (`{{.Name.StartsWith "a"}}`) that passed
+// the adapter's gate with NO diagnostic, then exploded at `go run`
+// time with `can't evaluate field StartsWith in type string`. They are
+// 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 @client escape hatch (unsupported methods)', () => {
   // Compile a single expression placed in `<div>` text position, with
   // and without the directive, and return both the build errors and
@@ -1970,54 +2318,61 @@ export function C() {
     return { errors: adapter.errors ?? [], template }
   }
 
-  // Tier C array methods — bare form raises BF101 at build time.
-  const unsupportedArray: Array<[string, string]> = [
-    ['reduce', `items().reduce((a, b) => a + b.n, 0)`],
-    ['flatMap', `items().flatMap(i => i.tags)`],
-    ['flat', `items().flat()`],
+  // Unsupported methods that surface as BF101 at build time: Tier C
+  // array methods + Tier B/C string methods. `badEmit` is the invalid
+  // Go fragment that must NOT survive into the template (the pre-fix
+  // silent-footgun output for the string rows).
+  const unsupported: Array<{ name: string; expr: string; badEmit: string }> = [
+    // Tier C array methods.
+    { name: 'reduce', expr: `items().reduce((a, b) => a + b.n, 0)`, badEmit: '.Reduce' },
+    { name: 'flatMap', expr: `items().flatMap(i => i.tags)`, badEmit: '.FlatMap' },
+    { name: 'flat', expr: `items().flat()`, badEmit: '.Flat' },
+    // Tier B/C string methods — previously slipped through with no
+    // diagnostic; now gated by `UNSUPPORTED_METHODS`.
+    { name: 'split', expr: `name().split(",")`, badEmit: '.Name.Split' },
+    { name: 'startsWith', expr: `name().startsWith("a")`, badEmit: '.Name.StartsWith' },
+    { name: 'endsWith', expr: `name().endsWith("z")`, badEmit: '.Name.EndsWith' },
+    { name: 'replace', expr: `name().replace("a", "b")`, badEmit: '.Name.Replace' },
+    { name: 'repeat', expr: `name().repeat(3)`, badEmit: '.Name.Repeat' },
+    { name: 'padStart', expr: `name().padStart(5, "0")`, badEmit: '.Name.PadStart' },
+    { name: 'padEnd', expr: `name().padEnd(5, "0")`, badEmit: '.Name.PadEnd' },
+    { name: 'charAt', expr: `name().charAt(0)`, badEmit: '.Name.CharAt' },
   ]
-  for (const [name, expr] of unsupportedArray) {
-    test(`array .${name}: bare raises BF101, @client clears it + emits client placeholder`, () => {
+  for (const { name, expr, badEmit } of unsupported) {
+    test(`.${name}: bare raises BF101, @client clears it + emits client placeholder`, () => {
       const bare = emit(expr, false)
       expect(bare.errors.some(e => e.code === 'BF101')).toBe(true)
+      // The unlowerable method call must NOT leak into the template;
+      // the adapter degrades to a safe empty slot alongside the error.
+      expect(bare.template).not.toContain(badEmit)
 
       const guarded = emit(expr, true)
       expect(guarded.errors).toEqual([])
       // Client-only text slot → `{{bfComment "client:sN"}}` placeholder.
       expect(guarded.template).toMatch(/bfComment "client:s\d+"/)
-      // The unlowerable expression must NOT survive into the template.
-      expect(guarded.template).not.toContain('.Reduce')
-      expect(guarded.template).not.toContain('.FlatMap')
-    })
-  }
-
-  // Tier B/C string methods — bare form emits an INVALID Go method
-  // call with NO build error (the silent footgun). `@client` is the
-  // only thing that prevents the render-time crash.
-  const unsupportedString: Array<[string, string, string]> = [
-    ['split', `name().split(",")`, '.Name.Split'],
-    ['startsWith', `name().startsWith("a")`, '.Name.StartsWith'],
-    ['endsWith', `name().endsWith("z")`, '.Name.EndsWith'],
-    ['replace', `name().replace("a", "b")`, '.Name.Replace'],
-    ['repeat', `name().repeat(3)`, '.Name.Repeat'],
-    ['padStart', `name().padStart(5, "0")`, '.Name.PadStart'],
-    ['padEnd', `name().padEnd(5, "0")`, '.Name.PadEnd'],
-    ['charAt', `name().charAt(0)`, '.Name.CharAt'],
-  ]
-  for (const [name, expr, badEmit] of unsupportedString) {
-    test(`string .${name}: bare emits invalid Go method call, @client emits client placeholder`, () => {
-      const bare = emit(expr, false)
-      // Documents the footgun: no BF101 guard, invalid template emitted.
-      expect(bare.errors.filter(e => e.code === 'BF101')).toEqual([])
-      expect(bare.template).toContain(badEmit)
-
-      const guarded = emit(expr, true)
-      expect(guarded.errors).toEqual([])
-      expect(guarded.template).toMatch(/bfComment "client:s\d+"/)
       expect(guarded.template).not.toContain(badEmit)
     })
   }
 
+  // Predicate-level use of an unsupported string method also fails the
+  // build loudly (intended): a `.filter(t => t.name.startsWith("a"))`
+  // whose predicate calls one of the gated methods now refuses the whole
+  // loop with BF101 (via the shared `isSupported` predicate gate in
+  // jsx-to-ir) rather than lowering to a broken `.StartsWith` inside the
+  // range. Pinning this so the loud-failure contract can't silently
+  // regress back to the old emit-broken-template behaviour.
+  test('unsupported string method inside a .filter() predicate raises BF101', () => {
+    const result = compileJSX(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string }[]>([])
+  return <ul>{items().filter(t => t.name.startsWith("a")).map(t => <li key={t.name}>{t.name}</li>)}</ul>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter() })
+    expect(result.errors?.some(e => e.code === 'BF101')).toBe(true)
+  })
+
   // 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>)`],
@@ -2043,22 +2398,25 @@ export function C() {
     })
   }
 
-  // End-to-end proof via `go run`: the bare unsupported form crashes
-  // the Go template execution, while the `@client` form renders a
-  // `<!--bf-client:sN-->` placeholder. Skipped on hosts without Go.
-  test('e2e: bare string method crashes go render, @client renders placeholder', async () => {
-    const guarded = `
+  // 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
+  // more `can't evaluate field …` crash), so we assert the build error
+  // rather than a render crash. Skipped on hosts without Go.
+  test('e2e: @client renders placeholder; bare is caught at build with BF101', async () => {
+    const bare = emit(`name().repeat(3)`, false)
+    expect(bare.errors.some(e => e.code === 'BF101')).toBe(true)
+
+    try {
+      const html = await renderGoTemplateComponent({
+        source: `
 "use client"
 import { createSignal } from "@barefootjs/client"
 export function C() {
   const [name, setName] = createSignal("hello")
   return <div>{/* @client */ name().repeat(3)}</div>
 }
-`
-    const bareSrc = guarded.replace('/* @client */ ', '')
-    try {
-      const html = await renderGoTemplateComponent({
-        source: guarded.trimStart(),
+`.trimStart(),
         adapter: new GoTemplateAdapter(),
       })
       expect(html).toContain('<!--bf-client:s0-->')
@@ -2069,12 +2427,5 @@ export function C() {
       }
       throw err
     }
-    // Bare form must fail Go template execution (no @client guard).
-    await expect(
-      renderGoTemplateComponent({
-        source: bareSrc.trimStart(),
-        adapter: new GoTemplateAdapter(),
-      }),
-    ).rejects.toThrow(/can't evaluate field Repeat in type string/)
   })
 })