@barefootjs/go-template 0.33.4 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/adapter-go-template"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.33.4"
+    "@barefootjs/shared": "0.34.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -67,9 +67,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/client": "0.33.4",
-    "@barefootjs/jsx": "0.33.4",
-    "@barefootjs/vite": "0.33.4",
+    "@barefootjs/client": "0.34.0",
+    "@barefootjs/jsx": "0.34.0",
+    "@barefootjs/vite": "0.34.0",
     "vite": "^6.0.0"
   }
 }

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

@@ -18,6 +18,7 @@ import {
 } from '@barefootjs/jsx'
 import { conformancePins } from '../conformance-pins'
 import { renderDivergences } from '../render-divergences'
+import { findNestedComponents } from '../adapter/analysis/component-tree.ts'
 
 runAdapterConformanceTests({
   name: 'go-template',
@@ -128,14 +129,6 @@ runAdapterConformanceTests({
     // produces no complete template.
     'jsx-element-prop-rest-bag-dynamic',
   ]),
-  skipDataPoints: new Set<string>([
-    // #2743: html/template's URL-context autoescape percent-encodes the
-    // queryHref BASE in href position (`日本語` → `%e6%97%a5…`); the JS
-    // reference only HTML-escapes. The bf_query helper itself is faithful —
-    // the divergence is Go's contextual escaper on the whole href value.
-    'query-href:gen:base:markup',
-    'query-href:gen:base:multibyte',
-  ]),
   onRenderError: (err, id) => {
     if (err instanceof GoNotAvailableError) {
       console.log(`Skipping [${id}]: ${err.message}`)
@@ -987,7 +980,9 @@ export function List() {
 
     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.
+      // shape can't be synthesised — bail to nil. `tags` is a nested array
+      // of SCALARS (not objects) — #2800 only teaches synthesis to recurse
+      // into an array of OBJECT literals, so this shape is unchanged.
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`
 "use client"
@@ -1001,6 +996,85 @@ export function List() {
       expect(adapter.generate(ir).types!).toContain('Items: nil,')
     })
 
+    // #2800: a nested array-of-objects field (`children: [{...}]`) recurses
+    // into its own synthesized struct instead of aborting the whole
+    // signal's synthesis.
+    test('synthesises a nested struct for a nested array-of-objects field and bakes it (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function NestedRefConst() {
+  const [items] = createSignal([
+    { id: 1, label: 'Alpha', children: [{ id: 10, label: 'Alpha-child' }] },
+    { id: 2, label: 'Beta', children: [{ id: 20, label: 'Beta-child' }] },
+  ])
+  return <ul>{items().map((row) => <li key={row.id}>{row.label}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('type NestedRefConstItemsItemChildrenItem struct')
+      expect(types).toContain('Children []NestedRefConstItemsItemChildrenItem')
+      expect(types).not.toContain('Items: nil,')
+      expect(types).toContain(
+        'Items: []NestedRefConstItemsItem{NestedRefConstItemsItem{ID: 1, Label: "Alpha", Children: []NestedRefConstItemsItemChildrenItem{NestedRefConstItemsItemChildrenItem{ID: 10, Label: "Alpha-child"}}}, NestedRefConstItemsItem{ID: 2, Label: "Beta", Children: []NestedRefConstItemsItemChildrenItem{NestedRefConstItemsItemChildrenItem{ID: 20, Label: "Beta-child"}}}}',
+      )
+    })
+
+    test('recurses to arbitrary depth, widening a numeric field at the innermost level (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Depth3() {
+  const [items] = createSignal([
+    { id: 1, kids: [{ id: 10, grand: [{ id: 100, n: 1 }, { id: 101, n: 2.5 }] }] },
+  ])
+  return <ul>{items().map((row) => <li key={row.id}>{row.id}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('type Depth3ItemsItemKidsItemGrandItem struct')
+      expect(types).toMatch(/type Depth3ItemsItemKidsItemGrandItem struct \{\n\tID int[\s\S]*\tN float64/)
+      expect(types).toContain('Kids []Depth3ItemsItemKidsItem')
+      expect(types).toContain('Grand []Depth3ItemsItemKidsItemGrandItem')
+      expect(types).not.toContain('Items: nil,')
+    })
+
+    test('keeps nil when a nested struct name collides with a user type (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type ListItemsItemChildrenItem = { id: string }
+export function List() {
+  const [items] = createSignal([{ id: 1, children: [{ id: 2 }] }])
+  return <ul>{items().map((row) => <li key={row.id}>{row.id}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(ir).types!).toContain('Items: nil,')
+    })
+
+    test('keeps nil when a key is a nested array in some rows and scalar in others (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function List() {
+  const [items] = createSignal([
+    { id: 1, children: [{ id: 2 }] },
+    { id: 3, children: 'not-an-array' },
+  ])
+  return <ul>{items().map((row) => <li key={row.id}>{row.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
@@ -1407,6 +1481,201 @@ export function Widget(props: P) {
       expect(types).toContain('Classes: "a b" + " " + "c d" + " " + in.ClassName + " tail"')
     })
 
+    // A signal seeded from a bare identifier referencing a module-level
+    // const (`const PAYLOAD = '...'; createSignal(PAYLOAD)`) used to bake
+    // to `nil` — the analyzer types it `unknown` since it never chases an
+    // identifier to its declaration, so none of convertInitialValue's typed
+    // branches saw it (#2794). Now resolved via the same
+    // resolveModuleStringConst/resolveModuleNumericConst the adapter
+    // already used for live template expressions (template-interp.ts).
+    test('signal seeded from a module-level const bakes its literal value, not nil', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+const PAYLOAD = 'hello'
+const WIDTH = 8
+export function Demo() {
+  const [value] = createSignal(PAYLOAD)
+  const [width] = createSignal(WIDTH)
+  return <textarea value={value()} data-w={width()} />
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).toContain('Value: "hello"')
+      expect(types).toContain('Width: 8')
+    })
+
+    // Same family, boolean shape (#2815 — filed and fixed in the same PR
+    // as #2794 above, since it's the identical resolver-not-wired gap on
+    // a third literal kind rather than a new mechanism).
+    test('signal seeded from a module-level boolean const bakes true/false, not nil', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+const OPEN = true
+export function Demo() {
+  const [open] = createSignal(OPEN)
+  return <div>{open() ? 'y' : 'n'}</div>
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).toContain('Open: true')
+    })
+
+    // #2700: a `derived` signal (non-empty free set, e.g. `{ ...base, done }`)
+    // whose object literal the constructor-time baker can't reproduce
+    // (identifier/member/call operands defer) used to silently keep the Go
+    // zero value for every field the SSR template reads. Loud-ified instead
+    // of taught a live-expression lowering — Go has none — since the
+    // template's `.Merged.ID` / `.Merged.Done` reads would otherwise see a
+    // wrong value with no diagnostic at all.
+    test('signal object-literal spreading a live prop refuses with BF101 when the template reads it (#2700)', () => {
+      const adapter = new GoTemplateAdapter()
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return (
+    <div>
+      <span>{merged().id}</span>
+      <span>{merged().done ? 'yes' : 'no'}</span>
+    </div>
+  )
+}
+`, adapter)
+      const bf101 = adapter.errors.filter(e => e.code === 'BF101')
+      expect(bf101.length).toBe(1)
+      expect(bf101[0].message).toContain("Signal 'merged'")
+      expect(bf101[0].message).toContain('base')
+      expect(bf101[0].suggestion?.escape).toEqual([{ kind: 'client-directive' }])
+      expect(result.template).toBeTruthy()
+    })
+
+    // Same refusal for an EXPLICITLY typed object signal (`createSignal<Item>`)
+    // — the typed `interface` branch (`value-lowering.ts`) also defers to a
+    // struct zero value (`Item{}`) for the identical reason.
+    test('typed object signal spreading a live prop also refuses with BF101 (#2700)', () => {
+      const adapter = new GoTemplateAdapter()
+      compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal<Item>({ id: base.id, done: true })
+  return <span>{merged().id}</span>
+}
+`, adapter)
+      expect(adapter.errors.some(e => e.code === 'BF101')).toBe(true)
+    })
+
+    // No memo-side counterpart: the analyzer deliberately never sets
+    // `MemoInfo.parsed` to an `object-literal` for an object-returning memo
+    // body (`analyzer.ts`, "isn't lowered from the parsed tree yet") — a
+    // pre-existing, unrelated exclusion — so this refusal has no structural
+    // handle to reach a memo without re-parsing `computation` as text,
+    // which the repo's own convention rules out. #2700's own reproduction
+    // and fixture are signal-only.
+
+    // The `/* @client */` escape: wrapping every SSR read defers evaluation
+    // to the client, so the template never reaches `rootFieldRef` for this
+    // signal — no refusal, even though the constructor still bakes `nil`.
+    test('/* @client */ on every read suppresses the #2700 refusal', () => {
+      const adapter = new GoTemplateAdapter()
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return (
+    <div>
+      <span>{/* @client */ merged().id}</span>
+      <span>{/* @client */ merged().done ? 'yes' : 'no'}</span>
+    </div>
+  )
+}
+`, adapter)
+      expect(adapter.errors.filter(e => e.code === 'BF101')).toEqual([])
+      expect(result.types).toContain('Merged: nil,')
+    })
+
+    // A signal that ONLY feeds a JSX spread (`{...merged()}`) never reaches
+    // `rootFieldRef` — spread bags bake through their own `.Spread_<slot>`
+    // route (`emitSpreadBagInits`) — so it must not trip the #2700 check even
+    // though the constructor still can't bake the literal. (This shape DOES
+    // still refuse, but with the PRE-EXISTING, unrelated "JSX spread has no
+    // Go template lowering" BF101 for `{...merged()}` on an intrinsic
+    // element — not a second, redundant #2700-shaped one.)
+    test('a signal only spread into attrs does not double-refuse under #2700', () => {
+      const adapter = new GoTemplateAdapter()
+      compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return <div {...merged()} />
+}
+`, adapter)
+      const bf101 = adapter.errors.filter(e => e.code === 'BF101')
+      expect(bf101.length).toBe(1)
+      expect(bf101[0].message).not.toContain("Signal 'merged' is seeded")
+    })
+
+    // A signal read ONLY from inside a `.filter()` predicate (never a plain
+    // `{merged()}` text read) must still register in `templateReadRootFields`
+    // and trip #2700's refusal — `renderFilterExprNode`'s zero-arg-call arm
+    // used to build the `$.Merged` field reference by hand instead of
+    // through `rootFieldRef`, so this exact shape was a false negative
+    // (pullfrog review, PR #2818).
+    test('a signal reachable only through a .filter() predicate still refuses with BF101 (#2700, #2818 pullfrog review)', () => {
+      const adapter = new GoTemplateAdapter()
+      compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base, items }: { base: Item; items: Item[] }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return (
+    <ul>
+      {items().filter(i => i.id === merged().id).map(i => <li key={i.id}>{i.id}</li>)}
+    </ul>
+  )
+}
+`, adapter)
+      const bf101 = adapter.errors.filter(e => e.code === 'BF101')
+      expect(bf101.length).toBe(1)
+      expect(bf101[0].message).toContain("Signal 'merged'")
+    })
+
+    // A destructured prop sharing the module const's name must still win
+    // (shadowing) — the const resolver is checked AFTER the prop lookup.
+    test('a destructured prop shadows a same-named module const', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+const PAYLOAD = 'const-value'
+interface P { PAYLOAD?: string }
+export function Demo({ PAYLOAD }: P) {
+  const [value] = createSignal(PAYLOAD)
+  return <textarea value={value()} />
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).not.toContain('Value: "const-value"')
+      // Positive pin (pullfrog review, #2816): the absence check above
+      // would pass just as well if the value fell through to `nil`
+      // instead of resolving to the prop — assert the actual expected
+      // shadowing output too, matching the `Value: in.Value,` convention
+      // used elsewhere in this file.
+      expect(types).toContain('Value: in.PAYLOAD,')
+    })
+
     // A boolean ternary memo (`isChecked = ctrl() ? c() : i()`) types its
     // SSR field as `bool` (not `int`), so `aria-checked={isChecked()}`
     // matches Hono's `aria-checked="false"` shape. Since #2260, `checked`'s
