@barefootjs/go-template 0.33.6 → 0.35.0

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/expr/url-builder.ts

@@ -128,6 +128,44 @@ function lowerTernaryTest(ctx: GoEmitContext, test: ParsedExpr): string {
   return isBoolShape ? go : `(bf_truthy ${go})`
 }
 
+/**
+ * First registered matcher that recognises `callee(args)`, or null (#2842).
+ * The single registry consultation every Go lowering path shares: the
+ * top-level `lowerRegisteredCall` early return, the ParsedExpr `call()`
+ * dispatcher (`go-template-adapter.ts`, so a registered call is recognised no
+ * matter how deep it sits in an expression tree — a ternary branch, a
+ * template-literal interpolation, a binary operand — not only when the call
+ * IS the whole expression), and the attribute-position `bf_attr` route all
+ * ask this one question. First-match-wins: a malformed helper id from one
+ * plugin must not be silently masked by falling through to another.
+ */
+export function matchRegisteredCall(
+  ctx: GoEmitContext,
+  callee: ParsedExpr,
+  args: readonly ParsedExpr[],
+): LoweringNode | null {
+  for (const matcher of ctx.state.loweringMatchers) {
+    const node = matcher(callee, args)
+    if (node) return node
+  }
+  return null
+}
+
+/**
+ * Render a recognised call's neutral node to its Go pipeline (unparenthesised
+ * — same contract as `lowerRegisteredCall`), or null when no plugin matches
+ * or the matched helper has no Go mapping.
+ */
+export function lowerRegisteredCallNode(
+  ctx: GoEmitContext,
+  callee: ParsedExpr,
+  args: readonly ParsedExpr[],
+): string | null {
+  if (ctx.state.loweringMatchers.length === 0) return null
+  const node = matchRegisteredCall(ctx, callee, args)
+  return node ? renderLoweringNode(ctx, node) : null
+}
+
 /**
  * Lower a helper call to a Go template expression, or null when no registered
  * plugin recognises it (→ the generic lowering). Matchers — including the
@@ -144,8 +182,7 @@ export function lowerRegisteredCall(
   jsExpr: string,
   preParsed?: ParsedExpr,
 ): string | null {
-  const matchers = ctx.state.loweringMatchers
-  if (matchers.length === 0) return null
+  if (ctx.state.loweringMatchers.length === 0) return null
 
   let call: ParsedExpr | undefined = preParsed?.kind === 'call' ? preParsed : undefined
   if (!call) {
@@ -155,13 +192,82 @@ export function lowerRegisteredCall(
     call = parsed
   }
 
-  for (const matcher of matchers) {
-    const node = matcher(call.callee, call.args)
-    if (!node) continue
-    const rendered = renderLoweringNode(ctx, node)
-    if (rendered !== null) return rendered
+  return lowerRegisteredCallNode(ctx, call.callee, call.args)
+}
+
+/**
+ * Attribute-position twin of `lowerRegisteredCall` (#2743). When an intrinsic
+ * element attribute's value is a `query` guard-list (the neutral node the
+ * `queryHref` plugin — or any plugin reusing the `query` helper — produces),
+ * emit the WHOLE attribute as one `bf_attr` action returning
+ * `template.HTMLAttr`, instead of `name="{{bf_query …}}"`. html/template
+ * infers a URL context from the attribute NAME (`href`, `src`, `action`,
+ * `data-*`, anything containing `src`/`uri`/`url`, …) and percent-encodes the
+ * entire value there; the JS reference (Hono) only HTML-escapes. Keyed on the
+ * neutral `helper` id, not the attribute name (Go's URL-context table is a
+ * heuristic we must not re-implement) and not the JS API name. Returns null
+ * for a non-call, an unmatched call, or any other node kind/helper — the
+ * caller then takes its ordinary path.
+ *
+ * Also accepts a `conditional` node directly (#2743 follow-up, pullfrog
+ * review on #2841): a ternary with a real, non-`undefined` alternate
+ * (`cond ? queryHref(...) : '/fallback'`) is syntactically valid and already
+ * lowers its branches correctly via `lowerTernary` — but the CALLER used to
+ * still wrap the resulting `(bf_ternary …)` pipeline in the ordinary
+ * `name="{{...}}"` form, which leaves it exposed to the same URL-context
+ * percent-encoding this function exists to route around. Whenever EITHER
+ * branch (recursing through a right-folded nested ternary chain, the same
+ * shape `lowerTernary` itself right-folds) is a `query` guard-list call, the
+ * whole ternary is wrapped in `bf_attr` too — matching the reference, which
+ * HTML-escapes the picked branch's value the same way regardless of which
+ * branch won.
+ *
+ * The caller passes the CONSEQUENT ALONE (not the full ternary) for the
+ * `undefined`-alternate omission shape (`cond ? queryHref(...) : undefined`,
+ * #2842) — omission needs the `{{if}}` wrapper that shape's caller already
+ * builds; a `bf_ternary … ""` inside `bf_attr` can't express it (`Attr`
+ * renders `name=""` for an empty value, not attribute absence).
+ */
+export function lowerRegisteredAttrCall(
+  ctx: GoEmitContext,
+  attrName: string,
+  parsed: ParsedExpr,
+): string | null {
+  if (parsed.kind === 'conditional') {
+    if (!ternaryHasQueryBranch(ctx, parsed.consequent, parsed.alternate)) return null
+    // `lowerTernary` already returns a complete parenthesised `(bf_ternary …)`
+    // pipeline — pass it straight through as `bf_attr`'s value argument
+    // rather than re-wrapping it in a redundant second set of parens.
+    const rendered = lowerTernary(ctx, parsed.test, parsed.consequent, parsed.alternate)
+    return `{{bf_attr ${JSON.stringify(attrName)} ${rendered}}}`
   }
-  return null
+  if (parsed.kind !== 'call') return null
+  const node = matchRegisteredCall(ctx, parsed.callee, parsed.args)
+  if (!node || node.kind !== 'guard-list' || node.helper !== 'query') return null
+  const rendered = renderLoweringNode(ctx, node)
+  return rendered === null ? null : `{{bf_attr ${JSON.stringify(attrName)} (${rendered})}}`
+}
+
+/** Whether a `call` node is a recognised `query` guard-list lowering. */
+function isQueryGuardListCall(ctx: GoEmitContext, node: ParsedExpr): boolean {
+  if (node.kind !== 'call') return false
+  const lowered = matchRegisteredCall(ctx, node.callee, node.args)
+  return lowered?.kind === 'guard-list' && lowered.helper === 'query'
+}
+
+/**
+ * Whether either branch of a ternary is (or, for a right-folded chain,
+ * eventually resolves to) a `query` guard-list call — the trigger for
+ * routing the whole ternary through `bf_attr` in `lowerRegisteredAttrCall`.
+ */
+function ternaryHasQueryBranch(
+  ctx: GoEmitContext,
+  consequent: ParsedExpr,
+  alternate: ParsedExpr,
+): boolean {
+  const branchHasQuery = (n: ParsedExpr): boolean =>
+    n.kind === 'conditional' ? ternaryHasQueryBranch(ctx, n.consequent, n.alternate) : isQueryGuardListCall(ctx, n)
+  return branchHasQuery(consequent) || branchHasQuery(alternate)
 }
 
 /**

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

@@ -80,6 +80,9 @@ import {
   evaluateStaticLiteral,
   BindingScope,
   buildImportAliasMap,
+  resolveGetterAliases,
+  collectAliasableGetterNames,
+  resolveBodyDestructuredPropAliases,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
 import { BF_REGION, escapeHtml, resolveJsxChildrenProp } from '@barefootjs/shared'
@@ -127,7 +130,7 @@ import { analyzeBakeableStaticChildLoop, scalarToGoLiteral, type BakedStaticChil
 import { analyzeBakeableStaticElementLoop } from "./analysis/static-element-loop-bake.ts"
 import type { GoEmitContext } from "./emit-context.ts"
 import { inlineLocalHelperCall } from "./expr/helper-inline.ts"
-import { lowerRegisteredCall, lowerTernary } from "./expr/url-builder.ts"
+import { lowerRegisteredAttrCall, lowerRegisteredCall, lowerRegisteredCallNode, lowerTernary } from "./expr/url-builder.ts"
 import {
   convertInitialValue,
   jsLiteralToGo,
@@ -465,6 +468,23 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     )
     this.state.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
     this.state.localConstants = ir.metadata.localConstants ?? []
+    // #2813: precompute which local consts are bare alias-hop chains onto a
+    // signal/memo getter, so `rootFieldRef` can route a call through the
+    // getter's OWN field instead of registering a separate, never-seeded
+    // field under the alias's name. Env-signal getters are excluded — they
+    // resolve through `searchParamsFieldRef`, not a seeded root field.
+    {
+      const getterNames = collectAliasableGetterNames(ir.metadata.signals ?? [], ir.metadata.memos ?? [])
+      this.state.getterAliases = resolveGetterAliases(ir.metadata.localConstants ?? [], (n) => getterNames.has(n))
+    }
+    // #2788: bare-props-form body destructure aliases (`const { children:
+    // kids } = props`) — same alias-resolution need as `getterAliases`
+    // above, different terminal set (a prop key here, a signal/memo
+    // getter there).
+    this.state.propDestructureAliases = resolveBodyDestructuredPropAliases(
+      ir.metadata.localConstants ?? [],
+      ir.metadata.propsObjectName,
+    )
     // #2208 fable review: every name a `.map()`/`.filter()` loop callback
     // binds as its item/index parameter anywhere in the component. Static
     // loop-source resolution (`getBakedStaticChildLoop` /
@@ -4846,9 +4866,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * rebinds. Outside any loop the root *is* the dot, so we emit `.Field`.
    */
   private rootFieldRef(name: string): string {
-    this.state.templateReadRootFields.add(name)
+    // #2813 / #2788: `name` may be a bare local-const alias of a
+    // signal/memo getter (`const items__alias = items`) or a bare-props-
+    // form body destructure's renamed prop (`const { children: kids } =
+    // props`) — resolve it to the ALIASED entity's own name FIRST, so the
+    // emitted field matches what that entity itself seeds (`.Items`,
+    // `.Children`) instead of registering a second, never-populated field
+    // under the local alias (`.Items__alias`, `.Kids`).
+    const resolved = this.state.getterAliases.get(name) ?? this.state.propDestructureAliases.get(name) ?? name
+    this.state.templateReadRootFields.add(resolved)
     const prefix = this.inLoop ? '$.' : '.'
-    return `${prefix}${capitalizeFieldName(name)}`
+    return `${prefix}${capitalizeFieldName(resolved)}`
   }
 
   /**
@@ -4956,6 +4984,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string {
+    // #2842: a registered lowering (the built-in `queryHref`, or any userland
+    // plugin) must win in EVERY position this shared dispatcher reaches — a
+    // ternary branch, a template-literal interpolation, a binary operand —
+    // not only when the call is the whole expression (`convertExpressionToGo`'s
+    // own early return). Same precedence as that top-level path, where the
+    // registry is consulted before signal-read resolution and template
+    // primitives.
+    const lowered = lowerRegisteredCallNode(this.emitCtx, callee, args)
+    if (lowered !== null) return lowered
     // Signal call: count() -> .Count (or $.Count inside a loop). An env-signal
     // binding (`searchParams()`, or an aliased `sp()`) resolves to the canonical
     // `.SearchParams` field regardless of the JS name.
@@ -5232,7 +5269,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
   unary(op: string, argument: ParsedExpr, emit: (e: ParsedExpr) => string): string {
     const arg = emit(argument)
-    if (op === '!') return `not ${arg}`
+    // `not` is a Go template prefix builtin like `and`/`or` (see `logical()`
+    // below) — a multi-token argument (e.g. `or a b`) must be parenthesised
+    // or it degrades into extra sibling args of `not` itself (#2758: `not
+    // or a b` parses as `not` applied to 3 args, not 1).
+    if (op === '!') return `not ${wrapIfMultiToken(arg)}`
     if (op === '-') return `bf_neg ${arg}`
     return arg
   }
@@ -7074,7 +7115,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
       case 'unary': {
         const arg = this.renderConditionExpr(expr.argument)
-        if (expr.op === '!') return { preamble: arg.preamble, expr: `not ${arg.expr}` }
+        // Same prefix-builtin wrapping rule as the `logical` case just below
+        // (and the main `unary()` emitter above): `not` needs its multi-token
+        // argument parenthesised, or e.g. `not or a b` parses as `not`
+        // applied to 3 sibling args instead of 1 (#2758).
+        if (expr.op === '!') return { preamble: arg.preamble, expr: `not ${wrapIfMultiToken(arg.expr)}` }
         if (expr.op === '-') return { preamble: arg.preamble, expr: `bf_neg ${arg.expr}` }
         return arg
       }
@@ -7687,7 +7732,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // `bfComment` prepends `bf-`, so `printf "loop-i:%v"` yields
       // `<!--bf-loop-i:KEY-->`. The key expression resolves against the current
       // range item (`.` context), matching `data-key`'s emission.
-      return `{{bfComment (printf "loop-i:%v" ${this.convertExpressionToGo(loop.key)})}}`
+      // `bfEscapeCommentKey` (#2795 follow-up) neutralizes `-` so a key can't
+      // spell `-->` and close the comment early — see its doc in `bf.go`.
+      return `{{bfComment (printf "loop-i:%v" (bfEscapeCommentKey ${this.convertExpressionToGo(loop.key)}))}}`
     }
     return ''
   }
@@ -8021,10 +8068,30 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
               ? value.expr
               : value.expr.slice(0, value.expr.indexOf('?')).trim(),
           )
-          const valueExpr = this.renderParsedExpr(parsed.consequent)
-          const body = `${name}="{{${valueExpr}}}"`
+          // #2842 / #2743: a `query` guard-list consequent (queryHref) takes
+          // the whole-attribute `bf_attr` route INSIDE the `{{if}}`, so
+          // html/template's URL-context inference never percent-encodes it —
+          // the same route the direct-call and non-undefined-ternary shapes
+          // take. The consequent is passed alone (not the ternary): omission
+          // needs this `{{if}}` wrapper, which `bf_attr` can't express on its
+          // own. Any other consequent (a `helper-call` plugin, an unmatched
+          // call, a member/literal) keeps the ordinary `name="{{…}}"` form —
+          // `call()` now consults the registry too, so a plugin call renders
+          // its `bf_<helper>` pipeline there instead of invalid Go syntax.
+          const attrConsequent = lowerRegisteredAttrCall(this.emitCtx, name, parsed.consequent)
+          const body = attrConsequent !== null
+            ? attrConsequent
+            : `${name}="{{${this.renderParsedExpr(parsed.consequent)}}}"`
           return `${preamble}{{if ${goCond}}}${body}{{end}}`
         }
+        // #2743 follow-up (pullfrog review on #2841): a `query` guard-list
+        // value (queryHref) reachable through EITHER branch of this ternary
+        // still needs the whole-attribute `bf_attr` route — otherwise the
+        // pipeline below lands inside the ordinary `name="{{...}}"` wrapper
+        // and html/template's URL-context inference still percent-encodes
+        // whichever branch wins at render time. See `lowerRegisteredAttrCall`.
+        const attrTernary = lowerRegisteredAttrCall(this.emitCtx, name, parsed)
+        if (attrTernary !== null) return attrTernary
         // #2335: the ternary lowers to the pipeline-position `(bf_ternary …)`
         // value (no longer a `{{if}}…{{end}}` fragment), so wrap it in a single
         // `{{…}}` action inside the attribute string — `name="{{bf_ternary …}}"`.
@@ -8034,6 +8101,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // Inline Go template syntax with embedded `{{...}}` actions.
         return `${name}="${this.renderParsedExpr(parsed)}"`
       }
+      // #2743: a `query` guard-list value (queryHref) emits the WHOLE
+      // attribute via `bf_attr` (template.HTMLAttr) so html/template's
+      // URL-context inference on the attribute name never percent-encodes
+      // the base. See `lowerRegisteredAttrCall`.
+      const attrAction = lowerRegisteredAttrCall(this.emitCtx, name, parsed)
+      if (attrAction !== null) return attrAction
       // Nullish-attribute omission: when the attribute value is a BARE reference
       // to a nillable (`interface{}`) prop field, guard emission on `ne .X nil`
       // so an unset optional prop drops the attribute entirely instead of

package/src/adapter/lib/compile-state.ts

@@ -88,6 +88,28 @@ export class CompileState {
    */
   localConstants: IRMetadata['localConstants'] = []
 
