@barefootjs/cli 0.18.4 → 0.18.5

package/dist/index.js

@@ -448,6 +448,9 @@ function convertNode(node, raw) {
       if (callee.property === "trim") {
         return { kind: "array-method", method: "trim", object: callee.object, args: args2 };
       }
+      if (callee.property === "trimStart" || callee.property === "trimEnd") {
+        return { kind: "array-method", method: callee.property, object: callee.object, args: args2 };
+      }
       if (callee.property === "toFixed") {
         return { kind: "array-method", method: "toFixed", object: callee.object, args: args2 };
       }
@@ -473,24 +476,25 @@ function convertNode(node, raw) {
         }
         return { kind: "array-method", method: callee.property, object: callee.object, args: args2 };
       }
-      if (callee.property === "replace") {
+      if (callee.property === "replace" || callee.property === "replaceAll") {
+        const method2 = callee.property;
         if (args2.length < 2) {
           return {
             kind: "unsupported",
             raw,
-            reason: `\`.replace(${args2.length === 0 ? "" : "pattern"})\` needs both a pattern and a replacement \u2014 JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`
+            reason: `\`.${method2}(${args2.length === 0 ? "" : "pattern"})\` needs both a pattern and a replacement \u2014 JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`
           };
         }
         const patternNode = node.arguments[0];
         if (patternNode && ts.isRegularExpressionLiteral(patternNode)) {
-          return { kind: "array-method", method: "replace", object: callee.object, args: args2 };
+          return { kind: "array-method", method: method2, object: callee.object, args: args2 };
         }
         const badArg = args2[0].kind === "unsupported" || args2[0].kind === "object-literal" ? args2[0] : args2[1].kind === "unsupported" || args2[1].kind === "object-literal" ? args2[1] : void 0;
         if (badArg) {
           const reason2 = badArg.kind === "unsupported" ? badArg.reason : "Unsupported syntax: ObjectLiteralExpression";
           return { kind: "unsupported", raw, reason: reason2 };
         }
-        return { kind: "array-method", method: "replace", object: callee.object, args: args2 };
+        return { kind: "array-method", method: method2, object: callee.object, args: args2 };
       }
       if (callee.property === "repeat") {
         return { kind: "array-method", method: "repeat", object: callee.object, args: args2 };
@@ -524,7 +528,7 @@ function convertNode(node, raw) {
   if (ts.isPropertyAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
     const property = node.name.text;
-    return { kind: "member", object, property, computed: false };
+    return { kind: "member", object, property, computed: false, optional: !!node.questionDotToken };
   }
   if (ts.isElementAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
@@ -533,10 +537,10 @@ function convertNode(node, raw) {
       return { kind: "unsupported", raw, reason: "Element access with no index expression" };
     }
     if (ts.isNumericLiteral(argNode)) {
-      return { kind: "member", object, property: argNode.text, computed: true };
+      return { kind: "member", object, property: argNode.text, computed: true, optional: !!node.questionDotToken };
     }
     if (ts.isStringLiteral(argNode)) {
-      return { kind: "member", object, property: argNode.text, computed: true };
+      return { kind: "member", object, property: argNode.text, computed: true, optional: !!node.questionDotToken };
     }
     const index = convertNode(argNode, raw);
     if (index.kind === "unsupported" || index.kind === "object-literal") return index;
@@ -1051,7 +1055,7 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
         if (entry === void 0) return e;
         let node = { kind: "identifier", name: syntheticParam };
         for (const segment of entry.path) {
-          node = { kind: "member", object: node, property: segment, computed: false };
+          node = { kind: "member", object: node, property: segment, computed: false, optional: false };
         }
         if (entry.defaultExpr) {
           return { kind: "logical", op: "??", left: node, right: entry.defaultExpr };
@@ -1066,10 +1070,11 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
             kind: "member",
             object: { kind: "identifier", name: syntheticParam },
             property: e.property,
-            computed: false
+            computed: false,
+            optional: e.optional
           };
         }
-        return { kind: "member", object: walk(e.object), property: e.property, computed: e.computed };
+        return { kind: "member", object: walk(e.object), property: e.property, computed: e.computed, optional: e.optional };
       case "index-access":
         return { kind: "index-access", object: walk(e.object), index: walk(e.index) };
       case "binary":
@@ -1192,10 +1197,10 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "array-method": {
-      if (expr.method === "replace" && expr.args[0]?.kind === "regex") {
+      if ((expr.method === "replace" || expr.method === "replaceAll") && expr.args[0]?.kind === "regex") {
         return {
           supported: false,
-          reason: "String.prototype.replace supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */"
+          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);
@@ -1548,7 +1553,7 @@ function inlineBinding(expr, name2, value2) {
       case "call":
         return { kind: "call", callee: walk(e.callee, enclosing), args: e.args.map((a) => walk(a, enclosing)) };
       case "member":
-        return { kind: "member", object: walk(e.object, enclosing), property: e.property, computed: e.computed };
+        return { kind: "member", object: walk(e.object, enclosing), property: e.property, computed: e.computed, optional: e.optional };
       case "index-access":
         return { kind: "index-access", object: walk(e.object, enclosing), index: walk(e.index, enclosing) };
       case "binary":
@@ -1795,7 +1800,7 @@ function materializeGetterCalls(expr, names) {
         alternate: rw(expr.alternate)
       };
     case "member":
-      return { kind: "member", object: rw(expr.object), property: expr.property, computed: expr.computed };
+      return { kind: "member", object: rw(expr.object), property: expr.property, computed: expr.computed, optional: expr.optional };
     case "index-access":
       return { kind: "index-access", object: rw(expr.object), index: rw(expr.index) };
     case "template-literal":
@@ -2173,18 +2178,17 @@ var init_expression_parser = __esm({
       // `startsWith` / `endsWith` are no longer here — both lower via the
       // `array-method` IR + `bf_starts_with` / `bf_ends_with` (Go) and
       // `bf->starts_with` / `bf->ends_with` (Mojo). See #1448 Tier B.
-      // `replace` is no longer here — the string-pattern form lowers via
-      // the `array-method` IR + `bf_replace` (Go) / `bf->replace` (Mojo);
-      // the regex-pattern form is refused at the parse arm below (it would
-      // need the per-adapter regex-flavour decision). `replaceAll` stays
-      // refused. See #1448 Tier B.
+      // `replace` / `replaceAll` are no longer here — the string-pattern
+      // form of each lowers via the `array-method` IR + `bf_replace` /
+      // `bf_replace_all` (Go) / `bf->replace` / `bf->replace_all` (Mojo);
+      // the regex-pattern form of EITHER is refused at the parse arm below
+      // (it would need the per-adapter regex-flavour decision).
       // `repeat` is no longer here — `String.prototype.repeat(n)` lowers via
       // the `array-method` IR + `bf_repeat` (Go) / `bf->repeat` (Mojo).
       // See #1448 Tier B.
       // `padStart` / `padEnd` are no longer here — both lower via the
       // `array-method` IR + `bf_pad_start` / `bf_pad_end` (Go) and
       // `bf->pad_start` / `bf->pad_end` (Mojo). See #1448 Tier B.
-      "replaceAll",
       "charAt",
       "charCodeAt",
       "codePointAt",
@@ -2607,12 +2611,89 @@ var init_dom_prop = __esm({
   }
 });
 
+// ../shared/src/html-entities.ts
+function decodeEntities(text) {
+  return text.replace(/&(#[xX]?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, body2) => {
+    if (body2[0] === "#") {
+      const isHex = body2[1] === "x" || body2[1] === "X";
+      const digits = body2.slice(isHex ? 2 : 1);
+      if (!isHex && !/^[0-9]+$/.test(digits)) return match;
+      const code = parseInt(digits, isHex ? 16 : 10);
+      if (!Number.isFinite(code) || code > 1114111 || code >= 55296 && code <= 57343) {
+        return match;
+      }
+      return String.fromCodePoint(code);
+    }
+    return NAMED_ENTITIES[body2] ?? match;
+  });
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var NAMED_ENTITIES;
+var init_html_entities = __esm({
+  "../shared/src/html-entities.ts"() {
+    "use strict";
+    NAMED_ENTITIES = {
+      amp: "&",
+      lt: "<",
+      gt: ">",
+      quot: '"',
+      apos: "'",
+      nbsp: "\xA0",
+      copy: "\xA9",
+      reg: "\xAE",
+      trade: "\u2122",
+      deg: "\xB0",
+      plusmn: "\xB1",
+      times: "\xD7",
+      divide: "\xF7",
+      middot: "\xB7",
+      bull: "\u2022",
+      hellip: "\u2026",
+      ndash: "\u2013",
+      mdash: "\u2014",
+      lsquo: "\u2018",
+      rsquo: "\u2019",
+      ldquo: "\u201C",
+      rdquo: "\u201D",
+      laquo: "\xAB",
+      raquo: "\xBB",
+      sect: "\xA7",
+      para: "\xB6",
+      dagger: "\u2020",
+      Dagger: "\u2021",
+      euro: "\u20AC",
+      pound: "\xA3",
+      yen: "\xA5",
+      cent: "\xA2",
+      sup1: "\xB9",
+      sup2: "\xB2",
+      sup3: "\xB3",
+      frac12: "\xBD",
+      frac14: "\xBC",
+      frac34: "\xBE",
+      larr: "\u2190",
+      uarr: "\u2191",
+      rarr: "\u2192",
+      darr: "\u2193",
+      harr: "\u2194",
+      minus: "\u2212",
+      infin: "\u221E",
+      ne: "\u2260",
+      le: "\u2264",
+      ge: "\u2265"
+    };
+  }
+});
+
 // ../shared/src/index.ts
 var init_src = __esm({
   "../shared/src/index.ts"() {
     "use strict";
     init_markers();
     init_dom_prop();
+    init_html_entities();
   }
 });
 
@@ -2663,13 +2744,20 @@ function attrValueToString(value2, opts) {
       return null;
   }
 }
+function applyObjectIterationWrap(node, arrayExpr) {
+  if (node.objectIteration === "entries") return `Object.entries(${arrayExpr})`;
+  if (node.objectIteration === "keys") return `Object.keys(${arrayExpr})`;
+  if (node.objectIteration === "values") return `Object.values(${arrayExpr})`;
+  return arrayExpr;
+}
 function buildChainedArrayExpr(elem) {
-  return buildLoopChainExpr({
+  const chained = buildLoopChainExpr({
     base: elem.array,
     sortComparator: elem.sortComparator,
     filterPredicate: elem.filterPredicate,
     chainOrder: elem.chainOrder
   });
+  return applyObjectIterationWrap(elem, chained);
 }
 function loopOffsetTerms(offset2) {
   if (!offset2) return [];
@@ -3435,6 +3523,24 @@ function applyIterationShape(node, arrayExpr, indexParam) {
       callbackParam: `(${node.param})`
     };
   }
+  if (node.objectIteration === "entries") {
+    return {
+      array: `Object.entries(${arrayExpr})`,
+      callbackParam: node.index ? `([${node.index}, ${node.param}])` : `(${node.param}${indexParam})`
+    };
+  }
+  if (node.objectIteration === "keys") {
+    return {
+      array: `Object.keys(${arrayExpr})`,
+      callbackParam: `(${node.param})`
+    };
+  }
+  if (node.objectIteration === "values") {
+    return {
+      array: `Object.values(${arrayExpr})`,
+      callbackParam: `(${node.param})`
+    };
+  }
   return { array: arrayExpr, callbackParam: `(${node.param}${indexParam})` };
 }
 function childrenPropEntry(children2, recurse) {
@@ -3490,7 +3596,7 @@ function renderTemplateAttrPart(attr, attrName, wrap, restSpreadNames) {
     case "boolean-attr":
       return attrName;
     case "literal":
-      return `${attrName}="${v.value}"`;
+      return `${attrName}="${escapeHtml(v.value)}"`;
     case "expression": {
       const valExpr = wrap(v.expr);
       return templateAttrExpr(attrName, valExpr, v.presenceOrUndefined);
@@ -3606,7 +3712,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined") return "";
       if (node.slotId) {
@@ -3709,7 +3815,7 @@ function buildLoopSkeletonTemplate(node, safe) {
         const v = a.value;
         switch (v.kind) {
           case "literal":
-            attrParts.push(`${toHTMLAttrName(a.name)}="${v.value}"`);
+            attrParts.push(`${toHTMLAttrName(a.name)}="${escapeHtml(v.value)}"`);
             break;
           case "boolean-attr":
             attrParts.push(toHTMLAttrName(a.name));
@@ -3741,7 +3847,7 @@ function buildLoopSkeletonTemplate(node, safe) {
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined") return "";
       if (!node.slotId) {
@@ -3793,7 +3899,7 @@ function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParam
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined") return "";
       if (node.slotId) {
@@ -3988,7 +4094,7 @@ function irToComponentTemplateWithOpts(node, opts) {
               return templateAttrExpr(keyName, transformExpr(tmplStr));
             }
             case "literal":
-              return `${keyName}="${v.value}"`;
+              return `${keyName}="${escapeHtml(v.value)}"`;
             default:
               return "";
           }
@@ -3998,7 +4104,7 @@ function irToComponentTemplateWithOpts(node, opts) {
           case "boolean-attr":
             return attrName;
           case "literal":
-            return `${attrName}="${v.value}"`;
+            return `${attrName}="${escapeHtml(v.value)}"`;
           case "expression":
             return templateAttrExpr(attrName, transformExpr(v.expr, v.templateExpr), v.presenceOrUndefined);
           case "template": {
@@ -4023,7 +4129,7 @@ function irToComponentTemplateWithOpts(node, opts) {
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined") return "";
       if (node.slotId) {
@@ -4294,7 +4400,7 @@ function generateCsrTemplateWithOpts(node, opts) {
           case "boolean-attr":
             return attrName;
           case "literal":
-            return `${attrName}="${v.value}"`;
+            return `${attrName}="${escapeHtml(v.value)}"`;
           case "expression":
             return templateAttrExpr(attrName, transformExpr(v.expr, v.templateExpr), v.presenceOrUndefined);
           case "template": {
@@ -4319,7 +4425,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined") return "";
       if (node.clientOnly && node.slotId) {
@@ -8138,6 +8244,7 @@ function createTransformContext(analyzer) {
     isRoot: true,
     insideComponentChildren: false,
     loopParams: /* @__PURE__ */ new Set(),
+    loopDepth: 0,
     patterns: {
       signals: analyzer.signals.map((s) => ({
         getter: s.getter,
@@ -8776,7 +8883,12 @@ function transformText(node, ctx2) {
   }
   return {
     type: "text",
-    value: text,
+    // JSX decodes character references at parse time (`&copy;` IS the
+    // text `©`), so the IR carries the DECODED value — the semantics —
+    // and each adapter re-escapes for its own emission context.
+    // Decode AFTER whitespace normalization: `&nbsp;` yields U+00A0,
+    // which `\s+` would otherwise collapse into a plain space.
+    value: decodeEntities(text),
     loc: getSourceLocation(node, ctx2.sourceFile, ctx2.filePath)
   };
 }
@@ -9339,6 +9451,16 @@ function isIteratorShapeCall(node) {
   if (name2 !== "entries" && name2 !== "keys" && name2 !== "values") return null;
   return { array: node.expression.expression, shape: name2 };
 }
+function isObjectIteratorCall(node) {
+  if (!ts11.isCallExpression(node)) return null;
+  if (!ts11.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts11.isIdentifier(node.expression.expression)) return null;
+  if (node.expression.expression.text !== "Object") return null;
+  if (node.arguments.length !== 1) return null;
+  const name2 = node.expression.name.text;
+  if (name2 !== "entries" && name2 !== "keys" && name2 !== "values") return null;
+  return { object: node.arguments[0], shape: name2 };
+}
 function extractSortComparator(callback, _method, ctx2) {
   const outerRaw = ctx2.getJS(callback);
   const unsupported = () => ({
@@ -9741,6 +9863,7 @@ function extractItemConditionalKey(cond) {
 }
 function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   const isNested = ctx2.loopParams.size > 0;
+  const depth = ctx2.loopDepth;
   const propAccess = node.expression;
   const mapSource = propAccess.expression;
   let array = "";
@@ -9753,6 +9876,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   let templateMapPreamble;
   let typedMapPreamble;
   let iterationShape;
+  let objectIteration;
   const setArray = (node2) => {
     array = ctx2.getJS(node2);
     templateArray = rewriteBarePropRefs2(array, node2, ctx2);
@@ -9767,6 +9891,12 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
     } else if (iteratorInfo.shape === "keys") {
       iterationShape = "keys";
     }
+  } else {
+    const objectIteratorInfo = isObjectIteratorCall(mapSource);
+    if (objectIteratorInfo) {
+      chainSource = objectIteratorInfo.object;
+      objectIteration = objectIteratorInfo.shape;
+    }
   }
   const filterInfo = isFilterCall(chainSource);
   const sortInfo = isSortCall(chainSource);
@@ -9888,7 +10018,8 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
       if (firstParam.type) {
         paramType = firstParam.type.getText(ctx2.sourceFile);
       }
-      if (iterationShape === "entries" && ts11.isArrayBindingPattern(firstParam.name)) {
+      const isEntriesShape = iterationShape === "entries" || objectIteration === "entries";
+      if (isEntriesShape && ts11.isArrayBindingPattern(firstParam.name)) {
         const elements2 = firstParam.name.elements.filter(
           (el) => !ts11.isOmittedExpression(el)
         );
@@ -9922,7 +10053,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         }
       }
     }
-    if (callback.parameters.length > 1 && iterationShape !== "entries") {
+    if (callback.parameters.length > 1 && iterationShape !== "entries" && objectIteration !== "entries") {
       const secondParam = callback.parameters[1];
       index = secondParam.name.getText(ctx2.sourceFile);
       if (secondParam.type) {
@@ -9935,6 +10066,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
       ctx2.loopParams.add(param);
     }
     if (index) ctx2.loopParams.add(index);
+    ctx2.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
       if (!ts11.isBinaryExpression(expr)) return;
       const op = expr.operatorToken.kind;
@@ -10025,6 +10157,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
       ctx2.loopParams.delete(param);
     }
     if (index) ctx2.loopParams.delete(index);
+    ctx2.loopDepth--;
   }
   if (children2.length === 0 && !flatMapCallback) {
     return null;
@@ -10053,7 +10186,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   const callsReactive = exprCallsReactiveGetters(arrayExpr, ctx2);
   const hasCalls = exprHasFunctionCalls(arrayExpr);
   const isDirectPropArray = method2 !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx2);
-  const isStaticArray = !isSignalOrMemoArray(array, ctx2) && !isDirectPropArray && !hasCalls;
+  const isStaticArray = !isSignalOrMemoArray(array, ctx2) && !isDirectPropArray && !hasCalls && !objectIteration;
   const nestedComponents = collectNestedComponents(children2).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -10087,6 +10220,8 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
     sortComparator,
     chainOrder,
     iterationShape,
+    objectIteration,
+    depth,
     clientOnly: isClientOnly || void 0,
     mapPreamble,
     templateMapPreamble,
@@ -10326,7 +10461,7 @@ function getAttributeValue(attr, ctx2) {
     return AttrValueOf.booleanAttr();
   }
   if (ts11.isStringLiteral(attr.initializer)) {
-    return AttrValueOf.literal(attr.initializer.text);
+    return AttrValueOf.literal(decodeEntities(attr.initializer.text));
   }
   if (ts11.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     let expr = attr.initializer.expression;
@@ -11615,6 +11750,7 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
           bodyIsMultiRoot: n.bodyIsMultiRoot,
           bodyIsItemConditional: n.bodyIsItemConditional,
           iterationShape: n.iterationShape,
+          objectIteration: n.objectIteration,
           containerSlotId: scope.parentSlotId,
           template,
           mapPreamble: n.mapPreamble,
@@ -11828,6 +11964,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
         bodyIsMultiRoot: l.bodyIsMultiRoot,
         bodyIsItemConditional: l.bodyIsItemConditional,
         iterationShape: l.iterationShape,
+        objectIteration: l.objectIteration,
         template,
         staticItemTemplate,
         skeletonTemplate,
@@ -12025,6 +12162,7 @@ function collectBranchLoops(node, ctx2, siblingOffsets) {
         bodyIsMultiRoot: n.bodyIsMultiRoot,
         bodyIsItemConditional: n.bodyIsItemConditional,
         iterationShape: n.iterationShape,
+        objectIteration: n.objectIteration,
         template: childTemplate,
         containerSlotId: containerSlot,
         mapPreamble: n.mapPreamble ?? null,
@@ -15631,6 +15769,7 @@ function buildDynamicLoopDelegationPlan(elem, profileComponentName) {
       param: elem.param,
       paramBindings: elem.paramBindings,
       key: elem.key,
+      index: elem.index,
       mapPreamble: elem.mapPreamble ?? null
     })
   };
@@ -15647,6 +15786,7 @@ function buildBranchLoopDelegationPlan(loop, cv, profileComponentName) {
       param: loop.param,
       paramBindings: loop.paramBindings,
       key: loop.key,
+      index: loop.index,
       mapPreamble: loop.mapPreamble ?? null
     })
   };
@@ -15665,7 +15805,8 @@ function buildStaticArrayDelegationPlan(elem, profileComponentName) {
       arrayExpr: buildChainedArrayExpr(elem),
       param: elem.param,
       mapPreamble: elem.mapPreamble ?? null,
-      offset: elem.offset ?? null
+      offset: elem.offset ?? null,
+      indexParam: elem.index ?? null
     }
   };
 }
@@ -15680,7 +15821,8 @@ function buildKeyedOrIndexLookup(args2) {
       paramBindings: args2.paramBindings,
       keyWithItem,
       mapPreamble: args2.mapPreamble,
-      hasBindings
+      hasBindings,
+      indexParam: args2.index
     };
   }
   return {
@@ -15688,7 +15830,8 @@ function buildKeyedOrIndexLookup(args2) {
     arrayExpr: args2.array,
     param: args2.param,
     mapPreamble: args2.mapPreamble,
-    hasBindings
+    hasBindings,
+    indexParam: args2.index
   };
 }
 var init_build_event_delegation = __esm({
@@ -16825,6 +16968,11 @@ function withTurn(call, componentName, childSlotId, eventName) {
   const id2 = JSON.stringify(`${componentName}#handler:${childSlotId}:${eventName}`);
   return `beginTurn(${id2}); try { ${call} } finally { endTurn() }`;
 }
+function indexBindingLine(handler, indexParam, indexExpr) {
+  if (!indexParam || indexParam === indexExpr) return null;
+  if (!extractFreeIdentifiersFromText(handler).has(indexParam)) return null;
+  return `const ${indexParam} = ${indexExpr}`;
+}
 function stringifyEventDelegation(lines, plan) {
   const { containerVar, events, itemLookup, profileComponentName } = plan;
   const eventsByName = /* @__PURE__ */ new Map();
@@ -16869,8 +17017,9 @@ function stringifyEventDelegation(lines, plan) {
   }
 }
 function emitKeyedLookup(ls, ev, handlerCall, lookup) {
-  const { arrayExpr, param, keyWithItem, mapPreamble, hasBindings } = lookup;
+  const { arrayExpr, param, keyWithItem, mapPreamble, hasBindings, indexParam } = lookup;
   if (ev.nestedLoops.length === 0) {
+    const idxLine2 = indexBindingLine(ev.handler, indexParam, `${arrayExpr}.findIndex(item => String(${keyWithItem}) === key)`);
     ls.push(`      const li = ${varSlotId(ev.childSlotId)}El.closest('[${BF_KEY}]')`);
     ls.push(`      if (li) {`);
     ls.push(`        const key = li.getAttribute('${BF_KEY}')`);
@@ -16879,12 +17028,14 @@ function emitKeyedLookup(ls, ev, handlerCall, lookup) {
       ls.push(`        if (__bfLoopItem) {`);
       ls.push(`          const ${param} = __bfLoopItem`);
       if (mapPreamble) ls.push(`          ${mapPreamble}`);
+      if (idxLine2) ls.push(`          ${idxLine2}`);
       ls.push(`          ${handlerCall}`);
       ls.push(`        }`);
     } else {
       ls.push(`        const ${param} = ${arrayExpr}.find(item => String(${keyWithItem}) === key)`);
       if (mapPreamble) ls.push(`        ${mapPreamble}`);
-      ls.push(`        if (${param}) ${handlerCall}`);
+      if (idxLine2) ls.push(`        if (${param}) { ${idxLine2}; ${handlerCall} }`);
+      else ls.push(`        if (${param}) ${handlerCall}`);
     }
     ls.push(`      }`);
     return;
@@ -16912,10 +17063,13 @@ function emitKeyedLookup(ls, ev, handlerCall, lookup) {
   const outerGuard = hasBindings ? "__bfLoopItem" : param;
   const allParams = [outerGuard, ...ev.nestedLoops.map((n) => n.param)];
   if (mapPreamble) ls.push(`      ${mapPreamble}`);
-  ls.push(`      if (${allParams.join(" && ")}) ${handlerCall}`);
+  const idxLine = indexBindingLine(ev.handler, indexParam, `${arrayExpr}.findIndex(item => String(${keyWithItem}) === outerKey)`);
+  if (idxLine) ls.push(`      if (${allParams.join(" && ")}) { ${idxLine}; ${handlerCall} }`);
+  else ls.push(`      if (${allParams.join(" && ")}) ${handlerCall}`);
 }
 function emitDynamicIndexLookup(ls, ev, handlerCall, lookup) {
-  const { arrayExpr, param, mapPreamble, hasBindings } = lookup;
+  const { arrayExpr, param, mapPreamble, hasBindings, indexParam } = lookup;
+  const idxLine = indexBindingLine(ev.handler, indexParam, "idx");
   ls.push(`      const li = ${varSlotId(ev.childSlotId)}El.closest('li, [bf-i]')`);
   ls.push(`      if (li && li.parentElement) {`);
   ls.push(`        const idx = Array.from(li.parentElement.children).indexOf(li)`);
@@ -16924,17 +17078,20 @@ function emitDynamicIndexLookup(ls, ev, handlerCall, lookup) {
     ls.push(`        if (__bfLoopItem) {`);
     ls.push(`          const ${param} = __bfLoopItem`);
     if (mapPreamble) ls.push(`          ${mapPreamble}`);
+    if (idxLine) ls.push(`          ${idxLine}`);
     ls.push(`          ${handlerCall}`);
     ls.push(`        }`);
   } else {
     ls.push(`        const ${param} = ${arrayExpr}[idx]`);
     if (mapPreamble) ls.push(`        ${mapPreamble}`);
-    ls.push(`        if (${param}) ${handlerCall}`);
+    if (idxLine) ls.push(`        if (${param}) { ${idxLine}; ${handlerCall} }`);
+    else ls.push(`        if (${param}) ${handlerCall}`);
   }
   ls.push(`      }`);
 }
 function emitStaticIndexLookup(ls, ev, handlerCall, lookup, containerVar) {
-  const { arrayExpr, param, mapPreamble, offset: offset2 } = lookup;
+  const { arrayExpr, param, mapPreamble, offset: offset2, indexParam } = lookup;
+  const idxLine = indexBindingLine(ev.handler, indexParam, "__idx");
   ls.push(`      let __el = ${varSlotId(ev.childSlotId)}El`);
   ls.push(`      while (__el.parentElement && __el.parentElement !== ${containerVar}) __el = __el.parentElement`);
   ls.push(`      if (__el.parentElement === ${containerVar}) {`);
@@ -16942,7 +17099,8 @@ function emitStaticIndexLookup(ls, ev, handlerCall, lookup, containerVar) {
   ls.push(`        const __idx = Array.from(${containerVar}.children).indexOf(__el)${idxOffset}`);
   ls.push(`        const ${param} = ${arrayExpr}[__idx]`);
   if (mapPreamble) ls.push(`        ${mapPreamble}`);
-  ls.push(`        if (${param}) ${handlerCall}`);
+  if (idxLine) ls.push(`        if (${param}) { ${idxLine}; ${handlerCall} }`);
+  else ls.push(`        if (${param}) ${handlerCall}`);
   ls.push(`      }`);
 }
 var NON_BUBBLING_EVENTS;
@@ -16950,6 +17108,7 @@ var init_event_delegation = __esm({
   "../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts"() {
     "use strict";
     init_utils();
+    init_csr_substitute();
     NON_BUBBLING_EVENTS = /* @__PURE__ */ new Set([
       "blur",
       "focus",
@@ -20313,7 +20472,7 @@ function emitParsedExpr(expr, emitter) {
       return emitter.call(expr.callee, expr.args, emit);
     }
     case "member":
-      return emitter.member(expr.object, expr.property, expr.computed, emit);
+      return emitter.member(expr.object, expr.property, expr.computed, expr.optional, emit);
     case "index-access":
       return emitter.indexAccess(expr.object, expr.index, emit);
     case "binary":
@@ -27426,8 +27585,8 @@ var bfGoSource, evalGoSource, streamingGoSource, bfdevGoSource;
 var init_runtimes_generated = __esm({
   "src/lib/adapters/runtimes.generated.ts"() {
     "use strict";
-    bfGoSource = '// Package bf provides runtime helper functions for BarefootJS Go templates.\n// These functions mirror JavaScript behavior for consistent SSR output.\npackage bf\n\nimport (\n	"bytes"\n	"encoding/json"\n	"fmt"\n	"html/template"\n	"math"\n	"math/rand"\n	"net/url"\n	"os"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode/utf8"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Arithmetic\n		"bf_add": Add,\n		"bf_sub": Sub,\n		"bf_mul": Mul,\n		"bf_div": Div,\n		"bf_mod": Mod,\n		"bf_neg": Neg,\n		"bf_min": Min,\n		"bf_max": Max,\n\n		// String\n		"bf_lower":       Lower,\n		"bf_upper":       Upper,\n		"bf_trim":        Trim,\n		"bf_contains":    Contains,\n		"bf_join":        Join,\n		"bf_split":       Split,\n		"bf_starts_with": StartsWith,\n		"bf_ends_with":   EndsWith,\n		"bf_replace":     Replace,\n		"bf_repeat":      Repeat,\n		"bf_pad_start":   PadStart,\n		"bf_pad_end":     PadEnd,\n		"bf_string":      String,\n\n		// URL query builder (#1897 PostList href helpers): conditional\n		// (include, key, value) triples \u2192 "base?k=v&\u2026", mirroring a\n		// URLSearchParams builder with guarded `.set()` calls.\n		"bf_query": Query,\n\n		// JSON / numeric primitives \u2014 JS-compat callees registered on\n		// the Go adapter\'s `templatePrimitives` map (#1188).\n		"bf_json":     JSON,\n		"bf_number":   Number,\n		"bf_floor":    Floor,\n		"bf_ceil":     Ceil,\n		"bf_round":    Round,\n		"bf_to_fixed": ToFixed,\n\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_flat":           Flat,\n		"bf_flat_dynamic":   FlatDynamicDepth,\n		"bf_flat_map":       FlatMap,\n		"bf_flat_map_tuple": FlatMapTuple,\n		"bf_first":          First,\n		"bf_last":           Last,\n		"bf_arr":            Arr,\n		"bf_filter_truthy":  FilterTruthy,\n\n		// Higher-order Array Methods\n		"bf_every":           Every,\n		"bf_some":            Some,\n		"bf_filter":          Filter,\n		"bf_find":            Find,\n		"bf_find_index":      FindIndex,\n		"bf_find_last":       FindLast,\n		"bf_find_last_index": FindLastIndex,\n		"bf_sort":            Sort,\n		"bf_reduce":          Reduce,\n\n		// Evaluator-driven higher-order folds (#2018): the comparator / reducer\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_sort / bf_reduce beyond their fixed catalogues. The\n		// adapter falls back to bf_sort for a comparator the evaluator can\'t\n		// model (e.g. localeCompare). `bf_env` builds the captured-free-var\n		// environment passed as the trailing base_env argument.\n		"bf_sort_eval":   SortEval,\n		"bf_reduce_eval": FoldEval,\n		"bf_env":         Env,\n\n		// Evaluator-driven higher-order predicates (#2018, P2): the predicate\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_filter / bf_find / bf_find_index / bf_every / bf_some\n		// beyond their field-equality / truthiness catalogues. `bf_find_eval` /\n		// `bf_find_index_eval` take a `forward` bool (false \u2192 findLast variants).\n		"bf_filter_eval":     FilterEval,\n		"bf_every_eval":      EveryEval,\n		"bf_some_eval":       SomeEval,\n		"bf_find_eval":       FindEval,\n		"bf_find_index_eval": FindIndexEval,\n		// `.flatMap(proj)`: project each element through the serialized\n		// projection body, then flatten one level.\n		"bf_flat_map_eval": FlatMapEval,\n		// Value-producing `.map(cb)` (#2073): project each element, one\n		// result per element (no flatten).\n		"bf_map_eval": MapEval,\n\n		// Comment marker (for hydration)\n		"bfComment":   Comment,\n		"bfTextStart": TextStart,\n		"bfTextEnd":   TextEnd,\n\n		// Script collection\n		"bfScripts": BfScripts,\n\n		// Scope attribute value (#1249: bare scope id, no `~` prefix)\n		"bfScopeAttr": ScopeAttr,\n\n		// Slot-identity markers (#1249): bf-h, bf-m, bf-r\n		"bfHydrationAttrs": HydrationAttrs,\n\n		// Child component marker (kept for backward compatibility)\n		"bfIsChild": IsChild,\n\n		// Props attribute for hydration\n		"bfPropsAttr": BfPropsAttr,\n\n		// Portal HTML rendering (parses and executes template string)\n		"bfPortalHTML": PortalHTML,\n\n		// JSX children passed to an imported child component (#1896):\n		// the parent renders the children fragment via a companion\n		// define (executed through bf_tmpl from TemplateFuncMap) and\n		// injects the result into the child\'s Children field.\n		"bf_with_children": WithChildren,\n\n		// Scope comment for fragment roots\n		"bfScopeComment": ScopeComment,\n\n		// JSX intrinsic-element spread lowering (#1407)\n		"bf_spread_attrs": SpreadAttrs,\n\n		// Destructure object-rest spread-onto-element residual (#2087):\n		// "every field except these" for a struct/map, keyed by json tag.\n		"bf_omit": Omit,\n\n		// Case-tolerant single-field read off a map or struct (#2087): a\n		// `useContext` local whose `createContext` default is object-shaped\n		// (e.g. `createContext<{ config: X }>({ config: {} })`) is typed\n		// `map[string]interface{}`, and its keys are the SOURCE (JS-cased)\n		// property names a `<Ctx.Provider value={{ \u2026 }}>` bakes\n		// (`providerObjectValueToGoMap`, go-template-adapter.ts) \u2014 plain\n		// `text/template` dot access does an exact-string `MapIndex`, so\n		// `ctx.config.label` lowers to nested `bf_get` calls instead of\n		// `.Ctx.Config.Label`. Reuses the same `getFieldValue` the\n		// project/sort helpers already use for a dynamic field-name lookup;\n		// safe on a nil map/interface (returns nil) so a missing Provider or\n		// an absent key falls through to `??`\'s fallback.\n		"bf_get": getFieldValue,\n	}\n}\n\n// Query builds a URL from a base path plus a query string assembled from\n// (include, key, value) triples, in order. A pair is considered only when its\n// `include` flag is true \u2014 mirroring a JS URLSearchParams builder whose\n// `.set(key, value)` calls are each guarded by an `if`. The compiler lowers a\n// conditional `cond ? v : undefined` to the `include` bool and a plain `key: v`\n// to a `true` include; the emptiness check is applied HERE (an included but\n// empty value is dropped), matching the client `queryHref` and the Perl `query`\n// helper. Keys and values use formEscape (application/x-www-form-urlencoded),\n// so the rendered query is byte-for-byte identical to the browser\'s\n// URLSearchParams. An empty query yields the bare base.\n//\n// A value may be a string slice ([]string or []any), which APPENDS one pair per\n// non-empty member (URLSearchParams.append) \u2014 `{tag: [a, b]}` \u2192 `tag=a&tag=b`.\n// A scalar value follows URLSearchParams.set() semantics: repeating a key\n// overwrites the value at the key\'s first position rather than duplicating it\n// (object literals have unique keys, so this is defensive). Trailing args that\n// don\'t complete a triple are ignored.\n//\n// formEscape differs from url.QueryEscape only on `~` (kept by QueryEscape,\n// `%7E` here) and `*` (`%2A` by QueryEscape, kept here).\nfunc Query(base string, triples ...any) string {\n	type kv struct{ key, val string }\n	pairs := make([]kv, 0, len(triples)/3)\n	pos := make(map[string]int)\n	for i := 0; i+2 < len(triples); i += 3 {\n		include, _ := triples[i].(bool)\n		if !include {\n			continue\n		}\n		k := String(triples[i+1])\n		if members, ok := asStringSlice(triples[i+2]); ok {\n			// Array value \u2192 append each non-empty member; appended pairs never\n			// overwrite, so they don\'t participate in the set()-position map.\n			for _, m := range members {\n				if m == "" {\n					continue\n				}\n				pairs = append(pairs, kv{k, m})\n			}\n			continue\n		}\n		v := String(triples[i+2])\n		if v == "" {\n			continue // omit an included-but-empty value (client / Perl parity)\n		}\n		if at, ok := pos[k]; ok {\n			pairs[at].val = v // set(): overwrite the first occurrence\'s value\n		} else {\n			pos[k] = len(pairs)\n			pairs = append(pairs, kv{k, v})\n		}\n	}\n	var b strings.Builder\n	for _, p := range pairs {\n		if b.Len() == 0 {\n			b.WriteByte(\'?\')\n		} else {\n			b.WriteByte(\'&\')\n		}\n		b.WriteString(formEscape(p.key))\n		b.WriteByte(\'=\')\n		b.WriteString(formEscape(p.val))\n	}\n	return base + b.String()\n}\n\n// asStringSlice reports whether v is a query *array* value and, if so, returns\n// its members stringified. A compiled template passes a `[]string` field; the\n// golden conformance vectors decode JSON arrays to `[]any`. Anything else is a\n// scalar (false), handled by the set() path.\nfunc asStringSlice(v any) ([]string, bool) {\n	switch s := v.(type) {\n	case []string:\n		return s, true\n	case []any:\n		out := make([]string, len(s))\n		for i, m := range s {\n			out[i] = String(m)\n		}\n		return out, true\n	default:\n		return nil, false\n	}\n}\n\nconst hexUpper = "0123456789ABCDEF"\n\n// formEscape percent-encodes s with the application/x-www-form-urlencoded byte\n// set, matching the browser\'s URLSearchParams serialization (and the Perl\n// `query` helper) so SSR query strings render byte-for-byte identically across\n// adapters. The unreserved set kept verbatim is A-Z a-z 0-9 and `* - . _`; a\n// space becomes `+`; every other byte is `%XX` with uppercase hex. Encoding is\n// byte-wise, so multi-byte UTF-8 is percent-encoded per byte (`\xE9` \u2192 `%C3%A9`).\n//\n// This differs from url.QueryEscape only for `~` (kept by QueryEscape, encoded\n// to `%7E` here) and `*` (encoded to `%2A` by QueryEscape, kept here).\nfunc formEscape(s string) string {\n	var b strings.Builder\n	for i := 0; i < len(s); i++ {\n		c := s[i]\n		switch {\n		case c >= \'A\' && c <= \'Z\', c >= \'a\' && c <= \'z\', c >= \'0\' && c <= \'9\',\n			c == \'*\', c == \'-\', c == \'.\', c == \'_\':\n			b.WriteByte(c)\n		case c == \' \':\n			b.WriteByte(\'+\')\n		default:\n			b.WriteByte(\'%\')\n			b.WriteByte(hexUpper[c>>4])\n			b.WriteByte(hexUpper[c&0x0F])\n		}\n	}\n	return b.String()\n}\n\n// ScopeAttr returns the bare bf-s scope id (#1249).\nfunc ScopeAttr(props interface{}) string {\n	return getStringField(props, "ScopeID")\n}\n\n// HydrationAttrs emits `bf-h="<host>" bf-m="<slot>" bf-r=""` conditionally.\n// See spec/compiler.md "Slot identity".\nfunc HydrationAttrs(props interface{}) template.HTMLAttr {\n	parts := []string{}\n	if host := getStringField(props, "BfParent"); host != "" {\n		parts = append(parts, fmt.Sprintf(`bf-h="%s"`, template.HTMLEscapeString(host)))\n	}\n	if mount := getStringField(props, "BfMount"); mount != "" {\n		parts = append(parts, fmt.Sprintf(`bf-m="%s"`, template.HTMLEscapeString(mount)))\n	}\n	if !getBoolField(props, "BfIsChild") {\n		parts = append(parts, `bf-r=""`)\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// IsChild is a deprecated no-op stub. Child status is signalled by bf-h\n// presence (#1249); use HydrationAttrs instead.\nfunc IsChild(props interface{}) template.HTMLAttr {\n	return ""\n}\n\n// svgCamelCaseAttrs mirrors SVG_CAMEL_CASE_ATTRS from\n// packages/client/src/runtime/spread-attrs.ts. SVG XML attribute\n// names are case-sensitive; the default camelCase \u2192 kebab-case\n// rewrite must NOT apply to these or the SVG stops rendering\n// (#1407). Coordinates with the compile-time SVG_CAMEL_TO_KEBAB\n// table in packages/jsx/src/ir-to-client-js/utils.ts: presentation\n// attrs (clipPath, strokeWidth, \u2026) live there and must NOT appear\n// here, or the same JSX prop would lower to clip-path via the\n// explicit-attr path and stay clipPath via the spread path.\nvar svgCamelCaseAttrs = map[string]struct{}{\n	"allowReorder": {}, "attributeName": {}, "attributeType": {}, "autoReverse": {},\n	"baseFrequency": {}, "baseProfile": {}, "calcMode": {}, "clipPathUnits": {},\n	"contentScriptType": {}, "contentStyleType": {}, "diffuseConstant": {}, "edgeMode": {},\n	"externalResourcesRequired": {}, "filterRes": {}, "filterUnits": {}, "glyphRef": {},\n	"gradientTransform": {}, "gradientUnits": {}, "kernelMatrix": {}, "kernelUnitLength": {},\n	"keyPoints": {}, "keySplines": {}, "keyTimes": {}, "lengthAdjust": {}, "limitingConeAngle": {},\n	"markerHeight": {}, "markerUnits": {}, "markerWidth": {}, "maskContentUnits": {},\n	"maskUnits": {}, "numOctaves": {}, "pathLength": {}, "patternContentUnits": {},\n	"patternTransform": {}, "patternUnits": {}, "pointsAtX": {}, "pointsAtY": {}, "pointsAtZ": {},\n	"preserveAlpha": {}, "preserveAspectRatio": {}, "primitiveUnits": {}, "refX": {}, "refY": {},\n	"repeatCount": {}, "repeatDur": {}, "requiredExtensions": {}, "requiredFeatures": {},\n	"specularConstant": {}, "specularExponent": {}, "spreadMethod": {}, "startOffset": {},\n	"stdDeviation": {}, "stitchTiles": {}, "surfaceScale": {}, "systemLanguage": {},\n	"tableValues": {}, "targetX": {}, "targetY": {}, "textLength": {}, "viewBox": {}, "viewTarget": {},\n	"xChannelSelector": {}, "yChannelSelector": {}, "zoomAndPan": {},\n}\n\n// toAttrName mirrors the JSX\u2192HTML attribute-name rewrite from\n// packages/client/src/runtime/spread-attrs.ts. className \u2192 class,\n// htmlFor \u2192 for, SVG camelCase attrs preserved, other camelCase\n// keys lowered to kebab-case.\nfunc toAttrName(key string) string {\n	if key == "className" {\n		return "class"\n	}\n	if key == "htmlFor" {\n		return "for"\n	}\n	if _, ok := svgCamelCaseAttrs[key]; ok {\n		return key\n	}\n	// camelCase \u2192 kebab-case: mirror the JS reference exactly\n	// (`key.replace(/([A-Z])/g, \'-$1\').toLowerCase()`). The JS shape\n	// produces a leading `-` for an initial uppercase letter\n	// (`XData` \u2192 `-x-data`); both this Go path and the matching JS\n	// runtime are wrong-by-construction for that case (the resulting\n	// HTML attribute name is invalid), but keeping them byte-equal\n	// avoids silent SSR/CSR divergence (#1411 review).\n	var b strings.Builder\n	for _, r := range key {\n		if r >= \'A\' && r <= \'Z\' {\n			b.WriteByte(\'-\')\n			b.WriteRune(r + 32)\n		} else {\n			b.WriteRune(r)\n		}\n	}\n	return b.String()\n}\n\n// StyleToCss mirrors styleToCss from\n// packages/client/src/runtime/style.ts. Accepts a string passthrough,\n// or a map (JSON-deserialized object) whose camelCase keys are\n// lowered to kebab-case and joined with `;`. Returns ("", false) for\n// nullish/empty input so callers can omit the attribute entirely.\nfunc StyleToCss(v any) (string, bool) {\n	if v == nil {\n		return "", false\n	}\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return "", false\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		// Non-object: stringify and return as-is, matching the JS\n		// `typeof value !== \'object\'` branch.\n		s := fmt.Sprint(v)\n		if s == "" {\n			return "", false\n		}\n		return s, true\n	}\n	keys := rv.MapKeys()\n	sorted := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sorted = append(sorted, k.String())\n		}\n	}\n	sort.Strings(sorted)\n	parts := make([]string, 0, len(sorted))\n	for _, k := range sorted {\n		val := rv.MapIndex(reflect.ValueOf(k))\n		// Skip nil entries (matches the JS `if (v == null) continue`).\n		if !val.IsValid() {\n			continue\n		}\n		if val.Kind() == reflect.Interface || val.Kind() == reflect.Pointer {\n			if val.IsNil() {\n				continue\n			}\n			val = val.Elem()\n		}\n		prop := toAttrName(k)\n		parts = append(parts, fmt.Sprintf("%s:%v", prop, val.Interface()))\n	}\n	if len(parts) == 0 {\n		return "", false\n	}\n	return strings.Join(parts, ";"), true\n}\n\n// SpreadAttrs lowers a JSX intrinsic-element spread bag (#1407) to\n// an HTML attribute string. Mirrors spreadAttrs from\n// packages/client/src/runtime/spread-attrs.ts so SSR output matches\n// what CSR\'s `applyRestAttrs` writes at hydration.\n//\n// Skip rules: nil/false values, event handlers (`on[A-Z]*`),\n// `children`, `ref`.\n//\n// Key remap: className \u2192 class, htmlFor \u2192 for, SVG camelCase\n// preserved, other camelCase \u2192 kebab-case.\n//\n// `style` is routed through StyleToCss so object literals serialize\n// to a real CSS string instead of Go\'s default `map[k:v]` form.\n//\n// Booleans: true \u2192 bare attribute name, false \u2192 omitted.\n// Other scalar values are HTML-escaped via template.HTMLEscapeString.\n// Returns a `template.HTMLAttr` so html/template emits the result\n// verbatim (the function does its own escaping).\n//\n// Keys are sorted alphabetically before emission for deterministic\n// output. SSR/CSR attribute-order divergence is acceptable per the\n// rest-destructure-object-spread-in-map fixture\'s documented policy\n// \u2014 browsers honor the LAST value when a key is duplicated, so\n// pairing with static attrs (`<div class="x" {...rest}>`) is\n// last-wins regardless of order.\nfunc SpreadAttrs(bag any) template.HTMLAttr {\n	if bag == nil {\n		return ""\n	}\n	rv := reflect.ValueOf(bag)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return ""\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		return ""\n	}\n	keys := rv.MapKeys()\n	sortedKeys := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sortedKeys = append(sortedKeys, k.String())\n		}\n	}\n	sort.Strings(sortedKeys)\n	parts := make([]string, 0, len(sortedKeys))\n	for _, key := range sortedKeys {\n		// Event handlers \u2014 skip at SSR the same way\n		// packages/client/src/runtime/spread-attrs.ts does at\n		// hydration. The JS predicate is\n		// `key.startsWith(\'on\') && key.length > 2 && key[2] === key[2].toUpperCase()`,\n		// which is true for any character whose uppercase form is\n		// itself: ASCII A-Z, digits, underscore, and non-letter\n		// symbols. Mirror that here by skipping when key[2] is NOT\n		// a lowercase ASCII letter \u2014 so `onClick`, `on_custom`, and\n		// `on0` all match (#1411 review).\n		if len(key) > 2 && key[0] == \'o\' && key[1] == \'n\' && !(key[2] >= \'a\' && key[2] <= \'z\') {\n			continue\n		}\n		// `children` is a JSX construct rendered inside the element,\n		// never a DOM attribute. `ref` is intentionally NOT filtered\n		// here so output stays byte-equal with the JS reference\n		// `spreadAttrs` in packages/client/src/runtime/spread-attrs.ts\n		// (which only filters null/false, event handlers, and\n		// children) \u2014 aligning Go\'s filter set diverges from JS in\n		// the opposite direction. Filtering `ref` consistently across\n		// both SSR runtimes is a separate concern tracked alongside\n		// the JS `applyRestAttrs` vs `spreadAttrs` mismatch (#1411\n		// review).\n		if key == "children" {\n			continue\n		}\n		val := rv.MapIndex(reflect.ValueOf(key))\n		if !val.IsValid() {\n			continue\n		}\n		// Unwrap interface wrappers (json.Unmarshal produces\n		// interface{}-wrapped values for map[string]any).\n		v := val\n		for v.Kind() == reflect.Interface || v.Kind() == reflect.Pointer {\n			if v.IsNil() {\n				// Skip null entries.\n				v = reflect.Value{}\n				break\n			}\n			v = v.Elem()\n		}\n		if !v.IsValid() {\n			continue\n		}\n		// Boolean values: true \u2192 bare attribute, false \u2192 omitted.\n		if v.Kind() == reflect.Bool {\n			if !v.Bool() {\n				continue\n			}\n			parts = append(parts, toAttrName(key))\n			continue\n		}\n		// `style` routes through StyleToCss so object literals get a\n		// real CSS string. The JS side does the same.\n		if key == "style" {\n			css, ok := StyleToCss(v.Interface())\n			if !ok {\n				continue\n			}\n			parts = append(parts, fmt.Sprintf(`style="%s"`, template.HTMLEscapeString(css)))\n			continue\n		}\n		// Stringify and escape. fmt.Sprint handles numbers, bools-as-\n		// strings, and arbitrary stringer types the same way the JS\n		// `String(value)` coercion does for the analogous cases.\n		s := fmt.Sprint(v.Interface())\n		parts = append(parts, fmt.Sprintf(`%s="%s"`, toAttrName(key), template.HTMLEscapeString(s)))\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// Omit builds a `map[string]any` residual bag from a struct or map value,\n// excluding the given keys \u2014 powers the `{...rest}` spread-onto-element\n// lowering for a destructured `.map()` loop-item\'s object-rest binding\n// (#2087): `.map(({ id, title, ...rest }) => <li {...rest}>)` needs "every\n// field EXCEPT the ones the pattern already destructured out", and a static\n// Go struct type has no way to express "minus a field" \u2014 the exclude set is\n// known at COMPILE TIME (the sibling keys the destructure pattern names), so\n// the compiler passes them here and this does the per-item field-vs-key\n// matching a static type can\'t. The result feeds `bf_spread_attrs`\n// (`SpreadAttrs`), same as a top-level `{...attrs()}` bag.\n//\n// Struct receiver: iterates exported fields via reflection, keyed by each\n// field\'s `json` struct tag (falling back to the Go field name when absent)\n// \u2014 the generated struct\'s json tag is always the ORIGINAL source property\n// name (see `structFieldsFor` / `typeDefinitionToGo` in the Go adapter), so\n// this reproduces the exact JS key `SpreadAttrs`\'s `toAttrName` expects\n// (`"data-priority"`, not a re-derived `"DataPriority"`). A tag of `"-"`\n// (opt-out) is skipped like `encoding/json` does.\n//\n// Map receiver: copies string keys through directly, same exclude/skip\n// rules.\n//\n// Anything else (nil, a non-struct/non-map interface) returns an empty map.\nfunc Omit(item any, excludeKeys ...string) map[string]any {\n	exclude := make(map[string]struct{}, len(excludeKeys))\n	for _, k := range excludeKeys {\n		exclude[k] = struct{}{}\n	}\n	out := map[string]any{}\n	rv := reflect.ValueOf(item)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return out\n		}\n		rv = rv.Elem()\n	}\n	switch rv.Kind() {\n	case reflect.Struct:\n		rt := rv.Type()\n		for i := 0; i < rt.NumField(); i++ {\n			field := rt.Field(i)\n			if !field.IsExported() {\n				continue\n			}\n			key := field.Name\n			if tag, ok := field.Tag.Lookup("json"); ok {\n				if comma := strings.Index(tag, ","); comma >= 0 {\n					tag = tag[:comma]\n				}\n				if tag == "-" {\n					continue\n				}\n				if tag != "" {\n					key = tag\n				}\n			}\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			out[key] = rv.Field(i).Interface()\n		}\n	case reflect.Map:\n		for _, k := range rv.MapKeys() {\n			if k.Kind() != reflect.String {\n				continue\n			}\n			key := k.String()\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			val := rv.MapIndex(k)\n			if val.IsValid() {\n				out[key] = val.Interface()\n			}\n		}\n	}\n	return out\n}\n\n// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Min returns the smaller of a and b (two-arg `Math.min`). Like Mul, it keeps\n// an integer result when both operands are int-like so a CSS value such as\n// `bf_min 100 x` stays `100` rather than `100.000000`.\nfunc Min(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	r := av\n	if bv < av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Max returns the larger of a and b (two-arg `Math.max`), with the same\n// int-preserving rule as Min.\nfunc Max(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	r := av\n	if bv > av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Split lowers `String.prototype.split(sep, limit?)` (#1448 Tier B). It\n// wraps `strings.Split` and normalises the result to `[]any` so the\n// slice composes with the array-method surface downstream (`bf_join`,\n// range loops, `bf_len`, \u2026) the same way `bf_slice` / `bf_reverse`\n// results do. Like JS, an empty separator splits into individual UTF-8\n// characters and trailing empty fields are preserved (`"a,".split(",")`\n// \u2192 `["a", ""]`). An optional `limit` caps the number of returned\n// pieces (`"a,b,c".split(",", 2)` \u2192 `["a", "b"]`); a negative limit is\n// ignored (JS would also return every piece \u2014 its ToUint32 wrap makes\n// the limit effectively unbounded). The no-separator form is handled by\n// the adapter (it emits `bf_arr` for the whole-string single element).\nfunc Split(s, sep string, limit ...int) []any {\n	parts := strings.Split(s, sep)\n	if len(limit) > 0 && limit[0] >= 0 && limit[0] < len(parts) {\n		parts = parts[:limit[0]]\n	}\n	out := make([]any, len(parts))\n	for i, p := range parts {\n		out[i] = p\n	}\n	return out\n}\n\n// StartsWith lowers `String.prototype.startsWith(prefix, position?)`\n// (#1448 Tier B). Wraps `strings.HasPrefix`; an empty prefix is always\n// true (JS parity). The optional `position` re-anchors the test to start\n// at that index (clamped to `[0, len]` so it never panics), matching JS\n// `"abc".startsWith("b", 1) === true`.\nfunc StartsWith(s, prefix string, position ...int) bool {\n	if len(position) > 0 {\n		p := position[0]\n		if p < 0 {\n			p = 0\n		}\n		if p > len(s) {\n			p = len(s)\n		}\n		s = s[p:]\n	}\n	return strings.HasPrefix(s, prefix)\n}\n\n// EndsWith lowers `String.prototype.endsWith(suffix, endPosition?)`\n// (#1448 Tier B). Wraps `strings.HasSuffix`; an empty suffix is always\n// true (JS parity). The optional `endPosition` treats the string as if\n// it were only that many bytes long (clamped to `[0, len]`), matching JS\n// `"abc".endsWith("b", 2) === true`.\nfunc EndsWith(s, suffix string, endPosition ...int) bool {\n	if len(endPosition) > 0 {\n		e := endPosition[0]\n		if e < 0 {\n			e = 0\n		}\n		if e > len(s) {\n			e = len(s)\n		}\n		s = s[:e]\n	}\n	return strings.HasSuffix(s, suffix)\n}\n\n// Replace lowers the string-pattern form of `String.prototype.replace`\n// (#1448 Tier B). JS replaces only the FIRST occurrence for a string\n// pattern, so the count is 1 (`strings.Replace` with n=1; n<0 would\n// replace all \u2014 that\'s `.replaceAll`, still refused). The replacement\n// is treated literally: unlike JS, special replacement patterns like\n// `$&` / `$1` are NOT interpreted (Go and Perl agree on literal\n// replacement, keeping the two template adapters byte-equal; this\n// diverges from the Hono/CSR JS path only for replacement strings that\n// contain `$`-patterns, which are rare in template position).\nfunc Replace(s, old, new string) string {\n	return strings.Replace(s, old, new, 1)\n}\n\n// Repeat lowers `String.prototype.repeat(n)` (#1448 Tier B): the\n// receiver concatenated n times. JS throws RangeError for a negative\n// count and `strings.Repeat` panics, so a negative count clamps to the\n// empty string \u2014 SSR templates degrade rather than crash the render.\n// A zero count is the empty string (JS parity).\nfunc Repeat(s string, n int) string {\n	if n <= 0 {\n		return ""\n	}\n	return strings.Repeat(s, n)\n}\n\n// padTo lowers the shared body of `String.prototype.padStart` /\n// `padEnd` (#1448 Tier B): pad `s` to `target` code points using `pad`\n// repeated and truncated to fill, prepended (atStart) or appended.\n// Length is measured in runes (not bytes) so the result matches the\n// Perl `bf->pad_*` helpers \u2014 this diverges from JS\'s UTF-16-unit length\n// only for astral-plane input. An empty pad, or a receiver already at\n// least `target` long, returns `s` unchanged (JS parity).\nfunc padTo(s string, target int, pad string, atStart bool) string {\n	if pad == "" {\n		return s\n	}\n	sLen := utf8.RuneCountInString(s)\n	if sLen >= target {\n		return s\n	}\n	need := target - sLen\n	padRunes := []rune(pad)\n	fill := make([]rune, 0, need)\n	for len(fill) < need {\n		for _, r := range padRunes {\n			if len(fill) >= need {\n				break\n			}\n			fill = append(fill, r)\n		}\n	}\n	if atStart {\n		return string(fill) + s\n	}\n	return s + string(fill)\n}\n\n// PadStart lowers `String.prototype.padStart(target, pad?)` (#1448 Tier\n// B). The pad string defaults to a single space when omitted.\nfunc PadStart(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, true)\n}\n\n// PadEnd lowers `String.prototype.padEnd(target, pad?)` (#1448 Tier B).\nfunc PadEnd(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, false)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// String returns the string form of v. Mirrors JS `String(v)` for\n// non-nil values via `fmt.Sprintf("%v", ...)`. Diverges from JS on\n// nil: JS `String(null)` is "null", but the template path renders\n// `nil` as the empty string here so an unset prop doesn\'t surface\n// as a literal "null"/"undefined" in user-facing HTML. Document the\n// divergence explicitly so callers don\'t rely on JS-exact parity.\nfunc String(v any) string {\n	if v == nil {\n		return ""\n	}\n	return fmt.Sprintf("%v", v)\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// ToFixed formats v with exactly `digits` decimal places, mirroring JS\n// `Number.prototype.toFixed` (zero-padding + half-toward-+Infinity\n// rounding). JS rounds the scaled integer half up (`(2.5).toFixed(0)`\n// is "3"); bare `fmt.Sprintf("%.*f")` rounds half-to-even ("2"), so we\n// scale, round with `Floor(x + 0.5)` (matching `Round`), then format\n// the exact multiple. #1897.\nfunc ToFixed(v any, digits int) string {\n	if digits < 0 {\n		digits = 0\n	}\n	n := Number(v)\n	// JS toFixed returns the strings "NaN" / "Infinity" / "-Infinity" for\n	// non-finite inputs; fmt would render "NaN"/"+Inf"/"-Inf".\n	if math.IsNaN(n) {\n		return "NaN"\n	}\n	if math.IsInf(n, 1) {\n		return "Infinity"\n	}\n	if math.IsInf(n, -1) {\n		return "-Infinity"\n	}\n	factor := math.Pow(10, float64(digits))\n	rounded := math.Floor(n*factor + 0.5)\n	return fmt.Sprintf("%.*f", digits, rounded/factor)\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  SameValueZero element search (matches\n//     the evaluator\'s `evalSameValueZero`/`evalIncludes` in eval.go,\n//     which back the serialized-callback path) \u2014 numeric types compare\n//     by value across int/float64 the way JS\'s single "number" type\n//     does, and NaN matches NaN (unlike `===`). This used to be\n//     `reflect.DeepEqual`, which is type-strict (`int(2)` != `float64(2)`)\n//     and never matches NaN to NaN; that diverged from the evaluator\'s\n//     `.includes` and from JS itself, so it was unified here.\n//   - string receiver:       strings.Contains substring search\n//\n// Anything else returns false (matches the JS semantic where\n// `.includes` is only defined on Array / TypedArray / String).\nfunc Includes(recv any, elem any) bool {\n	v := reflect.ValueOf(recv)\n	if v.Kind() == reflect.String {\n		// JS `String.prototype.includes` accepts only string args;\n		// non-string `elem` would TypeError in real JS but our\n		// callers have lowered through `convertExpressionToGo`\n		// where the arg type is whatever the template binds. Stringify\n		// via fmt to keep the helper total.\n		needle, ok := elem.(string)\n		if !ok {\n			needle = fmt.Sprintf("%v", elem)\n		}\n		return strings.Contains(v.String(), needle)\n	}\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if evalSameValueZero(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A). The variadic\n// `end` arg lets Go template\'s call dispatcher pass either 2 or 3\n// arguments; an absent end means "to length".\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\n//   - start >= end       \u2192 empty slice (no panic)\n//\n// Non-array receivers return an empty `[]any`.\nfunc Slice(items any, start int, end ...int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n\n	// Normalise start (negative = from end).\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	// Normalise end (optional; absent = length).\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n\n	if start >= stop {\n		return []any{}\n	}\n\n	out := make([]any, 0, stop-start)\n	for i := start; i < stop; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// Flat flattens nested slices/arrays `depth` levels deep. Lowers\n// `Array.prototype.flat(depth?)` (#1448 Tier C). A `depth` of `-1` is the\n// `Infinity` sentinel (flatten fully); `0` (or negative-from-JS, already\n// normalised to 0 at compile time) returns a shallow copy. Non-array\n// elements are kept as-is (JS only flattens nested arrays). A non-array\n// receiver returns an empty `[]any`.\nfunc Flat(items any, depth int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		ev := reflect.ValueOf(el)\n		if depth != 0 && (ev.Kind() == reflect.Slice || ev.Kind() == reflect.Array) {\n			// `-1` (Infinity) recurses unbounded; a finite depth spends one level.\n			next := depth\n			if depth > 0 {\n				next = depth - 1\n			}\n			out = append(out, Flat(el, next)...)\n		} else {\n			out = append(out, el)\n		}\n	}\n	return out\n}\n\n// FlatDynamicDepth coerces `depth` via JS\'s `ToIntegerOrInfinity` and\n// flattens `items` that many levels. Lowers a DYNAMIC `.flat(depth)`\n// (#2094) \u2014 one whose depth isn\'t a compile-time literal, so (unlike\n// `Flat` above) the coercion happens here at render time instead of in the\n// parser.\n//\n// This is a SEPARATE helper from `Flat`/`bf_flat` \u2014 NOT a drop-in\n// replacement \u2014 because `Flat`\'s `depth int` parameter treats `-1` as a\n// compile-time SENTINEL meaning "flatten fully" (the parser\'s own\n// normalisation of a literal `Infinity`). A genuinely dynamic depth value\n// of `-1` means the JS-correct OPPOSITE: `Array.prototype.flat(-1)` never\n// recurses (same as `.flat(0)`, a shallow copy), because\n// `FlattenIntoArray` only recurses when `depth > 0`. Reusing `Flat`\'s int\n// contract for a raw dynamic value would silently invert that case, so\n// this function coerces FIRST \u2014 mapping a real `+Infinity` / huge finite\n// value to `Flat`\'s own `-1` sentinel, and a real negative value to `0` \u2014\n// and only then delegates to `Flat`\'s recursion.\n//\n// Coercion rules (JS `ToIntegerOrInfinity`, mirrored exactly; pinned by the\n// `flat_dynamic` golden-vector cases in\n// packages/adapter-tests/vectors/cases.ts):\n//   - the value converts via `ToNumber` first (numeric string / bool /\n//     number all coerce; see `flatDepthToFloat`);\n//   - a NaN result (including a non-numeric string) \u2192 `0`;\n//   - truncates toward zero (`2.7` \u2192 `2`);\n//   - negative \u2192 `0`;\n//   - `+Infinity` / a huge finite value \u2192 flattens fully.\nfunc FlatDynamicDepth(items any, depth any) []any {\n	return Flat(items, coerceFlatDepth(depth))\n}\n\n// coerceFlatDepth implements JS\'s `ToIntegerOrInfinity` for a dynamic\n// `.flat(depth)` argument, returning an int in `Flat`\'s own contract (`-1`\n// = unbounded, `>= 0` = that many levels).\nfunc coerceFlatDepth(depth any) int {\n	f, ok := flatDepthToFloat(depth)\n	if !ok || math.IsNaN(f) {\n		return 0\n	}\n	if math.IsInf(f, 1) {\n		return -1 // Flat\'s "flatten fully" sentinel\n	}\n	if math.IsInf(f, -1) {\n		return 0\n	}\n	trunc := math.Trunc(f)\n	if trunc < 0 {\n		return 0\n	}\n	// A huge finite depth behaves identically to "flatten fully" in\n	// practice \u2014 real data bottoms out at its actual nesting depth long\n	// before a counter this large would ever reach zero. Capping it here\n	// avoids an absurd countdown without needing a second sentinel.\n	if trunc > 1_000_000 {\n		return -1\n	}\n	return int(trunc)\n}\n\n// flatDepthToFloat converts a dynamic `.flat(depth)` argument to a float64,\n// mirroring JS\'s `ToNumber` across the value shapes a Go template data\n// model can carry (every numeric kind, bool, numeric string). `ok` is\n// false for a shape `ToNumber` can\'t coerce meaningfully (`nil`, or a\n// non-numeric string) \u2014 `coerceFlatDepth` treats that the same as NaN\n// (\u2192 depth `0`), matching JS.\nfunc flatDepthToFloat(v any) (float64, bool) {\n	switch n := v.(type) {\n	case nil:\n		return 0, false\n	case float64:\n		return n, true\n	case float32:\n		return float64(n), true\n	case int:\n		return float64(n), true\n	case int8:\n		return float64(n), true\n	case int16:\n		return float64(n), true\n	case int32:\n		return float64(n), true\n	case int64:\n		return float64(n), true\n	case uint:\n		return float64(n), true\n	case uint8:\n		return float64(n), true\n	case uint16:\n		return float64(n), true\n	case uint32:\n		return float64(n), true\n	case uint64:\n		return float64(n), true\n	case bool:\n		if n {\n			return 1, true\n		}\n		return 0, true\n	case string:\n		s := strings.TrimSpace(n)\n		if s == "" {\n			return 0, true // JS: Number("") is 0\n		}\n		f, err := strconv.ParseFloat(s, 64)\n		if err != nil {\n			return 0, false // not numeric \u2192 NaN path\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// FlatMap projects each element through a `self` / `field` projection and\n// flattens the result one level. Lowers value-returning\n// `Array.prototype.flatMap(fn)` for the field-projection catalogue\n// (#1448 Tier C): `items.flatMap(i => i)` (self) and\n// `items.flatMap(i => i.field)` (field). A projected non-array value is\n// kept as-is (flatMap = map + flat(1)). Non-array receiver \u2192 empty.\nfunc FlatMap(items any, keyKind, keyName string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	projected := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		if keyKind == "field" {\n			projected = append(projected, getFieldValue(el, keyName))\n		} else {\n			projected = append(projected, el)\n		}\n	}\n	return Flat(projected, 1)\n}\n\n// FlatMapTuple lowers an array-literal flatMap projection\n// `items.flatMap(i => [i.a, i.b])` (#1448 Tier C). `specs` is a flat list\n// of (kind, name) pairs, one per array-literal leaf: ("self", "") for the\n// item itself, ("field", "<Name>") for a struct field. For each item it\n// appends every leaf\'s value in order. Unlike the scalar `FlatMap`, the\n// per-item array is flattened only one level (flat(1) removes the literal\n// wrapper), so an array-valued leaf is appended verbatim rather than\n// spread \u2014 which is exactly "append each leaf". Non-array receiver \u2192 empty.\nfunc FlatMapTuple(items any, specs ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		for j := 0; j+1 < len(specs); j += 2 {\n			if specs[j] == "field" {\n				out = append(out, getFieldValue(el, specs[j+1]))\n			} else {\n				out = append(out, el)\n			}\n		}\n	}\n	return out\n}\n\n// First returns the first element of a slice, or nil if empty.\nfunc First(items any) any {\n	return At(items, 0)\n}\n\n// Last returns the last element of a slice, or nil if empty.\nfunc Last(items any) any {\n	return At(items, -1)\n}\n\n// Arr builds an []any from variadic args. Used to lower JS array\n// literals like `[a, b]` for the registry Slot\'s\n// `[className, childClass].filter(Boolean).join(\' \')` shape (#1443) \u2014\n// Go templates have no array-literal syntax, so the codegen routes\n// array-literal IR nodes through this helper.\nfunc Arr(items ...any) []any {\n	return items\n}\n\n// FilterTruthy returns a new slice containing only truthy items.\n// Mirrors `arr.filter(Boolean)` semantics: drop nil, false, 0, "" \u2014 the\n// same falsy set JavaScript\'s `Boolean(x)` recognises. Used to lower\n// the registry Slot\'s class-merge pattern (#1443); generalising to\n// arbitrary callable predicates would need the callee-resolution path\n// blocked by #1389, so this stays Boolean-specific.\nfunc FilterTruthy(items any) []any {\n	v := reflect.ValueOf(items)\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	result := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		raw := v.Index(i).Interface()\n		if isTruthy(raw) {\n			result = append(result, raw)\n		}\n	}\n	return result\n}\n\n// Truthy is the exported form of isTruthy \u2014 JavaScript\'s `Boolean(x)`\n// semantics \u2014 for generated `NewXxxProps` code lowering a conditional\n// inline-object spread condition on an `interface{}` prop (whose runtime\n// value may be a string, number, bool, \u2026). Keeps the spread bag\'s\n// inclusion test faithful to JS rather than string-biased (#1752).\nfunc Truthy(v any) bool { return isTruthy(v) }\n\n// isTruthy mirrors JavaScript\'s `Boolean(x)` for the value shapes the\n// template path actually receives \u2014 nil / false / 0 / "" are falsy.\n// Other shapes (non-empty maps, slices, structs, true) are truthy, in\n// line with JS\'s "objects are truthy" rule.\nfunc isTruthy(v any) bool {\n	if v == nil {\n		return false\n	}\n	switch x := v.(type) {\n	case bool:\n		return x\n	case string:\n		return x != ""\n	case int:\n		return x != 0\n	case int8, int16, int32, int64:\n		return reflect.ValueOf(v).Int() != 0\n	case uint, uint8, uint16, uint32, uint64:\n		return reflect.ValueOf(v).Uint() != 0\n	case float32:\n		// JS `Boolean(NaN)` is false regardless of float width \u2014 the\n		// float64 arm below was the only one checking IsNaN, which\n		// diverged from JS for `float32` NaN inputs (Copilot review on\n		// #1445). Widening to float64 for the IsNaN check keeps the\n		// two branches in lock-step.\n		return x != 0 && !math.IsNaN(float64(x))\n	case float64:\n		return x != 0 && !math.IsNaN(x)\n	}\n	return true\n}\n\n// =============================================================================\n// Higher-order Array Methods\n// =============================================================================\n\n// fieldValue projects item.field for the higher-order predicate\n// helpers. The field name arrives in JS casing; structs resolve via\n// the capitalized Go convention (FieldByName inside getFieldValue),\n// maps via getFieldValue\'s case-variant lookup \u2014 the same dual\n// support Sort/Reduce gained in #1487, extended here so JSON-decoded\n// data (map items) participates instead of being silently skipped.\n// nil-safe: missing fields and nil items project to nil.\nfunc fieldValue(item any, field string) any {\n	return getFieldValue(item, capitalize(field))\n}\n\n// Every returns true if every item\'s field is truthy under JS\n// `Boolean(item.field)` semantics. Mirrors JavaScript\'s\n// Array.prototype.every(item => item.field) \u2014 including being\n// vacuously true for an empty receiver.\nfunc Every(items any, field string) bool {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if !isTruthy(fieldValue(v.Index(i).Interface(), field)) {\n			return false\n		}\n	}\n	return true\n}\n\n// Some returns true if at least one item\'s field is truthy. Mirrors\n// JavaScript\'s Array.prototype.some(item => item.field).\nfunc Some(items any, field string) bool {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if isTruthy(fieldValue(v.Index(i).Interface(), field)) {\n			return true\n		}\n	}\n	return false\n}\n\n// Filter returns items where item.field == value.\n// Mirrors JavaScript\'s Array.prototype.filter(item => item.field === value).\n// Returns []any to allow chaining with other bf_* functions.\nfunc Filter(items any, field string, value any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	var result []any\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			result = append(result, item)\n		}\n	}\n	return result\n}\n\n// Find returns the first item where item.field == value, or nil if not found.\n// Mirrors JavaScript\'s Array.prototype.find(item => item.field === value).\nfunc Find(items any, field string, value any) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			return item\n		}\n	}\n	return nil\n}\n\n// FindIndex returns the index of the first item where item.field == value, or -1.\n// Mirrors JavaScript\'s Array.prototype.findIndex(item => item.field === value).\nfunc FindIndex(items any, field string, value any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(fieldValue(v.Index(i).Interface(), field), value) {\n			return i\n		}\n	}\n	return -1\n}\n\n// FindLast returns the last item where item.field == value, or nil if not found.\n// Mirrors JavaScript\'s Array.prototype.findLast(item => item.field === value).\nfunc FindLast(items any, field string, value any) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			return item\n		}\n	}\n	return nil\n}\n\n// FindLastIndex returns the index of the last item where item.field == value, or -1.\n// Mirrors JavaScript\'s Array.prototype.findLastIndex(item => item.field === value).\nfunc FindLastIndex(items any, field string, value any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(fieldValue(v.Index(i).Interface(), field), value) {\n			return i\n		}\n	}\n	return -1\n}\n\n// sortKeySpec is one parsed comparison key. A simple comparator has\n// one; a `||`-chained multi-key comparator has several, applied in\n// order as tie-breakers.\ntype sortKeySpec struct {\n	kind        string // "self" | "field"\n	name        string // capitalised field name, or "" for "self"\n	compareType string // "numeric" | "string" | "auto"\n	direction   string // "asc" | "desc"\n}\n\n// Sort returns a new stable-sorted slice. Lowers\n// `Array.prototype.sort` / `Array.prototype.toSorted` (#1448 Tier B).\n// Non-mutating \u2014 JS\'s mutate-vs-new distinction is moot in SSR\n// template context (templates render a snapshot).\n//\n// Call shape (the compiler emits one 4-string group per key):\n//\n//	bf_sort <items> (<keyKind> <keyName> <compareType> <direction>)+\n//\n//	keyKind:      "self" | "field"\n//	keyName:      "" when keyKind == "self"; capitalised struct field\n//	              name (e.g. "Price") otherwise\n//	compareType:  "numeric" | "string" | "auto"\n//	direction:    "asc" | "desc"\n//\n// The groups cover the accepted comparator catalogue: `a.f - b.f`,\n// `a - b`, `a[.f].localeCompare(b[.f])`, and relational-ternary keys\n// (`a.f > b.f ? 1 : -1` \u2192 "auto"), each `||`-chainable for multi-key\n// tie-breaks. Anything outside refuses at compile time (BF101 from the\n// JSX compiler) and never reaches this helper.\n//\n// "auto" compares numerically when both projected keys parse as\n// numbers, else lexically \u2014 mirroring the Perl `bf->sort` helper\'s\n// `looks_like_number` rule so the two template adapters stay\n// byte-equal. This diverges from JS `<`/`>` only for numeric strings.\n//\n// A future `nulls` knob can extend the per-key group without rewriting\n// existing call sites \u2014 each key already projects before comparing.\nfunc Sort(items any, spec ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return []any{}\n	}\n\n	// Copy into a fresh []any so the sort is non-mutating regardless\n	// of whether the receiver is `[]T` or `[]any`.\n	result := make([]any, length)\n	for i := 0; i < length; i++ {\n		result[i] = v.Index(i).Interface()\n	}\n\n	keys := parseSortSpec(spec)\n	sort.SliceStable(result, func(i, j int) bool {\n		for _, k := range keys {\n			ki := projectSortKey(result[i], k.kind, k.name)\n			kj := projectSortKey(result[j], k.kind, k.name)\n			c := compareSortKey(ki, kj, k.compareType)\n			if c == 0 {\n				continue // tie on this key \u2014 fall through to the next\n			}\n			if k.direction == "desc" {\n				return c > 0\n			}\n			return c < 0\n		}\n		return false\n	})\n\n	return result\n}\n\n// parseSortSpec chunks the variadic operand list into 4-string key\n// groups. A trailing partial group (malformed emit) is ignored rather\n// than panicking \u2014 defensive, mirroring the helper\'s nil-safe stance.\nfunc parseSortSpec(spec []string) []sortKeySpec {\n	var keys []sortKeySpec\n	for i := 0; i+3 < len(spec); i += 4 {\n		keys = append(keys, sortKeySpec{\n			kind:        spec[i],\n			name:        spec[i+1],\n			compareType: spec[i+2],\n			direction:   spec[i+3],\n		})\n	}\n	return keys\n}\n\n// compareSortKey returns -1 / 0 / 1 for two projected keys under the\n// given compare type (ascending orientation; the caller flips for\n// "desc"). "string" stringifies both (nil \u2192 "", matching the\n// documented `bf->string(undef) === ""` divergence). "auto" compares\n// numerically when both parse as numbers, else lexically.\nfunc compareSortKey(ki, kj any, compareType string) int {\n	switch compareType {\n	case "string":\n		return strings.Compare(toString(ki), toString(kj))\n	case "auto":\n		ni, okI := toFloat64WithOK(ki)\n		nj, okJ := toFloat64WithOK(kj)\n		if okI && okJ {\n			return cmpFloat(ni, nj)\n		}\n		return strings.Compare(toString(ki), toString(kj))\n	default: // numeric\n		return cmpFloat(toFloat64(ki), toFloat64(kj))\n	}\n}\n\nfunc cmpFloat(a, b float64) int {\n	if a < b {\n		return -1\n	}\n	if a > b {\n		return 1\n	}\n	return 0\n}\n\n// toFloat64WithOK reports a value\'s numeric float and whether it is\n// number-like. Genuine numeric kinds always qualify; strings qualify\n// when they parse as a float (so the "auto" compare path matches the\n// Perl `looks_like_number` rule). Everything else is non-numeric.\nfunc toFloat64WithOK(v any) (float64, bool) {\n	switch n := v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:\n		return toFloat64(v), true\n	case string:\n		f, err := strconv.ParseFloat(strings.TrimSpace(n), 64)\n		if err != nil {\n			return 0, false\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// projectSortKey reduces an item to the value the comparator\n// actually compares. For `keyKind == "field"` it reads the named\n// struct field; for `keyKind == "self"` (primitive arrays) it\n// returns the item unchanged.\nfunc projectSortKey(item any, keyKind, keyName string) any {\n	if keyKind == "field" {\n		return getFieldValue(item, keyName)\n	}\n	return item\n}\n\n// getFieldValue extracts a struct field value using reflection. For\n// map receivers it falls back to case-variant lookup so JSON-decoded\n// user data (`map[string]any{"price": 30}`) and PascalCase-emitted\n// test data both resolve under a single key name. (#1487)\nfunc getFieldValue(item any, field string) any {\n	v := reflect.ValueOf(item)\n	// Defensive IsNil guards mirror `SpreadAttrs` \u2014 keeps the helper\n	// safe against typed-nil pointer / nil-interface items inside a\n	// `[]any` so a single bad row doesn\'t crash the whole sort.\n	if v.Kind() == reflect.Interface {\n		if v.IsNil() {\n			return nil\n		}\n		v = v.Elem()\n	}\n	if v.Kind() == reflect.Ptr {\n		if v.IsNil() {\n			return nil\n		}\n		v = v.Elem()\n	}\n\n	if v.Kind() == reflect.Map {\n		keyType := v.Type().Key()\n		if keyType.Kind() != reflect.String {\n			return nil\n		}\n		// Convert the lookup string to the map\'s actual key type so\n		// maps keyed by a named string type (`type Key string`) don\'t\n		// panic with `value of type string is not assignable to type X`.\n		lookup := func(s string) (any, bool) {\n			k := reflect.ValueOf(s).Convert(keyType)\n			if mv := v.MapIndex(k); mv.IsValid() {\n				return mv.Interface(), true\n			}\n			return nil, false\n		}\n		if r, ok := lookup(field); ok {\n			return r\n		}\n		if cap := capitalize(field); cap != field {\n			if r, ok := lookup(cap); ok {\n				return r\n			}\n		}\n		if low := decapitalize(field); low != field {\n			if r, ok := lookup(low); ok {\n				return r\n			}\n		}\n		// All-lowercase fallback: a Go-initialism field projects as an\n		// all-caps key (`id` \u2192 `ID`), and `decapitalize("ID")` only\n		// lowers the first char (`iD`), so the JS-keyed map ("id") still\n		// misses. Try the fully-lowered key last to resolve it.\n		if lower := strings.ToLower(field); lower != field && lower != decapitalize(field) {\n			if r, ok := lookup(lower); ok {\n				return r\n			}\n		}\n		return nil\n	}\n\n	if v.Kind() != reflect.Struct {\n		return nil\n	}\n\n	fieldVal := v.FieldByName(field)\n	if !fieldVal.IsValid() {\n		// Case-variant fallback: the evaluator carries the JS field name\n		// (`id` / `url`) against a Go-capitalised struct field (`ID` / `URL`),\n		// which exact `FieldByName` misses and the initialism rules can\'t be\n		// reproduced char-for-char here. Match case-insensitively instead \u2014\n		// `FieldByNameFunc` returns the zero Value (\u2192 nil) for an ambiguous\n		// match, so it stays safe. The legacy bf_sort/bf_reduce pass an\n		// already-capitalised name, so they hit the exact match above and never\n		// reach this fallback.\n		fieldVal = v.FieldByNameFunc(func(n string) bool { return strings.EqualFold(n, field) })\n		if !fieldVal.IsValid() {\n			return nil\n		}\n	}\n	return fieldVal.Interface()\n}\n\n// AsMap normalizes a dynamically-typed prop value into a\n// map[string]interface{} for object-valued context bindings\n// (`lowerProviderMapMemberValue`, go-template-adapter.ts). A caller-side\n// `interface{}` field can legally hold ANY string-keyed map kind \u2014 a Go\n// handler modelling `Record<string, string>` naturally passes\n// map[string]string \u2014 so a bare `.(map[string]interface{})` type assertion\n// would silently drop provided values (#2111 review). Returns nil (never an\n// empty map) when the value is absent \u2014 nil interface, typed-nil map or\n// pointer, or any non-map / non-string-keyed value \u2014 so the generated\n// `?? {}` fallback can distinguish "missing" (fall back) from "present but\n// empty" (use as-is). map[string]interface{} passes through without copying.\nfunc AsMap(v any) map[string]interface{} {\n	if v == nil {\n		return nil\n	}\n	if m, ok := v.(map[string]interface{}); ok {\n		if m == nil {\n			return nil\n		}\n		return m\n	}\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		if rv.IsNil() {\n			return nil\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map || rv.Type().Key().Kind() != reflect.String || rv.IsNil() {\n		return nil\n	}\n	out := make(map[string]interface{}, rv.Len())\n	iter := rv.MapRange()\n	for iter.Next() {\n		out[iter.Key().String()] = iter.Value().Interface()\n	}\n	return out\n}\n\n// capitalize uppercases the first character of a string.\nfunc capitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToUpper(s[:1]) + s[1:]\n}\n\n// decapitalize lowercases the first character of a string. Used by\n// `getFieldValue`\'s map-receiver fallback when the projected key\n// name is PascalCase but the receiver carries lowercase JS-style\n// keys (the inverse of the `capitalize` lookup).\nfunc decapitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToLower(s[:1]) + s[1:]\n}\n\n// Reduce folds an array into a scalar via the arithmetic-fold\n// catalogue (#1448 Tier C). It lowers `Array.prototype.reduce(fn, init)`\n// and `Array.prototype.reduceRight(fn, init)` for the shapes\n// `(acc, x) => acc <op> x` and `(acc, x) => acc <op> x.field`:\n//\n//	bf_reduce <items> "<op>" "<keyKind>" "<keyName>" "<type>" "<init>" "<direction>"\n//\n//	direction: "left" (reduce) | "right" (reduceRight). Only changes the\n//	           result for string concatenation; numeric folds commute.\n//\n//	op:       "+" | "*"\n//	keyKind:  "self" | "field"\n//	keyName:  "" when keyKind == "self"; capitalised struct field name\n//	          (e.g. "Duration") otherwise\n//	type:     "numeric" | "string"\n//	init:     the fold\'s start value \u2014 the compiler emits the *decoded*\n//	          seed, so numeric inits arrive as canonical decimal\n//	          (`1_000`/`0x10` already normalised to `1000`/`16`) that\n//	          ParseFloat accepts, and string inits arrive as escape-free\n//	          contents\n//\n// Numeric folds accumulate as float64; each projected key is read via\n// `toFloat64WithOK`, so numeric *strings* ("5" \u2192 5) parse and\n// non-numeric values fold as 0 \u2014 matching Perl\'s\n// `looks_like_number ? $n : 0` so the two template adapters stay\n// byte-equal. String folds concatenate (toString per projected key,\n// matching the documented `bf->string(undef) === ""` convention). The\n// init seeds the accumulator, so an empty receiver returns the init\n// unchanged \u2014 exactly like JS `reduce(fn, init)`. Anything outside the\n// catalogue refuses at compile time (BF101 from the JSX compiler) and\n// never reaches here.\n//\n// Two documented divergences from the JS / Hono path, both rare and\n// mirroring the `bf_sort` "auto" caveat:\n//   - float64 stringification differs for sums whose binary expansion\n//     isn\'t exact (e.g. 0.1 + 0.2);\n//   - numeric-*string* keys fold numerically here, but JS `+`\n//     string-concatenates once an operand is a string, so\n//     numeric-string data can render differently under CSR.\n//\n// Genuine numbers \u2014 the common SSR case \u2014 agree across all three.\nfunc Reduce(items any, op, keyKind, keyName, typ, init, direction string) any {\n	v := reflect.ValueOf(items)\n	isSlice := v.Kind() == reflect.Slice || v.Kind() == reflect.Array\n\n	// `direction == "right"` (reduceRight) folds right-to-left. Only\n	// observable for string concatenation \u2014 numeric sum / product are\n	// commutative, so the order doesn\'t change the result there. Build a\n	// start/stop/step triple so both folds share one loop shape.\n	start, stop, step := 0, 0, 1\n	if isSlice {\n		stop = v.Len()\n		if direction == "right" {\n			start, stop, step = v.Len()-1, -1, -1\n		}\n	}\n\n	if typ == "string" {\n		acc := init\n		if isSlice {\n			for i := start; i != stop; i += step {\n				key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n				acc += toString(key)\n			}\n		}\n		return acc\n	}\n\n	// numeric fold\n	acc, _ := strconv.ParseFloat(strings.TrimSpace(init), 64)\n	if isSlice {\n		for i := start; i != stop; i += step {\n			key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n			// `toFloat64WithOK` parses numeric *strings* ("5" \u2192 5) and\n			// returns 0 for non-numeric values \u2014 mirroring Perl\'s\n			// `looks_like_number ? $n : 0` so numeric-string data folds\n			// byte-equal across adapters (the same rule `bf_sort`\'s\n			// "auto" compare uses). Plain `toFloat64` would zero "5".\n			n, _ := toFloat64WithOK(key)\n			if op == "*" {\n				acc *= n\n			} else {\n				acc += n\n			}\n		}\n	}\n	return acc\n}\n\n// =============================================================================\n// HTML/Template Helpers\n// =============================================================================\n\n// Comment returns an HTML comment string for hydration markers.\n// The "bf-" prefix is automatically added.\nfunc Comment(content string) template.HTML {\n	return template.HTML("<!--bf-" + content + "-->")\n}\n\n// TextStart returns an HTML comment start marker for reactive text expressions.\n// Format: <!--bf:slotId-->\nfunc TextStart(slotId string) template.HTML {\n	return template.HTML("<!--bf:" + slotId + "-->")\n}\n\n// TextEnd returns an HTML comment end marker for reactive text expressions.\n// Format: <!--/-->\nfunc TextEnd() template.HTML {\n	return "<!--/-->"\n}\n\n// ScopeComment emits a fragment-rooted scope marker. See spec/compiler.md\n// "Slot identity" for the wire format. Loud-fails on marshal errors\n// (same policy as JSON / BfPropsAttr).\nfunc ScopeComment(props interface{}) (template.HTML, error) {\n	scopeID := getStringField(props, "ScopeID")\n	hostSegment := ""\n	if host := getStringField(props, "BfParent"); host != "" {\n		mount := getStringField(props, "BfMount")\n		hostSegment = "|h=" + host + "|m=" + mount\n	}\n	propsJSON := ""\n	if getBoolField(props, "BfIsRoot") {\n		pJSON, err := json.Marshal(props)\n		if err != nil {\n			return "", err\n		}\n		propsJSON = "|" + string(pJSON)\n	}\n	return template.HTML("<!--bf-scope:" + scopeID + hostSegment + propsJSON + "-->"), nil\n}\n\n// TemplateFuncMap returns the helpers that need access to the executing\n// template set itself, closed over the *template.Template the component\n// defines are parsed into. Register it alongside FuncMap BEFORE parsing:\n//\n//	t := template.New("")\n//	t.Funcs(bf.FuncMap()).Funcs(bf.TemplateFuncMap(t))\n//	template.Must(t.Parse(src))\n//\n// bf_tmpl executes a named define from the same set and returns its\n// output \u2014 used for the per-call-site children defines the Go adapter\n// emits when JSX children passed to an imported component contain\n// template actions (nested components, dynamic text) and therefore\n// cannot be baked to a static HTML string (#1896). Reentrant execution\n// of an html/template set from inside a FuncMap function is safe: the\n// escape analysis over every define completes before the outer\n// Execute begins evaluating.\nfunc TemplateFuncMap(t *template.Template) template.FuncMap {\n	return template.FuncMap{\n		"bf_tmpl": func(name string, data interface{}) (template.HTML, error) {\n			var buf bytes.Buffer\n			if err := t.ExecuteTemplate(&buf, name, data); err != nil {\n				return "", err\n			}\n			return template.HTML(buf.String()), nil\n		},\n	}\n}\n\n// WithChildren returns a shallow copy of a component Props struct with its\n// Children field replaced by the given pre-rendered fragment (#1896). The\n// props value stays by-value semantics: callers\' originals are untouched.\n// A props type without a Children field passes through unchanged \u2014 the\n// child template then simply has no children to render, matching the\n// pre-#1896 behaviour.\nfunc WithChildren(props interface{}, children template.HTML) (interface{}, error) {\n	v := reflect.ValueOf(props)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return props, nil\n	}\n	field := v.FieldByName("Children")\n	if !field.IsValid() {\n		return props, nil\n	}\n	copyPtr := reflect.New(v.Type())\n	copyPtr.Elem().Set(v)\n	target := copyPtr.Elem().FieldByName("Children")\n	switch {\n	case target.Kind() == reflect.Interface:\n		target.Set(reflect.ValueOf(children))\n	case target.Kind() == reflect.String:\n		// Covers both `string` and `template.HTML`-typed fields.\n		target.SetString(string(children))\n	default:\n		return props, fmt.Errorf("bf_with_children: unsupported Children field type %s", target.Type())\n	}\n	return copyPtr.Elem().Interface(), nil\n}\n\n// PortalHTML parses and executes a template string with the provided data.\n// Used for rendering dynamic portal content where the template string\n// contains Go template expressions (e.g., {{if .Open}}open{{end}}).\n//\n// The template string is parsed fresh each time to support dynamic content.\n// Standard Go template functions (if, range, eq, etc.) are available.\nfunc PortalHTML(data interface{}, tmplStr string) template.HTML {\n	// Create a new template with the FuncMap for custom functions\n	t, err := template.New("portal").Funcs(FuncMap()).Parse(tmplStr)\n	if err != nil {\n		// Return error message as HTML comment for debugging\n		return template.HTML("<!-- bfPortalHTML error: " + err.Error() + " -->")\n	}\n\n	var buf bytes.Buffer\n	if err := t.Execute(&buf, data); err != nil {\n		return template.HTML("<!-- bfPortalHTML exec error: " + err.Error() + " -->")\n	}\n\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Portal Collection\n// =============================================================================\n\n// PortalContent represents a single portal\'s content to be rendered at body end.\ntype PortalContent struct {\n	ID      string        // Unique portal ID for hydration matching\n	OwnerID string        // Owner scope ID for find() support\n	Content template.HTML // Portal HTML content\n}\n\n// PortalCollector collects portal content during template rendering.\n// Portal content is rendered at </body> to avoid z-index issues.\ntype PortalCollector struct {\n	portals []PortalContent\n	counter int\n}\n\n// NewPortalCollector creates a new PortalCollector.\nfunc NewPortalCollector() *PortalCollector {\n	return &PortalCollector{\n		portals: []PortalContent{},\n		counter: 0,\n	}\n}\n\n// Add registers portal content to be rendered at body end.\nfunc (pc *PortalCollector) Add(ownerID string, content template.HTML) string {\n	pc.counter++\n	id := "bf-portal-" + strconv.Itoa(pc.counter)\n	pc.portals = append(pc.portals, PortalContent{\n		ID:      id,\n		OwnerID: ownerID,\n		Content: content,\n	})\n	return "" // Return empty string for template use\n}\n\n// Render outputs all collected portals as HTML.\n// Each portal is wrapped in a div with bf-pi (portal ID) and bf-po (portal owner).\nfunc (pc *PortalCollector) Render() template.HTML {\n	if pc == nil || len(pc.portals) == 0 {\n		return ""\n	}\n	var buf strings.Builder\n	for _, p := range pc.portals {\n		buf.WriteString(`<div bf-pi="`)\n		buf.WriteString(p.ID)\n		buf.WriteString(`" bf-po="`)\n		buf.WriteString(p.OwnerID)\n		buf.WriteString(`">`)\n		buf.WriteString(string(p.Content))\n		buf.WriteString("</div>\\n")\n	}\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Script Collection\n// =============================================================================\n\n// ScriptCollector collects client scripts with deduplication.\n// It preserves insertion order for deterministic output.\ntype ScriptCollector struct {\n	scripts map[string]bool\n	order   []string\n}\n\n// NewScriptCollector creates a new ScriptCollector.\nfunc NewScriptCollector() *ScriptCollector {\n	return &ScriptCollector{\n		scripts: make(map[string]bool),\n		order:   []string{},\n	}\n}\n\n// Register adds a script source to the collection.\n// Duplicate scripts are ignored (only first registration counts).\nfunc (sc *ScriptCollector) Register(src string) string {\n	if sc.scripts[src] {\n		return "" // Already registered\n	}\n	sc.scripts[src] = true\n	sc.order = append(sc.order, src)\n	return "" // Return empty string for template use\n}\n\n// Scripts returns all registered scripts in insertion order.\nfunc (sc *ScriptCollector) Scripts() []string {\n	return sc.order\n}\n\n// BfScripts generates script tags for all registered scripts.\n// Returns HTML safe for embedding in templates.\nfunc BfScripts(collector *ScriptCollector) template.HTML {\n	if collector == nil {\n		return ""\n	}\n	var result strings.Builder\n	for _, src := range collector.Scripts() {\n		result.WriteString(`<script type="module" src="`)\n		result.WriteString(src)\n		result.WriteString(`"></script>`)\n		result.WriteString("\\n")\n	}\n	return template.HTML(result.String())\n}\n\n// =============================================================================\n// Component Renderer\n// =============================================================================\n\n// RenderContext contains all data needed to render a component page.\n// The layout function receives this context to build the final HTML.\ntype RenderContext struct {\n	// ComponentName is the template name being rendered\n	ComponentName string\n\n	// Props is the component props (for layout to access if needed)\n	Props interface{}\n\n	// ComponentHTML is the rendered component template output\n	ComponentHTML template.HTML\n\n	// Portals contains collected portal content to render at body end\n	Portals template.HTML\n\n	// Scripts contains the collected JS script tags\n	Scripts template.HTML\n\n	// Title is the page title (defaults to "{ComponentName} - BarefootJS")\n	Title string\n\n	// Heading is the page heading. Empty string means no heading.\n	Heading string\n\n	// Extra holds additional user-defined data for the layout\n	Extra map[string]interface{}\n}\n\n// LayoutFunc renders the final HTML page given the render context.\ntype LayoutFunc func(ctx *RenderContext) string\n\n// Renderer renders BarefootJS components with a customizable layout.\ntype Renderer struct {\n	templates *template.Template\n	layout    LayoutFunc\n}\n\n// NewRenderer creates a Renderer with the given templates and layout function.\n//\n// Example usage:\n//\n//	renderer := bf.NewRenderer(templates, func(ctx *bf.RenderContext) string {\n//	    return fmt.Sprintf(`<!DOCTYPE html>\n//	<html>\n//	<head><title>%s</title></head>\n//	<body>%s%s</body>\n//	</html>`, ctx.Title, ctx.ComponentHTML, ctx.Scripts)\n//	})\nfunc NewRenderer(tmpl *template.Template, layout LayoutFunc) *Renderer {\n	return &Renderer{\n		templates: tmpl,\n		layout:    layout,\n	}\n}\n\n// RenderOptions configures a single render call.\ntype RenderOptions struct {\n	// ComponentName is the template name to render (required)\n	ComponentName string\n\n	// Props is the component props (must be a pointer to struct with Scripts field)\n	Props interface{}\n\n	// Title is the page title. If empty, defaults to "{ComponentName} - BarefootJS"\n	Title string\n\n	// Heading is the page heading. If empty, no heading is shown.\n	Heading string\n\n	// Extra holds additional data to pass to the layout\n	Extra map[string]interface{}\n}\n\n// Render renders a component to a full HTML page using the configured layout.\n// Child component props are automatically detected (any slice field with ScopeID/Scripts).\n// renderTemplateErrorPanel formats a Go template execution error into a\n// fragment of HTML that\'s visible in the browser. The panel is\n// HTML-escaped so a faulty template name (anything from `template:\n// "..."`) can\'t smuggle markup back into the page. Keep the styling\n// inline so the panel surfaces even when the project\'s CSS hasn\'t\n// loaded yet (e.g. the failure aborted before the stylesheet links\n// emitted).\n//\n// Surfaced for the #1442 echo repro: a template referencing\n// `.Todo.Done` (instead of the range dot\'s `.Done`) used to fail\n// silently \u2014 Go\'s html/template aborted mid-stream, the partial body\n// flushed as a 200, and the user saw a truncated list with no console\n// signal. With this panel they get the template name, the error\n// message, and a "what to look at" hint inline.\nfunc renderTemplateErrorPanel(componentName string, err error) string {\n	return `<div style="margin:1em 0;padding:1em;border:2px solid #d33;background:#fff5f5;color:#900;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:13px;line-height:1.5"><strong style="display:block;margin-bottom:.5em">Template error in <code>` +\n		template.HTMLEscapeString(componentName) +\n		`</code></strong><pre style="margin:0;white-space:pre-wrap;word-break:break-word">` +\n		template.HTMLEscapeString(err.Error()) +\n		`</pre><div style="margin-top:.75em;font-size:12px;opacity:.7">Common cause: a JSX expression referenced a name the adapter could not resolve to a struct field. Open the matching <code>dist/templates/*.tmpl</code> for the unresolved reference, then fix the source component.</div></div>`\n}\n\n// renderComponentInto wires a component\'s props (script/portal collectors,\n// child-slot scope ids + hydration, root marking) against the PROVIDED\n// collectors and returns just the component\'s HTML \u2014 no layout. Both Render\n// (one fresh collector pair per page) and RenderFragment (a shared pair across\n// several islands) funnel through here so their wiring stays identical.\nfunc (r *Renderer) renderComponentInto(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	// Inject the shared collectors into the props.\n	setScriptsField(opts.Props, scriptCollector)\n	setPortalsField(opts.Props, portalCollector)\n\n	// Auto-detect and process child component props (slices)\n	childSlices := findChildComponentSlices(opts.Props)\n	for _, slice := range childSlices {\n		setScopeIDsOnSlice(slice)\n		setScriptsOnSlice(slice, scriptCollector)\n		setPortalsOnSlice(slice, portalCollector)\n		setBoolOnSlice(slice, "BfIsChild", true)\n	}\n\n	// Auto-detect and process single child component props\n	singleChildren := findSingleChildComponents(opts.Props)\n	for _, child := range singleChildren {\n		setScopeIDOnSingle(child)\n		setScriptsOnSingle(child, scriptCollector)\n		setPortalsOnSingle(child, portalCollector)\n		setBoolField(child, "BfIsChild", true)\n	}\n\n	// Mark the root component so BfPropsAttr emits bf-p only for it\n	setBoolField(opts.Props, "BfIsRoot", true)\n\n	// Render the component template.\n	//\n	// Errors here are NOT silently dropped. The original implementation\n	// ignored the return value of `ExecuteTemplate`, which masked a real\n	// onboarding failure mode: a template referencing a non-existent\n	// field (`.Todo.Done` instead of the range dot\'s `.Done`) caused\n	// html/template to abort mid-stream, the partial output got\n	// returned, and the HTTP server happily flushed a 200 with a\n	// truncated body. No error log, no signal \u2014 the user just saw a\n	// blank list (#1442 echo TodoApp repro).\n	//\n	// Now we capture the error and replace the partial output with a\n	// visible inline panel (dev mode) or a fenced error comment\n	// (production), so the cause is on-screen and grep-able in logs.\n	// Either way the renderer also writes to stderr so structured log\n	// aggregators see it.\n	var componentBuf strings.Builder\n	if err := r.templates.ExecuteTemplate(&componentBuf, opts.ComponentName, opts.Props); err != nil {\n		fmt.Fprintf(os.Stderr, "barefoot: template %q failed to render: %v\\n", opts.ComponentName, err)\n		// Preserve whatever the template did manage to emit before\n		// failing (Go\'s text/template flushes incrementally), but\n		// follow it with a clearly-marked error block so the user\n		// notices something is wrong instead of seeing a silent\n		// truncation.\n		componentBuf.WriteString(renderTemplateErrorPanel(opts.ComponentName, err))\n	}\n\n	return template.HTML(componentBuf.String())\n}\n\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// One script + portal collector pair for the whole page.\n	scriptCollector := NewScriptCollector()\n	portalCollector := NewPortalCollector()\n\n	componentHTML := r.renderComponentInto(opts, scriptCollector, portalCollector)\n\n	// Determine title (default: "{ComponentName} - BarefootJS")\n	title := opts.Title\n	if title == "" {\n		title = opts.ComponentName + " - BarefootJS"\n	}\n\n	// Heading (empty means no heading)\n	heading := opts.Heading\n\n	// Build render context\n	ctx := &RenderContext{\n		ComponentName: opts.ComponentName,\n		Props:         opts.Props,\n		ComponentHTML: componentHTML,\n		Portals:       portalCollector.Render(),\n		Scripts:       BfScripts(scriptCollector),\n		Title:         title,\n		Heading:       heading,\n		Extra:         opts.Extra,\n	}\n\n	return r.layout(ctx)\n}\n\n// RenderFragment renders a single island subtree into the caller-provided\n// script and portal collectors and returns just its HTML \u2014 no page layout.\n//\n// It exists for hand-authored "region shell" pages (the `@barefootjs/router`\n// showcase): a layout that places several independent islands \u2014 e.g. a header\n// ThemeToggle, an `<aside bf-region>` Sidebar, and a `<PageShell>` wrapping the\n// route content \u2014 must collect ALL their scripts and portals into ONE place so\n// the runtime (`barefoot.js`) and each island\'s client JS are emitted exactly\n// once and share a single reactive instance. Render each island with the same\n// collectors, splice the returned HTML into the shell, then emit\n// `BfScripts(sc)` and `pc.Render()` once at the end of the document.\n//\n// Each fragment is treated as its own root (it emits `bf-p` like any top-level\n// island); nested children declared in its props are wired as children, exactly\n// as in Render.\nfunc (r *Renderer) RenderFragment(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	return r.renderComponentInto(opts, scriptCollector, portalCollector)\n}\n\n// setScriptsField sets the Scripts field on a struct using reflection.\nfunc setScriptsField(v interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Scripts")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// setPortalsField sets the Portals field on a struct using reflection.\nfunc setPortalsField(v interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Portals")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// getStringField extracts a string field from a struct using reflection.\nfunc setBoolField(v interface{}, fieldName string, val bool) {\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Struct {\n		return\n	}\n	field := rv.FieldByName(fieldName)\n	if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n		field.SetBool(val)\n	}\n}\n\nfunc getBoolField(v interface{}, fieldName string) bool {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return false\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.Bool {\n		return false\n	}\n	return field.Bool()\n}\n\nfunc getStringField(v interface{}, fieldName string) string {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return ""\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.String {\n		return ""\n	}\n	return field.String()\n}\n\n// scopeIDChars is the alphabet for auto-generated ScopeID suffixes. It\n// mirrors the `randomID` helper the go-template adapter emits into the\n// generated New<Component>Props constructors so runtime-assigned and\n// constructor-assigned ids are indistinguishable.\nconst scopeIDChars = "abcdefghijklmnopqrstuvwxyz0123456789"\n\n// randomScopeSuffix returns a random lowercase-alphanumeric string of\n// length n. math/rand (auto-seeded since Go 1.20) is sufficient here: the\n// suffix only needs to be unique enough to keep a page\'s bf-s scope ids\n// from colliding, not cryptographically unpredictable.\nfunc randomScopeSuffix(n int) string {\n	b := make([]byte, n)\n	for i := range b {\n		b[i] = scopeIDChars[rand.Intn(len(scopeIDChars))]\n	}\n	return string(b)\n}\n\n// scopeIDPrefix derives the human-readable ScopeID prefix from a child\n// component\'s type, e.g. `TodoItemProps` \u2192 `TodoItem`. Matches the\n// `"<Component>_" + randomID(6)` shape the generated constructors use.\nfunc scopeIDPrefix(t reflect.Type) string {\n	for t.Kind() == reflect.Ptr {\n		t = t.Elem()\n	}\n	return strings.TrimSuffix(t.Name(), "Props")\n}\n\n// assignScopeID fills a child component\'s ScopeID with a generated id when\n// the caller left it empty, so application code doesn\'t have to mint scope\n// ids by hand (the parent\'s New<Component>Props constructor does the same\n// for components built through it). A non-empty ScopeID is left untouched,\n// so callers can still pin a stable id when they need one.\nfunc assignScopeID(structVal reflect.Value, prefix string) {\n	field := structVal.FieldByName("ScopeID")\n	if !field.IsValid() || !field.CanSet() || field.Kind() != reflect.String {\n		return\n	}\n	if field.String() != "" {\n		return\n	}\n	id := randomScopeSuffix(6)\n	if prefix != "" {\n		id = prefix + "_" + id\n	}\n	field.SetString(id)\n}\n\n// setScopeIDsOnSlice assigns a generated ScopeID to every child in a slice\n// whose ScopeID is empty.\nfunc setScopeIDsOnSlice(slice interface{}) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	prefix := scopeIDPrefix(v.Type().Elem())\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			assignScopeID(item, prefix)\n		}\n	}\n}\n\n// setScopeIDOnSingle assigns a generated ScopeID to a single child\n// component when its ScopeID is empty.\nfunc setScopeIDOnSingle(child interface{}) {\n	v := reflect.ValueOf(child)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return\n	}\n	assignScopeID(v, scopeIDPrefix(v.Type()))\n}\n\n// findChildComponentSlices finds slice fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findChildComponentSlices(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n		if field.Kind() != reflect.Slice || field.Len() == 0 {\n			continue\n		}\n\n		elem := field.Index(0)\n		if elem.Kind() == reflect.Ptr {\n			elem = elem.Elem()\n		}\n		if elem.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := elem.FieldByName("ScopeID").IsValid()\n		hasScripts := elem.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSlice sets Scripts on all items in a slice.\nfunc setScriptsOnSlice(slice interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Scripts")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// setBoolOnSlice sets a bool field on all items in a slice.\nfunc setBoolOnSlice(slice interface{}, fieldName string, val bool) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName(fieldName)\n			if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n				field.SetBool(val)\n			}\n		}\n	}\n}\n\n// setPortalsOnSlice sets Portals on all items in a slice.\nfunc setPortalsOnSlice(slice interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Portals")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		return ""\n	}\n}\n\n// =============================================================================\n// searchParams() \u2014 request-scoped environment signal (router v0.5, #1922)\n// =============================================================================\n\n// SearchParams is the SSR view of the request query string behind the\n// reactive searchParams() environment signal. The route handler builds it\n// from the request URL and assigns it to the component\'s SearchParams input\n// field; the generated template reads it via `.SearchParams.Get "key"`.\n//\n// The zero value is an empty query (url.Values.Get tolerates a nil map), so a\n// render with no request query \u2014 e.g. the adapter conformance harness, which\n// issues no query string \u2014 resolves every key to "", which the template\'s\n// `or`/`??` fallback turns into the author\'s default.\ntype SearchParams struct {\n	values url.Values\n}\n\n// NewSearchParams parses a raw query string (with or without a leading "?")\n// into a SearchParams. A malformed query yields an empty set rather than an\n// error, mirroring the browser\'s URLSearchParams, which never throws on junk.\n//\n// Typical handler use (net/http):\n//\n//	in := MyComponentInput{SearchParams: bf.NewSearchParams(r.URL.RawQuery)}\nfunc NewSearchParams(raw string) SearchParams {\n	raw = strings.TrimPrefix(raw, "?")\n	values, err := url.ParseQuery(raw)\n	if err != nil {\n		values = url.Values{}\n	}\n	return SearchParams{values: values}\n}\n\n// Get returns the first value associated with key, or "" when the key is\n// absent. This mirrors url.Values.Get, which also returns "" for a\n// present-but-empty value (`?sort=`). Safe on the zero value (nil map).\n//\n// This is not byte-for-byte URLSearchParams.get under the template\'s `??`\n// lowering. JS distinguishes absent (`null`) from present-but-empty (`""`):\n// `null ?? d` yields the default, but `"" ?? d` keeps the empty string. The\n// Go adapter lowers `??` to the `or` builtin \u2014 Go templates have no\n// null-coalescing operator \u2014 so here BOTH an absent key and a present-but-\n// empty value fall back to the author\'s default. The conformance fixture only\n// exercises the absent-key default, where the two runtimes agree; the\n// empty-string divergence is the same general `?? \u2192 or` limitation that\n// applies to any `x ?? default` the Go adapter lowers.\nfunc (s SearchParams) Get(key string) string {\n	return s.values.Get(key)\n}\n';
-    evalGoSource = 'package bf\n\nimport (\n	"encoding/json"\n	"math"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode/utf8"\n)\n\n// =============================================================================\n// Lightweight ParsedExpr evaluator (issue #2018)\n// =============================================================================\n//\n// Templates cannot carry a lambda in expression position, which is why the\n// adapter historically special-cased higher-order callbacks (reduce / sort /\n// map / filter / find) into fixed shapes (bf_sort\'s comparator catalogue,\n// bf_reduce\'s +/* fold). This evaluator replaces that ad-hoc list: a callback\n// BODY is carried as a pure `ParsedExpr` subtree (the same structured IR the\n// compiler already produces) and evaluated here against an environment\n// (`{acc, item, \u2026captured free vars}`).\n//\n// Scope: higher-order callback bodies only. Ordinary expressions stay lowered\n// to template-native syntax \u2014 this is NOT a general expression engine.\n//\n// The accepted pure subset and its semantics (evaluation order, coercion,\n// equality, allowed operators / builtins) are documented in spec/compiler.md\n// ("ParsedExpr Evaluator Semantics") and pinned isomorphically by the golden\n// vectors in packages/adapter-tests/vectors/eval-vectors.json (shared\n// with the Perl evaluator). The coercion rules below are the literal JS rules\n// (ToNumber / ToString / ToBoolean) \u2014 deliberately NOT the divergent\n// bf->string / bf_reduce helper conventions \u2014 so the contract is unambiguous\n// and the backends stay byte-isomorphic.\n//\n// String semantics operate on Unicode code points / UTF-8 bytes: `.length`\n// counts code points and relational `<`/`>` compares byte order. This equals\n// the JS reference (UTF-16 code units) across the BMP \u2014 the range template\n// data uses \u2014 and matches the Perl evaluator exactly (the primary "same input\n// \u2192 same output" contract is between the two SSR backends). Astral-plane\n// characters (where JS counts a surrogate pair as length 2 and orders by\n// surrogate code units) are a documented divergence region, alongside the\n// already-documented non-ASCII relational / localeCompare carve-outs\n// (spec/compiler.md). Both backends stay equal; only the JS reference differs,\n// and no corpus vector exercises the astral range.\n\n// EvalExpr evaluates a pure ParsedExpr (carried as its JSON encoding) against\n// env. The result is a value in the JSON domain: a number (Go int or float64 \u2014\n// both are the single JS number type; e.g. `.length` returns int, arithmetic\n// returns float64), string, bool, nil, []any, or map[string]any. A malformed\n// tree yields nil.\nfunc EvalExpr(exprJSON string, env map[string]any) any {\n	var node any\n	if err := json.Unmarshal([]byte(exprJSON), &node); err != nil {\n		return nil\n	}\n	return EvalNode(node, env)\n}\n\n// EvalNode evaluates an already-decoded ParsedExpr node (a map[string]any with\n// a "kind" discriminator) against env. Exported so callers that already hold a\n// decoded tree (e.g. the golden-vector harness) skip a re-marshal.\nfunc EvalNode(node any, env map[string]any) any {\n	n, ok := node.(map[string]any)\n	if !ok {\n		return nil\n	}\n	kind, _ := n["kind"].(string)\n	switch kind {\n	case "literal":\n		return n["value"]\n\n	case "identifier":\n		name, _ := n["name"].(string)\n		return env[name]\n\n	case "binary":\n		op, _ := n["op"].(string)\n		return evalBinary(op, EvalNode(n["left"], env), EvalNode(n["right"], env))\n\n	case "unary":\n		op, _ := n["op"].(string)\n		return evalUnary(op, EvalNode(n["argument"], env))\n\n	case "logical":\n		op, _ := n["op"].(string)\n		left := EvalNode(n["left"], env)\n		switch op {\n		case "&&":\n			if !evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "||":\n			if evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "??":\n			if left == nil {\n				return EvalNode(n["right"], env)\n			}\n			return left\n		}\n		return nil\n\n	case "conditional":\n		if evalTruthy(EvalNode(n["test"], env)) {\n			return EvalNode(n["consequent"], env)\n		}\n		return EvalNode(n["alternate"], env)\n\n	case "member":\n		prop, _ := n["property"].(string)\n		return evalReadProperty(EvalNode(n["object"], env), prop)\n\n	case "index-access":\n		return evalReadIndex(EvalNode(n["object"], env), EvalNode(n["index"], env))\n\n	case "call":\n		// A nested `.map(cb)` / `.filter(cb)` callback call (#2094): syntactically\n		// a `call` whose callee is `<recv>.map`/`<recv>.filter` and whose first\n		// argument is an `arrow` \u2014 the SAME shape `asCallbackMethodCall`\n		// recognizes at compile time, and the shape the `eval-vectors.json`\n		// golden corpus itself carries (it stores the genuine `ParsedExpr`, not\n		// a bespoke wrapper). Checked BEFORE the builtin-callee gate below,\n		// since `<recv>.map` would otherwise resolve to a non-builtin member\n		// callee and refuse.\n		if method, objNode, arrowNode, ok := evalArrayCallbackCall(n); ok {\n			return evalArrayCallback(method, objNode, arrowNode, env)\n		}\n		name := evalBuiltinName(n["callee"])\n		if name == "" {\n			return nil\n		}\n		rawArgs, _ := n["args"].([]any)\n		args := make([]any, len(rawArgs))\n		for i, a := range rawArgs {\n			args[i] = EvalNode(a, env)\n		}\n		return evalCallBuiltin(name, args)\n\n	case "template-literal":\n		parts, _ := n["parts"].([]any)\n		var sb strings.Builder\n		for _, p := range parts {\n			pm, _ := p.(map[string]any)\n			if t, _ := pm["type"].(string); t == "string" {\n				s, _ := pm["value"].(string)\n				sb.WriteString(s)\n			} else {\n				sb.WriteString(evalToString(EvalNode(pm["expr"], env)))\n			}\n		}\n		return sb.String()\n\n	case "array-literal":\n		elems, _ := n["elements"].([]any)\n		out := make([]any, len(elems))\n		for i, e := range elems {\n			out[i] = EvalNode(e, env)\n		}\n		return out\n\n	case "object-literal":\n		props, _ := n["properties"].([]any)\n		out := make(map[string]any, len(props))\n		for _, p := range props {\n			pm, _ := p.(map[string]any)\n			key, _ := pm["key"].(string)\n			out[key] = EvalNode(pm["value"], env)\n		}\n		return out\n\n	case "array-method":\n		// `.includes(x)` / `.join(sep?)` are the `array-method` shapes the\n		// evaluator executes (the JS reference\'s `evaluate` "array-method" arm,\n		// eval-reference.ts). A nested `.map`/`.filter` is NOT an\n		// `array-method` node \u2014 it reaches the `call` case above (it carries\n		// an `arrow` callback, not a plain `args` list). Every other\n		// array/string method (`slice`, `flat`, \u2026) is refused upstream\n		// (BF101) and never reaches here.\n		method, _ := n["method"].(string)\n		rawArgs, _ := n["args"].([]any)\n		if method == "includes" && len(rawArgs) == 1 {\n			return evalIncludes(EvalNode(n["object"], env), EvalNode(rawArgs[0], env))\n		}\n		if method == "join" && len(rawArgs) <= 1 {\n			sep := ","\n			if len(rawArgs) == 1 {\n				sep = evalToString(EvalNode(rawArgs[0], env))\n			}\n			return evalJoin(EvalNode(n["object"], env), sep)\n		}\n		return nil\n	}\n	// arrow-fn / higher-order / unsupported: a callback body containing these\n	// is refused upstream (BF101); never reached here.\n	return nil\n}\n\n// evalArrayCallbackCall reports whether the decoded `call` node `n` is a\n// nested `.map(cb)` / `.filter(cb)` callback call (#2094): its callee is a\n// non-computed member `<recv>.map`/`<recv>.filter` and its first argument is\n// an `arrow` node. Returns the method name, the (still-encoded) receiver\n// object node, and the (still-encoded) arrow node.\nfunc evalArrayCallbackCall(n map[string]any) (method string, object any, arrow map[string]any, ok bool) {\n	callee, _ := n["callee"].(map[string]any)\n	if callee == nil || callee["kind"] != "member" {\n		return "", nil, nil, false\n	}\n	if computed, _ := callee["computed"].(bool); computed {\n		return "", nil, nil, false\n	}\n	prop, _ := callee["property"].(string)\n	if prop != "map" && prop != "filter" {\n		return "", nil, nil, false\n	}\n	rawArgs, _ := n["args"].([]any)\n	if len(rawArgs) == 0 {\n		return "", nil, nil, false\n	}\n	arrowNode, _ := rawArgs[0].(map[string]any)\n	if arrowNode == nil || arrowNode["kind"] != "arrow" {\n		return "", nil, nil, false\n	}\n	return prop, callee["object"], arrowNode, true\n}\n\n// evalArrayCallback executes a nested `.map`/`.filter` callback call: evaluates\n// the receiver, then evaluates the arrow body per element in a CHILD env that\n// binds the arrow\'s first param to the element and (when the arrow declares a\n// second param) the second to the integer index \u2014 both 1- and 2-param arrows\n// are supported. `map` keeps one result per element (order-preserving);\n// `filter` keeps the elements whose body evaluates truthy. A non-array\n// receiver degrades to nil (unreachable for a body the compiler validated,\n// since the receiver of a nested `.map`/`.filter` is itself gated upstream).\nfunc evalArrayCallback(method string, objectNode any, arrowNode map[string]any, env map[string]any) any {\n	arr := toAnySlice(EvalNode(objectNode, env))\n	if arr == nil {\n		return nil\n	}\n	rawParams, _ := arrowNode["params"].([]any)\n	params := make([]string, len(rawParams))\n	for i, p := range rawParams {\n		params[i], _ = p.(string)\n	}\n	body := arrowNode["body"]\n	callCb := func(item any, index int) any {\n		inner := make(map[string]any, len(env)+2)\n		for k, v := range env {\n			inner[k] = v\n		}\n		if len(params) > 0 {\n			inner[params[0]] = item\n		}\n		if len(params) > 1 {\n			inner[params[1]] = index\n		}\n		return EvalNode(body, inner)\n	}\n	if method == "map" {\n		out := make([]any, len(arr))\n		for i, item := range arr {\n			out[i] = callCb(item, i)\n		}\n		return out\n	}\n	out := []any{}\n	for i, item := range arr {\n		if evalTruthy(callCb(item, i)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// evalJoin implements `.join(sep)`: elements ToString\'d and joined; a\n// null/undefined element ToStrings to the empty string (matching JS\n// `Array.prototype.join`, which skips null/undefined rather than rendering\n// the literal string "null"/"undefined"). A non-array receiver degrades to\n// the empty string (unreachable for a validated body).\nfunc evalJoin(obj any, sep string) string {\n	arr := toAnySlice(obj)\n	if arr == nil {\n		return ""\n	}\n	parts := make([]string, len(arr))\n	for i, el := range arr {\n		if el == nil {\n			parts[i] = ""\n			continue\n		}\n		parts[i] = evalToString(el)\n	}\n	return strings.Join(parts, sep)\n}\n\n// ---------------------------------------------------------------------------\n// JS coercion primitives (ToNumber / ToString / ToBoolean), pinned so the\n// evaluator matches the JS reference. These are JS-faithful and intentionally\n// distinct from the bf->string / Number helpers, which diverge (null \u2192 "",\n// null/"" \u2192 NaN) for SSR-survival reasons that do not apply to the evaluator.\n// ---------------------------------------------------------------------------\n\nfunc evalToNumber(v any) float64 {\n	switch x := v.(type) {\n	case nil:\n		return 0\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		t := strings.TrimSpace(x)\n		if t == "" {\n			return 0\n		}\n		// Decimal / exponent / "Infinity" numeric strings parse JS-faithfully\n		// (ParseFloat handles these, matching the Perl evaluator). The\n		// radix-prefixed forms JS Number() also accepts ("0x10" / "0o17" /\n		// "0b101") are a documented divergence region: they yield NaN here, as\n		// they do in the Perl evaluator (looks_like_number is false for them),\n		// so Go==Perl while differing from the JS reference. Template data\n		// carries JSON numbers, not radix-string literals, so this never\n		// arises in practice.\n		f, err := strconv.ParseFloat(t, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	default:\n		if evalIsNumeric(v) {\n			return toFloat64(v)\n		}\n		return math.NaN()\n	}\n}\n\n// evalIsNumeric reports whether v is one of the Go numeric types (all of\n// which are the single JS "number" type to the evaluator).\nfunc evalIsNumeric(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:\n		return true\n	}\n	return false\n}\n\nfunc evalToString(v any) string {\n	if v == nil {\n		return "null"\n	}\n	// JS spells the non-finite doubles "Infinity" / "-Infinity" / "NaN"; the\n	// runtime String() helper (fmt %v) would render "+Inf" / "-Inf" / "NaN",\n	// so the non-finite cases are pinned here to stay JS-faithful (and match\n	// the Perl evaluator\'s _to_string). Strings, bools and nil are JS-faithful\n	// through String() (nil is already handled above as "null").\n	//\n	// Finite-number formatting is a documented divergence region. Go\'s fmt is\n	// shortest-round-trip (it matches JS\'s *digits*, e.g. 0.1+0.2 \u2192\n	// "0.30000000000000004"), but its exponent threshold/padding differ from\n	// JS Number::toString for very large / very small magnitudes (Go renders\n	// 1e6 as "1e+06" where JS keeps "1000000", and "1e-07" vs JS "1e-7").\n	// Perl\'s `%.15g` instead diverges on *precision* (the pinned helper-vector\n	// "0.3" case). A fully JS-faithful Number::toString is not reimplemented\n	// here because Perl has no shortest-round-trip formatter, so the three\n	// could never all agree; the common integer / short-decimal range \u2014 what\n	// arithmetic over template data produces \u2014 renders identically across all\n	// three. Only the \xB10 sign is normalised below, since it is cheap and the\n	// realisticly-reachable case.\n	if f, ok := v.(float64); ok {\n		if math.IsNaN(f) {\n			return "NaN"\n		}\n		if math.IsInf(f, 1) {\n			return "Infinity"\n		}\n		if math.IsInf(f, -1) {\n			return "-Infinity"\n		}\n		// JS `String(-0)` is "0", but fmt %v renders Go\'s negative zero as\n		// "-0". `f == 0` matches both \xB10, normalising to JS\'s spelling. (A\n		// unary `-` on a zero operand is the way the evaluator can produce -0.)\n		if f == 0 {\n			return "0"\n		}\n	}\n	// Non-primitive operands (arrays / objects) in ToString position are\n	// outside the evaluator subset \u2014 the JS reference refuses them, and the\n	// compiler gates such a callback body with BF101 before it ever reaches\n	// the runtime. This evaluator runs already-validated bodies, so it does\n	// not re-reject here; String() (fmt %v) is a best-effort fallback for that\n	// unreachable path, never exercised by the in-subset corpus.\n	return String(v)\n}\n\nfunc evalTruthy(v any) bool {\n	return isTruthy(v)\n}\n\n// ---------------------------------------------------------------------------\n// Operators\n// ---------------------------------------------------------------------------\n\nfunc evalBinary(op string, l, r any) any {\n	switch op {\n	case "+":\n		// JS `+`: string concatenation once either operand is a string,\n		// numeric addition otherwise.\n		if _, lok := l.(string); lok {\n			return evalToString(l) + evalToString(r)\n		}\n		if _, rok := r.(string); rok {\n			return evalToString(l) + evalToString(r)\n		}\n		return evalToNumber(l) + evalToNumber(r)\n	case "-":\n		return evalToNumber(l) - evalToNumber(r)\n	case "*":\n		return evalToNumber(l) * evalToNumber(r)\n	case "/":\n		return evalToNumber(l) / evalToNumber(r)\n	case "%":\n		return math.Mod(evalToNumber(l), evalToNumber(r))\n	case "<", "<=", ">", ">=":\n		return evalRelational(op, l, r)\n	case "===":\n		return evalStrictEq(l, r)\n	case "!==":\n		return !evalStrictEq(l, r)\n	}\n	// Loose equality / bitwise / shift are out of the subset.\n	return nil\n}\n\nfunc evalRelational(op string, l, r any) bool {\n	// JS Abstract Relational Comparison: both strings \u2192 compare by code\n	// unit; otherwise coerce both to numbers (a NaN operand makes every\n	// comparison false).\n	var c int\n	ls, lok := l.(string)\n	rs, rok := r.(string)\n	if lok && rok {\n		if ls < rs {\n			c = -1\n		} else if ls > rs {\n			c = 1\n		}\n	} else {\n		ln := evalToNumber(l)\n		rn := evalToNumber(r)\n		if math.IsNaN(ln) || math.IsNaN(rn) {\n			return false\n		}\n		if ln < rn {\n			c = -1\n		} else if ln > rn {\n			c = 1\n		}\n	}\n	switch op {\n	case "<":\n		return c < 0\n	case "<=":\n		return c <= 0\n	case ">":\n		return c > 0\n	case ">=":\n		return c >= 0\n	}\n	return false\n}\n\nfunc evalStrictEq(l, r any) bool {\n	// Strict `===`: equal JS type and value, no coercion. All numeric Go\n	// types are the single JS "number" type, so int 2 === float64 2.\n	lnum := evalIsNumeric(l)\n	rnum := evalIsNumeric(r)\n	if lnum && rnum {\n		lf, rf := toFloat64(l), toFloat64(r)\n		if math.IsNaN(lf) || math.IsNaN(rf) {\n			return false\n		}\n		return lf == rf\n	}\n	if lnum != rnum {\n		return false\n	}\n	switch lv := l.(type) {\n	case nil:\n		return r == nil\n	case string:\n		rv, ok := r.(string)\n		return ok && rv == lv\n	case bool:\n		rv, ok := r.(bool)\n		return ok && rv == lv\n	}\n	// Non-primitive operands (arrays / objects) are outside the subset: the JS\n	// reference refuses `===` on them and the compiler gates such a body with\n	// BF101 upstream, so this is unreachable for an in-subset corpus. The\n	// runtime trusts that gate rather than re-validating, returning false\n	// here (it does not attempt JS reference identity, which templates can\'t\n	// model anyway).\n	return false\n}\n\n// evalSameValueZero implements `Array.prototype.includes`\'s membership\n// comparison: `===` except `NaN` equals itself (JS\'s SameValueZero). Reuses\n// evalStrictEq \u2014 the one divergence, both operands NaN, is checked first;\n// every other pair (including "one NaN, one not") falls through to the same\n// equality `evalBinary`\'s `===` uses, so the two operators stay in lockstep.\nfunc evalSameValueZero(a, b any) bool {\n	if evalIsNumeric(a) && evalIsNumeric(b) {\n		af, bf := toFloat64(a), toFloat64(b)\n		if math.IsNaN(af) && math.IsNaN(bf) {\n			return true\n		}\n	}\n	return evalStrictEq(a, b)\n}\n\n// evalIncludes implements `.includes(needle)`, shared between\n// `Array.prototype.includes` (SameValueZero membership over a slice/array\n// receiver) and `String.prototype.includes` (substring search), mirroring\n// the receiver-type dispatch the SSR template lowering already does\n// (`bf_includes`). Any other receiver type is not a JS `.includes` target;\n// this degrades to false rather than panicking (there is no receiver here\n// for which JS itself would throw), matching the JS reference\n// (eval-reference.ts `includes`).\nfunc evalIncludes(obj, needle any) bool {\n	if arr := toAnySlice(obj); arr != nil {\n		for _, el := range arr {\n			if evalSameValueZero(el, needle) {\n				return true\n			}\n		}\n		return false\n	}\n	if s, ok := obj.(string); ok {\n		return strings.Contains(s, evalToString(needle))\n	}\n	return false\n}\n\nfunc evalUnary(op string, v any) any {\n	switch op {\n	case "!":\n		return !evalTruthy(v)\n	case "-":\n		return -evalToNumber(v)\n	case "+":\n		return evalToNumber(v)\n	}\n	return nil\n}\n\n// ---------------------------------------------------------------------------\n// Built-in calls (the deterministic allowlist). Locale-sensitive builtins\n// (localeCompare) are deliberately excluded to keep the backends isomorphic.\n// ---------------------------------------------------------------------------\n\n// evalBuiltinName resolves a `call` callee to its builtin name (e.g.\n// "Math.max"), or "" if the callee is not an allowlisted builtin reference.\nfunc evalBuiltinName(callee any) string {\n	cm, ok := callee.(map[string]any)\n	if !ok {\n		return ""\n	}\n	switch cm["kind"] {\n	case "identifier":\n		name, _ := cm["name"].(string)\n		return name\n	case "member":\n		if computed, _ := cm["computed"].(bool); computed {\n			return ""\n		}\n		obj, _ := cm["object"].(map[string]any)\n		if obj == nil || obj["kind"] != "identifier" {\n			return ""\n		}\n		objName, _ := obj["name"].(string)\n		prop, _ := cm["property"].(string)\n		return objName + "." + prop\n	}\n	return ""\n}\n\n// evalMathRound rounds a half toward +Infinity (JS Math.round: 2.5\u21923,\n// -2.5\u2192-2), matching the existing `round` helper rather than Go\'s math.Round.\nfunc evalMathRound(n float64) float64 {\n	// floor(n+0.5) yields +0 for x in [-0.5, -0], where JS Math.round returns\n	// -0. That sign is only observable through a subsequent division\n	// (`1 / Math.round(-0.5)` is -Infinity in JS, +Infinity here) \u2014 through\n	// ToString both \xB10 render "0". It is left as +0 deliberately: the two SSR\n	// backends must stay equal, and Perl can\'t reproduce the -0 divisor sign\n	// without fragile, version-dependent zero handling (its native `/` even\n	// dies on a zero divisor). So Math.round\'s -0 is a JS-reference-only\n	// divergence region, like the astral-plane / radix-string carve-outs.\n	return math.Floor(n + 0.5)\n}\n\nfunc evalCallBuiltin(name string, args []any) any {\n	switch name {\n	case "Math.max":\n		if len(args) == 0 {\n			return math.Inf(-1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Max(m, evalToNumber(a))\n		}\n		return m\n	case "Math.min":\n		if len(args) == 0 {\n			return math.Inf(1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Min(m, evalToNumber(a))\n		}\n		return m\n	case "Math.abs":\n		return math.Abs(evalToNumber(arg0(args)))\n	case "Math.floor":\n		return math.Floor(evalToNumber(arg0(args)))\n	case "Math.ceil":\n		return math.Ceil(evalToNumber(arg0(args)))\n	case "Math.round":\n		return evalMathRound(evalToNumber(arg0(args)))\n	case "String":\n		return evalToString(arg0(args))\n	case "Number":\n		return evalToNumber(arg0(args))\n	case "Boolean":\n		return evalTruthy(arg0(args))\n	}\n	// Any other callee is outside the subset (refused upstream).\n	return nil\n}\n\nfunc arg0(args []any) any {\n	if len(args) == 0 {\n		return nil\n	}\n	return args[0]\n}\n\n// ---------------------------------------------------------------------------\n// Member / index access\n// ---------------------------------------------------------------------------\n\nfunc evalReadProperty(obj any, key string) any {\n	switch o := obj.(type) {\n	case string:\n		if key == "length" {\n			// Code-point count (== JS UTF-16 length across the BMP, == Perl\n			// `length`). RuneCountInString avoids the []rune allocation since\n			// this can run inside comparator / reducer evaluation.\n			return utf8.RuneCountInString(o)\n		}\n		return nil\n	case []any:\n		if key == "length" {\n			return len(o)\n		}\n		return nil\n	case map[string]any:\n		// Case-variant lookup: a callback body reads the raw JS property\n		// (`t.duration`), but test data / Go-keyed maps may carry PascalCase\n		// keys (`{"Duration": \u2026}`). Reuse the field reader the sort / reduce\n		// helpers use \u2014 it resolves `duration` \u2192 `Duration` and reads a\n		// genuinely missing key as null (the backends\' single absent value).\n		return getFieldValue(o, key)\n	case nil:\n		return nil\n	default:\n		// Real template data (Go structs): reuse the field reader the sort /\n		// reduce helpers use, which handles case-variant keys.\n		return getFieldValue(obj, key)\n	}\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order folds (the generalization of bf_reduce /\n// bf_sort onto the evaluator)\n//\n// These prove the evaluator subsumes the special-cased callback catalogue:\n// the callback BODY is carried as a pure ParsedExpr (JSON) and evaluated per\n// element against an environment, so the op restriction (bf_reduce\'s +/*),\n// the acc-canonical form, and the comparator pattern restriction (bf_sort)\n// all disappear \u2014 any pure reducer / comparator body works. They are the\n// runtime half of the integration; the compiler-side emit migration (carrying\n// callback bodies as ParsedExpr) and the byte-equal divergence decision for\n// the string-`localeCompare` sort path (won\'t-fix for byte-equal SSR, see\n// spec/compiler.md Known limitations) are the remaining follow-up.\n// ---------------------------------------------------------------------------\n\n// toAnySlice copies a reflect-iterable receiver into a fresh []any, returning\n// nil for a non-slice/array (matching the bf_sort / bf_reduce nil-tolerance).\nfunc toAnySlice(items any) []any {\n	v := reflect.ValueOf(items)\n	// A nil interface yields an invalid Value (Kind() == Invalid, not a\n	// panic), so the Slice/Array guard below already tolerates nil; the\n	// explicit IsValid check just documents the nil-tolerance intent.\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	out := make([]any, v.Len())\n	for i := range out {\n		out[i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// FoldEval folds items into a value via the ParsedExpr evaluator. The reducer\n// body is a pure ParsedExpr (JSON) evaluated against `{accName: acc, itemName:\n// item}` plus the captured free vars in `baseEnv` for each element; `init`\n// seeds the accumulator and `direction` is "left" (reduce) or "right"\n// (reduceRight). This is the evaluator-based generalization of bf_reduce \u2014 any\n// reducer body, not just the `+`/`*` arithmetic catalogue, and `acc` may\n// appear anywhere in the body. `baseEnv` may be nil when the body captures no\n// outer references; the accName / itemName keys shadow any same-named base key.\nfunc FoldEval(items any, bodyJSON, accName, itemName string, init any, direction string, baseEnv map[string]any) any {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return init\n	}\n	arr := toAnySlice(items)\n	if direction == "right" {\n		for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {\n			arr[i], arr[j] = arr[j], arr[i]\n		}\n	}\n	acc := init\n	// Seed the env from the captured free vars once; acc / item are\n	// overwritten each iteration (constant base keys carry through).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	for _, item := range arr {\n		env[accName] = acc\n		env[itemName] = item\n		acc = EvalNode(body, env)\n	}\n	return acc\n}\n\n// SortEval returns a new stable-sorted slice ordered by a ParsedExpr\n// comparator body (JSON) evaluated against `{paramA: a, paramB: b}` plus the\n// captured free vars in `baseEnv` to a number (negative / zero / positive,\n// like a JS comparator). This is the evaluator-based generalization of bf_sort\n// \u2014 any comparator body, not just the subtraction / relational-ternary\n// catalogue. `baseEnv` may be nil. Non-mutating.\nfunc SortEval(items any, cmpJSON, paramA, paramB string, baseEnv map[string]any) []any {\n	arr := toAnySlice(items)\n	if arr == nil {\n		return nil\n	}\n	var cmp any\n	if err := json.Unmarshal([]byte(cmpJSON), &cmp); err != nil {\n		return arr\n	}\n	// One env seeded from the captured free vars; the two operand keys are\n	// overwritten per comparison (the comparator runs synchronously).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	sort.SliceStable(arr, func(i, j int) bool {\n		env[paramA] = arr[i]\n		env[paramB] = arr[j]\n		return evalToNumber(EvalNode(cmp, env)) < 0\n	})\n	return arr\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order predicates (#2018, P2) \u2014 the generalization\n// of bf_filter / bf_find / bf_find_index / bf_every / bf_some onto the\n// evaluator. The predicate BODY travels as a pure ParsedExpr (JSON) and is\n// evaluated per element against `{param: item}` plus the captured free vars in\n// `baseEnv`, lifting the field-equality / truthiness restriction of the\n// special-cased helpers to any pure predicate. `baseEnv` may be nil.\n// ---------------------------------------------------------------------------\n\n// decodeEvalBody unmarshals a serialized ParsedExpr body; ok is false on bad\n// JSON (only reachable by a corrupt emit \u2014 the adapter always emits valid JSON).\nfunc decodeEvalBody(bodyJSON string) (any, bool) {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return nil, false\n	}\n	return body, true\n}\n\n// seedPredEnv copies the captured free vars into a fresh env with room for the\n// single predicate param, which the callers overwrite per element.\nfunc seedPredEnv(baseEnv map[string]any) map[string]any {\n	env := make(map[string]any, len(baseEnv)+1)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	return env\n}\n\n// FilterEval returns a new slice of the elements for which the predicate body\n// evaluates truthy \u2014 the evaluator generalization of bf_filter. Returns a\n// non-nil empty slice when nothing matches (so a downstream `range` / `bf_join`\n// sees a real slice); returns nil only on a bad body.\nfunc FilterEval(items any, predJSON, param string, baseEnv map[string]any) []any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// EveryEval reports whether every element satisfies the predicate (vacuously\n// true for an empty receiver, like JS) \u2014 the generalization of bf_every.\nfunc EveryEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if !evalTruthy(EvalNode(pred, env)) {\n			return false\n		}\n	}\n	return true\n}\n\n// SomeEval reports whether any element satisfies the predicate (false for an\n// empty receiver, like JS) \u2014 the generalization of bf_some.\nfunc SomeEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			return true\n		}\n	}\n	return false\n}\n\n// FindEval returns the first element satisfying the predicate, or nil when none\n// does \u2014 the generalization of bf_find. `forward` false searches from the end\n// (findLast).\nfunc FindEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return arr[i]\n		}\n	}\n	return nil\n}\n\n// FindIndexEval returns the index of the first element satisfying the predicate,\n// or -1 when none does \u2014 the generalization of bf_find_index. `forward` false\n// searches from the end (findLastIndex).\nfunc FindIndexEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) int {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return -1\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return i\n		}\n	}\n	return -1\n}\n\n// FlatMapEval projects each element through the projection body (a pure\n// ParsedExpr JSON evaluated against `{param: item}` + baseEnv) and flattens the\n// results one level \u2014 the evaluator generalization of bf_flat_map /\n// bf_flat_map_tuple. A projection that yields a slice contributes its elements;\n// any other value contributes itself (matching JS `.flatMap`, where a non-array\n// return is kept as a single element). Returns a non-nil empty slice on a bad\n// body so a downstream `range` / `bf_join` sees a real slice.\nfunc FlatMapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		v := EvalNode(proj, env)\n		// Flatten any slice/array kind one level, not just []any: real Go\n		// template data projects a field like `i.tags` to a typed slice\n		// (`[]string` / `[]int`), which `toAnySlice` normalizes to []any. A\n		// non-slice value (string / number / struct / nil) contributes itself,\n		// matching JS `.flatMap` (a non-array return is kept as one element).\n		if sub := toAnySlice(v); sub != nil {\n			out = append(out, sub...)\n		} else {\n			out = append(out, v)\n		}\n	}\n	return out\n}\n\n// MapEval projects each element through the projection body (a pure ParsedExpr\n// JSON evaluated against `{param: item}` + baseEnv), keeping one result per\n// element \u2014 the value-producing `.map(cb)` lowering (#2073). Unlike\n// FlatMapEval there is no flatten: a projection yielding a slice contributes\n// that slice as a single element, matching JS `.map`. Returns a non-nil empty\n// slice on a bad body so a downstream `range` / `bf_join` sees a real slice.\nfunc MapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		out = append(out, EvalNode(proj, env))\n	}\n	return out\n}\n\n// Env builds the captured-free-var environment for FoldEval / SortEval from a\n// flat key, value, key, value, \u2026 argument list \u2014 the adapter emits\n// `bf_env "k1" v1 "k2" v2 \u2026` for the free variables a callback body references\n// beyond its own params. An odd trailing key with no value is ignored; with no\n// pairs it returns an empty (non-nil) map, the no-capture case. A non-string\n// key (only reachable by a malformed template call, never by the adapter\'s\n// quoted-literal emit) is skipped rather than collapsed into an `env[""]` slot.\nfunc Env(pairs ...any) map[string]any {\n	env := make(map[string]any, len(pairs)/2)\n	for i := 0; i+1 < len(pairs); i += 2 {\n		key, ok := pairs[i].(string)\n		if !ok {\n			continue\n		}\n		env[key] = pairs[i+1]\n	}\n	return env\n}\n\nfunc evalReadIndex(obj any, index any) any {\n	switch o := obj.(type) {\n	case []any:\n		f := evalToNumber(index)\n		i := int(f)\n		if float64(i) != f || i < 0 || i >= len(o) {\n			return nil\n		}\n		return o[i]\n	case map[string]any:\n		return o[evalToString(index)]\n	case nil:\n		return nil\n	default:\n		return getFieldValue(obj, evalToString(index))\n	}\n}\n';
+    bfGoSource = '// Package bf provides runtime helper functions for BarefootJS Go templates.\n// These functions mirror JavaScript behavior for consistent SSR output.\npackage bf\n\nimport (\n	"bytes"\n	"encoding/json"\n	"fmt"\n	"html/template"\n	"math"\n	"math/rand"\n	"net/url"\n	"os"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode"\n	"unicode/utf8"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Arithmetic\n		"bf_add":        Add,\n		"bf_concat_str": ConcatStr,\n		"bf_sub":        Sub,\n		"bf_mul":        Mul,\n		"bf_div":        Div,\n		"bf_mod":        Mod,\n		"bf_neg":        Neg,\n		"bf_min":        Min,\n		"bf_max":        Max,\n\n		// String\n		"bf_lower":       Lower,\n		"bf_upper":       Upper,\n		"bf_trim":        Trim,\n		"bf_trim_start":  TrimStart,\n		"bf_trim_end":    TrimEnd,\n		"bf_contains":    Contains,\n		"bf_join":        Join,\n		"bf_split":       Split,\n		"bf_starts_with": StartsWith,\n		"bf_ends_with":   EndsWith,\n		"bf_replace":     Replace,\n		"bf_replace_all": ReplaceAll,\n		"bf_repeat":      Repeat,\n		"bf_pad_start":   PadStart,\n		"bf_pad_end":     PadEnd,\n		"bf_string":      String,\n\n		// URL query builder (#1897 PostList href helpers): conditional\n		// (include, key, value) triples \u2192 "base?k=v&\u2026", mirroring a\n		// URLSearchParams builder with guarded `.set()` calls.\n		"bf_query": Query,\n\n		// JSON / numeric primitives \u2014 JS-compat callees registered on\n		// the Go adapter\'s `templatePrimitives` map (#1188).\n		"bf_json":     JSON,\n		"bf_number":   Number,\n		"bf_floor":    Floor,\n		"bf_ceil":     Ceil,\n		"bf_round":    Round,\n		"bf_abs":      Abs,\n		"bf_to_fixed": ToFixed,\n\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_flat":           Flat,\n		"bf_flat_dynamic":   FlatDynamicDepth,\n		"bf_flat_map":       FlatMap,\n		"bf_flat_map_tuple": FlatMapTuple,\n		"bf_first":          First,\n		"bf_last":           Last,\n		"bf_arr":            Arr,\n		"bf_filter_truthy":  FilterTruthy,\n\n		// Higher-order Array Methods\n		"bf_every":           Every,\n		"bf_some":            Some,\n		"bf_filter":          Filter,\n		"bf_find":            Find,\n		"bf_find_index":      FindIndex,\n		"bf_find_last":       FindLast,\n		"bf_find_last_index": FindLastIndex,\n		"bf_sort":            Sort,\n		"bf_reduce":          Reduce,\n\n		// Evaluator-driven higher-order folds (#2018): the comparator / reducer\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_sort / bf_reduce beyond their fixed catalogues. The\n		// adapter falls back to bf_sort for a comparator the evaluator can\'t\n		// model (e.g. localeCompare). `bf_env` builds the captured-free-var\n		// environment passed as the trailing base_env argument.\n		"bf_sort_eval":   SortEval,\n		"bf_reduce_eval": FoldEval,\n		"bf_env":         Env,\n\n		// Evaluator-driven higher-order predicates (#2018, P2): the predicate\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_filter / bf_find / bf_find_index / bf_every / bf_some\n		// beyond their field-equality / truthiness catalogues. `bf_find_eval` /\n		// `bf_find_index_eval` take a `forward` bool (false \u2192 findLast variants).\n		"bf_filter_eval":     FilterEval,\n		"bf_every_eval":      EveryEval,\n		"bf_some_eval":       SomeEval,\n		"bf_find_eval":       FindEval,\n		"bf_find_index_eval": FindIndexEval,\n		// `.flatMap(proj)`: project each element through the serialized\n		// projection body, then flatten one level.\n		"bf_flat_map_eval": FlatMapEval,\n		// Value-producing `.map(cb)` (#2073): project each element, one\n		// result per element (no flatten).\n		"bf_map_eval": MapEval,\n\n		// Comment marker (for hydration)\n		"bfComment":   Comment,\n		"bfTextStart": TextStart,\n		"bfTextEnd":   TextEnd,\n\n		// Script collection\n		"bfScripts": BfScripts,\n\n		// Scope attribute value (#1249: bare scope id, no `~` prefix)\n		"bfScopeAttr": ScopeAttr,\n\n		// Slot-identity markers (#1249): bf-h, bf-m, bf-r\n		"bfHydrationAttrs": HydrationAttrs,\n\n		// Child component marker (kept for backward compatibility)\n		"bfIsChild": IsChild,\n\n		// Props attribute for hydration\n		"bfPropsAttr": BfPropsAttr,\n\n		// Portal HTML rendering (parses and executes template string)\n		"bfPortalHTML": PortalHTML,\n\n		// JSX children passed to an imported child component (#1896):\n		// the parent renders the children fragment via a companion\n		// define (executed through bf_tmpl from TemplateFuncMap) and\n		// injects the result into the child\'s Children field.\n		"bf_with_children": WithChildren,\n\n		// Scope comment for fragment roots\n		"bfScopeComment": ScopeComment,\n\n		// JSX intrinsic-element spread lowering (#1407)\n		"bf_spread_attrs": SpreadAttrs,\n\n		// Destructure object-rest spread-onto-element residual (#2087):\n		// "every field except these" for a struct/map, keyed by json tag.\n		"bf_omit": Omit,\n\n		// Case-tolerant single-field read off a map or struct (#2087): a\n		// `useContext` local whose `createContext` default is object-shaped\n		// (e.g. `createContext<{ config: X }>({ config: {} })`) is typed\n		// `map[string]interface{}`, and its keys are the SOURCE (JS-cased)\n		// property names a `<Ctx.Provider value={{ \u2026 }}>` bakes\n		// (`providerObjectValueToGoMap`, go-template-adapter.ts) \u2014 plain\n		// `text/template` dot access does an exact-string `MapIndex`, so\n		// `ctx.config.label` lowers to nested `bf_get` calls instead of\n		// `.Ctx.Config.Label`. Reuses the same `getFieldValue` the\n		// project/sort helpers already use for a dynamic field-name lookup;\n		// safe on a nil map/interface (returns nil) so a missing Provider or\n		// an absent key falls through to `??`\'s fallback.\n		"bf_get": getFieldValue,\n	}\n}\n\n// Query builds a URL from a base path plus a query string assembled from\n// (include, key, value) triples, in order. A pair is considered only when its\n// `include` flag is true \u2014 mirroring a JS URLSearchParams builder whose\n// `.set(key, value)` calls are each guarded by an `if`. The compiler lowers a\n// conditional `cond ? v : undefined` to the `include` bool and a plain `key: v`\n// to a `true` include; the emptiness check is applied HERE (an included but\n// empty value is dropped), matching the client `queryHref` and the Perl `query`\n// helper. Keys and values use formEscape (application/x-www-form-urlencoded),\n// so the rendered query is byte-for-byte identical to the browser\'s\n// URLSearchParams. An empty query yields the bare base.\n//\n// A value may be a string slice ([]string or []any), which APPENDS one pair per\n// non-empty member (URLSearchParams.append) \u2014 `{tag: [a, b]}` \u2192 `tag=a&tag=b`.\n// A scalar value follows URLSearchParams.set() semantics: repeating a key\n// overwrites the value at the key\'s first position rather than duplicating it\n// (object literals have unique keys, so this is defensive). Trailing args that\n// don\'t complete a triple are ignored.\n//\n// formEscape differs from url.QueryEscape only on `~` (kept by QueryEscape,\n// `%7E` here) and `*` (`%2A` by QueryEscape, kept here).\nfunc Query(base string, triples ...any) string {\n	type kv struct{ key, val string }\n	pairs := make([]kv, 0, len(triples)/3)\n	pos := make(map[string]int)\n	for i := 0; i+2 < len(triples); i += 3 {\n		include, _ := triples[i].(bool)\n		if !include {\n			continue\n		}\n		k := String(triples[i+1])\n		if members, ok := asStringSlice(triples[i+2]); ok {\n			// Array value \u2192 append each non-empty member; appended pairs never\n			// overwrite, so they don\'t participate in the set()-position map.\n			for _, m := range members {\n				if m == "" {\n					continue\n				}\n				pairs = append(pairs, kv{k, m})\n			}\n			continue\n		}\n		v := String(triples[i+2])\n		if v == "" {\n			continue // omit an included-but-empty value (client / Perl parity)\n		}\n		if at, ok := pos[k]; ok {\n			pairs[at].val = v // set(): overwrite the first occurrence\'s value\n		} else {\n			pos[k] = len(pairs)\n			pairs = append(pairs, kv{k, v})\n		}\n	}\n	var b strings.Builder\n	for _, p := range pairs {\n		if b.Len() == 0 {\n			b.WriteByte(\'?\')\n		} else {\n			b.WriteByte(\'&\')\n		}\n		b.WriteString(formEscape(p.key))\n		b.WriteByte(\'=\')\n		b.WriteString(formEscape(p.val))\n	}\n	return base + b.String()\n}\n\n// asStringSlice reports whether v is a query *array* value and, if so, returns\n// its members stringified. A compiled template passes a `[]string` field; the\n// golden conformance vectors decode JSON arrays to `[]any`. Anything else is a\n// scalar (false), handled by the set() path.\nfunc asStringSlice(v any) ([]string, bool) {\n	switch s := v.(type) {\n	case []string:\n		return s, true\n	case []any:\n		out := make([]string, len(s))\n		for i, m := range s {\n			out[i] = String(m)\n		}\n		return out, true\n	default:\n		return nil, false\n	}\n}\n\nconst hexUpper = "0123456789ABCDEF"\n\n// formEscape percent-encodes s with the application/x-www-form-urlencoded byte\n// set, matching the browser\'s URLSearchParams serialization (and the Perl\n// `query` helper) so SSR query strings render byte-for-byte identically across\n// adapters. The unreserved set kept verbatim is A-Z a-z 0-9 and `* - . _`; a\n// space becomes `+`; every other byte is `%XX` with uppercase hex. Encoding is\n// byte-wise, so multi-byte UTF-8 is percent-encoded per byte (`\xE9` \u2192 `%C3%A9`).\n//\n// This differs from url.QueryEscape only for `~` (kept by QueryEscape, encoded\n// to `%7E` here) and `*` (encoded to `%2A` by QueryEscape, kept here).\nfunc formEscape(s string) string {\n	var b strings.Builder\n	for i := 0; i < len(s); i++ {\n		c := s[i]\n		switch {\n		case c >= \'A\' && c <= \'Z\', c >= \'a\' && c <= \'z\', c >= \'0\' && c <= \'9\',\n			c == \'*\', c == \'-\', c == \'.\', c == \'_\':\n			b.WriteByte(c)\n		case c == \' \':\n			b.WriteByte(\'+\')\n		default:\n			b.WriteByte(\'%\')\n			b.WriteByte(hexUpper[c>>4])\n			b.WriteByte(hexUpper[c&0x0F])\n		}\n	}\n	return b.String()\n}\n\n// ScopeAttr returns the bare bf-s scope id (#1249).\nfunc ScopeAttr(props interface{}) string {\n	return getStringField(props, "ScopeID")\n}\n\n// HydrationAttrs emits `bf-h="<host>" bf-m="<slot>" bf-r=""` conditionally.\n// See spec/compiler.md "Slot identity".\nfunc HydrationAttrs(props interface{}) template.HTMLAttr {\n	parts := []string{}\n	if host := getStringField(props, "BfParent"); host != "" {\n		parts = append(parts, fmt.Sprintf(`bf-h="%s"`, template.HTMLEscapeString(host)))\n	}\n	if mount := getStringField(props, "BfMount"); mount != "" {\n		parts = append(parts, fmt.Sprintf(`bf-m="%s"`, template.HTMLEscapeString(mount)))\n	}\n	if !getBoolField(props, "BfIsChild") {\n		parts = append(parts, `bf-r=""`)\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// IsChild is a deprecated no-op stub. Child status is signalled by bf-h\n// presence (#1249); use HydrationAttrs instead.\nfunc IsChild(props interface{}) template.HTMLAttr {\n	return ""\n}\n\n// svgCamelCaseAttrs mirrors SVG_CAMEL_CASE_ATTRS from\n// packages/client/src/runtime/spread-attrs.ts. SVG XML attribute\n// names are case-sensitive; the default camelCase \u2192 kebab-case\n// rewrite must NOT apply to these or the SVG stops rendering\n// (#1407). Coordinates with the compile-time SVG_CAMEL_TO_KEBAB\n// table in packages/jsx/src/ir-to-client-js/utils.ts: presentation\n// attrs (clipPath, strokeWidth, \u2026) live there and must NOT appear\n// here, or the same JSX prop would lower to clip-path via the\n// explicit-attr path and stay clipPath via the spread path.\nvar svgCamelCaseAttrs = map[string]struct{}{\n	"allowReorder": {}, "attributeName": {}, "attributeType": {}, "autoReverse": {},\n	"baseFrequency": {}, "baseProfile": {}, "calcMode": {}, "clipPathUnits": {},\n	"contentScriptType": {}, "contentStyleType": {}, "diffuseConstant": {}, "edgeMode": {},\n	"externalResourcesRequired": {}, "filterRes": {}, "filterUnits": {}, "glyphRef": {},\n	"gradientTransform": {}, "gradientUnits": {}, "kernelMatrix": {}, "kernelUnitLength": {},\n	"keyPoints": {}, "keySplines": {}, "keyTimes": {}, "lengthAdjust": {}, "limitingConeAngle": {},\n	"markerHeight": {}, "markerUnits": {}, "markerWidth": {}, "maskContentUnits": {},\n	"maskUnits": {}, "numOctaves": {}, "pathLength": {}, "patternContentUnits": {},\n	"patternTransform": {}, "patternUnits": {}, "pointsAtX": {}, "pointsAtY": {}, "pointsAtZ": {},\n	"preserveAlpha": {}, "preserveAspectRatio": {}, "primitiveUnits": {}, "refX": {}, "refY": {},\n	"repeatCount": {}, "repeatDur": {}, "requiredExtensions": {}, "requiredFeatures": {},\n	"specularConstant": {}, "specularExponent": {}, "spreadMethod": {}, "startOffset": {},\n	"stdDeviation": {}, "stitchTiles": {}, "surfaceScale": {}, "systemLanguage": {},\n	"tableValues": {}, "targetX": {}, "targetY": {}, "textLength": {}, "viewBox": {}, "viewTarget": {},\n	"xChannelSelector": {}, "yChannelSelector": {}, "zoomAndPan": {},\n}\n\n// toAttrName mirrors the JSX\u2192HTML attribute-name rewrite from\n// packages/client/src/runtime/spread-attrs.ts. className \u2192 class,\n// htmlFor \u2192 for, SVG camelCase attrs preserved, other camelCase\n// keys lowered to kebab-case.\nfunc toAttrName(key string) string {\n	if key == "className" {\n		return "class"\n	}\n	if key == "htmlFor" {\n		return "for"\n	}\n	if _, ok := svgCamelCaseAttrs[key]; ok {\n		return key\n	}\n	// camelCase \u2192 kebab-case: mirror the JS reference exactly\n	// (`key.replace(/([A-Z])/g, \'-$1\').toLowerCase()`). The JS shape\n	// produces a leading `-` for an initial uppercase letter\n	// (`XData` \u2192 `-x-data`); both this Go path and the matching JS\n	// runtime are wrong-by-construction for that case (the resulting\n	// HTML attribute name is invalid), but keeping them byte-equal\n	// avoids silent SSR/CSR divergence (#1411 review).\n	var b strings.Builder\n	for _, r := range key {\n		if r >= \'A\' && r <= \'Z\' {\n			b.WriteByte(\'-\')\n			b.WriteRune(r + 32)\n		} else {\n			b.WriteRune(r)\n		}\n	}\n	return b.String()\n}\n\n// StyleToCss mirrors styleToCss from\n// packages/client/src/runtime/style.ts. Accepts a string passthrough,\n// or a map (JSON-deserialized object) whose camelCase keys are\n// lowered to kebab-case and joined with `;`. Returns ("", false) for\n// nullish/empty input so callers can omit the attribute entirely.\nfunc StyleToCss(v any) (string, bool) {\n	if v == nil {\n		return "", false\n	}\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return "", false\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		// Non-object: stringify and return as-is, matching the JS\n		// `typeof value !== \'object\'` branch.\n		s := fmt.Sprint(v)\n		if s == "" {\n			return "", false\n		}\n		return s, true\n	}\n	keys := rv.MapKeys()\n	sorted := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sorted = append(sorted, k.String())\n		}\n	}\n	sort.Strings(sorted)\n	parts := make([]string, 0, len(sorted))\n	for _, k := range sorted {\n		val := rv.MapIndex(reflect.ValueOf(k))\n		// Skip nil entries (matches the JS `if (v == null) continue`).\n		if !val.IsValid() {\n			continue\n		}\n		if val.Kind() == reflect.Interface || val.Kind() == reflect.Pointer {\n			if val.IsNil() {\n				continue\n			}\n			val = val.Elem()\n		}\n		prop := toAttrName(k)\n		parts = append(parts, fmt.Sprintf("%s:%v", prop, val.Interface()))\n	}\n	if len(parts) == 0 {\n		return "", false\n	}\n	return strings.Join(parts, ";"), true\n}\n\n// SpreadAttrs lowers a JSX intrinsic-element spread bag (#1407) to\n// an HTML attribute string. Mirrors spreadAttrs from\n// packages/client/src/runtime/spread-attrs.ts so SSR output matches\n// what CSR\'s `applyRestAttrs` writes at hydration.\n//\n// Skip rules: nil/false values, event handlers (`on[A-Z]*`),\n// `children`, `ref`.\n//\n// Key remap: className \u2192 class, htmlFor \u2192 for, SVG camelCase\n// preserved, other camelCase \u2192 kebab-case.\n//\n// `style` is routed through StyleToCss so object literals serialize\n// to a real CSS string instead of Go\'s default `map[k:v]` form.\n//\n// Booleans: true \u2192 bare attribute name, false \u2192 omitted.\n// Other scalar values are HTML-escaped via template.HTMLEscapeString.\n// Returns a `template.HTMLAttr` so html/template emits the result\n// verbatim (the function does its own escaping).\n//\n// Keys are sorted alphabetically before emission for deterministic\n// output. SSR/CSR attribute-order divergence is acceptable per the\n// rest-destructure-object-spread-in-map fixture\'s documented policy\n// \u2014 browsers honor the LAST value when a key is duplicated, so\n// pairing with static attrs (`<div class="x" {...rest}>`) is\n// last-wins regardless of order.\nfunc SpreadAttrs(bag any) template.HTMLAttr {\n	if bag == nil {\n		return ""\n	}\n	rv := reflect.ValueOf(bag)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return ""\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		return ""\n	}\n	keys := rv.MapKeys()\n	sortedKeys := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sortedKeys = append(sortedKeys, k.String())\n		}\n	}\n	sort.Strings(sortedKeys)\n	parts := make([]string, 0, len(sortedKeys))\n	for _, key := range sortedKeys {\n		// Event handlers \u2014 skip at SSR the same way\n		// packages/client/src/runtime/spread-attrs.ts does at\n		// hydration. The JS predicate is\n		// `key.startsWith(\'on\') && key.length > 2 && key[2] === key[2].toUpperCase()`,\n		// which is true for any character whose uppercase form is\n		// itself: ASCII A-Z, digits, underscore, and non-letter\n		// symbols. Mirror that here by skipping when key[2] is NOT\n		// a lowercase ASCII letter \u2014 so `onClick`, `on_custom`, and\n		// `on0` all match (#1411 review).\n		if len(key) > 2 && key[0] == \'o\' && key[1] == \'n\' && !(key[2] >= \'a\' && key[2] <= \'z\') {\n			continue\n		}\n		// `children` is a JSX construct rendered inside the element,\n		// never a DOM attribute. `ref` is intentionally NOT filtered\n		// here so output stays byte-equal with the JS reference\n		// `spreadAttrs` in packages/client/src/runtime/spread-attrs.ts\n		// (which only filters null/false, event handlers, and\n		// children) \u2014 aligning Go\'s filter set diverges from JS in\n		// the opposite direction. Filtering `ref` consistently across\n		// both SSR runtimes is a separate concern tracked alongside\n		// the JS `applyRestAttrs` vs `spreadAttrs` mismatch (#1411\n		// review).\n		if key == "children" {\n			continue\n		}\n		val := rv.MapIndex(reflect.ValueOf(key))\n		if !val.IsValid() {\n			continue\n		}\n		// Unwrap interface wrappers (json.Unmarshal produces\n		// interface{}-wrapped values for map[string]any).\n		v := val\n		for v.Kind() == reflect.Interface || v.Kind() == reflect.Pointer {\n			if v.IsNil() {\n				// Skip null entries.\n				v = reflect.Value{}\n				break\n			}\n			v = v.Elem()\n		}\n		if !v.IsValid() {\n			continue\n		}\n		// Boolean values: true \u2192 bare attribute, false \u2192 omitted.\n		if v.Kind() == reflect.Bool {\n			if !v.Bool() {\n				continue\n			}\n			parts = append(parts, toAttrName(key))\n			continue\n		}\n		// `style` routes through StyleToCss so object literals get a\n		// real CSS string. The JS side does the same.\n		if key == "style" {\n			css, ok := StyleToCss(v.Interface())\n			if !ok {\n				continue\n			}\n			parts = append(parts, fmt.Sprintf(`style="%s"`, template.HTMLEscapeString(css)))\n			continue\n		}\n		// Stringify and escape. fmt.Sprint handles numbers, bools-as-\n		// strings, and arbitrary stringer types the same way the JS\n		// `String(value)` coercion does for the analogous cases.\n		s := fmt.Sprint(v.Interface())\n		parts = append(parts, fmt.Sprintf(`%s="%s"`, toAttrName(key), template.HTMLEscapeString(s)))\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// Omit builds a `map[string]any` residual bag from a struct or map value,\n// excluding the given keys \u2014 powers the `{...rest}` spread-onto-element\n// lowering for a destructured `.map()` loop-item\'s object-rest binding\n// (#2087): `.map(({ id, title, ...rest }) => <li {...rest}>)` needs "every\n// field EXCEPT the ones the pattern already destructured out", and a static\n// Go struct type has no way to express "minus a field" \u2014 the exclude set is\n// known at COMPILE TIME (the sibling keys the destructure pattern names), so\n// the compiler passes them here and this does the per-item field-vs-key\n// matching a static type can\'t. The result feeds `bf_spread_attrs`\n// (`SpreadAttrs`), same as a top-level `{...attrs()}` bag.\n//\n// Struct receiver: iterates exported fields via reflection, keyed by each\n// field\'s `json` struct tag (falling back to the Go field name when absent)\n// \u2014 the generated struct\'s json tag is always the ORIGINAL source property\n// name (see `structFieldsFor` / `typeDefinitionToGo` in the Go adapter), so\n// this reproduces the exact JS key `SpreadAttrs`\'s `toAttrName` expects\n// (`"data-priority"`, not a re-derived `"DataPriority"`). A tag of `"-"`\n// (opt-out) is skipped like `encoding/json` does.\n//\n// Map receiver: copies string keys through directly, same exclude/skip\n// rules.\n//\n// Anything else (nil, a non-struct/non-map interface) returns an empty map.\nfunc Omit(item any, excludeKeys ...string) map[string]any {\n	exclude := make(map[string]struct{}, len(excludeKeys))\n	for _, k := range excludeKeys {\n		exclude[k] = struct{}{}\n	}\n	out := map[string]any{}\n	rv := reflect.ValueOf(item)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return out\n		}\n		rv = rv.Elem()\n	}\n	switch rv.Kind() {\n	case reflect.Struct:\n		rt := rv.Type()\n		for i := 0; i < rt.NumField(); i++ {\n			field := rt.Field(i)\n			if !field.IsExported() {\n				continue\n			}\n			key := field.Name\n			if tag, ok := field.Tag.Lookup("json"); ok {\n				if comma := strings.Index(tag, ","); comma >= 0 {\n					tag = tag[:comma]\n				}\n				if tag == "-" {\n					continue\n				}\n				if tag != "" {\n					key = tag\n				}\n			}\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			out[key] = rv.Field(i).Interface()\n		}\n	case reflect.Map:\n		for _, k := range rv.MapKeys() {\n			if k.Kind() != reflect.String {\n				continue\n			}\n			key := k.String()\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			val := rv.MapIndex(k)\n			if val.IsValid() {\n				out[key] = val.Interface()\n			}\n		}\n	}\n	return out\n}\n\n// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// ConcatStr returns a and b concatenated as strings \u2014 the string-typed half\n// of JS `+` (#2168 string-concat-plus). JS `+` is addition when BOTH\n// operands are numeric and concatenation when EITHER is a string; `Add`\n// (above) covers the numeric case, this covers the string one \u2014 `Add`\n// itself can\'t (`toFloat64` returns 0 for a string operand, so `\'Hello, \' +\n// name` silently rendered "0" before this existed).\nfunc ConcatStr(a, b any) string {\n	return toString(a) + toString(b)\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Min returns the smaller of a and b (two-arg `Math.min`). Like Mul, it keeps\n// an integer result when both operands are int-like so a CSS value such as\n// `bf_min 100 x` stays `100` rather than `100.000000`. Uses `Number` (not\n// `toFloat64`, which silently zeroes an unrecognized type like a non-numeric\n// string) plus explicit NaN checks, since IEEE-754 `<`/`>` comparisons\n// against NaN are always false and would otherwise let a non-NaN operand\n// win instead of propagating NaN like JS `Math.min`/`Math.max` do.\nfunc Min(a, b any) any {\n	av, bv := Number(a), Number(b)\n	if math.IsNaN(av) {\n		return av\n	}\n	if math.IsNaN(bv) {\n		return bv\n	}\n	r := av\n	if bv < av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Max returns the larger of a and b (two-arg `Math.max`), with the same\n// int-preserving rule and NaN-propagation as Min.\nfunc Max(a, b any) any {\n	av, bv := Number(a), Number(b)\n	if math.IsNaN(av) {\n		return av\n	}\n	if math.IsNaN(bv) {\n		return bv\n	}\n	r := av\n	if bv > av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// TrimStart returns s with leading whitespace removed\n// (String.prototype.trimStart, #2183) \u2014 the one-sided sibling of\n// Trim above, using the same unicode.IsSpace predicate strings.TrimSpace\n// applies to both sides.\nfunc TrimStart(s string) string {\n	return strings.TrimLeftFunc(s, unicode.IsSpace)\n}\n\n// TrimEnd returns s with trailing whitespace removed\n// (String.prototype.trimEnd, #2183) \u2014 the one-sided sibling of Trim.\nfunc TrimEnd(s string) string {\n	return strings.TrimRightFunc(s, unicode.IsSpace)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Split lowers `String.prototype.split(sep, limit?)` (#1448 Tier B). It\n// wraps `strings.Split` and normalises the result to `[]any` so the\n// slice composes with the array-method surface downstream (`bf_join`,\n// range loops, `bf_len`, \u2026) the same way `bf_slice` / `bf_reverse`\n// results do. Like JS, an empty separator splits into individual UTF-8\n// characters and trailing empty fields are preserved (`"a,".split(",")`\n// \u2192 `["a", ""]`). An optional `limit` caps the number of returned\n// pieces (`"a,b,c".split(",", 2)` \u2192 `["a", "b"]`); a negative limit is\n// ignored (JS would also return every piece \u2014 its ToUint32 wrap makes\n// the limit effectively unbounded). The no-separator form is handled by\n// the adapter (it emits `bf_arr` for the whole-string single element).\nfunc Split(s, sep string, limit ...int) []any {\n	parts := strings.Split(s, sep)\n	if len(limit) > 0 && limit[0] >= 0 && limit[0] < len(parts) {\n		parts = parts[:limit[0]]\n	}\n	out := make([]any, len(parts))\n	for i, p := range parts {\n		out[i] = p\n	}\n	return out\n}\n\n// StartsWith lowers `String.prototype.startsWith(prefix, position?)`\n// (#1448 Tier B). Wraps `strings.HasPrefix`; an empty prefix is always\n// true (JS parity). The optional `position` re-anchors the test to start\n// at that index (clamped to `[0, len]` so it never panics), matching JS\n// `"abc".startsWith("b", 1) === true`.\nfunc StartsWith(s, prefix string, position ...int) bool {\n	if len(position) > 0 {\n		p := position[0]\n		if p < 0 {\n			p = 0\n		}\n		if p > len(s) {\n			p = len(s)\n		}\n		s = s[p:]\n	}\n	return strings.HasPrefix(s, prefix)\n}\n\n// EndsWith lowers `String.prototype.endsWith(suffix, endPosition?)`\n// (#1448 Tier B). Wraps `strings.HasSuffix`; an empty suffix is always\n// true (JS parity). The optional `endPosition` treats the string as if\n// it were only that many bytes long (clamped to `[0, len]`), matching JS\n// `"abc".endsWith("b", 2) === true`.\nfunc EndsWith(s, suffix string, endPosition ...int) bool {\n	if len(endPosition) > 0 {\n		e := endPosition[0]\n		if e < 0 {\n			e = 0\n		}\n		if e > len(s) {\n			e = len(s)\n		}\n		s = s[:e]\n	}\n	return strings.HasSuffix(s, suffix)\n}\n\n// Replace lowers the string-pattern form of `String.prototype.replace`\n// (#1448 Tier B). JS replaces only the FIRST occurrence for a string\n// pattern, so the count is 1 (`strings.Replace` with n=1; `ReplaceAll`\n// below is the every-occurrence sibling, `.replaceAll`, #2182). The\n// replacement is treated literally: unlike JS, special replacement\n// patterns like `$&` / `$1` are NOT interpreted (Go and Perl agree on\n// literal replacement, keeping the two template adapters byte-equal;\n// this diverges from the Hono/CSR JS path only for replacement strings\n// that contain `$`-patterns, which are rare in template position).\nfunc Replace(s, old, new string) string {\n	return strings.Replace(s, old, new, 1)\n}\n\n// ReplaceAll lowers the string-pattern form of\n// `String.prototype.replaceAll` (#2182): every occurrence, via\n// `strings.ReplaceAll` (equivalent to `strings.Replace` with n=-1).\n// Same literal-replacement caveat as `Replace` above.\nfunc ReplaceAll(s, old, new string) string {\n	return strings.ReplaceAll(s, old, new)\n}\n\n// Repeat lowers `String.prototype.repeat(n)` (#1448 Tier B): the\n// receiver concatenated n times. JS throws RangeError for a negative\n// count and `strings.Repeat` panics, so a negative count clamps to the\n// empty string \u2014 SSR templates degrade rather than crash the render.\n// A zero count is the empty string (JS parity).\nfunc Repeat(s string, n int) string {\n	if n <= 0 {\n		return ""\n	}\n	return strings.Repeat(s, n)\n}\n\n// padTo lowers the shared body of `String.prototype.padStart` /\n// `padEnd` (#1448 Tier B): pad `s` to `target` code points using `pad`\n// repeated and truncated to fill, prepended (atStart) or appended.\n// Length is measured in runes (not bytes) so the result matches the\n// Perl `bf->pad_*` helpers \u2014 this diverges from JS\'s UTF-16-unit length\n// only for astral-plane input. An empty pad, or a receiver already at\n// least `target` long, returns `s` unchanged (JS parity).\nfunc padTo(s string, target int, pad string, atStart bool) string {\n	if pad == "" {\n		return s\n	}\n	sLen := utf8.RuneCountInString(s)\n	if sLen >= target {\n		return s\n	}\n	need := target - sLen\n	padRunes := []rune(pad)\n	fill := make([]rune, 0, need)\n	for len(fill) < need {\n		for _, r := range padRunes {\n			if len(fill) >= need {\n				break\n			}\n			fill = append(fill, r)\n		}\n	}\n	if atStart {\n		return string(fill) + s\n	}\n	return s + string(fill)\n}\n\n// PadStart lowers `String.prototype.padStart(target, pad?)` (#1448 Tier\n// B). The pad string defaults to a single space when omitted.\nfunc PadStart(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, true)\n}\n\n// PadEnd lowers `String.prototype.padEnd(target, pad?)` (#1448 Tier B).\nfunc PadEnd(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, false)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// String returns the string form of v. Mirrors JS `String(v)` for\n// non-nil values via `fmt.Sprintf("%v", ...)`. Diverges from JS on\n// nil: JS `String(null)` is "null", but the template path renders\n// `nil` as the empty string here so an unset prop doesn\'t surface\n// as a literal "null"/"undefined" in user-facing HTML. Document the\n// divergence explicitly so callers don\'t rely on JS-exact parity.\nfunc String(v any) string {\n	if v == nil {\n		return ""\n	}\n	return fmt.Sprintf("%v", v)\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// Abs returns the absolute value of v as a float64, mirroring JS\n// `Math.abs`. #2168 math-methods.\nfunc Abs(v any) float64 {\n	return math.Abs(Number(v))\n}\n\n// ToFixed formats v with exactly `digits` decimal places, mirroring JS\n// `Number.prototype.toFixed` (zero-padding + half-toward-+Infinity\n// rounding). JS rounds the scaled integer half up (`(2.5).toFixed(0)`\n// is "3"); bare `fmt.Sprintf("%.*f")` rounds half-to-even ("2"), so we\n// scale, round with `Floor(x + 0.5)` (matching `Round`), then format\n// the exact multiple. #1897.\nfunc ToFixed(v any, digits int) string {\n	if digits < 0 {\n		digits = 0\n	}\n	n := Number(v)\n	// JS toFixed returns the strings "NaN" / "Infinity" / "-Infinity" for\n	// non-finite inputs; fmt would render "NaN"/"+Inf"/"-Inf".\n	if math.IsNaN(n) {\n		return "NaN"\n	}\n	if math.IsInf(n, 1) {\n		return "Infinity"\n	}\n	if math.IsInf(n, -1) {\n		return "-Infinity"\n	}\n	factor := math.Pow(10, float64(digits))\n	rounded := math.Floor(n*factor + 0.5)\n	return fmt.Sprintf("%.*f", digits, rounded/factor)\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  SameValueZero element search (matches\n//     the evaluator\'s `evalSameValueZero`/`evalIncludes` in eval.go,\n//     which back the serialized-callback path) \u2014 numeric types compare\n//     by value across int/float64 the way JS\'s single "number" type\n//     does, and NaN matches NaN (unlike `===`). This used to be\n//     `reflect.DeepEqual`, which is type-strict (`int(2)` != `float64(2)`)\n//     and never matches NaN to NaN; that diverged from the evaluator\'s\n//     `.includes` and from JS itself, so it was unified here.\n//   - string receiver:       strings.Contains substring search\n//\n// Anything else returns false (matches the JS semantic where\n// `.includes` is only defined on Array / TypedArray / String).\nfunc Includes(recv any, elem any) bool {\n	v := reflect.ValueOf(recv)\n	if v.Kind() == reflect.String {\n		// JS `String.prototype.includes` accepts only string args;\n		// non-string `elem` would TypeError in real JS but our\n		// callers have lowered through `convertExpressionToGo`\n		// where the arg type is whatever the template binds. Stringify\n		// via fmt to keep the helper total.\n		needle, ok := elem.(string)\n		if !ok {\n			needle = fmt.Sprintf("%v", elem)\n		}\n		return strings.Contains(v.String(), needle)\n	}\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if evalSameValueZero(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// clampSliceRange normalizes JS `.slice(start, end?)` bounds against a\n// receiver of `length` elements (runes, for the string branch of\n// `Slice` below; array elements, for the array branch) \u2014 shared so\n// both branches clamp identically.\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\nfunc clampSliceRange(length, start int, end []int) (int, int) {\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n	return start, stop\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A) AND\n// `String.prototype.slice(start, end?)` (the `string-slice`\n// divergence) \u2014 the adapter emits the same `bf_slice` call for both\n// receiver shapes (it can\'t disambiguate string vs. array at compile\n// time), so this helper dispatches at runtime on `reflect.Kind()`,\n// mirroring `Includes` above. The variadic `end` arg lets Go\n// template\'s call dispatcher pass either 2 or 3 arguments; an absent\n// end means "to length".\n//\n// String length/positions are measured in runes, not UTF-16 code\n// units \u2014 the same divergence boundary `padTo` already accepts\n// (differs from JS only for astral-plane input). `start >= end`\n// (after clamping) returns an empty result for either receiver.\n//\n// Any other receiver kind returns an empty `[]any`.\nfunc Slice(items any, start int, end ...int) any {\n	v := reflect.ValueOf(items)\n\n	if v.Kind() == reflect.String {\n		runes := []rune(v.String())\n		s, e := clampSliceRange(len(runes), start, end)\n		if s >= e {\n			return ""\n		}\n		return string(runes[s:e])\n	}\n\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	s, e := clampSliceRange(v.Len(), start, end)\n	if s >= e {\n		return []any{}\n	}\n	out := make([]any, 0, e-s)\n	for i := s; i < e; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// Flat flattens nested slices/arrays `depth` levels deep. Lowers\n// `Array.prototype.flat(depth?)` (#1448 Tier C). A `depth` of `-1` is the\n// `Infinity` sentinel (flatten fully); `0` (or negative-from-JS, already\n// normalised to 0 at compile time) returns a shallow copy. Non-array\n// elements are kept as-is (JS only flattens nested arrays). A non-array\n// receiver returns an empty `[]any`.\nfunc Flat(items any, depth int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		ev := reflect.ValueOf(el)\n		if depth != 0 && (ev.Kind() == reflect.Slice || ev.Kind() == reflect.Array) {\n			// `-1` (Infinity) recurses unbounded; a finite depth spends one level.\n			next := depth\n			if depth > 0 {\n				next = depth - 1\n			}\n			out = append(out, Flat(el, next)...)\n		} else {\n			out = append(out, el)\n		}\n	}\n	return out\n}\n\n// FlatDynamicDepth coerces `depth` via JS\'s `ToIntegerOrInfinity` and\n// flattens `items` that many levels. Lowers a DYNAMIC `.flat(depth)`\n// (#2094) \u2014 one whose depth isn\'t a compile-time literal, so (unlike\n// `Flat` above) the coercion happens here at render time instead of in the\n// parser.\n//\n// This is a SEPARATE helper from `Flat`/`bf_flat` \u2014 NOT a drop-in\n// replacement \u2014 because `Flat`\'s `depth int` parameter treats `-1` as a\n// compile-time SENTINEL meaning "flatten fully" (the parser\'s own\n// normalisation of a literal `Infinity`). A genuinely dynamic depth value\n// of `-1` means the JS-correct OPPOSITE: `Array.prototype.flat(-1)` never\n// recurses (same as `.flat(0)`, a shallow copy), because\n// `FlattenIntoArray` only recurses when `depth > 0`. Reusing `Flat`\'s int\n// contract for a raw dynamic value would silently invert that case, so\n// this function coerces FIRST \u2014 mapping a real `+Infinity` / huge finite\n// value to `Flat`\'s own `-1` sentinel, and a real negative value to `0` \u2014\n// and only then delegates to `Flat`\'s recursion.\n//\n// Coercion rules (JS `ToIntegerOrInfinity`, mirrored exactly; pinned by the\n// `flat_dynamic` golden-vector cases in\n// packages/adapter-tests/vectors/cases.ts):\n//   - the value converts via `ToNumber` first (numeric string / bool /\n//     number all coerce; see `flatDepthToFloat`);\n//   - a NaN result (including a non-numeric string) \u2192 `0`;\n//   - truncates toward zero (`2.7` \u2192 `2`);\n//   - negative \u2192 `0`;\n//   - `+Infinity` / a huge finite value \u2192 flattens fully.\nfunc FlatDynamicDepth(items any, depth any) []any {\n	return Flat(items, coerceFlatDepth(depth))\n}\n\n// coerceFlatDepth implements JS\'s `ToIntegerOrInfinity` for a dynamic\n// `.flat(depth)` argument, returning an int in `Flat`\'s own contract (`-1`\n// = unbounded, `>= 0` = that many levels).\nfunc coerceFlatDepth(depth any) int {\n	f, ok := flatDepthToFloat(depth)\n	if !ok || math.IsNaN(f) {\n		return 0\n	}\n	if math.IsInf(f, 1) {\n		return -1 // Flat\'s "flatten fully" sentinel\n	}\n	if math.IsInf(f, -1) {\n		return 0\n	}\n	trunc := math.Trunc(f)\n	if trunc < 0 {\n		return 0\n	}\n	// A huge finite depth behaves identically to "flatten fully" in\n	// practice \u2014 real data bottoms out at its actual nesting depth long\n	// before a counter this large would ever reach zero. Capping it here\n	// avoids an absurd countdown without needing a second sentinel.\n	if trunc > 1_000_000 {\n		return -1\n	}\n	return int(trunc)\n}\n\n// flatDepthToFloat converts a dynamic `.flat(depth)` argument to a float64,\n// mirroring JS\'s `ToNumber` across the value shapes a Go template data\n// model can carry (every numeric kind, bool, numeric string). `ok` is\n// false for a shape `ToNumber` can\'t coerce meaningfully (`nil`, or a\n// non-numeric string) \u2014 `coerceFlatDepth` treats that the same as NaN\n// (\u2192 depth `0`), matching JS.\nfunc flatDepthToFloat(v any) (float64, bool) {\n	switch n := v.(type) {\n	case nil:\n		return 0, false\n	case float64:\n		return n, true\n	case float32:\n		return float64(n), true\n	case int:\n		return float64(n), true\n	case int8:\n		return float64(n), true\n	case int16:\n		return float64(n), true\n	case int32:\n		return float64(n), true\n	case int64:\n		return float64(n), true\n	case uint:\n		return float64(n), true\n	case uint8:\n		return float64(n), true\n	case uint16:\n		return float64(n), true\n	case uint32:\n		return float64(n), true\n	case uint64:\n		return float64(n), true\n	case bool:\n		if n {\n			return 1, true\n		}\n		return 0, true\n	case string:\n		s := strings.TrimSpace(n)\n		if s == "" {\n			return 0, true // JS: Number("") is 0\n		}\n		f, err := strconv.ParseFloat(s, 64)\n		if err != nil {\n			return 0, false // not numeric \u2192 NaN path\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// FlatMap projects each element through a `self` / `field` projection and\n// flattens the result one level. Lowers value-returning\n// `Array.prototype.flatMap(fn)` for the field-projection catalogue\n// (#1448 Tier C): `items.flatMap(i => i)` (self) and\n// `items.flatMap(i => i.field)` (field). A projected non-array value is\n// kept as-is (flatMap = map + flat(1)). Non-array receiver \u2192 empty.\nfunc FlatMap(items any, keyKind, keyName string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	projected := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		if keyKind == "field" {\n			projected = append(projected, getFieldValue(el, keyName))\n		} else {\n			projected = append(projected, el)\n		}\n	}\n	return Flat(projected, 1)\n}\n\n// FlatMapTuple lowers an array-literal flatMap projection\n// `items.flatMap(i => [i.a, i.b])` (#1448 Tier C). `specs` is a flat list\n// of (kind, name) pairs, one per array-literal leaf: ("self", "") for the\n// item itself, ("field", "<Name>") for a struct field. For each item it\n// appends every leaf\'s value in order. Unlike the scalar `FlatMap`, the\n// per-item array is flattened only one level (flat(1) removes the literal\n// wrapper), so an array-valued leaf is appended verbatim rather than\n// spread \u2014 which is exactly "append each leaf". Non-array receiver \u2192 empty.\nfunc FlatMapTuple(items any, specs ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		for j := 0; j+1 < len(specs); j += 2 {\n			if specs[j] == "field" {\n				out = append(out, getFieldValue(el, specs[j+1]))\n			} else {\n				out = append(out, el)\n			}\n		}\n	}\n	return out\n}\n\n// First returns the first element of a slice, or nil if empty.\nfunc First(items any) any {\n	return At(items, 0)\n}\n\n// Last returns the last element of a slice, or nil if empty.\nfunc Last(items any) any {\n	return At(items, -1)\n}\n\n// Arr builds an []any from variadic args. Used to lower JS array\n// literals like `[a, b]` for the registry Slot\'s\n// `[className, childClass].filter(Boolean).join(\' \')` shape (#1443) \u2014\n// Go templates have no array-literal syntax, so the codegen routes\n// array-literal IR nodes through this helper.\nfunc Arr(items ...any) []any {\n	return items\n}\n\n// FilterTruthy returns a new slice containing only truthy items.\n// Mirrors `arr.filter(Boolean)` semantics: drop nil, false, 0, "" \u2014 the\n// same falsy set JavaScript\'s `Boolean(x)` recognises. Used to lower\n// the registry Slot\'s class-merge pattern (#1443); generalising to\n// arbitrary callable predicates would need the callee-resolution path\n// blocked by #1389, so this stays Boolean-specific.\nfunc FilterTruthy(items any) []any {\n	v := reflect.ValueOf(items)\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	result := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		raw := v.Index(i).Interface()\n		if isTruthy(raw) {\n			result = append(result, raw)\n		}\n	}\n	return result\n}\n\n// Truthy is the exported form of isTruthy \u2014 JavaScript\'s `Boolean(x)`\n// semantics \u2014 for generated `NewXxxProps` code lowering a conditional\n// inline-object spread condition on an `interface{}` prop (whose runtime\n// value may be a string, number, bool, \u2026). Keeps the spread bag\'s\n// inclusion test faithful to JS rather than string-biased (#1752).\nfunc Truthy(v any) bool { return isTruthy(v) }\n\n// isTruthy mirrors JavaScript\'s `Boolean(x)` for the value shapes the\n// template path actually receives \u2014 nil / false / 0 / "" are falsy.\n// Other shapes (non-empty maps, slices, structs, true) are truthy, in\n// line with JS\'s "objects are truthy" rule.\nfunc isTruthy(v any) bool {\n	if v == nil {\n		return false\n	}\n	switch x := v.(type) {\n	case bool:\n		return x\n	case string:\n		return x != ""\n	case int:\n		return x != 0\n	case int8, int16, int32, int64:\n		return reflect.ValueOf(v).Int() != 0\n	case uint, uint8, uint16, uint32, uint64:\n		return reflect.ValueOf(v).Uint() != 0\n	case float32:\n		// JS `Boolean(NaN)` is false regardless of float width \u2014 the\n		// float64 arm below was the only one checking IsNaN, which\n		// diverged from JS for `float32` NaN inputs (Copilot review on\n		// #1445). Widening to float64 for the IsNaN check keeps the\n		// two branches in lock-step.\n		return x != 0 && !math.IsNaN(float64(x))\n	case float64:\n		return x != 0 && !math.IsNaN(x)\n	}\n	return true\n}\n\n// =============================================================================\n// Higher-order Array Methods\n// =============================================================================\n\n// fieldValue projects item.field for the higher-order predicate\n// helpers. The field name arrives in JS casing; structs resolve via\n// the capitalized Go convention (FieldByName inside getFieldValue),\n// maps via getFieldValue\'s case-variant lookup \u2014 the same dual\n// support Sort/Reduce gained in #1487, extended here so JSON-decoded\n// data (map items) participates instead of being silently skipped.\n// nil-safe: missing fields and nil items project to nil.\nfunc fieldValue(item any, field string) any {\n	return getFieldValue(item, capitalize(field))\n}\n\n// Every returns true if every item\'s field is truthy under JS\n// `Boolean(item.field)` semantics. Mirrors JavaScript\'s\n// Array.prototype.every(item => item.field) \u2014 including being\n// vacuously true for an empty receiver.\nfunc Every(items any, field string) bool {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if !isTruthy(fieldValue(v.Index(i).Interface(), field)) {\n			return false\n		}\n	}\n	return true\n}\n\n// Some returns true if at least one item\'s field is truthy. Mirrors\n// JavaScript\'s Array.prototype.some(item => item.field).\nfunc Some(items any, field string) bool {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if isTruthy(fieldValue(v.Index(i).Interface(), field)) {\n			return true\n		}\n	}\n	return false\n}\n\n// Filter returns items where item.field == value.\n// Mirrors JavaScript\'s Array.prototype.filter(item => item.field === value).\n// Returns []any to allow chaining with other bf_* functions.\nfunc Filter(items any, field string, value any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	var result []any\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			result = append(result, item)\n		}\n	}\n	return result\n}\n\n// Find returns the first item where item.field == value, or nil if not found.\n// Mirrors JavaScript\'s Array.prototype.find(item => item.field === value).\nfunc Find(items any, field string, value any) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			return item\n		}\n	}\n	return nil\n}\n\n// FindIndex returns the index of the first item where item.field == value, or -1.\n// Mirrors JavaScript\'s Array.prototype.findIndex(item => item.field === value).\nfunc FindIndex(items any, field string, value any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(fieldValue(v.Index(i).Interface(), field), value) {\n			return i\n		}\n	}\n	return -1\n}\n\n// FindLast returns the last item where item.field == value, or nil if not found.\n// Mirrors JavaScript\'s Array.prototype.findLast(item => item.field === value).\nfunc FindLast(items any, field string, value any) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			return item\n		}\n	}\n	return nil\n}\n\n// FindLastIndex returns the index of the last item where item.field == value, or -1.\n// Mirrors JavaScript\'s Array.prototype.findLastIndex(item => item.field === value).\nfunc FindLastIndex(items any, field string, value any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(fieldValue(v.Index(i).Interface(), field), value) {\n			return i\n		}\n	}\n	return -1\n}\n\n// sortKeySpec is one parsed comparison key. A simple comparator has\n// one; a `||`-chained multi-key comparator has several, applied in\n// order as tie-breakers.\ntype sortKeySpec struct {\n	kind        string // "self" | "field"\n	name        string // capitalised field name, or "" for "self"\n	compareType string // "numeric" | "string" | "auto"\n	direction   string // "asc" | "desc"\n}\n\n// Sort returns a new stable-sorted slice. Lowers\n// `Array.prototype.sort` / `Array.prototype.toSorted` (#1448 Tier B).\n// Non-mutating \u2014 JS\'s mutate-vs-new distinction is moot in SSR\n// template context (templates render a snapshot).\n//\n// Call shape (the compiler emits one 4-string group per key):\n//\n//	bf_sort <items> (<keyKind> <keyName> <compareType> <direction>)+\n//\n//	keyKind:      "self" | "field"\n//	keyName:      "" when keyKind == "self"; capitalised struct field\n//	              name (e.g. "Price") otherwise\n//	compareType:  "numeric" | "string" | "auto"\n//	direction:    "asc" | "desc"\n//\n// The groups cover the accepted comparator catalogue: `a.f - b.f`,\n// `a - b`, `a[.f].localeCompare(b[.f])`, and relational-ternary keys\n// (`a.f > b.f ? 1 : -1` \u2192 "auto"), each `||`-chainable for multi-key\n// tie-breaks. Anything outside refuses at compile time (BF101 from the\n// JSX compiler) and never reaches this helper.\n//\n// "auto" compares numerically when both projected keys parse as\n// numbers, else lexically \u2014 mirroring the Perl `bf->sort` helper\'s\n// `looks_like_number` rule so the two template adapters stay\n// byte-equal. This diverges from JS `<`/`>` only for numeric strings.\n//\n// A future `nulls` knob can extend the per-key group without rewriting\n// existing call sites \u2014 each key already projects before comparing.\nfunc Sort(items any, spec ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return []any{}\n	}\n\n	// Copy into a fresh []any so the sort is non-mutating regardless\n	// of whether the receiver is `[]T` or `[]any`.\n	result := make([]any, length)\n	for i := 0; i < length; i++ {\n		result[i] = v.Index(i).Interface()\n	}\n\n	keys := parseSortSpec(spec)\n	sort.SliceStable(result, func(i, j int) bool {\n		for _, k := range keys {\n			ki := projectSortKey(result[i], k.kind, k.name)\n			kj := projectSortKey(result[j], k.kind, k.name)\n			c := compareSortKey(ki, kj, k.compareType)\n			if c == 0 {\n				continue // tie on this key \u2014 fall through to the next\n			}\n			if k.direction == "desc" {\n				return c > 0\n			}\n			return c < 0\n		}\n		return false\n	})\n\n	return result\n}\n\n// parseSortSpec chunks the variadic operand list into 4-string key\n// groups. A trailing partial group (malformed emit) is ignored rather\n// than panicking \u2014 defensive, mirroring the helper\'s nil-safe stance.\nfunc parseSortSpec(spec []string) []sortKeySpec {\n	var keys []sortKeySpec\n	for i := 0; i+3 < len(spec); i += 4 {\n		keys = append(keys, sortKeySpec{\n			kind:        spec[i],\n			name:        spec[i+1],\n			compareType: spec[i+2],\n			direction:   spec[i+3],\n		})\n	}\n	return keys\n}\n\n// compareSortKey returns -1 / 0 / 1 for two projected keys under the\n// given compare type (ascending orientation; the caller flips for\n// "desc"). "string" stringifies both (nil \u2192 "", matching the\n// documented `bf->string(undef) === ""` divergence). "auto" compares\n// numerically when both parse as numbers, else lexically.\nfunc compareSortKey(ki, kj any, compareType string) int {\n	switch compareType {\n	case "string":\n		return strings.Compare(toString(ki), toString(kj))\n	case "auto":\n		ni, okI := toFloat64WithOK(ki)\n		nj, okJ := toFloat64WithOK(kj)\n		if okI && okJ {\n			return cmpFloat(ni, nj)\n		}\n		return strings.Compare(toString(ki), toString(kj))\n	default: // numeric\n		return cmpFloat(toFloat64(ki), toFloat64(kj))\n	}\n}\n\nfunc cmpFloat(a, b float64) int {\n	if a < b {\n		return -1\n	}\n	if a > b {\n		return 1\n	}\n	return 0\n}\n\n// toFloat64WithOK reports a value\'s numeric float and whether it is\n// number-like. Genuine numeric kinds always qualify; strings qualify\n// when they parse as a float (so the "auto" compare path matches the\n// Perl `looks_like_number` rule). Everything else is non-numeric.\nfunc toFloat64WithOK(v any) (float64, bool) {\n	switch n := v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:\n		return toFloat64(v), true\n	case string:\n		f, err := strconv.ParseFloat(strings.TrimSpace(n), 64)\n		if err != nil {\n			return 0, false\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// projectSortKey reduces an item to the value the comparator\n// actually compares. For `keyKind == "field"` it reads the named\n// struct field; for `keyKind == "self"` (primitive arrays) it\n// returns the item unchanged.\nfunc projectSortKey(item any, keyKind, keyName string) any {\n	if keyKind == "field" {\n		return getFieldValue(item, keyName)\n	}\n	return item\n}\n\n// getFieldValue extracts a struct field value using reflection. For\n// map receivers it falls back to case-variant lookup so JSON-decoded\n// user data (`map[string]any{"price": 30}`) and PascalCase-emitted\n// test data both resolve under a single key name. (#1487)\nfunc getFieldValue(item any, field string) any {\n	v := reflect.ValueOf(item)\n	// Defensive IsNil guards mirror `SpreadAttrs` \u2014 keeps the helper\n	// safe against typed-nil pointer / nil-interface items inside a\n	// `[]any` so a single bad row doesn\'t crash the whole sort.\n	if v.Kind() == reflect.Interface {\n		if v.IsNil() {\n			return nil\n		}\n		v = v.Elem()\n	}\n	if v.Kind() == reflect.Ptr {\n		if v.IsNil() {\n			return nil\n		}\n		v = v.Elem()\n	}\n\n	if v.Kind() == reflect.Map {\n		keyType := v.Type().Key()\n		if keyType.Kind() != reflect.String {\n			return nil\n		}\n		// Convert the lookup string to the map\'s actual key type so\n		// maps keyed by a named string type (`type Key string`) don\'t\n		// panic with `value of type string is not assignable to type X`.\n		lookup := func(s string) (any, bool) {\n			k := reflect.ValueOf(s).Convert(keyType)\n			if mv := v.MapIndex(k); mv.IsValid() {\n				return mv.Interface(), true\n			}\n			return nil, false\n		}\n		if r, ok := lookup(field); ok {\n			return r\n		}\n		if cap := capitalize(field); cap != field {\n			if r, ok := lookup(cap); ok {\n				return r\n			}\n		}\n		if low := decapitalize(field); low != field {\n			if r, ok := lookup(low); ok {\n				return r\n			}\n		}\n		// All-lowercase fallback: a Go-initialism field projects as an\n		// all-caps key (`id` \u2192 `ID`), and `decapitalize("ID")` only\n		// lowers the first char (`iD`), so the JS-keyed map ("id") still\n		// misses. Try the fully-lowered key last to resolve it.\n		if lower := strings.ToLower(field); lower != field && lower != decapitalize(field) {\n			if r, ok := lookup(lower); ok {\n				return r\n			}\n		}\n		return nil\n	}\n\n	if v.Kind() != reflect.Struct {\n		return nil\n	}\n\n	fieldVal := v.FieldByName(field)\n	if !fieldVal.IsValid() {\n		// Case-variant fallback: the evaluator carries the JS field name\n		// (`id` / `url`) against a Go-capitalised struct field (`ID` / `URL`),\n		// which exact `FieldByName` misses and the initialism rules can\'t be\n		// reproduced char-for-char here. Match case-insensitively instead \u2014\n		// `FieldByNameFunc` returns the zero Value (\u2192 nil) for an ambiguous\n		// match, so it stays safe. The legacy bf_sort/bf_reduce pass an\n		// already-capitalised name, so they hit the exact match above and never\n		// reach this fallback.\n		fieldVal = v.FieldByNameFunc(func(n string) bool { return strings.EqualFold(n, field) })\n		if !fieldVal.IsValid() {\n			return nil\n		}\n	}\n	return fieldVal.Interface()\n}\n\n// AsMap normalizes a dynamically-typed prop value into a\n// map[string]interface{} for object-valued context bindings\n// (`lowerProviderMapMemberValue`, go-template-adapter.ts). A caller-side\n// `interface{}` field can legally hold ANY string-keyed map kind \u2014 a Go\n// handler modelling `Record<string, string>` naturally passes\n// map[string]string \u2014 so a bare `.(map[string]interface{})` type assertion\n// would silently drop provided values (#2111 review). Returns nil (never an\n// empty map) when the value is absent \u2014 nil interface, typed-nil map or\n// pointer, or any non-map / non-string-keyed value \u2014 so the generated\n// `?? {}` fallback can distinguish "missing" (fall back) from "present but\n// empty" (use as-is). map[string]interface{} passes through without copying.\nfunc AsMap(v any) map[string]interface{} {\n	if v == nil {\n		return nil\n	}\n	if m, ok := v.(map[string]interface{}); ok {\n		if m == nil {\n			return nil\n		}\n		return m\n	}\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		if rv.IsNil() {\n			return nil\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map || rv.Type().Key().Kind() != reflect.String || rv.IsNil() {\n		return nil\n	}\n	out := make(map[string]interface{}, rv.Len())\n	iter := rv.MapRange()\n	for iter.Next() {\n		out[iter.Key().String()] = iter.Value().Interface()\n	}\n	return out\n}\n\n// capitalize uppercases the first character of a string.\nfunc capitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToUpper(s[:1]) + s[1:]\n}\n\n// decapitalize lowercases the first character of a string. Used by\n// `getFieldValue`\'s map-receiver fallback when the projected key\n// name is PascalCase but the receiver carries lowercase JS-style\n// keys (the inverse of the `capitalize` lookup).\nfunc decapitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToLower(s[:1]) + s[1:]\n}\n\n// Reduce folds an array into a scalar via the arithmetic-fold\n// catalogue (#1448 Tier C). It lowers `Array.prototype.reduce(fn, init)`\n// and `Array.prototype.reduceRight(fn, init)` for the shapes\n// `(acc, x) => acc <op> x` and `(acc, x) => acc <op> x.field`:\n//\n//	bf_reduce <items> "<op>" "<keyKind>" "<keyName>" "<type>" "<init>" "<direction>"\n//\n//	direction: "left" (reduce) | "right" (reduceRight). Only changes the\n//	           result for string concatenation; numeric folds commute.\n//\n//	op:       "+" | "*"\n//	keyKind:  "self" | "field"\n//	keyName:  "" when keyKind == "self"; capitalised struct field name\n//	          (e.g. "Duration") otherwise\n//	type:     "numeric" | "string"\n//	init:     the fold\'s start value \u2014 the compiler emits the *decoded*\n//	          seed, so numeric inits arrive as canonical decimal\n//	          (`1_000`/`0x10` already normalised to `1000`/`16`) that\n//	          ParseFloat accepts, and string inits arrive as escape-free\n//	          contents\n//\n// Numeric folds accumulate as float64; each projected key is read via\n// `toFloat64WithOK`, so numeric *strings* ("5" \u2192 5) parse and\n// non-numeric values fold as 0 \u2014 matching Perl\'s\n// `looks_like_number ? $n : 0` so the two template adapters stay\n// byte-equal. String folds concatenate (toString per projected key,\n// matching the documented `bf->string(undef) === ""` convention). The\n// init seeds the accumulator, so an empty receiver returns the init\n// unchanged \u2014 exactly like JS `reduce(fn, init)`. Anything outside the\n// catalogue refuses at compile time (BF101 from the JSX compiler) and\n// never reaches here.\n//\n// Two documented divergences from the JS / Hono path, both rare and\n// mirroring the `bf_sort` "auto" caveat:\n//   - float64 stringification differs for sums whose binary expansion\n//     isn\'t exact (e.g. 0.1 + 0.2);\n//   - numeric-*string* keys fold numerically here, but JS `+`\n//     string-concatenates once an operand is a string, so\n//     numeric-string data can render differently under CSR.\n//\n// Genuine numbers \u2014 the common SSR case \u2014 agree across all three.\nfunc Reduce(items any, op, keyKind, keyName, typ, init, direction string) any {\n	v := reflect.ValueOf(items)\n	isSlice := v.Kind() == reflect.Slice || v.Kind() == reflect.Array\n\n	// `direction == "right"` (reduceRight) folds right-to-left. Only\n	// observable for string concatenation \u2014 numeric sum / product are\n	// commutative, so the order doesn\'t change the result there. Build a\n	// start/stop/step triple so both folds share one loop shape.\n	start, stop, step := 0, 0, 1\n	if isSlice {\n		stop = v.Len()\n		if direction == "right" {\n			start, stop, step = v.Len()-1, -1, -1\n		}\n	}\n\n	if typ == "string" {\n		acc := init\n		if isSlice {\n			for i := start; i != stop; i += step {\n				key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n				acc += toString(key)\n			}\n		}\n		return acc\n	}\n\n	// numeric fold\n	acc, _ := strconv.ParseFloat(strings.TrimSpace(init), 64)\n	if isSlice {\n		for i := start; i != stop; i += step {\n			key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n			// `toFloat64WithOK` parses numeric *strings* ("5" \u2192 5) and\n			// returns 0 for non-numeric values \u2014 mirroring Perl\'s\n			// `looks_like_number ? $n : 0` so numeric-string data folds\n			// byte-equal across adapters (the same rule `bf_sort`\'s\n			// "auto" compare uses). Plain `toFloat64` would zero "5".\n			n, _ := toFloat64WithOK(key)\n			if op == "*" {\n				acc *= n\n			} else {\n				acc += n\n			}\n		}\n	}\n	return acc\n}\n\n// =============================================================================\n// HTML/Template Helpers\n// =============================================================================\n\n// Comment returns an HTML comment string for hydration markers.\n// The "bf-" prefix is automatically added.\nfunc Comment(content string) template.HTML {\n	return template.HTML("<!--bf-" + content + "-->")\n}\n\n// TextStart returns an HTML comment start marker for reactive text expressions.\n// Format: <!--bf:slotId-->\nfunc TextStart(slotId string) template.HTML {\n	return template.HTML("<!--bf:" + slotId + "-->")\n}\n\n// TextEnd returns an HTML comment end marker for reactive text expressions.\n// Format: <!--/-->\nfunc TextEnd() template.HTML {\n	return "<!--/-->"\n}\n\n// ScopeComment emits a fragment-rooted scope marker. See spec/compiler.md\n// "Slot identity" for the wire format. Loud-fails on marshal errors\n// (same policy as JSON / BfPropsAttr).\nfunc ScopeComment(props interface{}) (template.HTML, error) {\n	scopeID := getStringField(props, "ScopeID")\n	hostSegment := ""\n	if host := getStringField(props, "BfParent"); host != "" {\n		mount := getStringField(props, "BfMount")\n		hostSegment = "|h=" + host + "|m=" + mount\n	}\n	propsJSON := ""\n	if getBoolField(props, "BfIsRoot") {\n		pJSON, err := json.Marshal(props)\n		if err != nil {\n			return "", err\n		}\n		propsJSON = "|" + string(pJSON)\n	}\n	return template.HTML("<!--bf-scope:" + scopeID + hostSegment + propsJSON + "-->"), nil\n}\n\n// TemplateFuncMap returns the helpers that need access to the executing\n// template set itself, closed over the *template.Template the component\n// defines are parsed into. Register it alongside FuncMap BEFORE parsing:\n//\n//	t := template.New("")\n//	t.Funcs(bf.FuncMap()).Funcs(bf.TemplateFuncMap(t))\n//	template.Must(t.Parse(src))\n//\n// bf_tmpl executes a named define from the same set and returns its\n// output \u2014 used for the per-call-site children defines the Go adapter\n// emits when JSX children passed to an imported component contain\n// template actions (nested components, dynamic text) and therefore\n// cannot be baked to a static HTML string (#1896). Reentrant execution\n// of an html/template set from inside a FuncMap function is safe: the\n// escape analysis over every define completes before the outer\n// Execute begins evaluating.\nfunc TemplateFuncMap(t *template.Template) template.FuncMap {\n	return template.FuncMap{\n		"bf_tmpl": func(name string, data interface{}) (template.HTML, error) {\n			var buf bytes.Buffer\n			if err := t.ExecuteTemplate(&buf, name, data); err != nil {\n				return "", err\n			}\n			return template.HTML(buf.String()), nil\n		},\n	}\n}\n\n// WithChildren returns a shallow copy of a component Props struct with its\n// Children field replaced by the given pre-rendered fragment (#1896). The\n// props value stays by-value semantics: callers\' originals are untouched.\n// A props type without a Children field passes through unchanged \u2014 the\n// child template then simply has no children to render, matching the\n// pre-#1896 behaviour.\nfunc WithChildren(props interface{}, children template.HTML) (interface{}, error) {\n	v := reflect.ValueOf(props)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return props, nil\n	}\n	field := v.FieldByName("Children")\n	if !field.IsValid() {\n		return props, nil\n	}\n	copyPtr := reflect.New(v.Type())\n	copyPtr.Elem().Set(v)\n	target := copyPtr.Elem().FieldByName("Children")\n	switch {\n	case target.Kind() == reflect.Interface:\n		target.Set(reflect.ValueOf(children))\n	case target.Kind() == reflect.String:\n		// Covers both `string` and `template.HTML`-typed fields.\n		target.SetString(string(children))\n	default:\n		return props, fmt.Errorf("bf_with_children: unsupported Children field type %s", target.Type())\n	}\n	return copyPtr.Elem().Interface(), nil\n}\n\n// PortalHTML parses and executes a template string with the provided data.\n// Used for rendering dynamic portal content where the template string\n// contains Go template expressions (e.g., {{if .Open}}open{{end}}).\n//\n// The template string is parsed fresh each time to support dynamic content.\n// Standard Go template functions (if, range, eq, etc.) are available.\nfunc PortalHTML(data interface{}, tmplStr string) template.HTML {\n	// Create a new template with the FuncMap for custom functions\n	t, err := template.New("portal").Funcs(FuncMap()).Parse(tmplStr)\n	if err != nil {\n		// Return error message as HTML comment for debugging\n		return template.HTML("<!-- bfPortalHTML error: " + err.Error() + " -->")\n	}\n\n	var buf bytes.Buffer\n	if err := t.Execute(&buf, data); err != nil {\n		return template.HTML("<!-- bfPortalHTML exec error: " + err.Error() + " -->")\n	}\n\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Portal Collection\n// =============================================================================\n\n// PortalContent represents a single portal\'s content to be rendered at body end.\ntype PortalContent struct {\n	ID      string        // Unique portal ID for hydration matching\n	OwnerID string        // Owner scope ID for find() support\n	Content template.HTML // Portal HTML content\n}\n\n// PortalCollector collects portal content during template rendering.\n// Portal content is rendered at </body> to avoid z-index issues.\ntype PortalCollector struct {\n	portals []PortalContent\n	counter int\n}\n\n// NewPortalCollector creates a new PortalCollector.\nfunc NewPortalCollector() *PortalCollector {\n	return &PortalCollector{\n		portals: []PortalContent{},\n		counter: 0,\n	}\n}\n\n// Add registers portal content to be rendered at body end.\nfunc (pc *PortalCollector) Add(ownerID string, content template.HTML) string {\n	pc.counter++\n	id := "bf-portal-" + strconv.Itoa(pc.counter)\n	pc.portals = append(pc.portals, PortalContent{\n		ID:      id,\n		OwnerID: ownerID,\n		Content: content,\n	})\n	return "" // Return empty string for template use\n}\n\n// Render outputs all collected portals as HTML.\n// Each portal is wrapped in a div with bf-pi (portal ID) and bf-po (portal owner).\nfunc (pc *PortalCollector) Render() template.HTML {\n	if pc == nil || len(pc.portals) == 0 {\n		return ""\n	}\n	var buf strings.Builder\n	for _, p := range pc.portals {\n		buf.WriteString(`<div bf-pi="`)\n		buf.WriteString(p.ID)\n		buf.WriteString(`" bf-po="`)\n		buf.WriteString(p.OwnerID)\n		buf.WriteString(`">`)\n		buf.WriteString(string(p.Content))\n		buf.WriteString("</div>\\n")\n	}\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Script Collection\n// =============================================================================\n\n// ScriptCollector collects client scripts with deduplication.\n// It preserves insertion order for deterministic output.\ntype ScriptCollector struct {\n	scripts map[string]bool\n	order   []string\n}\n\n// NewScriptCollector creates a new ScriptCollector.\nfunc NewScriptCollector() *ScriptCollector {\n	return &ScriptCollector{\n		scripts: make(map[string]bool),\n		order:   []string{},\n	}\n}\n\n// Register adds a script source to the collection.\n// Duplicate scripts are ignored (only first registration counts).\nfunc (sc *ScriptCollector) Register(src string) string {\n	if sc.scripts[src] {\n		return "" // Already registered\n	}\n	sc.scripts[src] = true\n	sc.order = append(sc.order, src)\n	return "" // Return empty string for template use\n}\n\n// Scripts returns all registered scripts in insertion order.\nfunc (sc *ScriptCollector) Scripts() []string {\n	return sc.order\n}\n\n// BfScripts generates script tags for all registered scripts.\n// Returns HTML safe for embedding in templates.\nfunc BfScripts(collector *ScriptCollector) template.HTML {\n	if collector == nil {\n		return ""\n	}\n	var result strings.Builder\n	for _, src := range collector.Scripts() {\n		result.WriteString(`<script type="module" src="`)\n		result.WriteString(src)\n		result.WriteString(`"></script>`)\n		result.WriteString("\\n")\n	}\n	return template.HTML(result.String())\n}\n\n// =============================================================================\n// Component Renderer\n// =============================================================================\n\n// RenderContext contains all data needed to render a component page.\n// The layout function receives this context to build the final HTML.\ntype RenderContext struct {\n	// ComponentName is the template name being rendered\n	ComponentName string\n\n	// Props is the component props (for layout to access if needed)\n	Props interface{}\n\n	// ComponentHTML is the rendered component template output\n	ComponentHTML template.HTML\n\n	// Portals contains collected portal content to render at body end\n	Portals template.HTML\n\n	// Scripts contains the collected JS script tags\n	Scripts template.HTML\n\n	// Title is the page title (defaults to "{ComponentName} - BarefootJS")\n	Title string\n\n	// Heading is the page heading. Empty string means no heading.\n	Heading string\n\n	// Extra holds additional user-defined data for the layout\n	Extra map[string]interface{}\n}\n\n// LayoutFunc renders the final HTML page given the render context.\ntype LayoutFunc func(ctx *RenderContext) string\n\n// Renderer renders BarefootJS components with a customizable layout.\ntype Renderer struct {\n	templates *template.Template\n	layout    LayoutFunc\n}\n\n// NewRenderer creates a Renderer with the given templates and layout function.\n//\n// Example usage:\n//\n//	renderer := bf.NewRenderer(templates, func(ctx *bf.RenderContext) string {\n//	    return fmt.Sprintf(`<!DOCTYPE html>\n//	<html>\n//	<head><title>%s</title></head>\n//	<body>%s%s</body>\n//	</html>`, ctx.Title, ctx.ComponentHTML, ctx.Scripts)\n//	})\nfunc NewRenderer(tmpl *template.Template, layout LayoutFunc) *Renderer {\n	return &Renderer{\n		templates: tmpl,\n		layout:    layout,\n	}\n}\n\n// RenderOptions configures a single render call.\ntype RenderOptions struct {\n	// ComponentName is the template name to render (required)\n	ComponentName string\n\n	// Props is the component props (must be a pointer to struct with Scripts field)\n	Props interface{}\n\n	// Title is the page title. If empty, defaults to "{ComponentName} - BarefootJS"\n	Title string\n\n	// Heading is the page heading. If empty, no heading is shown.\n	Heading string\n\n	// Extra holds additional data to pass to the layout\n	Extra map[string]interface{}\n}\n\n// Render renders a component to a full HTML page using the configured layout.\n// Child component props are automatically detected (any slice field with ScopeID/Scripts).\n// renderTemplateErrorPanel formats a Go template execution error into a\n// fragment of HTML that\'s visible in the browser. The panel is\n// HTML-escaped so a faulty template name (anything from `template:\n// "..."`) can\'t smuggle markup back into the page. Keep the styling\n// inline so the panel surfaces even when the project\'s CSS hasn\'t\n// loaded yet (e.g. the failure aborted before the stylesheet links\n// emitted).\n//\n// Surfaced for the #1442 echo repro: a template referencing\n// `.Todo.Done` (instead of the range dot\'s `.Done`) used to fail\n// silently \u2014 Go\'s html/template aborted mid-stream, the partial body\n// flushed as a 200, and the user saw a truncated list with no console\n// signal. With this panel they get the template name, the error\n// message, and a "what to look at" hint inline.\nfunc renderTemplateErrorPanel(componentName string, err error) string {\n	return `<div style="margin:1em 0;padding:1em;border:2px solid #d33;background:#fff5f5;color:#900;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:13px;line-height:1.5"><strong style="display:block;margin-bottom:.5em">Template error in <code>` +\n		template.HTMLEscapeString(componentName) +\n		`</code></strong><pre style="margin:0;white-space:pre-wrap;word-break:break-word">` +\n		template.HTMLEscapeString(err.Error()) +\n		`</pre><div style="margin-top:.75em;font-size:12px;opacity:.7">Common cause: a JSX expression referenced a name the adapter could not resolve to a struct field. Open the matching <code>dist/templates/*.tmpl</code> for the unresolved reference, then fix the source component.</div></div>`\n}\n\n// renderComponentInto wires a component\'s props (script/portal collectors,\n// child-slot scope ids + hydration, root marking) against the PROVIDED\n// collectors and returns just the component\'s HTML \u2014 no layout. Both Render\n// (one fresh collector pair per page) and RenderFragment (a shared pair across\n// several islands) funnel through here so their wiring stays identical.\nfunc (r *Renderer) renderComponentInto(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	// Inject the shared collectors into the props.\n	setScriptsField(opts.Props, scriptCollector)\n	setPortalsField(opts.Props, portalCollector)\n\n	// Auto-detect and process child component props (slices)\n	childSlices := findChildComponentSlices(opts.Props)\n	for _, slice := range childSlices {\n		setScopeIDsOnSlice(slice)\n		setScriptsOnSlice(slice, scriptCollector)\n		setPortalsOnSlice(slice, portalCollector)\n		setBoolOnSlice(slice, "BfIsChild", true)\n	}\n\n	// Auto-detect and process single child component props\n	singleChildren := findSingleChildComponents(opts.Props)\n	for _, child := range singleChildren {\n		setScopeIDOnSingle(child)\n		setScriptsOnSingle(child, scriptCollector)\n		setPortalsOnSingle(child, portalCollector)\n		setBoolField(child, "BfIsChild", true)\n	}\n\n	// Mark the root component so BfPropsAttr emits bf-p only for it\n	setBoolField(opts.Props, "BfIsRoot", true)\n\n	// Render the component template.\n	//\n	// Errors here are NOT silently dropped. The original implementation\n	// ignored the return value of `ExecuteTemplate`, which masked a real\n	// onboarding failure mode: a template referencing a non-existent\n	// field (`.Todo.Done` instead of the range dot\'s `.Done`) caused\n	// html/template to abort mid-stream, the partial output got\n	// returned, and the HTTP server happily flushed a 200 with a\n	// truncated body. No error log, no signal \u2014 the user just saw a\n	// blank list (#1442 echo TodoApp repro).\n	//\n	// Now we capture the error and replace the partial output with a\n	// visible inline panel (dev mode) or a fenced error comment\n	// (production), so the cause is on-screen and grep-able in logs.\n	// Either way the renderer also writes to stderr so structured log\n	// aggregators see it.\n	var componentBuf strings.Builder\n	if err := r.templates.ExecuteTemplate(&componentBuf, opts.ComponentName, opts.Props); err != nil {\n		fmt.Fprintf(os.Stderr, "barefoot: template %q failed to render: %v\\n", opts.ComponentName, err)\n		// Preserve whatever the template did manage to emit before\n		// failing (Go\'s text/template flushes incrementally), but\n		// follow it with a clearly-marked error block so the user\n		// notices something is wrong instead of seeing a silent\n		// truncation.\n		componentBuf.WriteString(renderTemplateErrorPanel(opts.ComponentName, err))\n	}\n\n	return template.HTML(componentBuf.String())\n}\n\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// One script + portal collector pair for the whole page.\n	scriptCollector := NewScriptCollector()\n	portalCollector := NewPortalCollector()\n\n	componentHTML := r.renderComponentInto(opts, scriptCollector, portalCollector)\n\n	// Determine title (default: "{ComponentName} - BarefootJS")\n	title := opts.Title\n	if title == "" {\n		title = opts.ComponentName + " - BarefootJS"\n	}\n\n	// Heading (empty means no heading)\n	heading := opts.Heading\n\n	// Build render context\n	ctx := &RenderContext{\n		ComponentName: opts.ComponentName,\n		Props:         opts.Props,\n		ComponentHTML: componentHTML,\n		Portals:       portalCollector.Render(),\n		Scripts:       BfScripts(scriptCollector),\n		Title:         title,\n		Heading:       heading,\n		Extra:         opts.Extra,\n	}\n\n	return r.layout(ctx)\n}\n\n// RenderFragment renders a single island subtree into the caller-provided\n// script and portal collectors and returns just its HTML \u2014 no page layout.\n//\n// It exists for hand-authored "region shell" pages (the `@barefootjs/router`\n// showcase): a layout that places several independent islands \u2014 e.g. a header\n// ThemeToggle, an `<aside bf-region>` Sidebar, and a `<PageShell>` wrapping the\n// route content \u2014 must collect ALL their scripts and portals into ONE place so\n// the runtime (`barefoot.js`) and each island\'s client JS are emitted exactly\n// once and share a single reactive instance. Render each island with the same\n// collectors, splice the returned HTML into the shell, then emit\n// `BfScripts(sc)` and `pc.Render()` once at the end of the document.\n//\n// Each fragment is treated as its own root (it emits `bf-p` like any top-level\n// island); nested children declared in its props are wired as children, exactly\n// as in Render.\nfunc (r *Renderer) RenderFragment(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	return r.renderComponentInto(opts, scriptCollector, portalCollector)\n}\n\n// setScriptsField sets the Scripts field on a struct using reflection.\nfunc setScriptsField(v interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Scripts")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// setPortalsField sets the Portals field on a struct using reflection.\nfunc setPortalsField(v interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Portals")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// getStringField extracts a string field from a struct using reflection.\nfunc setBoolField(v interface{}, fieldName string, val bool) {\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Struct {\n		return\n	}\n	field := rv.FieldByName(fieldName)\n	if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n		field.SetBool(val)\n	}\n}\n\nfunc getBoolField(v interface{}, fieldName string) bool {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return false\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.Bool {\n		return false\n	}\n	return field.Bool()\n}\n\nfunc getStringField(v interface{}, fieldName string) string {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return ""\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.String {\n		return ""\n	}\n	return field.String()\n}\n\n// scopeIDChars is the alphabet for auto-generated ScopeID suffixes. It\n// mirrors the `randomID` helper the go-template adapter emits into the\n// generated New<Component>Props constructors so runtime-assigned and\n// constructor-assigned ids are indistinguishable.\nconst scopeIDChars = "abcdefghijklmnopqrstuvwxyz0123456789"\n\n// randomScopeSuffix returns a random lowercase-alphanumeric string of\n// length n. math/rand (auto-seeded since Go 1.20) is sufficient here: the\n// suffix only needs to be unique enough to keep a page\'s bf-s scope ids\n// from colliding, not cryptographically unpredictable.\nfunc randomScopeSuffix(n int) string {\n	b := make([]byte, n)\n	for i := range b {\n		b[i] = scopeIDChars[rand.Intn(len(scopeIDChars))]\n	}\n	return string(b)\n}\n\n// scopeIDPrefix derives the human-readable ScopeID prefix from a child\n// component\'s type, e.g. `TodoItemProps` \u2192 `TodoItem`. Matches the\n// `"<Component>_" + randomID(6)` shape the generated constructors use.\nfunc scopeIDPrefix(t reflect.Type) string {\n	for t.Kind() == reflect.Ptr {\n		t = t.Elem()\n	}\n	return strings.TrimSuffix(t.Name(), "Props")\n}\n\n// assignScopeID fills a child component\'s ScopeID with a generated id when\n// the caller left it empty, so application code doesn\'t have to mint scope\n// ids by hand (the parent\'s New<Component>Props constructor does the same\n// for components built through it). A non-empty ScopeID is left untouched,\n// so callers can still pin a stable id when they need one.\nfunc assignScopeID(structVal reflect.Value, prefix string) {\n	field := structVal.FieldByName("ScopeID")\n	if !field.IsValid() || !field.CanSet() || field.Kind() != reflect.String {\n		return\n	}\n	if field.String() != "" {\n		return\n	}\n	id := randomScopeSuffix(6)\n	if prefix != "" {\n		id = prefix + "_" + id\n	}\n	field.SetString(id)\n}\n\n// setScopeIDsOnSlice assigns a generated ScopeID to every child in a slice\n// whose ScopeID is empty.\nfunc setScopeIDsOnSlice(slice interface{}) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	prefix := scopeIDPrefix(v.Type().Elem())\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			assignScopeID(item, prefix)\n		}\n	}\n}\n\n// setScopeIDOnSingle assigns a generated ScopeID to a single child\n// component when its ScopeID is empty.\nfunc setScopeIDOnSingle(child interface{}) {\n	v := reflect.ValueOf(child)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return\n	}\n	assignScopeID(v, scopeIDPrefix(v.Type()))\n}\n\n// findChildComponentSlices finds slice fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findChildComponentSlices(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n		if field.Kind() != reflect.Slice || field.Len() == 0 {\n			continue\n		}\n\n		elem := field.Index(0)\n		if elem.Kind() == reflect.Ptr {\n			elem = elem.Elem()\n		}\n		if elem.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := elem.FieldByName("ScopeID").IsValid()\n		hasScripts := elem.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSlice sets Scripts on all items in a slice.\nfunc setScriptsOnSlice(slice interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Scripts")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// setBoolOnSlice sets a bool field on all items in a slice.\nfunc setBoolOnSlice(slice interface{}, fieldName string, val bool) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName(fieldName)\n			if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n				field.SetBool(val)\n			}\n		}\n	}\n}\n\n// setPortalsOnSlice sets Portals on all items in a slice.\nfunc setPortalsOnSlice(slice interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Portals")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		return ""\n	}\n}\n\n// =============================================================================\n// searchParams() \u2014 request-scoped environment signal (router v0.5, #1922)\n// =============================================================================\n\n// SearchParams is the SSR view of the request query string behind the\n// reactive searchParams() environment signal. The route handler builds it\n// from the request URL and assigns it to the component\'s SearchParams input\n// field; the generated template reads it via `.SearchParams.Get "key"`.\n//\n// The zero value is an empty query (url.Values.Get tolerates a nil map), so a\n// render with no request query \u2014 e.g. the adapter conformance harness, which\n// issues no query string \u2014 resolves every key to "", which the template\'s\n// `or`/`??` fallback turns into the author\'s default.\ntype SearchParams struct {\n	values url.Values\n}\n\n// NewSearchParams parses a raw query string (with or without a leading "?")\n// into a SearchParams. A malformed query yields an empty set rather than an\n// error, mirroring the browser\'s URLSearchParams, which never throws on junk.\n//\n// Typical handler use (net/http):\n//\n//	in := MyComponentInput{SearchParams: bf.NewSearchParams(r.URL.RawQuery)}\nfunc NewSearchParams(raw string) SearchParams {\n	raw = strings.TrimPrefix(raw, "?")\n	values, err := url.ParseQuery(raw)\n	if err != nil {\n		values = url.Values{}\n	}\n	return SearchParams{values: values}\n}\n\n// Get returns the first value associated with key, or "" when the key is\n// absent. This mirrors url.Values.Get, which also returns "" for a\n// present-but-empty value (`?sort=`). Safe on the zero value (nil map).\n//\n// This is not byte-for-byte URLSearchParams.get under the template\'s `??`\n// lowering. JS distinguishes absent (`null`) from present-but-empty (`""`):\n// `null ?? d` yields the default, but `"" ?? d` keeps the empty string. The\n// Go adapter lowers `??` to the `or` builtin \u2014 Go templates have no\n// null-coalescing operator \u2014 so here BOTH an absent key and a present-but-\n// empty value fall back to the author\'s default. The conformance fixture only\n// exercises the absent-key default, where the two runtimes agree; the\n// empty-string divergence is the same general `?? \u2192 or` limitation that\n// applies to any `x ?? default` the Go adapter lowers.\nfunc (s SearchParams) Get(key string) string {\n	return s.values.Get(key)\n}\n';
+    evalGoSource = 'package bf\n\nimport (\n	"encoding/json"\n	"errors"\n	"math"\n	"reflect"\n	"regexp"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode/utf8"\n)\n\n// =============================================================================\n// Lightweight ParsedExpr evaluator (issue #2018)\n// =============================================================================\n//\n// Templates cannot carry a lambda in expression position, which is why the\n// adapter historically special-cased higher-order callbacks (reduce / sort /\n// map / filter / find) into fixed shapes (bf_sort\'s comparator catalogue,\n// bf_reduce\'s +/* fold). This evaluator replaces that ad-hoc list: a callback\n// BODY is carried as a pure `ParsedExpr` subtree (the same structured IR the\n// compiler already produces) and evaluated here against an environment\n// (`{acc, item, \u2026captured free vars}`).\n//\n// Scope: higher-order callback bodies only. Ordinary expressions stay lowered\n// to template-native syntax \u2014 this is NOT a general expression engine.\n//\n// The accepted pure subset and its semantics (evaluation order, coercion,\n// equality, allowed operators / builtins) are documented in spec/compiler.md\n// ("ParsedExpr Evaluator Semantics") and pinned isomorphically by the golden\n// vectors in packages/adapter-tests/vectors/eval-vectors.json (shared\n// with the Perl evaluator). The coercion rules below are the literal JS rules\n// (ToNumber / ToString / ToBoolean) \u2014 deliberately NOT the divergent\n// bf->string / bf_reduce helper conventions \u2014 so the contract is unambiguous\n// and the backends stay byte-isomorphic.\n//\n// String semantics operate on Unicode code points / UTF-8 bytes: `.length`\n// counts code points and relational `<`/`>` compares byte order. This equals\n// the JS reference (UTF-16 code units) across the BMP \u2014 the range template\n// data uses \u2014 and matches the Perl evaluator exactly (the primary "same input\n// \u2192 same output" contract is between the two SSR backends). Astral-plane\n// characters (where JS counts a surrogate pair as length 2 and orders by\n// surrogate code units) are a documented divergence region, alongside the\n// already-documented non-ASCII relational / localeCompare carve-outs\n// (spec/compiler.md). Both backends stay equal; only the JS reference differs,\n// and no corpus vector exercises the astral range.\n\n// EvalExpr evaluates a pure ParsedExpr (carried as its JSON encoding) against\n// env. The result is a value in the JSON domain: a number (Go int or float64 \u2014\n// both are the single JS number type; e.g. `.length` returns int, arithmetic\n// returns float64), string, bool, nil, []any, or map[string]any. A malformed\n// tree yields nil.\nfunc EvalExpr(exprJSON string, env map[string]any) any {\n	var node any\n	if err := json.Unmarshal([]byte(exprJSON), &node); err != nil {\n		return nil\n	}\n	return EvalNode(node, env)\n}\n\n// EvalNode evaluates an already-decoded ParsedExpr node (a map[string]any with\n// a "kind" discriminator) against env. Exported so callers that already hold a\n// decoded tree (e.g. the golden-vector harness) skip a re-marshal.\nfunc EvalNode(node any, env map[string]any) any {\n	n, ok := node.(map[string]any)\n	if !ok {\n		return nil\n	}\n	kind, _ := n["kind"].(string)\n	switch kind {\n	case "literal":\n		return n["value"]\n\n	case "identifier":\n		name, _ := n["name"].(string)\n		return env[name]\n\n	case "binary":\n		op, _ := n["op"].(string)\n		return evalBinary(op, EvalNode(n["left"], env), EvalNode(n["right"], env))\n\n	case "unary":\n		op, _ := n["op"].(string)\n		return evalUnary(op, EvalNode(n["argument"], env))\n\n	case "logical":\n		op, _ := n["op"].(string)\n		left := EvalNode(n["left"], env)\n		switch op {\n		case "&&":\n			if !evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "||":\n			if evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "??":\n			if left == nil {\n				return EvalNode(n["right"], env)\n			}\n			return left\n		}\n		return nil\n\n	case "conditional":\n		if evalTruthy(EvalNode(n["test"], env)) {\n			return EvalNode(n["consequent"], env)\n		}\n		return EvalNode(n["alternate"], env)\n\n	case "member":\n		prop, _ := n["property"].(string)\n		return evalReadProperty(EvalNode(n["object"], env), prop)\n\n	case "index-access":\n		return evalReadIndex(EvalNode(n["object"], env), EvalNode(n["index"], env))\n\n	case "call":\n		// A nested `.map(cb)` / `.filter(cb)` callback call (#2094): syntactically\n		// a `call` whose callee is `<recv>.map`/`<recv>.filter` and whose first\n		// argument is an `arrow` \u2014 the SAME shape `asCallbackMethodCall`\n		// recognizes at compile time, and the shape the `eval-vectors.json`\n		// golden corpus itself carries (it stores the genuine `ParsedExpr`, not\n		// a bespoke wrapper). Checked BEFORE the builtin-callee gate below,\n		// since `<recv>.map` would otherwise resolve to a non-builtin member\n		// callee and refuse.\n		if method, objNode, arrowNode, ok := evalArrayCallbackCall(n); ok {\n			return evalArrayCallback(method, objNode, arrowNode, env)\n		}\n		name := evalBuiltinName(n["callee"])\n		if name == "" {\n			return nil\n		}\n		rawArgs, _ := n["args"].([]any)\n		args := make([]any, len(rawArgs))\n		for i, a := range rawArgs {\n			args[i] = EvalNode(a, env)\n		}\n		return evalCallBuiltin(name, args)\n\n	case "template-literal":\n		parts, _ := n["parts"].([]any)\n		var sb strings.Builder\n		for _, p := range parts {\n			pm, _ := p.(map[string]any)\n			if t, _ := pm["type"].(string); t == "string" {\n				s, _ := pm["value"].(string)\n				sb.WriteString(s)\n			} else {\n				sb.WriteString(evalToString(EvalNode(pm["expr"], env)))\n			}\n		}\n		return sb.String()\n\n	case "array-literal":\n		elems, _ := n["elements"].([]any)\n		out := make([]any, len(elems))\n		for i, e := range elems {\n			out[i] = EvalNode(e, env)\n		}\n		return out\n\n	case "object-literal":\n		props, _ := n["properties"].([]any)\n		out := make(map[string]any, len(props))\n		for _, p := range props {\n			pm, _ := p.(map[string]any)\n			key, _ := pm["key"].(string)\n			out[key] = EvalNode(pm["value"], env)\n		}\n		return out\n\n	case "array-method":\n		// `.includes(x)` / `.join(sep?)` are the `array-method` shapes the\n		// evaluator executes (the JS reference\'s `evaluate` "array-method" arm,\n		// eval-reference.ts). A nested `.map`/`.filter` is NOT an\n		// `array-method` node \u2014 it reaches the `call` case above (it carries\n		// an `arrow` callback, not a plain `args` list). Every other\n		// array/string method (`slice`, `flat`, \u2026) is refused upstream\n		// (BF101) and never reaches here.\n		method, _ := n["method"].(string)\n		rawArgs, _ := n["args"].([]any)\n		if method == "includes" && len(rawArgs) == 1 {\n			return evalIncludes(EvalNode(n["object"], env), EvalNode(rawArgs[0], env))\n		}\n		if method == "join" && len(rawArgs) <= 1 {\n			sep := ","\n			if len(rawArgs) == 1 {\n				sep = evalToString(EvalNode(rawArgs[0], env))\n			}\n			return evalJoin(EvalNode(n["object"], env), sep)\n		}\n		return nil\n	}\n	// arrow-fn / higher-order / unsupported: a callback body containing these\n	// is refused upstream (BF101); never reached here.\n	return nil\n}\n\n// evalArrayCallbackCall reports whether the decoded `call` node `n` is a\n// nested `.map(cb)` / `.filter(cb)` callback call (#2094): its callee is a\n// non-computed member `<recv>.map`/`<recv>.filter` and its first argument is\n// an `arrow` node. Returns the method name, the (still-encoded) receiver\n// object node, and the (still-encoded) arrow node.\nfunc evalArrayCallbackCall(n map[string]any) (method string, object any, arrow map[string]any, ok bool) {\n	callee, _ := n["callee"].(map[string]any)\n	if callee == nil || callee["kind"] != "member" {\n		return "", nil, nil, false\n	}\n	if computed, _ := callee["computed"].(bool); computed {\n		return "", nil, nil, false\n	}\n	prop, _ := callee["property"].(string)\n	if prop != "map" && prop != "filter" {\n		return "", nil, nil, false\n	}\n	rawArgs, _ := n["args"].([]any)\n	if len(rawArgs) == 0 {\n		return "", nil, nil, false\n	}\n	arrowNode, _ := rawArgs[0].(map[string]any)\n	if arrowNode == nil || arrowNode["kind"] != "arrow" {\n		return "", nil, nil, false\n	}\n	return prop, callee["object"], arrowNode, true\n}\n\n// evalArrayCallback executes a nested `.map`/`.filter` callback call: evaluates\n// the receiver, then evaluates the arrow body per element in a CHILD env that\n// binds the arrow\'s first param to the element and (when the arrow declares a\n// second param) the second to the integer index \u2014 both 1- and 2-param arrows\n// are supported. `map` keeps one result per element (order-preserving);\n// `filter` keeps the elements whose body evaluates truthy. A non-array\n// receiver degrades to nil (unreachable for a body the compiler validated,\n// since the receiver of a nested `.map`/`.filter` is itself gated upstream).\nfunc evalArrayCallback(method string, objectNode any, arrowNode map[string]any, env map[string]any) any {\n	arr := toAnySlice(EvalNode(objectNode, env))\n	if arr == nil {\n		return nil\n	}\n	rawParams, _ := arrowNode["params"].([]any)\n	params := make([]string, len(rawParams))\n	for i, p := range rawParams {\n		params[i], _ = p.(string)\n	}\n	body := arrowNode["body"]\n	callCb := func(item any, index int) any {\n		inner := make(map[string]any, len(env)+2)\n		for k, v := range env {\n			inner[k] = v\n		}\n		if len(params) > 0 {\n			inner[params[0]] = item\n		}\n		if len(params) > 1 {\n			inner[params[1]] = index\n		}\n		return EvalNode(body, inner)\n	}\n	if method == "map" {\n		out := make([]any, len(arr))\n		for i, item := range arr {\n			out[i] = callCb(item, i)\n		}\n		return out\n	}\n	out := []any{}\n	for i, item := range arr {\n		if evalTruthy(callCb(item, i)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// evalJoin implements `.join(sep)`: elements ToString\'d and joined; a\n// null/undefined element ToStrings to the empty string (matching JS\n// `Array.prototype.join`, which skips null/undefined rather than rendering\n// the literal string "null"/"undefined"). A non-array receiver degrades to\n// the empty string (unreachable for a validated body).\nfunc evalJoin(obj any, sep string) string {\n	arr := toAnySlice(obj)\n	if arr == nil {\n		return ""\n	}\n	parts := make([]string, len(arr))\n	for i, el := range arr {\n		if el == nil {\n			parts[i] = ""\n			continue\n		}\n		parts[i] = evalToString(el)\n	}\n	return strings.Join(parts, sep)\n}\n\n// ---------------------------------------------------------------------------\n// JS coercion primitives (ToNumber / ToString / ToBoolean), pinned so the\n// evaluator matches the JS reference. These are JS-faithful and intentionally\n// distinct from the bf->string / Number helpers, which diverge (null \u2192 "",\n// null/"" \u2192 NaN) for SSR-survival reasons that do not apply to the evaluator.\n// ---------------------------------------------------------------------------\n\n// jsDecimalNumberRe matches the JS StringToNumber decimal numeric literal\n// grammar (ASCII digits only): optional sign, then integer/fraction digits,\n// then an optional exponent. It deliberately excludes underscore digit\n// separators, radix prefixes (0x/0o/0b), and hex-float forms \u2014 none of which\n// are valid JS decimal numeric literals.\nvar jsDecimalNumberRe = regexp.MustCompile(`^[+-]?(?:[0-9]+\\.?[0-9]*|\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$`)\n\nfunc evalToNumber(v any) float64 {\n	switch x := v.(type) {\n	case nil:\n		return 0\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		t := strings.TrimSpace(x)\n		if t == "" {\n			return 0\n		}\n		// Exact JS Infinity spellings (case-sensitive, no other aliases like\n		// "infinity"/"inf" are valid JS numeric strings).\n		switch t {\n		case "Infinity", "+Infinity":\n			return math.Inf(1)\n		case "-Infinity":\n			return math.Inf(-1)\n		}\n		// Decimal / exponent numeric strings parse JS-faithfully, including\n		// overflow: strconv.ParseFloat rejects underscores, hex-floats, and\n		// non-canonical "inf"/"nan" spellings via the anchored decimal-grammar\n		// gate below, so those correctly yield NaN. The radix-prefixed forms\n		// JS Number() also accepts ("0x10" / "0o17" / "0b101") are a\n		// documented divergence region: they fail the decimal grammar (a\n		// leading "0x"/"0o"/"0b" is not a valid decimal literal) and yield\n		// NaN here, as they do in the Perl evaluator (looks_like_number is\n		// false for them), so Go==Perl while differing from the JS\n		// reference. Template data carries JSON numbers, not radix-string\n		// literals, so this never arises in practice.\n		if !jsDecimalNumberRe.MatchString(t) {\n			return math.NaN()\n		}\n		f, err := strconv.ParseFloat(t, 64)\n		if err == nil {\n			return f\n		}\n		if errors.Is(err, strconv.ErrRange) {\n			// ParseFloat still returns the correctly-signed \xB1Inf (or a\n			// subnormal) as its best-effort value on overflow/underflow;\n			// JS Number() on an overflowing decimal literal yields \xB1Infinity\n			// (e.g. "1e1000" -> +Infinity), so surface that value as-is.\n			return f\n		}\n		return math.NaN()\n	default:\n		if evalIsNumeric(v) {\n			return toFloat64(v)\n		}\n		return math.NaN()\n	}\n}\n\n// evalIsNumeric reports whether v is one of the Go numeric types (all of\n// which are the single JS "number" type to the evaluator).\nfunc evalIsNumeric(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:\n		return true\n	}\n	return false\n}\n\nfunc evalToString(v any) string {\n	if v == nil {\n		return "null"\n	}\n	// JS spells the non-finite doubles "Infinity" / "-Infinity" / "NaN"; the\n	// runtime String() helper (fmt %v) would render "+Inf" / "-Inf" / "NaN",\n	// so the non-finite cases are pinned here to stay JS-faithful (and match\n	// the Perl evaluator\'s _to_string). Strings, bools and nil are JS-faithful\n	// through String() (nil is already handled above as "null").\n	//\n	// Finite-number formatting is a documented divergence region. Go\'s fmt is\n	// shortest-round-trip (it matches JS\'s *digits*, e.g. 0.1+0.2 \u2192\n	// "0.30000000000000004"), but its exponent threshold/padding differ from\n	// JS Number::toString for very large / very small magnitudes (Go renders\n	// 1e6 as "1e+06" where JS keeps "1000000", and "1e-07" vs JS "1e-7").\n	// Perl\'s `%.15g` instead diverges on *precision* (the pinned helper-vector\n	// "0.3" case). A fully JS-faithful Number::toString is not reimplemented\n	// here because Perl has no shortest-round-trip formatter, so the three\n	// could never all agree; the common integer / short-decimal range \u2014 what\n	// arithmetic over template data produces \u2014 renders identically across all\n	// three. Only the \xB10 sign is normalised below, since it is cheap and the\n	// realisticly-reachable case.\n	if f, ok := v.(float64); ok {\n		if math.IsNaN(f) {\n			return "NaN"\n		}\n		if math.IsInf(f, 1) {\n			return "Infinity"\n		}\n		if math.IsInf(f, -1) {\n			return "-Infinity"\n		}\n		// JS `String(-0)` is "0", but fmt %v renders Go\'s negative zero as\n		// "-0". `f == 0` matches both \xB10, normalising to JS\'s spelling. (A\n		// unary `-` on a zero operand is the way the evaluator can produce -0.)\n		if f == 0 {\n			return "0"\n		}\n	}\n	// Non-primitive operands (arrays / objects) in ToString position are\n	// outside the evaluator subset \u2014 the JS reference refuses them, and the\n	// compiler gates such a callback body with BF101 before it ever reaches\n	// the runtime. This evaluator runs already-validated bodies, so it does\n	// not re-reject here; String() (fmt %v) is a best-effort fallback for that\n	// unreachable path, never exercised by the in-subset corpus.\n	return String(v)\n}\n\nfunc evalTruthy(v any) bool {\n	return isTruthy(v)\n}\n\n// ---------------------------------------------------------------------------\n// Operators\n// ---------------------------------------------------------------------------\n\nfunc evalBinary(op string, l, r any) any {\n	switch op {\n	case "+":\n		// JS `+`: string concatenation once either operand is a string,\n		// numeric addition otherwise.\n		if _, lok := l.(string); lok {\n			return evalToString(l) + evalToString(r)\n		}\n		if _, rok := r.(string); rok {\n			return evalToString(l) + evalToString(r)\n		}\n		return evalToNumber(l) + evalToNumber(r)\n	case "-":\n		return evalToNumber(l) - evalToNumber(r)\n	case "*":\n		return evalToNumber(l) * evalToNumber(r)\n	case "/":\n		return evalToNumber(l) / evalToNumber(r)\n	case "%":\n		return math.Mod(evalToNumber(l), evalToNumber(r))\n	case "<", "<=", ">", ">=":\n		return evalRelational(op, l, r)\n	case "===":\n		return evalStrictEq(l, r)\n	case "!==":\n		return !evalStrictEq(l, r)\n	}\n	// Loose equality / bitwise / shift are out of the subset.\n	return nil\n}\n\nfunc evalRelational(op string, l, r any) bool {\n	// JS Abstract Relational Comparison: both strings \u2192 compare by code\n	// unit; otherwise coerce both to numbers (a NaN operand makes every\n	// comparison false).\n	var c int\n	ls, lok := l.(string)\n	rs, rok := r.(string)\n	if lok && rok {\n		if ls < rs {\n			c = -1\n		} else if ls > rs {\n			c = 1\n		}\n	} else {\n		ln := evalToNumber(l)\n		rn := evalToNumber(r)\n		if math.IsNaN(ln) || math.IsNaN(rn) {\n			return false\n		}\n		if ln < rn {\n			c = -1\n		} else if ln > rn {\n			c = 1\n		}\n	}\n	switch op {\n	case "<":\n		return c < 0\n	case "<=":\n		return c <= 0\n	case ">":\n		return c > 0\n	case ">=":\n		return c >= 0\n	}\n	return false\n}\n\nfunc evalStrictEq(l, r any) bool {\n	// Strict `===`: equal JS type and value, no coercion. All numeric Go\n	// types are the single JS "number" type, so int 2 === float64 2.\n	lnum := evalIsNumeric(l)\n	rnum := evalIsNumeric(r)\n	if lnum && rnum {\n		lf, rf := toFloat64(l), toFloat64(r)\n		if math.IsNaN(lf) || math.IsNaN(rf) {\n			return false\n		}\n		return lf == rf\n	}\n	if lnum != rnum {\n		return false\n	}\n	switch lv := l.(type) {\n	case nil:\n		return r == nil\n	case string:\n		rv, ok := r.(string)\n		return ok && rv == lv\n	case bool:\n		rv, ok := r.(bool)\n		return ok && rv == lv\n	}\n	// Non-primitive operands (arrays / objects) are outside the subset: the JS\n	// reference refuses `===` on them and the compiler gates such a body with\n	// BF101 upstream, so this is unreachable for an in-subset corpus. The\n	// runtime trusts that gate rather than re-validating, returning false\n	// here (it does not attempt JS reference identity, which templates can\'t\n	// model anyway).\n	return false\n}\n\n// evalSameValueZero implements `Array.prototype.includes`\'s membership\n// comparison: `===` except `NaN` equals itself (JS\'s SameValueZero). Reuses\n// evalStrictEq \u2014 the one divergence, both operands NaN, is checked first;\n// every other pair (including "one NaN, one not") falls through to the same\n// equality `evalBinary`\'s `===` uses, so the two operators stay in lockstep.\nfunc evalSameValueZero(a, b any) bool {\n	if evalIsNumeric(a) && evalIsNumeric(b) {\n		af, bf := toFloat64(a), toFloat64(b)\n		if math.IsNaN(af) && math.IsNaN(bf) {\n			return true\n		}\n	}\n	return evalStrictEq(a, b)\n}\n\n// evalIncludes implements `.includes(needle)`, shared between\n// `Array.prototype.includes` (SameValueZero membership over a slice/array\n// receiver) and `String.prototype.includes` (substring search), mirroring\n// the receiver-type dispatch the SSR template lowering already does\n// (`bf_includes`). Any other receiver type is not a JS `.includes` target;\n// this degrades to false rather than panicking (there is no receiver here\n// for which JS itself would throw), matching the JS reference\n// (eval-reference.ts `includes`).\nfunc evalIncludes(obj, needle any) bool {\n	if arr := toAnySlice(obj); arr != nil {\n		for _, el := range arr {\n			if evalSameValueZero(el, needle) {\n				return true\n			}\n		}\n		return false\n	}\n	if s, ok := obj.(string); ok {\n		return strings.Contains(s, evalToString(needle))\n	}\n	return false\n}\n\nfunc evalUnary(op string, v any) any {\n	switch op {\n	case "!":\n		return !evalTruthy(v)\n	case "-":\n		return -evalToNumber(v)\n	case "+":\n		return evalToNumber(v)\n	}\n	return nil\n}\n\n// ---------------------------------------------------------------------------\n// Built-in calls (the deterministic allowlist). Locale-sensitive builtins\n// (localeCompare) are deliberately excluded to keep the backends isomorphic.\n// ---------------------------------------------------------------------------\n\n// evalBuiltinName resolves a `call` callee to its builtin name (e.g.\n// "Math.max"), or "" if the callee is not an allowlisted builtin reference.\nfunc evalBuiltinName(callee any) string {\n	cm, ok := callee.(map[string]any)\n	if !ok {\n		return ""\n	}\n	switch cm["kind"] {\n	case "identifier":\n		name, _ := cm["name"].(string)\n		return name\n	case "member":\n		if computed, _ := cm["computed"].(bool); computed {\n			return ""\n		}\n		obj, _ := cm["object"].(map[string]any)\n		if obj == nil || obj["kind"] != "identifier" {\n			return ""\n		}\n		objName, _ := obj["name"].(string)\n		prop, _ := cm["property"].(string)\n		return objName + "." + prop\n	}\n	return ""\n}\n\n// evalMathRound rounds a half toward +Infinity (JS Math.round: 2.5\u21923,\n// -2.5\u2192-2), matching the existing `round` helper rather than Go\'s math.Round.\nfunc evalMathRound(n float64) float64 {\n	// floor(n+0.5) yields +0 for x in [-0.5, -0], where JS Math.round returns\n	// -0. That sign is only observable through a subsequent division\n	// (`1 / Math.round(-0.5)` is -Infinity in JS, +Infinity here) \u2014 through\n	// ToString both \xB10 render "0". It is left as +0 deliberately: the two SSR\n	// backends must stay equal, and Perl can\'t reproduce the -0 divisor sign\n	// without fragile, version-dependent zero handling (its native `/` even\n	// dies on a zero divisor). So Math.round\'s -0 is a JS-reference-only\n	// divergence region, like the astral-plane / radix-string carve-outs.\n	return math.Floor(n + 0.5)\n}\n\nfunc evalCallBuiltin(name string, args []any) any {\n	switch name {\n	case "Math.max":\n		if len(args) == 0 {\n			return math.Inf(-1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Max(m, evalToNumber(a))\n		}\n		return m\n	case "Math.min":\n		if len(args) == 0 {\n			return math.Inf(1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Min(m, evalToNumber(a))\n		}\n		return m\n	case "Math.abs":\n		return math.Abs(evalToNumber(arg0(args)))\n	case "Math.floor":\n		return math.Floor(evalToNumber(arg0(args)))\n	case "Math.ceil":\n		return math.Ceil(evalToNumber(arg0(args)))\n	case "Math.round":\n		return evalMathRound(evalToNumber(arg0(args)))\n	case "String":\n		return evalToString(arg0(args))\n	case "Number":\n		return evalToNumber(arg0(args))\n	case "Boolean":\n		return evalTruthy(arg0(args))\n	}\n	// Any other callee is outside the subset (refused upstream).\n	return nil\n}\n\nfunc arg0(args []any) any {\n	if len(args) == 0 {\n		return nil\n	}\n	return args[0]\n}\n\n// ---------------------------------------------------------------------------\n// Member / index access\n// ---------------------------------------------------------------------------\n\nfunc evalReadProperty(obj any, key string) any {\n	switch o := obj.(type) {\n	case string:\n		if key == "length" {\n			// Code-point count (== JS UTF-16 length across the BMP, == Perl\n			// `length`). RuneCountInString avoids the []rune allocation since\n			// this can run inside comparator / reducer evaluation.\n			return utf8.RuneCountInString(o)\n		}\n		return nil\n	case []any:\n		if key == "length" {\n			return len(o)\n		}\n		return nil\n	case map[string]any:\n		// Case-variant lookup: a callback body reads the raw JS property\n		// (`t.duration`), but test data / Go-keyed maps may carry PascalCase\n		// keys (`{"Duration": \u2026}`). Reuse the field reader the sort / reduce\n		// helpers use \u2014 it resolves `duration` \u2192 `Duration` and reads a\n		// genuinely missing key as null (the backends\' single absent value).\n		return getFieldValue(o, key)\n	case nil:\n		return nil\n	default:\n		// Real template data (Go structs): reuse the field reader the sort /\n		// reduce helpers use, which handles case-variant keys.\n		return getFieldValue(obj, key)\n	}\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order folds (the generalization of bf_reduce /\n// bf_sort onto the evaluator)\n//\n// These prove the evaluator subsumes the special-cased callback catalogue:\n// the callback BODY is carried as a pure ParsedExpr (JSON) and evaluated per\n// element against an environment, so the op restriction (bf_reduce\'s +/*),\n// the acc-canonical form, and the comparator pattern restriction (bf_sort)\n// all disappear \u2014 any pure reducer / comparator body works. They are the\n// runtime half of the integration; the compiler-side emit migration (carrying\n// callback bodies as ParsedExpr) and the byte-equal divergence decision for\n// the string-`localeCompare` sort path (won\'t-fix for byte-equal SSR, see\n// spec/compiler.md Known limitations) are the remaining follow-up.\n// ---------------------------------------------------------------------------\n\n// toAnySlice copies a reflect-iterable receiver into a fresh []any, returning\n// nil for a non-slice/array (matching the bf_sort / bf_reduce nil-tolerance).\nfunc toAnySlice(items any) []any {\n	v := reflect.ValueOf(items)\n	// A nil interface yields an invalid Value (Kind() == Invalid, not a\n	// panic), so the Slice/Array guard below already tolerates nil; the\n	// explicit IsValid check just documents the nil-tolerance intent.\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	out := make([]any, v.Len())\n	for i := range out {\n		out[i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// FoldEval folds items into a value via the ParsedExpr evaluator. The reducer\n// body is a pure ParsedExpr (JSON) evaluated against `{accName: acc, itemName:\n// item}` plus the captured free vars in `baseEnv` for each element; `init`\n// seeds the accumulator and `direction` is "left" (reduce) or "right"\n// (reduceRight). This is the evaluator-based generalization of bf_reduce \u2014 any\n// reducer body, not just the `+`/`*` arithmetic catalogue, and `acc` may\n// appear anywhere in the body. `baseEnv` may be nil when the body captures no\n// outer references; the accName / itemName keys shadow any same-named base key.\nfunc FoldEval(items any, bodyJSON, accName, itemName string, init any, direction string, baseEnv map[string]any) any {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return init\n	}\n	arr := toAnySlice(items)\n	if direction == "right" {\n		for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {\n			arr[i], arr[j] = arr[j], arr[i]\n		}\n	}\n	acc := init\n	// Seed the env from the captured free vars once; acc / item are\n	// overwritten each iteration (constant base keys carry through).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	for _, item := range arr {\n		env[accName] = acc\n		env[itemName] = item\n		acc = EvalNode(body, env)\n	}\n	return acc\n}\n\n// SortEval returns a new stable-sorted slice ordered by a ParsedExpr\n// comparator body (JSON) evaluated against `{paramA: a, paramB: b}` plus the\n// captured free vars in `baseEnv` to a number (negative / zero / positive,\n// like a JS comparator). This is the evaluator-based generalization of bf_sort\n// \u2014 any comparator body, not just the subtraction / relational-ternary\n// catalogue. `baseEnv` may be nil. Non-mutating.\nfunc SortEval(items any, cmpJSON, paramA, paramB string, baseEnv map[string]any) []any {\n	arr := toAnySlice(items)\n	if arr == nil {\n		return nil\n	}\n	var cmp any\n	if err := json.Unmarshal([]byte(cmpJSON), &cmp); err != nil {\n		return arr\n	}\n	// One env seeded from the captured free vars; the two operand keys are\n	// overwritten per comparison (the comparator runs synchronously).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	sort.SliceStable(arr, func(i, j int) bool {\n		env[paramA] = arr[i]\n		env[paramB] = arr[j]\n		return evalToNumber(EvalNode(cmp, env)) < 0\n	})\n	return arr\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order predicates (#2018, P2) \u2014 the generalization\n// of bf_filter / bf_find / bf_find_index / bf_every / bf_some onto the\n// evaluator. The predicate BODY travels as a pure ParsedExpr (JSON) and is\n// evaluated per element against `{param: item}` plus the captured free vars in\n// `baseEnv`, lifting the field-equality / truthiness restriction of the\n// special-cased helpers to any pure predicate. `baseEnv` may be nil.\n// ---------------------------------------------------------------------------\n\n// decodeEvalBody unmarshals a serialized ParsedExpr body; ok is false on bad\n// JSON (only reachable by a corrupt emit \u2014 the adapter always emits valid JSON).\nfunc decodeEvalBody(bodyJSON string) (any, bool) {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return nil, false\n	}\n	return body, true\n}\n\n// seedPredEnv copies the captured free vars into a fresh env with room for the\n// single predicate param, which the callers overwrite per element.\nfunc seedPredEnv(baseEnv map[string]any) map[string]any {\n	env := make(map[string]any, len(baseEnv)+1)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	return env\n}\n\n// FilterEval returns a new slice of the elements for which the predicate body\n// evaluates truthy \u2014 the evaluator generalization of bf_filter. Returns a\n// non-nil empty slice when nothing matches (so a downstream `range` / `bf_join`\n// sees a real slice); returns nil only on a bad body.\nfunc FilterEval(items any, predJSON, param string, baseEnv map[string]any) []any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// EveryEval reports whether every element satisfies the predicate (vacuously\n// true for an empty receiver, like JS) \u2014 the generalization of bf_every.\nfunc EveryEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if !evalTruthy(EvalNode(pred, env)) {\n			return false\n		}\n	}\n	return true\n}\n\n// SomeEval reports whether any element satisfies the predicate (false for an\n// empty receiver, like JS) \u2014 the generalization of bf_some.\nfunc SomeEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			return true\n		}\n	}\n	return false\n}\n\n// FindEval returns the first element satisfying the predicate, or nil when none\n// does \u2014 the generalization of bf_find. `forward` false searches from the end\n// (findLast).\nfunc FindEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return arr[i]\n		}\n	}\n	return nil\n}\n\n// FindIndexEval returns the index of the first element satisfying the predicate,\n// or -1 when none does \u2014 the generalization of bf_find_index. `forward` false\n// searches from the end (findLastIndex).\nfunc FindIndexEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) int {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return -1\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return i\n		}\n	}\n	return -1\n}\n\n// FlatMapEval projects each element through the projection body (a pure\n// ParsedExpr JSON evaluated against `{param: item}` + baseEnv) and flattens the\n// results one level \u2014 the evaluator generalization of bf_flat_map /\n// bf_flat_map_tuple. A projection that yields a slice contributes its elements;\n// any other value contributes itself (matching JS `.flatMap`, where a non-array\n// return is kept as a single element). Returns a non-nil empty slice on a bad\n// body so a downstream `range` / `bf_join` sees a real slice.\nfunc FlatMapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		v := EvalNode(proj, env)\n		// Flatten any slice/array kind one level, not just []any: real Go\n		// template data projects a field like `i.tags` to a typed slice\n		// (`[]string` / `[]int`), which `toAnySlice` normalizes to []any. A\n		// non-slice value (string / number / struct / nil) contributes itself,\n		// matching JS `.flatMap` (a non-array return is kept as one element).\n		if sub := toAnySlice(v); sub != nil {\n			out = append(out, sub...)\n		} else {\n			out = append(out, v)\n		}\n	}\n	return out\n}\n\n// MapEval projects each element through the projection body (a pure ParsedExpr\n// JSON evaluated against `{param: item}` + baseEnv), keeping one result per\n// element \u2014 the value-producing `.map(cb)` lowering (#2073). Unlike\n// FlatMapEval there is no flatten: a projection yielding a slice contributes\n// that slice as a single element, matching JS `.map`. Returns a non-nil empty\n// slice on a bad body so a downstream `range` / `bf_join` sees a real slice.\nfunc MapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		out = append(out, EvalNode(proj, env))\n	}\n	return out\n}\n\n// Env builds the captured-free-var environment for FoldEval / SortEval from a\n// flat key, value, key, value, \u2026 argument list \u2014 the adapter emits\n// `bf_env "k1" v1 "k2" v2 \u2026` for the free variables a callback body references\n// beyond its own params. An odd trailing key with no value is ignored; with no\n// pairs it returns an empty (non-nil) map, the no-capture case. A non-string\n// key (only reachable by a malformed template call, never by the adapter\'s\n// quoted-literal emit) is skipped rather than collapsed into an `env[""]` slot.\nfunc Env(pairs ...any) map[string]any {\n	env := make(map[string]any, len(pairs)/2)\n	for i := 0; i+1 < len(pairs); i += 2 {\n		key, ok := pairs[i].(string)\n		if !ok {\n			continue\n		}\n		env[key] = pairs[i+1]\n	}\n	return env\n}\n\nfunc evalReadIndex(obj any, index any) any {\n	switch o := obj.(type) {\n	case []any:\n		f := evalToNumber(index)\n		i := int(f)\n		if float64(i) != f || i < 0 || i >= len(o) {\n			return nil\n		}\n		return o[i]\n	case map[string]any:\n		return o[evalToString(index)]\n	case nil:\n		return nil\n	default:\n		return getFieldValue(obj, evalToString(index))\n	}\n}\n';
     streamingGoSource = `// Package bf \u2014 Out-of-Order Streaming SSR helpers
 //
 // Provides StreamRenderer for progressive page rendering using HTTP
@@ -29081,14 +29240,16 @@ export default createConfig({
       devDependencies: {
         ...UNOCSS_DEV_DEPENDENCIES,
         "@barefootjs/cli": "latest",
-        // Must track wrangler's `peerOptional @cloudflare/workers-types`
-        // MAJOR: wrangler 4.108.0 moved it to `^5.20260706.1`, and with the
-        // v4 pin every fresh scaffold's `npm install` fails with ERESOLVE
-        // (bun tolerates the mismatch; npm does not — CI's smoke-publish
-        // caught it). v5 still ships a root `index.d.ts`, so the generated
-        // tsconfig's `"types": ["@cloudflare/workers-types", ...]` entry
-        // resolves unchanged.
-        "@cloudflare/workers-types": "^5.20260706.1",
+        // Must satisfy wrangler's `peerOptional @cloudflare/workers-types`
+        // (bun tolerates a mismatch; npm does not — CI's smoke-publish gate
+        // catches it). Upstream keeps flip-flopping which major it peers on:
+        // 4.107.1 peers `^4.20260702.1`; 4.108.0 moved to `^5.20260706.1` and
+        // was deprecated same-day; 4.110.0 (which `^4.0.0` resolves to today)
+        // peers `^5.20260708.1`. Rather than chase whichever version last
+        // shipped, accept BOTH majors so npm installs whichever the resolved
+        // wrangler actually peers on — v5 when it wants v5, v4 after a
+        // deprecation falls back to a v4-peering wrangler. No ERESOLVE either way.
+        "@cloudflare/workers-types": "^4.20260702.1 || ^5.20260708.1",
         // `@barefootjs/test` powers `renderToTest()` — the canonical
         // millisecond IR test the docs (and `bf gen test`) point new users
         // at. Without it the scaffold's `test` script is a no-op and any