@barefootjs/jsx 0.29.0 → 0.30.0

package/dist/index.js

@@ -3073,7 +3073,7 @@ function buildSignalMemoEnv(signals, memos, propsObjectName) {
   for (const m of memos) {
     substitutions.set(m.name, {
       kind: "call",
-      replacement: extractMemoBodyExpr(m.computation),
+      replacement: extractMemoBodyExpr(m.templateComputation ?? m.computation),
       freeIdentifiers: m.computationFreeIdentifiers ?? new Set
     });
   }
@@ -3091,6 +3091,13 @@ function normalizeSignalInitial(signal, propsObjectName) {
 
 // src/ir-to-client-js/html-template.ts
 import { BF_PARENT_SCOPE_PLACEHOLDER, BF_SCOPE, escapeHtml } from "@barefootjs/shared";
+
+// src/adapters/child-scope.ts
+function derivesScopeFromSlot(comp) {
+  return comp.slotId != null && comp.loopItemRoot !== true;
+}
+
+// src/ir-to-client-js/html-template.ts
 function createStringProtector() {
   const strings = [];
   const protect = (s) => {
@@ -3423,7 +3430,7 @@ function renderFlatMapClientBody(cb, restSpreadNames) {
     rawLeaf: true,
     renderLeaf: (ir) => {
       const key = flatMapLeafKeyExpr(ir);
-      const html = irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, 1, undefined, undefined, true);
+      const html = irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, 1, undefined, undefined);
       return `({ k: ${key ?? "undefined"}, h: \`${html}\` })`;
     }
   });
@@ -3435,7 +3442,7 @@ function renderFlatMapProjectionClientBody(inner, restSpreadNames) {
   const chained = applyLoopChain(inner);
   const params = inner.index ? `(${inner.param}, ${inner.index})` : `(${inner.param})`;
   const key = inner.key ? `(${inner.key})` : "undefined";
-  const html = inner.children.map((c) => irToHtmlTemplate(escapeLeafTextExpressions(c), restSpreadNames, 1, undefined, undefined, true)).join("");
+  const html = inner.children.map((c) => irToHtmlTemplate(escapeLeafTextExpressions(c), restSpreadNames, 1, undefined, undefined)).join("");
   return `${chained}.map(${params} => ({ k: ${key}, h: \`${html}\` }))`;
 }
 function escapeLeafTextExpressions(ir) {
@@ -3461,8 +3468,8 @@ function escapeLeafTextExpressions(ir) {
       return ir;
   }
 }
-function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, branchSlotsVar, insideLoop = false, inHoistedChildren = false) {
-  const recurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, insideLoop, inHoistedChildren);
+function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, branchSlotsVar, inHoistedChildren = false) {
+  const recurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, inHoistedChildren);
   const wrapExpr = (expr) => wrapExprWithLoopParams(expr, loopParams);
   const wrapInterpolation = (expr) => branchSlotsVar ? `__bfSlot(${expr}, ${branchSlotsVar})` : expr;
   switch (node.type) {
@@ -3493,7 +3500,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
         attrParts.push(`bf="${node.slotId}"`);
       }
       const attrs = attrParts.join(" ");
-      const childrenRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, insideLoop, false);
+      const childrenRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, false);
       const children = dangerouslyHtmlChildren(node.attrs, (v) => wrapExpr(v.expr)) ?? node.children.map(childrenRecurse).join("");
       if (children || !VOID_ELEMENTS.has(node.tag)) {
         return `<${node.tag}${attrs ? " " + attrs : ""}>${children}</${node.tag}>`;
@@ -3530,12 +3537,12 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       if (node.name === "Portal") {
         return node.children.map(recurse).join("");
       }
-      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
+      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => p.name !== "ref" && !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
         if (p.clientOnly)
           return null;
         switch (p.value.kind) {
           case "jsx-children": {
-            const hoistedRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, insideLoop, true);
+            const hoistedRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth, loopParams, branchSlotsVar, true);
             const childHtml = p.value.children.map((c) => hoistedRecurse(c)).join("");
             return `${quotePropName(p.name)}: \`${childHtml}\``;
           }
@@ -3548,7 +3555,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
           case "expression":
           case "template":
           case "spread": {
-            const expr = attrValueToString(p.value) ?? "undefined";
+            const expr = attrValueToString(p.value, { useTemplate: true }) ?? "undefined";
             return `${quotePropName(p.name)}: ${expr}`;
           }
         }
@@ -3559,11 +3566,11 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       const propsExpr = propsEntries.length > 0 ? `{${propsEntries.join(", ")}}` : "{}";
       const keyProp = node.props.find((p) => p.name === "key");
       const keyArg = keyProp ? `, ${attrValueToString(keyProp.value) ?? "undefined"}` : "";
