@barefootjs/cli 0.26.4 → 0.28.0

package/dist/index.js

@@ -3926,6 +3926,10 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
       return escapeHtml(node.value);
     case "expression": {
       if (node.expr === "null" || node.expr === "undefined") return "";
+      if (node.markerless) {
+        const bare = wrapInterpolation(wrapExpr(node.expr));
+        return `\${${bare}}`;
+      }
       const inner = wrapInterpolation(wrapExpr(node.expr));
       const valueExpr = node.joinArrayChild ? `Array.isArray(${inner}) ? ${inner}.join('') : (${inner} ?? '')` : inner;
       if (node.slotId) {
@@ -4741,7 +4745,7 @@ function generateCsrTemplateWithOpts(node, opts) {
     case "expression":
       if (node.expr === "null" || node.expr === "undefined") return "";
       if (node.clientOnly && node.slotId) {
-        return `<!--bf-client:${node.slotId}--><!--/-->`;
+        return `<!--bf:${node.slotId}--><!--/-->`;
       }
       {
         const transformed = transformExpr(node.expr, node.templateExpr);
@@ -11157,7 +11161,8 @@ function transformConditionalBranch(node, ctx2) {
   const callsReactive = exprCallsReactiveGetters(node, ctx2);
   const hasCalls = exprHasFunctionCalls(node);
   const reactive = isReactiveExpression(exprText, ctx2, node) || isReactiveOrigin(branchOrigin);
-  const needsSlot = reactive || callsReactive;
+  const refsLoopParam = branchOrigin.freeRefs?.some((r2) => r2.kind === "render-item") ?? false;
+  const needsSlot = reactive || callsReactive || refsLoopParam;
   const slotId = needsSlot ? generateSlotId(ctx2) : null;
   return {
     type: "expression",
@@ -14323,7 +14328,11 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
     },
     expression: ({ node: ex, scope: inCond }) => {
       if (ex.clientOnly && ex.slotId) {
-        ctx2.clientOnlyElements.push({ slotId: ex.slotId, expression: ex.expr });
+        ctx2.clientOnlyElements.push({
+          slotId: ex.slotId,
+          expression: ex.expr,
+          elidedPath: ex.markerless ? ex.elidedPath : void 0
+        });
         return;
       }
       if (!ex.slotId || inCond) return;
@@ -14753,19 +14762,54 @@ function summarizeLoopChildBranch(node, ctx2, siblingOffsets, loopParam, loopPar
     // on the branch root yields exactly this branch's direct bindings
     // without re-collecting what a nested arm already owns (#2347).
     reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, true),
-    // Skip when the branch's ENTIRE content is a single bare `expression`
-    // (no wrapping element) — e.g. a hoisted `renderNode={(n) => <Pill/>}`
-    // callback (#1211/#1213). That value is already fully re-evaluated and
-    // spliced via `__bfSlot` whenever `insert()` (re-)mounts this branch;
-    // an *additional* nested createEffect for the same expression re-calls
-    // it and creates a second, independent live element (a JSX-callback
-    // result isn't idempotent to re-invoke the way a plain signal read is),
-    // and the loop-child arm's `$t()`-based anchor lookup — designed for
-    // text nodes — doesn't cleanly displace an already-mounted Element,
-    // so the second instance lands beside the first instead of replacing
-    // it. A text *nested inside* a static wrapper element in the branch
-    // (the element-descent case) is unaffected and still collected below.
-    reactiveTexts: node.type === "expression" ? [] : collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, true)
+    // Skip ONLY when the branch's entire content is a single bare
+    // `expression` (no wrapping element) that MAY yield a live DOM node —
+    // i.e. it contains a call anywhere (`node.hasFunctionCalls`, computed
+    // by the AST walk in `exprHasFunctionCalls`/jsx-to-ir.ts, recursively —
+    // catches a call nested in a template literal or a nested ternary, not
+    // just a top-level call). A call can return an Element (a hoisted
+    // `renderNode={(n) => <Pill/>}` callback lowered to a component call,
+    // #1211/#1213) and the compiler cannot tell from syntax whether it does
+    // — both `renderChild(...)` and `_p.renderCell(...)` are a
+    // `CallExpression` — so this stays conservative for ANY call, not just
+    // ones known to return JSX. Re-evaluating a non-idempotent call inside
+    // an *additional* nested createEffect (on top of the eval already done
+    // for the `__bfSlot`-wrapped splice whenever `insert()` (re-)mounts this
+    // branch) would call it again on every unrelated tick and discard the
+    // previous element's listeners/state.
+    //
+    // Everything else — a property access (`row.label`), an identifier, a
+    // literal, a template literal, string concatenation, or a nested
+    // ternary of those — cannot itself construct a DOM node (only a JSX
+    // literal or a call can, and a JSX literal branch is never `type:
+    // 'expression'` in the first place — see `transformJsxExpression`), so
+    // it is safe to collect. This is the fix for the loop-branch-stale-text
+    // defect: a keyed loop row whose branch is e.g. `row.done ? row.label :
+    // 'pending'` previously had NO update path at all when `row.label`
+    // changed without `row.done` flipping — `insert()` (runtime/insert.ts)
+    // correctly no-ops when its condition is unchanged (branch-internal
+    // updates are deliberately the effect system's job, not DOM
+    // replacement's), but with reactiveTexts always `[]` for this shape,
+    // no effect existed either, so the branch was frozen at its mount-time
+    // value. The stale rationale in a prior version of this comment blamed
+    // "the loop-child arm's `$t()`-based anchor lookup", but `$t()` no
+    // longer exists — it was one of four content mechanisms deleted by the
+    // slot-unification work. The current claim door
+    // (`stringifyLoopChildArm` → `lazySlots(..., kind: 'markup')` →
+    // `writeMarkup`, runtime/claim-slots.ts) clears the claimed range and
+    // splices the Node by identity, so "lands beside the first" cannot
+    // happen through it; only the call's non-idempotence still applies, and
+    // that alone is why the skip narrows rather than disappears.
+    //
+    // Collecting here is necessary but not sufficient: `n.slotId` must also
+    // be set for `collectLoopChildReactiveTexts` (ir-to-client-js/
+    // reactivity.ts) to do anything — see `transformConditionalBranch`'s
+    // `refsLoopParam` check (jsx-to-ir.ts) for the matching half of this fix
+    // that gives a bare loop-item-reading branch a slotId at all, which also
+    // makes `irToHtmlTemplate` emit its `<!--bf:sN-->…<!--/-->` marker (the
+    // same call builds both the SSR and the CSR/hydration template, so the
+    // two can't disagree on shape).
+    reactiveTexts: node.type === "expression" && node.hasFunctionCalls ? [] : collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, true)
   };
 }
 var EMPTY_RENDER_EXPRS, branchInnerLoopOptions;
@@ -15327,13 +15371,12 @@ var init_imports = __esm({
       "onMount",
       "hydrate",
       "insert",
-      "reconcileElements",
       "getLoopChildren",
       "getLoopNodes",
       "mapArray",
       "mapArrayAnchored",
+      "mapArrayLazy",
       "patchLeaf",
-      "patchSlotRange",
       "createDisposableEffect",
       "createComponent",
       "renderChild",
@@ -15341,7 +15384,6 @@ var init_imports = __esm({
       "registerTemplate",
       "initChild",
       "upsertChild",
-      "updateClientMarker",
       "createPortal",
       "provideContext",
       "createContext",
@@ -15353,6 +15395,7 @@ var init_imports = __esm({
       "styleToCss",
       "escapeAttr",
       "escapeText",
+      "escapeTextOrNode",
       "qsa",
       "qsaItem",
       "qsaChildScope",
@@ -15361,7 +15404,19 @@ var init_imports = __esm({
       "__slot",
       "__bfSlot",
       "__bfText",
-      "tAfter",
+      // Claim-plan interpreter (slot unification A2/A3, spec/slot-unification.md)
+      // — the "one claim mechanism" that replaced `patchSlotRange` and
+      // `updateClientMarker` (both deleted) as the content-slot update door.
+      // `lazyClaimSlots` is the read-capable twin of `lazySlots` over the same
+      // claim — emitted only by lazy loops that seed an outer-involving TEXT
+      // binding by read-compare-write (§9.3(1)).
+      // `textOrNode` is the 'text' door's Node guard: a child-position value that
+      // turns out to be a live Node must reach the writer as a Node so the claim
+      // can promote to 'markup', never as `String(node)`.
+      "claimSlots",
+      "lazySlots",
+      "lazyClaimSlots",
+      "textOrNode",
       // Profile mode (#1690, SR3) — turn-boundary markers around event handlers.
       "beginTurn",
       "endTurn",
@@ -18484,8 +18539,340 @@ var init_build_event_delegation = __esm({
   }
 });
 
+// ../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
+function lazyRowEligibility(args2) {
+  const { shape, bindings, arraySourceIdentifiers, scope } = args2;
+  if (scope.profile) return NO("profile mode keeps the granular eager emission");
+  if (shape.callSite !== "plain" && shape.callSite !== "branch-plain") {
+    return NO(`call site '${shape.callSite}' is not a plain loop row`);
+  }
+  if (shape.flatMapLeafItem) return NO("flatMap descriptor loop (build-or-patch renderItem)");
+  if (shape.anchored) return NO("anchored whole-item-conditional loop");
+  if (shape.bodyIsMultiRoot) return NO("multi-root (Fragment) row");
+  if (!shape.hasExplicitKey) return NO("index-keyed loop (no explicit key)");
+  if (shape.conditionalCount > 0) return NO("row contains a reactive conditional");
+  if (shape.childRefCount > 0) return NO("row has imperative child refs");
+  if (shape.hasChildComponent) return NO("row body is a child component");
+  if (shape.nestedComponentCount > 0) return NO("row contains nested child components");
+  if (shape.innerLoopCount > 0) return NO("row contains an inner loop");
+  if (shape.hasMapPreamble) return NO("row has a map-callback preamble (may declare row-local reactivity)");
+  if (shape.preambleRegionCount > 0) return NO("row has preamble-patched regions");
+  if (shape.hasParamUnwrap) return NO("destructured loop param without param bindings");
+  for (const b of bindings) {
+    if (b.referencesIndex) {
+      return NO(`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`);
+    }
+  }
+  if (!arraySourceIdentifiers) return NO("loop source free identifiers unavailable");
+  const sourceGate = checkSourceConsistency(arraySourceIdentifiers, scope);
+  if (sourceGate) return NO(`loop source is not provably hydration-consistent: ${sourceGate}`);
+  return { eligible: true };
+}
+function checkSourceConsistency(names, scope) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolve12 = (name2) => {
+    if (seen.has(name2)) return null;
+    seen.add(name2);
+    if (scope.props.has(name2)) return null;
+    if (PURE_SOURCE_GLOBALS.has(name2)) return null;
+    const constFree = scope.constants.get(name2);
+    if (constFree !== void 0) {
+      if (constFree === null) return `constant '${name2}' has no analyzable value`;
+      for (const inner of constFree) {
+        const failure = resolve12(inner);
+        if (failure) return failure;
+      }
+      return null;
+    }
+    const signal2 = scope.signals.get(name2);
+    if (signal2 !== void 0) {
+      if (signal2.initializerFreeIdentifiers === null) {
+        return `signal '${name2}' has no structured initializer to prove props/literal derivation`;
+      }
+      for (const inner of signal2.initializerFreeIdentifiers) {
+        const failure = resolve12(inner);
+        if (failure) return failure;
+      }
+      return null;
+    }
+    if (scope.memos.has(name2)) return `memo '${name2}' initializer is not analyzed by the v1 gate`;
+    if (scope.inert.has(name2)) return `'${name2}' is an import or local function`;
+    return `'${name2}' does not resolve to a prop, literal-derived const, or props/literal-derived signal`;
+  };
+  for (const name2 of names) {
+    const failure = resolve12(name2);
+    if (failure) return failure;
+  }
+  return null;
+}
+function classifyLazyBinding(args2) {
+  const { kind: kind2, slotId, free, rowLocalNames, indexParam, scope } = args2;
+  if (free === null) {
+    return {
+      kind: kind2,
+      slotId,
+      readsItem: true,
+      readsOuter: true,
+      reactiveOuterNames: [],
+      opaqueOuterNames: [UNKNOWN_IDENTIFIERS],
+      // An ASSUMPTION, not knowledge — which is precisely why
+      // `UNKNOWN_IDENTIFIERS` must keep refusing the loop: with no
+      // identifier set we cannot rule out an index read either, and
+      // `applyItem` / `applyOuter` have no index parameter to give it.
+      referencesIndex: false
+    };
+  }
+  let readsItem = false;
+  let referencesIndex = false;
+  const reactiveOuterNames = [];
+  const opaqueOuterNames = [];
+  for (const name2 of free) {
+    if (rowLocalNames.has(name2)) {
+      readsItem = true;
+      continue;
+    }
+    if (name2 === indexParam) {
+      referencesIndex = true;
+      continue;
+    }
+    if (INERT_BINDING_GLOBALS.has(name2)) continue;
+    if (scope.signals.has(name2) || scope.memos.has(name2)) {
+      if (!reactiveOuterNames.includes(name2)) reactiveOuterNames.push(name2);
+      continue;
+    }
+    const constFree = scope.constants.get(name2);
+    if (constFree !== void 0 && constFree !== null && constFree.size === 0) continue;
+    opaqueOuterNames.push(name2);
+  }
+  return {
+    kind: kind2,
+    slotId,
+    readsItem,
+    readsOuter: reactiveOuterNames.length > 0 || opaqueOuterNames.length > 0,
+    reactiveOuterNames,
+    opaqueOuterNames,
+    referencesIndex
+  };
+}
+var PURE_SOURCE_GLOBALS, INERT_BINDING_GLOBALS, UNKNOWN_IDENTIFIERS, NO;
+var init_lazy_row_eligibility = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts"() {
+    "use strict";
+    PURE_SOURCE_GLOBALS = /* @__PURE__ */ new Set([
+      "Object",
+      "Array",
+      "JSON",
+      "Number",
+      "String",
+      "Boolean"
+    ]);
+    INERT_BINDING_GLOBALS = /* @__PURE__ */ new Set([
+      "Object",
+      "Array",
+      "JSON",
+      "Number",
+      "String",
+      "Boolean",
+      "Math",
+      "Date",
+      "Intl",
+      "Symbol",
+      "Map",
+      "Set",
+      "WeakMap",
+      "WeakSet",
+      "Promise",
+      "RegExp",
+      "Error",
+      "BigInt",
+      "console",
+      "undefined",
+      "NaN",
+      "Infinity",
+      "globalThis",
+      "parseInt",
+      "parseFloat",
+      "isNaN",
+      "isFinite",
+      "encodeURIComponent",
+      "decodeURIComponent",
+      "encodeURI",
+      "decodeURI"
+    ]);
+    UNKNOWN_IDENTIFIERS = "<unknown>";
+    NO = (reason2) => ({ eligible: false, reason: reason2 });
+  }
+});
+
+// ../jsx/src/ir-to-client-js/control-flow/plan/build-lazy-row.ts
+function buildLazyRowPlan(args2) {
+  return decideLazyRow(args2).plan;
+}
+function decideLazyRow(args2) {
+  const { loop, scope } = args2;
+  if (!scope) {
+    return { plan: null, decision: { eligible: false, reason: "no component scope info supplied" } };
+  }
+  const wrap = (expr) => wrapLoopParamAsAccessor(expr, loop.param, loop.paramBindings);
+  const rowLocalNames = /* @__PURE__ */ new Set([loop.param]);
+  for (const b of loop.paramBindings ?? []) rowLocalNames.add(b.name);
+  const classified = [];
+  const attrClass = /* @__PURE__ */ new Map();
+  loop.bindings.reactiveAttrs.forEach((attr, i) => {
+    const c = classifyLazyBinding({
+      kind: "attr",
+      slotId: attr.childSlotId,
+      free: attrFreeIdentifiers2(attr.expression),
+      rowLocalNames,
+      indexParam: args2.indexParam,
+      scope
+    });
+    attrClass.set(i, c);
+    classified.push(c);
+  });
+  const textClass = /* @__PURE__ */ new Map();
+  loop.bindings.reactiveTexts.forEach((text, i) => {
+    const c = classifyLazyBinding({
+      kind: "text",
+      slotId: text.slotId,
+      free: text.freeIdentifiers ?? null,
+      rowLocalNames,
+      indexParam: args2.indexParam,
+      scope
+    });
+    textClass.set(i, c);
+    classified.push(c);
+  });
+  const shape = {
+    callSite: args2.callSite,
+    flatMapLeafItem: args2.flatMapLeafItem,
+    anchored: args2.anchored,
+    bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
+    hasExplicitKey: loop.key != null,
+    conditionalCount: loop.bindings.conditionals?.length ?? 0,
+    childRefCount: loop.bindings.refs?.length ?? 0,
+    nestedComponentCount: loop.nestedComponents?.length ?? 0,
+    innerLoopCount: loop.innerLoops?.length ?? 0,
+    hasChildComponent: "childComponent" in loop && loop.childComponent != null,
+    hasMapPreamble: args2.mapPreambleWrapped.length > 0,
+    preambleRegionCount: args2.preambleRegionCount,
+    hasParamUnwrap: args2.paramUnwrap.length > 0
+  };
+  const decision = lazyRowEligibility({
+    shape,
+    bindings: classified,
+    arraySourceIdentifiers: loopSourceIdentifiers(loop, args2.arrayExpr),
+    scope
+  });
+  if (!decision.eligible) return { plan: null, decision };
+  const attrSlotIds = [];
+  for (const attr of loop.bindings.reactiveAttrs) {
+    if (!attrSlotIds.includes(attr.childSlotId)) attrSlotIds.push(attr.childSlotId);
+  }
+  let ordinal = 0;
+  const attrs = loop.bindings.reactiveAttrs.map((attr, i) => {
+    const c = attrClass.get(i);
+    return {
+      slotId: attr.childSlotId,
+      attrName: attr.attrName,
+      wrappedExpression: wrap(attr.expression),
+      meta: pickAttrMeta(attr),
+      refIndex: attrSlotIds.indexOf(attr.childSlotId),
+      ordinal: ordinal++,
+      readsItem: c.readsItem,
+      readsOuter: c.readsOuter
+    };
+  });
+  const texts = loop.bindings.reactiveTexts.map((text, i) => {
+    const c = textClass.get(i);
+    return {
+      slotId: text.slotId,
+      wrappedExpression: wrap(text.expression),
+      ordinal: ordinal++,
+      // A text that classified as NEITHER item- nor outer-driven still gets
+      // applied on item change (harmless, dedup-guarded) rather than
+      // silently never being written. Anything the classifier did place in
+      // a list keeps exactly the classifier's answer.
+      readsItem: c.readsItem || !c.readsOuter,
+      readsOuter: c.readsOuter
+    };
+  });
+  const outerPrimeGetters = [];
+  for (const c of classified) {
+    for (const name2 of c.reactiveOuterNames) {
+      if (!outerPrimeGetters.includes(name2)) outerPrimeGetters.push(name2);
+    }
+  }
+  return {
+    plan: {
+      attrSlotIds,
+      attrs,
+      texts,
+      writerIndex: texts.length > 0 ? attrSlotIds.length : -1,
+      textNeedsRead: texts.some((t) => t.readsOuter),
+      lastCount: ordinal,
+      outerPrimeGetters,
+      hasOuter: attrs.some((a) => a.readsOuter) || texts.some((t) => t.readsOuter)
+    },
+    decision
+  };
+}
+function buildLazyRowScopeInfo(ctx2) {
+  const signals = /* @__PURE__ */ new Map();
+  for (const s of ctx2.signals) {
+    signals.set(s.getter, {
+      // `parsed` is the analyzer's structured initializer. Absent (or
+      // refused by `freeIdentifiers`) ⇒ unprovable, which the source gate
+      // treats as a hard stop rather than an assumption.
+      initializerFreeIdentifiers: s.parsed ? freeIdentifiers(s.parsed) : null
+    });
+  }
+  const memos = new Set(ctx2.memos.map((m) => m.name));
+  const props = /* @__PURE__ */ new Set([PROPS_PARAM]);
+  if (ctx2.propsObjectName) props.add(ctx2.propsObjectName);
+  for (const p of ctx2.propsParams) props.add(p.name);
+  const constants = /* @__PURE__ */ new Map();
+  for (const c of ctx2.localConstants) {
+    constants.set(c.name, c.freeIdentifiers ?? null);
+  }
+  const inert = /* @__PURE__ */ new Set();
+  for (const f of ctx2.localFunctions) inert.add(f.name);
+  for (const imp of ctx2.imports) {
+    if (imp.isTypeOnly) continue;
+    for (const spec of imp.specifiers) inert.add(spec.alias || spec.name);
+  }
+  return { signals, memos, props, constants, inert, profile: ctx2.profile };
+}
+function attrFreeIdentifiers2(expression) {
+  if (!expression || expression.trim().length === 0) return /* @__PURE__ */ new Set();
+  try {
+    return freeIdentifiers(parseExpression(expression));
+  } catch {
+    return null;
+  }
+}
+function loopSourceIdentifiers(loop, arrayExpr) {
+  if (!loop.arrayFreeIdentifiers) return null;
+  const names = new Set(loop.arrayFreeIdentifiers);
+  for (const name2 of extractFreeIdentifiersFromText(arrayExpr)) names.add(name2);
+  return names;
+}
+var init_build_lazy_row = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/plan/build-lazy-row.ts"() {
+    "use strict";
+    init_expression_parser();
+    init_types();
+    init_csr_substitute();
+    init_utils();
+    init_lazy_row_eligibility();
+  }
+});
+
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-branch-loop.ts
-function buildBranchLoopPlan(loop, profileComponentName) {
+function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
   const containerSlotId = loop.containerSlotId;
   const cv = varSlotId(containerSlotId);
   const containerVar = `__loop_${cv}`;
@@ -18501,6 +18888,13 @@ function buildBranchLoopPlan(loop, profileComponentName) {
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(loop.param, loop.paramBindings);
   const hasReactiveEffects = loop.bindings.reactiveAttrs.length > 0 || loop.bindings.reactiveTexts.length > 0 || loop.bindings.conditionals.length > 0;
   const fm = loop.flatMapClient;
+  const arrayExpr = fm ? `(${buildChainedArrayExpr(loop)}).flatMap(${fm.params} => ${fm.body})` : buildChainedArrayExpr(loop);
+  const indexParam = loop.index || "__idx";
+  const mapPreambleWrapped = loop.preamble ? renderPreamble(loop.preamble, {
+    transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
+    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0, true)
+  }) : "";
+  const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings);
   const plan = {
     kind: "plain",
     rowConstruction: "string-template",
@@ -18508,17 +18902,27 @@ function buildBranchLoopPlan(loop, profileComponentName) {
     containerVar,
     markerId: loop.markerId,
     flatMapLeafItem: fm ? true : void 0,
-    arrayExpr: fm ? `(${buildChainedArrayExpr(loop)}).flatMap(${fm.params} => ${fm.body})` : buildChainedArrayExpr(loop),
+    arrayExpr,
     keyFn: fm ? fm.keyed ? "(__bfD, __bfI) => String(__bfD.k ?? __bfI)" : "null" : loopKeyFn(loop),
     paramHead,
     paramUnwrap,
-    indexParam: loop.index || "__idx",
+    indexParam,
     // Wrap loop-param references to signal-accessor form so the preamble
     // matches the template literal's already-wrapped reads (#1065).
-    mapPreambleWrapped: loop.preamble ? renderPreamble(loop.preamble, {
-      transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0, true)
-    }) : "",
+    mapPreambleWrapped,
+    // Lazy row graph (§9, L3) — undefined for every ineligible loop.
+    lazyRow: buildLazyRowPlan({
+      loop,
+      arrayExpr,
+      indexParam,
+      paramUnwrap,
+      mapPreambleWrapped,
+      preambleRegionCount: preambleRegions.length,
+      callSite: "branch-plain",
+      flatMapLeafItem: Boolean(fm),
+      anchored: false,
+      scope: lazyScope
+    }) ?? void 0,
     template: loop.template,
     reactiveEffects: hasReactiveEffects ? buildReactiveEffectsPlan({
       attrs: loop.bindings.reactiveAttrs,
@@ -18530,7 +18934,7 @@ function buildBranchLoopPlan(loop, profileComponentName) {
     }) : null,
     eventDelegation: buildBranchLoopDelegationPlan(loop, cv, profileComponentName),
     childRefs: buildChildRefBindings(loop.bindings.refs, loop.param, loop.paramBindings),
-    preambleRegions: buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings),
+    preambleRegions,
     bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
     profileLoopId: profileComponentName ? `${profileComponentName}#binding:${containerSlotId}` : void 0
   };
@@ -18543,6 +18947,7 @@ var init_build_branch_loop = __esm({
     init_build_composite_loop();
     init_build_event_delegation();
     init_build_reactive_effects();
+    init_build_lazy_row();
     init_shared();
     init_html_template();
   }
@@ -18599,13 +19004,13 @@ function buildArmBody(branch, options2) {
       expression: t.expression
     })),
     // Branch-scoped loops, fully Plan-built (Item 2 final migration).
-    loops: branch.loops.map((l) => buildBranchLoopPlan(l, pc)),
+    loops: branch.loops.map((l) => buildBranchLoopPlan(l, pc, options2.lazyScope)),
     // Nested conditionals are themselves InsertPlans — built recursively so
     // the same stringifier handles arbitrary depth. Their scope is always
     // `__branchScope` (the parent arm's bindEvents argument), regardless of
     // the outer scope; only the eventNameMode is inherited.
     conditionals: branch.conditionals.map(
-      (c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options2.eventNameMode, profileComponentName: pc })
+      (c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options2.eventNameMode, profileComponentName: pc, lazyScope: options2.lazyScope })
     )
   };
 }
