@barefootjs/jsx 0.27.0 → 0.28.1

package/dist/index.js

@@ -5367,6 +5367,7 @@ var ErrorCodes = {
   SHARED_PROGRAM_REQUIRED: "BF050",
   WRONG_PACKAGE_IMPORT: "BF051",
   BUILTIN_REQUIRES_IMPORT: "BF054",
+  INLINED_IMPORT_MISSING_EXPORT: "BF055",
   UNDECLARED_INIT_STATEMENT_REFERENCE: "BF052",
   STRIPPED_CLIENT_IMPORT_REFERENCED: "BF053",
   STAGE_REACTIVE_IN_TEMPLATE: "BF060",
@@ -5397,6 +5398,7 @@ var errorMessages = {
   [ErrorCodes.BUILTIN_REQUIRES_IMPORT]: "Built-in <Async> / <Region> must be imported from '@barefootjs/client'. " + "The compiler recognises these tags by their import (not by tag name), " + "so an unimported tag with this name is treated as an undeclared component.",
   [ErrorCodes.UNDECLARED_INIT_STATEMENT_REFERENCE]: "Init statement references an undeclared identifier. Declare it at module scope, inside the component, or import it — otherwise ESM strict mode throws ReferenceError at runtime.",
   [ErrorCodes.STRIPPED_CLIENT_IMPORT_REFERENCED]: "Import was stripped from the client bundle but its binding is still referenced. Client components ('use client' .tsx) are not callable as plain functions from imperative .ts modules — render them as JSX from a 'use client' parent instead. If the flagged name is a local shadow rather than the stripped import, please file an issue.",
+  [ErrorCodes.INLINED_IMPORT_MISSING_EXPORT]: "An inlined relative import requests a name the target module does not export. The client bundle would throw ReferenceError at load.",
   [ErrorCodes.STAGE_REACTIVE_IN_TEMPLATE]: "Reactive binding (signal getter or memo) referenced from template scope. The template lambda runs at module scope without the reactive context, so the value cannot be evaluated at SSR. Wrap the JSX expression in /* @client */ to defer it to hydrate, or restructure so the template uses a prop or static value.",
   [ErrorCodes.STAGE_INIT_LOCAL_IN_TEMPLATE]: "Init-scope local referenced from template scope. The template lambda runs at module scope (via render() / renderChild()) and cannot reach init-body locals. Wrap the JSX expression in /* @client */, or lift the value to a prop or module-scope const.",
   [ErrorCodes.STAGE_AWAIT_IN_TEMPLATE]: "AwaitExpression in template scope. The generated template and init functions are synchronous — a bare `await` produces a SyntaxError at parse time. Move the await into the component body (before the return) or into an onMount/effect callback, and pass the resolved value to JSX.",
@@ -7931,6 +7933,8 @@ function importsBrowserOnlyClientApi(ctx) {
     if (imp.isTypeOnly)
       continue;
     for (const spec of imp.specifiers) {
+      if (spec.isTypeOnly)
+        continue;
       const importedName = spec.name;
       if (BROWSER_ONLY_CLIENT_APIS.has(importedName))
         return true;
@@ -11237,7 +11241,8 @@ function transformConditionalBranch(node, ctx) {
   const callsReactive = exprCallsReactiveGetters(node, ctx);
   const hasCalls = exprHasFunctionCalls(node);
   const reactive = isReactiveExpression(exprText, ctx, node) || isReactiveOrigin(branchOrigin);
-  const needsSlot = reactive || callsReactive;
+  const refsLoopParam = branchOrigin.freeRefs?.some((r) => r.kind === "render-item") ?? false;
+  const needsSlot = reactive || callsReactive || refsLoopParam;
   const slotId = needsSlot ? generateSlotId(ctx) : null;
   return {
     type: "expression",
@@ -14832,7 +14837,7 @@ function summarizeLoopChildBranch(node, ctx, siblingOffsets, loopParam, loopPara
     conditionals: collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings),
     events: collectConditionalBranchEvents(node),
     reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, true),
-    reactiveTexts: node.type === "expression" ? [] : collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, true)
+    reactiveTexts: node.type === "expression" && node.hasFunctionCalls ? [] : collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, true)
   };
 }
 
@@ -15278,6 +15283,70 @@ function propHasPropertyAccess(u) {
   return u.accessKinds.has("property") || u.accessKinds.has("index");
 }
 
+// src/value-references.ts
+import ts13 from "typescript";
+function isValueReferenceIdentifier(id) {
+  const parent = id.parent;
+  if (!parent)
+    return false;
+  if (ts13.isPropertyAccessExpression(parent) && parent.name === id)
+    return false;
+  if (ts13.isPropertyAssignment(parent) && parent.name === id)
+    return false;
+  if ((ts13.isMethodDeclaration(parent) || ts13.isGetAccessorDeclaration(parent) || ts13.isSetAccessorDeclaration(parent)) && parent.name === id) {
+    return false;
+  }
+  if (ts13.isVariableDeclaration(parent) && parent.name === id)
+    return false;
+  if (ts13.isFunctionDeclaration(parent) && parent.name === id)
+    return false;
+  if (ts13.isFunctionExpression(parent) && parent.name === id)
+    return false;
+  if (ts13.isClassDeclaration(parent) && parent.name === id)
+    return false;
+  if (ts13.isClassExpression(parent) && parent.name === id)
+    return false;
+  if (ts13.isParameter(parent) && parent.name === id)
+    return false;
+  if (ts13.isBindingElement(parent) && (parent.name === id || parent.propertyName === id))
+    return false;
+  if (ts13.isLabeledStatement(parent) && parent.label === id)
+    return false;
+  if (ts13.isBreakOrContinueStatement(parent) && parent.label === id)
+    return false;
+  if (ts13.isImportSpecifier(parent) && (parent.name === id || parent.propertyName === id))
+    return false;
+  if (ts13.isExportSpecifier(parent) && (parent.name === id || parent.propertyName === id))
+    return false;
+  if (ts13.isImportClause(parent) && parent.name === id)
+    return false;
+  if (ts13.isNamespaceImport(parent) && parent.name === id)
+    return false;
+  if (ts13.isQualifiedName(parent) && parent.right === id)
+    return false;
+  return true;
+}
+function collectValueReferencedNames(code) {
+  let sourceFile;
+  try {
+    sourceFile = ts13.createSourceFile("generated.js", code, ts13.ScriptTarget.Latest, true, ts13.ScriptKind.JS);
+  } catch {
+    return null;
+  }
+  const diagnostics = sourceFile.parseDiagnostics;
+  if (diagnostics && diagnostics.length > 0)
+    return null;
+  const names = new Set;
+  function visit3(node) {
+    if (ts13.isIdentifier(node) && isValueReferenceIdentifier(node)) {
+      names.add(node.text);
+    }
+    ts13.forEachChild(node, visit3);
+  }
+  visit3(sourceFile);
+  return names;
+}
+
 // src/ir-to-client-js/imports.ts
 var RUNTIME_IMPORT_CANDIDATES = [
   "createSignal",
@@ -15291,6 +15360,7 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "getLoopNodes",
   "mapArray",
   "mapArrayAnchored",
+  "mapArrayLazy",
   "patchLeaf",
   "createDisposableEffect",
   "createComponent",
@@ -15321,6 +15391,8 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "__bfText",
   "claimSlots",
   "lazySlots",
+  "lazyClaimSlots",
+  "textOrNode",
   "beginTurn",
   "endTurn",
   "date",
@@ -15353,7 +15425,7 @@ function collectUserDomImports(ir) {
   for (const imp of ir.metadata.imports) {
     if (runtimeSources.has(imp.source) && !imp.isTypeOnly) {
       for (const spec of imp.specifiers) {
-        if (!spec.isDefault && !spec.isNamespace) {
+        if (!spec.isDefault && !spec.isNamespace && !spec.isTypeOnly) {
           if (isClientBuiltinName(spec.name))
             continue;
           userImports.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name);
@@ -15363,9 +15435,22 @@ function collectUserDomImports(ir) {
   }
   return userImports;
 }
+function makeValueUsageTest(generatedCode) {
+  let referenced;
+  return (localName) => {
+    if (referenced === undefined) {
+      referenced = collectValueReferencedNames(generatedCode);
+    }
+    if (referenced !== null) {
+      return referenced.has(localName);
+    }
+    return generatedCode.includes(localName);
+  };
+}
 function collectExternalImports(ir, generatedCode, localImportPrefixes) {
   const componentNames = collectComponentNames(ir.root);
   const importLines = [];
+  const isUsedAsValue = makeValueUsageTest(generatedCode);
   for (const imp of ir.metadata.imports) {
     if (imp.isTypeOnly)
       continue;
@@ -15379,10 +15464,12 @@ function collectExternalImports(ir, generatedCode, localImportPrefixes) {
     }
     const usedSpecs = [];
     for (const spec of imp.specifiers) {
+      if (spec.isTypeOnly)
+        continue;
       const localName = spec.alias || spec.name;
       if (componentNames.has(localName))
         continue;
-      if (new RegExp(`\\b${localName}\\b`).test(generatedCode)) {
+      if (isUsedAsValue(localName)) {
         usedSpecs.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name);
       }
     }
@@ -15421,7 +15508,7 @@ function collectComponentNames(node) {
 }
 
 // src/relocate.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 
 // src/lowering-registry.ts
 var plugins = [];
@@ -15467,19 +15554,19 @@ function classify(name, env) {
 function collectFreeRefs(node) {
   const refs = new Map;
   function visit3(n, parent) {
-    if (ts13.isIdentifier(n)) {
-      if (parent && ts13.isPropertyAccessExpression(parent) && parent.name === n)
+    if (ts14.isIdentifier(n)) {
+      if (parent && ts14.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts13.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts14.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && ts13.isShorthandPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts14.isShorthandPropertyAssignment(parent) && parent.name === n)
         return;
       const list = refs.get(n.text) ?? [];
       list.push(n);
       refs.set(n.text, list);
       return;
     }
-    ts13.forEachChild(n, (child) => visit3(child, n));
+    ts14.forEachChild(n, (child) => visit3(child, n));
   }
   visit3(node);
   return refs;
@@ -15582,11 +15669,11 @@ function isInlinableInTemplate(value, env) {
   return { ok: true, rewrittenValue: r.text, decisions: r.decisions };
 }
 function getCalleeIdentifierPath(callee) {
-  if (ts13.isParenthesizedExpression(callee))
+  if (ts14.isParenthesizedExpression(callee))
     return getCalleeIdentifierPath(callee.expression);
-  if (ts13.isIdentifier(callee))
+  if (ts14.isIdentifier(callee))
     return callee.text;
-  if (ts13.isPropertyAccessExpression(callee)) {
+  if (ts14.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression);
     if (left === null)
       return null;
@@ -15595,11 +15682,11 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
-  if (ts13.isParenthesizedExpression(callee))
+  if (ts14.isParenthesizedExpression(callee))
     return getCalleeLeftmostIdentifier(callee.expression);
-  if (ts13.isIdentifier(callee))
+  if (ts14.isIdentifier(callee))
     return callee.text;
-  if (ts13.isPropertyAccessExpression(callee)) {
+  if (ts14.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression);
   }
   return null;
@@ -15647,12 +15734,12 @@ function isCallAcceptedByAdapter(call, env) {
 }
 function parseExpressionNode(text) {
   try {
-    const sf = ts13.createSourceFile("__inline_check__.ts", `(${text});`, ts13.ScriptTarget.Latest, false, ts13.ScriptKind.TS);
+    const sf = ts14.createSourceFile("__inline_check__.ts", `(${text});`, ts14.ScriptTarget.Latest, false, ts14.ScriptKind.TS);
     const stmt = sf.statements[0];
-    if (!stmt || !ts13.isExpressionStatement(stmt))
+    if (!stmt || !ts14.isExpressionStatement(stmt))
       return null;
     const inner = stmt.expression;
-    return ts13.isParenthesizedExpression(inner) ? inner.expression : inner;
+    return ts14.isParenthesizedExpression(inner) ? inner.expression : inner;
   } catch {
     return null;
   }
@@ -15669,8 +15756,8 @@ function hasCallWithBridgedArg(node, decisions, env) {
   function visit3(n) {
     if (found)
       return;
-    if (ts13.isCallExpression(n) || ts13.isNewExpression(n)) {
-      const accepted = ts13.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
+    if (ts14.isCallExpression(n) || ts14.isNewExpression(n)) {
+      const accepted = ts14.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
       if (!accepted) {
         const args = n.arguments;
         if (args) {
@@ -15683,7 +15770,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts13.forEachChild(n, visit3);
+    ts14.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15693,13 +15780,13 @@ function hasZeroArgCall(node, env) {
   function visit3(n) {
     if (found)
       return;
-    if (ts13.isCallExpression(n) && n.arguments.length === 0) {
+    if (ts14.isCallExpression(n) && n.arguments.length === 0) {
       if (!isCallAcceptedByAdapter(n, env)) {
         found = true;
         return;
       }
     }
-    ts13.forEachChild(n, visit3);
+    ts14.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15709,25 +15796,25 @@ function containsAnyIdentifier(node, names) {
   function visit3(n) {
     if (found)
       return;
-    if (ts13.isPropertyAccessExpression(n)) {
+    if (ts14.isPropertyAccessExpression(n)) {
       visit3(n.expression);
       return;
     }
-    if (ts13.isPropertyAssignment(n)) {
+    if (ts14.isPropertyAssignment(n)) {
       visit3(n.initializer);
       return;
     }
-    if (ts13.isShorthandPropertyAssignment(n)) {
-      if (ts13.isIdentifier(n.name) && names.has(n.name.text)) {
+    if (ts14.isShorthandPropertyAssignment(n)) {
+      if (ts14.isIdentifier(n.name) && names.has(n.name.text)) {
         found = true;
       }
       return;
     }
-    if (ts13.isIdentifier(n) && names.has(n.text)) {
+    if (ts14.isIdentifier(n) && names.has(n.text)) {
       found = true;
       return;
     }
-    ts13.forEachChild(n, visit3);
+    ts14.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -18389,8 +18476,352 @@ function buildKeyedOrIndexLookup(args) {
   };
 }
 
+// src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
+var PURE_SOURCE_GLOBALS = new Set([
+  "Object",
+  "Array",
+  "JSON",
+  "Number",
+  "String",
+  "Boolean"
+]);
+var INERT_BINDING_GLOBALS = 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"
+]);
+var UNKNOWN_IDENTIFIERS = "<unknown>";
+var NO = (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");
+  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 = new Set;
+  const resolve2 = (name) => {
+    if (seen.has(name))
+      return null;
+    seen.add(name);
+    if (scope.props.has(name))
+      return null;
+    if (PURE_SOURCE_GLOBALS.has(name))
+      return null;
+    const constFree = scope.constants.get(name);
+    if (constFree !== undefined) {
+      if (constFree === null)
+        return `constant '${name}' has no analyzable value`;
+      for (const inner of constFree) {
+        const failure = resolve2(inner);
+        if (failure)
+          return failure;
+      }
+      return null;
+    }
+    const signal = scope.signals.get(name);
+    if (signal !== undefined) {
+      if (signal.initializerFreeIdentifiers === null) {
+        return `signal '${name}' has no structured initializer to prove props/literal derivation`;
+      }
+      for (const inner of signal.initializerFreeIdentifiers) {
+        const failure = resolve2(inner);
+        if (failure)
+          return failure;
+      }
+      return null;
+    }
+    if (scope.memos.has(name))
+      return `memo '${name}' initializer is not analyzed by the v1 gate`;
+    if (scope.inert.has(name))
+      return `'${name}' is an import or local function`;
+    return `'${name}' does not resolve to a prop, literal-derived const, or props/literal-derived signal`;
+  };
+  for (const name of names) {
+    const failure = resolve2(name);
+    if (failure)
+      return failure;
+  }
+  return null;
+}
+function classifyLazyBinding(args) {
+  const { kind, slotId, free, rowLocalNames, indexParam, scope } = args;
+  if (free === null) {
+    return {
+      kind,
+      slotId,
+      readsItem: true,
+      readsOuter: true,
+      reactiveOuterNames: [],
+      opaqueOuterNames: [UNKNOWN_IDENTIFIERS],
+      referencesIndex: false
+    };
+  }
+  let readsItem = false;
+  let referencesIndex = false;
+  const reactiveOuterNames = [];
+  const opaqueOuterNames = [];
+  for (const name of free) {
+    if (rowLocalNames.has(name)) {
+      readsItem = true;
+      continue;
+    }
+    if (name === indexParam) {
+      referencesIndex = true;
+      continue;
+    }
+    if (INERT_BINDING_GLOBALS.has(name))
+      continue;
+    if (scope.signals.has(name) || scope.memos.has(name)) {
+      if (!reactiveOuterNames.includes(name))
+        reactiveOuterNames.push(name);
+      continue;
+    }
+    const constFree = scope.constants.get(name);
+    if (constFree !== undefined && constFree !== null && constFree.size === 0)
+      continue;
+    opaqueOuterNames.push(name);
+  }
+  return {
+    kind,
+    slotId,
+    readsItem,
+    readsOuter: reactiveOuterNames.length > 0 || opaqueOuterNames.length > 0,
+    reactiveOuterNames,
+    opaqueOuterNames,
+    referencesIndex
+  };
+}
+
+// src/ir-to-client-js/control-flow/plan/build-lazy-row.ts
+function buildLazyRowPlan(args) {
+  return decideLazyRow(args).plan;
+}
+function decideLazyRow(args) {
+  const { loop, scope } = args;
+  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 = new Set([loop.param]);
+  for (const b of loop.paramBindings ?? [])
+    rowLocalNames.add(b.name);
+  const classified = [];
+  const attrClass = new Map;
+  loop.bindings.reactiveAttrs.forEach((attr, i) => {
+    const c = classifyLazyBinding({
+      kind: "attr",
+      slotId: attr.childSlotId,
+      free: attrFreeIdentifiers2(attr.expression),
+      rowLocalNames,
+      indexParam: args.indexParam,
+      scope
+    });
+    attrClass.set(i, c);
+    classified.push(c);
+  });
+  const textClass = new Map;
+  loop.bindings.reactiveTexts.forEach((text, i) => {
+    const c = classifyLazyBinding({
+      kind: "text",
+      slotId: text.slotId,
+      free: text.freeIdentifiers ?? null,
+      rowLocalNames,
+      indexParam: args.indexParam,
+      scope
+    });
+    textClass.set(i, c);
+    classified.push(c);
+  });
+  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,
+    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,
+    preambleRegionCount: args.preambleRegionCount,
+    hasParamUnwrap: args.paramUnwrap.length > 0
+  };
+  const decision = lazyRowEligibility({
+    shape,
+    bindings: classified,
+    arraySourceIdentifiers: loopSourceIdentifiers(loop, args.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++,
+      readsItem: c.readsItem || !c.readsOuter,
+      readsOuter: c.readsOuter
+    };
+  });
+  const outerPrimeGetters = [];
+  for (const c of classified) {
+    for (const name of c.reactiveOuterNames) {
+      if (!outerPrimeGetters.includes(name))
+        outerPrimeGetters.push(name);
+    }
+  }
+  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(ctx) {
+  const signals = new Map;
+  for (const s of ctx.signals) {
+    signals.set(s.getter, {
+      initializerFreeIdentifiers: s.parsed ? freeIdentifiers(s.parsed) : null
+    });
+  }
+  const memos = new Set(ctx.memos.map((m) => m.name));
+  const props = new Set([PROPS_PARAM]);
+  if (ctx.propsObjectName)
+    props.add(ctx.propsObjectName);
+  for (const p of ctx.propsParams)
+    props.add(p.name);
+  const constants = new Map;
+  for (const c of ctx.localConstants) {
+    constants.set(c.name, c.freeIdentifiers ?? null);
+  }
+  const inert = new Set;
+  for (const f of ctx.localFunctions)
+    inert.add(f.name);
+  for (const imp of ctx.imports) {
+    if (imp.isTypeOnly)
+      continue;
+    for (const spec of imp.specifiers)
+      inert.add(spec.alias || spec.name);
+  }
+  return { signals, memos, props, constants, inert, profile: ctx.profile };
+}
+function attrFreeIdentifiers2(expression) {
+  if (!expression || expression.trim().length === 0)
+    return 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 name of extractFreeIdentifiersFromText(arrayExpr))
+    names.add(name);
+  return names;
+}
+
 // 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}`;
@@ -18406,6 +18837,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, undefined, 1, [{ param: loop.param, bindings: loop.paramBindings }], undefined, true)
+  }) : "";
+  const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings);
   const plan = {
     kind: "plain",
     rowConstruction: "string-template",
@@ -18413,15 +18851,24 @@ function buildBranchLoopPlan(loop, profileComponentName) {
     containerVar,
     markerId: loop.markerId,
     flatMapLeafItem: fm ? true : undefined,
-    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",
-    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)
-    }) : "",
+    indexParam,
+    mapPreambleWrapped,
+    lazyRow: buildLazyRowPlan({
+      loop,
+      arrayExpr,
+      indexParam,
+      paramUnwrap,
+      mapPreambleWrapped,
+      preambleRegionCount: preambleRegions.length,
+      callSite: "branch-plain",
+      flatMapLeafItem: Boolean(fm),
+      anchored: false,
+      scope: lazyScope
+    }) ?? undefined,
     template: loop.template,
     reactiveEffects: hasReactiveEffects ? buildReactiveEffectsPlan({
       attrs: loop.bindings.reactiveAttrs,
@@ -18433,7 +18880,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}` : undefined
   };
@@ -18484,13 +18931,13 @@ function buildArmBody(branch, options) {
       slotId: t.slotId,
       expression: t.expression
     })),
-    loops: branch.loops.map((l) => buildBranchLoopPlan(l, pc)),
-    conditionals: branch.conditionals.map((c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options.eventNameMode, profileComponentName: pc }))
+    loops: branch.loops.map((l) => buildBranchLoopPlan(l, pc, options.lazyScope)),
+    conditionals: branch.conditionals.map((c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options.eventNameMode, profileComponentName: pc, lazyScope: options.lazyScope }))
   };
 }
 
 // src/ir-to-client-js/emit-reactive.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -18593,20 +19040,20 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts14.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.TS);
+    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts14.isExpressionStatement(stmt))
+  if (!stmt || !ts15.isExpressionStatement(stmt))
     return expr;
-  const root = ts14.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts14.isCallExpression(n) && n.arguments.length === 2 && ts14.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts15.isCallExpression(n) && n.arguments.length === 2 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts14.forEachChild(n, visit3);
+    ts15.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -18642,20 +19089,20 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts14.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.TS);
+    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts14.isExpressionStatement(stmt))
+  if (!stmt || !ts15.isExpressionStatement(stmt))
     return expr;
-  const root = ts14.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts14.isCallExpression(n) && n.arguments.length === 0 && ts14.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts15.isCallExpression(n) && n.arguments.length === 0 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts14.forEachChild(n, visit3);
+    ts15.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -18862,7 +19309,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('[${DATA_BF_PH}="${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('[${DATA_BF_PH}="${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) {
@@ -19171,6 +19618,184 @@ function emitNestedInit(lines, indent, parentVar, nc) {
   }
 }
 
+// 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 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})`);
+  }
+  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, mode) {
+  lines.push(`${ind}{ const __t = __r[${a.refIndex}]`);
+  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)})`;
+  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, mode, rwDoor) {
+  lines.push(`${ind}{ const __x = ${t.wrappedExpression}`);
+  const writeOf = (valueExpr) => rwDoor ? `${doorExpr}.write('${t.slotId}', ${valueExpr})` : `${doorExpr}('${t.slotId}', ${valueExpr})`;
+  if (mode === "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 (mode === "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(target, a) {
+  const html = toHtmlAttrName(a.attrName);
+  if (a.attrName === "dangerouslySetInnerHTML" || html === "dangerouslySetInnerHTML")
+    return "true";
+  if (html === "style")
+    return `${target}.getAttribute('style') !== styleToCss(__x)`;
+  if (html === "class")
+    return `${target}.getAttribute('class') !== (__x != null ? String(__x) : null)`;
+  if (html === "value")
+    return `${target}.value !== String(__x)`;
+  if (isBooleanAttr(html))
+    return `${target}.${html} !== !!(__x)`;
+  if (a.meta.presenceOrUndefined) {
+    const written = html.startsWith("aria-") ? "true" : "";
+    return `${target}.getAttribute('${html}') !== (__x ? '${written}' : null)`;
+  }
+  return `${target}.getAttribute('${html}') !== (__x != null ? String(__x) : null)`;
+}
+
 // src/ir-to-client-js/control-flow/stringify/loop.ts
 function emitLoopChildRefs(lines, refs, opts) {
   if (refs.length === 0)
@@ -19248,6 +19873,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) {
@@ -19841,6 +20483,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) {
@@ -20039,7 +20698,7 @@ function buildComponentLoopPlan(elem, profileComponentName) {
 // 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);
@@ -20051,9 +20710,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;
@@ -20080,27 +20739,43 @@ 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, undefined, 1, [{ param: elem.param, bindings: elem.paramBindings }], undefined, 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}` : undefined,
-    arrayExpr: buildChainedArrayExpr(elem),
+    arrayExpr,
     keyFn: loopKeyFn(elem),
     paramHead,
     paramUnwrap,
-    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)
-    }) : "",
+    indexParam,
+    lazyRow: buildLazyRowPlan({
+      loop: elem,
+      arrayExpr,
+      indexParam,
+      paramUnwrap,
+      mapPreambleWrapped,
+      preambleRegionCount: preambleRegions.length,
+      callSite: "plain",
+      flatMapLeafItem: false,
+      anchored: elem.bodyIsItemConditional ?? false,
+      scope: lazyScope
+    }) ?? undefined,
+    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,
     anchorKeyExpr: elem.key ? wrap(elem.key) : elem.index || "__idx"
@@ -20155,7 +20830,7 @@ function buildStaticLoopMaterialize(elem, unsafeLocalNames) {
 function emitConditionalUpdates(lines, ctx) {
   const profileComponentName = ctx.profile ? ctx.componentName : undefined;
   for (const elem of ctx.conditionalElements) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom", profileComponentName });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom", profileComponentName, lazyScope: buildLazyRowScopeInfo(ctx) });
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
   }
@@ -20163,17 +20838,19 @@ function emitConditionalUpdates(lines, ctx) {
 function emitClientOnlyConditionals(lines, ctx) {
   const profileComponentName = ctx.profile ? ctx.componentName : undefined;
   for (const elem of ctx.clientOnlyConditionals) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw", profileComponentName });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw", profileComponentName, lazyScope: buildLazyRowScopeInfo(ctx) });
     lines.push(`  // @client conditional: ${elem.slotId}`);
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
   }
 }
 function emitLoopUpdates(lines, ctx, unsafeLocalNames) {
+  const lazyScope = buildLazyRowScopeInfo(ctx);
   for (const elem of ctx.loopElements) {
     const plan = buildLoopPlan(elem, {
       unsafeLocalNames,
-      profileComponentName: ctx.profile ? ctx.componentName : undefined
+      profileComponentName: ctx.profile ? ctx.componentName : undefined,
+      lazyScope
     });
     internalInvariant(!(elem.preamble && elem.preamble.builderNames.length > 0 && plan.rowConstruction === "dom-ops"), `loop variant '${plan.kind}' declares dom-ops row construction but received a JSX-bearing preamble — add a Phase-1 refusal (or wire renderPreamble support) for this shape`);
     stringifyLoop(lines, plan);
@@ -20380,20 +21057,20 @@ var PHASES = [
 ];
 
 // src/ir-to-client-js/rewrite-props-object.ts
-import ts15 from "typescript";
+import ts16 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 = ts15.createSourceFile("init-body.ts", code, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+  const sourceFile = ts16.createSourceFile("init-body.ts", code, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
   const spans = [];
   function visit3(node) {
-    if (ts15.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts16.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts15.forEachChild(node, visit3);
+    ts16.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0)
@@ -20409,17 +21086,17 @@ function shouldRewrite(node) {
   const parent = node.parent;
   if (!parent)
     return true;
-  if (ts15.isPropertyAccessExpression(parent) && parent.name === node)
+  if (ts16.isPropertyAccessExpression(parent) && parent.name === node)
     return false;
-  if (ts15.isPropertyAssignment(parent) && parent.name === node)
+  if (ts16.isPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts15.isShorthandPropertyAssignment(parent) && parent.name === node)
+  if (ts16.isShorthandPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts15.isPropertySignature(parent) && parent.name === node)
+  if (ts16.isPropertySignature(parent) && parent.name === node)
     return false;
-  if (ts15.isPropertyDeclaration(parent) && parent.name === node)
+  if (ts16.isPropertyDeclaration(parent) && parent.name === node)
     return false;
-  if (ts15.isBindingElement(parent) && parent.name === node)
+  if (ts16.isBindingElement(parent) && parent.name === node)
     return false;
   return true;
 }
@@ -21049,7 +21726,7 @@ function walkIR2(node, visitor) {
 }
 
 // src/preprocess-inline-jsx-callbacks.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 var SYNTHETIC_PREFIX = "BFInlineJsxCallback";
 var MAX_FIXPOINT_ITERATIONS = 16;
 function preprocessInlineJsxCallbacks(source, filePath) {
@@ -21071,8 +21748,8 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts16.createSourceFile(filePath, source, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TSX);
-  const hasUseClient = sourceFile.statements.some((stmt) => ts16.isExpressionStatement(stmt) && ts16.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
+  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'"));
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
   }
@@ -21094,22 +21771,22 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts16.isJsxAttribute(node) && node.initializer && ts16.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts17.isJsxAttribute(node) && node.initializer && ts17.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts16.isPropertyAssignment(node) && node.initializer) {
+    if (ts17.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer))
         return;
     }
-    ts16.forEachChild(node, visit3);
+    ts17.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts16.isParenthesizedExpression(expr))
+    while (ts17.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts16.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    if (ts17.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -21146,7 +21823,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name });
     return true;
   }
-  ts16.forEachChild(sourceFile, visit3);
+  ts17.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -21169,11 +21846,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 (ts16.isBlock(arrow.body)) {
+  if (ts17.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body = arrow.body;
-  while (ts16.isParenthesizedExpression(body))
+  while (ts17.isParenthesizedExpression(body))
     body = body.expression;
   return isJsxLike(body);
 }
@@ -21182,24 +21859,24 @@ function blockReturnsJsx(block) {
   function visit3(n) {
     if (found)
       return;
-    if (ts16.isReturnStatement(n) && n.expression) {
+    if (ts17.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts16.isParenthesizedExpression(e))
+      while (ts17.isParenthesizedExpression(e))
         e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts16.isArrowFunction(n) || ts16.isFunctionDeclaration(n) || ts16.isFunctionExpression(n))
+    if (ts17.isArrowFunction(n) || ts17.isFunctionDeclaration(n) || ts17.isFunctionExpression(n))
       return;
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   }
-  ts16.forEachChild(block, visit3);
+  ts17.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts16.isJsxElement(expr) || ts16.isJsxSelfClosingElement(expr) || ts16.isJsxFragment(expr);
+  return ts17.isJsxElement(expr) || ts17.isJsxSelfClosingElement(expr) || ts17.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = new Set;
@@ -21209,13 +21886,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames2(name, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts16.isIdentifier(name)) {
+  if (ts17.isIdentifier(name)) {
     push(name.text);
-  } else if (ts16.isObjectBindingPattern(name)) {
+  } else if (ts17.isObjectBindingPattern(name)) {
     name.elements.forEach((el) => collectBindingNames2(el.name, out));
-  } else if (ts16.isArrayBindingPattern(name)) {
+  } else if (ts17.isArrayBindingPattern(name)) {
     name.elements.forEach((el) => {
-      if (!ts16.isOmittedExpression(el))
+      if (!ts17.isOmittedExpression(el))
         collectBindingNames2(el.name, out);
     });
   }
@@ -21242,48 +21919,48 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name);
   }
   function visit3(node) {
-    if (ts16.isIdentifier(node)) {
+    if (ts17.isIdentifier(node)) {
       const parent = node.parent;
-      if (parent && ts16.isPropertyAccessExpression(parent) && parent.name === node)
+      if (parent && ts17.isPropertyAccessExpression(parent) && parent.name === node)
         return;
-      if (parent && ts16.isPropertyAssignment(parent) && parent.name === node)
+      if (parent && ts17.isPropertyAssignment(parent) && parent.name === node)
         return;
-      if (parent && ts16.isPropertySignature(parent) && parent.name === node)
+      if (parent && ts17.isPropertySignature(parent) && parent.name === node)
         return;
-      if (parent && ts16.isPropertyDeclaration(parent) && parent.name === node)
+      if (parent && ts17.isPropertyDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts16.isMethodDeclaration(parent) && parent.name === node)
+      if (parent && ts17.isMethodDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts16.isMethodSignature(parent) && parent.name === node)
+      if (parent && ts17.isMethodSignature(parent) && parent.name === node)
         return;
-      if (parent && ts16.isGetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts17.isGetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts16.isSetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts17.isSetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts16.isEnumMember(parent) && parent.name === node)
+      if (parent && ts17.isEnumMember(parent) && parent.name === node)
         return;
-      if (parent && ts16.isBindingElement(parent) && parent.propertyName === node)
+      if (parent && ts17.isBindingElement(parent) && parent.propertyName === node)
         return;
-      if (parent && ts16.isShorthandPropertyAssignment(parent) && parent.name === node) {
+      if (parent && ts17.isShorthandPropertyAssignment(parent) && parent.name === node) {
         if (!isBound(node.text))
           ids.add(node.text);
         return;
       }
-      if (parent && ts16.isParameter(parent) && parent.name === node)
+      if (parent && ts17.isParameter(parent) && parent.name === node)
         return;
-      if (parent && ts16.isVariableDeclaration(parent) && parent.name === node)
+      if (parent && ts17.isVariableDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts16.isFunctionDeclaration(parent) && parent.name === node)
+      if (parent && ts17.isFunctionDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts16.isClassDeclaration(parent) && parent.name === node)
+      if (parent && ts17.isClassDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts16.isJsxAttribute(parent) && parent.name === node)
+      if (parent && ts17.isJsxAttribute(parent) && parent.name === node)
         return;
-      if (parent && ts16.isJsxOpeningElement(parent) && parent.tagName === node) {
+      if (parent && ts17.isJsxOpeningElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
-      if (parent && ts16.isJsxClosingElement(parent) && parent.tagName === node) {
+      if (parent && ts17.isJsxClosingElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
@@ -21292,43 +21969,43 @@ function collectFreeIdentifiers(arrow) {
       ids.add(node.text);
       return;
     }
-    if (ts16.isVariableDeclaration(node)) {
+    if (ts17.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer)
         visit3(node.initializer);
       return;
     }
-    if (ts16.isFunctionDeclaration(node)) {
+    if (ts17.isFunctionDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts16.isClassDeclaration(node)) {
+    if (ts17.isClassDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
-      ts16.forEachChild(node, visit3);
+      ts17.forEachChild(node, visit3);
       return;
     }
-    if (ts16.isArrowFunction(node) || ts16.isFunctionExpression(node)) {
+    if (ts17.isArrowFunction(node) || ts17.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts16.isCatchClause(node)) {
+    if (ts17.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration)
         pushBindings(node.variableDeclaration.name);
-      ts16.forEachChild(node, visit3);
+      ts17.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts16.isBlock(node)) {
+    if (ts17.isBlock(node)) {
       const before = bound.length;
-      ts16.forEachChild(node, visit3);
+      ts17.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts16.forEachChild(node, visit3);
+    ts17.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -21351,29 +22028,29 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (ts16.isFunctionDeclaration(stmt) && stmt.name)
+    if (ts17.isFunctionDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts16.isClassDeclaration(stmt) && stmt.name)
+    else if (ts17.isClassDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts16.isVariableStatement(stmt)) {
+    else if (ts17.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
         collectBindingNames2(decl.name, names);
-    } else if (ts16.isImportDeclaration(stmt) && stmt.importClause) {
+    } else if (ts17.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name)
         names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts16.isNamespaceImport(ic.namedBindings))
+        if (ts17.isNamespaceImport(ic.namedBindings))
           names.add(ic.namedBindings.name.text);
         else
           for (const e of ic.namedBindings.elements)
             names.add(e.name.text);
       }
-    } else if (ts16.isTypeAliasDeclaration(stmt))
+    } else if (ts17.isTypeAliasDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts16.isInterfaceDeclaration(stmt))
+    else if (ts17.isInterfaceDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts16.isEnumDeclaration(stmt))
+    else if (ts17.isEnumDeclaration(stmt))
       names.add(stmt.name.text);
   }
   return names;
@@ -21381,7 +22058,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 (ts16.isBlock(arrow.body)) {
+  if (ts17.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -21391,7 +22068,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // src/ssr-defaults.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 function extractSsrDefaults(metadata) {
@@ -21467,11 +22144,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   if (!node)
     return;
   const visit3 = (n) => {
-    if (ts17.isPropertyAccessExpression(n) && ts17.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts17.isIdentifier(n.name)) {
+    if (ts18.isPropertyAccessExpression(n) && ts18.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts18.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts17.forEachChild(n, visit3);
+    ts18.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -21492,23 +22169,23 @@ function tryStaticEval(expr, ctx) {
 }
 function evalStatementsForReturn(statements, ctx) {
   for (const stmt of statements) {
-    if (ts17.isVariableStatement(stmt)) {
+    if (ts18.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts17.isIdentifier(d.name) || !d.initializer)
+        if (!ts18.isIdentifier(d.name) || !d.initializer)
           continue;
         const v = evalNode(d.initializer, ctx);
         if (v !== UNRESOLVED)
           ctx.bindings[d.name.text] = v;
       }
-    } else if (ts17.isReturnStatement(stmt)) {
+    } else if (ts18.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx) : UNRESOLVED;
-    } else if (ts17.isIfStatement(stmt)) {
+    } else if (ts18.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(ts17.isBlock(branch) ? branch.statements : [branch], ctx);
+        const taken = evalStatementsForReturn(ts18.isBlock(branch) ? branch.statements : [branch], ctx);
         if (taken !== NO_RETURN)
           return taken;
       }
@@ -21519,45 +22196,45 @@ function evalStatementsForReturn(statements, ctx) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts17.createSourceFile("__ssr_default__.ts", `(${expr})`, ts17.ScriptTarget.Latest, false, ts17.ScriptKind.TS);
+  const sf = ts18.createSourceFile("__ssr_default__.ts", `(${expr})`, ts18.ScriptTarget.Latest, false, ts18.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts17.isExpressionStatement(stmt))
+  if (!stmt || !ts18.isExpressionStatement(stmt))
     return null;
-  const inner = ts17.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const inner = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx) {
-  if (ts17.isParenthesizedExpression(node))
+  if (ts18.isParenthesizedExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts17.isAsExpression(node))
+  if (ts18.isAsExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts17.isSatisfiesExpression(node))
+  if (ts18.isSatisfiesExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts17.isTypeAssertionExpression(node))
+  if (ts18.isTypeAssertionExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts17.isNonNullExpression(node))
+  if (ts18.isNonNullExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts17.isArrowFunction(node)) {
+  if (ts18.isArrowFunction(node)) {
     if (node.parameters.length !== 0)
       return UNRESOLVED;
-    if (!ts17.isBlock(node.body))
+    if (!ts18.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 (ts17.isNumericLiteral(node))
+  if (ts18.isNumericLiteral(node))
     return Number(node.text);
-  if (ts17.isStringLiteralLike(node))
+  if (ts18.isStringLiteralLike(node))
     return node.text;
-  if (node.kind === ts17.SyntaxKind.TrueKeyword)
+  if (node.kind === ts18.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts17.SyntaxKind.FalseKeyword)
+  if (node.kind === ts18.SyntaxKind.FalseKeyword)
     return false;
-  if (node.kind === ts17.SyntaxKind.NullKeyword)
+  if (node.kind === ts18.SyntaxKind.NullKeyword)
     return null;
-  if (ts17.isIdentifier(node)) {
+  if (ts18.isIdentifier(node)) {
     if (node.text === "undefined")
       return;
     if (node.text in ctx.bindings)
@@ -21566,29 +22243,29 @@ function evalNode(node, ctx) {
       return;
     return UNRESOLVED;
   }
-  if (ts17.isPrefixUnaryExpression(node)) {
+  if (ts18.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx);
     if (arg === UNRESOLVED)
       return UNRESOLVED;
     switch (node.operator) {
-      case ts17.SyntaxKind.MinusToken:
+      case ts18.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts17.SyntaxKind.PlusToken:
+      case ts18.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts17.SyntaxKind.ExclamationToken:
+      case ts18.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts17.isObjectLiteralExpression(node)) {
+  if (ts18.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts17.isPropertyAssignment(prop))
+      if (!ts18.isPropertyAssignment(prop))
         return UNRESOLVED;
       let key;
-      if (ts17.isIdentifier(prop.name) || ts17.isStringLiteralLike(prop.name)) {
+      if (ts18.isIdentifier(prop.name) || ts18.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts17.isNumericLiteral(prop.name)) {
+      } else if (ts18.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -21600,10 +22277,10 @@ function evalNode(node, ctx) {
     }
     return obj;
   }
-  if (ts17.isArrayLiteralExpression(node)) {
+  if (ts18.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts17.isOmittedExpression(elem))
+      if (ts18.isOmittedExpression(elem))
         return UNRESOLVED;
       const v = evalNode(elem, ctx);
       if (v === UNRESOLVED)
@@ -21612,7 +22289,7 @@ function evalNode(node, ctx) {
     }
     return arr;
   }
-  if (ts17.isElementAccessExpression(node)) {
+  if (ts18.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx);
     if (base === undefined)
       return;
@@ -21626,17 +22303,17 @@ function evalNode(node, ctx) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : undefined;
   }
-  if (ts17.isPropertyAccessExpression(node)) {
+  if (ts18.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx);
     if (baseResult === undefined)
       return;
     return UNRESOLVED;
   }
-  if (ts17.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts17.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
+  if (ts18.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts18.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
       return ctx.bindings[node.expression.text];
     }
-    if (ts17.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts18.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
         let sep2 = ",";
@@ -21652,27 +22329,27 @@ function evalNode(node, ctx) {
     }
     return UNRESOLVED;
   }
-  if (ts17.isConditionalExpression(node)) {
+  if (ts18.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx);
     if (cond === UNRESOLVED)
       return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx) : evalNode(node.whenFalse, ctx);
   }
-  if (ts17.isBinaryExpression(node)) {
+  if (ts18.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts17.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts18.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== undefined)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts17.SyntaxKind.BarBarToken) {
+    if (op === ts18.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts17.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts18.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 === UNRESOLVED)
         return UNRESOLVED;
@@ -21685,30 +22362,30 @@ function evalNode(node, ctx) {
     if (l === UNRESOLVED || r === UNRESOLVED)
       return UNRESOLVED;
     switch (op) {
-      case ts17.SyntaxKind.PlusToken:
+      case ts18.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 ts17.SyntaxKind.MinusToken:
+      case ts18.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r === "number" ? l - r : UNRESOLVED;
-      case ts17.SyntaxKind.AsteriskToken:
+      case ts18.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r === "number" ? l * r : UNRESOLVED;
-      case ts17.SyntaxKind.SlashToken:
+      case ts18.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l / r : UNRESOLVED;
-      case ts17.SyntaxKind.PercentToken:
+      case ts18.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l % r : UNRESOLVED;
-      case ts17.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts17.SyntaxKind.EqualsEqualsToken:
+      case ts18.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts18.SyntaxKind.EqualsEqualsToken:
         return l === r;
-      case ts17.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts17.SyntaxKind.ExclamationEqualsToken:
+      case ts18.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts18.SyntaxKind.ExclamationEqualsToken:
         return l !== r;
     }
     return UNRESOLVED;
   }
-  if (ts17.isTemplateExpression(node)) {
+  if (ts18.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0)
       return node.head.text;
     let acc = node.head.text;
@@ -21720,13 +22397,13 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts17.isNoSubstitutionTemplateLiteral(node))
+  if (ts18.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // src/augment-inherited-props.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -21758,47 +22435,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts18.isCallExpression(expr))
+  if (!expr || !ts19.isCallExpression(expr))
     return null;
-  if (!ts18.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts19.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts18.isIdentifier(arg) ? arg.text : null;
+  return ts19.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts18.isCallExpression(expr))
+  if (!expr || !ts19.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts18.isStringLiteral(arg) || ts18.isNoSubstitutionTemplateLiteral(arg))
+  if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts18.isNumericLiteral(arg))
+  if (ts19.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts18.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts19.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts18.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts19.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts18.isCallExpression(expr))
+  if (!expr || !ts19.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts18.isObjectLiteralExpression(expr.arguments[0]);
+  return ts19.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts18.createSourceFile("__ctx.ts", `(${source})`, ts18.ScriptTarget.Latest, false);
+  const sf = ts19.createSourceFile("__ctx.ts", `(${source})`, ts19.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt))
+  if (!stmt || !ts19.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts18.isParenthesizedExpression(e))
+  while (ts19.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -21823,25 +22500,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts18.createSourceFile("__aug.ts", `(${s})`, ts18.ScriptTarget.Latest, false);
+    const sf = ts19.createSourceFile("__aug.ts", `(${s})`, ts19.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts18.isBinaryExpression(n) && (n.operatorToken.kind === ts18.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts18.SyntaxKind.BarBarToken)) {
+      if (ts19.isBinaryExpression(n) && (n.operatorToken.kind === ts19.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts19.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts18.isParenthesizedExpression(left))
+        while (ts19.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts18.isPropertyAccessExpression(left) && ts18.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts19.isPropertyAccessExpression(left) && ts19.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts18.isParenthesizedExpression(right))
+          while (ts19.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts18.isPrefixUnaryExpression(right))
+          if (ts19.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts18.isNumericLiteral(right) ? "number" : right.kind === ts18.SyntaxKind.TrueKeyword || right.kind === ts18.SyntaxKind.FalseKeyword ? "boolean" : ts18.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts19.isNumericLiteral(right) ? "number" : right.kind === ts19.SyntaxKind.TrueKeyword || right.kind === ts19.SyntaxKind.FalseKeyword ? "boolean" : ts19.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts18.forEachChild(n, visit3);
+      ts19.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -21952,33 +22629,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts18.createSourceFile("__const.ts", `const __x = (${source});`, ts18.ScriptTarget.Latest, false);
+  const sf = ts19.createSourceFile("__const.ts", `const __x = (${source});`, ts19.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isVariableStatement(stmt))
+  if (!stmt || !ts19.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts18.isParenthesizedExpression(init))
+  while (init && ts19.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts18.isStringLiteral(init) || ts18.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts19.isStringLiteral(init) || ts19.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts18.createSourceFile("__const.ts", `const __x = (${source});`, ts18.ScriptTarget.Latest, false);
+  const sf = ts19.createSourceFile("__const.ts", `const __x = (${source});`, ts19.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isVariableStatement(stmt))
+  if (!stmt || !ts19.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts18.isParenthesizedExpression(init))
+  while (init && ts19.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts18.isTemplateExpression(init))
+  if (!init || !ts19.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts18.isIdentifier(span.expression))
+    if (!ts19.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -22009,30 +22686,30 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts18.createSourceFile("__rec.ts", `(${constInfo.value})`, ts18.ScriptTarget.Latest, true);
+  const sf = ts19.createSourceFile("__rec.ts", `(${constInfo.value})`, ts19.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts18.isExpressionStatement(stmt))
+  if (!ts19.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts18.isParenthesizedExpression(parsed))
+  while (ts19.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts18.isObjectLiteralExpression(parsed))
+  if (!ts19.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts18.isPropertyAssignment(prop))
+    if (!ts19.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts18.isIdentifier(name) || ts18.isStringLiteral(name) || ts18.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts19.isIdentifier(name) || ts19.isStringLiteral(name) || ts19.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts18.isParenthesizedExpression(v))
+    while (ts19.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts18.isNumericLiteral(v))
+    if (ts19.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts18.isStringLiteral(v) || ts18.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -22040,28 +22717,28 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts18.createSourceFile("__join.ts", `const __x = (${source});`, ts18.ScriptTarget.Latest, false);
+  const sf = ts19.createSourceFile("__join.ts", `const __x = (${source});`, ts19.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isVariableStatement(stmt))
+  if (!stmt || !ts19.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts18.isParenthesizedExpression(node))
+  while (node && ts19.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts18.isCallExpression(node))
+  if (!node || !ts19.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts18.isPropertyAccessExpression(callee))
+  if (!ts19.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts18.isParenthesizedExpression(recv))
+  while (ts19.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts18.isArrayLiteralExpression(recv))
+  if (!ts19.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts18.isStringLiteral(el) || ts18.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts19.isStringLiteral(el) || ts19.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -22070,7 +22747,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts18.isStringLiteral(arg) || ts18.isNoSubstitutionTemplateLiteral(arg))
+    if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -22078,11 +22755,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts18.isElementAccessExpression(val))
+  if (!ts19.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts18.isIdentifier(obj) || !ts18.isIdentifier(arg))
+  if (!ts19.isIdentifier(obj) || !ts19.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -22098,35 +22775,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 = ts18.createSourceFile("__rec.ts", `(${constInfo.value})`, ts18.ScriptTarget.Latest, true);
+  const sf = ts19.createSourceFile("__rec.ts", `(${constInfo.value})`, ts19.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts18.isExpressionStatement(stmt))
+  if (!ts19.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts18.isParenthesizedExpression(parsed))
+  while (ts19.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts18.isObjectLiteralExpression(parsed))
+  if (!ts19.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts18.isPropertyAssignment(prop))
+    if (!ts19.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts18.isIdentifier(prop.name)) {
+    if (ts19.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts18.isStringLiteral(prop.name) || ts18.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts19.isStringLiteral(prop.name) || ts19.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts18.isParenthesizedExpression(v))
+    while (ts19.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts18.isNumericLiteral(v)) {
+    if (ts19.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts18.isStringLiteral(v) || ts18.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -22765,6 +23442,7 @@ function compileJSX(source, filePath, options) {
       const sortedRuntimeImports = [...runtimeImports].sort();
       const runtimeImportLine = sortedRuntimeImports.length > 0 ? `import { ${sortedRuntimeImports.join(", ")} } from '${RUNTIME_MODULE}'` : "";
       const externalImportLines = [];
+      const isUsedAsValue = makeValueUsageTest(body);
       for (const imp of ctx.imports) {
         if (imp.isTypeOnly)
           continue;
@@ -22774,7 +23452,7 @@ function compileJSX(source, filePath, options) {
           externalImportLines.push(`import '${imp.source}'`);
           continue;
         }
-        const used = imp.specifiers.filter((s2) => !s2.isDefault && !s2.isNamespace && new RegExp(`\\b${s2.alias || s2.name}\\b`).test(body)).map((s2) => s2.alias ? `${s2.name} as ${s2.alias}` : s2.name);
+        const used = imp.specifiers.filter((s2) => !s2.isDefault && !s2.isNamespace && !s2.isTypeOnly && isUsedAsValue(s2.alias || s2.name)).map((s2) => s2.alias ? `${s2.name} as ${s2.alias}` : s2.name);
         if (used.length > 0) {
           externalImportLines.push(`import { ${used.join(", ")} } from '${imp.source}'`);
         }
@@ -22810,6 +23488,8 @@ function compileJSX(source, filePath, options) {
       if (!imp.source.startsWith("./") && !imp.source.startsWith("../"))
         continue;
       for (const spec of imp.specifiers) {
+        if (spec.isTypeOnly)
+          continue;
         if (ctx.importedClientSignalNames.has(spec.alias ?? spec.name)) {
           sources.add(imp.source);
           break;
@@ -22906,7 +23586,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -22927,10 +23607,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files, options = {}) {
   const baseUrl = options.baseUrl ?? commonParent(files);
   const compilerOptions = {
-    target: ts19.ScriptTarget.Latest,
-    module: ts19.ModuleKind.ESNext,
-    moduleResolution: ts19.ModuleResolutionKind.Bundler,
-    jsx: ts19.JsxEmit.ReactJSX,
+    target: ts20.ScriptTarget.Latest,
+    module: ts20.ModuleKind.ESNext,
+    moduleResolution: ts20.ModuleResolutionKind.Bundler,
+    jsx: ts20.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -22940,7 +23620,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts19.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts20.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -23922,7 +24602,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // src/combine-client-js.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -23979,10 +24659,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts20.createSourceFile("combine.js", content, ts20.ScriptTarget.Latest, false, ts20.ScriptKind.JS);
+  const sourceFile = ts21.createSourceFile("combine.js", content, ts21.ScriptTarget.Latest, false, ts21.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts20.isImportDeclaration(stmt))
+    if (!ts21.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -23992,8 +24672,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts20.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts20.isNamedImports(bindings)) {
+    const specifier = ts21.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts21.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -24160,7 +24840,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -25445,7 +26125,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts21.createSourceFile("__attr.tsx", `(${expr})`, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TSX);
+    sf = ts22.createSourceFile("__attr.tsx", `(${expr})`, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -25453,11 +26133,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts21.isPropertyAccessExpression(n) && ts21.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts22.isPropertyAccessExpression(n) && ts22.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts21.forEachChild(n, visit3);
+    ts22.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -25527,7 +26207,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -25797,15 +26477,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts22.createSourceFile(filePath, source, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
+  const sf = ts23.createSourceFile(filePath, source, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts22.isCallExpression(node) && ts22.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts23.isCallExpression(node) && ts23.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 });
     }
-    ts22.forEachChild(node, visit3);
+    ts23.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -26113,13 +26793,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts22.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts22.ScriptTarget.Latest, true);
+    sf = ts23.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts23.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts22.isCallExpression(node) && ts22.isIdentifier(node.expression)) {
+    if (ts23.isCallExpression(node) && ts23.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -26128,7 +26808,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts22.forEachChild(node, visit3);
+    ts23.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -26805,6 +27485,7 @@ export {
   listComponentFunctions,
   jsxToIR,
   joinProfilerEvents,
+  isValueReferenceIdentifier,
   isValidHelperId,
   isSupported,
   isStringTypedOperand,
@@ -26879,6 +27560,7 @@ export {
   computeSsrSeedPlan,
   compileJSX,
   combineParentChildClientJs,
+  collectValueReferencedNames,
   collectModuleStringConsts,
   collectLoopBoundNames,
   collectContextConsumers,