-      const slotArg = !insideLoop && node.slotId ? `, '${node.slotId}'` : "";
+      const slotArg = derivesScopeFromSlot(node) ? `, '${node.slotId}'` : "";
       return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${keyArg || (slotArg ? ", undefined" : "")}${slotArg})}`;
     }
     case "loop": {
-      const innerRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar, insideLoop);
+      const innerRecurse = (n) => irToHtmlTemplate(n, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar);
       let childTemplate = node.children.map(innerRecurse).join("");
       if (node.bodyIsItemConditional && node.key) {
         childTemplate = `${itemAnchorTemplate(node.key)}${childTemplate}`;
@@ -3576,11 +3583,11 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       let mapExpr;
       if (node.flatMapCallback) {
         const body = renderPreamble(node.flatMapCallback, {
-          renderLeaf: (ir) => irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar, insideLoop)
+          renderLeaf: (ir) => irToHtmlTemplate(stripLeafKeyAttr(ir), restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar)
         });
         mapExpr = `\${${wrappedArray}.flatMap(${node.flatMapCallback.params} => ${body}).join('')}`;
       } else if (node.preamble) {
-        const preamble = renderPreamble(node.preamble, { textVariant: "client", renderLeaf: (ir) => irToHtmlTemplate(ir, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar, insideLoop) });
+        const preamble = renderPreamble(node.preamble, { textVariant: "client", renderLeaf: (ir) => irToHtmlTemplate(ir, restSpreadNames, loopDepth + 1, loopParams, branchSlotsVar) });
         mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => { ${preamble} return \`${childTemplate}\` }).join('')}`;
       } else {
         mapExpr = `\${${wrappedArray}.${iterMethod}(${callbackParam} => \`${childTemplate}\`).join('')}`;
@@ -4085,7 +4092,7 @@ function irToComponentTemplateWithOpts(node, opts) {
       if (node.name === "Portal") {
         return node.children.map(recurse).join("");
       }
-      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
+      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => p.name !== "ref" && !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
         if (p.clientOnly)
           return null;
         switch (p.value.kind) {
@@ -4202,7 +4209,7 @@ function canGenerateStaticTemplate(node, propNames, inlinableConstants, unsafeLo
       return assertNever(node);
   }
 }
-function generateCsrTemplate(node, inlinableConstants, ctx, insideLoop, restSpreadNames, propsObjectName, unsafeLocalNames, deferredChildSlots) {
+function generateCsrTemplate(node, inlinableConstants, ctx, restSpreadNames, propsObjectName, unsafeLocalNames, deferredChildSlots) {
   const base = buildSignalMemoEnv(ctx.signals, ctx.memos, propsObjectName ?? null);
   const csrEnv = { substitutions: new Map(base.substitutions), propsObjectName: base.propsObjectName };
   if (inlinableConstants) {
@@ -4213,7 +4220,7 @@ function generateCsrTemplate(node, inlinableConstants, ctx, insideLoop, restSpre
     }
   }
   const effectiveUnsafeLocalNames = mergeCsrNullUnsafe(ctx, unsafeLocalNames);
-  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames: effectiveUnsafeLocalNames, deferredChildSlots, loopDepth: -1 });
+  return generateCsrTemplateWithOpts(node, { inlinableConstants, restSpreadNames, propsObjectName, csrEnv, unsafeLocalNames: effectiveUnsafeLocalNames, deferredChildSlots, loopDepth: -1 });
 }
 function mergeCsrNullUnsafe(ctx, unsafeLocalNames) {
   let merged = null;
@@ -4278,6 +4285,8 @@ function computeDeferredChildSlots(node, ctx, inlinableConstants, unsafeLocalNam
           const dropped = n.props.some((p) => {
             if (p.name === "..." || p.name.startsWith("...") || p.name === "key")
               return false;
+            if (p.name === "ref")
+              return false;
             if (p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())
               return false;
             if (p.clientOnly)
@@ -4307,7 +4316,7 @@ function computeDeferredChildSlots(node, ctx, inlinableConstants, unsafeLocalNam
   return deferred;
 }
 function generateCsrTemplateWithOpts(node, opts) {
-  const { restSpreadNames, propsObjectName, csrEnv, insideLoop, unsafeLocalNames, loopDepth = 0 } = opts;
+  const { restSpreadNames, propsObjectName, csrEnv, unsafeLocalNames, loopDepth = 0 } = opts;
   const env = csrEnv ?? { substitutions: new Map, propsObjectName: propsObjectName ?? null };
   const transformExpr = (expr, templateExpr) => {
     const source = templateExpr ?? expr;
@@ -4321,7 +4330,6 @@ function generateCsrTemplateWithOpts(node, opts) {
   };
   const recurse = (n) => generateCsrTemplateWithOpts(n, opts);
   const childrenRecurse = (n) => generateCsrTemplateWithOpts(n, { ...opts, inHoistedChildren: false });
-  const recurseInLoop = (n) => generateCsrTemplateWithOpts(n, { ...opts, insideLoop: true, loopDepth: loopDepth + 1, inHoistedChildren: false });
   switch (node.type) {
     case "element": {
       const mergeCtx = {
@@ -4414,7 +4422,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       if (node.slotId && opts.deferredChildSlots?.has(node.slotId)) {
         return `<div ${DATA_BF_PH}="${node.slotId}"></div>`;
       }
-      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
+      const propsEntries = node.props.filter((p) => p.name !== "..." && !p.name.startsWith("...") && p.name !== "key").filter((p) => p.name !== "ref" && !(p.name.startsWith("on") && p.name.length > 2 && p.name[2] === p.name[2].toUpperCase())).map((p) => {
         if (p.clientOnly)
           return null;
         switch (p.value.kind) {
@@ -4452,7 +4460,7 @@ function generateCsrTemplateWithOpts(node, opts) {
       const propsExpr = propsEntries.length > 0 ? `{${propsEntries.join(", ")}}` : "{}";
       const keyProp = node.props.find((p) => p.name === "key");
       const keyArg = keyProp ? `, ${transformKeyValue(keyProp.value, transformExpr)}` : "";
-      const slotArg = !insideLoop && node.slotId ? `, '${node.slotId}'` : "";
+      const slotArg = derivesScopeFromSlot(node) ? `, '${node.slotId}'` : "";
       return `\${renderChild('${nameForRegistryRef(node.name)}', ${propsExpr}${keyArg || (slotArg ? ", undefined" : "")}${slotArg})}`;
     }
     case "loop": {
@@ -4471,7 +4479,6 @@ function generateCsrTemplateWithOpts(node, opts) {
       };
       const recurseInLoopBody = (n) => generateCsrTemplateWithOpts(n, {
         ...opts,
-        insideLoop: true,
         loopDepth: loopDepth + 1,
         inHoistedChildren: false,
         loopBoundNames: boundHere,
@@ -4948,6 +4955,30 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   if (ts7.isArrayTypeNode(typeNode)) {
     return { kind: "array", raw, elementType: recurse(typeNode.elementType) };
   }
+  if (ts7.isLiteralTypeNode(typeNode)) {
+    const lit = typeNode.literal;
+    if (ts7.isStringLiteral(lit) || ts7.isNoSubstitutionTemplateLiteral(lit)) {
+      return { kind: "primitive", raw, primitive: "string", literalValue: lit.text };
+    }
+    if (ts7.isNumericLiteral(lit)) {
+      return { kind: "primitive", raw, primitive: "number", literalValue: lit.text };
+    }
+    if (ts7.isPrefixUnaryExpression(lit) && lit.operator === ts7.SyntaxKind.MinusToken && ts7.isNumericLiteral(lit.operand)) {
+      return { kind: "primitive", raw, primitive: "number", literalValue: `-${lit.operand.text}` };
+    }
+    if (lit.kind === ts7.SyntaxKind.TrueKeyword || lit.kind === ts7.SyntaxKind.FalseKeyword) {
+      return {
+        kind: "primitive",
+        raw,
+        primitive: "boolean",
+        literalValue: lit.kind === ts7.SyntaxKind.TrueKeyword ? "true" : "false"
+      };
+    }
+    if (lit.kind === ts7.SyntaxKind.NullKeyword) {
+      return { kind: "primitive", raw, primitive: "null" };
+    }
+    return { kind: "unknown", raw };
+  }
   if (ts7.isUnionTypeNode(typeNode)) {
     return { kind: "union", raw, unionTypes: typeNode.types.map(recurse) };
   }
@@ -5515,9 +5546,7 @@ function baseTypeName(raw) {
   return (idx === -1 ? raw : raw.slice(0, idx)).trim();
 }
 function isNullishArm(t) {
-  if (t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined"))
-    return true;
-  return t.kind === "unknown" && (t.raw === "null" || t.raw === "undefined");
+  return t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined");
 }
 function stripUnion(type) {
   if (!type || type.kind !== "union" || !type.unionTypes)
@@ -6236,14 +6265,17 @@ function collectSignal(node, ctx) {
   const pattern = node.name;
   const callExpr = node.initializer;
   const elements = pattern.elements;
-  if (elements.length < 1 || elements.length > 2 || !ts8.isBindingElement(elements[0]) || !ts8.isIdentifier(elements[0].name)) {
+  const getterElided = elements.length === 2 && ts8.isOmittedExpression(elements[0]);
+  if (elements.length < 1 || elements.length > 2 || !getterElided && (!ts8.isBindingElement(elements[0]) || !ts8.isIdentifier(elements[0].name))) {
     return;
   }
   if (elements.length === 2 && (!ts8.isBindingElement(elements[1]) || !ts8.isIdentifier(elements[1].name))) {
     return;
   }
-  const getter = elements[0].name.text;
   const setter = elements.length === 2 && ts8.isBindingElement(elements[1]) && ts8.isIdentifier(elements[1].name) ? elements[1].name.text : null;
+  if (getterElided && !setter)
+    return;
+  const getter = getterElided ? `__bfGet_${setter}` : elements[0].name.text;
   const initialValue = callExpr.arguments[0] ? ctx.getJS(callExpr.arguments[0]) : "";
   const typedInitialValue = callExpr.arguments[0] ? callExpr.arguments[0].getText(ctx.sourceFile) : undefined;
   let type = { kind: "unknown", raw: "unknown" };
@@ -6264,6 +6296,7 @@ function collectSignal(node, ctx) {
   ctx.signals.push({
     getter,
     setter,
+    getterElided: getterElided || undefined,
     initialValue,
     typedInitialValue: typedInitialValue !== initialValue ? typedInitialValue : undefined,
     templateInitialValue,
@@ -6454,9 +6487,17 @@ function collectMemo(node, ctx) {
   const blockBody = arrowNode && ts8.isArrowFunction(arrowNode) && ts8.isBlock(arrowNode.body) ? arrowNode.body : undefined;
   const parsedBlock = blockBody ? parseBlockBodyTolerant(blockBody, ctx.sourceFile, (node2) => ctx.getJS(node2)) : undefined;
   const parsedBlockComplete = parsedBlock && blockBody ? parsedBlock.length === blockBody.statements.length : undefined;
+  let templateComputation;
+  if (!ctx.propsObjectName && callExpr.arguments[0]) {
+    const propNames = new Set(ctx.propsParams.map((p) => p.name));
+    if (propNames.size > 0) {
+      templateComputation = rewriteBarePropRefs(computation, callExpr.arguments[0], propNames);
+    }
+  }
   ctx.memos.push({
     name,
     computation,
+    templateComputation,
     parsedBlock,
     parsedBlockComplete,
     typedComputation: typedComputation !== computation ? typedComputation : undefined,
@@ -9677,8 +9718,10 @@ function deriveFormat(locale, probeOptions) {
   return { pattern, names };
 }
 function unionMemberLiteral(member) {
-  const m = /^'([^'\\]*)'$|^"([^"\\]*)"$/.exec(member.raw.trim());
-  return m ? m[1] ?? m[2] : null;
+  if (member.kind === "primitive" && member.primitive === "string" && member.literalValue !== undefined) {
+    return member.literalValue;
+  }
+  return null;
 }
 function resolveLocaleUnionMembers(locale, metadata) {
   let sourcePropName = null;
@@ -10284,6 +10327,13 @@ function jsxToIR(analyzer) {
 function buildIRRoot(analyzer) {
   if (analyzer.conditionalReturns.length > 0) {
     const ctx2 = createTransformContext(analyzer);
+    const allReactiveNoLocals = analyzer.jsxReturn != null && analyzer.conditionalReturns.every((cr) => cr.scopeVariables.length === 0 && exprCallsReactiveGetters(cr.condition, ctx2));
+    if (allReactiveNoLocals) {
+      const chain = buildIfStatementChain(analyzer, ctx2, { asConditional: true });
+      if (!chain)
+        return null;
+      return chain.type === "conditional" ? wrapInScopeElement(chain) : chain;
+    }
     return buildIfStatementChain(analyzer, ctx2);
   }
   if (!analyzer.jsxReturn)
@@ -10439,11 +10489,52 @@ function transformJsxElement(node, ctx) {
   }
   return transformHtmlElement(node, ctx, tagName);
 }
+function lowerFormControlValueSsr(tagName, attrs, children) {
+  if (tagName !== "textarea" && tagName !== "select")
+    return;
+  const valueAttr = attrs.find((a) => a.name === "value");
+  if (!valueAttr || valueAttr.clientOnly || valueAttr.value.kind !== "expression")
+    return;
+  const { expr, templateExpr } = valueAttr.value;
+  valueAttr.clientOnly = true;
+  if (tagName === "textarea") {
+    if (children.length > 0)
+      return;
+    children.push({
+      type: "expression",
+      expr,
+      templateExpr: `escapeText(${templateExpr ?? expr})`,
+      typeInfo: null,
+      reactive: false,
+      slotId: null,
+      loc: valueAttr.loc,
+      origin: { phase: "ssr", scope: "template", effect: "pure" }
+    });
+    return;
+  }
+  const selectedFor = (optValue) => AttrValueOf.expression(`(${expr}) === ${JSON.stringify(optValue)}`, templateExpr !== undefined ? { templateExpr: `(${templateExpr}) === ${JSON.stringify(optValue)}` } : undefined);
+  const distribute = (nodes) => {
+    for (const n of nodes) {
+      if (n.type === "element" && n.tag === "option") {
+        if (n.attrs.some((a) => a.name === "selected"))
+          continue;
+        const optValue = n.attrs.find((a) => a.name === "value");
+        if (!optValue || optValue.value.kind !== "literal")
+          continue;
+        n.attrs.push({ name: "selected", value: selectedFor(optValue.value.value), loc: n.loc });
+      } else if (n.type === "fragment" || n.type === "element" && n.tag === "optgroup") {
+        distribute(n.children);
+      }
+    }
+  };
+  distribute(children);
+}
 function transformHtmlElement(node, ctx, tagName) {
   const { attrs, events, ref } = processAttributes(node.openingElement.attributes, ctx);
   const needsScope = ctx.isRoot;
   ctx.isRoot = false;
   const children = transformChildren(node.children, ctx);
+  lowerFormControlValueSsr(tagName, attrs, children);
   const needsSlot = events.length > 0 || hasDynamicContent(children) || hasReactiveAttributes(attrs, ctx) || ref !== null;
   const slotId = needsSlot ? generateSlotId(ctx) : null;
   if (slotId) {
@@ -10475,6 +10566,8 @@ function transformSelfClosingElement(node, ctx) {
     return transformSelfClosingComponent(node, ctx, resolved ?? tagName);
   }
   const { attrs, events, ref } = processAttributes(node.attributes, ctx);
+  const selfClosingChildren = [];
+  lowerFormControlValueSsr(tagName, attrs, selfClosingChildren);
   const needsSlot = events.length > 0 || hasReactiveAttributes(attrs, ctx) || ref !== null;
   const slotId = needsSlot ? generateSlotId(ctx) : null;
   const needsScope = ctx.isRoot;
@@ -10485,7 +10578,7 @@ function transformSelfClosingElement(node, ctx) {
     attrs,
     events,
     ref,
-    children: [],
+    children: selfClosingChildren,
     slotId,
     needsScope,
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
@@ -11868,6 +11961,15 @@ function branchHasNoElement(node) {
   }
   return true;
 }
+function tagLoopItemRootComponents(nodes) {
+  for (const node of nodes) {
+    if (node.type === "component") {
+      node.loopItemRoot = true;
+    } else if (node.type === "conditional") {
+      tagLoopItemRootComponents([node.whenTrue, node.whenFalse]);
+    }
+  }
+}
 function loopBodyItemConditional(children) {
   const real = children.filter((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
   if (real.length !== 1)
@@ -12105,9 +12207,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         const pre = multiReturn.preamble ?? [];
         if (pre.length > 0) {
           preamble = preambleFromValueStatements(pre, ctx);
-          if (!isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
+          if (!preamble.declarations && !isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
             ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, loc, {
-              message: "A .map() callback body with a `const`/`let` preamble before its " + "branches cannot be lowered to a template: the loop-local binding " + "cannot be carried into a conditional branch on this backend.",
+              message: "A .map() callback body with a preamble before its branches cannot be " + "lowered to a template: the preamble is not a sequence of value " + "declarations, so this backend has no per-row local to carry into the " + "branches.",
               suggestion: {
                 message: "Add /* @client */ to evaluate this expression on the client only"
               }
@@ -12174,6 +12276,14 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
           }
           if (valueStmts.length > 0) {
             preamble = preambleFromValueStatements(valueStmts, ctx);
+            if (!preamble.declarations && !isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
+              ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(body, ctx.sourceFile, ctx.filePath), {
+                message: "A .map() callback preamble that is not a sequence of value " + "declarations cannot be lowered to a template: this backend can " + "declare a per-row local, but cannot run arbitrary statements per row.",
+                suggestion: {
+                  message: "Add /* @client */ to evaluate this expression on the client only"
+                }
+              }));
+            }
           }
         }
       }
@@ -12259,6 +12369,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }));
     preamble = undefined;
   }
+  tagLoopItemRootComponents(children);
   let childComponent;
   if (children.length === 1 && children[0].type === "component") {
     const comp = children[0];
@@ -12279,6 +12390,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const isDirectPropArray = method !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx);
   const isStaticArray = !isSignalOrMemoArray(array, ctx) && !isDirectPropArray && !hasCalls && !objectIteration;
   const preambleRegions = preamble && !isStaticArray ? collectPreambleRegions(children, new Set(preamble.declaredNames), ctx) : undefined;
+  if (preamble && !isStaticArray) {
+    markPreambleAttrSlots(children, new Set(preamble.declaredNames), ctx);
+  }
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -12503,6 +12617,52 @@ function collectPreambleRegions(nodes, declared, ctx) {
   visit2(nodes);
   return regions;
 }
+function markPreambleAttrSlots(nodes, declared, ctx) {
+  const readsDeclared = (attr) => {
+    if (attr.name === "key")
+      return false;
+    const value = attr.value;
+    if (value.kind !== "expression" && value.kind !== "template")
+      return false;
+    const refs = attr.freeIdentifiers ?? extractFreeIdentifiersFromText(attrValueText(value));
+    for (const r of refs)
+      if (declared.has(r))
+        return true;
+    return false;
+  };
+  const visit2 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "element":
+          if (!node.slotId && node.attrs.some(readsDeclared))
+            node.slotId = generateSlotId(ctx);
+          visit2(node.children);
+          break;
+        case "fragment":
+          visit2(node.children);
+          break;
+        case "conditional":
+          visit2([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+      }
+    }
+  };
+  visit2(nodes);
+}
+function attrValueText(value) {
+  if (value.kind === "expression")
+    return value.expr;
+  if (value.kind !== "template")
+    return "";
+  const out = [];
+  for (const p of value.parts) {
+    if (p.type === "ternary")
+      out.push(p.condition, p.whenTrue, p.whenFalse);
+    else if (p.type === "lookup")
+      out.push(p.key);
+  }
+  return out.join(" ");
+}
 function collectBindingNames(name, out) {
   if (ts11.isIdentifier(name)) {
     out.add(name.text);
@@ -12540,9 +12700,32 @@ function preambleFromValueStatements(statements, ctx) {
     segments: trimPreambleSegments(segments),
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
-    builderNames: []
+    builderNames: [],
+    declarations: neutralPreambleDeclarations(statements, ctx) ?? undefined
   };
 }
+function neutralPreambleDeclarations(statements, ctx) {
+  const out = [];
+  for (const stmt of statements) {
+    if (!ts11.isVariableStatement(stmt))
+      return null;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts11.isIdentifier(decl.name))
+        return null;
+      if (!decl.initializer)
+        return null;
+      const valueParsed = tsNodeToParsedExpr(decl.initializer);
+      if (!isSupported(valueParsed).supported)
+        return null;
+      out.push({
+        name: decl.name.text,
+        valueParsed,
+        raw: decl.initializer.getText(ctx.sourceFile)
+      });
+    }
+  }
+  return out.length > 0 ? out : null;
+}
 function trimPreambleSegments(segments) {
   const last = segments[segments.length - 1];
   if (last?.kind === "js") {
@@ -12988,6 +13171,9 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
   if (ts11.isNoSubstitutionTemplateLiteral(ast) || ts11.isStringLiteral(ast)) {
     return [{ type: "string", value: ast.text }];
   }
+  if (ts11.isElementAccessExpression(ast) && !ts11.isStringLiteralLike(ast.argumentExpression) && !ts11.isNumericLiteral(ast.argumentExpression)) {
+    return tryResolveTemplateSpanFromConst(ast, ctx);
+  }
   if (!ts11.isTemplateExpression(ast))
     return null;
   let resolvedAny = false;
@@ -13235,8 +13421,11 @@ function processComponentProps(attributes, ctx) {
     }
     let value = getAttributeValue(attr, ctx);
     if (value.kind === "template") {
-      value = AttrValueOf.expression(templatePartsToJsString(value.parts), {
-        parts: value.parts
+      const collapsed = templatePartsToJsString(value.parts);
+      const collapsedTemplate = templatePartsToJsString(value.parts, { useTemplate: true });
+      value = AttrValueOf.expression(collapsed, {
+        parts: value.parts,
+        ...collapsedTemplate !== collapsed && { templateExpr: collapsedTemplate }
       });
     } else if (value.kind === "boolean-attr") {
       value = AttrValueOf.booleanShorthand();
@@ -13265,16 +13454,18 @@ function processComponentProps(attributes, ctx) {
   }
   return props;
 }
-function templatePartsToJsString(parts) {
+function templatePartsToJsString(parts, opts) {
   let result = "`";
   for (const part of parts) {
     if (part.type === "string") {
-      result += part.value;
+      result += opts?.useTemplate && part.templateValue ? part.templateValue : part.value;
     } else if (part.type === "ternary") {
-      result += `\${${part.condition} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
+      const cond = opts?.useTemplate && part.templateCondition ? part.templateCondition : part.condition;
+      result += `\${${cond} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
     } else if (part.type === "lookup") {
+      const key = opts?.useTemplate && part.templateKey ? part.templateKey : part.key;
       const obj = "{" + Object.entries(part.cases).map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`).join(", ") + "}";
-      result += `\${(${obj})[${part.key}]}`;
+      result += `\${(${obj})[${key}]}`;
     }
   }
   result += "`";
@@ -13485,11 +13676,12 @@ function replaceBranchLocalRefs(text, branchNames, resolve2) {
   const pattern = new RegExp(`(?<![\\w$])(${branchNames.join("|")})(?![\\w$])`, "g");
   return replaceInExprContexts(text, pattern, (_match, name) => resolve2(name));
 }
-function buildIfStatementChain(analyzer, ctx) {
+function buildIfStatementChain(analyzer, ctx, opts) {
   const conditionalReturns = analyzer.conditionalReturns;
+  const asConditional = opts?.asConditional === true;
   let alternate = null;
   if (analyzer.jsxReturn) {
-    ctx.isRoot = true;
+    ctx.isRoot = !asConditional;
     alternate = transformNode(analyzer.jsxReturn, ctx);
   }
   for (let i = conditionalReturns.length - 1;i >= 0; i--) {
@@ -13558,7 +13750,7 @@ function buildIfStatementChain(analyzer, ctx) {
       ctx.getJS = substitutedGetJS;
       ctx.analyzer.getJS = substitutedGetJS;
     }
-    ctx.isRoot = true;
+    ctx.isRoot = !asConditional;
     let consequent;
     try {
       consequent = transformNode(condReturn.jsxReturn, ctx);
@@ -13588,6 +13780,27 @@ function buildIfStatementChain(analyzer, ctx) {
       }
     }
     const loc = getSourceLocation(condReturn.ifStatement, analyzer.sourceFile, analyzer.filePath);
+    if (asConditional && alternate) {
+      const conditional = {
+        type: "conditional",
+        condition,
+        templateCondition,
+        conditionType: null,
+        reactive: true,
+        whenTrue: consequent,
+        whenFalse: alternate,
+        slotId: generateSlotId(ctx),
+        loc,
+        origin: {
+          phase: "tick",
+          scope: "template",
+          effect: "pure",
+          freeRefs: resolveFreeRefs(condReturn.condition, makeBindingEnv(ctx))
+        }
+      };
+      alternate = conditional;
+      continue;
+    }
     const ifStmt = {
       type: "if-statement",
       condition,
@@ -13901,7 +14114,13 @@ function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings,
   });
   return texts;
 }
-function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false) {
+function anyNameIn(names, set) {
+  for (const n of names)
+    if (set.has(n))
+      return true;
+  return false;
+}
+function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames) {
   const attrs = [];
   traverseElements(node, (el) => {
     if (el.slotId) {
@@ -13916,7 +14135,8 @@ function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings,
         if (!valueStr)
           continue;
         const expanded = expandConstantForReactivity(valueStr, ctx, attr.freeIdentifiers);
-        const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || attr.callsReactiveGetters || attr.hasFunctionCalls;
+        const readsPreamble = preambleNames !== undefined && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
+        const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
         if (!attr.clientOnly && !reactive)
           continue;
         attrs.push({
@@ -13924,7 +14144,8 @@ function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings,
           attrName: attr.name,
           expression: expanded.expr,
           ...pickAttrMetaFromIR(attr),
-          ...expanded.freeIds !== undefined && { freeIdentifiers: expanded.freeIds }
+          ...expanded.freeIds !== undefined && { freeIdentifiers: expanded.freeIds },
+          ...readsPreamble && { readsPreamble: true }
         });
       }
     }
@@ -14220,10 +14441,11 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
         const template = n.children.map((c) => irToPlaceholderTemplate(c, undefined, emitDepth, loopParamsForTemplate)).join("");
         const refsOuter = outerLoopParam ? new RegExp(`\\b${outerLoopParam}\\b`).test(n.array) : false;
         const bindings = emptyLoopChildBindings();
+        const innerPreambleNames = preambleNamesOf(n);
         if (ctx) {
           for (const child of n.children) {
             bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings));
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings));
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, false, innerPreambleNames));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
         }
@@ -14446,7 +14668,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         return;
       const projectionInner = l.method === "flatMap" && l.children.length === 1 && l.children[0].type === "loop" ? l.children[0] : undefined;
       const childHandlers = [];
-      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx, siblingOffsets, l.param, l.paramBindings);
+      const bindings = projectionInner ? emptyLoopChildBindings() : collectLoopChildBindings(l.children, ctx, siblingOffsets, l.param, l.paramBindings, preambleNamesOf(l));
       if (!projectionInner) {
         for (const child of l.children) {
           childHandlers.push(...collectEventHandlersFromIR(child));
@@ -14469,7 +14691,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       if (l.childComponent) {
         template = "";
         if (l.isStaticArray && l.children[0]) {
-          staticItemTemplate = irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0, undefined, undefined, true);
+          staticItemTemplate = irToHtmlTemplate(l.children[0], buildRestSpreadNames(ctx), 0, undefined, undefined);
         }
       } else if (l.children[0] && !projectionInner) {
         const loopParamSpec = [{ param: l.param, bindings: l.paramBindings }];
@@ -14701,7 +14923,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
       } else {
         childTemplate = n.children.map((c) => irToHtmlTemplate(c, undefined, 0, branchLoopParamSpec)).join("");
       }
-      const branchBindings = ctx && !projectionInner ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings) : emptyLoopChildBindings();
+      const branchBindings = ctx && !projectionInner ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n)) : emptyLoopChildBindings();
       loops.push({
         kind: "branch",
         array: n.array,
@@ -14781,11 +15003,17 @@ function collectBranchConditionals(node, ctx, siblingOffsets) {
   });
   return result;
 }
-function collectLoopChildBindings(children, ctx, siblingOffsets, loopParam, loopParamBindings) {
+function preambleNamesOf(loop) {
+  if (loop.isStaticArray)
+    return;
+  const declared = loop.preamble?.declaredNames;
+  return declared && declared.length > 0 ? new Set(declared) : undefined;
+}
+function collectLoopChildBindings(children, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames) {
   const bindings = emptyLoopChildBindings();
   for (const child of children) {
     bindings.events.push(...collectLoopChildEventsWithNesting(child));
-    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings, true));
+    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings, true, preambleNames));
     bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, loopParam, loopParamBindings, true));
     bindings.refs.push(...collectLoopChildRefs(child));
     bindings.conditionals.push(...collectLoopChildConditionals(child, ctx, siblingOffsets, loopParam, loopParamBindings));
@@ -16399,7 +16627,7 @@ function emitRegistrationAndHydration(lines, ctx, _ir, graph, inlinability) {
     }
   } else {
     const csrInlinableConstants = csrInlinableConstantsFromCtx(ctx);
-    const templateHtml = generateCsrTemplate(_ir.root, csrInlinableConstants, ctx, undefined, restSpreadNames, ctx.propsObjectName, unsafeLocalNames, ctx.deferredChildSlots);
+    const templateHtml = generateCsrTemplate(_ir.root, csrInlinableConstants, ctx, restSpreadNames, ctx.propsObjectName, unsafeLocalNames, ctx.deferredChildSlots);
     if (templateHtml) {
       defParts.push(`template: (${PROPS_PARAM}) => \`${templateHtml}\``);
     }
@@ -16797,6 +17025,7 @@ function buildSignalPlan(signal, ctx, lookups) {
         kind: "signal",
         getter: signal.getter,
         setter: signal.setter,
+        getterElided: signal.getterElided,
         initialValueExpr: "",
         controlledEffect: null,
         initializerOverride: `${factory}()`
@@ -16811,6 +17040,7 @@ function buildSignalPlan(signal, ctx, lookups) {
     kind: "signal",
     getter: signal.getter,
     setter: signal.setter,
+    getterElided: signal.getterElided,
     initialValueExpr: resolveSignalInitialValue(signal, ctx, lookups),
     controlledEffect,
     branchCondition: signal.branchCondition,
@@ -16882,9 +17112,10 @@ function bfIdArg(bfId) {
   return bfId ? `, ${JSON.stringify(bfId)}` : "";
 }
 function emitSignal(lines, plan) {
+  const getterSlot = plan.getterElided ? "" : plan.getter;
   if (plan.initializerOverride) {
     if (plan.setter) {
-      lines.push(`  const [${plan.getter}, ${plan.setter}] = ${plan.initializerOverride}`);
+      lines.push(`  const [${getterSlot}, ${plan.setter}] = ${plan.initializerOverride}`);
     } else {
       lines.push(`  const [${plan.getter}] = ${plan.initializerOverride}`);
     }
@@ -16893,9 +17124,9 @@ function emitSignal(lines, plan) {
   const id = bfIdArg(plan.bfId);
   if (plan.branchCondition) {
     if (plan.setter) {
-      lines.push(`  let ${plan.getter}, ${plan.setter}`);
+      lines.push(plan.getterElided ? `  let ${plan.setter}` : `  let ${plan.getter}, ${plan.setter}`);
       lines.push(`  if (${plan.branchCondition}) {`);
-      lines.push(`    ;[${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`);
+      lines.push(`    ;[${getterSlot}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`);
       lines.push(`  }`);
     } else {
       lines.push(`  let ${plan.getter}`);
@@ -16906,7 +17137,7 @@ function emitSignal(lines, plan) {
     return;
   }
   if (plan.setter) {
-    lines.push(`  const [${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`);
+    lines.push(`  const [${getterSlot}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`);
   } else {
     lines.push(`  const [${plan.getter}] = createSignal(${plan.initialValueExpr}${id})`);
   }
@@ -17485,7 +17716,7 @@ function emitComponentAndEventSetup(ls, indent, elVar, comps, events, loopParam,
 // src/ir-to-client-js/plan/build-static-array-child-init.ts
 function staticPreludeStatements(preamble) {
   return preamble ? [renderPreamble(preamble, {
-    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true)
+    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined)
   })] : [];
 }
 function buildStaticArrayChildInitsPlan(ctx) {
@@ -18040,7 +18271,8 @@ function buildReactiveEffectsPlan(args) {
       attrs: slotAttrs.map((attr) => ({
         attrName: attr.attrName,
         wrappedExpression: wrap(attr.expression),
-        meta: pickAttrMeta(attr)
+        meta: pickAttrMeta(attr),
+        ...attr.readsPreamble && { readsPreamble: true }
       }))
     });
   }
@@ -18240,7 +18472,7 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
     ] : [{ param: inner.param, bindings: inner.paramBindings }];
     preludeStatements.push(renderPreamble(inner.preamble, {
       transformJs: (t) => wrapInner(wrapOuter(t)),
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, leafLoopParams, undefined, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, leafLoopParams, undefined)
     }));
   }
   const childRefs = buildChildRefBindings(inner.bindings.refs, inner.param, inner.paramBindings);
@@ -18266,7 +18498,7 @@ function buildStaticEmit(inner, level, uidSuffix) {
     preludeStatements.push(indexAlias);
   if (inner.preamble) {
     preludeStatements.push(renderPreamble(inner.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined)
     }));
   }
   return {
@@ -18298,7 +18530,7 @@ function buildTopLevelCompositePlan(elem, profileComponentName) {
     indexParam: elem.index || "__idx",
     mapPreambleWrapped: elem.preamble ? renderPreamble(elem.preamble, {
       transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined)
     }) : "",
     template: elem.template,
     outerComps: filterCondCompsOut(outerCompsByDepth, elem.bindings.conditionals),
@@ -18348,7 +18580,7 @@ function buildBranchCompositePlan(loop, cv, profileComponentName) {
     indexParam: loop.index || "__idx",
     mapPreambleWrapped: loop.preamble ? renderPreamble(loop.preamble, {
       transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined)
     }) : "",
     template: loop.template,
     outerComps: filterCondCompsOut(outerCompsByDepth, loop.bindings.conditionals),
@@ -18413,7 +18645,7 @@ function buildDynamicLoopDelegationPlan(elem, profileComponentName) {
       key: elem.key,
       index: elem.index,
       mapPreamble: elem.preamble ? renderPreamble(elem.preamble, {
-        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true)
+        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined)
       }) : null,
       mapPreambleDeclaredNames: elem.preamble?.declaredNames ?? []
     })
@@ -18432,7 +18664,7 @@ function buildBranchLoopDelegationPlan(loop, cv, profileComponentName) {
       key: loop.key,
       index: loop.index,
       mapPreamble: loop.preamble ? renderPreamble(loop.preamble, {
-        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true)
+        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined)
       }) : null,
       mapPreambleDeclaredNames: loop.preamble?.declaredNames ?? []
     })
@@ -18449,7 +18681,7 @@ function buildStaticArrayDelegationPlan(elem, profileComponentName) {
       arrayExpr: buildChainedArrayExpr(elem),
       param: elem.param,
       mapPreamble: elem.preamble ? renderPreamble(elem.preamble, {
-        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true)
+        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined)
       }) : null,
       mapPreambleDeclaredNames: elem.preamble?.declaredNames ?? [],
       offset: elem.offset ?? null,
@@ -18484,6 +18716,181 @@ function buildKeyedOrIndexLookup(args) {
   };
 }
 
+// src/ir-to-client-js/control-flow/plan/lazy-conditional.ts
+var NO = (reason) => ({ lazySafe: false, reason });
+function wiringOn(branch) {
+  const found = [];
+  if (branch.childComponents.length > 0)
+    found.push("child components");
+  if (branch.innerLoops && branch.innerLoops.length > 0)
+    found.push("an inner loop");
+  if (branch.conditionals && branch.conditionals.length > 0)
+    found.push("a nested conditional");
+  if (branch.events && branch.events.length > 0)
+    found.push("events");
+  if (branch.reactiveAttrs && branch.reactiveAttrs.length > 0)
+    found.push("reactive attrs");
+  if (branch.reactiveTexts && branch.reactiveTexts.length > 0)
+    found.push("reactive text");
+  return found;
+}
+function analyzeLazyConditional(cond, indexParam, arms) {
+  for (const [label, branch] of [["true", cond.whenTrue], ["false", cond.whenFalse]]) {
+    const wiring = wiringOn(branch);
+    if (wiring.length > 0) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label} arm owns ${wiring.join(" + ")}`);
+    }
+  }
+  for (const [label, html] of [["true", arms.whenTrueHtml], ["false", arms.whenFalseHtml]]) {
+    if (html.includes("bf-cond-start:")) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label} arm is a fragment conditional`);
+    }
+    if (!html.includes(`bf-c="${cond.slotId}"`)) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label} arm has no single bf-c root`);
+    }
+    if (html.includes("${")) {
+      return NO(`conditional on slot ${cond.slotId}: its ${label} arm interpolates a value`);
+    }
+  }
+  if (!cond.conditionFreeIdentifiers) {
+    return NO(`conditional on slot ${cond.slotId}: condition has no analyzable identifier set`);
+  }
+  if (cond.conditionFreeIdentifiers.has(indexParam)) {
+    return NO(`conditional on slot ${cond.slotId}: condition reads the loop index parameter '${indexParam}'`);
+  }
+  return {
+    lazySafe: true,
+    facts: {
+      slotId: cond.slotId,
+      condition: cond.condition,
+      whenTrueHtml: arms.whenTrueHtml,
+      whenFalseHtml: arms.whenFalseHtml
+    }
+  };
+}
+
+// src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
+import ts15 from "typescript";
+var NO_PREAMBLE = {
+  lazySafe: true,
+  facts: { declaredNames: new Set, freeNames: new Set }
+};
+var NO2 = (reason) => ({ lazySafe: false, reason });
+function analyzeLazyPreamble(preamble, indexParam, primableNames) {
+  if (!preamble)
+    return NO_PREAMBLE;
+  if (preamble.builderNames.length > 0) {
+    return NO2(`map-callback preamble accumulates JSX leaves (${preamble.builderNames.join(", ")})`);
+  }
+  for (const seg of preamble.segments) {
+    if (seg.kind !== "js")
+      return NO2("map-callback preamble contains a JSX leaf");
+  }
+  const text = preambleAnalysisText(preamble);
+  if (text.trim().length === 0)
+    return NO_PREAMBLE;
+  const declaredNames = new Set;
+  const sf = ts15.createSourceFile("__lazy_preamble__.ts", text, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+  for (const stmt of sf.statements) {
+    if (!ts15.isVariableStatement(stmt)) {
+      return NO2(`map-callback preamble has a non-declaration statement (${ts15.SyntaxKind[stmt.kind]})`);
+    }
+    const isConst = (stmt.declarationList.flags & ts15.NodeFlags.Const) !== 0;
+    if (!isConst)
+      return NO2("map-callback preamble declares a mutable binding (let/var)");
+    for (const decl of stmt.declarationList.declarations) {
+      collectBindingNames2(decl.name, declaredNames);
+      if (!decl.initializer) {
+        return NO2("map-callback preamble has a declaration with no initializer");
+      }
+      const impure = findImpureNode(decl.initializer, primableNames);
+      if (impure) {
+        return NO2(`map-callback preamble initializer is not re-runnable (${impure})`);
+      }
+    }
+  }
+  for (const name of declaredNames) {
+    if (primableNames.has(name)) {
+      return NO2(`map-callback preamble shadows the signal/memo getter '${name}'`);
+    }
+  }
+  const readNames = extractFreeIdentifiersFromStatementText(text);
+  if (readNames.has(indexParam) && !declaredNames.has(indexParam)) {
+    return NO2(`map-callback preamble reads the loop index parameter '${indexParam}'`);
+  }
+  const freeNames = new Set(readNames);
+  for (const declared of declaredNames)
+    freeNames.delete(declared);
+  return { lazySafe: true, facts: { declaredNames, freeNames } };
+}
+function collectBindingNames2(name, out) {
+  if (ts15.isIdentifier(name)) {
+    out.add(name.text);
+    return;
+  }
+  for (const element of name.elements) {
+    if (ts15.isOmittedExpression(element))
+      continue;
+    collectBindingNames2(element.name, out);
+  }
+}
+function findImpureNode(root, primableNames) {
+  let found = null;
+  const visit3 = (node) => {
+    if (found)
+      return;
+    if (ts15.isCallExpression(node)) {
+      const callee = node.expression;
+      const isSignalRead = ts15.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
+      if (!isSignalRead) {
+        found = `call to ${callee.getText(callee.getSourceFile())}`;
+        return;
+      }
+    }
+    if (ts15.isNewExpression(node)) {
+      found = "new expression";
+      return;
+    }
+    if (ts15.isTaggedTemplateExpression(node)) {
+      found = "tagged template";
+      return;
+    }
+    if (ts15.isAwaitExpression(node)) {
+      found = "await";
+      return;
+    }
+    if (ts15.isYieldExpression(node)) {
+      found = "yield";
+      return;
+    }
+    if (ts15.isPrefixUnaryExpression(node) || ts15.isPostfixUnaryExpression(node)) {
+      const op = node.operator;
+      if (op === ts15.SyntaxKind.PlusPlusToken || op === ts15.SyntaxKind.MinusMinusToken) {
+        found = "increment/decrement";
+        return;
+      }
+    }
+    if (ts15.isDeleteExpression(node)) {
+      found = "delete";
+      return;
+    }
+    if (ts15.isFunctionExpression(node) || ts15.isArrowFunction(node) || ts15.isClassExpression(node)) {
+      found = "function or class expression";
+      return;
+    }
+    if (ts15.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+      found = "assignment";
+      return;
+    }
+    ts15.forEachChild(node, visit3);
+  };
+  visit3(root);
+  return found;
+}
+function isAssignmentOperator(kind) {
+  return kind >= ts15.SyntaxKind.FirstAssignment && kind <= ts15.SyntaxKind.LastAssignment;
+}
+
 // src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
 var PURE_SOURCE_GLOBALS = new Set([
   "Object",
@@ -18527,51 +18934,51 @@ var INERT_BINDING_GLOBALS = new Set([
   "decodeURI"
 ]);
 var UNKNOWN_IDENTIFIERS = "<unknown>";
-var NO = (reason) => ({ eligible: false, reason });
+var NO3 = (reason) => ({ eligible: false, reason });
 function lazyRowEligibility(args) {
   const { shape, bindings, arraySourceIdentifiers, scope } = args;
   if (scope.profile)
-    return NO("profile mode keeps the granular eager emission");
+    return NO3("profile mode keeps the granular eager emission");
   if (shape.callSite !== "plain" && shape.callSite !== "branch-plain") {
-    return NO(`call site '${shape.callSite}' is not a plain loop row`);
+    return NO3(`call site '${shape.callSite}' is not a plain loop row`);
   }
   if (shape.flatMapLeafItem)
-    return NO("flatMap descriptor loop (build-or-patch renderItem)");
+    return NO3("flatMap descriptor loop (build-or-patch renderItem)");
   if (shape.anchored)
-    return NO("anchored whole-item-conditional loop");
+    return NO3("anchored whole-item-conditional loop");
   if (shape.bodyIsMultiRoot)
-    return NO("multi-root (Fragment) row");
+    return NO3("multi-root (Fragment) row");
   if (!shape.hasExplicitKey)
-    return NO("index-keyed loop (no explicit key)");
-  if (shape.conditionalCount > 0)
-    return NO("row contains a reactive conditional");
+    return NO3("index-keyed loop (no explicit key)");
+  if (shape.conditionalRefusal)
+    return NO3(shape.conditionalRefusal);
   if (shape.childRefCount > 0)
-    return NO("row has imperative child refs");
+    return NO3("row has imperative child refs");
   if (shape.hasChildComponent)
-    return NO("row body is a child component");
+    return NO3("row body is a child component");
   if (shape.nestedComponentCount > 0)
-    return NO("row contains nested child components");
+    return NO3("row contains nested child components");
   if (shape.innerLoopCount > 0)
-    return NO("row contains an inner loop");
-  if (shape.hasMapPreamble)
-    return NO("row has a map-callback preamble (may declare row-local reactivity)");
+    return NO3("row contains an inner loop");
+  if (shape.mapPreambleRefusal)
+    return NO3(shape.mapPreambleRefusal);
   if (shape.preambleRegionCount > 0)
-    return NO("row has preamble-patched regions");
+    return NO3("row has preamble-patched regions");
   if (shape.hasParamUnwrap)
-    return NO("destructured loop param without param bindings");
+    return NO3("destructured loop param without param bindings");
   for (const b of bindings) {
     if (b.referencesIndex) {
-      return NO(`binding on slot ${b.slotId} references the loop index parameter`);
+      return NO3(`binding on slot ${b.slotId} references the loop index parameter`);
     }
     if (b.opaqueOuterNames.includes(UNKNOWN_IDENTIFIERS)) {
-      return NO(`binding on slot ${b.slotId} has no analyzable identifier set`);
+      return NO3(`binding on slot ${b.slotId} has no analyzable identifier set`);
     }
   }
   if (!arraySourceIdentifiers)
-    return NO("loop source free identifiers unavailable");
+    return NO3("loop source free identifiers unavailable");
   const sourceGate = checkSourceConsistency(arraySourceIdentifiers, scope);
   if (sourceGate)
-    return NO(`loop source is not provably hydration-consistent: ${sourceGate}`);
+    return NO3(`loop source is not provably hydration-consistent: ${sourceGate}`);
   return { eligible: true };
 }
 function checkSourceConsistency(names, scope) {
@@ -18622,6 +19029,7 @@ function checkSourceConsistency(names, scope) {
 }
 function classifyLazyBinding(args) {
   const { kind, slotId, free, rowLocalNames, indexParam, scope } = args;
+  const preamble = args.preamble;
   if (free === null) {
     return {
       kind,
@@ -18630,33 +19038,44 @@ function classifyLazyBinding(args) {
       readsOuter: true,
       reactiveOuterNames: [],
       opaqueOuterNames: [UNKNOWN_IDENTIFIERS],
-      referencesIndex: false
+      referencesIndex: false,
+      readsPreamble: preamble != null && preamble.declaredNames.size > 0
     };
   }
   let readsItem = false;
   let referencesIndex = false;
+  let readsPreamble = false;
   const reactiveOuterNames = [];
   const opaqueOuterNames = [];
-  for (const name of free) {
+  const classifyName = (name) => {
     if (rowLocalNames.has(name)) {
       readsItem = true;
-      continue;
+      return;
     }
     if (name === indexParam) {
       referencesIndex = true;
-      continue;
+      return;
     }
     if (INERT_BINDING_GLOBALS.has(name))
-      continue;
+      return;
     if (scope.signals.has(name) || scope.memos.has(name)) {
       if (!reactiveOuterNames.includes(name))
         reactiveOuterNames.push(name);
-      continue;
+      return;
     }
     const constFree = scope.constants.get(name);
     if (constFree !== undefined && constFree !== null && constFree.size === 0)
-      continue;
+      return;
     opaqueOuterNames.push(name);
+  };
+  for (const name of free) {
+    if (preamble?.declaredNames.has(name)) {
+      readsPreamble = true;
+      for (const dep of preamble.freeNames)
+        classifyName(dep);
+      continue;
+    }
+    classifyName(name);
   }
   return {
     kind,
@@ -18665,7 +19084,8 @@ function classifyLazyBinding(args) {
     readsOuter: reactiveOuterNames.length > 0 || opaqueOuterNames.length > 0,
     reactiveOuterNames,
     opaqueOuterNames,
-    referencesIndex
+    referencesIndex,
+    readsPreamble
   };
 }
 
@@ -18682,6 +19102,23 @@ function decideLazyRow(args) {
   const rowLocalNames = new Set([loop.param]);
   for (const b of loop.paramBindings ?? [])
     rowLocalNames.add(b.name);
+  const primableNames = new Set([...scope.signals.keys(), ...scope.memos]);
+  const preambleAnalysis = analyzeLazyPreamble(loop.preamble, args.indexParam, primableNames);
+  const rawConditionals = loop.bindings.conditionals ?? [];
+  const condFacts = [];
+  let conditionalRefusal = null;
+  for (const cond of rawConditionals) {
+    const verdict = analyzeLazyConditional(cond, args.indexParam, {
+      whenTrueHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
+      whenFalseHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId)
+    });
+    if (!verdict.lazySafe) {
+      conditionalRefusal = verdict.reason;
+      break;
+    }
+    condFacts.push(verdict.facts);
+  }
+  const preambleFacts = preambleAnalysis.lazySafe ? preambleAnalysis.facts : undefined;
   const classified = [];
   const attrClass = new Map;
   loop.bindings.reactiveAttrs.forEach((attr, i) => {
@@ -18691,7 +19128,8 @@ function decideLazyRow(args) {
       free: attrFreeIdentifiers2(attr.expression),
       rowLocalNames,
       indexParam: args.indexParam,
-      scope
+      scope,
+      preamble: preambleFacts
     });
     attrClass.set(i, c);
     classified.push(c);
@@ -18704,23 +19142,38 @@ function decideLazyRow(args) {
       free: text.freeIdentifiers ?? null,
       rowLocalNames,
       indexParam: args.indexParam,
-      scope
+      scope,
+      preamble: preambleFacts
     });
     textClass.set(i, c);
     classified.push(c);
   });
+  const condClass = new Map;
+  condFacts.forEach((c, i) => {
+    const k = classifyLazyBinding({
+      kind: "attr",
+      slotId: c.slotId,
+      free: rawConditionals[i].conditionFreeIdentifiers ?? null,
+      rowLocalNames,
+      indexParam: args.indexParam,
+      scope,
+      preamble: preambleFacts
+    });
+    condClass.set(i, k);
+    classified.push(k);
+  });
   const shape = {
     callSite: args.callSite,
     flatMapLeafItem: args.flatMapLeafItem,
     anchored: args.anchored,
     bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
     hasExplicitKey: loop.key != null,
-    conditionalCount: loop.bindings.conditionals?.length ?? 0,
+    conditionalRefusal,
     childRefCount: loop.bindings.refs?.length ?? 0,
     nestedComponentCount: loop.nestedComponents?.length ?? 0,
     innerLoopCount: loop.innerLoops?.length ?? 0,
     hasChildComponent: "childComponent" in loop && loop.childComponent != null,
-    hasMapPreamble: args.mapPreambleWrapped.length > 0,
+    mapPreambleRefusal: preambleAnalysis.lazySafe ? null : preambleAnalysis.reason,
     preambleRegionCount: args.preambleRegionCount,
     hasParamUnwrap: args.paramUnwrap.length > 0
   };
@@ -18748,7 +19201,8 @@ function decideLazyRow(args) {
       refIndex: attrSlotIds.indexOf(attr.childSlotId),
       ordinal: ordinal++,
       readsItem: c.readsItem,
-      readsOuter: c.readsOuter
+      readsOuter: c.readsOuter,
+      readsPreamble: c.readsPreamble
     };
   });
   const texts = loop.bindings.reactiveTexts.map((text, i) => {
@@ -18758,7 +19212,8 @@ function decideLazyRow(args) {
       wrappedExpression: wrap(text.expression),
       ordinal: ordinal++,
       readsItem: c.readsItem || !c.readsOuter,
-      readsOuter: c.readsOuter
+      readsOuter: c.readsOuter,
+      readsPreamble: c.readsPreamble
     };
   });
   const outerPrimeGetters = [];
@@ -18768,6 +19223,21 @@ function decideLazyRow(args) {
         outerPrimeGetters.push(name);
     }
   }
+  const condRefBase = attrSlotIds.length + (texts.length > 0 ? 1 : 0);
+  const conditionals = condFacts.map((c, i) => {
+    const klass = condClass.get(i);
+    return {
+      slotId: c.slotId,
+      wrappedCondition: wrap(c.condition),
+      whenTrueHtml: c.whenTrueHtml,
+      whenFalseHtml: c.whenFalseHtml,
+      refIndex: condRefBase + i,
+      ordinal: ordinal++,
+      readsItem: klass.readsItem || !klass.readsOuter,
+      readsOuter: klass.readsOuter,
+      readsPreamble: klass.readsPreamble
+    };
+  });
   return {
     plan: {
       attrSlotIds,
@@ -18777,7 +19247,10 @@ function decideLazyRow(args) {
       textNeedsRead: texts.some((t) => t.readsOuter),
       lastCount: ordinal,
       outerPrimeGetters,
-      hasOuter: attrs.some((a) => a.readsOuter) || texts.some((t) => t.readsOuter)
+      preambleStatements: args.mapPreambleWrapped,
+      itemNeedsPreamble: [...attrs, ...texts, ...conditionals].some((b) => b.readsItem && b.readsPreamble),
+      outerNeedsPreamble: [...attrs, ...texts, ...conditionals].some((b) => b.readsOuter && b.readsPreamble),
+      conditionals
     },
     decision
   };
@@ -18849,7 +19322,7 @@ function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
   const indexParam = loop.index || "__idx";
   const mapPreambleWrapped = loop.preamble ? renderPreamble(loop.preamble, {
     transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
-    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined, true)
+    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined)
   }) : "";
   const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings);
   const plan = {
@@ -18945,7 +19418,7 @@ function buildArmBody(branch, options) {
 }
 
 // src/ir-to-client-js/emit-reactive.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 
 // src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -19048,20 +19521,20 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+    sourceFile = ts16.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts15.isExpressionStatement(stmt))
+  if (!stmt || !ts16.isExpressionStatement(stmt))
     return expr;
-  const root = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts16.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts15.isCallExpression(n) && n.arguments.length === 2 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts16.isCallExpression(n) && n.arguments.length === 2 && ts16.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -19097,20 +19570,20 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+    sourceFile = ts16.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts15.isExpressionStatement(stmt))
+  if (!stmt || !ts16.isExpressionStatement(stmt))
     return expr;
-  const root = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts16.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts15.isCallExpression(n) && n.arguments.length === 0 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts16.isCallExpression(n) && n.arguments.length === 0 && ts16.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -19418,7 +19891,7 @@ function stringifyReactiveEffects(lines, plan, opts) {
   const outerTexts = plan?.outerTexts ?? [];
   const conditionals = plan?.conditionals ?? [];
   if (pc) {
-    emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId);
+    emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId, mapPreambleWrapped);
     emitOuterTexts(lines, indent, elVar, outerTexts, bindingBfId, textClaimPathExprs);
     emitPreambleRegionsEffect(lines, indent, elVar, preambleRegions, mapPreambleWrapped);
   } else {
@@ -19428,7 +19901,7 @@ function stringifyReactiveEffects(lines, plan, opts) {
     emitOuterConditional(lines, indent, elVar, cond, pc);
   }
 }
-function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId) {
+function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId, mapPreambleWrapped) {
   for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     const lookupExpr = attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot);
@@ -19436,6 +19909,9 @@ function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementI
     lines.push(`${indent}if (${varName}) {`);
     for (const attr of slot.attrs) {
       lines.push(`${indent}  createEffect(() => {`);
+      if (attr.readsPreamble && mapPreambleWrapped) {
+        lines.push(`${indent}    ${mapPreambleWrapped}`);
+      }
       for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
         lines.push(`${indent}    ${stmt}`);
       }
@@ -19458,6 +19934,9 @@ function emitPreambleRegionsEffect(lines, indent, elVar, preambleRegions, mapPre
   }
   lines.push(`${indent}})`);
 }
+function attrsReadPreamble(attrSlots) {
+  return attrSlots.some((slot) => slot.attrs.some((a) => a.readsPreamble));
+}
 function attrLookupExpr(slotId, varName, elVar, lookup, elementIndexBySlot) {
   const pIdx = elementIndexBySlot?.get(slotId);
   return pIdx !== undefined ? `__p ? __p[${pIdx}] : ${lookup}(${elVar}, '[bf="${slotId}"]')` : `${lookup}(${elVar}, '[bf="${slotId}"]')`;
@@ -19483,6 +19962,9 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
     return;
   }
   lines.push(`${indent}createEffect(() => {`);
+  if (mapPreambleWrapped && (preambleRegions.length > 0 || attrsReadPreamble(attrSlots))) {
+    lines.push(`${indent}  ${mapPreambleWrapped}`);
+  }
   for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}  if (${varName}) {`);
@@ -19495,9 +19977,6 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
     }
     lines.push(`${indent}  }`);
   }
-  if (preambleRegions.length > 0 && mapPreambleWrapped) {
-    lines.push(`${indent}  ${mapPreambleWrapped}`);
-  }
   for (const text of outerTexts) {
     lines.push(`${indent}  ${writer}('${text.slotId}', String(${text.wrappedExpression}))`);
   }
@@ -19631,9 +20110,8 @@ function stringifyLazyRowLoop(lines, o) {
   const { indent, lazyRow, paramHead } = o;
   const mid = o.markerId.replace(/[^A-Za-z0-9_$]/g, "_");
   const tplVar = `__tpl_${mid}`;
-  const claimVar = `__lzc_${mid}`;
   const hasRefs = lazyRow.attrSlotIds.length > 0 || lazyRow.texts.length > 0;
-  const hasBindings = lazyRow.attrs.length > 0 || lazyRow.texts.length > 0;
+  const hasBindings = lazyRow.attrs.length > 0 || lazyRow.texts.length > 0 || lazyRow.conditionals.length > 0;
   const rwDoor = lazyRow.textNeedsRead;
   const paths = o.skeletonPaths;
   const useHoisted = Boolean(o.skeletonTemplate);
@@ -19663,13 +20141,10 @@ function stringifyLazyRowLoop(lines, o) {
       freshPlanVar = adoptedPlanVar;
     }
   }
-  if (hasRefs) {
-    const parts = refParts(lazyRow, "__el", null, adoptedPlanVar, true);
-    lines.push(`${indent}const ${claimVar} = (__e) => {`);
-    if (parts.some((p) => p.includes("__el")))
-      lines.push(`${indent}  const __el = __e.primaryEl`);
-    lines.push(`${indent}  return [${parts.join(", ")}]`);
-    lines.push(`${indent}}`);
+  for (const c of lazyRow.conditionals) {
+    const v = condVars(mid, c.slotId);
+    emitHoistedTemplateDecl(lines, indent, v.trueTpl, c.whenTrueHtml);
+    emitHoistedTemplateDecl(lines, indent, v.falseTpl, c.whenFalseHtml);
   }
   const call = `mapArrayLazy(() => ${o.arrayExpr}, ${o.containerVar}, ${o.keyFn}, {`;
   lines.push(`${indent}${o.guardContainer ? `if (${o.containerVar}) ` : ""}${call}`);
@@ -19677,6 +20152,8 @@ function stringifyLazyRowLoop(lines, o) {
   const b2 = `${indent}    `;
   lines.push(`${b1}createRow: (__e, ${o.indexParam}) => {`);
   lines.push(`${b2}const ${paramHead} = () => __e.item`);
+  if (lazyRow.preambleStatements)
+    lines.push(`${b2}${lazyRow.preambleStatements}`);
   const cloneExpr = useHoisted ? hoistedCloneExpr(tplVar, o.skeletonTemplate) : `(() => { ${emitTemplateCloneInline(o.template)} })()`;
   lines.push(`${b2}const __el = ${cloneExpr}`);
   if (hasRefs) {
@@ -19690,17 +20167,23 @@ function stringifyLazyRowLoop(lines, o) {
     for (const t of lazyRow.texts)
       emitTextBinding(lines, b2, t, createDoor, "create", rwDoor);
   }
+  for (const c of lazyRow.conditionals)
+    emitConditional(lines, b2, mid, c, "create");
   lines.push(`${b2}return __el`);
   lines.push(`${b1}},`);
   const itemAttrs = lazyRow.attrs.filter((a) => a.readsItem);
   const itemTexts = lazyRow.texts.filter((t) => t.readsItem);
-  if (itemAttrs.length === 0 && itemTexts.length === 0) {
+  const itemConds = lazyRow.conditionals.filter((c) => c.readsItem);
+  if (itemAttrs.length === 0 && itemTexts.length === 0 && itemConds.length === 0) {
     lines.push(`${b1}applyItem: () => {},`);
   } else {
     lines.push(`${b1}applyItem: (__e) => {`);
     lines.push(`${b2}const ${paramHead} = () => __e.item`);
-    lines.push(`${b2}const __r = __e.refs ?? (__e.refs = ${claimVar}(__e))`);
+    lines.push(`${b2}const __r = __e.refs ?? (__e.refs = [])`);
     lines.push(`${b2}const __l = __e.last ?? (__e.last = [])`);
+    if (lazyRow.itemNeedsPreamble && lazyRow.preambleStatements) {
+      lines.push(`${b2}${lazyRow.preambleStatements}`);
+    }
     for (const a of itemAttrs)
       emitAttrBinding(lines, b2, a, "item");
     if (itemTexts.length > 0) {
@@ -19708,19 +20191,25 @@ function stringifyLazyRowLoop(lines, o) {
       for (const t of itemTexts)
         emitTextBinding(lines, b2, t, "__d", "item", rwDoor);
     }
+    for (const c of itemConds)
+      emitConditional(lines, b2, mid, c, "item");
     lines.push(`${b1}},`);
   }
   const outerAttrs = lazyRow.attrs.filter((a) => a.readsOuter);
   const outerTexts = lazyRow.texts.filter((t) => t.readsOuter);
-  if (outerAttrs.length > 0 || outerTexts.length > 0) {
+  const outerConds = lazyRow.conditionals.filter((c) => c.readsOuter);
+  if (outerAttrs.length > 0 || outerTexts.length > 0 || outerConds.length > 0) {
     const b3 = `${indent}      `;
     lines.push(`${b1}applyOuter: (__es, __seed) => {`);
     for (const g of lazyRow.outerPrimeGetters)
       lines.push(`${b2}${g}()`);
     lines.push(`${b2}for (const __e of __es) {`);
     lines.push(`${b3}const ${paramHead} = () => __e.item`);
-    lines.push(`${b3}const __r = __e.refs ?? (__e.refs = ${claimVar}(__e))`);
+    lines.push(`${b3}const __r = __e.refs ?? (__e.refs = [])`);
     lines.push(`${b3}const __l = __e.last ?? (__e.last = [])`);
+    if (lazyRow.outerNeedsPreamble && lazyRow.preambleStatements) {
+      lines.push(`${b3}${lazyRow.preambleStatements}`);
+    }
     for (const a of outerAttrs)
       emitAttrBinding(lines, b3, a, "outer");
     if (outerTexts.length > 0) {
@@ -19728,22 +20217,28 @@ function stringifyLazyRowLoop(lines, o) {
       for (const t of outerTexts)
         emitTextBinding(lines, b3, t, "__d", "outer", rwDoor);
     }
+    for (const c of outerConds)
+      emitConditional(lines, b3, mid, c, "outer");
     lines.push(`${b2}}`);
     lines.push(`${b1}},`);
   }
   lines.push(`${indent}}, '${o.markerId}')`);
 }
-function refParts(lazyRow, elVar, skeletonPaths, planVar, deferDoor = false) {
+function refParts(lazyRow, elVar, skeletonPaths, planVar) {
   const parts = [];
   for (const slotId of lazyRow.attrSlotIds) {
     const path = skeletonPaths?.elementPaths.get(slotId);
     parts.push(path ? pathExpr(elVar, path) : `qsa(${elVar}, '[bf="${slotId}"]')`);
   }
   if (lazyRow.texts.length > 0) {
-    parts.push(deferDoor ? "null" : `${doorCtor(lazyRow)}(${elVar}, ${planVar})`);
+    parts.push(`${doorCtor(lazyRow)}(${elVar}, ${planVar})`);
   }
   return parts;
 }
+function elementAccess(a) {
+  const slot = `__r[${a.refIndex}]`;
+  return `${a.refIndex} in __r ? ${slot} : (${slot} = qsa(__e.primaryEl, '[bf="${a.slotId}"]'))`;
+}
 function doorCtor(lazyRow) {
   return lazyRow.textNeedsRead ? "lazyClaimSlots" : "lazySlots";
 }
@@ -19751,11 +20246,36 @@ function doorAccess(lazyRow, writerIndex, adoptedPlanVar) {
   const slot = `__r[${writerIndex}]`;
   return `${slot} ?? (${slot} = ${doorCtor(lazyRow)}(__e.primaryEl, ${adoptedPlanVar}))`;
 }
+function condVars(mid, slotId) {
+  const key = `${mid}_${slotId.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+  return { trueTpl: `__cbt_${key}`, falseTpl: `__cbf_${key}` };
+}
+function emitConditional(lines, ind, mid, c, mode) {
+  const v = condVars(mid, c.slotId);
+  if (mode === "create") {
+    lines.push(`${ind}__l[${c.ordinal}] = !!(${c.wrappedCondition})`);
+    return;
+  }
+  const slot = `__r[${c.refIndex}]`;
+  lines.push(`${ind}{ const __c = ${c.refIndex} in __r ? ${slot} : (${slot} = qsa(__e.primaryEl, '[bf-c="${c.slotId}"]'))`);
+  lines.push(`${ind}if (__c) {`);
+  lines.push(`${ind}  const __x = !!(${c.wrappedCondition})`);
+  lines.push(`${ind}  const __w = (__x ? ${v.trueTpl} : ${v.falseTpl}).content.firstElementChild`);
+  const guard = mode === "item" ? dedupGuard(c.ordinal) : `__seed ? (__c.outerHTML !== __w.outerHTML) : (${dedupGuard(c.ordinal)})`;
+  lines.push(`${ind}  if (${guard}) {`);
+  lines.push(`${ind}    const __n = __w.cloneNode(true)`);
+  lines.push(`${ind}    __c.replaceWith(__n)`);
+  lines.push(`${ind}    ${slot} = __n`);
+  lines.push(`${ind}  }`);
+  lines.push(`${ind}  __l[${c.ordinal}] = __x`);
+  lines.push(`${ind}} }`);
+}
 function dedupGuard(ordinal) {
   return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
 }
 function emitAttrBinding(lines, ind, a, mode) {
-  lines.push(`${ind}{ const __t = __r[${a.refIndex}]`);
+  const target = mode === "create" ? `__r[${a.refIndex}]` : elementAccess(a);
+  lines.push(`${ind}{ const __t = ${target}`);
   lines.push(`${ind}if (__t) {`);
   lines.push(`${ind}  const __x = ${a.wrappedExpression}`);
   const guard = mode === "create" ? null : mode === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
@@ -20752,7 +21272,7 @@ function buildPlainLoopPlan(elem, profileComponentName, lazyScope) {
   const indexParam = elem.index || "__idx";
   const mapPreambleWrapped = elem.preamble ? renderPreamble(elem.preamble, {
     transformJs: wrap,
-    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined, true)
+    renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined)
   }) : "";
   const preambleRegions = buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings);
   return {
@@ -20829,7 +21349,7 @@ function buildStaticLoopMaterialize(elem, unsafeLocalNames) {
   return {
     itemTemplate: elem.staticItemTemplate,
     mapPreamble: elem.preamble ? renderPreamble(elem.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined, true)
+      renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined)
     }) : "",
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false
   };
@@ -21066,20 +21586,20 @@ var PHASES = [
 ];
 
 // src/ir-to-client-js/rewrite-props-object.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName) {
   const srcPropsName = propsObjectName ?? "props";
   if (srcPropsName === PROPS_PARAM)
     return code;
   if (!new RegExp(`\\b${srcPropsName}\\b`).test(code))
     return code;
-  const sourceFile = ts16.createSourceFile("init-body.ts", code, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
+  const sourceFile = ts17.createSourceFile("init-body.ts", code, ts17.ScriptTarget.Latest, true, ts17.ScriptKind.TS);
   const spans = [];
   function visit3(node) {
-    if (ts16.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts17.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts16.forEachChild(node, visit3);
+    ts17.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0)
@@ -21095,17 +21615,17 @@ function shouldRewrite(node) {
   const parent = node.parent;
   if (!parent)
     return true;
-  if (ts16.isPropertyAccessExpression(parent) && parent.name === node)
+  if (ts17.isPropertyAccessExpression(parent) && parent.name === node)
     return false;
-  if (ts16.isPropertyAssignment(parent) && parent.name === node)
+  if (ts17.isPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts16.isShorthandPropertyAssignment(parent) && parent.name === node)
+  if (ts17.isShorthandPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts16.isPropertySignature(parent) && parent.name === node)
+  if (ts17.isPropertySignature(parent) && parent.name === node)
     return false;
-  if (ts16.isPropertyDeclaration(parent) && parent.name === node)
+  if (ts17.isPropertyDeclaration(parent) && parent.name === node)
     return false;
-  if (ts16.isBindingElement(parent) && parent.name === node)
+  if (ts17.isBindingElement(parent) && parent.name === node)
     return false;
   return true;
 }
@@ -21449,7 +21969,7 @@ function generateTemplateOnlyMount(ir, ctx) {
   }
   if (!templateHtml) {
     const csrInlinableConstants = csrInlinableConstantsFromCtx(ctx);
-    templateHtml = generateCsrTemplate(ir.root, csrInlinableConstants, ctx, undefined, restSpreadNames, ctx.propsObjectName, unsafeLocalNames);
+    templateHtml = generateCsrTemplate(ir.root, csrInlinableConstants, ctx, restSpreadNames, ctx.propsObjectName, unsafeLocalNames);
   }
   if (!templateHtml) {
     return "";
@@ -21735,7 +22255,7 @@ function walkIR2(node, visitor) {
 }
 
 // src/preprocess-inline-jsx-callbacks.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 var SYNTHETIC_PREFIX = "BFInlineJsxCallback";
 var MAX_FIXPOINT_ITERATIONS = 16;
 function preprocessInlineJsxCallbacks(source, filePath) {
@@ -21757,8 +22277,8 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts17.createSourceFile(filePath, source, ts17.ScriptTarget.Latest, true, ts17.ScriptKind.TSX);
-  const hasUseClient = sourceFile.statements.some((stmt) => ts17.isExpressionStatement(stmt) && ts17.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
+  const sourceFile = ts18.createSourceFile(filePath, source, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TSX);
+  const hasUseClient = sourceFile.statements.some((stmt) => ts18.isExpressionStatement(stmt) && ts18.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
   }
@@ -21780,22 +22300,22 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts17.isJsxAttribute(node) && node.initializer && ts17.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts18.isJsxAttribute(node) && node.initializer && ts18.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts17.isPropertyAssignment(node) && node.initializer) {
+    if (ts18.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer))
         return;
     }
-    ts17.forEachChild(node, visit3);
+    ts18.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts17.isParenthesizedExpression(expr))
+    while (ts18.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts17.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    if (ts18.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -21832,7 +22352,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name });
     return true;
   }
-  ts17.forEachChild(sourceFile, visit3);
+  ts18.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -21855,11 +22375,11 @@ function errorMessageForCapture(captures) {
   return `Inline JSX-returning arrow function captures non-module identifier(s): ` + `${captures.sort().join(", ")}. ` + `Extract the callback into a top-level '\\'use client\\'' component (e.g. ` + `\`function MyNode(n) { return <div/> }\` then \`renderNode={MyNode}\`) ` + `or pass captured values via component props.`;
 }
 function arrowBodyContainsJsx(arrow) {
-  if (ts17.isBlock(arrow.body)) {
+  if (ts18.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body = arrow.body;
-  while (ts17.isParenthesizedExpression(body))
+  while (ts18.isParenthesizedExpression(body))
     body = body.expression;
   return isJsxLike(body);
 }
@@ -21868,41 +22388,41 @@ function blockReturnsJsx(block) {
   function visit3(n) {
     if (found)
       return;
-    if (ts17.isReturnStatement(n) && n.expression) {
+    if (ts18.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts17.isParenthesizedExpression(e))
+      while (ts18.isParenthesizedExpression(e))
         e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts17.isArrowFunction(n) || ts17.isFunctionDeclaration(n) || ts17.isFunctionExpression(n))
+    if (ts18.isArrowFunction(n) || ts18.isFunctionDeclaration(n) || ts18.isFunctionExpression(n))
       return;
-    ts17.forEachChild(n, visit3);
+    ts18.forEachChild(n, visit3);
   }
-  ts17.forEachChild(block, visit3);
+  ts18.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts17.isJsxElement(expr) || ts17.isJsxSelfClosingElement(expr) || ts17.isJsxFragment(expr);
+  return ts18.isJsxElement(expr) || ts18.isJsxSelfClosingElement(expr) || ts18.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = new Set;
   for (const p of arrow.parameters)
-    collectBindingNames2(p.name, names);
+    collectBindingNames3(p.name, names);
   return names;
 }
-function collectBindingNames2(name, out) {
+function collectBindingNames3(name, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts17.isIdentifier(name)) {
+  if (ts18.isIdentifier(name)) {
     push(name.text);
-  } else if (ts17.isObjectBindingPattern(name)) {
-    name.elements.forEach((el) => collectBindingNames2(el.name, out));
-  } else if (ts17.isArrayBindingPattern(name)) {
+  } else if (ts18.isObjectBindingPattern(name)) {
+    name.elements.forEach((el) => collectBindingNames3(el.name, out));
+  } else if (ts18.isArrayBindingPattern(name)) {
     name.elements.forEach((el) => {
-      if (!ts17.isOmittedExpression(el))
-        collectBindingNames2(el.name, out);
+      if (!ts18.isOmittedExpression(el))
+        collectBindingNames3(el.name, out);
     });
   }
 }
@@ -21911,12 +22431,12 @@ function collectFreeIdentifiers(arrow) {
   const bound = [];
   for (const p of arrow.parameters) {
     const names = [];
-    collectBindingNames2(p.name, names);
+    collectBindingNames3(p.name, names);
     bound.push(...names);
   }
   function pushBindings(name) {
     const names = [];
-    collectBindingNames2(name, names);
+    collectBindingNames3(name, names);
     bound.push(...names);
     return names;
   }
@@ -21928,48 +22448,48 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name);
   }
   function visit3(node) {
-    if (ts17.isIdentifier(node)) {
+    if (ts18.isIdentifier(node)) {
       const parent = node.parent;
-      if (parent && ts17.isPropertyAccessExpression(parent) && parent.name === node)
+      if (parent && ts18.isPropertyAccessExpression(parent) && parent.name === node)
         return;
-      if (parent && ts17.isPropertyAssignment(parent) && parent.name === node)
+      if (parent && ts18.isPropertyAssignment(parent) && parent.name === node)
         return;
-      if (parent && ts17.isPropertySignature(parent) && parent.name === node)
+      if (parent && ts18.isPropertySignature(parent) && parent.name === node)
         return;
-      if (parent && ts17.isPropertyDeclaration(parent) && parent.name === node)
+      if (parent && ts18.isPropertyDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts17.isMethodDeclaration(parent) && parent.name === node)
+      if (parent && ts18.isMethodDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts17.isMethodSignature(parent) && parent.name === node)
+      if (parent && ts18.isMethodSignature(parent) && parent.name === node)
         return;
-      if (parent && ts17.isGetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts18.isGetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts17.isSetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts18.isSetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts17.isEnumMember(parent) && parent.name === node)
+      if (parent && ts18.isEnumMember(parent) && parent.name === node)
         return;
-      if (parent && ts17.isBindingElement(parent) && parent.propertyName === node)
+      if (parent && ts18.isBindingElement(parent) && parent.propertyName === node)
         return;
-      if (parent && ts17.isShorthandPropertyAssignment(parent) && parent.name === node) {
+      if (parent && ts18.isShorthandPropertyAssignment(parent) && parent.name === node) {
         if (!isBound(node.text))
           ids.add(node.text);
         return;
       }
-      if (parent && ts17.isParameter(parent) && parent.name === node)
+      if (parent && ts18.isParameter(parent) && parent.name === node)
         return;
-      if (parent && ts17.isVariableDeclaration(parent) && parent.name === node)
+      if (parent && ts18.isVariableDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts17.isFunctionDeclaration(parent) && parent.name === node)
+      if (parent && ts18.isFunctionDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts17.isClassDeclaration(parent) && parent.name === node)
+      if (parent && ts18.isClassDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts17.isJsxAttribute(parent) && parent.name === node)
+      if (parent && ts18.isJsxAttribute(parent) && parent.name === node)
         return;
-      if (parent && ts17.isJsxOpeningElement(parent) && parent.tagName === node) {
+      if (parent && ts18.isJsxOpeningElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
-      if (parent && ts17.isJsxClosingElement(parent) && parent.tagName === node) {
+      if (parent && ts18.isJsxClosingElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
@@ -21978,43 +22498,43 @@ function collectFreeIdentifiers(arrow) {
       ids.add(node.text);
       return;
     }
-    if (ts17.isVariableDeclaration(node)) {
+    if (ts18.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer)
         visit3(node.initializer);
       return;
     }
-    if (ts17.isFunctionDeclaration(node)) {
+    if (ts18.isFunctionDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts17.isClassDeclaration(node)) {
+    if (ts18.isClassDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
-      ts17.forEachChild(node, visit3);
+      ts18.forEachChild(node, visit3);
       return;
     }
-    if (ts17.isArrowFunction(node) || ts17.isFunctionExpression(node)) {
+    if (ts18.isArrowFunction(node) || ts18.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts17.isCatchClause(node)) {
+    if (ts18.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration)
         pushBindings(node.variableDeclaration.name);
-      ts17.forEachChild(node, visit3);
+      ts18.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts17.isBlock(node)) {
+    if (ts18.isBlock(node)) {
       const before = bound.length;
-      ts17.forEachChild(node, visit3);
+      ts18.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts17.forEachChild(node, visit3);
+    ts18.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -22037,29 +22557,29 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (ts17.isFunctionDeclaration(stmt) && stmt.name)
+    if (ts18.isFunctionDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts17.isClassDeclaration(stmt) && stmt.name)
+    else if (ts18.isClassDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts17.isVariableStatement(stmt)) {
+    else if (ts18.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
-        collectBindingNames2(decl.name, names);
-    } else if (ts17.isImportDeclaration(stmt) && stmt.importClause) {
+        collectBindingNames3(decl.name, names);
+    } else if (ts18.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name)
         names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts17.isNamespaceImport(ic.namedBindings))
+        if (ts18.isNamespaceImport(ic.namedBindings))
           names.add(ic.namedBindings.name.text);
         else
           for (const e of ic.namedBindings.elements)
             names.add(e.name.text);
       }
-    } else if (ts17.isTypeAliasDeclaration(stmt))
+    } else if (ts18.isTypeAliasDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts17.isInterfaceDeclaration(stmt))
+    else if (ts18.isInterfaceDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts17.isEnumDeclaration(stmt))
+    else if (ts18.isEnumDeclaration(stmt))
       names.add(stmt.name.text);
   }
   return names;
@@ -22067,7 +22587,7 @@ function collectModuleScopeNames(sourceFile) {
 function buildSyntheticDeclaration(name, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts17.isBlock(arrow.body)) {
+  if (ts18.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -22077,7 +22597,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // src/ssr-defaults.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 function extractSsrDefaults(metadata) {
@@ -22090,11 +22610,12 @@ function extractSsrDefaults(metadata) {
   for (const p of metadata.propsParams) {
     if (p.isRest)
       continue;
+    const callerPropName = p.sourceName ?? p.name;
     if (metadata.propsObjectName === null && p.defaultValue !== undefined) {
       const value = tryStaticEval(p.defaultValue, { bindings: {}, propsLike });
-      out[p.name] = { propName: p.name, value: resultToJsonable(value) };
+      out[p.name] = { propName: callerPropName, value: resultToJsonable(value) };
     } else {
-      out[p.name] = { propName: p.name, value: null };
+      out[p.name] = { propName: callerPropName, value: null };
     }
   }
   if (metadata.restPropsName) {
@@ -22153,11 +22674,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   if (!node)
     return;
   const visit3 = (n) => {
-    if (ts18.isPropertyAccessExpression(n) && ts18.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts18.isIdentifier(n.name)) {
+    if (ts19.isPropertyAccessExpression(n) && ts19.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts19.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts18.forEachChild(n, visit3);
+    ts19.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -22178,23 +22699,23 @@ function tryStaticEval(expr, ctx) {
 }
 function evalStatementsForReturn(statements, ctx) {
   for (const stmt of statements) {
-    if (ts18.isVariableStatement(stmt)) {
+    if (ts19.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts18.isIdentifier(d.name) || !d.initializer)
+        if (!ts19.isIdentifier(d.name) || !d.initializer)
           continue;
         const v = evalNode(d.initializer, ctx);
         if (v !== UNRESOLVED)
           ctx.bindings[d.name.text] = v;
       }
-    } else if (ts18.isReturnStatement(stmt)) {
+    } else if (ts19.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx) : UNRESOLVED;
-    } else if (ts18.isIfStatement(stmt)) {
+    } else if (ts19.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx);
       if (cond === UNRESOLVED)
         return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
-        const taken = evalStatementsForReturn(ts18.isBlock(branch) ? branch.statements : [branch], ctx);
+        const taken = evalStatementsForReturn(ts19.isBlock(branch) ? branch.statements : [branch], ctx);
         if (taken !== NO_RETURN)
           return taken;
       }
@@ -22205,45 +22726,45 @@ function evalStatementsForReturn(statements, ctx) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts18.createSourceFile("__ssr_default__.ts", `(${expr})`, ts18.ScriptTarget.Latest, false, ts18.ScriptKind.TS);
+  const sf = ts19.createSourceFile("__ssr_default__.ts", `(${expr})`, ts19.ScriptTarget.Latest, false, ts19.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt))
+  if (!stmt || !ts19.isExpressionStatement(stmt))
     return null;
-  const inner = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const inner = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx) {
-  if (ts18.isParenthesizedExpression(node))
+  if (ts19.isParenthesizedExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts18.isAsExpression(node))
+  if (ts19.isAsExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts18.isSatisfiesExpression(node))
+  if (ts19.isSatisfiesExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts18.isTypeAssertionExpression(node))
+  if (ts19.isTypeAssertionExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts18.isNonNullExpression(node))
+  if (ts19.isNonNullExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts18.isArrowFunction(node)) {
+  if (ts19.isArrowFunction(node)) {
     if (node.parameters.length !== 0)
       return UNRESOLVED;
-    if (!ts18.isBlock(node.body))
+    if (!ts19.isBlock(node.body))
       return evalNode(node.body, ctx);
     const localBindings = { ...ctx.bindings };
     const localCtx = { ...ctx, bindings: localBindings };
     const result = evalStatementsForReturn(node.body.statements, localCtx);
     return result === NO_RETURN ? UNRESOLVED : result;
   }
-  if (ts18.isNumericLiteral(node))
+  if (ts19.isNumericLiteral(node))
     return Number(node.text);
-  if (ts18.isStringLiteralLike(node))
+  if (ts19.isStringLiteralLike(node))
     return node.text;
-  if (node.kind === ts18.SyntaxKind.TrueKeyword)
+  if (node.kind === ts19.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts18.SyntaxKind.FalseKeyword)
+  if (node.kind === ts19.SyntaxKind.FalseKeyword)
     return false;
-  if (node.kind === ts18.SyntaxKind.NullKeyword)
+  if (node.kind === ts19.SyntaxKind.NullKeyword)
     return null;
-  if (ts18.isIdentifier(node)) {
+  if (ts19.isIdentifier(node)) {
     if (node.text === "undefined")
       return;
     if (node.text in ctx.bindings)
@@ -22252,29 +22773,29 @@ function evalNode(node, ctx) {
       return;
     return UNRESOLVED;
   }
-  if (ts18.isPrefixUnaryExpression(node)) {
+  if (ts19.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx);
     if (arg === UNRESOLVED)
       return UNRESOLVED;
     switch (node.operator) {
-      case ts18.SyntaxKind.MinusToken:
+      case ts19.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts18.SyntaxKind.PlusToken:
+      case ts19.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts18.SyntaxKind.ExclamationToken:
+      case ts19.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts18.isObjectLiteralExpression(node)) {
+  if (ts19.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts18.isPropertyAssignment(prop))
+      if (!ts19.isPropertyAssignment(prop))
         return UNRESOLVED;
       let key;
-      if (ts18.isIdentifier(prop.name) || ts18.isStringLiteralLike(prop.name)) {
+      if (ts19.isIdentifier(prop.name) || ts19.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts18.isNumericLiteral(prop.name)) {
+      } else if (ts19.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -22286,10 +22807,10 @@ function evalNode(node, ctx) {
     }
     return obj;
   }
-  if (ts18.isArrayLiteralExpression(node)) {
+  if (ts19.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts18.isOmittedExpression(elem))
+      if (ts19.isOmittedExpression(elem))
         return UNRESOLVED;
       const v = evalNode(elem, ctx);
       if (v === UNRESOLVED)
@@ -22298,7 +22819,7 @@ function evalNode(node, ctx) {
     }
     return arr;
   }
-  if (ts18.isElementAccessExpression(node)) {
+  if (ts19.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx);
     if (base === undefined)
       return;
@@ -22312,17 +22833,17 @@ function evalNode(node, ctx) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : undefined;
   }
-  if (ts18.isPropertyAccessExpression(node)) {
+  if (ts19.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx);
     if (baseResult === undefined)
       return;
     return UNRESOLVED;
   }
-  if (ts18.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts18.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
+  if (ts19.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts19.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
       return ctx.bindings[node.expression.text];
     }
-    if (ts18.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts19.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
         let sep2 = ",";
@@ -22338,27 +22859,27 @@ function evalNode(node, ctx) {
     }
     return UNRESOLVED;
   }
-  if (ts18.isConditionalExpression(node)) {
+  if (ts19.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx);
     if (cond === UNRESOLVED)
       return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx) : evalNode(node.whenFalse, ctx);
   }
-  if (ts18.isBinaryExpression(node)) {
+  if (ts19.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts18.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts19.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== undefined)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts18.SyntaxKind.BarBarToken) {
+    if (op === ts19.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts18.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts19.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 === UNRESOLVED)
         return UNRESOLVED;
@@ -22371,30 +22892,30 @@ function evalNode(node, ctx) {
     if (l === UNRESOLVED || r === UNRESOLVED)
       return UNRESOLVED;
     switch (op) {
-      case ts18.SyntaxKind.PlusToken:
+      case ts19.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r === "string")
           return `${l}${r}`;
         if (typeof l === "number" && typeof r === "number")
           return l + r;
         return UNRESOLVED;
-      case ts18.SyntaxKind.MinusToken:
+      case ts19.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r === "number" ? l - r : UNRESOLVED;
-      case ts18.SyntaxKind.AsteriskToken:
+      case ts19.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r === "number" ? l * r : UNRESOLVED;
-      case ts18.SyntaxKind.SlashToken:
+      case ts19.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l / r : UNRESOLVED;
-      case ts18.SyntaxKind.PercentToken:
+      case ts19.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l % r : UNRESOLVED;
-      case ts18.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts18.SyntaxKind.EqualsEqualsToken:
+      case ts19.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts19.SyntaxKind.EqualsEqualsToken:
         return l === r;
-      case ts18.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts18.SyntaxKind.ExclamationEqualsToken:
+      case ts19.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts19.SyntaxKind.ExclamationEqualsToken:
         return l !== r;
     }
     return UNRESOLVED;
   }
-  if (ts18.isTemplateExpression(node)) {
+  if (ts19.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0)
       return node.head.text;
     let acc = node.head.text;
@@ -22406,13 +22927,13 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts18.isNoSubstitutionTemplateLiteral(node))
+  if (ts19.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // src/augment-inherited-props.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -22444,47 +22965,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr))
+  if (!expr || !ts20.isCallExpression(expr))
     return null;
-  if (!ts19.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts20.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts19.isIdentifier(arg) ? arg.text : null;
+  return ts20.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr))
+  if (!expr || !ts20.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg))
+  if (ts20.isStringLiteral(arg) || ts20.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts19.isNumericLiteral(arg))
+  if (ts20.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts19.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts20.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts19.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts20.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr))
+  if (!expr || !ts20.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts19.isObjectLiteralExpression(expr.arguments[0]);
+  return ts20.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts19.createSourceFile("__ctx.ts", `(${source})`, ts19.ScriptTarget.Latest, false);
+  const sf = ts20.createSourceFile("__ctx.ts", `(${source})`, ts20.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isExpressionStatement(stmt))
+  if (!stmt || !ts20.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts19.isParenthesizedExpression(e))
+  while (ts20.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -22509,25 +23030,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts19.createSourceFile("__aug.ts", `(${s})`, ts19.ScriptTarget.Latest, false);
+    const sf = ts20.createSourceFile("__aug.ts", `(${s})`, ts20.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts19.isBinaryExpression(n) && (n.operatorToken.kind === ts19.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts19.SyntaxKind.BarBarToken)) {
+      if (ts20.isBinaryExpression(n) && (n.operatorToken.kind === ts20.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts20.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts19.isParenthesizedExpression(left))
+        while (ts20.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts19.isPropertyAccessExpression(left) && ts19.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts20.isPropertyAccessExpression(left) && ts20.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts19.isParenthesizedExpression(right))
+          while (ts20.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts19.isPrefixUnaryExpression(right))
+          if (ts20.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts19.isNumericLiteral(right) ? "number" : right.kind === ts19.SyntaxKind.TrueKeyword || right.kind === ts19.SyntaxKind.FalseKeyword ? "boolean" : ts19.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts20.isNumericLiteral(right) ? "number" : right.kind === ts20.SyntaxKind.TrueKeyword || right.kind === ts20.SyntaxKind.FalseKeyword ? "boolean" : ts20.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts19.forEachChild(n, visit3);
+      ts20.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -22638,33 +23159,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts19.createSourceFile("__const.ts", `const __x = (${source});`, ts19.ScriptTarget.Latest, false);
+  const sf = ts20.createSourceFile("__const.ts", `const __x = (${source});`, ts20.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isVariableStatement(stmt))
+  if (!stmt || !ts20.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts19.isParenthesizedExpression(init))
+  while (init && ts20.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts19.isStringLiteral(init) || ts19.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts20.isStringLiteral(init) || ts20.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts19.createSourceFile("__const.ts", `const __x = (${source});`, ts19.ScriptTarget.Latest, false);
+  const sf = ts20.createSourceFile("__const.ts", `const __x = (${source});`, ts20.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isVariableStatement(stmt))
+  if (!stmt || !ts20.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts19.isParenthesizedExpression(init))
+  while (init && ts20.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts19.isTemplateExpression(init))
+  if (!init || !ts20.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts19.isIdentifier(span.expression))
+    if (!ts20.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -22695,30 +23216,30 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts19.createSourceFile("__rec.ts", `(${constInfo.value})`, ts19.ScriptTarget.Latest, true);
+  const sf = ts20.createSourceFile("__rec.ts", `(${constInfo.value})`, ts20.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts19.isExpressionStatement(stmt))
+  if (!ts20.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts19.isParenthesizedExpression(parsed))
+  while (ts20.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts19.isObjectLiteralExpression(parsed))
+  if (!ts20.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts19.isPropertyAssignment(prop))
+    if (!ts20.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts19.isIdentifier(name) || ts19.isStringLiteral(name) || ts19.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts20.isIdentifier(name) || ts20.isStringLiteral(name) || ts20.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts19.isParenthesizedExpression(v))
+    while (ts20.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts19.isNumericLiteral(v))
+    if (ts20.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts20.isStringLiteral(v) || ts20.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -22726,28 +23247,28 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts19.createSourceFile("__join.ts", `const __x = (${source});`, ts19.ScriptTarget.Latest, false);
+  const sf = ts20.createSourceFile("__join.ts", `const __x = (${source});`, ts20.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isVariableStatement(stmt))
+  if (!stmt || !ts20.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts19.isParenthesizedExpression(node))
+  while (node && ts20.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts19.isCallExpression(node))
+  if (!node || !ts20.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts19.isPropertyAccessExpression(callee))
+  if (!ts20.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts19.isParenthesizedExpression(recv))
+  while (ts20.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts19.isArrayLiteralExpression(recv))
+  if (!ts20.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts19.isStringLiteral(el) || ts19.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts20.isStringLiteral(el) || ts20.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -22756,7 +23277,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg))
+    if (ts20.isStringLiteral(arg) || ts20.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -22764,11 +23285,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts19.isElementAccessExpression(val))
+  if (!ts20.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts19.isIdentifier(obj) || !ts19.isIdentifier(arg))
+  if (!ts20.isIdentifier(obj) || !ts20.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -22784,35 +23305,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts19.createSourceFile("__rec.ts", `(${constInfo.value})`, ts19.ScriptTarget.Latest, true);
+  const sf = ts20.createSourceFile("__rec.ts", `(${constInfo.value})`, ts20.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts19.isExpressionStatement(stmt))
+  if (!ts20.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts19.isParenthesizedExpression(parsed))
+  while (ts20.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts19.isObjectLiteralExpression(parsed))
+  if (!ts20.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts19.isPropertyAssignment(prop))
+    if (!ts20.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts19.isIdentifier(prop.name)) {
+    if (ts20.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts19.isStringLiteral(prop.name) || ts19.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts20.isStringLiteral(prop.name) || ts20.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts19.isParenthesizedExpression(v))
+    while (ts20.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts19.isNumericLiteral(v)) {
+    if (ts20.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts20.isStringLiteral(v) || ts20.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -23595,7 +24116,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -23616,10 +24137,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files, options = {}) {
   const baseUrl = options.baseUrl ?? commonParent(files);
   const compilerOptions = {
-    target: ts20.ScriptTarget.Latest,
-    module: ts20.ModuleKind.ESNext,
-    moduleResolution: ts20.ModuleResolutionKind.Bundler,
-    jsx: ts20.JsxEmit.ReactJSX,
+    target: ts21.ScriptTarget.Latest,
+    module: ts21.ModuleKind.ESNext,
+    moduleResolution: ts21.ModuleResolutionKind.Bundler,
+    jsx: ts21.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -23629,7 +24150,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts20.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts21.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -24184,6 +24705,8 @@ function collectLoopBoundNames(ir) {
           names.add(binding.name);
         if (node.filterPredicate)
           names.add(node.filterPredicate.param);
+        for (const name of node.preamble?.declaredNames ?? [])
+          names.add(name);
         for (const child of node.children)
           visit3(child);
         if (node.childComponent) {
@@ -24611,7 +25134,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // src/combine-client-js.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -24668,10 +25191,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts21.createSourceFile("combine.js", content, ts21.ScriptTarget.Latest, false, ts21.ScriptKind.JS);
+  const sourceFile = ts22.createSourceFile("combine.js", content, ts22.ScriptTarget.Latest, false, ts22.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts21.isImportDeclaration(stmt))
+    if (!ts22.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -24681,8 +25204,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts21.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts21.isNamedImports(bindings)) {
+    const specifier = ts22.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts22.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -24849,7 +25372,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -26134,7 +26657,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts22.createSourceFile("__attr.tsx", `(${expr})`, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
+    sf = ts23.createSourceFile("__attr.tsx", `(${expr})`, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -26142,11 +26665,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts22.isPropertyAccessExpression(n) && ts22.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts23.isPropertyAccessExpression(n) && ts23.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts22.forEachChild(n, visit3);
+    ts23.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -26216,7 +26739,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -26486,15 +27009,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts23.createSourceFile(filePath, source, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
+  const sf = ts24.createSourceFile(filePath, source, ts24.ScriptTarget.Latest, true, ts24.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts23.isCallExpression(node) && ts23.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts24.isCallExpression(node) && ts24.isIdentifier(node.expression) && node.expression.text === "createEffect") {
       const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
       if (!instrumentedLines.has(line))
         out.push({ file: filePath, line });
     }
-    ts23.forEachChild(node, visit3);
+    ts24.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -26802,13 +27325,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts23.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts23.ScriptTarget.Latest, true);
+    sf = ts24.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts24.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts23.isCallExpression(node) && ts23.isIdentifier(node.expression)) {
+    if (ts24.isCallExpression(node) && ts24.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -26817,7 +27340,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts23.forEachChild(node, visit3);
+    ts24.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -27559,6 +28082,7 @@ export {
   diffStaticBudget,
   diffProfiles,
   describeFallback,
+  derivesScopeFromSlot,
   decideClientOnlyElision,
   dangerousInnerHtmlMetacharViolation,
   dangerousInnerHtmlDiagnostic,