@barefootjs/go-template 0.35.0 → 0.35.2

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

@@ -130,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,
@@ -262,8 +262,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     extractCollisionDerivation: (parsed) => this.extractCollisionDerivation(parsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
-    resolveModuleNumericConst: (name) => this.resolveModuleNumericConst(name),
-    resolveModuleBooleanConst: (name) => this.resolveModuleBooleanConst(name),
+    resolveModuleConstAsGo: (name, target) => this.resolveModuleConstAsGo(name, target),
   }
 
   /** Diagnostics from the current compile (backed by `CompileState`); `generate()` also merges these into `ir.errors`. */
@@ -4726,11 +4725,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
     const inlined = this.resolveModuleStringConst(name)
     if (inlined !== null) return inlined
-    // Module numeric const (e.g. `const TRACK = 8` used in a width expression):
-    // inline the literal value rather than emit `{{.TRACK}}` against a Props
-    // field that never exists. Mirrors the string-const inlining above.
-    const inlinedNum = this.resolveModuleNumericConst(name)
-    if (inlinedNum !== null) return inlinedNum
+    // Module scalar const (e.g. `const TRACK = 8` used in a width expression,
+    // or `const OPEN = true`): inline the literal value rather than emit
+    // `{{.TRACK}}` against a Props field that never exists. Mirrors the
+    // string-const inlining above.
+    const inlinedScalar = this.resolveModuleConstAsGo(name, { kind: 'template-action' })
+    if (inlinedScalar !== null) return inlinedScalar
     if (this.isCurrentLoopItem(name)) return '.'
     // An *outer* loop's value variable (we're in a nested loop) is in scope as
     // the Go range variable `$name` declared by that loop's `{{range … := …}}`;
@@ -4866,19 +4866,41 @@ 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 {
-    // #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
+    const resolved = this.resolveRootFieldAlias(name)
     this.state.templateReadRootFields.add(resolved)
     const prefix = this.inLoop ? '$.' : '.'
     return `${prefix}${capitalizeFieldName(resolved)}`
   }
 