@@ -18617,6 +19022,25 @@ var init_build_insert = __esm({
   }
 });
 
+// ../jsx/src/ir-to-client-js/control-flow/stringify/claim-plan.ts
+function slotSpecLiteral(slot) {
+  const pathSrc = slot.pathExpr ?? `[${slot.path.join(", ")}]`;
+  const markerlessSrc = slot.markerless ? ", markerless: true" : "";
+  return `{ id: '${slot.id}', kind: '${slot.kind}', path: ${pathSrc}${markerlessSrc} }`;
+}
+function claimPlanLiteral(slots) {
+  return `[${slots.map(slotSpecLiteral).join(", ")}]`;
+}
+function claimWriterVarName(slots, sanitize) {
+  const first = slots[0]?.id ?? "0";
+  return `__bfw_${sanitize(first)}`;
+}
+var init_claim_plan = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/stringify/claim-plan.ts"() {
+    "use strict";
+  }
+});
+
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
 import ts14 from "typescript";
 function bindingIdArg(ctx2, slotId) {
@@ -18795,17 +19219,18 @@ function emitDynamicTextUpdates(lines, ctx2) {
     const conditionalElems = elems.filter((e) => e.insideConditional);
     const normalElems = elems.filter((e) => !e.insideConditional);
     if (normalElems.length > 0 || conditionalElems.length > 0) {
-      for (const elem of normalElems) {
-        const v = varSlotId(elem.slotId);
-        lines.push(`  let __anchor_${v} = _${v}`);
-      }
       const __textSlot = (normalElems[0] ?? conditionalElems[0])?.slotId;
+      let writer = "";
+      if (normalElems.length > 0) {
+        const slots = normalElems.map((elem) => ({ id: elem.slotId, kind: "markup", path: [] }));
+        writer = claimWriterVarName(slots, varSlotId);
+        lines.push(`  const ${writer} = lazySlots(__scope, ${claimPlanLiteral(slots)})`);
+      }
       lines.push(`  createEffect(() => {`);
       if (normalElems.length > 0) {
         lines.push(`    const __val = ${expr}`);
         for (const elem of normalElems) {
-          const v = varSlotId(elem.slotId);
-          lines.push(`    __anchor_${v} = __bfText(__anchor_${v}, __val)`);
+          lines.push(`    ${writer}('${elem.slotId}', escapeTextOrNode(__val))`);
         }
         for (const elem of conditionalElems) {
           const v = varSlotId(elem.slotId);
@@ -18828,10 +19253,13 @@ function emitDynamicTextUpdates(lines, ctx2) {
 }
 function emitClientOnlyExpressions(lines, ctx2) {
   for (const elem of ctx2.clientOnlyElements) {
+    const slots = elem.elidedPath ? [{ id: elem.slotId, kind: "text", path: elem.elidedPath, markerless: true }] : [{ id: elem.slotId, kind: "text", path: [] }];
+    const writer = claimWriterVarName(slots, varSlotId);
     lines.push(`  // @client: ${elem.slotId}`);
+    lines.push(`  { const ${writer} = lazySlots(__scope, ${claimPlanLiteral(slots)})`);
     lines.push(`  createEffect(() => {`);
-    lines.push(`    updateClientMarker(__scope, '${elem.slotId}', ${elem.expression})`);
-    lines.push(`  }${bindingIdArg(ctx2, elem.slotId)})`);
+    lines.push(`    ${writer}('${elem.slotId}', ${elem.expression})`);
+    lines.push(`  }${bindingIdArg(ctx2, elem.slotId)}) }`);
     lines.push("");
   }
 }
@@ -18939,6 +19367,7 @@ var init_emit_reactive = __esm({
     "use strict";
     init_html_constants();
     init_utils();
+    init_claim_plan();
     init_html_template();
     init_date_lowering();
     init_to_locale_date_lowering();
@@ -18974,7 +19403,7 @@ function stringifyBranchEventBindings(lines, plan, indent) {
 }
 function stringifyBranchChildComponentInits(lines, plan, indent) {
   for (const init of plan) {
-    lines.push(`${indent}{ let __c = qsa(__branchScope, ${init.selector}); if (!__c) { const __ph = __branchScope.querySelector('[${BF_PLACEHOLDER}="${init.placeholderId}"]'); if (__ph) { __c = createComponent('${nameForRegistryRef(init.name)}', ${init.propsExpr}); __ph.replaceWith(__c) } } if (__c) initChild('${nameForRegistryRef(init.name)}', __c, ${init.propsExpr}) }`);
+    lines.push(`${indent}{ let __c = qsa(__branchScope, ${init.selector}); if (!__c) { const __ph = __branchScope.querySelector('[${BF_PLACEHOLDER}="${init.placeholderId}"]'); if (__ph) { __c = createComponent('${nameForRegistryRef(init.name)}', ${init.propsExpr}, undefined, undefined, __ph) } } if (__c) initChild('${nameForRegistryRef(init.name)}', __c, ${init.propsExpr}) }`);
   }
 }
 function stringifyBranchInnerLoops(lines, plan, indent, pc) {
@@ -19008,13 +19437,18 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
         inner.outerLoopParamBindings
       );
     }
-    for (const text of inner.reactiveTexts) {
+    const conditionalTexts = inner.reactiveTexts.filter((t) => t.insideConditional);
+    const plainTexts = inner.reactiveTexts.filter((t) => !t.insideConditional);
+    for (const text of conditionalTexts) {
       const bf = profileBindingId(pc, text.slotId);
-      if (text.insideConditional) {
-        lines.push(`${indent}  createEffect(() => { const [__rt] = $t(__bel${uid}, '${text.slotId}'); if (__rt) __rt.textContent = String(${text.wrappedExpression}) }${bf})`);
-      } else {
-        lines.push(`${indent}  { const [__rt] = $t(__bel${uid}, '${text.slotId}')`);
-        lines.push(`${indent}  if (__rt) createEffect(() => { __rt.textContent = String(${text.wrappedExpression}) }${bf}) }`);
+      lines.push(`${indent}  createEffect(() => { claimSlots(__bel${uid}, [{ id: '${text.slotId}', kind: 'text', path: [] }]).write('${text.slotId}', String(${text.wrappedExpression})) }${bf})`);
+    }
+    if (plainTexts.length > 0) {
+      const slots = plainTexts.map((t) => ({ id: t.slotId, kind: "text", path: [] }));
+      const writer = claimWriterVarName(slots, varSlotId);
+      lines.push(`${indent}  const ${writer} = lazySlots(__bel${uid}, ${claimPlanLiteral(slots)})`);
+      for (const text of plainTexts) {
+        lines.push(`${indent}  createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${profileBindingId(pc, text.slotId)})`);
       }
     }
     if (inner.nestedConditionals.length > 0) {
@@ -19056,10 +19490,13 @@ function stringifyLoopChildArm(lines, arm, armIndent, pc) {
     stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc);
     lines.push(`${armIndent}}))`);
   }
-  for (const text of arm.texts) {
-    const varName = `__rt_${varSlotId(text.slotId)}`;
-    lines.push(`${armIndent}let ${varName} = $t(__branchScope, '${text.slotId}')[0]`);
-    lines.push(`${armIndent}__disposers.push(createDisposableEffect(() => { ${varName} = __bfText(${varName}, ${text.wrappedExpression}) }${profileBindingId(pc, text.slotId)}))`);
+  if (arm.texts.length > 0) {
+    const slots = arm.texts.map((t) => ({ id: t.slotId, kind: "markup", path: [] }));
+    const writer = claimWriterVarName(slots, varSlotId);
+    lines.push(`${armIndent}const ${writer} = lazySlots(__branchScope, ${claimPlanLiteral(slots)})`);
+    for (const text of arm.texts) {
+      lines.push(`${armIndent}__disposers.push(createDisposableEffect(() => { ${writer}('${text.slotId}', escapeTextOrNode(${text.wrappedExpression})) }${profileBindingId(pc, text.slotId)}))`);
+    }
   }
   lines.push(`${armIndent}return () => __disposers.forEach(d => d())`);
 }
@@ -19072,19 +19509,45 @@ var init_loop_child_arm = __esm({
     init_template_parse();
     init_event_listener();
     init_component_scope();
+    init_claim_plan();
   }
 });
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/reactive-effects.ts
 function stringifyReactiveEffects(lines, plan, opts) {
-  const { indent, elVar, bodyIsMultiRoot, elementIndexBySlot, textIndexBySlot } = opts;
+  const { indent, elVar, bodyIsMultiRoot, elementIndexBySlot, textClaimPathExprs, preambleRegions = [], mapPreambleWrapped } = opts;
   const lookup = bodyIsMultiRoot ? "qsaItem" : "qsa";
-  const pc = plan.profileComponentName;
+  const pc = plan?.profileComponentName;
   const bindingBfId = (slotId) => profileBindingId(pc, slotId);
-  for (const slot of plan.attrSlots) {
+  const attrSlots = plan?.attrSlots ?? [];
+  const outerTexts = plan?.outerTexts ?? [];
+  const conditionals = plan?.conditionals ?? [];
+  if (pc) {
+    emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId);
+    emitOuterTexts(lines, indent, elVar, outerTexts, bindingBfId, textClaimPathExprs);
+    emitPreambleRegionsEffect(lines, indent, elVar, preambleRegions, mapPreambleWrapped);
+  } else {
+    emitConsolidatedRowEffect(
+      lines,
+      indent,
+      elVar,
+      lookup,
+      attrSlots,
+      outerTexts,
+      elementIndexBySlot,
+      textClaimPathExprs,
+      preambleRegions,
+      mapPreambleWrapped
+    );
+  }
+  for (const cond of conditionals) {
+    emitOuterConditional(lines, indent, elVar, cond, pc);
+  }
+}
+function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId) {
+  for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
-    const pIdx = elementIndexBySlot?.get(slot.slotId);
-    const lookupExpr = pIdx !== void 0 ? `__p ? __p[${pIdx}] : ${lookup}(${elVar}, '[bf="${slot.slotId}"]')` : `${lookup}(${elVar}, '[bf="${slot.slotId}"]')`;
+    const lookupExpr = attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot);
     lines.push(`${indent}{ const ${varName} = ${lookupExpr}`);
     lines.push(`${indent}if (${varName}) {`);
     for (const attr of slot.attrs) {
@@ -19096,21 +19559,79 @@ function stringifyReactiveEffects(lines, plan, opts) {
     }
     lines.push(`${indent}} }`);
   }
-  for (const text of plan.outerTexts) {
-    emitOuterText(lines, indent, elVar, text, bindingBfId(text.slotId), textIndexBySlot?.get(text.slotId));
+}
+function emitPreambleRegionsEffect(lines, indent, elVar, preambleRegions, mapPreambleWrapped) {
+  if (preambleRegions.length === 0) return;
+  const slots = preambleRegions.map((r2) => ({ id: r2.slotId, kind: "markup", path: [] }));
+  const writer = claimWriterVarName(slots, varSlotId);
+  lines.push(`${indent}const ${writer} = lazySlots(${elVar}, ${claimPlanLiteral(slots)})`);
+  lines.push(`${indent}createEffect(() => {`);
+  if (mapPreambleWrapped) lines.push(`${indent}  ${mapPreambleWrapped}`);
+  for (const region of preambleRegions) {
+    lines.push(`${indent}  ${writer}('${region.slotId}', ${region.valueExpr})`);
   }
-  for (const cond of plan.conditionals) {
-    emitOuterConditional(lines, indent, elVar, cond, pc);
+  lines.push(`${indent}})`);
+}
+function attrLookupExpr(slotId, varName, elVar, lookup, elementIndexBySlot) {
+  const pIdx = elementIndexBySlot?.get(slotId);
+  return pIdx !== void 0 ? `__p ? __p[${pIdx}] : ${lookup}(${elVar}, '[bf="${slotId}"]')` : `${lookup}(${elVar}, '[bf="${slotId}"]')`;
+}
+function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, outerTexts, elementIndexBySlot, textClaimPathExprs, preambleRegions, mapPreambleWrapped) {
+  if (attrSlots.length === 0 && outerTexts.length === 0 && preambleRegions.length === 0) return;
+  for (const slot of attrSlots) {
+    const varName = `__ra_${varSlotId(slot.slotId)}`;
+    lines.push(`${indent}const ${varName} = ${attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot)}`);
   }
+  const claimSlots = [
+    ...outerTexts.map((t) => ({ id: t.slotId, kind: "text", path: [], pathExpr: textClaimPathExprs?.get(t.slotId) })),
+    ...preambleRegions.map((r2) => ({ id: r2.slotId, kind: "markup", path: [] }))
+  ];
+  const writer = claimSlots.length > 0 ? claimWriterVarName(claimSlots, varSlotId) : null;
+  if (writer) {
+    lines.push(`${indent}const ${writer} = lazySlots(${elVar}, ${claimPlanLiteral(claimSlots)})`);
+  }
+  if (attrSlots.length === 0 && preambleRegions.length === 0 && outerTexts.length === 1) {
+    const text = outerTexts[0];
+    lines.push(`${indent}createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) })`);
+    return;
+  }
+  lines.push(`${indent}createEffect(() => {`);
+  for (const slot of attrSlots) {
+    const varName = `__ra_${varSlotId(slot.slotId)}`;
+    lines.push(`${indent}  if (${varName}) {`);
+    for (const attr of slot.attrs) {
+      lines.push(`${indent}    {`);
+      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+        lines.push(`${indent}      ${stmt}`);
+      }
+      lines.push(`${indent}    }`);
+    }
+    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}))`);
+  }
+  for (const region of preambleRegions) {
+    lines.push(`${indent}  ${writer}('${region.slotId}', ${region.valueExpr})`);
+  }
+  lines.push(`${indent}})`);
 }
-function emitOuterText(lines, indent, elVar, text, bfId = "", pIdx) {
-  const varName = `__rt_${varSlotId(text.slotId)}`;
-  if (pIdx !== void 0) {
-    lines.push(`${indent}{ const ${varName} = __p ? tAfter(__p[${pIdx}]) : $t(${elVar}, '${text.slotId}')[0]`);
-  } else {
-    lines.push(`${indent}{ const [${varName}] = $t(${elVar}, '${text.slotId}')`);
+function emitOuterTexts(lines, indent, elVar, texts, bindingBfId, textClaimPathExprs) {
+  if (texts.length === 0) return;
+  const slots = texts.map((t) => ({
+    id: t.slotId,
+    kind: "text",
+    path: [],
+    pathExpr: textClaimPathExprs?.get(t.slotId)
+  }));
+  const writer = claimWriterVarName(slots, varSlotId);
+  lines.push(`${indent}const ${writer} = lazySlots(${elVar}, ${claimPlanLiteral(slots)})`);
+  for (const text of texts) {
+    lines.push(`${indent}createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${bindingBfId(text.slotId)})`);
   }
-  lines.push(`${indent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${bfId}) }`);
 }
 function emitOuterConditional(lines, indent, elVar, cond, pc) {
   const armIndent = `${indent}    `;
@@ -19132,6 +19653,7 @@ var init_reactive_effects = __esm({
     init_utils();
     init_emit_reactive();
     init_loop_child_arm();
+    init_claim_plan();
   }
 });
 
@@ -19229,6 +19751,179 @@ var init_component_loop = __esm({
   }
 });
 
+// ../jsx/src/ir-to-client-js/control-flow/stringify/lazy-row.ts
+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 rwDoor = lazyRow.textNeedsRead;
+  const paths = o.skeletonPaths;
+  const useHoisted = Boolean(o.skeletonTemplate);
+  if (useHoisted) emitHoistedTemplateDecl(lines, indent, tplVar, o.skeletonTemplate);
+  const textPathVar = useHoisted && paths && lazyRow.texts.length > 0 ? `__lzp_${mid}` : null;
+  if (textPathVar) {
+    const arrays = lazyRow.texts.map((t) => `[${(paths.textMarkerPaths.get(t.slotId) ?? []).join(", ")}]`);
+    lines.push(`${indent}const ${textPathVar} = [${arrays.join(", ")}]`);
+  }
+  let adoptedPlanVar = null;
+  let freshPlanVar = null;
+  if (lazyRow.texts.length > 0) {
+    adoptedPlanVar = `__lzs_${mid}`;
+    const adoptedSlots = lazyRow.texts.map((t) => ({ id: t.slotId, kind: "text", path: [] }));
+    lines.push(`${indent}const ${adoptedPlanVar} = ${claimPlanLiteral(adoptedSlots)}`);
+    if (textPathVar) {
+      freshPlanVar = `__lzsc_${mid}`;
+      const freshSlots = lazyRow.texts.map((t, i) => ({
+        id: t.slotId,
+        kind: "text",
+        path: [],
+        pathExpr: `${textPathVar}[${i}]`
+      }));
+      lines.push(`${indent}const ${freshPlanVar} = ${claimPlanLiteral(freshSlots)}`);
+    } else {
+      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}}`);
+  }
+  const call = `mapArrayLazy(() => ${o.arrayExpr}, ${o.containerVar}, ${o.keyFn}, {`;
+  lines.push(`${indent}${o.guardContainer ? `if (${o.containerVar}) ` : ""}${call}`);
+  const b1 = `${indent}  `;
+  const b2 = `${indent}    `;
+  lines.push(`${b1}createRow: (__e, ${o.indexParam}) => {`);
+  lines.push(`${b2}const ${paramHead} = () => __e.item`);
+  const cloneExpr = useHoisted ? hoistedCloneExpr(tplVar, o.skeletonTemplate) : `(() => { ${emitTemplateCloneInline(o.template)} })()`;
+  lines.push(`${b2}const __el = ${cloneExpr}`);
+  if (hasRefs) {
+    lines.push(`${b2}const __r = __e.refs = [${refParts(lazyRow, "__el", useHoisted ? paths ?? null : null, freshPlanVar).join(", ")}]`);
+  }
+  if (hasBindings) {
+    lines.push(`${b2}const __l = __e.last = []`);
+    for (const a of lazyRow.attrs) emitAttrBinding(lines, b2, a, "create");
+    const createDoor = `__r[${lazyRow.writerIndex}]`;
+    for (const t of lazyRow.texts) emitTextBinding(lines, b2, t, createDoor, "create", rwDoor);
+  }
+  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) {
+    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 __l = __e.last ?? (__e.last = [])`);
+    for (const a of itemAttrs) emitAttrBinding(lines, b2, a, "item");
+    if (itemTexts.length > 0) {
+      lines.push(`${b2}const __d = ${doorAccess(lazyRow, lazyRow.writerIndex, adoptedPlanVar)}`);
+      for (const t of itemTexts) emitTextBinding(lines, b2, t, "__d", "item", rwDoor);
+    }
+    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 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 __l = __e.last ?? (__e.last = [])`);
+    for (const a of outerAttrs) emitAttrBinding(lines, b3, a, "outer");
+    if (outerTexts.length > 0) {
+      lines.push(`${b3}const __d = ${doorAccess(lazyRow, lazyRow.writerIndex, adoptedPlanVar)}`);
+      for (const t of outerTexts) emitTextBinding(lines, b3, t, "__d", "outer", rwDoor);
+    }
+    lines.push(`${b2}}`);
+    lines.push(`${b1}},`);
+  }
+  lines.push(`${indent}}, '${o.markerId}')`);
+}
+function refParts(lazyRow, elVar, skeletonPaths, planVar, deferDoor = false) {
+  const parts = [];
+  for (const slotId of lazyRow.attrSlotIds) {
+    const path25 = skeletonPaths?.elementPaths.get(slotId);
+    parts.push(path25 ? pathExpr(elVar, path25) : `qsa(${elVar}, '[bf="${slotId}"]')`);
+  }
+  if (lazyRow.texts.length > 0) {
+    parts.push(deferDoor ? "null" : `${doorCtor(lazyRow)}(${elVar}, ${planVar})`);
+  }
+  return parts;
+}
+function doorCtor(lazyRow) {
+  return lazyRow.textNeedsRead ? "lazyClaimSlots" : "lazySlots";
+}
+function doorAccess(lazyRow, writerIndex, adoptedPlanVar) {
+  const slot = `__r[${writerIndex}]`;
+  return `${slot} ?? (${slot} = ${doorCtor(lazyRow)}(__e.primaryEl, ${adoptedPlanVar}))`;
+}
+function dedupGuard(ordinal) {
+  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
+}
+function emitAttrBinding(lines, ind, a, mode2) {
+  lines.push(`${ind}{ const __t = __r[${a.refIndex}]`);
+  lines.push(`${ind}if (__t) {`);
+  lines.push(`${ind}  const __x = ${a.wrappedExpression}`);
+  const guard = mode2 === "create" ? null : mode2 === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
+  const writeIndent = guard ? `${ind}    ` : `${ind}  `;
+  if (guard) lines.push(`${ind}  if (${guard}) {`);
+  for (const stmt of emitAttrUpdate("__t", a.attrName, "__x", a.meta)) {
+    lines.push(`${writeIndent}${stmt}`);
+  }
+  if (guard) lines.push(`${ind}  }`);
+  lines.push(`${ind}  __l[${a.ordinal}] = __x`);
+  lines.push(`${ind}} }`);
+}
+function emitTextBinding(lines, ind, t, doorExpr, mode2, rwDoor) {
+  lines.push(`${ind}{ const __x = ${t.wrappedExpression}`);
+  const writeOf = (valueExpr) => rwDoor ? `${doorExpr}.write('${t.slotId}', ${valueExpr})` : `${doorExpr}('${t.slotId}', ${valueExpr})`;
+  if (mode2 === "outer") {
+    lines.push(`${ind}if (__seed) {`);
+    lines.push(`${ind}  const __s = textOrNode(__x)`);
+    lines.push(`${ind}  if (${doorExpr}.read('${t.slotId}') !== __s) ${writeOf("__s")}`);
+    lines.push(`${ind}} else if (${dedupGuard(t.ordinal)}) ${writeOf("textOrNode(__x)")}`);
+  } else if (mode2 === "item") {
+    lines.push(`${ind}if (${dedupGuard(t.ordinal)}) ${writeOf("textOrNode(__x)")}`);
+  } else {
+    lines.push(`${ind}${writeOf("textOrNode(__x)")}`);
+  }
+  lines.push(`${ind}__l[${t.ordinal}] = __x }`);
+}
+function seedDiffersExpr(target2, a) {
+  const html = toHTMLAttrName(a.attrName);
+  if (a.attrName === "dangerouslySetInnerHTML" || html === "dangerouslySetInnerHTML") return "true";
+  if (html === "style") return `${target2}.getAttribute('style') !== styleToCss(__x)`;
+  if (html === "class") return `${target2}.getAttribute('class') !== (__x != null ? String(__x) : null)`;
+  if (html === "value") return `${target2}.value !== String(__x)`;
+  if (isBooleanAttr(html)) return `${target2}.${html} !== !!(__x)`;
+  if (a.meta.presenceOrUndefined) {
+    const written = html.startsWith("aria-") ? "true" : "";
+    return `${target2}.getAttribute('${html}') !== (__x ? '${written}' : null)`;
+  }
+  return `${target2}.getAttribute('${html}') !== (__x != null ? String(__x) : null)`;
+}
+var init_lazy_row = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/stringify/lazy-row.ts"() {
+    "use strict";
+    init_html_constants();
+    init_emit_reactive();
+    init_utils();
+    init_claim_plan();
+    init_skeleton_paths();
+    init_template_parse();
+  }
+});
+
 // ../jsx/src/ir-to-client-js/control-flow/stringify/loop.ts
 function emitLoopChildRefs(lines, refs, opts) {
   if (refs.length === 0) return;
@@ -19242,20 +19937,6 @@ function emitLoopChildRefs(lines, refs, opts) {
     lines.push(`${indent}if (${varName}) ${emitRefCall(ref.callback, varName)} }`);
   }
 }