+  /**
+   * Bare local-const alias-hop chains that ultimately name a signal/memo
+   * getter (`const items__alias = items` → `items__alias` -> `items`,
+   * #2813) — the SSR-side twin of #2778's CSR-template fix. `rootFieldRef`
+   * resolves a name through this map before capitalizing it into a struct
+   * field, so `items__alias()` reads `.Items` (the field the getter
+   * actually seeds) instead of a phantom, never-seeded `.Items__alias`.
+   */
+  getterAliases: Map<string, string> = new Map()
+
+  /**
+   * Local names that are BODY-level destructured aliases of a prop key
+   * for a bare-props-form component (`const { children: kids } =
+   * props`), #2788 — the SSR-side twin of `aliased-destructured-prop`'s
+   * PARAMETER-destructuring case (`{ n: count }`, already handled via
+   * `ParamInfo.sourceName`/`capitalizeFieldName(p.name)`). `rootFieldRef`
+   * resolves a name through this map too, so `kids` reads the same
+   * `.Children` field the prop itself seeds instead of a phantom,
+   * never-populated `.Kids`.
+   */
+  propDestructureAliases: Map<string, string> = new Map()
+
   /**
    * Every name a `.map()`/`.filter()` loop callback binds as its item/index
    * parameter anywhere in the component (#2208 fable review). Consulted by

package/src/render-divergences.ts

@@ -37,9 +37,4 @@
 
 import type { RenderDivergences } from '@barefootjs/jsx'
 
-export const renderDivergences: RenderDivergences = {
-  'children-passthrough-renamed':
-    'A `children` prop destructured under a different name (`const { children: kids } = props`) does not reach the SSR template on Go, tracked as https://github.com/piconic-ai/barefootjs/issues/2788. The same fixture also fails on Mojolicious, where the mechanism IS isolated: the `.html.ep` interpolates the LOCAL alias (`$kids`) while the stash defines only the caller-facing `children`, so the Perl render dies inside `Mojo::Template::process`. Go\'s own failure mode has NOT been read — `go` is not reachable from the local test process (the conformance case prints "go command not found" and skips), so this entry is declared from the CI failure on #2787 alone, not from a local reproduction. Whoever graduates this should read Go\'s actual output first rather than assume it shares Mojo\'s mechanism. Same alias family as `aliased-destructured-prop` (`{ n: count }`), whose Go half graduated in #2525 — worth checking whether the reserved `children` slot bypasses that fix or never had it. `children-passthrough-renamed` asserts the CORRECT (Hono-generated) output, so deleting this entry is the graduation.',
-  'aliased-loop-source':
-    'A `.map()` loop whose source is a local const alias of a signal getter (`const items__alias = items`) fails template execution on real Go (`can\'t evaluate field Items__alias in type main.AliasedLoopSourceProps`) — the zero-arg-call-to-field lowering routes `items__alias()` to a `.Items__alias` struct field that was never seeded, since seeding only knows about `items`, the real signal name; the alias hop is never resolved. This is the SSR-side twin of #2778 (fixed for the CSR client-JS template in the same PR that added this fixture) — that fix only touches client-JS emission, not Go\'s field-routing/seeding. Tracked at https://github.com/piconic-ai/barefootjs/issues/2813; graduate by resolving the alias hop at field-routing time using the same `resolveAliasOrigin`/`resolveGetterAliases` mechanism #2778 introduced, rather than a third alias-hop walker.',
-}
+export const renderDivergences: RenderDivergences = {}