@barefootjs/go-template 0.34.0 → 0.35.1

package/src/adapter/expr/url-builder.ts

@@ -10,13 +10,14 @@
 import {
   type LoweringNode,
   type ParsedExpr,
+  type TemplatePart,
   parseExpression,
   stringifyParsedExpr,
   isValidHelperId,
 } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
-import { wrapIfMultiToken } from '../lib/go-emit.ts'
+import { escapeGoString, wrapIfMultiToken } from '../lib/go-emit.ts'
 
 /**
  * Logical helper id → Go template helper name. `bf_<helper>` is a formula,
@@ -61,7 +62,7 @@ function lowerUrlGuard(ctx: GoEmitContext, g: ParsedExpr): string {
   if (isBoolShape) {
     return ctx.convertConditionToGo(stringifyParsedExpr(g), g).condition
   }
-  const valueGo = wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(g), undefined, g))
+  const valueGo = lowerValueOperand(ctx, g)
   return `ne ${valueGo} ""`
 }
 
@@ -91,21 +92,63 @@ export function lowerTernary(
   alternate: ParsedExpr,
 ): string {
   const t = lowerTernaryTest(ctx, test)
-  return `(bf_ternary ${t} ${lowerTernaryOperand(ctx, consequent)} ${lowerTernaryOperand(ctx, alternate)})`
+  return `(bf_ternary ${t} ${lowerValueOperand(ctx, consequent)} ${lowerValueOperand(ctx, alternate)})`
 }
 
 /**
- * A ternary branch in value position: a nested ternary recurses to another
- * `bf_ternary`; anything else lowers to its Go value (parenthesised when
- * multi-token so it stays one argument). String branches become quoted,
- * html/template-escaped values — not the bare unquoted text the old `{{if}}`
- * fragment path emitted — which is exactly right for the value positions this
- * is reached for.
+ * Lower a template literal to ONE Go pipeline VALUE (#2863): a left fold of
+ * `bf_concat_str` over the parts — static text as an escaped Go string
+ * literal, each interpolation as its own value operand. The TEXT-position
+ * form (`GoTemplateAdapter.templateLiteral()`: literal text interleaved with
+ * `{{…}}` actions) is only legal where the result is spliced directly into
+ * markup; inside another action's argument list (a `bf_ternary` branch, a
+ * helper-call arg, a `bf_query` guard value, …) Go rejects nested `{{`/`}}`
+ * delimiters ("unexpected \"{\" in operand"). This is the Go twin of the
+ * concatenation every other DSL adapter already emits for the same nested
+ * shape (e.g. Jinja/Twig `bf.string(a) ~ '–' ~ bf.string(b)`) — Go was the
+ * lone outlier because `text/template` has no expression-level string
+ * concatenation operator of its own, only this runtime helper (already used
+ * by `binary()`'s string-typed `+`, #2168).
+ *
+ * A single-part literal (`` `${x}` `` alone) reduces to that one value with
+ * no `bf_concat_str` wrapper — mirrors the sibling single-part unwrap at the
+ * child-prop call site. An all-static literal (already reduced to a plain
+ * `literal` ParsedExpr by the parser in practice, but handled here too)
+ * folds to one escaped string.
  */
