@barefootjs/go-template 0.34.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";
@@ -2250,7 +2250,33 @@ function propsDestructureBinding(p) {
   const binding = callerKey === localName ? localName : `${isIdentifierName(callerKey) ? callerKey : JSON.stringify(callerKey)}: ${localName}`;
   return p.defaultValue ? `${binding} = ${p.defaultValue}` : binding;
 }
+function resolveBodyDestructuredPropAliases(localConstants, propsObjectName) {
+  const aliases = new Map;
+  if (propsObjectName === null)
+    return aliases;
+  for (const c of localConstants) {
+    if (c.isModule)
+      continue;
+    const m = c.parsed;
+    if (m?.kind === "member" && !m.computed && m.object.kind === "identifier" && m.object.name === propsObjectName) {
+      aliases.set(c.name, m.property);
+    }
+  }
+  return aliases;
+}
 var EMPTY_SET = new Set;
+function resolveAliasOrigin(constantValues, name, terminal) {
+  const visited = new Set;
+  let current = name.trim();
+  while (current !== undefined && !visited.has(current)) {
+    const hit = terminal(current);
+    if (hit !== null)
+      return hit;
+    visited.add(current);
+    current = constantValues.get(current)?.trim();
+  }
+  return null;
+}
 
 // ../jsx/src/ir-to-client-js/csr-substitute.ts
 function extractFreeIdentifiersFromText(text) {
@@ -2263,6 +2289,35 @@ function extractFreeIdentifiersFromText(text) {
   const expr = ts5.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return extractFreeIdentifiersFromNode(expr);
 }
+function resolveGetterAliases(localConstants, isGetter) {
+  const constantValues = new Map;
+  for (const c of localConstants) {
+    if (c.isModule)
+      continue;
+    constantValues.set(c.name, c.value);
+  }
+  const aliases = new Map;
+  for (const c of localConstants) {
+    if (c.isModule || isGetter(c.name))
+      continue;
+    const origin = resolveAliasOrigin(constantValues, c.name, (current) => isGetter(current) ? current : null);
+    if (origin !== null && origin !== c.name)
+      aliases.set(c.name, origin);
+  }
+  return aliases;
+}
+function collectAliasableGetterNames(signals, memos) {
+  const getterNames = new Set;
+  for (const sig of signals) {
+    if (sig.getter && !sig.isModule && !sig.envReader)
+      getterNames.add(sig.getter);
+  }
+  for (const memo of memos) {
+    if (!memo.isModule)
+      getterNames.add(memo.name);
+  }
+  return getterNames;
+}
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
 import ts6 from "typescript";
@@ -2344,6 +2399,12 @@ class BindingScope {
   }
 }
 
+// ../jsx/src/ir-to-client-js/safe-html.ts
+function safeHtml(expr) {
+  return expr;
+}
+var EMPTY_MARKUP = safeHtml("''");
+
 // ../jsx/src/ir-to-client-js/html-template.ts
 var VOID_ELEMENTS = new Set([
   "area",
@@ -2401,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 = {
@@ -2630,6 +2694,7 @@ var CLIENT_EXPORTS = new Set([
   "isSSRPortal",
   "findSiblingSlot",
   "cleanupPortalPlaceholder",
+  "trackPosition",
   "createSearchParams",
   "queryHref",
   "formatDate",
@@ -2640,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;
@@ -2690,7 +2755,8 @@ var BROWSER_ONLY_CLIENT_APIS = new Set([
   "createPortal",
   "isSSRPortal",
   "findSiblingSlot",
-  "cleanupPortalPlaceholder"
+  "cleanupPortalPlaceholder",
+  "trackPosition"
 ]);
 var REACTIVE_PRIMITIVES = new Set([
   "createSignal",
@@ -2752,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 ? "?" : "";
@@ -2787,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) {
@@ -2824,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;
@@ -5568,6 +5631,8 @@ class CompileState {
   restPropsName = null;
   moduleStringConsts = new Map;
   localConstants = [];
+  getterAliases = new Map;
+  propDestructureAliases = new Map;
   staticLoopSourceBoundNames = new Set;
   localHelperNames = new Set;
   currentMemos = [];
@@ -6118,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})`;
 }
@@ -6193,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(" ")}`;
 }
@@ -8195,6 +8275,11 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.objectTypedPropNames = new Set((ir.metadata.propsParams ?? []).filter((p) => p.type.kind === "object").map((p) => p.name));
     this.state.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
     this.state.localConstants = ir.metadata.localConstants ?? [];
+    {
+      const getterNames = collectAliasableGetterNames(ir.metadata.signals ?? [], ir.metadata.memos ?? []);
+      this.state.getterAliases = resolveGetterAliases(ir.metadata.localConstants ?? [], (n) => getterNames.has(n));
+    }
+    this.state.propDestructureAliases = resolveBodyDestructuredPropAliases(ir.metadata.localConstants ?? [], ir.metadata.propsObjectName);
     this.state.staticLoopSourceBoundNames = collectLoopBoundNames(ir);
     this.bakedStaticChildLoopCache = new Map;
     this.state.localHelperNames = new Set(this.state.localConstants.filter((c) => !c.isModule && c.containsArrow).map((c) => c.name));
@@ -10431,9 +10516,10 @@ ${goFields.join(`
     return hit !== null && hit.depth > 0 && hit.binding.source === "item";
   }
   rootFieldRef(name) {
-    this.state.templateReadRootFields.add(name);
+    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)}`;
   }
   searchParamsFieldRef(name) {
     return this.state.searchParamsLocals.has(name) ? this.rootFieldRef("searchParams") : null;
@@ -10569,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) {
@@ -10619,16 +10711,16 @@ ${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 ${arg}`;
+      return `not ${wrapIfMultiToken(arg)}`;
     if (op === "-")
       return `bf_neg ${arg}`;
     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) {
@@ -10793,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);
@@ -11383,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",
@@ -11672,7 +11763,7 @@ ${goFields.join(`
       case "unary": {
         const arg = this.renderConditionExpr(expr.argument);
         if (expr.op === "!")
-          return { preamble: arg.preamble, expr: `not ${arg.expr}` };
+          return { preamble: arg.preamble, expr: `not ${wrapIfMultiToken(arg.expr)}` };
         if (expr.op === "-")
           return { preamble: arg.preamble, expr: `bf_neg ${arg.expr}` };
         return arg;
@@ -11690,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":
@@ -11917,7 +12008,7 @@ ${goFields.join(`
     if (loop.bodyIsMultiRoot)
       return `{{bfComment "loop-i"}}`;
     if (loop.bodyIsItemConditional && loop.key) {
-      return `{{bfComment (printf "loop-i:%v" ${this.convertExpressionToGo(loop.key)})}}`;
+      return `{{bfComment (printf "loop-i:%v" (bfEscapeCommentKey ${this.convertExpressionToGo(loop.key)}))}}`;
     }
     return "";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.34.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.34.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.34.0",
-    "@barefootjs/jsx": "0.34.0",
-    "@barefootjs/vite": "0.34.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