@barefootjs/cli 0.1.2 → 0.1.3

package/dist/docs/core/{README.md → README.mdx}

@@ -2,7 +2,7 @@
 
 ## Table of Contents
 
-### 1. [Introduction](./introduction.md)
+### 1. [Introduction](./introduction.mdx)
 
 - What is BarefootJS?
 - Why BarefootJS?
@@ -20,7 +20,7 @@
 - [MPA-style Development](./core-concepts/mpa-style.md) — Server-rendering by default, JS only where marked
 - [Fine-grained Reactivity](./core-concepts/reactivity.md) — Signals, effects, memos — no virtual DOM needed
 - [AI-native Development](./core-concepts/ai-native.md) — Testable IR, CLI discovery, AI-assisted workflows
-- [How It Works](./core-concepts/how-it-works.md) — Two-phase compilation, hydration markers, clean overrides
+- [How It Works](./core-concepts/how-it-works.mdx) — Two-phase compilation, hydration markers, clean overrides
 
 ### 4. [Reactivity](./reactivity.md)
 
@@ -40,7 +40,7 @@
 
 ### 6. [Components](./components.md)
 
-- [Component Authoring](./components/component-authoring.md) — Server components, client components, and the compilation model
+- [Component Authoring](./components/component-authoring.mdx) — Server components, client components, and the compilation model
 - [Props & Type Safety](./components/props-type-safety.md) — Typing props, defaults, and rest spreading
 - [Children & Slots](./components/children-slots.md) — Children prop, the `Slot` component, and the `asChild` pattern
 - [Context API](./components/context-api.md) — Sharing state with `createContext` / `useContext`
@@ -69,16 +69,10 @@ Code examples use **switchable tabs** for adapter output and package manager com
 
 **Adapter** — Hono (default) or Go Template:
 
-<!-- tabs:adapter -->
-- Hono (default)
-- Go Template
+<Tabs id="adapter" labels="Hono (default),Go Template" />
 
 **Package Manager** — npm (default), bun, pnpm, or yarn:
 
-<!-- tabs:pm -->
-- npm (default)
-- bun
-- pnpm
-- yarn
+<Tabs id="pm" labels="npm (default),bun,pnpm,yarn" />
 
 > Sections marked with 💡 explain JSX and TypeScript concepts for developers from Go, Python, or other backend languages.

package/dist/docs/core/components/{component-authoring.md → component-authoring.mdx}

@@ -40,7 +40,7 @@ export function Counter() {
 }
 ```
 
-The compiler produces a **marked template** (server HTML with `bf-*` attributes) and **client JS** (signals, effects, event handlers). See [How It Works](../core-concepts/how-it-works.md#two-phase-compilation) for details.
+The compiler produces a **marked template** (server HTML with `bf-*` attributes) and **client JS** (signals, effects, event handlers). See [How It Works](../core-concepts/how-it-works.mdx#two-phase-compilation) for details.
 
 ### When `"use client"` Is Required
 
@@ -92,8 +92,9 @@ export function Toggle() {
 
 **Marked template:**
 
-<!-- tabs:adapter -->
-<!-- tab:Hono -->
+<Tabs id="adapter" default="Hono">
+<Tab label="Hono" />
+
 ```tsx
 export function Toggle({ __instanceId, ... }) {
   const __scopeId = __instanceId || `Toggle_${...}`
@@ -107,7 +108,9 @@ export function Toggle({ __instanceId, ... }) {
   )
 }
 ```
-<!-- tab:Go Template -->
+
+<Tab label="Go Template" />
+
 ```go-template
 {{define "Toggle"}}
 <button bf-s="{{bfScopeAttr .}}" bf="s1">
