@barefootjs/go-template 0.33.6 → 0.35.0

package/dist/vite.js

@@ -12,6 +12,41 @@ import ts10 from "typescript";
 
 // ../jsx/src/expression-parser.ts
 import ts from "typescript";
+
+// ../jsx/src/lowering-registry.ts
+var plugins = [];
+function registerLoweringPlugin(plugin) {
+  const existing = plugins.findIndex((p) => p.name === plugin.name);
+  if (existing >= 0)
+    plugins[existing] = plugin;
+  else
+    plugins.push(plugin);
+}
+function prepareLoweringMatchers(metadata) {
+  const matchers = [];
+  for (const plugin of plugins) {
+    const matcher = plugin.prepare(metadata);
+    if (matcher)
+      matchers.push(matcher);
+  }
+  return matchers;
+}
+function loweringNodeChildren(node) {
+  if (node.kind === "helper-call")
+    return [...node.args];
+  const children = [node.base];
+  for (const t of node.triples) {
+    if (t.guard)
+      children.push(t.guard);
+    children.push(t.value);
+  }
+  return children;
+}
+function isValidHelperId(helper) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(helper);
+}
+
+// ../jsx/src/expression-parser.ts
 var UNSUPPORTED_METHODS = new Set([
   "filter",
   "map",
@@ -209,7 +244,7 @@ function convertNode(node, raw) {
           }
           if (n === undefined || Number.isNaN(n)) {
             const parsedDepth = convertNode(depthNode, raw);
-            if (checkSupport(parsedDepth, "rendered").supported) {
+            if (checkSupport(parsedDepth, "rendered", []).supported) {
               depthExpr = parsedDepth;
               flatDepth = 1;
             } else {
@@ -987,13 +1022,13 @@ function getUnaryOperatorString(op) {
       return "unknown";
   }
 }
-function isSupported(expr) {
-  return checkSupport(expr, "rendered");
+function isSupported(expr, opts) {
+  return checkSupport(expr, "rendered", opts?.loweringMatchers ?? []);
 }
-function isSupportedValue(expr) {
-  return checkSupport(expr, "value");
+function isSupportedValue(expr, opts) {
+  return checkSupport(expr, "value", opts?.loweringMatchers ?? []);
 }
-function checkSupport(expr, pos) {
+function checkSupport(expr, pos, matchers) {
   switch (expr.kind) {
     case "unsupported":
       return { supported: false, reason: expr.reason };
@@ -1002,7 +1037,7 @@ function checkSupport(expr, pos) {
         return { supported: false, reason: "Unsupported syntax: ObjectLiteralExpression" };
       }
       for (const prop of expr.properties) {
-        const propSupport = checkSupport(prop.kind === "spread" ? prop.expr : prop.value, pos);
+        const propSupport = checkSupport(prop.kind === "spread" ? prop.expr : prop.value, pos, matchers);
         if (!propSupport.supported)
           return propSupport;
       }
@@ -1017,7 +1052,7 @@ function checkSupport(expr, pos) {
       return { supported: false, reason: "Standalone arrow functions / regex literals are not supported" };
     case "array-literal": {
       for (const el of expr.elements) {
-        const elSupport = checkSupport(el, pos);
+        const elSupport = checkSupport(el, pos, matchers);
         if (!elSupport.supported)
           return elSupport;
       }
@@ -1030,28 +1065,39 @@ function checkSupport(expr, pos) {
           reason: `String.prototype.${expr.method} supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */`
         };
       }
-      const objSupport = checkSupport(expr.object, pos);
+      const objSupport = checkSupport(expr.object, pos, matchers);
       if (!objSupport.supported)
         return objSupport;
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg, pos);
+        const argSupport = checkSupport(arg, pos, matchers);
         if (!argSupport.supported)
           return argSupport;
       }
       if (expr.method === "flat" && expr.depthExpr) {
-        const depthSupport = checkSupport(expr.depthExpr, pos);
+        const depthSupport = checkSupport(expr.depthExpr, pos, matchers);
         if (!depthSupport.supported)
           return depthSupport;
       }
       return { supported: true, level: "L2" };
     }
     case "call": {
+      for (const matcher of matchers) {
+        const node = matcher(expr.callee, expr.args);
+        if (!node)
+          continue;
+        for (const child of loweringNodeChildren(node)) {
+          const childSupport = checkSupport(child, pos, matchers);
+          if (!childSupport.supported)
+            return childSupport;
+        }
+        return { supported: true, level: "L2" };
+      }
       const cb = asCallbackMethodCall(expr);
       if (cb) {
-        const objSupport = checkSupport(cb.object, pos);
+        const objSupport = checkSupport(cb.object, pos, matchers);
         if (!objSupport.supported)
           return objSupport;
-        const bodySupport = checkSupport(cb.arrow.body, pos);
+        const bodySupport = checkSupport(cb.arrow.body, pos, matchers);
         if (!bodySupport.supported) {
           return {
             supported: false,
@@ -1060,13 +1106,13 @@ function checkSupport(expr, pos) {
           };
         }
         for (const rest of cb.args) {
-          const restSupport = checkSupport(rest, pos);
+          const restSupport = checkSupport(rest, pos, matchers);
           if (!restSupport.supported)
             return restSupport;
         }
         return { supported: true, level: "L5" };
       }
-      const calleeSupport = checkSupport(expr.callee, pos);
+      const calleeSupport = checkSupport(expr.callee, pos, matchers);
       if (!calleeSupport.supported) {
         return calleeSupport;
       }
@@ -1085,7 +1131,7 @@ function checkSupport(expr, pos) {
         return { supported: true, level: "L1" };
       }
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg, pos);
+        const argSupport = checkSupport(arg, pos, matchers);
         if (!argSupport.supported) {
           return argSupport;
         }
@@ -1093,7 +1139,7 @@ function checkSupport(expr, pos) {
       return { supported: true, level: "L2" };
     }
     case "member": {
-      const objSupport = checkSupport(expr.object, pos);
+      const objSupport = checkSupport(expr.object, pos, matchers);
       if (!objSupport.supported) {
         return objSupport;
       }
@@ -1103,19 +1149,19 @@ function checkSupport(expr, pos) {
       return { supported: true, level: "L2" };
     }
     case "index-access": {
-      const objSupport = checkSupport(expr.object, pos);
+      const objSupport = checkSupport(expr.object, pos, matchers);
       if (!objSupport.supported)
         return objSupport;
-      const indexSupport = checkSupport(expr.index, pos);
+      const indexSupport = checkSupport(expr.index, pos, matchers);
       if (!indexSupport.supported)
         return indexSupport;
       return { supported: true, level: "L2" };
     }
     case "binary": {
-      const leftSupport = checkSupport(expr.left, pos);
+      const leftSupport = checkSupport(expr.left, pos, matchers);
       if (!leftSupport.supported)
         return leftSupport;
-      const rightSupport = checkSupport(expr.right, pos);
+      const rightSupport = checkSupport(expr.right, pos, matchers);
       if (!rightSupport.supported)
         return rightSupport;
       if (["===", "==", "!==", "!=", ">", "<", ">=", "<="].includes(expr.op)) {
@@ -1127,7 +1173,7 @@ function checkSupport(expr, pos) {
       return { supported: false, reason: `Unknown operator: ${expr.op}` };
     }
     case "unary": {
-      const argSupport = checkSupport(expr.argument, pos);
+      const argSupport = checkSupport(expr.argument, pos, matchers);
       if (!argSupport.supported)
         return argSupport;
       if (expr.op === "!") {
@@ -1139,25 +1185,25 @@ function checkSupport(expr, pos) {
       return { supported: false, reason: `Unsupported unary operator: ${expr.op}` };
     }
     case "logical": {
-      const leftSupport = checkSupport(expr.left, pos);
+      const leftSupport = checkSupport(expr.left, pos, matchers);
       if (!leftSupport.supported)
         return leftSupport;
       if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
         return { supported: true, level: "L4" };
       }
-      const rightSupport = checkSupport(expr.right, pos);
+      const rightSupport = checkSupport(expr.right, pos, matchers);
       if (!rightSupport.supported)
         return rightSupport;
       return { supported: true, level: "L4" };
     }
     case "conditional": {
-      const testSupport = checkSupport(expr.test, pos);
+      const testSupport = checkSupport(expr.test, pos, matchers);
       if (!testSupport.supported)
         return testSupport;
-      const consSupport = checkSupport(expr.consequent, pos);
+      const consSupport = checkSupport(expr.consequent, pos, matchers);
       if (!consSupport.supported)
         return consSupport;
-      const altSupport = checkSupport(expr.alternate, pos);
+      const altSupport = checkSupport(expr.alternate, pos, matchers);
       if (!altSupport.supported)
         return altSupport;
       return { supported: true, level: "L4" };
@@ -1165,7 +1211,7 @@ function checkSupport(expr, pos) {
     case "template-literal": {
       for (const part of expr.parts) {
         if (part.type === "expression") {
-          const partSupport = checkSupport(part.expr, pos);
+          const partSupport = checkSupport(part.expr, pos, matchers);
           if (!partSupport.supported)
             return partSupport;
         }
@@ -2204,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) {
@@ -2217,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";
@@ -2298,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",
@@ -2584,6 +2691,7 @@ var CLIENT_EXPORTS = new Set([
   "isSSRPortal",
   "findSiblingSlot",
   "cleanupPortalPlaceholder",
+  "trackPosition",
   "createSearchParams",
   "queryHref",
   "formatDate",
@@ -2644,7 +2752,8 @@ var BROWSER_ONLY_CLIENT_APIS = new Set([
   "createPortal",
   "isSSRPortal",
   "findSiblingSlot",
-  "cleanupPortalPlaceholder"
+  "cleanupPortalPlaceholder",
+  "trackPosition"
 ]);
 var REACTIVE_PRIMITIVES = new Set([
   "createSignal",
@@ -3243,30 +3352,6 @@ import ts16 from "typescript";
 
 // ../jsx/src/relocate.ts
 import ts18 from "typescript";
-
-// ../jsx/src/lowering-registry.ts
-var plugins = [];
-function registerLoweringPlugin(plugin) {
-  const existing = plugins.findIndex((p) => p.name === plugin.name);
-  if (existing >= 0)
-    plugins[existing] = plugin;
-  else
-    plugins.push(plugin);
-}
-function prepareLoweringMatchers(metadata) {
-  const matchers = [];
-  for (const plugin of plugins) {
-    const matcher = plugin.prepare(metadata);
-    if (matcher)
-      matchers.push(matcher);
-  }
-  return matchers;
-}
-function isValidHelperId(helper) {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(helper);
-}
-
-// ../jsx/src/relocate.ts
 var REGISTRY_SAFE_BINDING_KINDS = new Set([
   "global",
   "module-import",
@@ -4694,6 +4779,17 @@ function emitParsedExpr(expr, emitter) {
     case "literal":
       return emitter.literal(expr.value, expr.literalType);
     case "call": {
+      if (emitter.lowering) {
+        for (const matcher of emitter.lowering.matchers) {
+          const node = matcher(expr.callee, expr.args);
+          if (!node)
+            continue;
+          const rendered = emitter.lowering.render(node, emit);
+          if (rendered !== null)
+            return rendered;
+          break;
+        }
+      }
       const cb = asCallbackMethodCall(expr);
       if (cb)
         return emitter.callbackMethod(cb.method, cb.object, cb.arrow, cb.args, emit);
@@ -5535,6 +5631,8 @@ class CompileState {
   restPropsName = null;
   moduleStringConsts = new Map;
   localConstants = [];
+  getterAliases = new Map;
+  propDestructureAliases = new Map;
   staticLoopSourceBoundNames = new Set;
   localHelperNames = new Set;
   currentMemos = [];
@@ -6103,9 +6201,22 @@ function lowerTernaryTest(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})`;
 }
+function matchRegisteredCall(ctx, callee, args) {
+  for (const matcher of ctx.state.loweringMatchers) {
+    const node = matcher(callee, args);
+    if (node)
+      return node;
+  }
+  return null;
+}
+function lowerRegisteredCallNode(ctx, callee, args) {
+  if (ctx.state.loweringMatchers.length === 0)
+    return null;
+  const node = matchRegisteredCall(ctx, callee, args);
+  return node ? renderLoweringNode(ctx, node) : null;
+}
 function lowerRegisteredCall(ctx, jsExpr, preParsed) {
-  const matchers = ctx.state.loweringMatchers;
-  if (matchers.length === 0)
+  if (ctx.state.loweringMatchers.length === 0)
     return null;
   let call = preParsed?.kind === "call" ? preParsed : undefined;
   if (!call) {
@@ -6116,15 +6227,32 @@ function lowerRegisteredCall(ctx, jsExpr, preParsed) {
       return null;
     call = parsed;
   }
-  for (const matcher of matchers) {
-    const node = matcher(call.callee, call.args);
-    if (!node)
-      continue;
-    const rendered = renderLoweringNode(ctx, node);
-    if (rendered !== null)
-      return rendered;
+  return lowerRegisteredCallNode(ctx, call.callee, call.args);
+}
+function lowerRegisteredAttrCall(ctx, attrName, parsed) {
+  if (parsed.kind === "conditional") {
+    if (!ternaryHasQueryBranch(ctx, parsed.consequent, parsed.alternate))
+      return null;
+    const rendered2 = lowerTernary(ctx, parsed.test, parsed.consequent, parsed.alternate);
+    return `{{bf_attr ${JSON.stringify(attrName)} ${rendered2}}}`;
   }
-  return null;
+  if (parsed.kind !== "call")
+    return null;
+  const node = matchRegisteredCall(ctx, parsed.callee, parsed.args);
+  if (!node || node.kind !== "guard-list" || node.helper !== "query")
+    return null;
+  const rendered = renderLoweringNode(ctx, node);
+  return rendered === null ? null : `{{bf_attr ${JSON.stringify(attrName)} (${rendered})}}`;
+}
+function isQueryGuardListCall(ctx, node) {
+  if (node.kind !== "call")
+    return false;
+  const lowered = matchRegisteredCall(ctx, node.callee, node.args);
+  return lowered?.kind === "guard-list" && lowered.helper === "query";
+}
+function ternaryHasQueryBranch(ctx, consequent, alternate) {
+  const branchHasQuery = (n) => n.kind === "conditional" ? ternaryHasQueryBranch(ctx, n.consequent, n.alternate) : isQueryGuardListCall(ctx, n);
+  return branchHasQuery(consequent) || branchHasQuery(alternate);
 }
 function renderLoweringNode(ctx, node) {
   const helper = goHelperName(node.helper);
@@ -8132,6 +8260,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));
@@ -10368,9 +10501,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;
@@ -10427,6 +10561,9 @@ ${goFields.join(`
     return String(value);
   }
   call(callee, args, emit) {
+    const lowered = lowerRegisteredCallNode(this.emitCtx, callee, args);
+    if (lowered !== null)
+      return lowered;
     if (callee.kind === "identifier" && args.length === 0) {
       return this.searchParamsFieldRef(callee.name) ?? this.rootFieldRef(callee.name);
     }
@@ -10555,7 +10692,7 @@ ${goFields.join(`
   unary(op, argument, emit) {
     const arg = emit(argument);
     if (op === "!")
-      return `not ${arg}`;
+      return `not ${wrapIfMultiToken(arg)}`;
     if (op === "-")
       return `bf_neg ${arg}`;
     return arg;
@@ -11606,7 +11743,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;
@@ -11851,7 +11988,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 "";
   }
@@ -12012,15 +12149,21 @@ ${children}`;
         const test = parsed.test;
         if (undef(parsed.alternate) && !undef(parsed.consequent)) {
           const { condition: goCond, preamble } = this.convertConditionToGo(this.isTemplateFragment(this.renderParsedExpr(test), test.kind) ? value.expr : value.expr.slice(0, value.expr.indexOf("?")).trim());
-          const valueExpr = this.renderParsedExpr(parsed.consequent);
-          const body = `${name}="{{${valueExpr}}}"`;
+          const attrConsequent = lowerRegisteredAttrCall(this.emitCtx, name, parsed.consequent);
+          const body = attrConsequent !== null ? attrConsequent : `${name}="{{${this.renderParsedExpr(parsed.consequent)}}}"`;
           return `${preamble}{{if ${goCond}}}${body}{{end}}`;
         }
+        const attrTernary = lowerRegisteredAttrCall(this.emitCtx, name, parsed);
+        if (attrTernary !== null)
+          return attrTernary;
         return `${name}="{{${this.renderParsedExpr(parsed)}}}"`;
       }
       if (parsed.kind === "template-literal") {
         return `${name}="${this.renderParsedExpr(parsed)}"`;
       }
+      const attrAction = lowerRegisteredAttrCall(this.emitCtx, name, parsed);
+      if (attrAction !== null)
+        return attrAction;
       const bareId = value.expr.trim();
       const propName = this.state.propsObjectName && bareId.startsWith(`${this.state.propsObjectName}.`) ? bareId.slice(this.state.propsObjectName.length + 1) : bareId;
       if (/^[A-Za-z_$][\w$]*$/.test(propName) && this.state.nillablePropNames.has(propName)) {

package/package.json

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

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

@@ -129,14 +129,6 @@ runAdapterConformanceTests({
     // produces no complete template.
     'jsx-element-prop-rest-bag-dynamic',
   ]),
-  skipDataPoints: new Set<string>([
-    // #2743: html/template's URL-context autoescape percent-encodes the
-    // queryHref BASE in href position (`日本語` → `%e6%97%a5…`); the JS
-    // reference only HTML-escapes. The bf_query helper itself is faithful —
-    // the divergence is Go's contextual escaper on the whole href value.
-    'query-href:gen:base:markup',
-    'query-href:gen:base:multibyte',
-  ]),
   onRenderError: (err, id) => {
     if (err instanceof GoNotAvailableError) {
       console.log(`Skipping [${id}]: ${err.message}`)

package/src/__tests__/lowering-plugin.test.ts

@@ -149,6 +149,11 @@ export function P(props: { config: object }) {
     // naming exactly — the formula generalises, it isn't a lookup table
     // limited to `query`.
     expect(template).toContain('bf_custom_serialize .Config')
+    // #2743: the whole-attribute `bf_attr` route is keyed on the neutral
+    // `guard-list` + `helper === 'query'` shape specifically — a
+    // `helper-call` node (this plugin's shape) is a different node kind and
+    // must not be routed through it.
+    expect(template).not.toContain('bf_attr')
   })
 
   test('without the plugin registered, the call falls back to the generic (unsupported) lowering', () => {
@@ -163,6 +168,39 @@ export function P(props: { config: object }) {
     expect(template).not.toContain('bf_custom_serialize')
   })
 
+  // #2842: a `helper-call` node (not the `query` guard-list) reached through
+  // the undef-alternate omission shape now routes through the fixed `call()`
+  // dispatcher — but NOT through `bf_attr` (only `query` needs the
+  // URL-context-escape bypass; a plain helper-call keeps the ordinary
+  // `name="{{…}}"` wrapper the `{{if}}` already builds around).
+  test('an undef-alternate helper-call consequent is registry-lowered without bf_attr (#2842)', () => {
+    registerLoweringPlugin(customSerializePlugin)
+    const src = `
+'use client'
+import { customSerialize } from './lib'
+export function P(props: { on: boolean; config: object }) {
+  return <div data-config={props.on ? customSerialize(props.config) : undefined}>x</div>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('{{if .On}}data-config="{{bf_custom_serialize .Config}}"{{end}}')
+    expect(template).not.toContain('bf_attr')
+  })
+
+  // Same shape, plugin NOT registered — pins that an unmatched call keeps the
+  // existing generic Go-method-call convention (no new BF10x refusal).
+  test('an undef-alternate helper-call consequent with no plugin registered keeps the generic convention', () => {
+    const src = `
+'use client'
+import { customSerialize } from './lib'
+export function P(props: { on: boolean; config: object }) {
+  return <div data-config={props.on ? customSerialize(props.config) : undefined}>x</div>
+}
+`
+    const { template } = generate(src)
+    expect(template).toContain('{{if .On}}data-config="{{.CustomSerialize .Config}}"{{end}}')
+  })
+
   test('a CONDITIONAL helper-call arg renders as pipeline-position bf_ternary, not an {{if}} action', () => {
     // The #2324 union stage lowers a union-typed locale to a ternary
     // pattern arg. Go templates have no expression-level conditional, and