+  /**
+   * #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, so a caller that needs to
+   * build its own prefixed field reference (e.g. `renderFilterExprNode`,
+   * which must hardcode `$.` regardless of `rootFieldRef`'s
+   * `this.inLoop`-conditional prefix — #2857) still lands on the field that
+   * entity itself seeds (`.Items`, `.Children`) instead of a never-populated
+   * field under the local alias (`.Items__alias`, `.Kids`). `rootFieldRef`
+   * itself is built on top of this so there is exactly one resolution.
+   */
+  private resolveRootFieldAlias(name: string): string {
+    return this.state.getterAliases.get(name) ?? this.state.propDestructureAliases.get(name) ?? name
+  }
+
+  /**
+   * Root-scope field reference from INSIDE a `.filter()`/`.find()` predicate
+   * (#2857, #2879). Same registration + alias resolution as `rootFieldRef`,
+   * but the `$.` prefix is unconditional: a filter predicate's `{{if}}`
+   * always sits inside its loop's own `{{range}}` (`renderLoop` restores
+   * `this.inLoop` before rendering it), so a bare `.Field` would resolve
+   * against the current row's type instead of root.
+   */
+  private filterRootFieldRef(name: string): string {
+    this.rootFieldRef(name)
+    return `$.${capitalizeFieldName(this.resolveRootFieldAlias(name))}`
+  }
+
   /**
    * When `name` is a local binding of the `searchParams()` env signal, resolve
    * it to the canonical `.SearchParams` field — not `.<Capitalized name>` — so
@@ -4926,13 +4948,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   /**
-   * The single module-const lookup shared by `resolveModuleNumericConst`
-   * and `resolveModuleBooleanConst` — they differ only in which literal
-   * SHAPE they accept from the same "plain module-level const" search, not
-   * in how that search is performed. A second inline lookup per resolver
-   * would grow `binding-scope-ratchet.test.ts`'s shrink-only floor for this
-   * file (already at 5) for a shape variance the callers can express
-   * themselves instead.
+   * The single module-const lookup shared by `resolveModuleConstAsGo` —
+   * kept as its own method (rather than inlined) so a second `.find(` isn't
+   * added elsewhere, growing `binding-scope-ratchet.test.ts`'s shrink-only
+   * floor for this file (already at 5).
    */
   private findModuleConst(name: string): ConstantInfo | undefined {
     return this.state.localConstants.find(
@@ -4941,40 +4960,50 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   /**
-   * Inline a module-level numeric const (`const TRACK = 8`) as its literal
-   * value. Only a plain numeric initializer qualifies — anything computed or
-   * non-numeric falls through to the normal field/ident resolution. Scoped to
-   * module consts (like the string variant) and guarded against loop vars so a
-   * range variable that shadows a const name still wins.
-   */
-  private resolveModuleNumericConst(name: string): string | null {
-    if (this.isCurrentLoopItem(name)) return null
-    if (this.loopVarRefCount.has(name)) return null
-    if (this.isOuterLoopParam(name)) return null
-    const c = this.findModuleConst(name)
-    if (!c || c.value === undefined) return null
-    // `value` is reconstructed from source text, so a valid TS literal may carry
-    // numeric separators (`100_000`). Strip them between digits, then accept a
-    // plain decimal / float; Go template numeric literals don't allow `_`.
-    const v = c.value.trim().replace(/(?<=\d)_(?=\d)/g, '')
-    return /^-?\d+(\.\d+)?$/.test(v) ? v : null
-  }
-
-  /**
-   * Inline a module-level boolean const (`const OPEN = true`) as its Go
-   * literal (`true`/`false`). Only a plain `true`/`false` initializer
-   * qualifies (#2815) — mirrors `resolveModuleNumericConst`'s shape, sharing
-   * its lookup rather than adding a second `.find(` (see
-   * `findModuleConst`'s docstring).
+   * Resolve a bare identifier naming a plain module-level const (`const
+   * TRACK = 8`, `const OPEN = true`, `const INITIAL: Row[] = [...]`, #2794 /
+   * #2815 / #2862) to its value's Go literal — dispatched STRUCTURALLY off
+   * `ConstantInfo.parsed`, through the same `parsedLiteralToGo` door an
+   * inline `createSignal([...])`/`createSignal({...})` seed already takes,
+   * rather than a separate per-type text-matching resolver for each literal
+   * shape (the numeric/boolean resolvers this replaces, and the array/
+   * object-literal gap #2862 tracked, were exactly that repeated pattern).
+   * `resolveModuleStringConst` stays separate: its fixed-point text
+   * resolution also covers a COMPOSED template-literal const (`` `${A}-${B}`
+   * ``) that has no single structural literal to bake.
+   *
+   * `target` names the emission position, which constrains what can resolve
+   * there:
+   *   - `go-source` (the `New<Component>Props` constructor) may bake a
+   *     composite (array/object) literal against `bakeType` — falling back
+   *     to the const's OWN declared type when the consumer's type is
+   *     `unknown` (the analyzer's inference is text-shaped and never chases
+   *     a bare `createSignal(INITIAL)` seed to its declaration).
+   *   - `template-action` (a bare `{{...}}` splice, e.g. a className
+   *     expression) has no valid Go template spelling for a composite
+   *     literal, so only a scalar (or unary-minus number) resolves there —
+   *     the same restriction the numeric/boolean resolvers already had.
+   *
+   * Scoped to module consts and guarded against loop vars so a range
+   * variable that shadows a const name still wins (same guards the
+   * resolvers this replaces already had).
    */
-  private resolveModuleBooleanConst(name: string): string | null {
+  private resolveModuleConstAsGo(
+    name: string,
+    target: { kind: 'template-action' } | { kind: 'go-source'; bakeType: TypeInfo },
+  ): string | null {
     if (this.isCurrentLoopItem(name)) return null
     if (this.loopVarRefCount.has(name)) return null
     if (this.isOuterLoopParam(name)) return null
     const c = this.findModuleConst(name)
-    if (!c || c.value === undefined) return null
-    const v = c.value.trim()
-    return v === 'true' || v === 'false' ? v : null
+    if (!c?.parsed) return null
+    if (target.kind === 'template-action') {
+      return c.parsed.kind === 'literal' || c.parsed.kind === 'unary'
+        ? parsedLiteralToGo(this.emitCtx, c.parsed)
+        : null
+    }
+    const bakeType = target.bakeType.kind !== 'unknown' ? target.bakeType : (c.type ?? undefined)
+    return parsedLiteralToGo(this.emitCtx, c.parsed, bakeType)
   }
 
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
@@ -5180,12 +5209,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.
@@ -5268,7 +5320,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   unary(op: string, argument: ParsedExpr, emit: (e: ParsedExpr) => string): string {
-    const arg = emit(argument)
+    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
@@ -5291,8 +5343,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
@@ -5600,8 +5652,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
@@ -6181,12 +6241,28 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           // prefix because a filter predicate must always escape back to
           // root regardless of loop nesting; call it only for its
           // registration side effect and keep the prefix here (pullfrog
-          // review, PR #2818).
-          this.rootFieldRef(signal)
-          return `$.${capitalizeFieldName(signal)}`
+          // review, PR #2818). The field name itself DOES go through
+          // `resolveRootFieldAlias` (#2857) so a getter-alias local
+          // (`const items__alias = items`) still emits the field the
+          // signal itself seeds instead of a phantom `.Items__alias`.
+          return this.filterRootFieldRef(signal)
         }
-        this.rootFieldRef(expr.name)
-        return `.${capitalizeFieldName(expr.name)}`
+        // Any other identifier reaching here is ALSO a root-scope
+        // reference (a memo, a plain derived const, or — #2857 — a
+        // bare-props-form destructured/renamed prop) rather than the
+        // loop's own param, so it needs the same unconditional `$.`
+        // escape as the signal branch above, for the same reason: a
+        // `.filter().map()` JSX loop's `{{if}}` gate (built from
+        // `loop.filterPredicate` a few hundred lines below, via
+        // `renderPredicateCondition` → this method) always sits inside
+        // that loop's own `{{range}}`, never at the template's un-rebound
+        // root, so `rootFieldRef`'s own `this.inLoop`-conditional prefix
+        // would be wrong here even without the alias bug — a bare
+        // `.Field` resolves against the CURRENT LOOP ITEM's type, not
+        // root, and `html/template` panics at execute time (`can't
+        // evaluate field ... in type ...`) the first time such a
+        // reference is exercised.
+        return this.filterRootFieldRef(expr.name)
       }
 
       case 'literal':
@@ -6203,6 +6279,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (expr.object.kind === 'identifier' && expr.object.name === param) {
           return `${paramPrefix}.${capitalizeFieldName(expr.property)}`
         }
+        // props.x on a bare-props-form component (#2879): props are
+        // flattened onto the root struct, so this is a root-scope read
+        // (`$.X`), not `.Props.X`. Mirrors `renderConditionExpr`'s own
+        // `propsObjectName` branch; `props.a.b` still reaches root through
+        // the generic recursion below.
+        if (
+          expr.object.kind === 'identifier' &&
+          this.state.propsObjectName &&
+          expr.object.name === this.state.propsObjectName
+        ) {
+          return this.filterRootFieldRef(expr.property)
+        }
         // `.length` on a higher-order filter result (e.g.
         // `x.tags.filter(t => t.active).length > 0`). Reuse
         // `renderFilterLengthExpr` so the inner filter lowers to
@@ -6231,11 +6319,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           return `${paramPrefix}.${capitalizeFieldName(expr.callee.property)}`
         }
         // Signal calls: `filter()` -> `$.Filter`. Same registration-only
-        // `rootFieldRef` call as the `identifier` case above, for the same
+        // `rootFieldRef` call — and the same `resolveRootFieldAlias` field
+        // resolution (#2857) — as the `identifier` case above, for the same
         // reason (#2700's BF101 gate; pullfrog review, PR #2818).
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
-          this.rootFieldRef(expr.callee.name)
-          return `$.${capitalizeFieldName(expr.callee.name)}`
+          return this.filterRootFieldRef(expr.callee.name)
         }
         // A nested callback method call (`other.some(r => …)`) reaching this
         // arm has no Go template form in filter context — the fallthrough