-function emitPreambleRegionEffects(lines, regions, mapPreambleWrapped, opts) {
-  if (regions.length === 0) return;
-  const { indent, elVar } = opts;
-  for (const region of regions) {
-    const v = varSlotId(region.slotId);
-    lines.push(`${indent}{ let __last_${v}`);
-    lines.push(`${indent}createEffect(() => {`);
-    if (mapPreambleWrapped) lines.push(`${indent}  ${mapPreambleWrapped}`);
-    lines.push(`${indent}  const __html_${v} = ${region.valueExpr}`);
-    lines.push(`${indent}  if (__last_${v} === undefined) { __last_${v} = __html_${v}; return }`);
-    lines.push(`${indent}  if (__html_${v} !== __last_${v}) { __last_${v} = __html_${v}; patchSlotRange(${elVar}, '${region.slotId}', __html_${v}) }`);
-    lines.push(`${indent}}) }`);
-  }
-}
 function stringifyLoop(lines, plan) {
   switch (plan.kind) {
     case "static":
@@ -19319,6 +20000,23 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     stringifyAnchoredLoop(lines, plan, topIndent, anchorKeyExpr);
     return;
   }
+  if (plan.lazyRow) {
+    stringifyLazyRowLoop(lines, {
+      indent: topIndent,
+      containerVar,
+      guardContainer: false,
+      markerId,
+      arrayExpr,
+      keyFn,
+      paramHead,
+      indexParam,
+      template,
+      skeletonTemplate,
+      skeletonPaths: plan.skeletonPaths,
+      lazyRow: plan.lazyRow
+    });
+    return;
+  }
   const hoistedTpl = !bodyIsMultiRoot && skeletonTemplate ? skeletonTemplate : null;
   const tplVar = `__tpl_${markerId.replace(/[^A-Za-z0-9_$]/g, "_")}`;
   if (hoistedTpl) {
@@ -19354,26 +20052,33 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
       ...reactiveEffects?.attrSlots.map((s) => s.slotId) ?? [],
       ...childRefs.map((r2) => r2.childSlotId)
     ];
-    const textSlotIds = reactiveEffects?.outerTexts.map((t) => t.slotId) ?? [];
-    if (elementSlotIds.length > 0 || textSlotIds.length > 0) {
-      const built = buildSkeletonPathPlan(plan.skeletonPaths, "__el", { elementSlotIds, textSlotIds });
+    if (elementSlotIds.length > 0) {
+      const built = buildSkeletonPathPlan(plan.skeletonPaths, "__el", { elementSlotIds, textSlotIds: [] });
       if (built.arrayElems.length > 0) {
         pathPlan = built;
         lines.push(`${bodyIndent}const __p = __existing ? null : [${built.arrayElems.join(", ")}]`);
       }
     }
   }
-  if (reactiveEffects !== null) {
+  const textClaimPathExprs = /* @__PURE__ */ new Map();
+  if (hoistedTpl && plan.skeletonPaths) {
+    for (const text of reactiveEffects?.outerTexts ?? []) {
+      const path25 = plan.skeletonPaths.textMarkerPaths.get(text.slotId);
+      if (path25) textClaimPathExprs.set(text.slotId, `__existing ? [] : [${path25.join(", ")}]`);
+    }
+  }
+  if (reactiveEffects !== null || preambleRegions.length > 0) {
     stringifyReactiveEffects(lines, reactiveEffects, {
       indent: bodyIndent,
       elVar: "__el",
       bodyIsMultiRoot,
       elementIndexBySlot: pathPlan?.elementIndexBySlot,
-      textIndexBySlot: pathPlan?.textIndexBySlot
+      textClaimPathExprs,
+      preambleRegions,
+      mapPreambleWrapped
     });
   }
   emitLoopChildRefs(lines, childRefs, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot, elementIndexBySlot: pathPlan?.elementIndexBySlot });
-  emitPreambleRegionEffects(lines, preambleRegions, mapPreambleWrapped, { indent: bodyIndent, elVar: "__el" });
   lines.push(`${bodyIndent}return __el`);
   lines.push(`${topIndent}}, '${markerId}'${loopBfId})`);
 }