@@ -116,7 +119,8 @@ export function Toggle({ __instanceId, ... }) {
 </button>
 {{end}}
 ```
-<!-- /tabs -->
+
+</Tabs>
 
 **Client JS:**
 

package/dist/docs/core/components.md

@@ -11,7 +11,7 @@ For the `"use client"` directive and the server/client boundary, see [Backend Fr
 
 | Topic | Description |
 |-------|-------------|
-| [Component Authoring](./components/component-authoring.md) | Server components, client components, and the compilation model |
+| [Component Authoring](./components/component-authoring.mdx) | Server components, client components, and the compilation model |
 | [Props & Type Safety](./components/props-type-safety.md) | Typing props, defaults, and rest spreading |
 | [Children & Slots](./components/children-slots.md) | Children prop, the `Slot` component, and the `asChild` pattern |
 | [Context API](./components/context-api.md) | Sharing state across compound components with `createContext` / `useContext` |

package/dist/docs/core/core-concepts/{how-it-works.md → how-it-works.mdx}

@@ -51,8 +51,9 @@ The IR records:
 
 Marked template (Phase 2a):
 
-<!-- tabs:adapter -->
-<!-- tab:Hono -->
+<Tabs id="adapter" default="Hono">
+<Tab label="Hono" />
+
 ```tsx
 export function Counter({ __instanceId, ... }) {
   const __scopeId = __instanceId || `Counter_${Math.random().toString(36).slice(2, 8)}`
@@ -65,7 +66,9 @@ export function Counter({ __instanceId, ... }) {
   )
 }
 ```
-<!-- tab:Go Template -->
+
+<Tab label="Go Template" />
+
 ```go-template
 {{define "Counter"}}
 <button bf-s="{{bfScopeAttr .}}" bf="s1">
@@ -73,7 +76,8 @@ export function Counter({ __instanceId, ... }) {
 </button>
 {{end}}
 ```
-<!-- /tabs -->
+
+</Tabs>
 
 Client JS (Phase 2b):
 

package/dist/docs/core/{introduction.md → introduction.mdx}

@@ -28,8 +28,9 @@ export function Counter() {
 
 This single file compiles into two outputs:
 
-<!-- tabs:adapter -->
-<!-- tab:Hono -->
+<Tabs id="adapter" default="Hono">
+<Tab label="Hono" />
+
 **Marked template** — Renders static HTML with hydration markers:
 
 ```tsx
@@ -45,7 +46,8 @@ export function Counter({ __instanceId, ... }) {
 }
 ```
 
-<!-- tab:Go Template -->
+<Tab label="Go Template" />
+
 **Marked template** — Go `html/template` with hydration markers:
 
 ```go-template
@@ -56,7 +58,7 @@ export function Counter({ __instanceId, ... }) {
 {{end}}
 ```
 
-<!-- /tabs -->
+</Tabs>
 
 **Client script** — Wires up only the interactive parts:
 
@@ -84,4 +86,3 @@ hydrate('Counter', {
   template: (_p) => `<button bf="s1"> Count: <!--bf:s0-->${(0)}<!--/--></button>`
 })
 ```
-

package/dist/index.js

@@ -1127,6 +1127,7 @@ function createAnalyzerContext(sourceFile, filePath) {
     jsxConstants: /* @__PURE__ */ new Map(),
     inlineableJsxConsts: /* @__PURE__ */ new Map(),
     jsxFunctions: /* @__PURE__ */ new Map(),
+    jsxMultiReturnFunctions: /* @__PURE__ */ new Map(),
     reactiveFactories: /* @__PURE__ */ new Map(),
     signalTupleRefs: /* @__PURE__ */ new Map(),
     propsType: null,
@@ -1345,24 +1346,14 @@ var init_errors = __esm({
       // Directive errors (BF001-BF009)
       MISSING_USE_CLIENT: "BF001",
       CLIENT_IMPORTING_SERVER: "BF003",
-      // Signal/Memo errors (BF010-BF019)
-      UNKNOWN_SIGNAL: "BF010",
+      // Signal/Memo errors (BF011-BF019)
       SIGNAL_OUTSIDE_COMPONENT: "BF011",
-      INVALID_SIGNAL_USAGE: "BF012",
-      // JSX errors (BF020-BF029)
-      INVALID_JSX_EXPRESSION: "BF020",
+      // JSX errors (BF021-BF029)
       UNSUPPORTED_JSX_PATTERN: "BF021",
-      INVALID_JSX_ATTRIBUTE: "BF022",
       MISSING_KEY_IN_LIST: "BF023",
       MISSING_KEY_IN_NESTED_LIST: "BF024",
       UNSUPPORTED_DESTRUCTURE_REST: "BF025",
-      // Type errors (BF030-BF039)
-      TYPE_INFERENCE_FAILED: "BF030",
-      PROPS_TYPE_MISMATCH: "BF031",
-      // Component errors (BF040-BF049)
-      COMPONENT_NOT_FOUND: "BF040",
-      CIRCULAR_DEPENDENCY: "BF041",
-      INVALID_COMPONENT_NAME: "BF042",
+      // Component errors (BF043-BF049)
       PROPS_DESTRUCTURING: "BF043",
       SIGNAL_GETTER_NOT_CALLED: "BF044",
       JSX_IN_LOCAL_FUNCTION: "BF045",
@@ -1414,12 +1405,8 @@ var init_errors = __esm({
     errorMessages = {
       [ErrorCodes.MISSING_USE_CLIENT]: "'use client' directive required for components with createSignal or event handlers",
       [ErrorCodes.CLIENT_IMPORTING_SERVER]: "Client component cannot import server component",
-      [ErrorCodes.UNKNOWN_SIGNAL]: "Unknown signal reference",
       [ErrorCodes.SIGNAL_OUTSIDE_COMPONENT]: "Module-level reactive declaration (createSignal / createMemo) is not allowed. The downstream codegen drops the declaration silently and every reference becomes a ReferenceError at SSR and at hydrate. Move the declaration inside a component function so each mount gets its own state.",
-      [ErrorCodes.INVALID_SIGNAL_USAGE]: "Invalid signal usage",
-      [ErrorCodes.INVALID_JSX_EXPRESSION]: "Invalid JSX expression",
       [ErrorCodes.UNSUPPORTED_JSX_PATTERN]: "Unsupported JSX pattern",
-      [ErrorCodes.INVALID_JSX_ATTRIBUTE]: "Invalid JSX attribute",
       [ErrorCodes.MISSING_KEY_IN_LIST]: "Missing key attribute in list rendering. Add a key prop for efficient updates",
       [ErrorCodes.MISSING_KEY_IN_NESTED_LIST]: "Nested .map() loop requires key attribute for event delegation. Add a key prop to elements in the inner loop",
       [ErrorCodes.UNSUPPORTED_DESTRUCTURE_REST]: (
@@ -1431,11 +1418,6 @@ var init_errors = __esm({
         // stable.
         "Computed property key in .map() callback destructure is not supported. Rewrite the callback to destructure explicit bindings (e.g., `({ a, b }) => ...`) so the compiler can rewrite references to per-item signal accessors."
       ),
-      [ErrorCodes.TYPE_INFERENCE_FAILED]: "Failed to infer type",
-      [ErrorCodes.PROPS_TYPE_MISMATCH]: "Props type mismatch",
-      [ErrorCodes.COMPONENT_NOT_FOUND]: "Component not found",
-      [ErrorCodes.CIRCULAR_DEPENDENCY]: "Circular dependency detected",
-      [ErrorCodes.INVALID_COMPONENT_NAME]: "Component name must start with uppercase letter",
       [ErrorCodes.PROPS_DESTRUCTURING]: "Props destructuring in function parameters breaks reactivity. Use props object directly.",
       [ErrorCodes.SIGNAL_GETTER_NOT_CALLED]: "Signal/memo getter passed without calling it. Use getter() to read the value.",
       [ErrorCodes.JSX_IN_LOCAL_FUNCTION]: "Local function returns JSX but cannot be inlined. Extract it as a top-level PascalCase component or use a single return statement.",
@@ -1447,7 +1429,7 @@ var init_errors = __esm({
       [ErrorCodes.STRIPPED_CLIENT_IMPORT_REFERENCED]: "Import was stripped from the client bundle but its binding is still referenced. Client components ('use client' .tsx) are not callable as plain functions from imperative .ts modules \u2014 render them as JSX from a 'use client' parent instead. If the flagged name is a local shadow rather than the stripped import, please file an issue.",
       [ErrorCodes.STAGE_REACTIVE_IN_TEMPLATE]: "Reactive binding (signal getter or memo) referenced from template scope. The template lambda runs at module scope without the reactive context, so the value cannot be evaluated at SSR. Wrap the JSX expression in /* @client */ to defer it to hydrate, or restructure so the template uses a prop or static value.",
       [ErrorCodes.STAGE_INIT_LOCAL_IN_TEMPLATE]: "Init-scope local referenced from template scope. The template lambda runs at module scope (via render() / renderChild()) and cannot reach init-body locals. Wrap the JSX expression in /* @client */, or lift the value to a prop or module-scope const.",
-      [ErrorCodes.STAGE_AWAIT_IN_TEMPLATE]: "AwaitExpression in template scope. The hydrate-time template lambda is synchronous; awaiting here would hang first render. Move the await into a server-side handler and pass the resolved value as a prop.",
+      [ErrorCodes.STAGE_AWAIT_IN_TEMPLATE]: "AwaitExpression in template scope. The generated template and init functions are synchronous \u2014 a bare `await` produces a SyntaxError at parse time. Move the await into the component body (before the return) or into an onMount/effect callback, and pass the resolved value to JSX.",
       [ErrorCodes.INLINE_JSX_CALLBACK_CAPTURE]: "Inline JSX-returning arrow function captures a non-module identifier. 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.",
       [ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY]: "Tuple destructuring of a non-reactive factory call. The compiler only recognizes createSignal / createMemo calls and same-file helpers that wrap them with a single `return [a, b]` exit."
     };
@@ -2443,6 +2425,126 @@ function extractSingleJsxReturn(body) {
   if (returnCount !== 1) return null;
   return jsxReturn;
 }
+function extractMultiReturnJsxBranches(body) {
+  const branches = [];
+  let fallback = null;
+  const stmts = body.statements;
+  for (let i = 0; i < stmts.length; i++) {
+    const stmt = stmts[i];
+    if (ts6.isIfStatement(stmt)) {
+      let current = stmt;
+      while (ts6.isIfStatement(current)) {
+        const ifStmt = current;
+        if (!isDirectReturnBlock(ifStmt.thenStatement)) return null;
+        const jsxReturn = findJsxReturnInBlock(ifStmt.thenStatement);
+        const nullReturn = findNullReturnInBlock(ifStmt.thenStatement);
+        if (!jsxReturn && !nullReturn) return null;
+        branches.push({ condition: ifStmt.expression, jsxReturn: jsxReturn ?? null });
+        if (ifStmt.elseStatement) {
+          if (ts6.isIfStatement(ifStmt.elseStatement)) {
+            current = ifStmt.elseStatement;
+            continue;
+          }
+          if (!isDirectReturnBlock(ifStmt.elseStatement)) return null;
+          const elseJsx = findJsxReturnInBlock(ifStmt.elseStatement);
+          if (elseJsx) {
+            fallback = elseJsx;
+          } else if (!findNullReturnInBlock(ifStmt.elseStatement)) {
+            return null;
+          }
+          if (branches.length === 0) return null;
+          return { branches, fallback };
+        }
+        break;
+      }
+      continue;
+    }
+    if (ts6.isSwitchStatement(stmt)) {
+      if (branches.length > 0) return null;
+      if (!ts6.isIdentifier(stmt.expression) && !ts6.isPropertyAccessExpression(stmt.expression)) {
+        return null;
+      }
+      const hasDefault = stmt.caseBlock.clauses.some((c) => ts6.isDefaultClause(c));
+      if (!hasDefault) return null;
+      for (const clause of stmt.caseBlock.clauses) {
+        const jsxReturn = findJsxReturnInCaseClause(clause);
+        const nullReturn = findNullReturnInCaseClause(clause);
+        if (!jsxReturn && !nullReturn) return null;
+        if (ts6.isCaseClause(clause)) {
+          branches.push({
+            condition: clause.expression,
+            jsxReturn: jsxReturn ?? null
+          });
+        } else {
+          fallback = jsxReturn ?? null;
+        }
+      }
+      if (branches.length === 0) return null;
+      return { branches, fallback, switchDiscriminant: stmt.expression };
+    }
+    if (ts6.isReturnStatement(stmt) && stmt.expression) {
+      const expr = unwrapJsxTransparent(stmt.expression);
+      if (ts6.isJsxElement(expr) || ts6.isJsxSelfClosingElement(expr) || ts6.isJsxFragment(expr)) {
+        fallback = expr;
+      } else if (expr.kind === ts6.SyntaxKind.NullKeyword) {
+      } else {
+        return null;
+      }
+      continue;
+    }
+    if (ts6.isVariableStatement(stmt)) return null;
+    return null;
+  }
+  if (branches.length === 0) return null;
+  return { branches, fallback };
+}
+function isDirectReturnBlock(node) {
+  if (ts6.isReturnStatement(node)) return true;
+  if (ts6.isBlock(node)) {
+    let returnCount = 0;
+    for (const stmt of node.statements) {
+      if (ts6.isReturnStatement(stmt)) {
+        returnCount++;
+      } else if (ts6.isIfStatement(stmt) || ts6.isSwitchStatement(stmt) || ts6.isForStatement(stmt) || ts6.isForOfStatement(stmt) || ts6.isForInStatement(stmt) || ts6.isWhileStatement(stmt) || ts6.isDoStatement(stmt) || ts6.isTryStatement(stmt)) {
+        return false;
+      }
+    }
+    return returnCount === 1;
+  }
+  return false;
+}
+function findNullReturnInBlock(node) {
+  if (ts6.isBlock(node)) {
+    for (const stmt of node.statements) {
+      if (ts6.isReturnStatement(stmt) && stmt.expression) {
+        const expr = unwrapJsxTransparent(stmt.expression);
+        if (expr.kind === ts6.SyntaxKind.NullKeyword) return true;
+      }
+    }
+  }
+  if (ts6.isReturnStatement(node) && node.expression) {
+    const expr = unwrapJsxTransparent(node.expression);
+    if (expr.kind === ts6.SyntaxKind.NullKeyword) return true;
+  }
+  return false;
+}
+function findJsxReturnInCaseClause(clause) {
+  for (const stmt of clause.statements) {
+    if (ts6.isReturnStatement(stmt) && stmt.expression) {
+      return extractJsxFromExpression(stmt.expression);
+    }
+  }
+  return null;
+}
+function findNullReturnInCaseClause(clause) {
+  for (const stmt of clause.statements) {
+    if (ts6.isReturnStatement(stmt) && stmt.expression) {
+      const expr = unwrapJsxTransparent(stmt.expression);
+      if (expr.kind === ts6.SyntaxKind.NullKeyword) return true;
+    }
+  }
+  return false;
+}
 function isMultiReturnJsxFunctionBody(body) {
   let returnCount = 0;
   let hasJsxReturn = false;
@@ -2519,6 +2621,15 @@ function collectFunction(node, ctx2, _isModule, isExported = false) {
         jsxReturn,
         params: node.parameters.map((p) => p.name.getText(ctx2.sourceFile))
       });
+    } else {
+      const multi = extractMultiReturnJsxBranches(node.body);
+      if (multi) {
+        isJsxFunction = true;
+        ctx2.jsxMultiReturnFunctions.set(name, {
+          ...multi,
+          params: node.parameters.map((p) => p.name.getText(ctx2.sourceFile))
+        });
+      }
     }
   }
   const isAsync = node.modifiers?.some((m) => m.kind === ts6.SyntaxKind.AsyncKeyword) ?? false;
@@ -2739,6 +2850,15 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
             jsxReturn,
             params: init.parameters.map((p) => p.name.getText(ctx2.sourceFile))
           });
+        } else {
+          const multi = extractMultiReturnJsxBranches(arrowBody);
+          if (multi) {
+            isJsxFunction = true;
+            ctx2.jsxMultiReturnFunctions.set(name, {
+              ...multi,
+              params: init.parameters.map((p) => p.name.getText(ctx2.sourceFile))
+            });
+          }
         }
       } else {
         let body = arrowBody;
@@ -2991,7 +3111,7 @@ function inferTypeFromValue(value) {
   if (/\.(some|every|includes)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
     return { kind: "primitive", raw: "boolean", primitive: "boolean" };
   }
-  if (/\.(indexOf|findIndex|lastIndexOf)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
+  if (/\.(indexOf|findIndex|findLastIndex|lastIndexOf)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
     return { kind: "primitive", raw: "number", primitive: "number" };
   }
   if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
@@ -3685,7 +3805,7 @@ function convertNode(node, raw) {
   if (ts7.isCallExpression(node)) {
     const callee = convertNode(node.expression, raw);
     const args2 = node.arguments.map((arg) => convertNode(arg, raw));
-    if (callee.kind === "member" && ["filter", "every", "some", "find", "findIndex"].includes(callee.property)) {
+    if (callee.kind === "member" && ["filter", "every", "some", "find", "findIndex", "findLast", "findLastIndex"].includes(callee.property)) {
       if (args2.length === 1 && args2[0].kind === "arrow-fn") {
         const arrowFn = args2[0];
         return {
@@ -4670,19 +4790,17 @@ var init_expression_parser = __esm({
   "../jsx/src/expression-parser.ts"() {
     "use strict";
     UNSUPPORTED_METHODS = /* @__PURE__ */ new Set([
-      // Higher-order array methods. Five of these (`filter`, `every`,
-      // `some`, `find`, `findIndex`) are intercepted as `higher-order`
-      // IR before reaching this gate; `map` is intercepted as an
-      // IRLoop. The rest stay refused — see #1448 Tier C for the
-      // design questions.
+      // Higher-order array methods. Seven of these (`filter`, `every`,
+      // `some`, `find`, `findIndex`, `findLast`, `findLastIndex`) are
+      // intercepted as `higher-order` IR before reaching this gate;
+      // `map` is intercepted as an IRLoop. The rest stay refused — see
+      // #1448 Tier C for the design questions.
       "filter",
       "map",
       "reduce",
       "reduceRight",
       "every",
       "some",
-      "findLast",
-      "findLastIndex",
       "forEach",
       "flatMap",
       "flat"
@@ -5643,6 +5761,23 @@ function transformExpressionInner(expr, ctx2, node, isClientOnly) {
     }
     return ir;
   }
+  if (containsAwaitExpression(expr)) {
+    ctx2.analyzer.errors.push(
+      createError(
+        ErrorCodes.STAGE_AWAIT_IN_TEMPLATE,
+        getSourceLocation(expr, ctx2.sourceFile, ctx2.filePath)
+      )
+    );
+    return {
+      type: "expression",
+      expr: "undefined",
+      typeInfo: null,
+      reactive: false,
+      slotId: null,
+      loc: getSourceLocation(node, ctx2.sourceFile, ctx2.filePath),
+      origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
+    };
+  }
   const exprText = ctx2.getJS(expr);
   const freeRefs = resolveFreeRefs(expr, makeBindingEnv(ctx2));
   const origin = {
@@ -5714,6 +5849,105 @@ function transformJsxFunctionCall(callExpr, jsxFunc, ctx2, _isClientOnly) {
     ctx2.analyzer.getJS = originalAnalyzerGetJS;
   }
 }
+function transformMultiReturnJsxFunctionCall(callExpr, info, ctx2) {
+  const substitutions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < info.params.length; i++) {
+    const paramName = info.params[i];
+    const arg = callExpr.arguments[i];
+    if (arg) {
+      substitutions.set(paramName, ctx2.getJS(arg));
+    }
+  }
+  const baseGetJS = ctx2.analyzer.getJS.bind(ctx2.analyzer);
+  const originalCtxGetJS = ctx2.getJS;
+  const originalAnalyzerGetJS = ctx2.analyzer.getJS;
+  const substitutedGetJS = (node) => {
+    let text = baseGetJS(node);
+    for (const [paramName, argExpr] of substitutions) {
+      text = text.replace(new RegExp(`\\b${paramName}\\b`, "g"), argExpr);
+    }
+    return text;
+  };
+  ctx2.getJS = substitutedGetJS;
+  ctx2.analyzer.getJS = substitutedGetJS;
+  try {
+    const loc = getSourceLocation(callExpr, ctx2.sourceFile, ctx2.filePath);
+    const nullExpr = {
+      type: "expression",
+      expr: "null",
+      typeInfo: { kind: "primitive", raw: "null", primitive: "null" },
+      reactive: false,
+      slotId: null,
+      loc,
+      origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
+    };
+    let result = info.fallback ? transformNode(info.fallback, ctx2) ?? nullExpr : nullExpr;
+    for (let i = info.branches.length - 1; i >= 0; i--) {
+      const branch = info.branches[i];
+      let conditionText;
+      if (info.switchDiscriminant) {
+        const discText = substitutedGetJS(info.switchDiscriminant);
+        const caseText = substitutedGetJS(branch.condition);
+        conditionText = `${discText} === ${caseText}`;
+      } else {
+        conditionText = substitutedGetJS(branch.condition);
+      }
+      const env = makeBindingEnv(ctx2);
+      const caseFreeRefs = resolveFreeRefs(branch.condition, env);
+      const discFreeRefs = info.switchDiscriminant ? resolveFreeRefs(info.switchDiscriminant, env) : [];
+      const conditionOrigin = {
+        phase: "tick",
+        scope: "template",
+        effect: "pure",
+        freeRefs: [...discFreeRefs, ...caseFreeRefs]
+      };
+      const reactive = isReactiveExpression(conditionText, ctx2, branch.condition) || isReactiveOrigin(conditionOrigin);
+      const loopParamReactive = !reactive && referencesLoopParam(conditionText, ctx2);
+      const callsReactive = exprCallsReactiveGetters(branch.condition, ctx2) || (info.switchDiscriminant ? exprCallsReactiveGetters(info.switchDiscriminant, ctx2) : false);
+      const hasCalls = exprHasFunctionCalls(branch.condition) || (info.switchDiscriminant ? exprHasFunctionCalls(info.switchDiscriminant) : false);
+      const needsSlot = reactive || loopParamReactive || callsReactive || hasCalls;
+      const slotId = needsSlot ? generateSlotId(ctx2) : null;
+      const whenTrue = branch.jsxReturn ? transformNode(branch.jsxReturn, ctx2) ?? nullExpr : nullExpr;
+      let templateCondition;
+      if (info.switchDiscriminant) {
+        const discRewritten = rewriteBarePropRefs2(
+          substitutedGetJS(info.switchDiscriminant),
+          info.switchDiscriminant,
+          ctx2
+        );
+        const caseRewritten = rewriteBarePropRefs2(
+          substitutedGetJS(branch.condition),
+          branch.condition,
+          ctx2
+        );
+        const discPart = discRewritten ?? substitutedGetJS(info.switchDiscriminant);
+        const casePart = caseRewritten ?? substitutedGetJS(branch.condition);
+        templateCondition = `${discPart} === ${casePart}`;
+      } else {
+        templateCondition = rewriteBarePropRefs2(conditionText, branch.condition, ctx2);
+      }
+      const conditional = {
+        type: "conditional",
+        condition: conditionText,
+        templateCondition,
+        conditionType: null,
+        reactive,
+        whenTrue,
+        whenFalse: result,
+        slotId,
+        callsReactiveGetters: callsReactive || void 0,
+        hasFunctionCalls: hasCalls || void 0,
+        loc,
+        origin: conditionOrigin
+      };
+      result = conditional;
+    }
+    return result;
+  } finally {
+    ctx2.getJS = originalCtxGetJS;
+    ctx2.analyzer.getJS = originalAnalyzerGetJS;
+  }
+}
 function transformConditional(node, ctx2) {
   const condition = ctx2.getJS(node.condition);
   const conditionOrigin = {
@@ -5795,6 +6029,11 @@ function containsJsxInExpression(node) {
   }
   return ts10.forEachChild(node, containsJsxInExpression) ?? false;
 }
+function containsAwaitExpression(node) {
+  if (ts10.isAwaitExpression(node)) return true;
+  if (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node)) return false;
+  return ts10.forEachChild(node, containsAwaitExpression) ?? false;
+}
 function transformNullishCoalescing(node, ctx2) {
   const leftText = ctx2.getJS(node.left);
   const isNullish = node.operatorToken.kind === ts10.SyntaxKind.QuestionQuestionToken;
@@ -5888,6 +6127,10 @@ function transformJsxExpression(expr, ctx2, isClientOnly = false) {
         if (jsxFunc) {
           return transformJsxFunctionCall(node, jsxFunc, ctx2, isClientOnly);
         }
+        const multiJsxFunc = ctx2.analyzer.jsxMultiReturnFunctions.get(callee.text);
+        if (multiJsxFunc) {
+          return transformMultiReturnJsxFunctionCall(node, multiJsxFunc, ctx2);
+        }
       }
       return null;
     }
@@ -5925,10 +6168,22 @@ function transformJsxExpression(expr, ctx2, isClientOnly = false) {
     case ts10.SyntaxKind.ArrayLiteralExpression:
       return null;
     // --- Forbidden in render position ---
-    // Spec A.3.3 / A.3.5 reserve BF050 (`AwaitExpression`) and BF051
-    // (`YieldExpression`) for PR 5 once the dispatcher is the single
-    // entry point; for now preserve today's scalar-fallback behaviour.
     case ts10.SyntaxKind.AwaitExpression:
+      ctx2.analyzer.errors.push(
+        createError(
+          ErrorCodes.STAGE_AWAIT_IN_TEMPLATE,
+          getSourceLocation(node, ctx2.sourceFile, ctx2.filePath)
+        )
+      );
+      return {
+        type: "expression",
+        expr: "undefined",
+        typeInfo: null,
+        reactive: false,
+        slotId: null,
+        loc: getSourceLocation(node, ctx2.sourceFile, ctx2.filePath),
+        origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
+      };
     case ts10.SyntaxKind.YieldExpression:
       return null;
     // --- Unreachable at render position ---
@@ -6578,7 +6833,8 @@ function transformMapCall(node, ctx2, isClientOnly = false, method = "map") {
   const bodyIsMultiRoot = loopBodyIsMultiRoot(children);
   const callsReactive = exprCallsReactiveGetters(arrayExpr, ctx2);
   const hasCalls = exprHasFunctionCalls(arrayExpr);
-  const isStaticArray = !isSignalOrMemoArray(array, ctx2) && !hasCalls;
+  const isDirectPropArray = method !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx2);
+  const isStaticArray = !isSignalOrMemoArray(array, ctx2) && !isDirectPropArray && !hasCalls;
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -6601,6 +6857,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method = "map") {
     // and ssr-hydration-contract assertions don't shift when loops are added.
     markerId: `l${ctx2.loopMarkerCounter++}`,
     isStaticArray,
+    isPropDerivedArray: isDirectPropArray || void 0,
     callsReactiveGetters: callsReactive || void 0,
     hasFunctionCalls: hasCalls || void 0,
     bodyIsMultiRoot: bodyIsMultiRoot || void 0,
@@ -6857,6 +7114,15 @@ function getAttributeValue(attr, ctx2) {
         expr = branchInit;
       }
     }
+    if (ts10.isAwaitExpression(expr)) {
+      ctx2.analyzer.errors.push(
+        createError(
+          ErrorCodes.STAGE_AWAIT_IN_TEMPLATE,
+          getSourceLocation(expr, ctx2.sourceFile, ctx2.filePath)
+        )
+      );
+      return AttrValueOf.expression("undefined");
+    }
     checkBareSignalOrMemoIdentifier(expr, ctx2);
     if (attr.name.getText(ctx2.sourceFile) === "style" && ts10.isObjectLiteralExpression(expr)) {
       const cssString = tryStaticStyleObjectToCss(expr);
@@ -7176,6 +7442,20 @@ function checkBareSignalOrMemoIdentifier(expr, ctx2) {
     }
   }
 }
+function isArrayExprDirectPropRef(arrayExpr, ctx2) {
+  const propNames = new Set(ctx2.patterns.props.map((p) => p.name));
+  const propsObjName = ctx2.analyzer.propsObjectName;
+  if (ts10.isIdentifier(arrayExpr)) {
+    return propNames.has(arrayExpr.text);
+  }
+  if (ts10.isPropertyAccessExpression(arrayExpr) && propsObjName) {
+    const obj = arrayExpr.expression;
+    if (ts10.isIdentifier(obj) && obj.text === propsObjName) {
+      return true;
+    }
+  }
+  return false;
+}
 function isSignalOrMemoArray(array, ctx2) {
   for (const { pattern } of ctx2.patterns.signals) {
     if (pattern.test(array)) return true;
@@ -12730,14 +13010,11 @@ function buildReactiveEmit(inner, level, wrapOuter) {
   }));
   const reactiveAttrs = inner.bindings.reactiveAttrs.map((attr) => {
     const wrapped = wrapLoopParamAsAccessor(wrapOuter(attr.expression), inner.param, inner.paramBindings);
-    const isStyleObject = attr.attrName === "style" && /^\s*\{/.test(attr.expression);
     return {
       slotId: attr.childSlotId,
-      attrName: toHtmlAttrName(attr.attrName),
+      attrName: attr.attrName,
       wrappedExpression: wrapped,
-      isStyleObject,
-      isBoolean: isBooleanAttr(attr.attrName),
-      presenceOrUndefined: !!attr.presenceOrUndefined
+      meta: pickAttrMeta(attr)
     };
   });
   const preludeStatements = [];
@@ -12777,8 +13054,6 @@ var init_build_inner_loop = __esm({
     init_utils();
     init_shared();
     init_shared();
-    init_utils();
-    init_html_constants();
   }
 });
 
@@ -13876,16 +14151,11 @@ function emitReactive(lines, inner, indent) {
   for (const attr of emit.reactiveAttrs) {
     const targetVar = `__ta_${attr.slotId.replace(/[^a-zA-Z0-9]/g, "_")}`;
     lines.push(`${indent}  { const ${targetVar} = qsa(__innerEl${uid}, '[bf="${attr.slotId}"]')`);
-    if (attr.isStyleObject) {
-      lines.push(`${indent}  if (${targetVar}) createEffect(() => { const __v = styleToCss(${attr.wrappedExpression}); if (__v != null) ${targetVar}.setAttribute('style', __v); else ${targetVar}.removeAttribute('style') }) }`);
-    } else if (attr.isBoolean) {
-      lines.push(`${indent}  if (${targetVar}) createEffect(() => { if (${attr.wrappedExpression}) ${targetVar}.setAttribute('${attr.attrName}', ''); else ${targetVar}.removeAttribute('${attr.attrName}') }) }`);
-    } else if (attr.presenceOrUndefined) {
-      const ariaVal = attr.attrName.startsWith("aria-") ? "'true'" : "''";
-      lines.push(`${indent}  if (${targetVar}) createEffect(() => { if (${attr.wrappedExpression}) ${targetVar}.setAttribute('${attr.attrName}', ${ariaVal}); else ${targetVar}.removeAttribute('${attr.attrName}') }) }`);
-    } else {
-      lines.push(`${indent}  if (${targetVar}) createEffect(() => { const __v = ${attr.wrappedExpression}; if (__v != null) ${targetVar}.setAttribute('${attr.attrName}', String(__v)); else ${targetVar}.removeAttribute('${attr.attrName}') }) }`);
+    lines.push(`${indent}  if (${targetVar}) createEffect(() => {`);
+    for (const stmt of emitAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta)) {
+      lines.push(`${indent}    ${stmt}`);
     }
+    lines.push(`${indent}  }) }`);
   }
   emitLoopChildRefs(lines, emit.childRefs, {
     indent: `${indent}  `,
@@ -13934,6 +14204,7 @@ var init_inner_loop = __esm({
     "use strict";
     init_utils();
     init_shared();
+    init_emit_reactive();
     init_template_parse();
     init_loop();
   }
@@ -19655,13 +19926,56 @@ function parseMdx(source) {
   const nodes = [];
   let buffer = [];
   let inFence = false;
+  let inBlock = false;
+  let blockName = "";
+  let blockProps = {};
+  let blockChildren = [];
+  let blockChildProps = null;
+  let blockBuffer = [];
+  let blockFence = false;
   const flushBuffer = () => {
     if (buffer.length === 0) return;
     const text = buffer.join("\n").replace(/^\n+|\n+$/g, "");
     if (text.length > 0) nodes.push({ type: "md", text });
     buffer = [];
   };
+  const flushBlockChild = () => {
+    if (blockChildProps !== null) {
+      const content = blockBuffer.join("\n").replace(/^\n+|\n+$/g, "");
+      blockChildren.push({ props: blockChildProps, content });
+      blockBuffer = [];
+    }
+  };
   for (const line of lines) {
+    if (inBlock) {
+      if (FENCE_RE.test(line)) {
+        blockFence = !blockFence;
+        blockBuffer.push(line);
+        continue;
+      }
+      if (!blockFence) {
+        const closeMatch = line.match(CLOSE_TAG_RE);
+        if (closeMatch && closeMatch[1] === blockName) {
+          flushBlockChild();
+          nodes.push({ type: "jsx-block", name: blockName, props: blockProps, children: blockChildren });
+          inBlock = false;
+          blockName = "";
+          blockProps = {};
+          blockChildren = [];
+          blockChildProps = null;
+          blockBuffer = [];
+          continue;
+        }
+        const tabMatch = line.match(TAG_LINE_RE);
+        if (tabMatch) {
+          flushBlockChild();
+          blockChildProps = parseProps(tabMatch[2]);
+          continue;
+        }
+      }
+      blockBuffer.push(line);
+      continue;
+    }
     if (FENCE_RE.test(line)) {
       inFence = !inFence;
       buffer.push(line);
@@ -19674,6 +19988,18 @@ function parseMdx(source) {
         nodes.push({ type: "jsx", name: match[1], props: parseProps(match[2]) });
         continue;
       }
+      const openMatch = line.match(OPEN_TAG_RE);
+      if (openMatch) {
+        flushBuffer();
+        inBlock = true;
+        blockName = openMatch[1];
+        blockProps = parseProps(openMatch[2]);
+        blockChildren = [];
+        blockChildProps = null;
+        blockBuffer = [];
+        blockFence = false;
+        continue;
+      }
     }
     buffer.push(line);
   }
@@ -19685,6 +20011,10 @@ function projectMdxToMarkdown(source, projectors) {
   const fm = Object.entries(parsed.frontmatter).map(([k, v]) => `${k}: ${v}`).join("\n");
   const body = parsed.nodes.map((node) => {
     if (node.type === "md") return node.text;
+    if (node.type === "jsx-block") {
+      const project2 = projectors[node.name];
+      return project2 ? project2(node.props, node.children) : "";
+    }
     const project = projectors[node.name];
     return project ? project(node.props) : "";
   }).filter((chunk) => chunk.length > 0).join("\n\n");
@@ -19709,11 +20039,13 @@ function renderPackageManagerCommand(pm, command2, mode) {
   if (pm === "yarn") return `yarn dlx ${command2}`;
   return `npx ${command2}`;
 }
-var TAG_LINE_RE, FENCE_RE, ATTR_RE, defaultMdxProjectors;
+var TAG_LINE_RE, OPEN_TAG_RE, CLOSE_TAG_RE, FENCE_RE, ATTR_RE, defaultMdxProjectors;
 var init_mdx = __esm({
   "src/lib/mdx.ts"() {
     "use strict";
     TAG_LINE_RE = /^[\t ]*<([A-Z][A-Za-z0-9]*)\b([^>]*?)\/>[\t ]*$/;
+    OPEN_TAG_RE = /^[\t ]*<([A-Z][A-Za-z0-9]*)\b([^>]*?)>[\t ]*$/;
+    CLOSE_TAG_RE = /^[\t ]*<\/([A-Z][A-Za-z0-9]*)>[\t ]*$/;
     FENCE_RE = /^[\t ]*(```|~~~)/;
     ATTR_RE = /([a-zA-Z][a-zA-Z0-9-]*)\s*=\s*"([^"]*)"/g;
     defaultMdxProjectors = {
@@ -19721,6 +20053,16 @@ var init_mdx = __esm({
         const pm = defaultPm || "npm";
         const cmd = renderPackageManagerCommand(pm, command2 || "", mode || "dlx");
         return "```bash\n" + cmd + "\n```";
+      },
+      Tabs: (props, children) => {
+        if (!children || children.length === 0) {
+          const labels = props.labels;
+          if (labels) return labels.split(",").map((l) => `- ${l.trim()}`).join("\n");
+          return "";
+        }
+        const defaultLabel = props.default;
+        const defaultChild = children.find((c) => c.props.label === defaultLabel) || children[0];
+        return defaultChild?.content || "";
       }
     };
   }
@@ -21050,7 +21392,7 @@ var bfGoSource, streamingGoSource, barefootPmSource, barefootPluginPmSource, bar
 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	"os"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Arithmetic\n		"bf_add": Add,\n		"bf_sub": Sub,\n		"bf_mul": Mul,\n		"bf_div": Div,\n		"bf_mod": Mod,\n		"bf_neg": Neg,\n\n		// String\n		"bf_lower":    Lower,\n		"bf_upper":    Upper,\n		"bf_trim":     Trim,\n		"bf_contains": Contains,\n		"bf_join":     Join,\n		"bf_string":   String,\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\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_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_sort":       Sort,\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		// Scope comment for fragment roots\n		"bfScopeComment": ScopeComment,\n\n		// JSX intrinsic-element spread lowering (#1407)\n		"bf_spread_attrs": SpreadAttrs,\n	}\n}\n\n// ScopeAttr returns the bare bf-s scope id (#1249).\nfunc ScopeAttr(props interface{}) string {\n	return getStringField(props, "ScopeID")\n}\n\n// HydrationAttrs emits `bf-h="<host>" bf-m="<slot>" bf-r=""` conditionally.\n// See spec/compiler.md "Slot identity".\nfunc HydrationAttrs(props interface{}) template.HTMLAttr {\n	parts := []string{}\n	if host := getStringField(props, "BfParent"); host != "" {\n		parts = append(parts, fmt.Sprintf(`bf-h="%s"`, template.HTMLEscapeString(host)))\n	}\n	if mount := getStringField(props, "BfMount"); mount != "" {\n		parts = append(parts, fmt.Sprintf(`bf-m="%s"`, template.HTMLEscapeString(mount)))\n	}\n	if !getBoolField(props, "BfIsChild") {\n		parts = append(parts, `bf-r=""`)\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// IsChild is a deprecated no-op stub. Child status is signalled by bf-h\n// presence (#1249); use HydrationAttrs instead.\nfunc IsChild(props interface{}) template.HTMLAttr {\n	return ""\n}\n\n// svgCamelCaseAttrs mirrors SVG_CAMEL_CASE_ATTRS from\n// packages/client/src/runtime/spread-attrs.ts. SVG XML attribute\n// names are case-sensitive; the default camelCase \u2192 kebab-case\n// rewrite must NOT apply to these or the SVG stops rendering\n// (#1407). Coordinates with the compile-time SVG_CAMEL_TO_KEBAB\n// table in packages/jsx/src/ir-to-client-js/utils.ts: presentation\n// attrs (clipPath, strokeWidth, \u2026) live there and must NOT appear\n// here, or the same JSX prop would lower to clip-path via the\n// explicit-attr path and stay clipPath via the spread path.\nvar svgCamelCaseAttrs = map[string]struct{}{\n	"allowReorder": {}, "attributeName": {}, "attributeType": {}, "autoReverse": {},\n	"baseFrequency": {}, "baseProfile": {}, "calcMode": {}, "clipPathUnits": {},\n	"contentScriptType": {}, "contentStyleType": {}, "diffuseConstant": {}, "edgeMode": {},\n	"externalResourcesRequired": {}, "filterRes": {}, "filterUnits": {}, "glyphRef": {},\n	"gradientTransform": {}, "gradientUnits": {}, "kernelMatrix": {}, "kernelUnitLength": {},\n	"keyPoints": {}, "keySplines": {}, "keyTimes": {}, "lengthAdjust": {}, "limitingConeAngle": {},\n	"markerHeight": {}, "markerUnits": {}, "markerWidth": {}, "maskContentUnits": {},\n	"maskUnits": {}, "numOctaves": {}, "pathLength": {}, "patternContentUnits": {},\n	"patternTransform": {}, "patternUnits": {}, "pointsAtX": {}, "pointsAtY": {}, "pointsAtZ": {},\n	"preserveAlpha": {}, "preserveAspectRatio": {}, "primitiveUnits": {}, "refX": {}, "refY": {},\n	"repeatCount": {}, "repeatDur": {}, "requiredExtensions": {}, "requiredFeatures": {},\n	"specularConstant": {}, "specularExponent": {}, "spreadMethod": {}, "startOffset": {},\n	"stdDeviation": {}, "stitchTiles": {}, "surfaceScale": {}, "systemLanguage": {},\n	"tableValues": {}, "targetX": {}, "targetY": {}, "textLength": {}, "viewBox": {}, "viewTarget": {},\n	"xChannelSelector": {}, "yChannelSelector": {}, "zoomAndPan": {},\n}\n\n// toAttrName mirrors the JSX\u2192HTML attribute-name rewrite from\n// packages/client/src/runtime/spread-attrs.ts. className \u2192 class,\n// htmlFor \u2192 for, SVG camelCase attrs preserved, other camelCase\n// keys lowered to kebab-case.\nfunc toAttrName(key string) string {\n	if key == "className" {\n		return "class"\n	}\n	if key == "htmlFor" {\n		return "for"\n	}\n	if _, ok := svgCamelCaseAttrs[key]; ok {\n		return key\n	}\n	// camelCase \u2192 kebab-case: mirror the JS reference exactly\n	// (`key.replace(/([A-Z])/g, \'-$1\').toLowerCase()`). The JS shape\n	// produces a leading `-` for an initial uppercase letter\n	// (`XData` \u2192 `-x-data`); both this Go path and the matching JS\n	// runtime are wrong-by-construction for that case (the resulting\n	// HTML attribute name is invalid), but keeping them byte-equal\n	// avoids silent SSR/CSR divergence (#1411 review).\n	var b strings.Builder\n	for _, r := range key {\n		if r >= \'A\' && r <= \'Z\' {\n			b.WriteByte(\'-\')\n			b.WriteRune(r + 32)\n		} else {\n			b.WriteRune(r)\n		}\n	}\n	return b.String()\n}\n\n// StyleToCss mirrors styleToCss from\n// packages/client/src/runtime/style.ts. Accepts a string passthrough,\n// or a map (JSON-deserialized object) whose camelCase keys are\n// lowered to kebab-case and joined with `;`. Returns ("", false) for\n// nullish/empty input so callers can omit the attribute entirely.\nfunc StyleToCss(v any) (string, bool) {\n	if v == nil {\n		return "", false\n	}\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return "", false\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		// Non-object: stringify and return as-is, matching the JS\n		// `typeof value !== \'object\'` branch.\n		s := fmt.Sprint(v)\n		if s == "" {\n			return "", false\n		}\n		return s, true\n	}\n	keys := rv.MapKeys()\n	sorted := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sorted = append(sorted, k.String())\n		}\n	}\n	sort.Strings(sorted)\n	parts := make([]string, 0, len(sorted))\n	for _, k := range sorted {\n		val := rv.MapIndex(reflect.ValueOf(k))\n		// Skip nil entries (matches the JS `if (v == null) continue`).\n		if !val.IsValid() {\n			continue\n		}\n		if val.Kind() == reflect.Interface || val.Kind() == reflect.Pointer {\n			if val.IsNil() {\n				continue\n			}\n			val = val.Elem()\n		}\n		prop := toAttrName(k)\n		parts = append(parts, fmt.Sprintf("%s:%v", prop, val.Interface()))\n	}\n	if len(parts) == 0 {\n		return "", false\n	}\n	return strings.Join(parts, ";"), true\n}\n\n// SpreadAttrs lowers a JSX intrinsic-element spread bag (#1407) to\n// an HTML attribute string. Mirrors spreadAttrs from\n// packages/client/src/runtime/spread-attrs.ts so SSR output matches\n// what CSR\'s `applyRestAttrs` writes at hydration.\n//\n// Skip rules: nil/false values, event handlers (`on[A-Z]*`),\n// `children`, `ref`.\n//\n// Key remap: className \u2192 class, htmlFor \u2192 for, SVG camelCase\n// preserved, other camelCase \u2192 kebab-case.\n//\n// `style` is routed through StyleToCss so object literals serialize\n// to a real CSS string instead of Go\'s default `map[k:v]` form.\n//\n// Booleans: true \u2192 bare attribute name, false \u2192 omitted.\n// Other scalar values are HTML-escaped via template.HTMLEscapeString.\n// Returns a `template.HTMLAttr` so html/template emits the result\n// verbatim (the function does its own escaping).\n//\n// Keys are sorted alphabetically before emission for deterministic\n// output. SSR/CSR attribute-order divergence is acceptable per the\n// rest-destructure-object-spread-in-map fixture\'s documented policy\n// \u2014 browsers honor the LAST value when a key is duplicated, so\n// pairing with static attrs (`<div class="x" {...rest}>`) is\n// last-wins regardless of order.\nfunc SpreadAttrs(bag any) template.HTMLAttr {\n	if bag == nil {\n		return ""\n	}\n	rv := reflect.ValueOf(bag)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return ""\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		return ""\n	}\n	keys := rv.MapKeys()\n	sortedKeys := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sortedKeys = append(sortedKeys, k.String())\n		}\n	}\n	sort.Strings(sortedKeys)\n	parts := make([]string, 0, len(sortedKeys))\n	for _, key := range sortedKeys {\n		// Event handlers \u2014 skip at SSR the same way\n		// packages/client/src/runtime/spread-attrs.ts does at\n		// hydration. The JS predicate is\n		// `key.startsWith(\'on\') && key.length > 2 && key[2] === key[2].toUpperCase()`,\n		// which is true for any character whose uppercase form is\n		// itself: ASCII A-Z, digits, underscore, and non-letter\n		// symbols. Mirror that here by skipping when key[2] is NOT\n		// a lowercase ASCII letter \u2014 so `onClick`, `on_custom`, and\n		// `on0` all match (#1411 review).\n		if len(key) > 2 && key[0] == \'o\' && key[1] == \'n\' && !(key[2] >= \'a\' && key[2] <= \'z\') {\n			continue\n		}\n		// `children` is a JSX construct rendered inside the element,\n		// never a DOM attribute. `ref` is intentionally NOT filtered\n		// here so output stays byte-equal with the JS reference\n		// `spreadAttrs` in packages/client/src/runtime/spread-attrs.ts\n		// (which only filters null/false, event handlers, and\n		// children) \u2014 aligning Go\'s filter set diverges from JS in\n		// the opposite direction. Filtering `ref` consistently across\n		// both SSR runtimes is a separate concern tracked alongside\n		// the JS `applyRestAttrs` vs `spreadAttrs` mismatch (#1411\n		// review).\n		if key == "children" {\n			continue\n		}\n		val := rv.MapIndex(reflect.ValueOf(key))\n		if !val.IsValid() {\n			continue\n		}\n		// Unwrap interface wrappers (json.Unmarshal produces\n		// interface{}-wrapped values for map[string]any).\n		v := val\n		for v.Kind() == reflect.Interface || v.Kind() == reflect.Pointer {\n			if v.IsNil() {\n				// Skip null entries.\n				v = reflect.Value{}\n				break\n			}\n			v = v.Elem()\n		}\n		if !v.IsValid() {\n			continue\n		}\n		// Boolean values: true \u2192 bare attribute, false \u2192 omitted.\n		if v.Kind() == reflect.Bool {\n			if !v.Bool() {\n				continue\n			}\n			parts = append(parts, toAttrName(key))\n			continue\n		}\n		// `style` routes through StyleToCss so object literals get a\n		// real CSS string. The JS side does the same.\n		if key == "style" {\n			css, ok := StyleToCss(v.Interface())\n			if !ok {\n				continue\n			}\n			parts = append(parts, fmt.Sprintf(`style="%s"`, template.HTMLEscapeString(css)))\n			continue\n		}\n		// Stringify and escape. fmt.Sprint handles numbers, bools-as-\n		// strings, and arbitrary stringer types the same way the JS\n		// `String(value)` coercion does for the analogous cases.\n		s := fmt.Sprint(v.Interface())\n		parts = append(parts, fmt.Sprintf(`%s="%s"`, toAttrName(key), template.HTMLEscapeString(s)))\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// String returns the string form of v. Mirrors JS `String(v)` for\n// non-nil values via `fmt.Sprintf("%v", ...)`. Diverges from JS on\n// nil: JS `String(null)` is "null", but the template path renders\n// `nil` as the empty string here so an unset prop doesn\'t surface\n// as a literal "null"/"undefined" in user-facing HTML. Document the\n// divergence explicitly so callers don\'t rely on JS-exact parity.\nfunc String(v any) string {\n	if v == nil {\n		return ""\n	}\n	return fmt.Sprintf("%v", v)\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  DeepEqual element search\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 reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A). The variadic\n// `end` arg lets Go template\'s call dispatcher pass either 2 or 3\n// arguments; an absent end means "to length".\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\n//   - start >= end       \u2192 empty slice (no panic)\n//\n// Non-array receivers return an empty `[]any`.\nfunc Slice(items any, start int, end ...int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n\n	// Normalise start (negative = from end).\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	// Normalise end (optional; absent = length).\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n\n	if start >= stop {\n		return []any{}\n	}\n\n	out := make([]any, 0, stop-start)\n	for i := start; i < stop; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// 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// 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// Every returns true if all items have the specified field set to true.\n// Mirrors JavaScript\'s Array.prototype.every(item => item.field).\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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			return false\n		}\n		if fieldVal.Kind() == reflect.Bool && !fieldVal.Bool() {\n			return false\n		}\n	}\n	return true\n}\n\n// Some returns true if at least one item has the specified field set to true.\n// Mirrors 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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if fieldVal.IsValid() && fieldVal.Kind() == reflect.Bool && fieldVal.Bool() {\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\n	capitalizedField := capitalize(field)\n	var result []any\n\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		// Compare field value with target value\n		if reflect.DeepEqual(fieldVal.Interface(), value) {\n			result = append(result, v.Index(i).Interface())\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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		if reflect.DeepEqual(fieldVal.Interface(), value) {\n			return v.Index(i).Interface()\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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		if reflect.DeepEqual(fieldVal.Interface(), value) {\n			return i\n		}\n	}\n	return -1\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 exactly 5 args):\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"\n//	direction:    "asc" | "desc"\n//\n// The 4 string operands cover the accepted comparator catalogue:\n// `(a,b) => a.f - b.f`, `(a,b) => a - b`, and\n// `(a,b) => a[.f].localeCompare(b[.f])`, each with a reversed\n// counterpart for `desc`. Anything outside the catalogue refuses at\n// compile time (BF101 from the JSX compiler) and never reaches this\n// helper.\n//\n// A future `nulls => "first" | "last"` knob can land as a 6th arg\n// without rewriting the existing call sites \u2014 the keyKind / keyName\n// split already gives the helper everything it needs to project\n// each item\'s sort key before comparing.\nfunc Sort(items any, keyKind string, keyName string, compareType string, direction 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	desc := direction == "desc"\n	sort.SliceStable(result, func(i, j int) bool {\n		ki := projectSortKey(result[i], keyKind, keyName)\n		kj := projectSortKey(result[j], keyKind, keyName)\n		if compareType == "string" {\n			// `toString` maps nil / unknown types to "" \u2014 matches\n			// the documented `bf->string(undef) === ""` divergence\n			// from JS and the Perl `bf->sort` helper\'s `// \'\'`\n			// undef-coalesce. Using `fmt.Sprint` here would sort\n			// missing fields against the literal string "<nil>".\n			si := toString(ki)\n			sj := toString(kj)\n			if desc {\n				return si > sj\n			}\n			return si < sj\n		}\n		// numeric\n		ni := toFloat64(ki)\n		nj := toFloat64(kj)\n		if desc {\n			return ni > nj\n		}\n		return ni < nj\n	})\n\n	return result\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		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		return nil\n	}\n	return fieldVal.Interface()\n}\n\n// capitalize uppercases the first character of a string.\nfunc capitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToUpper(s[:1]) + s[1:]\n}\n\n// decapitalize lowercases the first character of a string. Used by\n// `getFieldValue`\'s map-receiver fallback when the projected key\n// name is PascalCase but the receiver carries lowercase JS-style\n// keys (the inverse of the `capitalize` lookup).\nfunc decapitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToLower(s[:1]) + s[1:]\n}\n\n// =============================================================================\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// 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\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// Create script collector and inject into props\n	scriptCollector := NewScriptCollector()\n	setScriptsField(opts.Props, scriptCollector)\n\n	// Create portal collector and inject into props\n	portalCollector := NewPortalCollector()\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		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		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	// 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: template.HTML(componentBuf.String()),\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// 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// 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\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		return ""\n	}\n}\n';
+    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	"os"\n	"reflect"\n	"sort"\n	"strconv"\n	"strings"\n)\n\n// FuncMap returns a template.FuncMap with all BarefootJS helper functions.\n// Usage:\n//\n//	tmpl := template.New("").Funcs(bf.FuncMap())\nfunc FuncMap() template.FuncMap {\n	return template.FuncMap{\n		// Arithmetic\n		"bf_add": Add,\n		"bf_sub": Sub,\n		"bf_mul": Mul,\n		"bf_div": Div,\n		"bf_mod": Mod,\n		"bf_neg": Neg,\n\n		// String\n		"bf_lower":    Lower,\n		"bf_upper":    Upper,\n		"bf_trim":     Trim,\n		"bf_contains": Contains,\n		"bf_join":     Join,\n		"bf_string":   String,\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\n		// Array/Slice\n		"bf_len":            Len,\n		"bf_at":             At,\n		"bf_includes":       Includes,\n		"bf_index_of":       IndexOf,\n		"bf_last_index_of":  LastIndexOf,\n		"bf_concat":         Concat,\n		"bf_slice":          Slice,\n		"bf_reverse":        Reverse,\n		"bf_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\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		// Scope comment for fragment roots\n		"bfScopeComment": ScopeComment,\n\n		// JSX intrinsic-element spread lowering (#1407)\n		"bf_spread_attrs": SpreadAttrs,\n	}\n}\n\n// ScopeAttr returns the bare bf-s scope id (#1249).\nfunc ScopeAttr(props interface{}) string {\n	return getStringField(props, "ScopeID")\n}\n\n// HydrationAttrs emits `bf-h="<host>" bf-m="<slot>" bf-r=""` conditionally.\n// See spec/compiler.md "Slot identity".\nfunc HydrationAttrs(props interface{}) template.HTMLAttr {\n	parts := []string{}\n	if host := getStringField(props, "BfParent"); host != "" {\n		parts = append(parts, fmt.Sprintf(`bf-h="%s"`, template.HTMLEscapeString(host)))\n	}\n	if mount := getStringField(props, "BfMount"); mount != "" {\n		parts = append(parts, fmt.Sprintf(`bf-m="%s"`, template.HTMLEscapeString(mount)))\n	}\n	if !getBoolField(props, "BfIsChild") {\n		parts = append(parts, `bf-r=""`)\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// IsChild is a deprecated no-op stub. Child status is signalled by bf-h\n// presence (#1249); use HydrationAttrs instead.\nfunc IsChild(props interface{}) template.HTMLAttr {\n	return ""\n}\n\n// svgCamelCaseAttrs mirrors SVG_CAMEL_CASE_ATTRS from\n// packages/client/src/runtime/spread-attrs.ts. SVG XML attribute\n// names are case-sensitive; the default camelCase \u2192 kebab-case\n// rewrite must NOT apply to these or the SVG stops rendering\n// (#1407). Coordinates with the compile-time SVG_CAMEL_TO_KEBAB\n// table in packages/jsx/src/ir-to-client-js/utils.ts: presentation\n// attrs (clipPath, strokeWidth, \u2026) live there and must NOT appear\n// here, or the same JSX prop would lower to clip-path via the\n// explicit-attr path and stay clipPath via the spread path.\nvar svgCamelCaseAttrs = map[string]struct{}{\n	"allowReorder": {}, "attributeName": {}, "attributeType": {}, "autoReverse": {},\n	"baseFrequency": {}, "baseProfile": {}, "calcMode": {}, "clipPathUnits": {},\n	"contentScriptType": {}, "contentStyleType": {}, "diffuseConstant": {}, "edgeMode": {},\n	"externalResourcesRequired": {}, "filterRes": {}, "filterUnits": {}, "glyphRef": {},\n	"gradientTransform": {}, "gradientUnits": {}, "kernelMatrix": {}, "kernelUnitLength": {},\n	"keyPoints": {}, "keySplines": {}, "keyTimes": {}, "lengthAdjust": {}, "limitingConeAngle": {},\n	"markerHeight": {}, "markerUnits": {}, "markerWidth": {}, "maskContentUnits": {},\n	"maskUnits": {}, "numOctaves": {}, "pathLength": {}, "patternContentUnits": {},\n	"patternTransform": {}, "patternUnits": {}, "pointsAtX": {}, "pointsAtY": {}, "pointsAtZ": {},\n	"preserveAlpha": {}, "preserveAspectRatio": {}, "primitiveUnits": {}, "refX": {}, "refY": {},\n	"repeatCount": {}, "repeatDur": {}, "requiredExtensions": {}, "requiredFeatures": {},\n	"specularConstant": {}, "specularExponent": {}, "spreadMethod": {}, "startOffset": {},\n	"stdDeviation": {}, "stitchTiles": {}, "surfaceScale": {}, "systemLanguage": {},\n	"tableValues": {}, "targetX": {}, "targetY": {}, "textLength": {}, "viewBox": {}, "viewTarget": {},\n	"xChannelSelector": {}, "yChannelSelector": {}, "zoomAndPan": {},\n}\n\n// toAttrName mirrors the JSX\u2192HTML attribute-name rewrite from\n// packages/client/src/runtime/spread-attrs.ts. className \u2192 class,\n// htmlFor \u2192 for, SVG camelCase attrs preserved, other camelCase\n// keys lowered to kebab-case.\nfunc toAttrName(key string) string {\n	if key == "className" {\n		return "class"\n	}\n	if key == "htmlFor" {\n		return "for"\n	}\n	if _, ok := svgCamelCaseAttrs[key]; ok {\n		return key\n	}\n	// camelCase \u2192 kebab-case: mirror the JS reference exactly\n	// (`key.replace(/([A-Z])/g, \'-$1\').toLowerCase()`). The JS shape\n	// produces a leading `-` for an initial uppercase letter\n	// (`XData` \u2192 `-x-data`); both this Go path and the matching JS\n	// runtime are wrong-by-construction for that case (the resulting\n	// HTML attribute name is invalid), but keeping them byte-equal\n	// avoids silent SSR/CSR divergence (#1411 review).\n	var b strings.Builder\n	for _, r := range key {\n		if r >= \'A\' && r <= \'Z\' {\n			b.WriteByte(\'-\')\n			b.WriteRune(r + 32)\n		} else {\n			b.WriteRune(r)\n		}\n	}\n	return b.String()\n}\n\n// StyleToCss mirrors styleToCss from\n// packages/client/src/runtime/style.ts. Accepts a string passthrough,\n// or a map (JSON-deserialized object) whose camelCase keys are\n// lowered to kebab-case and joined with `;`. Returns ("", false) for\n// nullish/empty input so callers can omit the attribute entirely.\nfunc StyleToCss(v any) (string, bool) {\n	if v == nil {\n		return "", false\n	}\n	rv := reflect.ValueOf(v)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return "", false\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		// Non-object: stringify and return as-is, matching the JS\n		// `typeof value !== \'object\'` branch.\n		s := fmt.Sprint(v)\n		if s == "" {\n			return "", false\n		}\n		return s, true\n	}\n	keys := rv.MapKeys()\n	sorted := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sorted = append(sorted, k.String())\n		}\n	}\n	sort.Strings(sorted)\n	parts := make([]string, 0, len(sorted))\n	for _, k := range sorted {\n		val := rv.MapIndex(reflect.ValueOf(k))\n		// Skip nil entries (matches the JS `if (v == null) continue`).\n		if !val.IsValid() {\n			continue\n		}\n		if val.Kind() == reflect.Interface || val.Kind() == reflect.Pointer {\n			if val.IsNil() {\n				continue\n			}\n			val = val.Elem()\n		}\n		prop := toAttrName(k)\n		parts = append(parts, fmt.Sprintf("%s:%v", prop, val.Interface()))\n	}\n	if len(parts) == 0 {\n		return "", false\n	}\n	return strings.Join(parts, ";"), true\n}\n\n// SpreadAttrs lowers a JSX intrinsic-element spread bag (#1407) to\n// an HTML attribute string. Mirrors spreadAttrs from\n// packages/client/src/runtime/spread-attrs.ts so SSR output matches\n// what CSR\'s `applyRestAttrs` writes at hydration.\n//\n// Skip rules: nil/false values, event handlers (`on[A-Z]*`),\n// `children`, `ref`.\n//\n// Key remap: className \u2192 class, htmlFor \u2192 for, SVG camelCase\n// preserved, other camelCase \u2192 kebab-case.\n//\n// `style` is routed through StyleToCss so object literals serialize\n// to a real CSS string instead of Go\'s default `map[k:v]` form.\n//\n// Booleans: true \u2192 bare attribute name, false \u2192 omitted.\n// Other scalar values are HTML-escaped via template.HTMLEscapeString.\n// Returns a `template.HTMLAttr` so html/template emits the result\n// verbatim (the function does its own escaping).\n//\n// Keys are sorted alphabetically before emission for deterministic\n// output. SSR/CSR attribute-order divergence is acceptable per the\n// rest-destructure-object-spread-in-map fixture\'s documented policy\n// \u2014 browsers honor the LAST value when a key is duplicated, so\n// pairing with static attrs (`<div class="x" {...rest}>`) is\n// last-wins regardless of order.\nfunc SpreadAttrs(bag any) template.HTMLAttr {\n	if bag == nil {\n		return ""\n	}\n	rv := reflect.ValueOf(bag)\n	for rv.Kind() == reflect.Interface || rv.Kind() == reflect.Pointer {\n		if rv.IsNil() {\n			return ""\n		}\n		rv = rv.Elem()\n	}\n	if rv.Kind() != reflect.Map {\n		return ""\n	}\n	keys := rv.MapKeys()\n	sortedKeys := make([]string, 0, len(keys))\n	for _, k := range keys {\n		if k.Kind() == reflect.String {\n			sortedKeys = append(sortedKeys, k.String())\n		}\n	}\n	sort.Strings(sortedKeys)\n	parts := make([]string, 0, len(sortedKeys))\n	for _, key := range sortedKeys {\n		// Event handlers \u2014 skip at SSR the same way\n		// packages/client/src/runtime/spread-attrs.ts does at\n		// hydration. The JS predicate is\n		// `key.startsWith(\'on\') && key.length > 2 && key[2] === key[2].toUpperCase()`,\n		// which is true for any character whose uppercase form is\n		// itself: ASCII A-Z, digits, underscore, and non-letter\n		// symbols. Mirror that here by skipping when key[2] is NOT\n		// a lowercase ASCII letter \u2014 so `onClick`, `on_custom`, and\n		// `on0` all match (#1411 review).\n		if len(key) > 2 && key[0] == \'o\' && key[1] == \'n\' && !(key[2] >= \'a\' && key[2] <= \'z\') {\n			continue\n		}\n		// `children` is a JSX construct rendered inside the element,\n		// never a DOM attribute. `ref` is intentionally NOT filtered\n		// here so output stays byte-equal with the JS reference\n		// `spreadAttrs` in packages/client/src/runtime/spread-attrs.ts\n		// (which only filters null/false, event handlers, and\n		// children) \u2014 aligning Go\'s filter set diverges from JS in\n		// the opposite direction. Filtering `ref` consistently across\n		// both SSR runtimes is a separate concern tracked alongside\n		// the JS `applyRestAttrs` vs `spreadAttrs` mismatch (#1411\n		// review).\n		if key == "children" {\n			continue\n		}\n		val := rv.MapIndex(reflect.ValueOf(key))\n		if !val.IsValid() {\n			continue\n		}\n		// Unwrap interface wrappers (json.Unmarshal produces\n		// interface{}-wrapped values for map[string]any).\n		v := val\n		for v.Kind() == reflect.Interface || v.Kind() == reflect.Pointer {\n			if v.IsNil() {\n				// Skip null entries.\n				v = reflect.Value{}\n				break\n			}\n			v = v.Elem()\n		}\n		if !v.IsValid() {\n			continue\n		}\n		// Boolean values: true \u2192 bare attribute, false \u2192 omitted.\n		if v.Kind() == reflect.Bool {\n			if !v.Bool() {\n				continue\n			}\n			parts = append(parts, toAttrName(key))\n			continue\n		}\n		// `style` routes through StyleToCss so object literals get a\n		// real CSS string. The JS side does the same.\n		if key == "style" {\n			css, ok := StyleToCss(v.Interface())\n			if !ok {\n				continue\n			}\n			parts = append(parts, fmt.Sprintf(`style="%s"`, template.HTMLEscapeString(css)))\n			continue\n		}\n		// Stringify and escape. fmt.Sprint handles numbers, bools-as-\n		// strings, and arbitrary stringer types the same way the JS\n		// `String(value)` coercion does for the analogous cases.\n		s := fmt.Sprint(v.Interface())\n		parts = append(parts, fmt.Sprintf(`%s="%s"`, toAttrName(key), template.HTMLEscapeString(s)))\n	}\n	if len(parts) == 0 {\n		return ""\n	}\n	return template.HTMLAttr(strings.Join(parts, " "))\n}\n\n// BfPropsAttr returns the bf-p attribute with the JSON-serialized\n// props in flat format. Output format: `bf-p=\'{"propName":value,...}\'`.\n// Only emits the attribute for root components (BfIsRoot == true);\n// child components receive props from their parent via initChild().\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported props rather than silently\n// dropping the bf-p attribute and breaking client-side hydration.\n// Same loud-failure policy as `JSON` \u2014 user data going through\n// `encoding/json` shouldn\'t fail invisibly.\nfunc BfPropsAttr(props interface{}) (template.HTMLAttr, error) {\n	// Only root components should emit bf-p\n	if !getBoolField(props, "BfIsRoot") {\n		return "", nil\n	}\n\n	propsJSON, err := json.Marshal(props)\n	if err != nil {\n		return "", err\n	}\n\n	escaped := template.HTMLEscapeString(string(propsJSON))\n	return template.HTMLAttr(`bf-p="` + escaped + `"`), nil\n}\n\n// =============================================================================\n// Arithmetic Operations\n// =============================================================================\n\n// Add returns a + b. Supports int and float64.\nfunc Add(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av + bv\n	// Return int if both inputs were int-like\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Sub returns a - b. Supports int and float64.\nfunc Sub(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av - bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Mul returns a * b. Supports int and float64.\nfunc Mul(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	result := av * bv\n	if isIntLike(a) && isIntLike(b) && result == float64(int(result)) {\n		return int(result)\n	}\n	return result\n}\n\n// Div returns a / b. Returns float64 to match JavaScript behavior.\n// Returns 0 if b is 0 (instead of panicking).\nfunc Div(a, b any) any {\n	av, bv := toFloat64(a), toFloat64(b)\n	if bv == 0 {\n		return 0\n	}\n	return av / bv\n}\n\n// Mod returns a % b (modulo). Supports int only.\nfunc Mod(a, b any) int {\n	av, bv := toInt(a), toInt(b)\n	if bv == 0 {\n		return 0\n	}\n	return av % bv\n}\n\n// Neg returns -a (negation).\nfunc Neg(a any) any {\n	if v, ok := a.(int); ok {\n		return -v\n	}\n	return -toFloat64(a)\n}\n\n// =============================================================================\n// String Operations\n// =============================================================================\n\n// Lower returns the lowercase version of s.\nfunc Lower(s string) string {\n	return strings.ToLower(s)\n}\n\n// Upper returns the uppercase version of s.\nfunc Upper(s string) string {\n	return strings.ToUpper(s)\n}\n\n// Trim returns s with leading and trailing whitespace removed.\nfunc Trim(s string) string {\n	return strings.TrimSpace(s)\n}\n\n// Contains returns true if s contains substr.\nfunc Contains(s, substr string) bool {\n	return strings.Contains(s, substr)\n}\n\n// Join concatenates elements of a slice with sep. Accepts both\n// reflect.Slice (the common case \u2014 `bf_arr` and `bf_filter_truthy`\n// both return `[]any`) AND reflect.Array (fixed-size Go arrays like\n// `[3]string{...}`), mirroring JS `Array.prototype.join` which\n// doesn\'t distinguish between the two. Pre-fix this returned "" for\n// fixed-size arrays passed through template data (Copilot review on\n// #1445).\nfunc Join(items any, sep string) string {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return ""\n	}\n\n	parts := make([]string, v.Len())\n	for i := 0; i < v.Len(); i++ {\n		parts[i] = toString(v.Index(i).Interface())\n	}\n	return strings.Join(parts, sep)\n}\n\n// String returns the string form of v. Mirrors JS `String(v)` for\n// non-nil values via `fmt.Sprintf("%v", ...)`. Diverges from JS on\n// nil: JS `String(null)` is "null", but the template path renders\n// `nil` as the empty string here so an unset prop doesn\'t surface\n// as a literal "null"/"undefined" in user-facing HTML. Document the\n// divergence explicitly so callers don\'t rely on JS-exact parity.\nfunc String(v any) string {\n	if v == nil {\n		return ""\n	}\n	return fmt.Sprintf("%v", v)\n}\n\n// JSON returns the JSON encoding of v as a string. Mirrors\n// JS `JSON.stringify(v)` for the V1 single-arg shape (no `replacer`\n// or `space`). Object key order is determined by Go\'s `encoding/json`\n// (alphabetical for maps, declaration order for structs) \u2014 the\n// #1187 contract requires value-compat, not order-compat.\n//\n// Top-level NaN / \xB1Inf are pre-handled to match JS \u2014 JS\'s\n// `JSON.stringify(NaN)` and `JSON.stringify(Infinity)` both produce\n// `"null"`, but Go\'s `encoding/json` rejects them with\n// `UnsupportedValueError`. Without this carve-out the common\n// composition `JSON.stringify(Number("garbage"))` would error\n// instead of emitting `"null"` like JS does. Nested NaN/Inf inside\n// a struct/map still surfaces an error \u2014 covering that needs a\n// custom marshaller; out of V1 scope.\n//\n// Returns the marshal error so a `template.Execute` call fails\n// loudly on cycles / unsupported values rather than silently\n// producing `""` and reintroducing the SSR data-loss class\n// #1187 was filed against. Go\'s text/template treats a non-nil\n// error return from a func as an execution failure.\nfunc JSON(v any) (string, error) {\n	if f, ok := v.(float64); ok && (math.IsNaN(f) || math.IsInf(f, 0)) {\n		return "null", nil\n	}\n	b, err := json.Marshal(v)\n	if err != nil {\n		return "", err\n	}\n	return string(b), nil\n}\n\n// Number coerces v to a float64. Mirrors JS `Number(v)` semantics:\n// numeric / boolean inputs convert as expected; non-numeric strings\n// and other unsupported shapes return `NaN` (matching JS rather\n// than silently substituting 0, which would mis-shape downstream\n// arithmetic and template-side comparisons). Templates that need\n// a deterministic fallback should compose with the user-side\n// default (e.g. `Number(props.x ?? 0)` in JSX).\nfunc Number(v any) float64 {\n	if v == nil {\n		return math.NaN()\n	}\n	switch x := v.(type) {\n	case float64:\n		return x\n	case float32:\n		return float64(x)\n	case int:\n		return float64(x)\n	case int32:\n		return float64(x)\n	case int64:\n		return float64(x)\n	case bool:\n		if x {\n			return 1\n		}\n		return 0\n	case string:\n		f, err := strconv.ParseFloat(x, 64)\n		if err != nil {\n			return math.NaN()\n		}\n		return f\n	}\n	return math.NaN()\n}\n\n// Floor returns the largest integer \u2264 v as a float64. Mirrors JS\n// `Math.floor`. The return type stays float64 so chained primitives\n// (`bf_floor` then `bf_string`) line up with JS\'s number type.\nfunc Floor(v any) float64 {\n	return math.Floor(Number(v))\n}\n\n// Ceil returns the smallest integer \u2265 v as a float64. Mirrors JS\n// `Math.ceil`.\nfunc Ceil(v any) float64 {\n	return math.Ceil(Number(v))\n}\n\n// Round returns v rounded to the nearest integer as a float64.\n// Mirrors JS `Math.round` \u2014 half-away-from-zero (Go\'s `math.Round`\n// matches; JS rounds half toward +Infinity which differs at .5\n// negatives; we accept that minor divergence since the conformance\n// contract is value-compat for the common positive case).\nfunc Round(v any) float64 {\n	return math.Round(Number(v))\n}\n\n// =============================================================================\n// Array/Slice Operations\n// =============================================================================\n\n// Len returns the length of a slice, array, map, string, or channel.\n// Returns 0 for nil or unsupported types.\nfunc Len(v any) int {\n	if v == nil {\n		return 0\n	}\n	rv := reflect.ValueOf(v)\n	switch rv.Kind() {\n	case reflect.Slice, reflect.Array, reflect.Map, reflect.String, reflect.Chan:\n		return rv.Len()\n	default:\n		return 0\n	}\n}\n\n// At returns the element at index i from a slice.\n// Supports negative indices (e.g., -1 for last element).\n// Returns nil if index is out of bounds.\nfunc At(items any, index int) any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return nil\n	}\n\n	length := v.Len()\n	if length == 0 {\n		return nil\n	}\n\n	// Handle negative indices\n	if index < 0 {\n		index = length + index\n	}\n\n	if index < 0 || index >= length {\n		return nil\n	}\n\n	return v.Index(index).Interface()\n}\n\n// Includes returns true if items contains elem. Lowers both\n// `Array.prototype.includes` and `String.prototype.includes` \u2014\n// the adapter can\'t disambiguate the receiver at compile time,\n// so this helper dispatches at runtime on `reflect.Kind()`:\n//\n//   - slice/array receiver:  DeepEqual element search\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 reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return true\n		}\n	}\n	return false\n}\n\n// IndexOf returns the 0-based position of the first item that\n// DeepEquals `elem`, or -1 if not found. Lowers\n// `Array.prototype.indexOf(x)` (#1448 Tier A). The existing\n// `FindIndex` helper does struct-field equality (used by the\n// higher-order `.find` lowering); this one does value equality\n// against scalar / struct items so callers don\'t have to compose\n// a synthetic predicate.\n//\n// Non-array / non-slice receivers return -1 (matches the JS\n// semantic that `.indexOf` is only defined on Array / TypedArray).\nfunc IndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := 0; i < v.Len(); i++ {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// LastIndexOf returns the 0-based position of the last item that\n// DeepEquals `elem`, or -1 if not found. Mirrors\n// `Array.prototype.lastIndexOf(x)`. The reverse traversal is the\n// only behavioural difference vs `IndexOf` \u2014 disambiguating a\n// duplicated value\'s first vs last position is the canonical\n// reason a JS author reaches for `lastIndexOf`.\nfunc LastIndexOf(items any, elem any) int {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return -1\n	}\n	for i := v.Len() - 1; i >= 0; i-- {\n		if reflect.DeepEqual(v.Index(i).Interface(), elem) {\n			return i\n		}\n	}\n	return -1\n}\n\n// Concat merges two arrays (or slices) into a single `[]any`,\n// preserving order: receiver elements first, then `other`\'s.\n// Lowers `Array.prototype.concat(other)` (#1448 Tier A). Non-array\n// operands collapse to an empty source \u2014 matches the JS semantic\n// where `.concat` on a non-Array reads it as a single element only\n// if its `Symbol.isConcatSpreadable` is true; the template-language\n// path doesn\'t have user objects with that flag, so treating\n// non-arrays as empty is the conservative lowering. Variadic\n// `.concat(a, b, c)` is out of scope here (parser gates to a single\n// arg); the helper itself stays binary so a future variadic IR can\n// fold via repeated calls without changing this signature.\nfunc Concat(a, b any) []any {\n	flatten := func(v reflect.Value) []any {\n		if !v.IsValid() {\n			return nil\n		}\n		if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n			return nil\n		}\n		out := make([]any, v.Len())\n		for i := 0; i < v.Len(); i++ {\n			out[i] = v.Index(i).Interface()\n		}\n		return out\n	}\n	left := flatten(reflect.ValueOf(a))\n	right := flatten(reflect.ValueOf(b))\n	return append(left, right...)\n}\n\n// Slice carves out a sub-range from `items`. Lowers\n// `Array.prototype.slice(start, end?)` (#1448 Tier A). The variadic\n// `end` arg lets Go template\'s call dispatcher pass either 2 or 3\n// arguments; an absent end means "to length".\n//\n// JS-compat clamping:\n//   - start < 0          \u2192 length + start  (e.g. -1 = last index)\n//   - end < 0            \u2192 length + end\n//   - start < 0 after clamp \u2192 0\n//   - end > length       \u2192 length\n//   - start >= end       \u2192 empty slice (no panic)\n//\n// Non-array receivers return an empty `[]any`.\nfunc Slice(items any, start int, end ...int) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n\n	// Normalise start (negative = from end).\n	if start < 0 {\n		start = length + start\n	}\n	if start < 0 {\n		start = 0\n	}\n	if start > length {\n		start = length\n	}\n\n	// Normalise end (optional; absent = length).\n	stop := length\n	if len(end) > 0 {\n		stop = end[0]\n		if stop < 0 {\n			stop = length + stop\n		}\n		if stop < 0 {\n			stop = 0\n		}\n		if stop > length {\n			stop = length\n		}\n	}\n\n	if start >= stop {\n		return []any{}\n	}\n\n	out := make([]any, 0, stop-start)\n	for i := start; i < stop; i++ {\n		out = append(out, v.Index(i).Interface())\n	}\n	return out\n}\n\n// Reverse returns a new slice with `items`\'s elements in reverse\n// order. Lowers both `Array.prototype.reverse()` and\n// `Array.prototype.toReversed()` (#1448 Tier A) \u2014 SSR templates\n// render a snapshot, so JS\'s mutate-receiver vs return-new-array\n// distinction has no template-level meaning, and the safer\n// non-mutating shape is used uniformly.\n//\n// Non-array receivers return an empty `[]any`.\nfunc Reverse(items any) []any {\n	v := reflect.ValueOf(items)\n	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {\n		return []any{}\n	}\n	length := v.Len()\n	out := make([]any, length)\n	for i := 0; i < length; i++ {\n		out[length-1-i] = v.Index(i).Interface()\n	}\n	return out\n}\n\n// 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// 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// Every returns true if all items have the specified field set to true.\n// Mirrors JavaScript\'s Array.prototype.every(item => item.field).\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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			return false\n		}\n		if fieldVal.Kind() == reflect.Bool && !fieldVal.Bool() {\n			return false\n		}\n	}\n	return true\n}\n\n// Some returns true if at least one item has the specified field set to true.\n// Mirrors 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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if fieldVal.IsValid() && fieldVal.Kind() == reflect.Bool && fieldVal.Bool() {\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\n	capitalizedField := capitalize(field)\n	var result []any\n\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		// Compare field value with target value\n		if reflect.DeepEqual(fieldVal.Interface(), value) {\n			result = append(result, v.Index(i).Interface())\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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		if reflect.DeepEqual(fieldVal.Interface(), value) {\n			return v.Index(i).Interface()\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\n	capitalizedField := capitalize(field)\n	for i := 0; i < v.Len(); i++ {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			item = item.Elem()\n		}\n		if item.Kind() == reflect.Ptr {\n			item = item.Elem()\n		}\n		if item.Kind() != reflect.Struct {\n			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		if reflect.DeepEqual(fieldVal.Interface(), 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\n	capitalizedField := capitalize(field)\n	for i := v.Len() - 1; i >= 0; i-- {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\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			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		if reflect.DeepEqual(fieldVal.Interface(), value) {\n			return v.Index(i).Interface()\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\n	capitalizedField := capitalize(field)\n	for i := v.Len() - 1; i >= 0; i-- {\n		item := v.Index(i)\n		if item.Kind() == reflect.Interface {\n			if item.IsNil() {\n				continue\n			}\n			item = item.Elem()\n		}\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			continue\n		}\n\n		fieldVal := item.FieldByName(capitalizedField)\n		if !fieldVal.IsValid() {\n			continue\n		}\n\n		if reflect.DeepEqual(fieldVal.Interface(), value) {\n			return i\n		}\n	}\n	return -1\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 exactly 5 args):\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"\n//	direction:    "asc" | "desc"\n//\n// The 4 string operands cover the accepted comparator catalogue:\n// `(a,b) => a.f - b.f`, `(a,b) => a - b`, and\n// `(a,b) => a[.f].localeCompare(b[.f])`, each with a reversed\n// counterpart for `desc`. Anything outside the catalogue refuses at\n// compile time (BF101 from the JSX compiler) and never reaches this\n// helper.\n//\n// A future `nulls => "first" | "last"` knob can land as a 6th arg\n// without rewriting the existing call sites \u2014 the keyKind / keyName\n// split already gives the helper everything it needs to project\n// each item\'s sort key before comparing.\nfunc Sort(items any, keyKind string, keyName string, compareType string, direction 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	desc := direction == "desc"\n	sort.SliceStable(result, func(i, j int) bool {\n		ki := projectSortKey(result[i], keyKind, keyName)\n		kj := projectSortKey(result[j], keyKind, keyName)\n		if compareType == "string" {\n			// `toString` maps nil / unknown types to "" \u2014 matches\n			// the documented `bf->string(undef) === ""` divergence\n			// from JS and the Perl `bf->sort` helper\'s `// \'\'`\n			// undef-coalesce. Using `fmt.Sprint` here would sort\n			// missing fields against the literal string "<nil>".\n			si := toString(ki)\n			sj := toString(kj)\n			if desc {\n				return si > sj\n			}\n			return si < sj\n		}\n		// numeric\n		ni := toFloat64(ki)\n		nj := toFloat64(kj)\n		if desc {\n			return ni > nj\n		}\n		return ni < nj\n	})\n\n	return result\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		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		return nil\n	}\n	return fieldVal.Interface()\n}\n\n// capitalize uppercases the first character of a string.\nfunc capitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToUpper(s[:1]) + s[1:]\n}\n\n// decapitalize lowercases the first character of a string. Used by\n// `getFieldValue`\'s map-receiver fallback when the projected key\n// name is PascalCase but the receiver carries lowercase JS-style\n// keys (the inverse of the `capitalize` lookup).\nfunc decapitalize(s string) string {\n	if s == "" {\n		return s\n	}\n	return strings.ToLower(s[:1]) + s[1:]\n}\n\n// =============================================================================\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// 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\nfunc (r *Renderer) Render(opts RenderOptions) string {\n	// Create script collector and inject into props\n	scriptCollector := NewScriptCollector()\n	setScriptsField(opts.Props, scriptCollector)\n\n	// Create portal collector and inject into props\n	portalCollector := NewPortalCollector()\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		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		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	// 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: template.HTML(componentBuf.String()),\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// 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// 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\n// findSingleChildComponents finds single struct fields containing child component props.\n// Child props are identified by having ScopeID and Scripts fields.\nfunc findSingleChildComponents(props interface{}) []interface{} {\n	var result []interface{}\n\n	val := reflect.ValueOf(props)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() != reflect.Struct {\n		return result\n	}\n\n	for i := 0; i < val.NumField(); i++ {\n		field := val.Field(i)\n\n		// Handle pointer to struct\n		if field.Kind() == reflect.Ptr {\n			if field.IsNil() {\n				continue\n			}\n			field = field.Elem()\n		}\n\n		// Skip non-struct fields (slices handled by findChildComponentSlices)\n		if field.Kind() != reflect.Struct {\n			continue\n		}\n\n		hasScopeID := field.FieldByName("ScopeID").IsValid()\n		hasScripts := field.FieldByName("Scripts").IsValid()\n\n		if hasScopeID && hasScripts {\n			result = append(result, field.Addr().Interface())\n		}\n	}\n\n	return result\n}\n\n// setScriptsOnSingle sets Scripts on a single struct child component.\nfunc setScriptsOnSingle(child interface{}, collector *ScriptCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Scripts")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n// setPortalsOnSingle sets Portals on a single struct child component.\nfunc setPortalsOnSingle(child interface{}, collector *PortalCollector) {\n	val := reflect.ValueOf(child)\n	if val.Kind() == reflect.Ptr {\n		val = val.Elem()\n	}\n	if val.Kind() == reflect.Struct {\n		field := val.FieldByName("Portals")\n		if field.IsValid() && field.CanSet() {\n			field.Set(reflect.ValueOf(collector))\n		}\n	}\n}\n\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\nfunc toFloat64(v any) float64 {\n	switch n := v.(type) {\n	case int:\n		return float64(n)\n	case int8:\n		return float64(n)\n	case int16:\n		return float64(n)\n	case int32:\n		return float64(n)\n	case int64:\n		return float64(n)\n	case uint:\n		return float64(n)\n	case uint8:\n		return float64(n)\n	case uint16:\n		return float64(n)\n	case uint32:\n		return float64(n)\n	case uint64:\n		return float64(n)\n	case float32:\n		return float64(n)\n	case float64:\n		return n\n	default:\n		return 0\n	}\n}\n\nfunc toInt(v any) int {\n	switch n := v.(type) {\n	case int:\n		return n\n	case int8:\n		return int(n)\n	case int16:\n		return int(n)\n	case int32:\n		return int(n)\n	case int64:\n		return int(n)\n	case uint:\n		return int(n)\n	case uint8:\n		return int(n)\n	case uint16:\n		return int(n)\n	case uint32:\n		return int(n)\n	case uint64:\n		return int(n)\n	case float32:\n		return int(n)\n	case float64:\n		return int(n)\n	default:\n		return 0\n	}\n}\n\nfunc isIntLike(v any) bool {\n	switch v.(type) {\n	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:\n		return true\n	default:\n		return false\n	}\n}\n\nfunc toString(v any) string {\n	switch s := v.(type) {\n	case string:\n		return s\n	case int:\n		return strconv.Itoa(s)\n	case int64:\n		return strconv.FormatInt(s, 10)\n	case float64:\n		return strconv.FormatFloat(s, \'f\', -1, 64)\n	case bool:\n		return strconv.FormatBool(s)\n	default:\n		return ""\n	}\n}\n';
     streamingGoSource = `// Package bf \u2014 Out-of-Order Streaming SSR helpers
 //
 // Provides StreamRenderer for progressive page rendering using HTTP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "CLI for agent-driven UI component discovery and scaffolding",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,7 +31,7 @@
     "typescript": "^5.0.0"
   },
   "devDependencies": {
-    "@barefootjs/jsx": "0.1.2",
+    "@barefootjs/jsx": "0.1.3",
     "@types/node": "^22.0.0"
   }
 }