@@ -6271,30 +6359,50 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (this.filterExprUnsupported) return 'false'
         const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
+        // #2873 (pullfrog review, PR #2882): every case below is a prefix
+        // function call (`bf_mod a b`, `eq a b`, …), so a COMPOUND operand —
+        // itself a nested binary result like `bf_mod .N 2` — must be
+        // parenthesised or the template parser folds its tokens into the
+        // outer call's argument list (`eq bf_mod .N 2 0` hands `eq` four
+        // args, and a bare func-name argument like `bf_mod` there is called
+        // with ZERO args instead of nested: `wrong number of args for
+        // bf_mod: want 2 got 0`). Mirrors the general (non-filter) binary
+        // emitter's `wl`/`wr` wrapping (`wrapIfMultiToken`, above) — this
+        // switch had never applied it, so `-`/`*`/`/` had the identical
+        // pre-existing gap for a nested compound operand.
+        const wl = wrapIfMultiToken(left)
+        const wr = wrapIfMultiToken(right)
 
         switch (expr.op) {
           case '===':
           case '==':
-            return `eq ${left} ${right}`
+            return `eq ${wl} ${wr}`
           case '!==':
           case '!=':
-            return `ne ${left} ${right}`
+            return `ne ${wl} ${wr}`
           case '>':
-            return `gt ${left} ${right}`
+            return `gt ${wl} ${wr}`
           case '<':
-            return `lt ${left} ${right}`
+            return `lt ${wl} ${wr}`
           case '>=':
-            return `ge ${left} ${right}`
+            return `ge ${wl} ${wr}`
           case '<=':
-            return `le ${left} ${right}`
+            return `le ${wl} ${wr}`
           case '+':
-            return this._emitPlus(expr.left, expr.right, left, right)
+            return this._emitPlus(expr.left, expr.right, wl, wr)
           case '-':
-            return `bf_sub ${left} ${right}`
+            return `bf_sub ${wl} ${wr}`
           case '*':
-            return `bf_mul ${left} ${right}`
+            return `bf_mul ${wl} ${wr}`
           case '/':
-            return `bf_div ${left} ${right}`
+            return `bf_div ${wl} ${wr}`
+          case '%':
+            // #2873: mirrors the general binary emitter's `%` case (below,
+            // `bf_mod`) — this switch previously had no `%` case, so the
+            // `default` arm emitted a literal ` % ` into the template text,
+            // which `html/template` can't parse (`unexpected "%" in
+            // operand`).
+            return `bf_mod ${wl} ${wr}`
           default:
             return `${left} ${expr.op} ${right}`
         }
