@barefootjs/cli 0.19.0 → 0.20.0

package/dist/index.js

@@ -286,6 +286,38 @@ function parseProviderObjectLiteral(source) {
 function cssKebabCase(name2) {
   return name2.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^ms-/, "-ms-");
 }
+function hasUnsafeStyleValue(value2) {
+  let quote = 0;
+  const blockStack = [];
+  for (let i = 0, len = value2.length; i < len; i++) {
+    const c = value2.charCodeAt(i);
+    if (c === 92) {
+      if (i === len - 1) return true;
+      i++;
+    } else if (quote !== 0) {
+      if (c === 10 || c === 12 || c === 13) return true;
+      if (c === quote) quote = 0;
+    } else if (c === 47 && value2.charCodeAt(i + 1) === 42) {
+      const end2 = value2.indexOf("*/", i + 2);
+      if (end2 === -1) return true;
+      i = end2 + 1;
+    } else if (c === 34 || c === 39) {
+      quote = c;
+    } else if (c === 40) {
+      blockStack.push(41);
+    } else if (c === 91) {
+      blockStack.push(93);
+    } else if (c === 123 || c === 125) {
+      return true;
+    } else if (c === 41 || c === 93) {
+      if (blockStack[blockStack.length - 1] !== c) return true;
+      blockStack.pop();
+    } else if (c === 59 && blockStack.length === 0) {
+      return true;
+    }
+  }
+  return quote !== 0 || blockStack.length !== 0;
+}
 function parseStyleObjectEntries(source) {
   const sf = ts.createSourceFile("__style__.ts", `(${source})`, ts.ScriptTarget.Latest, true);
   const stmt = sf.statements[0];
@@ -1907,7 +1939,7 @@ function freeIdentifiers(expr) {
       case "regex":
         return true;
       case "identifier":
-        if (!bound.has(e.name)) free.add(e.name);
+        if (e.name !== "undefined" && !bound.has(e.name)) free.add(e.name);
         return true;
       case "call": {
         const isBuiltinCallee = evalBuiltinCalleeName(e.callee) !== null;
@@ -3482,7 +3514,7 @@ function normalizeSignalInitial(signal2, propsObjectName) {
   if (initialValue.startsWith(propsPrefix) && !initialValue.includes("??")) {
     return `${initialValue} ?? ${inferDefaultValue(signal2.type)}`;
   }
-  return initialValue;
+  return signal2.templateInitialValue ?? initialValue;
 }
 var init_csr_substitute = __esm({
   "../jsx/src/ir-to-client-js/csr-substitute.ts"() {
@@ -6000,11 +6032,19 @@ function collectSignal(node, ctx2) {
   }
   const envReader = resolveEnvSignalKey(callExpr, ctx2) ?? void 0;
   const envFactory = envReader ? callExpr.expression.getText(ctx2.sourceFile) : void 0;
+  let templateInitialValue;
+  if (!ctx2.propsObjectName && callExpr.arguments[0]) {
+    const propNames = new Set(ctx2.propsParams.map((p) => p.name));
+    if (propNames.size > 0) {
+      templateInitialValue = rewriteBarePropRefs(initialValue, callExpr.arguments[0], propNames);
+    }
+  }
   ctx2.signals.push({
     getter,
     setter,
     initialValue,
     typedInitialValue: typedInitialValue !== initialValue ? typedInitialValue : void 0,
+    templateInitialValue,
     type: type2,
     loc: getSourceLocation(node, ctx2.sourceFile, ctx2.filePath),
     initialFreeIdentifiers: callExpr.arguments[0] ? extractFreeIdentifiersFromNode(callExpr.arguments[0]) : /* @__PURE__ */ new Set(),
@@ -7043,7 +7083,9 @@ function extractProps(param, ctx2) {
           // the caller may omit the prop.
           optional: !!member?.optional || !!element.initializer,
           defaultValue: defaultValue2,
-          defaultContainsArrow: defaultContainsArrow || void 0
+          defaultContainsArrow: defaultContainsArrow || void 0,
+          // Only aliased bindings carry the source key — see ParamInfo.sourceName.
+          ...sourcePropName !== localName2 && { sourceName: sourcePropName }
         });
       }
     }
@@ -11803,7 +11845,8 @@ function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings)
       if (!n.slotId) return;
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
       const expanded = expandConstantForReactivity(n.expr, ctx2, originFreeIds);
-      if (classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind === "none") return;
+      const reactive = classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
+      if (!reactive) return;
       texts.push({
         slotId: n.slotId,
         expression: expanded.expr,
@@ -12121,13 +12164,9 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
         const template = n.children.map((c) => irToPlaceholderTemplate(c, void 0, emitDepth, loopParamsForTemplate)).join("");
         const refsOuter = outerLoopParam ? new RegExp(`\\b${outerLoopParam}\\b`).test(n.array) : false;
         const bindings = emptyLoopChildBindings();
-        if (refsOuter && ctx2) {
-          for (const child of n.children) {
-            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, n.param, n.paramBindings));
-          }
-        }
         if (ctx2) {
           for (const child of n.children) {
+            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, n.param, n.paramBindings));
             bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, n.param, n.paramBindings));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
@@ -18252,14 +18291,15 @@ function generateInitFunction(ir, ctx2, siblingComponents, localImportPrefixes)
   const hydrateLine = emitRegistrationAndHydration(lines, ctx2, ir, graph, inlinability);
   let generatedCode = rewritePropsObjectRef(lines.join("\n"), ctx2.propsObjectName);
   generatedCode += "\n" + hydrateLine;
-  const allImportLines = resolveFinalImports(generatedCode, ir, localImportPrefixes);
   const moduleConstantsCode = emitModuleLevelDeclarations(
     classification.moduleLevelConstants,
     classification.moduleLevelFunctions,
     classification.moduleLevelSignals,
     classification.moduleLevelMemos
   );
-  return generatedCode.replace(IMPORT_PLACEHOLDER, allImportLines).replace(MODULE_CONSTANTS_PLACEHOLDER, moduleConstantsCode);
+  const codeWithModuleConstants = generatedCode.replace(MODULE_CONSTANTS_PLACEHOLDER, () => moduleConstantsCode);
+  const allImportLines = resolveFinalImports(codeWithModuleConstants, ir, localImportPrefixes);
+  return codeWithModuleConstants.replace(IMPORT_PLACEHOLDER, () => allImportLines);
 }
 var init_generate_init = __esm({
   "../jsx/src/ir-to-client-js/generate-init.ts"() {
@@ -19807,6 +19847,273 @@ var init_ssr_seed_plan = __esm({
   }
 });
 
+// ../jsx/src/rich-type-evidence.ts
+function baseTypeName(raw) {
+  const idx = raw.indexOf("<");
+  return (idx === -1 ? raw : raw.slice(0, idx)).trim();
+}
+function isNullishArm(t) {
+  if (t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined")) return true;
+  return t.kind === "unknown" && (t.raw === "null" || t.raw === "undefined");
+}
+function stripUnion(type2) {
+  if (!type2 || type2.kind !== "union" || !type2.unionTypes) return type2;
+  const nonNullish = type2.unionTypes.filter((t) => !isNullishArm(t));
+  return nonNullish.length === 1 ? stripUnion(nonNullish[0]) : type2;
+}
+function derefNamedType(type2, meta) {
+  if (type2.kind !== "interface") return type2;
+  if (type2.properties && type2.properties.length > 0) return type2;
+  const name2 = baseTypeName(type2.raw);
+  const def = meta.typeDefinitions.find((d) => d.name === name2);
+  if (!def?.properties) return type2;
+  return { ...type2, properties: def.properties };
+}
+function lookupProperty(objType, propName, meta) {
+  const stripped = stripUnion(objType);
+  if (!stripped) return null;
+  const deref = derefNamedType(stripped, meta);
+  const prop = deref.properties?.find((p) => p.name === propName);
+  return prop ? stripUnion(prop.type) : null;
+}
+function resolveReceiverType(expr, meta, bindings) {
+  if (expr.kind === "identifier") {
+    if (bindings.has(expr.name)) return stripUnion(bindings.get(expr.name) ?? null);
+    if (meta.propsObjectName !== null) {
+      return expr.name === meta.propsObjectName ? stripUnion(meta.propsType) : null;
+    }
+    const param = meta.propsParams.find((p) => p.name === expr.name && !p.isRest);
+    if (!param) return null;
+    return lookupProperty(meta.propsType, param.sourceName ?? param.name, meta);
+  }
+  if (expr.kind === "member" && !expr.computed) {
+    const objType = resolveReceiverType(expr.object, meta, bindings);
+    return lookupProperty(objType, expr.property, meta);
+  }
+  return null;
+}
+var HOST_RICH_TYPE_NAMES;
+var init_rich_type_evidence = __esm({
+  "../jsx/src/rich-type-evidence.ts"() {
+    "use strict";
+    HOST_RICH_TYPE_NAMES = /* @__PURE__ */ new Set([
+      "Date",
+      "Map",
+      "Set",
+      "WeakMap",
+      "WeakSet",
+      "URL",
+      "URLSearchParams",
+      "RegExp",
+      "Promise",
+      "Error",
+      "Symbol",
+      "BigInt",
+      "Function"
+    ]);
+  }
+});
+
+// ../jsx/src/rich-type-refusal.ts
+function checkRichTypeMethodCalls(root2, metadata, errors) {
+  if (!metadata.propsType) return;
+  const matchers = prepareLoweringMatchers(metadata);
+  const seen = /* @__PURE__ */ new Set();
+  walkNode(root2, metadata, EMPTY_BINDINGS, matchers, errors, seen);
+}
+function isLoweringClaimed(matchers, callee, args2) {
+  return matchers.some((m) => m(callee, args2) !== null);
+}
+function describeReceiverPath(expr) {
+  if (expr.kind === "identifier") return expr.name;
+  if (expr.kind === "member" && !expr.computed) return `${describeReceiverPath(expr.object)}.${expr.property}`;
+  return "<expression>";
+}
+function receiverRootIsProp(expr, bindings) {
+  let root2 = expr;
+  while (root2.kind === "member" && !root2.computed) root2 = root2.object;
+  return root2.kind === "identifier" && !bindings.has(root2.name);
+}
+function pushDiagnostic(errors, seen, loc, method2, receiverPath, isProp, typeName) {
+  const key = `${loc.start.line}:${loc.start.column}:${receiverPath}.${method2}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  const receiver = isProp ? `prop '${receiverPath}'` : `'${receiverPath}'`;
+  errors.push({
+    code: ErrorCodes.UNSUPPORTED_JSX_PATTERN,
+    severity: "error",
+    message: `Expression cannot be compiled to marked template: method '.${method2}()' on ${receiver} of host type '${typeName}' has no catalogued lowering.`,
+    loc,
+    suggestion: {
+      message: "Add /* @client */ to evaluate this expression on the client only, or pre-compute the value server-side."
+    }
+  });
+}
+function checkExpr(expr, loc, meta, bindings, matchers, errors, seen) {
+  const recurse = (e, b = bindings) => checkExpr(e, loc, meta, b, matchers, errors, seen);
+  switch (expr.kind) {
+    case "call": {
+      if (expr.callee.kind === "member") {
+        const receiverType = resolveReceiverType(expr.callee.object, meta, bindings);
+        if (receiverType && receiverType.kind === "interface") {
+          const typeName = baseTypeName(receiverType.raw);
+          const inFileShadow = meta.typeDefinitions.some((d) => d.name === typeName);
+          if (HOST_RICH_TYPE_NAMES.has(typeName) && !inFileShadow && !isLoweringClaimed(matchers, expr.callee, expr.args)) {
+            pushDiagnostic(
+              errors,
+              seen,
+              loc,
+              expr.callee.property,
+              describeReceiverPath(expr.callee.object),
+              receiverRootIsProp(expr.callee.object, bindings),
+              typeName
+            );
+          }
+        }
+      }
+      recurse(expr.callee);
+      for (const arg of expr.args) recurse(arg);
+      break;
+    }
+    case "member":
+      recurse(expr.object);
+      break;
+    case "index-access":
+      recurse(expr.object);
+      recurse(expr.index);
+      break;
+    case "binary":
+      recurse(expr.left);
+      recurse(expr.right);
+      break;
+    case "unary":
+      recurse(expr.argument);
+      break;
+    case "conditional":
+      recurse(expr.test);
+      recurse(expr.consequent);
+      recurse(expr.alternate);
+      break;
+    case "logical":
+      recurse(expr.left);
+      recurse(expr.right);
+      break;
+    case "template-literal":
+      for (const part of expr.parts) if (part.type === "expression") recurse(part.expr);
+      break;
+    case "arrow": {
+      const shadowed = new Map(bindings);
+      for (const param of expr.params) shadowed.set(param, null);
+      recurse(expr.body, shadowed);
+      break;
+    }
+    case "array-literal":
+      for (const el of expr.elements) recurse(el);
+      break;
+    case "object-literal":
+      for (const prop of expr.properties) recurse(prop.value);
+      break;
+    case "array-method":
+      recurse(expr.object);
+      for (const arg of expr.args) recurse(arg);
+      break;
+    case "identifier":
+    case "literal":
+    case "regex":
+    case "unsupported":
+      break;
+  }
+}
+function walkTemplateParts(parts, loc, meta, bindings, matchers, errors, seen) {
+  for (const part of parts) {
+    if (part.type === "ternary") {
+      const trimmed = part.condition.trim();
+      if (trimmed) checkExpr(parseExpression(trimmed), loc, meta, bindings, matchers, errors, seen);
+    } else if (part.type === "lookup") {
+      const trimmed = part.key.trim();
+      if (trimmed) checkExpr(parseExpression(trimmed), loc, meta, bindings, matchers, errors, seen);
+    }
+  }
+}
+function walkAttrValue(value2, clientOnly, loc, meta, bindings, matchers, errors, seen) {
+  if (clientOnly) return;
+  if (value2.kind === "expression") {
+    if (value2.parsed) checkExpr(value2.parsed, loc, meta, bindings, matchers, errors, seen);
+    if (value2.parts) walkTemplateParts(value2.parts, loc, meta, bindings, matchers, errors, seen);
+  } else if (value2.kind === "spread") {
+    if (value2.parsed) checkExpr(value2.parsed, loc, meta, bindings, matchers, errors, seen);
+  } else if (value2.kind === "template") {
+    walkTemplateParts(value2.parts, loc, meta, bindings, matchers, errors, seen);
+  }
+}
+function walkNode(node, meta, bindings, matchers, errors, seen) {
+  if (node.type === "expression") {
+    if (!node.clientOnly && node.parsed) checkExpr(node.parsed, node.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "conditional") {
+    if (!node.clientOnly && node.parsedCondition) checkExpr(node.parsedCondition, node.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "if-statement") {
+    if (node.parsedCondition) checkExpr(node.parsedCondition, node.loc, meta, bindings, matchers, errors, seen);
+  }
+  if (node.type === "element") {
+    for (const attr of node.attrs) walkAttrValue(attr.value, attr.clientOnly, attr.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "component") {
+    for (const prop of node.props) walkAttrValue(prop.value, prop.clientOnly, prop.loc, meta, bindings, matchers, errors, seen);
+  } else if (node.type === "provider") {
+    walkAttrValue(node.valueProp.value, node.valueProp.clientOnly, node.valueProp.loc, meta, bindings, matchers, errors, seen);
+  }
+  switch (node.type) {
+    case "element":
+    case "component":
+    case "fragment":
+    case "provider":
+      for (const child of node.children) walkNode(child, meta, bindings, matchers, errors, seen);
+      break;
+    case "async":
+      walkNode(node.fallback, meta, bindings, matchers, errors, seen);
+      for (const child of node.children) walkNode(child, meta, bindings, matchers, errors, seen);
+      break;
+    case "loop": {
+      if (node.clientOnly) break;
+      if (node.arrayParsed) checkExpr(node.arrayParsed, node.loc, meta, bindings, matchers, errors, seen);
+      const loopBindings = new Map(bindings);
+      const arrayType = node.arrayParsed ? resolveReceiverType(node.arrayParsed, meta, bindings) : null;
+      loopBindings.set(node.param, arrayType?.kind === "array" ? arrayType.elementType ?? null : null);
+      if (node.index) loopBindings.set(node.index, null);
+      for (const child of node.children) walkNode(child, meta, loopBindings, matchers, errors, seen);
+      if (node.childComponent) {
+        for (const child of node.childComponent.children) walkNode(child, meta, loopBindings, matchers, errors, seen);
+      }
+      for (const nested of node.nestedComponents ?? []) {
+        for (const child of nested.children) walkNode(child, meta, loopBindings, matchers, errors, seen);
+      }
+      for (const frag of node.flatMapCallback?.fragments ?? []) {
+        walkNode(frag.ir, meta, loopBindings, matchers, errors, seen);
+      }
+      break;
+    }
+    case "conditional":
+      if (node.clientOnly) break;
+      walkNode(node.whenTrue, meta, bindings, matchers, errors, seen);
+      walkNode(node.whenFalse, meta, bindings, matchers, errors, seen);
+      break;
+    case "if-statement":
+      walkNode(node.consequent, meta, bindings, matchers, errors, seen);
+      if (node.alternate) walkNode(node.alternate, meta, bindings, matchers, errors, seen);
+      break;
+  }
+}
+var EMPTY_BINDINGS;
+var init_rich_type_refusal = __esm({
+  "../jsx/src/rich-type-refusal.ts"() {
+    "use strict";
+    init_expression_parser();
+    init_lowering_registry();
+    init_errors();
+    init_rich_type_evidence();
+    EMPTY_BINDINGS = /* @__PURE__ */ new Map();
+  }
+});
+
 // ../jsx/src/compiler.ts
 function mergeTemplateImports(lines) {
   const result2 = [];
@@ -19863,6 +20170,7 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
       errors: []
     };
     componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
+    checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors);
     if (options2.cssLayerPrefix) {
       applyCssLayerPrefix(componentIR, options2.cssLayerPrefix);
     }
@@ -20199,6 +20507,7 @@ function compileJSX(source, filePath, options2) {
     errors: []
   };
   componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
+  checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors);
   if (ctx2.importedClientSignalNames.size > 0) {
     const sources = /* @__PURE__ */ new Set();
     for (const imp of ctx2.imports) {
@@ -20328,6 +20637,7 @@ var init_compiler = __esm({
     init_preprocess_inline_jsx_callbacks();
     init_ssr_defaults();
     init_ssr_seed_plan();
+    init_rich_type_refusal();
   }
 });
 
@@ -24253,6 +24563,7 @@ __export(src_exports, {
   getLoweringPlugins: () => getLoweringPlugins,
   graphToJSON: () => graphToJSON,
   groupBinaryOperand: () => groupBinaryOperand,
+  hasUnsafeStyleValue: () => hasUnsafeStyleValue,
   identifierPath: () => identifierPath,
   importsSearchParams: () => importsSearchParams,
   isBooleanAttr: () => isBooleanAttr,
@@ -28304,7 +28615,7 @@ 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"\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		// Nullish coalescing (#2248): JS `??` semantics \u2014 fall back only on\n		// nil, keeping present-but-falsy values (`""`, `0`, `false`) that\n		// Go\'s truthiness-based `or` would replace.\n		"bf_nullish": Nullish,\n\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// Nullish implements JS `??` for template use (`bf_nullish`, #2248): returns\n// fallback iff v is nil (untyped nil or a nil pointer/map/slice boxed in the\n// interface), otherwise v \u2014 so present-but-falsy `""`/`0`/`false` are KEPT,\n// unlike the truthiness-based template `or`.\nfunc Nullish(v, fallback any) any {\n	if v == nil {\n		return fallback\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Interface, reflect.Func, reflect.Chan:\n		if rv.IsNil() {\n			return fallback\n		}\n	}\n	return v\n}\n\n// ToInt exposes the runtime\'s numeric coercion for generated constructors\n// (#2248): a nillable-lowered numeric prop arrives as `interface{}`, and an\n// untyped Go literal (`Size: 3`) boxes as int even when the prop is\n// float64-shaped \u2014 a direct type assertion would panic where JS accepts the\n// number. Non-numeric values coerce to 0, matching the helpers\' behaviour.\nfunc ToInt(v any) int { return toInt(v) }\n\n// ToFloat64 is ToInt\'s float64 counterpart \u2014 see ToInt.\nfunc ToFloat64(v any) float64 { return toFloat64(v) }\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';
+    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		// Nullish coalescing (#2248): JS `??` semantics \u2014 fall back only on\n		// nil, keeping present-but-falsy values (`""`, `0`, `false`) that\n		// Go\'s truthiness-based `or` would replace.\n		"bf_nullish": Nullish,\n\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_length":         Length,\n		"bf_is_element":     IsValidElement,\n		"bf_style_object":   StyleObjectToCSS,\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// hasUnsafeStyleValue mirrors Hono\'s own CSS-injection guard\n// (`hono/jsx/utils.ts`\'s `hasUnsafeStyleValue` \u2014 the ORACLE this adapter\'s\n// dynamic `style={{...}}` values must match, #2261): a hand-rolled\n// structural scan for characters that could break out of a CSS\n// declaration, NOT real CSSOM property validation. Ported byte-for-byte \u2014\n// every character this scan tests is ASCII, so scanning by byte (Go\n// string indexing) agrees with Hono\'s UTF-16-code-unit scan for every\n// input; a multibyte UTF-8 sequence has no byte in the ASCII range, so it\n// can never spuriously match one of these single-byte comparisons. Skips\n// the reference implementation\'s regex fast-path (a pure optimization \u2014\n// the scan below already returns `false` promptly for a clean value).\nfunc hasUnsafeStyleValue(value string) bool {\n	quote := byte(0)\n	blockStack := make([]byte, 0, 4)\n	for i := 0; i < len(value); i++ {\n		c := value[i]\n		switch {\n		case c == \'\\\\\':\n			if i == len(value)-1 {\n				return true\n			}\n			i++\n		case quote != 0:\n			if c == \'\\n\' || c == \'\\f\' || c == \'\\r\' {\n				return true\n			}\n			if c == quote {\n				quote = 0\n			}\n		case c == \'/\' && i+1 < len(value) && value[i+1] == \'*\':\n			end := strings.Index(value[i+2:], "*/")\n			if end == -1 {\n				return true\n			}\n			i = i + 2 + end + 1\n		case c == \'"\' || c == \'\\\'\':\n			quote = c\n		case c == \'(\':\n			blockStack = append(blockStack, \')\')\n		case c == \'[\':\n			blockStack = append(blockStack, \']\')\n		case c == \'{\' || c == \'}\':\n			return true\n		case c == \')\' || c == \']\':\n			if len(blockStack) == 0 || blockStack[len(blockStack)-1] != c {\n				return true\n			}\n			blockStack = blockStack[:len(blockStack)-1]\n		case c == \';\' && len(blockStack) == 0:\n			return true\n		}\n	}\n	return quote != 0 || len(blockStack) != 0\n}\n\n// StyleObjectToCSS builds the CSS string for a `style={{...}}` JSX\n// object-literal attribute (#2261) \u2014 `pairs` alternates CSS key (always a\n// compile-time-known literal), then value (`any`, possibly a runtime\n// expression\'s result). A value that fails `hasUnsafeStyleValue` (after\n// JS-`String()`-style stringification) is DROPPED \u2014 the whole `key:value`\n// pair is omitted \u2014 matching Hono\'s oracle behavior exactly, rather than\n// html/template\'s own contextual CSS auto-escaper (which instead emits its\n// `ZgotmplZ` unsafe-content sentinel for the same input). The final joined\n// string is STILL HTML-escaped (mirroring Hono\'s own `escapeToBuffer` call\n// on its accumulated style string) \u2014 a "safe" value can still carry a\n// literal `"`/`\'`/`&` (e.g. a BALANCED-quote CSS string value like\n// `"hello"` passes the structural scan; the quote chars survive into the\n// value) that would otherwise break out of the double-quoted `style="..."`\n// attribute. Returns `template.CSS` (over the escaped result) so\n// html/template treats it as trusted CSS content instead of ALSO applying\n// its own contextual CSS auto-escaper (which would re-derive the exact\n// `ZgotmplZ` divergence this function exists to avoid).\nfunc StyleObjectToCSS(pairs ...any) template.CSS {\n	parts := make([]string, 0, len(pairs)/2)\n	for i := 0; i+1 < len(pairs); i += 2 {\n		key := fmt.Sprint(pairs[i])\n		value := String(pairs[i+1])\n		if hasUnsafeStyleValue(value) {\n			continue\n		}\n		parts = append(parts, template.HTMLEscapeString(key)+":"+template.HTMLEscapeString(value))\n	}\n	return template.CSS(strings.Join(parts, ";"))\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// Length lowers JS `.length`, matching JS semantics per receiver shape\n// (#2255): a slice/array/map counts ELEMENTS (`reflect.Value.Len`, same as\n// `Len` below), but a STRING counts UTF-16 CODE UNITS \u2014 JS\n// `String.prototype.length` counts UTF-16 code units, not bytes (Go\'s\n// native `len`) or codepoints. A codepoint outside the Basic Multilingual\n// Plane (astral, U+10000-U+10FFFF \u2014 e.g. \'\u{1F44D}\') is a surrogate PAIR in\n// UTF-16, so it counts as 2, not 1; `\'\u65E5\u672C\u8A9E\'` is 3 either way (BMP-only).\n// Routed from the `.length` member lowering\'s generic (non-array,\n// non-loop-slice) fallback \u2014 see `member()`\'s `bf_length` call site.\nfunc Length(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.Chan:\n		return rv.Len()\n	case reflect.String:\n		n := 0\n		for _, r := range rv.String() {\n			if r > 0xFFFF {\n				n += 2\n			} else {\n				n++\n			}\n		}\n		return n\n	default:\n		return 0\n	}\n}\n\n// IsValidElement lowers React/Hono-style `isValidElement(x)` \u2014 the "is this\n// a renderable element (not plain text)?" predicate the `Slot` component\'s\n// `asChild` pattern (#2266) uses to decide whether to merge props into a\n// child ELEMENT (`children.tag`/`children.props`) or fall back to rendering\n// `children` as-is. The JS runtime checks `\'tag\' in x && \'props\' in x`; on\n// Go SSR a passed-through JSX child is represented as pre-rendered markup\n// (a plain string) OR \u2014 where a struct/map shape carrying `Tag`/`Props`\n// (case-insensitively, mirroring `bf_get`\'s field lookup) is available \u2014 an\n// element-shaped value. A plain string/number/bool/nil is never a valid\n// element, so `isValidElement` must NOT be lowered as bare truthiness\n// (previously done via `renderConditionExpr`) \u2014 a truthy non-empty STRING\n// child wrongly took the element-merge branch and panicked dereferencing\n// `.Props` on a string (`can\'t evaluate field Props in type interface {}`).\nfunc IsValidElement(v any) bool {\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	switch rv.Kind() {\n	case reflect.Map:\n		hasTag, hasProps := false, false\n		for _, k := range rv.MapKeys() {\n			key := fmt.Sprintf("%v", k.Interface())\n			if strings.EqualFold(key, "tag") {\n				hasTag = true\n			}\n			if strings.EqualFold(key, "props") {\n				hasProps = true\n			}\n		}\n		return hasTag && hasProps\n	case reflect.Struct:\n		return fieldByFoldedName(rv, "tag").IsValid() && fieldByFoldedName(rv, "props").IsValid()\n	default:\n		return false\n	}\n}\n\n// fieldByFoldedName finds a struct field by case-insensitive name match \u2014\n// shared by IsValidElement; mirrors getFieldValue\'s (bf_get) struct-branch\n// lookup so the two case-tolerant field resolutions stay consistent.\nfunc fieldByFoldedName(rv reflect.Value, name string) reflect.Value {\n	t := rv.Type()\n	for i := 0; i < t.NumField(); i++ {\n		if strings.EqualFold(t.Field(i).Name, name) {\n			return rv.Field(i)\n		}\n	}\n	return reflect.Value{}\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// Nullish implements JS `??` for template use (`bf_nullish`, #2248): returns\n// fallback iff v is nil (untyped nil or a nil pointer/map/slice boxed in the\n// interface), otherwise v \u2014 so present-but-falsy `""`/`0`/`false` are KEPT,\n// unlike the truthiness-based template `or`.\nfunc Nullish(v, fallback any) any {\n	if v == nil {\n		return fallback\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Interface, reflect.Func, reflect.Chan:\n		if rv.IsNil() {\n			return fallback\n		}\n	}\n	return v\n}\n\n// ToInt exposes the runtime\'s numeric coercion for generated constructors\n// (#2248): a nillable-lowered numeric prop arrives as `interface{}`, and an\n// untyped Go literal (`Size: 3`) boxes as int even when the prop is\n// float64-shaped \u2014 a direct type assertion would panic where JS accepts the\n// number. Non-numeric values coerce to 0, matching the helpers\' behaviour.\nfunc ToInt(v any) int { return toInt(v) }\n\n// ToFloat64 is ToInt\'s float64 counterpart \u2014 see ToInt.\nfunc ToFloat64(v any) float64 { return toFloat64(v) }\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		rv := reflect.ValueOf(v)\n		if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {\n			// JS `Array.prototype.toString` is `this.join(\',\')`, applied\n			// recursively \u2014 a nested array element stringifies the same\n			// way rather than via Go\'s `%v`. Reached via `Join`/`ConcatStr`\n			// on an element that is itself an array (e.g. `.flat(0)`\'s\n			// shallow copy joined afterwards, #2262).\n			parts := make([]string, rv.Len())\n			for i := 0; i < rv.Len(); i++ {\n				parts[i] = toString(rv.Index(i).Interface())\n			}\n			return strings.Join(parts, ",")\n		}\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
 //
@@ -85375,9 +85686,9 @@ var init_WebSocketReadyStateEnum = __esm({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/constants.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/constants.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/constants.js"(exports, module) {
     "use strict";
     var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
     var hasBlob = typeof Blob !== "undefined";
@@ -85398,9 +85709,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/buffer-util.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/buffer-util.js
 var require_buffer_util = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/buffer-util.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/buffer-util.js"(exports, module) {
     "use strict";
     var { EMPTY_BUFFER } = require_constants();
     var FastBuffer = Buffer[Symbol.species];
@@ -85473,9 +85784,9 @@ var require_buffer_util = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/limiter.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/limiter.js
 var require_limiter = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/limiter.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/limiter.js"(exports, module) {
     "use strict";
     var kDone = Symbol("kDone");
     var kRun = Symbol("kRun");
@@ -85523,9 +85834,9 @@ var require_limiter = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/permessage-deflate.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/permessage-deflate.js
 var require_permessage_deflate = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/permessage-deflate.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/permessage-deflate.js"(exports, module) {
     "use strict";
     var zlib = __require("node:zlib");
     var bufferUtil = require_buffer_util();
@@ -85906,9 +86217,9 @@ var require_permessage_deflate = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/validation.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/validation.js
 var require_validation = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/validation.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/validation.js"(exports, module) {
     "use strict";
     var { isUtf8 } = __require("node:buffer");
     var { hasBlob } = require_constants();
@@ -86107,9 +86418,9 @@ var require_validation = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/receiver.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/receiver.js
 var require_receiver = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/receiver.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/receiver.js"(exports, module) {
     "use strict";
     var { Writable } = __require("node:stream");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -86172,6 +86483,7 @@ var require_receiver = __commonJS({
         this._opcode = 0;
         this._totalPayloadLength = 0;
         this._messageLength = 0;
+        this._numFragments = 0;
         this._fragments = [];
         this._errored = false;
         this._loop = false;
@@ -86522,23 +86834,23 @@ var require_receiver = __commonJS({
           this.controlMessage(data2, cb);
           return;
         }
+        if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
+          const error2 = this.createError(
+            RangeError,
+            "Too many message fragments",
+            false,
+            1008,
+            "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+          );
+          cb(error2);
+          return;
+        }
         if (this._compressed) {
           this._state = INFLATING;
           this.decompress(data2, cb);
           return;
         }
         if (data2.length) {
-          if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-            const error2 = this.createError(
-              RangeError,
-              "Too many message fragments",
-              false,
-              1008,
-              "WS_ERR_TOO_MANY_BUFFERED_PARTS"
-            );
-            cb(error2);
-            return;
-          }
           this._messageLength = this._totalPayloadLength;
           this._fragments.push(data2);
         }
@@ -86568,17 +86880,6 @@ var require_receiver = __commonJS({
               cb(error2);
               return;
             }
-            if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-              const error2 = this.createError(
-                RangeError,
-                "Too many message fragments",
-                false,
-                1008,
-                "WS_ERR_TOO_MANY_BUFFERED_PARTS"
-              );
-              cb(error2);
-              return;
-            }
             this._fragments.push(buf);
           }
           this.dataMessage(cb);
@@ -86601,6 +86902,7 @@ var require_receiver = __commonJS({
         this._totalPayloadLength = 0;
         this._messageLength = 0;
         this._fragmented = 0;
+        this._numFragments = 0;
         this._fragments = [];
         if (this._opcode === 2) {
           let data2;
@@ -86739,9 +87041,9 @@ var require_receiver = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/sender.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/sender.js
 var require_sender = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/sender.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/sender.js"(exports, module) {
     "use strict";
     var { Duplex } = __require("node:stream");
     var { randomFillSync } = __require("node:crypto");
@@ -87232,9 +87534,9 @@ var require_sender = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/event-target.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/event-target.js
 var require_event_target = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/event-target.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/event-target.js"(exports, module) {
     "use strict";
     var { kForOnEventAttribute, kListener } = require_constants();
     var kCode = Symbol("kCode");
@@ -87461,9 +87763,9 @@ var require_event_target = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/extension.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/extension.js
 var require_extension = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/extension.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/extension.js"(exports, module) {
     "use strict";
     var { tokenChars } = require_validation();
     function push(dest, name2, elem) {
@@ -87614,9 +87916,9 @@ var require_extension = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/websocket.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/websocket.js
 var require_websocket = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/websocket.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
     var EventEmitter = __require("node:events");
     var https = __require("node:https");
@@ -88101,8 +88403,8 @@ var require_websocket = __commonJS({
         autoPong: true,
         closeTimeout: CLOSE_TIMEOUT,
         protocolVersion: protocolVersions[1],
-        maxBufferedChunks: 1024 * 1024,
-        maxFragments: 128 * 1024,
+        maxBufferedChunks: 256 * 1024,
+        maxFragments: 16 * 1024,
         maxPayload: 100 * 1024 * 1024,
         skipUTF8Validation: false,
         perMessageDeflate: true,
@@ -88510,9 +88812,9 @@ var require_websocket = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/stream.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/stream.js
 var require_stream = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/stream.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/stream.js"(exports, module) {
     "use strict";
     var WebSocket3 = require_websocket();
     var { Duplex } = __require("node:stream");
@@ -88608,9 +88910,9 @@ var require_stream = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/subprotocol.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/subprotocol.js
 var require_subprotocol = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/subprotocol.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/subprotocol.js"(exports, module) {
     "use strict";
     var { tokenChars } = require_validation();
     function parse(header) {
@@ -88653,9 +88955,9 @@ var require_subprotocol = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/websocket-server.js
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/websocket-server.js
 var require_websocket_server = __commonJS({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/websocket-server.js"(exports, module) {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
     var EventEmitter = __require("node:events");
     var http = __require("node:http");
@@ -88689,9 +88991,9 @@ var require_websocket_server = __commonJS({
        *     called
        * @param {Function} [options.handleProtocols] A hook to handle protocols
        * @param {String} [options.host] The hostname where to bind the server
-       * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+       * @param {Number} [options.maxBufferedChunks=262144] The maximum number of
        *     buffered data chunks
-       * @param {Number} [options.maxFragments=131072] The maximum number of message
+       * @param {Number} [options.maxFragments=16384] The maximum number of message
        *     fragments
        * @param {Number} [options.maxPayload=104857600] The maximum allowed message
        *     size
@@ -88714,8 +89016,8 @@ var require_websocket_server = __commonJS({
         options2 = {
           allowSynchronousEvents: true,
           autoPong: true,
-          maxBufferedChunks: 1024 * 1024,
-          maxFragments: 128 * 1024,
+          maxBufferedChunks: 256 * 1024,
+          maxFragments: 16 * 1024,
           maxPayload: 100 * 1024 * 1024,
           skipUTF8Validation: false,
           perMessageDeflate: false,
@@ -89054,10 +89356,10 @@ var require_websocket_server = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/ws@8.21.0/node_modules/ws/wrapper.mjs
+// ../../node_modules/.bun/ws@8.21.1/node_modules/ws/wrapper.mjs
 var import_stream3, import_extension, import_permessage_deflate, import_receiver, import_sender, import_subprotocol, import_websocket, import_websocket_server, wrapper_default;
 var init_wrapper = __esm({
-  "../../node_modules/.bun/ws@8.21.0/node_modules/ws/wrapper.mjs"() {
+  "../../node_modules/.bun/ws@8.21.1/node_modules/ws/wrapper.mjs"() {
     import_stream3 = __toESM(require_stream(), 1);
     import_extension = __toESM(require_extension(), 1);
     import_permessage_deflate = __toESM(require_permessage_deflate(), 1);