@barefootjs/go-template 0.35.0 → 0.35.1

package/dist/vite.js

@@ -8,7 +8,7 @@ import { devModuleUrl, loadManifest, resolveDevOrigin, resolveScriptAssets, toPo
 import ts25 from "typescript";
 
 // ../jsx/src/analyzer.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 
 // ../jsx/src/expression-parser.ts
 import ts from "typescript";
@@ -2462,14 +2462,17 @@ function freshCounters() {
 }
 
 // ../jsx/src/analyzer-context.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // ../jsx/src/strip-types.ts
 import ts8 from "typescript";
 
+// ../jsx/src/reactivity-checker.ts
+import ts9 from "typescript";
+
 // ../jsx/src/analyzer-context.ts
-var _typePrinter = ts9.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-var _blankTypeSourceFile = ts9.createSourceFile("__bf_types__.ts", "", ts9.ScriptTarget.Latest);
+var _typePrinter = ts10.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+var _blankTypeSourceFile = ts10.createSourceFile("__bf_types__.ts", "", ts10.ScriptTarget.Latest);
 
 // ../jsx/src/errors.ts
 var ErrorCodes = {
@@ -2702,46 +2705,46 @@ function extractFreeIdentifiersFromNode(node) {
   const ids = new Set;
   const boundNames = new Set;
   function addBindingNames(name, out) {
-    if (ts10.isIdentifier(name))
+    if (ts11.isIdentifier(name))
       out.push(name.text);
-    else if (ts10.isObjectBindingPattern(name))
+    else if (ts11.isObjectBindingPattern(name))
       name.elements.forEach((e) => addBindingNames(e.name, out));
-    else if (ts10.isArrayBindingPattern(name))
+    else if (ts11.isArrayBindingPattern(name))
       name.elements.forEach((e) => {
-        if (!ts10.isOmittedExpression(e))
+        if (!ts11.isOmittedExpression(e))
           addBindingNames(e.name, out);
       });
   }
   function visit(n) {
-    if (ts10.isTypeNode(n))
+    if (ts11.isTypeNode(n))
       return;
-    if (ts10.isIdentifier(n)) {
+    if (ts11.isIdentifier(n)) {
       const parent = n.parent;
-      if (parent && ts10.isPropertyAccessExpression(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts10.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && ts10.isParameter(parent) && parent.name === n)
+      if (parent && ts11.isParameter(parent) && parent.name === n)
         return;
-      if (parent && ts10.isVariableDeclaration(parent) && parent.name === n)
+      if (parent && ts11.isVariableDeclaration(parent) && parent.name === n)
         return;
       if (boundNames.has(n.text))
         return;
       ids.add(n.text);
       return;
     }
-    if (ts10.isArrowFunction(n)) {
+    if (ts11.isArrowFunction(n)) {
       const params = [];
       for (const p of n.parameters)
         addBindingNames(p.name, params);
       for (const name of params)
         boundNames.add(name);
-      ts10.forEachChild(n, visit);
+      ts11.forEachChild(n, visit);
       for (const name of params)
         boundNames.delete(name);
       return;
     }
-    ts10.forEachChild(n, visit);
+    ts11.forEachChild(n, visit);
   }
   visit(node);
   return ids;
@@ -2815,7 +2818,7 @@ function preambleAnalysisTemplateText(p) {
 }
 
 // ../jsx/src/module-exports.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function formatParamWithType(p) {
   const rest = p.isRest ? "..." : "";
   const optional = p.optional ? "?" : "";
@@ -2850,21 +2853,21 @@ function findAssignedNames(bodyText, candidates) {
   const assigned = new Set;
   if (candidates.size === 0)
     return assigned;
-  const sf = ts11.createSourceFile("bf-assignment-scan.tsx", bodyText, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
+  const sf = ts12.createSourceFile("bf-assignment-scan.tsx", bodyText, ts12.ScriptTarget.Latest, false, ts12.ScriptKind.TSX);
   const record = (target) => {
-    if (ts11.isIdentifier(target) && candidates.has(target.text)) {
+    if (ts12.isIdentifier(target) && candidates.has(target.text)) {
       assigned.add(target.text);
     }
   };
   const visit = (node) => {
-    if (ts11.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts12.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
       record(node.left);
-    } else if ((ts11.isPrefixUnaryExpression(node) || ts11.isPostfixUnaryExpression(node)) && (node.operator === ts11.SyntaxKind.PlusPlusToken || node.operator === ts11.SyntaxKind.MinusMinusToken)) {
+    } else if ((ts12.isPrefixUnaryExpression(node) || ts12.isPostfixUnaryExpression(node)) && (node.operator === ts12.SyntaxKind.PlusPlusToken || node.operator === ts12.SyntaxKind.MinusMinusToken)) {
       record(node.operand);
     }
-    ts11.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   };
-  ts11.forEachChild(sf, visit);
+  ts12.forEachChild(sf, visit);
   return assigned;
 }
 function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
@@ -2887,12 +2890,9 @@ function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNam
   return reachable;
 }
 function isAssignmentOperator(kind) {
-  return kind >= ts11.SyntaxKind.FirstAssignment && kind <= ts11.SyntaxKind.LastAssignment;
+  return kind >= ts12.SyntaxKind.FirstAssignment && kind <= ts12.SyntaxKind.LastAssignment;
 }
 
-// ../jsx/src/reactivity-checker.ts
-import ts12 from "typescript";
-
 // ../jsx/src/free-refs.ts
 import ts13 from "typescript";
 var _bindingMapCache = new WeakMap;
@@ -6183,21 +6183,38 @@ function lowerUrlGuard(ctx, g) {
   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} ""`;
 }
 function lowerTernary(ctx, test, consequent, alternate) {
   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)})`;
 }
-function lowerTernaryOperand(ctx, n) {
+function lowerTemplateLiteralValue(ctx, parts) {
+  const terms = [];
+  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]);
+}
+function lowerValueOperand(ctx, n) {
   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));
 }
 function lowerTernaryTest(ctx, test) {
-  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 === "!" || test.kind === "literal" && test.literalType === "boolean";
   return isBoolShape ? go : `(bf_truthy ${go})`;
 }
@@ -6258,18 +6275,16 @@ function renderLoweringNode(ctx, node) {
   const helper = goHelperName(node.helper);
   if (!helper)
     return null;
-  const lowerExpr = (n) => ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n);
-  const lowerArg = (n) => n.kind === "conditional" ? lowerTernary(ctx, n.test, n.consequent, n.alternate) : wrapIfMultiToken(lowerExpr(n));
   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(" ");
   }
-  const parts = [wrapIfMultiToken(lowerExpr(node.base))];
+  const parts = [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(" ")}`;
 }
@@ -10640,11 +10655,17 @@ ${goFields.join(`
     return `${obj}.${goFieldNameForKey(property)}`;
   }
   indexAccess(object, index, emit) {
-    return `bf_get ${wrapIfMultiToken(emit(object))} ${wrapIfMultiToken(emit(index))}`;
+    return `bf_get ${wrapIfMultiToken(this.emitOperand(object, emit))} ${wrapIfMultiToken(this.emitOperand(index, emit))}`;
+  }
+  emitOperand(n, emit) {
+    if (n.kind === "template-literal") {
+      return wrapIfMultiToken(lowerTemplateLiteralValue(this.emitCtx, n.parts));
+    }
+    return emit(n);
   }
   binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
+    const l = this.emitOperand(left, emit);
+    const r = this.emitOperand(right, emit);
     const wl = wrapIfMultiToken(l);
     const wr = wrapIfMultiToken(r);
     switch (op) {
@@ -10690,7 +10711,7 @@ ${goFields.join(`
     return this.state.stringValueNames.has(name);
   }
   unary(op, argument, emit) {
-    const arg = emit(argument);
+    const arg = this.emitOperand(argument, emit);
     if (op === "!")
       return `not ${wrapIfMultiToken(arg)}`;
     if (op === "-")
@@ -10698,8 +10719,8 @@ ${goFields.join(`
     return arg;
   }
   logical(op, left, right, emit) {
-    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}`;
     if (op === "??" && this.nillablePropNameOf(left) !== null) {
@@ -10864,7 +10885,8 @@ ${goFields.join(`
     }
     return this.pushCallbackBF101(method, true);
   }
-  arrayMethod(method, object, args, emit) {
+  arrayMethod(method, object, args, rawEmit) {
+    const emit = (e) => this.emitOperand(e, rawEmit);
     switch (method) {
       case "join": {
         const obj = emit(object);
@@ -11454,11 +11476,9 @@ ${goFields.join(`
         }
         continue;
       }
-      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);
-      }
-      if (!singlePartTemplateLiteral && this.isTemplateFragment(go, exprOut.parsed?.kind)) {
+      if (exprOut.parsed?.kind === "template-literal" || exprOut.parsed?.kind === "conditional") {
+        go = lowerValueOperand(this.emitCtx, exprOut.parsed);
+      } else if (this.isTemplateFragment(go, exprOut.parsed?.kind)) {
         this.state.errors.push({
           code: "BF101",
           severity: "error",
@@ -11761,7 +11781,7 @@ ${goFields.join(`
         return plain(lowerTernary(this.emitCtx, expr.test, expr.consequent, expr.alternate));
       }
       case "template-literal":
-        return plain(this.renderParsedExpr(expr));
+        return plain(lowerTemplateLiteralValue(this.emitCtx, expr.parts));
       case "arrow":
         return plain("[ARROW-FN]");
       case "regex":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.35.0",
+  "version": "0.35.1",
   "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.35.0"
+    "@barefootjs/shared": "0.35.1"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -67,9 +67,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/client": "0.35.0",
-    "@barefootjs/jsx": "0.35.0",
-    "@barefootjs/vite": "0.35.0",
+    "@barefootjs/client": "0.35.1",
+    "@barefootjs/jsx": "0.35.1",
+    "@barefootjs/vite": "0.35.1",
     "vite": "^6.0.0"
   }
 }

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

@@ -376,6 +376,161 @@ describe('GoTemplateAdapter - bf_ternary value-position lowering (#2335)', () =>
   test('emits no {{if}} action fragment for a value-position ternary', () => {
     expect(render("flag ? 'a' : 'b'")).not.toContain('{{if')
   })
+
+  // #2863: a multi-part template literal (mixed literal text and MULTIPLE
+  // interpolations) as a ternary BRANCH used to lower through the TEXT-
+  // position `templateLiteral()` path (`{{.Start}}-{{.End}}`), nesting raw
+  // `{{`/`}}` delimiters inside `bf_ternary`'s own argument list — a
+  // `html/template` parse error ("unexpected \"{\" in operand") at Go
+  // application startup, even though `bf build` itself succeeded. It must
+  // instead fold to one pipeline value, chained through the same
+  // `bf_concat_str` runtime helper JS string-concat `+` already uses (#2168).
+  test('a multi-part template-literal branch folds to a bf_concat_str chain, not a raw fragment (#2863)', () => {
+    expect(render('end ? `${start}-${end}` : start')).toBe(
+      '{{(bf_ternary (bf_truthy .End) (bf_concat_str (bf_concat_str .Start "-") .End) .Start)}}',
+    )
+  })
+
+  test('a template-literal branch never leaks a raw {{ or }} into the surrounding action (#2863)', () => {
+    const out = render('end ? `${start}-${end}` : start')
+    const inner = out.slice(2, -2) // strip the outer {{ }} the whole expression is wrapped in
+    expect(inner).not.toContain('{{')
+    expect(inner).not.toContain('}}')
+  })
+
+  test('a single-part template-literal branch reduces to the bare value, no bf_concat_str wrap (#2863)', () => {
+    expect(render('end ? `${start}` : end')).toBe('{{(bf_ternary (bf_truthy .End) .Start .End)}}')
+  })
+
+  test('static text in a template-literal branch is an escaped Go string literal (#2863)', () => {
+    expect(render('end ? `say "hi" ${start}` : end')).toBe(
+      '{{(bf_ternary (bf_truthy .End) (bf_concat_str "say \\"hi\\" " .Start) .End)}}',
+    )
+  })
+
+  test('a nested ternary inside a template-literal branch still lowers to bf_ternary, not {{if}} (#2863)', () => {
+    const out = render('end ? `x ${flag ? \'a\' : \'b\'}` : end')
+    expect(out).toBe(
+      '{{(bf_ternary (bf_truthy .End) (bf_concat_str "x " (bf_ternary (bf_truthy .Flag) "a" "b")) .End)}}',
+    )
+    expect(out).not.toContain('{{if')
+  })
+})
+
+// #2863 follow-up: the same value-position leak existed for a `+`/`||`
+// operand and a registered-lowering (`queryHref`) argument, not just a
+// `bf_ternary` branch — every such position funnels through the Go
+// adapter's shared `lowerValueOperand` door (`expr/url-builder.ts`).
+describe('GoTemplateAdapter - value-position template literal in other operand positions (#2863)', () => {
+  const adapter = new GoTemplateAdapter()
+  const render = (expr: string) => adapter.renderExpression({ expr } as IRExpression)
+
+  test('a template-literal operand of `+` folds through bf_concat_str, not a raw fragment', () => {
+    const out = render('`${a}-${b}` + a')
+    const inner = out.slice(2, -2)
+    expect(inner).not.toContain('{{')
+    expect(inner).toContain('bf_concat_str')
+  })
+
+  test('a template-literal operand of `||` folds through bf_concat_str, not a raw fragment', () => {
+    const out = render('a || `${a}-${b}`')
+    const inner = out.slice(2, -2)
+    expect(inner).not.toContain('{{')
+  })
+
+  // The issue's exact repro shape: a local, expression-bodied helper arrow
+  // (`eventTime`) whose body is the ternary+template-literal, called from a
+  // `.map()` row. A ternary written DIRECTLY inline in JSX instead compiles
+  // to a text-position `IRConditional` (`{{if}}…{{else}}…{{end}}`, correct
+  // and unaffected by this bug) — the buggy VALUE-position path is only
+  // reached once `inlineLocalHelperCall` substitutes the helper's body into
+  // the `eventTime(event)` call site and the Go adapter re-parses the
+  // result as a plain expression, not a JSX conditional.
+  test('the issue #2863 repro: a local-helper ternary+template-literal inlined in a .map() row lowers to valid Go source', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Event = { id: string; time: string; endTime: string }
+type Dashboard = { events: Event[] }
+const empty: Dashboard = { events: [] }
+export function Schedule() {
+  const [data] = createSignal<Dashboard>(empty)
+  const eventTime = (event: Event) =>
+    event.endTime ? \`\${event.time}–\${event.endTime}\` : event.time
+  return (
+    <ol>
+      {data().events.map((event) => (
+        <li key={event.id}><time>{eventTime(event)}</time></li>
+      ))}
+    </ol>
+  )
+}
+`)
+    expect(template).toContain(
+      '(bf_ternary (bf_truthy .EndTime) (bf_concat_str (bf_concat_str .Time "–") .EndTime) .Time)',
+    )
+    expect(template).not.toContain('{{.Time}}–{{.EndTime}}')
+  })
+})
+
+// #2863 (pullfrog review on #2877): three more argument/operand positions
+// that reach a template literal without going through `lowerValueOperand`/
+// `emitOperand` — verified to reproduce the identical `unexpected "{" in
+// operand` class of bug before this fix, via a standalone script driving
+// `html/template.Parse` on the pre-fix output.
+describe('GoTemplateAdapter - value-position template literal in condition/array-method/index positions (#2863 follow-up)', () => {
+  // `renderConditionExpr`'s own `binary`/`unary`/`logical` recursion is a
+  // SEPARATE walker from the generic `emit()` dispatcher (it threads a
+  // `preamble` string `emitOperand` doesn't track) — reached whenever a
+  // ternary/`&&`/`||`/`!` TEST is a comparison against (or otherwise
+  // contains) a template literal, since `lowerTernaryTest`/`lowerUrlGuard`'s
+  // "bool-shape" branch routes through `convertConditionToGo` instead of
+  // `lowerValueOperand`.
+  test('a ternary TEST comparing to a template literal folds through bf_concat_str inside the {{if}}', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function T() {
+  const [x] = createSignal('x')
+  const [y] = createSignal('y')
+  const [z] = createSignal('z')
+  return <span>{(x() === \`\${y()}-\${z()}\`) ? 'a' : 'b'}</span>
+}
+`)
+    expect(template).toContain('{{if eq .X (bf_concat_str (bf_concat_str .Y "-") .Z)}}')
+  })
+
+  // `arrayMethod()`'s per-method cases (`join`, `includes`, `indexOf`, …) all
+  // lower their receiver/args via the dispatcher's plain `emit`, not
+  // `emitOperand` — no ternary or helper-inlining needed to reach the bug.
+  test('Array.join with a template-literal separator folds through bf_concat_str', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function T() {
+  const [items] = createSignal<string[]>([])
+  const [y] = createSignal('y')
+  const [z] = createSignal('z')
+  return <span>{items().join(\`\${y()}-\${z()}\`)}</span>
+}
+`)
+    expect(template).toContain('bf_join (.Items) (bf_concat_str (bf_concat_str .Y "-") .Z)')
+  })
+
+  // `indexAccess()` lowers both the object and the index via plain `emit`.
+  test('a computed index-access with a template-literal key folds through bf_concat_str', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function T() {
+  const [obj] = createSignal<Record<string, string>>({})
+  const [y] = createSignal('y')
+  const [z] = createSignal('z')
+  return <span>{obj()[\`\${y()}-\${z()}\`]}</span>
+}
+`)
+    expect(template).toContain('bf_get .Obj (bf_concat_str (bf_concat_str .Y "-") .Z)')
+  })
 })
 
 // #2335 item 2 (correctness): a ternary used as a boolean CONDITION used to
@@ -4701,11 +4856,14 @@ export function CompositeRowChildComponent(props: { items: Item[] }) {
   })
 
   // A multi-part template literal (mixed literal text and interpolation,
-  // `` `#${row.id} ${row.label}` ``) has no single-pipeline-value reduction
-  // the way a single-part ternary does — refuse it loudly (BF101) instead
-  // of silently emitting the stale constructor-only value (the #2445 bug
-  // this whole fix exists to close).
-  test('a multi-part template-literal per-row prop is refused with BF101, not silently stale', () => {
+  // `` `#${row.id} ${row.label}` ``) folds through the shared value-operand
+  // door (#2863) — a left-folded `bf_concat_str` chain — instead of being
+  // refused (BF101) the way it used to be here (this call site had no
+  // reduction for the multi-part case before #2863, only a single-part
+  // unwrap). It must still NOT silently emit the stale constructor-only
+  // value (the #2445 bug this whole fix exists to close) — it now emits the
+  // correct live per-row value instead.
+  test('a multi-part template-literal per-row prop folds through bf_concat_str, not silently stale (#2445, #2863)', () => {
     const result = compileJSX(`
 'use client'
 import { createSignal } from '@barefootjs/client'
@@ -4726,9 +4884,11 @@ export function CompositeRowChildComponent(props: { items: Item[] }) {
   )
 }
 `.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
-    expect((result.errors ?? []).some(e => e.code === 'BF101')).toBe(true)
+    expect(result.errors ?? []).toEqual([])
     const template = result.files.find(f => f.type === 'markedTemplate')!.content
-    expect(template).not.toContain('bf_with_props')
+    expect(template).toContain(
+      '{{template "Badge" (bf_with_props $.BadgeSlot0 "Text" (bf_concat_str (bf_concat_str (bf_concat_str "#" .ID) " ") .Label))}}',
+    )
   })
 
   // A prop whose expression `convertExpressionToGo` itself refuses (an

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(' ')}`
 }