-function lowerTernaryOperand(ctx: GoEmitContext, n: ParsedExpr): string {
+export function lowerTemplateLiteralValue(ctx: GoEmitContext, parts: readonly TemplatePart[]): string {
+  const terms: string[] = []
+  for (const part of parts) {
+    if (part.type === 'string') {
+      if (part.value !== '') terms.push(`"${escapeGoString(part.value)}"`)
+    } else {
+      terms.push(lowerValueOperand(ctx, part.expr))
+    }
+  }
+  if (terms.length === 0) return '""'
+  return terms.slice(1).reduce((acc, t) => `(bf_concat_str ${acc} ${t})`, terms[0])
+}
+
+/**
+ * The single door for "this ParsedExpr sits in Go pipeline ARGUMENT
+ * position" — a `bf_ternary` branch, a ternary/guard test's value form, a
+ * helper-call arg, a `bf_query` base/guard/value. A nested ternary recurses
+ * to another `bf_ternary`; a template literal folds through
+ * `lowerTemplateLiteralValue` (#2863) rather than the generic expression
+ * path, which would otherwise return the TEXT-position mixed
+ * literal-text-plus-`{{…}}`-actions form; anything else lowers to its Go
+ * value (parenthesised when multi-token so it stays one argument). String
+ * branches become quoted, html/template-escaped values — not the bare
+ * unquoted text the old `{{if}}` fragment path emitted — which is exactly
+ * right for the value positions this is reached for.
+ */
+export function lowerValueOperand(ctx: GoEmitContext, n: ParsedExpr): string {
   if (n.kind === 'conditional') {
     return lowerTernary(ctx, n.test, n.consequent, n.alternate)
   }
+  if (n.kind === 'template-literal') {
+    return wrapIfMultiToken(lowerTemplateLiteralValue(ctx, n.parts))
+  }
   return wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n))
 }
 
@@ -120,7 +163,7 @@ function lowerTernaryOperand(ctx: GoEmitContext, n: ParsedExpr): string {
  * counterpart of `lowerUrlGuard`'s string-only `ne <value> ""`.
  */
 function lowerTernaryTest(ctx: GoEmitContext, test: ParsedExpr): string {
-  const go = wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(test), undefined, test))
+  const go = lowerValueOperand(ctx, test)
   const isBoolShape =
     (test.kind === 'binary' && BOOL_COMPARISON_OPS.has(test.op)) ||
     (test.kind === 'unary' && test.op === '!') ||
