@barefootjs/jsx 0.18.4 → 0.18.7

package/dist/index.js

@@ -206,7 +206,6 @@ var UNSUPPORTED_METHODS = new Set([
   "some",
   "forEach",
   "flatMap",
-  "replaceAll",
   "charAt",
   "charCodeAt",
   "codePointAt",
@@ -481,6 +480,9 @@ function convertNode(node, raw) {
       if (callee.property === "trim") {
         return { kind: "array-method", method: "trim", object: callee.object, args };
       }
+      if (callee.property === "trimStart" || callee.property === "trimEnd") {
+        return { kind: "array-method", method: callee.property, object: callee.object, args };
+      }
       if (callee.property === "toFixed") {
         return { kind: "array-method", method: "toFixed", object: callee.object, args };
       }
@@ -506,24 +508,25 @@ function convertNode(node, raw) {
         }
         return { kind: "array-method", method: callee.property, object: callee.object, args };
       }
-      if (callee.property === "replace") {
+      if (callee.property === "replace" || callee.property === "replaceAll") {
+        const method = callee.property;
         if (args.length < 2) {
           return {
             kind: "unsupported",
             raw,
-            reason: `\`.replace(${args.length === 0 ? "" : "pattern"})\` needs both a pattern and a replacement — JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`
+            reason: `\`.${method}(${args.length === 0 ? "" : "pattern"})\` needs both a pattern and a replacement — JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`
           };
         }
         const patternNode = node.arguments[0];
         if (patternNode && ts2.isRegularExpressionLiteral(patternNode)) {
-          return { kind: "array-method", method: "replace", object: callee.object, args };
+          return { kind: "array-method", method, object: callee.object, args };
         }
         const badArg = args[0].kind === "unsupported" || args[0].kind === "object-literal" ? args[0] : args[1].kind === "unsupported" || args[1].kind === "object-literal" ? args[1] : undefined;
         if (badArg) {
           const reason = badArg.kind === "unsupported" ? badArg.reason : "Unsupported syntax: ObjectLiteralExpression";
           return { kind: "unsupported", raw, reason };
         }
-        return { kind: "array-method", method: "replace", object: callee.object, args };
+        return { kind: "array-method", method, object: callee.object, args };
       }
       if (callee.property === "repeat") {
         return { kind: "array-method", method: "repeat", object: callee.object, args };
@@ -558,7 +561,7 @@ function convertNode(node, raw) {
   if (ts2.isPropertyAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
     const property = node.name.text;
-    return { kind: "member", object, property, computed: false };
+    return { kind: "member", object, property, computed: false, optional: !!node.questionDotToken };
   }
   if (ts2.isElementAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
@@ -567,10 +570,10 @@ function convertNode(node, raw) {
       return { kind: "unsupported", raw, reason: "Element access with no index expression" };
     }
     if (ts2.isNumericLiteral(argNode)) {
-      return { kind: "member", object, property: argNode.text, computed: true };
+      return { kind: "member", object, property: argNode.text, computed: true, optional: !!node.questionDotToken };
     }
     if (ts2.isStringLiteral(argNode)) {
-      return { kind: "member", object, property: argNode.text, computed: true };
+      return { kind: "member", object, property: argNode.text, computed: true, optional: !!node.questionDotToken };
     }
     const index = convertNode(argNode, raw);
     if (index.kind === "unsupported" || index.kind === "object-literal")
@@ -1121,7 +1124,7 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
           return e;
         let node = { kind: "identifier", name: syntheticParam };
         for (const segment of entry.path) {
-          node = { kind: "member", object: node, property: segment, computed: false };
+          node = { kind: "member", object: node, property: segment, computed: false, optional: false };
         }
         if (entry.defaultExpr) {
           return { kind: "logical", op: "??", left: node, right: entry.defaultExpr };
@@ -1136,10 +1139,11 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
             kind: "member",
             object: { kind: "identifier", name: syntheticParam },
             property: e.property,
-            computed: false
+            computed: false,
+            optional: e.optional
           };
         }
-        return { kind: "member", object: walk(e.object), property: e.property, computed: e.computed };
+        return { kind: "member", object: walk(e.object), property: e.property, computed: e.computed, optional: e.optional };
       case "index-access":
         return { kind: "index-access", object: walk(e.object), index: walk(e.index) };
       case "binary":
@@ -1251,10 +1255,10 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "array-method": {
-      if (expr.method === "replace" && expr.args[0]?.kind === "regex") {
+      if ((expr.method === "replace" || expr.method === "replaceAll") && expr.args[0]?.kind === "regex") {
         return {
           supported: false,
-          reason: "String.prototype.replace supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */"
+          reason: `String.prototype.${expr.method} supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */`
         };
       }
       const objSupport = checkSupport(expr.object);
@@ -1628,7 +1632,7 @@ function inlineBinding(expr, name, value) {
       case "call":
         return { kind: "call", callee: walk(e.callee, enclosing), args: e.args.map((a) => walk(a, enclosing)) };
       case "member":
-        return { kind: "member", object: walk(e.object, enclosing), property: e.property, computed: e.computed };
+        return { kind: "member", object: walk(e.object, enclosing), property: e.property, computed: e.computed, optional: e.optional };
       case "index-access":
         return { kind: "index-access", object: walk(e.object, enclosing), index: walk(e.index, enclosing) };
       case "binary":
@@ -1879,7 +1883,7 @@ function materializeGetterCalls(expr, names) {
         alternate: rw(expr.alternate)
       };
     case "member":
-      return { kind: "member", object: rw(expr.object), property: expr.property, computed: expr.computed };
+      return { kind: "member", object: rw(expr.object), property: expr.property, computed: expr.computed, optional: expr.optional };
     case "index-access":
       return { kind: "index-access", object: rw(expr.object), index: rw(expr.index) };
     case "template-literal":
@@ -2293,13 +2297,23 @@ function attrValueToString(value, opts) {
       return null;
   }
 }
+function applyObjectIterationWrap(node, arrayExpr) {
+  if (node.objectIteration === "entries")
+    return `Object.entries(${arrayExpr})`;
+  if (node.objectIteration === "keys")
+    return `Object.keys(${arrayExpr})`;
+  if (node.objectIteration === "values")
+    return `Object.values(${arrayExpr})`;
+  return arrayExpr;
+}
 function buildChainedArrayExpr(elem) {
-  return buildLoopChainExpr({
+  const chained = buildLoopChainExpr({
     base: elem.array,
     sortComparator: elem.sortComparator,
     filterPredicate: elem.filterPredicate,
     chainOrder: elem.chainOrder
   });
+  return applyObjectIterationWrap(elem, chained);
 }
 function loopOffsetTerms(offset) {
   if (!offset)
@@ -2928,6 +2942,29 @@ function extractFreeIdentifiersFromText(text) {
   const expr = ts4.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return extractFreeIdentifiersFromNode(expr);
 }
+function extractFreeIdentifiersFromStatementText(text) {
+  if (!text || text.trim().length === 0)
+    return new Set;
+  const sf = ts4.createSourceFile("__free_ids_stmt__.ts", text, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+  return extractFreeIdentifiersFromNode(sf);
+}
+function extractFreeIdentifiersFromTemplateText(template) {
+  if (!template || template.length === 0)
+    return new Set;
+  const sf = ts4.createSourceFile("__free_ids_template__.ts", `(\`${template}\`);`, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts4.isExpressionStatement(stmt))
+    return new Set;
+  const expr = ts4.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!ts4.isTemplateExpression(expr))
+    return new Set;
+  const ids = new Set;
+  for (const span of expr.templateSpans) {
+    for (const id of extractFreeIdentifiersFromNode(span.expression))
+      ids.add(id);
+  }
+  return ids;
+}
 function extractMemoBodyExpr(computation) {
   const arrowMatch = computation.match(/^\(\)\s*=>\s*(.+)$/s);
   if (!arrowMatch)
@@ -2971,7 +3008,7 @@ function normalizeSignalInitial(signal, propsObjectName) {
 }
 
 // src/ir-to-client-js/html-template.ts
-import { BF_PARENT_SCOPE_PLACEHOLDER, BF_SCOPE } from "@barefootjs/shared";
+import { BF_PARENT_SCOPE_PLACEHOLDER, BF_SCOPE, escapeHtml } from "@barefootjs/shared";
 function createStringProtector() {
   const strings = [];
   const protect = (s) => {
@@ -3073,6 +3110,24 @@ function applyIterationShape(node, arrayExpr, indexParam) {
       callbackParam: `(${node.param})`
     };
   }
+  if (node.objectIteration === "entries") {
+    return {
+      array: `Object.entries(${arrayExpr})`,
+      callbackParam: node.index ? `([${node.index}, ${node.param}])` : `(${node.param}${indexParam})`
+    };
+  }
+  if (node.objectIteration === "keys") {
+    return {
+      array: `Object.keys(${arrayExpr})`,
+      callbackParam: `(${node.param})`
+    };
+  }
+  if (node.objectIteration === "values") {
+    return {
+      array: `Object.values(${arrayExpr})`,
+      callbackParam: `(${node.param})`
+    };
+  }
   return { array: arrayExpr, callbackParam: `(${node.param}${indexParam})` };
 }
 function childrenPropEntry(children, recurse) {
@@ -3132,7 +3187,7 @@ function renderTemplateAttrPart(attr, attrName, wrap, restSpreadNames) {
     case "boolean-attr":
       return attrName;
     case "literal":
-      return `${attrName}="${v.value}"`;
+      return `${attrName}="${escapeHtml(v.value)}"`;
     case "expression": {
       const valExpr = wrap(v.expr);
       return templateAttrExpr(attrName, valExpr, v.presenceOrUndefined);
@@ -3263,7 +3318,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined")
         return "";
@@ -3371,7 +3426,7 @@ function buildLoopSkeletonTemplate(node, safe) {
         const v = a.value;
         switch (v.kind) {
           case "literal":
-            attrParts.push(`${toHtmlAttrName(a.name)}="${v.value}"`);
+            attrParts.push(`${toHtmlAttrName(a.name)}="${escapeHtml(v.value)}"`);
             break;
           case "boolean-attr":
             attrParts.push(toHtmlAttrName(a.name));
@@ -3406,7 +3461,7 @@ function buildLoopSkeletonTemplate(node, safe) {
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined")
         return "";
@@ -3438,6 +3493,133 @@ function buildLoopSkeletonTemplate(node, safe) {
       return assertNever(node);
   }
 }
+var SKELETON_PATH_HAZARD_TAGS = new Set([
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "caption",
+  "colgroup",
+  "col",
+  "select",
+  "optgroup",
+  "p",
+  "pre",
+  "textarea",
+  "listing",
+  "template",
+  "math"
+]);
+var SKELETON_PATH_FORCE_CLOSE_GROUPS = [
+  new Set(["a"]),
+  new Set(["button"]),
+  new Set(["form"]),
+  new Set(["option"]),
+  new Set(["h1", "h2", "h3", "h4", "h5", "h6"]),
+  new Set(["dd", "dt"]),
+  new Set(["li"])
+];
+function skeletonForceCloseGroup(tag) {
+  return SKELETON_PATH_FORCE_CLOSE_GROUPS.findIndex((group) => group.has(tag));
+}
+function computeSkeletonSlotPaths(node, safe) {
+  const state = { elementPaths: new Map, textMarkerPaths: new Map, bailed: false };
+  walkSkeletonPathNode(node, [], safe, state, new Set);
+  if (state.bailed)
+    return null;
+  return { elementPaths: state.elementPaths, textMarkerPaths: state.textMarkerPaths };
+}
+function walkSkeletonPathNode(node, path, safe, state, forceCloseAncestors) {
+  if (state.bailed || node.type !== "element")
+    return;
+  if (SKELETON_PATH_HAZARD_TAGS.has(node.tag)) {
+    state.bailed = true;
+    return;
+  }
+  const groupIdx = skeletonForceCloseGroup(node.tag);
+  if (groupIdx >= 0 && forceCloseAncestors.has(groupIdx)) {
+    state.bailed = true;
+    return;
+  }
+  const flatChildren = flattenSkeletonChildren(node.children);
+  if (VOID_ELEMENTS.has(node.tag) && flatChildren.length > 0) {
+    state.bailed = true;
+    return;
+  }
+  if (node.tag === "tr" && hasForeignTableRowContent(flatChildren)) {
+    state.bailed = true;
+    return;
+  }
+  if (node.slotId)
+    state.elementPaths.set(node.slotId, path);
+  const nextAncestors = groupIdx >= 0 ? new Set([...forceCloseAncestors, groupIdx]) : forceCloseAncestors;
+  walkSkeletonPathChildren(flatChildren, path, safe, state, nextAncestors);
+}
+function hasForeignTableRowContent(children) {
+  for (const child of children) {
+    if (child.type === "text") {
+      if (child.value.trim() !== "")
+        return true;
+      continue;
+    }
+    if (child.type === "element" && child.tag !== "td" && child.tag !== "th") {
+      return true;
+    }
+  }
+  return false;
+}
+function flattenSkeletonChildren(children) {
+  const out = [];
+  for (const child of children) {
+    if (child.type === "fragment") {
+      out.push(...flattenSkeletonChildren(child.children));
+    } else {
+      out.push(child);
+    }
+  }
+  return out;
+}
+function walkSkeletonPathChildren(children, parentPath, safe, state, forceCloseAncestors) {
+  let idx = 0;
+  let pendingText = false;
+  for (const child of children) {
+    if (state.bailed)
+      return;
+    switch (child.type) {
+      case "text": {
+        if (child.value === "")
+          continue;
+        if (!pendingText)
+          idx += 1;
+        pendingText = true;
+        continue;
+      }
+      case "expression": {
+        if (child.expr === "null" || child.expr === "undefined")
+          continue;
+        if (!child.slotId || !safe.reactiveTextSlotIds.has(child.slotId)) {
+          state.bailed = true;
+          return;
+        }
+        state.textMarkerPaths.set(child.slotId, [...parentPath, idx]);
+        idx += 2;
+        pendingText = false;
+        continue;
+      }
+      case "element": {
+        walkSkeletonPathNode(child, [...parentPath, idx], safe, state, forceCloseAncestors);
+        idx += 1;
+        pendingText = false;
+        continue;
+      }
+      case "fragment":
+        continue;
+      default:
+        state.bailed = true;
+        return;
+    }
+  }
+}
 function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParams) {
   const recurse = (n) => irToPlaceholderTemplate(n, restSpreadNames, loopDepth, loopParams);
   const wrapExpr = (expr) => wrapExprWithLoopParams(expr, loopParams);
@@ -3458,7 +3640,7 @@ function irToPlaceholderTemplate(node, restSpreadNames, loopDepth = 0, loopParam
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined")
         return "";
@@ -3650,7 +3832,7 @@ function irToComponentTemplateWithOpts(node, opts) {
               return templateAttrExpr(keyName, transformExpr(tmplStr));
             }
             case "literal":
-              return `${keyName}="${v.value}"`;
+              return `${keyName}="${escapeHtml(v.value)}"`;
             default:
               return "";
           }
@@ -3660,7 +3842,7 @@ function irToComponentTemplateWithOpts(node, opts) {
           case "boolean-attr":
             return attrName;
           case "literal":
-            return `${attrName}="${v.value}"`;
+            return `${attrName}="${escapeHtml(v.value)}"`;
           case "expression":
             return templateAttrExpr(attrName, transformExpr(v.expr, v.templateExpr), v.presenceOrUndefined);
           case "template": {
@@ -3686,7 +3868,7 @@ function irToComponentTemplateWithOpts(node, opts) {
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined")
         return "";
@@ -3978,7 +4160,7 @@ function generateCsrTemplateWithOpts(node, opts) {
           case "boolean-attr":
             return attrName;
           case "literal":
-            return `${attrName}="${v.value}"`;
+            return `${attrName}="${escapeHtml(v.value)}"`;
           case "expression":
             return templateAttrExpr(attrName, transformExpr(v.expr, v.templateExpr), v.presenceOrUndefined);
           case "template": {
@@ -4004,7 +4186,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       return `<${node.tag}${attrs ? " " + attrs : ""} />`;
     }
     case "text":
-      return node.value;
+      return escapeHtml(node.value);
     case "expression":
       if (node.expr === "null" || node.expr === "undefined")
         return "";
@@ -4080,7 +4262,28 @@ function generateCsrTemplateWithOpts(node, opts) {
       return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${keyArg || (slotArg ? ", undefined" : "")}${slotArg})}`;
     }
     case "loop": {
-      let childTemplate = node.children.map(recurseInLoop).join("");
+      const boundHere = new Set(opts.loopBoundNames ?? []);
+      if (node.paramBindings && node.paramBindings.length > 0) {
+        for (const b of node.paramBindings)
+          boundHere.add(b.name);
+      } else if (!node.param.startsWith("[") && !node.param.startsWith("{")) {
+        boundHere.add(node.param);
+      }
+      if (node.index)
+        boundHere.add(node.index);
+      const childEnv = {
+        ...env,
+        substitutions: new Map([...env.substitutions].filter(([name]) => !boundHere.has(name)))
+      };
+      const recurseInLoopBody = (n) => generateCsrTemplateWithOpts(n, {
+        ...opts,
+        insideLoop: true,
+        loopDepth: loopDepth + 1,
+        inHoistedChildren: false,
+        loopBoundNames: boundHere,
+        csrEnv: childEnv
+      });
+      let childTemplate = node.children.map(recurseInLoopBody).join("");
       if (node.bodyIsItemConditional && node.key) {
         childTemplate = `${itemAnchorTemplate(node.key)}${childTemplate}`;
       }
@@ -4094,7 +4297,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       if (node.flatMapCallback) {
         let body = node.flatMapCallback.templateBody ?? node.flatMapCallback.body;
         for (const frag of node.flatMapCallback.fragments) {
-          const renderedIr = recurseInLoop(frag.ir);
+          const renderedIr = recurseInLoopBody(frag.ir);
           body = body.replace(frag.placeholder, `\`${renderedIr}\``);
         }
         body = applyPropsRewrite(body, propsObjectName ?? null);
@@ -5054,6 +5257,8 @@ function needsTypeBasedDetection(source) {
     return true;
   if (/\.map\s*\(/.test(source))
     return true;
+  if (source.includes("createSelector"))
+    return true;
   return false;
 }
 function findBrandPackageImportLoc(sourceFile, filePath) {
@@ -6030,6 +6235,7 @@ var CLIENT_EXPORTS = new Set([
   "createEffect",
   "createDisposableEffect",
   "createMemo",
+  "createSelector",
   "createRoot",
   "onCleanup",
   "onMount",
@@ -8034,7 +8240,7 @@ function resolveFreeRefs(node, env) {
 }
 
 // src/jsx-to-ir.ts
-import { toHTMLAttrName } from "@barefootjs/shared";
+import { toHTMLAttrName, decodeEntities } from "@barefootjs/shared";
 var CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
 var BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
 function hasLeadingClientDirective(expr, sourceFile) {
@@ -8116,9 +8322,15 @@ function exprHasFunctionCalls(expr) {
   return found;
 }
 function rewriteBarePropRefs2(text, expr, ctx) {
-  const propNames = getDestructuredPropNames(ctx);
+  let propNames = getDestructuredPropNames(ctx);
   if (!propNames)
     return;
+  if (ctx.loopParams.size > 0) {
+    const filtered = new Set([...propNames].filter((n) => !ctx.loopParams.has(n)));
+    if (filtered.size === 0)
+      return;
+    propNames = filtered;
+  }
   const extraPropRefs = collectBranchLocalPropRefsViaSubstitution(expr, ctx);
   return rewriteBarePropRefs(text, expr, propNames, extraPropRefs);
 }
@@ -8183,6 +8395,7 @@ function createTransformContext(analyzer) {
     isRoot: true,
     insideComponentChildren: false,
     loopParams: new Set,
+    loopDepth: 0,
     patterns: {
       signals: analyzer.signals.map((s) => ({
         getter: s.getter,
@@ -8283,26 +8496,29 @@ function makeBindingEnv(ctx) {
 function parseValueExpr(trimmed) {
   return parseExpression(trimmed.startsWith("{") ? `(${trimmed})` : trimmed);
 }
-function attachParsedExpressions(node) {
+var EMPTY_BOUND = new Set;
+function attachParsedExpressions(node, analyzer, bound = EMPTY_BOUND) {
+  const parse2 = (trimmed) => resolveCallbackMethodFunctionReferences(parseExpression(trimmed), analyzer, bound);
+  const parseValue = (trimmed) => resolveCallbackMethodFunctionReferences(parseValueExpr(trimmed), analyzer, bound);
   if (node.type === "expression") {
     const trimmed = node.expr.trim();
     if (trimmed)
-      node.parsed = parseExpression(trimmed);
+      node.parsed = parse2(trimmed);
   } else if (node.type === "conditional" || node.type === "if-statement") {
     const trimmed = node.condition.trim();
     if (trimmed)
-      node.parsedCondition = parseExpression(trimmed);
+      node.parsedCondition = parse2(trimmed);
   }
   if (node.type === "element") {
     for (const attr of node.attrs) {
       if (attr.value.kind === "expression") {
         const trimmed = attr.value.expr.trim();
         if (trimmed)
-          attr.value.parsed = parseValueExpr(trimmed);
+          attr.value.parsed = parseValue(trimmed);
       } else if (attr.value.kind === "spread") {
         const trimmed = attr.value.expr.trim();
         if (trimmed)
-          attr.value.parsed = parseExpression(trimmed);
+          attr.value.parsed = parse2(trimmed);
       }
     }
   } else if (node.type === "component") {
@@ -8310,14 +8526,14 @@ function attachParsedExpressions(node) {
       if (prop.value.kind === "expression") {
         const trimmed = prop.value.expr.trim();
         if (trimmed)
-          prop.value.parsed = parseValueExpr(trimmed);
+          prop.value.parsed = parseValue(trimmed);
       }
     }
   } else if (node.type === "provider") {
     if (node.valueProp.value.kind === "expression") {
       const trimmed = node.valueProp.value.expr.trim();
       if (trimmed)
-        node.valueProp.value.parsed = parseValueExpr(trimmed);
+        node.valueProp.value.parsed = parseValue(trimmed);
     }
   }
   switch (node.type) {
@@ -8326,47 +8542,51 @@ function attachParsedExpressions(node) {
     case "fragment":
     case "provider":
       for (const child of node.children)
-        attachParsedExpressions(child);
+        attachParsedExpressions(child, analyzer, bound);
       break;
     case "async":
-      attachParsedExpressions(node.fallback);
+      attachParsedExpressions(node.fallback, analyzer, bound);
       for (const child of node.children)
-        attachParsedExpressions(child);
+        attachParsedExpressions(child, analyzer, bound);
       break;
     case "loop": {
       const trimmedArray = node.array.trim();
       if (trimmedArray)
-        node.arrayParsed = parseExpression(trimmedArray);
+        node.arrayParsed = parse2(trimmedArray);
+      const loopBound = new Set(bound);
+      loopBound.add(node.param);
+      if (node.index)
+        loopBound.add(node.index);
       for (const child of node.children)
-        attachParsedExpressions(child);
+        attachParsedExpressions(child, analyzer, loopBound);
       if (node.childComponent) {
         for (const child of node.childComponent.children)
-          attachParsedExpressions(child);
+          attachParsedExpressions(child, analyzer, loopBound);
       }
       for (const nested of node.nestedComponents ?? []) {
         for (const child of nested.children)
-          attachParsedExpressions(child);
+          attachParsedExpressions(child, analyzer, loopBound);
       }
       for (const frag of node.flatMapCallback?.fragments ?? []) {
-        attachParsedExpressions(frag.ir);
+        attachParsedExpressions(frag.ir, analyzer, loopBound);
       }
       break;
     }
     case "conditional":
-      attachParsedExpressions(node.whenTrue);
-      attachParsedExpressions(node.whenFalse);
+      attachParsedExpressions(node.whenTrue, analyzer, bound);
+      attachParsedExpressions(node.whenFalse, analyzer, bound);
       break;
     case "if-statement":
-      attachParsedExpressions(node.consequent);
+      attachParsedExpressions(node.consequent, analyzer, bound);
       if (node.alternate)
-        attachParsedExpressions(node.alternate);
+        attachParsedExpressions(node.alternate, analyzer, bound);
       break;
   }
 }
 function jsxToIR(analyzer) {
   const root = buildIRRoot(analyzer);
   if (root)
-    attachParsedExpressions(root);
+    attachParsedExpressions(root, analyzer);
   return root;
 }
 function buildIRRoot(analyzer) {
@@ -8836,7 +9056,7 @@ function transformText(node, ctx) {
   }
   return {
     type: "text",
-    value: text,
+    value: decodeEntities(text),
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
   };
 }
@@ -9392,6 +9612,22 @@ function isIteratorShapeCall(node) {
     return null;
   return { array: node.expression.expression, shape: name };
 }
+function isObjectIteratorCall(node) {
+  if (!ts11.isCallExpression(node))
+    return null;
+  if (!ts11.isPropertyAccessExpression(node.expression))
+    return null;
+  if (!ts11.isIdentifier(node.expression.expression))
+    return null;
+  if (node.expression.expression.text !== "Object")
+    return null;
+  if (node.arguments.length !== 1)
+    return null;
+  const name = node.expression.name.text;
+  if (name !== "entries" && name !== "keys" && name !== "values")
+    return null;
+  return { object: node.arguments[0], shape: name };
+}
 function extractSortComparator(callback, _method, ctx) {
   const outerRaw = ctx.getJS(callback);
   const unsupported = () => ({
@@ -9437,8 +9673,23 @@ function extractSortComparator(callback, _method, ctx) {
   };
 }
 function resolveSortComparatorIdentifier(name, ctx) {
-  const constInfo = findLocalConst(name, ctx);
-  const fnInfo = findLocalFunction(name, ctx);
+  const constInfo = findLocalConst(name, ctx.analyzer);
+  const fnInfo = findLocalFunction(name, ctx.analyzer);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (ts11.isArrowFunction(ast) || ts11.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
+function resolveCallbackMethodFunctionReferenceIdentifier(name, analyzer) {
+  const constInfo = findLocalConst(name, analyzer);
+  const fnInfo = findLocalFunction(name, analyzer);
   if (constInfo && fnInfo)
     return null;
   if (constInfo) {
@@ -9451,6 +9702,57 @@ function resolveSortComparatorIdentifier(name, ctx) {
   }
   return null;
 }
+function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_BOUND) {
+  function visit2(e, bound2) {
+    switch (e.kind) {
+      case "literal":
+      case "identifier":
+      case "regex":
+      case "unsupported":
+        return e;
+      case "call": {
+        const callee = visit2(e.callee, bound2);
+        const args = e.args.map((a) => visit2(a, bound2));
+        if (callee.kind === "member" && !callee.computed && CALLBACK_METHODS.has(callee.property) && args[0]?.kind === "identifier" && !bound2.has(args[0].name)) {
+          const resolved = resolveCallbackMethodFunctionReferenceIdentifier(args[0].name, analyzer);
+          const arrow = resolved ? tsNodeToParsedExpr(resolved) : null;
+          if (arrow && arrow.kind === "arrow")
+            args[0] = arrow;
+        }
+        return { ...e, callee, args };
+      }
+      case "member":
+        return { ...e, object: visit2(e.object, bound2) };
+      case "index-access":
+        return { ...e, object: visit2(e.object, bound2), index: visit2(e.index, bound2) };
+      case "binary":
+      case "logical":
+        return { ...e, left: visit2(e.left, bound2), right: visit2(e.right, bound2) };
+      case "unary":
+        return { ...e, argument: visit2(e.argument, bound2) };
+      case "conditional":
+        return { ...e, test: visit2(e.test, bound2), consequent: visit2(e.consequent, bound2), alternate: visit2(e.alternate, bound2) };
+      case "template-literal":
+        return { ...e, parts: e.parts.map((p) => p.type === "expression" ? { ...p, expr: visit2(p.expr, bound2) } : p) };
+      case "array-literal":
+        return { ...e, elements: e.elements.map((el) => visit2(el, bound2)) };
+      case "array-method":
+        return {
+          ...e,
+          object: visit2(e.object, bound2),
+          args: e.args.map((a) => visit2(a, bound2)),
+          ...e.method === "flat" && e.depthExpr ? { depthExpr: visit2(e.depthExpr, bound2) } : {}
+        };
+      case "object-literal":
+        return { ...e, properties: e.properties.map((p) => ({ ...p, value: visit2(p.value, bound2) })) };
+      case "arrow": {
+        const inner = e.params.length === 0 ? bound2 : new Set([...bound2, ...e.params]);
+        return { ...e, body: visit2(e.body, inner) };
+      }
+    }
+  }
+  return visit2(expr, bound);
+}
 function extractFilterPredicate(callback, ctx) {
   if (!ts11.isArrowFunction(callback))
     return { result: null };
@@ -9810,6 +10112,7 @@ function extractItemConditionalKey(cond) {
 }
 function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const isNested = ctx.loopParams.size > 0;
+  const depth = ctx.loopDepth;
   const propAccess = node.expression;
   const mapSource = propAccess.expression;
   let array = "";
@@ -9822,6 +10125,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   let templateMapPreamble;
   let typedMapPreamble;
   let iterationShape;
+  let objectIteration;
   const setArray = (node2) => {
     array = ctx.getJS(node2);
     templateArray = rewriteBarePropRefs2(array, node2, ctx);
@@ -9836,6 +10140,12 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     } else if (iteratorInfo.shape === "keys") {
       iterationShape = "keys";
     }
+  } else {
+    const objectIteratorInfo = isObjectIteratorCall(mapSource);
+    if (objectIteratorInfo) {
+      chainSource = objectIteratorInfo.object;
+      objectIteration = objectIteratorInfo.shape;
+    }
   }
   const filterInfo = isFilterCall(chainSource);
   const sortInfo = isSortCall(chainSource);
@@ -9910,13 +10220,11 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
           setArray(innerSort.array);
         }
       } else {
-        array = ctx.getJS(filterInfo.array);
-        arrayExpr = filterInfo.array;
+        setArray(filterInfo.array);
       }
     }
   } else {
-    array = ctx.getJS(chainSource);
-    arrayExpr = chainSource;
+    setArray(chainSource);
   }
   const callback = node.arguments[0];
   let param = "item";
@@ -9933,7 +10241,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
       if (firstParam.type) {
         paramType = firstParam.type.getText(ctx.sourceFile);
       }
-      if (iterationShape === "entries" && ts11.isArrayBindingPattern(firstParam.name)) {
+      const isEntriesShape = iterationShape === "entries" || objectIteration === "entries";
+      if (isEntriesShape && ts11.isArrayBindingPattern(firstParam.name)) {
         const elements = firstParam.name.elements.filter((el) => !ts11.isOmittedExpression(el));
         if (elements.length === 2 && ts11.isBindingElement(elements[0]) && ts11.isIdentifier(elements[0].name) && ts11.isBindingElement(elements[1]) && ts11.isIdentifier(elements[1].name)) {
           index = elements[0].name.text;
@@ -9955,7 +10264,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         }
       }
     }
-    if (callback.parameters.length > 1 && iterationShape !== "entries") {
+    if (callback.parameters.length > 1 && iterationShape !== "entries" && objectIteration !== "entries") {
       const secondParam = callback.parameters[1];
       index = secondParam.name.getText(ctx.sourceFile);
       if (secondParam.type) {
@@ -9970,6 +10279,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }
     if (index)
       ctx.loopParams.add(index);
+    ctx.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
       if (!ts11.isBinaryExpression(expr))
         return;
@@ -10066,6 +10376,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }
     if (index)
       ctx.loopParams.delete(index);
+    ctx.loopDepth--;
   }
   if (children.length === 0 && !flatMapCallback) {
     return null;
@@ -10094,7 +10405,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const callsReactive = exprCallsReactiveGetters(arrayExpr, ctx);
   const hasCalls = exprHasFunctionCalls(arrayExpr);
   const isDirectPropArray = method !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx);
-  const isStaticArray = !isSignalOrMemoArray(array, ctx) && !isDirectPropArray && !hasCalls;
+  const isStaticArray = !isSignalOrMemoArray(array, ctx) && !isDirectPropArray && !hasCalls && !objectIteration;
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -10121,6 +10432,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     sortComparator,
     chainOrder,
     iterationShape,
+    objectIteration,
+    depth,
     clientOnly: isClientOnly || undefined,
     mapPreamble,
     templateMapPreamble,
@@ -10363,7 +10676,7 @@ function getAttributeValue(attr, ctx) {
     return AttrValueOf.booleanAttr();
   }
   if (ts11.isStringLiteral(attr.initializer)) {
-    return AttrValueOf.literal(attr.initializer.text);
+    return AttrValueOf.literal(decodeEntities(attr.initializer.text));
   }
   if (ts11.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     let expr = attr.initializer.expression;
@@ -10461,7 +10774,7 @@ function parseTemplateLiteral(expr, ctx) {
 }
 function tryResolveTemplateSpanFromConst(expr, ctx) {
   if (ts11.isIdentifier(expr)) {
-    const constInfo = findLocalConst(expr.text, ctx);
+    const constInfo = findLocalConst(expr.text, ctx.analyzer);
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
@@ -10475,7 +10788,7 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
   if (ts11.isElementAccessExpression(expr)) {
     if (!ts11.isIdentifier(expr.expression))
       return null;
-    const constInfo = findLocalConst(expr.expression.text, ctx);
+    const constInfo = findLocalConst(expr.expression.text, ctx.analyzer);
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
@@ -10501,16 +10814,16 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
   }
   return null;
 }
-function findLocalConst(name, ctx) {
-  const matches = ctx.analyzer.localConstants.filter((c) => c.name === name);
+function findLocalConst(name, analyzer) {
+  const matches = analyzer.localConstants.filter((c) => c.name === name);
   if (matches.length === 0)
     return;
   const fnScoped = matches.filter((c) => !c.isModule);
   const pool = fnScoped.length > 0 ? fnScoped : matches;
   return pool[pool.length - 1];
 }
-function findLocalFunction(name, ctx) {
-  const matches = ctx.analyzer.localFunctions.filter((f) => f.name === name);
+function findLocalFunction(name, analyzer) {
+  const matches = analyzer.localFunctions.filter((f) => f.name === name);
   if (matches.length === 0)
     return;
   const fnScoped = matches.filter((f) => !f.isModule);
@@ -10552,7 +10865,9 @@ function hasDynamicTagBinding(name, sourceFile) {
   return found;
 }
 function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
-  const constInfo = findLocalConst(ident.text, ctx);
+  if (ctx.loopParams.has(ident.text))
+    return null;
+  const constInfo = findLocalConst(ident.text, ctx.analyzer);
   if (!constInfo)
     return null;
   const ast = parseConstInitializer(constInfo);
@@ -10649,8 +10964,8 @@ function tryDesugarInterleaveTaggedTemplate(expr, ctx) {
   return rewritten ?? expr;
 }
 function resolveInterleaveTagIdentifier(name, ctx) {
-  const constInfo = findLocalConst(name, ctx);
-  const fnInfo = findLocalFunction(name, ctx);
+  const constInfo = findLocalConst(name, ctx.analyzer);
+  const fnInfo = findLocalFunction(name, ctx.analyzer);
   if (constInfo && fnInfo)
     return null;
   if (constInfo) {
@@ -11404,6 +11719,7 @@ function collectLoopChildEventsWithNesting(node, initialNestingStack = []) {
             depth: scope.nestingStack.length + 1,
             array: l.array,
             param: l.param,
+            index: l.index,
             key: l.key,
             markerId: l.markerId,
             containerSlotId: scope.lastElementSlotId,
@@ -11494,64 +11810,215 @@ function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings)
   return attrs;
 }
 
-// src/ir-to-client-js/collect-elements.ts
-var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
-function domElementCount(node) {
-  switch (node.type) {
-    case "element":
-    case "component":
-    case "provider":
-    case "async":
-      return 1;
-    case "text":
-      return 0;
-    case "expression":
-      return EMPTY_RENDER_EXPRS.has(node.expr.trim()) ? 0 : null;
-    case "loop":
-      if (node.bodyIsItemConditional || node.method === "flatMap")
-        return null;
-      return `(${buildLoopChainExpr({
-        base: node.array,
-        sortComparator: node.sortComparator,
-        filterPredicate: node.filterPredicate,
-        chainOrder: node.chainOrder
-      })}).length`;
-    case "conditional": {
-      const t = domElementCount(node.whenTrue);
-      const f = domElementCount(node.whenFalse);
-      if (t === null || f === null)
-        return null;
-      if (typeof t === "number" && typeof f === "number" && t === f)
-        return t;
-      return `(${node.condition} ? ${t} : ${f})`;
-    }
-    case "fragment":
-      return sumElementCounts(node.children);
-    default:
-      return null;
-  }
-}
-function sumElementCounts(nodes) {
-  let staticCount = 0;
-  const dynamic = [];
-  for (const n of nodes) {
-    const c = domElementCount(n);
-    if (c === null)
-      return null;
-    if (typeof c === "number")
-      staticCount += c;
-    else
-      dynamic.push(c);
+// src/ir-to-client-js/control-flow/stringify/template-parse.ts
+var SVG_ROOT_TAGS = new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "text",
+  "tspan",
+  "textPath",
+  "g",
+  "defs",
+  "use",
+  "symbol",
+  "switch",
+  "clipPath",
+  "mask",
+  "marker",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "image",
+  "foreignObject",
+  "filter",
+  "feBlend",
+  "feColorMatrix",
+  "feComposite",
+  "feFlood",
+  "feGaussianBlur",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "feTurbulence",
+  "animate",
+  "animateTransform",
+  "animateMotion"
+]);
+function templateRootIsSvg(template) {
+  const stripped = stripLeadingNonContent(template);
+  const m = stripped.match(/^<\s*([A-Za-z][A-Za-z0-9-]*)/);
+  if (m) {
+    const tag = m[1];
+    if (SVG_ROOT_TAGS.has(tag))
+      return true;
+    return SVG_ROOT_TAGS.has(tag.toLowerCase());
   }
-  if (dynamic.length === 0)
-    return staticCount;
-  const parts = staticCount > 0 ? [String(staticCount), ...dynamic] : dynamic;
-  return parts.length === 1 ? parts[0] : `(${parts.join(" + ")})`;
+  const branches = extractConditionalBranchTemplates(stripped);
+  if (branches === null || branches.length === 0)
+    return false;
+  return branches.every(templateRootIsSvg);
 }
-function legacyElementCount(node) {
-  return node.type === "element" || node.type === "component" || node.type === "provider" || node.type === "async" || node.type === "text" || node.type === "expression" && !node.reactive || node.type === "conditional" ? 1 : 0;
+function multiRootTemplateNeedsSvgWrap(template) {
+  const m = stripLeadingNonContent(template).match(/^<\s*([A-Za-z][A-Za-z0-9-]*)/);
+  if (m && m[1].toLowerCase() === "svg")
+    return false;
+  return templateRootIsSvg(template);
 }
-function computeLoopSiblingOffsets(root) {
+function stripLeadingNonContent(template) {
+  let s = template.trimStart();
+  while (s.startsWith("<!--")) {
+    const end = s.indexOf("-->");
+    if (end < 0)
+      return s;
+    s = s.slice(end + 3).trimStart();
+  }
+  return s;
+}
+function extractConditionalBranchTemplates(template) {
+  if (!template.startsWith("${"))
+    return null;
+  const exprEnd = findInterpolationEnd(template, 2);
+  if (exprEnd < 0)
+    return null;
+  const trailing = stripLeadingNonContent(template.slice(exprEnd + 1));
+  if (trailing.length > 0)
+    return null;
+  const expr = template.slice(2, exprEnd);
+  return findTopLevelTemplateLiterals(expr);
+}
+function emitTemplateCloneInline(template) {
+  if (templateRootIsSvg(template)) {
+    return `const __tpl = document.createElement('template'); __tpl.innerHTML = \`<svg>${template}</svg>\`; return __tpl.content.firstElementChild.firstElementChild.cloneNode(true)`;
+  }
+  return `const __tpl = document.createElement('template'); __tpl.innerHTML = \`${template}\`; return __tpl.content.firstElementChild.cloneNode(true)`;
+}
+function emitHoistedTemplateDecl(lines, indent, tplVar, skeletonTemplate) {
+  const isSvg = templateRootIsSvg(skeletonTemplate);
+  const html = isSvg ? `<svg>${skeletonTemplate}</svg>` : skeletonTemplate;
+  lines.push(`${indent}const ${tplVar} = document.createElement('template')`);
+  lines.push(`${indent}${tplVar}.innerHTML = \`${html}\``);
+}
+function hoistedCloneExpr(tplVar, skeletonTemplate) {
+  return templateRootIsSvg(skeletonTemplate) ? `${tplVar}.content.firstElementChild.firstElementChild.cloneNode(true)` : `${tplVar}.content.firstElementChild.cloneNode(true)`;
+}
+function emitTemplateCloneLines(template, indent) {
+  if (templateRootIsSvg(template)) {
+    return [
+      `${indent}const __tpl = document.createElement('template')`,
+      `${indent}__tpl.innerHTML = \`<svg>${template}</svg>\``,
+      `${indent}return __tpl.content.firstElementChild.firstElementChild.cloneNode(true)`
+    ];
+  }
+  return [
+    `${indent}const __tpl = document.createElement('template')`,
+    `${indent}__tpl.innerHTML = \`${template}\``,
+    `${indent}return __tpl.content.firstElementChild.cloneNode(true)`
+  ];
+}
+function emitLoopItemElementSetup(lines, opts) {
+  const { template, bodyIsMultiRoot, indent, singleRootLayout } = opts;
+  const innerIndent = indent + "  ";
+  if (bodyIsMultiRoot) {
+    lines.push(`${indent}let __el, __extras`);
+    lines.push(`${indent}if (__existing) {`);
+    lines.push(`${innerIndent}__el = __existing`);
+    lines.push(`${indent}} else {`);
+    for (const ln of emitMultiRootTemplateCloneLines(template, innerIndent, "__el", "__extras")) {
+      lines.push(ln);
+    }
+    lines.push(`${innerIndent}__el.__bfExtras = __extras`);
+    lines.push(`${indent}}`);
+    return;
+  }
+  if (singleRootLayout === "inline") {
+    const cloneExpr = emitTemplateCloneInline(template);
+    lines.push(`${indent}const __el = __existing ?? (() => { ${cloneExpr} })()`);
+    return;
+  }
+  lines.push(`${indent}const __el = __existing ?? (() => {`);
+  for (const ln of emitTemplateCloneLines(template, innerIndent))
+    lines.push(ln);
+  lines.push(`${indent}})()`);
+}
+function emitMultiRootTemplateCloneLines(template, indent, varEl, varExtras) {
+  const isSvg = multiRootTemplateNeedsSvgWrap(template);
+  const innerHtmlExpr = isSvg ? `\`<svg>${template}</svg>\`` : `\`${template}\``;
+  const parentExpr = isSvg ? `__tpl.content.firstElementChild` : `__tpl.content`;
+  return [
+    `${indent}const __tpl = document.createElement('template')`,
+    `${indent}__tpl.innerHTML = ${innerHtmlExpr}`,
+    `${indent}${varEl} = ${parentExpr}.firstElementChild.cloneNode(true)`,
+    `${indent}${varExtras} = []`,
+    `${indent}{ let __sib = ${parentExpr}.firstElementChild.nextElementSibling; while (__sib) { ${varExtras}.push(__sib.cloneNode(true)); __sib = __sib.nextElementSibling } }`
+  ];
+}
+
+// src/ir-to-client-js/collect-elements.ts
+var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
+function domElementCount(node) {
+  switch (node.type) {
+    case "element":
+    case "component":
+    case "provider":
+    case "async":
+      return 1;
+    case "text":
+      return 0;
+    case "expression":
+      return EMPTY_RENDER_EXPRS.has(node.expr.trim()) ? 0 : null;
+    case "loop":
+      if (node.bodyIsItemConditional || node.method === "flatMap")
+        return null;
+      return `(${buildLoopChainExpr({
+        base: node.array,
+        sortComparator: node.sortComparator,
+        filterPredicate: node.filterPredicate,
+        chainOrder: node.chainOrder
+      })}).length`;
+    case "conditional": {
+      const t = domElementCount(node.whenTrue);
+      const f = domElementCount(node.whenFalse);
+      if (t === null || f === null)
+        return null;
+      if (typeof t === "number" && typeof f === "number" && t === f)
+        return t;
+      return `(${node.condition} ? ${t} : ${f})`;
+    }
+    case "fragment":
+      return sumElementCounts(node.children);
+    default:
+      return null;
+  }
+}
+function sumElementCounts(nodes) {
+  let staticCount = 0;
+  const dynamic = [];
+  for (const n of nodes) {
+    const c = domElementCount(n);
+    if (c === null)
+      return null;
+    if (typeof c === "number")
+      staticCount += c;
+    else
+      dynamic.push(c);
+  }
+  if (dynamic.length === 0)
+    return staticCount;
+  const parts = staticCount > 0 ? [String(staticCount), ...dynamic] : dynamic;
+  return parts.length === 1 ? parts[0] : `(${parts.join(" + ")})`;
+}
+function legacyElementCount(node) {
+  return node.type === "element" || node.type === "component" || node.type === "provider" || node.type === "async" || node.type === "text" || node.type === "expression" && !node.reactive || node.type === "conditional" ? 1 : 0;
+}
+function computeLoopSiblingOffsets(root) {
   const offsets = new Map;
   const recordRun = (children, preceding) => {
     for (const child of children) {
@@ -11672,11 +12139,13 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
           arrayFreeIdentifiers: n.arrayFreeIdentifiers,
           param: n.param,
           paramBindings: n.paramBindings,
+          index: n.index,
           key: n.key,
           markerId: n.markerId,
           bodyIsMultiRoot: n.bodyIsMultiRoot,
           bodyIsItemConditional: n.bodyIsItemConditional,
           iterationShape: n.iterationShape,
+          objectIteration: n.objectIteration,
           containerSlotId: scope.parentSlotId,
           template,
           mapPreamble: n.mapPreamble,
@@ -11868,6 +12337,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       let template = "";
       let staticItemTemplate;
       let skeletonTemplate;
+      let skeletonPaths;
       if (l.childComponent) {
         template = "";
         if (l.isStaticArray && l.children[0]) {
@@ -11879,10 +12349,14 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         if (l.isStaticArray) {
           staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], buildRestSpreadNames(ctx), 0) : irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0);
         } else if (!useElementReconciliation && !l.bodyIsMultiRoot && !l.bodyIsItemConditional) {
-          skeletonTemplate = buildLoopSkeletonTemplate(l.children[0], {
+          const skeletonSafeSlots = {
             reactiveAttrKeys: new Set(bindings.reactiveAttrs.map((a) => `${a.childSlotId}::${a.attrName}`)),
             reactiveTextSlotIds: new Set(bindings.reactiveTexts.map((t) => t.slotId))
-          }) ?? undefined;
+          };
+          skeletonTemplate = buildLoopSkeletonTemplate(l.children[0], skeletonSafeSlots) ?? undefined;
+          if (skeletonTemplate && !templateRootIsSvg(skeletonTemplate)) {
+            skeletonPaths = computeSkeletonSlotPaths(l.children[0], skeletonSafeSlots) ?? undefined;
+          }
         }
       }
       ctx.loopElements.push({
@@ -11898,9 +12372,11 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         bodyIsMultiRoot: l.bodyIsMultiRoot,
         bodyIsItemConditional: l.bodyIsItemConditional,
         iterationShape: l.iterationShape,
+        objectIteration: l.objectIteration,
         template,
         staticItemTemplate,
         skeletonTemplate,
+        skeletonPaths,
         childEventHandlers: childHandlers,
         bindings,
         childComponent: l.childComponent,
@@ -12097,6 +12573,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
         bodyIsMultiRoot: n.bodyIsMultiRoot,
         bodyIsItemConditional: n.bodyIsItemConditional,
         iterationShape: n.iterationShape,
+        objectIteration: n.objectIteration,
         template: childTemplate,
         containerSlotId: containerSlot,
         mapPreamble: n.mapPreamble ?? null,
@@ -12690,6 +13167,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "__slot",
   "__bfSlot",
   "__bfText",
+  "tAfter",
   "beginTurn",
   "endTurn"
 ];
@@ -14560,9 +15038,63 @@ import { BF_SCOPE as BF_SCOPE2, BF_HOST, BF_AT } from "@barefootjs/shared";
 function loopKeyFn(loop) {
   if (loop.key === null)
     return "null";
-  const params = loop.kind === "nested" ? loop.param : `${loop.param}${loop.index ? `, ${loop.index}` : ""}`;
+  const params = `${loop.param}${loop.index ? `, ${loop.index}` : ""}`;
   return `(${params}) => String(${loop.key})`;
 }
+function nestedLoopReferencesIndex(inner, comps, events) {
+  const index = inner.index;
+  if (!index)
+    return false;
+  const exprRefs = (text, precomputed) => {
+    if (precomputed)
+      return precomputed.has(index);
+    if (!text)
+      return false;
+    return extractFreeIdentifiersFromText(text).has(index);
+  };
+  if (exprRefs(inner.key))
+    return true;
+  for (const t of inner.bindings.reactiveTexts) {
+    if (exprRefs(t.expression, t.freeIdentifiers))
+      return true;
+  }
+  for (const a of inner.bindings.reactiveAttrs) {
+    if (exprRefs(a.expression, a.freeIdentifiers))
+      return true;
+  }
+  if (inner.mapPreamble && extractFreeIdentifiersFromStatementText(inner.mapPreamble).has(index))
+    return true;
+  if (inner.template && extractFreeIdentifiersFromTemplateText(inner.template).has(index))
+    return true;
+  for (const ev of events) {
+    if (exprRefs(ev.handler))
+      return true;
+  }
+  for (const r of inner.bindings.refs) {
+    if (exprRefs(r.callback))
+      return true;
+  }
+  for (const c of comps) {
+    for (const p of c.props) {
+      if (exprRefs(attrValueToString(p.value)))
+        return true;
+    }
+    if (c.children?.length) {
+      const childrenExpr = irChildrenToJsExpr(c.children);
+      if (childrenExpr && exprRefs(childrenExpr))
+        return true;
+    }
+  }
+  return false;
+}
+function nestedLoopIndexAlias(inner, syntheticIndexVar, paramHead, comps, events) {
+  const index = inner.index;
+  if (!index || index === paramHead)
+    return null;
+  if (!nestedLoopReferencesIndex(inner, comps, events))
+    return null;
+  return `const ${index} = ${syntheticIndexVar}`;
+}
 function buildChildRefBindings(refs, loopParam, loopParamBindings) {
   if (refs.length === 0)
     return [];
@@ -14743,6 +15275,7 @@ function buildOuterNestedPlan(elem, comp) {
 }
 function buildInnerLoopNestedPlan(elem, innerLoop, innerComps) {
   const outerIndexParam = elem.index || "__idx";
+  const innerIndexParam = innerLoop.index || "__innerIdx";
   const comps = innerComps.map((comp) => ({
     componentName: comp.name,
     selector: buildCompSelector(comp),
@@ -14759,7 +15292,8 @@ function buildInnerLoopNestedPlan(elem, innerLoop, innerComps) {
     innerContainerSlotId: innerLoop.containerSlotId ?? null,
     innerArrayExpr: innerLoop.array,
     innerParam: innerLoop.param,
-    innerOffsetExpr: buildLoopChildIndexExpr("__innerIdx", innerLoop.offset),
+    innerIndexParam,
+    innerOffsetExpr: buildLoopChildIndexExpr(innerIndexParam, innerLoop.offset),
     innerPreludeStatements: innerLoop.mapPreamble ? [innerLoop.mapPreamble] : [],
     depth: innerLoop.depth,
     comps
@@ -14776,9 +15310,11 @@ function buildComponentRootedInnerLoopPlan(elem, innerLoop, innerComps) {
     containerVar: `_${varSlotId(elem.slotId)}`,
     outerArrayExpr: elem.array,
     outerParam: elem.param,
+    outerIndexParam: elem.index,
     outerPreludeStatements: elem.mapPreamble ? [elem.mapPreamble] : [],
     innerArrayExpr: innerLoop.array,
     innerParam: innerLoop.param,
+    innerIndexParam: innerLoop.index,
     innerPreludeStatements: innerLoop.mapPreamble ? [innerLoop.mapPreamble] : [],
     depth: innerLoop.depth,
     comps
@@ -14871,6 +15407,7 @@ function emitInnerLoopNested(lines, plan) {
     innerContainerSlotId,
     innerArrayExpr,
     innerParam,
+    innerIndexParam,
     innerOffsetExpr,
     innerPreludeStatements,
     depth,
@@ -14889,7 +15426,7 @@ function emitInnerLoopNested(lines, plan) {
   } else {
     lines.push(`      const __ic = __outerEl`);
   }
-  lines.push(`      ${innerArrayExpr}.forEach((${innerParam}, __innerIdx) => {`);
+  lines.push(`      ${innerArrayExpr}.forEach((${innerParam}, ${innerIndexParam}) => {`);
   lines.push(`        const __innerEl = __ic.children[${innerOffsetExpr}]`);
   lines.push(`        if (!__innerEl) return`);
   for (const stmt of innerPreludeStatements) {
@@ -14910,9 +15447,11 @@ function emitComponentRootedInnerLoop(lines, plan) {
     containerVar,
     outerArrayExpr,
     outerParam,
+    outerIndexParam,
     outerPreludeStatements,
     innerArrayExpr,
     innerParam,
+    innerIndexParam,
     innerPreludeStatements,
     depth,
     comps
@@ -14926,11 +15465,11 @@ function emitComponentRootedInnerLoop(lines, plan) {
     lines.push(`    const ${scopesVar(i)} = qsaChildScopes(${containerVar}, ${comp.selector})`);
     lines.push(`    let ${cursorVar(i)} = 0`);
   });
-  lines.push(`    ${outerArrayExpr}.forEach((${outerParam}) => {`);
+  lines.push(`    ${outerArrayExpr}.forEach((${outerParam}${outerIndexParam ? `, ${outerIndexParam}` : ""}) => {`);
   for (const stmt of outerPreludeStatements) {
     lines.push(`      ${stmt}`);
   }
-  lines.push(`      ${innerArrayExpr}.forEach((${innerParam}) => {`);
+  lines.push(`      ${innerArrayExpr}.forEach((${innerParam}${innerIndexParam ? `, ${innerIndexParam}` : ""}) => {`);
   for (const stmt of innerPreludeStatements) {
     lines.push(`        ${stmt}`);
   }
@@ -15082,6 +15621,7 @@ function buildBranchInnerLoopsPlan(args) {
       ...ev,
       handler: wrapInner(ev.handler)
     }));
+    const indexAlias = nestedLoopIndexAlias(inner, `__bidxbr_${i}`, paramHead, inner.childComponents ?? [], inner.bindings.events);
     const reactiveTexts = inner.bindings.reactiveTexts.map((text) => ({
       slotId: text.slotId,
       wrappedExpression: wrapBoth(text.expression),
@@ -15096,6 +15636,7 @@ function buildBranchInnerLoopsPlan(args) {
       keyFn: loopKeyFn(inner),
       paramHead,
       paramUnwrap,
+      indexAlias,
       wrappedTemplate: inner.template,
       wrappedKey,
       keyDepth: 1,
@@ -15337,7 +15878,7 @@ function buildInnerLoopsPlan(args) {
     const containerExpr = inner.containerSlotId ? `qsa(${parentElVar}, '[bf="${inner.containerSlotId}"]')` : parentElVar;
     const refsParent = !!outerLoopParam && (inner.arrayFreeIdentifiers?.has(outerLoopParam) ?? false);
     const useReactive = refsParent && !!inner.template;
-    const emit = useReactive ? buildReactiveEmit(inner, level, wrapOuter) : buildStaticEmit(inner, level);
+    const emit = useReactive ? buildReactiveEmit(inner, level, wrapOuter, uidSuffix) : buildStaticEmit(inner, level, uidSuffix);
     const arrayExpr = useReactive ? wrapOuter(inner.array) : inner.array;
     const childLevelsPlan = childLevels.length > 0 ? buildInnerLoopsPlan({
       levels: childLevels,
@@ -15363,7 +15904,7 @@ function buildInnerLoopsPlan(args) {
   }
   return plan;
 }
-function buildReactiveEmit(inner, level, wrapOuter) {
+function buildReactiveEmit(inner, level, wrapOuter, uidSuffix) {
   const wrapInner = (expr) => wrapLoopParamAsAccessor(expr, inner.param, inner.paramBindings);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(inner.param, inner.paramBindings);
   const wrappedKey = inner.key ? wrapLoopParamAsAccessor(inner.key, inner.param, inner.paramBindings) : null;
@@ -15410,6 +15951,9 @@ function buildReactiveEmit(inner, level, wrapOuter) {
     };
   });
   const preludeStatements = [];
+  const indexAlias = nestedLoopIndexAlias(inner, `__innerIdx${uidSuffix}`, paramHead, level.comps, level.events);
+  if (indexAlias)
+    preludeStatements.push(indexAlias);
   if (paramUnwrap)
     preludeStatements.push(paramUnwrap);
   if (inner.mapPreamble)
@@ -15430,8 +15974,13 @@ function buildReactiveEmit(inner, level, wrapOuter) {
     childRefs
   };
 }
-function buildStaticEmit(inner, level) {
-  const preludeStatements = inner.mapPreamble ? [inner.mapPreamble] : [];
+function buildStaticEmit(inner, level, uidSuffix) {
+  const preludeStatements = [];
+  const indexAlias = nestedLoopIndexAlias(inner, `__innerIdx${uidSuffix}`, inner.param, level.comps, level.events);
+  if (indexAlias)
+    preludeStatements.push(indexAlias);
+  if (inner.mapPreamble)
+    preludeStatements.push(inner.mapPreamble);
   return {
     mode: "static",
     rawKey: inner.key ?? null,
@@ -15566,6 +16115,7 @@ function buildDynamicLoopDelegationPlan(elem, profileComponentName) {
       param: elem.param,
       paramBindings: elem.paramBindings,
       key: elem.key,
+      index: elem.index,
       mapPreamble: elem.mapPreamble ?? null
     })
   };
@@ -15581,6 +16131,7 @@ function buildBranchLoopDelegationPlan(loop, cv, profileComponentName) {
       param: loop.param,
       paramBindings: loop.paramBindings,
       key: loop.key,
+      index: loop.index,
       mapPreamble: loop.mapPreamble ?? null
     })
   };
@@ -15596,7 +16147,8 @@ function buildStaticArrayDelegationPlan(elem, profileComponentName) {
       arrayExpr: buildChainedArrayExpr(elem),
       param: elem.param,
       mapPreamble: elem.mapPreamble ?? null,
-      offset: elem.offset ?? null
+      offset: elem.offset ?? null,
+      indexParam: elem.index ?? null
     }
   };
 }
@@ -15611,7 +16163,8 @@ function buildKeyedOrIndexLookup(args) {
       paramBindings: args.paramBindings,
       keyWithItem,
       mapPreamble: args.mapPreamble,
-      hasBindings
+      hasBindings,
+      indexParam: args.index
     };
   }
   return {
@@ -15619,7 +16172,8 @@ function buildKeyedOrIndexLookup(args) {
     arrayExpr: args.array,
     param: args.param,
     mapPreamble: args.mapPreamble,
-    hasBindings
+    hasBindings,
+    indexParam: args.index
   };
 }
 
@@ -15929,151 +16483,6 @@ function emitReactiveChildProps(lines, ctx) {
   }
 }
 
-// src/ir-to-client-js/control-flow/stringify/template-parse.ts
-var SVG_ROOT_TAGS = new Set([
-  "svg",
-  "path",
-  "circle",
-  "rect",
-  "line",
-  "polyline",
-  "polygon",
-  "ellipse",
-  "text",
-  "tspan",
-  "textPath",
-  "g",
-  "defs",
-  "use",
-  "symbol",
-  "switch",
-  "clipPath",
-  "mask",
-  "marker",
-  "pattern",
-  "linearGradient",
-  "radialGradient",
-  "stop",
-  "image",
-  "foreignObject",
-  "filter",
-  "feBlend",
-  "feColorMatrix",
-  "feComposite",
-  "feFlood",
-  "feGaussianBlur",
-  "feMerge",
-  "feMergeNode",
-  "feMorphology",
-  "feOffset",
-  "feTurbulence",
-  "animate",
-  "animateTransform",
-  "animateMotion"
-]);
-function templateRootIsSvg(template) {
-  const stripped = stripLeadingNonContent(template);
-  const m = stripped.match(/^<\s*([A-Za-z][A-Za-z0-9-]*)/);
-  if (m) {
-    const tag = m[1];
-    if (SVG_ROOT_TAGS.has(tag))
-      return true;
-    return SVG_ROOT_TAGS.has(tag.toLowerCase());
-  }
-  const branches = extractConditionalBranchTemplates(stripped);
-  if (branches === null || branches.length === 0)
-    return false;
-  return branches.every(templateRootIsSvg);
-}
-function stripLeadingNonContent(template) {
-  let s = template.trimStart();
-  while (s.startsWith("<!--")) {
-    const end = s.indexOf("-->");
-    if (end < 0)
-      return s;
-    s = s.slice(end + 3).trimStart();
-  }
-  return s;
-}
-function extractConditionalBranchTemplates(template) {
-  if (!template.startsWith("${"))
-    return null;
-  const exprEnd = findInterpolationEnd(template, 2);
-  if (exprEnd < 0)
-    return null;
-  const trailing = stripLeadingNonContent(template.slice(exprEnd + 1));
-  if (trailing.length > 0)
-    return null;
-  const expr = template.slice(2, exprEnd);
-  return findTopLevelTemplateLiterals(expr);
-}
-function emitTemplateCloneInline(template) {
-  if (templateRootIsSvg(template)) {
-    return `const __tpl = document.createElement('template'); __tpl.innerHTML = \`<svg>${template}</svg>\`; return __tpl.content.firstElementChild.firstElementChild.cloneNode(true)`;
-  }
-  return `const __tpl = document.createElement('template'); __tpl.innerHTML = \`${template}\`; return __tpl.content.firstElementChild.cloneNode(true)`;
-}
-function emitHoistedTemplateDecl(lines, indent, tplVar, skeletonTemplate) {
-  const isSvg = templateRootIsSvg(skeletonTemplate);
-  const html = isSvg ? `<svg>${skeletonTemplate}</svg>` : skeletonTemplate;
-  lines.push(`${indent}const ${tplVar} = document.createElement('template')`);
-  lines.push(`${indent}${tplVar}.innerHTML = \`${html}\``);
-}
-function hoistedCloneExpr(tplVar, skeletonTemplate) {
-  return templateRootIsSvg(skeletonTemplate) ? `${tplVar}.content.firstElementChild.firstElementChild.cloneNode(true)` : `${tplVar}.content.firstElementChild.cloneNode(true)`;
-}
-function emitTemplateCloneLines(template, indent) {
-  if (templateRootIsSvg(template)) {
-    return [
-      `${indent}const __tpl = document.createElement('template')`,
-      `${indent}__tpl.innerHTML = \`<svg>${template}</svg>\``,
-      `${indent}return __tpl.content.firstElementChild.firstElementChild.cloneNode(true)`
-    ];
-  }
-  return [
-    `${indent}const __tpl = document.createElement('template')`,
-    `${indent}__tpl.innerHTML = \`${template}\``,
-    `${indent}return __tpl.content.firstElementChild.cloneNode(true)`
-  ];
-}
-function emitLoopItemElementSetup(lines, opts) {
-  const { template, bodyIsMultiRoot, indent, singleRootLayout } = opts;
-  const innerIndent = indent + "  ";
-  if (bodyIsMultiRoot) {
-    lines.push(`${indent}let __el, __extras`);
-    lines.push(`${indent}if (__existing) {`);
-    lines.push(`${innerIndent}__el = __existing`);
-    lines.push(`${indent}} else {`);
-    for (const ln of emitMultiRootTemplateCloneLines(template, innerIndent, "__el", "__extras")) {
-      lines.push(ln);
-    }
-    lines.push(`${innerIndent}__el.__bfExtras = __extras`);
-    lines.push(`${indent}}`);
-    return;
-  }
-  if (singleRootLayout === "inline") {
-    const cloneExpr = emitTemplateCloneInline(template);
-    lines.push(`${indent}const __el = __existing ?? (() => { ${cloneExpr} })()`);
-    return;
-  }
-  lines.push(`${indent}const __el = __existing ?? (() => {`);
-  for (const ln of emitTemplateCloneLines(template, innerIndent))
-    lines.push(ln);
-  lines.push(`${indent}})()`);
-}
-function emitMultiRootTemplateCloneLines(template, indent, varEl, varExtras) {
-  const isSvg = templateRootIsSvg(template);
-  const innerHtmlExpr = isSvg ? `\`<svg>${template}</svg>\`` : `\`${template}\``;
-  const parentExpr = isSvg ? `__tpl.content.firstElementChild` : `__tpl.content`;
-  return [
-    `${indent}const __tpl = document.createElement('template')`,
-    `${indent}__tpl.innerHTML = ${innerHtmlExpr}`,
-    `${indent}${varEl} = ${parentExpr}.firstElementChild.cloneNode(true)`,
-    `${indent}${varExtras} = []`,
-    `${indent}{ let __sib = ${parentExpr}.firstElementChild.nextElementSibling; while (__sib) { ${varExtras}.push(__sib.cloneNode(true)); __sib = __sib.nextElementSibling } }`
-  ];
-}
-
 // src/ir-to-client-js/control-flow/stringify/loop-child-arm.ts
 function stringifyBranchEventBindings(lines, plan, indent) {
   for (const slot of plan) {
@@ -16095,6 +16504,9 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
     const uid = inner.uidSuffix;
     lines.push(`${indent}{ const __bic${uid} = ${inner.containerExpr}`);
     lines.push(`${indent}if (__bic${uid}) mapArray(() => ${inner.arrayExpr} || [], __bic${uid}, ${inner.keyFn}, (${inner.paramHead}, __bidx${uid}, __existing) => {`);
+    if (inner.indexAlias) {
+      lines.push(`${indent}  ${inner.indexAlias}`);
+    }
     if (inner.paramUnwrap) {
       lines.push(`${indent}  ${inner.paramUnwrap}`);
     }
@@ -16159,13 +16571,15 @@ function stringifyLoopChildArm(lines, arm, armIndent, pc) {
 
 // src/ir-to-client-js/control-flow/stringify/reactive-effects.ts
 function stringifyReactiveEffects(lines, plan, opts) {
-  const { indent, elVar, bodyIsMultiRoot } = opts;
+  const { indent, elVar, bodyIsMultiRoot, elementIndexBySlot, textIndexBySlot } = opts;
   const lookup = bodyIsMultiRoot ? "qsaItem" : "qsa";
   const pc = plan.profileComponentName;
   const bindingBfId = (slotId) => profileBindingId(pc, slotId);
   for (const slot of plan.attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
-    lines.push(`${indent}{ const ${varName} = ${lookup}(${elVar}, '[bf="${slot.slotId}"]')`);
+    const pIdx = elementIndexBySlot?.get(slot.slotId);
+    const lookupExpr = pIdx !== undefined ? `__p ? __p[${pIdx}] : ${lookup}(${elVar}, '[bf="${slot.slotId}"]')` : `${lookup}(${elVar}, '[bf="${slot.slotId}"]')`;
+    lines.push(`${indent}{ const ${varName} = ${lookupExpr}`);
     lines.push(`${indent}if (${varName}) {`);
     for (const attr of slot.attrs) {
       lines.push(`${indent}  createEffect(() => {`);
@@ -16177,15 +16591,19 @@ function stringifyReactiveEffects(lines, plan, opts) {
     lines.push(`${indent}} }`);
   }
   for (const text of plan.outerTexts) {
-    emitOuterText(lines, indent, elVar, text, bindingBfId(text.slotId));
+    emitOuterText(lines, indent, elVar, text, bindingBfId(text.slotId), textIndexBySlot?.get(text.slotId));
   }
   for (const cond of plan.conditionals) {
     emitOuterConditional(lines, indent, elVar, cond, pc);
   }
 }
-function emitOuterText(lines, indent, elVar, text, bfId = "") {
+function emitOuterText(lines, indent, elVar, text, bfId = "", pIdx) {
   const varName = `__rt_${varSlotId(text.slotId)}`;
-  lines.push(`${indent}{ const [${varName}] = $t(${elVar}, '${text.slotId}')`);
+  if (pIdx !== undefined) {
+    lines.push(`${indent}{ const ${varName} = __p ? tAfter(__p[${pIdx}]) : $t(${elVar}, '${text.slotId}')[0]`);
+  } else {
+    lines.push(`${indent}{ const [${varName}] = $t(${elVar}, '${text.slotId}')`);
+  }
   lines.push(`${indent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${bfId}) }`);
 }
 function emitOuterConditional(lines, indent, elVar, cond, pc) {
@@ -16217,6 +16635,41 @@ function emitArmText(lines, indent, text, pc) {
   lines.push(`${indent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${profileBindingId(pc, text.slotId)}) }`);
 }
 
+// src/ir-to-client-js/control-flow/stringify/skeleton-paths.ts
+function pathExpr(base, path) {
+  let expr = base;
+  for (const idx of path) {
+    expr += ".firstChild";
+    if (idx > 0)
+      expr += ".nextSibling".repeat(idx);
+  }
+  return expr;
+}
+function buildSkeletonPathPlan(skeletonPaths, elVar, opts) {
+  const arrayElems = [];
+  const elementIndexBySlot = new Map;
+  const textIndexBySlot = new Map;
+  for (const slotId of opts.elementSlotIds) {
+    if (elementIndexBySlot.has(slotId))
+      continue;
+    const path = skeletonPaths.elementPaths.get(slotId);
+    if (!path)
+      continue;
+    elementIndexBySlot.set(slotId, arrayElems.length);
+    arrayElems.push(pathExpr(elVar, path));
+  }
+  for (const slotId of opts.textSlotIds) {
+    if (textIndexBySlot.has(slotId))
+      continue;
+    const path = skeletonPaths.textMarkerPaths.get(slotId);
+    if (!path)
+      continue;
+    textIndexBySlot.set(slotId, arrayElems.length);
+    arrayElems.push(pathExpr(elVar, path));
+  }
+  return { arrayElems, elementIndexBySlot, textIndexBySlot };
+}
+
 // src/ir-to-client-js/control-flow/stringify/component-loop.ts
 function stringifyComponentLoop(lines, plan) {
   const {
@@ -16276,11 +16729,13 @@ function emitNestedInit(lines, indent, parentVar, nc) {
 function emitLoopChildRefs(lines, refs, opts) {
   if (refs.length === 0)
     return;
-  const { indent, elVar, bodyIsMultiRoot } = opts;
+  const { indent, elVar, bodyIsMultiRoot, elementIndexBySlot } = opts;
   const lookup = bodyIsMultiRoot ? "qsaItem" : "qsa";
   for (const ref of refs) {
     const varName = `__rf_${varSlotId(ref.childSlotId)}`;
-    lines.push(`${indent}{ const ${varName} = ${lookup}(${elVar}, '[bf="${ref.childSlotId}"]')`);
+    const pIdx = elementIndexBySlot?.get(ref.childSlotId);
+    const lookupExpr = pIdx !== undefined ? `__p ? __p[${pIdx}] : ${lookup}(${elVar}, '[bf="${ref.childSlotId}"]')` : `${lookup}(${elVar}, '[bf="${ref.childSlotId}"]')`;
+    lines.push(`${indent}{ const ${varName} = ${lookupExpr}`);
     lines.push(`${indent}if (${varName}) ${emitRefCall(ref.callback, varName)} }`);
   }
 }
@@ -16360,10 +16815,31 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
       singleRootLayout: "inline"
     });
   }
+  let pathPlan = null;
+  if (hoistedTpl && plan.skeletonPaths) {
+    const elementSlotIds = [
+      ...reactiveEffects?.attrSlots.map((s) => s.slotId) ?? [],
+      ...childRefs.map((r) => r.childSlotId)
+    ];
+    const textSlotIds = reactiveEffects?.outerTexts.map((t) => t.slotId) ?? [];
+    if (elementSlotIds.length > 0 || textSlotIds.length > 0) {
+      const built = buildSkeletonPathPlan(plan.skeletonPaths, "__el", { elementSlotIds, textSlotIds });
+      if (built.arrayElems.length > 0) {
+        pathPlan = built;
+        lines.push(`${bodyIndent}const __p = __existing ? null : [${built.arrayElems.join(", ")}]`);
+      }
+    }
+  }
   if (reactiveEffects !== null) {
-    stringifyReactiveEffects(lines, reactiveEffects, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot });
+    stringifyReactiveEffects(lines, reactiveEffects, {
+      indent: bodyIndent,
+      elVar: "__el",
+      bodyIsMultiRoot,
+      elementIndexBySlot: pathPlan?.elementIndexBySlot,
+      textIndexBySlot: pathPlan?.textIndexBySlot
+    });
   }
-  emitLoopChildRefs(lines, childRefs, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot });
+  emitLoopChildRefs(lines, childRefs, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot, elementIndexBySlot: pathPlan?.elementIndexBySlot });
   lines.push(`${bodyIndent}return __el`);
   lines.push(`${topIndent}}, '${markerId}'${loopBfId})`);
 }
@@ -16430,12 +16906,14 @@ function stringifyStaticLoop(lines, plan) {
   lines.push(`      let __iterEl = ${containerVar}.children[${childIndexExpr}]`);
   if (csrMaterialize) {
     lines.push(`      if (!__iterEl) {`);
+    const isSvg = csrMaterialize.bodyIsMultiRoot ? multiRootTemplateNeedsSvgWrap(csrMaterialize.itemTemplate) : templateRootIsSvg(csrMaterialize.itemTemplate);
+    const itemHtml = isSvg ? `<svg>${csrMaterialize.itemTemplate}</svg>` : csrMaterialize.itemTemplate;
     if (csrMaterialize.bodyIsMultiRoot) {
       lines.push(`        const __mtpl = document.createElement('template')`);
-      lines.push(`        __mtpl.innerHTML = \`${csrMaterialize.itemTemplate}\``);
+      lines.push(`        __mtpl.innerHTML = \`${itemHtml}\``);
       lines.push(`        const __anchor = ${containerVar}.children[${childIndexExpr}] ?? null`);
       lines.push(`        let __first = null`);
-      lines.push(`        let __sib = __mtpl.content.firstElementChild`);
+      lines.push(`        let __sib = __mtpl.content${isSvg ? ".firstElementChild" : ""}.firstElementChild`);
       lines.push(`        while (__sib) {`);
       lines.push(`          const __next = __sib.nextElementSibling`);
       lines.push(`          const __cloned = __sib.cloneNode(true)`);
@@ -16446,8 +16924,8 @@ function stringifyStaticLoop(lines, plan) {
       lines.push(`        __iterEl = __first`);
     } else {
       lines.push(`        const __tpl = document.createElement('template')`);
-      lines.push(`        __tpl.innerHTML = \`${csrMaterialize.itemTemplate}\``);
-      lines.push(`        const __cloned = __tpl.content.firstElementChild`);
+      lines.push(`        __tpl.innerHTML = \`${itemHtml}\``);
+      lines.push(`        const __cloned = __tpl.content${isSvg ? ".firstElementChild" : ""}.firstElementChild`);
       lines.push(`        if (__cloned) {`);
       lines.push(`          const __anchor = ${containerVar}.children[${childIndexExpr}] ?? null`);
       lines.push(`          ${containerVar}.insertBefore(__cloned, __anchor)`);
@@ -16514,7 +16992,10 @@ function emitReactive(lines, inner, indent, pc) {
     lines.push(`${innerIndent}  __innerEl${uid}.__bfExtras = __innerExtras${uid}`);
     lines.push(`${indent}  }`);
   } else {
-    lines.push(`${indent}  let __innerEl${uid} = __existing ?? (() => { const __t = document.createElement('template'); __t.innerHTML = \`${emit.wrappedTemplate}\`; return __t.content.firstElementChild.cloneNode(true) })()`);
+    const isSvg = templateRootIsSvg(emit.wrappedTemplate);
+    const innerHtml = isSvg ? `<svg>${emit.wrappedTemplate}</svg>` : emit.wrappedTemplate;
+    const childPath = isSvg ? ".firstElementChild.firstElementChild" : ".firstElementChild";
+    lines.push(`${indent}  let __innerEl${uid} = __existing ?? (() => { const __t = document.createElement('template'); __t.innerHTML = \`${innerHtml}\`; return __t.content${childPath}.cloneNode(true) })()`);
   }
   if (emit.wrappedKey) {
     lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName(inner.keyDepth)}', String(${emit.wrappedKey}))`);
@@ -16662,6 +17143,13 @@ function withTurn(call, componentName, childSlotId, eventName) {
   const id = JSON.stringify(`${componentName}#handler:${childSlotId}:${eventName}`);
   return `beginTurn(${id}); try { ${call} } finally { endTurn() }`;
 }
+function indexBindingLine(handler, indexParam, indexExpr) {
+  if (!indexParam || indexParam === indexExpr)
+    return null;
+  if (!extractFreeIdentifiersFromText(handler).has(indexParam))
+    return null;
+  return `const ${indexParam} = ${indexExpr}`;
+}
 function stringifyEventDelegation(lines, plan) {
   const { containerVar, events, itemLookup, profileComponentName } = plan;
   const eventsByName = new Map;
@@ -16707,8 +17195,9 @@ function stringifyEventDelegation(lines, plan) {
   }
 }
 function emitKeyedLookup(ls, ev, handlerCall, lookup) {
-  const { arrayExpr, param, keyWithItem, mapPreamble, hasBindings } = lookup;
+  const { arrayExpr, param, keyWithItem, mapPreamble, hasBindings, indexParam } = lookup;
   if (ev.nestedLoops.length === 0) {
+    const idxLine2 = indexBindingLine(ev.handler, indexParam, `${arrayExpr}.findIndex(item => String(${keyWithItem}) === key)`);
     ls.push(`      const li = ${varSlotId(ev.childSlotId)}El.closest('[${DATA_KEY}]')`);
     ls.push(`      if (li) {`);
     ls.push(`        const key = li.getAttribute('${DATA_KEY}')`);
@@ -16718,13 +17207,18 @@ function emitKeyedLookup(ls, ev, handlerCall, lookup) {
       ls.push(`          const ${param} = __bfLoopItem`);
       if (mapPreamble)
         ls.push(`          ${mapPreamble}`);
+      if (idxLine2)
+        ls.push(`          ${idxLine2}`);
       ls.push(`          ${handlerCall}`);
       ls.push(`        }`);
     } else {
       ls.push(`        const ${param} = ${arrayExpr}.find(item => String(${keyWithItem}) === key)`);
       if (mapPreamble)
         ls.push(`        ${mapPreamble}`);
-      ls.push(`        if (${param}) ${handlerCall}`);
+      if (idxLine2)
+        ls.push(`        if (${param}) { ${idxLine2}; ${handlerCall} }`);
+      else
+        ls.push(`        if (${param}) ${handlerCall}`);
     }
     ls.push(`      }`);
     return;
@@ -16753,10 +17247,15 @@ function emitKeyedLookup(ls, ev, handlerCall, lookup) {
   const allParams = [outerGuard, ...ev.nestedLoops.map((n) => n.param)];
   if (mapPreamble)
     ls.push(`      ${mapPreamble}`);
-  ls.push(`      if (${allParams.join(" && ")}) ${handlerCall}`);
+  const idxLine = indexBindingLine(ev.handler, indexParam, `${arrayExpr}.findIndex(item => String(${keyWithItem}) === outerKey)`);
+  if (idxLine)
+    ls.push(`      if (${allParams.join(" && ")}) { ${idxLine}; ${handlerCall} }`);
+  else
+    ls.push(`      if (${allParams.join(" && ")}) ${handlerCall}`);
 }
 function emitDynamicIndexLookup(ls, ev, handlerCall, lookup) {
-  const { arrayExpr, param, mapPreamble, hasBindings } = lookup;
+  const { arrayExpr, param, mapPreamble, hasBindings, indexParam } = lookup;
+  const idxLine = indexBindingLine(ev.handler, indexParam, "idx");
   ls.push(`      const li = ${varSlotId(ev.childSlotId)}El.closest('li, [bf-i]')`);
   ls.push(`      if (li && li.parentElement) {`);
   ls.push(`        const idx = Array.from(li.parentElement.children).indexOf(li)`);
@@ -16766,18 +17265,24 @@ function emitDynamicIndexLookup(ls, ev, handlerCall, lookup) {
     ls.push(`          const ${param} = __bfLoopItem`);
     if (mapPreamble)
       ls.push(`          ${mapPreamble}`);
+    if (idxLine)
+      ls.push(`          ${idxLine}`);
     ls.push(`          ${handlerCall}`);
     ls.push(`        }`);
   } else {
     ls.push(`        const ${param} = ${arrayExpr}[idx]`);
     if (mapPreamble)
       ls.push(`        ${mapPreamble}`);
-    ls.push(`        if (${param}) ${handlerCall}`);
+    if (idxLine)
+      ls.push(`        if (${param}) { ${idxLine}; ${handlerCall} }`);
+    else
+      ls.push(`        if (${param}) ${handlerCall}`);
   }
   ls.push(`      }`);
 }
 function emitStaticIndexLookup(ls, ev, handlerCall, lookup, containerVar) {
-  const { arrayExpr, param, mapPreamble, offset } = lookup;
+  const { arrayExpr, param, mapPreamble, offset, indexParam } = lookup;
+  const idxLine = indexBindingLine(ev.handler, indexParam, "__idx");
   ls.push(`      let __el = ${varSlotId(ev.childSlotId)}El`);
   ls.push(`      while (__el.parentElement && __el.parentElement !== ${containerVar}) __el = __el.parentElement`);
   ls.push(`      if (__el.parentElement === ${containerVar}) {`);
@@ -16786,7 +17291,10 @@ function emitStaticIndexLookup(ls, ev, handlerCall, lookup, containerVar) {
   ls.push(`        const ${param} = ${arrayExpr}[__idx]`);
   if (mapPreamble)
     ls.push(`        ${mapPreamble}`);
-  ls.push(`        if (${param}) ${handlerCall}`);
+  if (idxLine)
+    ls.push(`        if (${param}) { ${idxLine}; ${handlerCall} }`);
+  else
+    ls.push(`        if (${param}) ${handlerCall}`);
   ls.push(`      }`);
 }
 
@@ -17046,6 +17554,7 @@ function buildPlainLoopPlan(elem, profileComponentName) {
     mapPreambleWrapped: elem.mapPreamble ? wrap(elem.mapPreamble) : "",
     template: elem.template,
     skeletonTemplate: elem.skeletonTemplate,
+    skeletonPaths: elem.skeletonPaths,
     reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem, profileComponentName) : null,
     childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
@@ -20019,6 +20528,8 @@ function isStringTypedOperand(expr, isStringName) {
   if (expr.kind === "member" && expr.object.kind === "identifier" && expr.object.name === "props") {
     return isStringName(expr.property);
   }
+  if (expr.kind === "identifier")
+    return isStringName(expr.name);
   if (expr.kind === "binary" && expr.op === "+") {
     return isStringTypedOperand(expr.left, isStringName) || isStringTypedOperand(expr.right, isStringName);
   }
@@ -20044,7 +20555,7 @@ function emitParsedExpr(expr, emitter) {
       return emitter.call(expr.callee, expr.args, emit);
     }
     case "member":
-      return emitter.member(expr.object, expr.property, expr.computed, emit);
+      return emitter.member(expr.object, expr.property, expr.computed, expr.optional, emit);
     case "index-access":
       return emitter.indexAccess(expr.object, expr.index, emit);
     case "binary":
@@ -20078,6 +20589,221 @@ function emitParsedExpr(expr, emitter) {
     }
   }
 }
+// src/adapters/loop-bound-names.ts
+function collectLoopBoundNames(ir) {
+  const names = new Set;
+  const visit3 = (node) => {
+    if (!node)
+      return;
+    switch (node.type) {
+      case "element":
+      case "component":
+      case "fragment":
+      case "provider":
+        for (const child of node.children)
+          visit3(child);
+        break;
+      case "async":
+        visit3(node.fallback);
+        for (const child of node.children)
+          visit3(child);
+        break;
+      case "loop":
+        names.add(node.param);
+        if (node.index)
+          names.add(node.index);
+        for (const binding of node.paramBindings ?? [])
+          names.add(binding.name);
+        if (node.filterPredicate)
+          names.add(node.filterPredicate.param);
+        for (const child of node.children)
+          visit3(child);
+        if (node.childComponent) {
+          for (const child of node.childComponent.children)
+            visit3(child);
+        }
+        for (const nested of node.nestedComponents ?? []) {
+          for (const child of nested.children)
+            visit3(child);
+        }
+        for (const frag of node.flatMapCallback?.fragments ?? []) {
+          visit3(frag.ir);
+        }
+        break;
+      case "conditional":
+        visit3(node.whenTrue);
+        visit3(node.whenFalse);
+        break;
+      case "if-statement":
+        visit3(node.consequent);
+        if (node.alternate)
+          visit3(node.alternate);
+        break;
+      case "text":
+      case "expression":
+      case "slot":
+        break;
+    }
+  };
+  visit3(ir.root);
+  return names;
+}
+// src/signal-init-eval.ts
+var BLOCKED_GLOBALS = [
+  "globalThis",
+  "window",
+  "document",
+  "Date",
+  "Math",
+  "crypto",
+  "performance",
+  "fetch",
+  "setTimeout",
+  "setInterval",
+  "require",
+  "process",
+  "Function"
+];
+function isTransportable(value, ancestors = new Set) {
+  if (value === null)
+    return true;
+  const t = typeof value;
+  if (t === "boolean" || t === "number" || t === "string")
+    return true;
+  if (t !== "object")
+    return false;
+  if (ancestors.has(value))
+    return false;
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.keys(value).length !== value.length)
+        return false;
+      return value.every((el) => el !== undefined && isTransportable(el, ancestors));
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null)
+      return false;
+    return Object.values(value).every((v) => isTransportable(v, ancestors));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function tryEvaluateSignalInit(expr, props) {
+  const src = expr.trim();
+  if (src === "")
+    return { ok: false };
+  let fn;
+  try {
+    fn = new Function("props", ...BLOCKED_GLOBALS, `'use strict'; return (
+${src}
+);`);
+  } catch {
+    return { ok: false };
+  }
+  try {
+    const value = fn(props ?? {});
+    if (value === undefined)
+      return { ok: true, value: undefined };
+    return isTransportable(value) ? { ok: true, value } : { ok: false };
+  } catch {
+    return { ok: false };
+  }
+}
+function evaluateSignalInit(expr, props) {
+  const result = tryEvaluateSignalInit(expr, props);
+  return result.ok && result.value !== undefined ? result.value : null;
+}
+// src/static-literal.ts
+function evaluateStaticLiteral(expr, bindings) {
+  switch (expr.kind) {
+    case "literal":
+      return { value: expr.value };
+    case "template-literal": {
+      let out = "";
+      for (const part of expr.parts) {
+        if (part.type === "string") {
+          out += part.value;
+          continue;
+        }
+        const resolved = evaluateStaticLiteral(part.expr, bindings);
+        if (!resolved)
+          return null;
+        out += String(resolved.value);
+      }
+      return { value: out };
+    }
+    case "array-literal": {
+      const values = [];
+      for (const element of expr.elements) {
+        const resolved = evaluateStaticLiteral(element, bindings);
+        if (!resolved)
+          return null;
+        values.push(resolved.value);
+      }
+      return { value: values };
+    }
+    case "object-literal": {
+      const out = {};
+      for (const prop of expr.properties) {
+        const resolved = evaluateStaticLiteral(prop.value, bindings);
+        if (!resolved)
+          return null;
+        out[prop.key] = resolved.value;
+      }
+      return { value: out };
+    }
+    case "unary": {
+      const resolved = evaluateStaticLiteral(expr.argument, bindings);
+      if (!resolved)
+        return null;
+      if (expr.op === "-")
+        return typeof resolved.value === "number" ? { value: -resolved.value } : null;
+      if (expr.op === "+")
+        return typeof resolved.value === "number" ? { value: +resolved.value } : null;
+      if (expr.op === "!")
+        return { value: !resolved.value };
+      return null;
+    }
+    case "identifier":
+      return bindings?.has(expr.name) ? { value: bindings.get(expr.name) } : null;
+    case "member": {
+      const base = evaluateStaticLiteral(expr.object, bindings);
+      if (!base || base.value === null || typeof base.value !== "object")
+        return null;
+      return { value: base.value[expr.property] };
+    }
+    case "index-access": {
+      const base = evaluateStaticLiteral(expr.object, bindings);
+      const index = evaluateStaticLiteral(expr.index, bindings);
+      if (!base || !index || !Array.isArray(base.value) || typeof index.value !== "number")
+        return null;
+      return { value: base.value[index.value] };
+    }
+    default:
+      return null;
+  }
+}
+function isFullyStaticLiteral(expr) {
+  return evaluateStaticLiteral(expr) !== null;
+}
+function resolveStaticLoopSource(arrayParsed, localConstants, opts) {
+  if (!arrayParsed)
+    return null;
+  let target = arrayParsed;
+  if (arrayParsed.kind === "identifier") {
+    if (opts?.isNameShadowed?.(arrayParsed.name))
+      return null;
+    const local = localConstants?.find((c) => c.name === arrayParsed.name);
+    if (!local || local.isModule || !local.parsed)
+      return null;
+    target = local.parsed;
+  }
+  const resolved = evaluateStaticLiteral(target);
+  if (!resolved || !Array.isArray(resolved.value))
+    return null;
+  return resolved.value;
+}
 // src/query-href-lowering.ts
 function matchQueryHrefCall(callee, args, localNames) {
   if (callee.kind !== "identifier" || !localNames.has(callee.name))
@@ -20213,6 +20939,71 @@ function emitAttrValue(value, emitter, name) {
     }
   }
 }
+// src/adapters/dangerous-inner-html.ts
+var DANGEROUS_INNER_HTML_ATTR = "dangerouslySetInnerHTML";
+function isDangerousInnerHtmlAttr(attr) {
+  return attr.name === DANGEROUS_INNER_HTML_ATTR;
+}
+function resolveDangerousInnerHtml(element) {
+  const attr = element.attrs.find(isDangerousInnerHtmlAttr);
+  if (!attr)
+    return null;
+  if (attr.clientOnly)
+    return null;
+  if (attr.value.kind !== "expression") {
+    return { kind: "dynamic", expr: "", loc: attr.loc };
+  }
+  const parsed = attr.value.parsed ?? parseExpression(attr.value.expr.trim());
+  const html = staticHtmlLiteral(parsed);
+  if (html !== null)
+    return { kind: "static", html };
+  return { kind: "dynamic", expr: attr.value.expr, loc: attr.loc };
+}
+function staticHtmlLiteral(parsed) {
+  if (parsed.kind !== "object-literal")
+    return null;
+  if (parsed.properties.length !== 1)
+    return null;
+  const [prop] = parsed.properties;
+  if (prop.shorthand)
+    return null;
+  if (prop.key !== "__html")
+    return null;
+  if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
+    return null;
+  return prop.value.value;
+}
+var TEMPLATE_METACHAR_PATTERNS = {
+  blade: /\{\{|\{!!|<\?|@\w|<\/?\s*x[-:]/,
+  erb: /<%/,
+  "go-template": /\{\{/,
+  jinja: /\{\{|\{%|\{#/,
+  minijinja: /\{\{|\{%|\{#/,
+  mojolicious: /<%|^\s*%/m,
+  twig: /\{\{|\{%|\{#/,
+  xslate: /<:|^\s*:/m
+};
+function dangerousInnerHtmlMetacharViolation(html, adapterId) {
+  const pattern = TEMPLATE_METACHAR_PATTERNS[adapterId];
+  if (!pattern) {
+    return `no template-metacharacter guard is defined for adapter '${adapterId}' — refusing rather than splicing unguarded`;
+  }
+  if (!pattern.test(html))
+    return null;
+  return `the literal HTML contains a sequence ${adapterId}'s own template compiler would interpret (not inert text once spliced into the template)`;
+}
+function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
+  const detail = reason ? ` — ${reason}.` : "";
+  return {
+    code: "BF101",
+    severity: "error",
+    message: `dangerouslySetInnerHTML requires a compile-time string literal __html value on template adapters (e.g. { __html: '...' })${expr ? `: ${expr.trim()}` : ""}${detail}`,
+    loc,
+    suggestion: {
+      message: "Dynamic or signal-derived HTML for dangerouslySetInnerHTML is only supported on Hono/CSR today (tracked separately: https://github.com/piconic-ai/barefootjs/issues/2215). Use an inline string literal, or defer it to the client with /* @client */ (e.g. dangerouslySetInnerHTML={/* @client */ { __html: expr }}) so hydration sets it instead of SSR."
+    }
+  };
+}
 // src/combine-client-js.ts
 import ts19 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
@@ -23054,6 +23845,7 @@ function profileToJSON(profile) {
 registerBuiltinLoweringPlugins();
 export {
   tsNodeToParsedExpr,
+  tryEvaluateSignalInit,
   traceUpdatePath,
   testAdapter,
   stringifyParsedExpr,
@@ -23061,7 +23853,9 @@ export {
   serializeParsedExpr,
   searchParamsLocalNames,
   rewriteImportsForTemplate,
+  resolveStaticLoopSource,
   resolveSetters,
+  resolveDangerousInnerHtml,
   resetCompilerCounters,
   renderImportMapHtml,
   registerLoweringPlugin,
@@ -23096,6 +23890,8 @@ export {
   isStringConcatBinary,
   isLowerableObjectRestDestructure,
   isLowerableLoopDestructure,
+  isFullyStaticLiteral,
+  isDangerousInnerHtmlAttr,
   isBooleanAttr,
   importsSearchParams,
   identifierPath,
@@ -23136,6 +23932,8 @@ export {
   extractFunctionParams,
   extractArrowBodyExpression,
   exprToString,
+  evaluateStaticLiteral,
+  evaluateSignalInit,
   evaluateProfileGates,
   evalStringArrayJoin,
   envSignalReaderFor,
@@ -23148,6 +23946,8 @@ export {
   diffStaticBudget,
   diffProfiles,
   describeFallback,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
   createProgramForFile,
   createProgramForCorpus,
   createError,
@@ -23156,6 +23956,7 @@ export {
   compileJSX,
   combineParentChildClientJs,
   collectModuleStringConsts,
+  collectLoopBoundNames,
   collectContextConsumers,
   buildWhyUpdate,
   buildStaticBudget,