@barefootjs/cli 0.31.4 → 0.31.5

package/dist/index.js

@@ -3739,7 +3739,7 @@ var init_binding_scope = __esm({
        *     qualifies, including a preamble local shadowing a module const.
        *     These call `isBound` / `boundNames()`.
        *   - REACTIVITY / SLOT-ID CLASSIFIERS (`referencesLoopParam`,
-       *     `hasReactiveAttributes`, and the `BindingEnvironment.loopParams`
+       *     `hasReactiveAttributes`, and the `BindingEnvironment.loopValueBoundNames`
        *     feed built from `makeBindingEnv`, all in `jsx-to-ir.ts`) ask
        *     "does this expression read a value that changes per row and so
        *     needs its own patchable slot" — a preamble local already gets
@@ -9404,6 +9404,7 @@ var init_types = __esm({
 });
 
 // ../jsx/src/module-exports.ts
+import ts10 from "typescript";
 function generateModuleExports(ir, extraInlineExported = /* @__PURE__ */ new Set(), rewriteRelativeImport, options2) {
   const lines = [];
   for (const constant of options2?.skipValueDeclarations ? [] : ir.metadata.localConstants) {
@@ -9491,6 +9492,52 @@ function findReachableNames(primaryRefs, declarations) {
   }
   return reachable;
 }
+function findAssignedNames(bodyText, candidates) {
+  const assigned = /* @__PURE__ */ new Set();
+  if (candidates.size === 0) return assigned;
+  const sf = ts10.createSourceFile(
+    "bf-assignment-scan.tsx",
+    bodyText,
+    ts10.ScriptTarget.Latest,
+    /* setParentNodes */
+    false,
+    ts10.ScriptKind.TSX
+  );
+  const record = (target2) => {
+    if (ts10.isIdentifier(target2) && candidates.has(target2.text)) {
+      assigned.add(target2.text);
+    }
+  };
+  const visit3 = (node) => {
+    if (ts10.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+      record(node.left);
+    } else if ((ts10.isPrefixUnaryExpression(node) || ts10.isPostfixUnaryExpression(node)) && (node.operator === ts10.SyntaxKind.PlusPlusToken || node.operator === ts10.SyntaxKind.MinusMinusToken)) {
+      record(node.operand);
+    }
+    ts10.forEachChild(node, visit3);
+  };
+  ts10.forEachChild(sf, visit3);
+  return assigned;
+}
+function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
+  let reachable = findReachableNames(primaryRefs, declarations);
+  if (mutableNames.size === 0) return reachable;
+  let seedText = primaryRefs;
+  for (let round = 0; round <= declarations.length; round++) {
+    const survivingMutables = new Set(
+      [...reachable].filter((name2) => mutableNames.has(name2))
+    );
+    if (survivingMutables.size === 0) return reachable;
+    const added = declarations.filter((d) => !reachable.has(d.name)).filter((d) => findAssignedNames(d.body, survivingMutables).size > 0).map((d) => d.name);
+    if (added.length === 0) return reachable;
+    seedText += "\n" + added.join("\n");
+    reachable = findReachableNames(seedText, declarations);
+  }
+  return reachable;
+}
+function isAssignmentOperator(kind2) {
+  return kind2 >= ts10.SyntaxKind.FirstAssignment && kind2 <= ts10.SyntaxKind.LastAssignment;
+}
 function extractFunctionParams(value2) {
   const arrowMatch = value2.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
   if (arrowMatch) {
@@ -9543,7 +9590,7 @@ var init_builtins = __esm({
 });
 
 // ../jsx/src/reactivity-checker.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 function queryType(checker, node) {
   incrementCounter("typeCheckerQueries");
   return checker.getTypeAtLocation(node);
@@ -9559,7 +9606,7 @@ function safeGetText(node) {
   }
 }
 function analyze(node, checker) {
-  if (ts10.isPropertyAccessExpression(node)) {
+  if (ts11.isPropertyAccessExpression(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -9584,7 +9631,7 @@ function analyze(node, checker) {
     }
     return NOT_REACTIVE;
   }
-  if (ts10.isIdentifier(node)) {
+  if (ts11.isIdentifier(node)) {
     try {
       const type2 = queryType(checker, node);
       if (isReactiveType(type2)) {
@@ -9597,7 +9644,7 @@ function analyze(node, checker) {
     }
     return NOT_REACTIVE;
   }
-  if (ts10.isCallExpression(node)) {
+  if (ts11.isCallExpression(node)) {
     try {
       const calleeType = queryType(checker, node.expression);
       if (isReactiveType(calleeType)) {
@@ -9611,7 +9658,7 @@ function analyze(node, checker) {
   }
   let foundChild;
   let foundChildText = "";
-  ts10.forEachChild(node, (child) => {
+  ts11.forEachChild(node, (child) => {
     if (foundChild?.isReactive) return;
     const result2 = analyze(child, checker);
     if (result2.isReactive) {
@@ -9648,7 +9695,7 @@ var init_reactivity_checker = __esm({
 });
 
 // ../jsx/src/free-refs.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function buildBindingMap(env) {
   const cached = _bindingMapCache.get(env);
   if (cached) return cached;
@@ -9682,8 +9729,8 @@ function buildBindingMap(env) {
   for (const m of env.memos) {
     map.set(m.name, "memo-getter");
   }
-  if (env.loopParams) {
-    for (const name2 of env.loopParams) map.set(name2, "render-item");
+  if (env.loopValueBoundNames) {
+    for (const name2 of env.loopValueBoundNames) map.set(name2, "render-item");
   }
   _bindingMapCache.set(env, map);
   return map;
@@ -9712,17 +9759,17 @@ function defaultBindingScope(kind2) {
 function collectIdentifiers2(node) {
   const out = [];
   const visit3 = (n, parent2) => {
-    if (ts11.isIdentifier(n)) {
-      if (parent2 && ts11.isPropertyAccessExpression(parent2) && parent2.name === n) return;
-      if (parent2 && ts11.isPropertyAssignment(parent2) && parent2.name === n) return;
-      if (parent2 && (ts11.isJsxOpeningElement(parent2) || ts11.isJsxClosingElement(parent2) || ts11.isJsxSelfClosingElement(parent2)) && parent2.tagName === n) {
+    if (ts12.isIdentifier(n)) {
+      if (parent2 && ts12.isPropertyAccessExpression(parent2) && parent2.name === n) return;
+      if (parent2 && ts12.isPropertyAssignment(parent2) && parent2.name === n) return;
+      if (parent2 && (ts12.isJsxOpeningElement(parent2) || ts12.isJsxClosingElement(parent2) || ts12.isJsxSelfClosingElement(parent2)) && parent2.tagName === n) {
         return;
       }
-      if (parent2 && ts11.isJsxAttribute(parent2) && parent2.name === n) return;
+      if (parent2 && ts12.isJsxAttribute(parent2) && parent2.name === n) return;
       out.push(n);
       return;
     }
-    ts11.forEachChild(n, (child) => visit3(child, n));
+    ts12.forEachChild(n, (child) => visit3(child, n));
   };
   visit3(node);
   return out;
@@ -9731,7 +9778,7 @@ function collectReactiveBrandRefs(node, checker) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const visit3 = (n) => {
-    if (ts11.isPropertyAccessExpression(n)) {
+    if (ts12.isPropertyAccessExpression(n)) {
       try {
         const type2 = checker.getTypeAtLocation(n);
         if (isReactiveType(type2)) {
@@ -9749,7 +9796,7 @@ function collectReactiveBrandRefs(node, checker) {
         incrementCounter("freeRefsTypeLookupFailures");
       }
     }
-    ts11.forEachChild(n, visit3);
+    ts12.forEachChild(n, visit3);
   };
   visit3(node);
   return out;
@@ -9757,17 +9804,17 @@ function collectReactiveBrandRefs(node, checker) {
 function resolveConstantInitializerRefs(c, env, visited) {
   if (c.value === void 0) return [];
   if (c.containsArrow) return [];
-  const sf = ts11.createSourceFile(
+  const sf = ts12.createSourceFile(
     "__const_init.ts",
     `const __probe = (${c.value});`,
-    ts11.ScriptTarget.Latest,
+    ts12.ScriptTarget.Latest,
     true
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts11.isVariableStatement(stmt)) return [];
+  if (!stmt || !ts12.isVariableStatement(stmt)) return [];
   const decl = stmt.declarationList.declarations[0];
   if (!decl || !decl.initializer) return [];
-  const expr = ts11.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  const expr = ts12.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
   return resolveFreeRefsInternal(expr, env, visited);
 }
 function resolveFreeRefsInternal(node, env, visited) {
@@ -9779,7 +9826,7 @@ function resolveFreeRefsInternal(node, env, visited) {
     const name2 = ident.text;
     if (env.propsObjectName === name2) {
       const parent2 = ident.parent;
-      if (parent2 && ts11.isPropertyAccessExpression(parent2) && parent2.expression === ident && parent2.name.text === "children") {
+      if (parent2 && ts12.isPropertyAccessExpression(parent2) && parent2.expression === ident && parent2.name.text === "children") {
         continue;
       }
     }
@@ -10174,7 +10221,7 @@ var init_to_locale_date_lowering = __esm({
 });
 
 // ../jsx/src/jsx-to-ir.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 function hasLeadingClientDirective(expr, sourceFile) {
   const trivia = sourceFile.text.slice(expr.pos, expr.getStart(sourceFile));
   BLOCK_COMMENT_RE2.lastIndex = 0;
@@ -10195,13 +10242,13 @@ function exprCallsReactiveGetters(expr, ctx2) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts12.isCallExpression(n) && ts12.isIdentifier(n.expression)) {
+    if (ts13.isCallExpression(n) && ts13.isIdentifier(n.expression)) {
       if (names.has(n.expression.text)) {
         found = true;
         return;
       }
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   return found;
@@ -10224,11 +10271,11 @@ function exprReferencesModuleClientSignal(expr, ctx2) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts12.isCallExpression(n) && ts12.isIdentifier(n.expression) && names.has(n.expression.text)) {
+    if (ts13.isCallExpression(n) && ts13.isIdentifier(n.expression) && names.has(n.expression.text)) {
       found = true;
       return;
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   return found;
@@ -10237,11 +10284,11 @@ function exprHasFunctionCalls(expr) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts12.isCallExpression(n)) {
+    if (ts13.isCallExpression(n)) {
       found = true;
       return;
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   return found;
@@ -10277,10 +10324,10 @@ function lowerDateCalls(text, expr, ctx2) {
   if (!matcher) return text;
   const candidates = [];
   function visit3(n) {
-    if (ts12.isCallExpression(n) && n.arguments.length === 0 && ts12.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts13.isCallExpression(n) && n.arguments.length === 0 && ts13.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   if (candidates.length === 0) return text;
@@ -10302,10 +10349,10 @@ function lowerToLocaleDateCalls(text, expr, ctx2) {
   if (!matcher) return text;
   const candidates = [];
   function visit3(n) {
-    if (ts12.isCallExpression(n) && n.arguments.length === 2 && ts12.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts13.isCallExpression(n) && n.arguments.length === 2 && ts13.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   }
   visit3(expr);
   if (candidates.length === 0) return text;
@@ -10358,10 +10405,10 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx2) {
   if (!propDepsMap || !branchVars || propDepsMap.size === 0) return void 0;
   let acc;
   function visit3(n, parent2) {
-    if (ts12.isIdentifier(n) && propDepsMap.has(n.text)) {
-      const isObjectKey = parent2 && ts12.isPropertyAssignment(parent2) && parent2.name === n;
-      const isShorthand = parent2 && ts12.isShorthandPropertyAssignment(parent2) && parent2.name === n;
-      const isAccessName = parent2 && ts12.isPropertyAccessExpression(parent2) && parent2.name === n;
+    if (ts13.isIdentifier(n) && propDepsMap.has(n.text)) {
+      const isObjectKey = parent2 && ts13.isPropertyAssignment(parent2) && parent2.name === n;
+      const isShorthand = parent2 && ts13.isShorthandPropertyAssignment(parent2) && parent2.name === n;
+      const isAccessName = parent2 && ts13.isPropertyAccessExpression(parent2) && parent2.name === n;
       if (!isObjectKey && !isShorthand && !isAccessName) {
         const deps = propDepsMap.get(n.text);
         if (deps && deps.size > 0) {
@@ -10370,7 +10417,7 @@ function collectBranchLocalPropRefsViaSubstitution(node, ctx2) {
         }
       }
     }
-    ts12.forEachChild(n, (child) => visit3(child, n));
+    ts13.forEachChild(n, (child) => visit3(child, n));
   }
   visit3(node);
   return acc;
@@ -10442,17 +10489,17 @@ function createTransformContext(analyzer) {
 function buildComponentNamespaces(ctx2) {
   const result2 = /* @__PURE__ */ new Map();
   for (const stmt of ctx2.sourceFile.statements) {
-    if (!ts12.isVariableStatement(stmt)) continue;
+    if (!ts13.isVariableStatement(stmt)) continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts12.isIdentifier(decl.name)) continue;
+      if (!decl.initializer || !ts13.isIdentifier(decl.name)) continue;
       let init = decl.initializer;
-      while (ts12.isParenthesizedExpression(init)) init = init.expression;
-      if (!ts12.isObjectLiteralExpression(init)) continue;
+      while (ts13.isParenthesizedExpression(init)) init = init.expression;
+      if (!ts13.isObjectLiteralExpression(init)) continue;
       const members = /* @__PURE__ */ new Map();
       for (const prop of init.properties) {
-        if (ts12.isShorthandPropertyAssignment(prop)) {
+        if (ts13.isShorthandPropertyAssignment(prop)) {
           members.set(prop.name.text, prop.name.text);
-        } else if (ts12.isPropertyAssignment(prop) && (ts12.isIdentifier(prop.name) || ts12.isStringLiteral(prop.name)) && ts12.isIdentifier(prop.initializer)) {
+        } else if (ts13.isPropertyAssignment(prop) && (ts13.isIdentifier(prop.name) || ts13.isStringLiteral(prop.name)) && ts13.isIdentifier(prop.initializer)) {
           members.set(prop.name.text, prop.initializer.text);
         }
       }
@@ -10464,9 +10511,9 @@ function buildComponentNamespaces(ctx2) {
   return result2;
 }
 function resolveMemberExpressionTag(tagNode, ctx2) {
-  if (!ts12.isPropertyAccessExpression(tagNode)) return null;
-  if (!ts12.isIdentifier(tagNode.expression)) return null;
-  if (!ts12.isIdentifier(tagNode.name)) return null;
+  if (!ts13.isPropertyAccessExpression(tagNode)) return null;
+  if (!ts13.isIdentifier(tagNode.expression)) return null;
+  if (!ts13.isIdentifier(tagNode.name)) return null;
   if (!ctx2._componentNamespaces) {
     ctx2._componentNamespaces = buildComponentNamespaces(ctx2);
   }
@@ -10501,7 +10548,7 @@ function makeBindingEnv(ctx2) {
     // mutated (cached on the immutable `BindingScope`) — a stable
     // snapshot even if `ctx.scope` is later reassigned by an enclosing
     // visitor frame, which swaps the instance rather than mutating it.
-    loopParams: boundNames,
+    loopValueBoundNames: boundNames,
     checker: a.checker
   };
   ctx2._bindingEnv = env;
@@ -10607,7 +10654,7 @@ function buildIRRoot(analyzer) {
   if (!analyzer.jsxReturn) return null;
   const ctx2 = createTransformContext(analyzer);
   const jsxReturn = analyzer.jsxReturn;
-  if (ts12.isJsxElement(jsxReturn) || ts12.isJsxSelfClosingElement(jsxReturn) || ts12.isJsxFragment(jsxReturn)) {
+  if (ts13.isJsxElement(jsxReturn) || ts13.isJsxSelfClosingElement(jsxReturn) || ts13.isJsxFragment(jsxReturn)) {
     const ir2 = transformNode(jsxReturn, ctx2);
     if (ir2 && needsScopeWrapper(ir2)) {
       return wrapInScopeElement(ir2);
@@ -10660,22 +10707,22 @@ function wrapInScopeElement(node) {
   };
 }
 function transformNode(node, ctx2) {
-  if (ts12.isJsxElement(node)) {
+  if (ts13.isJsxElement(node)) {
     return transformJsxElement(node, ctx2);
   }
-  if (ts12.isJsxSelfClosingElement(node)) {
+  if (ts13.isJsxSelfClosingElement(node)) {
     return transformSelfClosingElement(node, ctx2);
   }
-  if (ts12.isJsxFragment(node)) {
+  if (ts13.isJsxFragment(node)) {
     return transformFragment(node, ctx2);
   }
-  if (ts12.isJsxText(node)) {
+  if (ts13.isJsxText(node)) {
     return transformText(node, ctx2);
   }
-  if (ts12.isJsxExpression(node)) {
+  if (ts13.isJsxExpression(node)) {
     return transformExpression(node, ctx2);
   }
-  if (ts12.isConditionalExpression(node)) {
+  if (ts13.isConditionalExpression(node)) {
     return transformConditional(node, ctx2);
   }
   return null;
@@ -11054,14 +11101,14 @@ function transformSelfClosingComponent(node, ctx2, name2) {
 }
 function isTransparentFragment(node, ctx2) {
   const children2 = node.children.filter((child2) => {
-    if (ts12.isJsxText(child2)) {
+    if (ts13.isJsxText(child2)) {
       return child2.text.trim() !== "";
     }
     return true;
   });
   if (children2.length !== 1) return false;
   const child = children2[0];
-  if (!ts12.isJsxExpression(child)) return false;
+  if (!ts13.isJsxExpression(child)) return false;
   if (!child.expression) return false;
   const exprText = child.expression.getText(ctx2.sourceFile);
   if (exprText === "children") return true;
@@ -11100,7 +11147,7 @@ function transformChildren(children2, ctx2) {
   const result2 = [];
   for (let i = 0; i < children2.length; i++) {
     const child = children2[i];
-    if (ts12.isJsxExpression(child) && !child.expression) {
+    if (ts13.isJsxExpression(child) && !child.expression) {
       continue;
     }
     const transformed = transformNode(child, ctx2);
@@ -11115,10 +11162,10 @@ function transformChildren(children2, ctx2) {
 }
 function isRenderNothingLiteral(expr, ctx2) {
   let e = expr;
-  while (ts12.isParenthesizedExpression(e) || ts12.isAsExpression(e) || ts12.isSatisfiesExpression(e) || ts12.isNonNullExpression(e)) {
+  while (ts13.isParenthesizedExpression(e) || ts13.isAsExpression(e) || ts13.isSatisfiesExpression(e) || ts13.isNonNullExpression(e)) {
     e = e.expression;
   }
-  return e.kind === ts12.SyntaxKind.NullKeyword || e.kind === ts12.SyntaxKind.TrueKeyword || e.kind === ts12.SyntaxKind.FalseKeyword || ts12.isIdentifier(e) && e.text === "undefined" && !isNameBound("undefined", makeBindingEnv(ctx2));
+  return e.kind === ts13.SyntaxKind.NullKeyword || e.kind === ts13.SyntaxKind.TrueKeyword || e.kind === ts13.SyntaxKind.FalseKeyword || ts13.isIdentifier(e) && e.text === "undefined" && !isNameBound("undefined", makeBindingEnv(ctx2));
 }
 function transformText(node, ctx2) {
   const text = node.text.replace(/\s+/g, " ");
@@ -11148,7 +11195,7 @@ function transformExpressionInner(expr, ctx2, node, isClientOnly) {
     return null;
   }
   checkBareSignalOrMemoIdentifier(expr, ctx2);
-  if (ts12.isIdentifier(expr)) {
+  if (ts13.isIdentifier(expr)) {
     const jsxNode = ctx2.analyzer.jsxConstants.get(expr.text);
     if (jsxNode) {
       return transformNode(jsxNode, ctx2);
@@ -11436,35 +11483,35 @@ function transformLogicalAnd(node, ctx2) {
   };
 }
 function containsJsxInExpression(node) {
-  if (ts12.isJsxElement(node) || ts12.isJsxSelfClosingElement(node) || ts12.isJsxFragment(node)) {
+  if (ts13.isJsxElement(node) || ts13.isJsxSelfClosingElement(node) || ts13.isJsxFragment(node)) {
     return true;
   }
-  return ts12.forEachChild(node, containsJsxInExpression) ?? false;
+  return ts13.forEachChild(node, containsJsxInExpression) ?? false;
 }
 function callsJsxHelper(node, ctx2) {
   let found = false;
   const visit3 = (n) => {
     if (found) return;
-    if (ts12.isCallExpression(n) && ts12.isIdentifier(n.expression)) {
+    if (ts13.isCallExpression(n) && ts13.isIdentifier(n.expression)) {
       const name2 = n.expression.text;
       if (ctx2.analyzer.jsxFunctions.has(name2) || ctx2.analyzer.jsxMultiReturnFunctions.has(name2)) {
         found = true;
         return;
       }
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   };
   visit3(node);
   return found;
 }
 function containsAwaitExpression(node) {
-  if (ts12.isAwaitExpression(node)) return true;
-  if (ts12.isFunctionDeclaration(node) || ts12.isFunctionExpression(node) || ts12.isArrowFunction(node)) return false;
-  return ts12.forEachChild(node, containsAwaitExpression) ?? false;
+  if (ts13.isAwaitExpression(node)) return true;
+  if (ts13.isFunctionDeclaration(node) || ts13.isFunctionExpression(node) || ts13.isArrowFunction(node)) return false;
+  return ts13.forEachChild(node, containsAwaitExpression) ?? false;
 }
 function transformNullishCoalescing(node, ctx2) {
   const leftText = ctx2.getJS(node.left);
-  const isNullish = node.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken;
+  const isNullish = node.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken;
   const condition = isNullish ? `${leftText} != null` : leftText;
   const leftOrigin = {
     phase: "tick",
@@ -11511,46 +11558,46 @@ function transformNullishCoalescing(node, ctx2) {
 function assertNever2(expr) {
   const kind2 = expr?.kind;
   throw new Error(
-    `transformJsxExpression: unhandled ts.SyntaxKind ${kind2 !== void 0 ? ts12.SyntaxKind[kind2] : "unknown"} (kind=${kind2}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`
+    `transformJsxExpression: unhandled ts.SyntaxKind ${kind2 !== void 0 ? ts13.SyntaxKind[kind2] : "unknown"} (kind=${kind2}). Update spec/compiler.md Appendix A and the switch in jsx-to-ir.ts.`
   );
 }
 function transformJsxExpression(expr, ctx2, isClientOnly = false) {
   const node = expr;
   switch (node.kind) {
     // --- Transparent: unwrap and recurse ---
-    case ts12.SyntaxKind.ParenthesizedExpression:
-    case ts12.SyntaxKind.AsExpression:
-    case ts12.SyntaxKind.SatisfiesExpression:
-    case ts12.SyntaxKind.NonNullExpression:
-    case ts12.SyntaxKind.TypeAssertionExpression:
-    case ts12.SyntaxKind.PartiallyEmittedExpression:
+    case ts13.SyntaxKind.ParenthesizedExpression:
+    case ts13.SyntaxKind.AsExpression:
+    case ts13.SyntaxKind.SatisfiesExpression:
+    case ts13.SyntaxKind.NonNullExpression:
+    case ts13.SyntaxKind.TypeAssertionExpression:
+    case ts13.SyntaxKind.PartiallyEmittedExpression:
       return transformJsxExpression(node.expression, ctx2, isClientOnly);
     // --- JSX-structural: delegate to shape transformer ---
-    case ts12.SyntaxKind.JsxElement:
+    case ts13.SyntaxKind.JsxElement:
       return transformJsxElement(node, ctx2);
-    case ts12.SyntaxKind.JsxFragment:
+    case ts13.SyntaxKind.JsxFragment:
       return transformFragment(node, ctx2);
-    case ts12.SyntaxKind.JsxSelfClosingElement:
+    case ts13.SyntaxKind.JsxSelfClosingElement:
       return transformSelfClosingElement(node, ctx2);
-    case ts12.SyntaxKind.ConditionalExpression:
+    case ts13.SyntaxKind.ConditionalExpression:
       return transformConditional(node, ctx2);
-    case ts12.SyntaxKind.BinaryExpression: {
-      if (node.operatorToken.kind === ts12.SyntaxKind.AmpersandAmpersandToken) {
+    case ts13.SyntaxKind.BinaryExpression: {
+      if (node.operatorToken.kind === ts13.SyntaxKind.AmpersandAmpersandToken) {
         return transformLogicalAnd(node, ctx2);
       }
-      if ((node.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === ts12.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx2))) {
+      if ((node.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === ts13.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx2))) {
         return transformNullishCoalescing(node, ctx2);
       }
       return null;
     }
-    case ts12.SyntaxKind.CallExpression: {
+    case ts13.SyntaxKind.CallExpression: {
       const mapMethod = getMapLikeMethod(node);
       if (mapMethod) {
         const mapResult = transformMapCall(node, ctx2, isClientOnly, mapMethod);
         if (mapResult) return mapResult;
       }
       const callee = node.expression;
-      if (ts12.isIdentifier(callee)) {
+      if (ts13.isIdentifier(callee)) {
         const jsxFunc = ctx2.analyzer.jsxFunctions.get(callee.text);
         if (jsxFunc) {
           return transformJsxFunctionCall(node, jsxFunc, ctx2, isClientOnly);
@@ -11563,40 +11610,40 @@ function transformJsxExpression(expr, ctx2, isClientOnly = false) {
       return null;
     }
     // --- Scalar leaf: caller emits IRExpression ---
-    case ts12.SyntaxKind.Identifier:
-    case ts12.SyntaxKind.StringLiteral:
-    case ts12.SyntaxKind.NumericLiteral:
-    case ts12.SyntaxKind.BigIntLiteral:
-    case ts12.SyntaxKind.RegularExpressionLiteral:
-    case ts12.SyntaxKind.NoSubstitutionTemplateLiteral:
-    case ts12.SyntaxKind.TemplateExpression:
-    case ts12.SyntaxKind.TaggedTemplateExpression:
-    case ts12.SyntaxKind.TrueKeyword:
-    case ts12.SyntaxKind.FalseKeyword:
-    case ts12.SyntaxKind.NullKeyword:
-    case ts12.SyntaxKind.ThisKeyword:
-    case ts12.SyntaxKind.SuperKeyword:
-    case ts12.SyntaxKind.ImportKeyword:
-    case ts12.SyntaxKind.PropertyAccessExpression:
-    case ts12.SyntaxKind.ElementAccessExpression:
-    case ts12.SyntaxKind.PrefixUnaryExpression:
-    case ts12.SyntaxKind.PostfixUnaryExpression:
-    case ts12.SyntaxKind.TypeOfExpression:
-    case ts12.SyntaxKind.VoidExpression:
-    case ts12.SyntaxKind.DeleteExpression:
-    case ts12.SyntaxKind.NewExpression:
-    case ts12.SyntaxKind.ObjectLiteralExpression:
-    case ts12.SyntaxKind.ArrowFunction:
-    case ts12.SyntaxKind.FunctionExpression:
-    case ts12.SyntaxKind.ClassExpression:
-    case ts12.SyntaxKind.MetaProperty:
-    case ts12.SyntaxKind.ExpressionWithTypeArguments:
-    case ts12.SyntaxKind.CommaListExpression:
-    case ts12.SyntaxKind.SyntheticExpression:
-    case ts12.SyntaxKind.ArrayLiteralExpression:
+    case ts13.SyntaxKind.Identifier:
+    case ts13.SyntaxKind.StringLiteral:
+    case ts13.SyntaxKind.NumericLiteral:
+    case ts13.SyntaxKind.BigIntLiteral:
+    case ts13.SyntaxKind.RegularExpressionLiteral:
+    case ts13.SyntaxKind.NoSubstitutionTemplateLiteral:
+    case ts13.SyntaxKind.TemplateExpression:
+    case ts13.SyntaxKind.TaggedTemplateExpression:
+    case ts13.SyntaxKind.TrueKeyword:
+    case ts13.SyntaxKind.FalseKeyword:
+    case ts13.SyntaxKind.NullKeyword:
+    case ts13.SyntaxKind.ThisKeyword:
+    case ts13.SyntaxKind.SuperKeyword:
+    case ts13.SyntaxKind.ImportKeyword:
+    case ts13.SyntaxKind.PropertyAccessExpression:
+    case ts13.SyntaxKind.ElementAccessExpression:
+    case ts13.SyntaxKind.PrefixUnaryExpression:
+    case ts13.SyntaxKind.PostfixUnaryExpression:
+    case ts13.SyntaxKind.TypeOfExpression:
+    case ts13.SyntaxKind.VoidExpression:
+    case ts13.SyntaxKind.DeleteExpression:
+    case ts13.SyntaxKind.NewExpression:
+    case ts13.SyntaxKind.ObjectLiteralExpression:
+    case ts13.SyntaxKind.ArrowFunction:
+    case ts13.SyntaxKind.FunctionExpression:
+    case ts13.SyntaxKind.ClassExpression:
+    case ts13.SyntaxKind.MetaProperty:
+    case ts13.SyntaxKind.ExpressionWithTypeArguments:
+    case ts13.SyntaxKind.CommaListExpression:
+    case ts13.SyntaxKind.SyntheticExpression:
+    case ts13.SyntaxKind.ArrayLiteralExpression:
       return null;
     // --- Forbidden in render position ---
-    case ts12.SyntaxKind.AwaitExpression:
+    case ts13.SyntaxKind.AwaitExpression:
       ctx2.analyzer.errors.push(
         createError(
           ErrorCodes.STAGE_AWAIT_IN_TEMPLATE,
@@ -11612,20 +11659,20 @@ function transformJsxExpression(expr, ctx2, isClientOnly = false) {
         loc: getSourceLocation(node, ctx2.sourceFile, ctx2.filePath),
         origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
       };
-    case ts12.SyntaxKind.YieldExpression:
+    case ts13.SyntaxKind.YieldExpression:
       return null;
     // --- Unreachable at render position ---
     // Parser prevents these in well-formed sources; listed for exhaustiveness
     // so an upstream TypeScript change that repurposes one of these kinds
     // surfaces as a compile error here instead of silently drifting.
-    case ts12.SyntaxKind.SpreadElement:
-    case ts12.SyntaxKind.OmittedExpression:
-    case ts12.SyntaxKind.JsxExpression:
-    case ts12.SyntaxKind.JsxOpeningElement:
-    case ts12.SyntaxKind.JsxOpeningFragment:
-    case ts12.SyntaxKind.JsxClosingFragment:
-    case ts12.SyntaxKind.JsxAttributes:
-    case ts12.SyntaxKind.MissingDeclaration:
+    case ts13.SyntaxKind.SpreadElement:
+    case ts13.SyntaxKind.OmittedExpression:
+    case ts13.SyntaxKind.JsxExpression:
+    case ts13.SyntaxKind.JsxOpeningElement:
+    case ts13.SyntaxKind.JsxOpeningFragment:
+    case ts13.SyntaxKind.JsxClosingFragment:
+    case ts13.SyntaxKind.JsxAttributes:
+    case ts13.SyntaxKind.MissingDeclaration:
       return null;
     default:
       return assertNever2(node);
@@ -11661,15 +11708,15 @@ function transformConditionalBranch(node, ctx2) {
   };
 }
 function getMapLikeMethod(node) {
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   const name2 = node.expression.name.text;
   if (name2 === "map") return "map";
   if (name2 === "flatMap") return "flatMap";
   return null;
 }
 function isFilterCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   if (node.expression.name.text !== "filter") return null;
   if (node.arguments.length !== 1) return null;
   return {
@@ -11678,8 +11725,8 @@ function isFilterCall(node) {
   };
 }
 function isSortCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   const methodName = node.expression.name.text;
   if (methodName !== "sort" && methodName !== "toSorted") return null;
   if (node.arguments.length !== 1) return null;
@@ -11690,17 +11737,17 @@ function isSortCall(node) {
   };
 }
 function isIteratorShapeCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
   if (node.arguments.length !== 0) return null;
   const name2 = node.expression.name.text;
   if (name2 !== "entries" && name2 !== "keys" && name2 !== "values") return null;
   return { array: node.expression.expression, shape: name2 };
 }
 function isObjectIteratorCall(node) {
-  if (!ts12.isCallExpression(node)) return null;
-  if (!ts12.isPropertyAccessExpression(node.expression)) return null;
-  if (!ts12.isIdentifier(node.expression.expression)) return null;
+  if (!ts13.isCallExpression(node)) return null;
+  if (!ts13.isPropertyAccessExpression(node.expression)) return null;
+  if (!ts13.isIdentifier(node.expression.expression)) return null;
   if (node.expression.expression.text !== "Object") return null;
   if (node.arguments.length !== 1) return null;
   const name2 = node.expression.name.text;
@@ -11721,7 +11768,7 @@ function extractSortComparator(callback, _method, ctx2) {
 (reverse the operands for descending order).`
   });
   let resolvedNode = callback;
-  if (ts12.isIdentifier(callback)) {
+  if (ts13.isIdentifier(callback)) {
     const resolved = resolveSortComparatorIdentifier(callback.text, ctx2);
     if (!resolved) {
       return {
@@ -11731,7 +11778,7 @@ function extractSortComparator(callback, _method, ctx2) {
     }
     resolvedNode = resolved;
   }
-  if (!ts12.isArrowFunction(resolvedNode) && !ts12.isFunctionExpression(resolvedNode)) {
+  if (!ts13.isArrowFunction(resolvedNode) && !ts13.isFunctionExpression(resolvedNode)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
@@ -11755,11 +11802,11 @@ function resolveSortComparatorIdentifier(name2, ctx2) {
   if (constInfo && fnInfo) return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
@@ -11769,11 +11816,11 @@ function resolveCallbackMethodFunctionReferenceIdentifier(name2, analyzer) {
   if (constInfo && fnInfo) return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
@@ -11828,11 +11875,11 @@ function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_B
   return visit3(expr, bound);
 }
 function extractFilterPredicate(callback, ctx2) {
-  if (!ts12.isArrowFunction(callback)) return { result: null };
+  if (!ts13.isArrowFunction(callback)) return { result: null };
   if (callback.parameters.length < 1) return { result: null };
   const firstParam = callback.parameters[0];
-  if (!ts12.isIdentifier(firstParam.name)) {
-    if (ts12.isBlock(callback.body)) {
+  if (!ts13.isIdentifier(firstParam.name)) {
+    if (ts13.isBlock(callback.body)) {
       return {
         result: null,
         unsupportedReason: "Block body in a destructured filter param is not supported. Workaround: use an expression-body arrow, or add /* @client */."
@@ -11852,7 +11899,7 @@ function extractFilterPredicate(callback, ctx2) {
     return { result: null };
   }
   const param = firstParam.name.getText(ctx2.sourceFile);
-  if (ts12.isBlock(callback.body)) {
+  if (ts13.isBlock(callback.body)) {
     const raw2 = ctx2.getJS(callback.body);
     const statements = parseBlockBody(callback.body, ctx2.sourceFile, (n) => ctx2.getJS(n));
     if (!statements) {
@@ -11878,14 +11925,14 @@ function extractFilterPredicate(callback, ctx2) {
   return { result: { param, predicate, raw } };
 }
 function extractLoopParamBindings(pattern) {
-  if (ts12.isIdentifier(pattern)) return null;
+  if (ts13.isIdentifier(pattern)) return null;
   const bindings = [];
   let unsupported = false;
   const isIdent = (key) => {
     if (key.length === 0) return false;
     for (let i = 0; i < key.length; ) {
       const cp = key.codePointAt(i);
-      const ok = i === 0 ? ts12.isIdentifierStart(cp, ts12.ScriptTarget.Latest) : ts12.isIdentifierPart(cp, ts12.ScriptTarget.Latest);
+      const ok = i === 0 ? ts13.isIdentifierStart(cp, ts13.ScriptTarget.Latest) : ts13.isIdentifierPart(cp, ts13.ScriptTarget.Latest);
       if (!ok) return false;
       i += cp > 65535 ? 2 : 1;
     }
@@ -11896,19 +11943,19 @@ function extractLoopParamBindings(pattern) {
   };
   const walk = (p, prefix2, segments) => {
     if (unsupported) return;
-    if (ts12.isArrayBindingPattern(p)) {
+    if (ts13.isArrayBindingPattern(p)) {
       const elements3 = p.elements;
       for (let index = 0; index < elements3.length; index++) {
         if (unsupported) return;
         const el = elements3[index];
-        if (ts12.isOmittedExpression(el)) continue;
+        if (ts13.isOmittedExpression(el)) continue;
         if (el.dotDotDotToken) {
           internalInvariant(
             index === elements3.length - 1,
             "extractLoopParamBindings: array rest token in non-final position (parser should reject)"
           );
           internalInvariant(
-            ts12.isIdentifier(el.name),
+            ts13.isIdentifier(el.name),
             "extractLoopParamBindings: array rest target is not an identifier (parser should reject)"
           );
           bindings.push({
@@ -11921,7 +11968,7 @@ function extractLoopParamBindings(pattern) {
         }
         const path25 = `${prefix2}[${index}]`;
         const nextSegments = [...segments, { kind: "index", index }];
-        if (ts12.isIdentifier(el.name)) {
+        if (ts13.isIdentifier(el.name)) {
           bindings.push({ name: el.name.text, path: path25, segments: nextSegments });
         } else {
           walk(el.name, path25, nextSegments);
@@ -11940,7 +11987,7 @@ function extractLoopParamBindings(pattern) {
           "extractLoopParamBindings: object rest token in non-final position (parser should reject)"
         );
         internalInvariant(
-          ts12.isIdentifier(el.name),
+          ts13.isIdentifier(el.name),
           "extractLoopParamBindings: object rest target is not an identifier (parser should reject)"
         );
         bindings.push({
@@ -11954,14 +12001,14 @@ function extractLoopParamBindings(pattern) {
       let keyText2 = null;
       if (el.propertyName) {
         const pn = el.propertyName;
-        if (ts12.isIdentifier(pn)) keyText2 = pn.text;
-        else if (ts12.isStringLiteral(pn)) keyText2 = pn.text;
-        else if (ts12.isNumericLiteral(pn)) keyText2 = pn.text;
+        if (ts13.isIdentifier(pn)) keyText2 = pn.text;
+        else if (ts13.isStringLiteral(pn)) keyText2 = pn.text;
+        else if (ts13.isNumericLiteral(pn)) keyText2 = pn.text;
         else {
           unsupported = true;
           return;
         }
-      } else if (ts12.isIdentifier(el.name)) {
+      } else if (ts13.isIdentifier(el.name)) {
         keyText2 = el.name.text;
       } else {
         unsupported = true;
@@ -11971,14 +12018,14 @@ function extractLoopParamBindings(pattern) {
       collectedKeys.push({ key: keyText2, isIdent: keyIsIdent });
       const path25 = appendDotAccess(prefix2, keyText2);
       const nextSegments = [...segments, { kind: "field", key: keyText2, isIdent: keyIsIdent }];
-      if (ts12.isIdentifier(el.name)) {
+      if (ts13.isIdentifier(el.name)) {
         bindings.push({ name: el.name.text, path: path25, segments: nextSegments });
       } else {
         walk(el.name, path25, nextSegments);
       }
     }
   };
-  if (ts12.isArrayBindingPattern(pattern) || ts12.isObjectBindingPattern(pattern)) {
+  if (ts13.isArrayBindingPattern(pattern) || ts13.isObjectBindingPattern(pattern)) {
     walk(pattern, "", []);
     if (unsupported) return { unsupported: true };
     return bindings;
@@ -11987,7 +12034,7 @@ function extractLoopParamBindings(pattern) {
 }
 function findKeyJsxAttribute(opening) {
   for (const prop of opening.attributes.properties) {
-    if (ts12.isJsxAttribute(prop) && prop.name.getText() === "key") {
+    if (ts13.isJsxAttribute(prop) && prop.name.getText() === "key") {
       return prop;
     }
   }
@@ -12028,7 +12075,7 @@ function keyAttrValueToExpr(v) {
 function normalizeKeyExpr(expr) {
   let out = "";
   for (const tok of iterateJsTokens(expr)) {
-    if (tok.kind === ts12.SyntaxKind.WhitespaceTrivia || tok.kind === ts12.SyntaxKind.NewLineTrivia) {
+    if (tok.kind === ts13.SyntaxKind.WhitespaceTrivia || tok.kind === ts13.SyntaxKind.NewLineTrivia) {
       continue;
     }
     out += expr.slice(tok.pos, tok.end);
@@ -12040,33 +12087,33 @@ function conditionalHasExplicitNullishBranch(cond) {
 }
 function branchHasExplicitNullish(branch) {
   let b = branch;
-  while (ts12.isParenthesizedExpression(b)) b = b.expression;
-  if (b.kind === ts12.SyntaxKind.NullKeyword) return true;
-  if (ts12.isIdentifier(b) && b.text === "undefined") return true;
-  if (ts12.isConditionalExpression(b)) return conditionalHasExplicitNullishBranch(b);
+  while (ts13.isParenthesizedExpression(b)) b = b.expression;
+  if (b.kind === ts13.SyntaxKind.NullKeyword) return true;
+  if (ts13.isIdentifier(b) && b.text === "undefined") return true;
+  if (ts13.isConditionalExpression(b)) return conditionalHasExplicitNullishBranch(b);
   return false;
 }
 function classifyKeyProblem(keyAttr, checker) {
   if (!keyAttr) return "missing";
   if (!keyAttr.initializer) return "missing";
-  if (ts12.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
+  if (ts13.isJsxExpression(keyAttr.initializer) && !keyAttr.initializer.expression) {
     return "missing";
   }
   let expr;
-  if (ts12.isStringLiteral(keyAttr.initializer)) {
+  if (ts13.isStringLiteral(keyAttr.initializer)) {
     return null;
-  } else if (ts12.isJsxExpression(keyAttr.initializer)) {
+  } else if (ts13.isJsxExpression(keyAttr.initializer)) {
     expr = keyAttr.initializer.expression;
   }
   if (!expr) return null;
-  if (expr.kind === ts12.SyntaxKind.NullKeyword) return null;
-  if (ts12.isIdentifier(expr) && expr.text === "undefined") return null;
-  if (ts12.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr)) return null;
+  if (expr.kind === ts13.SyntaxKind.NullKeyword) return null;
+  if (ts13.isIdentifier(expr) && expr.text === "undefined") return null;
+  if (ts13.isConditionalExpression(expr) && conditionalHasExplicitNullishBranch(expr)) return null;
   if (checker) {
     const type2 = checker.getTypeAtLocation(expr);
     const isNullable = type2.isUnion() ? type2.types.some(
-      (t) => (t.flags & (ts12.TypeFlags.Null | ts12.TypeFlags.Undefined | ts12.TypeFlags.Void)) !== 0
-    ) : (type2.flags & (ts12.TypeFlags.Null | ts12.TypeFlags.Undefined | ts12.TypeFlags.Void)) !== 0;
+      (t) => (t.flags & (ts13.TypeFlags.Null | ts13.TypeFlags.Undefined | ts13.TypeFlags.Void)) !== 0
+    ) : (type2.flags & (ts13.TypeFlags.Null | ts13.TypeFlags.Undefined | ts13.TypeFlags.Void)) !== 0;
     if (isNullable) return "nullable-type";
   }
   return null;
@@ -12095,70 +12142,70 @@ function checkLoopKey(callback, ctx2, isNested) {
     );
   }
   let body2 = callback.body;
-  if (ts12.isBlock(body2)) {
+  if (ts13.isBlock(body2)) {
     const ret = body2.statements.find(
-      (s) => ts12.isReturnStatement(s) && s.expression != null
+      (s) => ts13.isReturnStatement(s) && s.expression != null
     );
     if (!ret?.expression) return;
     body2 = ret.expression;
   }
-  while (ts12.isParenthesizedExpression(body2)) body2 = body2.expression;
+  while (ts13.isParenthesizedExpression(body2)) body2 = body2.expression;
   function checkJsxOperand(node) {
     let n = node;
-    while (ts12.isParenthesizedExpression(n)) n = n.expression;
-    if (ts12.isJsxElement(n)) checkOpening(n.openingElement);
-    else if (ts12.isJsxSelfClosingElement(n)) checkOpening(n);
+    while (ts13.isParenthesizedExpression(n)) n = n.expression;
+    if (ts13.isJsxElement(n)) checkOpening(n.openingElement);
+    else if (ts13.isJsxSelfClosingElement(n)) checkOpening(n);
   }
-  if (ts12.isConditionalExpression(body2)) {
+  if (ts13.isConditionalExpression(body2)) {
     checkJsxOperand(body2.whenTrue);
     checkJsxOperand(body2.whenFalse);
     return;
   }
-  if (ts12.isBinaryExpression(body2) && (body2.operatorToken.kind === ts12.SyntaxKind.AmpersandAmpersandToken || body2.operatorToken.kind === ts12.SyntaxKind.BarBarToken || body2.operatorToken.kind === ts12.SyntaxKind.QuestionQuestionToken)) {
+  if (ts13.isBinaryExpression(body2) && (body2.operatorToken.kind === ts13.SyntaxKind.AmpersandAmpersandToken || body2.operatorToken.kind === ts13.SyntaxKind.BarBarToken || body2.operatorToken.kind === ts13.SyntaxKind.QuestionQuestionToken)) {
     checkJsxOperand(body2.left);
     checkJsxOperand(body2.right);
     return;
   }
-  if (ts12.isJsxElement(body2)) {
+  if (ts13.isJsxElement(body2)) {
     checkOpening(body2.openingElement);
     return;
   }
-  if (ts12.isJsxSelfClosingElement(body2)) {
+  if (ts13.isJsxSelfClosingElement(body2)) {
     checkOpening(body2);
     return;
   }
 }
 function flatMapProjectionCall(body2) {
   let expr;
-  if (ts12.isBlock(body2)) {
+  if (ts13.isBlock(body2)) {
     const real = body2.statements;
-    if (real.length !== 1 || !ts12.isReturnStatement(real[0]) || !real[0].expression) return null;
+    if (real.length !== 1 || !ts13.isReturnStatement(real[0]) || !real[0].expression) return null;
     expr = real[0].expression;
   } else {
     expr = body2;
   }
-  while (ts12.isParenthesizedExpression(expr)) expr = expr.expression;
-  if (!ts12.isCallExpression(expr)) return null;
+  while (ts13.isParenthesizedExpression(expr)) expr = expr.expression;
+  if (!ts13.isCallExpression(expr)) return null;
   if (!getMapLikeMethod(expr)) return null;
   const cb = expr.arguments[0];
-  if (!cb || !ts12.isArrowFunction(cb) && !ts12.isFunctionExpression(cb)) return null;
+  if (!cb || !ts13.isArrowFunction(cb) && !ts13.isFunctionExpression(cb)) return null;
   for (const p of cb.parameters) {
-    if (!ts12.isIdentifier(p.name)) return null;
+    if (!ts13.isIdentifier(p.name)) return null;
   }
   let innerBody = cb.body;
-  if (ts12.isBlock(innerBody)) {
+  if (ts13.isBlock(innerBody)) {
     const ret = innerBody.statements.find(
-      (s) => ts12.isReturnStatement(s) && s.expression != null
+      (s) => ts13.isReturnStatement(s) && s.expression != null
     );
     if (innerBody.statements.length !== 1 || !ret?.expression) return null;
     innerBody = ret.expression;
   }
-  while (ts12.isParenthesizedExpression(innerBody)) innerBody = innerBody.expression;
+  while (ts13.isParenthesizedExpression(innerBody)) innerBody = innerBody.expression;
   const isElementish = (n) => {
     let m = n;
-    while (ts12.isParenthesizedExpression(m)) m = m.expression;
-    if (ts12.isJsxElement(m) || ts12.isJsxSelfClosingElement(m)) return leafIsWirelessElement(m);
-    if (ts12.isConditionalExpression(m)) return isElementish(m.whenTrue) && isElementish(m.whenFalse);
+    while (ts13.isParenthesizedExpression(m)) m = m.expression;
+    if (ts13.isJsxElement(m) || ts13.isJsxSelfClosingElement(m)) return leafIsWirelessElement(m);
+    if (ts13.isConditionalExpression(m)) return isElementish(m.whenTrue) && isElementish(m.whenFalse);
     return false;
   };
   if (!isElementish(innerBody)) return null;
@@ -12168,19 +12215,19 @@ function leafIsWirelessElement(el) {
   let ok = true;
   const visit3 = (n) => {
     if (!ok) return;
-    if (ts12.isJsxOpeningElement(n) || ts12.isJsxSelfClosingElement(n)) {
+    if (ts13.isJsxOpeningElement(n) || ts13.isJsxSelfClosingElement(n)) {
       const tagNode = n.tagName;
-      const isIntrinsic = ts12.isIdentifier(tagNode) ? !/^[A-Z]/.test(tagNode.text) : ts12.isJsxNamespacedName(tagNode);
+      const isIntrinsic = ts13.isIdentifier(tagNode) ? !/^[A-Z]/.test(tagNode.text) : ts13.isJsxNamespacedName(tagNode);
       if (!isIntrinsic) {
         ok = false;
         return;
       }
       for (const attr of n.attributes.properties) {
-        if (ts12.isJsxSpreadAttribute(attr)) {
+        if (ts13.isJsxSpreadAttribute(attr)) {
           ok = false;
           return;
         }
-        if (ts12.isJsxAttribute(attr)) {
+        if (ts13.isJsxAttribute(attr)) {
           const name2 = attr.name.getText();
           if (/^on[A-Z]/.test(name2)) {
             ok = false;
@@ -12189,11 +12236,11 @@ function leafIsWirelessElement(el) {
         }
       }
     }
-    if (ts12.isCallExpression(n) && getMapLikeMethod(n) && containsJsxInExpression(n)) {
+    if (ts13.isCallExpression(n) && getMapLikeMethod(n) && containsJsxInExpression(n)) {
       ok = false;
       return;
     }
-    ts12.forEachChild(n, visit3);
+    ts13.forEachChild(n, visit3);
   };
   visit3(el);
   return ok;
@@ -12397,7 +12444,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   let children2 = [];
   let paramBindings;
   let flatMapCallback;
-  if (ts12.isArrowFunction(callback)) {
+  if (ts13.isArrowFunction(callback)) {
     if (callback.parameters.length > 0) {
       const firstParam = callback.parameters[0];
       param = firstParam.name.getText(ctx2.sourceFile);
@@ -12405,11 +12452,11 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         paramType = firstParam.type.getText(ctx2.sourceFile);
       }
       const isEntriesShape = iterationShape === "entries" || objectIteration === "entries";
-      if (isEntriesShape && ts12.isArrayBindingPattern(firstParam.name)) {
+      if (isEntriesShape && ts13.isArrayBindingPattern(firstParam.name)) {
         const elements2 = firstParam.name.elements.filter(
-          (el) => !ts12.isOmittedExpression(el)
+          (el) => !ts13.isOmittedExpression(el)
         );
-        if (elements2.length === 2 && ts12.isBindingElement(elements2[0]) && ts12.isIdentifier(elements2[0].name) && ts12.isBindingElement(elements2[1]) && ts12.isIdentifier(elements2[1].name)) {
+        if (elements2.length === 2 && ts13.isBindingElement(elements2[0]) && ts13.isIdentifier(elements2[0].name) && ts13.isBindingElement(elements2[1]) && ts13.isIdentifier(elements2[1].name)) {
           index = elements2[0].name.text;
           param = elements2[1].name.text;
         } else {
@@ -12450,9 +12497,9 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
     ctx2.scope = ctx2.scope.enterLoopRow({ param, index, paramBindings });
     ctx2.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
-      if (!ts12.isBinaryExpression(expr)) return;
+      if (!ts13.isBinaryExpression(expr)) return;
       const op = expr.operatorToken.kind;
-      if (op !== ts12.SyntaxKind.AmpersandAmpersandToken && op !== ts12.SyntaxKind.BarBarToken && op !== ts12.SyntaxKind.QuestionQuestionToken) {
+      if (op !== ts13.SyntaxKind.AmpersandAmpersandToken && op !== ts13.SyntaxKind.BarBarToken && op !== ts13.SyntaxKind.QuestionQuestionToken) {
         return;
       }
       if (!containsJsxInExpression(expr) && !callsJsxHelper(expr, ctx2)) return;
@@ -12460,33 +12507,33 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
       if (transformed) children2 = [transformed];
     };
     const body2 = callback.body;
-    if (ts12.isJsxElement(body2) || ts12.isJsxSelfClosingElement(body2) || ts12.isJsxFragment(body2)) {
+    if (ts13.isJsxElement(body2) || ts13.isJsxSelfClosingElement(body2) || ts13.isJsxFragment(body2)) {
       const transformed = transformNode(body2, ctx2);
       if (transformed) {
         children2 = [transformed];
       }
-    } else if (ts12.isConditionalExpression(body2)) {
+    } else if (ts13.isConditionalExpression(body2)) {
       children2 = [transformConditional(body2, ctx2)];
-    } else if (ts12.isParenthesizedExpression(body2)) {
+    } else if (ts13.isParenthesizedExpression(body2)) {
       let inner = body2.expression;
-      while (ts12.isParenthesizedExpression(inner)) {
+      while (ts13.isParenthesizedExpression(inner)) {
         inner = inner.expression;
       }
-      if (ts12.isJsxElement(inner) || ts12.isJsxSelfClosingElement(inner) || ts12.isJsxFragment(inner)) {
+      if (ts13.isJsxElement(inner) || ts13.isJsxSelfClosingElement(inner) || ts13.isJsxFragment(inner)) {
         const transformed = transformNode(inner, ctx2);
         if (transformed) {
           children2 = [transformed];
         }
-      } else if (ts12.isConditionalExpression(inner)) {
+      } else if (ts13.isConditionalExpression(inner)) {
         children2 = [transformConditional(inner, ctx2)];
-      } else if (method2 === "flatMap" && ts12.isArrayLiteralExpression(inner)) {
+      } else if (method2 === "flatMap" && ts13.isArrayLiteralExpression(inner)) {
         children2 = transformArrayLiteralChildren(inner, ctx2);
       } else {
         tryTransformRenderableBody(inner);
       }
-    } else if (method2 === "flatMap" && ts12.isArrayLiteralExpression(body2)) {
+    } else if (method2 === "flatMap" && ts13.isArrayLiteralExpression(body2)) {
       children2 = transformArrayLiteralChildren(body2, ctx2);
-    } else if (ts12.isBlock(body2)) {
+    } else if (ts13.isBlock(body2)) {
       const multiReturn = method2 !== "flatMap" ? extractMultiReturnJsxBranches(body2, true) : null;
       if (multiReturn && multiReturn.branches.length > 0) {
         const loc = getSourceLocation(body2, ctx2.sourceFile, ctx2.filePath);
@@ -12507,7 +12554,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         }
       }
       const returnStmt = children2.length === 0 ? body2.statements.find(
-        (s) => ts12.isReturnStatement(s) && s.expression != null
+        (s) => ts13.isReturnStatement(s) && s.expression != null
       ) : void 0;
       let rowScopeBeforePreamble = null;
       if (returnStmt) {
@@ -12528,10 +12575,10 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
       }
       if (returnStmt && returnStmt.expression) {
         let returnExpr = returnStmt.expression;
-        while (ts12.isParenthesizedExpression(returnExpr)) {
+        while (ts13.isParenthesizedExpression(returnExpr)) {
           returnExpr = returnExpr.expression;
         }
-        if (ts12.isJsxElement(returnExpr) || ts12.isJsxSelfClosingElement(returnExpr) || ts12.isJsxFragment(returnExpr)) {
+        if (ts13.isJsxElement(returnExpr) || ts13.isJsxSelfClosingElement(returnExpr) || ts13.isJsxFragment(returnExpr)) {
           const transformed = transformNode(returnExpr, ctx2);
           if (transformed) {
             children2 = [transformed];
@@ -12635,7 +12682,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         }
       }
     }
-    if (method2 === "flatMap" && children2.length === 0 && !flatMapCallback && !ts12.isBlock(body2)) {
+    if (method2 === "flatMap" && children2.length === 0 && !flatMapCallback && !ts13.isBlock(body2)) {
       flatMapCallback = buildFlatMapCallback(callback, body2, ctx2);
     }
     if (flatMapCallback) preamble = void 0;
@@ -12658,7 +12705,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   }
   if (children2.length === 0 && !flatMapCallback) {
     const cb = node.arguments[0];
-    const cbBody = cb && (ts12.isArrowFunction(cb) || ts12.isFunctionExpression(cb)) ? cb.body : void 0;
+    const cbBody = cb && (ts13.isArrowFunction(cb) || ts13.isFunctionExpression(cb)) ? cb.body : void 0;
     if (cbBody && containsJsxInExpression(cbBody) && ctx2.analyzer.errors.length === diagCountAtEntry) {
       ctx2.analyzer.errors.push(
         createError(
@@ -12675,7 +12722,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
     }
     return null;
   }
-  if (ts12.isArrowFunction(node.arguments[0]) && children2.length > 0) {
+  if (ts13.isArrowFunction(node.arguments[0]) && children2.length > 0) {
     checkLoopKey(node.arguments[0], ctx2, isNested);
   }
   const itemConditional = children2.length > 0 ? loopBodyItemConditional(children2) : null;
@@ -12733,6 +12780,9 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
   const preambleRegions = preamble && !isStaticArray ? collectPreambleRegions(children2, new Set(preamble.declaredNames), ctx2) : void 0;
   if (preamble && !isStaticArray) {
     markPreambleAttrSlots(children2, new Set(preamble.declaredNames), ctx2);
+    if (preamble.reactiveNames && preamble.reactiveNames.length > 0) {
+      markPreambleConditionalReactivity(children2, new Set(preamble.reactiveNames), ctx2);
+    }
   }
   const nestedComponents = collectNestedComponents(children2).filter((c) => c.name !== childComponent?.name);
   return {
@@ -12783,10 +12833,10 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
 function transformArrayLiteralChildren(arrayLiteral, ctx2) {
   const children2 = [];
   for (const element of arrayLiteral.elements) {
-    if (ts12.isSpreadElement(element)) continue;
+    if (ts13.isSpreadElement(element)) continue;
     let inner = element;
-    while (ts12.isParenthesizedExpression(inner)) inner = inner.expression;
-    if (ts12.isJsxElement(inner) || ts12.isJsxSelfClosingElement(inner) || ts12.isJsxFragment(inner)) {
+    while (ts13.isParenthesizedExpression(inner)) inner = inner.expression;
+    if (ts13.isJsxElement(inner) || ts13.isJsxSelfClosingElement(inner) || ts13.isJsxFragment(inner)) {
       const transformed = transformNode(inner, ctx2);
       if (transformed) children2.push(transformed);
     }
@@ -12794,7 +12844,7 @@ function transformArrayLiteralChildren(arrayLiteral, ctx2) {
   return children2;
 }
 function containsJsx(node) {
-  if (ts12.isJsxElement(node) || ts12.isJsxSelfClosingElement(node) || ts12.isJsxFragment(node)) return true;
+  if (ts13.isJsxElement(node) || ts13.isJsxSelfClosingElement(node) || ts13.isJsxFragment(node)) return true;
   let found = false;
   node.forEachChild((child) => {
     if (!found) found = containsJsx(child);
@@ -12807,14 +12857,14 @@ function buildFlatMapCallback(callback, body2, ctx2) {
   const leafIrs = [];
   let refusalNode;
   const collectJsx = (n, underTemplate) => {
-    if (ts12.isJsxElement(n) || ts12.isJsxSelfClosingElement(n) || ts12.isJsxFragment(n)) {
+    if (ts13.isJsxElement(n) || ts13.isJsxSelfClosingElement(n) || ts13.isJsxFragment(n)) {
       if (underTemplate) refusalNode ??= n;
       leafSpans.push({ start: n.getStart(ctx2.sourceFile), end: n.getEnd() });
       const ir = transformNode(n, ctx2);
       leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx2.sourceFile, ctx2.filePath) });
       return;
     }
-    const inTemplate = underTemplate || ts12.isTemplateExpression(n) || ts12.isTaggedTemplateExpression(n);
+    const inTemplate = underTemplate || ts13.isTemplateExpression(n) || ts13.isTaggedTemplateExpression(n);
     n.forEachChild((c) => collectJsx(c, inTemplate));
   };
   collectJsx(body2, false);
@@ -12999,6 +13049,31 @@ function markPreambleAttrSlots(nodes, declared, ctx2) {
   };
   visit3(nodes);
 }
+function markPreambleConditionalReactivity(nodes, reactiveNames, ctx2) {
+  if (reactiveNames.size === 0) return;
+  const visit3 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "element":
+        case "fragment":
+          visit3(node.children);
+          break;
+        case "conditional": {
+          if (!node.reactive) {
+            const refs = extractFreeIdentifiersFromText(node.condition);
+            if ([...refs].some((r2) => reactiveNames.has(r2))) {
+              node.reactive = true;
+              if (!node.slotId) node.slotId = generateSlotId(ctx2);
+            }
+          }
+          visit3([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+        }
+      }
+    }
+  };
+  visit3(nodes);
+}
 function attrValueText(value2) {
   if (value2.kind === "expression") return value2.expr;
   if (value2.kind !== "template") return "";
@@ -13010,23 +13085,42 @@ function attrValueText(value2) {
   return out.join(" ");
 }
 function collectBindingNames2(name2, out) {
-  if (ts12.isIdentifier(name2)) {
+  if (ts13.isIdentifier(name2)) {
     out.add(name2.text);
     return;
   }
   for (const el of name2.elements) {
-    if (ts12.isBindingElement(el)) collectBindingNames2(el.name, out);
+    if (ts13.isBindingElement(el)) collectBindingNames2(el.name, out);
   }
 }
 function collectPreambleDeclaredNames(stmt, out) {
-  if (ts12.isVariableStatement(stmt)) {
+  if (ts13.isVariableStatement(stmt)) {
     for (const decl of stmt.declarationList.declarations) {
       collectBindingNames2(decl.name, out);
     }
-  } else if (ts12.isFunctionDeclaration(stmt) && stmt.name) {
+  } else if (ts13.isFunctionDeclaration(stmt) && stmt.name) {
     out.add(stmt.name.text);
   }
 }
+function computePreambleReactiveNames(statements, ctx2) {
+  const reactiveNames = /* @__PURE__ */ new Set();
+  for (const stmt of statements) {
+    if (!ts13.isVariableStatement(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!decl.initializer) continue;
+      const boundNames = /* @__PURE__ */ new Set();
+      collectBindingNames2(decl.name, boundNames);
+      const initText = ctx2.getJS(decl.initializer);
+      const initFreeRefs = extractFreeIdentifiersFromNode(decl.initializer);
+      const readsEarlierReactive = [...initFreeRefs].some((r2) => reactiveNames.has(r2));
+      const isReactive = readsEarlierReactive || isReactiveExpression(initText, ctx2, decl.initializer);
+      if (isReactive) {
+        for (const n of boundNames) reactiveNames.add(n);
+      }
+    }
+  }
+  return reactiveNames;
+}
 function preambleFromValueStatements(statements, ctx2) {
   const segments = [];
   const typedParts = [];
@@ -13041,21 +13135,23 @@ function preambleFromValueStatements(statements, ctx2) {
     typedParts.push(raw0.endsWith(";") ? raw0 : raw0 + ";");
     segments.push(tjs !== js ? { kind: "js", text: js, templateText: tjs } : { kind: "js", text: js });
   }
+  const reactiveNames = computePreambleReactiveNames(statements, ctx2);
   return {
     segments: trimPreambleSegments(segments),
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
     // Value-only preambles accumulate no JSX, so no child needs the array join.
     builderNames: [],
-    declarations: neutralPreambleDeclarations(statements, ctx2) ?? void 0
+    declarations: neutralPreambleDeclarations(statements, ctx2) ?? void 0,
+    reactiveNames: reactiveNames.size > 0 ? [...reactiveNames] : void 0
   };
 }
 function neutralPreambleDeclarations(statements, ctx2) {
   const out = [];
   for (const stmt of statements) {
-    if (!ts12.isVariableStatement(stmt)) return null;
+    if (!ts13.isVariableStatement(stmt)) return null;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts12.isIdentifier(decl.name)) return null;
+      if (!ts13.isIdentifier(decl.name)) return null;
       if (!decl.initializer) return null;
       const valueParsed = tsNodeToParsedExpr(decl.initializer);
       if (!isSupported(valueParsed).supported) return null;
@@ -13085,11 +13181,11 @@ function buildPreambleSegments(statements, returnStmt, ctx2) {
   let refusalNode;
   const recordBuilderTarget = (leaf, stmt) => {
     for (let n = leaf.parent; n && n !== stmt.parent; n = n.parent) {
-      if (ts12.isCallExpression(n) && ts12.isPropertyAccessExpression(n.expression) && (n.expression.name.text === "push" || n.expression.name.text === "unshift") && ts12.isIdentifier(n.expression.expression)) {
+      if (ts13.isCallExpression(n) && ts13.isPropertyAccessExpression(n.expression) && (n.expression.name.text === "push" || n.expression.name.text === "unshift") && ts13.isIdentifier(n.expression.expression)) {
         builders.add(n.expression.expression.text);
         return;
       }
-      if (ts12.isVariableDeclaration(n) && ts12.isIdentifier(n.name)) {
+      if (ts13.isVariableDeclaration(n) && ts13.isIdentifier(n.name)) {
         builders.add(n.name.text);
         return;
       }
@@ -13101,7 +13197,7 @@ function buildPreambleSegments(statements, returnStmt, ctx2) {
     const leafSpans = [];
     const leafIrs = [];
     const collect = (n, underTemplate) => {
-      if (ts12.isJsxElement(n) || ts12.isJsxSelfClosingElement(n) || ts12.isJsxFragment(n)) {
+      if (ts13.isJsxElement(n) || ts13.isJsxSelfClosingElement(n) || ts13.isJsxFragment(n)) {
         if (underTemplate) refusalNode ??= n;
         recordBuilderTarget(n, stmt);
         leafSpans.push({ start: n.getStart(ctx2.sourceFile), end: n.getEnd() });
@@ -13110,7 +13206,7 @@ function buildPreambleSegments(statements, returnStmt, ctx2) {
         leafIrs.push(ir ?? { type: "text", value: "", loc: getSourceLocation(n, ctx2.sourceFile, ctx2.filePath) });
         return;
       }
-      const inTemplate = underTemplate || ts12.isTemplateExpression(n) || ts12.isTaggedTemplateExpression(n);
+      const inTemplate = underTemplate || ts13.isTemplateExpression(n) || ts13.isTaggedTemplateExpression(n);
       n.forEachChild((c) => collect(c, inTemplate));
     };
     collect(stmt, false);
@@ -13214,13 +13310,13 @@ function expandSpreadAttribute(attr, ctx2) {
   }];
 }
 function attrFreeIdentifiers(attr) {
-  if (!attr.initializer || !ts12.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !ts13.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return void 0;
   }
   return extractFreeIdentifiersFromNode(attr.initializer.expression);
 }
 function computeReactivityFlags(attr, ctx2) {
-  if (!attr.initializer || !ts12.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
+  if (!attr.initializer || !ts13.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
     return {};
   }
   const expr = attr.initializer.expression;
@@ -13251,21 +13347,21 @@ function processAttributes(attributes2, ctx2) {
   const events = [];
   let ref = null;
   for (const attr of attributes2.properties) {
-    if (ts12.isJsxSpreadAttribute(attr)) {
+    if (ts13.isJsxSpreadAttribute(attr)) {
       attrs.push(...expandSpreadAttribute(attr, ctx2));
       continue;
     }
-    if (!ts12.isJsxAttribute(attr)) continue;
+    if (!ts13.isJsxAttribute(attr)) continue;
     const rawName = attr.name.getText(ctx2.sourceFile);
     if (rawName === "ref") {
-      if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx2);
         ref = ctx2.getJS(attr.initializer.expression);
       }
       continue;
     }
     if (/^on[A-Z]/.test(rawName)) {
-      if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+      if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         const eventName = rawName.slice(2).toLowerCase();
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx2);
         events.push({
@@ -13280,7 +13376,7 @@ function processAttributes(attributes2, ctx2) {
     const name2 = toHTMLAttrName(rawName);
     let value2 = getAttributeValue(attr, ctx2);
     let clientOnly;
-    if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       if (value2.kind === "expression" && value2.templateExpr === void 0) {
         const rewritten = rewriteBarePropRefs2(value2.expr, attr.initializer.expression, ctx2);
         if (rewritten !== value2.expr) {
@@ -13307,19 +13403,19 @@ function getAttributeValue(attr, ctx2) {
   if (!attr.initializer) {
     return AttrValueOf.booleanAttr();
   }
-  if (ts12.isStringLiteral(attr.initializer)) {
+  if (ts13.isStringLiteral(attr.initializer)) {
     return AttrValueOf.literal(decodeEntities(attr.initializer.text));
   }
-  if (ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+  if (ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     let expr = attr.initializer.expression;
-    if (ts12.isIdentifier(expr)) {
+    if (ts13.isIdentifier(expr)) {
       const branchInit = ctx2._branchScopeVars?.get(expr.text);
       if (branchInit && !initializerShapeContainsJsx(branchInit)) {
         expr = branchInit;
       }
     }
     expr = tryDesugarInterleaveTaggedTemplate(expr, ctx2);
-    if (ts12.isAwaitExpression(expr)) {
+    if (ts13.isAwaitExpression(expr)) {
       ctx2.analyzer.errors.push(
         createError(
           ErrorCodes.STAGE_AWAIT_IN_TEMPLATE,
@@ -13329,38 +13425,38 @@ function getAttributeValue(attr, ctx2) {
       return AttrValueOf.expression("undefined");
     }
     checkBareSignalOrMemoIdentifier(expr, ctx2);
-    if (attr.name.getText(ctx2.sourceFile) === "style" && ts12.isObjectLiteralExpression(expr)) {
+    if (attr.name.getText(ctx2.sourceFile) === "style" && ts13.isObjectLiteralExpression(expr)) {
       const cssString = tryStaticStyleObjectToCss(expr);
       if (cssString !== null) {
         return AttrValueOf.literal(cssString);
       }
     }
-    if (ts12.isTemplateExpression(expr)) {
+    if (ts13.isTemplateExpression(expr)) {
       const parts = parseTemplateLiteral(expr, ctx2);
       if (parts.some((p) => p.type === "ternary" || p.type === "lookup")) {
         return AttrValueOf.template(parts);
       }
     }
-    if (ts12.isElementAccessExpression(expr) && !ts12.isStringLiteralLike(expr.argumentExpression) && !ts12.isNumericLiteral(expr.argumentExpression)) {
+    if (ts13.isElementAccessExpression(expr) && !ts13.isStringLiteralLike(expr.argumentExpression) && !ts13.isNumericLiteral(expr.argumentExpression)) {
       const parts = tryResolveTemplateSpanFromConst(expr, ctx2);
       if (parts) {
         return AttrValueOf.template(parts);
       }
     }
-    if (ts12.isIdentifier(expr)) {
+    if (ts13.isIdentifier(expr)) {
       const resolved = tryResolveIdentifierAsTemplateLiteral(expr, ctx2);
       if (resolved) {
         return AttrValueOf.template(resolved);
       }
     }
-    if (ts12.isConditionalExpression(expr)) {
+    if (ts13.isConditionalExpression(expr)) {
       const ternary = parseTernary(expr, ctx2);
       if (ternary) {
         return AttrValueOf.template([ternary]);
       }
     }
-    if (ts12.isBinaryExpression(expr) && expr.operatorToken.kind === ts12.SyntaxKind.BarBarToken) {
-      if (ts12.isIdentifier(expr.right) && expr.right.text === "undefined") {
+    if (ts13.isBinaryExpression(expr) && expr.operatorToken.kind === ts13.SyntaxKind.BarBarToken) {
+      if (ts13.isIdentifier(expr.right) && expr.right.text === "undefined") {
         const baseExpr = ctx2.getJS(expr.left);
         return AttrValueOf.expression(baseExpr, { presenceOrUndefined: true });
       }
@@ -13373,9 +13469,9 @@ function getAttributeValue(attr, ctx2) {
 function tryStaticStyleObjectToCss(expr) {
   const parts = [];
   for (const prop of expr.properties) {
-    if (!ts12.isPropertyAssignment(prop)) return null;
-    if (!ts12.isIdentifier(prop.name) && !ts12.isStringLiteral(prop.name)) return null;
-    if (!ts12.isStringLiteral(prop.initializer)) return null;
+    if (!ts13.isPropertyAssignment(prop)) return null;
+    if (!ts13.isIdentifier(prop.name) && !ts13.isStringLiteral(prop.name)) return null;
+    if (!ts13.isStringLiteral(prop.initializer)) return null;
     const key = cssKebabCase(prop.name.text);
     parts.push(`${key}:${prop.initializer.text}`);
   }
@@ -13387,7 +13483,7 @@ function parseTemplateLiteral(expr, ctx2) {
     parts.push({ type: "string", value: expr.head.text });
   }
   for (const span of expr.templateSpans) {
-    if (ts12.isConditionalExpression(span.expression)) {
+    if (ts13.isConditionalExpression(span.expression)) {
       const ternary = parseTernary(span.expression, ctx2);
       if (ternary) {
         parts.push(ternary);
@@ -13413,31 +13509,31 @@ function parseTemplateLiteral(expr, ctx2) {
   return parts;
 }
 function tryResolveTemplateSpanFromConst(expr, ctx2) {
-  if (ts12.isIdentifier(expr)) {
+  if (ts13.isIdentifier(expr)) {
     if (ctx2.scope.isBound(expr.text)) return null;
     const constInfo = findLocalConst(expr.text, ctx2.analyzer);
     if (!constInfo) return null;
     const ast = parseConstInitializer(constInfo);
     if (!ast) return null;
-    if (ts12.isStringLiteral(ast) || ts12.isNoSubstitutionTemplateLiteral(ast)) {
+    if (ts13.isStringLiteral(ast) || ts13.isNoSubstitutionTemplateLiteral(ast)) {
       return [{ type: "string", value: ast.text }];
     }
     return null;
   }
-  if (ts12.isElementAccessExpression(expr)) {
-    if (!ts12.isIdentifier(expr.expression)) return null;
+  if (ts13.isElementAccessExpression(expr)) {
+    if (!ts13.isIdentifier(expr.expression)) return null;
     if (ctx2.scope.isBound(expr.expression.text)) return null;
     const constInfo = findLocalConst(expr.expression.text, ctx2.analyzer);
     if (!constInfo) return null;
     const ast = parseConstInitializer(constInfo);
-    if (!ast || !ts12.isObjectLiteralExpression(ast)) return null;
+    if (!ast || !ts13.isObjectLiteralExpression(ast)) return null;
     const cases = {};
     for (const prop of ast.properties) {
-      if (!ts12.isPropertyAssignment(prop)) return null;
-      const keyName = prop.name && (ts12.isStringLiteral(prop.name) || ts12.isIdentifier(prop.name)) ? prop.name.text : null;
+      if (!ts13.isPropertyAssignment(prop)) return null;
+      const keyName = prop.name && (ts13.isStringLiteral(prop.name) || ts13.isIdentifier(prop.name)) ? prop.name.text : null;
       if (!keyName) return null;
       const value2 = prop.initializer;
-      if (ts12.isStringLiteral(value2) || ts12.isNoSubstitutionTemplateLiteral(value2)) {
+      if (ts13.isStringLiteral(value2) || ts13.isNoSubstitutionTemplateLiteral(value2)) {
         cases[keyName] = value2.text;
       } else {
         return null;
@@ -13476,17 +13572,17 @@ function hasDynamicTagBinding(name2, sourceFile) {
   let found = false;
   const visit3 = (node) => {
     if (found) return;
-    if (ts12.isVariableDeclaration(node) && ts12.isIdentifier(node.name) && node.name.text === name2 && node.initializer) {
+    if (ts13.isVariableDeclaration(node) && ts13.isIdentifier(node.name) && node.name.text === name2 && node.initializer) {
       let init = node.initializer;
-      while (ts12.isAsExpression(init) || ts12.isSatisfiesExpression(init) || ts12.isParenthesizedExpression(init) || ts12.isNonNullExpression(init)) {
+      while (ts13.isAsExpression(init) || ts13.isSatisfiesExpression(init) || ts13.isParenthesizedExpression(init) || ts13.isNonNullExpression(init)) {
         init = init.expression;
       }
-      if (ts12.isPropertyAccessExpression(init) && init.name.text === "tag") {
+      if (ts13.isPropertyAccessExpression(init) && init.name.text === "tag") {
         found = true;
         return;
       }
     }
-    ts12.forEachChild(node, visit3);
+    ts13.forEachChild(node, visit3);
   };
   visit3(sourceFile);
   return found;
@@ -13497,13 +13593,13 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx2) {
   if (!constInfo) return null;
   const ast = parseConstInitializer(constInfo);
   if (!ast) return null;
-  if (ts12.isNoSubstitutionTemplateLiteral(ast) || ts12.isStringLiteral(ast)) {
+  if (ts13.isNoSubstitutionTemplateLiteral(ast) || ts13.isStringLiteral(ast)) {
     return [{ type: "string", value: ast.text }];
   }
-  if (ts12.isElementAccessExpression(ast) && !ts12.isStringLiteralLike(ast.argumentExpression) && !ts12.isNumericLiteral(ast.argumentExpression)) {
+  if (ts13.isElementAccessExpression(ast) && !ts13.isStringLiteralLike(ast.argumentExpression) && !ts13.isNumericLiteral(ast.argumentExpression)) {
     return tryResolveTemplateSpanFromConst(ast, ctx2);
   }
-  if (!ts12.isTemplateExpression(ast)) return null;
+  if (!ts13.isTemplateExpression(ast)) return null;
   let resolvedAny = false;
   const parts = [];
   if (ast.head.text) parts.push({ type: "string", value: ast.head.text });
@@ -13535,19 +13631,19 @@ function parseConstInitializer(c) {
 function parseConstInitializerImpl(c) {
   if (!c.value) return null;
   const wrapped = `const __bf_resolve__ = (${c.value})`;
-  const sf = ts12.createSourceFile(
+  const sf = ts13.createSourceFile(
     "__bf_resolve.ts",
     wrapped,
-    ts12.ScriptTarget.Latest,
+    ts13.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts12.ScriptKind.TS
+    ts13.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts13.isVariableStatement(stmt)) return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer) return null;
-  return ts12.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  return ts13.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
 }
 function astText(node) {
   return node.getText(node.getSourceFile());
@@ -13564,23 +13660,23 @@ function parseFunctionInfoAsExprImpl(fn) {
   const params = fn.typedParams !== void 0 ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
   const body2 = fn.typedBody ?? fn.body;
   const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body2}`;
-  const sf = ts12.createSourceFile(
+  const sf = ts13.createSourceFile(
     "__bf_resolve_fn.ts",
     wrapped,
-    ts12.ScriptTarget.Latest,
+    ts13.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts12.ScriptKind.TS
+    ts13.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts13.isVariableStatement(stmt)) return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer) return null;
   return decl.initializer;
 }
 function tryDesugarInterleaveTaggedTemplate(expr, ctx2) {
-  if (!ts12.isTaggedTemplateExpression(expr)) return expr;
-  if (!ts12.isIdentifier(expr.tag)) return expr;
+  if (!ts13.isTaggedTemplateExpression(expr)) return expr;
+  if (!ts13.isIdentifier(expr.tag)) return expr;
   const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx2);
   if (!resolvedTag) return expr;
   if (!isInterleaveTagFunction(resolvedTag)) return expr;
@@ -13593,20 +13689,20 @@ function resolveInterleaveTagIdentifier(name2, ctx2) {
   if (constInfo && fnInfo) return null;
   if (constInfo) {
     const ast = parseConstInitializer(constInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   if (fnInfo) {
     const ast = parseFunctionInfoAsExpr(fnInfo);
-    return ast && (ts12.isArrowFunction(ast) || ts12.isFunctionExpression(ast)) ? ast : null;
+    return ast && (ts13.isArrowFunction(ast) || ts13.isFunctionExpression(ast)) ? ast : null;
   }
   return null;
 }
 function isInterleaveTagFunction(fn) {
-  if (!ts12.isArrowFunction(fn) && !ts12.isFunctionExpression(fn)) return false;
+  if (!ts13.isArrowFunction(fn) && !ts13.isFunctionExpression(fn)) return false;
   if (fn.parameters.length !== 2) return false;
   const [partsParam, argsParam] = fn.parameters;
-  if (!ts12.isIdentifier(partsParam.name) || partsParam.dotDotDotToken) return false;
-  if (!ts12.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken) return false;
+  if (!ts13.isIdentifier(partsParam.name) || partsParam.dotDotDotToken) return false;
+  if (!ts13.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken) return false;
   const parsed = tsNodeToParsedExpr(fn);
   if (parsed.kind !== "arrow") return false;
   return isInterleaveReduceCall(parsed.body, partsParam.name.text, argsParam.name.text);
@@ -13648,7 +13744,7 @@ function isInterleaveSpanExpr(expr, i, argsName) {
 function buildUntaggedTemplateLiteral(node, ctx2) {
   const template = node.template;
   let text;
-  if (ts12.isNoSubstitutionTemplateLiteral(template)) {
+  if (ts13.isNoSubstitutionTemplateLiteral(template)) {
     text = "`" + (template.rawText ?? template.text) + "`";
   } else {
     let body2 = template.head.rawText ?? template.head.text;
@@ -13660,20 +13756,20 @@ function buildUntaggedTemplateLiteral(node, ctx2) {
     text = "`" + body2 + "`";
   }
   const wrapped = `const __bf_resolve_tagged__ = (${text})`;
-  const sf = ts12.createSourceFile(
+  const sf = ts13.createSourceFile(
     "__bf_resolve_tagged.tsx",
     wrapped,
-    ts12.ScriptTarget.Latest,
+    ts13.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts12.ScriptKind.TSX
+    ts13.ScriptKind.TSX
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts12.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts13.isVariableStatement(stmt)) return null;
   const decl = stmt.declarationList.declarations[0];
   if (!decl?.initializer) return null;
-  const result2 = ts12.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
-  if (!ts12.isTemplateExpression(result2) && !ts12.isNoSubstitutionTemplateLiteral(result2)) return null;
+  const result2 = ts13.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!ts13.isTemplateExpression(result2) && !ts13.isNoSubstitutionTemplateLiteral(result2)) return null;
   return result2;
 }
 function parseTernary(expr, ctx2) {
@@ -13692,10 +13788,10 @@ function parseTernary(expr, ctx2) {
   return null;
 }
 function getStringValue(node) {
-  if (ts12.isStringLiteral(node)) {
+  if (ts13.isStringLiteral(node)) {
     return node.text;
   }
-  if (ts12.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts13.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
   return null;
@@ -13703,18 +13799,18 @@ function getStringValue(node) {
 function processComponentProps(attributes2, ctx2) {
   const props = [];
   for (const attr of attributes2.properties) {
-    if (ts12.isJsxSpreadAttribute(attr)) {
+    if (ts13.isJsxSpreadAttribute(attr)) {
       props.push(...expandSpreadAttribute(attr, ctx2));
       continue;
     }
-    if (!ts12.isJsxAttribute(attr)) continue;
+    if (!ts13.isJsxAttribute(attr)) continue;
     const name2 = attr.name.getText(ctx2.sourceFile);
-    if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       let jsxExpr = attr.initializer.expression;
-      while (ts12.isParenthesizedExpression(jsxExpr)) {
+      while (ts13.isParenthesizedExpression(jsxExpr)) {
         jsxExpr = jsxExpr.expression;
       }
-      if (ts12.isJsxElement(jsxExpr) || ts12.isJsxSelfClosingElement(jsxExpr) || ts12.isJsxFragment(jsxExpr)) {
+      if (ts13.isJsxElement(jsxExpr) || ts13.isJsxSelfClosingElement(jsxExpr) || ts13.isJsxFragment(jsxExpr)) {
         const prevInsideComponentChildren = ctx2.insideComponentChildren;
         ctx2.insideComponentChildren = true;
         const irNode = transformNode(jsxExpr, ctx2);
@@ -13741,7 +13837,7 @@ function processComponentProps(attributes2, ctx2) {
       value2 = AttrValueOf.booleanShorthand();
     }
     let clientOnly;
-    if (attr.initializer && ts12.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    if (attr.initializer && ts13.isJsxExpression(attr.initializer) && attr.initializer.expression) {
       if (value2.kind === "expression" && value2.templateExpr === void 0) {
         const rewritten = rewriteBarePropRefs2(value2.expr, attr.initializer.expression, ctx2);
         if (rewritten !== value2.expr) {
@@ -13765,7 +13861,7 @@ function processComponentProps(attributes2, ctx2) {
   return props;
 }
 function checkBareSignalOrMemoIdentifier(expr, ctx2) {
-  if (!ts12.isIdentifier(expr)) return;
+  if (!ts13.isIdentifier(expr)) return;
   const name2 = expr.text;
   for (const signal2 of ctx2.analyzer.signals) {
     if (signal2.getter === name2) {
@@ -13807,12 +13903,12 @@ function checkBareSignalOrMemoIdentifier(expr, ctx2) {
 function isArrayExprDirectPropRef(arrayExpr, ctx2) {
   const propNames = new Set(ctx2.patterns.props.map((p) => p.name));
   const propsObjName = ctx2.analyzer.propsObjectName;
-  if (ts12.isIdentifier(arrayExpr)) {
+  if (ts13.isIdentifier(arrayExpr)) {
     return propNames.has(arrayExpr.text);
   }
-  if (ts12.isPropertyAccessExpression(arrayExpr) && propsObjName) {
+  if (ts13.isPropertyAccessExpression(arrayExpr) && propsObjName) {
     const obj = arrayExpr.expression;
-    if (ts12.isIdentifier(obj) && obj.text === propsObjName) {
+    if (ts13.isIdentifier(obj) && obj.text === propsObjName) {
       return true;
     }
   }
@@ -13984,7 +14080,7 @@ function buildIfStatementChain(analyzer, ctx2, opts) {
       for (const n of prevJsxBranchLocalNames) jsxBranchLocalNames.add(n);
     }
     for (const decl of condReturn.scopeVariables) {
-      if (ts12.isIdentifier(decl.name) && decl.initializer) {
+      if (ts13.isIdentifier(decl.name) && decl.initializer) {
         branchScopeVars.set(decl.name.text, decl.initializer);
         if (initializerShapeContainsJsx(decl.initializer)) {
           jsxBranchLocalNames.add(decl.name.text);
@@ -14048,7 +14144,7 @@ function buildIfStatementChain(analyzer, ctx2, opts) {
     }
     const scopeVariables = [];
     for (const decl of condReturn.scopeVariables) {
-      if (ts12.isIdentifier(decl.name) && decl.initializer) {
+      if (ts13.isIdentifier(decl.name) && decl.initializer) {
         const init = ctx2.getJS(decl.initializer);
         const typedInit = decl.initializer.getText(ctx2.sourceFile);
         scopeVariables.push({
@@ -15353,7 +15449,8 @@ function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loo
       const refsLoopParamInSource = refsAnyBindingViaFreeIds(sourceFreeIds);
       if (!n.reactive && !refsLoopParamInSource) return;
       const expanded = expandConstantForReactivity(n.condition, ctx2, sourceFreeIds, scope);
-      if (classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind === "none") return;
+      const readsPreamble = preambleNames !== void 0 && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
+      if (!readsPreamble && classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind === "none") return;
       const loopParamsForCond = loopParam ? [{ param: loopParam, bindings: loopParamBindings }] : void 0;
       const whenTrueHtml = irToHtmlTemplate(n.whenTrue, void 0, 0, loopParamsForCond, "__slots");
       const whenFalseHtml = irToHtmlTemplate(n.whenFalse, void 0, 0, loopParamsForCond, "__slots");
@@ -15364,7 +15461,8 @@ function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loo
         whenFalseHtml,
         whenTrue: summarizeLoopChildBranch(n.whenTrue, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
         whenFalse: summarizeLoopChildBranch(n.whenFalse, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex),
-        ...expanded.freeIds !== void 0 && { conditionFreeIdentifiers: expanded.freeIds }
+        ...expanded.freeIds !== void 0 && { conditionFreeIdentifiers: expanded.freeIds },
+        ...readsPreamble && { readsPreamble: true }
       });
     }
   });
@@ -15443,6 +15541,7 @@ var init_collect_elements = __esm({
     init_html_template();
     init_template_parse();
     init_prop_handling();
+    init_csr_substitute();
     init_walker();
     init_loop_chain();
     init_identifier_pattern();
@@ -15800,7 +15899,7 @@ var init_build_references = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function collectPropAccesses(source, propNames, out) {
   if (propNames.size === 0) return;
   let anyMentioned = false;
@@ -15812,13 +15911,13 @@ function collectPropAccesses(source, propNames, out) {
   }
   if (!anyMentioned) return;
   for (const expr of normaliseExpressionParts(source)) {
-    const sourceFile = ts13.createSourceFile(
+    const sourceFile = ts14.createSourceFile(
       "p.ts",
       expr,
-      ts13.ScriptTarget.Latest,
+      ts14.ScriptTarget.Latest,
       /*setParentNodes*/
       false,
-      ts13.ScriptKind.TS
+      ts14.ScriptKind.TS
     );
     visit2(sourceFile, propNames, out);
   }
@@ -15828,15 +15927,15 @@ function normaliseExpressionParts(source) {
   return extractTemplateExpressions(source);
 }
 function visit2(node, propNames, out) {
-  if (ts13.isPropertyAccessExpression(node)) {
+  if (ts14.isPropertyAccessExpression(node)) {
     recordIfPropAccess(node.expression, "property", propNames, out);
-  } else if (ts13.isElementAccessExpression(node)) {
+  } else if (ts14.isElementAccessExpression(node)) {
     recordIfPropAccess(node.expression, "index", propNames, out);
   }
-  ts13.forEachChild(node, (child) => visit2(child, propNames, out));
+  ts14.forEachChild(node, (child) => visit2(child, propNames, out));
 }
 function recordIfPropAccess(receiver, kind2, propNames, out) {
-  if (!ts13.isIdentifier(receiver)) return;
+  if (!ts14.isIdentifier(receiver)) return;
   const name2 = receiver.text;
   if (!propNames.has(name2)) return;
   let kinds = out.get(name2);
@@ -15897,43 +15996,43 @@ var init_compute_prop_usage = __esm({
 });
 
 // ../jsx/src/value-references.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 function isValueReferenceIdentifier(id2) {
   const parent2 = id2.parent;
   if (!parent2) return false;
-  if (ts14.isPropertyAccessExpression(parent2) && parent2.name === id2) return false;
-  if (ts14.isPropertyAssignment(parent2) && parent2.name === id2) return false;
-  if ((ts14.isMethodDeclaration(parent2) || ts14.isGetAccessorDeclaration(parent2) || ts14.isSetAccessorDeclaration(parent2)) && parent2.name === id2) {
+  if (ts15.isPropertyAccessExpression(parent2) && parent2.name === id2) return false;
+  if (ts15.isPropertyAssignment(parent2) && parent2.name === id2) return false;
+  if ((ts15.isMethodDeclaration(parent2) || ts15.isGetAccessorDeclaration(parent2) || ts15.isSetAccessorDeclaration(parent2)) && parent2.name === id2) {
     return false;
   }
-  if (ts14.isPropertyDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isMetaProperty(parent2) && parent2.name === id2) return false;
-  if (ts14.isVariableDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isFunctionDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isFunctionExpression(parent2) && parent2.name === id2) return false;
-  if (ts14.isClassDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts14.isClassExpression(parent2) && parent2.name === id2) return false;
-  if (ts14.isParameter(parent2) && parent2.name === id2) return false;
-  if (ts14.isBindingElement(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts14.isLabeledStatement(parent2) && parent2.label === id2) return false;
-  if (ts14.isBreakOrContinueStatement(parent2) && parent2.label === id2) return false;
-  if (ts14.isImportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts14.isExportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts14.isImportClause(parent2) && parent2.name === id2) return false;
-  if (ts14.isNamespaceImport(parent2) && parent2.name === id2) return false;
-  if (ts14.isQualifiedName(parent2) && parent2.right === id2) return false;
+  if (ts15.isPropertyDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isMetaProperty(parent2) && parent2.name === id2) return false;
+  if (ts15.isVariableDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isFunctionDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isFunctionExpression(parent2) && parent2.name === id2) return false;
+  if (ts15.isClassDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts15.isClassExpression(parent2) && parent2.name === id2) return false;
+  if (ts15.isParameter(parent2) && parent2.name === id2) return false;
+  if (ts15.isBindingElement(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts15.isLabeledStatement(parent2) && parent2.label === id2) return false;
+  if (ts15.isBreakOrContinueStatement(parent2) && parent2.label === id2) return false;
+  if (ts15.isImportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts15.isExportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts15.isImportClause(parent2) && parent2.name === id2) return false;
+  if (ts15.isNamespaceImport(parent2) && parent2.name === id2) return false;
+  if (ts15.isQualifiedName(parent2) && parent2.right === id2) return false;
   return true;
 }
 function collectValueReferencedNames(code) {
   let sourceFile;
   try {
-    sourceFile = ts14.createSourceFile(
+    sourceFile = ts15.createSourceFile(
       "generated.js",
       code,
-      ts14.ScriptTarget.Latest,
+      ts15.ScriptTarget.Latest,
       /*setParentNodes*/
       true,
-      ts14.ScriptKind.JS
+      ts15.ScriptKind.JS
     );
   } catch {
     return null;
@@ -15942,10 +16041,10 @@ function collectValueReferencedNames(code) {
   if (diagnostics && diagnostics.length > 0) return null;
   const names = /* @__PURE__ */ new Set();
   function visit3(node) {
-    if (ts14.isIdentifier(node) && isValueReferenceIdentifier(node)) {
+    if (ts15.isIdentifier(node) && isValueReferenceIdentifier(node)) {
       names.add(node.text);
     }
-    ts14.forEachChild(node, visit3);
+    ts15.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   return names;
@@ -16178,23 +16277,23 @@ var init_lowering_registry = __esm({
 });
 
 // ../jsx/src/relocate.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 function classify(name2, env) {
   return env.bindings.get(name2) ?? "global";
 }
 function collectFreeRefs(node) {
   const refs = /* @__PURE__ */ new Map();
   function visit3(n, parent2) {
-    if (ts15.isIdentifier(n)) {
-      if (parent2 && ts15.isPropertyAccessExpression(parent2) && parent2.name === n) return;
-      if (parent2 && ts15.isPropertyAssignment(parent2) && parent2.name === n) return;
-      if (parent2 && ts15.isShorthandPropertyAssignment(parent2) && parent2.name === n) return;
+    if (ts16.isIdentifier(n)) {
+      if (parent2 && ts16.isPropertyAccessExpression(parent2) && parent2.name === n) return;
+      if (parent2 && ts16.isPropertyAssignment(parent2) && parent2.name === n) return;
+      if (parent2 && ts16.isShorthandPropertyAssignment(parent2) && parent2.name === n) return;
       const list = refs.get(n.text) ?? [];
       list.push(n);
       refs.set(n.text, list);
       return;
     }
-    ts15.forEachChild(n, (child) => visit3(child, n));
+    ts16.forEachChild(n, (child) => visit3(child, n));
   }
   visit3(node);
   return refs;
@@ -16296,9 +16395,9 @@ function isInlinableInTemplate(value2, env) {
   return { ok: true, rewrittenValue: r2.text, decisions: r2.decisions };
 }
 function getCalleeIdentifierPath(callee) {
-  if (ts15.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression);
-  if (ts15.isIdentifier(callee)) return callee.text;
-  if (ts15.isPropertyAccessExpression(callee)) {
+  if (ts16.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression);
+  if (ts16.isIdentifier(callee)) return callee.text;
+  if (ts16.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression);
     if (left === null) return null;
     return `${left}.${callee.name.text}`;
@@ -16306,9 +16405,9 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
-  if (ts15.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression);
-  if (ts15.isIdentifier(callee)) return callee.text;
-  if (ts15.isPropertyAccessExpression(callee)) {
+  if (ts16.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression);
+  if (ts16.isIdentifier(callee)) return callee.text;
+  if (ts16.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression);
   }
   return null;
@@ -16347,17 +16446,17 @@ function isCallAcceptedByAdapter(call, env) {
 }
 function parseExpressionNode(text) {
   try {
-    const sf = ts15.createSourceFile(
+    const sf = ts16.createSourceFile(
       "__inline_check__.ts",
       `(${text});`,
-      ts15.ScriptTarget.Latest,
+      ts16.ScriptTarget.Latest,
       false,
-      ts15.ScriptKind.TS
+      ts16.ScriptKind.TS
     );
     const stmt = sf.statements[0];
-    if (!stmt || !ts15.isExpressionStatement(stmt)) return null;
+    if (!stmt || !ts16.isExpressionStatement(stmt)) return null;
     const inner = stmt.expression;
-    return ts15.isParenthesizedExpression(inner) ? inner.expression : inner;
+    return ts16.isParenthesizedExpression(inner) ? inner.expression : inner;
   } catch {
     return null;
   }
@@ -16371,8 +16470,8 @@ function hasCallWithBridgedArg(node, decisions, env) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts15.isCallExpression(n) || ts15.isNewExpression(n)) {
-      const accepted = ts15.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
+    if (ts16.isCallExpression(n) || ts16.isNewExpression(n)) {
+      const accepted = ts16.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
       if (!accepted) {
         const args2 = n.arguments;
         if (args2) {
@@ -16385,7 +16484,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16394,13 +16493,13 @@ function hasZeroArgCall(node, env) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts15.isCallExpression(n) && n.arguments.length === 0) {
+    if (ts16.isCallExpression(n) && n.arguments.length === 0) {
       if (!isCallAcceptedByAdapter(n, env)) {
         found = true;
         return;
       }
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -16409,25 +16508,25 @@ function containsAnyIdentifier(node, names) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts15.isPropertyAccessExpression(n)) {
+    if (ts16.isPropertyAccessExpression(n)) {
       visit3(n.expression);
       return;
     }
-    if (ts15.isPropertyAssignment(n)) {
+    if (ts16.isPropertyAssignment(n)) {
       visit3(n.initializer);
       return;
     }
-    if (ts15.isShorthandPropertyAssignment(n)) {
-      if (ts15.isIdentifier(n.name) && names.has(n.name.text)) {
+    if (ts16.isShorthandPropertyAssignment(n)) {
+      if (ts16.isIdentifier(n.name) && names.has(n.name.text)) {
         found = true;
       }
       return;
     }
-    if (ts15.isIdentifier(n) && names.has(n.text)) {
+    if (ts16.isIdentifier(n) && names.has(n.text)) {
       found = true;
       return;
     }
-    ts15.forEachChild(n, visit3);
+    ts16.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -17757,19 +17856,19 @@ var init_emit_module_level = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 function propExtractionName(stmt) {
-  if (!ts16.isVariableStatement(stmt)) return null;
+  if (!ts17.isVariableStatement(stmt)) return null;
   const decls = stmt.declarationList.declarations;
   if (decls.length !== 1) return null;
   const decl = decls[0];
-  if (!ts16.isIdentifier(decl.name) || !decl.initializer) return null;
+  if (!ts17.isIdentifier(decl.name) || !decl.initializer) return null;
   let core = decl.initializer;
-  if (ts16.isBinaryExpression(core) && core.operatorToken.kind === ts16.SyntaxKind.QuestionQuestionToken) {
+  if (ts17.isBinaryExpression(core) && core.operatorToken.kind === ts17.SyntaxKind.QuestionQuestionToken) {
     core = core.left;
   }
-  if (!ts16.isPropertyAccessExpression(core)) return null;
-  if (!ts16.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM) return null;
+  if (!ts17.isPropertyAccessExpression(core)) return null;
+  if (!ts17.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM) return null;
   if (core.name.text !== decl.name.text) return null;
   return decl.name.text;
 }
@@ -17780,17 +17879,17 @@ function pruneUnusedPropExtractions(code) {
       console.warn("[barefootjs] pruneUnusedPropExtractions: generated code did not parse; skipping prune");
       return code;
     }
-    const sourceFile = ts16.createSourceFile(
+    const sourceFile = ts17.createSourceFile(
       "generated.js",
       code,
-      ts16.ScriptTarget.Latest,
+      ts17.ScriptTarget.Latest,
       /*setParentNodes*/
       false,
-      ts16.ScriptKind.JS
+      ts17.ScriptKind.JS
     );
     const spans = [];
     for (const stmt of sourceFile.statements) {
-      if (!ts16.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body) continue;
+      if (!ts17.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body) continue;
       for (const inner of stmt.body.statements) {
         const name2 = propExtractionName(inner);
         if (name2 !== null && !referenced.has(name2)) {
@@ -18835,7 +18934,8 @@ function buildReactiveEffectsPlan(args2) {
         whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
         whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
         whenTrueArm: buildOuterArm(cond.whenTrue, wrap, loopParam, loopParamBindings, profileComponentName),
-        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, profileComponentName)
+        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, profileComponentName),
+        ...cond.readsPreamble && { readsPreamble: true }
       });
     }
   }
@@ -19369,7 +19469,7 @@ var init_lazy_conditional = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   if (!preamble) return NO_PREAMBLE;
   if (preamble.builderNames.length > 0) {
@@ -19381,19 +19481,19 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   const text = preambleAnalysisText(preamble);
   if (text.trim().length === 0) return NO_PREAMBLE;
   const declaredNames = /* @__PURE__ */ new Set();
-  const sf = ts17.createSourceFile(
+  const sf = ts18.createSourceFile(
     "__lazy_preamble__.ts",
     text,
-    ts17.ScriptTarget.Latest,
+    ts18.ScriptTarget.Latest,
     /* setParentNodes */
     true,
-    ts17.ScriptKind.TS
+    ts18.ScriptKind.TS
   );
   for (const stmt of sf.statements) {
-    if (!ts17.isVariableStatement(stmt)) {
-      return NO2(`map-callback preamble has a non-declaration statement (${ts17.SyntaxKind[stmt.kind]})`);
+    if (!ts18.isVariableStatement(stmt)) {
+      return NO2(`map-callback preamble has a non-declaration statement (${ts18.SyntaxKind[stmt.kind]})`);
     }
-    const isConst = (stmt.declarationList.flags & ts17.NodeFlags.Const) !== 0;
+    const isConst = (stmt.declarationList.flags & ts18.NodeFlags.Const) !== 0;
     if (!isConst) return NO2("map-callback preamble declares a mutable binding (let/var)");
     for (const decl of stmt.declarationList.declarations) {
       collectBindingNames3(decl.name, declaredNames);
@@ -19420,12 +19520,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   return { lazySafe: true, facts: { declaredNames, freeNames } };
 }
 function collectBindingNames3(name2, out) {
-  if (ts17.isIdentifier(name2)) {
+  if (ts18.isIdentifier(name2)) {
     out.add(name2.text);
     return;
   }
   for (const element of name2.elements) {
-    if (ts17.isOmittedExpression(element)) continue;
+    if (ts18.isOmittedExpression(element)) continue;
     collectBindingNames3(element.name, out);
   }
 }
@@ -19433,56 +19533,56 @@ function findImpureNode(root2, primableNames) {
   let found = null;
   const visit3 = (node) => {
     if (found) return;
-    if (ts17.isCallExpression(node)) {
+    if (ts18.isCallExpression(node)) {
       const callee = node.expression;
-      const isSignalRead = ts17.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === void 0;
+      const isSignalRead = ts18.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === void 0;
       if (!isSignalRead) {
         found = `call to ${callee.getText(callee.getSourceFile())}`;
         return;
       }
     }
-    if (ts17.isNewExpression(node)) {
+    if (ts18.isNewExpression(node)) {
       found = "new expression";
       return;
     }
-    if (ts17.isTaggedTemplateExpression(node)) {
+    if (ts18.isTaggedTemplateExpression(node)) {
       found = "tagged template";
       return;
     }
-    if (ts17.isAwaitExpression(node)) {
+    if (ts18.isAwaitExpression(node)) {
       found = "await";
       return;
     }
-    if (ts17.isYieldExpression(node)) {
+    if (ts18.isYieldExpression(node)) {
       found = "yield";
       return;
     }
-    if (ts17.isPrefixUnaryExpression(node) || ts17.isPostfixUnaryExpression(node)) {
+    if (ts18.isPrefixUnaryExpression(node) || ts18.isPostfixUnaryExpression(node)) {
       const op = node.operator;
-      if (op === ts17.SyntaxKind.PlusPlusToken || op === ts17.SyntaxKind.MinusMinusToken) {
+      if (op === ts18.SyntaxKind.PlusPlusToken || op === ts18.SyntaxKind.MinusMinusToken) {
         found = "increment/decrement";
         return;
       }
     }
-    if (ts17.isDeleteExpression(node)) {
+    if (ts18.isDeleteExpression(node)) {
       found = "delete";
       return;
     }
-    if (ts17.isFunctionExpression(node) || ts17.isArrowFunction(node) || ts17.isClassExpression(node)) {
+    if (ts18.isFunctionExpression(node) || ts18.isArrowFunction(node) || ts18.isClassExpression(node)) {
       found = "function or class expression";
       return;
     }
-    if (ts17.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts18.isBinaryExpression(node) && isAssignmentOperator2(node.operatorToken.kind)) {
       found = "assignment";
       return;
     }
-    ts17.forEachChild(node, visit3);
+    ts18.forEachChild(node, visit3);
   };
   visit3(root2);
   return found;
 }
-function isAssignmentOperator(kind2) {
-  return kind2 >= ts17.SyntaxKind.FirstAssignment && kind2 <= ts17.SyntaxKind.LastAssignment;
+function isAssignmentOperator2(kind2) {
+  return kind2 >= ts18.SyntaxKind.FirstAssignment && kind2 <= ts18.SyntaxKind.LastAssignment;
 }
 var NO_PREAMBLE, NO2;
 var init_lazy_preamble = __esm({
@@ -20080,7 +20180,7 @@ var init_claim_plan = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 function bindingIdArg(ctx2, slotId) {
   if (!ctx2.profile || !slotId) return "";
   return `, ${JSON.stringify(`${ctx2.componentName}#binding:${slotId}`)}`;
@@ -20161,19 +20261,19 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
   if (!matcher) return expr;
   let sourceFile;
   try {
-    sourceFile = ts18.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TS);
+    sourceFile = ts19.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt)) return expr;
-  const root2 = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts19.isExpressionStatement(stmt)) return expr;
+  const root2 = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts18.isCallExpression(n) && n.arguments.length === 2 && ts18.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts19.isCallExpression(n) && n.arguments.length === 2 && ts19.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts18.forEachChild(n, visit3);
+    ts19.forEachChild(n, visit3);
   };
   visit3(root2);
   if (candidates.length === 0) return expr;
@@ -20210,19 +20310,19 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
   if (!matcher) return expr;
   let sourceFile;
   try {
-    sourceFile = ts18.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TS);
+    sourceFile = ts19.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt)) return expr;
-  const root2 = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts19.isExpressionStatement(stmt)) return expr;
+  const root2 = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts18.isCallExpression(n) && n.arguments.length === 0 && ts18.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts19.isCallExpression(n) && n.arguments.length === 0 && ts19.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts18.forEachChild(n, visit3);
+    ts19.forEachChild(n, visit3);
   };
   visit3(root2);
   if (candidates.length === 0) return expr;
@@ -20580,7 +20680,7 @@ function stringifyReactiveEffects(lines, plan, opts) {
     );
   }
   for (const cond of conditionals) {
-    emitOuterConditional(lines, indent, elVar, cond, pc);
+    emitOuterConditional(lines, indent, elVar, cond, pc, mapPreambleWrapped);
   }
 }
 function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementIndexBySlot, bindingBfId, mapPreambleWrapped) {
@@ -20678,9 +20778,10 @@ function emitOuterTexts(lines, indent, elVar, texts, bindingBfId, textClaimPathE
     lines.push(`${indent}createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${bindingBfId(text.slotId)})`);
   }
 }
-function emitOuterConditional(lines, indent, elVar, cond, pc) {
+function emitOuterConditional(lines, indent, elVar, cond, pc, mapPreambleWrapped) {
   const armIndent = `${indent}    `;
-  lines.push(`${indent}insert(${elVar}, '${cond.slotId}', () => ${cond.wrappedCondition}, {`);
+  const conditionGetter = cond.readsPreamble && mapPreambleWrapped ? `() => { ${mapPreambleWrapped}; return (${cond.wrappedCondition}) }` : `() => ${cond.wrappedCondition}`;
+  lines.push(`${indent}insert(${elVar}, '${cond.slotId}', ${conditionGetter}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenTrueTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
   stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc);
@@ -22406,25 +22507,25 @@ var init_phases = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName) {
   const srcPropsName = propsObjectName ?? "props";
   if (srcPropsName === PROPS_PARAM) return code;
   if (!identifierPattern(srcPropsName).test(code)) return code;
-  const sourceFile = ts19.createSourceFile(
+  const sourceFile = ts20.createSourceFile(
     "init-body.ts",
     code,
-    ts19.ScriptTarget.Latest,
+    ts20.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts19.ScriptKind.TS
+    ts20.ScriptKind.TS
   );
   const spans = [];
   function visit3(node) {
-    if (ts19.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts20.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts19.forEachChild(node, visit3);
+    ts20.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0) return code;
@@ -22438,12 +22539,12 @@ function rewritePropsObjectRef(code, propsObjectName) {
 function shouldRewrite(node) {
   const parent2 = node.parent;
   if (!parent2) return true;
-  if (ts19.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
-  if (ts19.isPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts19.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts19.isPropertySignature(parent2) && parent2.name === node) return false;
-  if (ts19.isPropertyDeclaration(parent2) && parent2.name === node) return false;
-  if (ts19.isBindingElement(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts20.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertySignature(parent2) && parent2.name === node) return false;
+  if (ts20.isPropertyDeclaration(parent2) && parent2.name === node) return false;
+  if (ts20.isBindingElement(parent2) && parent2.name === node) return false;
   return true;
 }
 var init_rewrite_props_object = __esm({
@@ -23150,7 +23251,7 @@ var init_css_layer_prefixer = __esm({
 });
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 function preprocessInlineJsxCallbacks(source, filePath) {
   const errors = [];
   const syntheticNames = [];
@@ -23170,15 +23271,15 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts20.createSourceFile(
+  const sourceFile = ts21.createSourceFile(
     filePath,
     source,
-    ts20.ScriptTarget.Latest,
+    ts21.ScriptTarget.Latest,
     true,
-    ts20.ScriptKind.TSX
+    ts21.ScriptKind.TSX
   );
   const hasUseClient = sourceFile.statements.some(
-    (stmt) => ts20.isExpressionStatement(stmt) && ts20.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
+    (stmt) => ts21.isExpressionStatement(stmt) && ts21.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
   );
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
@@ -23201,20 +23302,20 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts20.isJsxAttribute(node) && node.initializer && ts20.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts21.isJsxAttribute(node) && node.initializer && ts21.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts20.isPropertyAssignment(node) && node.initializer) {
+    if (ts21.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer)) return;
     }
-    ts20.forEachChild(node, visit3);
+    ts21.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts20.isParenthesizedExpression(expr)) expr = expr.expression;
-    if (ts20.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    while (ts21.isParenthesizedExpression(expr)) expr = expr.expression;
+    if (ts21.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -23249,7 +23350,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name2 });
     return true;
   }
-  ts20.forEachChild(sourceFile, visit3);
+  ts21.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -23268,33 +23369,33 @@ 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 (ts20.isBlock(arrow.body)) {
+  if (ts21.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body2 = arrow.body;
-  while (ts20.isParenthesizedExpression(body2)) body2 = body2.expression;
+  while (ts21.isParenthesizedExpression(body2)) body2 = body2.expression;
   return isJsxLike(body2);
 }
 function blockReturnsJsx(block) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts20.isReturnStatement(n) && n.expression) {
+    if (ts21.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts20.isParenthesizedExpression(e)) e = e.expression;
+      while (ts21.isParenthesizedExpression(e)) e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts20.isArrowFunction(n) || ts20.isFunctionDeclaration(n) || ts20.isFunctionExpression(n)) return;
-    ts20.forEachChild(n, visit3);
+    if (ts21.isArrowFunction(n) || ts21.isFunctionDeclaration(n) || ts21.isFunctionExpression(n)) return;
+    ts21.forEachChild(n, visit3);
   }
-  ts20.forEachChild(block, visit3);
+  ts21.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts20.isJsxElement(expr) || ts20.isJsxSelfClosingElement(expr) || ts20.isJsxFragment(expr);
+  return ts21.isJsxElement(expr) || ts21.isJsxSelfClosingElement(expr) || ts21.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = /* @__PURE__ */ new Set();
@@ -23303,13 +23404,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames4(name2, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts20.isIdentifier(name2)) {
+  if (ts21.isIdentifier(name2)) {
     push(name2.text);
-  } else if (ts20.isObjectBindingPattern(name2)) {
+  } else if (ts21.isObjectBindingPattern(name2)) {
     name2.elements.forEach((el) => collectBindingNames4(el.name, out));
-  } else if (ts20.isArrayBindingPattern(name2)) {
+  } else if (ts21.isArrayBindingPattern(name2)) {
     name2.elements.forEach((el) => {
-      if (!ts20.isOmittedExpression(el)) collectBindingNames4(el.name, out);
+      if (!ts21.isOmittedExpression(el)) collectBindingNames4(el.name, out);
     });
   }
 }
@@ -23334,71 +23435,71 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name2);
   }
   function visit3(node) {
-    if (ts20.isIdentifier(node)) {
+    if (ts21.isIdentifier(node)) {
       const parent2 = node.parent;
-      if (parent2 && ts20.isPropertyAccessExpression(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isPropertyAssignment(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isPropertySignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isPropertyDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isMethodDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isMethodSignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isEnumMember(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isBindingElement(parent2) && parent2.propertyName === node) return;
-      if (parent2 && ts20.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
+      if (parent2 && ts21.isPropertyAccessExpression(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isPropertyAssignment(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isPropertySignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isPropertyDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isMethodDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isMethodSignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isEnumMember(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isBindingElement(parent2) && parent2.propertyName === node) return;
+      if (parent2 && ts21.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
         if (!isBound(node.text)) ids.add(node.text);
         return;
       }
-      if (parent2 && ts20.isParameter(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isVariableDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isFunctionDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isClassDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isJsxAttribute(parent2) && parent2.name === node) return;
-      if (parent2 && ts20.isJsxOpeningElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts21.isParameter(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isVariableDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isFunctionDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isClassDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isJsxAttribute(parent2) && parent2.name === node) return;
+      if (parent2 && ts21.isJsxOpeningElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
-      if (parent2 && ts20.isJsxClosingElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts21.isJsxClosingElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
       if (isBound(node.text)) return;
       ids.add(node.text);
       return;
     }
-    if (ts20.isVariableDeclaration(node)) {
+    if (ts21.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer) visit3(node.initializer);
       declared;
       return;
     }
-    if (ts20.isFunctionDeclaration(node)) {
+    if (ts21.isFunctionDeclaration(node)) {
       if (node.name) bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts20.isClassDeclaration(node)) {
+    if (ts21.isClassDeclaration(node)) {
       if (node.name) bound.push(node.name.text);
-      ts20.forEachChild(node, visit3);
+      ts21.forEachChild(node, visit3);
       return;
     }
-    if (ts20.isArrowFunction(node) || ts20.isFunctionExpression(node)) {
+    if (ts21.isArrowFunction(node) || ts21.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts20.isCatchClause(node)) {
+    if (ts21.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration) pushBindings(node.variableDeclaration.name);
-      ts20.forEachChild(node, visit3);
+      ts21.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts20.isBlock(node)) {
+    if (ts21.isBlock(node)) {
       const before = bound.length;
-      ts20.forEachChild(node, visit3);
+      ts21.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts20.forEachChild(node, visit3);
+    ts21.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -23418,27 +23519,27 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = /* @__PURE__ */ new Set();
   for (const stmt of sourceFile.statements) {
-    if (ts20.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts20.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts20.isVariableStatement(stmt)) {
+    if (ts21.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    else if (ts21.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    else if (ts21.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) collectBindingNames4(decl.name, names);
-    } else if (ts20.isImportDeclaration(stmt) && stmt.importClause) {
+    } else if (ts21.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name) names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts20.isNamespaceImport(ic.namedBindings)) names.add(ic.namedBindings.name.text);
+        if (ts21.isNamespaceImport(ic.namedBindings)) names.add(ic.namedBindings.name.text);
         else for (const e of ic.namedBindings.elements) names.add(e.name.text);
       }
-    } else if (ts20.isTypeAliasDeclaration(stmt)) names.add(stmt.name.text);
-    else if (ts20.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
-    else if (ts20.isEnumDeclaration(stmt)) names.add(stmt.name.text);
+    } else if (ts21.isTypeAliasDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts21.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts21.isEnumDeclaration(stmt)) names.add(stmt.name.text);
   }
   return names;
 }
 function buildSyntheticDeclaration(name2, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts20.isBlock(arrow.body)) {
+  if (ts21.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -23457,7 +23558,7 @@ var init_preprocess_inline_jsx_callbacks = __esm({
 });
 
 // ../jsx/src/ssr-defaults.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function deriveStashFromDefaults(defaults, props) {
   const extra = {};
   for (const [name2, d] of Object.entries(defaults)) {
@@ -23537,11 +23638,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   const node = parseExpression2(expr);
   if (!node) return;
   const visit3 = (n) => {
-    if (ts21.isPropertyAccessExpression(n) && ts21.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts21.isIdentifier(n.name)) {
+    if (ts22.isPropertyAccessExpression(n) && ts22.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts22.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts21.forEachChild(n, visit3);
+    ts22.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -23558,21 +23659,21 @@ function tryStaticEval(expr, ctx2) {
 }
 function evalStatementsForReturn(statements, ctx2) {
   for (const stmt of statements) {
-    if (ts21.isVariableStatement(stmt)) {
+    if (ts22.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts21.isIdentifier(d.name) || !d.initializer) continue;
+        if (!ts22.isIdentifier(d.name) || !d.initializer) continue;
         const v = evalNode(d.initializer, ctx2);
         if (v !== UNRESOLVED) ctx2.bindings[d.name.text] = v;
       }
-    } else if (ts21.isReturnStatement(stmt)) {
+    } else if (ts22.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx2) : UNRESOLVED;
-    } else if (ts21.isIfStatement(stmt)) {
+    } else if (ts22.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx2);
       if (cond === UNRESOLVED) return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
         const taken = evalStatementsForReturn(
-          ts21.isBlock(branch) ? branch.statements : [branch],
+          ts22.isBlock(branch) ? branch.statements : [branch],
           ctx2
         );
         if (taken !== NO_RETURN) return taken;
@@ -23584,64 +23685,64 @@ function evalStatementsForReturn(statements, ctx2) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts21.createSourceFile(
+  const sf = ts22.createSourceFile(
     "__ssr_default__.ts",
     `(${expr})`,
-    ts21.ScriptTarget.Latest,
+    ts22.ScriptTarget.Latest,
     false,
-    ts21.ScriptKind.TS
+    ts22.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isExpressionStatement(stmt)) return null;
-  const inner = ts21.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts22.isExpressionStatement(stmt)) return null;
+  const inner = ts22.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx2) {
-  if (ts21.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isAsExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts21.isArrowFunction(node)) {
+  if (ts22.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isAsExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts22.isArrowFunction(node)) {
     if (node.parameters.length !== 0) return UNRESOLVED;
-    if (!ts21.isBlock(node.body)) return evalNode(node.body, ctx2);
+    if (!ts22.isBlock(node.body)) return evalNode(node.body, ctx2);
     const localBindings = { ...ctx2.bindings };
     const localCtx = { ...ctx2, bindings: localBindings };
     const result2 = evalStatementsForReturn(node.body.statements, localCtx);
     return result2 === NO_RETURN ? UNRESOLVED : result2;
   }
-  if (ts21.isNumericLiteral(node)) return Number(node.text);
-  if (ts21.isStringLiteralLike(node)) return node.text;
-  if (node.kind === ts21.SyntaxKind.TrueKeyword) return true;
-  if (node.kind === ts21.SyntaxKind.FalseKeyword) return false;
-  if (node.kind === ts21.SyntaxKind.NullKeyword) return null;
-  if (ts21.isIdentifier(node)) {
+  if (ts22.isNumericLiteral(node)) return Number(node.text);
+  if (ts22.isStringLiteralLike(node)) return node.text;
+  if (node.kind === ts22.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts22.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts22.SyntaxKind.NullKeyword) return null;
+  if (ts22.isIdentifier(node)) {
     if (node.text === "undefined") return void 0;
     if (node.text in ctx2.bindings) return ctx2.bindings[node.text];
     if (ctx2.propsLike.has(node.text)) return void 0;
     return UNRESOLVED;
   }
-  if (ts21.isPrefixUnaryExpression(node)) {
+  if (ts22.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx2);
     if (arg === UNRESOLVED) return UNRESOLVED;
     switch (node.operator) {
-      case ts21.SyntaxKind.MinusToken:
+      case ts22.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts21.SyntaxKind.PlusToken:
+      case ts22.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts21.SyntaxKind.ExclamationToken:
+      case ts22.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts21.isObjectLiteralExpression(node)) {
+  if (ts22.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts21.isPropertyAssignment(prop)) return UNRESOLVED;
+      if (!ts22.isPropertyAssignment(prop)) return UNRESOLVED;
       let key;
-      if (ts21.isIdentifier(prop.name) || ts21.isStringLiteralLike(prop.name)) {
+      if (ts22.isIdentifier(prop.name) || ts22.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts21.isNumericLiteral(prop.name)) {
+      } else if (ts22.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -23652,17 +23753,17 @@ function evalNode(node, ctx2) {
     }
     return obj;
   }
-  if (ts21.isArrayLiteralExpression(node)) {
+  if (ts22.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts21.isOmittedExpression(elem)) return UNRESOLVED;
+      if (ts22.isOmittedExpression(elem)) return UNRESOLVED;
       const v = evalNode(elem, ctx2);
       if (v === UNRESOLVED) return UNRESOLVED;
       arr.push(v === void 0 ? null : v);
     }
     return arr;
   }
-  if (ts21.isElementAccessExpression(node)) {
+  if (ts22.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx2);
     if (base === void 0) return void 0;
     if (base === UNRESOLVED || base === null || typeof base !== "object") return UNRESOLVED;
@@ -23672,16 +23773,16 @@ function evalNode(node, ctx2) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : void 0;
   }
-  if (ts21.isPropertyAccessExpression(node)) {
+  if (ts22.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx2);
     if (baseResult === void 0) return void 0;
     return UNRESOLVED;
   }
-  if (ts21.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts21.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
+  if (ts22.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts22.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
       return ctx2.bindings[node.expression.text];
     }
-    if (ts21.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts22.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx2);
       if (Array.isArray(recv)) {
         let sep = ",";
@@ -23696,24 +23797,24 @@ function evalNode(node, ctx2) {
     }
     return UNRESOLVED;
   }
-  if (ts21.isConditionalExpression(node)) {
+  if (ts22.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx2);
     if (cond === UNRESOLVED) return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx2) : evalNode(node.whenFalse, ctx2);
   }
-  if (ts21.isBinaryExpression(node)) {
+  if (ts22.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts21.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts22.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== void 0) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts21.SyntaxKind.BarBarToken) {
+    if (op === ts22.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 !== UNRESOLVED && l2) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts21.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts22.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 === UNRESOLVED) return UNRESOLVED;
       if (!l2) return l2;
@@ -23723,28 +23824,28 @@ function evalNode(node, ctx2) {
     const r2 = evalNode(node.right, ctx2);
     if (l === UNRESOLVED || r2 === UNRESOLVED) return UNRESOLVED;
     switch (op) {
-      case ts21.SyntaxKind.PlusToken:
+      case ts22.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r2 === "string") return `${l}${r2}`;
         if (typeof l === "number" && typeof r2 === "number") return l + r2;
         return UNRESOLVED;
-      case ts21.SyntaxKind.MinusToken:
+      case ts22.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r2 === "number" ? l - r2 : UNRESOLVED;
-      case ts21.SyntaxKind.AsteriskToken:
+      case ts22.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r2 === "number" ? l * r2 : UNRESOLVED;
-      case ts21.SyntaxKind.SlashToken:
+      case ts22.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l / r2 : UNRESOLVED;
-      case ts21.SyntaxKind.PercentToken:
+      case ts22.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l % r2 : UNRESOLVED;
-      case ts21.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts21.SyntaxKind.EqualsEqualsToken:
+      case ts22.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts22.SyntaxKind.EqualsEqualsToken:
         return l === r2;
-      case ts21.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts21.SyntaxKind.ExclamationEqualsToken:
+      case ts22.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts22.SyntaxKind.ExclamationEqualsToken:
         return l !== r2;
     }
     return UNRESOLVED;
   }
-  if (ts21.isTemplateExpression(node)) {
+  if (ts22.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0) return node.head.text;
     let acc = node.head.text;
     for (const span of node.templateSpans) {
@@ -23754,7 +23855,7 @@ function evalNode(node, ctx2) {
     }
     return acc;
   }
-  if (ts21.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts22.isNoSubstitutionTemplateLiteral(node)) return node.text;
   return UNRESOLVED;
 }
 var UNRESOLVED, NO_RETURN;
@@ -23767,7 +23868,7 @@ var init_ssr_defaults = __esm({
 });
 
 // ../jsx/src/augment-inherited-props.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = /* @__PURE__ */ new Map();
@@ -23794,35 +23895,35 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr)) return null;
-  if (!ts22.isIdentifier(expr.expression) || expr.expression.text !== "useContext") return null;
+  if (!expr || !ts23.isCallExpression(expr)) return null;
+  if (!ts23.isIdentifier(expr.expression) || expr.expression.text !== "useContext") return null;
   if (expr.arguments.length !== 1) return null;
   const arg = expr.arguments[0];
-  return ts22.isIdentifier(arg) ? arg.text : null;
+  return ts23.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr)) return null;
+  if (!expr || !ts23.isCallExpression(expr)) return null;
   if (expr.arguments.length === 0) return null;
   const arg = expr.arguments[0];
-  if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
-  if (ts22.isNumericLiteral(arg)) return Number(arg.text);
-  if (arg.kind === ts22.SyntaxKind.TrueKeyword) return true;
-  if (arg.kind === ts22.SyntaxKind.FalseKeyword) return false;
+  if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
+  if (ts23.isNumericLiteral(arg)) return Number(arg.text);
+  if (arg.kind === ts23.SyntaxKind.TrueKeyword) return true;
+  if (arg.kind === ts23.SyntaxKind.FalseKeyword) return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts22.isCallExpression(expr)) return false;
+  if (!expr || !ts23.isCallExpression(expr)) return false;
   if (expr.arguments.length === 0) return false;
-  return ts22.isObjectLiteralExpression(expr.arguments[0]);
+  return ts23.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts22.createSourceFile("__ctx.ts", `(${source})`, ts22.ScriptTarget.Latest, false);
+  const sf = ts23.createSourceFile("__ctx.ts", `(${source})`, ts23.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isExpressionStatement(stmt)) return null;
+  if (!stmt || !ts23.isExpressionStatement(stmt)) return null;
   let e = stmt.expression;
-  while (ts22.isParenthesizedExpression(e)) e = e.expression;
+  while (ts23.isParenthesizedExpression(e)) e = e.expression;
   return e;
 }
 function augmentInheritedPropAccesses(ir) {
@@ -23843,21 +23944,21 @@ function augmentInheritedPropAccesses(ir) {
   const coalesceLiteralTypes = /* @__PURE__ */ new Map();
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj)) return;
-    const sf = ts22.createSourceFile("__aug.ts", `(${s})`, ts22.ScriptTarget.Latest, false);
+    const sf = ts23.createSourceFile("__aug.ts", `(${s})`, ts23.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts22.isBinaryExpression(n) && (n.operatorToken.kind === ts22.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts22.SyntaxKind.BarBarToken)) {
+      if (ts23.isBinaryExpression(n) && (n.operatorToken.kind === ts23.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts23.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts22.isParenthesizedExpression(left)) left = left.expression;
-        if (ts22.isPropertyAccessExpression(left) && ts22.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        while (ts23.isParenthesizedExpression(left)) left = left.expression;
+        if (ts23.isPropertyAccessExpression(left) && ts23.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name2 = left.name.text;
           let right = n.right;
-          while (ts22.isParenthesizedExpression(right)) right = right.expression;
-          if (ts22.isPrefixUnaryExpression(right)) right = right.operand;
-          const kind2 = ts22.isNumericLiteral(right) ? "number" : right.kind === ts22.SyntaxKind.TrueKeyword || right.kind === ts22.SyntaxKind.FalseKeyword ? "boolean" : ts22.isStringLiteralLike(right) ? "string" : null;
+          while (ts23.isParenthesizedExpression(right)) right = right.expression;
+          if (ts23.isPrefixUnaryExpression(right)) right = right.operand;
+          const kind2 = ts23.isNumericLiteral(right) ? "number" : right.kind === ts23.SyntaxKind.TrueKeyword || right.kind === ts23.SyntaxKind.FalseKeyword ? "boolean" : ts23.isStringLiteralLike(right) ? "string" : null;
           if (kind2 && !coalesceLiteralTypes.has(name2)) coalesceLiteralTypes.set(name2, kind2);
         }
       }
-      ts22.forEachChild(n, visit3);
+      ts23.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -23953,39 +24054,39 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts23.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts22.isParenthesizedExpression(init)) init = init.expression;
+  while (init && ts23.isParenthesizedExpression(init)) init = init.expression;
   if (!init) return null;
-  if (ts22.isStringLiteral(init) || ts22.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts23.isStringLiteral(init) || ts23.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts23.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts22.isParenthesizedExpression(init)) init = init.expression;
-  if (!init || !ts22.isTemplateExpression(init)) return null;
+  while (init && ts23.isParenthesizedExpression(init)) init = init.expression;
+  if (!init || !ts23.isTemplateExpression(init)) return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts22.isIdentifier(span.expression)) return null;
+    if (!ts23.isIdentifier(span.expression)) return null;
     const value2 = resolved.get(span.expression.text);
     if (value2 === void 0) return null;
     out += value2 + span.literal.text;
@@ -24011,31 +24112,32 @@ function collectModuleStringConsts(constants) {
   }
   return map;
 }
-function lookupStaticRecordLiteral(objectName, key, constants) {
+function lookupStaticRecordLiteral(objectName, key, constants, isShadowed) {
+  if (isShadowed(objectName)) return null;
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === void 0) return null;
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts22.isExpressionStatement(stmt)) return null;
+  if (!ts23.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts22.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts22.isObjectLiteralExpression(parsed)) return null;
+  while (ts23.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts23.isObjectLiteralExpression(parsed)) return null;
   for (const prop of parsed.properties) {
-    if (!ts22.isPropertyAssignment(prop)) continue;
+    if (!ts23.isPropertyAssignment(prop)) continue;
     const name2 = prop.name;
-    const propKey = ts22.isIdentifier(name2) || ts22.isStringLiteral(name2) || ts22.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
+    const propKey = ts23.isIdentifier(name2) || ts23.isStringLiteral(name2) || ts23.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
     if (propKey !== key) continue;
     let v = prop.initializer;
-    while (ts22.isParenthesizedExpression(v)) v = v.expression;
-    if (ts22.isNumericLiteral(v)) return { kind: "number", text: v.text };
-    if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
+    while (ts23.isParenthesizedExpression(v)) v = v.expression;
+    if (ts23.isNumericLiteral(v)) return { kind: "number", text: v.text };
+    if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -24043,27 +24145,27 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__join.ts",
     `const __x = (${source});`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts22.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts23.isVariableStatement(stmt)) return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts22.isParenthesizedExpression(node)) node = node.expression;
-  if (!node || !ts22.isCallExpression(node)) return null;
+  while (node && ts23.isParenthesizedExpression(node)) node = node.expression;
+  if (!node || !ts23.isCallExpression(node)) return null;
   const callee = node.expression;
-  if (!ts22.isPropertyAccessExpression(callee)) return null;
+  if (!ts23.isPropertyAccessExpression(callee)) return null;
   if (callee.name.text !== "join") return null;
   let recv = callee.expression;
-  while (ts22.isParenthesizedExpression(recv)) recv = recv.expression;
-  if (!ts22.isArrayLiteralExpression(recv)) return null;
+  while (ts23.isParenthesizedExpression(recv)) recv = recv.expression;
+  if (!ts23.isArrayLiteralExpression(recv)) return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts22.isStringLiteral(el) || ts22.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts23.isStringLiteral(el) || ts23.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -24072,16 +24174,16 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
+    if (ts23.isStringLiteral(arg) || ts23.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
     else return null;
   }
   return parts.join(sep);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts22.isElementAccessExpression(val)) return null;
+  if (!ts23.isElementAccessExpression(val)) return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts22.isIdentifier(obj) || !ts22.isIdentifier(arg)) return null;
+  if (!ts23.isIdentifier(obj) || !ts23.isIdentifier(arg)) return null;
   let indexPropName;
   let defaultKey;
   const resolved = resolveKey?.(arg.text);
@@ -24095,35 +24197,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   }
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === void 0) return null;
-  const sf = ts22.createSourceFile(
+  const sf = ts23.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts22.ScriptTarget.Latest,
+    ts23.ScriptTarget.Latest,
     /* setParentNodes */
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts22.isExpressionStatement(stmt)) return null;
+  if (!ts23.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts22.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts22.isObjectLiteralExpression(parsed)) return null;
+  while (ts23.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts23.isObjectLiteralExpression(parsed)) return null;
   const entries2 = [];
   for (const prop of parsed.properties) {
-    if (!ts22.isPropertyAssignment(prop)) return null;
+    if (!ts23.isPropertyAssignment(prop)) return null;
     let key;
-    if (ts22.isIdentifier(prop.name)) {
+    if (ts23.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts22.isStringLiteral(prop.name) || ts22.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts23.isStringLiteral(prop.name) || ts23.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts22.isParenthesizedExpression(v)) v = v.expression;
-    if (ts22.isNumericLiteral(v)) {
+    while (ts23.isParenthesizedExpression(v)) v = v.expression;
+    if (ts23.isNumericLiteral(v)) {
       entries2.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts23.isStringLiteral(v) || ts23.isNoSubstitutionTemplateLiteral(v)) {
       entries2.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -24395,7 +24497,7 @@ var init_rich_type_refusal = __esm({
 });
 
 // ../jsx/src/compiler.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 function mergeTemplateImports(lines) {
   const result2 = [];
   const valueIdx = /* @__PURE__ */ new Map();
@@ -24460,12 +24562,12 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
   if (entries2.some((e) => e.componentIR.metadata.isClientComponent)) {
     const topLevelNames = /* @__PURE__ */ new Set();
     {
-      const sf = ts23.createSourceFile(filePath, source, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
+      const sf = ts24.createSourceFile(filePath, source, ts24.ScriptTarget.Latest, true, ts24.ScriptKind.TSX);
       for (const stmt of sf.statements) {
-        if (ts23.isFunctionDeclaration(stmt) && stmt.name) topLevelNames.add(stmt.name.text);
-        else if (ts23.isVariableStatement(stmt)) {
+        if (ts24.isFunctionDeclaration(stmt) && stmt.name) topLevelNames.add(stmt.name.text);
+        else if (ts24.isVariableStatement(stmt)) {
           for (const d of stmt.declarationList.declarations) {
-            if (ts23.isIdentifier(d.name)) topLevelNames.add(d.name.text);
+            if (ts24.isIdentifier(d.name)) topLevelNames.add(d.name.text);
           }
         }
       }
@@ -24526,13 +24628,13 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
   const moduleStatementSeen = /* @__PURE__ */ new Set();
   const moduleStatementsOrdered = [];
   const collectModuleStatements = (block) => {
-    const sf = ts23.createSourceFile(
+    const sf = ts24.createSourceFile(
       "__bf_module_decls.tsx",
       block,
-      ts23.ScriptTarget.Latest,
+      ts24.ScriptTarget.Latest,
       /* setParentNodes */
       false,
-      ts23.ScriptKind.TSX
+      ts24.ScriptKind.TSX
     );
     for (const stmt of sf.statements) {
       const text = stmt.getText(sf);
@@ -24764,6 +24866,11 @@ function compileMultipleComponents(source, filePath, componentNames, options2) {
   }
   return { files: files2, errors };
 }
+function componentTypeParametersText(componentNode, sourceFile) {
+  const typeParameters = componentNode?.typeParameters;
+  if (!typeParameters || typeParameters.length === 0) return null;
+  return `<${typeParameters.map((p) => p.getText(sourceFile)).join(", ")}>`;
+}
 function buildMetadata(ctx2) {
   const metadata = {
     componentName: ctx2.componentName || "Unknown",
@@ -24772,6 +24879,7 @@ function buildMetadata(ctx2) {
     isClientComponent: ctx2.hasUseClientDirective,
     typeDefinitions: ctx2.typeDefinitions,
     propsType: ctx2.propsType,
+    typeParameters: componentTypeParametersText(ctx2.componentNode, ctx2.sourceFile),
     propsParams: ctx2.propsParams,
     propsObjectName: ctx2.propsObjectName,
     restPropsName: ctx2.restPropsName,
@@ -24997,7 +25105,7 @@ var init_compiler = __esm({
 });
 
 // ../jsx/src/shared-program.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 import path6 from "node:path";
 function commonParent(paths) {
   if (paths.length === 0) return process.cwd();
@@ -25015,10 +25123,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files2, options2 = {}) {
   const baseUrl = options2.baseUrl ?? commonParent(files2);
   const compilerOptions = {
-    target: ts24.ScriptTarget.Latest,
-    module: ts24.ModuleKind.ESNext,
-    moduleResolution: ts24.ModuleResolutionKind.Bundler,
-    jsx: ts24.JsxEmit.ReactJSX,
+    target: ts25.ScriptTarget.Latest,
+    module: ts25.ModuleKind.ESNext,
+    moduleResolution: ts25.ModuleResolutionKind.Bundler,
+    jsx: ts25.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -25028,7 +25136,7 @@ function createProgramForCorpus(files2, options2 = {}) {
     ...options2.compilerOptions
   };
   const absolute = files2.map((f) => path6.resolve(f));
-  return ts24.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
+  return ts25.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
 }
 var init_shared_program = __esm({
   "../jsx/src/shared-program.ts"() {
@@ -25128,7 +25236,13 @@ var init_jsx_adapter = __esm({
           ...localFunctions.map((f) => ({ name: f.name, body: f.body })),
           ...localConstants.map((c) => ({ name: c.name, body: c.value }))
         ];
-        const reachable = findReachableNames(primaryRefText, declarations);
+        const reachable = closeOverWritersOfMutableBindings(
+          primaryRefText,
+          declarations,
+          new Set(
+            ir.metadata.localConstants.filter((c) => (c.declarationKind ?? "const") !== "const").map((c) => c.name)
+          )
+        );
         const reachableBodies = [...reachable].map((name2) => {
           const func = localFunctions.find((f) => f.name === name2);
           if (func) return func.body;
@@ -25158,7 +25272,10 @@ var init_jsx_adapter = __esm({
           if (signal2.setter) {
             const setterUsed = identifierPattern(signal2.setter).test(setterRefText);
             if (setterUsed) {
-              lines.push(`  const ${signal2.setter} = (..._args: any[]) => {}`);
+              const setterType = preserveTypes && signal2.type.kind !== "unknown" ? `(valueOrFn: ${signal2.type.raw} | ((prev: ${signal2.type.raw}) => ${signal2.type.raw})) => void` : null;
+              lines.push(
+                setterType ? `  const ${signal2.setter}: ${setterType} = () => {}` : `  const ${signal2.setter} = (..._args: any[]) => {}`
+              );
             }
           }
         }
@@ -25425,7 +25542,7 @@ var init_jsx_adapter = __esm({
 });
 
 // ../jsx/src/adapters/template-imports.ts
-import ts25 from "typescript";
+import ts26 from "typescript";
 function rewriteImportsForTemplate(imports, shimSource, rewriteRelative) {
   const remap = (imp) => {
     if (!rewriteRelative || !imp.source.startsWith(".")) return imp;
@@ -25469,24 +25586,24 @@ function specKey(s) {
 }
 function rewriteDynamicImportsInSource(sourceText, rewriteRelative) {
   if (!sourceText.includes("import")) return sourceText;
-  const sf = ts25.createSourceFile(
+  const sf = ts26.createSourceFile(
     "bf-template-fragment.tsx",
     sourceText,
-    ts25.ScriptTarget.Latest,
+    ts26.ScriptTarget.Latest,
     /* setParentNodes */
     false,
-    ts25.ScriptKind.TSX
+    ts26.ScriptKind.TSX
   );
   const edits = [];
   const visit3 = (node) => {
-    if (ts25.isCallExpression(node) && node.expression.kind === ts25.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts25.isStringLiteralLike(node.arguments[0])) {
+    if (ts26.isCallExpression(node) && node.expression.kind === ts26.SyntaxKind.ImportKeyword && node.arguments.length > 0 && ts26.isStringLiteralLike(node.arguments[0])) {
       collect(node.arguments[0]);
     }
-    if (ts25.isImportTypeNode(node) && ts25.isLiteralTypeNode(node.argument)) {
+    if (ts26.isImportTypeNode(node) && ts26.isLiteralTypeNode(node.argument)) {
       const literal = node.argument.literal;
-      if (ts25.isStringLiteralLike(literal)) collect(literal);
+      if (ts26.isStringLiteralLike(literal)) collect(literal);
     }
-    ts25.forEachChild(node, visit3);
+    ts26.forEachChild(node, visit3);
   };
   const collect = (literal) => {
     const specifier = literal.text;
@@ -25501,7 +25618,7 @@ function rewriteDynamicImportsInSource(sourceText, rewriteRelative) {
       text: `'${next}'`
     });
   };
-  ts25.forEachChild(sf, visit3);
+  ts26.forEachChild(sf, visit3);
   if (edits.length === 0) return sourceText;
   let out = sourceText;
   for (const edit of edits.sort((a, b) => b.start - a.start)) {
@@ -25618,7 +25735,8 @@ export default ${this.componentName}` : "";
         const noArgDefault = hasRequiredProps ? "" : ` = {} as ${propsTypeExpr}`;
         const lines = [];
         const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
-        lines.push(`${exportPrefix}function ${name2}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+        const typeParameters = ir.metadata.typeParameters ?? "";
+        lines.push(`${exportPrefix}function ${name2}${typeParameters}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
         if (hasClientInteractivity) {
           lines.push(`  const __scopeId = (/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId || \`${name2}_\${Math.random().toString(36).slice(2, 8)}\``);
         } else {
@@ -26347,7 +26465,7 @@ var init_dangerous_inner_html = __esm({
 });
 
 // ../jsx/src/combine-client-js.ts
-import ts26 from "typescript";
+import ts27 from "typescript";
 function combineParentChildClientJs(files2) {
   const result2 = /* @__PURE__ */ new Map();
   const lookup = /* @__PURE__ */ new Map();
@@ -26404,17 +26522,17 @@ function combineParentChildClientJs(files2) {
   return result2;
 }
 function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts26.createSourceFile(
+  const sourceFile = ts27.createSourceFile(
     "combine.js",
     content2,
-    ts26.ScriptTarget.Latest,
+    ts27.ScriptTarget.Latest,
     /*setParentNodes*/
     false,
-    ts26.ScriptKind.JS
+    ts27.ScriptKind.JS
   );
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts26.isImportDeclaration(stmt)) continue;
+    if (!ts27.isImportDeclaration(stmt)) continue;
     const start2 = stmt.getStart(sourceFile);
     const end2 = stmt.getEnd();
     importSpans.push([start2, end2]);
@@ -26422,8 +26540,8 @@ function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
     if (stmtText.includes("@bf-child:")) continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts26.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts26.isNamedImports(bindings)) {
+    const specifier = ts27.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts27.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, /* @__PURE__ */ new Set());
       }
@@ -26598,7 +26716,7 @@ var init_loop_destructure = __esm({
 });
 
 // ../jsx/src/debug.ts
-import ts27 from "typescript";
+import ts28 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx2 = analyzeComponent(source, filePath, componentName);
   if (!ctx2.jsxReturn) {
@@ -26671,7 +26789,7 @@ function buildGraphFromIR(ir) {
     return propsObjectName ? exprReadsPropMember(expr, propsObjectName) : false;
   };
   const domBindings = [];
-  collectDomBindings(ir.root, domBindings, signalGetters, memoNames, void 0, /* @__PURE__ */ new Set(), exprReadsProp);
+  collectDomBindings(ir.root, domBindings, signalGetters, memoNames, void 0, BindingScope.EMPTY, exprReadsProp);
   const signalConsumers = /* @__PURE__ */ new Map();
   for (const s of meta.signals) signalConsumers.set(s.getter, []);
   for (const memo of meta.memos) {
@@ -27638,14 +27756,19 @@ function inferWrapReasonForAttrLike(hasStringReactive, hasPropsRef, flags) {
   const decision = decideWrapFromAstFlags(flags);
   return decision.wrap ? decision.reason : void 0;
 }
-function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag, loopParams = /* @__PURE__ */ new Set(), readsProp = () => false) {
-  const exprReadsLoopParam = (n) => loopParams.size > 0 && (n.origin?.freeRefs?.some((r2) => loopParams.has(r2.name)) ?? false);
-  const attrReadsLoopParam = (free) => loopParams.size > 0 && free !== void 0 && [...loopParams].some((p) => free.has(p));
+function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag, scope = BindingScope.EMPTY, readsProp = () => false) {
+  const boundNames = scope.valueBoundNames();
+  const setSomeIn = (names, other) => {
+    for (const n of names) if (other.has(n)) return true;
+    return false;
+  };
+  const exprReadsLoopParam = (n) => boundNames.size > 0 && (n.origin?.freeRefs?.some((r2) => boundNames.has(r2.name)) ?? false);
+  const attrReadsLoopParam = (free) => boundNames.size > 0 && free !== void 0 && setSomeIn(boundNames, free);
   switch (node.type) {
     case "element": {
       for (const attr of node.attrs) {
         if (attr.value.kind !== "expression" && attr.value.kind !== "template" && attr.value.kind !== "spread") continue;
-        if (attr.name === "key" && loopParams.size > 0) continue;
+        if (attr.name === "key" && boundNames.size > 0) continue;
         const expr = attrValueToString2(attr.value);
         if (!expr) continue;
         const deps = extractReactiveDeps(expr, signalGetters, memoNames);
@@ -27680,7 +27803,7 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
         });
       }
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, node.tag, loopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, node.tag, scope, readsProp);
       }
       break;
     }
@@ -27707,7 +27830,7 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
     }
     case "conditional": {
       const decision = decideWrapFromAstFlags(node);
-      const loopReactive = loopParams.size > 0 && (node.origin?.freeRefs?.some((r2) => loopParams.has(r2.name)) ?? false);
+      const loopReactive = boundNames.size > 0 && (node.origin?.freeRefs?.some((r2) => boundNames.has(r2.name)) ?? false);
       if ((decision.wrap || loopReactive) && node.slotId) {
         const deps = extractReactiveDeps(node.condition, signalGetters, memoNames);
         bindings.push({
@@ -27723,14 +27846,14 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
           jsxPreview: `{${truncateExpr(node.condition)} ? ... : ...}`
         });
       }
-      collectDomBindings(node.whenTrue, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
-      collectDomBindings(node.whenFalse, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+      collectDomBindings(node.whenTrue, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
+      collectDomBindings(node.whenFalse, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       break;
     }
     case "loop": {
       if (node.slotId) {
         const deps = extractReactiveDeps(node.array, signalGetters, memoNames);
-        const loopReactive = loopParams.size > 0 && node.arrayFreeIdentifiers !== void 0 && [...loopParams].some((p) => node.arrayFreeIdentifiers.has(p));
+        const loopReactive = boundNames.size > 0 && node.arrayFreeIdentifiers !== void 0 && setSomeIn(boundNames, node.arrayFreeIdentifiers);
         const isReactive = deps.length > 0 || node.callsReactiveGetters === true || loopReactive;
         const isFallback = !isReactive && node.hasFunctionCalls === true;
         if (isReactive || isFallback) {
@@ -27749,11 +27872,9 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
           });
         }
       }
-      const childLoopParams = new Set(loopParams);
-      for (const p of extractLoopParamNames(node.param, node)) childLoopParams.add(p);
-      if (node.index) childLoopParams.add(node.index);
+      const childScope = scope.enterLoopRow(node);
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, childLoopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, childScope, readsProp);
       }
       break;
     }
@@ -27783,21 +27904,21 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag,
         }
       }
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       }
       break;
     }
     case "fragment":
     case "provider": {
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       }
       break;
     }
     case "if-statement": {
-      collectDomBindings(node.consequent, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+      collectDomBindings(node.consequent, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       if (node.alternate) {
-        collectDomBindings(node.alternate, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+        collectDomBindings(node.alternate, bindings, signalGetters, memoNames, parentTag, scope, readsProp);
       }
       break;
     }
@@ -27810,18 +27931,18 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts27.createSourceFile("__attr.tsx", `(${expr})`, ts27.ScriptTarget.Latest, true, ts27.ScriptKind.TSX);
+    sf = ts28.createSourceFile("__attr.tsx", `(${expr})`, ts28.ScriptTarget.Latest, true, ts28.ScriptKind.TSX);
   } catch {
     return false;
   }
   let found = false;
   const visit3 = (n) => {
     if (found) return;
-    if (ts27.isPropertyAccessExpression(n) && ts27.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts28.isPropertyAccessExpression(n) && ts28.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts27.forEachChild(n, visit3);
+    ts28.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -27895,11 +28016,12 @@ var init_debug = __esm({
     init_reactivity();
     init_utils();
     init_identifier_pattern();
+    init_binding_scope();
   }
 });
 
 // ../jsx/src/profiler.ts
-import ts28 from "typescript";
+import ts29 from "typescript";
 function buildStaticBudget(source, filePath, componentName, options2 = {}) {
   const threshold = options2.fanOutThreshold ?? DEFAULT_FANOUT_THRESHOLD;
   const program = createProgramForFile(source, filePath)?.program;
@@ -28154,14 +28276,14 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts28.createSourceFile(filePath, source, ts28.ScriptTarget.Latest, true, ts28.ScriptKind.TSX);
+  const sf = ts29.createSourceFile(filePath, source, ts29.ScriptTarget.Latest, true, ts29.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts28.isCallExpression(node) && ts28.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts29.isCallExpression(node) && ts29.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 });
     }
-    ts28.forEachChild(node, visit3);
+    ts29.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -28447,19 +28569,19 @@ function assessBatchSafety(args2) {
   const signalGetters = new Set(args2.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts28.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts28.ScriptTarget.Latest, true);
+    sf = ts29.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts29.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts28.isCallExpression(node) && ts28.isIdentifier(node.expression)) {
+    if (ts29.isCallExpression(node) && ts29.isIdentifier(node.expression)) {
       const name2 = node.expression.text;
       if (setters.has(name2)) calls.push({ pos: node.getStart(sf), kind: "write" });
       else if (D.has(name2) && node.arguments.length === 0) calls.push({ pos: node.getStart(sf), kind: "memoRead" });
       else if (!signalGetters.has(name2) && !memoNames.has(name2)) calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts28.forEachChild(node, visit3);
+    ts29.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -110123,7 +110245,7 @@ __export(scenario_driver_exports, {
 import { writeFileSync as writeFileSync9, mkdtempSync, rmSync, readFileSync as readFileSync19, existsSync as existsSync23, statSync as statSync3 } from "node:fs";
 import { join as join2, dirname as dirname4, resolve as resolve6 } from "node:path";
 import { tmpdir } from "node:os";
-import ts29 from "typescript";
+import ts30 from "typescript";
 function externalRuntimeImport(clientJs) {
   const chunks = Array.isArray(clientJs) ? clientJs : [clientJs];
   for (const chunk of chunks) {
@@ -110193,11 +110315,11 @@ function resolveLocalFile(spec) {
 }
 function rewriteLocalImports(js, chunkPath, inlined) {
   const chunkDir = dirname4(chunkPath);
-  const sf = ts29.createSourceFile("chunk.mjs", js, ts29.ScriptTarget.Latest, false, ts29.ScriptKind.JS);
+  const sf = ts30.createSourceFile("chunk.mjs", js, ts30.ScriptTarget.Latest, false, ts30.ScriptKind.JS);
   const edits = [];
   for (const stmt of sf.statements) {
-    if (!ts29.isImportDeclaration(stmt)) continue;
-    if (!ts29.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts30.isImportDeclaration(stmt)) continue;
+    if (!ts30.isStringLiteral(stmt.moduleSpecifier)) continue;
     const spec = stmt.moduleSpecifier.text;
     if (!spec.startsWith(".")) continue;
     const resolved = resolveLocalFile(join2(chunkDir, spec.replace(/\.client\.js$/, "")));
@@ -110209,13 +110331,13 @@ function rewriteLocalImports(js, chunkPath, inlined) {
     const abs = resolve6(resolved);
     if (inlined.has(abs)) {
       const clause = stmt.importClause;
-      if (clause && (clause.name || clause.namedBindings && ts29.isNamespaceImport(clause.namedBindings))) {
+      if (clause && (clause.name || clause.namedBindings && ts30.isNamespaceImport(clause.namedBindings))) {
         throw new Error(
           `"${spec}" (imported by ${chunkPath}) uses a default or namespace import of a sibling client file, which the dynamic scenario runner cannot bind after inlining that file into the run. Import its exports by name, or use the static budget (\`bf debug profile <component>\`), which needs no run.`
         );
       }
       const shims = [];
-      if (clause?.namedBindings && ts29.isNamedImports(clause.namedBindings)) {
+      if (clause?.namedBindings && ts30.isNamedImports(clause.namedBindings)) {
         for (const el of clause.namedBindings.elements) {
           if (el.propertyName) shims.push(`var ${el.name.text} = ${el.propertyName.text}`);
         }