@@ -6540,7 +6648,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * `loopVarRefCount` — so both are still consulted. Shared by the
    * string-keyed fast paths (#2236, #2242 Copilot review) that resolve raw
    * `jsExpr` text before `identifier()`'s own guards can see it. Mirrors the
-   * checks in `resolveModuleStringConst` / `resolveModuleNumericConst`.
+   * checks in `resolveModuleStringConst` / `resolveModuleConstAsGo`.
    */
   private isLoopShadowedName(name: string): boolean {
     return this.scope.isBound(name) || this.loopVarRefCount.has(name)
@@ -6682,34 +6790,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',
@@ -7107,6 +7204,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             result = `bf_mul ${left} ${right}`; break
           case '/':
             result = `bf_div ${left} ${right}`; break
+          case '%':
+            // #2873: this switch had no `%` case even though
+            // `needsParensInGoTemplate` (above) already treats `%` as an
+            // arithmetic operator needing parens — so the `default` arm
+            // below emitted a literal ` % ` into a ternary/condition's
+            // template text, which `html/template` can't parse
+            // (`unexpected "%" in operand`). Mirrors the general binary
+            // emitter's `%` case (`bf_mod`, outside condition position).
+            result = `bf_mod ${left} ${right}`; break
           default:
             result = `${left} ${expr.op} ${right}`
         }
@@ -7164,7 +7270,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

package/src/adapter/value/value-lowering.ts

@@ -94,9 +94,10 @@ export function convertInitialValue(
     if (param) {
       return propRef(param)
     }
-    // Module-const seed (#2794): a signal seeded from a bare identifier
-    // that refers to a module-level const (`const PAYLOAD = 'x';
-    // createSignal(PAYLOAD)`) types `unknown` — the analyzer's type
+    // Module-const seed (#2794/#2815/#2862): a signal seeded from a bare
+    // identifier that refers to a module-level const (`const PAYLOAD = 'x';
+    // createSignal(PAYLOAD)`, or `const INITIAL: Row[] = [...];
+    // createSignal(INITIAL)`) types `unknown` — the analyzer's type
     // inference is text-shaped and never chases an identifier to its
     // declaration — so none of the typed branches below ever see it and
     // this used to fall through to the final `nil`. Checked AFTER the
@@ -107,10 +108,8 @@ export function convertInitialValue(
     // leaving that case on the pre-existing `nil` path unchanged.
     const inlinedStr = ctx.resolveModuleStringConst(value)
     if (inlinedStr !== null) return inlinedStr
-    const inlinedNum = ctx.resolveModuleNumericConst(value)
-    if (inlinedNum !== null) return inlinedNum
-    const inlinedBool = ctx.resolveModuleBooleanConst(value)
-    if (inlinedBool !== null) return inlinedBool
+    const inlinedConst = ctx.resolveModuleConstAsGo(value, { kind: 'go-source', bakeType: typeInfo })
+    if (inlinedConst !== null) return inlinedConst
   }
 
   const propName = ctx.extractPropNameFromInitialValue(value, preParsed)

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' }],
 }