@@ -19474,10 +20179,13 @@ function stringifyStaticLoop(lines, plan) {
     }
     lines.push(`        }`);
   }
-  for (const text of texts) {
-    const vn = `__rt_${varSlotId(text.slotId)}`;
-    lines.push(`        { const [${vn}] = $t(__iterEl, '${text.slotId}')`);
-    lines.push(`        if (${vn}) createEffect(() => { ${vn}.textContent = String(${text.expression}) }${profileBindingId(pc, text.slotId)}) }`);
+  if (texts.length > 0) {
+    const slots = texts.map((t) => ({ id: t.slotId, kind: "text", path: [] }));
+    const writer = claimWriterVarName(slots, varSlotId);
+    lines.push(`        const ${writer} = lazySlots(__iterEl, ${claimPlanLiteral(slots)})`);
+    for (const text of texts) {
+      lines.push(`        createEffect(() => { ${writer}('${text.slotId}', String(${text.expression})) }${profileBindingId(pc, text.slotId)})`);
+    }
   }
   emitLoopChildRefs(lines, childRefs, { indent: "        ", elVar: "__iterEl", bodyIsMultiRoot: false });
   lines.push(`      }`);
@@ -19495,6 +20203,8 @@ var init_loop = __esm({
     init_skeleton_paths();
     init_component_loop();
     init_composite_loop();
+    init_claim_plan();
+    init_lazy_row();
   }
 });
 
