@barefootjs/cli 0.17.1 → 0.18.1

package/dist/index.js

@@ -408,6 +408,7 @@ function convertNode(node, raw) {
       if (callee.property === "flat") {
         const depthNode = node.arguments[0];
         let flatDepth;
+        let depthExpr;
         if (depthNode === void 0) {
           flatDepth = 1;
         } else if (ts.isIdentifier(depthNode) && depthNode.text === "Infinity") {
@@ -420,16 +421,23 @@ function convertNode(node, raw) {
             n = -Number(depthNode.operand.text);
           }
           if (n === void 0 || Number.isNaN(n)) {
-            return {
-              kind: "unsupported",
-              raw,
-              reason: `\`.flat(depth)\` needs a literal integer or \`Infinity\` depth \u2014 a computed depth can't be resolved at template time. Use a literal depth, or pre-compute the value before the template.`
-            };
+            const parsedDepth = convertNode(depthNode, raw);
+            if (checkSupport(parsedDepth).supported) {
+              depthExpr = parsedDepth;
+              flatDepth = 1;
+            } else {
+              return {
+                kind: "unsupported",
+                raw,
+                reason: `\`.flat(depth)\` needs a literal integer, \`Infinity\`, or a supported dynamic depth expression \u2014 this depth can't be resolved. Use a literal depth, a supported expression (prop/signal/arithmetic), or pre-compute the value before the template.`
+              };
+            }
+          } else {
+            const truncated = Math.trunc(n);
+            flatDepth = truncated < 0 ? 0 : truncated;
           }
-          const truncated = Math.trunc(n);
-          flatDepth = truncated < 0 ? 0 : truncated;
         }
-        return { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
+        return depthExpr !== void 0 ? { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth, depthExpr } : { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
       }
       if (callee.property === "toLowerCase") {
         return { kind: "array-method", method: "toLowerCase", object: callee.object, args: args2 };
@@ -941,6 +949,7 @@ function validateRestUsage(expr, restName, excludedTopKeys) {
       case "array-method":
         walk(e.object);
         for (const a of e.args) walk(a);
+        if (e.method === "flat" && e.depthExpr) walk(e.depthExpr);
         return;
       case "literal":
       case "unsupported":
@@ -1023,6 +1032,7 @@ function collectIdentifiers(expr, out) {
     case "array-method":
       collectIdentifiers(expr.object, out);
       expr.args.forEach((e) => collectIdentifiers(e, out));
+      if (expr.method === "flat" && expr.depthExpr) collectIdentifiers(expr.depthExpr, out);
       return;
     case "literal":
     case "regex":
@@ -1083,7 +1093,14 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
         return { kind: "array-literal", elements: e.elements.map(walk) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object), args: e.args.map(walk) };
       case "literal":
@@ -1187,6 +1204,10 @@ function checkSupport(expr) {
         const argSupport = checkSupport(arg);
         if (!argSupport.supported) return argSupport;
       }
+      if (expr.method === "flat" && expr.depthExpr) {
+        const depthSupport = checkSupport(expr.depthExpr);
+        if (!depthSupport.supported) return depthSupport;
+      }
       return { supported: true, level: "L2" };
     }
     case "call": {
@@ -1278,6 +1299,9 @@ function checkSupport(expr) {
     case "logical": {
       const leftSupport = checkSupport(expr.left);
       if (!leftSupport.supported) return leftSupport;
+      if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
+        return { supported: true, level: "L4" };
+      }
       const rightSupport = checkSupport(expr.right);
       if (!rightSupport.supported) return rightSupport;
       return { supported: true, level: "L4" };
@@ -1326,7 +1350,7 @@ function containsHigherOrder(expr) {
     case "array-literal":
       return expr.elements.some(containsHigherOrder);
     case "array-method":
-      return containsHigherOrder(expr.object) || expr.args.some(containsHigherOrder);
+      return containsHigherOrder(expr.object) || expr.args.some(containsHigherOrder) || expr.method === "flat" && expr.depthExpr !== void 0 && containsHigherOrder(expr.depthExpr);
     default:
       return false;
   }
@@ -1492,7 +1516,10 @@ function usesPerPath(name2, expr) {
       case "array-literal":
         return sum(e.elements);
       case "array-method":
-        return add(walk(e.object), e.method === "flat" ? { min: 0, max: 0 } : sum(e.args));
+        if (e.method === "flat") {
+          return add(walk(e.object), e.depthExpr ? walk(e.depthExpr) : { min: 0, max: 0 });
+        }
+        return add(walk(e.object), sum(e.args));
       case "object-literal":
         return sum(e.properties.map((p) => p.value));
       case "arrow":
@@ -1547,7 +1574,14 @@ function inlineBinding(expr, name2, value2) {
         return { kind: "array-literal", elements: e.elements.map((el) => walk(el, enclosing)) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object, enclosing), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object, enclosing),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr, enclosing) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object, enclosing), args: e.args.map((a) => walk(a, enclosing)) };
       case "object-literal":
@@ -1669,6 +1703,9 @@ function exprToString(expr) {
       return `[${expr.elements.map(exprToString).join(", ")}]`;
     case "array-method":
       if (expr.method === "flat") {
+        if (expr.depthExpr) {
+          return `${exprToString(expr.object)}.flat(${exprToString(expr.depthExpr)})`;
+        }
         const d = expr.flatDepth;
         const depthSrc = d === "infinity" ? "Infinity" : String(d);
         return `${exprToString(expr.object)}.flat(${d === 1 ? "" : depthSrc})`;
@@ -1721,6 +1758,9 @@ function stringifyParsedExpr(expr) {
       return `[${expr.elements.map(stringifyParsedExpr).join(", ")}]`;
     case "array-method":
       if (expr.method === "flat") {
+        if (expr.depthExpr) {
+          return `${stringifyParsedExpr(expr.object)}.flat(${stringifyParsedExpr(expr.depthExpr)})`;
+        }
         const d = expr.flatDepth;
         const depthSrc = d === "infinity" ? "Infinity" : String(d);
         return `${stringifyParsedExpr(expr.object)}.flat(${d === 1 ? "" : depthSrc})`;
@@ -1766,7 +1806,9 @@ function materializeGetterCalls(expr, names) {
     case "array-literal":
       return { kind: "array-literal", elements: expr.elements.map(rw) };
     case "array-method":
-      if (expr.method === "flat") return { ...expr, object: rw(expr.object) };
+      if (expr.method === "flat") {
+        return { ...expr, object: rw(expr.object), ...expr.depthExpr ? { depthExpr: rw(expr.depthExpr) } : {} };
+      }
       return { ...expr, object: rw(expr.object), args: expr.args.map(rw) };
     case "object-literal":
       return {
@@ -1790,60 +1832,66 @@ function serializeParsedExpr(expr) {
 }
 function freeVarsInBody(body2, params) {
   const found = /* @__PURE__ */ new Set();
-  const visit3 = (e) => {
+  const visit3 = (e, bound) => {
     switch (e.kind) {
       case "identifier":
-        if (!params.has(e.name)) found.add(e.name);
+        if (!bound.has(e.name)) found.add(e.name);
         return;
       case "binary":
       case "logical":
-        visit3(e.left);
-        visit3(e.right);
+        visit3(e.left, bound);
+        visit3(e.right, bound);
         return;
       case "unary":
-        visit3(e.argument);
+        visit3(e.argument, bound);
         return;
       case "conditional":
-        visit3(e.test);
-        visit3(e.consequent);
-        visit3(e.alternate);
+        visit3(e.test, bound);
+        visit3(e.consequent, bound);
+        visit3(e.alternate, bound);
         return;
       case "member":
-        visit3(e.object);
+        visit3(e.object, bound);
         return;
       case "index-access":
-        visit3(e.object);
-        visit3(e.index);
+        visit3(e.object, bound);
+        visit3(e.index, bound);
         return;
       case "call":
-        if (evalBuiltinCalleeName(e.callee) === null) visit3(e.callee);
-        e.args.forEach(visit3);
+        if (evalBuiltinCalleeName(e.callee) === null) visit3(e.callee, bound);
+        e.args.forEach((a) => visit3(a, bound));
         return;
       case "template-literal":
-        for (const p of e.parts) if (p.type === "expression") visit3(p.expr);
+        for (const p of e.parts) if (p.type === "expression") visit3(p.expr, bound);
         return;
       case "array-literal":
-        e.elements.forEach(visit3);
+        e.elements.forEach((el) => visit3(el, bound));
         return;
       case "object-literal":
-        for (const p of e.properties) visit3(p.value);
+        for (const p of e.properties) visit3(p.value, bound);
         return;
       case "array-method":
-        if (e.method === "includes") {
-          visit3(e.object);
-          e.args.forEach(visit3);
+        if (e.method === "includes" || e.method === "join") {
+          visit3(e.object, bound);
+          e.args.forEach((a) => visit3(a, bound));
         }
         return;
+      // A nested callback arrow (the `.map`/`.filter` callback argument,
+      // #2094): its own params shadow the outer bound set for its body only.
+      case "arrow": {
+        const inner = e.params.length === 0 ? bound : /* @__PURE__ */ new Set([...bound, ...e.params]);
+        visit3(e.body, inner);
+        return;
+      }
       // Non-serializable kinds don't occur in a serializable body
       // (serializeParsedExpr returns null for them); nothing to collect.
       case "literal":
-      case "arrow":
       case "regex":
       case "unsupported":
         return;
     }
   };
-  visit3(body2);
+  visit3(body2, params);
   return [...found].sort();
 }
 function freeIdentifiers(expr) {
@@ -1884,6 +1932,7 @@ function freeIdentifiers(expr) {
       case "array-method":
         if (!visit3(e.object, bound)) return false;
         for (const a of e.args) if (!visit3(a, bound)) return false;
+        if (e.method === "flat" && e.depthExpr && !visit3(e.depthExpr, bound)) return false;
         return true;
       case "object-literal":
         for (const p of e.properties) if (!visit3(p.value, bound)) return false;
@@ -1949,6 +1998,18 @@ function toEvalNode(e) {
       return object && index ? { kind: "index-access", object, index } : null;
     }
     case "call": {
+      const cb = asCallbackMethodCall(e);
+      if (cb && (cb.method === "map" || cb.method === "filter")) {
+        const object = toEvalNode(cb.object);
+        if (!object) return null;
+        const body2 = toEvalNode(cb.arrow.body);
+        if (!body2) return null;
+        return {
+          kind: "call",
+          callee: { kind: "member", object, property: cb.method, computed: false },
+          args: [{ kind: "arrow", params: cb.arrow.params, body: body2 }]
+        };
+      }
       if (evalBuiltinCalleeName(e.callee) === null) return null;
       const callee = toEvalNode(e.callee);
       if (!callee) return null;
@@ -1997,6 +2058,13 @@ function toEvalNode(e) {
         const arg = toEvalNode(e.args[0]);
         return object && arg ? { kind: "array-method", method: "includes", object, args: [arg] } : null;
       }
+      if (e.method === "join" && e.args.length <= 1) {
+        const object = toEvalNode(e.object);
+        if (!object) return null;
+        if (e.args.length === 0) return { kind: "array-method", method: "join", object, args: [] };
+        const sep = toEvalNode(e.args[0]);
+        return sep ? { kind: "array-method", method: "join", object, args: [sep] } : null;
+      }
       return null;
     }
     // Outside the evaluator's pure-expression surface — refuse so the caller
@@ -3568,6 +3636,84 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       return assertNever(node);
   }
 }
+function buildLoopSkeletonTemplate(node, safe) {
+  switch (node.type) {
+    case "element": {
+      const attrParts = [];
+      for (const a of node.attrs) {
+        if (a.name === "...") return null;
+        if (a.name === "dangerouslySetInnerHTML") return null;
+        if (a.name === "key") {
+          attrParts.push(`${keyAttrName(0)}=""`);
+          continue;
+        }
+        const v = a.value;
+        switch (v.kind) {
+          case "literal":
+            attrParts.push(`${toHTMLAttrName(a.name)}="${v.value}"`);
+            break;
+          case "boolean-attr":
+            attrParts.push(toHTMLAttrName(a.name));
+            break;
+          case "boolean-shorthand":
+          case "jsx-children":
+            break;
+          case "expression":
+          case "template": {
+            const attrKey = node.slotId ? `${node.slotId}::${a.name}` : null;
+            if (!attrKey || !safe.reactiveAttrKeys.has(attrKey)) return null;
+            break;
+          }
+          case "spread":
+            return null;
+        }
+      }
+      if (node.slotId) attrParts.push(`bf="${node.slotId}"`);
+      const attrs = attrParts.join(" ");
+      let children2 = "";
+      for (const child of node.children) {
+        const rendered = buildLoopSkeletonTemplate(child, safe);
+        if (rendered === null) return null;
+        children2 += rendered;
+      }
+      if (children2 || !VOID_ELEMENTS.has(node.tag)) {
+        return `<${node.tag}${attrs ? " " + attrs : ""}>${children2}</${node.tag}>`;
+      }
+      return `<${node.tag}${attrs ? " " + attrs : ""} />`;
+    }
+    case "text":
+      return node.value;
+    case "expression":
+      if (node.expr === "null" || node.expr === "undefined") return "";
+      if (!node.slotId) {
+        return null;
+      }
+      if (!safe.reactiveTextSlotIds.has(node.slotId)) return null;
+      return `<!--bf:${node.slotId}--><!--/-->`;
+    case "fragment": {
+      let out = "";
+      for (const child of node.children) {
+        const rendered = buildLoopSkeletonTemplate(child, safe);
+        if (rendered === null) return null;
+        out += rendered;
+      }
+      return out;
+    }
+    // Conditionals, child components, nested loops, and provider/async/
+    // if-statement/slot boundaries are all out of scope for the hoisted
+    // fast path — the caller falls back to `irToHtmlTemplate`.
+    case "conditional":
+    case "component":
+    case "loop":
+    case "if-statement":
+    case "provider":
+    case "async":
+    case "slot":
+      return null;
+    default:
+      return assertNever(node);
+  }
+}
 function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParams) {
   const recurse = (n) => irToPlaceholderTemplate(n, restSpreadNames, loopDepth, loopParams);
   const wrapExpr = (expr) => wrapExprWithLoopParams(expr, loopParams);
@@ -3961,7 +4107,20 @@ function generateCsrTemplate(node, inlinableConstants, ctx2, insideLoop, restSpr
       }
     }
   }
-  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames, deferredChildSlots, loopDepth: -1 });
+  const effectiveUnsafeLocalNames = mergeCsrNullUnsafe(ctx2, unsafeLocalNames);
+  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames: effectiveUnsafeLocalNames, deferredChildSlots, loopDepth: -1 });
+}
+function mergeCsrNullUnsafe(ctx2, unsafeLocalNames) {
+  let merged = null;
+  let exemptNames = null;
+  for (const [name2, entry] of ctx2.csrInlinable) {
+    if (entry !== null || unsafeLocalNames?.has(name2)) continue;
+    exemptNames ??= new Set(ctx2.localConstants.filter((c) => c.isJsx || c.systemConstructKind).map((c) => c.name));
+    if (exemptNames.has(name2)) continue;
+    if (!merged) merged = new Set(unsafeLocalNames ?? []);
+    merged.add(name2);
+  }
+  return merged ?? unsafeLocalNames;
 }
 function buildCsrEnvForCtx(ctx2, inlinableConstants, propsObjectName) {
   const base = buildSignalMemoEnv(ctx2.signals, ctx2.memos, propsObjectName ?? null);
@@ -4561,6 +4720,15 @@ function createAnalyzerContext(sourceFile, filePath) {
     checker: null,
     componentBodyBlock: null,
     getJS(node) {
+      let ownSourceFile;
+      try {
+        ownSourceFile = node.getSourceFile();
+      } catch {
+        ownSourceFile = void 0;
+      }
+      if (ownSourceFile && ownSourceFile !== sourceFile) {
+        return node.getText(ownSourceFile);
+      }
       return reconstructWithoutTypes(node, sourceFile, this.typeExcludeRanges);
     }
   };
@@ -6499,6 +6667,7 @@ function extractProps(param, ctx2) {
       loc: getSourceLocation(param, ctx2.sourceFile, ctx2.filePath),
       hasIgnoreDirective: ignored
     };
+    const memberTypes = param.type ? collectMemberTypes(param.type, ctx2) : null;
     for (const element of param.name.elements) {
       if (ts8.isBindingElement(element) && ts8.isIdentifier(element.name)) {
         const localName2 = element.name.text;
@@ -6507,10 +6676,12 @@ function extractProps(param, ctx2) {
           ctx2.restPropsName = localName2;
           continue;
         }
+        const sourcePropName = element.propertyName && ts8.isIdentifier(element.propertyName) ? element.propertyName.text : localName2;
+        const resolvedType = memberTypes?.get(sourcePropName) ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false;
         ctx2.propsParams.push({
           name: localName2,
-          type: { kind: "unknown", raw: "unknown" },
+          type: resolvedType,
           optional: !!element.initializer,
           defaultValue: defaultValue2,
           defaultContainsArrow: defaultContainsArrow || void 0
@@ -6568,6 +6739,36 @@ function collectKeysFromMembers(members, ctx2) {
   }
   return keys;
 }
+function collectMemberTypes(typeNode, ctx2) {
+  const isResolvablePrimitive = (info) => info.kind === "primitive" && (info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean");
+  const fromMembers = (members) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const member of members) {
+      if (ts8.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
+        const info = typeNodeToTypeInfo(member.type, ctx2.sourceFile);
+        if (info && isResolvablePrimitive(info)) {
+          map.set(member.name.getText(ctx2.sourceFile), info);
+        }
+      }
+    }
+    return map;
+  };
+  if (ts8.isTypeLiteralNode(typeNode)) {
+    return fromMembers(typeNode.members);
+  }
+  if (ts8.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(ctx2.sourceFile);
+    const typeDecl = findTypeDeclaration(typeName, ctx2.sourceFile);
+    if (!typeDecl) return null;
+    if (ts8.isInterfaceDeclaration(typeDecl)) {
+      return fromMembers(typeDecl.members);
+    }
+    if (ts8.isTypeAliasDeclaration(typeDecl) && ts8.isTypeLiteralNode(typeDecl.type)) {
+      return fromMembers(typeDecl.type.members);
+    }
+  }
+  return null;
+}
 function extractPropsFromType(typeNode, ctx2) {
   if (ts8.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx2);
@@ -7300,6 +7501,115 @@ var init_types = __esm({
   }
 });
 
+// ../jsx/src/module-exports.ts
+function generateModuleExports(ir, extraInlineExported = /* @__PURE__ */ new Set(), rewriteRelativeImport) {
+  const lines = [];
+  for (const constant of ir.metadata.localConstants) {
+    if (!constant.isExported) continue;
+    const keyword = constant.declarationKind ?? "const";
+    if (!constant.value) {
+      lines.push(`export ${keyword} ${constant.name}`);
+      continue;
+    }
+    const value2 = constant.value.trim();
+    if (/^createContext\b/.test(value2) || /^new WeakMap\b/.test(value2)) continue;
+    lines.push(`export ${keyword} ${constant.name} = ${constant.value}`);
+  }
+  for (const func of ir.metadata.localFunctions) {
+    if (!func.isExported) continue;
+    const params = func.typedParams !== void 0 ? func.typedParams : func.params.map(formatParamWithType).join(", ");
+    const returnAnnotation = func.typedReturnType ? `: ${func.typedReturnType}` : "";
+    const body2 = func.typedBody ?? func.body;
+    const asyncKw = func.isAsync ? "async " : "";
+    lines.push(`export ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body2}`);
+  }
+  const inlineExported = collectInlineExportedNames(ir);
+  for (const name2 of extraInlineExported) inlineExported.add(name2);
+  for (const block of ir.metadata.namedExports) {
+    const isReexportFrom = block.source !== null;
+    const survivingSpecs = block.specifiers.filter((spec) => {
+      if (isReexportFrom) return true;
+      return !(inlineExported.has(spec.name) && spec.alias == null);
+    });
+    if (survivingSpecs.length === 0) continue;
+    const specText = survivingSpecs.map((s) => {
+      const prefix2 = s.isTypeOnly ? "type " : "";
+      return s.alias ? `${prefix2}${s.name} as ${s.alias}` : `${prefix2}${s.name}`;
+    }).join(", ");
+    const typeKw = block.isTypeOnly ? "type " : "";
+    if (isReexportFrom) {
+      const source = rewriteRelativeImport && block.source.startsWith(".") ? rewriteRelativeImport(block.source) : block.source;
+      lines.push(`export ${typeKw}{ ${specText} } from '${source}'`);
+    } else {
+      lines.push(`export ${typeKw}{ ${specText} }`);
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function collectInlineExportedNames(ir) {
+  const names = /* @__PURE__ */ new Set();
+  for (const c of ir.metadata.localConstants) {
+    if (c.isExported) names.add(c.name);
+  }
+  for (const f of ir.metadata.localFunctions) {
+    if (f.isExported) names.add(f.name);
+  }
+  if (ir.metadata.isExported && ir.metadata.componentName) {
+    names.add(ir.metadata.componentName);
+  }
+  return names;
+}
+function formatParamWithType(p) {
+  const rest2 = p.isRest ? "..." : "";
+  const optional = p.optional ? "?" : "";
+  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
+  const defaultPart = p.defaultValue !== void 0 ? ` = ${p.defaultValue}` : "";
+  return `${rest2}${p.name}${optional}${typeAnnotation}${defaultPart}`;
+}
+function findReachableNames(primaryRefs, declarations) {
+  const allNames = new Set(declarations.map((d) => d.name));
+  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const name2 of allNames) {
+    if (new RegExp(`\\b${name2}\\b`).test(primaryRefs)) {
+      reachable.add(name2);
+      queue.push(name2);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const body2 = bodyMap.get(current) || "";
+    for (const name2 of allNames) {
+      if (!reachable.has(name2) && new RegExp(`\\b${name2}\\b`).test(body2)) {
+        reachable.add(name2);
+        queue.push(name2);
+      }
+    }
+  }
+  return reachable;
+}
+function extractFunctionParams(value2) {
+  const arrowMatch = value2.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
+  if (arrowMatch) {
+    return arrowMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
+  }
+  const singleMatch = value2.match(/^(?:async\s*)?(\w+)\s*=>/);
+  if (singleMatch) {
+    return singleMatch[1];
+  }
+  const funcMatch = value2.match(/^(?:async\s*)?function\s*\w*\s*\(([^)]*)\)/);
+  if (funcMatch) {
+    return funcMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
+  }
+  return "";
+}
+var init_module_exports = __esm({
+  "../jsx/src/module-exports.ts"() {
+    "use strict";
+  }
+});
+
 // ../jsx/src/builtins.ts
 function isClientBuiltinName(name2) {
   return name2 === "Async" || name2 === "Region";
@@ -8408,6 +8718,7 @@ function transformExpression(node, ctx2) {
   return transformExpressionInner(expr, ctx2, node, isClientOnly);
 }
 function transformExpressionInner(expr, ctx2, node, isClientOnly) {
+  expr = tryDesugarInterleaveTaggedTemplate(expr, ctx2);
   checkBareSignalOrMemoIdentifier(expr, ctx2);
   if (ts11.isIdentifier(expr)) {
     const jsxNode = ctx2.analyzer.jsxConstants.get(expr.text);
@@ -8957,11 +9268,10 @@ function isIteratorShapeCall(node) {
   return { array: node.expression.expression, shape: name2 };
 }
 function extractSortComparator(callback, _method, ctx2) {
-  const unsupported = () => {
-    const raw = ctx2.getJS(callback);
-    return {
-      result: null,
-      unsupportedReason: `Sort comparator '${raw}' is not a supported shape. Accepted:
+  const outerRaw = ctx2.getJS(callback);
+  const unsupported = () => ({
+    result: null,
+    unsupportedReason: `Sort comparator '${outerRaw}' is not a supported shape. Accepted:
   (a, b) => a - b
   (a, b) => a.field - b.field
   (a, b) => a.localeCompare(b)
@@ -8969,15 +9279,25 @@ function extractSortComparator(callback, _method, ctx2) {
   (a, b) => a.field > b.field ? 1 : a.field < b.field ? -1 : 0
   any of the above '||'-chained for multi-key tie-breaks
 (reverse the operands for descending order).`
-    };
-  };
-  if (!ts11.isArrowFunction(callback) && !ts11.isFunctionExpression(callback)) {
+  });
+  let resolvedNode = callback;
+  if (ts11.isIdentifier(callback)) {
+    const resolved = resolveSortComparatorIdentifier(callback.text, ctx2);
+    if (!resolved) {
+      return {
+        result: null,
+        unsupportedReason: `Sort comparator '${outerRaw}' could not be resolved to a local function \u2014 declare it in the same file or inline it.`
+      };
+    }
+    resolvedNode = resolved;
+  }
+  if (!ts11.isArrowFunction(resolvedNode) && !ts11.isFunctionExpression(resolvedNode)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
     };
   }
-  const arrow = tsNodeToParsedExpr(callback);
+  const arrow = tsNodeToParsedExpr(resolvedNode);
   if (arrow.kind !== "arrow" || arrow.params.length !== 2) return unsupported();
   if (sortComparatorFromArrow(arrow) === null) return unsupported();
   return {
@@ -8989,6 +9309,20 @@ function extractSortComparator(callback, _method, ctx2) {
     }
   };
 }
+function resolveSortComparatorIdentifier(name2, ctx2) {
+  const constInfo = findLocalConst(name2, ctx2);
+  const fnInfo = findLocalFunction(name2, ctx2);
+  if (constInfo && fnInfo) return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
 function extractFilterPredicate(callback, ctx2) {
   if (!ts11.isArrowFunction(callback)) return { result: null };
   if (callback.parameters.length < 1) return { result: null };
@@ -9056,7 +9390,7 @@ function extractLoopParamBindings(pattern) {
   const appendDotAccess = (prefix2, key) => {
     return isIdent(key) ? `${prefix2}.${key}` : `${prefix2}[${JSON.stringify(key)}]`;
   };
-  const walk = (p, prefix2) => {
+  const walk = (p, prefix2, segments) => {
     if (unsupported) return;
     if (ts11.isArrayBindingPattern(p)) {
       const elements3 = p.elements;
@@ -9076,15 +9410,17 @@ function extractLoopParamBindings(pattern) {
           bindings.push({
             name: el.name.text,
             path: prefix2,
-            rest: { kind: "array", from: index }
+            rest: { kind: "array", from: index },
+            segments
           });
           return;
         }
         const path25 = `${prefix2}[${index}]`;
+        const nextSegments = [...segments, { kind: "index", index }];
         if (ts11.isIdentifier(el.name)) {
-          bindings.push({ name: el.name.text, path: path25 });
+          bindings.push({ name: el.name.text, path: path25, segments: nextSegments });
         } else {
-          walk(el.name, path25);
+          walk(el.name, path25, nextSegments);
         }
       }
       return;
@@ -9106,7 +9442,8 @@ function extractLoopParamBindings(pattern) {
         bindings.push({
           name: el.name.text,
           path: prefix2,
-          rest: { kind: "object", exclude: collectedKeys }
+          rest: { kind: "object", exclude: collectedKeys },
+          segments
         });
         return;
       }
@@ -9126,17 +9463,19 @@ function extractLoopParamBindings(pattern) {
         unsupported = true;
         return;
       }
-      collectedKeys.push({ key: keyText2, isIdent: isIdent(keyText2) });
+      const keyIsIdent = isIdent(keyText2);
+      collectedKeys.push({ key: keyText2, isIdent: keyIsIdent });
       const path25 = appendDotAccess(prefix2, keyText2);
+      const nextSegments = [...segments, { kind: "field", key: keyText2, isIdent: keyIsIdent }];
       if (ts11.isIdentifier(el.name)) {
-        bindings.push({ name: el.name.text, path: path25 });
+        bindings.push({ name: el.name.text, path: path25, segments: nextSegments });
       } else {
-        walk(el.name, path25);
+        walk(el.name, path25, nextSegments);
       }
     }
   };
   if (ts11.isArrayBindingPattern(pattern) || ts11.isObjectBindingPattern(pattern)) {
-    walk(pattern, "");
+    walk(pattern, "", []);
     if (unsupported) return { unsupported: true };
     return bindings;
   }
@@ -9585,11 +9924,11 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
           if (stmt === returnStmt) break;
           const js = ctx2.getJS(stmt);
           const tjs = ctx2.getTemplateJS(stmt);
-          const ts25 = stmt.getText(ctx2.sourceFile);
+          const ts26 = stmt.getText(ctx2.sourceFile);
           preambleStmts.push(js.endsWith(";") ? js : js + ";");
           templatePreambleStmts.push(tjs.endsWith(";") ? tjs : tjs + ";");
-          typedPreambleStmts.push(ts25.endsWith(";") ? ts25 : ts25 + ";");
-          if (js !== ts25) hasTypeDiff = true;
+          typedPreambleStmts.push(ts26.endsWith(";") ? ts26 : ts26 + ";");
+          if (js !== ts26) hasTypeDiff = true;
           if (js !== tjs) hasTemplateDiff = true;
         }
         if (preambleStmts.length > 0) {
@@ -9924,6 +10263,7 @@ function getAttributeValue(attr, ctx2) {
         expr = branchInit;
       }
     }
+    expr = tryDesugarInterleaveTaggedTemplate(expr, ctx2);
     if (ts11.isAwaitExpression(expr)) {
       ctx2.analyzer.errors.push(
         createError(
@@ -10053,6 +10393,13 @@ function findLocalConst(name2, ctx2) {
   const pool = fnScoped.length > 0 ? fnScoped : matches;
   return pool[pool.length - 1];
 }
+function findLocalFunction(name2, ctx2) {
+  const matches = ctx2.analyzer.localFunctions.filter((f) => f.name === name2);
+  if (matches.length === 0) return void 0;
+  const fnScoped = matches.filter((f) => !f.isModule);
+  const pool = fnScoped.length > 0 ? fnScoped : matches;
+  return pool[pool.length - 1];
+}
 function isDynamicTagLocal(name2, ctx2) {
   if (!hasDynamicTagBinding(name2, ctx2.sourceFile)) return false;
   const a = ctx2.analyzer;
@@ -10138,6 +10485,130 @@ function parseConstInitializerImpl(c) {
 function astText(node) {
   return node.getText(node.getSourceFile());
 }
+function parseFunctionInfoAsExpr(fn) {
+  const cached = functionInfoExprCache.get(fn);
+  if (cached !== void 0) return cached;
+  const result2 = parseFunctionInfoAsExprImpl(fn);
+  functionInfoExprCache.set(fn, result2);
+  return result2;
+}
+function parseFunctionInfoAsExprImpl(fn) {
+  if (!fn.body) return null;
+  const params = fn.typedParams !== void 0 ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
+  const body2 = fn.typedBody ?? fn.body;
+  const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body2}`;
+  const sf = ts11.createSourceFile(
+    "__bf_resolve_fn.ts",
+    wrapped,
+    ts11.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    ts11.ScriptKind.TS
+  );
+  const stmt = sf.statements[0];
+  if (!stmt || !ts11.isVariableStatement(stmt)) return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer) return null;
+  return decl.initializer;
+}
+function tryDesugarInterleaveTaggedTemplate(expr, ctx2) {
+  if (!ts11.isTaggedTemplateExpression(expr)) return expr;
+  if (!ts11.isIdentifier(expr.tag)) return expr;
+  const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx2);
+  if (!resolvedTag) return expr;
+  if (!isInterleaveTagFunction(resolvedTag)) return expr;
+  const rewritten = buildUntaggedTemplateLiteral(expr, ctx2);
+  return rewritten ?? expr;
+}
+function resolveInterleaveTagIdentifier(name2, ctx2) {
+  const constInfo = findLocalConst(name2, ctx2);
+  const fnInfo = findLocalFunction(name2, ctx2);
+  if (constInfo && fnInfo) return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
+function isInterleaveTagFunction(fn) {
+  if (!ts11.isArrowFunction(fn) && !ts11.isFunctionExpression(fn)) return false;
+  if (fn.parameters.length !== 2) return false;
+  const [partsParam, argsParam] = fn.parameters;
+  if (!ts11.isIdentifier(partsParam.name) || partsParam.dotDotDotToken) return false;
+  if (!ts11.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken) return false;
+  const parsed = tsNodeToParsedExpr(fn);
+  if (parsed.kind !== "arrow") return false;
+  return isInterleaveReduceCall(parsed.body, partsParam.name.text, argsParam.name.text);
+}
+function isInterleaveReduceCall(body2, partsName, argsName) {
+  if (body2.kind !== "call" || body2.args.length !== 2) return false;
+  const { callee, args: args2 } = body2;
+  if (callee.kind !== "member" || callee.computed || callee.property !== "reduce") return false;
+  if (callee.object.kind !== "identifier" || callee.object.name !== partsName) return false;
+  const [callback, init] = args2;
+  if (init.kind !== "literal" || init.literalType !== "string" || init.value !== "") return false;
+  if (callback.kind !== "arrow" || callback.params.length !== 3) return false;
+  const [acc, p, i] = callback.params;
+  return isInterleaveReduceCallbackBody(callback.body, acc, p, i, argsName);
+}
+function isInterleaveReduceCallbackBody(body2, acc, p, i, argsName) {
+  if (body2.kind !== "binary" || body2.op !== "+") return false;
+  const { left, right } = body2;
+  if (left.kind !== "binary" || left.op !== "+") return false;
+  if (left.left.kind !== "identifier" || left.left.name !== acc) return false;
+  if (left.right.kind !== "identifier" || left.right.name !== p) return false;
+  return isInterleaveSpanExpr(right, i, argsName);
+}
+function isInterleaveSpanExpr(expr, i, argsName) {
+  let inner = expr;
+  if (inner.kind === "call" && inner.args.length === 1 && inner.callee.kind === "identifier" && inner.callee.name === "String") {
+    inner = inner.args[0];
+  }
+  if (inner.kind !== "logical" || inner.op !== "??") return false;
+  if (inner.right.kind !== "literal" || inner.right.literalType !== "string" || inner.right.value !== "") {
+    return false;
+  }
+  const idx = inner.left;
+  if (idx.kind !== "index-access") return false;
+  if (idx.object.kind !== "identifier" || idx.object.name !== argsName) return false;
+  if (idx.index.kind !== "identifier" || idx.index.name !== i) return false;
+  return true;
+}
+function buildUntaggedTemplateLiteral(node, ctx2) {
+  const template = node.template;
+  let text;
+  if (ts11.isNoSubstitutionTemplateLiteral(template)) {
+    text = "`" + (template.rawText ?? template.text) + "`";
+  } else {
+    let body2 = template.head.rawText ?? template.head.text;
+    for (const span of template.templateSpans) {
+      const spanText = ctx2.getJS(span.expression);
+      body2 += "${(" + spanText + ") ?? ''}";
+      body2 += span.literal.rawText ?? span.literal.text;
+    }
+    text = "`" + body2 + "`";
+  }
+  const wrapped = `const __bf_resolve_tagged__ = (${text})`;
+  const sf = ts11.createSourceFile(
+    "__bf_resolve_tagged.tsx",
+    wrapped,
+    ts11.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    ts11.ScriptKind.TSX
+  );
+  const stmt = sf.statements[0];
+  if (!stmt || !ts11.isVariableStatement(stmt)) return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer) return null;
+  const result2 = ts11.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!ts11.isTemplateExpression(result2) && !ts11.isNoSubstitutionTemplateLiteral(result2)) return null;
+  return result2;
+}
 function parseTernary(expr, ctx2) {
   const whenTrueValue = getStringValue(expr.whenTrue);
   const whenFalseValue = getStringValue(expr.whenFalse);
@@ -10550,13 +11021,14 @@ function buildIfStatementChain(analyzer, ctx2) {
   }
   return alternate;
 }
-var CLIENT_DIRECTIVE_INTERIOR_RE2, BLOCK_COMMENT_RE2, constInitializerCache;
+var CLIENT_DIRECTIVE_INTERIOR_RE2, BLOCK_COMMENT_RE2, constInitializerCache, functionInfoExprCache;
 var init_jsx_to_ir = __esm({
   "../jsx/src/jsx-to-ir.ts"() {
     "use strict";
     init_types();
     init_analyzer_context();
     init_expression_parser();
+    init_module_exports();
     init_errors();
     init_builtins();
     init_reactivity_checker();
@@ -10568,6 +11040,7 @@ var init_jsx_to_ir = __esm({
     CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
     BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
     constInitializerCache = /* @__PURE__ */ new WeakMap();
+    functionInfoExprCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -11242,6 +11715,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
       const { useElementReconciliation, innerLoops } = decideLoopRendering(l, siblingOffsets, ctx2);
       let template = "";
       let staticItemTemplate;
+      let skeletonTemplate;
       if (l.childComponent) {
         template = "";
         if (l.isStaticArray && l.children[0]) {
@@ -11260,6 +11734,11 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
         template = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], buildRestSpreadNames(ctx2), 0, loopParamSpec) : irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx2), 0, loopParamSpec);
         if (l.isStaticArray) {
           staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], buildRestSpreadNames(ctx2), 0) : irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx2), 0);
+        } else if (!useElementReconciliation && !l.bodyIsMultiRoot && !l.bodyIsItemConditional) {
+          skeletonTemplate = buildLoopSkeletonTemplate(l.children[0], {
+            reactiveAttrKeys: new Set(bindings.reactiveAttrs.map((a) => `${a.childSlotId}::${a.attrName}`)),
+            reactiveTextSlotIds: new Set(bindings.reactiveTexts.map((t) => t.slotId))
+          }) ?? void 0;
         }
       }
       ctx2.loopElements.push({
@@ -11277,6 +11756,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
         iterationShape: l.iterationShape,
         template,
         staticItemTemplate,
+        skeletonTemplate,
         childEventHandlers: childHandlers,
         bindings,
         childComponent: l.childComponent,
@@ -12180,6 +12660,45 @@ var init_imports = __esm({
   }
 });
 
+// ../jsx/src/lowering-registry.ts
+function registerLoweringPlugin(plugin) {
+  const existing = plugins.findIndex((p) => p.name === plugin.name);
+  if (existing >= 0) plugins[existing] = plugin;
+  else plugins.push(plugin);
+}
+function getLoweringPlugins() {
+  return [...plugins];
+}
+function prepareLoweringMatchers(metadata) {
+  const matchers = [];
+  for (const plugin of plugins) {
+    const matcher = plugin.prepare(metadata);
+    if (matcher) matchers.push(matcher);
+  }
+  return matchers;
+}
+function matchLoweringCall(callee, args2, metadata) {
+  for (const matcher of prepareLoweringMatchers(metadata)) {
+    const node = matcher(callee, args2);
+    if (node) return node;
+  }
+  return null;
+}
+function isValidHelperId(helper) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(helper);
+}
+function __resetLoweringPluginsForTest(next = []) {
+  plugins.length = 0;
+  plugins.push(...next);
+}
+var plugins;
+var init_lowering_registry = __esm({
+  "../jsx/src/lowering-registry.ts"() {
+    "use strict";
+    plugins = [];
+  }
+});
+
 // ../jsx/src/relocate.ts
 import ts13 from "typescript";
 function classify(name2, env) {
@@ -12213,6 +12732,14 @@ function decideAction(kind2, toScope, env, name2) {
     return { action: "lift-to-prop", rewrittenAs: `${PROPS_PARAM}.${name2}` };
   }
   if ((kind2 === "init-local" || kind2 === "sub-init-local") && toScope === "template") {
+    const aliasTarget = env.aliasTargets?.get(name2);
+    if (aliasTarget !== void 0) {
+      const targetLeftmost = aliasTarget.includes(".") ? aliasTarget.split(".")[0] : aliasTarget;
+      const targetKind = classify(targetLeftmost, env);
+      if (isVisibleIn(toScope, targetKind)) {
+        return { action: "inline", rewrittenAs: aliasTarget };
+      }
+    }
     const inlineForm = env.inlinable.get(name2);
     if (inlineForm !== void 0) {
       return { action: "inline", rewrittenAs: inlineForm };
@@ -12290,6 +12817,7 @@ function isInlinableInTemplate(value2, env) {
   return { ok: true, rewrittenValue: r2.text, decisions: r2.decisions };
 }
 function getCalleeIdentifierPath(callee) {
+  if (ts13.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression);
   if (ts13.isIdentifier(callee)) return callee.text;
   if (ts13.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression);
@@ -12299,6 +12827,7 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
+  if (ts13.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression);
   if (ts13.isIdentifier(callee)) return callee.text;
   if (ts13.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression);
@@ -12306,17 +12835,35 @@ function getCalleeLeftmostIdentifier(callee) {
   return null;
 }
 function isCallAcceptedByAdapter(call, env) {
-  const name2 = getCalleeIdentifierPath(call.expression);
-  if (name2 === null) return false;
+  const originalPath = getCalleeIdentifierPath(call.expression);
+  if (originalPath === null) return false;
   const leftmost = getCalleeLeftmostIdentifier(call.expression);
+  let resolvedPath = originalPath;
+  let resolvedLeftmost = leftmost;
   if (leftmost !== null) {
-    const kind2 = env.bindings.get(leftmost);
+    const aliasTarget = env.aliasTargets?.get(leftmost);
+    if (aliasTarget !== void 0) {
+      resolvedPath = originalPath === leftmost ? aliasTarget : `${aliasTarget}${originalPath.slice(leftmost.length)}`;
+      resolvedLeftmost = aliasTarget.includes(".") ? aliasTarget.split(".")[0] : aliasTarget;
+    }
+  }
+  if (resolvedLeftmost !== null) {
+    const kind2 = env.bindings.get(resolvedLeftmost);
     if (kind2 !== void 0 && !REGISTRY_SAFE_BINDING_KINDS.has(kind2)) {
       return false;
     }
   }
-  if (env.templatePrimitives && env.templatePrimitives[name2]) return true;
-  if (env.acceptsTemplateCall && env.acceptsTemplateCall(name2)) return true;
+  if (env.templatePrimitives && env.templatePrimitives[resolvedPath]) return true;
+  if (env.acceptsTemplateCall && env.acceptsTemplateCall(resolvedPath)) return true;
+  if (env.loweringMatchers && env.loweringMatchers.length > 0) {
+    const parsed = tsNodeToParsedExpr(call);
+    if (parsed.kind === "call") {
+      const calleeForMatch = resolvedPath !== originalPath && !resolvedPath.includes(".") && parsed.callee.kind === "identifier" ? { kind: "identifier", name: resolvedPath } : parsed.callee;
+      for (const matcher of env.loweringMatchers) {
+        if (matcher(calleeForMatch, parsed.args)) return true;
+      }
+    }
+  }
   return false;
 }
 function parseExpressionNode(text) {
@@ -12422,6 +12969,7 @@ function buildRelocateEnvFromIR(metadata, options2) {
   const env = buildRelocateEnvFromFields(metadata);
   if (options2?.templatePrimitives) env.templatePrimitives = options2.templatePrimitives;
   if (options2?.acceptsTemplateCall) env.acceptsTemplateCall = options2.acceptsTemplateCall;
+  env.loweringMatchers = prepareLoweringMatchers(metadata);
   return env;
 }
 function buildRelocateEnvFromFields(src) {
@@ -12464,21 +13012,40 @@ function buildRelocateEnvFromFields(src) {
   for (const [name2, kind2] of bindings) {
     if (kind2 === "prop") propsForLift.add(name2);
   }
+  const aliasTargets = /* @__PURE__ */ new Map();
+  for (const c of src.localConstants) {
+    const kind2 = bindings.get(c.name);
+    if (kind2 !== "init-local" && kind2 !== "module-local") continue;
+    const target2 = identifierPathFromParsed(c.parsed);
+    if (target2 !== null) aliasTargets.set(c.name, target2);
+  }
   return {
     bindings,
     inlinable: /* @__PURE__ */ new Map(),
     // populated by compute-inlinability after analyzer runs
     propsForLift,
     propsObjectName,
-    allowFallback: true
+    allowFallback: true,
+    aliasTargets
   };
 }
+function identifierPathFromParsed(expr) {
+  if (!expr) return null;
+  if (expr.kind === "identifier") return expr.name;
+  if (expr.kind === "member" && !expr.computed) {
+    const object = identifierPathFromParsed(expr.object);
+    return object === null ? null : `${object}.${expr.property}`;
+  }
+  return null;
+}
 var REGISTRY_SAFE_BINDING_KINDS, RESERVED_WORDS;
 var init_relocate = __esm({
   "../jsx/src/relocate.ts"() {
     "use strict";
     init_types();
     init_utils();
+    init_expression_parser();
+    init_lowering_registry();
     REGISTRY_SAFE_BINDING_KINDS = /* @__PURE__ */ new Set([
       "global",
       "module-import",
@@ -12543,7 +13110,12 @@ function buildEnvFromCtx(ctx2) {
       effects: ctx2.effects,
       onMounts: ctx2.onMounts,
       initStatements: ctx2.initStatements,
-      imports: [],
+      // Real component imports (#2069) — `buildRelocateEnvFromIR` calls
+      // `prepareLoweringMatchers(metadata)` on this reconstructed object,
+      // and plugin `prepare()` resolves local import names from
+      // `metadata.imports`. `[]` here would silently disable every
+      // import-aware LoweringPlugin for the client-JS inline-safety gate.
+      imports: ctx2.imports,
       templateImports: [],
       namedExports: [],
       localFunctions: ctx2.localFunctions,
@@ -15431,6 +16003,15 @@ function emitTemplateCloneInline(template) {
   }
   return `const __tpl = document.createElement('template'); __tpl.innerHTML = \`${template}\`; return __tpl.content.firstElementChild.cloneNode(true)`;
 }
+function emitHoistedTemplateDecl(lines, indent, tplVar, skeletonTemplate) {
+  const isSvg = templateRootIsSvg(skeletonTemplate);
+  const html = isSvg ? `<svg>${skeletonTemplate}</svg>` : skeletonTemplate;
+  lines.push(`${indent}const ${tplVar} = document.createElement('template')`);
+  lines.push(`${indent}${tplVar}.innerHTML = \`${html}\``);
+}
+function hoistedCloneExpr(tplVar, skeletonTemplate) {
+  return templateRootIsSvg(skeletonTemplate) ? `${tplVar}.content.firstElementChild.firstElementChild.cloneNode(true)` : `${tplVar}.content.firstElementChild.cloneNode(true)`;
+}
 function emitTemplateCloneLines(template, indent) {
   if (templateRootIsSvg(template)) {
     return [
@@ -15805,6 +16386,7 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     indexParam,
     mapPreambleWrapped,
     template,
+    skeletonTemplate,
     reactiveEffects,
     childRefs,
     bodyIsMultiRoot,
@@ -15815,11 +16397,16 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     stringifyAnchoredLoop(lines, plan, topIndent, anchorKeyExpr);
     return;
   }
+  const hoistedTpl = !bodyIsMultiRoot && skeletonTemplate ? skeletonTemplate : null;
+  const tplVar = `__tpl_${markerId.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+  if (hoistedTpl) {
+    emitHoistedTemplateDecl(lines, topIndent, tplVar, hoistedTpl);
+  }
   const loopBfId = plan.profileLoopId ? `, ${JSON.stringify(plan.profileLoopId)}` : "";
   if (reactiveEffects === null && !bodyIsMultiRoot && childRefs.length === 0) {
     const unwrapInline = paramUnwrap ? `${paramUnwrap} ` : "";
     const preamble = mapPreambleWrapped ? `${mapPreambleWrapped}; ` : "";
-    const cloneExpr = emitTemplateCloneInline(template);
+    const cloneExpr = hoistedTpl ? `return ${hoistedCloneExpr(tplVar, hoistedTpl)}` : emitTemplateCloneInline(template);
     lines.push(
       `${topIndent}mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}${preamble}if (__existing) return __existing; ${cloneExpr} }, '${markerId}'${loopBfId})`
     );
@@ -15829,12 +16416,16 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
   const bodyIndent = topIndent + "  ";
   if (paramUnwrap) lines.push(`${bodyIndent}${paramUnwrap}`);
   if (mapPreambleWrapped) lines.push(`${bodyIndent}${mapPreambleWrapped}`);
-  emitLoopItemElementSetup(lines, {
-    template,
-    bodyIsMultiRoot,
-    indent: bodyIndent,
-    singleRootLayout: "inline"
-  });
+  if (hoistedTpl) {
+    lines.push(`${bodyIndent}const __el = __existing ?? ${hoistedCloneExpr(tplVar, hoistedTpl)}`);
+  } else {
+    emitLoopItemElementSetup(lines, {
+      template,
+      bodyIsMultiRoot,
+      indent: bodyIndent,
+      singleRootLayout: "inline"
+    });
+  }
   if (reactiveEffects !== null) {
     stringifyReactiveEffects(lines, reactiveEffects, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot });
   }
@@ -16582,6 +17173,7 @@ function buildPlainLoopPlan(elem, profileComponentName) {
     indexParam: elem.index || "__idx",
     mapPreambleWrapped: elem.mapPreamble ? wrap(elem.mapPreamble) : "",
     template: elem.template,
+    skeletonTemplate: elem.skeletonTemplate,
     reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem, profileComponentName) : null,
     childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
@@ -17292,6 +17884,7 @@ function createContext2(ir, scope, adapterCapabilities, profile) {
     initStatements: ir.metadata.initStatements ?? [],
     localFunctions: ir.metadata.localFunctions,
     localConstants: ir.metadata.localConstants,
+    imports: ir.metadata.imports,
     propsParams: ir.metadata.propsParams,
     propsObjectName: ir.metadata.propsObjectName,
     restPropsName: ir.metadata.restPropsName,
@@ -17391,115 +17984,6 @@ var init_ir_to_client_js = __esm({
   }
 });
 
-// ../jsx/src/module-exports.ts
-function generateModuleExports(ir, extraInlineExported = /* @__PURE__ */ new Set(), rewriteRelativeImport) {
-  const lines = [];
-  for (const constant of ir.metadata.localConstants) {
-    if (!constant.isExported) continue;
-    const keyword = constant.declarationKind ?? "const";
-    if (!constant.value) {
-      lines.push(`export ${keyword} ${constant.name}`);
-      continue;
-    }
-    const value2 = constant.value.trim();
-    if (/^createContext\b/.test(value2) || /^new WeakMap\b/.test(value2)) continue;
-    lines.push(`export ${keyword} ${constant.name} = ${constant.value}`);
-  }
-  for (const func of ir.metadata.localFunctions) {
-    if (!func.isExported) continue;
-    const params = func.typedParams !== void 0 ? func.typedParams : func.params.map(formatParamWithType).join(", ");
-    const returnAnnotation = func.typedReturnType ? `: ${func.typedReturnType}` : "";
-    const body2 = func.typedBody ?? func.body;
-    const asyncKw = func.isAsync ? "async " : "";
-    lines.push(`export ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body2}`);
-  }
-  const inlineExported = collectInlineExportedNames(ir);
-  for (const name2 of extraInlineExported) inlineExported.add(name2);
-  for (const block of ir.metadata.namedExports) {
-    const isReexportFrom = block.source !== null;
-    const survivingSpecs = block.specifiers.filter((spec) => {
-      if (isReexportFrom) return true;
-      return !(inlineExported.has(spec.name) && spec.alias == null);
-    });
-    if (survivingSpecs.length === 0) continue;
-    const specText = survivingSpecs.map((s) => {
-      const prefix2 = s.isTypeOnly ? "type " : "";
-      return s.alias ? `${prefix2}${s.name} as ${s.alias}` : `${prefix2}${s.name}`;
-    }).join(", ");
-    const typeKw = block.isTypeOnly ? "type " : "";
-    if (isReexportFrom) {
-      const source = rewriteRelativeImport && block.source.startsWith(".") ? rewriteRelativeImport(block.source) : block.source;
-      lines.push(`export ${typeKw}{ ${specText} } from '${source}'`);
-    } else {
-      lines.push(`export ${typeKw}{ ${specText} }`);
-    }
-  }
-  return lines.length > 0 ? lines.join("\n") : null;
-}
-function collectInlineExportedNames(ir) {
-  const names = /* @__PURE__ */ new Set();
-  for (const c of ir.metadata.localConstants) {
-    if (c.isExported) names.add(c.name);
-  }
-  for (const f of ir.metadata.localFunctions) {
-    if (f.isExported) names.add(f.name);
-  }
-  if (ir.metadata.isExported && ir.metadata.componentName) {
-    names.add(ir.metadata.componentName);
-  }
-  return names;
-}
-function formatParamWithType(p) {
-  const rest2 = p.isRest ? "..." : "";
-  const optional = p.optional ? "?" : "";
-  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
-  const defaultPart = p.defaultValue !== void 0 ? ` = ${p.defaultValue}` : "";
-  return `${rest2}${p.name}${optional}${typeAnnotation}${defaultPart}`;
-}
-function findReachableNames(primaryRefs, declarations) {
-  const allNames = new Set(declarations.map((d) => d.name));
-  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
-  const reachable = /* @__PURE__ */ new Set();
-  const queue = [];
-  for (const name2 of allNames) {
-    if (new RegExp(`\\b${name2}\\b`).test(primaryRefs)) {
-      reachable.add(name2);
-      queue.push(name2);
-    }
-  }
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const body2 = bodyMap.get(current) || "";
-    for (const name2 of allNames) {
-      if (!reachable.has(name2) && new RegExp(`\\b${name2}\\b`).test(body2)) {
-        reachable.add(name2);
-        queue.push(name2);
-      }
-    }
-  }
-  return reachable;
-}
-function extractFunctionParams(value2) {
-  const arrowMatch = value2.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
-  if (arrowMatch) {
-    return arrowMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
-  }
-  const singleMatch = value2.match(/^(?:async\s*)?(\w+)\s*=>/);
-  if (singleMatch) {
-    return singleMatch[1];
-  }
-  const funcMatch = value2.match(/^(?:async\s*)?function\s*\w*\s*\(([^)]*)\)/);
-  if (funcMatch) {
-    return funcMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter(Boolean).join(", ");
-  }
-  return "";
-}
-var init_module_exports = __esm({
-  "../jsx/src/module-exports.ts"() {
-    "use strict";
-  }
-});
-
 // ../jsx/src/css-layer-prefixer.ts
 function prefixClass(cls, layerName) {
   if (!cls || cls.startsWith("layer-")) return cls;
@@ -17962,15 +18446,13 @@ function extractSsrDefaults(metadata) {
   const propsLike = /* @__PURE__ */ new Set();
   if (metadata.propsObjectName) propsLike.add(metadata.propsObjectName);
   for (const p of metadata.propsParams) propsLike.add(p.name);
-  if (metadata.propsObjectName === null) {
-    for (const p of metadata.propsParams) {
-      if (p.isRest) continue;
-      if (p.defaultValue !== void 0) {
-        const value2 = tryStaticEval(p.defaultValue, { bindings: {}, propsLike });
-        out[p.name] = { propName: p.name, value: resultToJsonable(value2) };
-      } else {
-        out[p.name] = { propName: p.name, value: null };
-      }
+  for (const p of metadata.propsParams) {
+    if (p.isRest) continue;
+    if (metadata.propsObjectName === null && p.defaultValue !== void 0) {
+      const value2 = tryStaticEval(p.defaultValue, { bindings: {}, propsLike });
+      out[p.name] = { propName: p.name, value: resultToJsonable(value2) };
+    } else {
+      out[p.name] = { propName: p.name, value: null };
     }
   }
   if (metadata.restPropsName) {
@@ -18252,9 +18734,11 @@ import ts17 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = /* @__PURE__ */ new Map();
+  const contextDefaultKinds = /* @__PURE__ */ new Map();
   for (const c of constants) {
     if (c.systemConstructKind !== "createContext" || c.value === void 0) continue;
     contextDefaults.set(c.name, parseCreateContextDefault(c.value));
+    if (isObjectLiteralCreateContextDefault(c.value)) contextDefaultKinds.set(c.name, "object");
   }
   if (contextDefaults.size === 0) return [];
   const consumers = [];
@@ -18265,7 +18749,8 @@ function collectContextConsumers(metadata) {
     consumers.push({
       localName: c.name,
       contextName: ctxName,
-      defaultValue: contextDefaults.get(ctxName) ?? null
+      defaultValue: contextDefaults.get(ctxName) ?? null,
+      defaultKind: contextDefaultKinds.get(ctxName)
     });
   }
   return consumers;
@@ -18289,6 +18774,12 @@ function parseCreateContextDefault(source) {
   if (arg.kind === ts17.SyntaxKind.FalseKeyword) return false;
   return null;
 }
+function isObjectLiteralCreateContextDefault(source) {
+  const expr = parseSingleExpression(source);
+  if (!expr || !ts17.isCallExpression(expr)) return false;
+  if (expr.arguments.length === 0) return false;
+  return ts17.isObjectLiteralExpression(expr.arguments[0]);
+}
 function parseSingleExpression(source) {
   const sf = ts17.createSourceFile("__ctx.ts", `(${source})`, ts17.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
@@ -18305,21 +18796,77 @@ function augmentInheritedPropAccesses(ir) {
   const booleanAttrProps = /* @__PURE__ */ new Set();
   const accessed = /* @__PURE__ */ new Set();
   const accessRe = new RegExp(`(?:^|[^\\w$.])${propsObj}\\.([A-Za-z_$][\\w$]*)`, "g");
-  const scan = (s) => {
+  const scan = (s, also) => {
     if (!s) return;
-    for (const m of s.matchAll(accessRe)) accessed.add(m[1]);
+    for (const m of s.matchAll(accessRe)) {
+      accessed.add(m[1]);
+      also?.add(m[1]);
+    }
+  };
+  const coalesceLiteralTypes = /* @__PURE__ */ new Map();
+  const pinCoalesceLiterals = (s) => {
+    if (!s || !s.includes(propsObj)) return;
+    const sf = ts17.createSourceFile("__aug.ts", `(${s})`, ts17.ScriptTarget.Latest, false);
+    const visit3 = (n) => {
+      if (ts17.isBinaryExpression(n) && (n.operatorToken.kind === ts17.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts17.SyntaxKind.BarBarToken)) {
+        let left = n.left;
+        while (ts17.isParenthesizedExpression(left)) left = left.expression;
+        if (ts17.isPropertyAccessExpression(left) && ts17.isIdentifier(left.expression) && left.expression.text === propsObj) {
+          const name2 = left.name.text;
+          let right = n.right;
+          while (ts17.isParenthesizedExpression(right)) right = right.expression;
+          if (ts17.isPrefixUnaryExpression(right)) right = right.operand;
+          const kind2 = ts17.isNumericLiteral(right) ? "number" : right.kind === ts17.SyntaxKind.TrueKeyword || right.kind === ts17.SyntaxKind.FalseKeyword ? "boolean" : ts17.isStringLiteralLike(right) ? "string" : null;
+          if (kind2 && !coalesceLiteralTypes.has(name2)) coalesceLiteralTypes.set(name2, kind2);
+        }
+      }
+      ts17.forEachChild(n, visit3);
+    };
+    visit3(sf);
   };
-  for (const memo of ir.metadata.memos) scan(memo.computation);
-  for (const signal2 of ir.metadata.signals) scan(signal2.initialValue);
+  for (const memo of ir.metadata.memos) {
+    scan(memo.computation);
+    pinCoalesceLiterals(memo.computation);
+  }
+  for (const signal2 of ir.metadata.signals) {
+    scan(signal2.initialValue);
+    pinCoalesceLiterals(signal2.initialValue);
+  }
   for (const stmt of ir.metadata.initStatements ?? []) scan(stmt.body);
   for (const eff of ir.metadata.effects ?? []) scan(eff.body);
   for (const c of ir.metadata.localConstants ?? []) {
     if (c.isModule) continue;
     scan(c.value);
+    pinCoalesceLiterals(c.value);
   }
   const walk = (node) => {
     if (!node) return;
+    const carrier = node;
+    if (carrier.type === "expression") {
+      scan(carrier.expr);
+      pinCoalesceLiterals(carrier.expr);
+    }
+    scan(carrier.condition, bareRefProps);
+    pinCoalesceLiterals(carrier.condition);
+    scan(carrier.array, bareRefProps);
     const el = node;
+    for (const prop of node.props ?? []) {
+      const v = prop.value;
+      if (v?.parts) {
+        for (const part of v.parts) {
+          if (part.type === "string") scan(part.value);
+          else if (part.type === "ternary") {
+            scan(part.condition);
+            scan(part.whenTrue);
+            scan(part.whenFalse);
+          } else if (part.type === "lookup") scan(part.key);
+        }
+      }
+      if (v?.kind === "expression" && typeof v.expr === "string") {
+        scan(v.expr, bareRefProps);
+        pinCoalesceLiterals(v.expr);
+      }
+    }
     for (const attr of el.attrs ?? []) {
       const v = attr.value;
       if (v?.parts) {
@@ -18360,9 +18907,10 @@ function augmentInheritedPropAccesses(ir) {
     if (existing.has(name2)) continue;
     let raw;
     if (booleanAttrProps.has(name2)) raw = "boolean";
+    else if (coalesceLiteralTypes.has(name2)) raw = coalesceLiteralTypes.get(name2);
     else if (bareRefProps.has(name2)) raw = "unknown";
     else raw = "string";
-    const type2 = raw === "boolean" ? { kind: "primitive", raw: "boolean", primitive: "boolean" } : raw === "string" ? { kind: "primitive", raw: "string", primitive: "string" } : { kind: "unknown", raw: "unknown" };
+    const type2 = raw === "unknown" ? { kind: "unknown", raw: "unknown" } : { kind: "primitive", raw, primitive: raw };
     ir.metadata.propsParams.push({ name: name2, type: type2, optional: true });
     existing.add(name2);
   }
@@ -18751,7 +19299,8 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
       files2.push({
         path: dir + output.componentName + adapter.extension,
         content: output.rawTemplate,
-        type: "markedTemplate"
+        type: "markedTemplate",
+        componentName: output.componentName
       });
       const ir = entries2.find((e) => e.componentIR.metadata.componentName === output.componentName);
       const ssrDefaults = ir ? extractSsrDefaults(ir.componentIR.metadata) : void 0;
@@ -18759,7 +19308,8 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
         files2.push({
           path: dir + output.componentName + ".ssr-defaults.json",
           content: JSON.stringify(ssrDefaults),
-          type: "ssrDefaults"
+          type: "ssrDefaults",
+          componentName: output.componentName
         });
       }
     }
@@ -19038,7 +19588,8 @@ function compileJSX(source, filePath, options2) {
   files2.push({
     path: filePath.replace(/\.tsx?$/, adapter.extension),
     content: content2,
-    type: "markedTemplate"
+    type: "markedTemplate",
+    componentName: componentIR.metadata.componentName
   });
   {
     const ssrDefaults = extractSsrDefaults(componentIR.metadata);
@@ -19046,7 +19597,8 @@ function compileJSX(source, filePath, options2) {
       files2.push({
         path: filePath.replace(/\.tsx?$/, ".ssr-defaults.json"),
         content: JSON.stringify(ssrDefaults),
-        type: "ssrDefaults"
+        type: "ssrDefaults",
+        componentName: componentIR.metadata.componentName
       });
     }
   }
@@ -19690,7 +20242,11 @@ function emitParsedExpr(expr, emitter) {
       return emitter.objectLiteral(expr.properties, expr.raw, emit);
     case "array-method":
       if (expr.method === "flat") {
-        return emitter.flatMethod(expr.object, expr.flatDepth, emit);
+        return emitter.flatMethod(
+          expr.object,
+          expr.depthExpr ? { expr: expr.depthExpr } : expr.flatDepth,
+          emit
+        );
       }
       return emitter.arrayMethod(expr.method, expr.object, expr.args, emit);
     case "unsupported":
@@ -19775,42 +20331,6 @@ var init_query_href_lowering = __esm({
   }
 });
 
-// ../jsx/src/lowering-registry.ts
-function registerLoweringPlugin(plugin) {
-  const existing = plugins.findIndex((p) => p.name === plugin.name);
-  if (existing >= 0) plugins[existing] = plugin;
-  else plugins.push(plugin);
-}
-function getLoweringPlugins() {
-  return [...plugins];
-}
-function prepareLoweringMatchers(metadata) {
-  const matchers = [];
-  for (const plugin of plugins) {
-    const matcher = plugin.prepare(metadata);
-    if (matcher) matchers.push(matcher);
-  }
-  return matchers;
-}
-function matchLoweringCall(callee, args2, metadata) {
-  for (const matcher of prepareLoweringMatchers(metadata)) {
-    const node = matcher(callee, args2);
-    if (node) return node;
-  }
-  return null;
-}
-function __resetLoweringPluginsForTest(next = []) {
-  plugins.length = 0;
-  plugins.push(...next);
-}
-var plugins;
-var init_lowering_registry = __esm({
-  "../jsx/src/lowering-registry.ts"() {
-    "use strict";
-    plugins = [];
-  }
-});
-
 // ../jsx/src/builtin-lowering-plugins.ts
 function registerBuiltinLoweringPlugins() {
   for (const plugin of BUILTIN_LOWERING_PLUGINS) registerLoweringPlugin(plugin);
@@ -20040,7 +20560,7 @@ var init_import_map = __esm({
 });
 
 // ../jsx/src/loop-destructure.ts
-function isLowerableObjectRestDestructure(loop) {
+function isLowerableLoopDestructure(loop) {
   const bindings = loop.paramBindings;
   if (!bindings || bindings.length === 0) return false;
   if (loop.filterPredicate) return false;
@@ -20049,16 +20569,17 @@ function isLowerableObjectRestDestructure(loop) {
   }
   for (const b of bindings) {
     if (b.rest) {
-      if (b.rest.kind !== "object") return false;
-    } else if (!SIMPLE_FIELD.test(b.path)) {
+      if (!b.segments) return false;
+    } else if (!b.segments || b.segments.length === 0) {
       return false;
     }
   }
-  const restNames = bindings.filter((b) => b.rest).map((b) => b.name);
-  if (restNames.length === 0) return true;
-  return !restNamesMisused(loop, restNames);
+  const objectRestNames = bindings.filter((b) => b.rest?.kind === "object").map((b) => b.name);
+  if (objectRestNames.length === 0) return true;
+  return !restNamesMisused(loop, objectRestNames);
 }
 function restNamesMisused(loop, names) {
+  const nameSet = new Set(names);
   const valueUse = names.map(
     (n) => new RegExp(`(?<![\\w.$])${escapeRe(n)}(?!\\s*\\??\\.)(?![\\w$])`)
   );
@@ -20072,7 +20593,10 @@ function restNamesMisused(loop, names) {
       }
     }
   };
-  const attr = (v) => {
+  const attr = (v, isIntrinsicElementAttrs) => {
+    if (v.kind === "spread" && isIntrinsicElementAttrs && nameSet.has(v.expr.trim())) {
+      return;
+    }
     if (v.kind === "expression" || v.kind === "spread") {
       check(v.expr);
       check(v.templateExpr);
@@ -20129,16 +20653,16 @@ function restNamesMisused(loop, names) {
         if (node.alternate) visit3(node.alternate);
         break;
       case "element":
-        node.attrs.forEach((a) => attr(a.value));
+        node.attrs.forEach((a) => attr(a.value, true));
         node.events.forEach((e) => check(e.handler));
         node.children.forEach(visit3);
         break;
       case "component":
-        node.props.forEach((p) => attr(p.value));
+        node.props.forEach((p) => attr(p.value, false));
         node.children.forEach(visit3);
         break;
       case "provider":
-        attr(node.valueProp.value);
+        attr(node.valueProp.value, false);
         node.children.forEach(visit3);
         break;
       case "fragment":
@@ -20162,11 +20686,11 @@ function restNamesMisused(loop, names) {
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var SIMPLE_FIELD;
+var isLowerableObjectRestDestructure;
 var init_loop_destructure = __esm({
   "../jsx/src/loop-destructure.ts"() {
     "use strict";
-    SIMPLE_FIELD = /^\.[A-Za-z_$][\w$]*$/;
+    isLowerableObjectRestDestructure = isLowerableLoopDestructure;
   }
 });
 
@@ -22779,8 +23303,10 @@ __export(src_exports, {
   identifierPath: () => identifierPath,
   importsSearchParams: () => importsSearchParams,
   isBooleanAttr: () => isBooleanAttr,
+  isLowerableLoopDestructure: () => isLowerableLoopDestructure,
   isLowerableObjectRestDestructure: () => isLowerableObjectRestDestructure,
   isSupported: () => isSupported,
+  isValidHelperId: () => isValidHelperId,
   joinProfilerEvents: () => joinProfilerEvents,
   jsxToIR: () => jsxToIR,
   listComponentFunctions: () => listComponentFunctions,
@@ -23721,12 +24247,143 @@ var init_assets_ignore = __esm({
   }
 });
 
-// src/lib/build.ts
+// src/lib/runtime-treeshake.ts
 import ts23 from "typescript";
+import { basename, dirname as dirname3 } from "node:path";
+import { build as esbuildBuild } from "esbuild";
+function isBarefootClientSpecifier(spec) {
+  return spec === "@barefootjs/client" || spec.startsWith("@barefootjs/client/");
+}
+function emptyCollection() {
+  return { names: /* @__PURE__ */ new Set(), unsafe: false, reasons: [] };
+}
+function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
+  const result2 = emptyCollection();
+  if (!code.includes("@barefootjs/client")) return result2;
+  let sourceFile;
+  try {
+    sourceFile = ts23.createSourceFile(
+      sourceLabel,
+      code,
+      ts23.ScriptTarget.Latest,
+      /*setParentNodes*/
+      false,
+      ts23.ScriptKind.JS
+    );
+  } catch (err) {
+    result2.unsafe = true;
+    result2.reasons.push(`failed to parse ${sourceLabel}: ${err.message}`);
+    return result2;
+  }
+  const visit3 = (node) => {
+    if (ts23.isImportDeclaration(node)) {
+      const spec = node.moduleSpecifier;
+      if (ts23.isStringLiteral(spec) && isBarefootClientSpecifier(spec.text)) {
+        const clause = node.importClause;
+        if (!clause) {
+        } else if (clause.isTypeOnly) {
+        } else if (clause.namedBindings && ts23.isNamedImports(clause.namedBindings)) {
+          for (const el of clause.namedBindings.elements) {
+            if (el.isTypeOnly) continue;
+            const imported = (el.propertyName ?? el.name).text;
+            result2.names.add(imported);
+          }
+          if (clause.name) {
+            result2.unsafe = true;
+            result2.reasons.push(`default import of "${spec.text}" in ${sourceLabel}`);
+          }
+        } else if (clause.namedBindings && ts23.isNamespaceImport(clause.namedBindings)) {
+          result2.unsafe = true;
+          result2.reasons.push(`namespace import (* as ${clause.namedBindings.name.text}) of "${spec.text}" in ${sourceLabel}`);
+        } else if (clause.name) {
+          result2.unsafe = true;
+          result2.reasons.push(`default import of "${spec.text}" in ${sourceLabel}`);
+        }
+      }
+    } else if (ts23.isCallExpression(node) && node.expression.kind === ts23.SyntaxKind.ImportKeyword) {
+      const arg = node.arguments[0];
+      if (arg && ts23.isStringLiteral(arg) && isBarefootClientSpecifier(arg.text)) {
+        result2.unsafe = true;
+        result2.reasons.push(`dynamic import("${arg.text}") in ${sourceLabel}`);
+      }
+    }
+    ts23.forEachChild(node, visit3);
+  };
+  visit3(sourceFile);
+  return result2;
+}
+function mergeRuntimeImportCollections(collections) {
+  const merged = emptyCollection();
+  for (const c of collections) {
+    for (const n of c.names) merged.names.add(n);
+    if (c.unsafe) {
+      merged.unsafe = true;
+      merged.reasons.push(...c.reasons);
+    }
+  }
+  return merged;
+}
+async function buildRuntimeBundle(opts) {
+  const { entrySource, keepNames, minify } = opts;
+  const sorted = [...new Set(keepNames)].sort();
+  if (sorted.length === 0) {
+    throw new Error("buildRuntimeBundle: keepNames is empty");
+  }
+  const entryContents = `export { ${sorted.join(", ")} } from ${JSON.stringify(`./${basename(entrySource)}`)}
+`;
+  const result2 = await esbuildBuild({
+    stdin: {
+      contents: entryContents,
+      resolveDir: dirname3(entrySource),
+      sourcefile: "bf-runtime-entry.mjs",
+      loader: "js"
+    },
+    format: "esm",
+    bundle: true,
+    // Unlike `transpile()`'s policy for per-component client JS
+    // (packages/cli/src/lib/runtime.ts — identifiers preserved there so
+    // e.g. `hydrate('ComponentName', ...)` call-site names and combine.ts's
+    // cross-file lookups stay intact), `barefoot.js` is a self-contained
+    // leaf artifact loaded only via the importmap: nothing parses its
+    // source for internal identifier names, and esbuild always keeps
+    // *exported* binding names stable regardless of `minifyIdentifiers`
+    // (verified: a re-export entry's `export { keepMe } from '...'` still
+    // exports as `keepMe` even when the internal implementation is renamed).
+    // So full minification is safe here and meaningfully smaller.
+    minify,
+    treeShaking: true,
+    platform: "browser",
+    write: false
+  });
+  const out = result2.outputFiles?.[0];
+  if (!out) {
+    throw new Error("esbuild produced no output for the runtime bundle");
+  }
+  return out.text;
+}
+var ALWAYS_KEEP_RUNTIME_EXPORTS;
+var init_runtime_treeshake = __esm({
+  "src/lib/runtime-treeshake.ts"() {
+    "use strict";
+    ALWAYS_KEEP_RUNTIME_EXPORTS = [
+      "render",
+      "hydrate",
+      "flushHydration",
+      "rehydrateAll",
+      "rehydrateScope",
+      "disposeScope",
+      "setupStreaming",
+      "createSearchParams"
+    ];
+  }
+});
+
+// src/lib/build.ts
+import ts24 from "typescript";
 import { mkdir, readdir, stat, unlink } from "node:fs/promises";
-import { resolve as resolve6, basename, relative as relative2, dirname as dirname3, isAbsolute as isAbsolute2 } from "node:path";
+import { resolve as resolve6, basename as basename2, relative as relative2, dirname as dirname4, isAbsolute as isAbsolute2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { build as esbuildBuild } from "esbuild";
+import { build as esbuildBuild2 } from "esbuild";
 function detectMissingUseClient(content2) {
   const importRe = /import\s*(?:type\s+)?\{([^}]+)\}\s*from\s*['"]@barefootjs\/client['"]/g;
   const hits = /* @__PURE__ */ new Set();
@@ -23802,11 +24459,13 @@ function resolveBuildConfigFromTs(projectDir, tsConfig, overrides) {
       outfile: e.outfile,
       externals: e.externals
     })),
-    localImportPrefixes: tsConfig.localImportPrefixes
+    localImportPrefixes: tsConfig.localImportPrefixes,
+    runtimeBundle: tsConfig.runtimeBundle,
+    runtimeKeep: tsConfig.runtimeKeep
   };
 }
 async function findCliPackageJson() {
-  const here = dirname3(fileURLToPath2(import.meta.url));
+  const here = dirname4(fileURLToPath2(import.meta.url));
   const candidates = [
     resolve6(here, "../package.json"),
     // bundled dist/index.js
@@ -23825,7 +24484,7 @@ async function findNearestLockfile(projectDir) {
       const candidate = resolve6(dir, name2);
       if (await fileExists(candidate)) return candidate;
     }
-    const parent2 = dirname3(dir);
+    const parent2 = dirname4(dir);
     if (parent2 === dir) return null;
     dir = parent2;
   }
@@ -23856,7 +24515,7 @@ async function computeGlobalHash(config) {
   const lockfile = await findNearestLockfile(config.projectDir);
   if (lockfile) {
     const bytes = await readBytes(lockfile);
-    parts.push(`lockfile:${basename(lockfile)}:${hashBytes(bytes)}`);
+    parts.push(`lockfile:${basename2(lockfile)}:${hashBytes(bytes)}`);
   }
   return hashContent(parts.join("\0"));
 }
@@ -23900,27 +24559,29 @@ async function build(config, options2 = {}) {
     } catch {
     }
   }
-  if (domDistFile) {
-    const runtimeOutPath = resolve6(runtimeOutDir, "barefoot.js");
-    let runtimeContent;
-    if (config.minify) {
-      runtimeContent = transpile(await readText(domDistFile), { loader: "js", minify: true });
+  const runtimeMode = config.runtimeBundle ?? "treeshake";
+  if (runtimeMode === "full") {
+    if (domDistFile) {
+      const runtimeOutPath = resolve6(runtimeOutDir, "barefoot.js");
+      let runtimeContent;
+      if (config.minify) {
+        runtimeContent = transpile(await readText(domDistFile), { loader: "js", minify: true });
+      } else {
+        runtimeContent = await readBytes(domDistFile);
+      }
+      const wrote = await writeIfChanged(runtimeOutPath, runtimeContent);
+      if (wrote) {
+        anyOutputChanged = true;
+        console.log(`Generated: ${runtimeSubdir}/barefoot.js`);
+      }
     } else {
-      runtimeContent = await readBytes(domDistFile);
+      console.warn("Warning: @barefootjs/client dist not found. Skipping barefoot.js copy.");
     }
-    const wrote = await writeIfChanged(runtimeOutPath, runtimeContent);
-    if (wrote) {
-      anyOutputChanged = true;
-      console.log(`Generated: ${runtimeSubdir}/barefoot.js`);
-    }
-  } else {
-    console.warn("Warning: @barefootjs/client dist not found. Skipping barefoot.js copy.");
   }
-  const { changed: externalsChanged, allExternals } = await processExternals(config, runtimeSubdir, runtimeOutDir);
+  const { changed: externalsChanged, allExternals, outfiles: externalOutfiles } = await processExternals(config, runtimeSubdir, runtimeOutDir);
   if (externalsChanged) anyOutputChanged = true;
-  if (await processBundleEntries(config, clientJsOutDir, clientJsSubdir, allExternals, cache2, nextEntries, force)) {
-    anyOutputChanged = true;
-  }
+  const { changed: bundleEntriesChanged } = await processBundleEntries(config, clientJsOutDir, clientJsSubdir, allExternals, cache2, nextEntries, force);
+  if (bundleEntriesChanged) anyOutputChanged = true;
   const allFiles = [];
   for (const dir of config.componentDirs) {
     allFiles.push(...await discoverComponentFiles(dir));
@@ -23977,6 +24638,12 @@ async function build(config, options2 = {}) {
     }
     return sharedProgram;
   };
+  let childShapesRegistered = false;
+  const ensureChildShapesRegistered = () => {
+    if (childShapesRegistered) return;
+    childShapesRegistered = true;
+    registerAdapterChildShapes(config.adapter, allFiles, sourceContents, getSharedProgram());
+  };
   for (const entryPath of allFiles) {
     const sourceContent = sourceContents.get(entryPath);
     if (!hasUseClientDirective2(sourceContent)) {
@@ -24007,6 +24674,7 @@ async function build(config, options2 = {}) {
       cachedCount++;
       continue;
     }
+    ensureChildShapesRegistered();
     const result2 = await compileEntry({
       entryPath,
       sourceContent,
@@ -24129,7 +24797,7 @@ async function build(config, options2 = {}) {
   const sourceDirsByManifestKey = {};
   for (const [sourcePath, entry] of Object.entries(nextEntries)) {
     if (entry.manifestKey && !sourcePath.startsWith(BUNDLE_KEY_PREFIX)) {
-      sourceDirsByManifestKey[entry.manifestKey] = [dirname3(sourcePath)];
+      sourceDirsByManifestKey[entry.manifestKey] = [dirname4(sourcePath)];
     }
   }
   const { errors: resolveErrors, stubDepsByManifestKey } = await resolveRelativeImports({
@@ -24171,12 +24839,90 @@ async function build(config, options2 = {}) {
       if (cacheEntry?.manifestEntry) delete cacheEntry.manifestEntry.stubDeps;
     }
   }
+  let runtimeKeepHash = cache2.runtimeKeepHash;
+  if (runtimeMode === "treeshake") {
+    if (!domDistFile) {
+      console.warn("Warning: @barefootjs/client dist not found. Skipping barefoot.js generation.");
+      runtimeKeepHash = void 0;
+    } else {
+      const scanTargets = [...externalOutfiles];
+      for (const entry of Object.values(nextEntries)) {
+        for (const rel of entry.outputs) {
+          if (rel.endsWith(".js")) scanTargets.push(resolve6(config.outDir, rel));
+        }
+      }
+      const collections = [];
+      for (const filePath of scanTargets) {
+        try {
+          collections.push(collectUsedRuntimeExports(await readText(filePath), relative2(config.outDir, filePath)));
+        } catch {
+        }
+      }
+      const merged = mergeRuntimeImportCollections(collections);
+      const runtimeOutPath = resolve6(runtimeOutDir, "barefoot.js");
+      if (merged.unsafe) {
+        for (const reason2 of merged.reasons) {
+          console.warn(`Warning: runtime tree-shake \u2014 falling back to full runtime copy (${reason2})`);
+        }
+        let runtimeContent;
+        if (config.minify) {
+          runtimeContent = transpile(await readText(domDistFile), { loader: "js", minify: true });
+        } else {
+          runtimeContent = await readBytes(domDistFile);
+        }
+        if (await writeIfChanged(runtimeOutPath, runtimeContent)) {
+          anyOutputChanged = true;
+          console.log(`Generated: ${runtimeSubdir}/barefoot.js (full copy \u2014 see warning above)`);
+        }
+        runtimeKeepHash = void 0;
+      } else {
+        const keepNames = /* @__PURE__ */ new Set([
+          ...ALWAYS_KEEP_RUNTIME_EXPORTS,
+          ...config.runtimeKeep ?? [],
+          ...merged.names
+        ]);
+        const distBytes = await readBytes(domDistFile);
+        const nextKeepHash = hashContent(JSON.stringify({
+          mode: runtimeMode,
+          minify: config.minify,
+          distHash: hashBytes(distBytes),
+          keep: [...keepNames].sort()
+        }));
+        if (nextKeepHash === cache2.runtimeKeepHash && await fileExists(runtimeOutPath)) {
+          runtimeKeepHash = nextKeepHash;
+        } else {
+          try {
+            const bundled = await buildRuntimeBundle({
+              entrySource: domDistFile,
+              keepNames,
+              minify: config.minify
+            });
+            if (await writeIfChanged(runtimeOutPath, bundled)) {
+              anyOutputChanged = true;
+              console.log(`Generated: ${runtimeSubdir}/barefoot.js (tree-shaken: ${keepNames.size} exports kept)`);
+            }
+            runtimeKeepHash = nextKeepHash;
+          } catch (err) {
+            console.warn(
+              `Warning: runtime tree-shake bundling failed (${err.message}); falling back to full runtime copy.`
+            );
+            const runtimeContent = config.minify ? transpile(new TextDecoder().decode(distBytes), { loader: "js", minify: true }) : distBytes;
+            if (await writeIfChanged(runtimeOutPath, runtimeContent)) {
+              anyOutputChanged = true;
+              console.log(`Generated: ${runtimeSubdir}/barefoot.js (full copy \u2014 see warning above)`);
+            }
+            runtimeKeepHash = void 0;
+          }
+        }
+      }
+    }
+  }
   {
     const runtimeAbs = resolve6(config.outDir, runtimeSubdir, "barefoot.js");
     for (const [name2, entry] of Object.entries(manifest)) {
       if (!entry.clientJs || name2 === "__barefoot__") continue;
       const filePath = resolve6(config.outDir, entry.clientJs);
-      let rel = relative2(dirname3(filePath), runtimeAbs);
+      let rel = relative2(dirname4(filePath), runtimeAbs);
       if (!rel.startsWith(".")) rel = "./" + rel;
       try {
         let content2 = await readText(filePath);
@@ -24228,7 +24974,8 @@ async function build(config, options2 = {}) {
   }
   const nextCache = {
     globalHash,
-    entries: nextEntries
+    entries: nextEntries,
+    runtimeKeepHash
   };
   const nextLedger = emptyLedger();
   for (const [key, entry] of Object.entries(nextEntries)) {
@@ -24270,7 +25017,7 @@ async function build(config, options2 = {}) {
   };
 }
 function extractBareImports(code) {
-  const { importedFiles } = ts23.preProcessFile(code, true, true);
+  const { importedFiles } = ts24.preProcessFile(code, true, true);
   const specifiers = /* @__PURE__ */ new Set();
   for (const { fileName } of importedFiles) {
     if (!fileName.startsWith(".") && !fileName.startsWith("/") && !fileName.includes("://")) {
@@ -24296,7 +25043,7 @@ function vendorChunkFilename(pkgName) {
   return `${base}.js`;
 }
 function effectiveNamesFor(entryPath, componentDirs) {
-  const bn = basename(entryPath);
+  const bn = basename2(entryPath);
   if (componentDirs && componentDirs.length > 0) {
     for (const dir of componentDirs) {
       const root2 = resolve6(dir);
@@ -24311,8 +25058,8 @@ function effectiveNamesFor(entryPath, componentDirs) {
   return { baseFileName: bn, baseNameNoExt: noExt };
 }
 function buildRelativeImportRewriter(sourcePath, outputPath, componentDirs, templatesOutDir) {
-  const sourceDir = dirname3(sourcePath);
-  const outputDir = dirname3(outputPath);
+  const sourceDir = dirname4(sourcePath);
+  const outputDir = dirname4(outputPath);
   const resolvedComponentDirs = componentDirs.map((d) => resolve6(d));
   return (importPath) => {
     const srcAbs = resolve6(sourceDir, importPath);
@@ -24331,22 +25078,22 @@ function buildRelativeImportRewriter(sourcePath, outputPath, componentDirs, temp
   };
 }
 function effectiveOutName(tplPath, entryBaseNoExt) {
-  const bn = basename(tplPath);
+  const bn = basename2(tplPath);
   const entryDir = entryBaseNoExt.includes("/") ? entryBaseNoExt.slice(0, entryBaseNoExt.lastIndexOf("/")) : "";
   return entryDir ? `${entryDir}/${bn}` : bn;
 }
 function topLevelImportLines(content2) {
   const lines = /* @__PURE__ */ new Set();
-  const sourceFile = ts23.createSourceFile(
+  const sourceFile = ts24.createSourceFile(
     "merge.js",
     content2,
-    ts23.ScriptTarget.Latest,
+    ts24.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts23.ScriptKind.JS
+    ts24.ScriptKind.JS
   );
   for (const stmt of sourceFile.statements) {
-    if (ts23.isImportDeclaration(stmt)) {
+    if (ts24.isImportDeclaration(stmt)) {
       const { line } = sourceFile.getLineAndCharacterOfPosition(stmt.getStart(sourceFile));
       lines.add(line);
     }
@@ -24355,29 +25102,29 @@ function topLevelImportLines(content2) {
 }
 function rewriteBarefootClientSpecifiers(content2, rel) {
   if (!content2.includes("@barefootjs/client")) return content2;
-  const sourceFile = ts23.createSourceFile(
+  const sourceFile = ts24.createSourceFile(
     "client.js",
     content2,
-    ts23.ScriptTarget.Latest,
+    ts24.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts23.ScriptKind.JS
+    ts24.ScriptKind.JS
   );
   const isBarefootClient = (s) => s === "@barefootjs/client" || s.startsWith("@barefootjs/client/");
   const spans = [];
   const visit3 = (node) => {
-    if (ts23.isImportDeclaration(node) || ts23.isExportDeclaration(node)) {
+    if (ts24.isImportDeclaration(node) || ts24.isExportDeclaration(node)) {
       const ms = node.moduleSpecifier;
-      if (ms && ts23.isStringLiteral(ms) && isBarefootClient(ms.text)) {
+      if (ms && ts24.isStringLiteral(ms) && isBarefootClient(ms.text)) {
         spans.push([ms.getStart(sourceFile), ms.getEnd()]);
       }
-    } else if (ts23.isCallExpression(node) && node.expression.kind === ts23.SyntaxKind.ImportKeyword) {
+    } else if (ts24.isCallExpression(node) && node.expression.kind === ts24.SyntaxKind.ImportKeyword) {
       const arg = node.arguments[0];
-      if (arg && ts23.isStringLiteral(arg) && isBarefootClient(arg.text)) {
+      if (arg && ts24.isStringLiteral(arg) && isBarefootClient(arg.text)) {
         spans.push([arg.getStart(sourceFile), arg.getEnd()]);
       }
     }
-    ts23.forEachChild(node, visit3);
+    ts24.forEachChild(node, visit3);
   };
   visit3(sourceFile);
   if (spans.length === 0) return content2;
@@ -24465,11 +25212,14 @@ async function resolvePkgBrowserEntry(pkgDir) {
   return null;
 }
 async function processExternals(config, runtimeSubdir, runtimeOutDir) {
-  if (!config.externals || Object.keys(config.externals).length === 0) return { changed: false, allExternals: [] };
+  if (!config.externals || Object.keys(config.externals).length === 0) {
+    return { changed: false, allExternals: [], outfiles: [] };
+  }
   const basePath = config.externalsBasePath ?? `/${runtimeSubdir}/`;
   const base = basePath.endsWith("/") ? basePath : basePath + "/";
   const imports = {};
   const preloads2 = [];
+  const outfiles = [];
   let anyChanged = false;
   for (const [pkgName, spec] of Object.entries(config.externals)) {
     const isChunk = spec === true || typeof spec === "object" && !("url" in spec);
@@ -24492,8 +25242,9 @@ async function processExternals(config, runtimeSubdir, runtimeOutDir) {
       const srcFile = entry.path;
       const filename = vendorChunkFilename(pkgName);
       const destPath = resolve6(runtimeOutDir, filename);
+      outfiles.push(destPath);
       if (wantRebundle) {
-        await esbuildBuild({
+        await esbuildBuild2({
           entryPoints: [srcFile],
           outfile: destPath,
           format: "esm",
@@ -24553,16 +25304,18 @@ async function processExternals(config, runtimeSubdir, runtimeOutDir) {
       console.log("Generated: barefoot-importmap.html");
     }
   }
-  return { changed: anyChanged, allExternals };
+  return { changed: anyChanged, allExternals, outfiles };
 }
 async function processBundleEntries(config, clientJsOutDir, clientJsSubdir, allExternals, cache2, nextEntries, force) {
-  if (!config.bundleEntries || config.bundleEntries.length === 0) return false;
+  if (!config.bundleEntries || config.bundleEntries.length === 0) return { changed: false, outfiles: [] };
   let anyChanged = false;
+  const outfiles = [];
   for (const entry of config.bundleEntries) {
     const entryExternals = [
       .../* @__PURE__ */ new Set([...BF_CLIENT_DEDUP_KEYS, ...allExternals, ...entry.externals ?? []])
     ];
     const outfilePath = resolve6(clientJsOutDir, entry.outfile);
+    outfiles.push(outfilePath);
     const absEntry = resolve6(entry.entry);
     const cacheKey = `${BUNDLE_KEY_PREFIX}${absEntry}`;
     const sourceContent = await readText(absEntry);
@@ -24585,7 +25338,7 @@ async function processBundleEntries(config, clientJsOutDir, clientJsSubdir, allE
       }
     }
     const absWorkingDir = process.cwd();
-    const result2 = await esbuildBuild({
+    const result2 = await esbuildBuild2({
       entryPoints: [entry.entry],
       outfile: outfilePath,
       format: "esm",
@@ -24618,10 +25371,26 @@ async function processBundleEntries(config, clientJsOutDir, clientJsSubdir, allE
       manifestKey: null
     };
   }
-  return anyChanged;
+  return { changed: anyChanged, outfiles };
+}
+function registerAdapterChildShapes(adapter, allFiles, sourceContents, program) {
+  const hook = adapter.registerChildComponentShape;
+  if (typeof hook !== "function") return;
+  for (const filePath of allFiles) {
+    const source = sourceContents.get(filePath);
+    if (!source) continue;
+    try {
+      for (const componentName of listComponentFunctions(source, filePath)) {
+        const ctx2 = analyzeComponent(source, filePath, componentName, program);
+        if (!ctx2.jsxReturn) continue;
+        hook.call(adapter, { metadata: buildMetadata(ctx2) });
+      }
+    } catch {
+    }
+  }
 }
 async function collectRelativeImportDeps(entryPath, sourceContent) {
-  const baseDir = dirname3(entryPath);
+  const baseDir = dirname4(entryPath);
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   const EXT_CANDIDATES = [".tsx", ".ts", "/index.tsx", "/index.ts"];
@@ -24729,7 +25498,7 @@ async function compileEntry(args2) {
     const rel = `${clientJsSubdir}/${clientJsFilename}`;
     outputs.push(rel);
     const target2 = resolve6(clientJsOutDir, clientJsFilename);
-    await mkdir(dirname3(target2), { recursive: true });
+    await mkdir(dirname4(target2), { recursive: true });
     if (await writeIfChanged(target2, clientJsContent)) {
       wroteAny = true;
       console.log(`Generated: ${rel}`);
@@ -24746,7 +25515,7 @@ async function compileEntry(args2) {
       const rel = `${templatesSubdir}/${outName}`;
       outputs.push(rel);
       const target2 = resolve6(templatesOutDir, outName);
-      await mkdir(dirname3(target2), { recursive: true });
+      await mkdir(dirname4(target2), { recursive: true });
       if (await writeIfChanged(target2, outputContent)) {
         wroteAny = true;
         console.log(`Generated: ${rel}`);
@@ -24758,22 +25527,35 @@ async function compileEntry(args2) {
   if (!config.clientOnly && markedTemplates.length > 0) {
     const primaryTpl = markedTemplates.find((t) => effectiveOutName(t.path, baseNameNoExt).startsWith(baseNameNoExt + ".")) ?? markedTemplates[0];
     manifestKey = baseNameNoExt;
-    const primaryBase = primaryTpl.path.replace(/\.[^.]+$/, "").replace(/\.html$/, "");
-    const ssrDefaultsFile = result2.files.find(
-      (f) => f.type === "ssrDefaults" && f.path === primaryBase + ".ssr-defaults.json"
-    ) ?? result2.files.find((f) => f.type === "ssrDefaults");
-    let ssrDefaults;
-    if (ssrDefaultsFile) {
+    const ssrDefaultsForTemplate = (tplPath) => {
+      const base = tplPath.replace(/\.[^.]+$/, "").replace(/\.html$/, "");
+      const file = result2.files.find((f) => f.type === "ssrDefaults" && f.path === base + ".ssr-defaults.json") ?? (tplPath === primaryTpl.path ? result2.files.find((f) => f.type === "ssrDefaults") : void 0);
+      if (!file) return void 0;
       try {
-        ssrDefaults = JSON.parse(ssrDefaultsFile.content);
+        return JSON.parse(file.content);
       } catch {
-        ssrDefaults = void 0;
+        return void 0;
+      }
+    };
+    const ssrDefaults = ssrDefaultsForTemplate(primaryTpl.path);
+    let components;
+    if (config.adapter.templatesPerComponent) {
+      components = {};
+      for (const tpl of markedTemplates) {
+        if (!tpl.componentName) continue;
+        const componentDefaults = ssrDefaultsForTemplate(tpl.path);
+        components[tpl.componentName] = {
+          markedTemplate: `${templatesSubdir}/${effectiveOutName(tpl.path, baseNameNoExt)}`,
+          ...componentDefaults ? { ssrDefaults: componentDefaults } : {}
+        };
       }
+      if (Object.keys(components).length === 0) components = void 0;
     }
     manifestEntry = {
       markedTemplate: `${templatesSubdir}/${effectiveOutName(primaryTpl.path, baseNameNoExt)}`,
       clientJs: hasClientJs ? `${clientJsSubdir}/${clientJsFilename}` : void 0,
-      ...ssrDefaults ? { ssrDefaults } : {}
+      ...ssrDefaults ? { ssrDefaults } : {},
+      ...components ? { components } : {}
     };
   }
   return {
@@ -24937,6 +25719,7 @@ var init_build = __esm({
     init_fs_utils();
     init_assets_ignore();
     init_runtime();
+    init_runtime_treeshake();
     init_resolve_imports();
     BF001_TRIPWIRE_IMPORTS = /* @__PURE__ */ new Set([
       ...REACTIVE_PRIMITIVES,
@@ -25892,8 +26675,17 @@ __export(add_exports, {
   run: () => run3,
   toRegistryName: () => toRegistryName
 });
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, copyFileSync, writeFileSync as writeFileSync2, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, copyFileSync, writeFileSync as writeFileSync2, readFileSync as readFileSync4, readdirSync as readdirSync2, utimesSync } from "node:fs";
 import path9 from "node:path";
+function kickCssWatcher(projectDir) {
+  const unoConfig = path9.resolve(projectDir, "uno.config.ts");
+  if (!existsSync7(unoConfig)) return;
+  const now = /* @__PURE__ */ new Date();
+  try {
+    utimesSync(unoConfig, now, now);
+  } catch {
+  }
+}
 async function run3(args2, ctx2) {
   const force = args2.includes("--force");
   let registryUrl;
@@ -26038,6 +26830,9 @@ async function addFromRegistry(componentNames, registryUrl, projectDir, config,
   if (existsSync7(destMetaDir)) {
     rebuildMetaIndex(destMetaDir);
   }
+  if (added.length > 0) {
+    kickCssWatcher(projectDir);
+  }
   if (silent) return;
   if (added.length > 0) {
     console.log(`
@@ -26103,6 +26898,9 @@ function addFromLocal(componentNames, ctx2, projectDir, config, force) {
     added.push(name2);
   }
   rebuildMetaIndex(destMetaDir);
+  if (added.length > 0) {
+    kickCssWatcher(projectDir);
+  }
   if (added.length > 0) {
     console.log(`
   Added: ${added.join(", ")}`);
@@ -26154,6 +26952,9 @@ var init_add = __esm({
 });
 
 // src/lib/adapters/shared.ts
+function faviconLinkTag(href2) {
+  return FAVICON_LINK_TAG.replace("__FAVICON_HREF__", href2);
+}
 function unoConfigTs(scanGlobs) {
   const formatted = scanGlobs.map((g) => `'${g}'`).join(", ");
   return `import { defineConfig, presetWind4 } from 'unocss'
@@ -26229,7 +27030,7 @@ function buildGitignore(sections) {
   lines.push(...SHARED_GITIGNORE_LINES);
   return lines.join("\n") + "\n";
 }
-var CSS_LINKS_BEGIN, CSS_LINKS_END, SHARED_COUNTER_TSX, SHARED_COUNTER_TEST_TSX, SHARED_COUNTER_BARE_TSX, SHARED_COUNTER_BARE_TEST_TSX, TOKENS_CSS, STYLES_CSS, UNO_CSS_PLACEHOLDER, COMPONENTS_MANIFEST_SEED, UNOCSS_DEV_DEPENDENCIES, SHARED_GITIGNORE_LINES;
+var CSS_LINKS_BEGIN, CSS_LINKS_END, SHARED_COUNTER_TSX, SHARED_COUNTER_TEST_TSX, SHARED_COUNTER_BARE_TSX, SHARED_COUNTER_BARE_TEST_TSX, TOKENS_CSS, STYLES_CSS, UNO_CSS_PLACEHOLDER, FAVICON_SVG, FAVICON_LINK_TAG, COMPONENTS_MANIFEST_SEED, UNOCSS_DEV_DEPENDENCIES, SHARED_GITIGNORE_LINES;
 var init_shared2 = __esm({
   "src/lib/adapters/shared.ts"() {
     "use strict";
@@ -26485,6 +27286,16 @@ main {
 `;
     UNO_CSS_PLACEHOLDER = `/* generated by unocss --watch */
 `;
+    FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="7" fill="#1c1917"/>
+  <ellipse cx="16" cy="20.5" rx="6" ry="7" fill="#fafaf9"/>
+  <circle cx="9" cy="10" r="2.6" fill="#fafaf9"/>
+  <circle cx="14.5" cy="7.2" r="2.8" fill="#fafaf9"/>
+  <circle cx="20.5" cy="7.2" r="2.8" fill="#fafaf9"/>
+  <circle cx="25" cy="10.5" r="2.4" fill="#fafaf9"/>
+</svg>
+`;
+    FAVICON_LINK_TAG = '<link rel="icon" type="image/svg+xml" href="__FAVICON_HREF__" />';
     COMPONENTS_MANIFEST_SEED = "{}\n";
     UNOCSS_DEV_DEPENDENCIES = {
       "@unocss/cli": "^66.0.0",
@@ -26514,11 +27325,12 @@ main {
 });
 
 // src/lib/adapters/runtimes.generated.ts
-var bfGoSource, streamingGoSource, bfdevGoSource;
+var bfGoSource, evalGoSource, streamingGoSource, bfdevGoSource;
 var init_runtimes_generated = __esm({
   "src/lib/adapters/runtimes.generated.ts"() {
     "use strict";
-    bfGoSource = '// Package bf provides runtime helper functions for BarefootJS Go templates.\n// These functions mirror JavaScript behavior for consistent SSR output.\npackage bf\n\nimport (\n	"bytes"\n	"encoding/json"\n	"fmt"\n	"html/template"\n	"math"\n	"math/rand"\n	"net/url"\n	"os"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode/utf8"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Arithmetic\n		"bf_add": Add,\n		"bf_sub": Sub,\n		"bf_mul": Mul,\n		"bf_div": Div,\n		"bf_mod": Mod,\n		"bf_neg": Neg,\n		"bf_min": Min,\n		"bf_max": Max,\n\n		// String\n		"bf_lower":       Lower,\n		"bf_upper":       Upper,\n		"bf_trim":        Trim,\n		"bf_contains":    Contains,\n		"bf_join":        Join,\n		"bf_split":       Split,\n		"bf_starts_with": StartsWith,\n		"bf_ends_with":   EndsWith,\n		"bf_replace":     Replace,\n		"bf_repeat":      Repeat,\n		"bf_pad_start":   PadStart,\n		"bf_pad_end":     PadEnd,\n		"bf_string":      String,\n\n		// URL query builder (#1897 PostList href helpers): conditional\n		// (include, key, value) triples \u2192 "base?k=v&\u2026", mirroring a\n		// URLSearchParams builder with guarded `.set()` calls.\n		"bf_query": Query,\n\n		// JSON / numeric primitives \u2014 JS-compat callees registered on\n		// the Go adapter\'s `templatePrimitives` map (#1188).\n		"bf_json":     JSON,\n		"bf_number":   Number,\n		"bf_floor":    Floor,\n		"bf_ceil":     Ceil,\n		"bf_round":    Round,\n		"bf_to_fixed": ToFixed,\n\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_flat":           Flat,\n		"bf_flat_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}\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// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Min returns the smaller of a and b (two-arg `Math.min`). Like Mul, it keeps\n// an integer result when both operands are int-like so a CSS value such as\n// `bf_min 100 x` stays `100` rather than `100.000000`.\nfunc Min(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	r := av\n	if bv < av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Max returns the larger of a and b (two-arg `Math.max`), with the same\n// int-preserving rule as Min.\nfunc Max(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	r := av\n	if bv > av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Split lowers `String.prototype.split(sep, limit?)` (#1448 Tier B). It\n// wraps `strings.Split` and normalises the result to `[]any` so the\n// slice composes with the array-method surface downstream (`bf_join`,\n// range loops, `bf_len`, \u2026) the same way `bf_slice` / `bf_reverse`\n// results do. Like JS, an empty separator splits into individual UTF-8\n// characters and trailing empty fields are preserved (`"a,".split(",")`\n// \u2192 `["a", ""]`). An optional `limit` caps the number of returned\n// pieces (`"a,b,c".split(",", 2)` \u2192 `["a", "b"]`); a negative limit is\n// ignored (JS would also return every piece \u2014 its ToUint32 wrap makes\n// the limit effectively unbounded). The no-separator form is handled by\n// the adapter (it emits `bf_arr` for the whole-string single element).\nfunc Split(s, sep string, limit ...int) []any {\n	parts := strings.Split(s, sep)\n	if len(limit) > 0 && limit[0] >= 0 && limit[0] < len(parts) {\n		parts = parts[:limit[0]]\n	}\n	out := make([]any, len(parts))\n	for i, p := range parts {\n		out[i] = p\n	}\n	return out\n}\n\n// StartsWith lowers `String.prototype.startsWith(prefix, position?)`\n// (#1448 Tier B). Wraps `strings.HasPrefix`; an empty prefix is always\n// true (JS parity). The optional `position` re-anchors the test to start\n// at that index (clamped to `[0, len]` so it never panics), matching JS\n// `"abc".startsWith("b", 1) === true`.\nfunc StartsWith(s, prefix string, position ...int) bool {\n	if len(position) > 0 {\n		p := position[0]\n		if p < 0 {\n			p = 0\n		}\n		if p > len(s) {\n			p = len(s)\n		}\n		s = s[p:]\n	}\n	return strings.HasPrefix(s, prefix)\n}\n\n// EndsWith lowers `String.prototype.endsWith(suffix, endPosition?)`\n// (#1448 Tier B). Wraps `strings.HasSuffix`; an empty suffix is always\n// true (JS parity). The optional `endPosition` treats the string as if\n// it were only that many bytes long (clamped to `[0, len]`), matching JS\n// `"abc".endsWith("b", 2) === true`.\nfunc EndsWith(s, suffix string, endPosition ...int) bool {\n	if len(endPosition) > 0 {\n		e := endPosition[0]\n		if e < 0 {\n			e = 0\n		}\n		if e > len(s) {\n			e = len(s)\n		}\n		s = s[:e]\n	}\n	return strings.HasSuffix(s, suffix)\n}\n\n// Replace lowers the string-pattern form of `String.prototype.replace`\n// (#1448 Tier B). JS replaces only the FIRST occurrence for a string\n// pattern, so the count is 1 (`strings.Replace` with n=1; n<0 would\n// replace all \u2014 that\'s `.replaceAll`, still refused). The replacement\n// is treated literally: unlike JS, special replacement patterns like\n// `$&` / `$1` are NOT interpreted (Go and Perl agree on literal\n// replacement, keeping the two template adapters byte-equal; this\n// diverges from the Hono/CSR JS path only for replacement strings that\n// contain `$`-patterns, which are rare in template position).\nfunc Replace(s, old, new string) string {\n	return strings.Replace(s, old, new, 1)\n}\n\n// Repeat lowers `String.prototype.repeat(n)` (#1448 Tier B): the\n// receiver concatenated n times. JS throws RangeError for a negative\n// count and `strings.Repeat` panics, so a negative count clamps to the\n// empty string \u2014 SSR templates degrade rather than crash the render.\n// A zero count is the empty string (JS parity).\nfunc Repeat(s string, n int) string {\n	if n <= 0 {\n		return ""\n	}\n	return strings.Repeat(s, n)\n}\n\n// padTo lowers the shared body of `String.prototype.padStart` /\n// `padEnd` (#1448 Tier B): pad `s` to `target` code points using `pad`\n// repeated and truncated to fill, prepended (atStart) or appended.\n// Length is measured in runes (not bytes) so the result matches the\n// Perl `bf->pad_*` helpers \u2014 this diverges from JS\'s UTF-16-unit length\n// only for astral-plane input. An empty pad, or a receiver already at\n// least `target` long, returns `s` unchanged (JS parity).\nfunc padTo(s string, target int, pad string, atStart bool) string {\n	if pad == "" {\n		return s\n	}\n	sLen := utf8.RuneCountInString(s)\n	if sLen >= target {\n		return s\n	}\n	need := target - sLen\n	padRunes := []rune(pad)\n	fill := make([]rune, 0, need)\n	for len(fill) < need {\n		for _, r := range padRunes {\n			if len(fill) >= need {\n				break\n			}\n			fill = append(fill, r)\n		}\n	}\n	if atStart {\n		return string(fill) + s\n	}\n	return s + string(fill)\n}\n\n// PadStart lowers `String.prototype.padStart(target, pad?)` (#1448 Tier\n// B). The pad string defaults to a single space when omitted.\nfunc PadStart(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, true)\n}\n\n// PadEnd lowers `String.prototype.padEnd(target, pad?)` (#1448 Tier B).\nfunc PadEnd(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, false)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// String returns the string form of v. Mirrors JS `String(v)` for\n// non-nil values via `fmt.Sprintf("%v", ...)`. Diverges from JS on\n// nil: JS `String(null)` is "null", but the template path renders\n// `nil` as the empty string here so an unset prop doesn\'t surface\n// as a literal "null"/"undefined" in user-facing HTML. Document the\n// divergence explicitly so callers don\'t rely on JS-exact parity.\nfunc String(v any) string {\n	if v == nil {\n		return ""\n	}\n	return fmt.Sprintf("%v", v)\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// ToFixed formats v with exactly `digits` decimal places, mirroring JS\n// `Number.prototype.toFixed` (zero-padding + half-toward-+Infinity\n// rounding). JS rounds the scaled integer half up (`(2.5).toFixed(0)`\n// is "3"); bare `fmt.Sprintf("%.*f")` rounds half-to-even ("2"), so we\n// scale, round with `Floor(x + 0.5)` (matching `Round`), then format\n// the exact multiple. #1897.\nfunc ToFixed(v any, digits int) string {\n	if digits < 0 {\n		digits = 0\n	}\n	n := Number(v)\n	// JS toFixed returns the strings "NaN" / "Infinity" / "-Infinity" for\n	// non-finite inputs; fmt would render "NaN"/"+Inf"/"-Inf".\n	if math.IsNaN(n) {\n		return "NaN"\n	}\n	if math.IsInf(n, 1) {\n		return "Infinity"\n	}\n	if math.IsInf(n, -1) {\n		return "-Infinity"\n	}\n	factor := math.Pow(10, float64(digits))\n	rounded := math.Floor(n*factor + 0.5)\n	return fmt.Sprintf("%.*f", digits, rounded/factor)\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  SameValueZero element search (matches\n//     the evaluator\'s `evalSameValueZero`/`evalIncludes` in eval.go,\n//     which back the serialized-callback path) \u2014 numeric types compare\n//     by value across int/float64 the way JS\'s single "number" type\n//     does, and NaN matches NaN (unlike `===`). This used to be\n//     `reflect.DeepEqual`, which is type-strict (`int(2)` != `float64(2)`)\n//     and never matches NaN to NaN; that diverged from the evaluator\'s\n//     `.includes` and from JS itself, so it was unified here.\n//   - string receiver:       strings.Contains substring search\n//\n// Anything else returns false (matches the JS semantic where\n// `.includes` is only defined on Array / TypedArray / String).\nfunc Includes(recv any, elem any) bool {\n	v := reflect.ValueOf(recv)\n	if v.Kind() == reflect.String {\n		// JS `String.prototype.includes` accepts only string args;\n		// non-string `elem` would TypeError in real JS but our\n		// callers have lowered through `convertExpressionToGo`\n		// where the arg type is whatever the template binds. Stringify\n		// via fmt to keep the helper total.\n		needle, ok := elem.(string)\n		if !ok {\n			needle = fmt.Sprintf("%v", elem)\n		}\n		return strings.Contains(v.String(), needle)\n	}\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if evalSameValueZero(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A). The variadic\n// `end` arg lets Go template\'s call dispatcher pass either 2 or 3\n// arguments; an absent end means "to length".\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\n//   - start >= end       \u2192 empty slice (no panic)\n//\n// Non-array receivers return an empty `[]any`.\nfunc Slice(items any, start int, end ...int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n\n	// Normalise start (negative = from end).\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	// Normalise end (optional; absent = length).\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n\n	if start >= stop {\n		return []any{}\n	}\n\n	out := make([]any, 0, stop-start)\n	for i := start; i < stop; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// Flat flattens nested slices/arrays `depth` levels deep. Lowers\n// `Array.prototype.flat(depth?)` (#1448 Tier C). A `depth` of `-1` is the\n// `Infinity` sentinel (flatten fully); `0` (or negative-from-JS, already\n// normalised to 0 at compile time) returns a shallow copy. Non-array\n// elements are kept as-is (JS only flattens nested arrays). A non-array\n// receiver returns an empty `[]any`.\nfunc Flat(items any, depth int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		ev := reflect.ValueOf(el)\n		if depth != 0 && (ev.Kind() == reflect.Slice || ev.Kind() == reflect.Array) {\n			// `-1` (Infinity) recurses unbounded; a finite depth spends one level.\n			next := depth\n			if depth > 0 {\n				next = depth - 1\n			}\n			out = append(out, Flat(el, next)...)\n		} else {\n			out = append(out, el)\n		}\n	}\n	return out\n}\n\n// 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// capitalize uppercases the first character of a string.\nfunc capitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToUpper(s[:1]) + s[1:]\n}\n\n// decapitalize lowercases the first character of a string. Used by\n// `getFieldValue`\'s map-receiver fallback when the projected key\n// name is PascalCase but the receiver carries lowercase JS-style\n// keys (the inverse of the `capitalize` lookup).\nfunc decapitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToLower(s[:1]) + s[1:]\n}\n\n// Reduce folds an array into a scalar via the arithmetic-fold\n// catalogue (#1448 Tier C). It lowers `Array.prototype.reduce(fn, init)`\n// and `Array.prototype.reduceRight(fn, init)` for the shapes\n// `(acc, x) => acc <op> x` and `(acc, x) => acc <op> x.field`:\n//\n//	bf_reduce <items> "<op>" "<keyKind>" "<keyName>" "<type>" "<init>" "<direction>"\n//\n//	direction: "left" (reduce) | "right" (reduceRight). Only changes the\n//	           result for string concatenation; numeric folds commute.\n//\n//	op:       "+" | "*"\n//	keyKind:  "self" | "field"\n//	keyName:  "" when keyKind == "self"; capitalised struct field name\n//	          (e.g. "Duration") otherwise\n//	type:     "numeric" | "string"\n//	init:     the fold\'s start value \u2014 the compiler emits the *decoded*\n//	          seed, so numeric inits arrive as canonical decimal\n//	          (`1_000`/`0x10` already normalised to `1000`/`16`) that\n//	          ParseFloat accepts, and string inits arrive as escape-free\n//	          contents\n//\n// Numeric folds accumulate as float64; each projected key is read via\n// `toFloat64WithOK`, so numeric *strings* ("5" \u2192 5) parse and\n// non-numeric values fold as 0 \u2014 matching Perl\'s\n// `looks_like_number ? $n : 0` so the two template adapters stay\n// byte-equal. String folds concatenate (toString per projected key,\n// matching the documented `bf->string(undef) === ""` convention). The\n// init seeds the accumulator, so an empty receiver returns the init\n// unchanged \u2014 exactly like JS `reduce(fn, init)`. Anything outside the\n// catalogue refuses at compile time (BF101 from the JSX compiler) and\n// never reaches here.\n//\n// Two documented divergences from the JS / Hono path, both rare and\n// mirroring the `bf_sort` "auto" caveat:\n//   - float64 stringification differs for sums whose binary expansion\n//     isn\'t exact (e.g. 0.1 + 0.2);\n//   - numeric-*string* keys fold numerically here, but JS `+`\n//     string-concatenates once an operand is a string, so\n//     numeric-string data can render differently under CSR.\n//\n// Genuine numbers \u2014 the common SSR case \u2014 agree across all three.\nfunc Reduce(items any, op, keyKind, keyName, typ, init, direction string) any {\n	v := reflect.ValueOf(items)\n	isSlice := v.Kind() == reflect.Slice || v.Kind() == reflect.Array\n\n	// `direction == "right"` (reduceRight) folds right-to-left. Only\n	// observable for string concatenation \u2014 numeric sum / product are\n	// commutative, so the order doesn\'t change the result there. Build a\n	// start/stop/step triple so both folds share one loop shape.\n	start, stop, step := 0, 0, 1\n	if isSlice {\n		stop = v.Len()\n		if direction == "right" {\n			start, stop, step = v.Len()-1, -1, -1\n		}\n	}\n\n	if typ == "string" {\n		acc := init\n		if isSlice {\n			for i := start; i != stop; i += step {\n				key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n				acc += toString(key)\n			}\n		}\n		return acc\n	}\n\n	// numeric fold\n	acc, _ := strconv.ParseFloat(strings.TrimSpace(init), 64)\n	if isSlice {\n		for i := start; i != stop; i += step {\n			key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n			// `toFloat64WithOK` parses numeric *strings* ("5" \u2192 5) and\n			// returns 0 for non-numeric values \u2014 mirroring Perl\'s\n			// `looks_like_number ? $n : 0` so numeric-string data folds\n			// byte-equal across adapters (the same rule `bf_sort`\'s\n			// "auto" compare uses). Plain `toFloat64` would zero "5".\n			n, _ := toFloat64WithOK(key)\n			if op == "*" {\n				acc *= n\n			} else {\n				acc += n\n			}\n		}\n	}\n	return acc\n}\n\n// =============================================================================\n// HTML/Template Helpers\n// =============================================================================\n\n// Comment returns an HTML comment string for hydration markers.\n// The "bf-" prefix is automatically added.\nfunc Comment(content string) template.HTML {\n	return template.HTML("<!--bf-" + content + "-->")\n}\n\n// TextStart returns an HTML comment start marker for reactive text expressions.\n// Format: <!--bf:slotId-->\nfunc TextStart(slotId string) template.HTML {\n	return template.HTML("<!--bf:" + slotId + "-->")\n}\n\n// TextEnd returns an HTML comment end marker for reactive text expressions.\n// Format: <!--/-->\nfunc TextEnd() template.HTML {\n	return "<!--/-->"\n}\n\n// ScopeComment emits a fragment-rooted scope marker. See spec/compiler.md\n// "Slot identity" for the wire format. Loud-fails on marshal errors\n// (same policy as JSON / BfPropsAttr).\nfunc ScopeComment(props interface{}) (template.HTML, error) {\n	scopeID := getStringField(props, "ScopeID")\n	hostSegment := ""\n	if host := getStringField(props, "BfParent"); host != "" {\n		mount := getStringField(props, "BfMount")\n		hostSegment = "|h=" + host + "|m=" + mount\n	}\n	propsJSON := ""\n	if getBoolField(props, "BfIsRoot") {\n		pJSON, err := json.Marshal(props)\n		if err != nil {\n			return "", err\n		}\n		propsJSON = "|" + string(pJSON)\n	}\n	return template.HTML("<!--bf-scope:" + scopeID + hostSegment + propsJSON + "-->"), nil\n}\n\n// TemplateFuncMap returns the helpers that need access to the executing\n// template set itself, closed over the *template.Template the component\n// defines are parsed into. Register it alongside FuncMap BEFORE parsing:\n//\n//	t := template.New("")\n//	t.Funcs(bf.FuncMap()).Funcs(bf.TemplateFuncMap(t))\n//	template.Must(t.Parse(src))\n//\n// bf_tmpl executes a named define from the same set and returns its\n// output \u2014 used for the per-call-site children defines the Go adapter\n// emits when JSX children passed to an imported component contain\n// template actions (nested components, dynamic text) and therefore\n// cannot be baked to a static HTML string (#1896). Reentrant execution\n// of an html/template set from inside a FuncMap function is safe: the\n// escape analysis over every define completes before the outer\n// Execute begins evaluating.\nfunc TemplateFuncMap(t *template.Template) template.FuncMap {\n	return template.FuncMap{\n		"bf_tmpl": func(name string, data interface{}) (template.HTML, error) {\n			var buf bytes.Buffer\n			if err := t.ExecuteTemplate(&buf, name, data); err != nil {\n				return "", err\n			}\n			return template.HTML(buf.String()), nil\n		},\n	}\n}\n\n// WithChildren returns a shallow copy of a component Props struct with its\n// Children field replaced by the given pre-rendered fragment (#1896). The\n// props value stays by-value semantics: callers\' originals are untouched.\n// A props type without a Children field passes through unchanged \u2014 the\n// child template then simply has no children to render, matching the\n// pre-#1896 behaviour.\nfunc WithChildren(props interface{}, children template.HTML) (interface{}, error) {\n	v := reflect.ValueOf(props)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return props, nil\n	}\n	field := v.FieldByName("Children")\n	if !field.IsValid() {\n		return props, nil\n	}\n	copyPtr := reflect.New(v.Type())\n	copyPtr.Elem().Set(v)\n	target := copyPtr.Elem().FieldByName("Children")\n	switch {\n	case target.Kind() == reflect.Interface:\n		target.Set(reflect.ValueOf(children))\n	case target.Kind() == reflect.String:\n		// Covers both `string` and `template.HTML`-typed fields.\n		target.SetString(string(children))\n	default:\n		return props, fmt.Errorf("bf_with_children: unsupported Children field type %s", target.Type())\n	}\n	return copyPtr.Elem().Interface(), nil\n}\n\n// PortalHTML parses and executes a template string with the provided data.\n// Used for rendering dynamic portal content where the template string\n// contains Go template expressions (e.g., {{if .Open}}open{{end}}).\n//\n// The template string is parsed fresh each time to support dynamic content.\n// Standard Go template functions (if, range, eq, etc.) are available.\nfunc PortalHTML(data interface{}, tmplStr string) template.HTML {\n	// Create a new template with the FuncMap for custom functions\n	t, err := template.New("portal").Funcs(FuncMap()).Parse(tmplStr)\n	if err != nil {\n		// Return error message as HTML comment for debugging\n		return template.HTML("<!-- bfPortalHTML error: " + err.Error() + " -->")\n	}\n\n	var buf bytes.Buffer\n	if err := t.Execute(&buf, data); err != nil {\n		return template.HTML("<!-- bfPortalHTML exec error: " + err.Error() + " -->")\n	}\n\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Portal Collection\n// =============================================================================\n\n// PortalContent represents a single portal\'s content to be rendered at body end.\ntype PortalContent struct {\n	ID      string        // Unique portal ID for hydration matching\n	OwnerID string        // Owner scope ID for find() support\n	Content template.HTML // Portal HTML content\n}\n\n// PortalCollector collects portal content during template rendering.\n// Portal content is rendered at </body> to avoid z-index issues.\ntype PortalCollector struct {\n	portals []PortalContent\n	counter int\n}\n\n// NewPortalCollector creates a new PortalCollector.\nfunc NewPortalCollector() *PortalCollector {\n	return &PortalCollector{\n		portals: []PortalContent{},\n		counter: 0,\n	}\n}\n\n// Add registers portal content to be rendered at body end.\nfunc (pc *PortalCollector) Add(ownerID string, content template.HTML) string {\n	pc.counter++\n	id := "bf-portal-" + strconv.Itoa(pc.counter)\n	pc.portals = append(pc.portals, PortalContent{\n		ID:      id,\n		OwnerID: ownerID,\n		Content: content,\n	})\n	return "" // Return empty string for template use\n}\n\n// Render outputs all collected portals as HTML.\n// Each portal is wrapped in a div with bf-pi (portal ID) and bf-po (portal owner).\nfunc (pc *PortalCollector) Render() template.HTML {\n	if pc == nil || len(pc.portals) == 0 {\n		return ""\n	}\n	var buf strings.Builder\n	for _, p := range pc.portals {\n		buf.WriteString(`<div bf-pi="`)\n		buf.WriteString(p.ID)\n		buf.WriteString(`" bf-po="`)\n		buf.WriteString(p.OwnerID)\n		buf.WriteString(`">`)\n		buf.WriteString(string(p.Content))\n		buf.WriteString("</div>\\n")\n	}\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Script Collection\n// =============================================================================\n\n// ScriptCollector collects client scripts with deduplication.\n// It preserves insertion order for deterministic output.\ntype ScriptCollector struct {\n	scripts map[string]bool\n	order   []string\n}\n\n// NewScriptCollector creates a new ScriptCollector.\nfunc NewScriptCollector() *ScriptCollector {\n	return &ScriptCollector{\n		scripts: make(map[string]bool),\n		order:   []string{},\n	}\n}\n\n// Register adds a script source to the collection.\n// Duplicate scripts are ignored (only first registration counts).\nfunc (sc *ScriptCollector) Register(src string) string {\n	if sc.scripts[src] {\n		return "" // Already registered\n	}\n	sc.scripts[src] = true\n	sc.order = append(sc.order, src)\n	return "" // Return empty string for template use\n}\n\n// Scripts returns all registered scripts in insertion order.\nfunc (sc *ScriptCollector) Scripts() []string {\n	return sc.order\n}\n\n// BfScripts generates script tags for all registered scripts.\n// Returns HTML safe for embedding in templates.\nfunc BfScripts(collector *ScriptCollector) template.HTML {\n	if collector == nil {\n		return ""\n	}\n	var result strings.Builder\n	for _, src := range collector.Scripts() {\n		result.WriteString(`<script type="module" src="`)\n		result.WriteString(src)\n		result.WriteString(`"></script>`)\n		result.WriteString("\\n")\n	}\n	return template.HTML(result.String())\n}\n\n// =============================================================================\n// Component Renderer\n// =============================================================================\n\n// RenderContext contains all data needed to render a component page.\n// The layout function receives this context to build the final HTML.\ntype RenderContext struct {\n	// ComponentName is the template name being rendered\n	ComponentName string\n\n	// Props is the component props (for layout to access if needed)\n	Props interface{}\n\n	// ComponentHTML is the rendered component template output\n	ComponentHTML template.HTML\n\n	// Portals contains collected portal content to render at body end\n	Portals template.HTML\n\n	// Scripts contains the collected JS script tags\n	Scripts template.HTML\n\n	// Title is the page title (defaults to "{ComponentName} - BarefootJS")\n	Title string\n\n	// Heading is the page heading. Empty string means no heading.\n	Heading string\n\n	// Extra holds additional user-defined data for the layout\n	Extra map[string]interface{}\n}\n\n// LayoutFunc renders the final HTML page given the render context.\ntype LayoutFunc func(ctx *RenderContext) string\n\n// Renderer renders BarefootJS components with a customizable layout.\ntype Renderer struct {\n	templates *template.Template\n	layout    LayoutFunc\n}\n\n// NewRenderer creates a Renderer with the given templates and layout function.\n//\n// Example usage:\n//\n//	renderer := bf.NewRenderer(templates, func(ctx *bf.RenderContext) string {\n//	    return fmt.Sprintf(`<!DOCTYPE html>\n//	<html>\n//	<head><title>%s</title></head>\n//	<body>%s%s</body>\n//	</html>`, ctx.Title, ctx.ComponentHTML, ctx.Scripts)\n//	})\nfunc NewRenderer(tmpl *template.Template, layout LayoutFunc) *Renderer {\n	return &Renderer{\n		templates: tmpl,\n		layout:    layout,\n	}\n}\n\n// RenderOptions configures a single render call.\ntype RenderOptions struct {\n	// ComponentName is the template name to render (required)\n	ComponentName string\n\n	// Props is the component props (must be a pointer to struct with Scripts field)\n	Props interface{}\n\n	// Title is the page title. If empty, defaults to "{ComponentName} - BarefootJS"\n	Title string\n\n	// Heading is the page heading. If empty, no heading is shown.\n	Heading string\n\n	// Extra holds additional data to pass to the layout\n	Extra map[string]interface{}\n}\n\n// Render renders a component to a full HTML page using the configured layout.\n// Child component props are automatically detected (any slice field with ScopeID/Scripts).\n// renderTemplateErrorPanel formats a Go template execution error into a\n// fragment of HTML that\'s visible in the browser. The panel is\n// HTML-escaped so a faulty template name (anything from `template:\n// "..."`) can\'t smuggle markup back into the page. Keep the styling\n// inline so the panel surfaces even when the project\'s CSS hasn\'t\n// loaded yet (e.g. the failure aborted before the stylesheet links\n// emitted).\n//\n// Surfaced for the #1442 echo repro: a template referencing\n// `.Todo.Done` (instead of the range dot\'s `.Done`) used to fail\n// silently \u2014 Go\'s html/template aborted mid-stream, the partial body\n// flushed as a 200, and the user saw a truncated list with no console\n// signal. With this panel they get the template name, the error\n// message, and a "what to look at" hint inline.\nfunc renderTemplateErrorPanel(componentName string, err error) string {\n	return `<div style="margin:1em 0;padding:1em;border:2px solid #d33;background:#fff5f5;color:#900;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:13px;line-height:1.5"><strong style="display:block;margin-bottom:.5em">Template error in <code>` +\n		template.HTMLEscapeString(componentName) +\n		`</code></strong><pre style="margin:0;white-space:pre-wrap;word-break:break-word">` +\n		template.HTMLEscapeString(err.Error()) +\n		`</pre><div style="margin-top:.75em;font-size:12px;opacity:.7">Common cause: a JSX expression referenced a name the adapter could not resolve to a struct field. Open the matching <code>dist/templates/*.tmpl</code> for the unresolved reference, then fix the source component.</div></div>`\n}\n\n// renderComponentInto wires a component\'s props (script/portal collectors,\n// child-slot scope ids + hydration, root marking) against the PROVIDED\n// collectors and returns just the component\'s HTML \u2014 no layout. Both Render\n// (one fresh collector pair per page) and RenderFragment (a shared pair across\n// several islands) funnel through here so their wiring stays identical.\nfunc (r *Renderer) renderComponentInto(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	// Inject the shared collectors into the props.\n	setScriptsField(opts.Props, scriptCollector)\n	setPortalsField(opts.Props, portalCollector)\n\n	// Auto-detect and process child component props (slices)\n	childSlices := findChildComponentSlices(opts.Props)\n	for _, slice := range childSlices {\n		setScopeIDsOnSlice(slice)\n		setScriptsOnSlice(slice, scriptCollector)\n		setPortalsOnSlice(slice, portalCollector)\n		setBoolOnSlice(slice, "BfIsChild", true)\n	}\n\n	// Auto-detect and process single child component props\n	singleChildren := findSingleChildComponents(opts.Props)\n	for _, child := range singleChildren {\n		setScopeIDOnSingle(child)\n		setScriptsOnSingle(child, scriptCollector)\n		setPortalsOnSingle(child, portalCollector)\n		setBoolField(child, "BfIsChild", true)\n	}\n\n	// Mark the root component so BfPropsAttr emits bf-p only for it\n	setBoolField(opts.Props, "BfIsRoot", true)\n\n	// Render the component template.\n	//\n	// Errors here are NOT silently dropped. The original implementation\n	// ignored the return value of `ExecuteTemplate`, which masked a real\n	// onboarding failure mode: a template referencing a non-existent\n	// field (`.Todo.Done` instead of the range dot\'s `.Done`) caused\n	// html/template to abort mid-stream, the partial output got\n	// returned, and the HTTP server happily flushed a 200 with a\n	// truncated body. No error log, no signal \u2014 the user just saw a\n	// blank list (#1442 echo TodoApp repro).\n	//\n	// Now we capture the error and replace the partial output with a\n	// visible inline panel (dev mode) or a fenced error comment\n	// (production), so the cause is on-screen and grep-able in logs.\n	// Either way the renderer also writes to stderr so structured log\n	// aggregators see it.\n	var componentBuf strings.Builder\n	if err := r.templates.ExecuteTemplate(&componentBuf, opts.ComponentName, opts.Props); err != nil {\n		fmt.Fprintf(os.Stderr, "barefoot: template %q failed to render: %v\\n", opts.ComponentName, err)\n		// Preserve whatever the template did manage to emit before\n		// failing (Go\'s text/template flushes incrementally), but\n		// follow it with a clearly-marked error block so the user\n		// notices something is wrong instead of seeing a silent\n		// truncation.\n		componentBuf.WriteString(renderTemplateErrorPanel(opts.ComponentName, err))\n	}\n\n	return template.HTML(componentBuf.String())\n}\n\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// One script + portal collector pair for the whole page.\n	scriptCollector := NewScriptCollector()\n	portalCollector := NewPortalCollector()\n\n	componentHTML := r.renderComponentInto(opts, scriptCollector, portalCollector)\n\n	// Determine title (default: "{ComponentName} - BarefootJS")\n	title := opts.Title\n	if title == "" {\n		title = opts.ComponentName + " - BarefootJS"\n	}\n\n	// Heading (empty means no heading)\n	heading := opts.Heading\n\n	// Build render context\n	ctx := &RenderContext{\n		ComponentName: opts.ComponentName,\n		Props:         opts.Props,\n		ComponentHTML: componentHTML,\n		Portals:       portalCollector.Render(),\n		Scripts:       BfScripts(scriptCollector),\n		Title:         title,\n		Heading:       heading,\n		Extra:         opts.Extra,\n	}\n\n	return r.layout(ctx)\n}\n\n// RenderFragment renders a single island subtree into the caller-provided\n// script and portal collectors and returns just its HTML \u2014 no page layout.\n//\n// It exists for hand-authored "region shell" pages (the `@barefootjs/router`\n// showcase): a layout that places several independent islands \u2014 e.g. a header\n// ThemeToggle, an `<aside bf-region>` Sidebar, and a `<PageShell>` wrapping the\n// route content \u2014 must collect ALL their scripts and portals into ONE place so\n// the runtime (`barefoot.js`) and each island\'s client JS are emitted exactly\n// once and share a single reactive instance. Render each island with the same\n// collectors, splice the returned HTML into the shell, then emit\n// `BfScripts(sc)` and `pc.Render()` once at the end of the document.\n//\n// Each fragment is treated as its own root (it emits `bf-p` like any top-level\n// island); nested children declared in its props are wired as children, exactly\n// as in Render.\nfunc (r *Renderer) RenderFragment(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	return r.renderComponentInto(opts, scriptCollector, portalCollector)\n}\n\n// setScriptsField sets the Scripts field on a struct using reflection.\nfunc setScriptsField(v interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Scripts")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// setPortalsField sets the Portals field on a struct using reflection.\nfunc setPortalsField(v interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Portals")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// getStringField extracts a string field from a struct using reflection.\nfunc setBoolField(v interface{}, fieldName string, val bool) {\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Struct {\n		return\n	}\n	field := rv.FieldByName(fieldName)\n	if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n		field.SetBool(val)\n	}\n}\n\nfunc getBoolField(v interface{}, fieldName string) bool {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return false\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.Bool {\n		return false\n	}\n	return field.Bool()\n}\n\nfunc getStringField(v interface{}, fieldName string) string {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return ""\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.String {\n		return ""\n	}\n	return field.String()\n}\n\n// scopeIDChars is the alphabet for auto-generated ScopeID suffixes. It\n// mirrors the `randomID` helper the go-template adapter emits into the\n// generated New<Component>Props constructors so runtime-assigned and\n// constructor-assigned ids are indistinguishable.\nconst scopeIDChars = "abcdefghijklmnopqrstuvwxyz0123456789"\n\n// randomScopeSuffix returns a random lowercase-alphanumeric string of\n// length n. math/rand (auto-seeded since Go 1.20) is sufficient here: the\n// suffix only needs to be unique enough to keep a page\'s bf-s scope ids\n// from colliding, not cryptographically unpredictable.\nfunc randomScopeSuffix(n int) string {\n	b := make([]byte, n)\n	for i := range b {\n		b[i] = scopeIDChars[rand.Intn(len(scopeIDChars))]\n	}\n	return string(b)\n}\n\n// scopeIDPrefix derives the human-readable ScopeID prefix from a child\n// component\'s type, e.g. `TodoItemProps` \u2192 `TodoItem`. Matches the\n// `"<Component>_" + randomID(6)` shape the generated constructors use.\nfunc scopeIDPrefix(t reflect.Type) string {\n	for t.Kind() == reflect.Ptr {\n		t = t.Elem()\n	}\n	return strings.TrimSuffix(t.Name(), "Props")\n}\n\n// assignScopeID fills a child component\'s ScopeID with a generated id when\n// the caller left it empty, so application code doesn\'t have to mint scope\n// ids by hand (the parent\'s New<Component>Props constructor does the same\n// for components built through it). A non-empty ScopeID is left untouched,\n// so callers can still pin a stable id when they need one.\nfunc assignScopeID(structVal reflect.Value, prefix string) {\n	field := structVal.FieldByName("ScopeID")\n	if !field.IsValid() || !field.CanSet() || field.Kind() != reflect.String {\n		return\n	}\n	if field.String() != "" {\n		return\n	}\n	id := randomScopeSuffix(6)\n	if prefix != "" {\n		id = prefix + "_" + id\n	}\n	field.SetString(id)\n}\n\n// setScopeIDsOnSlice assigns a generated ScopeID to every child in a slice\n// whose ScopeID is empty.\nfunc setScopeIDsOnSlice(slice interface{}) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	prefix := scopeIDPrefix(v.Type().Elem())\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			assignScopeID(item, prefix)\n		}\n	}\n}\n\n// setScopeIDOnSingle assigns a generated ScopeID to a single child\n// component when its ScopeID is empty.\nfunc setScopeIDOnSingle(child interface{}) {\n	v := reflect.ValueOf(child)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return\n	}\n	assignScopeID(v, scopeIDPrefix(v.Type()))\n}\n\n// findChildComponentSlices finds slice fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findChildComponentSlices(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n		if field.Kind() != reflect.Slice || field.Len() == 0 {\n			continue\n		}\n\n		elem := field.Index(0)\n		if elem.Kind() == reflect.Ptr {\n			elem = elem.Elem()\n		}\n		if elem.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := elem.FieldByName("ScopeID").IsValid()\n		hasScripts := elem.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSlice sets Scripts on all items in a slice.\nfunc setScriptsOnSlice(slice interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Scripts")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// setBoolOnSlice sets a bool field on all items in a slice.\nfunc setBoolOnSlice(slice interface{}, fieldName string, val bool) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName(fieldName)\n			if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n				field.SetBool(val)\n			}\n		}\n	}\n}\n\n// setPortalsOnSlice sets Portals on all items in a slice.\nfunc setPortalsOnSlice(slice interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Portals")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		return ""\n	}\n}\n\n// =============================================================================\n// searchParams() \u2014 request-scoped environment signal (router v0.5, #1922)\n// =============================================================================\n\n// SearchParams is the SSR view of the request query string behind the\n// reactive searchParams() environment signal. The route handler builds it\n// from the request URL and assigns it to the component\'s SearchParams input\n// field; the generated template reads it via `.SearchParams.Get "key"`.\n//\n// The zero value is an empty query (url.Values.Get tolerates a nil map), so a\n// render with no request query \u2014 e.g. the adapter conformance harness, which\n// issues no query string \u2014 resolves every key to "", which the template\'s\n// `or`/`??` fallback turns into the author\'s default.\ntype SearchParams struct {\n	values url.Values\n}\n\n// NewSearchParams parses a raw query string (with or without a leading "?")\n// into a SearchParams. A malformed query yields an empty set rather than an\n// error, mirroring the browser\'s URLSearchParams, which never throws on junk.\n//\n// Typical handler use (net/http):\n//\n//	in := MyComponentInput{SearchParams: bf.NewSearchParams(r.URL.RawQuery)}\nfunc NewSearchParams(raw string) SearchParams {\n	raw = strings.TrimPrefix(raw, "?")\n	values, err := url.ParseQuery(raw)\n	if err != nil {\n		values = url.Values{}\n	}\n	return SearchParams{values: values}\n}\n\n// Get returns the first value associated with key, or "" when the key is\n// absent. This mirrors url.Values.Get, which also returns "" for a\n// present-but-empty value (`?sort=`). Safe on the zero value (nil map).\n//\n// This is not byte-for-byte URLSearchParams.get under the template\'s `??`\n// lowering. JS distinguishes absent (`null`) from present-but-empty (`""`):\n// `null ?? d` yields the default, but `"" ?? d` keeps the empty string. The\n// Go adapter lowers `??` to the `or` builtin \u2014 Go templates have no\n// null-coalescing operator \u2014 so here BOTH an absent key and a present-but-\n// empty value fall back to the author\'s default. The conformance fixture only\n// exercises the absent-key default, where the two runtimes agree; the\n// empty-string divergence is the same general `?? \u2192 or` limitation that\n// applies to any `x ?? default` the Go adapter lowers.\nfunc (s SearchParams) Get(key string) string {\n	return s.values.Get(key)\n}\n';
+    bfGoSource = '// Package bf provides runtime helper functions for BarefootJS Go templates.\n// These functions mirror JavaScript behavior for consistent SSR output.\npackage bf\n\nimport (\n	"bytes"\n	"encoding/json"\n	"fmt"\n	"html/template"\n	"math"\n	"math/rand"\n	"net/url"\n	"os"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode/utf8"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Arithmetic\n		"bf_add": Add,\n		"bf_sub": Sub,\n		"bf_mul": Mul,\n		"bf_div": Div,\n		"bf_mod": Mod,\n		"bf_neg": Neg,\n		"bf_min": Min,\n		"bf_max": Max,\n\n		// String\n		"bf_lower":       Lower,\n		"bf_upper":       Upper,\n		"bf_trim":        Trim,\n		"bf_contains":    Contains,\n		"bf_join":        Join,\n		"bf_split":       Split,\n		"bf_starts_with": StartsWith,\n		"bf_ends_with":   EndsWith,\n		"bf_replace":     Replace,\n		"bf_repeat":      Repeat,\n		"bf_pad_start":   PadStart,\n		"bf_pad_end":     PadEnd,\n		"bf_string":      String,\n\n		// URL query builder (#1897 PostList href helpers): conditional\n		// (include, key, value) triples \u2192 "base?k=v&\u2026", mirroring a\n		// URLSearchParams builder with guarded `.set()` calls.\n		"bf_query": Query,\n\n		// JSON / numeric primitives \u2014 JS-compat callees registered on\n		// the Go adapter\'s `templatePrimitives` map (#1188).\n		"bf_json":     JSON,\n		"bf_number":   Number,\n		"bf_floor":    Floor,\n		"bf_ceil":     Ceil,\n		"bf_round":    Round,\n		"bf_to_fixed": ToFixed,\n\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_flat":           Flat,\n		"bf_flat_dynamic":   FlatDynamicDepth,\n		"bf_flat_map":       FlatMap,\n		"bf_flat_map_tuple": FlatMapTuple,\n		"bf_first":          First,\n		"bf_last":           Last,\n		"bf_arr":            Arr,\n		"bf_filter_truthy":  FilterTruthy,\n\n		// Higher-order Array Methods\n		"bf_every":           Every,\n		"bf_some":            Some,\n		"bf_filter":          Filter,\n		"bf_find":            Find,\n		"bf_find_index":      FindIndex,\n		"bf_find_last":       FindLast,\n		"bf_find_last_index": FindLastIndex,\n		"bf_sort":            Sort,\n		"bf_reduce":          Reduce,\n\n		// Evaluator-driven higher-order folds (#2018): the comparator / reducer\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_sort / bf_reduce beyond their fixed catalogues. The\n		// adapter falls back to bf_sort for a comparator the evaluator can\'t\n		// model (e.g. localeCompare). `bf_env` builds the captured-free-var\n		// environment passed as the trailing base_env argument.\n		"bf_sort_eval":   SortEval,\n		"bf_reduce_eval": FoldEval,\n		"bf_env":         Env,\n\n		// Evaluator-driven higher-order predicates (#2018, P2): the predicate\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_filter / bf_find / bf_find_index / bf_every / bf_some\n		// beyond their field-equality / truthiness catalogues. `bf_find_eval` /\n		// `bf_find_index_eval` take a `forward` bool (false \u2192 findLast variants).\n		"bf_filter_eval":     FilterEval,\n		"bf_every_eval":      EveryEval,\n		"bf_some_eval":       SomeEval,\n		"bf_find_eval":       FindEval,\n		"bf_find_index_eval": FindIndexEval,\n		// `.flatMap(proj)`: project each element through the serialized\n		// projection body, then flatten one level.\n		"bf_flat_map_eval": FlatMapEval,\n		// Value-producing `.map(cb)` (#2073): project each element, one\n		// result per element (no flatten).\n		"bf_map_eval": MapEval,\n\n		// Comment marker (for hydration)\n		"bfComment":   Comment,\n		"bfTextStart": TextStart,\n		"bfTextEnd":   TextEnd,\n\n		// Script collection\n		"bfScripts": BfScripts,\n\n		// Scope attribute value (#1249: bare scope id, no `~` prefix)\n		"bfScopeAttr": ScopeAttr,\n\n		// Slot-identity markers (#1249): bf-h, bf-m, bf-r\n		"bfHydrationAttrs": HydrationAttrs,\n\n		// Child component marker (kept for backward compatibility)\n		"bfIsChild": IsChild,\n\n		// Props attribute for hydration\n		"bfPropsAttr": BfPropsAttr,\n\n		// Portal HTML rendering (parses and executes template string)\n		"bfPortalHTML": PortalHTML,\n\n		// JSX children passed to an imported child component (#1896):\n		// the parent renders the children fragment via a companion\n		// define (executed through bf_tmpl from TemplateFuncMap) and\n		// injects the result into the child\'s Children field.\n		"bf_with_children": WithChildren,\n\n		// Scope comment for fragment roots\n		"bfScopeComment": ScopeComment,\n\n		// JSX intrinsic-element spread lowering (#1407)\n		"bf_spread_attrs": SpreadAttrs,\n\n		// Destructure object-rest spread-onto-element residual (#2087):\n		// "every field except these" for a struct/map, keyed by json tag.\n		"bf_omit": Omit,\n\n		// Case-tolerant single-field read off a map or struct (#2087): a\n		// `useContext` local whose `createContext` default is object-shaped\n		// (e.g. `createContext<{ config: X }>({ config: {} })`) is typed\n		// `map[string]interface{}`, and its keys are the SOURCE (JS-cased)\n		// property names a `<Ctx.Provider value={{ \u2026 }}>` bakes\n		// (`providerObjectValueToGoMap`, go-template-adapter.ts) \u2014 plain\n		// `text/template` dot access does an exact-string `MapIndex`, so\n		// `ctx.config.label` lowers to nested `bf_get` calls instead of\n		// `.Ctx.Config.Label`. Reuses the same `getFieldValue` the\n		// project/sort helpers already use for a dynamic field-name lookup;\n		// safe on a nil map/interface (returns nil) so a missing Provider or\n		// an absent key falls through to `??`\'s fallback.\n		"bf_get": getFieldValue,\n	}\n}\n\n// Query builds a URL from a base path plus a query string assembled from\n// (include, key, value) triples, in order. A pair is considered only when its\n// `include` flag is true \u2014 mirroring a JS URLSearchParams builder whose\n// `.set(key, value)` calls are each guarded by an `if`. The compiler lowers a\n// conditional `cond ? v : undefined` to the `include` bool and a plain `key: v`\n// to a `true` include; the emptiness check is applied HERE (an included but\n// empty value is dropped), matching the client `queryHref` and the Perl `query`\n// helper. Keys and values use formEscape (application/x-www-form-urlencoded),\n// so the rendered query is byte-for-byte identical to the browser\'s\n// URLSearchParams. An empty query yields the bare base.\n//\n// A value may be a string slice ([]string or []any), which APPENDS one pair per\n// non-empty member (URLSearchParams.append) \u2014 `{tag: [a, b]}` \u2192 `tag=a&tag=b`.\n// A scalar value follows URLSearchParams.set() semantics: repeating a key\n// overwrites the value at the key\'s first position rather than duplicating it\n// (object literals have unique keys, so this is defensive). Trailing args that\n// don\'t complete a triple are ignored.\n//\n// formEscape differs from url.QueryEscape only on `~` (kept by QueryEscape,\n// `%7E` here) and `*` (`%2A` by QueryEscape, kept here).\nfunc Query(base string, triples ...any) string {\n	type kv struct{ key, val string }\n	pairs := make([]kv, 0, len(triples)/3)\n	pos := make(map[string]int)\n	for i := 0; i+2 < len(triples); i += 3 {\n		include, _ := triples[i].(bool)\n		if !include {\n			continue\n		}\n		k := String(triples[i+1])\n		if members, ok := asStringSlice(triples[i+2]); ok {\n			// Array value \u2192 append each non-empty member; appended pairs never\n			// overwrite, so they don\'t participate in the set()-position map.\n			for _, m := range members {\n				if m == "" {\n					continue\n				}\n				pairs = append(pairs, kv{k, m})\n			}\n			continue\n		}\n		v := String(triples[i+2])\n		if v == "" {\n			continue // omit an included-but-empty value (client / Perl parity)\n		}\n		if at, ok := pos[k]; ok {\n			pairs[at].val = v // set(): overwrite the first occurrence\'s value\n		} else {\n			pos[k] = len(pairs)\n			pairs = append(pairs, kv{k, v})\n		}\n	}\n	var b strings.Builder\n	for _, p := range pairs {\n		if b.Len() == 0 {\n			b.WriteByte(\'?\')\n		} else {\n			b.WriteByte(\'&\')\n		}\n		b.WriteString(formEscape(p.key))\n		b.WriteByte(\'=\')\n		b.WriteString(formEscape(p.val))\n	}\n	return base + b.String()\n}\n\n// asStringSlice reports whether v is a query *array* value and, if so, returns\n// its members stringified. A compiled template passes a `[]string` field; the\n// golden conformance vectors decode JSON arrays to `[]any`. Anything else is a\n// scalar (false), handled by the set() path.\nfunc asStringSlice(v any) ([]string, bool) {\n	switch s := v.(type) {\n	case []string:\n		return s, true\n	case []any:\n		out := make([]string, len(s))\n		for i, m := range s {\n			out[i] = String(m)\n		}\n		return out, true\n	default:\n		return nil, false\n	}\n}\n\nconst hexUpper = "0123456789ABCDEF"\n\n// formEscape percent-encodes s with the application/x-www-form-urlencoded byte\n// set, matching the browser\'s URLSearchParams serialization (and the Perl\n// `query` helper) so SSR query strings render byte-for-byte identically across\n// adapters. The unreserved set kept verbatim is A-Z a-z 0-9 and `* - . _`; a\n// space becomes `+`; every other byte is `%XX` with uppercase hex. Encoding is\n// byte-wise, so multi-byte UTF-8 is percent-encoded per byte (`\xE9` \u2192 `%C3%A9`).\n//\n// This differs from url.QueryEscape only for `~` (kept by QueryEscape, encoded\n// to `%7E` here) and `*` (encoded to `%2A` by QueryEscape, kept here).\nfunc formEscape(s string) string {\n	var b strings.Builder\n	for i := 0; i < len(s); i++ {\n		c := s[i]\n		switch {\n		case c >= \'A\' && c <= \'Z\', c >= \'a\' && c <= \'z\', c >= \'0\' && c <= \'9\',\n			c == \'*\', c == \'-\', c == \'.\', c == \'_\':\n			b.WriteByte(c)\n		case c == \' \':\n			b.WriteByte(\'+\')\n		default:\n			b.WriteByte(\'%\')\n			b.WriteByte(hexUpper[c>>4])\n			b.WriteByte(hexUpper[c&0x0F])\n		}\n	}\n	return b.String()\n}\n\n// ScopeAttr returns the bare bf-s scope id (#1249).\nfunc ScopeAttr(props interface{}) string {\n	return getStringField(props, "ScopeID")\n}\n\n// HydrationAttrs emits `bf-h="<host>" bf-m="<slot>" bf-r=""` conditionally.\n// See spec/compiler.md "Slot identity".\nfunc HydrationAttrs(props interface{}) template.HTMLAttr {\n	parts := []string{}\n	if host := getStringField(props, "BfParent"); host != "" {\n		parts = append(parts, fmt.Sprintf(`bf-h="%s"`, template.HTMLEscapeString(host)))\n	}\n	if mount := getStringField(props, "BfMount"); mount != "" {\n		parts = append(parts, fmt.Sprintf(`bf-m="%s"`, template.HTMLEscapeString(mount)))\n	}\n	if !getBoolField(props, "BfIsChild") {\n		parts = append(parts, `bf-r=""`)\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// IsChild is a deprecated no-op stub. Child status is signalled by bf-h\n// presence (#1249); use HydrationAttrs instead.\nfunc IsChild(props interface{}) template.HTMLAttr {\n	return ""\n}\n\n// svgCamelCaseAttrs mirrors SVG_CAMEL_CASE_ATTRS from\n// packages/client/src/runtime/spread-attrs.ts. SVG XML attribute\n// names are case-sensitive; the default camelCase \u2192 kebab-case\n// rewrite must NOT apply to these or the SVG stops rendering\n// (#1407). Coordinates with the compile-time SVG_CAMEL_TO_KEBAB\n// table in packages/jsx/src/ir-to-client-js/utils.ts: presentation\n// attrs (clipPath, strokeWidth, \u2026) live there and must NOT appear\n// here, or the same JSX prop would lower to clip-path via the\n// explicit-attr path and stay clipPath via the spread path.\nvar svgCamelCaseAttrs = map[string]struct{}{\n	"allowReorder": {}, "attributeName": {}, "attributeType": {}, "autoReverse": {},\n	"baseFrequency": {}, "baseProfile": {}, "calcMode": {}, "clipPathUnits": {},\n	"contentScriptType": {}, "contentStyleType": {}, "diffuseConstant": {}, "edgeMode": {},\n	"externalResourcesRequired": {}, "filterRes": {}, "filterUnits": {}, "glyphRef": {},\n	"gradientTransform": {}, "gradientUnits": {}, "kernelMatrix": {}, "kernelUnitLength": {},\n	"keyPoints": {}, "keySplines": {}, "keyTimes": {}, "lengthAdjust": {}, "limitingConeAngle": {},\n	"markerHeight": {}, "markerUnits": {}, "markerWidth": {}, "maskContentUnits": {},\n	"maskUnits": {}, "numOctaves": {}, "pathLength": {}, "patternContentUnits": {},\n	"patternTransform": {}, "patternUnits": {}, "pointsAtX": {}, "pointsAtY": {}, "pointsAtZ": {},\n	"preserveAlpha": {}, "preserveAspectRatio": {}, "primitiveUnits": {}, "refX": {}, "refY": {},\n	"repeatCount": {}, "repeatDur": {}, "requiredExtensions": {}, "requiredFeatures": {},\n	"specularConstant": {}, "specularExponent": {}, "spreadMethod": {}, "startOffset": {},\n	"stdDeviation": {}, "stitchTiles": {}, "surfaceScale": {}, "systemLanguage": {},\n	"tableValues": {}, "targetX": {}, "targetY": {}, "textLength": {}, "viewBox": {}, "viewTarget": {},\n	"xChannelSelector": {}, "yChannelSelector": {}, "zoomAndPan": {},\n}\n\n// toAttrName mirrors the JSX\u2192HTML attribute-name rewrite from\n// packages/client/src/runtime/spread-attrs.ts. className \u2192 class,\n// htmlFor \u2192 for, SVG camelCase attrs preserved, other camelCase\n// keys lowered to kebab-case.\nfunc toAttrName(key string) string {\n	if key == "className" {\n		return "class"\n	}\n	if key == "htmlFor" {\n		return "for"\n	}\n	if _, ok := svgCamelCaseAttrs[key]; ok {\n		return key\n	}\n	// camelCase \u2192 kebab-case: mirror the JS reference exactly\n	// (`key.replace(/([A-Z])/g, \'-$1\').toLowerCase()`). The JS shape\n	// produces a leading `-` for an initial uppercase letter\n	// (`XData` \u2192 `-x-data`); both this Go path and the matching JS\n	// runtime are wrong-by-construction for that case (the resulting\n	// HTML attribute name is invalid), but keeping them byte-equal\n	// avoids silent SSR/CSR divergence (#1411 review).\n	var b strings.Builder\n	for _, r := range key {\n		if r >= \'A\' && r <= \'Z\' {\n			b.WriteByte(\'-\')\n			b.WriteRune(r + 32)\n		} else {\n			b.WriteRune(r)\n		}\n	}\n	return b.String()\n}\n\n// StyleToCss mirrors styleToCss from\n// packages/client/src/runtime/style.ts. Accepts a string passthrough,\n// or a map (JSON-deserialized object) whose camelCase keys are\n// lowered to kebab-case and joined with `;`. Returns ("", false) for\n// nullish/empty input so callers can omit the attribute entirely.\nfunc StyleToCss(v any) (string, bool) {\n	if v == nil {\n		return "", false\n	}\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return "", false\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		// Non-object: stringify and return as-is, matching the JS\n		// `typeof value !== \'object\'` branch.\n		s := fmt.Sprint(v)\n		if s == "" {\n			return "", false\n		}\n		return s, true\n	}\n	keys := rv.MapKeys()\n	sorted := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sorted = append(sorted, k.String())\n		}\n	}\n	sort.Strings(sorted)\n	parts := make([]string, 0, len(sorted))\n	for _, k := range sorted {\n		val := rv.MapIndex(reflect.ValueOf(k))\n		// Skip nil entries (matches the JS `if (v == null) continue`).\n		if !val.IsValid() {\n			continue\n		}\n		if val.Kind() == reflect.Interface || val.Kind() == reflect.Pointer {\n			if val.IsNil() {\n				continue\n			}\n			val = val.Elem()\n		}\n		prop := toAttrName(k)\n		parts = append(parts, fmt.Sprintf("%s:%v", prop, val.Interface()))\n	}\n	if len(parts) == 0 {\n		return "", false\n	}\n	return strings.Join(parts, ";"), true\n}\n\n// SpreadAttrs lowers a JSX intrinsic-element spread bag (#1407) to\n// an HTML attribute string. Mirrors spreadAttrs from\n// packages/client/src/runtime/spread-attrs.ts so SSR output matches\n// what CSR\'s `applyRestAttrs` writes at hydration.\n//\n// Skip rules: nil/false values, event handlers (`on[A-Z]*`),\n// `children`, `ref`.\n//\n// Key remap: className \u2192 class, htmlFor \u2192 for, SVG camelCase\n// preserved, other camelCase \u2192 kebab-case.\n//\n// `style` is routed through StyleToCss so object literals serialize\n// to a real CSS string instead of Go\'s default `map[k:v]` form.\n//\n// Booleans: true \u2192 bare attribute name, false \u2192 omitted.\n// Other scalar values are HTML-escaped via template.HTMLEscapeString.\n// Returns a `template.HTMLAttr` so html/template emits the result\n// verbatim (the function does its own escaping).\n//\n// Keys are sorted alphabetically before emission for deterministic\n// output. SSR/CSR attribute-order divergence is acceptable per the\n// rest-destructure-object-spread-in-map fixture\'s documented policy\n// \u2014 browsers honor the LAST value when a key is duplicated, so\n// pairing with static attrs (`<div class="x" {...rest}>`) is\n// last-wins regardless of order.\nfunc SpreadAttrs(bag any) template.HTMLAttr {\n	if bag == nil {\n		return ""\n	}\n	rv := reflect.ValueOf(bag)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return ""\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		return ""\n	}\n	keys := rv.MapKeys()\n	sortedKeys := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sortedKeys = append(sortedKeys, k.String())\n		}\n	}\n	sort.Strings(sortedKeys)\n	parts := make([]string, 0, len(sortedKeys))\n	for _, key := range sortedKeys {\n		// Event handlers \u2014 skip at SSR the same way\n		// packages/client/src/runtime/spread-attrs.ts does at\n		// hydration. The JS predicate is\n		// `key.startsWith(\'on\') && key.length > 2 && key[2] === key[2].toUpperCase()`,\n		// which is true for any character whose uppercase form is\n		// itself: ASCII A-Z, digits, underscore, and non-letter\n		// symbols. Mirror that here by skipping when key[2] is NOT\n		// a lowercase ASCII letter \u2014 so `onClick`, `on_custom`, and\n		// `on0` all match (#1411 review).\n		if len(key) > 2 && key[0] == \'o\' && key[1] == \'n\' && !(key[2] >= \'a\' && key[2] <= \'z\') {\n			continue\n		}\n		// `children` is a JSX construct rendered inside the element,\n		// never a DOM attribute. `ref` is intentionally NOT filtered\n		// here so output stays byte-equal with the JS reference\n		// `spreadAttrs` in packages/client/src/runtime/spread-attrs.ts\n		// (which only filters null/false, event handlers, and\n		// children) \u2014 aligning Go\'s filter set diverges from JS in\n		// the opposite direction. Filtering `ref` consistently across\n		// both SSR runtimes is a separate concern tracked alongside\n		// the JS `applyRestAttrs` vs `spreadAttrs` mismatch (#1411\n		// review).\n		if key == "children" {\n			continue\n		}\n		val := rv.MapIndex(reflect.ValueOf(key))\n		if !val.IsValid() {\n			continue\n		}\n		// Unwrap interface wrappers (json.Unmarshal produces\n		// interface{}-wrapped values for map[string]any).\n		v := val\n		for v.Kind() == reflect.Interface || v.Kind() == reflect.Pointer {\n			if v.IsNil() {\n				// Skip null entries.\n				v = reflect.Value{}\n				break\n			}\n			v = v.Elem()\n		}\n		if !v.IsValid() {\n			continue\n		}\n		// Boolean values: true \u2192 bare attribute, false \u2192 omitted.\n		if v.Kind() == reflect.Bool {\n			if !v.Bool() {\n				continue\n			}\n			parts = append(parts, toAttrName(key))\n			continue\n		}\n		// `style` routes through StyleToCss so object literals get a\n		// real CSS string. The JS side does the same.\n		if key == "style" {\n			css, ok := StyleToCss(v.Interface())\n			if !ok {\n				continue\n			}\n			parts = append(parts, fmt.Sprintf(`style="%s"`, template.HTMLEscapeString(css)))\n			continue\n		}\n		// Stringify and escape. fmt.Sprint handles numbers, bools-as-\n		// strings, and arbitrary stringer types the same way the JS\n		// `String(value)` coercion does for the analogous cases.\n		s := fmt.Sprint(v.Interface())\n		parts = append(parts, fmt.Sprintf(`%s="%s"`, toAttrName(key), template.HTMLEscapeString(s)))\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// Omit builds a `map[string]any` residual bag from a struct or map value,\n// excluding the given keys \u2014 powers the `{...rest}` spread-onto-element\n// lowering for a destructured `.map()` loop-item\'s object-rest binding\n// (#2087): `.map(({ id, title, ...rest }) => <li {...rest}>)` needs "every\n// field EXCEPT the ones the pattern already destructured out", and a static\n// Go struct type has no way to express "minus a field" \u2014 the exclude set is\n// known at COMPILE TIME (the sibling keys the destructure pattern names), so\n// the compiler passes them here and this does the per-item field-vs-key\n// matching a static type can\'t. The result feeds `bf_spread_attrs`\n// (`SpreadAttrs`), same as a top-level `{...attrs()}` bag.\n//\n// Struct receiver: iterates exported fields via reflection, keyed by each\n// field\'s `json` struct tag (falling back to the Go field name when absent)\n// \u2014 the generated struct\'s json tag is always the ORIGINAL source property\n// name (see `structFieldsFor` / `typeDefinitionToGo` in the Go adapter), so\n// this reproduces the exact JS key `SpreadAttrs`\'s `toAttrName` expects\n// (`"data-priority"`, not a re-derived `"DataPriority"`). A tag of `"-"`\n// (opt-out) is skipped like `encoding/json` does.\n//\n// Map receiver: copies string keys through directly, same exclude/skip\n// rules.\n//\n// Anything else (nil, a non-struct/non-map interface) returns an empty map.\nfunc Omit(item any, excludeKeys ...string) map[string]any {\n	exclude := make(map[string]struct{}, len(excludeKeys))\n	for _, k := range excludeKeys {\n		exclude[k] = struct{}{}\n	}\n	out := map[string]any{}\n	rv := reflect.ValueOf(item)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return out\n		}\n		rv = rv.Elem()\n	}\n	switch rv.Kind() {\n	case reflect.Struct:\n		rt := rv.Type()\n		for i := 0; i < rt.NumField(); i++ {\n			field := rt.Field(i)\n			if !field.IsExported() {\n				continue\n			}\n			key := field.Name\n			if tag, ok := field.Tag.Lookup("json"); ok {\n				if comma := strings.Index(tag, ","); comma >= 0 {\n					tag = tag[:comma]\n				}\n				if tag == "-" {\n					continue\n				}\n				if tag != "" {\n					key = tag\n				}\n			}\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			out[key] = rv.Field(i).Interface()\n		}\n	case reflect.Map:\n		for _, k := range rv.MapKeys() {\n			if k.Kind() != reflect.String {\n				continue\n			}\n			key := k.String()\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			val := rv.MapIndex(k)\n			if val.IsValid() {\n				out[key] = val.Interface()\n			}\n		}\n	}\n	return out\n}\n\n// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Min returns the smaller of a and b (two-arg `Math.min`). Like Mul, it keeps\n// an integer result when both operands are int-like so a CSS value such as\n// `bf_min 100 x` stays `100` rather than `100.000000`.\nfunc Min(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	r := av\n	if bv < av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Max returns the larger of a and b (two-arg `Math.max`), with the same\n// int-preserving rule as Min.\nfunc Max(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	r := av\n	if bv > av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Split lowers `String.prototype.split(sep, limit?)` (#1448 Tier B). It\n// wraps `strings.Split` and normalises the result to `[]any` so the\n// slice composes with the array-method surface downstream (`bf_join`,\n// range loops, `bf_len`, \u2026) the same way `bf_slice` / `bf_reverse`\n// results do. Like JS, an empty separator splits into individual UTF-8\n// characters and trailing empty fields are preserved (`"a,".split(",")`\n// \u2192 `["a", ""]`). An optional `limit` caps the number of returned\n// pieces (`"a,b,c".split(",", 2)` \u2192 `["a", "b"]`); a negative limit is\n// ignored (JS would also return every piece \u2014 its ToUint32 wrap makes\n// the limit effectively unbounded). The no-separator form is handled by\n// the adapter (it emits `bf_arr` for the whole-string single element).\nfunc Split(s, sep string, limit ...int) []any {\n	parts := strings.Split(s, sep)\n	if len(limit) > 0 && limit[0] >= 0 && limit[0] < len(parts) {\n		parts = parts[:limit[0]]\n	}\n	out := make([]any, len(parts))\n	for i, p := range parts {\n		out[i] = p\n	}\n	return out\n}\n\n// StartsWith lowers `String.prototype.startsWith(prefix, position?)`\n// (#1448 Tier B). Wraps `strings.HasPrefix`; an empty prefix is always\n// true (JS parity). The optional `position` re-anchors the test to start\n// at that index (clamped to `[0, len]` so it never panics), matching JS\n// `"abc".startsWith("b", 1) === true`.\nfunc StartsWith(s, prefix string, position ...int) bool {\n	if len(position) > 0 {\n		p := position[0]\n		if p < 0 {\n			p = 0\n		}\n		if p > len(s) {\n			p = len(s)\n		}\n		s = s[p:]\n	}\n	return strings.HasPrefix(s, prefix)\n}\n\n// EndsWith lowers `String.prototype.endsWith(suffix, endPosition?)`\n// (#1448 Tier B). Wraps `strings.HasSuffix`; an empty suffix is always\n// true (JS parity). The optional `endPosition` treats the string as if\n// it were only that many bytes long (clamped to `[0, len]`), matching JS\n// `"abc".endsWith("b", 2) === true`.\nfunc EndsWith(s, suffix string, endPosition ...int) bool {\n	if len(endPosition) > 0 {\n		e := endPosition[0]\n		if e < 0 {\n			e = 0\n		}\n		if e > len(s) {\n			e = len(s)\n		}\n		s = s[:e]\n	}\n	return strings.HasSuffix(s, suffix)\n}\n\n// Replace lowers the string-pattern form of `String.prototype.replace`\n// (#1448 Tier B). JS replaces only the FIRST occurrence for a string\n// pattern, so the count is 1 (`strings.Replace` with n=1; n<0 would\n// replace all \u2014 that\'s `.replaceAll`, still refused). The replacement\n// is treated literally: unlike JS, special replacement patterns like\n// `$&` / `$1` are NOT interpreted (Go and Perl agree on literal\n// replacement, keeping the two template adapters byte-equal; this\n// diverges from the Hono/CSR JS path only for replacement strings that\n// contain `$`-patterns, which are rare in template position).\nfunc Replace(s, old, new string) string {\n	return strings.Replace(s, old, new, 1)\n}\n\n// Repeat lowers `String.prototype.repeat(n)` (#1448 Tier B): the\n// receiver concatenated n times. JS throws RangeError for a negative\n// count and `strings.Repeat` panics, so a negative count clamps to the\n// empty string \u2014 SSR templates degrade rather than crash the render.\n// A zero count is the empty string (JS parity).\nfunc Repeat(s string, n int) string {\n	if n <= 0 {\n		return ""\n	}\n	return strings.Repeat(s, n)\n}\n\n// padTo lowers the shared body of `String.prototype.padStart` /\n// `padEnd` (#1448 Tier B): pad `s` to `target` code points using `pad`\n// repeated and truncated to fill, prepended (atStart) or appended.\n// Length is measured in runes (not bytes) so the result matches the\n// Perl `bf->pad_*` helpers \u2014 this diverges from JS\'s UTF-16-unit length\n// only for astral-plane input. An empty pad, or a receiver already at\n// least `target` long, returns `s` unchanged (JS parity).\nfunc padTo(s string, target int, pad string, atStart bool) string {\n	if pad == "" {\n		return s\n	}\n	sLen := utf8.RuneCountInString(s)\n	if sLen >= target {\n		return s\n	}\n	need := target - sLen\n	padRunes := []rune(pad)\n	fill := make([]rune, 0, need)\n	for len(fill) < need {\n		for _, r := range padRunes {\n			if len(fill) >= need {\n				break\n			}\n			fill = append(fill, r)\n		}\n	}\n	if atStart {\n		return string(fill) + s\n	}\n	return s + string(fill)\n}\n\n// PadStart lowers `String.prototype.padStart(target, pad?)` (#1448 Tier\n// B). The pad string defaults to a single space when omitted.\nfunc PadStart(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, true)\n}\n\n// PadEnd lowers `String.prototype.padEnd(target, pad?)` (#1448 Tier B).\nfunc PadEnd(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, false)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// String returns the string form of v. Mirrors JS `String(v)` for\n// non-nil values via `fmt.Sprintf("%v", ...)`. Diverges from JS on\n// nil: JS `String(null)` is "null", but the template path renders\n// `nil` as the empty string here so an unset prop doesn\'t surface\n// as a literal "null"/"undefined" in user-facing HTML. Document the\n// divergence explicitly so callers don\'t rely on JS-exact parity.\nfunc String(v any) string {\n	if v == nil {\n		return ""\n	}\n	return fmt.Sprintf("%v", v)\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// ToFixed formats v with exactly `digits` decimal places, mirroring JS\n// `Number.prototype.toFixed` (zero-padding + half-toward-+Infinity\n// rounding). JS rounds the scaled integer half up (`(2.5).toFixed(0)`\n// is "3"); bare `fmt.Sprintf("%.*f")` rounds half-to-even ("2"), so we\n// scale, round with `Floor(x + 0.5)` (matching `Round`), then format\n// the exact multiple. #1897.\nfunc ToFixed(v any, digits int) string {\n	if digits < 0 {\n		digits = 0\n	}\n	n := Number(v)\n	// JS toFixed returns the strings "NaN" / "Infinity" / "-Infinity" for\n	// non-finite inputs; fmt would render "NaN"/"+Inf"/"-Inf".\n	if math.IsNaN(n) {\n		return "NaN"\n	}\n	if math.IsInf(n, 1) {\n		return "Infinity"\n	}\n	if math.IsInf(n, -1) {\n		return "-Infinity"\n	}\n	factor := math.Pow(10, float64(digits))\n	rounded := math.Floor(n*factor + 0.5)\n	return fmt.Sprintf("%.*f", digits, rounded/factor)\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  SameValueZero element search (matches\n//     the evaluator\'s `evalSameValueZero`/`evalIncludes` in eval.go,\n//     which back the serialized-callback path) \u2014 numeric types compare\n//     by value across int/float64 the way JS\'s single "number" type\n//     does, and NaN matches NaN (unlike `===`). This used to be\n//     `reflect.DeepEqual`, which is type-strict (`int(2)` != `float64(2)`)\n//     and never matches NaN to NaN; that diverged from the evaluator\'s\n//     `.includes` and from JS itself, so it was unified here.\n//   - string receiver:       strings.Contains substring search\n//\n// Anything else returns false (matches the JS semantic where\n// `.includes` is only defined on Array / TypedArray / String).\nfunc Includes(recv any, elem any) bool {\n	v := reflect.ValueOf(recv)\n	if v.Kind() == reflect.String {\n		// JS `String.prototype.includes` accepts only string args;\n		// non-string `elem` would TypeError in real JS but our\n		// callers have lowered through `convertExpressionToGo`\n		// where the arg type is whatever the template binds. Stringify\n		// via fmt to keep the helper total.\n		needle, ok := elem.(string)\n		if !ok {\n			needle = fmt.Sprintf("%v", elem)\n		}\n		return strings.Contains(v.String(), needle)\n	}\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if evalSameValueZero(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A). The variadic\n// `end` arg lets Go template\'s call dispatcher pass either 2 or 3\n// arguments; an absent end means "to length".\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\n//   - start >= end       \u2192 empty slice (no panic)\n//\n// Non-array receivers return an empty `[]any`.\nfunc Slice(items any, start int, end ...int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n\n	// Normalise start (negative = from end).\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	// Normalise end (optional; absent = length).\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n\n	if start >= stop {\n		return []any{}\n	}\n\n	out := make([]any, 0, stop-start)\n	for i := start; i < stop; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// Flat flattens nested slices/arrays `depth` levels deep. Lowers\n// `Array.prototype.flat(depth?)` (#1448 Tier C). A `depth` of `-1` is the\n// `Infinity` sentinel (flatten fully); `0` (or negative-from-JS, already\n// normalised to 0 at compile time) returns a shallow copy. Non-array\n// elements are kept as-is (JS only flattens nested arrays). A non-array\n// receiver returns an empty `[]any`.\nfunc Flat(items any, depth int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		ev := reflect.ValueOf(el)\n		if depth != 0 && (ev.Kind() == reflect.Slice || ev.Kind() == reflect.Array) {\n			// `-1` (Infinity) recurses unbounded; a finite depth spends one level.\n			next := depth\n			if depth > 0 {\n				next = depth - 1\n			}\n			out = append(out, Flat(el, next)...)\n		} else {\n			out = append(out, el)\n		}\n	}\n	return out\n}\n\n// FlatDynamicDepth coerces `depth` via JS\'s `ToIntegerOrInfinity` and\n// flattens `items` that many levels. Lowers a DYNAMIC `.flat(depth)`\n// (#2094) \u2014 one whose depth isn\'t a compile-time literal, so (unlike\n// `Flat` above) the coercion happens here at render time instead of in the\n// parser.\n//\n// This is a SEPARATE helper from `Flat`/`bf_flat` \u2014 NOT a drop-in\n// replacement \u2014 because `Flat`\'s `depth int` parameter treats `-1` as a\n// compile-time SENTINEL meaning "flatten fully" (the parser\'s own\n// normalisation of a literal `Infinity`). A genuinely dynamic depth value\n// of `-1` means the JS-correct OPPOSITE: `Array.prototype.flat(-1)` never\n// recurses (same as `.flat(0)`, a shallow copy), because\n// `FlattenIntoArray` only recurses when `depth > 0`. Reusing `Flat`\'s int\n// contract for a raw dynamic value would silently invert that case, so\n// this function coerces FIRST \u2014 mapping a real `+Infinity` / huge finite\n// value to `Flat`\'s own `-1` sentinel, and a real negative value to `0` \u2014\n// and only then delegates to `Flat`\'s recursion.\n//\n// Coercion rules (JS `ToIntegerOrInfinity`, mirrored exactly; pinned by the\n// `flat_dynamic` golden-vector cases in\n// packages/adapter-tests/vectors/cases.ts):\n//   - the value converts via `ToNumber` first (numeric string / bool /\n//     number all coerce; see `flatDepthToFloat`);\n//   - a NaN result (including a non-numeric string) \u2192 `0`;\n//   - truncates toward zero (`2.7` \u2192 `2`);\n//   - negative \u2192 `0`;\n//   - `+Infinity` / a huge finite value \u2192 flattens fully.\nfunc FlatDynamicDepth(items any, depth any) []any {\n	return Flat(items, coerceFlatDepth(depth))\n}\n\n// coerceFlatDepth implements JS\'s `ToIntegerOrInfinity` for a dynamic\n// `.flat(depth)` argument, returning an int in `Flat`\'s own contract (`-1`\n// = unbounded, `>= 0` = that many levels).\nfunc coerceFlatDepth(depth any) int {\n	f, ok := flatDepthToFloat(depth)\n	if !ok || math.IsNaN(f) {\n		return 0\n	}\n	if math.IsInf(f, 1) {\n		return -1 // Flat\'s "flatten fully" sentinel\n	}\n	if math.IsInf(f, -1) {\n		return 0\n	}\n	trunc := math.Trunc(f)\n	if trunc < 0 {\n		return 0\n	}\n	// A huge finite depth behaves identically to "flatten fully" in\n	// practice \u2014 real data bottoms out at its actual nesting depth long\n	// before a counter this large would ever reach zero. Capping it here\n	// avoids an absurd countdown without needing a second sentinel.\n	if trunc > 1_000_000 {\n		return -1\n	}\n	return int(trunc)\n}\n\n// flatDepthToFloat converts a dynamic `.flat(depth)` argument to a float64,\n// mirroring JS\'s `ToNumber` across the value shapes a Go template data\n// model can carry (every numeric kind, bool, numeric string). `ok` is\n// false for a shape `ToNumber` can\'t coerce meaningfully (`nil`, or a\n// non-numeric string) \u2014 `coerceFlatDepth` treats that the same as NaN\n// (\u2192 depth `0`), matching JS.\nfunc flatDepthToFloat(v any) (float64, bool) {\n	switch n := v.(type) {\n	case nil:\n		return 0, false\n	case float64:\n		return n, true\n	case float32:\n		return float64(n), true\n	case int:\n		return float64(n), true\n	case int8:\n		return float64(n), true\n	case int16:\n		return float64(n), true\n	case int32:\n		return float64(n), true\n	case int64:\n		return float64(n), true\n	case uint:\n		return float64(n), true\n	case uint8:\n		return float64(n), true\n	case uint16:\n		return float64(n), true\n	case uint32:\n		return float64(n), true\n	case uint64:\n		return float64(n), true\n	case bool:\n		if n {\n			return 1, true\n		}\n		return 0, true\n	case string:\n		s := strings.TrimSpace(n)\n		if s == "" {\n			return 0, true // JS: Number("") is 0\n		}\n		f, err := strconv.ParseFloat(s, 64)\n		if err != nil {\n			return 0, false // not numeric \u2192 NaN path\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// FlatMap projects each element through a `self` / `field` projection and\n// flattens the result one level. Lowers value-returning\n// `Array.prototype.flatMap(fn)` for the field-projection catalogue\n// (#1448 Tier C): `items.flatMap(i => i)` (self) and\n// `items.flatMap(i => i.field)` (field). A projected non-array value is\n// kept as-is (flatMap = map + flat(1)). Non-array receiver \u2192 empty.\nfunc FlatMap(items any, keyKind, keyName string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	projected := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		if keyKind == "field" {\n			projected = append(projected, getFieldValue(el, keyName))\n		} else {\n			projected = append(projected, el)\n		}\n	}\n	return Flat(projected, 1)\n}\n\n// FlatMapTuple lowers an array-literal flatMap projection\n// `items.flatMap(i => [i.a, i.b])` (#1448 Tier C). `specs` is a flat list\n// of (kind, name) pairs, one per array-literal leaf: ("self", "") for the\n// item itself, ("field", "<Name>") for a struct field. For each item it\n// appends every leaf\'s value in order. Unlike the scalar `FlatMap`, the\n// per-item array is flattened only one level (flat(1) removes the literal\n// wrapper), so an array-valued leaf is appended verbatim rather than\n// spread \u2014 which is exactly "append each leaf". Non-array receiver \u2192 empty.\nfunc FlatMapTuple(items any, specs ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		for j := 0; j+1 < len(specs); j += 2 {\n			if specs[j] == "field" {\n				out = append(out, getFieldValue(el, specs[j+1]))\n			} else {\n				out = append(out, el)\n			}\n		}\n	}\n	return out\n}\n\n// First returns the first element of a slice, or nil if empty.\nfunc First(items any) any {\n	return At(items, 0)\n}\n\n// Last returns the last element of a slice, or nil if empty.\nfunc Last(items any) any {\n	return At(items, -1)\n}\n\n// Arr builds an []any from variadic args. Used to lower JS array\n// literals like `[a, b]` for the registry Slot\'s\n// `[className, childClass].filter(Boolean).join(\' \')` shape (#1443) \u2014\n// Go templates have no array-literal syntax, so the codegen routes\n// array-literal IR nodes through this helper.\nfunc Arr(items ...any) []any {\n	return items\n}\n\n// FilterTruthy returns a new slice containing only truthy items.\n// Mirrors `arr.filter(Boolean)` semantics: drop nil, false, 0, "" \u2014 the\n// same falsy set JavaScript\'s `Boolean(x)` recognises. Used to lower\n// the registry Slot\'s class-merge pattern (#1443); generalising to\n// arbitrary callable predicates would need the callee-resolution path\n// blocked by #1389, so this stays Boolean-specific.\nfunc FilterTruthy(items any) []any {\n	v := reflect.ValueOf(items)\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	result := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		raw := v.Index(i).Interface()\n		if isTruthy(raw) {\n			result = append(result, raw)\n		}\n	}\n	return result\n}\n\n// Truthy is the exported form of isTruthy \u2014 JavaScript\'s `Boolean(x)`\n// semantics \u2014 for generated `NewXxxProps` code lowering a conditional\n// inline-object spread condition on an `interface{}` prop (whose runtime\n// value may be a string, number, bool, \u2026). Keeps the spread bag\'s\n// inclusion test faithful to JS rather than string-biased (#1752).\nfunc Truthy(v any) bool { return isTruthy(v) }\n\n// isTruthy mirrors JavaScript\'s `Boolean(x)` for the value shapes the\n// template path actually receives \u2014 nil / false / 0 / "" are falsy.\n// Other shapes (non-empty maps, slices, structs, true) are truthy, in\n// line with JS\'s "objects are truthy" rule.\nfunc isTruthy(v any) bool {\n	if v == nil {\n		return false\n	}\n	switch x := v.(type) {\n	case bool:\n		return x\n	case string:\n		return x != ""\n	case int:\n		return x != 0\n	case int8, int16, int32, int64:\n		return reflect.ValueOf(v).Int() != 0\n	case uint, uint8, uint16, uint32, uint64:\n		return reflect.ValueOf(v).Uint() != 0\n	case float32:\n		// JS `Boolean(NaN)` is false regardless of float width \u2014 the\n		// float64 arm below was the only one checking IsNaN, which\n		// diverged from JS for `float32` NaN inputs (Copilot review on\n		// #1445). Widening to float64 for the IsNaN check keeps the\n		// two branches in lock-step.\n		return x != 0 && !math.IsNaN(float64(x))\n	case float64:\n		return x != 0 && !math.IsNaN(x)\n	}\n	return true\n}\n\n// =============================================================================\n// Higher-order Array Methods\n// =============================================================================\n\n// fieldValue projects item.field for the higher-order predicate\n// helpers. The field name arrives in JS casing; structs resolve via\n// the capitalized Go convention (FieldByName inside getFieldValue),\n// maps via getFieldValue\'s case-variant lookup \u2014 the same dual\n// support Sort/Reduce gained in #1487, extended here so JSON-decoded\n// data (map items) participates instead of being silently skipped.\n// nil-safe: missing fields and nil items project to nil.\nfunc fieldValue(item any, field string) any {\n	return getFieldValue(item, capitalize(field))\n}\n\n// Every returns true if every item\'s field is truthy under JS\n// `Boolean(item.field)` semantics. Mirrors JavaScript\'s\n// Array.prototype.every(item => item.field) \u2014 including being\n// vacuously true for an empty receiver.\nfunc Every(items any, field string) bool {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if !isTruthy(fieldValue(v.Index(i).Interface(), field)) {\n			return false\n		}\n	}\n	return true\n}\n\n// Some returns true if at least one item\'s field is truthy. Mirrors\n// JavaScript\'s Array.prototype.some(item => item.field).\nfunc Some(items any, field string) bool {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if isTruthy(fieldValue(v.Index(i).Interface(), field)) {\n			return true\n		}\n	}\n	return false\n}\n\n// Filter returns items where item.field == value.\n// Mirrors JavaScript\'s Array.prototype.filter(item => item.field === value).\n// Returns []any to allow chaining with other bf_* functions.\nfunc Filter(items any, field string, value any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	var result []any\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			result = append(result, item)\n		}\n	}\n	return result\n}\n\n// Find returns the first item where item.field == value, or nil if not found.\n// Mirrors JavaScript\'s Array.prototype.find(item => item.field === value).\nfunc Find(items any, field string, value any) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			return item\n		}\n	}\n	return nil\n}\n\n// FindIndex returns the index of the first item where item.field == value, or -1.\n// Mirrors JavaScript\'s Array.prototype.findIndex(item => item.field === value).\nfunc FindIndex(items any, field string, value any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(fieldValue(v.Index(i).Interface(), field), value) {\n			return i\n		}\n	}\n	return -1\n}\n\n// FindLast returns the last item where item.field == value, or nil if not found.\n// Mirrors JavaScript\'s Array.prototype.findLast(item => item.field === value).\nfunc FindLast(items any, field string, value any) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		item := v.Index(i).Interface()\n		if reflect.DeepEqual(fieldValue(item, field), value) {\n			return item\n		}\n	}\n	return nil\n}\n\n// FindLastIndex returns the index of the last item where item.field == value, or -1.\n// Mirrors JavaScript\'s Array.prototype.findLastIndex(item => item.field === value).\nfunc FindLastIndex(items any, field string, value any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(fieldValue(v.Index(i).Interface(), field), value) {\n			return i\n		}\n	}\n	return -1\n}\n\n// sortKeySpec is one parsed comparison key. A simple comparator has\n// one; a `||`-chained multi-key comparator has several, applied in\n// order as tie-breakers.\ntype sortKeySpec struct {\n	kind        string // "self" | "field"\n	name        string // capitalised field name, or "" for "self"\n	compareType string // "numeric" | "string" | "auto"\n	direction   string // "asc" | "desc"\n}\n\n// Sort returns a new stable-sorted slice. Lowers\n// `Array.prototype.sort` / `Array.prototype.toSorted` (#1448 Tier B).\n// Non-mutating \u2014 JS\'s mutate-vs-new distinction is moot in SSR\n// template context (templates render a snapshot).\n//\n// Call shape (the compiler emits one 4-string group per key):\n//\n//	bf_sort <items> (<keyKind> <keyName> <compareType> <direction>)+\n//\n//	keyKind:      "self" | "field"\n//	keyName:      "" when keyKind == "self"; capitalised struct field\n//	              name (e.g. "Price") otherwise\n//	compareType:  "numeric" | "string" | "auto"\n//	direction:    "asc" | "desc"\n//\n// The groups cover the accepted comparator catalogue: `a.f - b.f`,\n// `a - b`, `a[.f].localeCompare(b[.f])`, and relational-ternary keys\n// (`a.f > b.f ? 1 : -1` \u2192 "auto"), each `||`-chainable for multi-key\n// tie-breaks. Anything outside refuses at compile time (BF101 from the\n// JSX compiler) and never reaches this helper.\n//\n// "auto" compares numerically when both projected keys parse as\n// numbers, else lexically \u2014 mirroring the Perl `bf->sort` helper\'s\n// `looks_like_number` rule so the two template adapters stay\n// byte-equal. This diverges from JS `<`/`>` only for numeric strings.\n//\n// A future `nulls` knob can extend the per-key group without rewriting\n// existing call sites \u2014 each key already projects before comparing.\nfunc Sort(items any, spec ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return []any{}\n	}\n\n	// Copy into a fresh []any so the sort is non-mutating regardless\n	// of whether the receiver is `[]T` or `[]any`.\n	result := make([]any, length)\n	for i := 0; i < length; i++ {\n		result[i] = v.Index(i).Interface()\n	}\n\n	keys := parseSortSpec(spec)\n	sort.SliceStable(result, func(i, j int) bool {\n		for _, k := range keys {\n			ki := projectSortKey(result[i], k.kind, k.name)\n			kj := projectSortKey(result[j], k.kind, k.name)\n			c := compareSortKey(ki, kj, k.compareType)\n			if c == 0 {\n				continue // tie on this key \u2014 fall through to the next\n			}\n			if k.direction == "desc" {\n				return c > 0\n			}\n			return c < 0\n		}\n		return false\n	})\n\n	return result\n}\n\n// parseSortSpec chunks the variadic operand list into 4-string key\n// groups. A trailing partial group (malformed emit) is ignored rather\n// than panicking \u2014 defensive, mirroring the helper\'s nil-safe stance.\nfunc parseSortSpec(spec []string) []sortKeySpec {\n	var keys []sortKeySpec\n	for i := 0; i+3 < len(spec); i += 4 {\n		keys = append(keys, sortKeySpec{\n			kind:        spec[i],\n			name:        spec[i+1],\n			compareType: spec[i+2],\n			direction:   spec[i+3],\n		})\n	}\n	return keys\n}\n\n// compareSortKey returns -1 / 0 / 1 for two projected keys under the\n// given compare type (ascending orientation; the caller flips for\n// "desc"). "string" stringifies both (nil \u2192 "", matching the\n// documented `bf->string(undef) === ""` divergence). "auto" compares\n// numerically when both parse as numbers, else lexically.\nfunc compareSortKey(ki, kj any, compareType string) int {\n	switch compareType {\n	case "string":\n		return strings.Compare(toString(ki), toString(kj))\n	case "auto":\n		ni, okI := toFloat64WithOK(ki)\n		nj, okJ := toFloat64WithOK(kj)\n		if okI && okJ {\n			return cmpFloat(ni, nj)\n		}\n		return strings.Compare(toString(ki), toString(kj))\n	default: // numeric\n		return cmpFloat(toFloat64(ki), toFloat64(kj))\n	}\n}\n\nfunc cmpFloat(a, b float64) int {\n	if a < b {\n		return -1\n	}\n	if a > b {\n		return 1\n	}\n	return 0\n}\n\n// toFloat64WithOK reports a value\'s numeric float and whether it is\n// number-like. Genuine numeric kinds always qualify; strings qualify\n// when they parse as a float (so the "auto" compare path matches the\n// Perl `looks_like_number` rule). Everything else is non-numeric.\nfunc toFloat64WithOK(v any) (float64, bool) {\n	switch n := v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:\n		return toFloat64(v), true\n	case string:\n		f, err := strconv.ParseFloat(strings.TrimSpace(n), 64)\n		if err != nil {\n			return 0, false\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// projectSortKey reduces an item to the value the comparator\n// actually compares. For `keyKind == "field"` it reads the named\n// struct field; for `keyKind == "self"` (primitive arrays) it\n// returns the item unchanged.\nfunc projectSortKey(item any, keyKind, keyName string) any {\n	if keyKind == "field" {\n		return getFieldValue(item, keyName)\n	}\n	return item\n}\n\n// getFieldValue extracts a struct field value using reflection. For\n// map receivers it falls back to case-variant lookup so JSON-decoded\n// user data (`map[string]any{"price": 30}`) and PascalCase-emitted\n// test data both resolve under a single key name. (#1487)\nfunc getFieldValue(item any, field string) any {\n	v := reflect.ValueOf(item)\n	// Defensive IsNil guards mirror `SpreadAttrs` \u2014 keeps the helper\n	// safe against typed-nil pointer / nil-interface items inside a\n	// `[]any` so a single bad row doesn\'t crash the whole sort.\n	if v.Kind() == reflect.Interface {\n		if v.IsNil() {\n			return nil\n		}\n		v = v.Elem()\n	}\n	if v.Kind() == reflect.Ptr {\n		if v.IsNil() {\n			return nil\n		}\n		v = v.Elem()\n	}\n\n	if v.Kind() == reflect.Map {\n		keyType := v.Type().Key()\n		if keyType.Kind() != reflect.String {\n			return nil\n		}\n		// Convert the lookup string to the map\'s actual key type so\n		// maps keyed by a named string type (`type Key string`) don\'t\n		// panic with `value of type string is not assignable to type X`.\n		lookup := func(s string) (any, bool) {\n			k := reflect.ValueOf(s).Convert(keyType)\n			if mv := v.MapIndex(k); mv.IsValid() {\n				return mv.Interface(), true\n			}\n			return nil, false\n		}\n		if r, ok := lookup(field); ok {\n			return r\n		}\n		if cap := capitalize(field); cap != field {\n			if r, ok := lookup(cap); ok {\n				return r\n			}\n		}\n		if low := decapitalize(field); low != field {\n			if r, ok := lookup(low); ok {\n				return r\n			}\n		}\n		// All-lowercase fallback: a Go-initialism field projects as an\n		// all-caps key (`id` \u2192 `ID`), and `decapitalize("ID")` only\n		// lowers the first char (`iD`), so the JS-keyed map ("id") still\n		// misses. Try the fully-lowered key last to resolve it.\n		if lower := strings.ToLower(field); lower != field && lower != decapitalize(field) {\n			if r, ok := lookup(lower); ok {\n				return r\n			}\n		}\n		return nil\n	}\n\n	if v.Kind() != reflect.Struct {\n		return nil\n	}\n\n	fieldVal := v.FieldByName(field)\n	if !fieldVal.IsValid() {\n		// Case-variant fallback: the evaluator carries the JS field name\n		// (`id` / `url`) against a Go-capitalised struct field (`ID` / `URL`),\n		// which exact `FieldByName` misses and the initialism rules can\'t be\n		// reproduced char-for-char here. Match case-insensitively instead \u2014\n		// `FieldByNameFunc` returns the zero Value (\u2192 nil) for an ambiguous\n		// match, so it stays safe. The legacy bf_sort/bf_reduce pass an\n		// already-capitalised name, so they hit the exact match above and never\n		// reach this fallback.\n		fieldVal = v.FieldByNameFunc(func(n string) bool { return strings.EqualFold(n, field) })\n		if !fieldVal.IsValid() {\n			return nil\n		}\n	}\n	return fieldVal.Interface()\n}\n\n// AsMap normalizes a dynamically-typed prop value into a\n// map[string]interface{} for object-valued context bindings\n// (`lowerProviderMapMemberValue`, go-template-adapter.ts). A caller-side\n// `interface{}` field can legally hold ANY string-keyed map kind \u2014 a Go\n// handler modelling `Record<string, string>` naturally passes\n// map[string]string \u2014 so a bare `.(map[string]interface{})` type assertion\n// would silently drop provided values (#2111 review). Returns nil (never an\n// empty map) when the value is absent \u2014 nil interface, typed-nil map or\n// pointer, or any non-map / non-string-keyed value \u2014 so the generated\n// `?? {}` fallback can distinguish "missing" (fall back) from "present but\n// empty" (use as-is). map[string]interface{} passes through without copying.\nfunc AsMap(v any) map[string]interface{} {\n	if v == nil {\n		return nil\n	}\n	if m, ok := v.(map[string]interface{}); ok {\n		if m == nil {\n			return nil\n		}\n		return m\n	}\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		if rv.IsNil() {\n			return nil\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map || rv.Type().Key().Kind() != reflect.String || rv.IsNil() {\n		return nil\n	}\n	out := make(map[string]interface{}, rv.Len())\n	iter := rv.MapRange()\n	for iter.Next() {\n		out[iter.Key().String()] = iter.Value().Interface()\n	}\n	return out\n}\n\n// capitalize uppercases the first character of a string.\nfunc capitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToUpper(s[:1]) + s[1:]\n}\n\n// decapitalize lowercases the first character of a string. Used by\n// `getFieldValue`\'s map-receiver fallback when the projected key\n// name is PascalCase but the receiver carries lowercase JS-style\n// keys (the inverse of the `capitalize` lookup).\nfunc decapitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToLower(s[:1]) + s[1:]\n}\n\n// Reduce folds an array into a scalar via the arithmetic-fold\n// catalogue (#1448 Tier C). It lowers `Array.prototype.reduce(fn, init)`\n// and `Array.prototype.reduceRight(fn, init)` for the shapes\n// `(acc, x) => acc <op> x` and `(acc, x) => acc <op> x.field`:\n//\n//	bf_reduce <items> "<op>" "<keyKind>" "<keyName>" "<type>" "<init>" "<direction>"\n//\n//	direction: "left" (reduce) | "right" (reduceRight). Only changes the\n//	           result for string concatenation; numeric folds commute.\n//\n//	op:       "+" | "*"\n//	keyKind:  "self" | "field"\n//	keyName:  "" when keyKind == "self"; capitalised struct field name\n//	          (e.g. "Duration") otherwise\n//	type:     "numeric" | "string"\n//	init:     the fold\'s start value \u2014 the compiler emits the *decoded*\n//	          seed, so numeric inits arrive as canonical decimal\n//	          (`1_000`/`0x10` already normalised to `1000`/`16`) that\n//	          ParseFloat accepts, and string inits arrive as escape-free\n//	          contents\n//\n// Numeric folds accumulate as float64; each projected key is read via\n// `toFloat64WithOK`, so numeric *strings* ("5" \u2192 5) parse and\n// non-numeric values fold as 0 \u2014 matching Perl\'s\n// `looks_like_number ? $n : 0` so the two template adapters stay\n// byte-equal. String folds concatenate (toString per projected key,\n// matching the documented `bf->string(undef) === ""` convention). The\n// init seeds the accumulator, so an empty receiver returns the init\n// unchanged \u2014 exactly like JS `reduce(fn, init)`. Anything outside the\n// catalogue refuses at compile time (BF101 from the JSX compiler) and\n// never reaches here.\n//\n// Two documented divergences from the JS / Hono path, both rare and\n// mirroring the `bf_sort` "auto" caveat:\n//   - float64 stringification differs for sums whose binary expansion\n//     isn\'t exact (e.g. 0.1 + 0.2);\n//   - numeric-*string* keys fold numerically here, but JS `+`\n//     string-concatenates once an operand is a string, so\n//     numeric-string data can render differently under CSR.\n//\n// Genuine numbers \u2014 the common SSR case \u2014 agree across all three.\nfunc Reduce(items any, op, keyKind, keyName, typ, init, direction string) any {\n	v := reflect.ValueOf(items)\n	isSlice := v.Kind() == reflect.Slice || v.Kind() == reflect.Array\n\n	// `direction == "right"` (reduceRight) folds right-to-left. Only\n	// observable for string concatenation \u2014 numeric sum / product are\n	// commutative, so the order doesn\'t change the result there. Build a\n	// start/stop/step triple so both folds share one loop shape.\n	start, stop, step := 0, 0, 1\n	if isSlice {\n		stop = v.Len()\n		if direction == "right" {\n			start, stop, step = v.Len()-1, -1, -1\n		}\n	}\n\n	if typ == "string" {\n		acc := init\n		if isSlice {\n			for i := start; i != stop; i += step {\n				key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n				acc += toString(key)\n			}\n		}\n		return acc\n	}\n\n	// numeric fold\n	acc, _ := strconv.ParseFloat(strings.TrimSpace(init), 64)\n	if isSlice {\n		for i := start; i != stop; i += step {\n			key := projectSortKey(v.Index(i).Interface(), keyKind, keyName)\n			// `toFloat64WithOK` parses numeric *strings* ("5" \u2192 5) and\n			// returns 0 for non-numeric values \u2014 mirroring Perl\'s\n			// `looks_like_number ? $n : 0` so numeric-string data folds\n			// byte-equal across adapters (the same rule `bf_sort`\'s\n			// "auto" compare uses). Plain `toFloat64` would zero "5".\n			n, _ := toFloat64WithOK(key)\n			if op == "*" {\n				acc *= n\n			} else {\n				acc += n\n			}\n		}\n	}\n	return acc\n}\n\n// =============================================================================\n// HTML/Template Helpers\n// =============================================================================\n\n// Comment returns an HTML comment string for hydration markers.\n// The "bf-" prefix is automatically added.\nfunc Comment(content string) template.HTML {\n	return template.HTML("<!--bf-" + content + "-->")\n}\n\n// TextStart returns an HTML comment start marker for reactive text expressions.\n// Format: <!--bf:slotId-->\nfunc TextStart(slotId string) template.HTML {\n	return template.HTML("<!--bf:" + slotId + "-->")\n}\n\n// TextEnd returns an HTML comment end marker for reactive text expressions.\n// Format: <!--/-->\nfunc TextEnd() template.HTML {\n	return "<!--/-->"\n}\n\n// ScopeComment emits a fragment-rooted scope marker. See spec/compiler.md\n// "Slot identity" for the wire format. Loud-fails on marshal errors\n// (same policy as JSON / BfPropsAttr).\nfunc ScopeComment(props interface{}) (template.HTML, error) {\n	scopeID := getStringField(props, "ScopeID")\n	hostSegment := ""\n	if host := getStringField(props, "BfParent"); host != "" {\n		mount := getStringField(props, "BfMount")\n		hostSegment = "|h=" + host + "|m=" + mount\n	}\n	propsJSON := ""\n	if getBoolField(props, "BfIsRoot") {\n		pJSON, err := json.Marshal(props)\n		if err != nil {\n			return "", err\n		}\n		propsJSON = "|" + string(pJSON)\n	}\n	return template.HTML("<!--bf-scope:" + scopeID + hostSegment + propsJSON + "-->"), nil\n}\n\n// TemplateFuncMap returns the helpers that need access to the executing\n// template set itself, closed over the *template.Template the component\n// defines are parsed into. Register it alongside FuncMap BEFORE parsing:\n//\n//	t := template.New("")\n//	t.Funcs(bf.FuncMap()).Funcs(bf.TemplateFuncMap(t))\n//	template.Must(t.Parse(src))\n//\n// bf_tmpl executes a named define from the same set and returns its\n// output \u2014 used for the per-call-site children defines the Go adapter\n// emits when JSX children passed to an imported component contain\n// template actions (nested components, dynamic text) and therefore\n// cannot be baked to a static HTML string (#1896). Reentrant execution\n// of an html/template set from inside a FuncMap function is safe: the\n// escape analysis over every define completes before the outer\n// Execute begins evaluating.\nfunc TemplateFuncMap(t *template.Template) template.FuncMap {\n	return template.FuncMap{\n		"bf_tmpl": func(name string, data interface{}) (template.HTML, error) {\n			var buf bytes.Buffer\n			if err := t.ExecuteTemplate(&buf, name, data); err != nil {\n				return "", err\n			}\n			return template.HTML(buf.String()), nil\n		},\n	}\n}\n\n// WithChildren returns a shallow copy of a component Props struct with its\n// Children field replaced by the given pre-rendered fragment (#1896). The\n// props value stays by-value semantics: callers\' originals are untouched.\n// A props type without a Children field passes through unchanged \u2014 the\n// child template then simply has no children to render, matching the\n// pre-#1896 behaviour.\nfunc WithChildren(props interface{}, children template.HTML) (interface{}, error) {\n	v := reflect.ValueOf(props)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return props, nil\n	}\n	field := v.FieldByName("Children")\n	if !field.IsValid() {\n		return props, nil\n	}\n	copyPtr := reflect.New(v.Type())\n	copyPtr.Elem().Set(v)\n	target := copyPtr.Elem().FieldByName("Children")\n	switch {\n	case target.Kind() == reflect.Interface:\n		target.Set(reflect.ValueOf(children))\n	case target.Kind() == reflect.String:\n		// Covers both `string` and `template.HTML`-typed fields.\n		target.SetString(string(children))\n	default:\n		return props, fmt.Errorf("bf_with_children: unsupported Children field type %s", target.Type())\n	}\n	return copyPtr.Elem().Interface(), nil\n}\n\n// PortalHTML parses and executes a template string with the provided data.\n// Used for rendering dynamic portal content where the template string\n// contains Go template expressions (e.g., {{if .Open}}open{{end}}).\n//\n// The template string is parsed fresh each time to support dynamic content.\n// Standard Go template functions (if, range, eq, etc.) are available.\nfunc PortalHTML(data interface{}, tmplStr string) template.HTML {\n	// Create a new template with the FuncMap for custom functions\n	t, err := template.New("portal").Funcs(FuncMap()).Parse(tmplStr)\n	if err != nil {\n		// Return error message as HTML comment for debugging\n		return template.HTML("<!-- bfPortalHTML error: " + err.Error() + " -->")\n	}\n\n	var buf bytes.Buffer\n	if err := t.Execute(&buf, data); err != nil {\n		return template.HTML("<!-- bfPortalHTML exec error: " + err.Error() + " -->")\n	}\n\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Portal Collection\n// =============================================================================\n\n// PortalContent represents a single portal\'s content to be rendered at body end.\ntype PortalContent struct {\n	ID      string        // Unique portal ID for hydration matching\n	OwnerID string        // Owner scope ID for find() support\n	Content template.HTML // Portal HTML content\n}\n\n// PortalCollector collects portal content during template rendering.\n// Portal content is rendered at </body> to avoid z-index issues.\ntype PortalCollector struct {\n	portals []PortalContent\n	counter int\n}\n\n// NewPortalCollector creates a new PortalCollector.\nfunc NewPortalCollector() *PortalCollector {\n	return &PortalCollector{\n		portals: []PortalContent{},\n		counter: 0,\n	}\n}\n\n// Add registers portal content to be rendered at body end.\nfunc (pc *PortalCollector) Add(ownerID string, content template.HTML) string {\n	pc.counter++\n	id := "bf-portal-" + strconv.Itoa(pc.counter)\n	pc.portals = append(pc.portals, PortalContent{\n		ID:      id,\n		OwnerID: ownerID,\n		Content: content,\n	})\n	return "" // Return empty string for template use\n}\n\n// Render outputs all collected portals as HTML.\n// Each portal is wrapped in a div with bf-pi (portal ID) and bf-po (portal owner).\nfunc (pc *PortalCollector) Render() template.HTML {\n	if pc == nil || len(pc.portals) == 0 {\n		return ""\n	}\n	var buf strings.Builder\n	for _, p := range pc.portals {\n		buf.WriteString(`<div bf-pi="`)\n		buf.WriteString(p.ID)\n		buf.WriteString(`" bf-po="`)\n		buf.WriteString(p.OwnerID)\n		buf.WriteString(`">`)\n		buf.WriteString(string(p.Content))\n		buf.WriteString("</div>\\n")\n	}\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Script Collection\n// =============================================================================\n\n// ScriptCollector collects client scripts with deduplication.\n// It preserves insertion order for deterministic output.\ntype ScriptCollector struct {\n	scripts map[string]bool\n	order   []string\n}\n\n// NewScriptCollector creates a new ScriptCollector.\nfunc NewScriptCollector() *ScriptCollector {\n	return &ScriptCollector{\n		scripts: make(map[string]bool),\n		order:   []string{},\n	}\n}\n\n// Register adds a script source to the collection.\n// Duplicate scripts are ignored (only first registration counts).\nfunc (sc *ScriptCollector) Register(src string) string {\n	if sc.scripts[src] {\n		return "" // Already registered\n	}\n	sc.scripts[src] = true\n	sc.order = append(sc.order, src)\n	return "" // Return empty string for template use\n}\n\n// Scripts returns all registered scripts in insertion order.\nfunc (sc *ScriptCollector) Scripts() []string {\n	return sc.order\n}\n\n// BfScripts generates script tags for all registered scripts.\n// Returns HTML safe for embedding in templates.\nfunc BfScripts(collector *ScriptCollector) template.HTML {\n	if collector == nil {\n		return ""\n	}\n	var result strings.Builder\n	for _, src := range collector.Scripts() {\n		result.WriteString(`<script type="module" src="`)\n		result.WriteString(src)\n		result.WriteString(`"></script>`)\n		result.WriteString("\\n")\n	}\n	return template.HTML(result.String())\n}\n\n// =============================================================================\n// Component Renderer\n// =============================================================================\n\n// RenderContext contains all data needed to render a component page.\n// The layout function receives this context to build the final HTML.\ntype RenderContext struct {\n	// ComponentName is the template name being rendered\n	ComponentName string\n\n	// Props is the component props (for layout to access if needed)\n	Props interface{}\n\n	// ComponentHTML is the rendered component template output\n	ComponentHTML template.HTML\n\n	// Portals contains collected portal content to render at body end\n	Portals template.HTML\n\n	// Scripts contains the collected JS script tags\n	Scripts template.HTML\n\n	// Title is the page title (defaults to "{ComponentName} - BarefootJS")\n	Title string\n\n	// Heading is the page heading. Empty string means no heading.\n	Heading string\n\n	// Extra holds additional user-defined data for the layout\n	Extra map[string]interface{}\n}\n\n// LayoutFunc renders the final HTML page given the render context.\ntype LayoutFunc func(ctx *RenderContext) string\n\n// Renderer renders BarefootJS components with a customizable layout.\ntype Renderer struct {\n	templates *template.Template\n	layout    LayoutFunc\n}\n\n// NewRenderer creates a Renderer with the given templates and layout function.\n//\n// Example usage:\n//\n//	renderer := bf.NewRenderer(templates, func(ctx *bf.RenderContext) string {\n//	    return fmt.Sprintf(`<!DOCTYPE html>\n//	<html>\n//	<head><title>%s</title></head>\n//	<body>%s%s</body>\n//	</html>`, ctx.Title, ctx.ComponentHTML, ctx.Scripts)\n//	})\nfunc NewRenderer(tmpl *template.Template, layout LayoutFunc) *Renderer {\n	return &Renderer{\n		templates: tmpl,\n		layout:    layout,\n	}\n}\n\n// RenderOptions configures a single render call.\ntype RenderOptions struct {\n	// ComponentName is the template name to render (required)\n	ComponentName string\n\n	// Props is the component props (must be a pointer to struct with Scripts field)\n	Props interface{}\n\n	// Title is the page title. If empty, defaults to "{ComponentName} - BarefootJS"\n	Title string\n\n	// Heading is the page heading. If empty, no heading is shown.\n	Heading string\n\n	// Extra holds additional data to pass to the layout\n	Extra map[string]interface{}\n}\n\n// Render renders a component to a full HTML page using the configured layout.\n// Child component props are automatically detected (any slice field with ScopeID/Scripts).\n// renderTemplateErrorPanel formats a Go template execution error into a\n// fragment of HTML that\'s visible in the browser. The panel is\n// HTML-escaped so a faulty template name (anything from `template:\n// "..."`) can\'t smuggle markup back into the page. Keep the styling\n// inline so the panel surfaces even when the project\'s CSS hasn\'t\n// loaded yet (e.g. the failure aborted before the stylesheet links\n// emitted).\n//\n// Surfaced for the #1442 echo repro: a template referencing\n// `.Todo.Done` (instead of the range dot\'s `.Done`) used to fail\n// silently \u2014 Go\'s html/template aborted mid-stream, the partial body\n// flushed as a 200, and the user saw a truncated list with no console\n// signal. With this panel they get the template name, the error\n// message, and a "what to look at" hint inline.\nfunc renderTemplateErrorPanel(componentName string, err error) string {\n	return `<div style="margin:1em 0;padding:1em;border:2px solid #d33;background:#fff5f5;color:#900;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:13px;line-height:1.5"><strong style="display:block;margin-bottom:.5em">Template error in <code>` +\n		template.HTMLEscapeString(componentName) +\n		`</code></strong><pre style="margin:0;white-space:pre-wrap;word-break:break-word">` +\n		template.HTMLEscapeString(err.Error()) +\n		`</pre><div style="margin-top:.75em;font-size:12px;opacity:.7">Common cause: a JSX expression referenced a name the adapter could not resolve to a struct field. Open the matching <code>dist/templates/*.tmpl</code> for the unresolved reference, then fix the source component.</div></div>`\n}\n\n// renderComponentInto wires a component\'s props (script/portal collectors,\n// child-slot scope ids + hydration, root marking) against the PROVIDED\n// collectors and returns just the component\'s HTML \u2014 no layout. Both Render\n// (one fresh collector pair per page) and RenderFragment (a shared pair across\n// several islands) funnel through here so their wiring stays identical.\nfunc (r *Renderer) renderComponentInto(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	// Inject the shared collectors into the props.\n	setScriptsField(opts.Props, scriptCollector)\n	setPortalsField(opts.Props, portalCollector)\n\n	// Auto-detect and process child component props (slices)\n	childSlices := findChildComponentSlices(opts.Props)\n	for _, slice := range childSlices {\n		setScopeIDsOnSlice(slice)\n		setScriptsOnSlice(slice, scriptCollector)\n		setPortalsOnSlice(slice, portalCollector)\n		setBoolOnSlice(slice, "BfIsChild", true)\n	}\n\n	// Auto-detect and process single child component props\n	singleChildren := findSingleChildComponents(opts.Props)\n	for _, child := range singleChildren {\n		setScopeIDOnSingle(child)\n		setScriptsOnSingle(child, scriptCollector)\n		setPortalsOnSingle(child, portalCollector)\n		setBoolField(child, "BfIsChild", true)\n	}\n\n	// Mark the root component so BfPropsAttr emits bf-p only for it\n	setBoolField(opts.Props, "BfIsRoot", true)\n\n	// Render the component template.\n	//\n	// Errors here are NOT silently dropped. The original implementation\n	// ignored the return value of `ExecuteTemplate`, which masked a real\n	// onboarding failure mode: a template referencing a non-existent\n	// field (`.Todo.Done` instead of the range dot\'s `.Done`) caused\n	// html/template to abort mid-stream, the partial output got\n	// returned, and the HTTP server happily flushed a 200 with a\n	// truncated body. No error log, no signal \u2014 the user just saw a\n	// blank list (#1442 echo TodoApp repro).\n	//\n	// Now we capture the error and replace the partial output with a\n	// visible inline panel (dev mode) or a fenced error comment\n	// (production), so the cause is on-screen and grep-able in logs.\n	// Either way the renderer also writes to stderr so structured log\n	// aggregators see it.\n	var componentBuf strings.Builder\n	if err := r.templates.ExecuteTemplate(&componentBuf, opts.ComponentName, opts.Props); err != nil {\n		fmt.Fprintf(os.Stderr, "barefoot: template %q failed to render: %v\\n", opts.ComponentName, err)\n		// Preserve whatever the template did manage to emit before\n		// failing (Go\'s text/template flushes incrementally), but\n		// follow it with a clearly-marked error block so the user\n		// notices something is wrong instead of seeing a silent\n		// truncation.\n		componentBuf.WriteString(renderTemplateErrorPanel(opts.ComponentName, err))\n	}\n\n	return template.HTML(componentBuf.String())\n}\n\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// One script + portal collector pair for the whole page.\n	scriptCollector := NewScriptCollector()\n	portalCollector := NewPortalCollector()\n\n	componentHTML := r.renderComponentInto(opts, scriptCollector, portalCollector)\n\n	// Determine title (default: "{ComponentName} - BarefootJS")\n	title := opts.Title\n	if title == "" {\n		title = opts.ComponentName + " - BarefootJS"\n	}\n\n	// Heading (empty means no heading)\n	heading := opts.Heading\n\n	// Build render context\n	ctx := &RenderContext{\n		ComponentName: opts.ComponentName,\n		Props:         opts.Props,\n		ComponentHTML: componentHTML,\n		Portals:       portalCollector.Render(),\n		Scripts:       BfScripts(scriptCollector),\n		Title:         title,\n		Heading:       heading,\n		Extra:         opts.Extra,\n	}\n\n	return r.layout(ctx)\n}\n\n// RenderFragment renders a single island subtree into the caller-provided\n// script and portal collectors and returns just its HTML \u2014 no page layout.\n//\n// It exists for hand-authored "region shell" pages (the `@barefootjs/router`\n// showcase): a layout that places several independent islands \u2014 e.g. a header\n// ThemeToggle, an `<aside bf-region>` Sidebar, and a `<PageShell>` wrapping the\n// route content \u2014 must collect ALL their scripts and portals into ONE place so\n// the runtime (`barefoot.js`) and each island\'s client JS are emitted exactly\n// once and share a single reactive instance. Render each island with the same\n// collectors, splice the returned HTML into the shell, then emit\n// `BfScripts(sc)` and `pc.Render()` once at the end of the document.\n//\n// Each fragment is treated as its own root (it emits `bf-p` like any top-level\n// island); nested children declared in its props are wired as children, exactly\n// as in Render.\nfunc (r *Renderer) RenderFragment(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	return r.renderComponentInto(opts, scriptCollector, portalCollector)\n}\n\n// setScriptsField sets the Scripts field on a struct using reflection.\nfunc setScriptsField(v interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Scripts")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// setPortalsField sets the Portals field on a struct using reflection.\nfunc setPortalsField(v interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Portals")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// getStringField extracts a string field from a struct using reflection.\nfunc setBoolField(v interface{}, fieldName string, val bool) {\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Struct {\n		return\n	}\n	field := rv.FieldByName(fieldName)\n	if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n		field.SetBool(val)\n	}\n}\n\nfunc getBoolField(v interface{}, fieldName string) bool {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return false\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.Bool {\n		return false\n	}\n	return field.Bool()\n}\n\nfunc getStringField(v interface{}, fieldName string) string {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return ""\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.String {\n		return ""\n	}\n	return field.String()\n}\n\n// scopeIDChars is the alphabet for auto-generated ScopeID suffixes. It\n// mirrors the `randomID` helper the go-template adapter emits into the\n// generated New<Component>Props constructors so runtime-assigned and\n// constructor-assigned ids are indistinguishable.\nconst scopeIDChars = "abcdefghijklmnopqrstuvwxyz0123456789"\n\n// randomScopeSuffix returns a random lowercase-alphanumeric string of\n// length n. math/rand (auto-seeded since Go 1.20) is sufficient here: the\n// suffix only needs to be unique enough to keep a page\'s bf-s scope ids\n// from colliding, not cryptographically unpredictable.\nfunc randomScopeSuffix(n int) string {\n	b := make([]byte, n)\n	for i := range b {\n		b[i] = scopeIDChars[rand.Intn(len(scopeIDChars))]\n	}\n	return string(b)\n}\n\n// scopeIDPrefix derives the human-readable ScopeID prefix from a child\n// component\'s type, e.g. `TodoItemProps` \u2192 `TodoItem`. Matches the\n// `"<Component>_" + randomID(6)` shape the generated constructors use.\nfunc scopeIDPrefix(t reflect.Type) string {\n	for t.Kind() == reflect.Ptr {\n		t = t.Elem()\n	}\n	return strings.TrimSuffix(t.Name(), "Props")\n}\n\n// assignScopeID fills a child component\'s ScopeID with a generated id when\n// the caller left it empty, so application code doesn\'t have to mint scope\n// ids by hand (the parent\'s New<Component>Props constructor does the same\n// for components built through it). A non-empty ScopeID is left untouched,\n// so callers can still pin a stable id when they need one.\nfunc assignScopeID(structVal reflect.Value, prefix string) {\n	field := structVal.FieldByName("ScopeID")\n	if !field.IsValid() || !field.CanSet() || field.Kind() != reflect.String {\n		return\n	}\n	if field.String() != "" {\n		return\n	}\n	id := randomScopeSuffix(6)\n	if prefix != "" {\n		id = prefix + "_" + id\n	}\n	field.SetString(id)\n}\n\n// setScopeIDsOnSlice assigns a generated ScopeID to every child in a slice\n// whose ScopeID is empty.\nfunc setScopeIDsOnSlice(slice interface{}) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	prefix := scopeIDPrefix(v.Type().Elem())\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			assignScopeID(item, prefix)\n		}\n	}\n}\n\n// setScopeIDOnSingle assigns a generated ScopeID to a single child\n// component when its ScopeID is empty.\nfunc setScopeIDOnSingle(child interface{}) {\n	v := reflect.ValueOf(child)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return\n	}\n	assignScopeID(v, scopeIDPrefix(v.Type()))\n}\n\n// findChildComponentSlices finds slice fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findChildComponentSlices(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n		if field.Kind() != reflect.Slice || field.Len() == 0 {\n			continue\n		}\n\n		elem := field.Index(0)\n		if elem.Kind() == reflect.Ptr {\n			elem = elem.Elem()\n		}\n		if elem.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := elem.FieldByName("ScopeID").IsValid()\n		hasScripts := elem.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSlice sets Scripts on all items in a slice.\nfunc setScriptsOnSlice(slice interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Scripts")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// setBoolOnSlice sets a bool field on all items in a slice.\nfunc setBoolOnSlice(slice interface{}, fieldName string, val bool) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName(fieldName)\n			if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n				field.SetBool(val)\n			}\n		}\n	}\n}\n\n// setPortalsOnSlice sets Portals on all items in a slice.\nfunc setPortalsOnSlice(slice interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Portals")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		return ""\n	}\n}\n\n// =============================================================================\n// searchParams() \u2014 request-scoped environment signal (router v0.5, #1922)\n// =============================================================================\n\n// SearchParams is the SSR view of the request query string behind the\n// reactive searchParams() environment signal. The route handler builds it\n// from the request URL and assigns it to the component\'s SearchParams input\n// field; the generated template reads it via `.SearchParams.Get "key"`.\n//\n// The zero value is an empty query (url.Values.Get tolerates a nil map), so a\n// render with no request query \u2014 e.g. the adapter conformance harness, which\n// issues no query string \u2014 resolves every key to "", which the template\'s\n// `or`/`??` fallback turns into the author\'s default.\ntype SearchParams struct {\n	values url.Values\n}\n\n// NewSearchParams parses a raw query string (with or without a leading "?")\n// into a SearchParams. A malformed query yields an empty set rather than an\n// error, mirroring the browser\'s URLSearchParams, which never throws on junk.\n//\n// Typical handler use (net/http):\n//\n//	in := MyComponentInput{SearchParams: bf.NewSearchParams(r.URL.RawQuery)}\nfunc NewSearchParams(raw string) SearchParams {\n	raw = strings.TrimPrefix(raw, "?")\n	values, err := url.ParseQuery(raw)\n	if err != nil {\n		values = url.Values{}\n	}\n	return SearchParams{values: values}\n}\n\n// Get returns the first value associated with key, or "" when the key is\n// absent. This mirrors url.Values.Get, which also returns "" for a\n// present-but-empty value (`?sort=`). Safe on the zero value (nil map).\n//\n// This is not byte-for-byte URLSearchParams.get under the template\'s `??`\n// lowering. JS distinguishes absent (`null`) from present-but-empty (`""`):\n// `null ?? d` yields the default, but `"" ?? d` keeps the empty string. The\n// Go adapter lowers `??` to the `or` builtin \u2014 Go templates have no\n// null-coalescing operator \u2014 so here BOTH an absent key and a present-but-\n// empty value fall back to the author\'s default. The conformance fixture only\n// exercises the absent-key default, where the two runtimes agree; the\n// empty-string divergence is the same general `?? \u2192 or` limitation that\n// applies to any `x ?? default` the Go adapter lowers.\nfunc (s SearchParams) Get(key string) string {\n	return s.values.Get(key)\n}\n';
+    evalGoSource = 'package bf\n\nimport (\n	"encoding/json"\n	"math"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode/utf8"\n)\n\n// =============================================================================\n// Lightweight ParsedExpr evaluator (issue #2018)\n// =============================================================================\n//\n// Templates cannot carry a lambda in expression position, which is why the\n// adapter historically special-cased higher-order callbacks (reduce / sort /\n// map / filter / find) into fixed shapes (bf_sort\'s comparator catalogue,\n// bf_reduce\'s +/* fold). This evaluator replaces that ad-hoc list: a callback\n// BODY is carried as a pure `ParsedExpr` subtree (the same structured IR the\n// compiler already produces) and evaluated here against an environment\n// (`{acc, item, \u2026captured free vars}`).\n//\n// Scope: higher-order callback bodies only. Ordinary expressions stay lowered\n// to template-native syntax \u2014 this is NOT a general expression engine.\n//\n// The accepted pure subset and its semantics (evaluation order, coercion,\n// equality, allowed operators / builtins) are documented in spec/compiler.md\n// ("ParsedExpr Evaluator Semantics") and pinned isomorphically by the golden\n// vectors in packages/adapter-tests/vectors/eval-vectors.json (shared\n// with the Perl evaluator). The coercion rules below are the literal JS rules\n// (ToNumber / ToString / ToBoolean) \u2014 deliberately NOT the divergent\n// bf->string / bf_reduce helper conventions \u2014 so the contract is unambiguous\n// and the backends stay byte-isomorphic.\n//\n// String semantics operate on Unicode code points / UTF-8 bytes: `.length`\n// counts code points and relational `<`/`>` compares byte order. This equals\n// the JS reference (UTF-16 code units) across the BMP \u2014 the range template\n// data uses \u2014 and matches the Perl evaluator exactly (the primary "same input\n// \u2192 same output" contract is between the two SSR backends). Astral-plane\n// characters (where JS counts a surrogate pair as length 2 and orders by\n// surrogate code units) are a documented divergence region, alongside the\n// already-documented non-ASCII relational / localeCompare carve-outs\n// (spec/compiler.md). Both backends stay equal; only the JS reference differs,\n// and no corpus vector exercises the astral range.\n\n// EvalExpr evaluates a pure ParsedExpr (carried as its JSON encoding) against\n// env. The result is a value in the JSON domain: a number (Go int or float64 \u2014\n// both are the single JS number type; e.g. `.length` returns int, arithmetic\n// returns float64), string, bool, nil, []any, or map[string]any. A malformed\n// tree yields nil.\nfunc EvalExpr(exprJSON string, env map[string]any) any {\n	var node any\n	if err := json.Unmarshal([]byte(exprJSON), &node); err != nil {\n		return nil\n	}\n	return EvalNode(node, env)\n}\n\n// EvalNode evaluates an already-decoded ParsedExpr node (a map[string]any with\n// a "kind" discriminator) against env. Exported so callers that already hold a\n// decoded tree (e.g. the golden-vector harness) skip a re-marshal.\nfunc EvalNode(node any, env map[string]any) any {\n	n, ok := node.(map[string]any)\n	if !ok {\n		return nil\n	}\n	kind, _ := n["kind"].(string)\n	switch kind {\n	case "literal":\n		return n["value"]\n\n	case "identifier":\n		name, _ := n["name"].(string)\n		return env[name]\n\n	case "binary":\n		op, _ := n["op"].(string)\n		return evalBinary(op, EvalNode(n["left"], env), EvalNode(n["right"], env))\n\n	case "unary":\n		op, _ := n["op"].(string)\n		return evalUnary(op, EvalNode(n["argument"], env))\n\n	case "logical":\n		op, _ := n["op"].(string)\n		left := EvalNode(n["left"], env)\n		switch op {\n		case "&&":\n			if !evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "||":\n			if evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "??":\n			if left == nil {\n				return EvalNode(n["right"], env)\n			}\n			return left\n		}\n		return nil\n\n	case "conditional":\n		if evalTruthy(EvalNode(n["test"], env)) {\n			return EvalNode(n["consequent"], env)\n		}\n		return EvalNode(n["alternate"], env)\n\n	case "member":\n		prop, _ := n["property"].(string)\n		return evalReadProperty(EvalNode(n["object"], env), prop)\n\n	case "index-access":\n		return evalReadIndex(EvalNode(n["object"], env), EvalNode(n["index"], env))\n\n	case "call":\n		// A nested `.map(cb)` / `.filter(cb)` callback call (#2094): syntactically\n		// a `call` whose callee is `<recv>.map`/`<recv>.filter` and whose first\n		// argument is an `arrow` \u2014 the SAME shape `asCallbackMethodCall`\n		// recognizes at compile time, and the shape the `eval-vectors.json`\n		// golden corpus itself carries (it stores the genuine `ParsedExpr`, not\n		// a bespoke wrapper). Checked BEFORE the builtin-callee gate below,\n		// since `<recv>.map` would otherwise resolve to a non-builtin member\n		// callee and refuse.\n		if method, objNode, arrowNode, ok := evalArrayCallbackCall(n); ok {\n			return evalArrayCallback(method, objNode, arrowNode, env)\n		}\n		name := evalBuiltinName(n["callee"])\n		if name == "" {\n			return nil\n		}\n		rawArgs, _ := n["args"].([]any)\n		args := make([]any, len(rawArgs))\n		for i, a := range rawArgs {\n			args[i] = EvalNode(a, env)\n		}\n		return evalCallBuiltin(name, args)\n\n	case "template-literal":\n		parts, _ := n["parts"].([]any)\n		var sb strings.Builder\n		for _, p := range parts {\n			pm, _ := p.(map[string]any)\n			if t, _ := pm["type"].(string); t == "string" {\n				s, _ := pm["value"].(string)\n				sb.WriteString(s)\n			} else {\n				sb.WriteString(evalToString(EvalNode(pm["expr"], env)))\n			}\n		}\n		return sb.String()\n\n	case "array-literal":\n		elems, _ := n["elements"].([]any)\n		out := make([]any, len(elems))\n		for i, e := range elems {\n			out[i] = EvalNode(e, env)\n		}\n		return out\n\n	case "object-literal":\n		props, _ := n["properties"].([]any)\n		out := make(map[string]any, len(props))\n		for _, p := range props {\n			pm, _ := p.(map[string]any)\n			key, _ := pm["key"].(string)\n			out[key] = EvalNode(pm["value"], env)\n		}\n		return out\n\n	case "array-method":\n		// `.includes(x)` / `.join(sep?)` are the `array-method` shapes the\n		// evaluator executes (the JS reference\'s `evaluate` "array-method" arm,\n		// eval-reference.ts). A nested `.map`/`.filter` is NOT an\n		// `array-method` node \u2014 it reaches the `call` case above (it carries\n		// an `arrow` callback, not a plain `args` list). Every other\n		// array/string method (`slice`, `flat`, \u2026) is refused upstream\n		// (BF101) and never reaches here.\n		method, _ := n["method"].(string)\n		rawArgs, _ := n["args"].([]any)\n		if method == "includes" && len(rawArgs) == 1 {\n			return evalIncludes(EvalNode(n["object"], env), EvalNode(rawArgs[0], env))\n		}\n		if method == "join" && len(rawArgs) <= 1 {\n			sep := ","\n			if len(rawArgs) == 1 {\n				sep = evalToString(EvalNode(rawArgs[0], env))\n			}\n			return evalJoin(EvalNode(n["object"], env), sep)\n		}\n		return nil\n	}\n	// arrow-fn / higher-order / unsupported: a callback body containing these\n	// is refused upstream (BF101); never reached here.\n	return nil\n}\n\n// evalArrayCallbackCall reports whether the decoded `call` node `n` is a\n// nested `.map(cb)` / `.filter(cb)` callback call (#2094): its callee is a\n// non-computed member `<recv>.map`/`<recv>.filter` and its first argument is\n// an `arrow` node. Returns the method name, the (still-encoded) receiver\n// object node, and the (still-encoded) arrow node.\nfunc evalArrayCallbackCall(n map[string]any) (method string, object any, arrow map[string]any, ok bool) {\n	callee, _ := n["callee"].(map[string]any)\n	if callee == nil || callee["kind"] != "member" {\n		return "", nil, nil, false\n	}\n	if computed, _ := callee["computed"].(bool); computed {\n		return "", nil, nil, false\n	}\n	prop, _ := callee["property"].(string)\n	if prop != "map" && prop != "filter" {\n		return "", nil, nil, false\n	}\n	rawArgs, _ := n["args"].([]any)\n	if len(rawArgs) == 0 {\n		return "", nil, nil, false\n	}\n	arrowNode, _ := rawArgs[0].(map[string]any)\n	if arrowNode == nil || arrowNode["kind"] != "arrow" {\n		return "", nil, nil, false\n	}\n	return prop, callee["object"], arrowNode, true\n}\n\n// evalArrayCallback executes a nested `.map`/`.filter` callback call: evaluates\n// the receiver, then evaluates the arrow body per element in a CHILD env that\n// binds the arrow\'s first param to the element and (when the arrow declares a\n// second param) the second to the integer index \u2014 both 1- and 2-param arrows\n// are supported. `map` keeps one result per element (order-preserving);\n// `filter` keeps the elements whose body evaluates truthy. A non-array\n// receiver degrades to nil (unreachable for a body the compiler validated,\n// since the receiver of a nested `.map`/`.filter` is itself gated upstream).\nfunc evalArrayCallback(method string, objectNode any, arrowNode map[string]any, env map[string]any) any {\n	arr := toAnySlice(EvalNode(objectNode, env))\n	if arr == nil {\n		return nil\n	}\n	rawParams, _ := arrowNode["params"].([]any)\n	params := make([]string, len(rawParams))\n	for i, p := range rawParams {\n		params[i], _ = p.(string)\n	}\n	body := arrowNode["body"]\n	callCb := func(item any, index int) any {\n		inner := make(map[string]any, len(env)+2)\n		for k, v := range env {\n			inner[k] = v\n		}\n		if len(params) > 0 {\n			inner[params[0]] = item\n		}\n		if len(params) > 1 {\n			inner[params[1]] = index\n		}\n		return EvalNode(body, inner)\n	}\n	if method == "map" {\n		out := make([]any, len(arr))\n		for i, item := range arr {\n			out[i] = callCb(item, i)\n		}\n		return out\n	}\n	out := []any{}\n	for i, item := range arr {\n		if evalTruthy(callCb(item, i)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// evalJoin implements `.join(sep)`: elements ToString\'d and joined; a\n// null/undefined element ToStrings to the empty string (matching JS\n// `Array.prototype.join`, which skips null/undefined rather than rendering\n// the literal string "null"/"undefined"). A non-array receiver degrades to\n// the empty string (unreachable for a validated body).\nfunc evalJoin(obj any, sep string) string {\n	arr := toAnySlice(obj)\n	if arr == nil {\n		return ""\n	}\n	parts := make([]string, len(arr))\n	for i, el := range arr {\n		if el == nil {\n			parts[i] = ""\n			continue\n		}\n		parts[i] = evalToString(el)\n	}\n	return strings.Join(parts, sep)\n}\n\n// ---------------------------------------------------------------------------\n// JS coercion primitives (ToNumber / ToString / ToBoolean), pinned so the\n// evaluator matches the JS reference. These are JS-faithful and intentionally\n// distinct from the bf->string / Number helpers, which diverge (null \u2192 "",\n// null/"" \u2192 NaN) for SSR-survival reasons that do not apply to the evaluator.\n// ---------------------------------------------------------------------------\n\nfunc evalToNumber(v any) float64 {\n	switch x := v.(type) {\n	case nil:\n		return 0\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		t := strings.TrimSpace(x)\n		if t == "" {\n			return 0\n		}\n		// Decimal / exponent / "Infinity" numeric strings parse JS-faithfully\n		// (ParseFloat handles these, matching the Perl evaluator). The\n		// radix-prefixed forms JS Number() also accepts ("0x10" / "0o17" /\n		// "0b101") are a documented divergence region: they yield NaN here, as\n		// they do in the Perl evaluator (looks_like_number is false for them),\n		// so Go==Perl while differing from the JS reference. Template data\n		// carries JSON numbers, not radix-string literals, so this never\n		// arises in practice.\n		f, err := strconv.ParseFloat(t, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	default:\n		if evalIsNumeric(v) {\n			return toFloat64(v)\n		}\n		return math.NaN()\n	}\n}\n\n// evalIsNumeric reports whether v is one of the Go numeric types (all of\n// which are the single JS "number" type to the evaluator).\nfunc evalIsNumeric(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:\n		return true\n	}\n	return false\n}\n\nfunc evalToString(v any) string {\n	if v == nil {\n		return "null"\n	}\n	// JS spells the non-finite doubles "Infinity" / "-Infinity" / "NaN"; the\n	// runtime String() helper (fmt %v) would render "+Inf" / "-Inf" / "NaN",\n	// so the non-finite cases are pinned here to stay JS-faithful (and match\n	// the Perl evaluator\'s _to_string). Strings, bools and nil are JS-faithful\n	// through String() (nil is already handled above as "null").\n	//\n	// Finite-number formatting is a documented divergence region. Go\'s fmt is\n	// shortest-round-trip (it matches JS\'s *digits*, e.g. 0.1+0.2 \u2192\n	// "0.30000000000000004"), but its exponent threshold/padding differ from\n	// JS Number::toString for very large / very small magnitudes (Go renders\n	// 1e6 as "1e+06" where JS keeps "1000000", and "1e-07" vs JS "1e-7").\n	// Perl\'s `%.15g` instead diverges on *precision* (the pinned helper-vector\n	// "0.3" case). A fully JS-faithful Number::toString is not reimplemented\n	// here because Perl has no shortest-round-trip formatter, so the three\n	// could never all agree; the common integer / short-decimal range \u2014 what\n	// arithmetic over template data produces \u2014 renders identically across all\n	// three. Only the \xB10 sign is normalised below, since it is cheap and the\n	// realisticly-reachable case.\n	if f, ok := v.(float64); ok {\n		if math.IsNaN(f) {\n			return "NaN"\n		}\n		if math.IsInf(f, 1) {\n			return "Infinity"\n		}\n		if math.IsInf(f, -1) {\n			return "-Infinity"\n		}\n		// JS `String(-0)` is "0", but fmt %v renders Go\'s negative zero as\n		// "-0". `f == 0` matches both \xB10, normalising to JS\'s spelling. (A\n		// unary `-` on a zero operand is the way the evaluator can produce -0.)\n		if f == 0 {\n			return "0"\n		}\n	}\n	// Non-primitive operands (arrays / objects) in ToString position are\n	// outside the evaluator subset \u2014 the JS reference refuses them, and the\n	// compiler gates such a callback body with BF101 before it ever reaches\n	// the runtime. This evaluator runs already-validated bodies, so it does\n	// not re-reject here; String() (fmt %v) is a best-effort fallback for that\n	// unreachable path, never exercised by the in-subset corpus.\n	return String(v)\n}\n\nfunc evalTruthy(v any) bool {\n	return isTruthy(v)\n}\n\n// ---------------------------------------------------------------------------\n// Operators\n// ---------------------------------------------------------------------------\n\nfunc evalBinary(op string, l, r any) any {\n	switch op {\n	case "+":\n		// JS `+`: string concatenation once either operand is a string,\n		// numeric addition otherwise.\n		if _, lok := l.(string); lok {\n			return evalToString(l) + evalToString(r)\n		}\n		if _, rok := r.(string); rok {\n			return evalToString(l) + evalToString(r)\n		}\n		return evalToNumber(l) + evalToNumber(r)\n	case "-":\n		return evalToNumber(l) - evalToNumber(r)\n	case "*":\n		return evalToNumber(l) * evalToNumber(r)\n	case "/":\n		return evalToNumber(l) / evalToNumber(r)\n	case "%":\n		return math.Mod(evalToNumber(l), evalToNumber(r))\n	case "<", "<=", ">", ">=":\n		return evalRelational(op, l, r)\n	case "===":\n		return evalStrictEq(l, r)\n	case "!==":\n		return !evalStrictEq(l, r)\n	}\n	// Loose equality / bitwise / shift are out of the subset.\n	return nil\n}\n\nfunc evalRelational(op string, l, r any) bool {\n	// JS Abstract Relational Comparison: both strings \u2192 compare by code\n	// unit; otherwise coerce both to numbers (a NaN operand makes every\n	// comparison false).\n	var c int\n	ls, lok := l.(string)\n	rs, rok := r.(string)\n	if lok && rok {\n		if ls < rs {\n			c = -1\n		} else if ls > rs {\n			c = 1\n		}\n	} else {\n		ln := evalToNumber(l)\n		rn := evalToNumber(r)\n		if math.IsNaN(ln) || math.IsNaN(rn) {\n			return false\n		}\n		if ln < rn {\n			c = -1\n		} else if ln > rn {\n			c = 1\n		}\n	}\n	switch op {\n	case "<":\n		return c < 0\n	case "<=":\n		return c <= 0\n	case ">":\n		return c > 0\n	case ">=":\n		return c >= 0\n	}\n	return false\n}\n\nfunc evalStrictEq(l, r any) bool {\n	// Strict `===`: equal JS type and value, no coercion. All numeric Go\n	// types are the single JS "number" type, so int 2 === float64 2.\n	lnum := evalIsNumeric(l)\n	rnum := evalIsNumeric(r)\n	if lnum && rnum {\n		lf, rf := toFloat64(l), toFloat64(r)\n		if math.IsNaN(lf) || math.IsNaN(rf) {\n			return false\n		}\n		return lf == rf\n	}\n	if lnum != rnum {\n		return false\n	}\n	switch lv := l.(type) {\n	case nil:\n		return r == nil\n	case string:\n		rv, ok := r.(string)\n		return ok && rv == lv\n	case bool:\n		rv, ok := r.(bool)\n		return ok && rv == lv\n	}\n	// Non-primitive operands (arrays / objects) are outside the subset: the JS\n	// reference refuses `===` on them and the compiler gates such a body with\n	// BF101 upstream, so this is unreachable for an in-subset corpus. The\n	// runtime trusts that gate rather than re-validating, returning false\n	// here (it does not attempt JS reference identity, which templates can\'t\n	// model anyway).\n	return false\n}\n\n// evalSameValueZero implements `Array.prototype.includes`\'s membership\n// comparison: `===` except `NaN` equals itself (JS\'s SameValueZero). Reuses\n// evalStrictEq \u2014 the one divergence, both operands NaN, is checked first;\n// every other pair (including "one NaN, one not") falls through to the same\n// equality `evalBinary`\'s `===` uses, so the two operators stay in lockstep.\nfunc evalSameValueZero(a, b any) bool {\n	if evalIsNumeric(a) && evalIsNumeric(b) {\n		af, bf := toFloat64(a), toFloat64(b)\n		if math.IsNaN(af) && math.IsNaN(bf) {\n			return true\n		}\n	}\n	return evalStrictEq(a, b)\n}\n\n// evalIncludes implements `.includes(needle)`, shared between\n// `Array.prototype.includes` (SameValueZero membership over a slice/array\n// receiver) and `String.prototype.includes` (substring search), mirroring\n// the receiver-type dispatch the SSR template lowering already does\n// (`bf_includes`). Any other receiver type is not a JS `.includes` target;\n// this degrades to false rather than panicking (there is no receiver here\n// for which JS itself would throw), matching the JS reference\n// (eval-reference.ts `includes`).\nfunc evalIncludes(obj, needle any) bool {\n	if arr := toAnySlice(obj); arr != nil {\n		for _, el := range arr {\n			if evalSameValueZero(el, needle) {\n				return true\n			}\n		}\n		return false\n	}\n	if s, ok := obj.(string); ok {\n		return strings.Contains(s, evalToString(needle))\n	}\n	return false\n}\n\nfunc evalUnary(op string, v any) any {\n	switch op {\n	case "!":\n		return !evalTruthy(v)\n	case "-":\n		return -evalToNumber(v)\n	case "+":\n		return evalToNumber(v)\n	}\n	return nil\n}\n\n// ---------------------------------------------------------------------------\n// Built-in calls (the deterministic allowlist). Locale-sensitive builtins\n// (localeCompare) are deliberately excluded to keep the backends isomorphic.\n// ---------------------------------------------------------------------------\n\n// evalBuiltinName resolves a `call` callee to its builtin name (e.g.\n// "Math.max"), or "" if the callee is not an allowlisted builtin reference.\nfunc evalBuiltinName(callee any) string {\n	cm, ok := callee.(map[string]any)\n	if !ok {\n		return ""\n	}\n	switch cm["kind"] {\n	case "identifier":\n		name, _ := cm["name"].(string)\n		return name\n	case "member":\n		if computed, _ := cm["computed"].(bool); computed {\n			return ""\n		}\n		obj, _ := cm["object"].(map[string]any)\n		if obj == nil || obj["kind"] != "identifier" {\n			return ""\n		}\n		objName, _ := obj["name"].(string)\n		prop, _ := cm["property"].(string)\n		return objName + "." + prop\n	}\n	return ""\n}\n\n// evalMathRound rounds a half toward +Infinity (JS Math.round: 2.5\u21923,\n// -2.5\u2192-2), matching the existing `round` helper rather than Go\'s math.Round.\nfunc evalMathRound(n float64) float64 {\n	// floor(n+0.5) yields +0 for x in [-0.5, -0], where JS Math.round returns\n	// -0. That sign is only observable through a subsequent division\n	// (`1 / Math.round(-0.5)` is -Infinity in JS, +Infinity here) \u2014 through\n	// ToString both \xB10 render "0". It is left as +0 deliberately: the two SSR\n	// backends must stay equal, and Perl can\'t reproduce the -0 divisor sign\n	// without fragile, version-dependent zero handling (its native `/` even\n	// dies on a zero divisor). So Math.round\'s -0 is a JS-reference-only\n	// divergence region, like the astral-plane / radix-string carve-outs.\n	return math.Floor(n + 0.5)\n}\n\nfunc evalCallBuiltin(name string, args []any) any {\n	switch name {\n	case "Math.max":\n		if len(args) == 0 {\n			return math.Inf(-1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Max(m, evalToNumber(a))\n		}\n		return m\n	case "Math.min":\n		if len(args) == 0 {\n			return math.Inf(1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Min(m, evalToNumber(a))\n		}\n		return m\n	case "Math.abs":\n		return math.Abs(evalToNumber(arg0(args)))\n	case "Math.floor":\n		return math.Floor(evalToNumber(arg0(args)))\n	case "Math.ceil":\n		return math.Ceil(evalToNumber(arg0(args)))\n	case "Math.round":\n		return evalMathRound(evalToNumber(arg0(args)))\n	case "String":\n		return evalToString(arg0(args))\n	case "Number":\n		return evalToNumber(arg0(args))\n	case "Boolean":\n		return evalTruthy(arg0(args))\n	}\n	// Any other callee is outside the subset (refused upstream).\n	return nil\n}\n\nfunc arg0(args []any) any {\n	if len(args) == 0 {\n		return nil\n	}\n	return args[0]\n}\n\n// ---------------------------------------------------------------------------\n// Member / index access\n// ---------------------------------------------------------------------------\n\nfunc evalReadProperty(obj any, key string) any {\n	switch o := obj.(type) {\n	case string:\n		if key == "length" {\n			// Code-point count (== JS UTF-16 length across the BMP, == Perl\n			// `length`). RuneCountInString avoids the []rune allocation since\n			// this can run inside comparator / reducer evaluation.\n			return utf8.RuneCountInString(o)\n		}\n		return nil\n	case []any:\n		if key == "length" {\n			return len(o)\n		}\n		return nil\n	case map[string]any:\n		// Case-variant lookup: a callback body reads the raw JS property\n		// (`t.duration`), but test data / Go-keyed maps may carry PascalCase\n		// keys (`{"Duration": \u2026}`). Reuse the field reader the sort / reduce\n		// helpers use \u2014 it resolves `duration` \u2192 `Duration` and reads a\n		// genuinely missing key as null (the backends\' single absent value).\n		return getFieldValue(o, key)\n	case nil:\n		return nil\n	default:\n		// Real template data (Go structs): reuse the field reader the sort /\n		// reduce helpers use, which handles case-variant keys.\n		return getFieldValue(obj, key)\n	}\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order folds (the generalization of bf_reduce /\n// bf_sort onto the evaluator)\n//\n// These prove the evaluator subsumes the special-cased callback catalogue:\n// the callback BODY is carried as a pure ParsedExpr (JSON) and evaluated per\n// element against an environment, so the op restriction (bf_reduce\'s +/*),\n// the acc-canonical form, and the comparator pattern restriction (bf_sort)\n// all disappear \u2014 any pure reducer / comparator body works. They are the\n// runtime half of the integration; the compiler-side emit migration (carrying\n// callback bodies as ParsedExpr) and the byte-equal divergence decision for\n// the string-`localeCompare` sort path (won\'t-fix for byte-equal SSR, see\n// spec/compiler.md Known limitations) are the remaining follow-up.\n// ---------------------------------------------------------------------------\n\n// toAnySlice copies a reflect-iterable receiver into a fresh []any, returning\n// nil for a non-slice/array (matching the bf_sort / bf_reduce nil-tolerance).\nfunc toAnySlice(items any) []any {\n	v := reflect.ValueOf(items)\n	// A nil interface yields an invalid Value (Kind() == Invalid, not a\n	// panic), so the Slice/Array guard below already tolerates nil; the\n	// explicit IsValid check just documents the nil-tolerance intent.\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	out := make([]any, v.Len())\n	for i := range out {\n		out[i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// FoldEval folds items into a value via the ParsedExpr evaluator. The reducer\n// body is a pure ParsedExpr (JSON) evaluated against `{accName: acc, itemName:\n// item}` plus the captured free vars in `baseEnv` for each element; `init`\n// seeds the accumulator and `direction` is "left" (reduce) or "right"\n// (reduceRight). This is the evaluator-based generalization of bf_reduce \u2014 any\n// reducer body, not just the `+`/`*` arithmetic catalogue, and `acc` may\n// appear anywhere in the body. `baseEnv` may be nil when the body captures no\n// outer references; the accName / itemName keys shadow any same-named base key.\nfunc FoldEval(items any, bodyJSON, accName, itemName string, init any, direction string, baseEnv map[string]any) any {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return init\n	}\n	arr := toAnySlice(items)\n	if direction == "right" {\n		for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {\n			arr[i], arr[j] = arr[j], arr[i]\n		}\n	}\n	acc := init\n	// Seed the env from the captured free vars once; acc / item are\n	// overwritten each iteration (constant base keys carry through).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	for _, item := range arr {\n		env[accName] = acc\n		env[itemName] = item\n		acc = EvalNode(body, env)\n	}\n	return acc\n}\n\n// SortEval returns a new stable-sorted slice ordered by a ParsedExpr\n// comparator body (JSON) evaluated against `{paramA: a, paramB: b}` plus the\n// captured free vars in `baseEnv` to a number (negative / zero / positive,\n// like a JS comparator). This is the evaluator-based generalization of bf_sort\n// \u2014 any comparator body, not just the subtraction / relational-ternary\n// catalogue. `baseEnv` may be nil. Non-mutating.\nfunc SortEval(items any, cmpJSON, paramA, paramB string, baseEnv map[string]any) []any {\n	arr := toAnySlice(items)\n	if arr == nil {\n		return nil\n	}\n	var cmp any\n	if err := json.Unmarshal([]byte(cmpJSON), &cmp); err != nil {\n		return arr\n	}\n	// One env seeded from the captured free vars; the two operand keys are\n	// overwritten per comparison (the comparator runs synchronously).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	sort.SliceStable(arr, func(i, j int) bool {\n		env[paramA] = arr[i]\n		env[paramB] = arr[j]\n		return evalToNumber(EvalNode(cmp, env)) < 0\n	})\n	return arr\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order predicates (#2018, P2) \u2014 the generalization\n// of bf_filter / bf_find / bf_find_index / bf_every / bf_some onto the\n// evaluator. The predicate BODY travels as a pure ParsedExpr (JSON) and is\n// evaluated per element against `{param: item}` plus the captured free vars in\n// `baseEnv`, lifting the field-equality / truthiness restriction of the\n// special-cased helpers to any pure predicate. `baseEnv` may be nil.\n// ---------------------------------------------------------------------------\n\n// decodeEvalBody unmarshals a serialized ParsedExpr body; ok is false on bad\n// JSON (only reachable by a corrupt emit \u2014 the adapter always emits valid JSON).\nfunc decodeEvalBody(bodyJSON string) (any, bool) {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return nil, false\n	}\n	return body, true\n}\n\n// seedPredEnv copies the captured free vars into a fresh env with room for the\n// single predicate param, which the callers overwrite per element.\nfunc seedPredEnv(baseEnv map[string]any) map[string]any {\n	env := make(map[string]any, len(baseEnv)+1)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	return env\n}\n\n// FilterEval returns a new slice of the elements for which the predicate body\n// evaluates truthy \u2014 the evaluator generalization of bf_filter. Returns a\n// non-nil empty slice when nothing matches (so a downstream `range` / `bf_join`\n// sees a real slice); returns nil only on a bad body.\nfunc FilterEval(items any, predJSON, param string, baseEnv map[string]any) []any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// EveryEval reports whether every element satisfies the predicate (vacuously\n// true for an empty receiver, like JS) \u2014 the generalization of bf_every.\nfunc EveryEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if !evalTruthy(EvalNode(pred, env)) {\n			return false\n		}\n	}\n	return true\n}\n\n// SomeEval reports whether any element satisfies the predicate (false for an\n// empty receiver, like JS) \u2014 the generalization of bf_some.\nfunc SomeEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			return true\n		}\n	}\n	return false\n}\n\n// FindEval returns the first element satisfying the predicate, or nil when none\n// does \u2014 the generalization of bf_find. `forward` false searches from the end\n// (findLast).\nfunc FindEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return arr[i]\n		}\n	}\n	return nil\n}\n\n// FindIndexEval returns the index of the first element satisfying the predicate,\n// or -1 when none does \u2014 the generalization of bf_find_index. `forward` false\n// searches from the end (findLastIndex).\nfunc FindIndexEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) int {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return -1\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return i\n		}\n	}\n	return -1\n}\n\n// FlatMapEval projects each element through the projection body (a pure\n// ParsedExpr JSON evaluated against `{param: item}` + baseEnv) and flattens the\n// results one level \u2014 the evaluator generalization of bf_flat_map /\n// bf_flat_map_tuple. A projection that yields a slice contributes its elements;\n// any other value contributes itself (matching JS `.flatMap`, where a non-array\n// return is kept as a single element). Returns a non-nil empty slice on a bad\n// body so a downstream `range` / `bf_join` sees a real slice.\nfunc FlatMapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		v := EvalNode(proj, env)\n		// Flatten any slice/array kind one level, not just []any: real Go\n		// template data projects a field like `i.tags` to a typed slice\n		// (`[]string` / `[]int`), which `toAnySlice` normalizes to []any. A\n		// non-slice value (string / number / struct / nil) contributes itself,\n		// matching JS `.flatMap` (a non-array return is kept as one element).\n		if sub := toAnySlice(v); sub != nil {\n			out = append(out, sub...)\n		} else {\n			out = append(out, v)\n		}\n	}\n	return out\n}\n\n// MapEval projects each element through the projection body (a pure ParsedExpr\n// JSON evaluated against `{param: item}` + baseEnv), keeping one result per\n// element \u2014 the value-producing `.map(cb)` lowering (#2073). Unlike\n// FlatMapEval there is no flatten: a projection yielding a slice contributes\n// that slice as a single element, matching JS `.map`. Returns a non-nil empty\n// slice on a bad body so a downstream `range` / `bf_join` sees a real slice.\nfunc MapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		out = append(out, EvalNode(proj, env))\n	}\n	return out\n}\n\n// Env builds the captured-free-var environment for FoldEval / SortEval from a\n// flat key, value, key, value, \u2026 argument list \u2014 the adapter emits\n// `bf_env "k1" v1 "k2" v2 \u2026` for the free variables a callback body references\n// beyond its own params. An odd trailing key with no value is ignored; with no\n// pairs it returns an empty (non-nil) map, the no-capture case. A non-string\n// key (only reachable by a malformed template call, never by the adapter\'s\n// quoted-literal emit) is skipped rather than collapsed into an `env[""]` slot.\nfunc Env(pairs ...any) map[string]any {\n	env := make(map[string]any, len(pairs)/2)\n	for i := 0; i+1 < len(pairs); i += 2 {\n		key, ok := pairs[i].(string)\n		if !ok {\n			continue\n		}\n		env[key] = pairs[i+1]\n	}\n	return env\n}\n\nfunc evalReadIndex(obj any, index any) any {\n	switch o := obj.(type) {\n	case []any:\n		f := evalToNumber(index)\n		i := int(f)\n		if float64(i) != f || i < 0 || i >= len(o) {\n			return nil\n		}\n		return o[i]\n	case map[string]any:\n		return o[evalToString(index)]\n	case nil:\n		return nil\n	default:\n		return getFieldValue(obj, evalToString(index))\n	}\n}\n';
     streamingGoSource = `// Package bf \u2014 Out-of-Order Streaming SSR helpers
 //
 // Provides StreamRenderer for progressive page rendering using HTTP
@@ -26736,6 +27548,7 @@ function goCommonFiles() {
     "renderer.go": GO_RENDERER_GO,
     "env.go": GO_ENV_GO,
     "bf-runtime/bf.go": bfGoSource,
+    "bf-runtime/eval.go": evalGoSource,
     "bf-runtime/streaming.go": streamingGoSource,
     "bf-runtime/bfdev/bfdev.go": bfdevGoSource,
     "bf-runtime/go.mod": GO_BF_RUNTIME_GO_MOD,
@@ -26750,13 +27563,16 @@ function goCommonFiles() {
     "public/styles.css": STYLES_CSS,
     "public/tokens.css": TOKENS_CSS,
     "public/uno.css": UNO_CSS_PLACEHOLDER,
+    "public/favicon.svg": FAVICON_SVG,
     ".gitignore": GO_GITIGNORE
   };
 }
 function goScripts() {
   return {
     dev: 'go mod tidy && bf build && unocss && concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "go run ."',
-    build: "go mod tidy && bf build && unocss",
+    // `--minify` (not on `dev`): matches the site's "~14 kB min+gzip"
+    // runtime-size claim, which is measured on a minified build.
+    build: "go mod tidy && bf build --minify && unocss",
     start: "go run ."
   };
 }
@@ -26851,6 +27667,7 @@ func defaultLayout(ctx *bf.RenderContext) string {
 	<meta charset="utf-8" />
 	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 	<title>%s</title>
+	${faviconLinkTag("/static/favicon.svg")}
 	${CSS_LINKS_BEGIN}
 	<!-- Link all three sheets so the browser fetches them in parallel \u2014
 	     chaining via styles.css @import would defer tokens/uno to a
@@ -26934,6 +27751,7 @@ func IsDev() bool {
 // inside Slot that's only reachable when AsChild=true.
 func loadTemplates() (*template.Template, error) {
 	root := template.New("").Funcs(bf.FuncMap())
+	root = root.Funcs(bf.TemplateFuncMap(root))
 	if _, err := root.New("Tag").Parse(""); err != nil {
 		return nil, err
 	}
@@ -27243,6 +28061,7 @@ server.listen(port, () => {
   <script type="importmap">
     { "imports": { "@barefootjs/client/runtime": "/static/components/barefoot.js" } }
   </script>
+  ${faviconLinkTag("/static/favicon.svg")}
   ${CSS_LINKS_BEGIN}
   <!-- Link all three sheets so the browser fetches them in parallel \u2014
        chaining via styles.css @import would defer tokens/uno to a
@@ -27305,11 +28124,14 @@ server.listen(port, () => {
         "public/styles.css": STYLES_CSS,
         "public/tokens.css": TOKENS_CSS,
         "public/uno.css": UNO_CSS_PLACEHOLDER,
+        "public/favicon.svg": FAVICON_SVG,
         ".gitignore": CSR_GITIGNORE
       },
       scripts: {
         dev: 'bf build && unocss && concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "tsx watch server.ts"',
-        build: "bf build && unocss",
+        // `--minify` (not on `dev`): matches the site's "~14 kB min+gzip"
+        // runtime-size claim, which is measured on a minified build.
+        build: "bf build --minify && unocss",
         start: "tsx server.ts"
       },
       dependencies: {
@@ -27444,6 +28266,7 @@ func defaultLayout(ctx *bf.RenderContext) string {
 	<meta charset="utf-8" />
 	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 	<title>%s</title>
+	${faviconLinkTag("/static/favicon.svg")}
 	${CSS_LINKS_BEGIN}
 	<!-- Link all three sheets so the browser fetches them in parallel \u2014
 	     chaining via styles.css @import would defer tokens/uno to a
@@ -27514,6 +28337,7 @@ import (
 // updated boilerplate).
 func loadTemplates() (*template.Template, error) {
 	root := template.New("").Funcs(bf.FuncMap())
+	root = root.Funcs(bf.TemplateFuncMap(root))
 	if _, err := root.New("Tag").Parse(""); err != nil {
 		return nil, err
 	}
@@ -27803,6 +28627,7 @@ replace github.com/barefootjs/runtime/bf => ./bf-runtime
         "env.go": ECHO_ENV_GO,
         "go.mod": ECHO_GO_MOD,
         "bf-runtime/bf.go": bfGoSource,
+        "bf-runtime/eval.go": evalGoSource,
         "bf-runtime/streaming.go": streamingGoSource,
         "bf-runtime/go.mod": ECHO_BF_RUNTIME_GO_MOD,
         "barefoot.config.ts": ECHO_BAREFOOT_CONFIG_TS,
@@ -27816,11 +28641,14 @@ replace github.com/barefootjs/runtime/bf => ./bf-runtime
         "public/styles.css": STYLES_CSS,
         "public/tokens.css": TOKENS_CSS,
         "public/uno.css": UNO_CSS_PLACEHOLDER,
+        "public/favicon.svg": FAVICON_SVG,
         ".gitignore": ECHO_GITIGNORE
       },
       scripts: {
         dev: 'go mod tidy && bf build && unocss && concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "go run ."',
-        build: "go mod tidy && bf build && unocss",
+        // `--minify` (not on `dev`): matches the site's "~14 kB min+gzip"
+        // runtime-size claim, which is measured on a minified build.
+        build: "go mod tidy && bf build --minify && unocss",
         start: "go run ."
       },
       dependencies: {
@@ -27969,7 +28797,6 @@ var HONO_SERVER_TSX, HONO_RENDERER_TSX, HONO_BAREFOOT_CONFIG_TS, HONO_TSCONFIG,
 var init_hono = __esm({
   "src/lib/adapters/hono.ts"() {
     "use strict";
-    init_pm();
     init_shared2();
     HONO_SERVER_TSX = `import { Hono } from 'hono'
 import { renderer } from './renderer'
@@ -28009,6 +28836,7 @@ export const renderer = jsxRenderer(({ children, title }) => (
       <meta charset="UTF-8" />
       <meta name="viewport" content="width=device-width, initial-scale=1.0" />
       <title>{title ?? 'BarefootJS app'}</title>
+      ${faviconLinkTag("/favicon.svg")}
       ${CSS_LINKS_BEGIN}
       {/* Link all three sheets so the browser fetches them in
           parallel \u2014 chaining via styles.css @import would defer
@@ -28125,15 +28953,22 @@ export default createConfig({
         "public/styles.css": STYLES_CSS,
         "public/tokens.css": TOKENS_CSS,
         "public/uno.css": UNO_CSS_PLACEHOLDER,
+        "public/favicon.svg": FAVICON_SVG,
         "public/components/manifest.json": COMPONENTS_MANIFEST_SEED,
         ".gitignore": HONO_GITIGNORE
       },
       scripts: {
-        dev: (pm) => `concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "${commandsFor(pm).exec(
-          "wrangler dev --live-reload"
-        )}"`,
-        build: "bf build && unocss",
-        deploy: (pm) => `bf build && unocss && ${commandsFor(pm).exec("wrangler deploy")}`
+        // `wrangler` is a devDependency below, so package.json scripts
+        // resolve it straight from `node_modules/.bin` — no `npx`/`bunx`/
+        // `pnpm dlx` wrapper needed (and no unpinned download on first
+        // `<pm> run dev`, since the version is pinned in devDependencies).
+        dev: 'concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "wrangler dev --live-reload"',
+        // `--minify` here (not on `dev`/`watch`): the site's landing-page
+        // runtime-size claim ("~14 kB min+gzip", site/core/build.ts) is
+        // measured on a minified build, and the dev pipeline intentionally
+        // serves the unminified runtime for readable stack traces.
+        build: "bf build --minify && unocss",
+        deploy: "bf build --minify && unocss && wrangler deploy"
       },
       deploy: {
         target: "Cloudflare Workers",
@@ -28162,7 +28997,12 @@ export default createConfig({
         // doesn't ship vitest, and an npm project doesn't ship a bun-only
         // type package.
         concurrently: "^9.0.0",
-        typescript: "^5.6.0"
+        typescript: "^5.6.0",
+        // Pinned so `<pm> run dev` / `<pm> run deploy` resolve a known
+        // `wrangler` from `node_modules/.bin` instead of pausing on an
+        // unpinned download the first time they run (see the `scripts`
+        // comment above — this is what makes the bare invocation safe).
+        wrangler: "^4.0.0"
       },
       prereqWarnings: () => []
     };
@@ -28304,6 +29144,7 @@ export function createRenderer({ componentsBase }: CreateRendererOptions) {
           <meta charset="UTF-8" />
           <meta name="viewport" content="width=device-width, initial-scale=1.0" />
           <title>{title ?? 'BarefootJS app'}</title>
+          ${faviconLinkTag("/static/favicon.svg")}
           ${CSS_LINKS_BEGIN}
           {/* Link all three sheets so the browser fetches them in
               parallel \u2014 chaining via styles.css @import would defer
@@ -28401,12 +29242,15 @@ export default createConfig({
         "public/styles.css": STYLES_CSS,
         "public/tokens.css": TOKENS_CSS,
         "public/uno.css": UNO_CSS_PLACEHOLDER,
+        "public/favicon.svg": FAVICON_SVG,
         "dist/components/manifest.json": COMPONENTS_MANIFEST_SEED,
         ".gitignore": HONO_NODE_GITIGNORE
       },
       scripts: {
         dev: 'bf build && unocss && concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "tsx watch server.tsx"',
-        build: "bf build && unocss",
+        // `--minify` (not on `dev`): matches the site's "~14 kB min+gzip"
+        // runtime-size claim, which is measured on a minified build.
+        build: "bf build --minify && unocss",
         start: "tsx server.tsx"
       },
       dependencies: {
@@ -28512,8 +29356,12 @@ get '/static/*asset' => sub ($c) {
     $c->reply->static($c->stash('asset') // '') or $c->reply->not_found;
 };
 
+# Component props are ordinary stash values. The plugin seeds every
+# template variable's static default from the build manifest, so
+# passing \`initial\` here is optional \u2014 but it's how you hand real
+# data to a component, so the starter route shows the shape.
 get '/' => sub ($c) {
-    $c->render(template => 'Counter', layout => 'default');
+    $c->render(template => 'Counter', layout => 'default', initial => 0);
 };
 
 app->start;
@@ -28527,6 +29375,7 @@ __DATA__
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>BarefootJS app</title>
+    ${faviconLinkTag("/static/favicon.svg")}
     ${CSS_LINKS_BEGIN}
     <!-- Link all three sheets so the browser fetches them in parallel \u2014
          chaining via styles.css @import would defer tokens/uno to a
@@ -28606,6 +29455,7 @@ requires 'Mojolicious', '9.0';
         "public/styles.css": STYLES_CSS,
         "public/tokens.css": TOKENS_CSS,
         "public/uno.css": UNO_CSS_PLACEHOLDER,
+        "public/favicon.svg": FAVICON_SVG,
         "dist/components/manifest.json": COMPONENTS_MANIFEST_SEED,
         ".gitignore": MOJO_GITIGNORE
       },
@@ -28620,7 +29470,9 @@ requires 'Mojolicious', '9.0';
         // a concern now that the adapter lowers that expression
         // natively.)
         dev: 'concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "morbo app.pl -l http://*:3002"',
-        build: "bf build && unocss",
+        // `--minify` (not on `dev`): matches the site's "~14 kB min+gzip"
+        // runtime-size claim, which is measured on a minified build.
+        build: "bf build --minify && unocss",
         start: "perl app.pl daemon -l http://*:3002"
       },
       dependencies: {
@@ -28922,6 +29774,7 @@ sub layout (%a) {
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>BarefootJS app</title>
+    ${faviconLinkTag("/static/favicon.svg")}
     ${CSS_LINKS_BEGIN}
     <!-- Link all three sheets so the browser fetches them in parallel.
          tokens first so its CSS variables exist before any rule uses them. -->
@@ -29109,6 +29962,7 @@ describe('Counter', () => {
         "public/styles.css": STYLES_CSS,
         "public/tokens.css": TOKENS_CSS,
         "public/uno.css": UNO_CSS_PLACEHOLDER,
+        "public/favicon.svg": FAVICON_SVG,
         "dist/components/manifest.json": COMPONENTS_MANIFEST_SEED,
         ".gitignore": XSLATE_GITIGNORE
       },
@@ -29118,7 +29972,9 @@ describe('Counter', () => {
         // Starman (not plackup's default single-process server) so the
         // dev-reload SSE endpoint can stream while requests are served.
         dev: `concurrently -k -n build,uno,server -c blue,magenta,green "bf build --watch" "unocss --watch" "plackup -s Starman --workers 5 -p ${XSLATE_PORT} app.psgi"`,
-        build: "bf build && unocss",
+        // `--minify` (not on `dev`): matches the site's "~14 kB min+gzip"
+        // runtime-size claim, which is measured on a minified build.
+        build: "bf build --minify && unocss",
         start: `PLACK_ENV=production plackup -s Starman --workers 5 -p ${XSLATE_PORT} app.psgi`
       },
       dependencies: {
@@ -29189,6 +30045,9 @@ var init_templates = __esm({
 
 // src/lib/select.ts
 import readline from "node:readline";
+function confirmationLabel(opt) {
+  return opt.shortLabel ?? opt.label.replace(/\s*\(.*\)$/, "");
+}
 async function select(args2) {
   const input = args2.input ?? process.stdin;
   const output = args2.output ?? process.stdout;
@@ -29251,7 +30110,7 @@ async function select(args2) {
       if (key.name === "return") {
         cleanup();
         const picked = args2.options[cursor];
-        const shortLabel = picked.shortLabel ?? picked.label.replace(/\s*\(.*\)$/, "");
+        const shortLabel = confirmationLabel(picked);
         const totalLines = args2.options.length + 1;
         output.write(`\x1B[${totalLines}A`);
         for (let i = 0; i < totalLines; i++) {
@@ -29372,13 +30231,91 @@ var init_css = __esm({
   }
 });
 
+// src/lib/readme.ts
+function generateReadmeMd(pkgName, adapter, pm) {
+  const cmd = commandsFor(pm);
+  const lines = [];
+  lines.push(`# ${pkgName}`, "");
+  lines.push(
+    `A [BarefootJS](https://barefootjs.dev) app scaffolded with the **${adapter.label}** adapter.`,
+    ""
+  );
+  lines.push("## Getting started", "");
+  lines.push("```sh");
+  lines.push(cmd.install);
+  if (adapter.extraSetupSteps) {
+    for (const step of adapter.extraSetupSteps) {
+      if (step.label) lines.push(`# ${step.label}`);
+      lines.push(step.command);
+    }
+  }
+  lines.push(cmd.run("dev"));
+  lines.push("```", "");
+  if (adapter.scripts.build || adapter.deploy) {
+    lines.push("## Build & deploy", "");
+    lines.push("```sh");
+    if (adapter.scripts.build) lines.push(cmd.run("build"));
+    if (adapter.deploy) {
+      lines.push(`${cmd.run(adapter.deploy.script)}   # deploy to ${adapter.deploy.target}`);
+    }
+    lines.push("```", "");
+  }
+  lines.push("## `bf` CLI cheat sheet", "");
+  lines.push(
+    "The `bf` CLI is the first reference for component APIs and framework docs \u2014 run `bf --help` for the full command list.",
+    ""
+  );
+  lines.push("| Command | What it does |");
+  lines.push("| --- | --- |");
+  lines.push("| `bf search <term>` | Search the component registry |");
+  lines.push("| `bf add <component>` | Add a component from the registry |");
+  lines.push("| `bf docs <component>` | Show a component's API surface |");
+  lines.push(
+    '| `bf debug graph <component>` | Inspect a `"use client"` component\'s reactive signal graph |'
+  );
+  lines.push("| `bf guide` | Open the framework guide |");
+  lines.push("");
+  lines.push("## Generated output", "");
+  lines.push(
+    "The compiled output directory (produced by `bf build`) is regenerated on every build \u2014 don't edit it by hand.",
+    ""
+  );
+  return lines.join("\n");
+}
+var init_readme = __esm({
+  "src/lib/readme.ts"() {
+    "use strict";
+    init_pm();
+  }
+});
+
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
   run: () => run4
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import path10 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function readCliVersion() {
+  const bundledPkgJsonPath = path10.resolve(path10.dirname(thisFile), "../package.json");
+  const devPkgJsonPath = path10.resolve(path10.dirname(thisFile), "../../package.json");
+  const pkgJsonPath = existsSync8(bundledPkgJsonPath) ? bundledPkgJsonPath : devPkgJsonPath;
+  const { version } = JSON.parse(readFileSync5(pkgJsonPath, "utf-8"));
+  if (typeof version !== "string" || version.length === 0) {
+    throw new Error(
+      `Could not read the CLI's own version from ${pkgJsonPath} \u2014 cannot pin @barefootjs/* scaffold dependencies.`
+    );
+  }
+  return version;
+}
+function pinBarefootDeps(deps) {
+  const pinned = {};
+  for (const [name2, version] of Object.entries(deps)) {
+    pinned[name2] = name2.startsWith("@barefootjs/") && version === "latest" ? `^${CLI_VERSION}` : version;
+  }
+  return pinned;
+}
 function parseFlags(args2) {
   const flags = {};
   for (let i = 0; i < args2.length; i++) {
@@ -29403,6 +30340,10 @@ async function run4(args2, ctx2) {
     console.error("  # or: pnpm create barefootjs");
     process.exit(1);
   }
+  if (args2.includes("--list-adapters")) {
+    printAdapterList();
+    process.exit(0);
+  }
   const projectDir = process.cwd();
   const flags = parseFlags(args2);
   const tsConfigPath = path10.join(projectDir, "barefoot.config.ts");
@@ -29457,10 +30398,16 @@ async function run4(args2, ctx2) {
 async function resolveAdapter(flag) {
   if (flag) {
     if (!ADAPTERS[flag]) {
-      const known = Object.keys(ADAPTERS).join(", ");
-      console.error(`Error: unknown adapter "${flag}". Available: ${known}`);
+      const hint = LANGUAGE_ADAPTER_HINTS[flag.toLowerCase()];
+      if (hint) {
+        console.error(`Error: unknown adapter "${flag}". ${hint}`);
+      } else {
+        const known = Object.keys(ADAPTERS).join(", ");
+        console.error(`Error: unknown adapter "${flag}". Available: ${known}`);
+      }
       process.exit(1);
     }
+    printSelectConfirmation(ADAPTER_SELECT_MESSAGE, ADAPTERS[flag]);
     return flag;
   }
   const options2 = Object.entries(ADAPTERS).map(([value2, t]) => ({
@@ -29469,7 +30416,7 @@ async function resolveAdapter(flag) {
     shortLabel: t.shortLabel
   }));
   try {
-    return await select({ message: "Choose a framework or runtime", options: options2, defaultValue: DEFAULT_ADAPTER });
+    return await select({ message: ADAPTER_SELECT_MESSAGE, options: options2, defaultValue: DEFAULT_ADAPTER });
   } catch (err) {
     bailOnSelectError(err);
   }
@@ -29481,15 +30428,36 @@ async function resolveCssLibrary(flag) {
       console.error(`Error: unknown CSS library "${flag}". Available: ${known}`);
       process.exit(1);
     }
+    printSelectConfirmation(CSS_SELECT_MESSAGE, CSS_LIBRARIES[flag]);
     return flag;
   }
   const options2 = Object.entries(CSS_LIBRARIES).map(([value2, t]) => ({ value: value2, label: t.label }));
   try {
-    return await select({ message: "Choose a CSS library", options: options2, defaultValue: DEFAULT_CSS_LIBRARY });
+    return await select({ message: CSS_SELECT_MESSAGE, options: options2, defaultValue: DEFAULT_CSS_LIBRARY });
   } catch (err) {
     bailOnSelectError(err);
   }
 }
+function printSelectConfirmation(message, opt) {
+  const label2 = confirmationLabel(opt);
+  const highlighted = process.stdout.isTTY ? `\x1B[1;32m${label2}\x1B[0m` : label2;
+  console.log(`\u2714 ${message} ${highlighted}`);
+}
+function printAdapterList() {
+  const adapterIds = Object.keys(ADAPTERS);
+  const idWidth = Math.max(...adapterIds.map((id2) => id2.length));
+  console.log("Adapters (--adapter <id>):");
+  for (const id2 of adapterIds) {
+    console.log(`  ${id2.padEnd(idWidth)}  ${ADAPTERS[id2].label}`);
+  }
+  console.log("");
+  const cssIds = Object.keys(CSS_LIBRARIES);
+  const cssWidth = Math.max(...cssIds.map((id2) => id2.length));
+  console.log("CSS libraries (--css <id>):");
+  for (const id2 of cssIds) {
+    console.log(`  ${id2.padEnd(cssWidth)}  ${CSS_LIBRARIES[id2].label}`);
+  }
+}
 function bailOnSelectError(err) {
   if (err instanceof SelectCancelled) {
     console.error("Cancelled \u2014 nothing scaffolded.");
@@ -29545,6 +30513,11 @@ async function scaffoldApp(projectDir, adapter, flags, usesUno, _ctx) {
     JSON.stringify({ version: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), components: [] }, null, 2) + "\n"
   );
   created++;
+  const readmePath = path10.join(projectDir, "README.md");
+  if (!existsSync8(readmePath)) {
+    writeFileSync3(readmePath, generateReadmeMd(pkgName, adapter, pm));
+    created++;
+  }
   const pkgJsonPath = path10.join(projectDir, "package.json");
   const resolvedAdapterScripts = {};
   for (const [k, v] of Object.entries(adapter.scripts)) {
@@ -29574,8 +30547,10 @@ async function scaffoldApp(projectDir, adapter, flags, usesUno, _ctx) {
       // without manual migration. See `testRunnerFor` in `../lib/pm.ts`.
       test: runner.scriptValue
     },
-    dependencies: { ...adapter.dependencies },
-    devDependencies: { ...adapterDevDeps, ...pmDevDeps }
+    // `@barefootjs/*` entries are pinned from the `'latest'` sentinel to
+    // `^<CLI_VERSION>` here — see `pinBarefootDeps` above.
+    dependencies: pinBarefootDeps({ ...adapter.dependencies }),
+    devDependencies: pinBarefootDeps({ ...adapterDevDeps, ...pmDevDeps })
   };
   if (!existsSync8(pkgJsonPath)) {
     writeFileSync3(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
@@ -29623,7 +30598,7 @@ function heading(s) {
 function dim(s) {
   return process.stdout.isTTY ? `\x1B[2m${s}\x1B[0m` : s;
 }
-var INIT_GATE_ENV, DEFAULT_REGISTRY_URL2;
+var thisFile, CLI_VERSION, INIT_GATE_ENV, ADAPTER_SELECT_MESSAGE, CSS_SELECT_MESSAGE, LANGUAGE_ADAPTER_HINTS, DEFAULT_REGISTRY_URL2;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
@@ -29634,7 +30609,17 @@ var init_init = __esm({
     init_spinner();
     init_css();
     init_shared2();
+    init_readme();
+    thisFile = fileURLToPath3(import.meta.url);
+    CLI_VERSION = readCliVersion();
     INIT_GATE_ENV = "BAREFOOT_INIT_VIA_CREATE";
+    ADAPTER_SELECT_MESSAGE = "Choose a framework or runtime";
+    CSS_SELECT_MESSAGE = "Choose a CSS library";
+    LANGUAGE_ADAPTER_HINTS = {
+      go: "Go apps use one of the Go web-framework adapters: echo, gin, chi, nethttp (e.g. --adapter chi)",
+      golang: "Go apps use one of the Go web-framework adapters: echo, gin, chi, nethttp (e.g. --adapter chi)",
+      perl: "Perl apps use one of the Perl adapters: mojo, xslate (e.g. --adapter mojo)"
+    };
     DEFAULT_REGISTRY_URL2 = "https://ui.barefootjs.dev/r/";
   }
 });
@@ -29732,7 +30717,7 @@ var init_resolve_source = __esm({
 });
 
 // src/lib/meta-loader.ts
-import { readFileSync as readFileSync5, existsSync as existsSync10, readdirSync as readdirSync4 } from "node:fs";
+import { readFileSync as readFileSync6, existsSync as existsSync10, readdirSync as readdirSync4 } from "node:fs";
 import path12 from "node:path";
 function loadIndex(metaDir) {
   const indexPath = path12.join(metaDir, "index.json");
@@ -29740,7 +30725,7 @@ function loadIndex(metaDir) {
     console.error(`Error: ${indexPath} not found.`);
     process.exit(1);
   }
-  return JSON.parse(readFileSync5(indexPath, "utf-8"));
+  return JSON.parse(readFileSync6(indexPath, "utf-8"));
 }
 function registryIndexUrl(registryUrl) {
   return registryUrl.endsWith("/") ? `${registryUrl}index.json` : `${registryUrl}/index.json`;
@@ -29775,7 +30760,7 @@ async function tryFetchIndex(registryUrl) {
 }
 function tryLoadComponent(metaDir, name2) {
   const filePath = path12.join(metaDir, `${name2}.json`);
-  if (existsSync10(filePath)) return JSON.parse(readFileSync5(filePath, "utf-8"));
+  if (existsSync10(filePath)) return JSON.parse(readFileSync6(filePath, "utf-8"));
   if (!existsSync10(metaDir)) return null;
   const wanted = `${name2.toLowerCase()}.json`;
   let entries2;
@@ -29789,7 +30774,7 @@ function tryLoadComponent(metaDir, name2) {
     if (entry.toLowerCase() === wanted) matches.push(entry);
   }
   if (matches.length !== 1) return null;
-  return JSON.parse(readFileSync5(path12.join(metaDir, matches[0]), "utf-8"));
+  return JSON.parse(readFileSync6(path12.join(metaDir, matches[0]), "utf-8"));
 }
 function formatMissingComponentError(metaDir, name2, ctx2) {
   const filePath = path12.join(metaDir, `${name2}.json`);
@@ -30123,11 +31108,11 @@ __export(guide_exports, {
 });
 import path15 from "node:path";
 import { existsSync as existsSync11 } from "node:fs";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 function findDocsDir(ctx2) {
   const monorepoDocs = path15.join(ctx2.root, "docs/core");
   if (existsSync11(monorepoDocs)) return monorepoDocs;
-  const bundledDocs = path15.resolve(path15.dirname(thisFile), "docs/core");
+  const bundledDocs = path15.resolve(path15.dirname(thisFile2), "docs/core");
   if (existsSync11(bundledDocs)) return bundledDocs;
   return null;
 }
@@ -30169,7 +31154,7 @@ function run7(args2, ctx2) {
   const docsDir = findDocsDir(ctx2);
   if (!docsDir) {
     const monorepoDocs = path15.join(ctx2.root, "docs/core");
-    const bundledDocs = path15.resolve(path15.dirname(thisFile), "docs/core");
+    const bundledDocs = path15.resolve(path15.dirname(thisFile2), "docs/core");
     console.error("Error: Core documentation not found.");
     console.error("Looked in:");
     console.error(`  - ${monorepoDocs} (monorepo)`);
@@ -30201,12 +31186,12 @@ function run7(args2, ctx2) {
   }
   printDoc(doc, ctx2.jsonFlag);
 }
-var thisFile;
+var thisFile2;
 var init_guide = __esm({
   "src/commands/guide.ts"() {
     "use strict";
     init_docs_loader();
-    thisFile = fileURLToPath3(import.meta.url);
+    thisFile2 = fileURLToPath4(import.meta.url);
   }
 });
 
@@ -30487,8 +31472,8 @@ var init_compile = __esm({
 // src/lib/tokens.ts
 import { readFile as readFile3 } from "node:fs/promises";
 import { existsSync as existsSync13 } from "node:fs";
-import { resolve as resolve8, dirname as dirname4 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { resolve as resolve8, dirname as dirname5 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 async function loadTokens(jsonPath) {
   const content2 = await readFile3(jsonPath, "utf-8");
   return JSON.parse(content2);
@@ -30564,7 +31549,7 @@ ${darkLines.join("\n")}
 function findBaseTokensJson(ctx2) {
   const monorepoTokens = resolve8(ctx2.root, "site/shared/tokens/tokens.json");
   if (existsSync13(monorepoTokens)) return monorepoTokens;
-  const bundledTokens = resolve8(dirname4(thisFile2), "tokens.json");
+  const bundledTokens = resolve8(dirname5(thisFile3), "tokens.json");
   if (existsSync13(bundledTokens)) return bundledTokens;
   return null;
 }
@@ -30589,12 +31574,12 @@ async function loadTokenSet(ctx2) {
 async function loadTokensCss(ctx2) {
   return generateCSS(await loadTokenSet(ctx2));
 }
-var thisFile2;
+var thisFile3;
 var init_tokens = __esm({
   "src/lib/tokens.ts"() {
     "use strict";
     init_runtime();
-    thisFile2 = fileURLToPath4(import.meta.url);
+    thisFile3 = fileURLToPath5(import.meta.url);
   }
 });
 
@@ -30611,8 +31596,8 @@ var init_errors2 = __esm({
 // src/lib/preview/assets.ts
 import { existsSync as existsSync14 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import { resolve as resolve9, dirname as dirname5 } from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { resolve as resolve9, dirname as dirname6 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
 function firstExisting(...candidates) {
   return candidates.find((c) => !!c && existsSync14(c));
 }
@@ -30682,7 +31667,7 @@ var init_assets = __esm({
     "use strict";
     init_tokens();
     init_errors2();
-    assetDir = dirname5(fileURLToPath5(import.meta.url));
+    assetDir = dirname6(fileURLToPath6(import.meta.url));
   }
 });
 
@@ -30960,7 +31945,7 @@ var init_preview_generate = __esm({
 
 // src/lib/preview/run.ts
 import { resolve as resolve10, relative as relative4 } from "node:path";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync15 } from "node:fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync15 } from "node:fs";
 async function runPreview(componentName, ctx2, opts = {}) {
   const assets = await resolvePreviewAssets(ctx2);
   const previewsPath = resolve10(assets.srcComponentsDir, componentName, "index.preview.tsx");
@@ -30977,7 +31962,7 @@ Run: bf gen preview ${componentName}`
       );
     }
   }
-  const source = readFileSync6(previewsPath, "utf-8");
+  const source = readFileSync7(previewsPath, "utf-8");
   const previewNames = [
     ...source.matchAll(/export\s+(?:async\s+)?function\s+(\w+)/g),
     ...source.matchAll(/export\s+const\s+(\w+)\s*=/g)
@@ -31219,7 +32204,7 @@ __export(tokens_apply_exports, {
   resolveTokensCss: () => resolveTokensCss,
   run: () => run9
 });
-import { existsSync as existsSync18, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
 import path17 from "node:path";
 async function run9(args2, ctx2) {
   const url2 = args2[0];
@@ -31302,7 +32287,7 @@ function buildBlockOverrides(config) {
 }
 function applyCssOverrides(cssPath, config) {
   const overrides = buildBlockOverrides(config);
-  let css = readFileSync7(cssPath, "utf-8");
+  let css = readFileSync8(cssPath, "utf-8");
   css = patchBlock(css, /:root\s*\{/, overrides.root);
   css = patchBlock(css, /\.dark\s*\{/, overrides.dark);
   writeFileSync5(cssPath, css);
@@ -31351,7 +32336,7 @@ function escapeRegex2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function applyTokenOverrides(tokensJsonPath, config) {
-  const raw = readFileSync7(tokensJsonPath, "utf-8");
+  const raw = readFileSync8(tokensJsonPath, "utf-8");
   const tokensData = JSON.parse(raw);
   if (config.tokens) {
     for (const [name2, values2] of Object.entries(config.tokens)) {
@@ -31535,12 +32520,12 @@ var init_tokens2 = __esm({
 });
 
 // src/lib/scaffold.ts
-import { readFileSync as readFileSync8, existsSync as existsSync19 } from "node:fs";
+import { readFileSync as readFileSync9, existsSync as existsSync19 } from "node:fs";
 import path18 from "node:path";
 function loadMeta(metaDir, name2) {
   const filePath = path18.join(metaDir, `${name2}.json`);
   if (!existsSync19(filePath)) return null;
-  return JSON.parse(readFileSync8(filePath, "utf-8"));
+  return JSON.parse(readFileSync9(filePath, "utf-8"));
 }
 function toPascalCase2(kebab) {
   return kebab.split("-").map((w2) => w2[0].toUpperCase() + w2.slice(1)).join("");
@@ -31956,11 +32941,11 @@ var init_parse_component = __esm({
 });
 
 // src/lib/test-template.ts
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 import path20 from "node:path";
 function generateTestTemplate(componentPath, options2 = {}) {
   const importSource = options2.importSource ?? "bun:test";
-  const source = readFileSync9(componentPath, "utf-8");
+  const source = readFileSync10(componentPath, "utf-8");
   const parsed = parseComponent(source);
   const fileName = path20.basename(componentPath);
   const baseName = fileName.replace(/\.tsx$/, "");
@@ -32300,7 +33285,7 @@ var debug_graph_exports = {};
 __export(debug_graph_exports, {
   run: () => run14
 });
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 import "node:path";
 async function run14(args2, ctx2) {
   const componentName = args2[0];
@@ -32318,7 +33303,7 @@ async function run14(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync10(resolved.filePath, "utf-8");
+  const source = readFileSync11(resolved.filePath, "utf-8");
   const graph = buildComponentGraph2(source, resolved.filePath, resolved.componentName);
   if (ctx2.jsonFlag) {
     console.log(JSON.stringify(graphToJSON2(graph), null, 2));
@@ -32338,7 +33323,7 @@ var debug_trace_exports = {};
 __export(debug_trace_exports, {
   run: () => run15
 });
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 async function run15(args2, ctx2) {
   const componentName = args2[0];
   const targetName = args2[1];
@@ -32356,7 +33341,7 @@ async function run15(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync11(resolved.filePath, "utf-8");
+  const source = readFileSync12(resolved.filePath, "utf-8");
   const graph = buildComponentGraph2(source, resolved.filePath, resolved.componentName);
   const path25 = traceUpdatePath2(graph, targetName);
   if (!path25) {
@@ -32388,7 +33373,7 @@ var debug_fallbacks_exports = {};
 __export(debug_fallbacks_exports, {
   run: () => run16
 });
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 async function run16(args2, ctx2) {
   const componentName = args2[0];
   if (!componentName) {
@@ -32405,7 +33390,7 @@ async function run16(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync12(resolved.filePath, "utf-8");
+  const source = readFileSync13(resolved.filePath, "utf-8");
   const graph = buildComponentGraph2(source, resolved.filePath, resolved.componentName);
   const isEventHandlerProp = (d) => d.type === "attribute" && /^on[A-Z]/.test(d.label.split(".").pop() ?? "");
   const fallbacks = graph.domBindings.filter((d) => d.classification === "fallback" && !isEventHandlerProp(d));
@@ -32447,7 +33432,7 @@ var debug_signals_exports = {};
 __export(debug_signals_exports, {
   run: () => run17
 });
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 async function run17(args2, ctx2) {
   const componentName = args2[0];
   if (!componentName) {
@@ -32464,7 +33449,7 @@ async function run17(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync13(resolved.filePath, "utf-8");
+  const source = readFileSync14(resolved.filePath, "utf-8");
   const graph = buildComponentGraph2(source, resolved.filePath, resolved.componentName);
   const trace = generateStaticTrace2(graph);
   if (ctx2.jsonFlag) {
@@ -32487,7 +33472,7 @@ var debug_events_exports = {};
 __export(debug_events_exports, {
   run: () => run18
 });
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 async function run18(args2, ctx2) {
   const componentName = args2[0];
   if (!componentName) {
@@ -32504,7 +33489,7 @@ async function run18(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync14(resolved.filePath, "utf-8");
+  const source = readFileSync15(resolved.filePath, "utf-8");
   const summary = buildEventSummary2(source, resolved.filePath, resolved.componentName);
   if (ctx2.jsonFlag) {
     console.log(JSON.stringify({ componentName: summary.componentName, sourceFile: summary.sourceFile, events: summary.events }, null, 2));
@@ -32524,7 +33509,7 @@ var debug_loops_exports = {};
 __export(debug_loops_exports, {
   run: () => run19
 });
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 async function run19(args2, ctx2) {
   const componentName = args2[0];
   if (!componentName) {
@@ -32541,7 +33526,7 @@ async function run19(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync15(resolved.filePath, "utf-8");
+  const source = readFileSync16(resolved.filePath, "utf-8");
   const summary = buildLoopSummary2(source, resolved.filePath, resolved.componentName);
   if (ctx2.jsonFlag) {
     console.log(JSON.stringify(summary, null, 2));
@@ -32561,7 +33546,7 @@ var debug_why_update_exports = {};
 __export(debug_why_update_exports, {
   run: () => run20
 });
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 async function run20(args2, ctx2) {
   const componentName = args2[0];
   const bindingLabel = args2[1];
@@ -32581,7 +33566,7 @@ async function run20(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync16(resolved.filePath, "utf-8");
+  const source = readFileSync17(resolved.filePath, "utf-8");
   const result2 = buildWhyUpdate2(source, resolved.filePath, bindingLabel, resolved.componentName);
   if (!result2) {
     const graph = buildComponentGraph2(source, resolved.filePath, resolved.componentName);
@@ -32619,7 +33604,7 @@ var debug_summary_exports = {};
 __export(debug_summary_exports, {
   run: () => run21
 });
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 async function run21(args2, ctx2) {
   const componentName = args2[0];
   if (!componentName) {
@@ -32636,7 +33621,7 @@ async function run21(args2, ctx2) {
     for (const p of searched) console.error(`  - ${p}`);
     process.exit(1);
   }
-  const source = readFileSync17(resolved.filePath, "utf-8");
+  const source = readFileSync18(resolved.filePath, "utf-8");
   const summary = buildComponentSummary2(source, resolved.filePath, resolved.componentName);
   if (ctx2.jsonFlag) {
     console.log(JSON.stringify(summary, null, 2));
@@ -105108,10 +106093,10 @@ __export(scenario_driver_exports, {
   runAutoScenario: () => runAutoScenario,
   runFileScenario: () => runFileScenario
 });
-import { writeFileSync as writeFileSync9, mkdtempSync, rmSync, readFileSync as readFileSync18, existsSync as existsSync23, statSync as statSync3 } from "node:fs";
-import { join as join2, dirname as dirname6, resolve as resolve11 } from "node:path";
+import { writeFileSync as writeFileSync9, mkdtempSync, rmSync, readFileSync as readFileSync19, existsSync as existsSync23, statSync as statSync3 } from "node:fs";
+import { join as join2, dirname as dirname7, resolve as resolve11 } from "node:path";
 import { tmpdir } from "node:os";
-import ts24 from "typescript";
+import ts25 from "typescript";
 function externalRuntimeImport(clientJs) {
   const chunks = Array.isArray(clientJs) ? clientJs : [clientJs];
   for (const chunk of chunks) {
@@ -105180,12 +106165,12 @@ function resolveLocalFile(spec) {
   return null;
 }
 function rewriteLocalImports(js, chunkPath, inlined) {
-  const chunkDir = dirname6(chunkPath);
-  const sf = ts24.createSourceFile("chunk.mjs", js, ts24.ScriptTarget.Latest, false, ts24.ScriptKind.JS);
+  const chunkDir = dirname7(chunkPath);
+  const sf = ts25.createSourceFile("chunk.mjs", js, ts25.ScriptTarget.Latest, false, ts25.ScriptKind.JS);
   const edits = [];
   for (const stmt of sf.statements) {
-    if (!ts24.isImportDeclaration(stmt)) continue;
-    if (!ts24.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts25.isImportDeclaration(stmt)) continue;
+    if (!ts25.isStringLiteral(stmt.moduleSpecifier)) continue;
     const spec = stmt.moduleSpecifier.text;
     if (!spec.startsWith(".")) continue;
     const resolved = resolveLocalFile(join2(chunkDir, spec.replace(/\.client\.js$/, "")));
@@ -105197,13 +106182,13 @@ function rewriteLocalImports(js, chunkPath, inlined) {
     const abs = resolve11(resolved);
     if (inlined.has(abs)) {
       const clause = stmt.importClause;
-      if (clause && (clause.name || clause.namedBindings && ts24.isNamespaceImport(clause.namedBindings))) {
+      if (clause && (clause.name || clause.namedBindings && ts25.isNamespaceImport(clause.namedBindings))) {
         throw new Error(
           `"${spec}" (imported by ${chunkPath}) uses a default or namespace import of a sibling client file, which the dynamic scenario runner cannot bind after inlining that file into the run. Import its exports by name, or use the static budget (\`bf debug profile <component>\`), which needs no run.`
         );
       }
       const shims = [];
-      if (clause?.namedBindings && ts24.isNamedImports(clause.namedBindings)) {
+      if (clause?.namedBindings && ts25.isNamedImports(clause.namedBindings)) {
         for (const el of clause.namedBindings.elements) {
           if (el.propertyName) shims.push(`var ${el.name.text} = ${el.propertyName.text}`);
         }
@@ -105228,17 +106213,17 @@ function loadWithLocalImports(entryPath, seedSource) {
     const resolved = resolveLocalFile(p);
     if (!resolved || visited.has(resolved)) return;
     visited.add(resolved);
-    const source = readFileSync18(resolved, "utf-8");
+    const source = readFileSync19(resolved, "utf-8");
     for (const m of source.matchAll(/from\s+['"](\.[^'"]+)['"]/g)) {
-      visitImport(join2(dirname6(resolved), m[1]));
+      visitImport(join2(dirname7(resolved), m[1]));
     }
     out.push({ source, filePath: resolved });
   };
   const entryResolved = resolveLocalFile(entryPath);
   if (seedSource === void 0 && !entryResolved) return out;
   if (entryResolved) visited.add(entryResolved);
-  const entrySource = seedSource ?? readFileSync18(entryResolved, "utf-8");
-  const entryDir = dirname6(entryResolved ?? entryPath);
+  const entrySource = seedSource ?? readFileSync19(entryResolved, "utf-8");
+  const entryDir = dirname7(entryResolved ?? entryPath);
   for (const m of entrySource.matchAll(/from\s+['"](\.[^'"]+)['"]/g)) {
     visitImport(join2(entryDir, m[1]));
   }
@@ -105369,7 +106354,7 @@ __export(debug_profile_exports, {
   run: () => run22
 });
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { readFileSync as readFileSync19 } from "node:fs";
+import { readFileSync as readFileSync20 } from "node:fs";
 import path24 from "node:path";
 function parseFailOn(raw) {
   const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -105472,7 +106457,7 @@ async function run22(args2, ctx2) {
   if (resolved.isPreview) {
     console.error(`Note: "${componentName}" has no index.tsx \u2014 profiling its preview (index.preview.tsx).`);
   }
-  const source = readFileSync19(resolved.filePath, "utf-8");
+  const source = readFileSync20(resolved.filePath, "utf-8");
   if (flags.scenario) {
     try {
       const { runAutoScenario: runAutoScenario2, runFileScenario: runFileScenario2 } = await Promise.resolve().then(() => (init_scenario_driver(), scenario_driver_exports));
@@ -105712,9 +106697,9 @@ function findProjectConfig(startDir) {
   let dir = path.resolve(startDir);
   const { root: fsRoot } = path.parse(dir);
   while (true) {
-    const ts25 = path.join(dir, "barefoot.config.ts");
-    if (existsSync2(ts25)) {
-      return { dir, tsConfigPath: ts25 };
+    const ts26 = path.join(dir, "barefoot.config.ts");
+    if (existsSync2(ts26)) {
+      return { dir, tsConfigPath: ts26 };
     }
     if (dir === fsRoot) return null;
     dir = path.dirname(dir);