@@ -280,22 +323,14 @@ function ternaryHasQueryBranch(
 function renderLoweringNode(ctx: GoEmitContext, node: LoweringNode): string | null {
   const helper = goHelperName(node.helper)
   if (!helper) return null
-  const lowerExpr = (n: ParsedExpr): string =>
-    ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n)
-  // A `conditional` in ARGUMENT position lowers to the pipeline-position
-  // `(bf_ternary …)` form via the shared `lowerTernary` (#2335) — the same
-  // form the ParsedExpr `conditional()` emitter and the condition-expression
-  // emitter produce. Routing it here explicitly (rather than leaning on the
-  // generic `lowerExpr`, whose `conditional()` dispatch now reaches the very
-  // same helper) keeps the arg lowering self-contained and its intent local;
-  // `lowerTernary` itself right-folds a nested chain (the #2324 union stage's
-  // locale→pattern table) into `(bf_ternary <cond> <a> (bf_ternary …))`.
-  const lowerArg = (n: ParsedExpr): string =>
-    n.kind === 'conditional'
-      ? lowerTernary(ctx, n.test, n.consequent, n.alternate)
-      : wrapIfMultiToken(lowerExpr(n))
+  // Every argument here is Go pipeline ARGUMENT position — a `conditional`
+  // lowers to `(bf_ternary …)`, a `template-literal` folds through
+  // `bf_concat_str` (#2863) rather than leaking the TEXT-position
+  // `{{…}}`-actions form into this call's argument list, anything else takes
+  // the generic value path. `lowerValueOperand` is the one shared door every
+  // such position in this file now goes through.
   if (node.kind === 'helper-call') {
-    const args = node.args.map(a => lowerArg(a))
+    const args = node.args.map(a => lowerValueOperand(ctx, a))
     return [helper, ...args].join(' ')
   }
   // guard-list — `queryHref`-shaped. Inclusion mirrors the client exactly, where
@@ -304,12 +339,12 @@ function renderLoweringNode(ctx: GoEmitContext, node: LoweringNode): string | nu
   //   - plain `key: v` (guard null)        → `(true) "key" v`
   //   - conditional `key: cond ? a : <omit>` → `(<cond>) "key" a`, where the
   //     non-empty check is done by bf_query, not folded into the guard.
-  const parts: string[] = [wrapIfMultiToken(lowerExpr(node.base))]
+  const parts: string[] = [lowerValueOperand(ctx, node.base)]
   for (const t of node.triples) {
     const includeGo = t.guard === null ? 'true' : lowerUrlGuard(ctx, t.guard)
     parts.push(`(${includeGo})`)
     parts.push(JSON.stringify(t.key))
-    parts.push(wrapIfMultiToken(lowerExpr(t.value)))
+    parts.push(lowerValueOperand(ctx, t.value))
   }
   return `${helper} ${parts.join(' ')}`
 }

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 { lowerRegisteredAttrCall, lowerRegisteredCall, lowerRegisteredCallNode, lowerTernary } from "./expr/url-builder.ts"
+import { lowerRegisteredAttrCall, lowerRegisteredCall, lowerRegisteredCallNode, lowerTemplateLiteralValue, lowerTernary, lowerValueOperand } 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)}`
   }
 
   /**
@@ -5152,12 +5180,35 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // arithmetic index lowers correctly. A multi-token operand
     // (`bf_add $i 1`) must be parenthesised or Go parses it as extra
     // `bf_get` arguments.
-    return `bf_get ${wrapIfMultiToken(emit(object))} ${wrapIfMultiToken(emit(index))}`
+    return `bf_get ${wrapIfMultiToken(this.emitOperand(object, emit))} ${wrapIfMultiToken(this.emitOperand(index, emit))}`
+  }
+
+  /**
+   * A `binary`/`logical`/`unary` operand that feeds a prefix-call Go form
+   * (`bf_mul a b`, `and a b`, `not a`, …), which cannot host a raw `{{…}}`
+   * action the way the generic `emit` dispatcher's `templateLiteral()` would
+   * produce for a template-literal operand (#2863). ONLY a template literal
+   * is special-cased here, folded through `bf_concat_str` (the same door
+   * `lowerValueOperand` uses for a ternary branch / helper-call arg /
+   * query-guard value); every other kind still goes through the caller's own
+   * `emit` closure unchanged. This matters: routing every operand through
+   * `lowerValueOperand`'s `convertExpressionToGo` fallback (rather than only
+   * the one broken kind) would ALSO pick up `convertExpressionToGo`'s own
+   * string-keyed fast paths — e.g. inlining a bare identifier bound to a
+   * local literal const — which `emit`'s AST-walk `identifier()` dispatch
+   * does not do, a real behavioral divergence for that shape (caught by the
+   * #2236 loop-param-shadowing regression pins).
+   */
+  private emitOperand(n: ParsedExpr, emit: (e: ParsedExpr) => string): string {
+    if (n.kind === 'template-literal') {
+      return wrapIfMultiToken(lowerTemplateLiteralValue(this.emitCtx, n.parts))
+    }
+    return emit(n)
   }
 
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
-    const l = emit(left)
-    const r = emit(right)
+    const l = this.emitOperand(left, emit)
+    const r = this.emitOperand(right, emit)
     // Every Go form below is a prefix function call (`bf_mul a b`, `gt a b`,
     // `eq a b`), so a COMPOUND operand must be parenthesised or the template
     // parser folds its tokens into the call's argument list — e.g.
@@ -5240,8 +5291,12 @@ 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}`
+    const arg = this.emitOperand(argument, emit)
+    // `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
   }
@@ -5259,8 +5314,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // `and`/`or`. This makes `searchParams().get(k) ?? d` lower to
     // `or (.SearchParams.Get "sort") "none"` instead of the broken
     // `or .SearchParams.Get "sort" "none"`.
-    const wrapLeft = wrapIfMultiToken(emit(left))
-    const wrapRight = wrapIfMultiToken(emit(right))
+    const wrapLeft = wrapIfMultiToken(this.emitOperand(left, emit))
+    const wrapRight = wrapIfMultiToken(this.emitOperand(right, emit))
     if (op === '&&') return `and ${wrapLeft} ${wrapRight}`
     // `??` on a nillable prop needs true JS nullish semantics (#2248): Go's
     // `or` is truthiness-based, so `{{or .Label "Default"}}` falls back on a