@@ -5112,6 +5381,61 @@ export function Toggle({ toggleItems }: ToggleProps) {
   })
 })
 
+describe('GoTemplateAdapter - #2835 name collision with a whole-props type member', () => {
+  // Same-file sibling components (`Item` alongside the exported `List`) —
+  // compiled with `compileJSX` directly, like the #2445 describe block above,
+  // since `compileToIR`'s single-component IR round trip isn't set up to
+  // pick a specific sibling out of a multi-component file.
+  const collidingSource = `
+type ItemProps = { label: string }
+function Item(props: ItemProps) {
+  return <div>{props.label}</div>
+}
+const base = [{ label: 'z' }]
+type Props = { base: ItemProps[] }
+export function List(props: Props) {
+  return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+}
+`
+  const controlSource = `
+type ItemProps = { label: string }
+function Item(props: ItemProps) {
+  return <div>{props.label}</div>
+}
+const base = [{ label: 'z' }]
+type Props = { other: string }
+export function List(props: Props) {
+  return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+}
+`
+
+  test('a module const colliding with `Props.base` is not classified prop-derived — the actual input `findNestedComponents` (component-tree.ts) feeds to Go codegen', () => {
+    const ctx = analyzeComponent(collidingSource.trimStart(), 'test.tsx', 'List')
+    const ir = jsxToIR(ctx)
+    expect(ir).not.toBeNull()
+    const item = findNestedComponents(ir!).find(c => c.name === 'Item')
+    expect(item).toBeDefined()
+    expect(item!.isPropDerived).toBe(false)
+    expect(item!.isDynamic).toBe(false)
+  })
+
+  test('Items stays a real hydrated field (`json:"items"`), matching the non-colliding control — misclassification previously hid it behind `json:"-"` and fabricated an unrelated `Base` prop read', () => {
+    const collidingResult = compileJSX(collidingSource.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const controlResult = compileJSX(controlSource.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const collidingTypes = collidingResult.files.find(f => f.type === 'types')!.content
+    const controlTypes = controlResult.files.find(f => f.type === 'types')!.content
+    // `Props.base` is a real declared member independent of the loop
+    // classification, so it legitimately gets its own `Base`/`bfCallerProps`
+    // entries in BOTH cases — the loop-specific signal is the `Items` field,
+    // which a misclassified `isPropDerived: true` hides from JSON entirely.
+    expect(collidingTypes).toContain('Items []ItemProps `json:"items"`')
+    expect(collidingTypes).not.toContain('Items []ItemProps `json:"-"`')
+    const itemsFieldLine = (src: string) => src.split('\n').find(l => l.includes('[]ItemInput')) ?? ''
+    expect(itemsFieldLine(collidingTypes)).not.toBe('')
+    expect(itemsFieldLine(collidingTypes)).toBe(itemsFieldLine(controlTypes))
+  })
+})
+
 describe('GoTemplateAdapter - collision-derivation lowering (#2683)', () => {
   test('a signal colliding with its own prop composes the presence-check fold with the surrounding arithmetic', () => {
     const result = compileJSX(`

package/src/__tests__/lowering-plugin.test.ts

@@ -149,6 +149,11 @@ export function P(props: { config: object }) {
     // naming exactly — the formula generalises, it isn't a lookup table
     // limited to `query`.
     expect(template).toContain('bf_custom_serialize .Config')
+    // #2743: the whole-attribute `bf_attr` route is keyed on the neutral
+    // `guard-list` + `helper === 'query'` shape specifically — a
+    // `helper-call` node (this plugin's shape) is a different node kind and
+    // must not be routed through it.
+    expect(template).not.toContain('bf_attr')
   })
 
   test('without the plugin registered, the call falls back to the generic (unsupported) lowering', () => {
@@ -163,6 +168,39 @@ export function P(props: { config: object }) {
     expect(template).not.toContain('bf_custom_serialize')
   })
 
+  // #2842: a `helper-call` node (not the `query` guard-list) reached through
+  // the undef-alternate omission shape now routes through the fixed `call()`
+  // dispatcher — but NOT through `bf_attr` (only `query` needs the
+  // URL-context-escape bypass; a plain helper-call keeps the ordinary
+  // `name="{{…}}"` wrapper the `{{if}}` already builds around).
+  test('an undef-alternate helper-call consequent is registry-lowered without bf_attr (#2842)', () => {
+    registerLoweringPlugin(customSerializePlugin)
+    const src = `
+'use client'
+import { customSerialize } from './lib'
+export function P(props: { on: boolean; config: object }) {
+  return <div data-config={props.on ? customSerialize(props.config) : undefined}>x</div>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('{{if .On}}data-config="{{bf_custom_serialize .Config}}"{{end}}')
+    expect(template).not.toContain('bf_attr')
+  })
+
+  // Same shape, plugin NOT registered — pins that an unmatched call keeps the
+  // existing generic Go-method-call convention (no new BF10x refusal).
+  test('an undef-alternate helper-call consequent with no plugin registered keeps the generic convention', () => {
+    const src = `
+'use client'
+import { customSerialize } from './lib'
+export function P(props: { on: boolean; config: object }) {
+  return <div data-config={props.on ? customSerialize(props.config) : undefined}>x</div>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('{{if .On}}data-config="{{.CustomSerialize .Config}}"{{end}}')
+  })
+
   test('a CONDITIONAL helper-call arg renders as pipeline-position bf_ternary, not an {{if}} action', () => {
     // The #2324 union stage lowers a union-typed locale to a ternary
     // pattern arg. Go templates have no expression-level conditional, and

package/src/__tests__/query-href.test.ts

@@ -176,4 +176,130 @@ export function P(props: { base: string; q: Record<string, string> }) {
     const { template } = generate(src)
     expect(template).not.toContain('bf_query')
   })
+
+  // #2743: a `queryHref` value in an ATTRIBUTE position emits the whole
+  // attribute via `bf_attr` (template.HTMLAttr) so html/template's
+  // contextual URL-context autoescape (keyed off the attribute NAME) never
+  // percent-encodes the base — see `lowerRegisteredAttrCall`.
+  test('an href-attribute queryHref value routes through bf_attr, not `href="{{...}}"`', () => {
+    const src = `
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; tag: string }) {
+  return <a href={queryHref(props.base, { tag: props.tag })}>x</a>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('{{bf_attr "href" (bf_query .Base (true) "tag" .Tag)}}')
+    expect(template).not.toContain('href="{{')
+  })
+
+  // The route is keyed on the neutral `helper === 'query'` fact, not on the
+  // attribute name `href` — any attribute (e.g. `title`) gets the same
+  // treatment, since `queryHref` returns a plain string with nothing
+  // href-specific about it.
+  test('a non-href attribute (title) with a queryHref value also routes through bf_attr', () => {
+    const src = `
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; tag: string }) {
+  return <a title={queryHref(props.base, { tag: props.tag })}>x</a>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('{{bf_attr "title" (bf_query .Base (true) "tag" .Tag)}}')
+    expect(template).not.toContain('title="{{')
+  })
+
+  // Text-position (non-attribute) use is unaffected — `bf_attr` only wraps
+  // the whole-attribute case; a queryHref value read as text still lowers
+  // to a bare `bf_query` pipeline.
+  test('a queryHref value in text position is not wrapped in bf_attr', () => {
+    const src = `
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; tag: string }) {
+  return <span>{queryHref(props.base, { tag: props.tag })}</span>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('bf_query .Base (true) "tag" .Tag')
+    expect(template).not.toContain('bf_attr')
+  })
+
+  // #2743 follow-up (pullfrog review on #2841): a ternary attribute value
+  // with a real (non-`undefined`) alternate is syntactically valid and
+  // already lowers both branches correctly via `bf_ternary` — but was still
+  // wrapped in the ordinary `name="{{...}}"` form, leaving it exposed to
+  // html/template's URL-context percent-encoding. This must route through
+  // `bf_attr` too, wrapping the whole `bf_ternary` pipeline.
+  test('a queryHref value in a ternary branch (non-undefined alternate) routes through bf_attr', () => {
+    const src = `
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { ok: boolean; base: string; tag: string }) {
+  return <a href={props.ok ? queryHref(props.base, { tag: props.tag }) : '/fallback'}>x</a>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain(
+      '{{bf_attr "href" (bf_ternary (bf_truthy .Ok) (bf_query .Base (true) "tag" .Tag) "/fallback")}}',
+    )
+    expect(template).not.toContain('href="{{')
+  })
+
+  // #2842: the `undefined`-alternate omission shape used to render only the
+  // consequent via a registry-blind path, emitting invalid Go syntax
+  // (`.QueryHref .Base bf_map "tag" .Tag`) with no diagnostic. The consequent
+  // now routes through `lowerRegisteredAttrCall` (the same whole-attribute
+  // `bf_attr` bypass the direct-call and non-undefined-ternary shapes use),
+  // inside the `{{if}}` that implements the omission.
+  test('the undefined-alternate omission shape routes the consequent through bf_attr inside the {{if}} (#2842)', () => {
+    const src = `
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { ok: boolean; base: string; tag: string }) {
+  return <a href={props.ok ? queryHref(props.base, { tag: props.tag }) : undefined}>x</a>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('{{if .Ok}}{{bf_attr "href" (bf_query .Base (true) "tag" .Tag)}}{{end}}')
+    expect(template).not.toContain('.QueryHref')
+    expect(template).not.toContain('bf_map')
+    expect(template).not.toContain('href="{{')
+  })
+
+  // #2842: a registered call nested in a template-literal interpolation
+  // (not just a direct attribute value) is registry-lowered too — the fix
+  // lives in the shared ParsedExpr `call()` dispatcher, so any nested
+  // position benefits, not only the ternary/attribute cases above.
+  test('a queryHref call nested in a template-literal interpolation is registry-lowered (#2842)', () => {
+    const src = `
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; tag: string }) {
+  return <a title={\`pre \${queryHref(props.base, { tag: props.tag })}\`}>x</a>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('title="pre {{bf_query .Base (true) "tag" .Tag}}"')
+    expect(template).not.toContain('.QueryHref')
+  })
+
+  // #2842: a nested ternary inside the undef-alternate consequent still
+  // recurses correctly — `lowerRegisteredAttrCall`'s `conditional` arm
+  // right-folds, matching `lowerTernary`'s own recursion.
+  test('a nested ternary inside the undef-alternate consequent still routes through bf_attr (#2842)', () => {
+    const src = `
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { a: boolean; b: boolean; base: string; tag: string }) {
+  return <a href={props.a ? (props.b ? queryHref(props.base, { tag: props.tag }) : '/x') : undefined}>x</a>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain(
+      '{{if .A}}{{bf_attr "href" (bf_ternary (bf_truthy .B) (bf_query .Base (true) "tag" .Tag) "/x")}}{{end}}',
+    )
+  })
 })

package/src/adapter/emit-context.ts

@@ -79,4 +79,18 @@ export interface GoEmitContext {
    * outer-loop params are excluded).
    */
   resolveModuleStringConst(name: string): string | null
+
+  /**
+   * Inline a module numeric const by name as its Go literal text (e.g.
+   * `8`, `-3.5`), or null when the name is not such a const (loop vars and
+   * outer-loop params are excluded, same as `resolveModuleStringConst`).
+   */
+  resolveModuleNumericConst(name: string): string | null
+
+  /**
+   * Inline a module boolean const by name as its Go literal text
+   * (`true`/`false`), or null when the name is not such a const (same
+   * exclusions as `resolveModuleNumericConst`).
+   */
+  resolveModuleBooleanConst(name: string): string | null
 }