@barefootjs/go-template 0.5.0 → 0.5.2

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

@@ -76,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
@@ -518,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)', () => {
@@ -1897,3 +2256,176 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
     })
   }
 })
+
+// =============================================================================
+// #1448 — `/* @client */` escape hatch for STILL-UNSUPPORTED methods
+// =============================================================================
+//
+// 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, 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.
+//
+// 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
+  // the emitted template.
+  function emit(expr: string, client: boolean) {
+    const marker = client ? '/* @client */ ' : ''
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string; n: number; tags: string[] }[]>([])
+  const [name, setName] = createSignal("x")
+  const myCmp = (a: { n: number }, b: { n: number }) => a.n - b.n
+  return <div>{${marker}${expr}}</div>
+}
+`, adapter)
+    const template = adapter.generate(ir).template ?? ''
+    return { errors: adapter.errors ?? [], template }
+  }
+
+  // Same shape but the expression is a `.map()` chain that renders a
+  // loop (sort follow-ups land here). The client placeholder is a
+  // loop comment rather than a text comment.
+  function emitLoop(chain: string, client: boolean) {
+    const marker = client ? '/* @client */ ' : ''
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string; n: number }[]>([])
+  const myCmp = (a: { n: number }, b: { n: number }) => a.n - b.n
+  return <ul>{${marker}${chain}}</ul>
+}
+`, adapter)
+    const template = adapter.generate(ir).template ?? ''
+    return { errors: adapter.errors ?? [], template }
+  }
+
+  // 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, 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+"/)
+      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>)`],
+    ['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) {
+    test(`sort follow-up (${label}): bare raises BF021, @client clears it`, () => {
+      const bare = compileJSX(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string; n: number }[]>([])
+  const myCmp = (a: { n: number }, b: { n: number }) => a.n - b.n
+  return <ul>{${chain}}</ul>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter() })
+      expect(bare.errors?.some(e => e.code === 'BF021')).toBe(true)
+
+      const guarded = emitLoop(chain, true)
+      expect(guarded.errors).toEqual([])
+      // Client-only loop → `{{bfComment "loop:lN"}}…{{bfComment "/loop:lN"}}`.
+      expect(guarded.template).toMatch(/bfComment "loop:l\d+"/)
+    })
+  }
+
+  // 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>
+}
+`.trimStart(),
+        adapter: new GoTemplateAdapter(),
+      })
+      expect(html).toContain('<!--bf-client:s0-->')
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) {
+        console.log('Skipping #1448 @client e2e: go command not found')
+        return
+      }
+      throw err
+    }
+  })
+})