@@ -5568,8 +5623,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     method: ArrayMethod,
     object: ParsedExpr,
     args: ParsedExpr[],
-    emit: (e: ParsedExpr) => string,
+    rawEmit: (e: ParsedExpr) => string,
   ): string {
+    // Every `emit(...)` call below lowers an ARGUMENT position (the
+    // receiver or a `.method(...)` arg) that feeds a prefix-call Go form
+    // (`bf_join (...) ...`, `bf_replace ... ... ...`, …) — shadow the
+    // dispatcher's own `emit` with `emitOperand` (#2863) so a
+    // template-literal receiver/argument (e.g. `items.join(\`${a}-${b}\`)`)
+    // folds through `bf_concat_str` instead of leaking the TEXT-position
+    // `templateLiteral()` form into another action's argument list.
+    const emit = (e: ParsedExpr): string => this.emitOperand(e, rawEmit)
     // `bf_join` etc. are registered in the runtime FuncMap. The exhaustive
     // switch on `method` mirrors the IR-level discriminator — adding a new
     // `ArrayMethod` variant becomes a TS compile error until every adapter
@@ -6650,34 +6713,23 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         }
         continue
       }
-      // A ternary / single-interpolation template literal with STRING-typed
-      // branches (`row.on ? "yes" : "no"`, `${row.x}` alone) parses to a
-      // ParsedExpr `template-literal` whose sole part is non-string —
-      // `templateLiteral()` wraps that one dynamic part's already-bare
-      // pipeline value (e.g. `(bf_ternary ...)`, #2335) in a bare `{{...}}`
-      // shell meant for TEXT-position embedding. A multi-part template
-      // literal (mixed literal text and interpolation) has no such reduction
-      // and stays refused below. Unwrap the single-part case back to the
-      // bare pipeline value this call site (a function ARGUMENT position,
-      // not a text position) needs.
-      const singlePartTemplateLiteral =
-        exprOut.parsed?.kind === 'template-literal' &&
-        exprOut.parsed.parts.length === 1 &&
-        exprOut.parsed.parts[0].type !== 'string' &&
-        go.startsWith('{{') &&
-        go.endsWith('}}')
-      if (singlePartTemplateLiteral) {
-        go = go.slice(2, -2)
-      }
-      // Skip the fragment re-check for the just-unwrapped single-part case —
-      // `kind` is still (accurately) `template-literal`, which would
-      // otherwise re-trip `isTemplateFragment`'s `kind === 'template-literal'`
-      // branch on the ALREADY-unwrapped bare value.
-      if (!singlePartTemplateLiteral && this.isTemplateFragment(go, exprOut.parsed?.kind)) {
-        // A genuine multi-part `{{if}}...{{end}}`-shaped fragment can't be a
-        // bare pipeline argument — refuse loudly rather than silently
-        // dropping the prop (the #2445 bug was exactly a silent drop one
-        // level up).
+      // A ternary or template literal (`row.on ? "yes" : "no"`, `` `#${row.id}
+      // ${row.label}` ``) in this ARGUMENT position (a `bf_with_props`/
+      // `bf_reprops` value, not a text position) must lower through the
+      // shared value-operand door (#2863/#2335) — `convertExpressionToGo`'s
+      // generic path returns `templateLiteral()`'s TEXT-position mixed
+      // literal-text-plus-`{{…}}`-actions form for a template literal, which
+      // is not a legal bare pipeline argument (multi-part) or needed an
+      // ad-hoc single-part unwrap here (this replaces both). Recompute from
+      // the already-validated `exprOut.parsed` tree rather than trying to
+      // unwrap or refuse the text-position string after the fact.
+      if (exprOut.parsed?.kind === 'template-literal' || exprOut.parsed?.kind === 'conditional') {
+        go = lowerValueOperand(this.emitCtx, exprOut.parsed)
+      } else if (this.isTemplateFragment(go, exprOut.parsed?.kind)) {
+        // A genuine `{{if}}...{{end}}`-shaped (or other `{{`-leading action)
+        // fragment can't be a bare pipeline argument — refuse loudly rather
+        // than silently dropping the prop (the #2445 bug was exactly a
+        // silent drop one level up).
         this.state.errors.push({
           code: 'BF101',
           severity: 'error',
@@ -7083,7 +7135,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
       }
@@ -7128,7 +7184,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
 
       case 'template-literal':
-        return plain(this.renderParsedExpr(expr))
+        // #2863 follow-up: fold to one Go value (`bf_concat_str` chain) via
+        // the same door as the `conditional` case just above, instead of
+        // `renderParsedExpr`'s TEXT-position `templateLiteral()` form —
+        // which would leak raw `{{…}}` into THIS condition-expression's own
+        // pipeline position (e.g. `(a === \`${x}-${y}\`) ? … : …`).
+        return plain(lowerTemplateLiteralValue(this.emitCtx, expr.parts))
 
       case 'arrow':
         // A standalone arrow has no Go condition form (callbacks reach the
@@ -7696,7 +7757,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 ''
   }

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/conformance-pins.ts

@@ -52,13 +52,16 @@ export const conformancePins: ConformancePins = {
   'filter-nested-find-predicate': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2320' }],
   'date-method-uncatalogued': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2356' }],
   'rich-prop-client-read': [{ code: 'BF049', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2648' }],
-  // #2667: a ternary/array LITERALLY WRAPPING JSX at a non-children prop
+  // A ternary or array literal LITERALLY WRAPPING JSX at a non-children prop
   // position (e.g. `header={cond ? <a/> : <b/>}`) is refused ahead of
   // `adapter.generate()` in the shared jsx-to-ir.ts phase, so it is pinned
   // identically on every adapter (including Hono) — same reasoning as
-  // `rich-prop-client-read` above.
-  'jsx-element-prop-ternary': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
-  'jsx-element-prop-array': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
+  // `rich-prop-client-read` above. This is the permanent, intended behavior
+  // (formerly tracked as #2667, closed): the issue's own acceptance criteria
+  // treated a loud refusal as fully resolving the silent-divergence bug, so
+  // no open issue tracks further work here.
+  'jsx-element-prop-ternary': [{ code: 'BF021', severity: 'error' }],
+  'jsx-element-prop-array': [{ code: 'BF021', severity: 'error' }],
   // `jsx-element-prop-fragment-conditional` (#2703) is NOT pinned here — it
   // renders correctly since `queueDynamicPropDefine` (go-template-adapter.ts)
   // extended the reserved `children` slot's `bf_with_children`/`bf_tmpl`
@@ -88,11 +91,14 @@ export const conformancePins: ConformancePins = {
     severity: 'error',
     issue: 'https://github.com/piconic-ai/barefootjs/issues/2700',
   }],
-  // #2771: a reactive primitive invoked through a namespace import
+  // A reactive primitive invoked through a namespace import
   // (`import * as bf from '@barefootjs/client'`, `bf.createSignal(...)`)
   // that the analyzer's checker-less fast path cannot recognize refuses
   // loudly (BF013) instead of silently dropping the declaration — fired
   // in the shared analyzer pass ahead of any adapter's `adapter.generate()`,
-  // so all nine adapters (including Hono) pin this identically.
-  'namespace-import-primitive': [{ code: 'BF013', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2771' }],
+  // so all nine adapters (including Hono) pin this identically. A compile
+  // that supplies a shared `ts.Program` (e.g. via `@barefootjs/vite`)
+  // resolves the primitive normally and never reaches this refusal (formerly
+  // tracked as #2771, closed) — no open issue tracks further work.
+  'namespace-import-primitive': [{ code: 'BF013', severity: 'error' }],
 }

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 = {}