@@ -19550,13 +20260,18 @@ function emitReactive(lines, inner, indent, pc) {
   if (inner.childLevels.length > 0) {
     stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc);
   }
-  for (const text of emit.reactiveTexts) {
+  const conditionalTexts = emit.reactiveTexts.filter((t) => t.insideConditional);
+  const plainTexts = emit.reactiveTexts.filter((t) => !t.insideConditional);
+  for (const text of conditionalTexts) {
     const bf = profileBindingId(pc, text.slotId);
-    if (text.insideConditional) {
-      lines.push(`${indent}  createEffect(() => { const [__rt] = $t(__innerEl${uid}, '${text.slotId}'); if (__rt) __rt.textContent = String(${text.wrappedExpression}) }${bf})`);
-    } else {
-      lines.push(`${indent}  { const [__rt] = $t(__innerEl${uid}, '${text.slotId}')`);
-      lines.push(`${indent}  if (__rt) createEffect(() => { __rt.textContent = String(${text.wrappedExpression}) }${bf}) }`);
+    lines.push(`${indent}  createEffect(() => { claimSlots(__innerEl${uid}, [{ id: '${text.slotId}', kind: 'text', path: [] }]).write('${text.slotId}', String(${text.wrappedExpression})) }${bf})`);
+  }
+  if (plainTexts.length > 0) {
+    const slots = plainTexts.map((t) => ({ id: t.slotId, kind: "text", path: [] }));
+    const writer = claimWriterVarName(slots, varSlotId);
+    lines.push(`${indent}  const ${writer} = lazySlots(__innerEl${uid}, ${claimPlanLiteral(slots)})`);
+    for (const text of plainTexts) {
+      lines.push(`${indent}  createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${profileBindingId(pc, text.slotId)})`);
     }
   }
   for (const attr of emit.reactiveAttrs) {
@@ -19618,6 +20333,7 @@ var init_inner_loop = __esm({
     init_emit_reactive();
     init_template_parse();
     init_loop();
+    init_claim_plan();
   }
 });
 
@@ -19922,6 +20638,23 @@ function emitPlain(lines, plan) {
     stringifyEventDelegation(lines, eventDelegation);
     return;
   }
+  if (plan.lazyRow) {
+    stringifyLazyRowLoop(lines, {
+      indent: "        ",
+      containerVar,
+      guardContainer: true,
+      markerId,
+      arrayExpr,
+      keyFn,
+      paramHead,
+      indexParam,
+      template,
+      lazyRow: plan.lazyRow
+    });
+    lines.push(`      }))`);
+    stringifyEventDelegation(lines, eventDelegation);
+    return;
+  }
   if (reactiveEffects === null && !bodyIsMultiRoot && childRefs.length === 0 && preambleRegions.length === 0) {
     const cloneExpr = emitTemplateCloneInline(template);
     if (mapPreambleWrapped) {
@@ -19943,11 +20676,16 @@ function emitPlain(lines, plan) {
       indent: "          ",
       singleRootLayout: "inline"
     });
-    if (reactiveEffects !== null) {
-      stringifyReactiveEffects(lines, reactiveEffects, { indent: "          ", elVar: "__el", bodyIsMultiRoot });
+    if (reactiveEffects !== null || preambleRegions.length > 0) {
+      stringifyReactiveEffects(lines, reactiveEffects, {
+        indent: "          ",
+        elVar: "__el",
+        bodyIsMultiRoot,
+        preambleRegions,
+        mapPreambleWrapped
+      });
     }
     emitLoopChildRefs(lines, childRefs, { indent: "          ", elVar: "__el", bodyIsMultiRoot });
-    emitPreambleRegionEffects(lines, preambleRegions, mapPreambleWrapped, { indent: "          ", elVar: "__el" });
     lines.push(`          return __el`);
     lines.push(`        }, '${markerId}'${loopBfId})`);
   }
@@ -19962,6 +20700,7 @@ var init_branch_loop = __esm({
     init_reactive_effects();
     init_template_parse();
     init_loop();
+    init_lazy_row();
   }
 });
 
@@ -20038,13 +20777,13 @@ function emitArmBody(lines, body2, mode2, indent, profileComponentName) {
     }
     lines.push(`${indent}} }`);
   }
-  for (const te of body2.textEffects) {
-    const v = varSlotId(te.slotId);
-    lines.push(`${indent}let __anchor_${v} = $t(__branchScope, '${te.slotId}')[0]`);
-    lines.push(`${indent}__disposers.push(createDisposableEffect(() => {`);
-    lines.push(`${indent}  const __val = ${te.expression}`);
-    lines.push(`${indent}  __anchor_${v} = __bfText(__anchor_${v}, __val)`);
-    lines.push(`${indent}}${bindingBfId(te.slotId)}))`);
+  if (body2.textEffects.length > 0) {
+    const slots = body2.textEffects.map((te) => ({ id: te.slotId, kind: "markup", path: [] }));
+    const writer = claimWriterVarName(slots, varSlotId);
+    lines.push(`${indent}const ${writer} = lazySlots(__branchScope, ${claimPlanLiteral(slots)})`);
+    for (const te of body2.textEffects) {
+      lines.push(`${indent}__disposers.push(createDisposableEffect(() => { ${writer}('${te.slotId}', escapeTextOrNode(${te.expression})) }${bindingBfId(te.slotId)}))`);
+    }
   }
   if (body2.loops.length > 0) {
     stringifyBranchLoops(lines, body2.loops);
@@ -20077,6 +20816,7 @@ var init_insert = __esm({
     init_branch_loop();
     init_event_listener();
     init_component_scope();
+    init_claim_plan();
   }
 });
 
@@ -20147,7 +20887,7 @@ var init_build_component_loop = __esm({
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-loop.ts
 function buildLoopPlan(elem, opts) {
   if (elem.bodyIsItemConditional) {
-    return buildPlainLoopPlan(elem, opts.profileComponentName);
+    return buildPlainLoopPlan(elem, opts.profileComponentName, opts.lazyScope);
   }
   if (elem.isStaticArray) {
     return buildStaticLoopPlan(elem, opts.unsafeLocalNames, opts.profileComponentName);
@@ -20159,9 +20899,9 @@ function buildLoopPlan(elem, opts) {
   if (elem.childComponent) {
     return buildComponentLoopPlan(elem, opts.profileComponentName);
   }
-  return buildPlainLoopPlan(elem, opts.profileComponentName);
+  return buildPlainLoopPlan(elem, opts.profileComponentName, opts.lazyScope);
 }
-function buildPlainLoopPlan(elem, profileComponentName) {
+function buildPlainLoopPlan(elem, profileComponentName, lazyScope) {
   const wrap = (expr) => wrapLoopParamAsAccessor(expr, elem.param, elem.paramBindings);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
   const hasReactive2 = elem.bindings.reactiveAttrs.length > 0 || elem.bindings.reactiveTexts.length > 0 || elem.bindings.conditionals.length > 0;
@@ -20190,30 +20930,48 @@ function buildPlainLoopPlan(elem, profileComponentName) {
       preambleRegions: []
     };
   }
+  const arrayExpr = buildChainedArrayExpr(elem);
+  const indexParam = elem.index || "__idx";
+  const mapPreambleWrapped = elem.preamble ? renderPreamble(elem.preamble, {
+    transformJs: wrap,
+    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0, true)
+  }) : "";
+  const preambleRegions = buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings);
   return {
     kind: "plain",
     rowConstruction: "string-template",
     containerVar: `_${varSlotId(elem.slotId)}`,
     markerId: elem.markerId,
     profileLoopId: profileComponentName ? `${profileComponentName}#binding:${elem.slotId}` : void 0,
-    arrayExpr: buildChainedArrayExpr(elem),
+    arrayExpr,
     keyFn: loopKeyFn(elem),
     paramHead,
     paramUnwrap,
-    indexParam: elem.index || "__idx",
+    indexParam,
+    // Lazy row graph (§9, L3). `null` for every ineligible loop, which then
+    // keeps the eager emission below byte-for-byte.
+    lazyRow: buildLazyRowPlan({
+      loop: elem,
+      arrayExpr,
+      indexParam,
+      paramUnwrap,
+      mapPreambleWrapped,
+      preambleRegionCount: preambleRegions.length,
+      callSite: "plain",
+      flatMapLeafItem: false,
+      anchored: elem.bodyIsItemConditional ?? false,
+      scope: lazyScope
+    }) ?? void 0,
     // Stage 3 / D4 — js segments get the loop-param accessor wrap; jsx leaves
     // render as HTML-string templates under this loop's param context so a
     // leaf that reads the item (`r`) becomes `r()`.
-    mapPreambleWrapped: elem.preamble ? renderPreamble(elem.preamble, {
-      transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0, true)
-    }) : "",
+    mapPreambleWrapped,
     template: elem.template,
     skeletonTemplate: elem.skeletonTemplate,
     skeletonPaths: elem.skeletonPaths,
     reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem, profileComponentName) : null,
     childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
-    preambleRegions: buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings),
+    preambleRegions,
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
     anchored: elem.bodyIsItemConditional ?? false,
     // Fall back to the iteration index when the loop has no key. A whole-item
@@ -20275,6 +21033,7 @@ var init_build_loop = __esm({
     init_utils();
     init_shared();
     init_build_reactive_effects();
+    init_build_lazy_row();
     init_build_component_loop();
     init_build_composite_loop();
     init_html_template();
@@ -20285,7 +21044,7 @@ var init_build_loop = __esm({
 function emitConditionalUpdates(lines, ctx2) {
   const profileComponentName = ctx2.profile ? ctx2.componentName : void 0;
   for (const elem of ctx2.conditionalElements) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom", profileComponentName });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom", profileComponentName, lazyScope: buildLazyRowScopeInfo(ctx2) });
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
   }
@@ -20293,17 +21052,19 @@ function emitConditionalUpdates(lines, ctx2) {
 function emitClientOnlyConditionals(lines, ctx2) {
   const profileComponentName = ctx2.profile ? ctx2.componentName : void 0;
   for (const elem of ctx2.clientOnlyConditionals) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw", profileComponentName });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw", profileComponentName, lazyScope: buildLazyRowScopeInfo(ctx2) });
     lines.push(`  // @client conditional: ${elem.slotId}`);
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
   }
 }
 function emitLoopUpdates(lines, ctx2, unsafeLocalNames) {
+  const lazyScope = buildLazyRowScopeInfo(ctx2);
   for (const elem of ctx2.loopElements) {
     const plan = buildLoopPlan(elem, {
       unsafeLocalNames,
-      profileComponentName: ctx2.profile ? ctx2.componentName : void 0
+      profileComponentName: ctx2.profile ? ctx2.componentName : void 0,
+      lazyScope
     });
     internalInvariant(
       !(elem.preamble && elem.preamble.builderNames.length > 0 && plan.rowConstruction === "dom-ops"),
@@ -20331,6 +21092,7 @@ var init_control_flow = __esm({
     init_build_insert();
     init_insert();
     init_build_loop();
+    init_build_lazy_row();
     init_loop();
     init_build_event_delegation();
     init_event_delegation();
@@ -20340,7 +21102,6 @@ var init_control_flow = __esm({
 // ../jsx/src/ir-to-client-js/element-refs.ts
 function generateElementRefs(ctx2) {
   const regularSlots = /* @__PURE__ */ new Set();
-  const textSlots = /* @__PURE__ */ new Set();
   const componentSlots = /* @__PURE__ */ new Set();
   const conditionalSlotIds = collectConditionalSlotIds(ctx2);
   for (const elem of ctx2.interactiveElements) {
@@ -20348,11 +21109,6 @@ function generateElementRefs(ctx2) {
       regularSlots.add(elem.slotId);
     }
   }
-  for (const elem of ctx2.dynamicElements) {
-    if (!elem.insideConditional) {
-      textSlots.add(elem.slotId);
-    }
-  }
   for (const elem of ctx2.conditionalElements) {
     regularSlots.add(elem.slotId);
   }
@@ -20381,10 +21137,9 @@ function generateElementRefs(ctx2) {
   for (const slotId of componentSlots) {
     regularSlots.delete(slotId);
   }
-  if (regularSlots.size === 0 && textSlots.size === 0 && componentSlots.size === 0) return "";
+  if (regularSlots.size === 0 && componentSlots.size === 0) return "";
   const refLines = [];
   emitSlotRefs(refLines, [...regularSlots], "$");
-  emitSlotRefs(refLines, [...textSlots], "$t");
   emitSlotRefs(refLines, [...componentSlots], "$c");
   return refLines.join("\n");
 }
@@ -21034,6 +21789,107 @@ var init_ir_to_client_js = __esm({
   }
 });
 
+// ../jsx/src/ir-to-client-js/client-only-elision.ts
+function decideClientOnlyElision(root2) {
+  walkNode(root2, [], /* @__PURE__ */ new Set(), { bailed: false });
+}
+function walkNode(node, path25, forceCloseAncestors, state2) {
+  if (state2.bailed) return;
+  if (node.type === "element") {
+    if (!elementIsPathSafe(node.tag, flattenSkeletonChildren(node.children))) {
+      state2.bailed = true;
+      return;
+    }
+    const groupIdx = skeletonForceCloseGroup(node.tag);
+    if (groupIdx >= 0 && forceCloseAncestors.has(groupIdx)) {
+      state2.bailed = true;
+      return;
+    }
+    const nextAncestors = groupIdx >= 0 ? /* @__PURE__ */ new Set([...forceCloseAncestors, groupIdx]) : forceCloseAncestors;
+    walkChildren(flattenSkeletonChildren(node.children), path25, nextAncestors, state2);
+  } else if (node.type === "fragment") {
+    walkChildren(flattenSkeletonChildren(node.children), path25, forceCloseAncestors, state2);
+  }
+}
+function walkChildren(children2, parentPath, forceCloseAncestors, state2) {
+  let frozen = false;
+  let idx = 0;
+  let pendingText = false;
+  for (let i = 0; i < children2.length; i++) {
+    if (state2.bailed) return;
+    const child = children2[i];
+    switch (child.type) {
+      case "text": {
+        if (child.value === "") continue;
+        if (!pendingText) idx += 1;
+        pendingText = true;
+        continue;
+      }
+      case "expression": {
+        if (child.expr === "null" || child.expr === "undefined") continue;
+        if (child.clientOnly && child.slotId) {
+          const adjacent = isTextLike(children2[i - 1]) || isTextLike(children2[i + 1]);
+          if (!frozen && !adjacent) {
+            markElided(child, [...parentPath, idx]);
+            frozen = true;
+          } else {
+            frozen = true;
+          }
+          idx += 1;
+          pendingText = false;
+          continue;
+        }
+        frozen = true;
+        idx += 1;
+        pendingText = false;
+        continue;
+      }
+      case "element": {
+        if (!elementIsPathSafe(child.tag, flattenSkeletonChildren(child.children))) {
+          state2.bailed = true;
+          return;
+        }
+        if (!frozen) {
+          walkNode(child, [...parentPath, idx], forceCloseAncestors, state2);
+        }
+        idx += 1;
+        pendingText = false;
+        continue;
+      }
+      case "fragment":
+        continue;
+      // already flattened
+      default:
+        frozen = true;
+        idx += 1;
+        pendingText = false;
+        continue;
+    }
+  }
+}
+function isTextLike(node) {
+  if (!node) return false;
+  if (node.type === "text") return node.value !== "";
+  if (node.type === "expression") return node.expr !== "null" && node.expr !== "undefined";
+  return false;
+}
+function markElided(expr, path25) {
+  expr.markerless = true;
+  expr.elidedPath = path25;
+}
+function elementIsPathSafe(tag, flatChildren) {
+  if (SKELETON_PATH_HAZARD_TAGS.has(tag)) return false;
+  if (VOID_ELEMENTS.has(tag) && flatChildren.length > 0) return false;
+  if (tag === "tr" && hasForeignTableRowContent(flatChildren)) return false;
+  return true;
+}
+var init_client_only_elision = __esm({
+  "../jsx/src/ir-to-client-js/client-only-elision.ts"() {
+    "use strict";
+    init_html_template();
+  }
+});
+
 // ../jsx/src/css-layer-prefixer.ts
 function prefixClass(cls, layerName) {
   if (!cls || cls.startsWith("layer-")) return cls;
@@ -22208,7 +23064,7 @@ function checkRichTypeMethodCalls(root2, metadata, errors) {
   if (!metadata.propsType) return;
   const matchers = prepareLoweringMatchers(metadata);
   const seen = /* @__PURE__ */ new Set();
-  walkNode(root2, metadata, EMPTY_BINDINGS2, matchers, errors, seen);
+  walkNode2(root2, metadata, EMPTY_BINDINGS2, matchers, errors, seen);
 }
 function isLoweringClaimed(matchers, callee, args2) {
   return matchers.some((m) => m(callee, args2) !== null);
@@ -22336,7 +23192,7 @@ function walkAttrValue(value2, clientOnly, loc, meta, bindings, matchers, errors
     walkTemplateParts(value2.parts, loc, meta, bindings, matchers, errors, seen);
   }
 }
-function walkNode(node, meta, bindings, matchers, errors, seen) {
+function walkNode2(node, meta, bindings, matchers, errors, seen) {
   if (node.type === "expression") {
     if (!node.clientOnly && node.parsed) checkExpr(node.parsed, node.loc, meta, bindings, matchers, errors, seen);
   } else if (node.type === "conditional") {
@@ -22356,11 +23212,11 @@ function walkNode(node, meta, bindings, matchers, errors, seen) {
     case "component":
     case "fragment":
     case "provider":
-      for (const child of node.children) walkNode(child, meta, bindings, matchers, errors, seen);
+      for (const child of node.children) walkNode2(child, meta, bindings, matchers, errors, seen);
       break;
     case "async":
-      walkNode(node.fallback, meta, bindings, matchers, errors, seen);
-      for (const child of node.children) walkNode(child, meta, bindings, matchers, errors, seen);
+      walkNode2(node.fallback, meta, bindings, matchers, errors, seen);
+      for (const child of node.children) walkNode2(child, meta, bindings, matchers, errors, seen);
       break;
     case "loop": {
       if (node.clientOnly) break;
@@ -22369,29 +23225,29 @@ function walkNode(node, meta, bindings, matchers, errors, seen) {
       const arrayType = node.arrayParsed ? resolveReceiverType(node.arrayParsed, meta, bindings) : null;
       loopBindings.set(node.param, arrayType?.kind === "array" ? arrayType.elementType ?? null : null);
       if (node.index) loopBindings.set(node.index, null);
-      for (const child of node.children) walkNode(child, meta, loopBindings, matchers, errors, seen);
+      for (const child of node.children) walkNode2(child, meta, loopBindings, matchers, errors, seen);
       if (node.childComponent) {
-        for (const child of node.childComponent.children) walkNode(child, meta, loopBindings, matchers, errors, seen);
+        for (const child of node.childComponent.children) walkNode2(child, meta, loopBindings, matchers, errors, seen);
       }
       for (const nested of node.nestedComponents ?? []) {
-        for (const child of nested.children) walkNode(child, meta, loopBindings, matchers, errors, seen);
+        for (const child of nested.children) walkNode2(child, meta, loopBindings, matchers, errors, seen);
       }
       for (const seg of node.flatMapCallback?.segments ?? []) {
-        if (seg.kind === "jsx") walkNode(seg.ir, meta, loopBindings, matchers, errors, seen);
+        if (seg.kind === "jsx") walkNode2(seg.ir, meta, loopBindings, matchers, errors, seen);
       }
       for (const seg of node.preamble?.segments ?? []) {
-        if (seg.kind === "jsx") walkNode(seg.ir, meta, loopBindings, matchers, errors, seen);
+        if (seg.kind === "jsx") walkNode2(seg.ir, meta, loopBindings, matchers, errors, seen);
       }
       break;
     }
     case "conditional":
       if (node.clientOnly) break;
-      walkNode(node.whenTrue, meta, bindings, matchers, errors, seen);
-      walkNode(node.whenFalse, meta, bindings, matchers, errors, seen);
+      walkNode2(node.whenTrue, meta, bindings, matchers, errors, seen);
+      walkNode2(node.whenFalse, meta, bindings, matchers, errors, seen);
       break;
     case "if-statement":
-      walkNode(node.consequent, meta, bindings, matchers, errors, seen);
-      if (node.alternate) walkNode(node.alternate, meta, bindings, matchers, errors, seen);
+      walkNode2(node.consequent, meta, bindings, matchers, errors, seen);
+      if (node.alternate) walkNode2(node.alternate, meta, bindings, matchers, errors, seen);
       break;
   }
 }
@@ -22464,6 +23320,7 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
     };
     componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
     checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors);
+    decideClientOnlyElision(componentIR.root);
     if (options2.cssLayerPrefix) {
       applyCssLayerPrefix(componentIR, options2.cssLayerPrefix);
     }
@@ -22801,6 +23658,7 @@ function compileJSX(source, filePath, options2) {
   };
   componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR);
   checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors);
+  decideClientOnlyElision(componentIR.root);
   if (ctx2.importedClientSignalNames.size > 0) {
     const sources = /* @__PURE__ */ new Set();
     for (const imp of ctx2.imports) {
@@ -22922,6 +23780,7 @@ var init_compiler = __esm({
     init_jsx_to_ir();
     init_builtins();
     init_ir_to_client_js();
+    init_client_only_elision();
     init_emit_module_level();
     init_imports();
     init_component_scope();
@@ -26867,6 +27726,7 @@ __export(src_exports, {
   createProgramForFile: () => createProgramForFile,
   dangerousInnerHtmlDiagnostic: () => dangerousInnerHtmlDiagnostic,
   dangerousInnerHtmlMetacharViolation: () => dangerousInnerHtmlMetacharViolation,
+  decideClientOnlyElision: () => decideClientOnlyElision,
   describeFallback: () => describeFallback,
   diffProfiles: () => diffProfiles,
   diffStaticBudget: () => diffStaticBudget,
@@ -26981,6 +27841,7 @@ var init_src2 = __esm({
     init_analyzer();
     init_shared_program();
     init_jsx_to_ir();
+    init_client_only_elision();
     init_module_exports();
     init_interface();
     init_test_adapter();