@barefootjs/cli 0.29.0 → 0.30.0

package/dist/index.js

@@ -3374,13 +3374,13 @@ function csrSubstituteOnce(value2, env) {
   const recordSubstitution = (start2, end2, sub2) => {
     splices.push({ start: start2 - OFFSET, end: end2 - OFFSET, text: `(${sub2.replacement})` });
   };
-  const collectBindingNames3 = (name2, out) => {
+  const collectBindingNames4 = (name2, out) => {
     if (ts4.isIdentifier(name2)) out.add(name2.text);
     else if (ts4.isObjectBindingPattern(name2)) {
-      for (const el of name2.elements) collectBindingNames3(el.name, out);
+      for (const el of name2.elements) collectBindingNames4(el.name, out);
     } else if (ts4.isArrayBindingPattern(name2)) {
       for (const el of name2.elements) {
-        if (!ts4.isOmittedExpression(el)) collectBindingNames3(el.name, out);
+        if (!ts4.isOmittedExpression(el)) collectBindingNames4(el.name, out);
       }
     }
   };
@@ -3388,7 +3388,7 @@ function csrSubstituteOnce(value2, env) {
     for (const stmt2 of block.statements) {
       if (ts4.isVariableStatement(stmt2)) {
         for (const decl of stmt2.declarationList.declarations) {
-          collectBindingNames3(decl.name, out);
+          collectBindingNames4(decl.name, out);
         }
       } else if (ts4.isFunctionDeclaration(stmt2) && stmt2.name) {
         out.add(stmt2.name.text);
@@ -3431,7 +3431,7 @@ function csrSubstituteOnce(value2, env) {
     }
     if (ts4.isArrowFunction(node) || ts4.isFunctionExpression(node)) {
       const bound = /* @__PURE__ */ new Set();
-      for (const p of node.parameters) collectBindingNames3(p.name, bound);
+      for (const p of node.parameters) collectBindingNames4(p.name, bound);
       if (node.body && ts4.isBlock(node.body)) {
         collectBlockDeclarations(node.body, bound);
       }
@@ -3535,7 +3535,12 @@ function buildSignalMemoEnv(signals, memos, propsObjectName) {
   for (const m of memos) {
     substitutions.set(m.name, {
       kind: "call",
-      replacement: extractMemoBodyExpr(m.computation),
+      // Destructured mode (#2468): `templateComputation` (when present) has
+      // bare destructured prop refs already rewritten to `_p.X` — the
+      // spliced body lands in the module-scope template arrow, which is not
+      // a closure over init's `const value = _p.value` extraction. Mirrors
+      // the signal `templateInitialValue` handling above (#2265).
+      replacement: extractMemoBodyExpr(m.templateComputation ?? m.computation),
       freeIdentifiers: m.computationFreeIdentifiers ?? /* @__PURE__ */ new Set()
     });
   }
@@ -3558,6 +3563,16 @@ var init_csr_substitute = __esm({
   }
 });
 
+// ../jsx/src/adapters/child-scope.ts
+function derivesScopeFromSlot(comp) {
+  return comp.slotId != null && comp.loopItemRoot !== true;
+}
+var init_child_scope = __esm({
+  "../jsx/src/adapters/child-scope.ts"() {
+    "use strict";
+  }
+});
+
 // ../jsx/src/ir-to-client-js/html-template.ts
 function createStringProtector() {
   const strings = [];
@@ -3848,7 +3863,7 @@ function renderFlatMapClientBody(cb, restSpreadNames) {
     rawLeaf: true,
     renderLeaf: (ir) => {
       const key = flatMapLeafKeyExpr(ir);
-      const html = irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, 1, void 0, void 0, true);
+      const html = irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, 1, void 0, void 0);
       return `({ k: ${key ?? "undefined"}, h: \`${html}\` })`;
     }
   });
@@ -3860,7 +3875,7 @@ function renderFlatMapProjectionClientBody(inner, restSpreadNames) {
   const chained = applyLoopChain(inner);
   const params = inner.index ? `(${inner.param}, ${inner.index})` : `(${inner.param})`;
   const key = inner.key ? `(${inner.key})` : "undefined";
-  const html = inner.children.map((c) => irToHtmlTemplate(escapeLeafTextExpressions(c), restSpreadNames, 1, void 0, void 0, true)).join("");
+  const html = inner.children.map((c) => irToHtmlTemplate(escapeLeafTextExpressions(c), restSpreadNames, 1, void 0, void 0)).join("");
   return `${chained}.map(${params} => ({ k: ${key}, h: \`${html}\` }))`;
 }
 function escapeLeafTextExpressions(ir) {
@@ -3884,8 +3899,8 @@ function escapeLeafTextExpressions(ir) {
       return ir;
   }
 }
-function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, branchSlotsVar, insideLoop = false, inHoistedChildren = false) {
-  const recurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, insideLoop, inHoistedChildren);
+function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, branchSlotsVar, inHoistedChildren = false) {
+  const recurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, inHoistedChildren);
   const wrapExpr = (expr) => wrapExprWithLoopParams(expr, loopParams);
   const wrapInterpolation = (expr) => branchSlotsVar ? `__bfSlot(${expr}, ${branchSlotsVar})` : expr;
   switch (node.type) {
@@ -3915,7 +3930,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
         attrParts.push(`bf="${node.slotId}"`);
       }
       const attrs = attrParts.join(" ");
-      const childrenRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, insideLoop, false);
+      const childrenRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, false);
       const children2 = dangerouslyHtmlChildren(node.attrs, (v) => wrapExpr(v.expr)) ?? node.children.map(childrenRecurse).join("");
       if (children2 || !VOID_ELEMENTS.has(node.tag)) {
         return `<${node.tag}${attrs ? " " + attrs : ""}>${children2}</${node.tag}>`;
@@ -3951,11 +3966,11 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       if (node.name === "Portal") {
         return node.children.map(recurse).join("");
       }
-      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
+      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => p.name !== "ref" && !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
         if (p.clientOnly) return null;
         switch (p.value.kind) {
           case "jsx-children": {
-            const hoistedRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, insideLoop, true);
+            const hoistedRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, true);
             const childHtml = p.value.children.map((c) => hoistedRecurse(c)).join("");
             return `${quotePropName(p.name)}: \`${childHtml}\``;
           }
@@ -3968,7 +3983,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
           case "expression":
           case "template":
           case "spread": {
-            const expr = attrValueToString(p.value) ?? "undefined";
+            const expr = attrValueToString(p.value, { useTemplate: true }) ?? "undefined";
             return `${quotePropName(p.name)}: ${expr}`;
           }
         }
@@ -3978,11 +3993,11 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       const propsExpr = propsEntries.length > 0 ? `{${propsEntries.join(", ")}}` : "{}";
       const keyProp = node.props.find((p) => p.name === "key");
       const keyArg = keyProp ? `, ${attrValueToString(keyProp.value) ?? "undefined"}` : "";
-      const slotArg = !insideLoop && node.slotId ? `, '${node.slotId}'` : "";
+      const slotArg = derivesScopeFromSlot(node) ? `, '${node.slotId}'` : "";
       return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${keyArg || (slotArg ? ", undefined" : "")}${slotArg})}`;
     }
     case "loop": {
-      const innerRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar, insideLoop);
+      const innerRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar);
       let childTemplate = node.children.map(innerRecurse).join("");
       if (node.bodyIsItemConditional && node.key) {
         childTemplate = `${itemAnchorTemplate(node.key)}${childTemplate}`;
@@ -3995,11 +4010,11 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       let mapExpr;
       if (node.flatMapCallback) {
         const body2 = renderPreamble(node.flatMapCallback, {
-          renderLeaf: (ir) => irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar, insideLoop)
+          renderLeaf: (ir) => irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar)
         });
         mapExpr = `\${${wrappedArray}.flatMap(${node.flatMapCallback.params} => ${body2}).join('')}`;
       } else if (node.preamble) {
-        const preamble = renderPreamble(node.preamble, { textVariant: "client", renderLeaf: (ir) => irToHtmlTemplate(ir, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar, insideLoop) });
+        const preamble = renderPreamble(node.preamble, { textVariant: "client", renderLeaf: (ir) => irToHtmlTemplate(ir, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar) });
         mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => { ${preamble} return \`${childTemplate}\` }).join('')}`;
       } else {
         mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => \`${childTemplate}\`).join('')}`;
@@ -4468,7 +4483,7 @@ function irToComponentTemplateWithOpts(node, opts) {
       if (node.name === "Portal") {
         return node.children.map(recurse).join("");
       }
-      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
+      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => p.name !== "ref" && !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
         if (p.clientOnly) return null;
         switch (p.value.kind) {
           case "jsx-children": {
@@ -4578,7 +4593,7 @@ function canGenerateStaticTemplate(node, propNames, inlinableConstants, unsafeLo
       return assertNever(node);
   }
 }
-function generateCsrTemplate(node, inlinableConstants, ctx2, insideLoop, restSpreadNames, propsObjectName, unsafeLocalNames, deferredChildSlots) {
+function generateCsrTemplate(node, inlinableConstants, ctx2, restSpreadNames, propsObjectName, unsafeLocalNames, deferredChildSlots) {
   const base = buildSignalMemoEnv(ctx2.signals, ctx2.memos, propsObjectName ?? null);
   const csrEnv = { substitutions: new Map(base.substitutions), propsObjectName: base.propsObjectName };
   if (inlinableConstants) {
@@ -4589,7 +4604,7 @@ function generateCsrTemplate(node, inlinableConstants, ctx2, insideLoop, restSpr
     }
   }
   const effectiveUnsafeLocalNames = mergeCsrNullUnsafe(ctx2, unsafeLocalNames);
-  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames: effectiveUnsafeLocalNames, deferredChildSlots, loopDepth: -1 });
+  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, unsafeLocalNames: effectiveUnsafeLocalNames, deferredChildSlots, loopDepth: -1 });
 }
 function mergeCsrNullUnsafe(ctx2, unsafeLocalNames) {
   let merged = null;
@@ -4647,6 +4662,7 @@ function computeDeferredChildSlots(node, ctx2, inlinableConstants, unsafeLocalNa
         if (n.slotId) {
           const dropped = n.props.some((p) => {
             if (p.name === "..." || p.name.startsWith("...") || p.name === "key") return false;
+            if (p.name === "ref") return false;
             if (p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase()) return false;
             if (p.clientOnly) return false;
             return propResolvesUnsafe(p, env, unsafeLocalNames);
@@ -4673,7 +4689,7 @@ function computeDeferredChildSlots(node, ctx2, inlinableConstants, unsafeLocalNa
   return deferred;
 }
 function generateCsrTemplateWithOpts(node, opts) {
-  const { restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames, loopDepth = 0 } = opts;
+  const { restSpreadNames, propsObjectName, csrEnv, unsafeLocalNames, loopDepth = 0 } = opts;
   const env = csrEnv ?? { substitutions: /* @__PURE__ */ new Map(), propsObjectName: propsObjectName ?? null };
   const transformExpr = (expr, templateExpr) => {
     const source = templateExpr ?? expr;
@@ -4686,7 +4702,6 @@ function generateCsrTemplateWithOpts(node, opts) {
   };
   const recurse = (n) => generateCsrTemplateWithOpts(n, opts);
   const childrenRecurse = (n) => generateCsrTemplateWithOpts(n, { ...opts, inHoistedChildren: false });
-  const recurseInLoop = (n) => generateCsrTemplateWithOpts(n, { ...opts, insideLoop: true, loopDepth: loopDepth + 1, inHoistedChildren: false });
   switch (node.type) {
     case "element": {
       const mergeCtx = {
@@ -4775,7 +4790,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       if (node.slotId && opts.deferredChildSlots?.has(node.slotId)) {
         return `<div ${BF_PLACEHOLDER}="${node.slotId}"></div>`;
       }
-      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
+      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => p.name !== "ref" && !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
         if (p.clientOnly) return null;
         switch (p.value.kind) {
           case "jsx-children": {
@@ -4808,7 +4823,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       const propsExpr = propsEntries.length > 0 ? `{${propsEntries.join(", ")}}` : "{}";
       const keyProp = node.props.find((p) => p.name === "key");
       const keyArg = keyProp ? `, ${transformKeyValue(keyProp.value, transformExpr)}` : "";
-      const slotArg = !insideLoop && node.slotId ? `, '${node.slotId}'` : "";
+      const slotArg = derivesScopeFromSlot(node) ? `, '${node.slotId}'` : "";
       return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${keyArg || (slotArg ? ", undefined" : "")}${slotArg})}`;
     }
     case "loop": {
@@ -4825,7 +4840,6 @@ function generateCsrTemplateWithOpts(node, opts) {
       };
       const recurseInLoopBody = (n) => generateCsrTemplateWithOpts(n, {
         ...opts,
-        insideLoop: true,
         loopDepth: loopDepth + 1,
         inHoistedChildren: false,
         loopBoundNames: boundHere,
@@ -4897,6 +4911,7 @@ var init_html_template = __esm({
     init_csr_substitute();
     init_src();
     init_loop_chain();
+    init_child_scope();
     VOID_ELEMENTS = /* @__PURE__ */ new Set([
       "area",
       "base",
@@ -5355,6 +5370,30 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   if (ts7.isArrayTypeNode(typeNode)) {
     return { kind: "array", raw, elementType: recurse(typeNode.elementType) };
   }
+  if (ts7.isLiteralTypeNode(typeNode)) {
+    const lit = typeNode.literal;
+    if (ts7.isStringLiteral(lit) || ts7.isNoSubstitutionTemplateLiteral(lit)) {
+      return { kind: "primitive", raw, primitive: "string", literalValue: lit.text };
+    }
+    if (ts7.isNumericLiteral(lit)) {
+      return { kind: "primitive", raw, primitive: "number", literalValue: lit.text };
+    }
+    if (ts7.isPrefixUnaryExpression(lit) && lit.operator === ts7.SyntaxKind.MinusToken && ts7.isNumericLiteral(lit.operand)) {
+      return { kind: "primitive", raw, primitive: "number", literalValue: `-${lit.operand.text}` };
+    }
+    if (lit.kind === ts7.SyntaxKind.TrueKeyword || lit.kind === ts7.SyntaxKind.FalseKeyword) {
+      return {
+        kind: "primitive",
+        raw,
+        primitive: "boolean",
+        literalValue: lit.kind === ts7.SyntaxKind.TrueKeyword ? "true" : "false"
+      };
+    }
+    if (lit.kind === ts7.SyntaxKind.NullKeyword) {
+      return { kind: "primitive", raw, primitive: "null" };
+    }
+    return { kind: "unknown", raw };
+  }
   if (ts7.isUnionTypeNode(typeNode)) {
     return { kind: "union", raw, unionTypes: typeNode.types.map(recurse) };
   }
@@ -5647,8 +5686,7 @@ function baseTypeName(raw) {
   return (idx === -1 ? raw : raw.slice(0, idx)).trim();
 }
 function isNullishArm(t) {
-  if (t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined")) return true;
-  return t.kind === "unknown" && (t.raw === "null" || t.raw === "undefined");
+  return t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined");
 }
 function stripUnion(type2) {
   if (!type2 || type2.kind !== "union" || !type2.unionTypes) return type2;
@@ -6339,14 +6377,16 @@ function collectSignal(node, ctx2) {
   const pattern = node.name;
   const callExpr = node.initializer;
   const elements2 = pattern.elements;
-  if (elements2.length < 1 || elements2.length > 2 || !ts8.isBindingElement(elements2[0]) || !ts8.isIdentifier(elements2[0].name)) {
+  const getterElided = elements2.length === 2 && ts8.isOmittedExpression(elements2[0]);
+  if (elements2.length < 1 || elements2.length > 2 || !getterElided && (!ts8.isBindingElement(elements2[0]) || !ts8.isIdentifier(elements2[0].name))) {
     return;
   }
   if (elements2.length === 2 && (!ts8.isBindingElement(elements2[1]) || !ts8.isIdentifier(elements2[1].name))) {
     return;
   }
-  const getter = elements2[0].name.text;
   const setter = elements2.length === 2 && ts8.isBindingElement(elements2[1]) && ts8.isIdentifier(elements2[1].name) ? elements2[1].name.text : null;
+  if (getterElided && !setter) return;
+  const getter = getterElided ? `__bfGet_${setter}` : elements2[0].name.text;
   const initialValue = callExpr.arguments[0] ? ctx2.getJS(callExpr.arguments[0]) : "";
   const typedInitialValue = callExpr.arguments[0] ? callExpr.arguments[0].getText(ctx2.sourceFile) : void 0;
   let type2 = { kind: "unknown", raw: "unknown" };
@@ -6367,6 +6407,7 @@ function collectSignal(node, ctx2) {
   ctx2.signals.push({
     getter,
     setter,
+    getterElided: getterElided || void 0,
     initialValue,
     typedInitialValue: typedInitialValue !== initialValue ? typedInitialValue : void 0,
     templateInitialValue,
@@ -6538,9 +6579,17 @@ function collectMemo(node, ctx2) {
   const blockBody = arrowNode && ts8.isArrowFunction(arrowNode) && ts8.isBlock(arrowNode.body) ? arrowNode.body : void 0;
   const parsedBlock = blockBody ? parseBlockBodyTolerant(blockBody, ctx2.sourceFile, (node2) => ctx2.getJS(node2)) : void 0;
   const parsedBlockComplete = parsedBlock && blockBody ? parsedBlock.length === blockBody.statements.length : void 0;
+  let templateComputation;
+  if (!ctx2.propsObjectName && callExpr.arguments[0]) {
+    const propNames = new Set(ctx2.propsParams.map((p) => p.name));
+    if (propNames.size > 0) {
+      templateComputation = rewriteBarePropRefs(computation, callExpr.arguments[0], propNames);
+    }
+  }
   ctx2.memos.push({
     name: name2,
     computation,
+    templateComputation,
     parsedBlock,
     parsedBlockComplete,
     typedComputation: typedComputation !== computation ? typedComputation : void 0,
@@ -9627,8 +9676,10 @@ function deriveFormat(locale, probeOptions) {
   return { pattern, names };
 }
 function unionMemberLiteral(member) {
-  const m = /^'([^'\\]*)'$|^"([^"\\]*)"$/.exec(member.raw.trim());
-  return m ? m[1] ?? m[2] : null;
+  if (member.kind === "primitive" && member.primitive === "string" && member.literalValue !== void 0) {
+    return member.literalValue;
+  }
+  return null;
 }
 function resolveLocaleUnionMembers(locale, metadata) {
   let sourcePropName = null;
@@ -10185,6 +10236,14 @@ function jsxToIR(analyzer) {
 function buildIRRoot(analyzer) {
   if (analyzer.conditionalReturns.length > 0) {
     const ctx3 = createTransformContext(analyzer);
+    const allReactiveNoLocals = analyzer.jsxReturn != null && analyzer.conditionalReturns.every(
+      (cr) => cr.scopeVariables.length === 0 && exprCallsReactiveGetters(cr.condition, ctx3)
+    );
+    if (allReactiveNoLocals) {
+      const chain = buildIfStatementChain(analyzer, ctx3, { asConditional: true });
+      if (!chain) return null;
+      return chain.type === "conditional" ? wrapInScopeElement(chain) : chain;
+    }
     return buildIfStatementChain(analyzer, ctx3);
   }
   if (!analyzer.jsxReturn) return null;
@@ -10336,6 +10395,50 @@ function transformJsxElement(node, ctx2) {
   }
   return transformHtmlElement(node, ctx2, tagName2);
 }
+function lowerFormControlValueSsr(tagName2, attrs, children2) {
+  if (tagName2 !== "textarea" && tagName2 !== "select") return;
+  const valueAttr = attrs.find((a) => a.name === "value");
+  if (!valueAttr || valueAttr.clientOnly || valueAttr.value.kind !== "expression") return;
+  const { expr, templateExpr } = valueAttr.value;
+  valueAttr.clientOnly = true;
+  if (tagName2 === "textarea") {
+    if (children2.length > 0) return;
+    children2.push({
+      type: "expression",
+      expr,
+      // The client-side registration template interpolates slotless
+      // expression children RAW (no text-slot `escapeText` wrapper), so a
+      // value containing `</textarea>` would break out of the element on
+      // CSR mount. Escape in the client-only template variant; `expr`
+      // stays clean for the SSR adapters, whose template engines (and
+      // hono/jsx) already escape text children natively.
+      templateExpr: `escapeText(${templateExpr ?? expr})`,
+      typeInfo: null,
+      reactive: false,
+      slotId: null,
+      loc: valueAttr.loc,
+      origin: { phase: "ssr", scope: "template", effect: "pure" }
+    });
+    return;
+  }
+  const selectedFor = (optValue) => AttrValueOf.expression(
+    `(${expr}) === ${JSON.stringify(optValue)}`,
+    templateExpr !== void 0 ? { templateExpr: `(${templateExpr}) === ${JSON.stringify(optValue)}` } : void 0
+  );
+  const distribute = (nodes) => {
+    for (const n of nodes) {
+      if (n.type === "element" && n.tag === "option") {
+        if (n.attrs.some((a) => a.name === "selected")) continue;
+        const optValue = n.attrs.find((a) => a.name === "value");
+        if (!optValue || optValue.value.kind !== "literal") continue;
+        n.attrs.push({ name: "selected", value: selectedFor(optValue.value.value), loc: n.loc });
+      } else if (n.type === "fragment" || n.type === "element" && n.tag === "optgroup") {
+        distribute(n.children);
+      }
+    }
+  };
+  distribute(children2);
+}
 function transformHtmlElement(node, ctx2, tagName2) {
   const { attrs, events, ref } = processAttributes(
     node.openingElement.attributes,
@@ -10344,6 +10447,7 @@ function transformHtmlElement(node, ctx2, tagName2) {
   const needsScope = ctx2.isRoot;
   ctx2.isRoot = false;
   const children2 = transformChildren(node.children, ctx2);
+  lowerFormControlValueSsr(tagName2, attrs, children2);
   const needsSlot = events.length > 0 || hasDynamicContent(children2) || hasReactiveAttributes(attrs, ctx2) || ref !== null;
   const slotId = needsSlot ? generateSlotId(ctx2) : null;
   if (slotId) {
@@ -10380,6 +10484,8 @@ function transformSelfClosingElement(node, ctx2) {
     return transformSelfClosingComponent(node, ctx2, resolved ?? tagName2);
   }
   const { attrs, events, ref } = processAttributes(node.attributes, ctx2);
+  const selfClosingChildren = [];
+  lowerFormControlValueSsr(tagName2, attrs, selfClosingChildren);
   const needsSlot = events.length > 0 || hasReactiveAttributes(attrs, ctx2) || ref !== null;
   const slotId = needsSlot ? generateSlotId(ctx2) : null;
   const needsScope = ctx2.isRoot;
@@ -10390,7 +10496,7 @@ function transformSelfClosingElement(node, ctx2) {
     attrs,
     events,
     ref,
-    children: [],
+    children: selfClosingChildren,
     slotId,
     needsScope,
     loc: getSourceLocation(node, ctx2.sourceFile, ctx2.filePath)
@@ -11747,6 +11853,15 @@ function branchHasNoElement(node) {
   }
   return true;
 }
+function tagLoopItemRootComponents(nodes) {
+  for (const node of nodes) {
+    if (node.type === "component") {
+      node.loopItemRoot = true;
+    } else if (node.type === "conditional") {
+      tagLoopItemRootComponents([node.whenTrue, node.whenFalse]);
+    }
+  }
+}
 function loopBodyItemConditional(children2) {
   const real = children2.filter(
     (c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim())
@@ -12015,10 +12130,10 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         const pre = multiReturn.preamble ?? [];
         if (pre.length > 0) {
           preamble = preambleFromValueStatements(pre, ctx2);
-          if (!isClientOnly && !(ctx2.analyzer.acceptsCallbackBody?.("map") ?? false)) {
+          if (!preamble.declarations && !isClientOnly && !(ctx2.analyzer.acceptsCallbackBody?.("map") ?? false)) {
             ctx2.analyzer.errors.push(
               createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, loc, {
-                message: "A .map() callback body with a `const`/`let` preamble before its branches cannot be lowered to a template: the loop-local binding cannot be carried into a conditional branch on this backend.",
+                message: "A .map() callback body with a preamble before its branches cannot be lowered to a template: the preamble is not a sequence of value declarations, so this backend has no per-row local to carry into the branches.",
                 suggestion: {
                   message: "Add /* @client */ to evaluate this expression on the client only"
                 }
@@ -12104,6 +12219,20 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
           }
           if (valueStmts.length > 0) {
             preamble = preambleFromValueStatements(valueStmts, ctx2);
+            if (!preamble.declarations && !isClientOnly && !(ctx2.analyzer.acceptsCallbackBody?.("map") ?? false)) {
+              ctx2.analyzer.errors.push(
+                createError(
+                  ErrorCodes.UNSUPPORTED_JSX_PATTERN,
+                  getSourceLocation(body2, ctx2.sourceFile, ctx2.filePath),
+                  {
+                    message: "A .map() callback preamble that is not a sequence of value declarations cannot be lowered to a template: this backend can declare a per-row local, but cannot run arbitrary statements per row.",
+                    suggestion: {
+                      message: "Add /* @client */ to evaluate this expression on the client only"
+                    }
+                  }
+                )
+              );
+            }
           }
         }
       }
@@ -12202,6 +12331,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
     );
     preamble = void 0;
   }
+  tagLoopItemRootComponents(children2);
   let childComponent;
   if (children2.length === 1 && children2[0].type === "component") {
     const comp = children2[0];
@@ -12222,6 +12352,9 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   const isDirectPropArray = method2 !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx2);
   const isStaticArray = !isSignalOrMemoArray(array, ctx2) && !isDirectPropArray && !hasCalls && !objectIteration;
   const preambleRegions = preamble && !isStaticArray ? collectPreambleRegions(children2, new Set(preamble.declaredNames), ctx2) : void 0;
+  if (preamble && !isStaticArray) {
+    markPreambleAttrSlots(children2, new Set(preamble.declaredNames), ctx2);
+  }
   const nestedComponents = collectNestedComponents(children2).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -12460,6 +12593,43 @@ function collectPreambleRegions(nodes, declared, ctx2) {
   visit3(nodes);
   return regions;
 }
+function markPreambleAttrSlots(nodes, declared, ctx2) {
+  const readsDeclared = (attr) => {
+    if (attr.name === "key") return false;
+    const value2 = attr.value;
+    if (value2.kind !== "expression" && value2.kind !== "template") return false;
+    const refs = attr.freeIdentifiers ?? extractFreeIdentifiersFromText(attrValueText(value2));
+    for (const r2 of refs) if (declared.has(r2)) return true;
+    return false;
+  };
+  const visit3 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "element":
+          if (!node.slotId && node.attrs.some(readsDeclared)) node.slotId = generateSlotId(ctx2);
+          visit3(node.children);
+          break;
+        case "fragment":
+          visit3(node.children);
+          break;
+        case "conditional":
+          visit3([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+      }
+    }
+  };
+  visit3(nodes);
+}
+function attrValueText(value2) {
+  if (value2.kind === "expression") return value2.expr;
+  if (value2.kind !== "template") return "";
+  const out = [];
+  for (const p of value2.parts) {
+    if (p.type === "ternary") out.push(p.condition, p.whenTrue, p.whenFalse);
+    else if (p.type === "lookup") out.push(p.key);
+  }
+  return out.join(" ");
+}
 function collectBindingNames(name2, out) {
   if (ts11.isIdentifier(name2)) {
     out.add(name2.text);
@@ -12497,9 +12667,28 @@ function preambleFromValueStatements(statements, ctx2) {
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
     // Value-only preambles accumulate no JSX, so no child needs the array join.
-    builderNames: []
+    builderNames: [],
+    declarations: neutralPreambleDeclarations(statements, ctx2) ?? void 0
   };
 }
+function neutralPreambleDeclarations(statements, ctx2) {
+  const out = [];
+  for (const stmt of statements) {
+    if (!ts11.isVariableStatement(stmt)) return null;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts11.isIdentifier(decl.name)) return null;
+      if (!decl.initializer) return null;
+      const valueParsed = tsNodeToParsedExpr(decl.initializer);
+      if (!isSupported(valueParsed).supported) return null;
+      out.push({
+        name: decl.name.text,
+        valueParsed,
+        raw: decl.initializer.getText(ctx2.sourceFile)
+      });
+    }
+  }
+  return out.length > 0 ? out : null;
+}
 function trimPreambleSegments(segments) {
   const last = segments[segments.length - 1];
   if (last?.kind === "js") {
@@ -12930,6 +13119,9 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx2) {
   if (ts11.isNoSubstitutionTemplateLiteral(ast) || ts11.isStringLiteral(ast)) {
     return [{ type: "string", value: ast.text }];
   }
+  if (ts11.isElementAccessExpression(ast) && !ts11.isStringLiteralLike(ast.argumentExpression) && !ts11.isNumericLiteral(ast.argumentExpression)) {
+    return tryResolveTemplateSpanFromConst(ast, ctx2);
+  }
   if (!ts11.isTemplateExpression(ast)) return null;
   let resolvedAny = false;
   const parts = [];
@@ -13158,8 +13350,11 @@ function processComponentProps(attributes2, ctx2) {
     }
     let value2 = getAttributeValue(attr, ctx2);
     if (value2.kind === "template") {
-      value2 = AttrValueOf.expression(templatePartsToJsString(value2.parts), {
-        parts: value2.parts
+      const collapsed = templatePartsToJsString(value2.parts);
+      const collapsedTemplate = templatePartsToJsString(value2.parts, { useTemplate: true });
+      value2 = AttrValueOf.expression(collapsed, {
+        parts: value2.parts,
+        ...collapsedTemplate !== collapsed && { templateExpr: collapsedTemplate }
       });
     } else if (value2.kind === "boolean-attr") {
       value2 = AttrValueOf.booleanShorthand();
@@ -13188,18 +13383,20 @@ function processComponentProps(attributes2, ctx2) {
   }
   return props;
 }
-function templatePartsToJsString(parts) {
+function templatePartsToJsString(parts, opts) {
   let result2 = "`";
   for (const part of parts) {
     if (part.type === "string") {
-      result2 += part.value;
+      result2 += opts?.useTemplate && part.templateValue ? part.templateValue : part.value;
     } else if (part.type === "ternary") {
-      result2 += `\${${part.condition} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
+      const cond = opts?.useTemplate && part.templateCondition ? part.templateCondition : part.condition;
+      result2 += `\${${cond} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
     } else if (part.type === "lookup") {
+      const key = opts?.useTemplate && part.templateKey ? part.templateKey : part.key;
       const obj = "{" + Object.entries(part.cases).map(
         ([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`
       ).join(", ") + "}";
-      result2 += `\${(${obj})[${part.key}]}`;
+      result2 += `\${(${obj})[${key}]}`;
     }
   }
   result2 += "`";
@@ -13400,11 +13597,12 @@ function replaceBranchLocalRefs(text, branchNames, resolve12) {
   const pattern = new RegExp(`(?<![\\w$])(${branchNames.join("|")})(?![\\w$])`, "g");
   return replaceInExprContexts(text, pattern, (_match, name2) => resolve12(name2));
 }
-function buildIfStatementChain(analyzer, ctx2) {
+function buildIfStatementChain(analyzer, ctx2, opts) {
   const conditionalReturns = analyzer.conditionalReturns;
+  const asConditional = opts?.asConditional === true;
   let alternate = null;
   if (analyzer.jsxReturn) {
-    ctx2.isRoot = true;
+    ctx2.isRoot = !asConditional;
     alternate = transformNode(analyzer.jsxReturn, ctx2);
   }
   for (let i = conditionalReturns.length - 1; i >= 0; i--) {
@@ -13468,7 +13666,7 @@ function buildIfStatementChain(analyzer, ctx2) {
       ctx2.getJS = substitutedGetJS;
       ctx2.analyzer.getJS = substitutedGetJS;
     }
-    ctx2.isRoot = true;
+    ctx2.isRoot = !asConditional;
     let consequent;
     try {
       consequent = transformNode(condReturn.jsxReturn, ctx2);
@@ -13502,6 +13700,27 @@ function buildIfStatementChain(analyzer, ctx2) {
       analyzer.sourceFile,
       analyzer.filePath
     );
+    if (asConditional && alternate) {
+      const conditional = {
+        type: "conditional",
+        condition,
+        templateCondition,
+        conditionType: null,
+        reactive: true,
+        whenTrue: consequent,
+        whenFalse: alternate,
+        slotId: generateSlotId(ctx2),
+        loc,
+        origin: {
+          phase: "tick",
+          scope: "template",
+          effect: "pure",
+          freeRefs: resolveFreeRefs(condReturn.condition, makeBindingEnv(ctx2))
+        }
+      };
+      alternate = conditional;
+      continue;
+    }
     const ifStmt = {
       type: "if-statement",
       condition,
@@ -13846,7 +14065,11 @@ function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings,
   });
   return texts;
 }
-function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false) {
+function anyNameIn(names, set) {
+  for (const n of names) if (set.has(n)) return true;
+  return false;
+}
+function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames) {
   const attrs = [];
   traverseElements(node, (el) => {
     if (el.slotId) {
@@ -13857,14 +14080,16 @@ function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings,
         const valueStr = attrValueToString(attr.value);
         if (!valueStr) continue;
         const expanded = expandConstantForReactivity(valueStr, ctx2, attr.freeIdentifiers);
-        const reactive = classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || attr.callsReactiveGetters || attr.hasFunctionCalls;
+        const readsPreamble = preambleNames !== void 0 && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
+        const reactive = classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
         if (!attr.clientOnly && !reactive) continue;
         attrs.push({
           childSlotId: el.slotId,
           attrName: attr.name,
           expression: expanded.expr,
           ...pickAttrMetaFromIR(attr),
-          ...expanded.freeIds !== void 0 && { freeIdentifiers: expanded.freeIds }
+          ...expanded.freeIds !== void 0 && { freeIdentifiers: expanded.freeIds },
+          ...readsPreamble && { readsPreamble: true }
         });
       }
     }
@@ -13877,6 +14102,7 @@ var init_reactivity = __esm({
     init_types();
     init_utils();
     init_prop_handling();
+    init_csr_substitute();
     init_walker();
   }
 });
@@ -14152,10 +14378,11 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
         const template = n.children.map((c) => irToPlaceholderTemplate(c, void 0, emitDepth, loopParamsForTemplate)).join("");
         const refsOuter = outerLoopParam ? new RegExp(`\\b${outerLoopParam}\\b`).test(n.array) : false;
         const bindings = emptyLoopChildBindings();
+        const innerPreambleNames = preambleNamesOf(n);
         if (ctx2) {
           for (const child of n.children) {
             bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, n.param, n.paramBindings));
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, n.param, n.paramBindings));
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, n.param, n.paramBindings, false, innerPreambleNames));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
         }
@@ -14369,7 +14596,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
       if (!l.slotId || inCond) return;
       const projectionInner = l.method === "flatMap" && l.children.length === 1 && l.children[0].type === "loop" ? l.children[0] : void 0;
       const childHandlers = [];
-      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx2, siblingOffsets, l.param, l.paramBindings);
+      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx2, siblingOffsets, l.param, l.paramBindings, preambleNamesOf(l));
       if (!projectionInner) {
         for (const child of l.children) {
           childHandlers.push(...collectEventHandlersFromIR(child));
@@ -14391,15 +14618,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
       if (l.childComponent) {
         template = "";
         if (l.isStaticArray && l.children[0]) {
-          staticItemTemplate = irToHtmlTemplate(
-            l.children[0],
-            buildRestSpreadNames(ctx2),
-            0,
-            void 0,
-            void 0,
-            /* insideLoop */
-            true
-          );
+          staticItemTemplate = irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx2), 0, void 0, void 0);
         }
       } else if (l.children[0] && !projectionInner) {
         const loopParamSpec = [{ param: l.param, bindings: l.paramBindings }];
@@ -14629,7 +14848,7 @@ function collectBranchLoops(node, ctx2, siblingOffsets) {
       } else {
         childTemplate = n.children.map((c) => irToHtmlTemplate(c, void 0, 0, branchLoopParamSpec)).join("");
       }
-      const branchBindings = ctx2 && !projectionInner ? collectLoopChildBindings(n.children, ctx2, siblingOffsets, n.param, n.paramBindings) : emptyLoopChildBindings();
+      const branchBindings = ctx2 && !projectionInner ? collectLoopChildBindings(n.children, ctx2, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n)) : emptyLoopChildBindings();
       loops.push({
         kind: "branch",
         array: n.array,
@@ -14710,11 +14929,16 @@ function collectBranchConditionals(node, ctx2, siblingOffsets) {
   });
   return result2;
 }
-function collectLoopChildBindings(children2, ctx2, siblingOffsets, loopParam, loopParamBindings) {
+function preambleNamesOf(loop) {
+  if (loop.isStaticArray) return void 0;
+  const declared = loop.preamble?.declaredNames;
+  return declared && declared.length > 0 ? new Set(declared) : void 0;
+}
+function collectLoopChildBindings(children2, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames) {
   const bindings = emptyLoopChildBindings();
   for (const child of children2) {
     bindings.events.push(...collectLoopChildEventsWithNesting(child));
-    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, loopParam, loopParamBindings, true));
+    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, loopParam, loopParamBindings, true, preambleNames));
     bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, loopParam, loopParamBindings, true));
     bindings.refs.push(...collectLoopChildRefs(child));
     bindings.conditionals.push(...collectLoopChildConditionals(child, ctx2, siblingOffsets, loopParam, loopParamBindings));
@@ -16396,7 +16620,6 @@ function emitRegistrationAndHydration(lines, ctx2, _ir, graph, inlinability) {
       _ir.root,
       csrInlinableConstants,
       ctx2,
-      void 0,
       restSpreadNames,
       ctx2.propsObjectName,
       unsafeLocalNames,
@@ -16800,6 +17023,7 @@ function buildSignalPlan(signal2, ctx2, lookups) {
         kind: "signal",
         getter: signal2.getter,
         setter: signal2.setter,
+        getterElided: signal2.getterElided,
         initialValueExpr: "",
         controlledEffect: null,
         initializerOverride: `${factory}()`
@@ -16814,6 +17038,7 @@ function buildSignalPlan(signal2, ctx2, lookups) {
     kind: "signal",
     getter: signal2.getter,
     setter: signal2.setter,
+    getterElided: signal2.getterElided,
     initialValueExpr: resolveSignalInitialValue(signal2, ctx2, lookups),
     controlledEffect,
     branchCondition: signal2.branchCondition,
@@ -16890,9 +17115,10 @@ function bfIdArg(bfId) {
   return bfId ? `, ${JSON.stringify(bfId)}` : "";
 }
 function emitSignal(lines, plan) {
+  const getterSlot = plan.getterElided ? "" : plan.getter;
   if (plan.initializerOverride) {
     if (plan.setter) {
-      lines.push(`  const [${plan.getter}, ${plan.setter}] = ${plan.initializerOverride}`);
+      lines.push(`  const [${getterSlot}, ${plan.setter}] = ${plan.initializerOverride}`);
     } else {
       lines.push(`  const [${plan.getter}] = ${plan.initializerOverride}`);
     }
@@ -16901,9 +17127,9 @@ function emitSignal(lines, plan) {
   const id2 = bfIdArg(plan.bfId);
   if (plan.branchCondition) {
     if (plan.setter) {
-      lines.push(`  let ${plan.getter}, ${plan.setter}`);
+      lines.push(plan.getterElided ? `  let ${plan.setter}` : `  let ${plan.getter}, ${plan.setter}`);
       lines.push(`  if (${plan.branchCondition}) {`);
-      lines.push(`    ;[${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id2})`);
+      lines.push(`    ;[${getterSlot}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id2})`);
       lines.push(`  }`);
     } else {
       lines.push(`  let ${plan.getter}`);
@@ -16914,7 +17140,7 @@ function emitSignal(lines, plan) {
     return;
   }
   if (plan.setter) {
-    lines.push(`  const [${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id2})`);
+    lines.push(`  const [${getterSlot}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id2})`);
   } else {
     lines.push(`  const [${plan.getter}] = createSignal(${plan.initialValueExpr}${id2})`);
   }
@@ -17541,7 +17767,7 @@ var init_shared = __esm({
 // ../jsx/src/ir-to-client-js/plan/build-static-array-child-init.ts
 function staticPreludeStatements(preamble) {
   return preamble ? [renderPreamble(preamble, {
-    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0, true)
+    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0)
   })] : [];
 }
 function buildStaticArrayChildInitsPlan(ctx2) {
@@ -18134,7 +18360,8 @@ function buildReactiveEffectsPlan(args2) {
       attrs: slotAttrs.map((attr) => ({
         attrName: attr.attrName,
         wrappedExpression: wrap(attr.expression),
-        meta: pickAttrMeta(attr)
+        meta: pickAttrMeta(attr),
+        ...attr.readsPreamble && { readsPreamble: true }
       }))
     });
   }
@@ -18342,7 +18569,7 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
     ] : [{ param: inner.param, bindings: inner.paramBindings }];
     preludeStatements.push(renderPreamble(inner.preamble, {
       transformJs: (t) => wrapInner(wrapOuter(t)),
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, leafLoopParams, void 0, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, leafLoopParams, void 0)
     }));
   }
   const childRefs = buildChildRefBindings(inner.bindings.refs, inner.param, inner.paramBindings);
@@ -18367,7 +18594,7 @@ function buildStaticEmit(inner, level, uidSuffix) {
   if (indexAlias) preludeStatements.push(indexAlias);
   if (inner.preamble) {
     preludeStatements.push(renderPreamble(inner.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0)
     }));
   }
   return {
@@ -18409,7 +18636,7 @@ function buildTopLevelCompositePlan(elem, profileComponentName) {
     indexParam: elem.index || "__idx",
     mapPreambleWrapped: elem.preamble ? renderPreamble(elem.preamble, {
       transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0)
     }) : "",
     template: elem.template,
     outerComps: filterCondCompsOut(outerCompsByDepth, elem.bindings.conditionals),
@@ -18462,7 +18689,7 @@ function buildBranchCompositePlan(loop, cv, profileComponentName) {
     indexParam: loop.index || "__idx",
     mapPreambleWrapped: loop.preamble ? renderPreamble(loop.preamble, {
       transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0)
     }) : "",
     template: loop.template,
     outerComps: filterCondCompsOut(outerCompsByDepth, loop.bindings.conditionals),
@@ -18544,7 +18771,7 @@ function buildDynamicLoopDelegationPlan(elem, profileComponentName) {
       // BUG-3: it rewrote leaf refs to accessor-call form (`t().name`),
       // which throws since `t` is a plain object in this scope.
       mapPreamble: elem.preamble ? renderPreamble(elem.preamble, {
-        renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0, true)
+        renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0)
       }) : null,
       mapPreambleDeclaredNames: elem.preamble?.declaredNames ?? []
     })
@@ -18566,7 +18793,7 @@ function buildBranchLoopDelegationPlan(loop, cv, profileComponentName) {
       // See note in `buildDynamicLoopDelegationPlan` above (BUG-3): no
       // loopParams spec — leaf refs must stay in plain-object form here.
       mapPreamble: loop.preamble ? renderPreamble(loop.preamble, {
-        renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0, true)
+        renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0)
       }) : null,
       mapPreambleDeclaredNames: loop.preamble?.declaredNames ?? []
     })
@@ -18588,7 +18815,7 @@ function buildStaticArrayDelegationPlan(elem, profileComponentName) {
       // See note in `buildDynamicLoopDelegationPlan` above (BUG-3): no
       // loopParams spec — leaf refs must stay in plain-object form here.
       mapPreamble: elem.preamble ? renderPreamble(elem.preamble, {
-        renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0, true)
+        renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0)
       }) : null,
       mapPreambleDeclaredNames: elem.preamble?.declaredNames ?? [],
       offset: elem.offset ?? null,
@@ -18630,36 +18857,219 @@ var init_build_event_delegation = __esm({
   }
 });
 
+// ../jsx/src/ir-to-client-js/control-flow/plan/lazy-conditional.ts
+function wiringOn(branch) {
+  const found = [];
+  if (branch.childComponents.length > 0) found.push("child components");
+  if (branch.innerLoops && branch.innerLoops.length > 0) found.push("an inner loop");
+  if (branch.conditionals && branch.conditionals.length > 0) found.push("a nested conditional");
+  if (branch.events && branch.events.length > 0) found.push("events");
+  if (branch.reactiveAttrs && branch.reactiveAttrs.length > 0) found.push("reactive attrs");
+  if (branch.reactiveTexts && branch.reactiveTexts.length > 0) found.push("reactive text");
+  return found;
+}
+function analyzeLazyConditional(cond, indexParam, arms) {
+  for (const [label2, branch] of [["true", cond.whenTrue], ["false", cond.whenFalse]]) {
+    const wiring = wiringOn(branch);
+    if (wiring.length > 0) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label2} arm owns ${wiring.join(" + ")}`);
+    }
+  }
+  for (const [label2, html] of [["true", arms.whenTrueHtml], ["false", arms.whenFalseHtml]]) {
+    if (html.includes("bf-cond-start:")) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label2} arm is a fragment conditional`);
+    }
+    if (!html.includes(`bf-c="${cond.slotId}"`)) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label2} arm has no single bf-c root`);
+    }
+    if (html.includes("${")) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label2} arm interpolates a value`);
+    }
+  }
+  if (!cond.conditionFreeIdentifiers) {
+    return NO(`conditional on slot ${cond.slotId}: condition has no analyzable identifier set`);
+  }
+  if (cond.conditionFreeIdentifiers.has(indexParam)) {
+    return NO(`conditional on slot ${cond.slotId}: condition reads the loop index parameter '${indexParam}'`);
+  }
+  return {
+    lazySafe: true,
+    facts: {
+      slotId: cond.slotId,
+      condition: cond.condition,
+      whenTrueHtml: arms.whenTrueHtml,
+      whenFalseHtml: arms.whenFalseHtml
+    }
+  };
+}
+var NO;
+var init_lazy_conditional = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/plan/lazy-conditional.ts"() {
+    "use strict";
+    NO = (reason2) => ({ lazySafe: false, reason: reason2 });
+  }
+});
+
+// ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
+import ts15 from "typescript";
+function analyzeLazyPreamble(preamble, indexParam, primableNames) {
+  if (!preamble) return NO_PREAMBLE;
+  if (preamble.builderNames.length > 0) {
+    return NO2(`map-callback preamble accumulates JSX leaves (${preamble.builderNames.join(", ")})`);
+  }
+  for (const seg of preamble.segments) {
+    if (seg.kind !== "js") return NO2("map-callback preamble contains a JSX leaf");
+  }
+  const text = preambleAnalysisText(preamble);
+  if (text.trim().length === 0) return NO_PREAMBLE;
+  const declaredNames = /* @__PURE__ */ new Set();
+  const sf = ts15.createSourceFile(
+    "__lazy_preamble__.ts",
+    text,
+    ts15.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    ts15.ScriptKind.TS
+  );
+  for (const stmt of sf.statements) {
+    if (!ts15.isVariableStatement(stmt)) {
+      return NO2(`map-callback preamble has a non-declaration statement (${ts15.SyntaxKind[stmt.kind]})`);
+    }
+    const isConst = (stmt.declarationList.flags & ts15.NodeFlags.Const) !== 0;
+    if (!isConst) return NO2("map-callback preamble declares a mutable binding (let/var)");
+    for (const decl of stmt.declarationList.declarations) {
+      collectBindingNames2(decl.name, declaredNames);
+      if (!decl.initializer) {
+        return NO2("map-callback preamble has a declaration with no initializer");
+      }
+      const impure = findImpureNode(decl.initializer, primableNames);
+      if (impure) {
+        return NO2(`map-callback preamble initializer is not re-runnable (${impure})`);
+      }
+    }
+  }
+  for (const name2 of declaredNames) {
+    if (primableNames.has(name2)) {
+      return NO2(`map-callback preamble shadows the signal/memo getter '${name2}'`);
+    }
+  }
+  const readNames = extractFreeIdentifiersFromStatementText(text);
+  if (readNames.has(indexParam) && !declaredNames.has(indexParam)) {
+    return NO2(`map-callback preamble reads the loop index parameter '${indexParam}'`);
+  }
+  const freeNames = new Set(readNames);
+  for (const declared of declaredNames) freeNames.delete(declared);
+  return { lazySafe: true, facts: { declaredNames, freeNames } };
+}
+function collectBindingNames2(name2, out) {
+  if (ts15.isIdentifier(name2)) {
+    out.add(name2.text);
+    return;
+  }
+  for (const element of name2.elements) {
+    if (ts15.isOmittedExpression(element)) continue;
+    collectBindingNames2(element.name, out);
+  }
+}
+function findImpureNode(root2, primableNames) {
+  let found = null;
+  const visit3 = (node) => {
+    if (found) return;
+    if (ts15.isCallExpression(node)) {
+      const callee = node.expression;
+      const isSignalRead = ts15.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === void 0;
+      if (!isSignalRead) {
+        found = `call to ${callee.getText(callee.getSourceFile())}`;
+        return;
+      }
+    }
+    if (ts15.isNewExpression(node)) {
+      found = "new expression";
+      return;
+    }
+    if (ts15.isTaggedTemplateExpression(node)) {
+      found = "tagged template";
+      return;
+    }
+    if (ts15.isAwaitExpression(node)) {
+      found = "await";
+      return;
+    }
+    if (ts15.isYieldExpression(node)) {
+      found = "yield";
+      return;
+    }
+    if (ts15.isPrefixUnaryExpression(node) || ts15.isPostfixUnaryExpression(node)) {
+      const op = node.operator;
+      if (op === ts15.SyntaxKind.PlusPlusToken || op === ts15.SyntaxKind.MinusMinusToken) {
+        found = "increment/decrement";
+        return;
+      }
+    }
+    if (ts15.isDeleteExpression(node)) {
+      found = "delete";
+      return;
+    }
+    if (ts15.isFunctionExpression(node) || ts15.isArrowFunction(node) || ts15.isClassExpression(node)) {
+      found = "function or class expression";
+      return;
+    }
+    if (ts15.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+      found = "assignment";
+      return;
+    }
+    ts15.forEachChild(node, visit3);
+  };
+  visit3(root2);
+  return found;
+}
+function isAssignmentOperator(kind2) {
+  return kind2 >= ts15.SyntaxKind.FirstAssignment && kind2 <= ts15.SyntaxKind.LastAssignment;
+}
+var NO_PREAMBLE, NO2;
+var init_lazy_preamble = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts"() {
+    "use strict";
+    init_types();
+    init_csr_substitute();
+    NO_PREAMBLE = {
+      lazySafe: true,
+      facts: { declaredNames: /* @__PURE__ */ new Set(), freeNames: /* @__PURE__ */ new Set() }
+    };
+    NO2 = (reason2) => ({ lazySafe: false, reason: reason2 });
+  }
+});
+
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
 function lazyRowEligibility(args2) {
   const { shape, bindings, arraySourceIdentifiers, scope } = args2;
-  if (scope.profile) return NO("profile mode keeps the granular eager emission");
+  if (scope.profile) return NO3("profile mode keeps the granular eager emission");
   if (shape.callSite !== "plain" && shape.callSite !== "branch-plain") {
-    return NO(`call site '${shape.callSite}' is not a plain loop row`);
-  }
-  if (shape.flatMapLeafItem) return NO("flatMap descriptor loop (build-or-patch renderItem)");
-  if (shape.anchored) return NO("anchored whole-item-conditional loop");
-  if (shape.bodyIsMultiRoot) return NO("multi-root (Fragment) row");
-  if (!shape.hasExplicitKey) return NO("index-keyed loop (no explicit key)");
-  if (shape.conditionalCount > 0) return NO("row contains a reactive conditional");
-  if (shape.childRefCount > 0) return NO("row has imperative child refs");
-  if (shape.hasChildComponent) return NO("row body is a child component");
-  if (shape.nestedComponentCount > 0) return NO("row contains nested child components");
-  if (shape.innerLoopCount > 0) return NO("row contains an inner loop");
-  if (shape.hasMapPreamble) return NO("row has a map-callback preamble (may declare row-local reactivity)");
-  if (shape.preambleRegionCount > 0) return NO("row has preamble-patched regions");
-  if (shape.hasParamUnwrap) return NO("destructured loop param without param bindings");
+    return NO3(`call site '${shape.callSite}' is not a plain loop row`);
+  }
+  if (shape.flatMapLeafItem) return NO3("flatMap descriptor loop (build-or-patch renderItem)");
+  if (shape.anchored) return NO3("anchored whole-item-conditional loop");
+  if (shape.bodyIsMultiRoot) return NO3("multi-root (Fragment) row");
+  if (!shape.hasExplicitKey) return NO3("index-keyed loop (no explicit key)");
+  if (shape.conditionalRefusal) return NO3(shape.conditionalRefusal);
+  if (shape.childRefCount > 0) return NO3("row has imperative child refs");
+  if (shape.hasChildComponent) return NO3("row body is a child component");
+  if (shape.nestedComponentCount > 0) return NO3("row contains nested child components");
+  if (shape.innerLoopCount > 0) return NO3("row contains an inner loop");
+  if (shape.mapPreambleRefusal) return NO3(shape.mapPreambleRefusal);
+  if (shape.preambleRegionCount > 0) return NO3("row has preamble-patched regions");
+  if (shape.hasParamUnwrap) return NO3("destructured loop param without param bindings");
   for (const b of bindings) {
     if (b.referencesIndex) {
-      return NO(`binding on slot ${b.slotId} references the loop index parameter`);
+      return NO3(`binding on slot ${b.slotId} references the loop index parameter`);
     }
     if (b.opaqueOuterNames.includes(UNKNOWN_IDENTIFIERS)) {
-      return NO(`binding on slot ${b.slotId} has no analyzable identifier set`);
+      return NO3(`binding on slot ${b.slotId} has no analyzable identifier set`);
     }
   }
-  if (!arraySourceIdentifiers) return NO("loop source free identifiers unavailable");
+  if (!arraySourceIdentifiers) return NO3("loop source free identifiers unavailable");
   const sourceGate = checkSourceConsistency(arraySourceIdentifiers, scope);
-  if (sourceGate) return NO(`loop source is not provably hydration-consistent: ${sourceGate}`);
+  if (sourceGate) return NO3(`loop source is not provably hydration-consistent: ${sourceGate}`);
   return { eligible: true };
 }
 function checkSourceConsistency(names, scope) {
@@ -18701,6 +19111,7 @@ function checkSourceConsistency(names, scope) {
 }
 function classifyLazyBinding(args2) {
   const { kind: kind2, slotId, free, rowLocalNames, indexParam, scope } = args2;
+  const preamble = args2.preamble;
   if (free === null) {
     return {
       kind: kind2,
@@ -18713,30 +19124,43 @@ function classifyLazyBinding(args2) {
       // `UNKNOWN_IDENTIFIERS` must keep refusing the loop: with no
       // identifier set we cannot rule out an index read either, and
       // `applyItem` / `applyOuter` have no index parameter to give it.
-      referencesIndex: false
+      referencesIndex: false,
+      // An assumption like `referencesIndex` above, and the conservative
+      // one: with no identifier set we cannot rule out a preamble read
+      // either. The loop is refused for `UNKNOWN_IDENTIFIERS` regardless.
+      readsPreamble: preamble != null && preamble.declaredNames.size > 0
     };
   }
   let readsItem = false;
   let referencesIndex = false;
+  let readsPreamble = false;
   const reactiveOuterNames = [];
   const opaqueOuterNames = [];
-  for (const name2 of free) {
+  const classifyName = (name2) => {
     if (rowLocalNames.has(name2)) {
       readsItem = true;
-      continue;
+      return;
     }
     if (name2 === indexParam) {
       referencesIndex = true;
-      continue;
+      return;
     }
-    if (INERT_BINDING_GLOBALS.has(name2)) continue;
+    if (INERT_BINDING_GLOBALS.has(name2)) return;
     if (scope.signals.has(name2) || scope.memos.has(name2)) {
       if (!reactiveOuterNames.includes(name2)) reactiveOuterNames.push(name2);
-      continue;
+      return;
     }
     const constFree = scope.constants.get(name2);
-    if (constFree !== void 0 && constFree !== null && constFree.size === 0) continue;
+    if (constFree !== void 0 && constFree !== null && constFree.size === 0) return;
     opaqueOuterNames.push(name2);
+  };
+  for (const name2 of free) {
+    if (preamble?.declaredNames.has(name2)) {
+      readsPreamble = true;
+      for (const dep of preamble.freeNames) classifyName(dep);
+      continue;
+    }
+    classifyName(name2);
   }
   return {
     kind: kind2,
@@ -18745,10 +19169,11 @@ function classifyLazyBinding(args2) {
     readsOuter: reactiveOuterNames.length > 0 || opaqueOuterNames.length > 0,
     reactiveOuterNames,
     opaqueOuterNames,
-    referencesIndex
+    referencesIndex,
+    readsPreamble
   };
 }
-var PURE_SOURCE_GLOBALS, INERT_BINDING_GLOBALS, UNKNOWN_IDENTIFIERS, NO;
+var PURE_SOURCE_GLOBALS, INERT_BINDING_GLOBALS, UNKNOWN_IDENTIFIERS, NO3;
 var init_lazy_row_eligibility = __esm({
   "../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts"() {
     "use strict";
@@ -18794,7 +19219,7 @@ var init_lazy_row_eligibility = __esm({
       "decodeURI"
     ]);
     UNKNOWN_IDENTIFIERS = "<unknown>";
-    NO = (reason2) => ({ eligible: false, reason: reason2 });
+    NO3 = (reason2) => ({ eligible: false, reason: reason2 });
   }
 });
 
@@ -18810,6 +19235,23 @@ function decideLazyRow(args2) {
   const wrap = (expr) => wrapLoopParamAsAccessor(expr, loop.param, loop.paramBindings);
   const rowLocalNames = /* @__PURE__ */ new Set([loop.param]);
   for (const b of loop.paramBindings ?? []) rowLocalNames.add(b.name);
+  const primableNames = /* @__PURE__ */ new Set([...scope.signals.keys(), ...scope.memos]);
+  const preambleAnalysis = analyzeLazyPreamble(loop.preamble, args2.indexParam, primableNames);
+  const rawConditionals = loop.bindings.conditionals ?? [];
+  const condFacts = [];
+  let conditionalRefusal = null;
+  for (const cond of rawConditionals) {
+    const verdict = analyzeLazyConditional(cond, args2.indexParam, {
+      whenTrueHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
+      whenFalseHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId)
+    });
+    if (!verdict.lazySafe) {
+      conditionalRefusal = verdict.reason;
+      break;
+    }
+    condFacts.push(verdict.facts);
+  }
+  const preambleFacts = preambleAnalysis.lazySafe ? preambleAnalysis.facts : void 0;
   const classified = [];
   const attrClass = /* @__PURE__ */ new Map();
   loop.bindings.reactiveAttrs.forEach((attr, i) => {
@@ -18819,7 +19261,8 @@ function decideLazyRow(args2) {
       free: attrFreeIdentifiers2(attr.expression),
       rowLocalNames,
       indexParam: args2.indexParam,
-      scope
+      scope,
+      preamble: preambleFacts
     });
     attrClass.set(i, c);
     classified.push(c);
@@ -18832,23 +19275,38 @@ function decideLazyRow(args2) {
       free: text.freeIdentifiers ?? null,
       rowLocalNames,
       indexParam: args2.indexParam,
-      scope
+      scope,
+      preamble: preambleFacts
     });
     textClass.set(i, c);
     classified.push(c);
   });
+  const condClass = /* @__PURE__ */ new Map();
+  condFacts.forEach((c, i) => {
+    const k = classifyLazyBinding({
+      kind: "attr",
+      slotId: c.slotId,
+      free: rawConditionals[i].conditionFreeIdentifiers ?? null,
+      rowLocalNames,
+      indexParam: args2.indexParam,
+      scope,
+      preamble: preambleFacts
+    });
+    condClass.set(i, k);
+    classified.push(k);
+  });
   const shape = {
     callSite: args2.callSite,
     flatMapLeafItem: args2.flatMapLeafItem,
     anchored: args2.anchored,
     bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
     hasExplicitKey: loop.key != null,
-    conditionalCount: loop.bindings.conditionals?.length ?? 0,
+    conditionalRefusal,
     childRefCount: loop.bindings.refs?.length ?? 0,
     nestedComponentCount: loop.nestedComponents?.length ?? 0,
     innerLoopCount: loop.innerLoops?.length ?? 0,
     hasChildComponent: "childComponent" in loop && loop.childComponent != null,
-    hasMapPreamble: args2.mapPreambleWrapped.length > 0,
+    mapPreambleRefusal: preambleAnalysis.lazySafe ? null : preambleAnalysis.reason,
     preambleRegionCount: args2.preambleRegionCount,
     hasParamUnwrap: args2.paramUnwrap.length > 0
   };
@@ -18874,7 +19332,8 @@ function decideLazyRow(args2) {
       refIndex: attrSlotIds.indexOf(attr.childSlotId),
       ordinal: ordinal++,
       readsItem: c.readsItem,
-      readsOuter: c.readsOuter
+      readsOuter: c.readsOuter,
+      readsPreamble: c.readsPreamble
     };
   });
   const texts = loop.bindings.reactiveTexts.map((text, i) => {
@@ -18888,7 +19347,8 @@ function decideLazyRow(args2) {
       // silently never being written. Anything the classifier did place in
       // a list keeps exactly the classifier's answer.
       readsItem: c.readsItem || !c.readsOuter,
-      readsOuter: c.readsOuter
+      readsOuter: c.readsOuter,
+      readsPreamble: c.readsPreamble
     };
   });
   const outerPrimeGetters = [];
@@ -18897,6 +19357,25 @@ function decideLazyRow(args2) {
       if (!outerPrimeGetters.includes(name2)) outerPrimeGetters.push(name2);
     }
   }
+  const condRefBase = attrSlotIds.length + (texts.length > 0 ? 1 : 0);
+  const conditionals = condFacts.map((c, i) => {
+    const klass = condClass.get(i);
+    return {
+      slotId: c.slotId,
+      wrappedCondition: wrap(c.condition),
+      whenTrueHtml: c.whenTrueHtml,
+      whenFalseHtml: c.whenFalseHtml,
+      refIndex: condRefBase + i,
+      ordinal: ordinal++,
+      // A condition reading neither the item nor a reactive outer name still
+      // has to be applied somewhere; `applyItem` is the harmless choice (the
+      // dedup makes a repeat a no-op), matching how a text that classified as
+      // neither is handled above.
+      readsItem: klass.readsItem || !klass.readsOuter,
+      readsOuter: klass.readsOuter,
+      readsPreamble: klass.readsPreamble
+    };
+  });
   return {
     plan: {
       attrSlotIds,
@@ -18906,7 +19385,14 @@ function decideLazyRow(args2) {
       textNeedsRead: texts.some((t) => t.readsOuter),
       lastCount: ordinal,
       outerPrimeGetters,
-      hasOuter: attrs.some((a) => a.readsOuter) || texts.some((t) => t.readsOuter)
+      preambleStatements: args2.mapPreambleWrapped,
+      // Which apply bodies must re-run the preamble — computed from the FINAL
+      // binding lists, not the raw classification, so a text/conditional that
+      // classified as neither item- nor outer-driven (and was therefore forced
+      // into `applyItem` above) is counted in the body it actually lands in.
+      itemNeedsPreamble: [...attrs, ...texts, ...conditionals].some((b) => b.readsItem && b.readsPreamble),
+      outerNeedsPreamble: [...attrs, ...texts, ...conditionals].some((b) => b.readsOuter && b.readsPreamble),
+      conditionals
     },
     decision
   };
@@ -18957,7 +19443,10 @@ var init_build_lazy_row = __esm({
     init_expression_parser();
     init_types();
     init_csr_substitute();
+    init_html_template();
     init_utils();
+    init_lazy_conditional();
+    init_lazy_preamble();
     init_lazy_row_eligibility();
   }
 });
@@ -18983,7 +19472,7 @@ function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
   const indexParam = loop.index || "__idx";
   const mapPreambleWrapped = loop.preamble ? renderPreamble(loop.preamble, {
     transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
-    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0, true)
+    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0)
   }) : "";
   const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings);
   const plan = {
@@ -19133,7 +19622,7 @@ var init_claim_plan = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 function bindingIdArg(ctx2, slotId) {
   if (!ctx2.profile || !slotId) return "";
   return `, ${JSON.stringify(`${ctx2.componentName}#binding:${slotId}`)}`;
@@ -19213,19 +19702,19 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
   if (!matcher) return expr;
   let sourceFile;
   try {
-    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+    sourceFile = ts16.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts15.isExpressionStatement(stmt)) return expr;
-  const root2 = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts16.isExpressionStatement(stmt)) return expr;
+  const root2 = ts16.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts15.isCallExpression(n) && n.arguments.length === 2 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts16.isCallExpression(n) && n.arguments.length === 2 && ts16.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   };
   visit3(root2);
   if (candidates.length === 0) return expr;
@@ -19262,19 +19751,19 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
   if (!matcher) return expr;
   let sourceFile;
   try {
-    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+    sourceFile = ts16.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts15.isExpressionStatement(stmt)) return expr;
-  const root2 = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts16.isExpressionStatement(stmt)) return expr;
+  const root2 = ts16.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts15.isCallExpression(n) && n.arguments.length === 0 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts16.isCallExpression(n) && n.arguments.length === 0 && ts16.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   };
   visit3(root2);
   if (candidates.length === 0) return expr;
@@ -19614,7 +20103,7 @@ function stringifyReactiveEffects(lines, plan, opts) {
   const outerTexts = plan?.outerTexts ?? [];
   const conditionals = plan?.conditionals ?? [];
   if (pc) {
-    emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId);
+    emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId, mapPreambleWrapped);
     emitOuterTexts(lines, indent, elVar, outerTexts, bindingBfId, textClaimPathExprs);
     emitPreambleRegionsEffect(lines, indent, elVar, preambleRegions, mapPreambleWrapped);
   } else {
@@ -19635,7 +20124,7 @@ function stringifyReactiveEffects(lines, plan, opts) {
     emitOuterConditional(lines, indent, elVar, cond, pc);
   }
 }
-function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId) {
+function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId, mapPreambleWrapped) {
   for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     const lookupExpr = attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot);
@@ -19643,6 +20132,9 @@ function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementI
     lines.push(`${indent}if (${varName}) {`);
     for (const attr of slot.attrs) {
       lines.push(`${indent}  createEffect(() => {`);
+      if (attr.readsPreamble && mapPreambleWrapped) {
+        lines.push(`${indent}    ${mapPreambleWrapped}`);
+      }
       for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
         lines.push(`${indent}    ${stmt}`);
       }
@@ -19663,6 +20155,9 @@ function emitPreambleRegionsEffect(lines, indent, elVar, preambleRegions, mapPre
   }
   lines.push(`${indent}})`);
 }
+function attrsReadPreamble(attrSlots) {
+  return attrSlots.some((slot) => slot.attrs.some((a) => a.readsPreamble));
+}
 function attrLookupExpr(slotId, varName, elVar, lookup, elementIndexBySlot) {
   const pIdx = elementIndexBySlot?.get(slotId);
   return pIdx !== void 0 ? `__p ? __p[${pIdx}] : ${lookup}(${elVar}, '[bf="${slotId}"]')` : `${lookup}(${elVar}, '[bf="${slotId}"]')`;
@@ -19687,6 +20182,9 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
     return;
   }
   lines.push(`${indent}createEffect(() => {`);
+  if (mapPreambleWrapped && (preambleRegions.length > 0 || attrsReadPreamble(attrSlots))) {
+    lines.push(`${indent}  ${mapPreambleWrapped}`);
+  }
   for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}  if (${varName}) {`);
@@ -19699,9 +20197,6 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
     }
     lines.push(`${indent}  }`);
   }
-  if (preambleRegions.length > 0 && mapPreambleWrapped) {
-    lines.push(`${indent}  ${mapPreambleWrapped}`);
-  }
   for (const text of outerTexts) {
     lines.push(`${indent}  ${writer}('${text.slotId}', String(${text.wrappedExpression}))`);
   }
@@ -19847,9 +20342,8 @@ function stringifyLazyRowLoop(lines, o) {
   const { indent, lazyRow, paramHead } = o;
   const mid = o.markerId.replace(/[^A-Za-z0-9_$]/g, "_");
   const tplVar = `__tpl_${mid}`;
-  const claimVar = `__lzc_${mid}`;
   const hasRefs = lazyRow.attrSlotIds.length > 0 || lazyRow.texts.length > 0;
-  const hasBindings = lazyRow.attrs.length > 0 || lazyRow.texts.length > 0;
+  const hasBindings = lazyRow.attrs.length > 0 || lazyRow.texts.length > 0 || lazyRow.conditionals.length > 0;
   const rwDoor = lazyRow.textNeedsRead;
   const paths = o.skeletonPaths;
   const useHoisted = Boolean(o.skeletonTemplate);
@@ -19878,12 +20372,10 @@ function stringifyLazyRowLoop(lines, o) {
       freshPlanVar = adoptedPlanVar;
     }
   }
-  if (hasRefs) {
-    const parts = refParts(lazyRow, "__el", null, adoptedPlanVar, true);
-    lines.push(`${indent}const ${claimVar} = (__e) => {`);
-    if (parts.some((p) => p.includes("__el"))) lines.push(`${indent}  const __el = __e.primaryEl`);
-    lines.push(`${indent}  return [${parts.join(", ")}]`);
-    lines.push(`${indent}}`);
+  for (const c of lazyRow.conditionals) {
+    const v = condVars(mid, c.slotId);
+    emitHoistedTemplateDecl(lines, indent, v.trueTpl, c.whenTrueHtml);
+    emitHoistedTemplateDecl(lines, indent, v.falseTpl, c.whenFalseHtml);
   }
   const call = `mapArrayLazy(() => ${o.arrayExpr}, ${o.containerVar}, ${o.keyFn}, {`;
   lines.push(`${indent}${o.guardContainer ? `if (${o.containerVar}) ` : ""}${call}`);
@@ -19891,6 +20383,7 @@ function stringifyLazyRowLoop(lines, o) {
   const b2 = `${indent}    `;
   lines.push(`${b1}createRow: (__e, ${o.indexParam}) => {`);
   lines.push(`${b2}const ${paramHead} = () => __e.item`);
+  if (lazyRow.preambleStatements) lines.push(`${b2}${lazyRow.preambleStatements}`);
   const cloneExpr = useHoisted ? hoistedCloneExpr(tplVar, o.skeletonTemplate) : `(() => { ${emitTemplateCloneInline(o.template)} })()`;
   lines.push(`${b2}const __el = ${cloneExpr}`);
   if (hasRefs) {
@@ -19902,55 +20395,70 @@ function stringifyLazyRowLoop(lines, o) {
     const createDoor = `__r[${lazyRow.writerIndex}]`;
     for (const t of lazyRow.texts) emitTextBinding(lines, b2, t, createDoor, "create", rwDoor);
   }
+  for (const c of lazyRow.conditionals) emitConditional(lines, b2, mid, c, "create");
   lines.push(`${b2}return __el`);
   lines.push(`${b1}},`);
   const itemAttrs = lazyRow.attrs.filter((a) => a.readsItem);
   const itemTexts = lazyRow.texts.filter((t) => t.readsItem);
-  if (itemAttrs.length === 0 && itemTexts.length === 0) {
+  const itemConds = lazyRow.conditionals.filter((c) => c.readsItem);
+  if (itemAttrs.length === 0 && itemTexts.length === 0 && itemConds.length === 0) {
     lines.push(`${b1}applyItem: () => {},`);
   } else {
     lines.push(`${b1}applyItem: (__e) => {`);
     lines.push(`${b2}const ${paramHead} = () => __e.item`);
-    lines.push(`${b2}const __r = __e.refs ?? (__e.refs = ${claimVar}(__e))`);
+    lines.push(`${b2}const __r = __e.refs ?? (__e.refs = [])`);
     lines.push(`${b2}const __l = __e.last ?? (__e.last = [])`);
+    if (lazyRow.itemNeedsPreamble && lazyRow.preambleStatements) {
+      lines.push(`${b2}${lazyRow.preambleStatements}`);
+    }
     for (const a of itemAttrs) emitAttrBinding(lines, b2, a, "item");
     if (itemTexts.length > 0) {
       lines.push(`${b2}const __d = ${doorAccess(lazyRow, lazyRow.writerIndex, adoptedPlanVar)}`);
       for (const t of itemTexts) emitTextBinding(lines, b2, t, "__d", "item", rwDoor);
     }
+    for (const c of itemConds) emitConditional(lines, b2, mid, c, "item");
     lines.push(`${b1}},`);
   }
   const outerAttrs = lazyRow.attrs.filter((a) => a.readsOuter);
   const outerTexts = lazyRow.texts.filter((t) => t.readsOuter);
-  if (outerAttrs.length > 0 || outerTexts.length > 0) {
+  const outerConds = lazyRow.conditionals.filter((c) => c.readsOuter);
+  if (outerAttrs.length > 0 || outerTexts.length > 0 || outerConds.length > 0) {
     const b3 = `${indent}      `;
     lines.push(`${b1}applyOuter: (__es, __seed) => {`);
     for (const g of lazyRow.outerPrimeGetters) lines.push(`${b2}${g}()`);
     lines.push(`${b2}for (const __e of __es) {`);
     lines.push(`${b3}const ${paramHead} = () => __e.item`);
-    lines.push(`${b3}const __r = __e.refs ?? (__e.refs = ${claimVar}(__e))`);
+    lines.push(`${b3}const __r = __e.refs ?? (__e.refs = [])`);
     lines.push(`${b3}const __l = __e.last ?? (__e.last = [])`);
+    if (lazyRow.outerNeedsPreamble && lazyRow.preambleStatements) {
+      lines.push(`${b3}${lazyRow.preambleStatements}`);
+    }
     for (const a of outerAttrs) emitAttrBinding(lines, b3, a, "outer");
     if (outerTexts.length > 0) {
       lines.push(`${b3}const __d = ${doorAccess(lazyRow, lazyRow.writerIndex, adoptedPlanVar)}`);
       for (const t of outerTexts) emitTextBinding(lines, b3, t, "__d", "outer", rwDoor);
     }
+    for (const c of outerConds) emitConditional(lines, b3, mid, c, "outer");
     lines.push(`${b2}}`);
     lines.push(`${b1}},`);
   }
   lines.push(`${indent}}, '${o.markerId}')`);
 }
-function refParts(lazyRow, elVar, skeletonPaths, planVar, deferDoor = false) {
+function refParts(lazyRow, elVar, skeletonPaths, planVar) {
   const parts = [];
   for (const slotId of lazyRow.attrSlotIds) {
     const path25 = skeletonPaths?.elementPaths.get(slotId);
     parts.push(path25 ? pathExpr(elVar, path25) : `qsa(${elVar}, '[bf="${slotId}"]')`);
   }
   if (lazyRow.texts.length > 0) {
-    parts.push(deferDoor ? "null" : `${doorCtor(lazyRow)}(${elVar}, ${planVar})`);
+    parts.push(`${doorCtor(lazyRow)}(${elVar}, ${planVar})`);
   }
   return parts;
 }
+function elementAccess(a) {
+  const slot = `__r[${a.refIndex}]`;
+  return `${a.refIndex} in __r ? ${slot} : (${slot} = qsa(__e.primaryEl, '[bf="${a.slotId}"]'))`;
+}
 function doorCtor(lazyRow) {
   return lazyRow.textNeedsRead ? "lazyClaimSlots" : "lazySlots";
 }
@@ -19958,11 +20466,36 @@ function doorAccess(lazyRow, writerIndex, adoptedPlanVar) {
   const slot = `__r[${writerIndex}]`;
   return `${slot} ?? (${slot} = ${doorCtor(lazyRow)}(__e.primaryEl, ${adoptedPlanVar}))`;
 }
+function condVars(mid, slotId) {
+  const key = `${mid}_${slotId.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+  return { trueTpl: `__cbt_${key}`, falseTpl: `__cbf_${key}` };
+}
+function emitConditional(lines, ind, mid, c, mode2) {
+  const v = condVars(mid, c.slotId);
+  if (mode2 === "create") {
+    lines.push(`${ind}__l[${c.ordinal}] = !!(${c.wrappedCondition})`);
+    return;
+  }
+  const slot = `__r[${c.refIndex}]`;
+  lines.push(`${ind}{ const __c = ${c.refIndex} in __r ? ${slot} : (${slot} = qsa(__e.primaryEl, '[bf-c="${c.slotId}"]'))`);
+  lines.push(`${ind}if (__c) {`);
+  lines.push(`${ind}  const __x = !!(${c.wrappedCondition})`);
+  lines.push(`${ind}  const __w = (__x ? ${v.trueTpl} : ${v.falseTpl}).content.firstElementChild`);
+  const guard = mode2 === "item" ? dedupGuard(c.ordinal) : `__seed ? (__c.outerHTML !== __w.outerHTML) : (${dedupGuard(c.ordinal)})`;
+  lines.push(`${ind}  if (${guard}) {`);
+  lines.push(`${ind}    const __n = __w.cloneNode(true)`);
+  lines.push(`${ind}    __c.replaceWith(__n)`);
+  lines.push(`${ind}    ${slot} = __n`);
+  lines.push(`${ind}  }`);
+  lines.push(`${ind}  __l[${c.ordinal}] = __x`);
+  lines.push(`${ind}} }`);
+}
 function dedupGuard(ordinal) {
   return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
 }
 function emitAttrBinding(lines, ind, a, mode2) {
-  lines.push(`${ind}{ const __t = __r[${a.refIndex}]`);
+  const target2 = mode2 === "create" ? `__r[${a.refIndex}]` : elementAccess(a);
+  lines.push(`${ind}{ const __t = ${target2}`);
   lines.push(`${ind}if (__t) {`);
   lines.push(`${ind}  const __x = ${a.wrappedExpression}`);
   const guard = mode2 === "create" ? null : mode2 === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
@@ -21029,7 +21562,7 @@ function buildPlainLoopPlan(elem, profileComponentName, lazyScope) {
   const indexParam = elem.index || "__idx";
   const mapPreambleWrapped = elem.preamble ? renderPreamble(elem.preamble, {
     transformJs: wrap,
-    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0, true)
+    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0)
   }) : "";
   const preambleRegions = buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings);
   return {
@@ -21117,7 +21650,7 @@ function buildStaticLoopMaterialize(elem, unsafeLocalNames) {
   return {
     itemTemplate: elem.staticItemTemplate,
     mapPreamble: elem.preamble ? renderPreamble(elem.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0)
     }) : "",
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false
   };
@@ -21413,25 +21946,25 @@ var init_phases = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName) {
   const srcPropsName = propsObjectName ?? "props";
   if (srcPropsName === PROPS_PARAM) return code;
   if (!new RegExp(`\\b${srcPropsName}\\b`).test(code)) return code;
-  const sourceFile = ts16.createSourceFile(
+  const sourceFile = ts17.createSourceFile(
     "init-body.ts",
     code,
-    ts16.ScriptTarget.Latest,
+    ts17.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts16.ScriptKind.TS
+    ts17.ScriptKind.TS
   );
   const spans = [];
   function visit3(node) {
-    if (ts16.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts17.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts16.forEachChild(node, visit3);
+    ts17.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0) return code;
@@ -21445,12 +21978,12 @@ function rewritePropsObjectRef(code, propsObjectName) {
 function shouldRewrite(node) {
   const parent2 = node.parent;
   if (!parent2) return true;
-  if (ts16.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
-  if (ts16.isPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts16.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts16.isPropertySignature(parent2) && parent2.name === node) return false;
-  if (ts16.isPropertyDeclaration(parent2) && parent2.name === node) return false;
-  if (ts16.isBindingElement(parent2) && parent2.name === node) return false;
+  if (ts17.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
+  if (ts17.isPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts17.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts17.isPropertySignature(parent2) && parent2.name === node) return false;
+  if (ts17.isPropertyDeclaration(parent2) && parent2.name === node) return false;
+  if (ts17.isBindingElement(parent2) && parent2.name === node) return false;
   return true;
 }
 var init_rewrite_props_object = __esm({
@@ -21839,7 +22372,6 @@ function generateTemplateOnlyMount(ir, ctx2) {
       ir.root,
       csrInlinableConstants,
       ctx2,
-      void 0,
       restSpreadNames,
       ctx2.propsObjectName,
       unsafeLocalNames
@@ -22134,7 +22666,7 @@ var init_css_layer_prefixer = __esm({
 });
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function preprocessInlineJsxCallbacks(source, filePath) {
   const errors = [];
   const syntheticNames = [];
@@ -22154,15 +22686,15 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts17.createSourceFile(
+  const sourceFile = ts18.createSourceFile(
     filePath,
     source,
-    ts17.ScriptTarget.Latest,
+    ts18.ScriptTarget.Latest,
     true,
-    ts17.ScriptKind.TSX
+    ts18.ScriptKind.TSX
   );
   const hasUseClient = sourceFile.statements.some(
-    (stmt) => ts17.isExpressionStatement(stmt) && ts17.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
+    (stmt) => ts18.isExpressionStatement(stmt) && ts18.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
   );
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
@@ -22185,20 +22717,20 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts17.isJsxAttribute(node) && node.initializer && ts17.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts18.isJsxAttribute(node) && node.initializer && ts18.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts17.isPropertyAssignment(node) && node.initializer) {
+    if (ts18.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer)) return;
     }
-    ts17.forEachChild(node, visit3);
+    ts18.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts17.isParenthesizedExpression(expr)) expr = expr.expression;
-    if (ts17.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    while (ts18.isParenthesizedExpression(expr)) expr = expr.expression;
+    if (ts18.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -22233,7 +22765,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name2 });
     return true;
   }
-  ts17.forEachChild(sourceFile, visit3);
+  ts18.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -22252,48 +22784,48 @@ function errorMessageForCapture(captures) {
   return `Inline JSX-returning arrow function captures non-module identifier(s): ${captures.sort().join(", ")}. Extract the callback into a top-level '\\'use client\\'' component (e.g. \`function MyNode(n) { return <div/> }\` then \`renderNode={MyNode}\`) or pass captured values via component props.`;
 }
 function arrowBodyContainsJsx(arrow) {
-  if (ts17.isBlock(arrow.body)) {
+  if (ts18.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body2 = arrow.body;
-  while (ts17.isParenthesizedExpression(body2)) body2 = body2.expression;
+  while (ts18.isParenthesizedExpression(body2)) body2 = body2.expression;
   return isJsxLike(body2);
 }
 function blockReturnsJsx(block) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts17.isReturnStatement(n) && n.expression) {
+    if (ts18.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts17.isParenthesizedExpression(e)) e = e.expression;
+      while (ts18.isParenthesizedExpression(e)) e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts17.isArrowFunction(n) || ts17.isFunctionDeclaration(n) || ts17.isFunctionExpression(n)) return;
-    ts17.forEachChild(n, visit3);
+    if (ts18.isArrowFunction(n) || ts18.isFunctionDeclaration(n) || ts18.isFunctionExpression(n)) return;
+    ts18.forEachChild(n, visit3);
   }
-  ts17.forEachChild(block, visit3);
+  ts18.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts17.isJsxElement(expr) || ts17.isJsxSelfClosingElement(expr) || ts17.isJsxFragment(expr);
+  return ts18.isJsxElement(expr) || ts18.isJsxSelfClosingElement(expr) || ts18.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = /* @__PURE__ */ new Set();
-  for (const p of arrow.parameters) collectBindingNames2(p.name, names);
+  for (const p of arrow.parameters) collectBindingNames3(p.name, names);
   return names;
 }
-function collectBindingNames2(name2, out) {
+function collectBindingNames3(name2, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts17.isIdentifier(name2)) {
+  if (ts18.isIdentifier(name2)) {
     push(name2.text);
-  } else if (ts17.isObjectBindingPattern(name2)) {
-    name2.elements.forEach((el) => collectBindingNames2(el.name, out));
-  } else if (ts17.isArrayBindingPattern(name2)) {
+  } else if (ts18.isObjectBindingPattern(name2)) {
+    name2.elements.forEach((el) => collectBindingNames3(el.name, out));
+  } else if (ts18.isArrayBindingPattern(name2)) {
     name2.elements.forEach((el) => {
-      if (!ts17.isOmittedExpression(el)) collectBindingNames2(el.name, out);
+      if (!ts18.isOmittedExpression(el)) collectBindingNames3(el.name, out);
     });
   }
 }
@@ -22302,12 +22834,12 @@ function collectFreeIdentifiers(arrow) {
   const bound = [];
   for (const p of arrow.parameters) {
     const names = [];
-    collectBindingNames2(p.name, names);
+    collectBindingNames3(p.name, names);
     bound.push(...names);
   }
   function pushBindings(name2) {
     const names = [];
-    collectBindingNames2(name2, names);
+    collectBindingNames3(name2, names);
     bound.push(...names);
     return names;
   }
@@ -22318,71 +22850,71 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name2);
   }
   function visit3(node) {
-    if (ts17.isIdentifier(node)) {
+    if (ts18.isIdentifier(node)) {
       const parent2 = node.parent;
-      if (parent2 && ts17.isPropertyAccessExpression(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isPropertyAssignment(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isPropertySignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isPropertyDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isMethodDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isMethodSignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isEnumMember(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isBindingElement(parent2) && parent2.propertyName === node) return;
-      if (parent2 && ts17.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
+      if (parent2 && ts18.isPropertyAccessExpression(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isPropertyAssignment(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isPropertySignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isPropertyDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isMethodDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isMethodSignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isEnumMember(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isBindingElement(parent2) && parent2.propertyName === node) return;
+      if (parent2 && ts18.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
         if (!isBound(node.text)) ids.add(node.text);
         return;
       }
-      if (parent2 && ts17.isParameter(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isVariableDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isFunctionDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isClassDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isJsxAttribute(parent2) && parent2.name === node) return;
-      if (parent2 && ts17.isJsxOpeningElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts18.isParameter(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isVariableDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isFunctionDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isClassDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isJsxAttribute(parent2) && parent2.name === node) return;
+      if (parent2 && ts18.isJsxOpeningElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
-      if (parent2 && ts17.isJsxClosingElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts18.isJsxClosingElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
       if (isBound(node.text)) return;
       ids.add(node.text);
       return;
     }
-    if (ts17.isVariableDeclaration(node)) {
+    if (ts18.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer) visit3(node.initializer);
       declared;
       return;
     }
-    if (ts17.isFunctionDeclaration(node)) {
+    if (ts18.isFunctionDeclaration(node)) {
       if (node.name) bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts17.isClassDeclaration(node)) {
+    if (ts18.isClassDeclaration(node)) {
       if (node.name) bound.push(node.name.text);
-      ts17.forEachChild(node, visit3);
+      ts18.forEachChild(node, visit3);
       return;
     }
-    if (ts17.isArrowFunction(node) || ts17.isFunctionExpression(node)) {
+    if (ts18.isArrowFunction(node) || ts18.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts17.isCatchClause(node)) {
+    if (ts18.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration) pushBindings(node.variableDeclaration.name);
-      ts17.forEachChild(node, visit3);
+      ts18.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts17.isBlock(node)) {
+    if (ts18.isBlock(node)) {
       const before = bound.length;
-      ts17.forEachChild(node, visit3);
+      ts18.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts17.forEachChild(node, visit3);
+    ts18.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -22402,27 +22934,27 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = /* @__PURE__ */ new Set();
   for (const stmt of sourceFile.statements) {
-    if (ts17.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts17.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts17.isVariableStatement(stmt)) {
-      for (const decl of stmt.declarationList.declarations) collectBindingNames2(decl.name, names);
-    } else if (ts17.isImportDeclaration(stmt) && stmt.importClause) {
+    if (ts18.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    else if (ts18.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    else if (ts18.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) collectBindingNames3(decl.name, names);
+    } else if (ts18.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name) names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts17.isNamespaceImport(ic.namedBindings)) names.add(ic.namedBindings.name.text);
+        if (ts18.isNamespaceImport(ic.namedBindings)) names.add(ic.namedBindings.name.text);
         else for (const e of ic.namedBindings.elements) names.add(e.name.text);
       }
-    } else if (ts17.isTypeAliasDeclaration(stmt)) names.add(stmt.name.text);
-    else if (ts17.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
-    else if (ts17.isEnumDeclaration(stmt)) names.add(stmt.name.text);
+    } else if (ts18.isTypeAliasDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts18.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts18.isEnumDeclaration(stmt)) names.add(stmt.name.text);
   }
   return names;
 }
 function buildSyntheticDeclaration(name2, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts17.isBlock(arrow.body)) {
+  if (ts18.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -22441,7 +22973,7 @@ var init_preprocess_inline_jsx_callbacks = __esm({
 });
 
 // ../jsx/src/ssr-defaults.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 function extractSsrDefaults(metadata) {
   const out = {};
   const propsLike = /* @__PURE__ */ new Set();
@@ -22449,11 +22981,12 @@ function extractSsrDefaults(metadata) {
   for (const p of metadata.propsParams) propsLike.add(p.name);
   for (const p of metadata.propsParams) {
     if (p.isRest) continue;
+    const callerPropName = p.sourceName ?? p.name;
     if (metadata.propsObjectName === null && p.defaultValue !== void 0) {
       const value2 = tryStaticEval(p.defaultValue, { bindings: {}, propsLike });
-      out[p.name] = { propName: p.name, value: resultToJsonable(value2) };
+      out[p.name] = { propName: callerPropName, value: resultToJsonable(value2) };
     } else {
-      out[p.name] = { propName: p.name, value: null };
+      out[p.name] = { propName: callerPropName, value: null };
     }
   }
   if (metadata.restPropsName) {
@@ -22501,11 +23034,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   const node = parseExpression2(expr);
   if (!node) return;
   const visit3 = (n) => {
-    if (ts18.isPropertyAccessExpression(n) && ts18.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts18.isIdentifier(n.name)) {
+    if (ts19.isPropertyAccessExpression(n) && ts19.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts19.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts18.forEachChild(n, visit3);
+    ts19.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -22522,21 +23055,21 @@ function tryStaticEval(expr, ctx2) {
 }
 function evalStatementsForReturn(statements, ctx2) {
   for (const stmt of statements) {
-    if (ts18.isVariableStatement(stmt)) {
+    if (ts19.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts18.isIdentifier(d.name) || !d.initializer) continue;
+        if (!ts19.isIdentifier(d.name) || !d.initializer) continue;
         const v = evalNode(d.initializer, ctx2);
         if (v !== UNRESOLVED) ctx2.bindings[d.name.text] = v;
       }
-    } else if (ts18.isReturnStatement(stmt)) {
+    } else if (ts19.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx2) : UNRESOLVED;
-    } else if (ts18.isIfStatement(stmt)) {
+    } else if (ts19.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx2);
       if (cond === UNRESOLVED) return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
         const taken = evalStatementsForReturn(
-          ts18.isBlock(branch) ? branch.statements : [branch],
+          ts19.isBlock(branch) ? branch.statements : [branch],
           ctx2
         );
         if (taken !== NO_RETURN) return taken;
@@ -22548,64 +23081,64 @@ function evalStatementsForReturn(statements, ctx2) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts18.createSourceFile(
+  const sf = ts19.createSourceFile(
     "__ssr_default__.ts",
     `(${expr})`,
-    ts18.ScriptTarget.Latest,
+    ts19.ScriptTarget.Latest,
     false,
-    ts18.ScriptKind.TS
+    ts19.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt)) return null;
-  const inner = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts19.isExpressionStatement(stmt)) return null;
+  const inner = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx2) {
-  if (ts18.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts18.isAsExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts18.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts18.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts18.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts18.isArrowFunction(node)) {
+  if (ts19.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts19.isAsExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts19.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts19.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts19.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts19.isArrowFunction(node)) {
     if (node.parameters.length !== 0) return UNRESOLVED;
-    if (!ts18.isBlock(node.body)) return evalNode(node.body, ctx2);
+    if (!ts19.isBlock(node.body)) return evalNode(node.body, ctx2);
     const localBindings = { ...ctx2.bindings };
     const localCtx = { ...ctx2, bindings: localBindings };
     const result2 = evalStatementsForReturn(node.body.statements, localCtx);
     return result2 === NO_RETURN ? UNRESOLVED : result2;
   }
-  if (ts18.isNumericLiteral(node)) return Number(node.text);
-  if (ts18.isStringLiteralLike(node)) return node.text;
-  if (node.kind === ts18.SyntaxKind.TrueKeyword) return true;
-  if (node.kind === ts18.SyntaxKind.FalseKeyword) return false;
-  if (node.kind === ts18.SyntaxKind.NullKeyword) return null;
-  if (ts18.isIdentifier(node)) {
+  if (ts19.isNumericLiteral(node)) return Number(node.text);
+  if (ts19.isStringLiteralLike(node)) return node.text;
+  if (node.kind === ts19.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts19.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts19.SyntaxKind.NullKeyword) return null;
+  if (ts19.isIdentifier(node)) {
     if (node.text === "undefined") return void 0;
     if (node.text in ctx2.bindings) return ctx2.bindings[node.text];
     if (ctx2.propsLike.has(node.text)) return void 0;
     return UNRESOLVED;
   }
-  if (ts18.isPrefixUnaryExpression(node)) {
+  if (ts19.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx2);
     if (arg === UNRESOLVED) return UNRESOLVED;
     switch (node.operator) {
-      case ts18.SyntaxKind.MinusToken:
+      case ts19.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts18.SyntaxKind.PlusToken:
+      case ts19.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts18.SyntaxKind.ExclamationToken:
+      case ts19.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts18.isObjectLiteralExpression(node)) {
+  if (ts19.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts18.isPropertyAssignment(prop)) return UNRESOLVED;
+      if (!ts19.isPropertyAssignment(prop)) return UNRESOLVED;
       let key;
-      if (ts18.isIdentifier(prop.name) || ts18.isStringLiteralLike(prop.name)) {
+      if (ts19.isIdentifier(prop.name) || ts19.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts18.isNumericLiteral(prop.name)) {
+      } else if (ts19.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -22616,17 +23149,17 @@ function evalNode(node, ctx2) {
     }
     return obj;
   }
-  if (ts18.isArrayLiteralExpression(node)) {
+  if (ts19.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts18.isOmittedExpression(elem)) return UNRESOLVED;
+      if (ts19.isOmittedExpression(elem)) return UNRESOLVED;
       const v = evalNode(elem, ctx2);
       if (v === UNRESOLVED) return UNRESOLVED;
       arr.push(v === void 0 ? null : v);
     }
     return arr;
   }
-  if (ts18.isElementAccessExpression(node)) {
+  if (ts19.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx2);
     if (base === void 0) return void 0;
     if (base === UNRESOLVED || base === null || typeof base !== "object") return UNRESOLVED;
@@ -22636,16 +23169,16 @@ function evalNode(node, ctx2) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : void 0;
   }
-  if (ts18.isPropertyAccessExpression(node)) {
+  if (ts19.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx2);
     if (baseResult === void 0) return void 0;
     return UNRESOLVED;
   }
-  if (ts18.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts18.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
+  if (ts19.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts19.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
       return ctx2.bindings[node.expression.text];
     }
-    if (ts18.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts19.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx2);
       if (Array.isArray(recv)) {
         let sep = ",";
@@ -22660,24 +23193,24 @@ function evalNode(node, ctx2) {
     }
     return UNRESOLVED;
   }
-  if (ts18.isConditionalExpression(node)) {
+  if (ts19.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx2);
     if (cond === UNRESOLVED) return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx2) : evalNode(node.whenFalse, ctx2);
   }
-  if (ts18.isBinaryExpression(node)) {
+  if (ts19.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts18.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts19.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== void 0) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts18.SyntaxKind.BarBarToken) {
+    if (op === ts19.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 !== UNRESOLVED && l2) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts18.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts19.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 === UNRESOLVED) return UNRESOLVED;
       if (!l2) return l2;
@@ -22687,28 +23220,28 @@ function evalNode(node, ctx2) {
     const r2 = evalNode(node.right, ctx2);
     if (l === UNRESOLVED || r2 === UNRESOLVED) return UNRESOLVED;
     switch (op) {
-      case ts18.SyntaxKind.PlusToken:
+      case ts19.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r2 === "string") return `${l}${r2}`;
         if (typeof l === "number" && typeof r2 === "number") return l + r2;
         return UNRESOLVED;
-      case ts18.SyntaxKind.MinusToken:
+      case ts19.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r2 === "number" ? l - r2 : UNRESOLVED;
-      case ts18.SyntaxKind.AsteriskToken:
+      case ts19.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r2 === "number" ? l * r2 : UNRESOLVED;
-      case ts18.SyntaxKind.SlashToken:
+      case ts19.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l / r2 : UNRESOLVED;
-      case ts18.SyntaxKind.PercentToken:
+      case ts19.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l % r2 : UNRESOLVED;
-      case ts18.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts18.SyntaxKind.EqualsEqualsToken:
+      case ts19.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts19.SyntaxKind.EqualsEqualsToken:
         return l === r2;
-      case ts18.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts18.SyntaxKind.ExclamationEqualsToken:
+      case ts19.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts19.SyntaxKind.ExclamationEqualsToken:
         return l !== r2;
     }
     return UNRESOLVED;
   }
-  if (ts18.isTemplateExpression(node)) {
+  if (ts19.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0) return node.head.text;
     let acc = node.head.text;
     for (const span of node.templateSpans) {
@@ -22718,7 +23251,7 @@ function evalNode(node, ctx2) {
     }
     return acc;
   }
-  if (ts18.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts19.isNoSubstitutionTemplateLiteral(node)) return node.text;
   return UNRESOLVED;
 }
 var UNRESOLVED, NO_RETURN;
@@ -22731,7 +23264,7 @@ var init_ssr_defaults = __esm({
 });
 
 // ../jsx/src/augment-inherited-props.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = /* @__PURE__ */ new Map();
@@ -22758,35 +23291,35 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr)) return null;
-  if (!ts19.isIdentifier(expr.expression) || expr.expression.text !== "useContext") return null;
+  if (!expr || !ts20.isCallExpression(expr)) return null;
+  if (!ts20.isIdentifier(expr.expression) || expr.expression.text !== "useContext") return null;
   if (expr.arguments.length !== 1) return null;
   const arg = expr.arguments[0];
-  return ts19.isIdentifier(arg) ? arg.text : null;
+  return ts20.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr)) return null;
+  if (!expr || !ts20.isCallExpression(expr)) return null;
   if (expr.arguments.length === 0) return null;
   const arg = expr.arguments[0];
-  if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
-  if (ts19.isNumericLiteral(arg)) return Number(arg.text);
-  if (arg.kind === ts19.SyntaxKind.TrueKeyword) return true;
-  if (arg.kind === ts19.SyntaxKind.FalseKeyword) return false;
+  if (ts20.isStringLiteral(arg) || ts20.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
+  if (ts20.isNumericLiteral(arg)) return Number(arg.text);
+  if (arg.kind === ts20.SyntaxKind.TrueKeyword) return true;
+  if (arg.kind === ts20.SyntaxKind.FalseKeyword) return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr)) return false;
+  if (!expr || !ts20.isCallExpression(expr)) return false;
   if (expr.arguments.length === 0) return false;
-  return ts19.isObjectLiteralExpression(expr.arguments[0]);
+  return ts20.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts19.createSourceFile("__ctx.ts", `(${source})`, ts19.ScriptTarget.Latest, false);
+  const sf = ts20.createSourceFile("__ctx.ts", `(${source})`, ts20.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isExpressionStatement(stmt)) return null;
+  if (!stmt || !ts20.isExpressionStatement(stmt)) return null;
   let e = stmt.expression;
-  while (ts19.isParenthesizedExpression(e)) e = e.expression;
+  while (ts20.isParenthesizedExpression(e)) e = e.expression;
   return e;
 }
 function augmentInheritedPropAccesses(ir) {
@@ -22807,21 +23340,21 @@ function augmentInheritedPropAccesses(ir) {
   const coalesceLiteralTypes = /* @__PURE__ */ new Map();
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj)) return;
-    const sf = ts19.createSourceFile("__aug.ts", `(${s})`, ts19.ScriptTarget.Latest, false);
+    const sf = ts20.createSourceFile("__aug.ts", `(${s})`, ts20.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts19.isBinaryExpression(n) && (n.operatorToken.kind === ts19.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts19.SyntaxKind.BarBarToken)) {
+      if (ts20.isBinaryExpression(n) && (n.operatorToken.kind === ts20.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts20.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts19.isParenthesizedExpression(left)) left = left.expression;
-        if (ts19.isPropertyAccessExpression(left) && ts19.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        while (ts20.isParenthesizedExpression(left)) left = left.expression;
+        if (ts20.isPropertyAccessExpression(left) && ts20.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name2 = left.name.text;
           let right = n.right;
-          while (ts19.isParenthesizedExpression(right)) right = right.expression;
-          if (ts19.isPrefixUnaryExpression(right)) right = right.operand;
-          const kind2 = ts19.isNumericLiteral(right) ? "number" : right.kind === ts19.SyntaxKind.TrueKeyword || right.kind === ts19.SyntaxKind.FalseKeyword ? "boolean" : ts19.isStringLiteralLike(right) ? "string" : null;
+          while (ts20.isParenthesizedExpression(right)) right = right.expression;
+          if (ts20.isPrefixUnaryExpression(right)) right = right.operand;
+          const kind2 = ts20.isNumericLiteral(right) ? "number" : right.kind === ts20.SyntaxKind.TrueKeyword || right.kind === ts20.SyntaxKind.FalseKeyword ? "boolean" : ts20.isStringLiteralLike(right) ? "string" : null;
           if (kind2 && !coalesceLiteralTypes.has(name2)) coalesceLiteralTypes.set(name2, kind2);
         }
       }
-      ts19.forEachChild(n, visit3);
+      ts20.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -22917,39 +23450,39 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts19.createSourceFile(
+  const sf = ts20.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts19.ScriptTarget.Latest,
+    ts20.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts20.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts19.isParenthesizedExpression(init)) init = init.expression;
+  while (init && ts20.isParenthesizedExpression(init)) init = init.expression;
   if (!init) return null;
-  if (ts19.isStringLiteral(init) || ts19.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts20.isStringLiteral(init) || ts20.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts19.createSourceFile(
+  const sf = ts20.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts19.ScriptTarget.Latest,
+    ts20.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts20.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts19.isParenthesizedExpression(init)) init = init.expression;
-  if (!init || !ts19.isTemplateExpression(init)) return null;
+  while (init && ts20.isParenthesizedExpression(init)) init = init.expression;
+  if (!init || !ts20.isTemplateExpression(init)) return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts19.isIdentifier(span.expression)) return null;
+    if (!ts20.isIdentifier(span.expression)) return null;
     const value2 = resolved.get(span.expression.text);
     if (value2 === void 0) return null;
     out += value2 + span.literal.text;
@@ -22978,28 +23511,28 @@ function collectModuleStringConsts(constants) {
 function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === void 0) return null;
-  const sf = ts19.createSourceFile(
+  const sf = ts20.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts19.ScriptTarget.Latest,
+    ts20.ScriptTarget.Latest,
     /*setParentNodes*/
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts19.isExpressionStatement(stmt)) return null;
+  if (!ts20.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts19.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts19.isObjectLiteralExpression(parsed)) return null;
+  while (ts20.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts20.isObjectLiteralExpression(parsed)) return null;
   for (const prop of parsed.properties) {
-    if (!ts19.isPropertyAssignment(prop)) continue;
+    if (!ts20.isPropertyAssignment(prop)) continue;
     const name2 = prop.name;
-    const propKey = ts19.isIdentifier(name2) || ts19.isStringLiteral(name2) || ts19.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
+    const propKey = ts20.isIdentifier(name2) || ts20.isStringLiteral(name2) || ts20.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
     if (propKey !== key) continue;
     let v = prop.initializer;
-    while (ts19.isParenthesizedExpression(v)) v = v.expression;
-    if (ts19.isNumericLiteral(v)) return { kind: "number", text: v.text };
-    if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
+    while (ts20.isParenthesizedExpression(v)) v = v.expression;
+    if (ts20.isNumericLiteral(v)) return { kind: "number", text: v.text };
+    if (ts20.isStringLiteral(v) || ts20.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -23007,27 +23540,27 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts19.createSourceFile(
+  const sf = ts20.createSourceFile(
     "__join.ts",
     `const __x = (${source});`,
-    ts19.ScriptTarget.Latest,
+    ts20.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts20.isVariableStatement(stmt)) return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts19.isParenthesizedExpression(node)) node = node.expression;
-  if (!node || !ts19.isCallExpression(node)) return null;
+  while (node && ts20.isParenthesizedExpression(node)) node = node.expression;
+  if (!node || !ts20.isCallExpression(node)) return null;
   const callee = node.expression;
-  if (!ts19.isPropertyAccessExpression(callee)) return null;
+  if (!ts20.isPropertyAccessExpression(callee)) return null;
   if (callee.name.text !== "join") return null;
   let recv = callee.expression;
-  while (ts19.isParenthesizedExpression(recv)) recv = recv.expression;
-  if (!ts19.isArrayLiteralExpression(recv)) return null;
+  while (ts20.isParenthesizedExpression(recv)) recv = recv.expression;
+  if (!ts20.isArrayLiteralExpression(recv)) return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts19.isStringLiteral(el) || ts19.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts20.isStringLiteral(el) || ts20.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -23036,16 +23569,16 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
+    if (ts20.isStringLiteral(arg) || ts20.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
     else return null;
   }
   return parts.join(sep);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts19.isElementAccessExpression(val)) return null;
+  if (!ts20.isElementAccessExpression(val)) return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts19.isIdentifier(obj) || !ts19.isIdentifier(arg)) return null;
+  if (!ts20.isIdentifier(obj) || !ts20.isIdentifier(arg)) return null;
   let indexPropName;
   let defaultKey;
   const resolved = resolveKey?.(arg.text);
@@ -23059,35 +23592,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   }
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === void 0) return null;
-  const sf = ts19.createSourceFile(
+  const sf = ts20.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts19.ScriptTarget.Latest,
+    ts20.ScriptTarget.Latest,
     /* setParentNodes */
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts19.isExpressionStatement(stmt)) return null;
+  if (!ts20.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts19.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts19.isObjectLiteralExpression(parsed)) return null;
+  while (ts20.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts20.isObjectLiteralExpression(parsed)) return null;
   const entries2 = [];
   for (const prop of parsed.properties) {
-    if (!ts19.isPropertyAssignment(prop)) return null;
+    if (!ts20.isPropertyAssignment(prop)) return null;
     let key;
-    if (ts19.isIdentifier(prop.name)) {
+    if (ts20.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts19.isStringLiteral(prop.name) || ts19.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts20.isStringLiteral(prop.name) || ts20.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts19.isParenthesizedExpression(v)) v = v.expression;
-    if (ts19.isNumericLiteral(v)) {
+    while (ts20.isParenthesizedExpression(v)) v = v.expression;
+    if (ts20.isNumericLiteral(v)) {
       entries2.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts20.isStringLiteral(v) || ts20.isNoSubstitutionTemplateLiteral(v)) {
       entries2.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -23891,7 +24424,7 @@ var init_compiler = __esm({
 });
 
 // ../jsx/src/shared-program.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 import path5 from "node:path";
 function commonParent(paths) {
   if (paths.length === 0) return process.cwd();
@@ -23909,10 +24442,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files2, options2 = {}) {
   const baseUrl = options2.baseUrl ?? commonParent(files2);
   const compilerOptions = {
-    target: ts20.ScriptTarget.Latest,
-    module: ts20.ModuleKind.ESNext,
-    moduleResolution: ts20.ModuleResolutionKind.Bundler,
-    jsx: ts20.JsxEmit.ReactJSX,
+    target: ts21.ScriptTarget.Latest,
+    module: ts21.ModuleKind.ESNext,
+    moduleResolution: ts21.ModuleResolutionKind.Bundler,
+    jsx: ts21.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -23922,7 +24455,7 @@ function createProgramForCorpus(files2, options2 = {}) {
     ...options2.compilerOptions
   };
   const absolute = files2.map((f) => path5.resolve(f));
-  return ts20.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
+  return ts21.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
 }
 var init_shared_program = __esm({
   "../jsx/src/shared-program.ts"() {
@@ -24533,6 +25066,7 @@ function collectLoopBoundNames(ir) {
         if (node.index) names.add(node.index);
         for (const binding of node.paramBindings ?? []) names.add(binding.name);
         if (node.filterPredicate) names.add(node.filterPredicate.param);
+        for (const name2 of node.preamble?.declaredNames ?? []) names.add(name2);
         for (const child of node.children) visit3(child);
         if (node.childComponent) {
           for (const child of node.childComponent.children) visit3(child);
@@ -24991,7 +25525,7 @@ var init_dangerous_inner_html = __esm({
 });
 
 // ../jsx/src/combine-client-js.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function combineParentChildClientJs(files2) {
   const result2 = /* @__PURE__ */ new Map();
   const lookup = /* @__PURE__ */ new Map();
@@ -25048,17 +25582,17 @@ function combineParentChildClientJs(files2) {
   return result2;
 }
 function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts21.createSourceFile(
+  const sourceFile = ts22.createSourceFile(
     "combine.js",
     content2,
-    ts21.ScriptTarget.Latest,
+    ts22.ScriptTarget.Latest,
     /*setParentNodes*/
     false,
-    ts21.ScriptKind.JS
+    ts22.ScriptKind.JS
   );
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts21.isImportDeclaration(stmt)) continue;
+    if (!ts22.isImportDeclaration(stmt)) continue;
     const start2 = stmt.getStart(sourceFile);
     const end2 = stmt.getEnd();
     importSpans.push([start2, end2]);
@@ -25066,8 +25600,8 @@ function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
     if (stmtText.includes("@bf-child:")) continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts21.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts21.isNamedImports(bindings)) {
+    const specifier = ts22.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts22.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, /* @__PURE__ */ new Set());
       }
@@ -25261,7 +25795,7 @@ var init_loop_destructure = __esm({
 });
 
 // ../jsx/src/debug.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx2 = analyzeComponent(source, filePath, componentName);
   if (!ctx2.jsxReturn) {
@@ -26473,18 +27007,18 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts22.createSourceFile("__attr.tsx", `(${expr})`, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
+    sf = ts23.createSourceFile("__attr.tsx", `(${expr})`, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
   } catch {
     return false;
   }
   let found = false;
   const visit3 = (n) => {
     if (found) return;
-    if (ts22.isPropertyAccessExpression(n) && ts22.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts23.isPropertyAccessExpression(n) && ts23.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts22.forEachChild(n, visit3);
+    ts23.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -26561,7 +27095,7 @@ var init_debug = __esm({
 });
 
 // ../jsx/src/profiler.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 function buildStaticBudget(source, filePath, componentName, options2 = {}) {
   const threshold = options2.fanOutThreshold ?? DEFAULT_FANOUT_THRESHOLD;
   const program = createProgramForFile(source, filePath)?.program;
@@ -26816,14 +27350,14 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts23.createSourceFile(filePath, source, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
+  const sf = ts24.createSourceFile(filePath, source, ts24.ScriptTarget.Latest, true, ts24.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts23.isCallExpression(node) && ts23.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts24.isCallExpression(node) && ts24.isIdentifier(node.expression) && node.expression.text === "createEffect") {
       const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
       if (!instrumentedLines.has(line)) out.push({ file: filePath, line });
     }
-    ts23.forEachChild(node, visit3);
+    ts24.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -27109,19 +27643,19 @@ function assessBatchSafety(args2) {
   const signalGetters = new Set(args2.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts23.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts23.ScriptTarget.Latest, true);
+    sf = ts24.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts24.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts23.isCallExpression(node) && ts23.isIdentifier(node.expression)) {
+    if (ts24.isCallExpression(node) && ts24.isIdentifier(node.expression)) {
       const name2 = node.expression.text;
       if (setters.has(name2)) calls.push({ pos: node.getStart(sf), kind: "write" });
       else if (D.has(name2) && node.arguments.length === 0) calls.push({ pos: node.getStart(sf), kind: "memoRead" });
       else if (!signalGetters.has(name2) && !memoNames.has(name2)) calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts23.forEachChild(node, visit3);
+    ts24.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -27825,6 +28359,7 @@ __export(src_exports, {
   dangerousInnerHtmlDiagnostic: () => dangerousInnerHtmlDiagnostic,
   dangerousInnerHtmlMetacharViolation: () => dangerousInnerHtmlMetacharViolation,
   decideClientOnlyElision: () => decideClientOnlyElision,
+  derivesScopeFromSlot: () => derivesScopeFromSlot,
   describeFallback: () => describeFallback,
   diffProfiles: () => diffProfiles,
   diffStaticBudget: () => diffStaticBudget,
@@ -27948,6 +28483,7 @@ var init_src2 = __esm({
     init_template_imports();
     init_parsed_expr_emitter();
     init_loop_bound_names();
+    init_child_scope();
     init_signal_init_eval();
     init_static_literal();
     init_env_signal();
@@ -28041,7 +28577,7 @@ var init_runtime = __esm({
 
 // src/lib/resolve-imports.ts
 import { dirname as dirname2, resolve as resolve2 } from "node:path";
-import ts24 from "typescript";
+import ts25 from "typescript";
 function shapeFromDecl(decl) {
   const clause = decl.importClause;
   if (!clause) return null;
@@ -28051,7 +28587,7 @@ function shapeFromDecl(decl) {
   }
   const bindings = clause.namedBindings;
   if (bindings) {
-    if (ts24.isNamespaceImport(bindings)) {
+    if (ts25.isNamespaceImport(bindings)) {
       shape.namespace = bindings.name.text;
     } else {
       for (const el of bindings.elements) {
@@ -28068,50 +28604,50 @@ function collectExportInfo(source) {
   const otherValueExports = /* @__PURE__ */ new Set();
   const reExportedNames = /* @__PURE__ */ new Set();
   let hasStarReExport = false;
-  const sourceFile = ts24.createSourceFile(
+  const sourceFile = ts25.createSourceFile(
     "mod.ts",
     source,
-    ts24.ScriptTarget.Latest,
+    ts25.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts24.ScriptKind.TS
+    ts25.ScriptKind.TS
   );
   function hasExport(node) {
-    if (!ts24.canHaveModifiers(node)) return false;
-    const mods = ts24.getModifiers(node);
-    return mods?.some((m) => m.kind === ts24.SyntaxKind.ExportKeyword) ?? false;
+    if (!ts25.canHaveModifiers(node)) return false;
+    const mods = ts25.getModifiers(node);
+    return mods?.some((m) => m.kind === ts25.SyntaxKind.ExportKeyword) ?? false;
   }
   function isAmbient(node) {
-    if (!ts24.canHaveModifiers(node)) return false;
-    const mods = ts24.getModifiers(node);
-    return mods?.some((m) => m.kind === ts24.SyntaxKind.DeclareKeyword) ?? false;
+    if (!ts25.canHaveModifiers(node)) return false;
+    const mods = ts25.getModifiers(node);
+    return mods?.some((m) => m.kind === ts25.SyntaxKind.DeclareKeyword) ?? false;
   }
   function collectFromBindingName(name2) {
-    if (ts24.isIdentifier(name2)) {
+    if (ts25.isIdentifier(name2)) {
       localValueExports.add(name2.text);
       return;
     }
     for (const el of name2.elements) {
-      if (ts24.isBindingElement(el)) collectFromBindingName(el.name);
+      if (ts25.isBindingElement(el)) collectFromBindingName(el.name);
     }
   }
   for (const stmt of sourceFile.statements) {
-    if (ts24.isVariableStatement(stmt) && hasExport(stmt)) {
+    if (ts25.isVariableStatement(stmt) && hasExport(stmt)) {
       for (const d of stmt.declarationList.declarations) {
         collectFromBindingName(d.name);
       }
-    } else if (ts24.isFunctionDeclaration(stmt) && hasExport(stmt) && stmt.name) {
+    } else if (ts25.isFunctionDeclaration(stmt) && hasExport(stmt) && stmt.name) {
       localValueExports.add(stmt.name.text);
-    } else if (ts24.isClassDeclaration(stmt) && hasExport(stmt) && stmt.name) {
+    } else if (ts25.isClassDeclaration(stmt) && hasExport(stmt) && stmt.name) {
       localValueExports.add(stmt.name.text);
-    } else if (ts24.isEnumDeclaration(stmt) && hasExport(stmt) && stmt.name) {
+    } else if (ts25.isEnumDeclaration(stmt) && hasExport(stmt) && stmt.name) {
       otherValueExports.add(stmt.name.text);
-    } else if (ts24.isModuleDeclaration(stmt) && hasExport(stmt) && ts24.isIdentifier(stmt.name)) {
+    } else if (ts25.isModuleDeclaration(stmt) && hasExport(stmt) && ts25.isIdentifier(stmt.name)) {
       if (!isAmbient(stmt)) otherValueExports.add(stmt.name.text);
-    } else if (ts24.isExportDeclaration(stmt)) {
+    } else if (ts25.isExportDeclaration(stmt)) {
       if (stmt.isTypeOnly) continue;
       if (!stmt.moduleSpecifier) {
-        if (stmt.exportClause && ts24.isNamedExports(stmt.exportClause)) {
+        if (stmt.exportClause && ts25.isNamedExports(stmt.exportClause)) {
           for (const el of stmt.exportClause.elements) {
             if (el.isTypeOnly) continue;
             localValueExports.add(el.name.text);
@@ -28119,9 +28655,9 @@ function collectExportInfo(source) {
         }
       } else if (!stmt.exportClause) {
         hasStarReExport = true;
-      } else if (ts24.isNamespaceExport(stmt.exportClause)) {
+      } else if (ts25.isNamespaceExport(stmt.exportClause)) {
         reExportedNames.add(stmt.exportClause.name.text);
-      } else if (ts24.isNamedExports(stmt.exportClause)) {
+      } else if (ts25.isNamedExports(stmt.exportClause)) {
         for (const el of stmt.exportClause.elements) {
           if (el.isTypeOnly) continue;
           reExportedNames.add(el.name.text);
@@ -28132,16 +28668,16 @@ function collectExportInfo(source) {
   return { localValueExports, otherValueExports, reExportedNames, hasStarReExport };
 }
 function hasUseClientDirective(source) {
-  const sourceFile = ts24.createSourceFile(
+  const sourceFile = ts25.createSourceFile(
     "check.tsx",
     source,
-    ts24.ScriptTarget.Latest,
+    ts25.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts24.ScriptKind.TSX
+    ts25.ScriptKind.TSX
   );
   for (const stmt of sourceFile.statements) {
-    if (!ts24.isExpressionStatement(stmt) || !ts24.isStringLiteral(stmt.expression)) {
+    if (!ts25.isExpressionStatement(stmt) || !ts25.isStringLiteral(stmt.expression)) {
       return false;
     }
     if (stmt.expression.text === "use client") return true;
@@ -28150,53 +28686,53 @@ function hasUseClientDirective(source) {
 }
 function collectTopLevelBindings(source) {
   const names = /* @__PURE__ */ new Set();
-  const sourceFile = ts24.createSourceFile(
+  const sourceFile = ts25.createSourceFile(
     "bundle.ts",
     source,
-    ts24.ScriptTarget.Latest,
+    ts25.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts24.ScriptKind.TS
+    ts25.ScriptKind.TS
   );
   function collectFromBindingName(name2) {
-    if (ts24.isIdentifier(name2)) {
+    if (ts25.isIdentifier(name2)) {
       names.add(name2.text);
       return;
     }
     for (const el of name2.elements) {
-      if (ts24.isBindingElement(el)) collectFromBindingName(el.name);
+      if (ts25.isBindingElement(el)) collectFromBindingName(el.name);
     }
   }
   for (const stmt of sourceFile.statements) {
-    if (ts24.isVariableStatement(stmt)) {
+    if (ts25.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
         collectFromBindingName(d.name);
       }
-    } else if (ts24.isFunctionDeclaration(stmt) && stmt.name) {
+    } else if (ts25.isFunctionDeclaration(stmt) && stmt.name) {
       names.add(stmt.name.text);
-    } else if (ts24.isClassDeclaration(stmt) && stmt.name) {
+    } else if (ts25.isClassDeclaration(stmt) && stmt.name) {
       names.add(stmt.name.text);
     }
   }
   return names;
 }
 function stripImportsAndExports(body2) {
-  const sourceFile = ts24.createSourceFile(
+  const sourceFile = ts25.createSourceFile(
     "body.ts",
     body2,
-    ts24.ScriptTarget.Latest,
+    ts25.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts24.ScriptKind.TS
+    ts25.ScriptKind.TS
   );
   const spans = [];
   const hoistedImports = [];
   for (const stmt of sourceFile.statements) {
-    if (ts24.isImportDeclaration(stmt)) {
+    if (ts25.isImportDeclaration(stmt)) {
       const start2 = stmt.getStart(sourceFile);
       const end2 = stmt.getEnd();
       const specifier = stmt.moduleSpecifier;
-      if (ts24.isStringLiteral(specifier)) {
+      if (ts25.isStringLiteral(specifier)) {
         const path25 = specifier.text;
         const isRelative = path25.startsWith("./") || path25.startsWith("../");
         if (!isRelative) {
@@ -28206,24 +28742,24 @@ function stripImportsAndExports(body2) {
       spans.push([start2, end2]);
       continue;
     }
-    if (ts24.isExportDeclaration(stmt)) {
+    if (ts25.isExportDeclaration(stmt)) {
       spans.push([stmt.getStart(sourceFile), stmt.getEnd()]);
       continue;
     }
-    if (ts24.isExportAssignment(stmt)) {
-      const exportKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts24.SyntaxKind.ExportKeyword);
-      const defaultKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts24.SyntaxKind.DefaultKeyword);
-      const equalsKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts24.SyntaxKind.EqualsToken);
+    if (ts25.isExportAssignment(stmt)) {
+      const exportKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts25.SyntaxKind.ExportKeyword);
+      const defaultKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts25.SyntaxKind.DefaultKeyword);
+      const equalsKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts25.SyntaxKind.EqualsToken);
       const start2 = exportKw?.getStart(sourceFile) ?? stmt.getStart(sourceFile);
       const end2 = (defaultKw ?? equalsKw)?.getEnd() ?? exportKw?.getEnd() ?? stmt.getStart(sourceFile);
       if (end2 > start2) spans.push([start2, end2]);
       continue;
     }
-    if (ts24.canHaveModifiers(stmt)) {
-      const mods = ts24.getModifiers(stmt);
+    if (ts25.canHaveModifiers(stmt)) {
+      const mods = ts25.getModifiers(stmt);
       if (!mods) continue;
       for (const mod of mods) {
-        if (mod.kind === ts24.SyntaxKind.ExportKeyword) {
+        if (mod.kind === ts25.SyntaxKind.ExportKeyword) {
           const start2 = mod.getStart(sourceFile);
           let end2 = mod.getEnd();
           while (end2 < body2.length && /\s/.test(body2[end2])) end2++;
@@ -28363,23 +28899,23 @@ function detectStrippedReferences(bundleSource, stripped) {
   if (stripped.length === 0) return [];
   let sf;
   try {
-    sf = ts24.createSourceFile(
+    sf = ts25.createSourceFile(
       "bundle.js",
       bundleSource,
-      ts24.ScriptTarget.Latest,
+      ts25.ScriptTarget.Latest,
       /*setParents*/
       true,
-      ts24.ScriptKind.JS
+      ts25.ScriptKind.JS
     );
   } catch {
     return [];
   }
   const firstReference = /* @__PURE__ */ new Map();
   function visit3(node) {
-    if (ts24.isIdentifier(node) && isValueReferenceIdentifier(node)) {
+    if (ts25.isIdentifier(node) && isValueReferenceIdentifier(node)) {
       if (!firstReference.has(node.text)) firstReference.set(node.text, node);
     }
-    ts24.forEachChild(node, visit3);
+    ts25.forEachChild(node, visit3);
   }
   visit3(sf);
   const errors = [];
@@ -28409,18 +28945,18 @@ function detectStrippedReferences(bundleSource, stripped) {
   return errors;
 }
 async function walkAndCollect(content2, searchDirs, modules2, visiting, loggingPath, stripped, stubDeps, nextId) {
-  const sourceFile = ts24.createSourceFile(
+  const sourceFile = ts25.createSourceFile(
     "walk.js",
     content2,
-    ts24.ScriptTarget.Latest,
+    ts25.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts24.ScriptKind.JS
+    ts25.ScriptKind.JS
   );
   const sites = [];
   for (const stmt of sourceFile.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("./") && !spec.startsWith("../")) continue;
     const start2 = stmt.getStart(sourceFile);
@@ -28874,7 +29410,7 @@ var init_assets_ignore = __esm({
 });
 
 // src/lib/runtime-treeshake.ts
-import ts25 from "typescript";
+import ts26 from "typescript";
 import { basename, dirname as dirname3 } from "node:path";
 import { build as esbuildBuild } from "esbuild";
 function isBarefootClientSpecifier(spec) {
@@ -28891,13 +29427,13 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
   if (!code.includes("@barefootjs/client") && !code.includes("barefoot.js")) return result2;
   let sourceFile;
   try {
-    sourceFile = ts25.createSourceFile(
+    sourceFile = ts26.createSourceFile(
       sourceLabel,
       code,
-      ts25.ScriptTarget.Latest,
+      ts26.ScriptTarget.Latest,
       /*setParentNodes*/
       false,
-      ts25.ScriptKind.JS
+      ts26.ScriptKind.JS
     );
   } catch (err) {
     result2.unsafe = true;
@@ -28905,13 +29441,13 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
     return result2;
   }
   const visit3 = (node) => {
-    if (ts25.isImportDeclaration(node)) {
+    if (ts26.isImportDeclaration(node)) {
       const spec = node.moduleSpecifier;
-      if (ts25.isStringLiteral(spec) && isEmittedRuntimeSpecifier(spec.text)) {
+      if (ts26.isStringLiteral(spec) && isEmittedRuntimeSpecifier(spec.text)) {
         const clause = node.importClause;
         if (!clause) {
         } else if (clause.isTypeOnly) {
-        } else if (clause.namedBindings && ts25.isNamedImports(clause.namedBindings)) {
+        } else if (clause.namedBindings && ts26.isNamedImports(clause.namedBindings)) {
           for (const el of clause.namedBindings.elements) {
             if (el.isTypeOnly) continue;
             const imported = (el.propertyName ?? el.name).text;
@@ -28921,7 +29457,7 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
             result2.unsafe = true;
             result2.reasons.push(`default import of "${spec.text}" in ${sourceLabel}`);
           }
-        } else if (clause.namedBindings && ts25.isNamespaceImport(clause.namedBindings)) {
+        } else if (clause.namedBindings && ts26.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) {
@@ -28929,14 +29465,14 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
           result2.reasons.push(`default import of "${spec.text}" in ${sourceLabel}`);
         }
       }
-    } else if (ts25.isCallExpression(node) && node.expression.kind === ts25.SyntaxKind.ImportKeyword) {
+    } else if (ts26.isCallExpression(node) && node.expression.kind === ts26.SyntaxKind.ImportKeyword) {
       const arg = node.arguments[0];
-      if (arg && ts25.isStringLiteral(arg) && isEmittedRuntimeSpecifier(arg.text)) {
+      if (arg && ts26.isStringLiteral(arg) && isEmittedRuntimeSpecifier(arg.text)) {
         result2.unsafe = true;
         result2.reasons.push(`dynamic import("${arg.text}") in ${sourceLabel}`);
       }
     }
-    ts25.forEachChild(node, visit3);
+    ts26.forEachChild(node, visit3);
   };
   visit3(sourceFile);
   return result2;
@@ -29009,7 +29545,7 @@ var init_runtime_treeshake = __esm({
 });
 
 // src/lib/build.ts
-import ts26 from "typescript";
+import ts27 from "typescript";
 import { mkdir, readdir, stat, unlink } from "node:fs/promises";
 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";
@@ -29657,7 +30193,7 @@ async function build(config, options2 = {}) {
   };
 }
 function extractBareImports(code) {
-  const { importedFiles } = ts26.preProcessFile(code, true, true);
+  const { importedFiles } = ts27.preProcessFile(code, true, true);
   const specifiers = /* @__PURE__ */ new Set();
   for (const { fileName } of importedFiles) {
     if (!fileName.startsWith(".") && !fileName.startsWith("/") && !fileName.includes("://")) {
@@ -29724,16 +30260,16 @@ function effectiveOutName(tplPath, entryBaseNoExt) {
 }
 function topLevelImportLines(content2) {
   const lines = /* @__PURE__ */ new Set();
-  const sourceFile = ts26.createSourceFile(
+  const sourceFile = ts27.createSourceFile(
     "merge.js",
     content2,
-    ts26.ScriptTarget.Latest,
+    ts27.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts26.ScriptKind.JS
+    ts27.ScriptKind.JS
   );
   for (const stmt of sourceFile.statements) {
-    if (ts26.isImportDeclaration(stmt)) {
+    if (ts27.isImportDeclaration(stmt)) {
       const { line } = sourceFile.getLineAndCharacterOfPosition(stmt.getStart(sourceFile));
       lines.add(line);
     }
@@ -29742,29 +30278,29 @@ function topLevelImportLines(content2) {
 }
 function rewriteBarefootClientSpecifiers(content2, rel) {
   if (!content2.includes("@barefootjs/client")) return content2;
-  const sourceFile = ts26.createSourceFile(
+  const sourceFile = ts27.createSourceFile(
     "client.js",
     content2,
-    ts26.ScriptTarget.Latest,
+    ts27.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts26.ScriptKind.JS
+    ts27.ScriptKind.JS
   );
   const isBarefootClient = (s) => s === "@barefootjs/client" || s.startsWith("@barefootjs/client/");
   const spans = [];
   const visit3 = (node) => {
-    if (ts26.isImportDeclaration(node) || ts26.isExportDeclaration(node)) {
+    if (ts27.isImportDeclaration(node) || ts27.isExportDeclaration(node)) {
       const ms = node.moduleSpecifier;
-      if (ms && ts26.isStringLiteral(ms) && isBarefootClient(ms.text)) {
+      if (ms && ts27.isStringLiteral(ms) && isBarefootClient(ms.text)) {
         spans.push([ms.getStart(sourceFile), ms.getEnd()]);
       }
-    } else if (ts26.isCallExpression(node) && node.expression.kind === ts26.SyntaxKind.ImportKeyword) {
+    } else if (ts27.isCallExpression(node) && node.expression.kind === ts27.SyntaxKind.ImportKeyword) {
       const arg = node.arguments[0];
-      if (arg && ts26.isStringLiteral(arg) && isBarefootClient(arg.text)) {
+      if (arg && ts27.isStringLiteral(arg) && isBarefootClient(arg.text)) {
         spans.push([arg.getStart(sourceFile), arg.getEnd()]);
       }
     }
-    ts26.forEachChild(node, visit3);
+    ts27.forEachChild(node, visit3);
   };
   visit3(sourceFile);
   if (spans.length === 0) return content2;
@@ -31965,12 +32501,13 @@ main {
 });
 
 // src/lib/adapters/runtimes.generated.ts
-var bfGoSource, evalGoSource, streamingGoSource, bfdevGoSource;
+var bfGoSource, evalGoSource, repropsGoSource, 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	"regexp"\n	"sort"\n	"strconv"\n	"strings"\n	"time"\n	"unicode"\n	"unicode/utf8"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Nullish coalescing (#2248): JS `??` semantics \u2014 fall back only on\n		// nil, keeping present-but-falsy values (`""`, `0`, `false`) that\n		// Go\'s truthiness-based `or` would replace.\n		"bf_nullish": Nullish,\n\n		// Arithmetic\n		"bf_add":        Add,\n		"bf_concat_str": ConcatStr,\n		"bf_sub":        Sub,\n		"bf_mul":        Mul,\n		"bf_div":        Div,\n		"bf_mod":        Mod,\n		"bf_neg":        Neg,\n		"bf_min":        Min,\n		"bf_max":        Max,\n\n		// String\n		"bf_lower":       Lower,\n		"bf_upper":       Upper,\n		"bf_trim":        Trim,\n		"bf_trim_start":  TrimStart,\n		"bf_trim_end":    TrimEnd,\n		"bf_contains":    Contains,\n		"bf_join":        Join,\n		"bf_split":       Split,\n		"bf_starts_with": StartsWith,\n		"bf_ends_with":   EndsWith,\n		"bf_replace":     Replace,\n		"bf_replace_all": ReplaceAll,\n		"bf_repeat":      Repeat,\n		"bf_pad_start":   PadStart,\n		"bf_pad_end":     PadEnd,\n		"bf_string":      String,\n		"bf_raw_html":    RawHTML,\n		"bf_ternary":     Ternary,\n		"bf_truthy":      Truthy,\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		// Date method lowering (#2274, spec entry "date"): the lowering\n		// target for a zero-arg call on a Date-typed prop.\n		"bf_date": Date,\n\n		// formatDate(date, pattern, tz) lowering (#2324, spec entry\n		// "format_date"): the total, locale-free date-pattern formatter \u2014\n		// see FormatDate\'s docstring for the full contract.\n		"bf_format_date": FormatDate,\n\n		// JSON / numeric primitives \u2014 JS-compat callees registered on\n		// the Go adapter\'s `templatePrimitives` map (#1188).\n		"bf_json":     JSON,\n		"bf_number":   Number,\n		"bf_floor":    Floor,\n		"bf_ceil":     Ceil,\n		"bf_round":    Round,\n		"bf_abs":      Abs,\n		"bf_to_fixed": ToFixed,\n\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_length":         Length,\n		"bf_is_element":     IsValidElement,\n		"bf_style_object":   StyleObjectToCSS,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_flat":           Flat,\n		"bf_flat_dynamic":   FlatDynamicDepth,\n		"bf_flat_map":       FlatMap,\n		"bf_flat_map_tuple": FlatMapTuple,\n		"bf_first":          First,\n		"bf_last":           Last,\n		"bf_arr":            Arr,\n		"bf_filter_truthy":  FilterTruthy,\n\n		// Higher-order Array Methods\n		"bf_every":           Every,\n		"bf_some":            Some,\n		"bf_filter":          Filter,\n		"bf_find":            Find,\n		"bf_find_index":      FindIndex,\n		"bf_find_last":       FindLast,\n		"bf_find_last_index": FindLastIndex,\n		"bf_sort":            Sort,\n		"bf_reduce":          Reduce,\n\n		// Evaluator-driven higher-order folds (#2018): the comparator / reducer\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_sort / bf_reduce beyond their fixed catalogues. The\n		// adapter falls back to bf_sort for a comparator the evaluator can\'t\n		// model (e.g. localeCompare). `bf_env` builds the captured-free-var\n		// environment passed as the trailing base_env argument.\n		"bf_sort_eval":   SortEval,\n		"bf_reduce_eval": FoldEval,\n		"bf_env":         Env,\n\n		// Evaluator-driven higher-order predicates (#2018, P2): the predicate\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_filter / bf_find / bf_find_index / bf_every / bf_some\n		// beyond their field-equality / truthiness catalogues. `bf_find_eval` /\n		// `bf_find_index_eval` take a `forward` bool (false \u2192 findLast variants).\n		"bf_filter_eval":     FilterEval,\n		"bf_every_eval":      EveryEval,\n		"bf_some_eval":       SomeEval,\n		"bf_find_eval":       FindEval,\n		"bf_find_index_eval": FindIndexEval,\n		// `.flatMap(proj)`: project each element through the serialized\n		// projection body, then flatten one level.\n		"bf_flat_map_eval": FlatMapEval,\n		// Value-producing `.map(cb)` (#2073): project each element, one\n		// result per element (no flatten).\n		"bf_map_eval": MapEval,\n\n		// Comment marker (for hydration)\n		"bfComment":   Comment,\n		"bfTextStart": TextStart,\n		"bfTextEnd":   TextEnd,\n\n		// Script collection\n		"bfScripts": BfScripts,\n\n		// Scope attribute value (#1249: bare scope id, no `~` prefix)\n		"bfScopeAttr": ScopeAttr,\n\n		// Slot-identity markers (#1249): bf-h, bf-m, bf-r\n		"bfHydrationAttrs": HydrationAttrs,\n\n		// Child component marker (kept for backward compatibility)\n		"bfIsChild": IsChild,\n\n		// Props attribute for hydration\n		"bfPropsAttr": BfPropsAttr,\n\n		// Portal HTML rendering (parses and executes template string)\n		"bfPortalHTML": PortalHTML,\n\n		// JSX children passed to an imported child component (#1896):\n		// the parent renders the children fragment via a companion\n		// define (executed through bf_tmpl from TemplateFuncMap) and\n		// injects the result into the child\'s Children field.\n		"bf_with_children": WithChildren,\n\n		// Scope comment for fragment roots\n		"bfScopeComment":    ScopeComment,\n		"bfScopeCommentEnd": ScopeCommentEnd,\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// Date implements the `date` helper (spec/template-helpers.md, #2274) \u2014 the\n// lowering target for a zero-arg call on a Date-typed prop\n// (`createdAt.toISOString()`). recv accepts the runtime\'s own `time.Time` /\n// `*time.Time` (however the host framework populated the prop) OR an\n// ISO-8601 string (the wire form a JSON-sourced prop arrives as); either is\n// normalized to UTC before dispatching op, matching the client `Date`\'s own\n// instant semantics regardless of which shape reaches this helper. A nil /\n// unparsable receiver yields this runtime\'s zero value for the requested op\n// (0 for every numeric accessor, "" for toISOString) rather than panicking\n// mid-render \u2014 the same tolerance `String`/`Number` already extend to a nil\n// prop. `getUTCMonth` subtracts 1: Go\'s `time.Month` is 1-based, JS\'s is not\n// (spec entry "date" is explicit that JS wins here).\nfunc Date(recv any, op string) any {\n	t, ok := toTime(recv)\n	if !ok {\n		if op == "toISOString" {\n			return ""\n		}\n		return 0\n	}\n	t = t.UTC()\n	switch op {\n	case "getUTCFullYear":\n		return t.Year()\n	case "getUTCMonth":\n		return int(t.Month()) - 1\n	case "getUTCDate":\n		return t.Day()\n	case "getUTCHours":\n		return t.Hour()\n	case "getUTCMinutes":\n		return t.Minute()\n	case "getUTCSeconds":\n		return t.Second()\n	case "getTime":\n		return t.UnixMilli()\n	case "toISOString":\n		return t.Format("2006-01-02T15:04:05.000Z")\n	default:\n		return 0\n	}\n}\n\n// tzOffsetRE matches a fixed UTC offset `\xB1HH:MM` within ECMA-402\'s valid\n// range \u2014 hours 00\u201323, minutes 00\u201359 (`\'+09:00\'`, `\'-05:30\'`) \u2014 one of the\n// three `tz` shapes FormatDate accepts (mirrors OFFSET_RE in\n// packages/client/src/format-date.ts). An out-of-range shape (`\'+25:00\'`)\n// falls through to the tzdata lookup, fails it, and errors \u2014 matching the\n// JS reference\'s RangeError (#2344).\nvar tzOffsetRE = regexp.MustCompile(`^([+-])([01][0-9]|2[0-3]):([0-5][0-9])$`)\n\n// formatDateTokenRE is the longest-match pattern-token alternation (mirrors\n// TOKEN_RE in packages/client/src/format-date.ts). Order matters: MMMM\n// before MMM before MM before M (and dddd before ddd, DD before D) so the\n// longer token wins at a position where a shorter one could also match \u2014\n// Go\'s regexp, like JS\'s, resolves alternation leftmost-first (not POSIX\n// leftmost-longest), so listing the longer alternative first is what makes\n// e.g. "MMMM" consume all four characters instead of "MM" + "MM".\nvar formatDateTokenRE = regexp.MustCompile(`YYYY|MMMM|MMM|MM|DD|dddd|ddd|M|D`)\n\n// nameTable section offsets (#2334, mirrors MONTHS_WIDE / MONTHS_ABBR /\n// WEEKDAYS_WIDE / WEEKDAYS_ABBR in packages/client/src/format-date.ts).\nconst (\n	monthsWide   = 0\n	monthsAbbr   = 12\n	weekdaysWide = 24\n	weekdaysAbbr = 31\n)\n\n// formatDateName reads a name-token table entry: index out of range, or a\n// non-string element, both render "" \u2014 the same total, zero-value\n// discipline as an unparseable date (mirrors the JS reference\'s\n// `names[index] ?? ""` fallback, where every table element the vectors ever\n// carry is a string).\nfunc formatDateName(names []any, index int) string {\n	if index < 0 || index >= len(names) {\n		return ""\n	}\n	s, ok := names[index].(string)\n	if !ok {\n		return ""\n	}\n	return s\n}\n\n// FormatDate implements the `format_date` helper (#2324, #2334, spec entry\n// "format_date") \u2014 the lowering target for\n// `formatDate(date, pattern, tz, names)`\n// (packages/client/src/format-date.ts, the JS-normative reference this must\n// match byte-for-byte). Total and deterministic: no locale, no host\n// timezone, no "now".\n//\n// recv: same receiver contract as the `date` helper above \u2014 the runtime\'s\n// own `time.Time` / `*time.Time`, or an ISO-8601 string \u2014 normalized via\n// `toTime`. A nil / unparseable receiver returns "" (never panics).\n//\n// tz (#2344): "UTC", a range-valid fixed offset `\xB1HH:MM` (shifts by\n// sign*(HH*60+MM) minutes), or a canonical IANA zone name ("Asia/Tokyo")\n// resolved through tzdata via time.LoadLocation \u2014 the zone\'s UTC offset AT\n// THE INSTANT being formatted (DST-aware, historical-transition-aware,\n// seconds precision: pre-standard LMT offsets like Tokyo\'s +09:18:59\n// count). ANY other value \u2014 an unknown zone, a malformed or out-of-range\n// offset ("+9:00", "+25:00"), the empty string or "Local" (LoadLocation\'s\n// implicit-environment aliases) \u2014 returns an ERROR, aborting template\n// execution loudly: the JS reference throws a RangeError there, and a\n// silently substituted timezone is the one failure mode this helper must\n// not have (the pre-#2344 normalize-to-UTC total function is gone). The\n// shifted instant\'s UTC calendar fields (not the original instant\'s) are\n// what pattern tokens read \u2014 the shifted UTC clock face IS the local clock\n// face in that zone, same reasoning as the JS reference.\n//\n// names (#2334): a flat name table in fixed layout \u2014 `[0..11]` wide month\n// names, `[12..23]` abbreviated month names, `[24..30]` wide weekday names\n// (Sunday-first), `[31..37]` abbreviated weekday names. The caller owns the\n// values; this helper only indexes the table.\n//\n// pattern: longest-match token substitution\n// (`YYYY|MMMM|MMM|MM|DD|dddd|ddd|M|D`); every other character \u2014 including\n// multi-byte ones like \u5E74/\u6708/\u65E5 \u2014 passes through literally. `YYYY` is\n// `abs(year)` zero-padded to 4 digits, `-`-prefixed for a negative year;\n// `MM`/`DD` zero-pad to 2; `M`/`D` are bare; `MMMM`/`MMM` and `dddd`/`ddd`\n// read the `names` table (weekday computed on the offset-shifted instant,\n// Sunday-first, matching `time.Time.Weekday()`\'s own Sunday=0 encoding).\nfunc FormatDate(recv any, pattern string, tz string, names []any) (string, error) {\n	t, ok := toTime(recv)\n	if !ok {\n		// Receiver contract precedes tz validation (spec receiver-first\n		// discipline, mirrored by every port).\n		return "", nil\n	}\n	offsetSeconds := 0\n	if tz != "UTC" {\n		if m := tzOffsetRE.FindStringSubmatch(tz); m != nil {\n			hh, _ := strconv.Atoi(m[2])\n			mm, _ := strconv.Atoi(m[3])\n			offsetSeconds = (hh*60 + mm) * 60\n			if m[1] == "-" {\n				offsetSeconds = -offsetSeconds\n			}\n		} else if tz == "" || tz == "Local" {\n			// LoadLocation("") is UTC and LoadLocation("Local") is the host\n			// zone \u2014 both implicit-environment reads the contract refuses.\n			return "", fmt.Errorf("format_date: unresolvable timeZone %q", tz)\n		} else {\n			loc, err := time.LoadLocation(tz)\n			if err != nil {\n				return "", fmt.Errorf("format_date: unresolvable timeZone %q", tz)\n			}\n			_, offsetSeconds = t.UTC().In(loc).Zone()\n		}\n	}\n	shifted := t.UTC().Add(time.Duration(offsetSeconds) * time.Second)\n	year := shifted.Year()\n	month := int(shifted.Month())\n	day := shifted.Day()\n	weekday := int(shifted.Weekday()) // time.Sunday == 0, matching the table\'s Sunday-first layout\n	absYear := year\n	if absYear < 0 {\n		absYear = -absYear\n	}\n	yyyy := fmt.Sprintf("%04d", absYear)\n	if year < 0 {\n		yyyy = "-" + yyyy\n	}\n	out := formatDateTokenRE.ReplaceAllStringFunc(pattern, func(token string) string {\n		switch token {\n		case "YYYY":\n			return yyyy\n		case "MMMM":\n			return formatDateName(names, monthsWide+month-1)\n		case "MMM":\n			return formatDateName(names, monthsAbbr+month-1)\n		case "MM":\n			return fmt.Sprintf("%02d", month)\n		case "M":\n			return strconv.Itoa(month)\n		case "DD":\n			return fmt.Sprintf("%02d", day)\n		case "D":\n			return strconv.Itoa(day)\n		case "dddd":\n			return formatDateName(names, weekdaysWide+weekday)\n		case "ddd":\n			return formatDateName(names, weekdaysAbbr+weekday)\n		default:\n			return token\n		}\n	})\n	return out, nil\n}\n\n// toTime normalizes a `Date` helper receiver to a `time.Time`: the runtime\'s\n// own `time.Time` / `*time.Time`, or an ISO-8601 string parsed with\n// `time.RFC3339Nano` (accepts both the `Z`-suffixed and numeric-offset\n// forms, and any sub-second precision \u2014 including the millisecond precision\n// every value this runtime itself ever produces via `toISOString` above).\n// Anything else (nil, an unparsable string, an unrelated type) reports !ok\n// so `Date` can apply its documented zero-value fallback instead of\n// panicking.\nfunc toTime(recv any) (time.Time, bool) {\n	switch v := recv.(type) {\n	case time.Time:\n		return v, true\n	case *time.Time:\n		if v == nil {\n			return time.Time{}, false\n		}\n		return *v, true\n	case string:\n		t, err := time.Parse(time.RFC3339Nano, v)\n		if err != nil {\n			return time.Time{}, false\n		}\n		return t, true\n	default:\n		return time.Time{}, false\n	}\n}\n\n// asStringSlice reports whether v is a query *array* value and, if so, returns\n// its members stringified. A compiled template passes a `[]string` field; the\n// golden conformance vectors decode JSON arrays to `[]any`. Anything else is a\n// scalar (false), handled by the set() path.\nfunc asStringSlice(v any) ([]string, bool) {\n	switch s := v.(type) {\n	case []string:\n		return s, true\n	case []any:\n		out := make([]string, len(s))\n		for i, m := range s {\n			out[i] = String(m)\n		}\n		return out, true\n	default:\n		return nil, false\n	}\n}\n\nconst hexUpper = "0123456789ABCDEF"\n\n// formEscape percent-encodes s with the application/x-www-form-urlencoded byte\n// set, matching the browser\'s URLSearchParams serialization (and the Perl\n// `query` helper) so SSR query strings render byte-for-byte identically across\n// adapters. The unreserved set kept verbatim is A-Z a-z 0-9 and `* - . _`; a\n// space becomes `+`; every other byte is `%XX` with uppercase hex. Encoding is\n// byte-wise, so multi-byte UTF-8 is percent-encoded per byte (`\xE9` \u2192 `%C3%A9`).\n//\n// This differs from url.QueryEscape only for `~` (kept by QueryEscape, encoded\n// to `%7E` here) and `*` (encoded to `%2A` by QueryEscape, kept here).\nfunc formEscape(s string) string {\n	var b strings.Builder\n	for i := 0; i < len(s); i++ {\n		c := s[i]\n		switch {\n		case c >= \'A\' && c <= \'Z\', c >= \'a\' && c <= \'z\', c >= \'0\' && c <= \'9\',\n			c == \'*\', c == \'-\', c == \'.\', c == \'_\':\n			b.WriteByte(c)\n		case c == \' \':\n			b.WriteByte(\'+\')\n		default:\n			b.WriteByte(\'%\')\n			b.WriteByte(hexUpper[c>>4])\n			b.WriteByte(hexUpper[c&0x0F])\n		}\n	}\n	return b.String()\n}\n\n// ScopeAttr returns the bare bf-s scope id (#1249).\nfunc ScopeAttr(props interface{}) string {\n	return getStringField(props, "ScopeID")\n}\n\n// HydrationAttrs emits `bf-h="<host>" bf-m="<slot>" bf-r=""` conditionally.\n// See spec/compiler.md "Slot identity".\nfunc HydrationAttrs(props interface{}) template.HTMLAttr {\n	parts := []string{}\n	if host := getStringField(props, "BfParent"); host != "" {\n		parts = append(parts, fmt.Sprintf(`bf-h="%s"`, template.HTMLEscapeString(host)))\n	}\n	if mount := getStringField(props, "BfMount"); mount != "" {\n		parts = append(parts, fmt.Sprintf(`bf-m="%s"`, template.HTMLEscapeString(mount)))\n	}\n	if !getBoolField(props, "BfIsChild") {\n		parts = append(parts, `bf-r=""`)\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// IsChild is a deprecated no-op stub. Child status is signalled by bf-h\n// presence (#1249); use HydrationAttrs instead.\nfunc IsChild(props interface{}) template.HTMLAttr {\n	return ""\n}\n\n// svgCamelCaseAttrs mirrors SVG_CAMEL_CASE_ATTRS from\n// packages/client/src/runtime/spread-attrs.ts. SVG XML attribute\n// names are case-sensitive; the default camelCase \u2192 kebab-case\n// rewrite must NOT apply to these or the SVG stops rendering\n// (#1407). Coordinates with the compile-time SVG_CAMEL_TO_KEBAB\n// table in packages/jsx/src/ir-to-client-js/utils.ts: presentation\n// attrs (clipPath, strokeWidth, \u2026) live there and must NOT appear\n// here, or the same JSX prop would lower to clip-path via the\n// explicit-attr path and stay clipPath via the spread path.\nvar svgCamelCaseAttrs = map[string]struct{}{\n	"allowReorder": {}, "attributeName": {}, "attributeType": {}, "autoReverse": {},\n	"baseFrequency": {}, "baseProfile": {}, "calcMode": {}, "clipPathUnits": {},\n	"contentScriptType": {}, "contentStyleType": {}, "diffuseConstant": {}, "edgeMode": {},\n	"externalResourcesRequired": {}, "filterRes": {}, "filterUnits": {}, "glyphRef": {},\n	"gradientTransform": {}, "gradientUnits": {}, "kernelMatrix": {}, "kernelUnitLength": {},\n	"keyPoints": {}, "keySplines": {}, "keyTimes": {}, "lengthAdjust": {}, "limitingConeAngle": {},\n	"markerHeight": {}, "markerUnits": {}, "markerWidth": {}, "maskContentUnits": {},\n	"maskUnits": {}, "numOctaves": {}, "pathLength": {}, "patternContentUnits": {},\n	"patternTransform": {}, "patternUnits": {}, "pointsAtX": {}, "pointsAtY": {}, "pointsAtZ": {},\n	"preserveAlpha": {}, "preserveAspectRatio": {}, "primitiveUnits": {}, "refX": {}, "refY": {},\n	"repeatCount": {}, "repeatDur": {}, "requiredExtensions": {}, "requiredFeatures": {},\n	"specularConstant": {}, "specularExponent": {}, "spreadMethod": {}, "startOffset": {},\n	"stdDeviation": {}, "stitchTiles": {}, "surfaceScale": {}, "systemLanguage": {},\n	"tableValues": {}, "targetX": {}, "targetY": {}, "textLength": {}, "viewBox": {}, "viewTarget": {},\n	"xChannelSelector": {}, "yChannelSelector": {}, "zoomAndPan": {},\n}\n\n// toAttrName mirrors the JSX\u2192HTML attribute-name rewrite from\n// packages/client/src/runtime/spread-attrs.ts. className \u2192 class,\n// htmlFor \u2192 for, SVG camelCase attrs preserved, other camelCase\n// keys lowered to kebab-case.\nfunc toAttrName(key string) string {\n	if key == "className" {\n		return "class"\n	}\n	if key == "htmlFor" {\n		return "for"\n	}\n	if _, ok := svgCamelCaseAttrs[key]; ok {\n		return key\n	}\n	// camelCase \u2192 kebab-case: mirror the JS reference exactly\n	// (`key.replace(/([A-Z])/g, \'-$1\').toLowerCase()`). The JS shape\n	// produces a leading `-` for an initial uppercase letter\n	// (`XData` \u2192 `-x-data`); both this Go path and the matching JS\n	// runtime are wrong-by-construction for that case (the resulting\n	// HTML attribute name is invalid), but keeping them byte-equal\n	// avoids silent SSR/CSR divergence (#1411 review).\n	var b strings.Builder\n	for _, r := range key {\n		if r >= \'A\' && r <= \'Z\' {\n			b.WriteByte(\'-\')\n			b.WriteRune(r + 32)\n		} else {\n			b.WriteRune(r)\n		}\n	}\n	return b.String()\n}\n\n// hasUnsafeStyleValue mirrors Hono\'s own CSS-injection guard\n// (`hono/jsx/utils.ts`\'s `hasUnsafeStyleValue` \u2014 the ORACLE this adapter\'s\n// dynamic `style={{...}}` values must match, #2261): a hand-rolled\n// structural scan for characters that could break out of a CSS\n// declaration, NOT real CSSOM property validation. Ported byte-for-byte \u2014\n// every character this scan tests is ASCII, so scanning by byte (Go\n// string indexing) agrees with Hono\'s UTF-16-code-unit scan for every\n// input; a multibyte UTF-8 sequence has no byte in the ASCII range, so it\n// can never spuriously match one of these single-byte comparisons. Skips\n// the reference implementation\'s regex fast-path (a pure optimization \u2014\n// the scan below already returns `false` promptly for a clean value).\nfunc hasUnsafeStyleValue(value string) bool {\n	quote := byte(0)\n	blockStack := make([]byte, 0, 4)\n	for i := 0; i < len(value); i++ {\n		c := value[i]\n		switch {\n		case c == \'\\\\\':\n			if i == len(value)-1 {\n				return true\n			}\n			i++\n		case quote != 0:\n			if c == \'\\n\' || c == \'\\f\' || c == \'\\r\' {\n				return true\n			}\n			if c == quote {\n				quote = 0\n			}\n		case c == \'/\' && i+1 < len(value) && value[i+1] == \'*\':\n			end := strings.Index(value[i+2:], "*/")\n			if end == -1 {\n				return true\n			}\n			i = i + 2 + end + 1\n		case c == \'"\' || c == \'\\\'\':\n			quote = c\n		case c == \'(\':\n			blockStack = append(blockStack, \')\')\n		case c == \'[\':\n			blockStack = append(blockStack, \']\')\n		case c == \'{\' || c == \'}\':\n			return true\n		case c == \')\' || c == \']\':\n			if len(blockStack) == 0 || blockStack[len(blockStack)-1] != c {\n				return true\n			}\n			blockStack = blockStack[:len(blockStack)-1]\n		case c == \';\' && len(blockStack) == 0:\n			return true\n		}\n	}\n	return quote != 0 || len(blockStack) != 0\n}\n\n// StyleObjectToCSS builds the CSS string for a `style={{...}}` JSX\n// object-literal attribute (#2261) \u2014 `pairs` alternates CSS key (always a\n// compile-time-known literal), then value (`any`, possibly a runtime\n// expression\'s result). A value that fails `hasUnsafeStyleValue` (after\n// JS-`String()`-style stringification) is DROPPED \u2014 the whole `key:value`\n// pair is omitted \u2014 matching Hono\'s oracle behavior exactly, rather than\n// html/template\'s own contextual CSS auto-escaper (which instead emits its\n// `ZgotmplZ` unsafe-content sentinel for the same input). The final joined\n// string is STILL HTML-escaped (mirroring Hono\'s own `escapeToBuffer` call\n// on its accumulated style string) \u2014 a "safe" value can still carry a\n// literal `"`/`\'`/`&` (e.g. a BALANCED-quote CSS string value like\n// `"hello"` passes the structural scan; the quote chars survive into the\n// value) that would otherwise break out of the double-quoted `style="..."`\n// attribute. Returns `template.CSS` (over the escaped result) so\n// html/template treats it as trusted CSS content instead of ALSO applying\n// its own contextual CSS auto-escaper (which would re-derive the exact\n// `ZgotmplZ` divergence this function exists to avoid).\nfunc StyleObjectToCSS(pairs ...any) template.CSS {\n	parts := make([]string, 0, len(pairs)/2)\n	for i := 0; i+1 < len(pairs); i += 2 {\n		key := fmt.Sprint(pairs[i])\n		value := String(pairs[i+1])\n		if hasUnsafeStyleValue(value) {\n			continue\n		}\n		parts = append(parts, template.HTMLEscapeString(key)+":"+template.HTMLEscapeString(value))\n	}\n	return template.CSS(strings.Join(parts, ";"))\n}\n\n// StyleToCss mirrors styleToCss from\n// packages/client/src/runtime/style.ts. Accepts a string passthrough,\n// or a map (JSON-deserialized object) whose camelCase keys are\n// lowered to kebab-case and joined with `;`. Returns ("", false) for\n// nullish/empty input so callers can omit the attribute entirely.\nfunc StyleToCss(v any) (string, bool) {\n	if v == nil {\n		return "", false\n	}\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return "", false\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		// Non-object: stringify and return as-is, matching the JS\n		// `typeof value !== \'object\'` branch.\n		s := fmt.Sprint(v)\n		if s == "" {\n			return "", false\n		}\n		return s, true\n	}\n	keys := rv.MapKeys()\n	sorted := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sorted = append(sorted, k.String())\n		}\n	}\n	sort.Strings(sorted)\n	parts := make([]string, 0, len(sorted))\n	for _, k := range sorted {\n		val := rv.MapIndex(reflect.ValueOf(k))\n		// Skip nil entries (matches the JS `if (v == null) continue`).\n		if !val.IsValid() {\n			continue\n		}\n		if val.Kind() == reflect.Interface || val.Kind() == reflect.Pointer {\n			if val.IsNil() {\n				continue\n			}\n			val = val.Elem()\n		}\n		prop := toAttrName(k)\n		parts = append(parts, fmt.Sprintf("%s:%v", prop, val.Interface()))\n	}\n	if len(parts) == 0 {\n		return "", false\n	}\n	return strings.Join(parts, ";"), true\n}\n\n// SpreadAttrs lowers a JSX intrinsic-element spread bag (#1407) to\n// an HTML attribute string. Mirrors spreadAttrs from\n// packages/client/src/runtime/spread-attrs.ts so SSR output matches\n// what CSR\'s `applyRestAttrs` writes at hydration.\n//\n// Skip rules: nil/false values, event handlers (`on[A-Z]*`),\n// `children`, `ref`.\n//\n// Key remap: className \u2192 class, htmlFor \u2192 for, SVG camelCase\n// preserved, other camelCase \u2192 kebab-case.\n//\n// `style` is routed through StyleToCss so object literals serialize\n// to a real CSS string instead of Go\'s default `map[k:v]` form.\n//\n// Booleans: true \u2192 bare attribute name, false \u2192 omitted.\n// Other scalar values are HTML-escaped via template.HTMLEscapeString.\n// Returns a `template.HTMLAttr` so html/template emits the result\n// verbatim (the function does its own escaping).\n//\n// Keys are sorted alphabetically before emission for deterministic\n// output. SSR/CSR attribute-order divergence is acceptable per the\n// rest-destructure-object-spread-in-map fixture\'s documented policy\n// \u2014 browsers honor the LAST value when a key is duplicated, so\n// pairing with static attrs (`<div class="x" {...rest}>`) is\n// last-wins regardless of order.\nfunc SpreadAttrs(bag any) template.HTMLAttr {\n	if bag == nil {\n		return ""\n	}\n	rv := reflect.ValueOf(bag)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return ""\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		return ""\n	}\n	keys := rv.MapKeys()\n	sortedKeys := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sortedKeys = append(sortedKeys, k.String())\n		}\n	}\n	sort.Strings(sortedKeys)\n	parts := make([]string, 0, len(sortedKeys))\n	for _, key := range sortedKeys {\n		// Event handlers \u2014 skip at SSR the same way\n		// packages/client/src/runtime/spread-attrs.ts does at\n		// hydration. The JS predicate is\n		// `key.startsWith(\'on\') && key.length > 2 && key[2] === key[2].toUpperCase()`,\n		// which is true for any character whose uppercase form is\n		// itself: ASCII A-Z, digits, underscore, and non-letter\n		// symbols. Mirror that here by skipping when key[2] is NOT\n		// a lowercase ASCII letter \u2014 so `onClick`, `on_custom`, and\n		// `on0` all match (#1411 review).\n		if len(key) > 2 && key[0] == \'o\' && key[1] == \'n\' && !(key[2] >= \'a\' && key[2] <= \'z\') {\n			continue\n		}\n		// `children` is a JSX construct rendered inside the element,\n		// never a DOM attribute. `ref` is intentionally NOT filtered\n		// here so output stays byte-equal with the JS reference\n		// `spreadAttrs` in packages/client/src/runtime/spread-attrs.ts\n		// (which only filters null/false, event handlers, and\n		// children) \u2014 aligning Go\'s filter set diverges from JS in\n		// the opposite direction. Filtering `ref` consistently across\n		// both SSR runtimes is a separate concern tracked alongside\n		// the JS `applyRestAttrs` vs `spreadAttrs` mismatch (#1411\n		// review).\n		if key == "children" {\n			continue\n		}\n		val := rv.MapIndex(reflect.ValueOf(key))\n		if !val.IsValid() {\n			continue\n		}\n		// Unwrap interface wrappers (json.Unmarshal produces\n		// interface{}-wrapped values for map[string]any).\n		v := val\n		for v.Kind() == reflect.Interface || v.Kind() == reflect.Pointer {\n			if v.IsNil() {\n				// Skip null entries.\n				v = reflect.Value{}\n				break\n			}\n			v = v.Elem()\n		}\n		if !v.IsValid() {\n			continue\n		}\n		// Boolean values: true \u2192 bare attribute, false \u2192 omitted.\n		if v.Kind() == reflect.Bool {\n			if !v.Bool() {\n				continue\n			}\n			parts = append(parts, toAttrName(key))\n			continue\n		}\n		// `style` routes through StyleToCss so object literals get a\n		// real CSS string. The JS side does the same.\n		if key == "style" {\n			css, ok := StyleToCss(v.Interface())\n			if !ok {\n				continue\n			}\n			parts = append(parts, fmt.Sprintf(`style="%s"`, template.HTMLEscapeString(css)))\n			continue\n		}\n		// Stringify and escape. fmt.Sprint handles numbers, bools-as-\n		// strings, and arbitrary stringer types the same way the JS\n		// `String(value)` coercion does for the analogous cases.\n		s := fmt.Sprint(v.Interface())\n		parts = append(parts, fmt.Sprintf(`%s="%s"`, toAttrName(key), template.HTMLEscapeString(s)))\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// Omit builds a `map[string]any` residual bag from a struct or map value,\n// excluding the given keys \u2014 powers the `{...rest}` spread-onto-element\n// lowering for a destructured `.map()` loop-item\'s object-rest binding\n// (#2087): `.map(({ id, title, ...rest }) => <li {...rest}>)` needs "every\n// field EXCEPT the ones the pattern already destructured out", and a static\n// Go struct type has no way to express "minus a field" \u2014 the exclude set is\n// known at COMPILE TIME (the sibling keys the destructure pattern names), so\n// the compiler passes them here and this does the per-item field-vs-key\n// matching a static type can\'t. The result feeds `bf_spread_attrs`\n// (`SpreadAttrs`), same as a top-level `{...attrs()}` bag.\n//\n// Struct receiver: iterates exported fields via reflection, keyed by each\n// field\'s `json` struct tag (falling back to the Go field name when absent)\n// \u2014 the generated struct\'s json tag is always the ORIGINAL source property\n// name (see `structFieldsFor` / `typeDefinitionToGo` in the Go adapter), so\n// this reproduces the exact JS key `SpreadAttrs`\'s `toAttrName` expects\n// (`"data-priority"`, not a re-derived `"DataPriority"`). A tag of `"-"`\n// (opt-out) is skipped like `encoding/json` does.\n//\n// Map receiver: copies string keys through directly, same exclude/skip\n// rules.\n//\n// Anything else (nil, a non-struct/non-map interface) returns an empty map.\nfunc Omit(item any, excludeKeys ...string) map[string]any {\n	exclude := make(map[string]struct{}, len(excludeKeys))\n	for _, k := range excludeKeys {\n		exclude[k] = struct{}{}\n	}\n	out := map[string]any{}\n	rv := reflect.ValueOf(item)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return out\n		}\n		rv = rv.Elem()\n	}\n	switch rv.Kind() {\n	case reflect.Struct:\n		rt := rv.Type()\n		for i := 0; i < rt.NumField(); i++ {\n			field := rt.Field(i)\n			if !field.IsExported() {\n				continue\n			}\n			key := field.Name\n			if tag, ok := field.Tag.Lookup("json"); ok {\n				if comma := strings.Index(tag, ","); comma >= 0 {\n					tag = tag[:comma]\n				}\n				if tag == "-" {\n					continue\n				}\n				if tag != "" {\n					key = tag\n				}\n			}\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			out[key] = rv.Field(i).Interface()\n		}\n	case reflect.Map:\n		for _, k := range rv.MapKeys() {\n			if k.Kind() != reflect.String {\n				continue\n			}\n			key := k.String()\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			val := rv.MapIndex(k)\n			if val.IsValid() {\n				out[key] = val.Interface()\n			}\n		}\n	}\n	return out\n}\n\n// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// ConcatStr returns a and b concatenated as strings \u2014 the string-typed half\n// of JS `+` (#2168 string-concat-plus). JS `+` is addition when BOTH\n// operands are numeric and concatenation when EITHER is a string; `Add`\n// (above) covers the numeric case, this covers the string one \u2014 `Add`\n// itself can\'t (`toFloat64` returns 0 for a string operand, so `\'Hello, \' +\n// name` silently rendered "0" before this existed).\nfunc ConcatStr(a, b any) string {\n	return toString(a) + toString(b)\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Min returns the smaller of a and b (two-arg `Math.min`). Like Mul, it keeps\n// an integer result when both operands are int-like so a CSS value such as\n// `bf_min 100 x` stays `100` rather than `100.000000`. Uses `Number` (not\n// `toFloat64`, which silently zeroes an unrecognized type like a non-numeric\n// string) plus explicit NaN checks, since IEEE-754 `<`/`>` comparisons\n// against NaN are always false and would otherwise let a non-NaN operand\n// win instead of propagating NaN like JS `Math.min`/`Math.max` do.\nfunc Min(a, b any) any {\n	av, bv := Number(a), Number(b)\n	if math.IsNaN(av) {\n		return av\n	}\n	if math.IsNaN(bv) {\n		return bv\n	}\n	r := av\n	if bv < av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Max returns the larger of a and b (two-arg `Math.max`), with the same\n// int-preserving rule and NaN-propagation as Min.\nfunc Max(a, b any) any {\n	av, bv := Number(a), Number(b)\n	if math.IsNaN(av) {\n		return av\n	}\n	if math.IsNaN(bv) {\n		return bv\n	}\n	r := av\n	if bv > av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// TrimStart returns s with leading whitespace removed\n// (String.prototype.trimStart, #2183) \u2014 the one-sided sibling of\n// Trim above, using the same unicode.IsSpace predicate strings.TrimSpace\n// applies to both sides.\nfunc TrimStart(s string) string {\n	return strings.TrimLeftFunc(s, unicode.IsSpace)\n}\n\n// TrimEnd returns s with trailing whitespace removed\n// (String.prototype.trimEnd, #2183) \u2014 the one-sided sibling of Trim.\nfunc TrimEnd(s string) string {\n	return strings.TrimRightFunc(s, unicode.IsSpace)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Split lowers `String.prototype.split(sep, limit?)` (#1448 Tier B). It\n// wraps `strings.Split` and normalises the result to `[]any` so the\n// slice composes with the array-method surface downstream (`bf_join`,\n// range loops, `bf_len`, \u2026) the same way `bf_slice` / `bf_reverse`\n// results do. Like JS, an empty separator splits into individual UTF-8\n// characters and trailing empty fields are preserved (`"a,".split(",")`\n// \u2192 `["a", ""]`). An optional `limit` caps the number of returned\n// pieces (`"a,b,c".split(",", 2)` \u2192 `["a", "b"]`); a negative limit is\n// ignored (JS would also return every piece \u2014 its ToUint32 wrap makes\n// the limit effectively unbounded). The no-separator form is handled by\n// the adapter (it emits `bf_arr` for the whole-string single element).\nfunc Split(s, sep string, limit ...int) []any {\n	parts := strings.Split(s, sep)\n	if len(limit) > 0 && limit[0] >= 0 && limit[0] < len(parts) {\n		parts = parts[:limit[0]]\n	}\n	out := make([]any, len(parts))\n	for i, p := range parts {\n		out[i] = p\n	}\n	return out\n}\n\n// StartsWith lowers `String.prototype.startsWith(prefix, position?)`\n// (#1448 Tier B). Wraps `strings.HasPrefix`; an empty prefix is always\n// true (JS parity). The optional `position` re-anchors the test to start\n// at that index (clamped to `[0, len]` so it never panics), matching JS\n// `"abc".startsWith("b", 1) === true`.\nfunc StartsWith(s, prefix string, position ...int) bool {\n	if len(position) > 0 {\n		p := position[0]\n		if p < 0 {\n			p = 0\n		}\n		if p > len(s) {\n			p = len(s)\n		}\n		s = s[p:]\n	}\n	return strings.HasPrefix(s, prefix)\n}\n\n// EndsWith lowers `String.prototype.endsWith(suffix, endPosition?)`\n// (#1448 Tier B). Wraps `strings.HasSuffix`; an empty suffix is always\n// true (JS parity). The optional `endPosition` treats the string as if\n// it were only that many bytes long (clamped to `[0, len]`), matching JS\n// `"abc".endsWith("b", 2) === true`.\nfunc EndsWith(s, suffix string, endPosition ...int) bool {\n	if len(endPosition) > 0 {\n		e := endPosition[0]\n		if e < 0 {\n			e = 0\n		}\n		if e > len(s) {\n			e = len(s)\n		}\n		s = s[:e]\n	}\n	return strings.HasSuffix(s, suffix)\n}\n\n// Replace lowers the string-pattern form of `String.prototype.replace`\n// (#1448 Tier B). JS replaces only the FIRST occurrence for a string\n// pattern, so the count is 1 (`strings.Replace` with n=1; `ReplaceAll`\n// below is the every-occurrence sibling, `.replaceAll`, #2182). The\n// replacement is treated literally: unlike JS, special replacement\n// patterns like `$&` / `$1` are NOT interpreted (Go and Perl agree on\n// literal replacement, keeping the two template adapters byte-equal;\n// this diverges from the Hono/CSR JS path only for replacement strings\n// that contain `$`-patterns, which are rare in template position).\nfunc Replace(s, old, new string) string {\n	return strings.Replace(s, old, new, 1)\n}\n\n// ReplaceAll lowers the string-pattern form of\n// `String.prototype.replaceAll` (#2182): every occurrence, via\n// `strings.ReplaceAll` (equivalent to `strings.Replace` with n=-1).\n// Same literal-replacement caveat as `Replace` above.\nfunc ReplaceAll(s, old, new string) string {\n	return strings.ReplaceAll(s, old, new)\n}\n\n// Repeat lowers `String.prototype.repeat(n)` (#1448 Tier B): the\n// receiver concatenated n times. JS throws RangeError for a negative\n// count and `strings.Repeat` panics, so a negative count clamps to the\n// empty string \u2014 SSR templates degrade rather than crash the render.\n// A zero count is the empty string (JS parity).\nfunc Repeat(s string, n int) string {\n	if n <= 0 {\n		return ""\n	}\n	return strings.Repeat(s, n)\n}\n\n// padTo lowers the shared body of `String.prototype.padStart` /\n// `padEnd` (#1448 Tier B): pad `s` to `target` code points using `pad`\n// repeated and truncated to fill, prepended (atStart) or appended.\n// Length is measured in runes (not bytes) so the result matches the\n// Perl `bf->pad_*` helpers \u2014 this diverges from JS\'s UTF-16-unit length\n// only for astral-plane input. An empty pad, or a receiver already at\n// least `target` long, returns `s` unchanged (JS parity).\nfunc padTo(s string, target int, pad string, atStart bool) string {\n	if pad == "" {\n		return s\n	}\n	sLen := utf8.RuneCountInString(s)\n	if sLen >= target {\n		return s\n	}\n	need := target - sLen\n	padRunes := []rune(pad)\n	fill := make([]rune, 0, need)\n	for len(fill) < need {\n		for _, r := range padRunes {\n			if len(fill) >= need {\n				break\n			}\n			fill = append(fill, r)\n		}\n	}\n	if atStart {\n		return string(fill) + s\n	}\n	return s + string(fill)\n}\n\n// PadStart lowers `String.prototype.padStart(target, pad?)` (#1448 Tier\n// B). The pad string defaults to a single space when omitted.\nfunc PadStart(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, true)\n}\n\n// PadEnd lowers `String.prototype.padEnd(target, pad?)` (#1448 Tier B).\nfunc PadEnd(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, false)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// Ternary returns a when cond is true, else b \u2014 the pipeline-position\n// counterpart of a template {{if}} action. Go templates have no\n// expression-level conditional, so a conditional value sitting in\n// ARGUMENT position (a lowering-node helper arg, e.g. the #2324 union\n// stage\'s locale\u2192pattern ternary) cannot be emitted as an {{if}}\n// fragment; the adapter renders it as `(bf_ternary <cond> <a> <b>)`\n// instead. Both branches are evaluated (function-call semantics) \u2014\n// fine for the value shapes the emitter feeds it, wrong for anything\n// with side effects, which template values never have.\nfunc Ternary(cond bool, a, b any) any {\n	if cond {\n		return a\n	}\n	return b\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// RawHTML marks a value as trusted, pre-formatted HTML so html/template\'s\n// contextual escaper emits it verbatim instead of escaping it. It is the SSR\n// half of a dynamic `dangerouslySetInnerHTML={{ __html: expr }}` (#2319) \u2014\n// the one raw-output sink Go lacks as bare template syntax, the counterpart\n// to Blade `{!! !!}`, ERB `<%= %>`, Jinja/MiniJinja `| safe`, Twig `| raw`,\n// Mojolicious `<%== %>`, and Xslate `mark_raw`. The caller owns the value\'s\n// safety (React\'s "dangerously" contract); a nil value renders "".\nfunc RawHTML(v any) template.HTML {\n	return template.HTML(String(v))\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// Abs returns the absolute value of v as a float64, mirroring JS\n// `Math.abs`. #2168 math-methods.\nfunc Abs(v any) float64 {\n	return math.Abs(Number(v))\n}\n\n// ToFixed formats v with exactly `digits` decimal places, mirroring JS\n// `Number.prototype.toFixed` (zero-padding + half-toward-+Infinity\n// rounding). JS rounds the scaled integer half up (`(2.5).toFixed(0)`\n// is "3"); bare `fmt.Sprintf("%.*f")` rounds half-to-even ("2"), so we\n// scale, round with `Floor(x + 0.5)` (matching `Round`), then format\n// the exact multiple. #1897.\nfunc ToFixed(v any, digits int) string {\n	if digits < 0 {\n		digits = 0\n	}\n	n := Number(v)\n	// JS toFixed returns the strings "NaN" / "Infinity" / "-Infinity" for\n	// non-finite inputs; fmt would render "NaN"/"+Inf"/"-Inf".\n	if math.IsNaN(n) {\n		return "NaN"\n	}\n	if math.IsInf(n, 1) {\n		return "Infinity"\n	}\n	if math.IsInf(n, -1) {\n		return "-Infinity"\n	}\n	factor := math.Pow(10, float64(digits))\n	rounded := math.Floor(n*factor + 0.5)\n	return fmt.Sprintf("%.*f", digits, rounded/factor)\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Length lowers JS `.length`, matching JS semantics per receiver shape\n// (#2255): a slice/array/map counts ELEMENTS (`reflect.Value.Len`, same as\n// `Len` below), but a STRING counts UTF-16 CODE UNITS \u2014 JS\n// `String.prototype.length` counts UTF-16 code units, not bytes (Go\'s\n// native `len`) or codepoints. A codepoint outside the Basic Multilingual\n// Plane (astral, U+10000-U+10FFFF \u2014 e.g. \'\u{1F44D}\') is a surrogate PAIR in\n// UTF-16, so it counts as 2, not 1; `\'\u65E5\u672C\u8A9E\'` is 3 either way (BMP-only).\n// Routed from the `.length` member lowering\'s generic (non-array,\n// non-loop-slice) fallback \u2014 see `member()`\'s `bf_length` call site.\nfunc Length(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.Chan:\n		return rv.Len()\n	case reflect.String:\n		n := 0\n		for _, r := range rv.String() {\n			if r > 0xFFFF {\n				n += 2\n			} else {\n				n++\n			}\n		}\n		return n\n	default:\n		return 0\n	}\n}\n\n// IsValidElement lowers React/Hono-style `isValidElement(x)` \u2014 the "is this\n// a renderable element (not plain text)?" predicate the `Slot` component\'s\n// `asChild` pattern (#2266) uses to decide whether to merge props into a\n// child ELEMENT (`children.tag`/`children.props`) or fall back to rendering\n// `children` as-is. The JS runtime checks `\'tag\' in x && \'props\' in x`; on\n// Go SSR a passed-through JSX child is represented as pre-rendered markup\n// (a plain string) OR \u2014 where a struct/map shape carrying `Tag`/`Props`\n// (case-insensitively, mirroring `bf_get`\'s field lookup) is available \u2014 an\n// element-shaped value. A plain string/number/bool/nil is never a valid\n// element, so `isValidElement` must NOT be lowered as bare truthiness\n// (previously done via `renderConditionExpr`) \u2014 a truthy non-empty STRING\n// child wrongly took the element-merge branch and panicked dereferencing\n// `.Props` on a string (`can\'t evaluate field Props in type interface {}`).\nfunc IsValidElement(v any) bool {\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return false\n		}\n		rv = rv.Elem()\n	}\n	switch rv.Kind() {\n	case reflect.Map:\n		hasTag, hasProps := false, false\n		for _, k := range rv.MapKeys() {\n			key := fmt.Sprintf("%v", k.Interface())\n			if strings.EqualFold(key, "tag") {\n				hasTag = true\n			}\n			if strings.EqualFold(key, "props") {\n				hasProps = true\n			}\n		}\n		return hasTag && hasProps\n	case reflect.Struct:\n		return fieldByFoldedName(rv, "tag").IsValid() && fieldByFoldedName(rv, "props").IsValid()\n	default:\n		return false\n	}\n}\n\n// fieldByFoldedName finds a struct field by case-insensitive name match \u2014\n// shared by IsValidElement; mirrors getFieldValue\'s (bf_get) struct-branch\n// lookup so the two case-tolerant field resolutions stay consistent.\nfunc fieldByFoldedName(rv reflect.Value, name string) reflect.Value {\n	t := rv.Type()\n	for i := 0; i < t.NumField(); i++ {\n		if strings.EqualFold(t.Field(i).Name, name) {\n			return rv.Field(i)\n		}\n	}\n	return reflect.Value{}\n}\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  SameValueZero element search (matches\n//     the evaluator\'s `evalSameValueZero`/`evalIncludes` in eval.go,\n//     which back the serialized-callback path) \u2014 numeric types compare\n//     by value across int/float64 the way JS\'s single "number" type\n//     does, and NaN matches NaN (unlike `===`). This used to be\n//     `reflect.DeepEqual`, which is type-strict (`int(2)` != `float64(2)`)\n//     and never matches NaN to NaN; that diverged from the evaluator\'s\n//     `.includes` and from JS itself, so it was unified here.\n//   - string receiver:       strings.Contains substring search\n//\n// Anything else returns false (matches the JS semantic where\n// `.includes` is only defined on Array / TypedArray / String).\nfunc Includes(recv any, elem any) bool {\n	v := reflect.ValueOf(recv)\n	if v.Kind() == reflect.String {\n		// JS `String.prototype.includes` accepts only string args;\n		// non-string `elem` would TypeError in real JS but our\n		// callers have lowered through `convertExpressionToGo`\n		// where the arg type is whatever the template binds. Stringify\n		// via fmt to keep the helper total.\n		needle, ok := elem.(string)\n		if !ok {\n			needle = fmt.Sprintf("%v", elem)\n		}\n		return strings.Contains(v.String(), needle)\n	}\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if evalSameValueZero(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// clampSliceRange normalizes JS `.slice(start, end?)` bounds against a\n// receiver of `length` elements (runes, for the string branch of\n// `Slice` below; array elements, for the array branch) \u2014 shared so\n// both branches clamp identically.\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\nfunc clampSliceRange(length, start int, end []int) (int, int) {\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n	return start, stop\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A) AND\n// `String.prototype.slice(start, end?)` (the `string-slice`\n// divergence) \u2014 the adapter emits the same `bf_slice` call for both\n// receiver shapes (it can\'t disambiguate string vs. array at compile\n// time), so this helper dispatches at runtime on `reflect.Kind()`,\n// mirroring `Includes` above. The variadic `end` arg lets Go\n// template\'s call dispatcher pass either 2 or 3 arguments; an absent\n// end means "to length".\n//\n// String length/positions are measured in runes, not UTF-16 code\n// units \u2014 the same divergence boundary `padTo` already accepts\n// (differs from JS only for astral-plane input). `start >= end`\n// (after clamping) returns an empty result for either receiver.\n//\n// Any other receiver kind returns an empty `[]any`.\nfunc Slice(items any, start int, end ...int) any {\n	v := reflect.ValueOf(items)\n\n	if v.Kind() == reflect.String {\n		runes := []rune(v.String())\n		s, e := clampSliceRange(len(runes), start, end)\n		if s >= e {\n			return ""\n		}\n		return string(runes[s:e])\n	}\n\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	s, e := clampSliceRange(v.Len(), start, end)\n	if s >= e {\n		return []any{}\n	}\n	out := make([]any, 0, e-s)\n	for i := s; i < e; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// Flat flattens nested slices/arrays `depth` levels deep. Lowers\n// `Array.prototype.flat(depth?)` (#1448 Tier C). A `depth` of `-1` is the\n// `Infinity` sentinel (flatten fully); `0` (or negative-from-JS, already\n// normalised to 0 at compile time) returns a shallow copy. Non-array\n// elements are kept as-is (JS only flattens nested arrays). A non-array\n// receiver returns an empty `[]any`.\nfunc Flat(items any, depth int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		ev := reflect.ValueOf(el)\n		if depth != 0 && (ev.Kind() == reflect.Slice || ev.Kind() == reflect.Array) {\n			// `-1` (Infinity) recurses unbounded; a finite depth spends one level.\n			next := depth\n			if depth > 0 {\n				next = depth - 1\n			}\n			out = append(out, Flat(el, next)...)\n		} else {\n			out = append(out, el)\n		}\n	}\n	return out\n}\n\n// FlatDynamicDepth coerces `depth` via JS\'s `ToIntegerOrInfinity` and\n// flattens `items` that many levels. Lowers a DYNAMIC `.flat(depth)`\n// (#2094) \u2014 one whose depth isn\'t a compile-time literal, so (unlike\n// `Flat` above) the coercion happens here at render time instead of in the\n// parser.\n//\n// This is a SEPARATE helper from `Flat`/`bf_flat` \u2014 NOT a drop-in\n// replacement \u2014 because `Flat`\'s `depth int` parameter treats `-1` as a\n// compile-time SENTINEL meaning "flatten fully" (the parser\'s own\n// normalisation of a literal `Infinity`). A genuinely dynamic depth value\n// of `-1` means the JS-correct OPPOSITE: `Array.prototype.flat(-1)` never\n// recurses (same as `.flat(0)`, a shallow copy), because\n// `FlattenIntoArray` only recurses when `depth > 0`. Reusing `Flat`\'s int\n// contract for a raw dynamic value would silently invert that case, so\n// this function coerces FIRST \u2014 mapping a real `+Infinity` / huge finite\n// value to `Flat`\'s own `-1` sentinel, and a real negative value to `0` \u2014\n// and only then delegates to `Flat`\'s recursion.\n//\n// Coercion rules (JS `ToIntegerOrInfinity`, mirrored exactly; pinned by the\n// `flat_dynamic` golden-vector cases in\n// packages/adapter-tests/vectors/cases.ts):\n//   - the value converts via `ToNumber` first (numeric string / bool /\n//     number all coerce; see `flatDepthToFloat`);\n//   - a NaN result (including a non-numeric string) \u2192 `0`;\n//   - truncates toward zero (`2.7` \u2192 `2`);\n//   - negative \u2192 `0`;\n//   - `+Infinity` / a huge finite value \u2192 flattens fully.\nfunc FlatDynamicDepth(items any, depth any) []any {\n	return Flat(items, coerceFlatDepth(depth))\n}\n\n// coerceFlatDepth implements JS\'s `ToIntegerOrInfinity` for a dynamic\n// `.flat(depth)` argument, returning an int in `Flat`\'s own contract (`-1`\n// = unbounded, `>= 0` = that many levels).\nfunc coerceFlatDepth(depth any) int {\n	f, ok := flatDepthToFloat(depth)\n	if !ok || math.IsNaN(f) {\n		return 0\n	}\n	if math.IsInf(f, 1) {\n		return -1 // Flat\'s "flatten fully" sentinel\n	}\n	if math.IsInf(f, -1) {\n		return 0\n	}\n	trunc := math.Trunc(f)\n	if trunc < 0 {\n		return 0\n	}\n	// A huge finite depth behaves identically to "flatten fully" in\n	// practice \u2014 real data bottoms out at its actual nesting depth long\n	// before a counter this large would ever reach zero. Capping it here\n	// avoids an absurd countdown without needing a second sentinel.\n	if trunc > 1_000_000 {\n		return -1\n	}\n	return int(trunc)\n}\n\n// flatDepthToFloat converts a dynamic `.flat(depth)` argument to a float64,\n// mirroring JS\'s `ToNumber` across the value shapes a Go template data\n// model can carry (every numeric kind, bool, numeric string). `ok` is\n// false for a shape `ToNumber` can\'t coerce meaningfully (`nil`, or a\n// non-numeric string) \u2014 `coerceFlatDepth` treats that the same as NaN\n// (\u2192 depth `0`), matching JS.\nfunc flatDepthToFloat(v any) (float64, bool) {\n	switch n := v.(type) {\n	case nil:\n		return 0, false\n	case float64:\n		return n, true\n	case float32:\n		return float64(n), true\n	case int:\n		return float64(n), true\n	case int8:\n		return float64(n), true\n	case int16:\n		return float64(n), true\n	case int32:\n		return float64(n), true\n	case int64:\n		return float64(n), true\n	case uint:\n		return float64(n), true\n	case uint8:\n		return float64(n), true\n	case uint16:\n		return float64(n), true\n	case uint32:\n		return float64(n), true\n	case uint64:\n		return float64(n), true\n	case bool:\n		if n {\n			return 1, true\n		}\n		return 0, true\n	case string:\n		s := strings.TrimSpace(n)\n		if s == "" {\n			return 0, true // JS: Number("") is 0\n		}\n		f, err := strconv.ParseFloat(s, 64)\n		if err != nil {\n			return 0, false // not numeric \u2192 NaN path\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// FlatMap projects each element through a `self` / `field` projection and\n// flattens the result one level. Lowers value-returning\n// `Array.prototype.flatMap(fn)` for the field-projection catalogue\n// (#1448 Tier C): `items.flatMap(i => i)` (self) and\n// `items.flatMap(i => i.field)` (field). A projected non-array value is\n// kept as-is (flatMap = map + flat(1)). Non-array receiver \u2192 empty.\nfunc FlatMap(items any, keyKind, keyName string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	projected := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		if keyKind == "field" {\n			projected = append(projected, getFieldValue(el, keyName))\n		} else {\n			projected = append(projected, el)\n		}\n	}\n	return Flat(projected, 1)\n}\n\n// FlatMapTuple lowers an array-literal flatMap projection\n// `items.flatMap(i => [i.a, i.b])` (#1448 Tier C). `specs` is a flat list\n// of (kind, name) pairs, one per array-literal leaf: ("self", "") for the\n// item itself, ("field", "<Name>") for a struct field. For each item it\n// appends every leaf\'s value in order. Unlike the scalar `FlatMap`, the\n// per-item array is flattened only one level (flat(1) removes the literal\n// wrapper), so an array-valued leaf is appended verbatim rather than\n// spread \u2014 which is exactly "append each leaf". Non-array receiver \u2192 empty.\nfunc FlatMapTuple(items any, specs ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		for j := 0; j+1 < len(specs); j += 2 {\n			if specs[j] == "field" {\n				out = append(out, getFieldValue(el, specs[j+1]))\n			} else {\n				out = append(out, el)\n			}\n		}\n	}\n	return out\n}\n\n// First returns the first element of a slice, or nil if empty.\nfunc First(items any) any {\n	return At(items, 0)\n}\n\n// Last returns the last element of a slice, or nil if empty.\nfunc Last(items any) any {\n	return At(items, -1)\n}\n\n// Arr builds an []any from variadic args. Used to lower JS array\n// literals like `[a, b]` for the registry Slot\'s\n// `[className, childClass].filter(Boolean).join(\' \')` shape (#1443) \u2014\n// Go templates have no array-literal syntax, so the codegen routes\n// array-literal IR nodes through this helper.\nfunc Arr(items ...any) []any {\n	return items\n}\n\n// FilterTruthy returns a new slice containing only truthy items.\n// Mirrors `arr.filter(Boolean)` semantics: drop nil, false, 0, "" \u2014 the\n// same falsy set JavaScript\'s `Boolean(x)` recognises. Used to lower\n// the registry Slot\'s class-merge pattern (#1443); generalising to\n// arbitrary callable predicates would need the callee-resolution path\n// blocked by #1389, so this stays Boolean-specific.\nfunc FilterTruthy(items any) []any {\n	v := reflect.ValueOf(items)\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	result := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		raw := v.Index(i).Interface()\n		if isTruthy(raw) {\n			result = append(result, raw)\n		}\n	}\n	return result\n}\n\n// Truthy is the exported form of isTruthy \u2014 JavaScript\'s `Boolean(x)`\n// semantics. Two callers:\n//   - generated `NewXxxProps` code lowering a conditional inline-object\n//     spread condition on an `interface{}` prop (whose runtime value may be\n//     a string, number, bool, \u2026), keeping the spread bag\'s inclusion test\n//     faithful to JS rather than string-biased (#1752); and\n//   - the `bf_truthy` template FuncMap entry (#2335), which coerces a\n//     `bf_ternary` test to a real bool when it isn\'t already a comparison /\n//     negation (`Ternary`\'s `cond` parameter is typed `bool`, unlike\n//     `{{if}}`\'s built-in truthiness). Uniform across string/number/bool/nil,\n//     so a `bf_ternary` test on any prop type can\'t hit a `bool`-vs-`string`\n//     comparison error the way a string-only `ne <value> ""` would.\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// ScopeCommentEnd emits the paired end marker for a fragment-rooted scope\n// (#2289): a fragment root has no single wrapping element to bound the\n// client\'s scope query, so the range leaks onto later siblings without an\n// explicit terminator. Carries only the scope id \u2014 no `|h=`/`|m=`/props\n// segment, unlike ScopeComment \u2014 since the client only needs it to confirm\n// the range closes on the matching scope (getCommentScopeBoundary in\n// packages/client/src/runtime/scope.ts).\nfunc ScopeCommentEnd(props interface{}) template.HTML {\n	scopeID := getStringField(props, "ScopeID")\n	return template.HTML("<!--bf-/scope:" + scopeID + "-->")\n}\n\n// TemplateFuncMap returns the helpers that need access to the executing\n// template set itself, closed over the *template.Template the component\n// defines are parsed into. Register it alongside FuncMap BEFORE parsing:\n//\n//	t := template.New("")\n//	t.Funcs(bf.FuncMap()).Funcs(bf.TemplateFuncMap(t))\n//	template.Must(t.Parse(src))\n//\n// bf_tmpl executes a named define from the same set and returns its\n// output \u2014 used for the per-call-site children defines the Go adapter\n// emits when JSX children passed to an imported component contain\n// template actions (nested components, dynamic text) and therefore\n// cannot be baked to a static HTML string (#1896). Reentrant execution\n// of an html/template set from inside a FuncMap function is safe: the\n// escape analysis over every define completes before the outer\n// Execute begins evaluating.\nfunc TemplateFuncMap(t *template.Template) template.FuncMap {\n	return template.FuncMap{\n		"bf_tmpl": func(name string, data interface{}) (template.HTML, error) {\n			var buf bytes.Buffer\n			if err := t.ExecuteTemplate(&buf, name, data); err != nil {\n				return "", err\n			}\n			return template.HTML(buf.String()), nil\n		},\n	}\n}\n\n// WithChildren returns a shallow copy of a component Props struct with its\n// Children field replaced by the given pre-rendered fragment (#1896). The\n// props value stays by-value semantics: callers\' originals are untouched.\n// A props type without a Children field passes through unchanged \u2014 the\n// child template then simply has no children to render, matching the\n// pre-#1896 behaviour.\nfunc WithChildren(props interface{}, children template.HTML) (interface{}, error) {\n	v := reflect.ValueOf(props)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return props, nil\n	}\n	field := v.FieldByName("Children")\n	if !field.IsValid() {\n		return props, nil\n	}\n	copyPtr := reflect.New(v.Type())\n	copyPtr.Elem().Set(v)\n	target := copyPtr.Elem().FieldByName("Children")\n	switch {\n	case target.Kind() == reflect.Interface:\n		target.Set(reflect.ValueOf(children))\n	case target.Kind() == reflect.String:\n		// Covers both `string` and `template.HTML`-typed fields.\n		target.SetString(string(children))\n	default:\n		return props, fmt.Errorf("bf_with_children: unsupported Children field type %s", target.Type())\n	}\n	return copyPtr.Elem().Interface(), nil\n}\n\n// PortalHTML parses and executes a template string with the provided data.\n// Used for rendering dynamic portal content where the template string\n// contains Go template expressions (e.g., {{if .Open}}open{{end}}).\n//\n// The template string is parsed fresh each time to support dynamic content.\n// Standard Go template functions (if, range, eq, etc.) are available.\nfunc PortalHTML(data interface{}, tmplStr string) template.HTML {\n	// Create a new template with the FuncMap for custom functions\n	t, err := template.New("portal").Funcs(FuncMap()).Parse(tmplStr)\n	if err != nil {\n		// Return error message as HTML comment for debugging\n		return template.HTML("<!-- bfPortalHTML error: " + err.Error() + " -->")\n	}\n\n	var buf bytes.Buffer\n	if err := t.Execute(&buf, data); err != nil {\n		return template.HTML("<!-- bfPortalHTML exec error: " + err.Error() + " -->")\n	}\n\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Portal Collection\n// =============================================================================\n\n// PortalContent represents a single portal\'s content to be rendered at body end.\ntype PortalContent struct {\n	ID      string        // Unique portal ID for hydration matching\n	OwnerID string        // Owner scope ID for find() support\n	Content template.HTML // Portal HTML content\n}\n\n// PortalCollector collects portal content during template rendering.\n// Portal content is rendered at </body> to avoid z-index issues.\ntype PortalCollector struct {\n	portals []PortalContent\n	counter int\n}\n\n// NewPortalCollector creates a new PortalCollector.\nfunc NewPortalCollector() *PortalCollector {\n	return &PortalCollector{\n		portals: []PortalContent{},\n		counter: 0,\n	}\n}\n\n// Add registers portal content to be rendered at body end.\nfunc (pc *PortalCollector) Add(ownerID string, content template.HTML) string {\n	pc.counter++\n	id := "bf-portal-" + strconv.Itoa(pc.counter)\n	pc.portals = append(pc.portals, PortalContent{\n		ID:      id,\n		OwnerID: ownerID,\n		Content: content,\n	})\n	return "" // Return empty string for template use\n}\n\n// Render outputs all collected portals as HTML.\n// Each portal is wrapped in a div with bf-pi (portal ID) and bf-po (portal owner).\nfunc (pc *PortalCollector) Render() template.HTML {\n	if pc == nil || len(pc.portals) == 0 {\n		return ""\n	}\n	var buf strings.Builder\n	for _, p := range pc.portals {\n		buf.WriteString(`<div bf-pi="`)\n		buf.WriteString(p.ID)\n		buf.WriteString(`" bf-po="`)\n		buf.WriteString(p.OwnerID)\n		buf.WriteString(`">`)\n		buf.WriteString(string(p.Content))\n		buf.WriteString("</div>\\n")\n	}\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Script Collection\n// =============================================================================\n\n// ScriptCollector collects client scripts with deduplication.\n// It preserves insertion order for deterministic output.\ntype ScriptCollector struct {\n	scripts map[string]bool\n	order   []string\n}\n\n// NewScriptCollector creates a new ScriptCollector.\nfunc NewScriptCollector() *ScriptCollector {\n	return &ScriptCollector{\n		scripts: make(map[string]bool),\n		order:   []string{},\n	}\n}\n\n// Register adds a script source to the collection.\n// Duplicate scripts are ignored (only first registration counts).\nfunc (sc *ScriptCollector) Register(src string) string {\n	if sc.scripts[src] {\n		return "" // Already registered\n	}\n	sc.scripts[src] = true\n	sc.order = append(sc.order, src)\n	return "" // Return empty string for template use\n}\n\n// Scripts returns all registered scripts in insertion order.\nfunc (sc *ScriptCollector) Scripts() []string {\n	return sc.order\n}\n\n// BfScripts generates script tags for all registered scripts.\n// Returns HTML safe for embedding in templates.\nfunc BfScripts(collector *ScriptCollector) template.HTML {\n	if collector == nil {\n		return ""\n	}\n	var result strings.Builder\n	for _, src := range collector.Scripts() {\n		result.WriteString(`<script type="module" src="`)\n		result.WriteString(src)\n		result.WriteString(`"></script>`)\n		result.WriteString("\\n")\n	}\n	return template.HTML(result.String())\n}\n\n// =============================================================================\n// Component Renderer\n// =============================================================================\n\n// RenderContext contains all data needed to render a component page.\n// The layout function receives this context to build the final HTML.\ntype RenderContext struct {\n	// ComponentName is the template name being rendered\n	ComponentName string\n\n	// Props is the component props (for layout to access if needed)\n	Props interface{}\n\n	// ComponentHTML is the rendered component template output\n	ComponentHTML template.HTML\n\n	// Portals contains collected portal content to render at body end\n	Portals template.HTML\n\n	// Scripts contains the collected JS script tags\n	Scripts template.HTML\n\n	// Title is the page title (defaults to "{ComponentName} - BarefootJS")\n	Title string\n\n	// Heading is the page heading. Empty string means no heading.\n	Heading string\n\n	// Extra holds additional user-defined data for the layout\n	Extra map[string]interface{}\n}\n\n// LayoutFunc renders the final HTML page given the render context.\ntype LayoutFunc func(ctx *RenderContext) string\n\n// Renderer renders BarefootJS components with a customizable layout.\ntype Renderer struct {\n	templates *template.Template\n	layout    LayoutFunc\n}\n\n// NewRenderer creates a Renderer with the given templates and layout function.\n//\n// Example usage:\n//\n//	renderer := bf.NewRenderer(templates, func(ctx *bf.RenderContext) string {\n//	    return fmt.Sprintf(`<!DOCTYPE html>\n//	<html>\n//	<head><title>%s</title></head>\n//	<body>%s%s</body>\n//	</html>`, ctx.Title, ctx.ComponentHTML, ctx.Scripts)\n//	})\nfunc NewRenderer(tmpl *template.Template, layout LayoutFunc) *Renderer {\n	return &Renderer{\n		templates: tmpl,\n		layout:    layout,\n	}\n}\n\n// RenderOptions configures a single render call.\ntype RenderOptions struct {\n	// ComponentName is the template name to render (required)\n	ComponentName string\n\n	// Props is the component props (must be a pointer to struct with Scripts field)\n	Props interface{}\n\n	// Title is the page title. If empty, defaults to "{ComponentName} - BarefootJS"\n	Title string\n\n	// Heading is the page heading. If empty, no heading is shown.\n	Heading string\n\n	// Extra holds additional data to pass to the layout\n	Extra map[string]interface{}\n}\n\n// Render renders a component to a full HTML page using the configured layout.\n// Child component props are automatically detected (any slice field with ScopeID/Scripts).\n// renderTemplateErrorPanel formats a Go template execution error into a\n// fragment of HTML that\'s visible in the browser. The panel is\n// HTML-escaped so a faulty template name (anything from `template:\n// "..."`) can\'t smuggle markup back into the page. Keep the styling\n// inline so the panel surfaces even when the project\'s CSS hasn\'t\n// loaded yet (e.g. the failure aborted before the stylesheet links\n// emitted).\n//\n// Surfaced for the #1442 echo repro: a template referencing\n// `.Todo.Done` (instead of the range dot\'s `.Done`) used to fail\n// silently \u2014 Go\'s html/template aborted mid-stream, the partial body\n// flushed as a 200, and the user saw a truncated list with no console\n// signal. With this panel they get the template name, the error\n// message, and a "what to look at" hint inline.\nfunc renderTemplateErrorPanel(componentName string, err error) string {\n	return `<div style="margin:1em 0;padding:1em;border:2px solid #d33;background:#fff5f5;color:#900;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:13px;line-height:1.5"><strong style="display:block;margin-bottom:.5em">Template error in <code>` +\n		template.HTMLEscapeString(componentName) +\n		`</code></strong><pre style="margin:0;white-space:pre-wrap;word-break:break-word">` +\n		template.HTMLEscapeString(err.Error()) +\n		`</pre><div style="margin-top:.75em;font-size:12px;opacity:.7">Common cause: a JSX expression referenced a name the adapter could not resolve to a struct field. Open the matching <code>dist/templates/*.tmpl</code> for the unresolved reference, then fix the source component.</div></div>`\n}\n\n// renderComponentInto wires a component\'s props (script/portal collectors,\n// child-slot scope ids + hydration, root marking) against the PROVIDED\n// collectors and returns just the component\'s HTML \u2014 no layout. Both Render\n// (one fresh collector pair per page) and RenderFragment (a shared pair across\n// several islands) funnel through here so their wiring stays identical.\nfunc (r *Renderer) renderComponentInto(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	// Inject the shared collectors into the props.\n	setScriptsField(opts.Props, scriptCollector)\n	setPortalsField(opts.Props, portalCollector)\n\n	// Auto-detect and process child component props (slices)\n	childSlices := findChildComponentSlices(opts.Props)\n	for _, slice := range childSlices {\n		setScopeIDsOnSlice(slice)\n		setScriptsOnSlice(slice, scriptCollector)\n		setPortalsOnSlice(slice, portalCollector)\n		setBoolOnSlice(slice, "BfIsChild", true)\n	}\n\n	// Auto-detect and process single child component props\n	singleChildren := findSingleChildComponents(opts.Props)\n	for _, child := range singleChildren {\n		setScopeIDOnSingle(child)\n		setScriptsOnSingle(child, scriptCollector)\n		setPortalsOnSingle(child, portalCollector)\n		setBoolField(child, "BfIsChild", true)\n	}\n\n	// Mark the root component so BfPropsAttr emits bf-p only for it\n	setBoolField(opts.Props, "BfIsRoot", true)\n\n	// Render the component template.\n	//\n	// Errors here are NOT silently dropped. The original implementation\n	// ignored the return value of `ExecuteTemplate`, which masked a real\n	// onboarding failure mode: a template referencing a non-existent\n	// field (`.Todo.Done` instead of the range dot\'s `.Done`) caused\n	// html/template to abort mid-stream, the partial output got\n	// returned, and the HTTP server happily flushed a 200 with a\n	// truncated body. No error log, no signal \u2014 the user just saw a\n	// blank list (#1442 echo TodoApp repro).\n	//\n	// Now we capture the error and replace the partial output with a\n	// visible inline panel (dev mode) or a fenced error comment\n	// (production), so the cause is on-screen and grep-able in logs.\n	// Either way the renderer also writes to stderr so structured log\n	// aggregators see it.\n	var componentBuf strings.Builder\n	if err := r.templates.ExecuteTemplate(&componentBuf, opts.ComponentName, opts.Props); err != nil {\n		fmt.Fprintf(os.Stderr, "barefoot: template %q failed to render: %v\\n", opts.ComponentName, err)\n		// Preserve whatever the template did manage to emit before\n		// failing (Go\'s text/template flushes incrementally), but\n		// follow it with a clearly-marked error block so the user\n		// notices something is wrong instead of seeing a silent\n		// truncation.\n		componentBuf.WriteString(renderTemplateErrorPanel(opts.ComponentName, err))\n	}\n\n	return template.HTML(componentBuf.String())\n}\n\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// One script + portal collector pair for the whole page.\n	scriptCollector := NewScriptCollector()\n	portalCollector := NewPortalCollector()\n\n	componentHTML := r.renderComponentInto(opts, scriptCollector, portalCollector)\n\n	// Determine title (default: "{ComponentName} - BarefootJS")\n	title := opts.Title\n	if title == "" {\n		title = opts.ComponentName + " - BarefootJS"\n	}\n\n	// Heading (empty means no heading)\n	heading := opts.Heading\n\n	// Build render context\n	ctx := &RenderContext{\n		ComponentName: opts.ComponentName,\n		Props:         opts.Props,\n		ComponentHTML: componentHTML,\n		Portals:       portalCollector.Render(),\n		Scripts:       BfScripts(scriptCollector),\n		Title:         title,\n		Heading:       heading,\n		Extra:         opts.Extra,\n	}\n\n	return r.layout(ctx)\n}\n\n// RenderFragment renders a single island subtree into the caller-provided\n// script and portal collectors and returns just its HTML \u2014 no page layout.\n//\n// It exists for hand-authored "region shell" pages (the `@barefootjs/router`\n// showcase): a layout that places several independent islands \u2014 e.g. a header\n// ThemeToggle, an `<aside bf-region>` Sidebar, and a `<PageShell>` wrapping the\n// route content \u2014 must collect ALL their scripts and portals into ONE place so\n// the runtime (`barefoot.js`) and each island\'s client JS are emitted exactly\n// once and share a single reactive instance. Render each island with the same\n// collectors, splice the returned HTML into the shell, then emit\n// `BfScripts(sc)` and `pc.Render()` once at the end of the document.\n//\n// Each fragment is treated as its own root (it emits `bf-p` like any top-level\n// island); nested children declared in its props are wired as children, exactly\n// as in Render.\nfunc (r *Renderer) RenderFragment(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	return r.renderComponentInto(opts, scriptCollector, portalCollector)\n}\n\n// setScriptsField sets the Scripts field on a struct using reflection.\nfunc setScriptsField(v interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Scripts")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// setPortalsField sets the Portals field on a struct using reflection.\nfunc setPortalsField(v interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Portals")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// getStringField extracts a string field from a struct using reflection.\nfunc setBoolField(v interface{}, fieldName string, val bool) {\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Struct {\n		return\n	}\n	field := rv.FieldByName(fieldName)\n	if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n		field.SetBool(val)\n	}\n}\n\nfunc getBoolField(v interface{}, fieldName string) bool {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return false\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.Bool {\n		return false\n	}\n	return field.Bool()\n}\n\nfunc getStringField(v interface{}, fieldName string) string {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return ""\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.String {\n		return ""\n	}\n	return field.String()\n}\n\n// scopeIDChars is the alphabet for auto-generated ScopeID suffixes. It\n// mirrors the `randomID` helper the go-template adapter emits into the\n// generated New<Component>Props constructors so runtime-assigned and\n// constructor-assigned ids are indistinguishable.\nconst scopeIDChars = "abcdefghijklmnopqrstuvwxyz0123456789"\n\n// randomScopeSuffix returns a random lowercase-alphanumeric string of\n// length n. math/rand (auto-seeded since Go 1.20) is sufficient here: the\n// suffix only needs to be unique enough to keep a page\'s bf-s scope ids\n// from colliding, not cryptographically unpredictable.\nfunc randomScopeSuffix(n int) string {\n	b := make([]byte, n)\n	for i := range b {\n		b[i] = scopeIDChars[rand.Intn(len(scopeIDChars))]\n	}\n	return string(b)\n}\n\n// scopeIDPrefix derives the human-readable ScopeID prefix from a child\n// component\'s type, e.g. `TodoItemProps` \u2192 `TodoItem`. Matches the\n// `"<Component>_" + randomID(6)` shape the generated constructors use.\nfunc scopeIDPrefix(t reflect.Type) string {\n	for t.Kind() == reflect.Ptr {\n		t = t.Elem()\n	}\n	return strings.TrimSuffix(t.Name(), "Props")\n}\n\n// assignScopeID fills a child component\'s ScopeID with a generated id when\n// the caller left it empty, so application code doesn\'t have to mint scope\n// ids by hand (the parent\'s New<Component>Props constructor does the same\n// for components built through it). A non-empty ScopeID is left untouched,\n// so callers can still pin a stable id when they need one.\nfunc assignScopeID(structVal reflect.Value, prefix string) {\n	field := structVal.FieldByName("ScopeID")\n	if !field.IsValid() || !field.CanSet() || field.Kind() != reflect.String {\n		return\n	}\n	if field.String() != "" {\n		return\n	}\n	id := randomScopeSuffix(6)\n	if prefix != "" {\n		id = prefix + "_" + id\n	}\n	field.SetString(id)\n}\n\n// setScopeIDsOnSlice assigns a generated ScopeID to every child in a slice\n// whose ScopeID is empty.\nfunc setScopeIDsOnSlice(slice interface{}) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	prefix := scopeIDPrefix(v.Type().Elem())\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			assignScopeID(item, prefix)\n		}\n	}\n}\n\n// setScopeIDOnSingle assigns a generated ScopeID to a single child\n// component when its ScopeID is empty.\nfunc setScopeIDOnSingle(child interface{}) {\n	v := reflect.ValueOf(child)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return\n	}\n	assignScopeID(v, scopeIDPrefix(v.Type()))\n}\n\n// findChildComponentSlices finds slice fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findChildComponentSlices(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n		if field.Kind() != reflect.Slice || field.Len() == 0 {\n			continue\n		}\n\n		elem := field.Index(0)\n		if elem.Kind() == reflect.Ptr {\n			elem = elem.Elem()\n		}\n		if elem.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := elem.FieldByName("ScopeID").IsValid()\n		hasScripts := elem.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSlice sets Scripts on all items in a slice.\nfunc setScriptsOnSlice(slice interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Scripts")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// setBoolOnSlice sets a bool field on all items in a slice.\nfunc setBoolOnSlice(slice interface{}, fieldName string, val bool) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName(fieldName)\n			if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n				field.SetBool(val)\n			}\n		}\n	}\n}\n\n// setPortalsOnSlice sets Portals on all items in a slice.\nfunc setPortalsOnSlice(slice interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Portals")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// Nullish implements JS `??` for template use (`bf_nullish`, #2248): returns\n// fallback iff v is nil (untyped nil or a nil pointer/map/slice boxed in the\n// interface), otherwise v \u2014 so present-but-falsy `""`/`0`/`false` are KEPT,\n// unlike the truthiness-based template `or`.\nfunc Nullish(v, fallback any) any {\n	if v == nil {\n		return fallback\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Interface, reflect.Func, reflect.Chan:\n		if rv.IsNil() {\n			return fallback\n		}\n	}\n	return v\n}\n\n// ToInt exposes the runtime\'s numeric coercion for generated constructors\n// (#2248): a nillable-lowered numeric prop arrives as `interface{}`, and an\n// untyped Go literal (`Size: 3`) boxes as int even when the prop is\n// float64-shaped \u2014 a direct type assertion would panic where JS accepts the\n// number. Non-numeric values coerce to 0, matching the helpers\' behaviour.\nfunc ToInt(v any) int { return toInt(v) }\n\n// ToFloat64 is ToInt\'s float64 counterpart \u2014 see ToInt.\nfunc ToFloat64(v any) float64 { return toFloat64(v) }\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		rv := reflect.ValueOf(v)\n		if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {\n			// JS `Array.prototype.toString` is `this.join(\',\')`, applied\n			// recursively \u2014 a nested array element stringifies the same\n			// way rather than via Go\'s `%v`. Reached via `Join`/`ConcatStr`\n			// on an element that is itself an array (e.g. `.flat(0)`\'s\n			// shallow copy joined afterwards, #2262).\n			parts := make([]string, rv.Len())\n			for i := 0; i < rv.Len(); i++ {\n				parts[i] = toString(rv.Index(i).Interface())\n			}\n			return strings.Join(parts, ",")\n		}\n		return ""\n	}\n}\n\n// =============================================================================\n// searchParams() \u2014 request-scoped environment signal (router v0.5, #1922)\n// =============================================================================\n\n// SearchParams is the SSR view of the request query string behind the\n// reactive searchParams() environment signal. The route handler builds it\n// from the request URL and assigns it to the component\'s SearchParams input\n// field; the generated template reads it via `.SearchParams.Get "key"`.\n//\n// The zero value is an empty query (url.Values.Get tolerates a nil map), so a\n// render with no request query \u2014 e.g. the adapter conformance harness, which\n// issues no query string \u2014 resolves every key to "", which the template\'s\n// `or`/`??` fallback turns into the author\'s default.\ntype SearchParams struct {\n	values url.Values\n}\n\n// NewSearchParams parses a raw query string (with or without a leading "?")\n// into a SearchParams. A malformed query yields an empty set rather than an\n// error, mirroring the browser\'s URLSearchParams, which never throws on junk.\n//\n// Typical handler use (net/http):\n//\n//	in := MyComponentInput{SearchParams: bf.NewSearchParams(r.URL.RawQuery)}\nfunc NewSearchParams(raw string) SearchParams {\n	raw = strings.TrimPrefix(raw, "?")\n	values, err := url.ParseQuery(raw)\n	if err != nil {\n		values = url.Values{}\n	}\n	return SearchParams{values: values}\n}\n\n// Get returns the first value associated with key, or "" when the key is\n// absent. This mirrors url.Values.Get, which also returns "" for a\n// present-but-empty value (`?sort=`). Safe on the zero value (nil map).\n//\n// This is not byte-for-byte URLSearchParams.get under the template\'s `??`\n// lowering. JS distinguishes absent (`null`) from present-but-empty (`""`):\n// `null ?? d` yields the default, but `"" ?? d` keeps the empty string. The\n// Go adapter lowers `??` to the `or` builtin \u2014 Go templates have no\n// null-coalescing operator \u2014 so here BOTH an absent key and a present-but-\n// empty value fall back to the author\'s default. The conformance fixture only\n// exercises the absent-key default, where the two runtimes agree; the\n// empty-string divergence is the same general `?? \u2192 or` limitation that\n// applies to any `x ?? default` the Go adapter lowers.\nfunc (s SearchParams) Get(key string) string {\n	return s.values.Get(key)\n}\n';
+    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	"regexp"\n	"sort"\n	"strconv"\n	"strings"\n	"time"\n	"unicode"\n	"unicode/utf8"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Nullish coalescing (#2248): JS `??` semantics \u2014 fall back only on\n		// nil, keeping present-but-falsy values (`""`, `0`, `false`) that\n		// Go\'s truthiness-based `or` would replace.\n		"bf_nullish": Nullish,\n\n		// Arithmetic\n		"bf_add":        Add,\n		"bf_concat_str": ConcatStr,\n		"bf_sub":        Sub,\n		"bf_mul":        Mul,\n		"bf_div":        Div,\n		"bf_mod":        Mod,\n		"bf_neg":        Neg,\n		"bf_min":        Min,\n		"bf_max":        Max,\n\n		// String\n		"bf_lower":       Lower,\n		"bf_upper":       Upper,\n		"bf_trim":        Trim,\n		"bf_trim_start":  TrimStart,\n		"bf_trim_end":    TrimEnd,\n		"bf_contains":    Contains,\n		"bf_join":        Join,\n		"bf_split":       Split,\n		"bf_starts_with": StartsWith,\n		"bf_ends_with":   EndsWith,\n		"bf_replace":     Replace,\n		"bf_replace_all": ReplaceAll,\n		"bf_repeat":      Repeat,\n		"bf_pad_start":   PadStart,\n		"bf_pad_end":     PadEnd,\n		"bf_string":      String,\n		"bf_raw_html":    RawHTML,\n		"bf_ternary":     Ternary,\n		"bf_truthy":      Truthy,\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		// Date method lowering (#2274, spec entry "date"): the lowering\n		// target for a zero-arg call on a Date-typed prop.\n		"bf_date": Date,\n\n		// formatDate(date, pattern, tz) lowering (#2324, spec entry\n		// "format_date"): the total, locale-free date-pattern formatter \u2014\n		// see FormatDate\'s docstring for the full contract.\n		"bf_format_date": FormatDate,\n\n		// JSON / numeric primitives \u2014 JS-compat callees registered on\n		// the Go adapter\'s `templatePrimitives` map (#1188).\n		"bf_json":     JSON,\n		"bf_number":   Number,\n		"bf_floor":    Floor,\n		"bf_ceil":     Ceil,\n		"bf_round":    Round,\n		"bf_abs":      Abs,\n		"bf_to_fixed": ToFixed,\n\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_length":         Length,\n		"bf_is_element":     IsValidElement,\n		"bf_style_object":   StyleObjectToCSS,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_flat":           Flat,\n		"bf_flat_dynamic":   FlatDynamicDepth,\n		"bf_flat_map":       FlatMap,\n		"bf_flat_map_tuple": FlatMapTuple,\n		"bf_first":          First,\n		"bf_last":           Last,\n		"bf_arr":            Arr,\n		"bf_filter_truthy":  FilterTruthy,\n\n		// Higher-order Array Methods\n		"bf_every":           Every,\n		"bf_some":            Some,\n		"bf_filter":          Filter,\n		"bf_find":            Find,\n		"bf_find_index":      FindIndex,\n		"bf_find_last":       FindLast,\n		"bf_find_last_index": FindLastIndex,\n		"bf_sort":            Sort,\n		"bf_reduce":          Reduce,\n\n		// Evaluator-driven higher-order folds (#2018): the comparator / reducer\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_sort / bf_reduce beyond their fixed catalogues. The\n		// adapter falls back to bf_sort for a comparator the evaluator can\'t\n		// model (e.g. localeCompare). `bf_env` builds the captured-free-var\n		// environment passed as the trailing base_env argument.\n		"bf_sort_eval":   SortEval,\n		"bf_reduce_eval": FoldEval,\n		"bf_env":         Env,\n\n		// Evaluator-driven higher-order predicates (#2018, P2): the predicate\n		// body travels as a serialized ParsedExpr (JSON) evaluated per element,\n		// generalizing bf_filter / bf_find / bf_find_index / bf_every / bf_some\n		// beyond their field-equality / truthiness catalogues. `bf_find_eval` /\n		// `bf_find_index_eval` take a `forward` bool (false \u2192 findLast variants).\n		"bf_filter_eval":     FilterEval,\n		"bf_every_eval":      EveryEval,\n		"bf_some_eval":       SomeEval,\n		"bf_find_eval":       FindEval,\n		"bf_find_index_eval": FindIndexEval,\n		// `.flatMap(proj)`: project each element through the serialized\n		// projection body, then flatten one level.\n		"bf_flat_map_eval": FlatMapEval,\n		// Value-producing `.map(cb)` (#2073): project each element, one\n		// result per element (no flatten).\n		"bf_map_eval": MapEval,\n\n		// Comment marker (for hydration)\n		"bfComment":   Comment,\n		"bfTextStart": TextStart,\n		"bfTextEnd":   TextEnd,\n\n		// Script collection\n		"bfScripts": BfScripts,\n\n		// Scope attribute value (#1249: bare scope id, no `~` prefix)\n		"bfScopeAttr": ScopeAttr,\n\n		// Slot-identity markers (#1249): bf-h, bf-m, bf-r\n		"bfHydrationAttrs": HydrationAttrs,\n\n		// Child component marker (kept for backward compatibility)\n		"bfIsChild": IsChild,\n\n		// Props attribute for hydration\n		"bfPropsAttr": BfPropsAttr,\n\n		// Portal HTML rendering (parses and executes template string)\n		"bfPortalHTML": PortalHTML,\n\n		// JSX children passed to an imported child component (#1896):\n		// the parent renders the children fragment via a companion\n		// define (executed through bf_tmpl from TemplateFuncMap) and\n		// injects the result into the child\'s Children field.\n		"bf_with_children": WithChildren,\n\n		// Per-row props for a child component nested inside a composite\n		// loop row (#2445): the parent\'s once-per-slot instance is shared\n		// across rows, so a prop that depends on the row is reapplied as a\n		// copy inside {{range}}, the props-argument sibling of\n		// bf_with_children.\n		"bf_with_props": WithProps,\n\n		// Per-row props for a child whose CONSTRUCTOR derives a field from\n		// the overridden prop (#2448). bf_with_props patches fields on the\n		// shared instance and cannot re-run New<Child>Props, so a memo body\n		// or a signal initial value computed there would stay at the shared\n		// instance\'s one-shot value on every row. This entry looks up the\n		// component\'s generated rebuilder and re-runs the real constructor\n		// instead. See reprops.go for why the lookup is deferred to execute\n		// time rather than merged into this map.\n		"bf_reprops": Reprops,\n\n		// Scope comment for fragment roots\n		"bfScopeComment":    ScopeComment,\n		"bfScopeCommentEnd": ScopeCommentEnd,\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// Date implements the `date` helper (spec/template-helpers.md, #2274) \u2014 the\n// lowering target for a zero-arg call on a Date-typed prop\n// (`createdAt.toISOString()`). recv accepts the runtime\'s own `time.Time` /\n// `*time.Time` (however the host framework populated the prop) OR an\n// ISO-8601 string (the wire form a JSON-sourced prop arrives as); either is\n// normalized to UTC before dispatching op, matching the client `Date`\'s own\n// instant semantics regardless of which shape reaches this helper. A nil /\n// unparsable receiver yields this runtime\'s zero value for the requested op\n// (0 for every numeric accessor, "" for toISOString) rather than panicking\n// mid-render \u2014 the same tolerance `String`/`Number` already extend to a nil\n// prop. `getUTCMonth` subtracts 1: Go\'s `time.Month` is 1-based, JS\'s is not\n// (spec entry "date" is explicit that JS wins here).\nfunc Date(recv any, op string) any {\n	t, ok := toTime(recv)\n	if !ok {\n		if op == "toISOString" {\n			return ""\n		}\n		return 0\n	}\n	t = t.UTC()\n	switch op {\n	case "getUTCFullYear":\n		return t.Year()\n	case "getUTCMonth":\n		return int(t.Month()) - 1\n	case "getUTCDate":\n		return t.Day()\n	case "getUTCHours":\n		return t.Hour()\n	case "getUTCMinutes":\n		return t.Minute()\n	case "getUTCSeconds":\n		return t.Second()\n	case "getTime":\n		return t.UnixMilli()\n	case "toISOString":\n		return t.Format("2006-01-02T15:04:05.000Z")\n	default:\n		return 0\n	}\n}\n\n// tzOffsetRE matches a fixed UTC offset `\xB1HH:MM` within ECMA-402\'s valid\n// range \u2014 hours 00\u201323, minutes 00\u201359 (`\'+09:00\'`, `\'-05:30\'`) \u2014 one of the\n// three `tz` shapes FormatDate accepts (mirrors OFFSET_RE in\n// packages/client/src/format-date.ts). An out-of-range shape (`\'+25:00\'`)\n// falls through to the tzdata lookup, fails it, and errors \u2014 matching the\n// JS reference\'s RangeError (#2344).\nvar tzOffsetRE = regexp.MustCompile(`^([+-])([01][0-9]|2[0-3]):([0-5][0-9])$`)\n\n// formatDateTokenRE is the longest-match pattern-token alternation (mirrors\n// TOKEN_RE in packages/client/src/format-date.ts). Order matters: MMMM\n// before MMM before MM before M (and dddd before ddd, DD before D) so the\n// longer token wins at a position where a shorter one could also match \u2014\n// Go\'s regexp, like JS\'s, resolves alternation leftmost-first (not POSIX\n// leftmost-longest), so listing the longer alternative first is what makes\n// e.g. "MMMM" consume all four characters instead of "MM" + "MM".\nvar formatDateTokenRE = regexp.MustCompile(`YYYY|MMMM|MMM|MM|DD|dddd|ddd|M|D`)\n\n// nameTable section offsets (#2334, mirrors MONTHS_WIDE / MONTHS_ABBR /\n// WEEKDAYS_WIDE / WEEKDAYS_ABBR in packages/client/src/format-date.ts).\nconst (\n	monthsWide   = 0\n	monthsAbbr   = 12\n	weekdaysWide = 24\n	weekdaysAbbr = 31\n)\n\n// formatDateName reads a name-token table entry: index out of range, or a\n// non-string element, both render "" \u2014 the same total, zero-value\n// discipline as an unparseable date (mirrors the JS reference\'s\n// `names[index] ?? ""` fallback, where every table element the vectors ever\n// carry is a string).\nfunc formatDateName(names []any, index int) string {\n	if index < 0 || index >= len(names) {\n		return ""\n	}\n	s, ok := names[index].(string)\n	if !ok {\n		return ""\n	}\n	return s\n}\n\n// FormatDate implements the `format_date` helper (#2324, #2334, spec entry\n// "format_date") \u2014 the lowering target for\n// `formatDate(date, pattern, tz, names)`\n// (packages/client/src/format-date.ts, the JS-normative reference this must\n// match byte-for-byte). Total and deterministic: no locale, no host\n// timezone, no "now".\n//\n// recv: same receiver contract as the `date` helper above \u2014 the runtime\'s\n// own `time.Time` / `*time.Time`, or an ISO-8601 string \u2014 normalized via\n// `toTime`. A nil / unparseable receiver returns "" (never panics).\n//\n// tz (#2344): "UTC", a range-valid fixed offset `\xB1HH:MM` (shifts by\n// sign*(HH*60+MM) minutes), or a canonical IANA zone name ("Asia/Tokyo")\n// resolved through tzdata via time.LoadLocation \u2014 the zone\'s UTC offset AT\n// THE INSTANT being formatted (DST-aware, historical-transition-aware,\n// seconds precision: pre-standard LMT offsets like Tokyo\'s +09:18:59\n// count). ANY other value \u2014 an unknown zone, a malformed or out-of-range\n// offset ("+9:00", "+25:00"), the empty string or "Local" (LoadLocation\'s\n// implicit-environment aliases) \u2014 returns an ERROR, aborting template\n// execution loudly: the JS reference throws a RangeError there, and a\n// silently substituted timezone is the one failure mode this helper must\n// not have (the pre-#2344 normalize-to-UTC total function is gone). The\n// shifted instant\'s UTC calendar fields (not the original instant\'s) are\n// what pattern tokens read \u2014 the shifted UTC clock face IS the local clock\n// face in that zone, same reasoning as the JS reference.\n//\n// names (#2334): a flat name table in fixed layout \u2014 `[0..11]` wide month\n// names, `[12..23]` abbreviated month names, `[24..30]` wide weekday names\n// (Sunday-first), `[31..37]` abbreviated weekday names. The caller owns the\n// values; this helper only indexes the table.\n//\n// pattern: longest-match token substitution\n// (`YYYY|MMMM|MMM|MM|DD|dddd|ddd|M|D`); every other character \u2014 including\n// multi-byte ones like \u5E74/\u6708/\u65E5 \u2014 passes through literally. `YYYY` is\n// `abs(year)` zero-padded to 4 digits, `-`-prefixed for a negative year;\n// `MM`/`DD` zero-pad to 2; `M`/`D` are bare; `MMMM`/`MMM` and `dddd`/`ddd`\n// read the `names` table (weekday computed on the offset-shifted instant,\n// Sunday-first, matching `time.Time.Weekday()`\'s own Sunday=0 encoding).\nfunc FormatDate(recv any, pattern string, tz string, names []any) (string, error) {\n	t, ok := toTime(recv)\n	if !ok {\n		// Receiver contract precedes tz validation (spec receiver-first\n		// discipline, mirrored by every port).\n		return "", nil\n	}\n	offsetSeconds := 0\n	if tz != "UTC" {\n		if m := tzOffsetRE.FindStringSubmatch(tz); m != nil {\n			hh, _ := strconv.Atoi(m[2])\n			mm, _ := strconv.Atoi(m[3])\n			offsetSeconds = (hh*60 + mm) * 60\n			if m[1] == "-" {\n				offsetSeconds = -offsetSeconds\n			}\n		} else if tz == "" || tz == "Local" {\n			// LoadLocation("") is UTC and LoadLocation("Local") is the host\n			// zone \u2014 both implicit-environment reads the contract refuses.\n			return "", fmt.Errorf("format_date: unresolvable timeZone %q", tz)\n		} else {\n			loc, err := time.LoadLocation(tz)\n			if err != nil {\n				return "", fmt.Errorf("format_date: unresolvable timeZone %q", tz)\n			}\n			_, offsetSeconds = t.UTC().In(loc).Zone()\n		}\n	}\n	shifted := t.UTC().Add(time.Duration(offsetSeconds) * time.Second)\n	year := shifted.Year()\n	month := int(shifted.Month())\n	day := shifted.Day()\n	weekday := int(shifted.Weekday()) // time.Sunday == 0, matching the table\'s Sunday-first layout\n	absYear := year\n	if absYear < 0 {\n		absYear = -absYear\n	}\n	yyyy := fmt.Sprintf("%04d", absYear)\n	if year < 0 {\n		yyyy = "-" + yyyy\n	}\n	out := formatDateTokenRE.ReplaceAllStringFunc(pattern, func(token string) string {\n		switch token {\n		case "YYYY":\n			return yyyy\n		case "MMMM":\n			return formatDateName(names, monthsWide+month-1)\n		case "MMM":\n			return formatDateName(names, monthsAbbr+month-1)\n		case "MM":\n			return fmt.Sprintf("%02d", month)\n		case "M":\n			return strconv.Itoa(month)\n		case "DD":\n			return fmt.Sprintf("%02d", day)\n		case "D":\n			return strconv.Itoa(day)\n		case "dddd":\n			return formatDateName(names, weekdaysWide+weekday)\n		case "ddd":\n			return formatDateName(names, weekdaysAbbr+weekday)\n		default:\n			return token\n		}\n	})\n	return out, nil\n}\n\n// toTime normalizes a `Date` helper receiver to a `time.Time`: the runtime\'s\n// own `time.Time` / `*time.Time`, or an ISO-8601 string parsed with\n// `time.RFC3339Nano` (accepts both the `Z`-suffixed and numeric-offset\n// forms, and any sub-second precision \u2014 including the millisecond precision\n// every value this runtime itself ever produces via `toISOString` above).\n// Anything else (nil, an unparsable string, an unrelated type) reports !ok\n// so `Date` can apply its documented zero-value fallback instead of\n// panicking.\nfunc toTime(recv any) (time.Time, bool) {\n	switch v := recv.(type) {\n	case time.Time:\n		return v, true\n	case *time.Time:\n		if v == nil {\n			return time.Time{}, false\n		}\n		return *v, true\n	case string:\n		t, err := time.Parse(time.RFC3339Nano, v)\n		if err != nil {\n			return time.Time{}, false\n		}\n		return t, true\n	default:\n		return time.Time{}, false\n	}\n}\n\n// asStringSlice reports whether v is a query *array* value and, if so, returns\n// its members stringified. A compiled template passes a `[]string` field; the\n// golden conformance vectors decode JSON arrays to `[]any`. Anything else is a\n// scalar (false), handled by the set() path.\nfunc asStringSlice(v any) ([]string, bool) {\n	switch s := v.(type) {\n	case []string:\n		return s, true\n	case []any:\n		out := make([]string, len(s))\n		for i, m := range s {\n			out[i] = String(m)\n		}\n		return out, true\n	default:\n		return nil, false\n	}\n}\n\nconst hexUpper = "0123456789ABCDEF"\n\n// formEscape percent-encodes s with the application/x-www-form-urlencoded byte\n// set, matching the browser\'s URLSearchParams serialization (and the Perl\n// `query` helper) so SSR query strings render byte-for-byte identically across\n// adapters. The unreserved set kept verbatim is A-Z a-z 0-9 and `* - . _`; a\n// space becomes `+`; every other byte is `%XX` with uppercase hex. Encoding is\n// byte-wise, so multi-byte UTF-8 is percent-encoded per byte (`\xE9` \u2192 `%C3%A9`).\n//\n// This differs from url.QueryEscape only for `~` (kept by QueryEscape, encoded\n// to `%7E` here) and `*` (encoded to `%2A` by QueryEscape, kept here).\nfunc formEscape(s string) string {\n	var b strings.Builder\n	for i := 0; i < len(s); i++ {\n		c := s[i]\n		switch {\n		case c >= \'A\' && c <= \'Z\', c >= \'a\' && c <= \'z\', c >= \'0\' && c <= \'9\',\n			c == \'*\', c == \'-\', c == \'.\', c == \'_\':\n			b.WriteByte(c)\n		case c == \' \':\n			b.WriteByte(\'+\')\n		default:\n			b.WriteByte(\'%\')\n			b.WriteByte(hexUpper[c>>4])\n			b.WriteByte(hexUpper[c&0x0F])\n		}\n	}\n	return b.String()\n}\n\n// ScopeAttr returns the bare bf-s scope id (#1249).\nfunc ScopeAttr(props interface{}) string {\n	return getStringField(props, "ScopeID")\n}\n\n// HydrationAttrs emits `bf-h="<host>" bf-m="<slot>" bf-r=""` conditionally.\n// See spec/compiler.md "Slot identity".\nfunc HydrationAttrs(props interface{}) template.HTMLAttr {\n	parts := []string{}\n	if host := getStringField(props, "BfParent"); host != "" {\n		parts = append(parts, fmt.Sprintf(`bf-h="%s"`, template.HTMLEscapeString(host)))\n	}\n	if mount := getStringField(props, "BfMount"); mount != "" {\n		parts = append(parts, fmt.Sprintf(`bf-m="%s"`, template.HTMLEscapeString(mount)))\n	}\n	if !getBoolField(props, "BfIsChild") {\n		parts = append(parts, `bf-r=""`)\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// IsChild is a deprecated no-op stub. Child status is signalled by bf-h\n// presence (#1249); use HydrationAttrs instead.\nfunc IsChild(props interface{}) template.HTMLAttr {\n	return ""\n}\n\n// svgCamelCaseAttrs mirrors SVG_CAMEL_CASE_ATTRS from\n// packages/client/src/runtime/spread-attrs.ts. SVG XML attribute\n// names are case-sensitive; the default camelCase \u2192 kebab-case\n// rewrite must NOT apply to these or the SVG stops rendering\n// (#1407). Coordinates with the compile-time SVG_CAMEL_TO_KEBAB\n// table in packages/jsx/src/ir-to-client-js/utils.ts: presentation\n// attrs (clipPath, strokeWidth, \u2026) live there and must NOT appear\n// here, or the same JSX prop would lower to clip-path via the\n// explicit-attr path and stay clipPath via the spread path.\nvar svgCamelCaseAttrs = map[string]struct{}{\n	"allowReorder": {}, "attributeName": {}, "attributeType": {}, "autoReverse": {},\n	"baseFrequency": {}, "baseProfile": {}, "calcMode": {}, "clipPathUnits": {},\n	"contentScriptType": {}, "contentStyleType": {}, "diffuseConstant": {}, "edgeMode": {},\n	"externalResourcesRequired": {}, "filterRes": {}, "filterUnits": {}, "glyphRef": {},\n	"gradientTransform": {}, "gradientUnits": {}, "kernelMatrix": {}, "kernelUnitLength": {},\n	"keyPoints": {}, "keySplines": {}, "keyTimes": {}, "lengthAdjust": {}, "limitingConeAngle": {},\n	"markerHeight": {}, "markerUnits": {}, "markerWidth": {}, "maskContentUnits": {},\n	"maskUnits": {}, "numOctaves": {}, "pathLength": {}, "patternContentUnits": {},\n	"patternTransform": {}, "patternUnits": {}, "pointsAtX": {}, "pointsAtY": {}, "pointsAtZ": {},\n	"preserveAlpha": {}, "preserveAspectRatio": {}, "primitiveUnits": {}, "refX": {}, "refY": {},\n	"repeatCount": {}, "repeatDur": {}, "requiredExtensions": {}, "requiredFeatures": {},\n	"specularConstant": {}, "specularExponent": {}, "spreadMethod": {}, "startOffset": {},\n	"stdDeviation": {}, "stitchTiles": {}, "surfaceScale": {}, "systemLanguage": {},\n	"tableValues": {}, "targetX": {}, "targetY": {}, "textLength": {}, "viewBox": {}, "viewTarget": {},\n	"xChannelSelector": {}, "yChannelSelector": {}, "zoomAndPan": {},\n}\n\n// toAttrName mirrors the JSX\u2192HTML attribute-name rewrite from\n// packages/client/src/runtime/spread-attrs.ts. className \u2192 class,\n// htmlFor \u2192 for, SVG camelCase attrs preserved, other camelCase\n// keys lowered to kebab-case.\nfunc toAttrName(key string) string {\n	if key == "className" {\n		return "class"\n	}\n	if key == "htmlFor" {\n		return "for"\n	}\n	if _, ok := svgCamelCaseAttrs[key]; ok {\n		return key\n	}\n	// camelCase \u2192 kebab-case: mirror the JS reference exactly\n	// (`key.replace(/([A-Z])/g, \'-$1\').toLowerCase()`). The JS shape\n	// produces a leading `-` for an initial uppercase letter\n	// (`XData` \u2192 `-x-data`); both this Go path and the matching JS\n	// runtime are wrong-by-construction for that case (the resulting\n	// HTML attribute name is invalid), but keeping them byte-equal\n	// avoids silent SSR/CSR divergence (#1411 review).\n	var b strings.Builder\n	for _, r := range key {\n		if r >= \'A\' && r <= \'Z\' {\n			b.WriteByte(\'-\')\n			b.WriteRune(r + 32)\n		} else {\n			b.WriteRune(r)\n		}\n	}\n	return b.String()\n}\n\n// hasUnsafeStyleValue mirrors Hono\'s own CSS-injection guard\n// (`hono/jsx/utils.ts`\'s `hasUnsafeStyleValue` \u2014 the ORACLE this adapter\'s\n// dynamic `style={{...}}` values must match, #2261): a hand-rolled\n// structural scan for characters that could break out of a CSS\n// declaration, NOT real CSSOM property validation. Ported byte-for-byte \u2014\n// every character this scan tests is ASCII, so scanning by byte (Go\n// string indexing) agrees with Hono\'s UTF-16-code-unit scan for every\n// input; a multibyte UTF-8 sequence has no byte in the ASCII range, so it\n// can never spuriously match one of these single-byte comparisons. Skips\n// the reference implementation\'s regex fast-path (a pure optimization \u2014\n// the scan below already returns `false` promptly for a clean value).\nfunc hasUnsafeStyleValue(value string) bool {\n	quote := byte(0)\n	blockStack := make([]byte, 0, 4)\n	for i := 0; i < len(value); i++ {\n		c := value[i]\n		switch {\n		case c == \'\\\\\':\n			if i == len(value)-1 {\n				return true\n			}\n			i++\n		case quote != 0:\n			if c == \'\\n\' || c == \'\\f\' || c == \'\\r\' {\n				return true\n			}\n			if c == quote {\n				quote = 0\n			}\n		case c == \'/\' && i+1 < len(value) && value[i+1] == \'*\':\n			end := strings.Index(value[i+2:], "*/")\n			if end == -1 {\n				return true\n			}\n			i = i + 2 + end + 1\n		case c == \'"\' || c == \'\\\'\':\n			quote = c\n		case c == \'(\':\n			blockStack = append(blockStack, \')\')\n		case c == \'[\':\n			blockStack = append(blockStack, \']\')\n		case c == \'{\' || c == \'}\':\n			return true\n		case c == \')\' || c == \']\':\n			if len(blockStack) == 0 || blockStack[len(blockStack)-1] != c {\n				return true\n			}\n			blockStack = blockStack[:len(blockStack)-1]\n		case c == \';\' && len(blockStack) == 0:\n			return true\n		}\n	}\n	return quote != 0 || len(blockStack) != 0\n}\n\n// StyleObjectToCSS builds the CSS string for a `style={{...}}` JSX\n// object-literal attribute (#2261) \u2014 `pairs` alternates CSS key (always a\n// compile-time-known literal), then value (`any`, possibly a runtime\n// expression\'s result). A value that fails `hasUnsafeStyleValue` (after\n// JS-`String()`-style stringification) is DROPPED \u2014 the whole `key:value`\n// pair is omitted \u2014 matching Hono\'s oracle behavior exactly, rather than\n// html/template\'s own contextual CSS auto-escaper (which instead emits its\n// `ZgotmplZ` unsafe-content sentinel for the same input). The final joined\n// string is STILL HTML-escaped (mirroring Hono\'s own `escapeToBuffer` call\n// on its accumulated style string) \u2014 a "safe" value can still carry a\n// literal `"`/`\'`/`&` (e.g. a BALANCED-quote CSS string value like\n// `"hello"` passes the structural scan; the quote chars survive into the\n// value) that would otherwise break out of the double-quoted `style="..."`\n// attribute. Returns `template.CSS` (over the escaped result) so\n// html/template treats it as trusted CSS content instead of ALSO applying\n// its own contextual CSS auto-escaper (which would re-derive the exact\n// `ZgotmplZ` divergence this function exists to avoid).\nfunc StyleObjectToCSS(pairs ...any) template.CSS {\n	parts := make([]string, 0, len(pairs)/2)\n	for i := 0; i+1 < len(pairs); i += 2 {\n		key := fmt.Sprint(pairs[i])\n		value := String(pairs[i+1])\n		if hasUnsafeStyleValue(value) {\n			continue\n		}\n		parts = append(parts, template.HTMLEscapeString(key)+":"+template.HTMLEscapeString(value))\n	}\n	return template.CSS(strings.Join(parts, ";"))\n}\n\n// StyleToCss mirrors styleToCss from\n// packages/client/src/runtime/style.ts. Accepts a string passthrough,\n// or a map (JSON-deserialized object) whose camelCase keys are\n// lowered to kebab-case and joined with `;`. Returns ("", false) for\n// nullish/empty input so callers can omit the attribute entirely.\nfunc StyleToCss(v any) (string, bool) {\n	if v == nil {\n		return "", false\n	}\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return "", false\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		// Non-object: stringify and return as-is, matching the JS\n		// `typeof value !== \'object\'` branch.\n		s := fmt.Sprint(v)\n		if s == "" {\n			return "", false\n		}\n		return s, true\n	}\n	keys := rv.MapKeys()\n	sorted := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sorted = append(sorted, k.String())\n		}\n	}\n	sort.Strings(sorted)\n	parts := make([]string, 0, len(sorted))\n	for _, k := range sorted {\n		val := rv.MapIndex(reflect.ValueOf(k))\n		// Skip nil entries (matches the JS `if (v == null) continue`).\n		if !val.IsValid() {\n			continue\n		}\n		if val.Kind() == reflect.Interface || val.Kind() == reflect.Pointer {\n			if val.IsNil() {\n				continue\n			}\n			val = val.Elem()\n		}\n		prop := toAttrName(k)\n		parts = append(parts, fmt.Sprintf("%s:%v", prop, val.Interface()))\n	}\n	if len(parts) == 0 {\n		return "", false\n	}\n	return strings.Join(parts, ";"), true\n}\n\n// SpreadAttrs lowers a JSX intrinsic-element spread bag (#1407) to\n// an HTML attribute string. Mirrors spreadAttrs from\n// packages/client/src/runtime/spread-attrs.ts so SSR output matches\n// what CSR\'s `applyRestAttrs` writes at hydration.\n//\n// Skip rules: nil/false values, event handlers (`on[A-Z]*`),\n// `children`, `ref`.\n//\n// Key remap: className \u2192 class, htmlFor \u2192 for, SVG camelCase\n// preserved, other camelCase \u2192 kebab-case.\n//\n// `style` is routed through StyleToCss so object literals serialize\n// to a real CSS string instead of Go\'s default `map[k:v]` form.\n//\n// Booleans: true \u2192 bare attribute name, false \u2192 omitted.\n// Other scalar values are HTML-escaped via template.HTMLEscapeString.\n// Returns a `template.HTMLAttr` so html/template emits the result\n// verbatim (the function does its own escaping).\n//\n// Keys are sorted alphabetically before emission for deterministic\n// output. SSR/CSR attribute-order divergence is acceptable per the\n// rest-destructure-object-spread-in-map fixture\'s documented policy\n// \u2014 browsers honor the LAST value when a key is duplicated, so\n// pairing with static attrs (`<div class="x" {...rest}>`) is\n// last-wins regardless of order.\nfunc SpreadAttrs(bag any) template.HTMLAttr {\n	if bag == nil {\n		return ""\n	}\n	rv := reflect.ValueOf(bag)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return ""\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		return ""\n	}\n	keys := rv.MapKeys()\n	sortedKeys := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sortedKeys = append(sortedKeys, k.String())\n		}\n	}\n	sort.Strings(sortedKeys)\n	parts := make([]string, 0, len(sortedKeys))\n	for _, key := range sortedKeys {\n		// Event handlers \u2014 skip at SSR the same way\n		// packages/client/src/runtime/spread-attrs.ts does at\n		// hydration. The JS predicate is\n		// `key.startsWith(\'on\') && key.length > 2 && key[2] === key[2].toUpperCase()`,\n		// which is true for any character whose uppercase form is\n		// itself: ASCII A-Z, digits, underscore, and non-letter\n		// symbols. Mirror that here by skipping when key[2] is NOT\n		// a lowercase ASCII letter \u2014 so `onClick`, `on_custom`, and\n		// `on0` all match (#1411 review).\n		if len(key) > 2 && key[0] == \'o\' && key[1] == \'n\' && !(key[2] >= \'a\' && key[2] <= \'z\') {\n			continue\n		}\n		// `children` is a JSX construct rendered inside the element,\n		// never a DOM attribute. `ref` is intentionally NOT filtered\n		// here so output stays byte-equal with the JS reference\n		// `spreadAttrs` in packages/client/src/runtime/spread-attrs.ts\n		// (which only filters null/false, event handlers, and\n		// children) \u2014 aligning Go\'s filter set diverges from JS in\n		// the opposite direction. Filtering `ref` consistently across\n		// both SSR runtimes is a separate concern tracked alongside\n		// the JS `applyRestAttrs` vs `spreadAttrs` mismatch (#1411\n		// review).\n		if key == "children" {\n			continue\n		}\n		val := rv.MapIndex(reflect.ValueOf(key))\n		if !val.IsValid() {\n			continue\n		}\n		// Unwrap interface wrappers (json.Unmarshal produces\n		// interface{}-wrapped values for map[string]any).\n		v := val\n		for v.Kind() == reflect.Interface || v.Kind() == reflect.Pointer {\n			if v.IsNil() {\n				// Skip null entries.\n				v = reflect.Value{}\n				break\n			}\n			v = v.Elem()\n		}\n		if !v.IsValid() {\n			continue\n		}\n		// Boolean values: true \u2192 bare attribute, false \u2192 omitted.\n		if v.Kind() == reflect.Bool {\n			if !v.Bool() {\n				continue\n			}\n			parts = append(parts, toAttrName(key))\n			continue\n		}\n		// `style` routes through StyleToCss so object literals get a\n		// real CSS string. The JS side does the same.\n		if key == "style" {\n			css, ok := StyleToCss(v.Interface())\n			if !ok {\n				continue\n			}\n			parts = append(parts, fmt.Sprintf(`style="%s"`, template.HTMLEscapeString(css)))\n			continue\n		}\n		// Stringify and escape. fmt.Sprint handles numbers, bools-as-\n		// strings, and arbitrary stringer types the same way the JS\n		// `String(value)` coercion does for the analogous cases.\n		s := fmt.Sprint(v.Interface())\n		parts = append(parts, fmt.Sprintf(`%s="%s"`, toAttrName(key), template.HTMLEscapeString(s)))\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// Omit builds a `map[string]any` residual bag from a struct or map value,\n// excluding the given keys \u2014 powers the `{...rest}` spread-onto-element\n// lowering for a destructured `.map()` loop-item\'s object-rest binding\n// (#2087): `.map(({ id, title, ...rest }) => <li {...rest}>)` needs "every\n// field EXCEPT the ones the pattern already destructured out", and a static\n// Go struct type has no way to express "minus a field" \u2014 the exclude set is\n// known at COMPILE TIME (the sibling keys the destructure pattern names), so\n// the compiler passes them here and this does the per-item field-vs-key\n// matching a static type can\'t. The result feeds `bf_spread_attrs`\n// (`SpreadAttrs`), same as a top-level `{...attrs()}` bag.\n//\n// Struct receiver: iterates exported fields via reflection, keyed by each\n// field\'s `json` struct tag (falling back to the Go field name when absent)\n// \u2014 the generated struct\'s json tag is always the ORIGINAL source property\n// name (see `structFieldsFor` / `typeDefinitionToGo` in the Go adapter), so\n// this reproduces the exact JS key `SpreadAttrs`\'s `toAttrName` expects\n// (`"data-priority"`, not a re-derived `"DataPriority"`). A tag of `"-"`\n// (opt-out) is skipped like `encoding/json` does.\n//\n// Map receiver: copies string keys through directly, same exclude/skip\n// rules.\n//\n// Anything else (nil, a non-struct/non-map interface) returns an empty map.\nfunc Omit(item any, excludeKeys ...string) map[string]any {\n	exclude := make(map[string]struct{}, len(excludeKeys))\n	for _, k := range excludeKeys {\n		exclude[k] = struct{}{}\n	}\n	out := map[string]any{}\n	rv := reflect.ValueOf(item)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return out\n		}\n		rv = rv.Elem()\n	}\n	switch rv.Kind() {\n	case reflect.Struct:\n		rt := rv.Type()\n		for i := 0; i < rt.NumField(); i++ {\n			field := rt.Field(i)\n			if !field.IsExported() {\n				continue\n			}\n			key := field.Name\n			if tag, ok := field.Tag.Lookup("json"); ok {\n				if comma := strings.Index(tag, ","); comma >= 0 {\n					tag = tag[:comma]\n				}\n				if tag == "-" {\n					continue\n				}\n				if tag != "" {\n					key = tag\n				}\n			}\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			out[key] = rv.Field(i).Interface()\n		}\n	case reflect.Map:\n		for _, k := range rv.MapKeys() {\n			if k.Kind() != reflect.String {\n				continue\n			}\n			key := k.String()\n			if _, skip := exclude[key]; skip {\n				continue\n			}\n			val := rv.MapIndex(k)\n			if val.IsValid() {\n				out[key] = val.Interface()\n			}\n		}\n	}\n	return out\n}\n\n// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// ConcatStr returns a and b concatenated as strings \u2014 the string-typed half\n// of JS `+` (#2168 string-concat-plus). JS `+` is addition when BOTH\n// operands are numeric and concatenation when EITHER is a string; `Add`\n// (above) covers the numeric case, this covers the string one \u2014 `Add`\n// itself can\'t (`toFloat64` returns 0 for a string operand, so `\'Hello, \' +\n// name` silently rendered "0" before this existed).\nfunc ConcatStr(a, b any) string {\n	return toString(a) + toString(b)\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Min returns the smaller of a and b (two-arg `Math.min`). Like Mul, it keeps\n// an integer result when both operands are int-like so a CSS value such as\n// `bf_min 100 x` stays `100` rather than `100.000000`. Uses `Number` (not\n// `toFloat64`, which silently zeroes an unrecognized type like a non-numeric\n// string) plus explicit NaN checks, since IEEE-754 `<`/`>` comparisons\n// against NaN are always false and would otherwise let a non-NaN operand\n// win instead of propagating NaN like JS `Math.min`/`Math.max` do.\nfunc Min(a, b any) any {\n	av, bv := Number(a), Number(b)\n	if math.IsNaN(av) {\n		return av\n	}\n	if math.IsNaN(bv) {\n		return bv\n	}\n	r := av\n	if bv < av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Max returns the larger of a and b (two-arg `Math.max`), with the same\n// int-preserving rule and NaN-propagation as Min.\nfunc Max(a, b any) any {\n	av, bv := Number(a), Number(b)\n	if math.IsNaN(av) {\n		return av\n	}\n	if math.IsNaN(bv) {\n		return bv\n	}\n	r := av\n	if bv > av {\n		r = bv\n	}\n	if isIntLike(a) && isIntLike(b) && r == float64(int(r)) {\n		return int(r)\n	}\n	return r\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// TrimStart returns s with leading whitespace removed\n// (String.prototype.trimStart, #2183) \u2014 the one-sided sibling of\n// Trim above, using the same unicode.IsSpace predicate strings.TrimSpace\n// applies to both sides.\nfunc TrimStart(s string) string {\n	return strings.TrimLeftFunc(s, unicode.IsSpace)\n}\n\n// TrimEnd returns s with trailing whitespace removed\n// (String.prototype.trimEnd, #2183) \u2014 the one-sided sibling of Trim.\nfunc TrimEnd(s string) string {\n	return strings.TrimRightFunc(s, unicode.IsSpace)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Split lowers `String.prototype.split(sep, limit?)` (#1448 Tier B). It\n// wraps `strings.Split` and normalises the result to `[]any` so the\n// slice composes with the array-method surface downstream (`bf_join`,\n// range loops, `bf_len`, \u2026) the same way `bf_slice` / `bf_reverse`\n// results do. Like JS, an empty separator splits into individual UTF-8\n// characters and trailing empty fields are preserved (`"a,".split(",")`\n// \u2192 `["a", ""]`). An optional `limit` caps the number of returned\n// pieces (`"a,b,c".split(",", 2)` \u2192 `["a", "b"]`); a negative limit is\n// ignored (JS would also return every piece \u2014 its ToUint32 wrap makes\n// the limit effectively unbounded). The no-separator form is handled by\n// the adapter (it emits `bf_arr` for the whole-string single element).\nfunc Split(s, sep string, limit ...int) []any {\n	parts := strings.Split(s, sep)\n	if len(limit) > 0 && limit[0] >= 0 && limit[0] < len(parts) {\n		parts = parts[:limit[0]]\n	}\n	out := make([]any, len(parts))\n	for i, p := range parts {\n		out[i] = p\n	}\n	return out\n}\n\n// StartsWith lowers `String.prototype.startsWith(prefix, position?)`\n// (#1448 Tier B). Wraps `strings.HasPrefix`; an empty prefix is always\n// true (JS parity). The optional `position` re-anchors the test to start\n// at that index (clamped to `[0, len]` so it never panics), matching JS\n// `"abc".startsWith("b", 1) === true`.\nfunc StartsWith(s, prefix string, position ...int) bool {\n	if len(position) > 0 {\n		p := position[0]\n		if p < 0 {\n			p = 0\n		}\n		if p > len(s) {\n			p = len(s)\n		}\n		s = s[p:]\n	}\n	return strings.HasPrefix(s, prefix)\n}\n\n// EndsWith lowers `String.prototype.endsWith(suffix, endPosition?)`\n// (#1448 Tier B). Wraps `strings.HasSuffix`; an empty suffix is always\n// true (JS parity). The optional `endPosition` treats the string as if\n// it were only that many bytes long (clamped to `[0, len]`), matching JS\n// `"abc".endsWith("b", 2) === true`.\nfunc EndsWith(s, suffix string, endPosition ...int) bool {\n	if len(endPosition) > 0 {\n		e := endPosition[0]\n		if e < 0 {\n			e = 0\n		}\n		if e > len(s) {\n			e = len(s)\n		}\n		s = s[:e]\n	}\n	return strings.HasSuffix(s, suffix)\n}\n\n// Replace lowers the string-pattern form of `String.prototype.replace`\n// (#1448 Tier B). JS replaces only the FIRST occurrence for a string\n// pattern, so the count is 1 (`strings.Replace` with n=1; `ReplaceAll`\n// below is the every-occurrence sibling, `.replaceAll`, #2182). The\n// replacement is treated literally: unlike JS, special replacement\n// patterns like `$&` / `$1` are NOT interpreted (Go and Perl agree on\n// literal replacement, keeping the two template adapters byte-equal;\n// this diverges from the Hono/CSR JS path only for replacement strings\n// that contain `$`-patterns, which are rare in template position).\nfunc Replace(s, old, new string) string {\n	return strings.Replace(s, old, new, 1)\n}\n\n// ReplaceAll lowers the string-pattern form of\n// `String.prototype.replaceAll` (#2182): every occurrence, via\n// `strings.ReplaceAll` (equivalent to `strings.Replace` with n=-1).\n// Same literal-replacement caveat as `Replace` above.\nfunc ReplaceAll(s, old, new string) string {\n	return strings.ReplaceAll(s, old, new)\n}\n\n// Repeat lowers `String.prototype.repeat(n)` (#1448 Tier B): the\n// receiver concatenated n times. JS throws RangeError for a negative\n// count and `strings.Repeat` panics, so a negative count clamps to the\n// empty string \u2014 SSR templates degrade rather than crash the render.\n// A zero count is the empty string (JS parity).\nfunc Repeat(s string, n int) string {\n	if n <= 0 {\n		return ""\n	}\n	return strings.Repeat(s, n)\n}\n\n// padTo lowers the shared body of `String.prototype.padStart` /\n// `padEnd` (#1448 Tier B): pad `s` to `target` code points using `pad`\n// repeated and truncated to fill, prepended (atStart) or appended.\n// Length is measured in runes (not bytes) so the result matches the\n// Perl `bf->pad_*` helpers \u2014 this diverges from JS\'s UTF-16-unit length\n// only for astral-plane input. An empty pad, or a receiver already at\n// least `target` long, returns `s` unchanged (JS parity).\nfunc padTo(s string, target int, pad string, atStart bool) string {\n	if pad == "" {\n		return s\n	}\n	sLen := utf8.RuneCountInString(s)\n	if sLen >= target {\n		return s\n	}\n	need := target - sLen\n	padRunes := []rune(pad)\n	fill := make([]rune, 0, need)\n	for len(fill) < need {\n		for _, r := range padRunes {\n			if len(fill) >= need {\n				break\n			}\n			fill = append(fill, r)\n		}\n	}\n	if atStart {\n		return string(fill) + s\n	}\n	return s + string(fill)\n}\n\n// PadStart lowers `String.prototype.padStart(target, pad?)` (#1448 Tier\n// B). The pad string defaults to a single space when omitted.\nfunc PadStart(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, true)\n}\n\n// PadEnd lowers `String.prototype.padEnd(target, pad?)` (#1448 Tier B).\nfunc PadEnd(s string, target int, pad ...string) string {\n	p := " "\n	if len(pad) > 0 {\n		p = pad[0]\n	}\n	return padTo(s, target, p, false)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// Ternary returns a when cond is true, else b \u2014 the pipeline-position\n// counterpart of a template {{if}} action. Go templates have no\n// expression-level conditional, so a conditional value sitting in\n// ARGUMENT position (a lowering-node helper arg, e.g. the #2324 union\n// stage\'s locale\u2192pattern ternary) cannot be emitted as an {{if}}\n// fragment; the adapter renders it as `(bf_ternary <cond> <a> <b>)`\n// instead. Both branches are evaluated (function-call semantics) \u2014\n// fine for the value shapes the emitter feeds it, wrong for anything\n// with side effects, which template values never have.\nfunc Ternary(cond bool, a, b any) any {\n	if cond {\n		return a\n	}\n	return b\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// RawHTML marks a value as trusted, pre-formatted HTML so html/template\'s\n// contextual escaper emits it verbatim instead of escaping it. It is the SSR\n// half of a dynamic `dangerouslySetInnerHTML={{ __html: expr }}` (#2319) \u2014\n// the one raw-output sink Go lacks as bare template syntax, the counterpart\n// to Blade `{!! !!}`, ERB `<%= %>`, Jinja/MiniJinja `| safe`, Twig `| raw`,\n// Mojolicious `<%== %>`, and Xslate `mark_raw`. The caller owns the value\'s\n// safety (React\'s "dangerously" contract); a nil value renders "".\nfunc RawHTML(v any) template.HTML {\n	return template.HTML(String(v))\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// Abs returns the absolute value of v as a float64, mirroring JS\n// `Math.abs`. #2168 math-methods.\nfunc Abs(v any) float64 {\n	return math.Abs(Number(v))\n}\n\n// ToFixed formats v with exactly `digits` decimal places, mirroring JS\n// `Number.prototype.toFixed` (zero-padding + half-toward-+Infinity\n// rounding). JS rounds the scaled integer half up (`(2.5).toFixed(0)`\n// is "3"); bare `fmt.Sprintf("%.*f")` rounds half-to-even ("2"), so we\n// scale, round with `Floor(x + 0.5)` (matching `Round`), then format\n// the exact multiple. #1897.\nfunc ToFixed(v any, digits int) string {\n	if digits < 0 {\n		digits = 0\n	}\n	n := Number(v)\n	// JS toFixed returns the strings "NaN" / "Infinity" / "-Infinity" for\n	// non-finite inputs; fmt would render "NaN"/"+Inf"/"-Inf".\n	if math.IsNaN(n) {\n		return "NaN"\n	}\n	if math.IsInf(n, 1) {\n		return "Infinity"\n	}\n	if math.IsInf(n, -1) {\n		return "-Infinity"\n	}\n	factor := math.Pow(10, float64(digits))\n	rounded := math.Floor(n*factor + 0.5)\n	return fmt.Sprintf("%.*f", digits, rounded/factor)\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Length lowers JS `.length`, matching JS semantics per receiver shape\n// (#2255): a slice/array/map counts ELEMENTS (`reflect.Value.Len`, same as\n// `Len` below), but a STRING counts UTF-16 CODE UNITS \u2014 JS\n// `String.prototype.length` counts UTF-16 code units, not bytes (Go\'s\n// native `len`) or codepoints. A codepoint outside the Basic Multilingual\n// Plane (astral, U+10000-U+10FFFF \u2014 e.g. \'\u{1F44D}\') is a surrogate PAIR in\n// UTF-16, so it counts as 2, not 1; `\'\u65E5\u672C\u8A9E\'` is 3 either way (BMP-only).\n// Routed from the `.length` member lowering\'s generic (non-array,\n// non-loop-slice) fallback \u2014 see `member()`\'s `bf_length` call site.\nfunc Length(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.Chan:\n		return rv.Len()\n	case reflect.String:\n		n := 0\n		for _, r := range rv.String() {\n			if r > 0xFFFF {\n				n += 2\n			} else {\n				n++\n			}\n		}\n		return n\n	default:\n		return 0\n	}\n}\n\n// IsValidElement lowers React/Hono-style `isValidElement(x)` \u2014 the "is this\n// a renderable element (not plain text)?" predicate the `Slot` component\'s\n// `asChild` pattern (#2266) uses to decide whether to merge props into a\n// child ELEMENT (`children.tag`/`children.props`) or fall back to rendering\n// `children` as-is. The JS runtime checks `\'tag\' in x && \'props\' in x`; on\n// Go SSR a passed-through JSX child is represented as pre-rendered markup\n// (a plain string) OR \u2014 where a struct/map shape carrying `Tag`/`Props`\n// (case-insensitively, mirroring `bf_get`\'s field lookup) is available \u2014 an\n// element-shaped value. A plain string/number/bool/nil is never a valid\n// element, so `isValidElement` must NOT be lowered as bare truthiness\n// (previously done via `renderConditionExpr`) \u2014 a truthy non-empty STRING\n// child wrongly took the element-merge branch and panicked dereferencing\n// `.Props` on a string (`can\'t evaluate field Props in type interface {}`).\nfunc IsValidElement(v any) bool {\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return false\n		}\n		rv = rv.Elem()\n	}\n	switch rv.Kind() {\n	case reflect.Map:\n		hasTag, hasProps := false, false\n		for _, k := range rv.MapKeys() {\n			key := fmt.Sprintf("%v", k.Interface())\n			if strings.EqualFold(key, "tag") {\n				hasTag = true\n			}\n			if strings.EqualFold(key, "props") {\n				hasProps = true\n			}\n		}\n		return hasTag && hasProps\n	case reflect.Struct:\n		return fieldByFoldedName(rv, "tag").IsValid() && fieldByFoldedName(rv, "props").IsValid()\n	default:\n		return false\n	}\n}\n\n// fieldByFoldedName finds a struct field by case-insensitive name match \u2014\n// shared by IsValidElement; mirrors getFieldValue\'s (bf_get) struct-branch\n// lookup so the two case-tolerant field resolutions stay consistent.\nfunc fieldByFoldedName(rv reflect.Value, name string) reflect.Value {\n	t := rv.Type()\n	for i := 0; i < t.NumField(); i++ {\n		if strings.EqualFold(t.Field(i).Name, name) {\n			return rv.Field(i)\n		}\n	}\n	return reflect.Value{}\n}\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  SameValueZero element search (matches\n//     the evaluator\'s `evalSameValueZero`/`evalIncludes` in eval.go,\n//     which back the serialized-callback path) \u2014 numeric types compare\n//     by value across int/float64 the way JS\'s single "number" type\n//     does, and NaN matches NaN (unlike `===`). This used to be\n//     `reflect.DeepEqual`, which is type-strict (`int(2)` != `float64(2)`)\n//     and never matches NaN to NaN; that diverged from the evaluator\'s\n//     `.includes` and from JS itself, so it was unified here.\n//   - string receiver:       strings.Contains substring search\n//\n// Anything else returns false (matches the JS semantic where\n// `.includes` is only defined on Array / TypedArray / String).\nfunc Includes(recv any, elem any) bool {\n	v := reflect.ValueOf(recv)\n	if v.Kind() == reflect.String {\n		// JS `String.prototype.includes` accepts only string args;\n		// non-string `elem` would TypeError in real JS but our\n		// callers have lowered through `convertExpressionToGo`\n		// where the arg type is whatever the template binds. Stringify\n		// via fmt to keep the helper total.\n		needle, ok := elem.(string)\n		if !ok {\n			needle = fmt.Sprintf("%v", elem)\n		}\n		return strings.Contains(v.String(), needle)\n	}\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return false\n	}\n	for i := 0; i < v.Len(); i++ {\n		if evalSameValueZero(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// clampSliceRange normalizes JS `.slice(start, end?)` bounds against a\n// receiver of `length` elements (runes, for the string branch of\n// `Slice` below; array elements, for the array branch) \u2014 shared so\n// both branches clamp identically.\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\nfunc clampSliceRange(length, start int, end []int) (int, int) {\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n	return start, stop\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A) AND\n// `String.prototype.slice(start, end?)` (the `string-slice`\n// divergence) \u2014 the adapter emits the same `bf_slice` call for both\n// receiver shapes (it can\'t disambiguate string vs. array at compile\n// time), so this helper dispatches at runtime on `reflect.Kind()`,\n// mirroring `Includes` above. The variadic `end` arg lets Go\n// template\'s call dispatcher pass either 2 or 3 arguments; an absent\n// end means "to length".\n//\n// String length/positions are measured in runes, not UTF-16 code\n// units \u2014 the same divergence boundary `padTo` already accepts\n// (differs from JS only for astral-plane input). `start >= end`\n// (after clamping) returns an empty result for either receiver.\n//\n// Any other receiver kind returns an empty `[]any`.\nfunc Slice(items any, start int, end ...int) any {\n	v := reflect.ValueOf(items)\n\n	if v.Kind() == reflect.String {\n		runes := []rune(v.String())\n		s, e := clampSliceRange(len(runes), start, end)\n		if s >= e {\n			return ""\n		}\n		return string(runes[s:e])\n	}\n\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	s, e := clampSliceRange(v.Len(), start, end)\n	if s >= e {\n		return []any{}\n	}\n	out := make([]any, 0, e-s)\n	for i := s; i < e; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// Flat flattens nested slices/arrays `depth` levels deep. Lowers\n// `Array.prototype.flat(depth?)` (#1448 Tier C). A `depth` of `-1` is the\n// `Infinity` sentinel (flatten fully); `0` (or negative-from-JS, already\n// normalised to 0 at compile time) returns a shallow copy. Non-array\n// elements are kept as-is (JS only flattens nested arrays). A non-array\n// receiver returns an empty `[]any`.\nfunc Flat(items any, depth int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		ev := reflect.ValueOf(el)\n		if depth != 0 && (ev.Kind() == reflect.Slice || ev.Kind() == reflect.Array) {\n			// `-1` (Infinity) recurses unbounded; a finite depth spends one level.\n			next := depth\n			if depth > 0 {\n				next = depth - 1\n			}\n			out = append(out, Flat(el, next)...)\n		} else {\n			out = append(out, el)\n		}\n	}\n	return out\n}\n\n// FlatDynamicDepth coerces `depth` via JS\'s `ToIntegerOrInfinity` and\n// flattens `items` that many levels. Lowers a DYNAMIC `.flat(depth)`\n// (#2094) \u2014 one whose depth isn\'t a compile-time literal, so (unlike\n// `Flat` above) the coercion happens here at render time instead of in the\n// parser.\n//\n// This is a SEPARATE helper from `Flat`/`bf_flat` \u2014 NOT a drop-in\n// replacement \u2014 because `Flat`\'s `depth int` parameter treats `-1` as a\n// compile-time SENTINEL meaning "flatten fully" (the parser\'s own\n// normalisation of a literal `Infinity`). A genuinely dynamic depth value\n// of `-1` means the JS-correct OPPOSITE: `Array.prototype.flat(-1)` never\n// recurses (same as `.flat(0)`, a shallow copy), because\n// `FlattenIntoArray` only recurses when `depth > 0`. Reusing `Flat`\'s int\n// contract for a raw dynamic value would silently invert that case, so\n// this function coerces FIRST \u2014 mapping a real `+Infinity` / huge finite\n// value to `Flat`\'s own `-1` sentinel, and a real negative value to `0` \u2014\n// and only then delegates to `Flat`\'s recursion.\n//\n// Coercion rules (JS `ToIntegerOrInfinity`, mirrored exactly; pinned by the\n// `flat_dynamic` golden-vector cases in\n// packages/adapter-tests/vectors/cases.ts):\n//   - the value converts via `ToNumber` first (numeric string / bool /\n//     number all coerce; see `flatDepthToFloat`);\n//   - a NaN result (including a non-numeric string) \u2192 `0`;\n//   - truncates toward zero (`2.7` \u2192 `2`);\n//   - negative \u2192 `0`;\n//   - `+Infinity` / a huge finite value \u2192 flattens fully.\nfunc FlatDynamicDepth(items any, depth any) []any {\n	return Flat(items, coerceFlatDepth(depth))\n}\n\n// coerceFlatDepth implements JS\'s `ToIntegerOrInfinity` for a dynamic\n// `.flat(depth)` argument, returning an int in `Flat`\'s own contract (`-1`\n// = unbounded, `>= 0` = that many levels).\nfunc coerceFlatDepth(depth any) int {\n	f, ok := flatDepthToFloat(depth)\n	if !ok || math.IsNaN(f) {\n		return 0\n	}\n	if math.IsInf(f, 1) {\n		return -1 // Flat\'s "flatten fully" sentinel\n	}\n	if math.IsInf(f, -1) {\n		return 0\n	}\n	trunc := math.Trunc(f)\n	if trunc < 0 {\n		return 0\n	}\n	// A huge finite depth behaves identically to "flatten fully" in\n	// practice \u2014 real data bottoms out at its actual nesting depth long\n	// before a counter this large would ever reach zero. Capping it here\n	// avoids an absurd countdown without needing a second sentinel.\n	if trunc > 1_000_000 {\n		return -1\n	}\n	return int(trunc)\n}\n\n// flatDepthToFloat converts a dynamic `.flat(depth)` argument to a float64,\n// mirroring JS\'s `ToNumber` across the value shapes a Go template data\n// model can carry (every numeric kind, bool, numeric string). `ok` is\n// false for a shape `ToNumber` can\'t coerce meaningfully (`nil`, or a\n// non-numeric string) \u2014 `coerceFlatDepth` treats that the same as NaN\n// (\u2192 depth `0`), matching JS.\nfunc flatDepthToFloat(v any) (float64, bool) {\n	switch n := v.(type) {\n	case nil:\n		return 0, false\n	case float64:\n		return n, true\n	case float32:\n		return float64(n), true\n	case int:\n		return float64(n), true\n	case int8:\n		return float64(n), true\n	case int16:\n		return float64(n), true\n	case int32:\n		return float64(n), true\n	case int64:\n		return float64(n), true\n	case uint:\n		return float64(n), true\n	case uint8:\n		return float64(n), true\n	case uint16:\n		return float64(n), true\n	case uint32:\n		return float64(n), true\n	case uint64:\n		return float64(n), true\n	case bool:\n		if n {\n			return 1, true\n		}\n		return 0, true\n	case string:\n		s := strings.TrimSpace(n)\n		if s == "" {\n			return 0, true // JS: Number("") is 0\n		}\n		f, err := strconv.ParseFloat(s, 64)\n		if err != nil {\n			return 0, false // not numeric \u2192 NaN path\n		}\n		return f, true\n	default:\n		return 0, false\n	}\n}\n\n// FlatMap projects each element through a `self` / `field` projection and\n// flattens the result one level. Lowers value-returning\n// `Array.prototype.flatMap(fn)` for the field-projection catalogue\n// (#1448 Tier C): `items.flatMap(i => i)` (self) and\n// `items.flatMap(i => i.field)` (field). A projected non-array value is\n// kept as-is (flatMap = map + flat(1)). Non-array receiver \u2192 empty.\nfunc FlatMap(items any, keyKind, keyName string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	projected := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		if keyKind == "field" {\n			projected = append(projected, getFieldValue(el, keyName))\n		} else {\n			projected = append(projected, el)\n		}\n	}\n	return Flat(projected, 1)\n}\n\n// FlatMapTuple lowers an array-literal flatMap projection\n// `items.flatMap(i => [i.a, i.b])` (#1448 Tier C). `specs` is a flat list\n// of (kind, name) pairs, one per array-literal leaf: ("self", "") for the\n// item itself, ("field", "<Name>") for a struct field. For each item it\n// appends every leaf\'s value in order. Unlike the scalar `FlatMap`, the\n// per-item array is flattened only one level (flat(1) removes the literal\n// wrapper), so an array-valued leaf is appended verbatim rather than\n// spread \u2014 which is exactly "append each leaf". Non-array receiver \u2192 empty.\nfunc FlatMapTuple(items any, specs ...string) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	out := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		el := v.Index(i).Interface()\n		for j := 0; j+1 < len(specs); j += 2 {\n			if specs[j] == "field" {\n				out = append(out, getFieldValue(el, specs[j+1]))\n			} else {\n				out = append(out, el)\n			}\n		}\n	}\n	return out\n}\n\n// First returns the first element of a slice, or nil if empty.\nfunc First(items any) any {\n	return At(items, 0)\n}\n\n// Last returns the last element of a slice, or nil if empty.\nfunc Last(items any) any {\n	return At(items, -1)\n}\n\n// Arr builds an []any from variadic args. Used to lower JS array\n// literals like `[a, b]` for the registry Slot\'s\n// `[className, childClass].filter(Boolean).join(\' \')` shape (#1443) \u2014\n// Go templates have no array-literal syntax, so the codegen routes\n// array-literal IR nodes through this helper.\nfunc Arr(items ...any) []any {\n	return items\n}\n\n// FilterTruthy returns a new slice containing only truthy items.\n// Mirrors `arr.filter(Boolean)` semantics: drop nil, false, 0, "" \u2014 the\n// same falsy set JavaScript\'s `Boolean(x)` recognises. Used to lower\n// the registry Slot\'s class-merge pattern (#1443); generalising to\n// arbitrary callable predicates would need the callee-resolution path\n// blocked by #1389, so this stays Boolean-specific.\nfunc FilterTruthy(items any) []any {\n	v := reflect.ValueOf(items)\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	result := make([]any, 0, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		raw := v.Index(i).Interface()\n		if isTruthy(raw) {\n			result = append(result, raw)\n		}\n	}\n	return result\n}\n\n// Truthy is the exported form of isTruthy \u2014 JavaScript\'s `Boolean(x)`\n// semantics. Two callers:\n//   - generated `NewXxxProps` code lowering a conditional inline-object\n//     spread condition on an `interface{}` prop (whose runtime value may be\n//     a string, number, bool, \u2026), keeping the spread bag\'s inclusion test\n//     faithful to JS rather than string-biased (#1752); and\n//   - the `bf_truthy` template FuncMap entry (#2335), which coerces a\n//     `bf_ternary` test to a real bool when it isn\'t already a comparison /\n//     negation (`Ternary`\'s `cond` parameter is typed `bool`, unlike\n//     `{{if}}`\'s built-in truthiness). Uniform across string/number/bool/nil,\n//     so a `bf_ternary` test on any prop type can\'t hit a `bool`-vs-`string`\n//     comparison error the way a string-only `ne <value> ""` would.\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// ScopeCommentEnd emits the paired end marker for a fragment-rooted scope\n// (#2289): a fragment root has no single wrapping element to bound the\n// client\'s scope query, so the range leaks onto later siblings without an\n// explicit terminator. Carries only the scope id \u2014 no `|h=`/`|m=`/props\n// segment, unlike ScopeComment \u2014 since the client only needs it to confirm\n// the range closes on the matching scope (getCommentScopeBoundary in\n// packages/client/src/runtime/scope.ts).\nfunc ScopeCommentEnd(props interface{}) template.HTML {\n	scopeID := getStringField(props, "ScopeID")\n	return template.HTML("<!--bf-/scope:" + scopeID + "-->")\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// WithProps returns a shallow copy of a component Props struct with the\n// given fields overridden (#2445): a child component nested inside a\n// COMPOSITE loop row (row root is a plain element, not the child itself) is\n// constructed ONCE outside `{{range}}` \u2014 every row shares that instance for\n// scope/parent/mount identity \u2014 so a prop that depends on the row\n// (`text={row.label}`) has to be applied per row, at template-execution\n// time, the same way WithChildren applies per-row JSX children to that\n// shared instance. `kv` is a flat name/value list ("Text", .Label, "Count",\n// .N, ...). The props value stays by-value semantics: the caller\'s original\n// is untouched. A name with no matching settable field is left alone for\n// that pair \u2014 the prop routes elsewhere (e.g. a rest bag) and the base\n// instance\'s constructor-built value stands, mirroring WithChildren\'s\n// "props type without a Children field" passthrough.\n//\n// This overrides fields on the ALREADY-CONSTRUCTED instance \u2014 it does not\n// re-run New<Child>Props. A field the child derives FROM the overridden prop\n// at construction time (a memo body, or a signal\'s initial value \u2014 the\n// constructor bakes both) would keep whatever the one-shot constructor\n// computed and never update per row; only the directly-overridden field is\n// correct per row. The compiler therefore does not route that case here: a\n// child with any constructor-derived field gets a generated props rebuilder\n// and the call site emits bf_reprops instead, which re-runs the real\n// constructor per row (#2448, see reprops.go). What reaches this helper is\n// the plain-passthrough case, where patching the field IS the whole update.\n//\n// Still exported and still registered: templates generated before #2448 call\n// it, and it remains the cheaper path when nothing is derived.\nfunc WithProps(props interface{}, kv ...interface{}) (interface{}, error) {\n	if len(kv)%2 != 0 {\n		return nil, fmt.Errorf("bf_with_props: odd number of key/value arguments (%d)", len(kv))\n	}\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	copyPtr := reflect.New(v.Type())\n	copyPtr.Elem().Set(v)\n	for i := 0; i < len(kv); i += 2 {\n		name, ok := kv[i].(string)\n		if !ok {\n			return nil, fmt.Errorf("bf_with_props: field name at position %d must be a string, got %T", i, kv[i])\n		}\n		target := copyPtr.Elem().FieldByName(name)\n		if !target.IsValid() || !target.CanSet() {\n			continue\n		}\n		if err := setStructFieldValue(target, kv[i+1]); err != nil {\n			return nil, fmt.Errorf("bf_with_props: field %s: %w", name, err)\n		}\n	}\n	return copyPtr.Elem().Interface(), nil\n}\n\n// setStructFieldValue assigns val into target, a settable struct field\n// obtained via reflect.Value.FieldByName. Mirrors WithChildren\'s\n// Interface/String branches (a String-kind target covers both `string` and\n// `template.HTML` fields, via String() rather than reflect.Convert \u2014 Go\'s\n// int-to-string conversion produces a rune, not a decimal string) and adds\n// the general assignable/convertible fallback for other field kinds\n// (numeric widening, etc.).\nfunc setStructFieldValue(target reflect.Value, val interface{}) error {\n	if val == nil {\n		target.Set(reflect.Zero(target.Type()))\n		return nil\n	}\n	switch {\n	case target.Kind() == reflect.Interface:\n		target.Set(reflect.ValueOf(val))\n		return nil\n	case target.Kind() == reflect.String:\n		target.SetString(String(val))\n		return nil\n	}\n	rv := reflect.ValueOf(val)\n	switch {\n	case rv.Type().AssignableTo(target.Type()):\n		target.Set(rv)\n	case rv.Type().ConvertibleTo(target.Type()):\n		target.Set(rv.Convert(target.Type()))\n	default:\n		return fmt.Errorf("cannot assign %T to %s", val, target.Type())\n	}\n	return nil\n}\n\n// PortalHTML parses and executes a template string with the provided data.\n// Used for rendering dynamic portal content where the template string\n// contains Go template expressions (e.g., {{if .Open}}open{{end}}).\n//\n// The template string is parsed fresh each time to support dynamic content.\n// Standard Go template functions (if, range, eq, etc.) are available.\nfunc PortalHTML(data interface{}, tmplStr string) template.HTML {\n	// Create a new template with the FuncMap for custom functions\n	t, err := template.New("portal").Funcs(FuncMap()).Parse(tmplStr)\n	if err != nil {\n		// Return error message as HTML comment for debugging\n		return template.HTML("<!-- bfPortalHTML error: " + err.Error() + " -->")\n	}\n\n	var buf bytes.Buffer\n	if err := t.Execute(&buf, data); err != nil {\n		return template.HTML("<!-- bfPortalHTML exec error: " + err.Error() + " -->")\n	}\n\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Portal Collection\n// =============================================================================\n\n// PortalContent represents a single portal\'s content to be rendered at body end.\ntype PortalContent struct {\n	ID      string        // Unique portal ID for hydration matching\n	OwnerID string        // Owner scope ID for find() support\n	Content template.HTML // Portal HTML content\n}\n\n// PortalCollector collects portal content during template rendering.\n// Portal content is rendered at </body> to avoid z-index issues.\ntype PortalCollector struct {\n	portals []PortalContent\n	counter int\n}\n\n// NewPortalCollector creates a new PortalCollector.\nfunc NewPortalCollector() *PortalCollector {\n	return &PortalCollector{\n		portals: []PortalContent{},\n		counter: 0,\n	}\n}\n\n// Add registers portal content to be rendered at body end.\nfunc (pc *PortalCollector) Add(ownerID string, content template.HTML) string {\n	pc.counter++\n	id := "bf-portal-" + strconv.Itoa(pc.counter)\n	pc.portals = append(pc.portals, PortalContent{\n		ID:      id,\n		OwnerID: ownerID,\n		Content: content,\n	})\n	return "" // Return empty string for template use\n}\n\n// Render outputs all collected portals as HTML.\n// Each portal is wrapped in a div with bf-pi (portal ID) and bf-po (portal owner).\nfunc (pc *PortalCollector) Render() template.HTML {\n	if pc == nil || len(pc.portals) == 0 {\n		return ""\n	}\n	var buf strings.Builder\n	for _, p := range pc.portals {\n		buf.WriteString(`<div bf-pi="`)\n		buf.WriteString(p.ID)\n		buf.WriteString(`" bf-po="`)\n		buf.WriteString(p.OwnerID)\n		buf.WriteString(`">`)\n		buf.WriteString(string(p.Content))\n		buf.WriteString("</div>\\n")\n	}\n	return template.HTML(buf.String())\n}\n\n// =============================================================================\n// Script Collection\n// =============================================================================\n\n// ScriptCollector collects client scripts with deduplication.\n// It preserves insertion order for deterministic output.\ntype ScriptCollector struct {\n	scripts map[string]bool\n	order   []string\n}\n\n// NewScriptCollector creates a new ScriptCollector.\nfunc NewScriptCollector() *ScriptCollector {\n	return &ScriptCollector{\n		scripts: make(map[string]bool),\n		order:   []string{},\n	}\n}\n\n// Register adds a script source to the collection.\n// Duplicate scripts are ignored (only first registration counts).\nfunc (sc *ScriptCollector) Register(src string) string {\n	if sc.scripts[src] {\n		return "" // Already registered\n	}\n	sc.scripts[src] = true\n	sc.order = append(sc.order, src)\n	return "" // Return empty string for template use\n}\n\n// Scripts returns all registered scripts in insertion order.\nfunc (sc *ScriptCollector) Scripts() []string {\n	return sc.order\n}\n\n// BfScripts generates script tags for all registered scripts.\n// Returns HTML safe for embedding in templates.\nfunc BfScripts(collector *ScriptCollector) template.HTML {\n	if collector == nil {\n		return ""\n	}\n	var result strings.Builder\n	for _, src := range collector.Scripts() {\n		result.WriteString(`<script type="module" src="`)\n		result.WriteString(src)\n		result.WriteString(`"></script>`)\n		result.WriteString("\\n")\n	}\n	return template.HTML(result.String())\n}\n\n// =============================================================================\n// Component Renderer\n// =============================================================================\n\n// RenderContext contains all data needed to render a component page.\n// The layout function receives this context to build the final HTML.\ntype RenderContext struct {\n	// ComponentName is the template name being rendered\n	ComponentName string\n\n	// Props is the component props (for layout to access if needed)\n	Props interface{}\n\n	// ComponentHTML is the rendered component template output\n	ComponentHTML template.HTML\n\n	// Portals contains collected portal content to render at body end\n	Portals template.HTML\n\n	// Scripts contains the collected JS script tags\n	Scripts template.HTML\n\n	// Title is the page title (defaults to "{ComponentName} - BarefootJS")\n	Title string\n\n	// Heading is the page heading. Empty string means no heading.\n	Heading string\n\n	// Extra holds additional user-defined data for the layout\n	Extra map[string]interface{}\n}\n\n// LayoutFunc renders the final HTML page given the render context.\ntype LayoutFunc func(ctx *RenderContext) string\n\n// Renderer renders BarefootJS components with a customizable layout.\ntype Renderer struct {\n	templates *template.Template\n	layout    LayoutFunc\n}\n\n// NewRenderer creates a Renderer with the given templates and layout function.\n//\n// Example usage:\n//\n//	renderer := bf.NewRenderer(templates, func(ctx *bf.RenderContext) string {\n//	    return fmt.Sprintf(`<!DOCTYPE html>\n//	<html>\n//	<head><title>%s</title></head>\n//	<body>%s%s</body>\n//	</html>`, ctx.Title, ctx.ComponentHTML, ctx.Scripts)\n//	})\nfunc NewRenderer(tmpl *template.Template, layout LayoutFunc) *Renderer {\n	return &Renderer{\n		templates: tmpl,\n		layout:    layout,\n	}\n}\n\n// RenderOptions configures a single render call.\ntype RenderOptions struct {\n	// ComponentName is the template name to render (required)\n	ComponentName string\n\n	// Props is the component props (must be a pointer to struct with Scripts field)\n	Props interface{}\n\n	// Title is the page title. If empty, defaults to "{ComponentName} - BarefootJS"\n	Title string\n\n	// Heading is the page heading. If empty, no heading is shown.\n	Heading string\n\n	// Extra holds additional data to pass to the layout\n	Extra map[string]interface{}\n}\n\n// Render renders a component to a full HTML page using the configured layout.\n// Child component props are automatically detected (any slice field with ScopeID/Scripts).\n// renderTemplateErrorPanel formats a Go template execution error into a\n// fragment of HTML that\'s visible in the browser. The panel is\n// HTML-escaped so a faulty template name (anything from `template:\n// "..."`) can\'t smuggle markup back into the page. Keep the styling\n// inline so the panel surfaces even when the project\'s CSS hasn\'t\n// loaded yet (e.g. the failure aborted before the stylesheet links\n// emitted).\n//\n// Surfaced for the #1442 echo repro: a template referencing\n// `.Todo.Done` (instead of the range dot\'s `.Done`) used to fail\n// silently \u2014 Go\'s html/template aborted mid-stream, the partial body\n// flushed as a 200, and the user saw a truncated list with no console\n// signal. With this panel they get the template name, the error\n// message, and a "what to look at" hint inline.\nfunc renderTemplateErrorPanel(componentName string, err error) string {\n	return `<div style="margin:1em 0;padding:1em;border:2px solid #d33;background:#fff5f5;color:#900;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:13px;line-height:1.5"><strong style="display:block;margin-bottom:.5em">Template error in <code>` +\n		template.HTMLEscapeString(componentName) +\n		`</code></strong><pre style="margin:0;white-space:pre-wrap;word-break:break-word">` +\n		template.HTMLEscapeString(err.Error()) +\n		`</pre><div style="margin-top:.75em;font-size:12px;opacity:.7">Common cause: a JSX expression referenced a name the adapter could not resolve to a struct field. Open the matching <code>dist/templates/*.tmpl</code> for the unresolved reference, then fix the source component.</div></div>`\n}\n\n// renderComponentInto wires a component\'s props (script/portal collectors,\n// child-slot scope ids + hydration, root marking) against the PROVIDED\n// collectors and returns just the component\'s HTML \u2014 no layout. Both Render\n// (one fresh collector pair per page) and RenderFragment (a shared pair across\n// several islands) funnel through here so their wiring stays identical.\nfunc (r *Renderer) renderComponentInto(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	// Inject the shared collectors into the props.\n	setScriptsField(opts.Props, scriptCollector)\n	setPortalsField(opts.Props, portalCollector)\n\n	// Auto-detect and process child component props (slices)\n	childSlices := findChildComponentSlices(opts.Props)\n	for _, slice := range childSlices {\n		setScopeIDsOnSlice(slice)\n		setScriptsOnSlice(slice, scriptCollector)\n		setPortalsOnSlice(slice, portalCollector)\n		setBoolOnSlice(slice, "BfIsChild", true)\n	}\n\n	// Auto-detect and process single child component props\n	singleChildren := findSingleChildComponents(opts.Props)\n	for _, child := range singleChildren {\n		setScopeIDOnSingle(child)\n		setScriptsOnSingle(child, scriptCollector)\n		setPortalsOnSingle(child, portalCollector)\n		setBoolField(child, "BfIsChild", true)\n	}\n\n	// Mark the root component so BfPropsAttr emits bf-p only for it\n	setBoolField(opts.Props, "BfIsRoot", true)\n\n	// Render the component template.\n	//\n	// Errors here are NOT silently dropped. The original implementation\n	// ignored the return value of `ExecuteTemplate`, which masked a real\n	// onboarding failure mode: a template referencing a non-existent\n	// field (`.Todo.Done` instead of the range dot\'s `.Done`) caused\n	// html/template to abort mid-stream, the partial output got\n	// returned, and the HTTP server happily flushed a 200 with a\n	// truncated body. No error log, no signal \u2014 the user just saw a\n	// blank list (#1442 echo TodoApp repro).\n	//\n	// Now we capture the error and replace the partial output with a\n	// visible inline panel (dev mode) or a fenced error comment\n	// (production), so the cause is on-screen and grep-able in logs.\n	// Either way the renderer also writes to stderr so structured log\n	// aggregators see it.\n	var componentBuf strings.Builder\n	if err := r.templates.ExecuteTemplate(&componentBuf, opts.ComponentName, opts.Props); err != nil {\n		fmt.Fprintf(os.Stderr, "barefoot: template %q failed to render: %v\\n", opts.ComponentName, err)\n		// Preserve whatever the template did manage to emit before\n		// failing (Go\'s text/template flushes incrementally), but\n		// follow it with a clearly-marked error block so the user\n		// notices something is wrong instead of seeing a silent\n		// truncation.\n		componentBuf.WriteString(renderTemplateErrorPanel(opts.ComponentName, err))\n	}\n\n	return template.HTML(componentBuf.String())\n}\n\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// One script + portal collector pair for the whole page.\n	scriptCollector := NewScriptCollector()\n	portalCollector := NewPortalCollector()\n\n	componentHTML := r.renderComponentInto(opts, scriptCollector, portalCollector)\n\n	// Determine title (default: "{ComponentName} - BarefootJS")\n	title := opts.Title\n	if title == "" {\n		title = opts.ComponentName + " - BarefootJS"\n	}\n\n	// Heading (empty means no heading)\n	heading := opts.Heading\n\n	// Build render context\n	ctx := &RenderContext{\n		ComponentName: opts.ComponentName,\n		Props:         opts.Props,\n		ComponentHTML: componentHTML,\n		Portals:       portalCollector.Render(),\n		Scripts:       BfScripts(scriptCollector),\n		Title:         title,\n		Heading:       heading,\n		Extra:         opts.Extra,\n	}\n\n	return r.layout(ctx)\n}\n\n// RenderFragment renders a single island subtree into the caller-provided\n// script and portal collectors and returns just its HTML \u2014 no page layout.\n//\n// It exists for hand-authored "region shell" pages (the `@barefootjs/router`\n// showcase): a layout that places several independent islands \u2014 e.g. a header\n// ThemeToggle, an `<aside bf-region>` Sidebar, and a `<PageShell>` wrapping the\n// route content \u2014 must collect ALL their scripts and portals into ONE place so\n// the runtime (`barefoot.js`) and each island\'s client JS are emitted exactly\n// once and share a single reactive instance. Render each island with the same\n// collectors, splice the returned HTML into the shell, then emit\n// `BfScripts(sc)` and `pc.Render()` once at the end of the document.\n//\n// Each fragment is treated as its own root (it emits `bf-p` like any top-level\n// island); nested children declared in its props are wired as children, exactly\n// as in Render.\nfunc (r *Renderer) RenderFragment(opts RenderOptions, scriptCollector *ScriptCollector, portalCollector *PortalCollector) template.HTML {\n	return r.renderComponentInto(opts, scriptCollector, portalCollector)\n}\n\n// setScriptsField sets the Scripts field on a struct using reflection.\nfunc setScriptsField(v interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Scripts")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// setPortalsField sets the Portals field on a struct using reflection.\nfunc setPortalsField(v interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return\n	}\n	field := val.FieldByName("Portals")\n	if field.IsValid() && field.CanSet() {\n		field.Set(reflect.ValueOf(collector))\n	}\n}\n\n// getStringField extracts a string field from a struct using reflection.\nfunc setBoolField(v interface{}, fieldName string, val bool) {\n	rv := reflect.ValueOf(v)\n	if rv.Kind() == reflect.Ptr {\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Struct {\n		return\n	}\n	field := rv.FieldByName(fieldName)\n	if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n		field.SetBool(val)\n	}\n}\n\nfunc getBoolField(v interface{}, fieldName string) bool {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return false\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.Bool {\n		return false\n	}\n	return field.Bool()\n}\n\nfunc getStringField(v interface{}, fieldName string) string {\n	val := reflect.ValueOf(v)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return ""\n	}\n	field := val.FieldByName(fieldName)\n	if !field.IsValid() || field.Kind() != reflect.String {\n		return ""\n	}\n	return field.String()\n}\n\n// scopeIDChars is the alphabet for auto-generated ScopeID suffixes. It\n// mirrors the `randomID` helper the go-template adapter emits into the\n// generated New<Component>Props constructors so runtime-assigned and\n// constructor-assigned ids are indistinguishable.\nconst scopeIDChars = "abcdefghijklmnopqrstuvwxyz0123456789"\n\n// randomScopeSuffix returns a random lowercase-alphanumeric string of\n// length n. math/rand (auto-seeded since Go 1.20) is sufficient here: the\n// suffix only needs to be unique enough to keep a page\'s bf-s scope ids\n// from colliding, not cryptographically unpredictable.\nfunc randomScopeSuffix(n int) string {\n	b := make([]byte, n)\n	for i := range b {\n		b[i] = scopeIDChars[rand.Intn(len(scopeIDChars))]\n	}\n	return string(b)\n}\n\n// scopeIDPrefix derives the human-readable ScopeID prefix from a child\n// component\'s type, e.g. `TodoItemProps` \u2192 `TodoItem`. Matches the\n// `"<Component>_" + randomID(6)` shape the generated constructors use.\nfunc scopeIDPrefix(t reflect.Type) string {\n	for t.Kind() == reflect.Ptr {\n		t = t.Elem()\n	}\n	return strings.TrimSuffix(t.Name(), "Props")\n}\n\n// assignScopeID fills a child component\'s ScopeID with a generated id when\n// the caller left it empty, so application code doesn\'t have to mint scope\n// ids by hand (the parent\'s New<Component>Props constructor does the same\n// for components built through it). A non-empty ScopeID is left untouched,\n// so callers can still pin a stable id when they need one.\nfunc assignScopeID(structVal reflect.Value, prefix string) {\n	field := structVal.FieldByName("ScopeID")\n	if !field.IsValid() || !field.CanSet() || field.Kind() != reflect.String {\n		return\n	}\n	if field.String() != "" {\n		return\n	}\n	id := randomScopeSuffix(6)\n	if prefix != "" {\n		id = prefix + "_" + id\n	}\n	field.SetString(id)\n}\n\n// setScopeIDsOnSlice assigns a generated ScopeID to every child in a slice\n// whose ScopeID is empty.\nfunc setScopeIDsOnSlice(slice interface{}) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	prefix := scopeIDPrefix(v.Type().Elem())\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			assignScopeID(item, prefix)\n		}\n	}\n}\n\n// setScopeIDOnSingle assigns a generated ScopeID to a single child\n// component when its ScopeID is empty.\nfunc setScopeIDOnSingle(child interface{}) {\n	v := reflect.ValueOf(child)\n	if v.Kind() == reflect.Ptr {\n		v = v.Elem()\n	}\n	if v.Kind() != reflect.Struct {\n		return\n	}\n	assignScopeID(v, scopeIDPrefix(v.Type()))\n}\n\n// findChildComponentSlices finds slice fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findChildComponentSlices(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n		if field.Kind() != reflect.Slice || field.Len() == 0 {\n			continue\n		}\n\n		elem := field.Index(0)\n		if elem.Kind() == reflect.Ptr {\n			elem = elem.Elem()\n		}\n		if elem.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := elem.FieldByName("ScopeID").IsValid()\n		hasScripts := elem.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSlice sets Scripts on all items in a slice.\nfunc setScriptsOnSlice(slice interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Scripts")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// setBoolOnSlice sets a bool field on all items in a slice.\nfunc setBoolOnSlice(slice interface{}, fieldName string, val bool) {\n	v := reflect.ValueOf(slice)\n	if v.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName(fieldName)\n			if field.IsValid() && field.CanSet() && field.Kind() == reflect.Bool {\n				field.SetBool(val)\n			}\n		}\n	}\n}\n\n// setPortalsOnSlice sets Portals on all items in a slice.\nfunc setPortalsOnSlice(slice interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(slice)\n	if val.Kind() != reflect.Slice {\n		return\n	}\n	for i := 0; i < val.Len(); i++ {\n		item := val.Index(i)\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Struct {\n			field := item.FieldByName("Portals")\n			if field.IsValid() && field.CanSet() {\n				field.Set(reflect.ValueOf(collector))\n			}\n		}\n	}\n}\n\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// Nullish implements JS `??` for template use (`bf_nullish`, #2248): returns\n// fallback iff v is nil (untyped nil or a nil pointer/map/slice boxed in the\n// interface), otherwise v \u2014 so present-but-falsy `""`/`0`/`false` are KEPT,\n// unlike the truthiness-based template `or`.\nfunc Nullish(v, fallback any) any {\n	if v == nil {\n		return fallback\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Interface, reflect.Func, reflect.Chan:\n		if rv.IsNil() {\n			return fallback\n		}\n	}\n	return v\n}\n\n// ToInt exposes the runtime\'s numeric coercion for generated constructors\n// (#2248): a nillable-lowered numeric prop arrives as `interface{}`, and an\n// untyped Go literal (`Size: 3`) boxes as int even when the prop is\n// float64-shaped \u2014 a direct type assertion would panic where JS accepts the\n// number. Non-numeric values coerce to 0, matching the helpers\' behaviour.\nfunc ToInt(v any) int { return toInt(v) }\n\n// ToFloat64 is ToInt\'s float64 counterpart \u2014 see ToInt.\nfunc ToFloat64(v any) float64 { return toFloat64(v) }\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		rv := reflect.ValueOf(v)\n		if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {\n			// JS `Array.prototype.toString` is `this.join(\',\')`, applied\n			// recursively \u2014 a nested array element stringifies the same\n			// way rather than via Go\'s `%v`. Reached via `Join`/`ConcatStr`\n			// on an element that is itself an array (e.g. `.flat(0)`\'s\n			// shallow copy joined afterwards, #2262).\n			parts := make([]string, rv.Len())\n			for i := 0; i < rv.Len(); i++ {\n				parts[i] = toString(rv.Index(i).Interface())\n			}\n			return strings.Join(parts, ",")\n		}\n		return ""\n	}\n}\n\n// =============================================================================\n// searchParams() \u2014 request-scoped environment signal (router v0.5, #1922)\n// =============================================================================\n\n// SearchParams is the SSR view of the request query string behind the\n// reactive searchParams() environment signal. The route handler builds it\n// from the request URL and assigns it to the component\'s SearchParams input\n// field; the generated template reads it via `.SearchParams.Get "key"`.\n//\n// The zero value is an empty query (url.Values.Get tolerates a nil map), so a\n// render with no request query \u2014 e.g. the adapter conformance harness, which\n// issues no query string \u2014 resolves every key to "", which the template\'s\n// `or`/`??` fallback turns into the author\'s default.\ntype SearchParams struct {\n	values url.Values\n}\n\n// NewSearchParams parses a raw query string (with or without a leading "?")\n// into a SearchParams. A malformed query yields an empty set rather than an\n// error, mirroring the browser\'s URLSearchParams, which never throws on junk.\n//\n// Typical handler use (net/http):\n//\n//	in := MyComponentInput{SearchParams: bf.NewSearchParams(r.URL.RawQuery)}\nfunc NewSearchParams(raw string) SearchParams {\n	raw = strings.TrimPrefix(raw, "?")\n	values, err := url.ParseQuery(raw)\n	if err != nil {\n		values = url.Values{}\n	}\n	return SearchParams{values: values}\n}\n\n// Get returns the first value associated with key, or "" when the key is\n// absent. This mirrors url.Values.Get, which also returns "" for a\n// present-but-empty value (`?sort=`). Safe on the zero value (nil map).\n//\n// This is not byte-for-byte URLSearchParams.get under the template\'s `??`\n// lowering. JS distinguishes absent (`null`) from present-but-empty (`""`):\n// `null ?? d` yields the default, but `"" ?? d` keeps the empty string. The\n// Go adapter lowers `??` to the `or` builtin \u2014 Go templates have no\n// null-coalescing operator \u2014 so here BOTH an absent key and a present-but-\n// empty value fall back to the author\'s default. The conformance fixture only\n// exercises the absent-key default, where the two runtimes agree; the\n// empty-string divergence is the same general `?? \u2192 or` limitation that\n// applies to any `x ?? default` the Go adapter lowers.\nfunc (s SearchParams) Get(key string) string {\n	return s.values.Get(key)\n}\n';
     evalGoSource = 'package bf\n\nimport (\n	"encoding/json"\n	"errors"\n	"math"\n	"reflect"\n	"regexp"\n	"sort"\n	"strconv"\n	"strings"\n	"unicode/utf8"\n)\n\n// =============================================================================\n// Lightweight ParsedExpr evaluator (issue #2018)\n// =============================================================================\n//\n// Templates cannot carry a lambda in expression position, which is why the\n// adapter historically special-cased higher-order callbacks (reduce / sort /\n// map / filter / find) into fixed shapes (bf_sort\'s comparator catalogue,\n// bf_reduce\'s +/* fold). This evaluator replaces that ad-hoc list: a callback\n// BODY is carried as a pure `ParsedExpr` subtree (the same structured IR the\n// compiler already produces) and evaluated here against an environment\n// (`{acc, item, \u2026captured free vars}`).\n//\n// Scope: higher-order callback bodies only. Ordinary expressions stay lowered\n// to template-native syntax \u2014 this is NOT a general expression engine.\n//\n// The accepted pure subset and its semantics (evaluation order, coercion,\n// equality, allowed operators / builtins) are documented in spec/compiler.md\n// ("ParsedExpr Evaluator Semantics") and pinned isomorphically by the golden\n// vectors in packages/adapter-tests/vectors/eval-vectors.json (shared\n// with the Perl evaluator). The coercion rules below are the literal JS rules\n// (ToNumber / ToString / ToBoolean) \u2014 deliberately NOT the divergent\n// bf->string / bf_reduce helper conventions \u2014 so the contract is unambiguous\n// and the backends stay byte-isomorphic.\n//\n// String semantics operate on Unicode code points / UTF-8 bytes: `.length`\n// counts code points and relational `<`/`>` compares byte order. This equals\n// the JS reference (UTF-16 code units) across the BMP \u2014 the range template\n// data uses \u2014 and matches the Perl evaluator exactly (the primary "same input\n// \u2192 same output" contract is between the two SSR backends). Astral-plane\n// characters (where JS counts a surrogate pair as length 2 and orders by\n// surrogate code units) are a documented divergence region, alongside the\n// already-documented non-ASCII relational / localeCompare carve-outs\n// (spec/compiler.md). Both backends stay equal; only the JS reference differs,\n// and no corpus vector exercises the astral range.\n\n// EvalExpr evaluates a pure ParsedExpr (carried as its JSON encoding) against\n// env. The result is a value in the JSON domain: a number (Go int or float64 \u2014\n// both are the single JS number type; e.g. `.length` returns int, arithmetic\n// returns float64), string, bool, nil, []any, or map[string]any. A malformed\n// tree yields nil.\nfunc EvalExpr(exprJSON string, env map[string]any) any {\n	var node any\n	if err := json.Unmarshal([]byte(exprJSON), &node); err != nil {\n		return nil\n	}\n	return EvalNode(node, env)\n}\n\n// EvalNode evaluates an already-decoded ParsedExpr node (a map[string]any with\n// a "kind" discriminator) against env. Exported so callers that already hold a\n// decoded tree (e.g. the golden-vector harness) skip a re-marshal.\nfunc EvalNode(node any, env map[string]any) any {\n	n, ok := node.(map[string]any)\n	if !ok {\n		return nil\n	}\n	kind, _ := n["kind"].(string)\n	switch kind {\n	case "literal":\n		return n["value"]\n\n	case "identifier":\n		name, _ := n["name"].(string)\n		return env[name]\n\n	case "binary":\n		op, _ := n["op"].(string)\n		return evalBinary(op, EvalNode(n["left"], env), EvalNode(n["right"], env))\n\n	case "unary":\n		op, _ := n["op"].(string)\n		return evalUnary(op, EvalNode(n["argument"], env))\n\n	case "logical":\n		op, _ := n["op"].(string)\n		left := EvalNode(n["left"], env)\n		switch op {\n		case "&&":\n			if !evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "||":\n			if evalTruthy(left) {\n				return left\n			}\n			return EvalNode(n["right"], env)\n		case "??":\n			if left == nil {\n				return EvalNode(n["right"], env)\n			}\n			return left\n		}\n		return nil\n\n	case "conditional":\n		if evalTruthy(EvalNode(n["test"], env)) {\n			return EvalNode(n["consequent"], env)\n		}\n		return EvalNode(n["alternate"], env)\n\n	case "member":\n		prop, _ := n["property"].(string)\n		return evalReadProperty(EvalNode(n["object"], env), prop)\n\n	case "index-access":\n		return evalReadIndex(EvalNode(n["object"], env), EvalNode(n["index"], env))\n\n	case "call":\n		// A nested `.map(cb)` / `.filter(cb)` callback call (#2094): syntactically\n		// a `call` whose callee is `<recv>.map`/`<recv>.filter` and whose first\n		// argument is an `arrow` \u2014 the SAME shape `asCallbackMethodCall`\n		// recognizes at compile time, and the shape the `eval-vectors.json`\n		// golden corpus itself carries (it stores the genuine `ParsedExpr`, not\n		// a bespoke wrapper). Checked BEFORE the builtin-callee gate below,\n		// since `<recv>.map` would otherwise resolve to a non-builtin member\n		// callee and refuse.\n		if method, objNode, arrowNode, ok := evalArrayCallbackCall(n); ok {\n			return evalArrayCallback(method, objNode, arrowNode, env)\n		}\n		name := evalBuiltinName(n["callee"])\n		if name == "" {\n			return nil\n		}\n		rawArgs, _ := n["args"].([]any)\n		args := make([]any, len(rawArgs))\n		for i, a := range rawArgs {\n			args[i] = EvalNode(a, env)\n		}\n		return evalCallBuiltin(name, args)\n\n	case "template-literal":\n		parts, _ := n["parts"].([]any)\n		var sb strings.Builder\n		for _, p := range parts {\n			pm, _ := p.(map[string]any)\n			if t, _ := pm["type"].(string); t == "string" {\n				s, _ := pm["value"].(string)\n				sb.WriteString(s)\n			} else {\n				sb.WriteString(evalToString(EvalNode(pm["expr"], env)))\n			}\n		}\n		return sb.String()\n\n	case "array-literal":\n		elems, _ := n["elements"].([]any)\n		out := make([]any, len(elems))\n		for i, e := range elems {\n			out[i] = EvalNode(e, env)\n		}\n		return out\n\n	case "object-literal":\n		props, _ := n["properties"].([]any)\n		out := make(map[string]any, len(props))\n		for _, p := range props {\n			pm, _ := p.(map[string]any)\n			key, _ := pm["key"].(string)\n			out[key] = EvalNode(pm["value"], env)\n		}\n		return out\n\n	case "array-method":\n		// `.includes(x)` / `.join(sep?)` are the `array-method` shapes the\n		// evaluator executes (the JS reference\'s `evaluate` "array-method" arm,\n		// eval-reference.ts). A nested `.map`/`.filter` is NOT an\n		// `array-method` node \u2014 it reaches the `call` case above (it carries\n		// an `arrow` callback, not a plain `args` list). Every other\n		// array/string method (`slice`, `flat`, \u2026) is refused upstream\n		// (BF101) and never reaches here.\n		method, _ := n["method"].(string)\n		rawArgs, _ := n["args"].([]any)\n		if method == "includes" && len(rawArgs) == 1 {\n			return evalIncludes(EvalNode(n["object"], env), EvalNode(rawArgs[0], env))\n		}\n		if method == "join" && len(rawArgs) <= 1 {\n			sep := ","\n			if len(rawArgs) == 1 {\n				sep = evalToString(EvalNode(rawArgs[0], env))\n			}\n			return evalJoin(EvalNode(n["object"], env), sep)\n		}\n		return nil\n	}\n	// arrow-fn / higher-order / unsupported: a callback body containing these\n	// is refused upstream (BF101); never reached here.\n	return nil\n}\n\n// evalArrayCallbackCall reports whether the decoded `call` node `n` is a\n// nested `.map(cb)` / `.filter(cb)` callback call (#2094): its callee is a\n// non-computed member `<recv>.map`/`<recv>.filter` and its first argument is\n// an `arrow` node. Returns the method name, the (still-encoded) receiver\n// object node, and the (still-encoded) arrow node.\nfunc evalArrayCallbackCall(n map[string]any) (method string, object any, arrow map[string]any, ok bool) {\n	callee, _ := n["callee"].(map[string]any)\n	if callee == nil || callee["kind"] != "member" {\n		return "", nil, nil, false\n	}\n	if computed, _ := callee["computed"].(bool); computed {\n		return "", nil, nil, false\n	}\n	prop, _ := callee["property"].(string)\n	if prop != "map" && prop != "filter" {\n		return "", nil, nil, false\n	}\n	rawArgs, _ := n["args"].([]any)\n	if len(rawArgs) == 0 {\n		return "", nil, nil, false\n	}\n	arrowNode, _ := rawArgs[0].(map[string]any)\n	if arrowNode == nil || arrowNode["kind"] != "arrow" {\n		return "", nil, nil, false\n	}\n	return prop, callee["object"], arrowNode, true\n}\n\n// evalArrayCallback executes a nested `.map`/`.filter` callback call: evaluates\n// the receiver, then evaluates the arrow body per element in a CHILD env that\n// binds the arrow\'s first param to the element and (when the arrow declares a\n// second param) the second to the integer index \u2014 both 1- and 2-param arrows\n// are supported. `map` keeps one result per element (order-preserving);\n// `filter` keeps the elements whose body evaluates truthy. A non-array\n// receiver degrades to nil (unreachable for a body the compiler validated,\n// since the receiver of a nested `.map`/`.filter` is itself gated upstream).\nfunc evalArrayCallback(method string, objectNode any, arrowNode map[string]any, env map[string]any) any {\n	arr := toAnySlice(EvalNode(objectNode, env))\n	if arr == nil {\n		return nil\n	}\n	rawParams, _ := arrowNode["params"].([]any)\n	params := make([]string, len(rawParams))\n	for i, p := range rawParams {\n		params[i], _ = p.(string)\n	}\n	body := arrowNode["body"]\n	callCb := func(item any, index int) any {\n		inner := make(map[string]any, len(env)+2)\n		for k, v := range env {\n			inner[k] = v\n		}\n		if len(params) > 0 {\n			inner[params[0]] = item\n		}\n		if len(params) > 1 {\n			inner[params[1]] = index\n		}\n		return EvalNode(body, inner)\n	}\n	if method == "map" {\n		out := make([]any, len(arr))\n		for i, item := range arr {\n			out[i] = callCb(item, i)\n		}\n		return out\n	}\n	out := []any{}\n	for i, item := range arr {\n		if evalTruthy(callCb(item, i)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// evalJoin implements `.join(sep)`: elements ToString\'d and joined; a\n// null/undefined element ToStrings to the empty string (matching JS\n// `Array.prototype.join`, which skips null/undefined rather than rendering\n// the literal string "null"/"undefined"). A non-array receiver degrades to\n// the empty string (unreachable for a validated body).\nfunc evalJoin(obj any, sep string) string {\n	arr := toAnySlice(obj)\n	if arr == nil {\n		return ""\n	}\n	parts := make([]string, len(arr))\n	for i, el := range arr {\n		if el == nil {\n			parts[i] = ""\n			continue\n		}\n		parts[i] = evalToString(el)\n	}\n	return strings.Join(parts, sep)\n}\n\n// ---------------------------------------------------------------------------\n// JS coercion primitives (ToNumber / ToString / ToBoolean), pinned so the\n// evaluator matches the JS reference. These are JS-faithful and intentionally\n// distinct from the bf->string / Number helpers, which diverge (null \u2192 "",\n// null/"" \u2192 NaN) for SSR-survival reasons that do not apply to the evaluator.\n// ---------------------------------------------------------------------------\n\n// jsDecimalNumberRe matches the JS StringToNumber decimal numeric literal\n// grammar (ASCII digits only): optional sign, then integer/fraction digits,\n// then an optional exponent. It deliberately excludes underscore digit\n// separators, radix prefixes (0x/0o/0b), and hex-float forms \u2014 none of which\n// are valid JS decimal numeric literals.\nvar jsDecimalNumberRe = regexp.MustCompile(`^[+-]?(?:[0-9]+\\.?[0-9]*|\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$`)\n\nfunc evalToNumber(v any) float64 {\n	switch x := v.(type) {\n	case nil:\n		return 0\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		t := strings.TrimSpace(x)\n		if t == "" {\n			return 0\n		}\n		// Exact JS Infinity spellings (case-sensitive, no other aliases like\n		// "infinity"/"inf" are valid JS numeric strings).\n		switch t {\n		case "Infinity", "+Infinity":\n			return math.Inf(1)\n		case "-Infinity":\n			return math.Inf(-1)\n		}\n		// Decimal / exponent numeric strings parse JS-faithfully, including\n		// overflow: strconv.ParseFloat rejects underscores, hex-floats, and\n		// non-canonical "inf"/"nan" spellings via the anchored decimal-grammar\n		// gate below, so those correctly yield NaN. The radix-prefixed forms\n		// JS Number() also accepts ("0x10" / "0o17" / "0b101") are a\n		// documented divergence region: they fail the decimal grammar (a\n		// leading "0x"/"0o"/"0b" is not a valid decimal literal) and yield\n		// NaN here, as they do in the Perl evaluator (looks_like_number is\n		// false for them), so Go==Perl while differing from the JS\n		// reference. Template data carries JSON numbers, not radix-string\n		// literals, so this never arises in practice.\n		if !jsDecimalNumberRe.MatchString(t) {\n			return math.NaN()\n		}\n		f, err := strconv.ParseFloat(t, 64)\n		if err == nil {\n			return f\n		}\n		if errors.Is(err, strconv.ErrRange) {\n			// ParseFloat still returns the correctly-signed \xB1Inf (or a\n			// subnormal) as its best-effort value on overflow/underflow;\n			// JS Number() on an overflowing decimal literal yields \xB1Infinity\n			// (e.g. "1e1000" -> +Infinity), so surface that value as-is.\n			return f\n		}\n		return math.NaN()\n	default:\n		if evalIsNumeric(v) {\n			return toFloat64(v)\n		}\n		return math.NaN()\n	}\n}\n\n// evalIsNumeric reports whether v is one of the Go numeric types (all of\n// which are the single JS "number" type to the evaluator).\nfunc evalIsNumeric(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:\n		return true\n	}\n	return false\n}\n\nfunc evalToString(v any) string {\n	if v == nil {\n		return "null"\n	}\n	// JS spells the non-finite doubles "Infinity" / "-Infinity" / "NaN"; the\n	// runtime String() helper (fmt %v) would render "+Inf" / "-Inf" / "NaN",\n	// so the non-finite cases are pinned here to stay JS-faithful (and match\n	// the Perl evaluator\'s _to_string). Strings, bools and nil are JS-faithful\n	// through String() (nil is already handled above as "null").\n	//\n	// Finite-number formatting is a documented divergence region. Go\'s fmt is\n	// shortest-round-trip (it matches JS\'s *digits*, e.g. 0.1+0.2 \u2192\n	// "0.30000000000000004"), but its exponent threshold/padding differ from\n	// JS Number::toString for very large / very small magnitudes (Go renders\n	// 1e6 as "1e+06" where JS keeps "1000000", and "1e-07" vs JS "1e-7").\n	// Perl\'s `%.15g` instead diverges on *precision* (the pinned helper-vector\n	// "0.3" case). A fully JS-faithful Number::toString is not reimplemented\n	// here because Perl has no shortest-round-trip formatter, so the three\n	// could never all agree; the common integer / short-decimal range \u2014 what\n	// arithmetic over template data produces \u2014 renders identically across all\n	// three. Only the \xB10 sign is normalised below, since it is cheap and the\n	// realisticly-reachable case.\n	if f, ok := v.(float64); ok {\n		if math.IsNaN(f) {\n			return "NaN"\n		}\n		if math.IsInf(f, 1) {\n			return "Infinity"\n		}\n		if math.IsInf(f, -1) {\n			return "-Infinity"\n		}\n		// JS `String(-0)` is "0", but fmt %v renders Go\'s negative zero as\n		// "-0". `f == 0` matches both \xB10, normalising to JS\'s spelling. (A\n		// unary `-` on a zero operand is the way the evaluator can produce -0.)\n		if f == 0 {\n			return "0"\n		}\n	}\n	// Non-primitive operands (arrays / objects) in ToString position are\n	// outside the evaluator subset \u2014 the JS reference refuses them, and the\n	// compiler gates such a callback body with BF101 before it ever reaches\n	// the runtime. This evaluator runs already-validated bodies, so it does\n	// not re-reject here; String() (fmt %v) is a best-effort fallback for that\n	// unreachable path, never exercised by the in-subset corpus.\n	return String(v)\n}\n\nfunc evalTruthy(v any) bool {\n	return isTruthy(v)\n}\n\n// ---------------------------------------------------------------------------\n// Operators\n// ---------------------------------------------------------------------------\n\nfunc evalBinary(op string, l, r any) any {\n	switch op {\n	case "+":\n		// JS `+`: string concatenation once either operand is a string,\n		// numeric addition otherwise.\n		if _, lok := l.(string); lok {\n			return evalToString(l) + evalToString(r)\n		}\n		if _, rok := r.(string); rok {\n			return evalToString(l) + evalToString(r)\n		}\n		return evalToNumber(l) + evalToNumber(r)\n	case "-":\n		return evalToNumber(l) - evalToNumber(r)\n	case "*":\n		return evalToNumber(l) * evalToNumber(r)\n	case "/":\n		return evalToNumber(l) / evalToNumber(r)\n	case "%":\n		return math.Mod(evalToNumber(l), evalToNumber(r))\n	case "<", "<=", ">", ">=":\n		return evalRelational(op, l, r)\n	case "===":\n		return evalStrictEq(l, r)\n	case "!==":\n		return !evalStrictEq(l, r)\n	}\n	// Loose equality / bitwise / shift are out of the subset.\n	return nil\n}\n\nfunc evalRelational(op string, l, r any) bool {\n	// JS Abstract Relational Comparison: both strings \u2192 compare by code\n	// unit; otherwise coerce both to numbers (a NaN operand makes every\n	// comparison false).\n	var c int\n	ls, lok := l.(string)\n	rs, rok := r.(string)\n	if lok && rok {\n		if ls < rs {\n			c = -1\n		} else if ls > rs {\n			c = 1\n		}\n	} else {\n		ln := evalToNumber(l)\n		rn := evalToNumber(r)\n		if math.IsNaN(ln) || math.IsNaN(rn) {\n			return false\n		}\n		if ln < rn {\n			c = -1\n		} else if ln > rn {\n			c = 1\n		}\n	}\n	switch op {\n	case "<":\n		return c < 0\n	case "<=":\n		return c <= 0\n	case ">":\n		return c > 0\n	case ">=":\n		return c >= 0\n	}\n	return false\n}\n\nfunc evalStrictEq(l, r any) bool {\n	// Strict `===`: equal JS type and value, no coercion. All numeric Go\n	// types are the single JS "number" type, so int 2 === float64 2.\n	lnum := evalIsNumeric(l)\n	rnum := evalIsNumeric(r)\n	if lnum && rnum {\n		lf, rf := toFloat64(l), toFloat64(r)\n		if math.IsNaN(lf) || math.IsNaN(rf) {\n			return false\n		}\n		return lf == rf\n	}\n	if lnum != rnum {\n		return false\n	}\n	switch lv := l.(type) {\n	case nil:\n		return r == nil\n	case string:\n		rv, ok := r.(string)\n		return ok && rv == lv\n	case bool:\n		rv, ok := r.(bool)\n		return ok && rv == lv\n	}\n	// Non-primitive operands (arrays / objects) are outside the subset: the JS\n	// reference refuses `===` on them and the compiler gates such a body with\n	// BF101 upstream, so this is unreachable for an in-subset corpus. The\n	// runtime trusts that gate rather than re-validating, returning false\n	// here (it does not attempt JS reference identity, which templates can\'t\n	// model anyway).\n	return false\n}\n\n// evalSameValueZero implements `Array.prototype.includes`\'s membership\n// comparison: `===` except `NaN` equals itself (JS\'s SameValueZero). Reuses\n// evalStrictEq \u2014 the one divergence, both operands NaN, is checked first;\n// every other pair (including "one NaN, one not") falls through to the same\n// equality `evalBinary`\'s `===` uses, so the two operators stay in lockstep.\nfunc evalSameValueZero(a, b any) bool {\n	if evalIsNumeric(a) && evalIsNumeric(b) {\n		af, bf := toFloat64(a), toFloat64(b)\n		if math.IsNaN(af) && math.IsNaN(bf) {\n			return true\n		}\n	}\n	return evalStrictEq(a, b)\n}\n\n// evalIncludes implements `.includes(needle)`, shared between\n// `Array.prototype.includes` (SameValueZero membership over a slice/array\n// receiver) and `String.prototype.includes` (substring search), mirroring\n// the receiver-type dispatch the SSR template lowering already does\n// (`bf_includes`). Any other receiver type is not a JS `.includes` target;\n// this degrades to false rather than panicking (there is no receiver here\n// for which JS itself would throw), matching the JS reference\n// (eval-reference.ts `includes`).\nfunc evalIncludes(obj, needle any) bool {\n	if arr := toAnySlice(obj); arr != nil {\n		for _, el := range arr {\n			if evalSameValueZero(el, needle) {\n				return true\n			}\n		}\n		return false\n	}\n	if s, ok := obj.(string); ok {\n		return strings.Contains(s, evalToString(needle))\n	}\n	return false\n}\n\nfunc evalUnary(op string, v any) any {\n	switch op {\n	case "!":\n		return !evalTruthy(v)\n	case "-":\n		return -evalToNumber(v)\n	case "+":\n		return evalToNumber(v)\n	}\n	return nil\n}\n\n// ---------------------------------------------------------------------------\n// Built-in calls (the deterministic allowlist). Locale-sensitive builtins\n// (localeCompare) are deliberately excluded to keep the backends isomorphic.\n// ---------------------------------------------------------------------------\n\n// evalBuiltinName resolves a `call` callee to its builtin name (e.g.\n// "Math.max"), or "" if the callee is not an allowlisted builtin reference.\nfunc evalBuiltinName(callee any) string {\n	cm, ok := callee.(map[string]any)\n	if !ok {\n		return ""\n	}\n	switch cm["kind"] {\n	case "identifier":\n		name, _ := cm["name"].(string)\n		return name\n	case "member":\n		if computed, _ := cm["computed"].(bool); computed {\n			return ""\n		}\n		obj, _ := cm["object"].(map[string]any)\n		if obj == nil || obj["kind"] != "identifier" {\n			return ""\n		}\n		objName, _ := obj["name"].(string)\n		prop, _ := cm["property"].(string)\n		return objName + "." + prop\n	}\n	return ""\n}\n\n// evalMathRound rounds a half toward +Infinity (JS Math.round: 2.5\u21923,\n// -2.5\u2192-2), matching the existing `round` helper rather than Go\'s math.Round.\nfunc evalMathRound(n float64) float64 {\n	// floor(n+0.5) yields +0 for x in [-0.5, -0], where JS Math.round returns\n	// -0. That sign is only observable through a subsequent division\n	// (`1 / Math.round(-0.5)` is -Infinity in JS, +Infinity here) \u2014 through\n	// ToString both \xB10 render "0". It is left as +0 deliberately: the two SSR\n	// backends must stay equal, and Perl can\'t reproduce the -0 divisor sign\n	// without fragile, version-dependent zero handling (its native `/` even\n	// dies on a zero divisor). So Math.round\'s -0 is a JS-reference-only\n	// divergence region, like the astral-plane / radix-string carve-outs.\n	return math.Floor(n + 0.5)\n}\n\nfunc evalCallBuiltin(name string, args []any) any {\n	switch name {\n	case "Math.max":\n		if len(args) == 0 {\n			return math.Inf(-1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Max(m, evalToNumber(a))\n		}\n		return m\n	case "Math.min":\n		if len(args) == 0 {\n			return math.Inf(1)\n		}\n		m := evalToNumber(args[0])\n		for _, a := range args[1:] {\n			m = math.Min(m, evalToNumber(a))\n		}\n		return m\n	case "Math.abs":\n		return math.Abs(evalToNumber(arg0(args)))\n	case "Math.floor":\n		return math.Floor(evalToNumber(arg0(args)))\n	case "Math.ceil":\n		return math.Ceil(evalToNumber(arg0(args)))\n	case "Math.round":\n		return evalMathRound(evalToNumber(arg0(args)))\n	case "String":\n		return evalToString(arg0(args))\n	case "Number":\n		return evalToNumber(arg0(args))\n	case "Boolean":\n		return evalTruthy(arg0(args))\n	}\n	// Any other callee is outside the subset (refused upstream).\n	return nil\n}\n\nfunc arg0(args []any) any {\n	if len(args) == 0 {\n		return nil\n	}\n	return args[0]\n}\n\n// ---------------------------------------------------------------------------\n// Member / index access\n// ---------------------------------------------------------------------------\n\nfunc evalReadProperty(obj any, key string) any {\n	switch o := obj.(type) {\n	case string:\n		if key == "length" {\n			// Code-point count (== JS UTF-16 length across the BMP, == Perl\n			// `length`). RuneCountInString avoids the []rune allocation since\n			// this can run inside comparator / reducer evaluation.\n			return utf8.RuneCountInString(o)\n		}\n		return nil\n	case []any:\n		if key == "length" {\n			return len(o)\n		}\n		return nil\n	case map[string]any:\n		// Case-variant lookup: a callback body reads the raw JS property\n		// (`t.duration`), but test data / Go-keyed maps may carry PascalCase\n		// keys (`{"Duration": \u2026}`). Reuse the field reader the sort / reduce\n		// helpers use \u2014 it resolves `duration` \u2192 `Duration` and reads a\n		// genuinely missing key as null (the backends\' single absent value).\n		return getFieldValue(o, key)\n	case nil:\n		return nil\n	default:\n		// Real template data (Go structs): reuse the field reader the sort /\n		// reduce helpers use, which handles case-variant keys.\n		return getFieldValue(obj, key)\n	}\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order folds (the generalization of bf_reduce /\n// bf_sort onto the evaluator)\n//\n// These prove the evaluator subsumes the special-cased callback catalogue:\n// the callback BODY is carried as a pure ParsedExpr (JSON) and evaluated per\n// element against an environment, so the op restriction (bf_reduce\'s +/*),\n// the acc-canonical form, and the comparator pattern restriction (bf_sort)\n// all disappear \u2014 any pure reducer / comparator body works. They are the\n// runtime half of the integration; the compiler-side emit migration (carrying\n// callback bodies as ParsedExpr) and the byte-equal divergence decision for\n// the string-`localeCompare` sort path (won\'t-fix for byte-equal SSR, see\n// spec/compiler.md Known limitations) are the remaining follow-up.\n// ---------------------------------------------------------------------------\n\n// toAnySlice copies a reflect-iterable receiver into a fresh []any, returning\n// nil for a non-slice/array (matching the bf_sort / bf_reduce nil-tolerance).\nfunc toAnySlice(items any) []any {\n	v := reflect.ValueOf(items)\n	// A nil interface yields an invalid Value (Kind() == Invalid, not a\n	// panic), so the Slice/Array guard below already tolerates nil; the\n	// explicit IsValid check just documents the nil-tolerance intent.\n	if !v.IsValid() || (v.Kind() != reflect.Slice && v.Kind() != reflect.Array) {\n		return nil\n	}\n	out := make([]any, v.Len())\n	for i := range out {\n		out[i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// FoldEval folds items into a value via the ParsedExpr evaluator. The reducer\n// body is a pure ParsedExpr (JSON) evaluated against `{accName: acc, itemName:\n// item}` plus the captured free vars in `baseEnv` for each element; `init`\n// seeds the accumulator and `direction` is "left" (reduce) or "right"\n// (reduceRight). This is the evaluator-based generalization of bf_reduce \u2014 any\n// reducer body, not just the `+`/`*` arithmetic catalogue, and `acc` may\n// appear anywhere in the body. `baseEnv` may be nil when the body captures no\n// outer references; the accName / itemName keys shadow any same-named base key.\nfunc FoldEval(items any, bodyJSON, accName, itemName string, init any, direction string, baseEnv map[string]any) any {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return init\n	}\n	arr := toAnySlice(items)\n	if direction == "right" {\n		for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {\n			arr[i], arr[j] = arr[j], arr[i]\n		}\n	}\n	acc := init\n	// Seed the env from the captured free vars once; acc / item are\n	// overwritten each iteration (constant base keys carry through).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	for _, item := range arr {\n		env[accName] = acc\n		env[itemName] = item\n		acc = EvalNode(body, env)\n	}\n	return acc\n}\n\n// SortEval returns a new stable-sorted slice ordered by a ParsedExpr\n// comparator body (JSON) evaluated against `{paramA: a, paramB: b}` plus the\n// captured free vars in `baseEnv` to a number (negative / zero / positive,\n// like a JS comparator). This is the evaluator-based generalization of bf_sort\n// \u2014 any comparator body, not just the subtraction / relational-ternary\n// catalogue. `baseEnv` may be nil. Non-mutating.\nfunc SortEval(items any, cmpJSON, paramA, paramB string, baseEnv map[string]any) []any {\n	arr := toAnySlice(items)\n	if arr == nil {\n		return nil\n	}\n	var cmp any\n	if err := json.Unmarshal([]byte(cmpJSON), &cmp); err != nil {\n		return arr\n	}\n	// One env seeded from the captured free vars; the two operand keys are\n	// overwritten per comparison (the comparator runs synchronously).\n	env := make(map[string]any, len(baseEnv)+2)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	sort.SliceStable(arr, func(i, j int) bool {\n		env[paramA] = arr[i]\n		env[paramB] = arr[j]\n		return evalToNumber(EvalNode(cmp, env)) < 0\n	})\n	return arr\n}\n\n// ---------------------------------------------------------------------------\n// Evaluator-driven higher-order predicates (#2018, P2) \u2014 the generalization\n// of bf_filter / bf_find / bf_find_index / bf_every / bf_some onto the\n// evaluator. The predicate BODY travels as a pure ParsedExpr (JSON) and is\n// evaluated per element against `{param: item}` plus the captured free vars in\n// `baseEnv`, lifting the field-equality / truthiness restriction of the\n// special-cased helpers to any pure predicate. `baseEnv` may be nil.\n// ---------------------------------------------------------------------------\n\n// decodeEvalBody unmarshals a serialized ParsedExpr body; ok is false on bad\n// JSON (only reachable by a corrupt emit \u2014 the adapter always emits valid JSON).\nfunc decodeEvalBody(bodyJSON string) (any, bool) {\n	var body any\n	if err := json.Unmarshal([]byte(bodyJSON), &body); err != nil {\n		return nil, false\n	}\n	return body, true\n}\n\n// seedPredEnv copies the captured free vars into a fresh env with room for the\n// single predicate param, which the callers overwrite per element.\nfunc seedPredEnv(baseEnv map[string]any) map[string]any {\n	env := make(map[string]any, len(baseEnv)+1)\n	for k, v := range baseEnv {\n		env[k] = v\n	}\n	return env\n}\n\n// FilterEval returns a new slice of the elements for which the predicate body\n// evaluates truthy \u2014 the evaluator generalization of bf_filter. Returns a\n// non-nil empty slice when nothing matches (so a downstream `range` / `bf_join`\n// sees a real slice); returns nil only on a bad body.\nfunc FilterEval(items any, predJSON, param string, baseEnv map[string]any) []any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			out = append(out, item)\n		}\n	}\n	return out\n}\n\n// EveryEval reports whether every element satisfies the predicate (vacuously\n// true for an empty receiver, like JS) \u2014 the generalization of bf_every.\nfunc EveryEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if !evalTruthy(EvalNode(pred, env)) {\n			return false\n		}\n	}\n	return true\n}\n\n// SomeEval reports whether any element satisfies the predicate (false for an\n// empty receiver, like JS) \u2014 the generalization of bf_some.\nfunc SomeEval(items any, predJSON, param string, baseEnv map[string]any) bool {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return false\n	}\n	env := seedPredEnv(baseEnv)\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		if evalTruthy(EvalNode(pred, env)) {\n			return true\n		}\n	}\n	return false\n}\n\n// FindEval returns the first element satisfying the predicate, or nil when none\n// does \u2014 the generalization of bf_find. `forward` false searches from the end\n// (findLast).\nfunc FindEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) any {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return nil\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return arr[i]\n		}\n	}\n	return nil\n}\n\n// FindIndexEval returns the index of the first element satisfying the predicate,\n// or -1 when none does \u2014 the generalization of bf_find_index. `forward` false\n// searches from the end (findLastIndex).\nfunc FindIndexEval(items any, predJSON, param string, forward bool, baseEnv map[string]any) int {\n	pred, ok := decodeEvalBody(predJSON)\n	if !ok {\n		return -1\n	}\n	env := seedPredEnv(baseEnv)\n	arr := toAnySlice(items)\n	for n := range arr {\n		i := n\n		if !forward {\n			i = len(arr) - 1 - n\n		}\n		env[param] = arr[i]\n		if evalTruthy(EvalNode(pred, env)) {\n			return i\n		}\n	}\n	return -1\n}\n\n// FlatMapEval projects each element through the projection body (a pure\n// ParsedExpr JSON evaluated against `{param: item}` + baseEnv) and flattens the\n// results one level \u2014 the evaluator generalization of bf_flat_map /\n// bf_flat_map_tuple. A projection that yields a slice contributes its elements;\n// any other value contributes itself (matching JS `.flatMap`, where a non-array\n// return is kept as a single element). Returns a non-nil empty slice on a bad\n// body so a downstream `range` / `bf_join` sees a real slice.\nfunc FlatMapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		v := EvalNode(proj, env)\n		// Flatten any slice/array kind one level, not just []any: real Go\n		// template data projects a field like `i.tags` to a typed slice\n		// (`[]string` / `[]int`), which `toAnySlice` normalizes to []any. A\n		// non-slice value (string / number / struct / nil) contributes itself,\n		// matching JS `.flatMap` (a non-array return is kept as one element).\n		if sub := toAnySlice(v); sub != nil {\n			out = append(out, sub...)\n		} else {\n			out = append(out, v)\n		}\n	}\n	return out\n}\n\n// MapEval projects each element through the projection body (a pure ParsedExpr\n// JSON evaluated against `{param: item}` + baseEnv), keeping one result per\n// element \u2014 the value-producing `.map(cb)` lowering (#2073). Unlike\n// FlatMapEval there is no flatten: a projection yielding a slice contributes\n// that slice as a single element, matching JS `.map`. Returns a non-nil empty\n// slice on a bad body so a downstream `range` / `bf_join` sees a real slice.\nfunc MapEval(items any, projJSON, param string, baseEnv map[string]any) []any {\n	proj, ok := decodeEvalBody(projJSON)\n	if !ok {\n		return []any{}\n	}\n	env := seedPredEnv(baseEnv)\n	out := []any{}\n	for _, item := range toAnySlice(items) {\n		env[param] = item\n		out = append(out, EvalNode(proj, env))\n	}\n	return out\n}\n\n// Env builds the captured-free-var environment for FoldEval / SortEval from a\n// flat key, value, key, value, \u2026 argument list \u2014 the adapter emits\n// `bf_env "k1" v1 "k2" v2 \u2026` for the free variables a callback body references\n// beyond its own params. An odd trailing key with no value is ignored; with no\n// pairs it returns an empty (non-nil) map, the no-capture case. A non-string\n// key (only reachable by a malformed template call, never by the adapter\'s\n// quoted-literal emit) is skipped rather than collapsed into an `env[""]` slot.\nfunc Env(pairs ...any) map[string]any {\n	env := make(map[string]any, len(pairs)/2)\n	for i := 0; i+1 < len(pairs); i += 2 {\n		key, ok := pairs[i].(string)\n		if !ok {\n			continue\n		}\n		env[key] = pairs[i+1]\n	}\n	return env\n}\n\nfunc evalReadIndex(obj any, index any) any {\n	switch o := obj.(type) {\n	case []any:\n		f := evalToNumber(index)\n		i := int(f)\n		if float64(i) != f || i < 0 || i >= len(o) {\n			return nil\n		}\n		return o[i]\n	case map[string]any:\n		return o[evalToString(index)]\n	case nil:\n		return nil\n	default:\n		return getFieldValue(obj, evalToString(index))\n	}\n}\n';
+    repropsGoSource = '// Per-row child props reconstruction (#2448).\n//\n// `bf_with_props` (#2445) overrides fields on a child\'s already-constructed\n// shared instance by reflection. That is correct for a plain passthrough prop\n// and WRONG for anything the child\'s constructor DERIVES from it: a\n// `createMemo` body and a `createSignal` initial value are both baked into the\n// struct once by `New<Child>Props`, and reflection cannot re-run that.\n//\n// This file is the fix. Instead of patching fields, the parent asks the child\n// to REBUILD its props: reconstruct the constructor Input from the base\n// instance, apply the row\'s overrides, re-run the real constructor. Every\n// derived field recomputes because the real Go code runs again.\n//\n// The constructor cannot be called from a template directly \u2014 `html/template`\n// has no expression language and can only call FuncMap entries. So the\n// compiler emits, per component, a closure that does the rebuild in generated\n// Go (typed field assignments, no reflection), and registers it here from the\n// generated package\'s `init()`. `FuncMap()` gains exactly ONE fixed entry,\n// `bf_reprops`, so `t.Funcs(bf.FuncMap())` keeps working unchanged.\n//\n// The registry is consulted at template EXECUTE time, never at `Funcs()` time.\n// That is load-bearing, not incidental: Go initializes a package\'s variables\n// BEFORE its `init()` functions, so an app that builds its template set in a\n// package-level var \u2014\n//\n//	var tmpl = template.Must(template.New("").Funcs(bf.FuncMap()).ParseGlob(...))\n//\n// \u2014 calls `FuncMap()` while the registry is still empty. Merging the\n// constructors into `FuncMap()`\'s return value would fail that app at parse\n// time with `function "bf_new_Badge" not defined`. Looking them up behind one\n// fixed entry, at execute time, makes the ordering irrelevant.\npackage bf\n\nimport (\n	"fmt"\n	"reflect"\n	"sync"\n)\n\n// RepropsFunc rebuilds a child component\'s props from a base instance plus a\n// flat name/value override list (`"Text", .Label, "N", .N, \u2026`), by re-running\n// the component\'s generated constructor.\n//\n// Names in `kv` are the Go FIELD names the PARENT computed from the JSX\n// attribute (`n=` \u2192 `"N"`). A generated implementation maps those onto its own\n// constructor Input, which is what makes an aliased destructure\n// (`{ n: count }`, whose field is `Count`) land correctly \u2014 the mapping lives\n// in generated code that knows both sides.\n//\n// Identity fields (ScopeID / BfParent / BfMount) MUST be carried over from the\n// base rather than re-derived: `New<Child>Props` mints a random ScopeID when\n// given an empty one, so a naive re-run would give every row its own scope and\n// break hydration. Fields that live only on Props and never on Input (Scripts,\n// BfIsChild, BfDataKey) must be carried over for the same reason.\ntype RepropsFunc func(base interface{}, kv ...interface{}) (interface{}, error)\n\nvar (\n	repropsMu       sync.RWMutex\n	repropsRegistry = map[string]RepropsFunc{}\n)\n\n// RegisterReprops registers a component\'s props rebuilder under its component\n// name. Called from the generated package\'s `init()`; re-registering the same\n// name replaces the previous entry, so a rebuilt components file in a\n// long-lived dev process wins.\nfunc RegisterReprops(name string, fn RepropsFunc) {\n	repropsMu.Lock()\n	defer repropsMu.Unlock()\n	repropsRegistry[name] = fn\n}\n\n// Reprops is the `bf_reprops` FuncMap entry: rebuild `base` with the row\'s\n// overrides applied, by re-running the named component\'s constructor.\n//\n//	{{template "Badge" (bf_reprops "Badge" $.BadgeSlot0 "Text" .Label "N" .N)}}\n//\n// An unregistered name is an error rather than a silent passthrough: the\n// compiler only emits this call for a component whose rebuilder it also\n// emitted, so a missing entry means the generated package was not linked in,\n// and falling back to the stale shared instance would reintroduce exactly the\n// silently-wrong output this exists to prevent.\nfunc Reprops(name string, base interface{}, kv ...interface{}) (interface{}, error) {\n	if len(kv)%2 != 0 {\n		return nil, fmt.Errorf("bf_reprops: odd number of key/value arguments (%d) for %q", len(kv), name)\n	}\n	// Field names are validated HERE, not in each generated rebuilder, so the\n	// generated `name, _ := kv[i].(string)` is safe by construction. Rejecting\n	// them matches `bf_with_props`: a non-string name would otherwise degrade\n	// to `""`, match no case, and silently drop the override \u2014 the same class\n	// of silent misrender this whole path exists to remove.\n	for i := 0; i < len(kv); i += 2 {\n		if _, ok := kv[i].(string); !ok {\n			return nil, fmt.Errorf(\n				"bf_reprops: %s field name at position %d must be a string, got %T", name, i, kv[i])\n		}\n	}\n	repropsMu.RLock()\n	fn, ok := repropsRegistry[name]\n	repropsMu.RUnlock()\n	if !ok {\n		return nil, fmt.Errorf(\n			"bf_reprops: no props rebuilder registered for %q \u2014 is the generated components package linked into this binary?",\n			name,\n		)\n	}\n	return fn(base, kv...)\n}\n\n// RepropsTypeError is the error a generated rebuilder returns when handed a\n// value that is not its own props struct. Kept here so the generated code\n// stays a fixed shape instead of formatting its own message.\nfunc RepropsTypeError(name string, base interface{}) error {\n	return fmt.Errorf("bf_reprops: the %s rebuilder got %T, not its own props struct", name, base)\n}\n\n// RepropsUnknownFieldError is what a generated rebuilder returns for a field\n// name it has no case for.\n//\n// Unlike `bf_with_props`, whose unknown-field passthrough is load-bearing (a\n// prop routed into a rest bag has no named field to set), a rebuilder is only\n// emitted for components with NO rest bag and no spread slot, and the compiler\n// emits a case for every prop the parent can override. So an unknown name here\n// is a compiler gap, and dropping it silently would leave the override\n// unapplied \u2014 the failure mode this path replaced.\nfunc RepropsUnknownFieldError(component, field string) error {\n	return fmt.Errorf("bf_reprops: %s has no overridable field %q", component, field)\n}\n\n// RepropsAssign writes `val` into `*target`, which a generated rebuilder passes\n// as a pointer to one field of its constructor Input (`&in.N`).\n//\n// This is the one place the rebuild uses reflection, and it does so on purpose:\n// it delegates to the SAME `setStructFieldValue` that `bf_with_props` uses, so\n// a prop that already assigned correctly under the old helper assigns\n// identically under this one. Re-deriving the conversion rules per Go type in\n// the generator would be more code and would drift from that behaviour.\n//\n// `field` names the field for the error message; `component` names the owner.\nfunc RepropsAssign(component, field string, target interface{}, val interface{}) error {\n	p := reflect.ValueOf(target)\n	if p.Kind() != reflect.Ptr || p.IsNil() {\n		return fmt.Errorf("bf_reprops: %s.%s: target must be a non-nil pointer, got %T", component, field, target)\n	}\n	if err := setStructFieldValue(p.Elem(), val); err != nil {\n		return fmt.Errorf("bf_reprops: %s.%s: %w", component, field, err)\n	}\n	return nil\n}\n\n// RepropsRegistered reports whether a rebuilder is registered for `name`.\n// For tests and diagnostics.\nfunc RepropsRegistered(name string) bool {\n	repropsMu.RLock()\n	defer repropsMu.RUnlock()\n	_, ok := repropsRegistry[name]\n	return ok\n}\n';
     streamingGoSource = `// Package bf \u2014 Out-of-Order Streaming SSR helpers
 //
 // Provides StreamRenderer for progressive page rendering using HTTP
@@ -32189,6 +32726,7 @@ function goCommonFiles() {
     "env.go": GO_ENV_GO,
     "bf-runtime/bf.go": bfGoSource,
     "bf-runtime/eval.go": evalGoSource,
+    "bf-runtime/reprops.go": repropsGoSource,
     "bf-runtime/streaming.go": streamingGoSource,
     "bf-runtime/bfdev/bfdev.go": bfdevGoSource,
     "bf-runtime/go.mod": GO_BF_RUNTIME_GO_MOD,
@@ -33268,6 +33806,7 @@ replace github.com/barefootjs/runtime/bf => ./bf-runtime
         "go.mod": ECHO_GO_MOD,
         "bf-runtime/bf.go": bfGoSource,
         "bf-runtime/eval.go": evalGoSource,
+        "bf-runtime/reprops.go": repropsGoSource,
         "bf-runtime/streaming.go": streamingGoSource,
         "bf-runtime/go.mod": ECHO_BF_RUNTIME_GO_MOD,
         "barefoot.config.ts": ECHO_BAREFOOT_CONFIG_TS,
@@ -111027,7 +111566,7 @@ __export(scenario_driver_exports, {
 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 ts27 from "typescript";
+import ts28 from "typescript";
 function externalRuntimeImport(clientJs) {
   const chunks = Array.isArray(clientJs) ? clientJs : [clientJs];
   for (const chunk of chunks) {
@@ -111097,11 +111636,11 @@ function resolveLocalFile(spec) {
 }
 function rewriteLocalImports(js, chunkPath, inlined) {
   const chunkDir = dirname7(chunkPath);
-  const sf = ts27.createSourceFile("chunk.mjs", js, ts27.ScriptTarget.Latest, false, ts27.ScriptKind.JS);
+  const sf = ts28.createSourceFile("chunk.mjs", js, ts28.ScriptTarget.Latest, false, ts28.ScriptKind.JS);
   const edits = [];
   for (const stmt of sf.statements) {
-    if (!ts27.isImportDeclaration(stmt)) continue;
-    if (!ts27.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts28.isImportDeclaration(stmt)) continue;
+    if (!ts28.isStringLiteral(stmt.moduleSpecifier)) continue;
     const spec = stmt.moduleSpecifier.text;
     if (!spec.startsWith(".")) continue;
     const resolved = resolveLocalFile(join2(chunkDir, spec.replace(/\.client\.js$/, "")));
@@ -111113,13 +111652,13 @@ function rewriteLocalImports(js, chunkPath, inlined) {
     const abs = resolve11(resolved);
     if (inlined.has(abs)) {
       const clause = stmt.importClause;
-      if (clause && (clause.name || clause.namedBindings && ts27.isNamespaceImport(clause.namedBindings))) {
+      if (clause && (clause.name || clause.namedBindings && ts28.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 && ts27.isNamedImports(clause.namedBindings)) {
+      if (clause?.namedBindings && ts28.isNamedImports(clause.namedBindings)) {
         for (const el of clause.namedBindings.elements) {
           if (el.propertyName) shims.push(`var ${el.name.text} = ${el.propertyName.text}`);
         }
@@ -111628,9 +112167,9 @@ function findProjectConfig(startDir) {
   let dir = path.resolve(startDir);
   const { root: fsRoot } = path.parse(dir);
   while (true) {
-    const ts28 = path.join(dir, "barefoot.config.ts");
-    if (existsSync2(ts28)) {
-      return { dir, tsConfigPath: ts28 };
+    const ts29 = path.join(dir, "barefoot.config.ts");
+    if (existsSync2(ts29)) {
+      return { dir, tsConfigPath: ts29 };
     }
     if (dir === fsRoot) return null;
     dir = path.dirname(dir);