npm - @barefootjs/cli - Versions diffs - 0.35.0 → 0.35.1 - Mend

@barefootjs/cli 0.35.0 → 0.35.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/docs/core/reactivity/untrack.md +40 -0
package/dist/index.js +782 -713
package/package.json +5 -5

package/dist/index.js CHANGED Viewed

@@ -4606,7 +4606,7 @@ function irToHtmlTemplate(node, restSpreadNames, loopDepth = 0, loopParams, bran
           case "expression":
           case "template":
           case "spread": {
-            const expr = attrValueToString(p.value, { useTemplate: true }) ?? "undefined";
+            const expr = wrapExpr(attrValueToString(p.value, { useTemplate: true }) ?? "undefined");
             return `${quotePropName(p.name)}: ${expr}`;
           }
         }
@@ -5975,8 +5975,152 @@ var init_strip_types = __esm({
   }
 });
-// ../jsx/src/analyzer-context.ts
+// ../jsx/src/reactivity-checker.ts
 import ts9 from "typescript";
+function queryType(checker, node) {
+  incrementCounter("typeCheckerQueries");
+  return checker.getTypeAtLocation(node);
+}
+function isReactiveType(type2) {
+  return type2.getProperty(REACTIVE_BRAND) !== void 0;
+}
+function safeGetText(node) {
+  try {
+    return node.getText();
+  } catch {
+    return "";
+  }
+}
+function analyze(node, checker) {
+  if (ts9.isPropertyAccessExpression(node)) {
+    try {
+      const type2 = queryType(checker, node);
+      if (isReactiveType(type2)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {
+    }
+    const sub2 = analyze(node.expression, checker);
+    if (sub2.isReactive) {
+      return {
+        isReactive: true,
+        reason: {
+          kind: "child",
+          via: "property-access-object",
+          childText: safeGetText(node.expression),
+          childReason: sub2.reason
+        }
+      };
+    }
+    return NOT_REACTIVE;
+  }
+  if (ts9.isIdentifier(node)) {
+    try {
+      const type2 = queryType(checker, node);
+      if (isReactiveType(type2)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "identifier", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {
+    }
+    return NOT_REACTIVE;
+  }
+  if (ts9.isCallExpression(node)) {
+    try {
+      const calleeType = queryType(checker, node.expression);
+      if (isReactiveType(calleeType)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "callee", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {
+    }
+  }
+  let foundChild;
+  let foundChildText = "";
+  ts9.forEachChild(node, (child) => {
+    if (foundChild?.isReactive) return;
+    const result2 = analyze(child, checker);
+    if (result2.isReactive) {
+      foundChild = result2;
+      foundChildText = safeGetText(child);
+    }
+  });
+  if (foundChild?.isReactive) {
+    return {
+      isReactive: true,
+      reason: {
+        kind: "child",
+        via: "sub-expression",
+        childText: foundChildText,
+        childReason: foundChild.reason
+      }
+    };
+  }
+  return NOT_REACTIVE;
+}
+function containsReactiveExpression(node, checker) {
+  incrementCounter("reactivityChecks");
+  return brandTypeReactivityAnalyzer.analyze(node, checker).isReactive;
+}
+function nodeContainsJsx(node) {
+  if (ts9.isJsxElement(node) || ts9.isJsxSelfClosingElement(node) || ts9.isJsxFragment(node)) return true;
+  return ts9.forEachChild(node, nodeContainsJsx) ?? false;
+}
+function collectReactiveBrandLeaves(node, checker) {
+  const leaves = [];
+  const visit3 = (n) => {
+    if (ts9.isPropertyAccessExpression(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n))) {
+          leaves.push(n);
+          return;
+        }
+      } catch {
+      }
+      visit3(n.expression);
+      return;
+    }
+    if (ts9.isIdentifier(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n))) leaves.push(n);
+      } catch {
+      }
+      return;
+    }
+    if (ts9.isCallExpression(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n.expression))) {
+          leaves.push(nodeContainsJsx(n) ? n.expression : n);
+          return;
+        }
+      } catch {
+      }
+    }
+    ts9.forEachChild(n, visit3);
+  };
+  visit3(node);
+  return leaves;
+}
+var REACTIVE_BRAND, NOT_REACTIVE, brandTypeReactivityAnalyzer;
+var init_reactivity_checker = __esm({
+  "../jsx/src/reactivity-checker.ts"() {
+    "use strict";
+    init_instrumentation();
+    REACTIVE_BRAND = "__reactive";
+    NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
+    brandTypeReactivityAnalyzer = { analyze };
+  }
+});
+// ../jsx/src/analyzer-context.ts
+import ts10 from "typescript";
 function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
   return {
     sourceFile,
@@ -6027,7 +6171,7 @@ function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
       } catch {
         ownSourceFile = void 0;
       }
-      if (process.env.BF_ASSERT_NO_JSX_IN_GETJS === "1" && this.errors.length === 0 && nodeContainsJsx(node)) {
+      if (process.env.BF_ASSERT_NO_JSX_IN_GETJS === "1" && !this.errors.some((e) => e.severity === "error") && nodeContainsJsx(node)) {
         throw new Error(
           "getJS() called on a JSX-bearing node \u2014 raw JSX must never be spliced into emitted output. Carry mixed content as structured segments (MapCallbackPreamble / FlatMapCallback) instead."
         );
@@ -6039,10 +6183,6 @@ function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
     }
   };
 }
-function nodeContainsJsx(node) {
-  if (ts9.isJsxElement(node) || ts9.isJsxSelfClosingElement(node) || ts9.isJsxFragment(node)) return true;
-  return ts9.forEachChild(node, nodeContainsJsx) ?? false;
-}
 function getSourceLocation(node, sourceFile, filePath) {
   const start2 = sourceFile.getLineAndCharacterOfPosition(node.getStart());
   const end2 = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
@@ -6060,7 +6200,7 @@ function getSourceLocation(node, sourceFile, filePath) {
   };
 }
 function membersToProperties(members, sourceFile) {
-  return members.filter(ts9.isPropertySignature).map((member) => ({
+  return members.filter(ts10.isPropertySignature).map((member) => ({
     name: propertyNameText(member.name, sourceFile),
     type: typeNodeToTypeInfo(member.type, sourceFile) ?? {
       kind: "unknown",
@@ -6068,13 +6208,13 @@ function membersToProperties(members, sourceFile) {
     },
     optional: !!member.questionToken,
     readonly: !!member.modifiers?.some(
-      (m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword
+      (m) => m.kind === ts10.SyntaxKind.ReadonlyKeyword
     )
   }));
 }
 function propertyNameText(name2, sourceFile) {
   if (!name2) return "";
-  if (ts9.isStringLiteral(name2) || ts9.isNumericLiteral(name2)) return name2.text;
+  if (ts10.isStringLiteral(name2) || ts10.isNumericLiteral(name2)) return name2.text;
   return name2.getText(sourceFile);
 }
 function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
@@ -6083,48 +6223,48 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   const raw = rawOf ? rawOf(typeNode) : typeNode.getText(sourceFile);
   const recurse = (n) => typeNodeToTypeInfo(n, sourceFile, rawOf) ?? { kind: "unknown", raw: "unknown" };
   switch (typeNode.kind) {
-    case ts9.SyntaxKind.StringKeyword:
+    case ts10.SyntaxKind.StringKeyword:
       return { kind: "primitive", raw, primitive: "string" };
-    case ts9.SyntaxKind.NumberKeyword:
+    case ts10.SyntaxKind.NumberKeyword:
       return { kind: "primitive", raw, primitive: "number" };
-    case ts9.SyntaxKind.BooleanKeyword:
+    case ts10.SyntaxKind.BooleanKeyword:
       return { kind: "primitive", raw, primitive: "boolean" };
-    case ts9.SyntaxKind.NullKeyword:
+    case ts10.SyntaxKind.NullKeyword:
       return { kind: "primitive", raw, primitive: "null" };
-    case ts9.SyntaxKind.UndefinedKeyword:
+    case ts10.SyntaxKind.UndefinedKeyword:
       return { kind: "primitive", raw, primitive: "undefined" };
   }
-  if (ts9.isArrayTypeNode(typeNode)) {
+  if (ts10.isArrayTypeNode(typeNode)) {
     return { kind: "array", raw, elementType: recurse(typeNode.elementType) };
   }
-  if (ts9.isLiteralTypeNode(typeNode)) {
+  if (ts10.isLiteralTypeNode(typeNode)) {
     const lit = typeNode.literal;
-    if (ts9.isStringLiteral(lit) || ts9.isNoSubstitutionTemplateLiteral(lit)) {
+    if (ts10.isStringLiteral(lit) || ts10.isNoSubstitutionTemplateLiteral(lit)) {
       return { kind: "primitive", raw, primitive: "string", literalValue: lit.text };
     }
-    if (ts9.isNumericLiteral(lit)) {
+    if (ts10.isNumericLiteral(lit)) {
       return { kind: "primitive", raw, primitive: "number", literalValue: lit.text };
     }
-    if (ts9.isPrefixUnaryExpression(lit) && lit.operator === ts9.SyntaxKind.MinusToken && ts9.isNumericLiteral(lit.operand)) {
+    if (ts10.isPrefixUnaryExpression(lit) && lit.operator === ts10.SyntaxKind.MinusToken && ts10.isNumericLiteral(lit.operand)) {
       return { kind: "primitive", raw, primitive: "number", literalValue: `-${lit.operand.text}` };
     }
-    if (lit.kind === ts9.SyntaxKind.TrueKeyword || lit.kind === ts9.SyntaxKind.FalseKeyword) {
+    if (lit.kind === ts10.SyntaxKind.TrueKeyword || lit.kind === ts10.SyntaxKind.FalseKeyword) {
       return {
         kind: "primitive",
         raw,
         primitive: "boolean",
-        literalValue: lit.kind === ts9.SyntaxKind.TrueKeyword ? "true" : "false"
+        literalValue: lit.kind === ts10.SyntaxKind.TrueKeyword ? "true" : "false"
       };
     }
-    if (lit.kind === ts9.SyntaxKind.NullKeyword) {
+    if (lit.kind === ts10.SyntaxKind.NullKeyword) {
       return { kind: "primitive", raw, primitive: "null" };
     }
     return { kind: "unknown", raw };
   }
-  if (ts9.isUnionTypeNode(typeNode)) {
+  if (ts10.isUnionTypeNode(typeNode)) {
     return { kind: "union", raw, unionTypes: typeNode.types.map(recurse) };
   }
-  if (ts9.isTypeLiteralNode(typeNode)) {
+  if (ts10.isTypeLiteralNode(typeNode)) {
     return {
       kind: "object",
       raw,
@@ -6133,8 +6273,8 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
       ...synthetic ? {} : { properties: membersToProperties(typeNode.members, sourceFile) }
     };
   }
-  if (ts9.isTypeReferenceNode(typeNode)) {
-    const refName = ts9.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : "";
+  if (ts10.isTypeReferenceNode(typeNode)) {
+    const refName = ts10.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : "";
     if ((refName === "Array" || refName === "ReadonlyArray") && typeNode.typeArguments?.length === 1) {
       return { kind: "array", raw, elementType: recurse(typeNode.typeArguments[0]) };
     }
@@ -6143,7 +6283,7 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
       raw
     };
   }
-  if (ts9.isFunctionTypeNode(typeNode)) {
+  if (ts10.isFunctionTypeNode(typeNode)) {
     if (synthetic) return { kind: "function", raw };
     return {
       kind: "function",
@@ -6163,11 +6303,11 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   return { kind: "unknown", raw };
 }
 function tsTypeToTypeInfo(type2, checker) {
-  const node = checker.typeToTypeNode(type2, void 0, ts9.NodeBuilderFlags.NoTruncation);
+  const node = checker.typeToTypeNode(type2, void 0, ts10.NodeBuilderFlags.NoTruncation);
   if (!node) return null;
   const rawOf = (n) => {
     try {
-      return _typePrinter.printNode(ts9.EmitHint.Unspecified, n, _blankTypeSourceFile);
+      return _typePrinter.printNode(ts10.EmitHint.Unspecified, n, _blankTypeSourceFile);
     } catch {
       return "unknown";
     }
@@ -6178,13 +6318,13 @@ function isPascalCase(name2) {
   return /^[A-Z][a-zA-Z0-9]*$/.test(name2);
 }
 function isComponentFunction(node) {
-  return ts9.isFunctionDeclaration(node) && !!node.name && isPascalCase(node.name.text) && !!node.body;
+  return ts10.isFunctionDeclaration(node) && !!node.name && isPascalCase(node.name.text) && !!node.body;
 }
 function isArrowComponentFunction(node) {
-  if (!ts9.isVariableDeclaration(node)) return false;
-  if (!ts9.isIdentifier(node.name)) return false;
+  if (!ts10.isVariableDeclaration(node)) return false;
+  if (!ts10.isIdentifier(node.name)) return false;
   if (!isPascalCase(node.name.text)) return false;
-  if (!node.initializer || !ts9.isArrowFunction(node.initializer)) return false;
+  if (!node.initializer || !ts10.isArrowFunction(node.initializer)) return false;
   return true;
 }
 function collectReactiveGetterNames(signals, memos) {
@@ -6198,8 +6338,9 @@ var init_analyzer_context = __esm({
   "../jsx/src/analyzer-context.ts"() {
     "use strict";
     init_strip_types();
-    _typePrinter = ts9.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-    _blankTypeSourceFile = ts9.createSourceFile("__bf_types__.ts", "", ts9.ScriptTarget.Latest);
+    init_reactivity_checker();
+    _typePrinter = ts10.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+    _blankTypeSourceFile = ts10.createSourceFile("__bf_types__.ts", "", ts10.ScriptTarget.Latest);
   }
 });
@@ -6596,7 +6737,7 @@ var init_date_lowering = __esm({
 });
 // ../jsx/src/analyzer.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 import path5 from "node:path";
 import fs from "node:fs";
 function needsTypeBasedDetection(source) {
@@ -6607,8 +6748,8 @@ function needsTypeBasedDetection(source) {
 }
 function findBrandPackageImportLoc(sourceFile, filePath) {
   for (const stmt of sourceFile.statements) {
-    if (!ts10.isImportDeclaration(stmt)) continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts11.isImportDeclaration(stmt)) continue;
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier)) continue;
     if (!REACTIVE_BRAND_PACKAGES.includes(stmt.moduleSpecifier.text)) continue;
     const start2 = sourceFile.getLineAndCharacterOfPosition(stmt.getStart(sourceFile));
     const end2 = sourceFile.getLineAndCharacterOfPosition(stmt.getEnd());
@@ -6625,21 +6766,21 @@ function createProgramForFile(source, filePath) {
   try {
     const normalizedPath = path5.resolve(filePath);
     const compilerOptions = {
-      target: ts10.ScriptTarget.Latest,
-      module: ts10.ModuleKind.ESNext,
-      moduleResolution: ts10.ModuleResolutionKind.Bundler,
-      jsx: ts10.JsxEmit.ReactJSX,
+      target: ts11.ScriptTarget.Latest,
+      module: ts11.ModuleKind.ESNext,
+      moduleResolution: ts11.ModuleResolutionKind.Bundler,
+      jsx: ts11.JsxEmit.ReactJSX,
       strict: true,
       skipLibCheck: true,
       noEmit: true,
       baseUrl: path5.dirname(normalizedPath)
     };
-    const defaultHost = ts10.createCompilerHost(compilerOptions);
+    const defaultHost = ts11.createCompilerHost(compilerOptions);
     const virtualHost = {
       ...defaultHost,
       getSourceFile(fileName, languageVersion) {
         if (path5.resolve(fileName) === normalizedPath) {
-          return ts10.createSourceFile(fileName, source, languageVersion, true, ts10.ScriptKind.TSX);
+          return ts11.createSourceFile(fileName, source, languageVersion, true, ts11.ScriptKind.TSX);
         }
         return defaultHost.getSourceFile(fileName, languageVersion);
       },
@@ -6652,7 +6793,7 @@ function createProgramForFile(source, filePath) {
         return defaultHost.readFile(fileName);
       }
     };
-    const program = ts10.createProgram([normalizedPath], compilerOptions, virtualHost);
+    const program = ts11.createProgram([normalizedPath], compilerOptions, virtualHost);
     const sourceFile = program.getSourceFile(normalizedPath);
     if (!sourceFile) return null;
     return { program, sourceFile, checker: program.getTypeChecker() };
@@ -6684,12 +6825,12 @@ function analyzeComponent(source, filePath, targetComponentName, program, accept
     }
   }
   if (!sourceFile) {
-    sourceFile = ts10.createSourceFile(
+    sourceFile = ts11.createSourceFile(
       filePath,
       source,
-      ts10.ScriptTarget.Latest,
+      ts11.ScriptTarget.Latest,
       true,
-      ts10.ScriptKind.TSX
+      ts11.ScriptKind.TSX
     );
   }
   if (!checker && needsTypeBasedDetection(source)) {
@@ -6735,23 +6876,23 @@ function analyzeComponent(source, filePath, targetComponentName, program, accept
 function findDefaultExportedComponent(sourceFile) {
   let defaultExportName;
   function findDefaultExport(node) {
-    if (ts10.isExportAssignment(node) && !node.isExportEquals) {
-      if (ts10.isIdentifier(node.expression)) {
+    if (ts11.isExportAssignment(node) && !node.isExportEquals) {
+      if (ts11.isIdentifier(node.expression)) {
         defaultExportName = node.expression.text;
       }
     }
-    if (ts10.isFunctionDeclaration(node) && node.name && node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DefaultKeyword)) {
+    if (ts11.isFunctionDeclaration(node) && node.name && node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DefaultKeyword)) {
       defaultExportName = node.name.text;
     }
-    ts10.forEachChild(node, findDefaultExport);
+    ts11.forEachChild(node, findDefaultExport);
   }
-  ts10.forEachChild(sourceFile, findDefaultExport);
+  ts11.forEachChild(sourceFile, findDefaultExport);
   return defaultExportName;
 }
 function collectNamedExports(sourceFile) {
   const exported = /* @__PURE__ */ new Set();
   for (const stmt of sourceFile.statements) {
-    if (ts10.isExportDeclaration(stmt) && stmt.exportClause && ts10.isNamedExports(stmt.exportClause)) {
+    if (ts11.isExportDeclaration(stmt) && stmt.exportClause && ts11.isNamedExports(stmt.exportClause)) {
       for (const spec of stmt.exportClause.elements) {
         const local = (spec.propertyName ?? spec.name).text;
         exported.add(local);
@@ -6761,22 +6902,22 @@ function collectNamedExports(sourceFile) {
   return exported;
 }
 function visit(node, ctx2, targetComponentName, namedExports) {
-  if (ts10.isExpressionStatement(node) && ts10.isStringLiteral(node.expression)) {
+  if (ts11.isExpressionStatement(node) && ts11.isStringLiteral(node.expression)) {
     if (node.expression.text === "use client" || node.expression.text === "'use client'") {
       ctx2.hasUseClientDirective = true;
     }
   }
-  if (ts10.isImportDeclaration(node)) {
+  if (ts11.isImportDeclaration(node)) {
     collectImport(node, ctx2);
   }
-  if (ts10.isInterfaceDeclaration(node)) {
+  if (ts11.isInterfaceDeclaration(node)) {
     collectInterfaceDefinition(node, ctx2);
   }
-  if (ts10.isTypeAliasDeclaration(node)) {
+  if (ts11.isTypeAliasDeclaration(node)) {
     collectTypeAliasDefinition(node, ctx2);
   }
-  if (!ctx2.hasUseClientDirective && ts10.isFunctionDeclaration(node) && node.name && node.body && isMultiReturnJsxFunctionBody(node.body)) {
-    const hasInlineExport = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+  if (!ctx2.hasUseClientDirective && ts11.isFunctionDeclaration(node) && node.name && node.body && isMultiReturnJsxFunctionBody(node.body)) {
+    const hasInlineExport = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
     const hasNamedExport = namedExports?.has(node.name.text) ?? false;
     if (!hasInlineExport && !hasNamedExport) {
       collectFunction(node, ctx2, true, false);
@@ -6790,9 +6931,9 @@ function visit(node, ctx2, targetComponentName, namedExports) {
       if (!ctx2.componentName) {
         ctx2.componentName = node.name.text;
         ctx2.componentNode = node;
-        ctx2.isExported = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+        ctx2.isExported = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
         analyzeComponentBody(node, ctx2);
-        if (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DefaultKeyword)) {
+        if (node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DefaultKeyword)) {
           ctx2.hasDefaultExport = true;
         }
       }
@@ -6806,10 +6947,10 @@ function visit(node, ctx2, targetComponentName, namedExports) {
         ctx2.componentName = node.name.text;
         ctx2.componentNode = node.initializer;
         const parentStatement = node.parent;
-        if (ts10.isVariableDeclarationList(parentStatement)) {
+        if (ts11.isVariableDeclarationList(parentStatement)) {
           const varStatement = parentStatement.parent;
-          if (ts10.isVariableStatement(varStatement)) {
-            ctx2.isExported = varStatement.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+          if (ts11.isVariableStatement(varStatement)) {
+            ctx2.isExported = varStatement.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
           }
         }
         analyzeComponentBody(node.initializer, ctx2);
@@ -6821,10 +6962,10 @@ function visit(node, ctx2, targetComponentName, namedExports) {
   if (!ctx2.componentNode) {
     collectAmbientGlobals(node, ctx2);
   }
-  const isDeclareStatement = ts10.isVariableStatement(node) && (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DeclareKeyword) ?? false);
-  if (ts10.isVariableStatement(node) && !ctx2.componentNode && !isDeclareStatement) {
-    const isExported = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
-    const isLet = (node.declarationList.flags & ts10.NodeFlags.Let) !== 0;
+  const isDeclareStatement = ts11.isVariableStatement(node) && (node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DeclareKeyword) ?? false);
+  if (ts11.isVariableStatement(node) && !ctx2.componentNode && !isDeclareStatement) {
+    const isExported = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
+    const isLet = (node.declarationList.flags & ts11.NodeFlags.Let) !== 0;
     const isModuleClientDirective = hasLeadingClientDirectiveOnStatement(node, ctx2.sourceFile);
     for (const decl of node.declarationList.declarations) {
       if (declarationIsReactiveFactoryCall(decl, ctx2)) {
@@ -6838,19 +6979,19 @@ function visit(node, ctx2, targetComponentName, namedExports) {
         }
         continue;
       }
-      if (ts10.isIdentifier(decl.name) && (decl.initializer || isLet) && !isArrowComponentFunction(decl)) {
+      if (ts11.isIdentifier(decl.name) && (decl.initializer || isLet) && !isArrowComponentFunction(decl)) {
         collectConstant(decl, ctx2, true, isLet ? "let" : "const", isExported);
       }
     }
   }
-  if (ts10.isFunctionDeclaration(node) && node.name && !isComponentFunction(node)) {
-    const isExported = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+  if (ts11.isFunctionDeclaration(node) && node.name && !isComponentFunction(node)) {
+    const isExported = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
     collectFunction(node, ctx2, true, isExported);
     return;
   }
-  if (ts10.isExportDeclaration(node) && node.exportClause && ts10.isNamedExports(node.exportClause)) {
+  if (ts11.isExportDeclaration(node) && node.exportClause && ts11.isNamedExports(node.exportClause)) {
     const isFromReexport = !!node.moduleSpecifier;
-    const sourceSpec = node.moduleSpecifier && ts10.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
+    const sourceSpec = node.moduleSpecifier && ts11.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
     const exportSpecifiers = node.exportClause.elements.map((spec) => ({
       name: (spec.propertyName ?? spec.name).text,
       alias: spec.propertyName ? spec.name.text : null,
@@ -6876,24 +7017,24 @@ function visit(node, ctx2, targetComponentName, namedExports) {
       }
     }
   }
-  if (ts10.isExportAssignment(node) && !node.isExportEquals) {
+  if (ts11.isExportAssignment(node) && !node.isExportEquals) {
     const expr = node.expression;
-    if (ts10.isIdentifier(expr)) {
+    if (ts11.isIdentifier(expr)) {
       if (ctx2.componentName && expr.text === ctx2.componentName) {
         ctx2.hasDefaultExport = true;
         ctx2.isExported = true;
       }
     }
   }
-  ts10.forEachChild(node, (child) => visit(child, ctx2, targetComponentName, namedExports));
+  ts11.forEachChild(node, (child) => visit(child, ctx2, targetComponentName, namedExports));
 }
 function analyzeComponentBody(node, ctx2) {
   if (node.parameters.length > 0) {
     extractProps(node.parameters[0], ctx2);
   }
-  const body2 = ts10.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
+  const body2 = ts11.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
   if (body2) {
-    ctx2.componentBodyBlock = ts10.isBlock(body2) ? body2 : null;
+    ctx2.componentBodyBlock = ts11.isBlock(body2) ? body2 : null;
     if (!ctx2.componentBodyBlock) {
       ctx2.jsxReturn = unwrapJsxTransparent(body2);
     }
@@ -6903,14 +7044,14 @@ function analyzeComponentBody(node, ctx2) {
   }
 }
 function getArrowFunctionBody(node) {
-  if (ts10.isBlock(node.body)) {
+  if (ts11.isBlock(node.body)) {
     return node.body;
   }
   return node.body;
 }
 function visitComponentBody(node, ctx2) {
   const isTopLevel = ctx2.componentBodyBlock !== null && node.parent === ctx2.componentBodyBlock;
-  if (ts10.isVariableStatement(node)) {
+  if (ts11.isVariableStatement(node)) {
     for (const decl of node.declarationList.declarations) {
       if (isSignalDeclaration(decl, ctx2)) {
         collectSignal(decl, ctx2);
@@ -6933,16 +7074,16 @@ function visitComponentBody(node, ctx2) {
         collectEffect(decl.initializer, ctx2, decl.name.text);
         continue;
       }
-      if (ts10.isIdentifier(decl.name)) {
-        const isLet = (node.declarationList.flags & ts10.NodeFlags.Let) !== 0;
+      if (ts11.isIdentifier(decl.name)) {
+        const isLet = (node.declarationList.flags & ts11.NodeFlags.Let) !== 0;
         collectConstant(decl, ctx2, false, isLet ? "let" : "const");
-      } else if (ts10.isObjectBindingPattern(decl.name) && decl.initializer && ts10.isIdentifier(decl.initializer) && ctx2.propsObjectName === decl.initializer.text) {
-        const isLet = (node.declarationList.flags & ts10.NodeFlags.Let) !== 0;
+      } else if (ts11.isObjectBindingPattern(decl.name) && decl.initializer && ts11.isIdentifier(decl.initializer) && ctx2.propsObjectName === decl.initializer.text) {
+        const isLet = (node.declarationList.flags & ts11.NodeFlags.Let) !== 0;
         collectConstant(decl, ctx2, false, isLet ? "let" : "const");
       }
     }
   }
-  if (ts10.isExpressionStatement(node)) {
+  if (ts11.isExpressionStatement(node)) {
     if (isEffectCall(node.expression, ctx2)) {
       collectEffect(node.expression, ctx2);
       return;
@@ -6956,10 +7097,10 @@ function visitComponentBody(node, ctx2) {
       return;
     }
   }
-  if (ts10.isFunctionDeclaration(node) && node.name) {
+  if (ts11.isFunctionDeclaration(node) && node.name) {
     collectFunction(node, ctx2, false);
   }
-  if (ts10.isIfStatement(node)) {
+  if (ts11.isIfStatement(node)) {
     const jsxReturn = findJsxReturnInBlock(node.thenStatement);
     if (jsxReturn) {
       const scopeVars = collectScopeVariables(node.thenStatement, ctx2);
@@ -6978,8 +7119,8 @@ function visitComponentBody(node, ctx2) {
       return;
     }
   }
-  if (isTopLevel && (ts10.isTryStatement(node) || ts10.isSwitchStatement(node) || ts10.isForStatement(node) || ts10.isForInStatement(node) || ts10.isForOfStatement(node) || ts10.isWhileStatement(node) || ts10.isDoStatement(node) || ts10.isThrowStatement(node) || ts10.isBlock(node) && node.parent === ctx2.componentBodyBlock)) {
-    if (ts10.isBlock(node)) {
+  if (isTopLevel && (ts11.isTryStatement(node) || ts11.isSwitchStatement(node) || ts11.isForStatement(node) || ts11.isForInStatement(node) || ts11.isForOfStatement(node) || ts11.isWhileStatement(node) || ts11.isDoStatement(node) || ts11.isThrowStatement(node) || ts11.isBlock(node) && node.parent === ctx2.componentBodyBlock)) {
+    if (ts11.isBlock(node)) {
       const returnedLocal = findBlockBodyReturnedJsxLocalName(node);
       if (returnedLocal) {
         ctx2.errors.push(createError(
@@ -6994,33 +7135,33 @@ function visitComponentBody(node, ctx2) {
     collectInitStatement(node, ctx2);
     return;
   }
-  if (ts10.isReturnStatement(node) && node.expression) {
+  if (ts11.isReturnStatement(node) && node.expression) {
     ctx2.jsxReturn = unwrapJsxTransparent(node.expression);
   }
-  ts10.forEachChild(node, (child) => {
-    if (ts10.isArrowFunction(child) || ts10.isFunctionExpression(child) || ts10.isFunctionDeclaration(child)) {
+  ts11.forEachChild(node, (child) => {
+    if (ts11.isArrowFunction(child) || ts11.isFunctionExpression(child) || ts11.isFunctionDeclaration(child)) {
       return;
     }
     visitComponentBody(child, ctx2);
   });
 }
 function findJsxReturnInBlock(node) {
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (ts10.isReturnStatement(stmt) && stmt.expression) {
+      if (ts11.isReturnStatement(stmt) && stmt.expression) {
         const jsx = extractJsxFromExpression(stmt.expression);
         if (jsx) return jsx;
       }
     }
   }
-  if (ts10.isReturnStatement(node) && node.expression) {
+  if (ts11.isReturnStatement(node) && node.expression) {
     return extractJsxFromExpression(node.expression);
   }
   return null;
 }
 function unwrapJsxTransparent(expr) {
   let current = expr;
-  while (ts10.isParenthesizedExpression(current) || ts10.isAsExpression(current) || ts10.isSatisfiesExpression(current) || ts10.isNonNullExpression(current) || ts10.isTypeAssertionExpression(current) || current.kind === ts10.SyntaxKind.PartiallyEmittedExpression) {
+  while (ts11.isParenthesizedExpression(current) || ts11.isAsExpression(current) || ts11.isSatisfiesExpression(current) || ts11.isNonNullExpression(current) || ts11.isTypeAssertionExpression(current) || current.kind === ts11.SyntaxKind.PartiallyEmittedExpression) {
     current = current.expression;
   }
   return current;
@@ -7028,17 +7169,17 @@ function unwrapJsxTransparent(expr) {
 function findBlockBodyReturnedJsxLocalName(block) {
   const stmts = block.statements;
   const last = stmts[stmts.length - 1];
-  if (!last || !ts10.isReturnStatement(last) || !last.expression) return null;
+  if (!last || !ts11.isReturnStatement(last) || !last.expression) return null;
   const returned = unwrapJsxTransparent(last.expression);
-  if (!ts10.isIdentifier(returned)) return null;
+  if (!ts11.isIdentifier(returned)) return null;
   const name2 = returned.text;
   for (const stmt of stmts) {
-    if (!ts10.isVariableStatement(stmt)) continue;
+    if (!ts11.isVariableStatement(stmt)) continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts10.isIdentifier(decl.name) || decl.name.text !== name2 || !decl.initializer) continue;
+      if (!ts11.isIdentifier(decl.name) || decl.name.text !== name2 || !decl.initializer) continue;
       let init = decl.initializer;
-      while (ts10.isParenthesizedExpression(init)) init = init.expression;
-      if (ts10.isJsxElement(init) || ts10.isJsxSelfClosingElement(init) || ts10.isJsxFragment(init) || initializerShapeContainsJsx(init) || // `initializerShapeContainsJsx` deliberately stops at arrow
+      while (ts11.isParenthesizedExpression(init)) init = init.expression;
+      if (ts11.isJsxElement(init) || ts11.isJsxSelfClosingElement(init) || ts11.isJsxFragment(init) || initializerShapeContainsJsx(init) || // `initializerShapeContainsJsx` deliberately stops at arrow
       // boundaries, so a `.map()`/`.flatMap()` whose CALLBACK returns JSX
       // needs the same dedicated check `collectConstant` uses to admit
       // that shape into `inlineableJsxConsts` (#1554) — without it,
@@ -7054,16 +7195,16 @@ function findBlockBodyReturnedJsxLocalName(block) {
 }
 function extractJsxFromExpression(expr) {
   const inner = unwrapJsxTransparent(expr);
-  if (ts10.isJsxElement(inner) || ts10.isJsxFragment(inner) || ts10.isJsxSelfClosingElement(inner)) {
+  if (ts11.isJsxElement(inner) || ts11.isJsxFragment(inner) || ts11.isJsxSelfClosingElement(inner)) {
     return inner;
   }
   return null;
 }
 function collectScopeVariables(node, ctx2) {
   const variables = [];
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (ts10.isVariableStatement(stmt)) {
+      if (ts11.isVariableStatement(stmt)) {
         for (const decl of stmt.declarationList.declarations) {
           variables.push(decl);
         }
@@ -7075,13 +7216,13 @@ function collectScopeVariables(node, ctx2) {
 function collectParamBindingNames(params) {
   const out = /* @__PURE__ */ new Set();
   const addBindingNames2 = (name2) => {
-    if (ts10.isIdentifier(name2)) {
+    if (ts11.isIdentifier(name2)) {
       out.add(name2.text);
-    } else if (ts10.isObjectBindingPattern(name2)) {
+    } else if (ts11.isObjectBindingPattern(name2)) {
       name2.elements.forEach((e) => addBindingNames2(e.name));
-    } else if (ts10.isArrayBindingPattern(name2)) {
+    } else if (ts11.isArrayBindingPattern(name2)) {
       name2.elements.forEach((e) => {
-        if (!ts10.isOmittedExpression(e)) addBindingNames2(e.name);
+        if (!ts11.isOmittedExpression(e)) addBindingNames2(e.name);
       });
     }
   };
@@ -7095,7 +7236,7 @@ function collectEnclosingBranchVars(node, ctx2) {
     for (const cr of ctx2.conditionalReturns) {
       if (cr.ifStatement.thenStatement !== current) continue;
       for (const decl of cr.scopeVariables) {
-        if (!ts10.isIdentifier(decl.name) || !decl.initializer) continue;
+        if (!ts11.isIdentifier(decl.name) || !decl.initializer) continue;
         const varName = decl.name.text;
         if (result2.has(varName)) continue;
         if (initializerShapeContainsJsx(decl.initializer)) continue;
@@ -7107,9 +7248,9 @@ function collectEnclosingBranchVars(node, ctx2) {
   return result2;
 }
 function collectBranchSignals(thenStatement, ctx2, branchCondition) {
-  if (!ts10.isBlock(thenStatement)) return;
+  if (!ts11.isBlock(thenStatement)) return;
   for (const stmt of thenStatement.statements) {
-    if (!ts10.isVariableStatement(stmt)) continue;
+    if (!ts11.isVariableStatement(stmt)) continue;
     for (const decl of stmt.declarationList.declarations) {
       if (!isSignalDeclaration(decl, ctx2)) continue;
       const before = ctx2.signals.length;
@@ -7122,12 +7263,12 @@ function collectBranchSignals(thenStatement, ctx2, branchCondition) {
   }
 }
 function resolvePrimitiveKind(callExpr, ctx2) {
-  if (ts10.isIdentifier(callExpr.expression)) {
+  if (ts11.isIdentifier(callExpr.expression)) {
     const hit = PRIMITIVE_CANONICAL_NAMES[callExpr.expression.text];
     if (hit) return hit;
     return resolveCalleeViaChecker(callExpr.expression, ctx2);
   }
-  if (ts10.isPropertyAccessExpression(callExpr.expression)) {
+  if (ts11.isPropertyAccessExpression(callExpr.expression)) {
     const propName = callExpr.expression.name.text;
     const hit = PRIMITIVE_CANONICAL_NAMES[propName];
     if (!hit) return null;
@@ -7151,7 +7292,7 @@ function resolveCanonicalClientExportName(ident, ctx2) {
   }
   if (!symbol) return null;
   let target2 = symbol;
-  if (symbol.flags & ts10.SymbolFlags.Alias) {
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
     try {
       target2 = ctx2.checker.getAliasedSymbol(symbol);
     } catch {
@@ -7167,20 +7308,20 @@ function resolveCanonicalClientExportName(ident, ctx2) {
   return null;
 }
 function resolveEnvSignalKey(callExpr, ctx2) {
-  if (ts10.isIdentifier(callExpr.expression)) {
+  if (ts11.isIdentifier(callExpr.expression)) {
     const key = ENV_SIGNAL_FACTORIES[callExpr.expression.text];
     if (key) return key;
     const canonical = resolveCanonicalClientExportName(callExpr.expression, ctx2);
     return canonical ? ENV_SIGNAL_FACTORIES[canonical] ?? null : null;
   }
-  if (ts10.isPropertyAccessExpression(callExpr.expression)) {
+  if (ts11.isPropertyAccessExpression(callExpr.expression)) {
     const key = ENV_SIGNAL_FACTORIES[callExpr.expression.name.text];
     if (key && isBarefootClientNamespace(callExpr.expression.expression, ctx2)) return key;
   }
   return null;
 }
 function isBarefootClientNamespace(expr, ctx2) {
-  if (!ts10.isIdentifier(expr)) return false;
+  if (!ts11.isIdentifier(expr)) return false;
   if (!ctx2.checker) return false;
   let symbol;
   try {
@@ -7190,33 +7331,33 @@ function isBarefootClientNamespace(expr, ctx2) {
   }
   if (!symbol) return false;
   for (const decl of symbol.declarations ?? []) {
-    if (!ts10.isNamespaceImport(decl)) continue;
+    if (!ts11.isNamespaceImport(decl)) continue;
     const importDecl = decl.parent.parent;
-    if (!ts10.isImportDeclaration(importDecl)) continue;
+    if (!ts11.isImportDeclaration(importDecl)) continue;
     const mod = importDecl.moduleSpecifier;
-    if (ts10.isStringLiteral(mod) && mod.text === "@barefootjs/client") {
+    if (ts11.isStringLiteral(mod) && mod.text === "@barefootjs/client") {
       return true;
     }
   }
   return false;
 }
 function isSignalDeclaration(node, ctx2) {
-  if (!ts10.isArrayBindingPattern(node.name)) return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer)) return false;
+  if (!ts11.isArrayBindingPattern(node.name)) return false;
+  if (!node.initializer || !ts11.isCallExpression(node.initializer)) return false;
   return resolvePrimitiveKind(node.initializer, ctx2) === "signal";
 }
 function collectSignal(node, ctx2) {
   const pattern = node.name;
   const callExpr = node.initializer;
   const elements2 = pattern.elements;
-  const getterElided = elements2.length === 2 && ts10.isOmittedExpression(elements2[0]);
-  if (elements2.length < 1 || elements2.length > 2 || !getterElided && (!ts10.isBindingElement(elements2[0]) || !ts10.isIdentifier(elements2[0].name))) {
+  const getterElided = elements2.length === 2 && ts11.isOmittedExpression(elements2[0]);
+  if (elements2.length < 1 || elements2.length > 2 || !getterElided && (!ts11.isBindingElement(elements2[0]) || !ts11.isIdentifier(elements2[0].name))) {
     return;
   }
-  if (elements2.length === 2 && (!ts10.isBindingElement(elements2[1]) || !ts10.isIdentifier(elements2[1].name))) {
+  if (elements2.length === 2 && (!ts11.isBindingElement(elements2[1]) || !ts11.isIdentifier(elements2[1].name))) {
     return;
   }
-  const setter = elements2.length === 2 && ts10.isBindingElement(elements2[1]) && ts10.isIdentifier(elements2[1].name) ? elements2[1].name.text : null;
+  const setter = elements2.length === 2 && ts11.isBindingElement(elements2[1]) && ts11.isIdentifier(elements2[1].name) ? elements2[1].name.text : null;
   if (getterElided && !setter) return;
   const getter = getterElided ? `__bfGet_${setter}` : elements2[0].name.text;
   const initialValue = callExpr.arguments[0] ? ctx2.getJS(callExpr.arguments[0]) : "";
@@ -7252,27 +7393,27 @@ function collectSignal(node, ctx2) {
   });
 }
 function isSignalTupleDeclaration(node) {
-  if (!ts10.isIdentifier(node.name)) return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer)) return false;
+  if (!ts11.isIdentifier(node.name)) return false;
+  if (!node.initializer || !ts11.isCallExpression(node.initializer)) return false;
   const callExpr = node.initializer;
-  return ts10.isIdentifier(callExpr.expression) && callExpr.expression.text === "createSignal";
+  return ts11.isIdentifier(callExpr.expression) && callExpr.expression.text === "createSignal";
 }
 function isSignalIndexAccess(node, ctx2) {
-  if (!ts10.isIdentifier(node.name)) return null;
-  if (!node.initializer || !ts10.isElementAccessExpression(node.initializer)) return null;
+  if (!ts11.isIdentifier(node.name)) return null;
+  if (!node.initializer || !ts11.isElementAccessExpression(node.initializer)) return null;
   const access2 = node.initializer;
-  if (!ts10.isNumericLiteral(access2.argumentExpression)) return null;
+  if (!ts11.isNumericLiteral(access2.argumentExpression)) return null;
   const indexValue = Number(access2.argumentExpression.text);
   if (indexValue !== 0 && indexValue !== 1) return null;
   const index = indexValue;
-  if (ts10.isCallExpression(access2.expression)) {
+  if (ts11.isCallExpression(access2.expression)) {
     const call = access2.expression;
-    if (ts10.isIdentifier(call.expression) && call.expression.text === "createSignal") {
+    if (ts11.isIdentifier(call.expression) && call.expression.text === "createSignal") {
       return { kind: "direct", index, callExpr: call };
     }
     return null;
   }
-  if (ts10.isIdentifier(access2.expression)) {
+  if (ts11.isIdentifier(access2.expression)) {
     const tupleName = access2.expression.text;
     if (ctx2.signalTupleRefs.has(tupleName)) {
       return { kind: "tupleRef", index, tupleName };
@@ -7363,23 +7504,23 @@ function flushPendingSignalTuples(ctx2) {
   ctx2.signalTupleRefs.clear();
 }
 function isMemoDeclaration(node, ctx2) {
-  if (!ts10.isIdentifier(node.name)) return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer)) return false;
+  if (!ts11.isIdentifier(node.name)) return false;
+  if (!node.initializer || !ts11.isCallExpression(node.initializer)) return false;
   return resolvePrimitiveKind(node.initializer, ctx2) === "memo";
 }
 function memoBodyIsTemplateLiteral(memoArrow) {
   let node = memoArrow;
-  while (node && ts10.isParenthesizedExpression(node)) node = node.expression;
-  if (!node || !ts10.isArrowFunction(node)) return false;
+  while (node && ts11.isParenthesizedExpression(node)) node = node.expression;
+  if (!node || !ts11.isArrowFunction(node)) return false;
   let body2 = node.body;
-  while (ts10.isParenthesizedExpression(body2)) body2 = body2.expression;
-  if (ts10.isBlock(body2)) {
-    const ret = body2.statements.find(ts10.isReturnStatement);
+  while (ts11.isParenthesizedExpression(body2)) body2 = body2.expression;
+  if (ts11.isBlock(body2)) {
+    const ret = body2.statements.find(ts11.isReturnStatement);
     if (!ret || !ret.expression) return false;
     body2 = ret.expression;
-    while (ts10.isParenthesizedExpression(body2)) body2 = body2.expression;
+    while (ts11.isParenthesizedExpression(body2)) body2 = body2.expression;
   }
-  return ts10.isTemplateExpression(body2) || ts10.isNoSubstitutionTemplateLiteral(body2);
+  return ts11.isTemplateExpression(body2) || ts11.isNoSubstitutionTemplateLiteral(body2);
 }
 function collectMemo(node, ctx2) {
   const name2 = node.name.text;
@@ -7396,7 +7537,7 @@ function collectMemo(node, ctx2) {
       type2 = inferTypeFromValue(arrowBody);
     }
   }
-  if (ctx2.checker && (type2.kind === "unknown" || type2.kind === "object") && callExpr.arguments[0] && (ts10.isArrowFunction(callExpr.arguments[0]) || ts10.isFunctionExpression(callExpr.arguments[0]))) {
+  if (ctx2.checker && (type2.kind === "unknown" || type2.kind === "object") && callExpr.arguments[0] && (ts11.isArrowFunction(callExpr.arguments[0]) || ts11.isFunctionExpression(callExpr.arguments[0]))) {
     const fnType = ctx2.checker.getTypeAtLocation(callExpr.arguments[0]);
     const sig = fnType.getCallSignatures()[0];
     if (sig) {
@@ -7405,11 +7546,11 @@ function collectMemo(node, ctx2) {
     }
   }
   const memoArrow = callExpr.arguments[0];
-  const parsedBody = memoArrow && ts10.isArrowFunction(memoArrow) && !ts10.isBlock(memoArrow.body) ? parseExpression(ctx2.getJS(memoArrow.body)) : void 0;
+  const parsedBody = memoArrow && ts11.isArrowFunction(memoArrow) && !ts11.isBlock(memoArrow.body) ? parseExpression(ctx2.getJS(memoArrow.body)) : void 0;
   const parsed = parsedBody && parsedBody.kind !== "unsupported" && parsedBody.kind !== "object-literal" ? parsedBody : void 0;
   let arrowNode = memoArrow;
-  while (arrowNode && ts10.isParenthesizedExpression(arrowNode)) arrowNode = arrowNode.expression;
-  const blockBody = arrowNode && ts10.isArrowFunction(arrowNode) && ts10.isBlock(arrowNode.body) ? arrowNode.body : void 0;
+  while (arrowNode && ts11.isParenthesizedExpression(arrowNode)) arrowNode = arrowNode.expression;
+  const blockBody = arrowNode && ts11.isArrowFunction(arrowNode) && ts11.isBlock(arrowNode.body) ? arrowNode.body : void 0;
   const parsedBlock = blockBody ? parseBlockBodyTolerant(blockBody, ctx2.sourceFile, (node2) => ctx2.getJS(node2)) : void 0;
   const parsedBlockComplete = parsedBlock && blockBody ? parsedBlock.length === blockBody.statements.length : void 0;
   let templateComputation;
@@ -7436,12 +7577,12 @@ function collectMemo(node, ctx2) {
   });
 }
 function isEffectCall(node, ctx2) {
-  if (!ts10.isCallExpression(node)) return false;
+  if (!ts11.isCallExpression(node)) return false;
   return resolvePrimitiveKind(node, ctx2) === "effect";
 }
 function isEffectDisposerCapture(node, ctx2) {
-  if (!ts10.isIdentifier(node.name)) return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer)) return false;
+  if (!ts11.isIdentifier(node.name)) return false;
+  if (!node.initializer || !ts11.isCallExpression(node.initializer)) return false;
   return resolvePrimitiveKind(node.initializer, ctx2) === "effect";
 }
 function collectEffect(node, ctx2, captureName) {
@@ -7455,7 +7596,7 @@ function collectEffect(node, ctx2, captureName) {
   });
 }
 function isOnMountCall(node, ctx2) {
-  if (!ts10.isCallExpression(node)) return false;
+  if (!ts11.isCallExpression(node)) return false;
   return resolvePrimitiveKind(node, ctx2) === "onMount";
 }
 function collectOnMount(node, ctx2) {
@@ -7494,18 +7635,18 @@ function leadsWithAsiHazard(body2) {
 function extractAssignedIdentifiersFromNode(node) {
   const ids = /* @__PURE__ */ new Set();
   function addFromTarget(target2) {
-    if (ts10.isIdentifier(target2)) {
+    if (ts11.isIdentifier(target2)) {
       ids.add(target2.text);
       return;
     }
-    if (ts10.isParenthesizedExpression(target2)) {
+    if (ts11.isParenthesizedExpression(target2)) {
       addFromTarget(target2.expression);
       return;
     }
-    if (ts10.isArrayLiteralExpression(target2)) {
+    if (ts11.isArrayLiteralExpression(target2)) {
       for (const el of target2.elements) {
-        if (ts10.isOmittedExpression(el)) continue;
-        if (ts10.isSpreadElement(el)) {
+        if (ts11.isOmittedExpression(el)) continue;
+        if (ts11.isSpreadElement(el)) {
           addFromTarget(el.expression);
           continue;
         }
@@ -7513,17 +7654,17 @@ function extractAssignedIdentifiersFromNode(node) {
       }
       return;
     }
-    if (ts10.isObjectLiteralExpression(target2)) {
+    if (ts11.isObjectLiteralExpression(target2)) {
       for (const prop of target2.properties) {
-        if (ts10.isShorthandPropertyAssignment(prop)) {
+        if (ts11.isShorthandPropertyAssignment(prop)) {
           ids.add(prop.name.text);
           continue;
         }
-        if (ts10.isPropertyAssignment(prop)) {
+        if (ts11.isPropertyAssignment(prop)) {
           addFromTarget(prop.initializer);
           continue;
         }
-        if (ts10.isSpreadAssignment(prop)) {
+        if (ts11.isSpreadAssignment(prop)) {
           addFromTarget(prop.expression);
           continue;
         }
@@ -7532,21 +7673,21 @@ function extractAssignedIdentifiersFromNode(node) {
     }
   }
   function visit3(n) {
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n) || ts10.isFunctionDeclaration(n) || ts10.isMethodDeclaration(n) || ts10.isGetAccessorDeclaration(n) || ts10.isSetAccessorDeclaration(n) || ts10.isConstructorDeclaration(n)) {
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n) || ts11.isFunctionDeclaration(n) || ts11.isMethodDeclaration(n) || ts11.isGetAccessorDeclaration(n) || ts11.isSetAccessorDeclaration(n) || ts11.isConstructorDeclaration(n)) {
       return;
     }
-    if (ts10.isBinaryExpression(n)) {
+    if (ts11.isBinaryExpression(n)) {
       const op = n.operatorToken.kind;
-      if (op === ts10.SyntaxKind.EqualsToken || op === ts10.SyntaxKind.PlusEqualsToken || op === ts10.SyntaxKind.MinusEqualsToken || op === ts10.SyntaxKind.AsteriskEqualsToken || op === ts10.SyntaxKind.SlashEqualsToken || op === ts10.SyntaxKind.PercentEqualsToken || op === ts10.SyntaxKind.AsteriskAsteriskEqualsToken || op === ts10.SyntaxKind.AmpersandEqualsToken || op === ts10.SyntaxKind.BarEqualsToken || op === ts10.SyntaxKind.CaretEqualsToken || op === ts10.SyntaxKind.LessThanLessThanEqualsToken || op === ts10.SyntaxKind.GreaterThanGreaterThanEqualsToken || op === ts10.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || op === ts10.SyntaxKind.AmpersandAmpersandEqualsToken || op === ts10.SyntaxKind.BarBarEqualsToken || op === ts10.SyntaxKind.QuestionQuestionEqualsToken) {
+      if (op === ts11.SyntaxKind.EqualsToken || op === ts11.SyntaxKind.PlusEqualsToken || op === ts11.SyntaxKind.MinusEqualsToken || op === ts11.SyntaxKind.AsteriskEqualsToken || op === ts11.SyntaxKind.SlashEqualsToken || op === ts11.SyntaxKind.PercentEqualsToken || op === ts11.SyntaxKind.AsteriskAsteriskEqualsToken || op === ts11.SyntaxKind.AmpersandEqualsToken || op === ts11.SyntaxKind.BarEqualsToken || op === ts11.SyntaxKind.CaretEqualsToken || op === ts11.SyntaxKind.LessThanLessThanEqualsToken || op === ts11.SyntaxKind.GreaterThanGreaterThanEqualsToken || op === ts11.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || op === ts11.SyntaxKind.AmpersandAmpersandEqualsToken || op === ts11.SyntaxKind.BarBarEqualsToken || op === ts11.SyntaxKind.QuestionQuestionEqualsToken) {
         addFromTarget(n.left);
       }
     }
-    if (ts10.isPrefixUnaryExpression(n) || ts10.isPostfixUnaryExpression(n)) {
-      if (n.operator === ts10.SyntaxKind.PlusPlusToken || n.operator === ts10.SyntaxKind.MinusMinusToken) {
+    if (ts11.isPrefixUnaryExpression(n) || ts11.isPostfixUnaryExpression(n)) {
+      if (n.operator === ts11.SyntaxKind.PlusPlusToken || n.operator === ts11.SyntaxKind.MinusMinusToken) {
         addFromTarget(n.operand);
       }
     }
-    ts10.forEachChild(n, visit3);
+    ts11.forEachChild(n, visit3);
   }
   visit3(node);
   const localDecls = collectLocalDeclarations(node);
@@ -7556,56 +7697,56 @@ function extractAssignedIdentifiersFromNode(node) {
 function collectLocalDeclarations(root2) {
   const names = /* @__PURE__ */ new Set();
   function addBindingName(name2) {
-    if (ts10.isIdentifier(name2)) {
+    if (ts11.isIdentifier(name2)) {
       names.add(name2.text);
       return;
     }
-    if (ts10.isArrayBindingPattern(name2)) {
+    if (ts11.isArrayBindingPattern(name2)) {
       for (const el of name2.elements) {
-        if (ts10.isBindingElement(el)) addBindingName(el.name);
+        if (ts11.isBindingElement(el)) addBindingName(el.name);
       }
       return;
     }
-    if (ts10.isObjectBindingPattern(name2)) {
+    if (ts11.isObjectBindingPattern(name2)) {
       for (const el of name2.elements) {
         addBindingName(el.name);
       }
     }
   }
   function visit3(n) {
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n) || ts10.isFunctionDeclaration(n)) return;
-    if (ts10.isVariableDeclaration(n)) {
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n) || ts11.isFunctionDeclaration(n)) return;
+    if (ts11.isVariableDeclaration(n)) {
       addBindingName(n.name);
     }
-    ts10.forEachChild(n, visit3);
+    ts11.forEachChild(n, visit3);
   }
   visit3(root2);
   return names;
 }
 function collectAmbientGlobals(node, ctx2) {
-  if (ts10.isVariableStatement(node)) {
-    const isDeclare = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DeclareKeyword) ?? false;
+  if (ts11.isVariableStatement(node)) {
+    const isDeclare = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DeclareKeyword) ?? false;
     if (!isDeclare) return;
     for (const decl of node.declarationList.declarations) {
-      if (ts10.isIdentifier(decl.name)) ctx2.ambientGlobals.add(decl.name.text);
+      if (ts11.isIdentifier(decl.name)) ctx2.ambientGlobals.add(decl.name.text);
     }
     return;
   }
-  if (ts10.isFunctionDeclaration(node) && node.name) {
-    const isDeclare = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DeclareKeyword) ?? false;
+  if (ts11.isFunctionDeclaration(node) && node.name) {
+    const isDeclare = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DeclareKeyword) ?? false;
     if (isDeclare) ctx2.ambientGlobals.add(node.name.text);
     return;
   }
-  if (ts10.isModuleDeclaration(node)) {
-    const isGlobalAugmentation = (node.flags & ts10.NodeFlags.GlobalAugmentation) !== 0;
+  if (ts11.isModuleDeclaration(node)) {
+    const isGlobalAugmentation = (node.flags & ts11.NodeFlags.GlobalAugmentation) !== 0;
     if (!isGlobalAugmentation) return;
-    if (!node.body || !ts10.isModuleBlock(node.body)) return;
+    if (!node.body || !ts11.isModuleBlock(node.body)) return;
     for (const inner of node.body.statements) {
-      if (ts10.isVariableStatement(inner)) {
+      if (ts11.isVariableStatement(inner)) {
         for (const decl of inner.declarationList.declarations) {
-          if (ts10.isIdentifier(decl.name)) ctx2.ambientGlobals.add(decl.name.text);
+          if (ts11.isIdentifier(decl.name)) ctx2.ambientGlobals.add(decl.name.text);
         }
-      } else if (ts10.isFunctionDeclaration(inner) && inner.name) {
+      } else if (ts11.isFunctionDeclaration(inner) && inner.name) {
         ctx2.ambientGlobals.add(inner.name.text);
       }
     }
@@ -7616,7 +7757,7 @@ function collectImport(node, ctx2) {
   const specifiers = [];
   const isTypeOnly = !!node.importClause?.isTypeOnly;
   const loc = getSourceLocation(node, ctx2.sourceFile, ctx2.filePath);
-  if (source === "@barefootjs/client" && !isTypeOnly && node.importClause?.namedBindings && ts10.isNamedImports(node.importClause.namedBindings)) {
+  if (source === "@barefootjs/client" && !isTypeOnly && node.importClause?.namedBindings && ts11.isNamedImports(node.importClause.namedBindings)) {
     const wrongImports = [];
     for (const element2 of node.importClause.namedBindings.elements) {
       const name2 = element2.propertyName?.text ?? element2.name.text;
@@ -7644,7 +7785,7 @@ function collectImport(node, ctx2) {
       });
     }
     if (node.importClause.namedBindings) {
-      if (ts10.isNamedImports(node.importClause.namedBindings)) {
+      if (ts11.isNamedImports(node.importClause.namedBindings)) {
         for (const element2 of node.importClause.namedBindings.elements) {
           specifiers.push({
             name: element2.propertyName?.text ?? element2.name.text,
@@ -7656,7 +7797,7 @@ function collectImport(node, ctx2) {
           });
         }
       }
-      if (ts10.isNamespaceImport(node.importClause.namedBindings)) {
+      if (ts11.isNamespaceImport(node.importClause.namedBindings)) {
         specifiers.push({
           name: node.importClause.namedBindings.name.text,
           alias: null,
@@ -7683,7 +7824,7 @@ function collectInterfaceDefinition(node, ctx2) {
   });
 }
 function collectTypeAliasDefinition(node, ctx2) {
-  const properties = ts10.isTypeLiteralNode(node.type) ? membersToProperties(node.type.members, ctx2.sourceFile) : void 0;
+  const properties = ts11.isTypeLiteralNode(node.type) ? membersToProperties(node.type.members, ctx2.sourceFile) : void 0;
   ctx2.typeDefinitions.push({
     kind: "type",
     name: node.name.text,
@@ -7696,19 +7837,19 @@ function extractSingleJsxReturn(body2) {
   let jsxReturn = null;
   let returnCount = 0;
   function visit3(node) {
-    if (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node)) return;
-    if (ts10.isReturnStatement(node)) {
+    if (ts11.isFunctionDeclaration(node) || ts11.isFunctionExpression(node) || ts11.isArrowFunction(node)) return;
+    if (ts11.isReturnStatement(node)) {
       returnCount++;
       if (node.expression) {
         const expr = unwrapJsxTransparent(node.expression);
-        if (ts10.isJsxElement(expr) || ts10.isJsxSelfClosingElement(expr) || ts10.isJsxFragment(expr)) {
+        if (ts11.isJsxElement(expr) || ts11.isJsxSelfClosingElement(expr) || ts11.isJsxFragment(expr)) {
           jsxReturn = expr;
         }
       }
     }
-    ts10.forEachChild(node, visit3);
+    ts11.forEachChild(node, visit3);
   }
-  ts10.forEachChild(body2, visit3);
+  ts11.forEachChild(body2, visit3);
   if (returnCount !== 1) return null;
   return jsxReturn;
 }
@@ -7723,9 +7864,9 @@ function extractMultiReturnJsxBranches(body2, allowPreamble = false) {
   const stmts = body2.statements;
   for (let i = 0; i < stmts.length; i++) {
     const stmt = stmts[i];
-    if (ts10.isIfStatement(stmt)) {
+    if (ts11.isIfStatement(stmt)) {
       let current = stmt;
-      while (ts10.isIfStatement(current)) {
+      while (ts11.isIfStatement(current)) {
         const ifStmt = current;
         if (!isDirectReturnBlock(ifStmt.thenStatement)) return null;
         const jsxReturn = findJsxReturnInBlock(ifStmt.thenStatement);
@@ -7733,7 +7874,7 @@ function extractMultiReturnJsxBranches(body2, allowPreamble = false) {
         if (!jsxReturn && !nullReturn) return null;
         branches.push({ condition: ifStmt.expression, jsxReturn: jsxReturn ?? null });
         if (ifStmt.elseStatement) {
-          if (ts10.isIfStatement(ifStmt.elseStatement)) {
+          if (ts11.isIfStatement(ifStmt.elseStatement)) {
             current = ifStmt.elseStatement;
             continue;
           }
@@ -7752,16 +7893,16 @@ function extractMultiReturnJsxBranches(body2, allowPreamble = false) {
       }
       continue;
     }
-    if (ts10.isSwitchStatement(stmt)) {
+    if (ts11.isSwitchStatement(stmt)) {
       if (branches.length > 0) return null;
-      if (!ts10.isIdentifier(stmt.expression) && !ts10.isPropertyAccessExpression(stmt.expression)) {
+      if (!ts11.isIdentifier(stmt.expression) && !ts11.isPropertyAccessExpression(stmt.expression)) {
         return null;
       }
-      const hasDefault = stmt.caseBlock.clauses.some((c) => ts10.isDefaultClause(c));
+      const hasDefault = stmt.caseBlock.clauses.some((c) => ts11.isDefaultClause(c));
       if (!hasDefault) return null;
       let pendingCases = [];
       for (const clause of stmt.caseBlock.clauses) {
-        if (ts10.isCaseClause(clause) && clause.statements.length === 0) {
+        if (ts11.isCaseClause(clause) && clause.statements.length === 0) {
           pendingCases.push(clause.expression);
           continue;
         }
@@ -7769,7 +7910,7 @@ function extractMultiReturnJsxBranches(body2, allowPreamble = false) {
         const nullReturn = findNullReturnInCaseClause(clause);
         if (!jsxReturn && !nullReturn) return null;
         if (!caseClauseIsDirectReturn(clause)) return null;
-        if (ts10.isCaseClause(clause)) {
+        if (ts11.isCaseClause(clause)) {
           branches.push({
             condition: clause.expression,
             jsxReturn: jsxReturn ?? null,
@@ -7786,19 +7927,19 @@ function extractMultiReturnJsxBranches(body2, allowPreamble = false) {
       if (preambleUnsafe(preamble, branches, fallback)) return null;
       return { branches, fallback, switchDiscriminant: stmt.expression, preamble };
     }
-    if (ts10.isReturnStatement(stmt) && stmt.expression) {
+    if (ts11.isReturnStatement(stmt) && stmt.expression) {
       const expr = unwrapJsxTransparent(stmt.expression);
-      if (ts10.isJsxElement(expr) || ts10.isJsxSelfClosingElement(expr) || ts10.isJsxFragment(expr)) {
+      if (ts11.isJsxElement(expr) || ts11.isJsxSelfClosingElement(expr) || ts11.isJsxFragment(expr)) {
         fallback = expr;
-      } else if (expr.kind === ts10.SyntaxKind.NullKeyword) {
+      } else if (expr.kind === ts11.SyntaxKind.NullKeyword) {
       } else {
         return null;
       }
       continue;
     }
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       const declFlags = stmt.declarationList.flags;
-      const isConstOrLet = (declFlags & ts10.NodeFlags.Const) !== 0 || (declFlags & ts10.NodeFlags.Let) !== 0;
+      const isConstOrLet = (declFlags & ts11.NodeFlags.Const) !== 0 || (declFlags & ts11.NodeFlags.Let) !== 0;
       if (allowPreamble && isConstOrLet && branches.length === 0 && fallback === null) {
         preamble.push(stmt);
         continue;
@@ -7812,11 +7953,11 @@ function extractMultiReturnJsxBranches(body2, allowPreamble = false) {
   return { branches, fallback, preamble };
 }
 function isDirectReturnBlock(node) {
-  if (ts10.isReturnStatement(node)) return true;
-  if (ts10.isBlock(node)) {
+  if (ts11.isReturnStatement(node)) return true;
+  if (ts11.isBlock(node)) {
     let returnCount = 0;
     for (const stmt of node.statements) {
-      if (ts10.isReturnStatement(stmt)) {
+      if (ts11.isReturnStatement(stmt)) {
         returnCount++;
         continue;
       }
@@ -7827,23 +7968,23 @@ function isDirectReturnBlock(node) {
   return false;
 }
 function findNullReturnInBlock(node) {
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     for (const stmt of node.statements) {
-      if (ts10.isReturnStatement(stmt) && stmt.expression) {
+      if (ts11.isReturnStatement(stmt) && stmt.expression) {
         const expr = unwrapJsxTransparent(stmt.expression);
-        if (expr.kind === ts10.SyntaxKind.NullKeyword) return true;
+        if (expr.kind === ts11.SyntaxKind.NullKeyword) return true;
       }
     }
   }
-  if (ts10.isReturnStatement(node) && node.expression) {
+  if (ts11.isReturnStatement(node) && node.expression) {
     const expr = unwrapJsxTransparent(node.expression);
-    if (expr.kind === ts10.SyntaxKind.NullKeyword) return true;
+    if (expr.kind === ts11.SyntaxKind.NullKeyword) return true;
   }
   return false;
 }
 function findJsxReturnInCaseClause(clause) {
   for (const stmt of clause.statements) {
-    if (ts10.isReturnStatement(stmt) && stmt.expression) {
+    if (ts11.isReturnStatement(stmt) && stmt.expression) {
       return extractJsxFromExpression(stmt.expression);
     }
   }
@@ -7853,12 +7994,12 @@ function caseClauseIsDirectReturn(clause) {
   let returnCount = 0;
   let seenReturn = false;
   for (const stmt of clause.statements) {
-    if (ts10.isReturnStatement(stmt)) {
+    if (ts11.isReturnStatement(stmt)) {
       returnCount++;
       seenReturn = true;
       continue;
     }
-    if (ts10.isBreakStatement(stmt)) {
+    if (ts11.isBreakStatement(stmt)) {
       if (!seenReturn) return false;
       continue;
     }
@@ -7868,9 +8009,9 @@ function caseClauseIsDirectReturn(clause) {
 }
 function findNullReturnInCaseClause(clause) {
   for (const stmt of clause.statements) {
-    if (ts10.isReturnStatement(stmt) && stmt.expression) {
+    if (ts11.isReturnStatement(stmt) && stmt.expression) {
       const expr = unwrapJsxTransparent(stmt.expression);
-      if (expr.kind === ts10.SyntaxKind.NullKeyword) return true;
+      if (expr.kind === ts11.SyntaxKind.NullKeyword) return true;
     }
   }
   return false;
@@ -7880,23 +8021,23 @@ function isMultiReturnJsxFunctionBody(body2) {
   let hasJsxReturn = false;
   let allReturnsAreJsxOrNull = true;
   function visit3(node) {
-    if (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node)) return;
-    if (ts10.isReturnStatement(node)) {
+    if (ts11.isFunctionDeclaration(node) || ts11.isFunctionExpression(node) || ts11.isArrowFunction(node)) return;
+    if (ts11.isReturnStatement(node)) {
       returnCount++;
       if (!node.expression) {
         allReturnsAreJsxOrNull = false;
         return;
       }
       const expr = unwrapJsxTransparent(node.expression);
-      const isJsx = ts10.isJsxElement(expr) || ts10.isJsxSelfClosingElement(expr) || ts10.isJsxFragment(expr);
-      const isNull = expr.kind === ts10.SyntaxKind.NullKeyword;
+      const isJsx = ts11.isJsxElement(expr) || ts11.isJsxSelfClosingElement(expr) || ts11.isJsxFragment(expr);
+      const isNull = expr.kind === ts11.SyntaxKind.NullKeyword;
       if (isJsx) hasJsxReturn = true;
       if (!isJsx && !isNull) allReturnsAreJsxOrNull = false;
       return;
     }
-    ts10.forEachChild(node, visit3);
+    ts11.forEachChild(node, visit3);
   }
-  ts10.forEachChild(body2, visit3);
+  ts11.forEachChild(body2, visit3);
   return returnCount > 1 && hasJsxReturn && allReturnsAreJsxOrNull;
 }
 function collectFunction(node, ctx2, _isModule, isExported = false) {
@@ -7962,7 +8103,7 @@ function collectFunction(node, ctx2, _isModule, isExported = false) {
       }
     }
   }
-  const isAsync = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.AsyncKeyword) ?? false;
+  const isAsync = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.AsyncKeyword) ?? false;
   const isGenerator = !!node.asteriskToken;
   ctx2.localFunctions.push({
     name: name2,
@@ -7983,10 +8124,10 @@ function collectFunction(node, ctx2, _isModule, isExported = false) {
   });
 }
 function extractValueBranches(node, ctx2) {
-  if (ts10.isParenthesizedExpression(node)) {
+  if (ts11.isParenthesizedExpression(node)) {
     return extractValueBranches(node.expression, ctx2);
   }
-  if (ts10.isConditionalExpression(node)) {
+  if (ts11.isConditionalExpression(node)) {
     return [
       ...extractValueBranches(node.whenTrue, ctx2),
       ...extractValueBranches(node.whenFalse, ctx2)
@@ -7998,33 +8139,33 @@ function extractFreeIdentifiersFromNode(node) {
   const ids = /* @__PURE__ */ new Set();
   const boundNames = /* @__PURE__ */ new Set();
   function addBindingNames2(name2, out) {
-    if (ts10.isIdentifier(name2)) out.push(name2.text);
-    else if (ts10.isObjectBindingPattern(name2)) name2.elements.forEach((e) => addBindingNames2(e.name, out));
-    else if (ts10.isArrayBindingPattern(name2)) name2.elements.forEach((e) => {
-      if (!ts10.isOmittedExpression(e)) addBindingNames2(e.name, out);
+    if (ts11.isIdentifier(name2)) out.push(name2.text);
+    else if (ts11.isObjectBindingPattern(name2)) name2.elements.forEach((e) => addBindingNames2(e.name, out));
+    else if (ts11.isArrayBindingPattern(name2)) name2.elements.forEach((e) => {
+      if (!ts11.isOmittedExpression(e)) addBindingNames2(e.name, out);
     });
   }
   function visit3(n) {
-    if (ts10.isTypeNode(n)) return;
-    if (ts10.isIdentifier(n)) {
+    if (ts11.isTypeNode(n)) return;
+    if (ts11.isIdentifier(n)) {
       const parent2 = n.parent;
-      if (parent2 && ts10.isPropertyAccessExpression(parent2) && parent2.name === n) return;
-      if (parent2 && ts10.isPropertyAssignment(parent2) && parent2.name === n) return;
-      if (parent2 && ts10.isParameter(parent2) && parent2.name === n) return;
-      if (parent2 && ts10.isVariableDeclaration(parent2) && parent2.name === n) return;
+      if (parent2 && ts11.isPropertyAccessExpression(parent2) && parent2.name === n) return;
+      if (parent2 && ts11.isPropertyAssignment(parent2) && parent2.name === n) return;
+      if (parent2 && ts11.isParameter(parent2) && parent2.name === n) return;
+      if (parent2 && ts11.isVariableDeclaration(parent2) && parent2.name === n) return;
       if (boundNames.has(n.text)) return;
       ids.add(n.text);
       return;
     }
-    if (ts10.isArrowFunction(n)) {
+    if (ts11.isArrowFunction(n)) {
       const params = [];
       for (const p of n.parameters) addBindingNames2(p.name, params);
       for (const name2 of params) boundNames.add(name2);
-      ts10.forEachChild(n, visit3);
+      ts11.forEachChild(n, visit3);
       for (const name2 of params) boundNames.delete(name2);
       return;
     }
-    ts10.forEachChild(n, visit3);
+    ts11.forEachChild(n, visit3);
   }
   visit3(node);
   return ids;
@@ -8033,25 +8174,25 @@ function extractFreeTypeIdentifiersFromNode(node) {
   const ids = /* @__PURE__ */ new Set();
   const boundTypeParams = /* @__PURE__ */ new Set();
   function rootName(name2) {
-    return ts10.isQualifiedName(name2) ? rootName(name2.left) : name2;
+    return ts11.isQualifiedName(name2) ? rootName(name2.left) : name2;
   }
   function visit3(n) {
-    if (ts10.isTypeReferenceNode(n)) {
+    if (ts11.isTypeReferenceNode(n)) {
       const name2 = rootName(n.typeName).text;
       if (!boundTypeParams.has(name2)) ids.add(name2);
     }
-    if (ts10.isTypeQueryNode(n)) {
+    if (ts11.isTypeQueryNode(n)) {
       const name2 = rootName(n.exprName).text;
       if (!boundTypeParams.has(name2)) ids.add(name2);
     }
-    if (ts10.isFunctionLike(n) && n.typeParameters && n.typeParameters.length > 0) {
+    if (ts11.isFunctionLike(n) && n.typeParameters && n.typeParameters.length > 0) {
       const names = n.typeParameters.map((p) => p.name.text);
       for (const p of names) boundTypeParams.add(p);
-      ts10.forEachChild(n, visit3);
+      ts11.forEachChild(n, visit3);
       for (const p of names) boundTypeParams.delete(p);
       return;
     }
-    ts10.forEachChild(n, visit3);
+    ts11.forEachChild(n, visit3);
   }
   visit3(node);
   return ids;
@@ -8060,30 +8201,30 @@ function initializerShapeContainsJsx(node) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts10.isJsxElement(n) || ts10.isJsxSelfClosingElement(n) || ts10.isJsxFragment(n)) {
+    if (ts11.isJsxElement(n) || ts11.isJsxSelfClosingElement(n) || ts11.isJsxFragment(n)) {
       found = true;
       return;
     }
-    if (ts10.isFunctionDeclaration(n) || ts10.isFunctionExpression(n) || ts10.isArrowFunction(n)) {
+    if (ts11.isFunctionDeclaration(n) || ts11.isFunctionExpression(n) || ts11.isArrowFunction(n)) {
       return;
     }
-    ts10.forEachChild(n, visit3);
+    ts11.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
 }
 function isMapLikeCallWithJsx(node) {
-  if (!ts10.isCallExpression(node)) return false;
-  if (!ts10.isPropertyAccessExpression(node.expression)) return false;
+  if (!ts11.isCallExpression(node)) return false;
+  if (!ts11.isPropertyAccessExpression(node.expression)) return false;
   const method2 = node.expression.name.text;
   if (method2 !== "map" && method2 !== "flatMap") return false;
   const callback = node.arguments[0];
   if (!callback) return false;
-  if (!ts10.isArrowFunction(callback) && !ts10.isFunctionExpression(callback)) return false;
+  if (!ts11.isArrowFunction(callback) && !ts11.isFunctionExpression(callback)) return false;
   return containsJsxDeep(callback.body);
 }
 function containsJsxDeep(node) {
-  if (ts10.isJsxElement(node) || ts10.isJsxSelfClosingElement(node) || ts10.isJsxFragment(node)) return true;
+  if (ts11.isJsxElement(node) || ts11.isJsxSelfClosingElement(node) || ts11.isJsxFragment(node)) return true;
   let found = false;
   node.forEachChild((child) => {
     if (!found) found = containsJsxDeep(child);
@@ -8094,11 +8235,11 @@ function nodeContainsArrow(node) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n)) {
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n)) {
       found = true;
       return;
     }
-    ts10.forEachChild(n, visit3);
+    ts11.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -8143,17 +8284,17 @@ function collectModuleScopeReactive(decl, ctx2, isExported) {
   ));
 }
 function getSystemConstructKind(node) {
-  if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === "createContext") return "createContext";
-  if (ts10.isNewExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === "WeakMap") return "weakMap";
+  if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === "createContext") return "createContext";
+  if (ts11.isNewExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === "WeakMap") return "weakMap";
   return void 0;
 }
 function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExported = false) {
-  if (!_isModule && ts10.isObjectBindingPattern(node.name) && node.initializer && ts10.isIdentifier(node.initializer) && ctx2.propsObjectName === node.initializer.text) {
+  if (!_isModule && ts11.isObjectBindingPattern(node.name) && node.initializer && ts11.isIdentifier(node.initializer) && ctx2.propsObjectName === node.initializer.text) {
     const propsName = node.initializer.text;
     for (const el of node.name.elements) {
-      if (!ts10.isBindingElement(el) || !ts10.isIdentifier(el.name) || el.dotDotDotToken) continue;
+      if (!ts11.isBindingElement(el) || !ts11.isIdentifier(el.name) || el.dotDotDotToken) continue;
       const localName2 = el.name.text;
-      const sourceKey = el.propertyName && ts10.isIdentifier(el.propertyName) ? el.propertyName.text : localName2;
+      const sourceKey = el.propertyName && ts11.isIdentifier(el.propertyName) ? el.propertyName.text : localName2;
       const defaultValueExpr = el.initializer ? ctx2.getJS(el.initializer) : void 0;
       const baseValue = `${propsName}.${sourceKey}`;
       const value3 = defaultValueExpr ? `${baseValue} ?? ${defaultValueExpr}` : baseValue;
@@ -8177,7 +8318,7 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
     }
     return;
   }
-  if (!ts10.isIdentifier(node.name)) return;
+  if (!ts11.isIdentifier(node.name)) return;
   if (isSignalDeclaration(node, ctx2) || isMemoDeclaration(node, ctx2)) return;
   if (isSignalTupleDeclaration(node)) return;
   if (isSignalIndexAccess(node, ctx2) !== null) return;
@@ -8190,8 +8331,8 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
   let isJsxFunction = false;
   if (node.initializer) {
     let init = node.initializer;
-    while (ts10.isParenthesizedExpression(init)) init = init.expression;
-    if (ts10.isJsxElement(init) || ts10.isJsxSelfClosingElement(init) || ts10.isJsxFragment(init)) {
+    while (ts11.isParenthesizedExpression(init)) init = init.expression;
+    if (ts11.isJsxElement(init) || ts11.isJsxSelfClosingElement(init) || ts11.isJsxFragment(init)) {
       isJsx = true;
       ctx2.jsxConstants.set(name2, init);
     } else if (initializerShapeContainsJsx(init)) {
@@ -8199,9 +8340,9 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
     } else if (isMapLikeCallWithJsx(init)) {
       ctx2.inlineableJsxConsts.set(name2, init);
     }
-    if (ts10.isArrowFunction(init)) {
+    if (ts11.isArrowFunction(init)) {
       const arrowBody = init.body;
-      if (ts10.isBlock(arrowBody)) {
+      if (ts11.isBlock(arrowBody)) {
         const jsxReturn = extractSingleJsxReturn(arrowBody);
         if (jsxReturn) {
           isJsxFunction = true;
@@ -8221,8 +8362,8 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
         }
       } else {
         let body2 = arrowBody;
-        while (ts10.isParenthesizedExpression(body2)) body2 = body2.expression;
-        if (ts10.isJsxElement(body2) || ts10.isJsxSelfClosingElement(body2) || ts10.isJsxFragment(body2)) {
+        while (ts11.isParenthesizedExpression(body2)) body2 = body2.expression;
+        if (ts11.isJsxElement(body2) || ts11.isJsxSelfClosingElement(body2) || ts11.isJsxFragment(body2)) {
           isJsxFunction = true;
           ctx2.jsxFunctions.set(name2, {
             jsxReturn: body2,
@@ -8235,8 +8376,8 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
   let valueBranches;
   if (node.initializer) {
     let inner = node.initializer;
-    while (ts10.isParenthesizedExpression(inner)) inner = inner.expression;
-    if (ts10.isConditionalExpression(inner)) {
+    while (ts11.isParenthesizedExpression(inner)) inner = inner.expression;
+    if (ts11.isConditionalExpression(inner)) {
       valueBranches = extractValueBranches(node.initializer, ctx2);
     }
   }
@@ -8312,7 +8453,7 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
 function hasIgnoreDirective(node, sourceFile, ruleId) {
   const checkComments = (targetNode) => {
     const fullStart = targetNode.getFullStart();
-    const leadingComments = ts10.getLeadingCommentRanges(
+    const leadingComments = ts11.getLeadingCommentRanges(
       sourceFile.getFullText(),
       fullStart
     );
@@ -8326,10 +8467,10 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
     return false;
   };
   if (checkComments(node)) return true;
-  if (ts10.isArrowFunction(node)) {
+  if (ts11.isArrowFunction(node)) {
     let current = node.parent;
     while (current) {
-      if (ts10.isVariableStatement(current)) {
+      if (ts11.isVariableStatement(current)) {
         if (checkComments(current)) return true;
         break;
       }
@@ -8339,7 +8480,7 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
   return false;
 }
 function extractProps(param, ctx2) {
-  if (ts10.isObjectBindingPattern(param.name)) {
+  if (ts11.isObjectBindingPattern(param.name)) {
     const componentNode = ctx2.componentNode;
     const ignored = !!(componentNode && hasIgnoreDirective(componentNode, ctx2.sourceFile, "props-destructuring"));
     ctx2.propsDestructuring = {
@@ -8348,14 +8489,14 @@ function extractProps(param, ctx2) {
     };
     const memberTypes = param.type ? collectMemberTypes(param.type, ctx2) : null;
     for (const element2 of param.name.elements) {
-      if (ts10.isBindingElement(element2) && ts10.isIdentifier(element2.name)) {
+      if (ts11.isBindingElement(element2) && ts11.isIdentifier(element2.name)) {
         const localName2 = element2.name.text;
         const defaultValue2 = element2.initializer ? ctx2.getJS(element2.initializer) : void 0;
         if (element2.dotDotDotToken) {
           ctx2.restPropsName = localName2;
           continue;
         }
-        const sourcePropName = element2.propertyName && ts10.isIdentifier(element2.propertyName) ? element2.propertyName.text : localName2;
+        const sourcePropName = element2.propertyName && ts11.isIdentifier(element2.propertyName) ? element2.propertyName.text : localName2;
         const member = memberTypes?.get(sourcePropName);
         const resolvedType = member?.type ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element2.initializer ? nodeContainsArrow(element2.initializer) : false;
@@ -8382,7 +8523,7 @@ function extractProps(param, ctx2) {
       }
     }
   }
-  if (ts10.isIdentifier(param.name)) {
+  if (ts11.isIdentifier(param.name)) {
     ctx2.propsObjectName = param.name.text;
     if (param.type) {
       extractPropsFromType(param.type, ctx2);
@@ -8393,22 +8534,22 @@ function extractProps(param, ctx2) {
   }
 }
 function collectTypeKeys(typeNode, ctx2) {
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     return collectKeysFromMembers(typeNode.members, ctx2);
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx2.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx2.sourceFile);
     if (!typeDecl) return null;
-    if (ts10.isInterfaceDeclaration(typeDecl)) {
+    if (ts11.isInterfaceDeclaration(typeDecl)) {
       if (typeDecl.heritageClauses && typeDecl.heritageClauses.length > 0) return null;
       return collectKeysFromMembers(typeDecl.members, ctx2);
     }
-    if (ts10.isTypeAliasDeclaration(typeDecl)) {
-      if (ts10.isTypeLiteralNode(typeDecl.type)) {
+    if (ts11.isTypeAliasDeclaration(typeDecl)) {
+      if (ts11.isTypeLiteralNode(typeDecl.type)) {
         return collectKeysFromMembers(typeDecl.type.members, ctx2);
       }
-      if (ts10.isIntersectionTypeNode(typeDecl.type)) {
+      if (ts11.isIntersectionTypeNode(typeDecl.type)) {
         return null;
       }
     }
@@ -8418,8 +8559,8 @@ function collectTypeKeys(typeNode, ctx2) {
 function collectKeysFromMembers(members, ctx2) {
   const keys = [];
   for (const member of members) {
-    if (ts10.isIndexSignatureDeclaration(member)) return null;
-    if (ts10.isPropertySignature(member) && member.name) {
+    if (ts11.isIndexSignatureDeclaration(member)) return null;
+    if (ts11.isPropertySignature(member) && member.name) {
       keys.push(member.name.getText(ctx2.sourceFile));
     }
   }
@@ -8444,7 +8585,7 @@ function collectMemberTypes(typeNode, ctx2) {
   const fromMembers = (members) => {
     const map = /* @__PURE__ */ new Map();
     for (const member of members) {
-      if (ts10.isPropertySignature(member) && member.name) {
+      if (ts11.isPropertySignature(member) && member.name) {
         const info = member.type ? typeNodeToTypeInfo(member.type, ctx2.sourceFile) : null;
         map.set(member.name.getText(ctx2.sourceFile), {
           type: info && isResolvableMemberType(info) ? info : null,
@@ -8454,34 +8595,34 @@ function collectMemberTypes(typeNode, ctx2) {
     }
     return map;
   };
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     return fromMembers(typeNode.members);
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx2.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx2.sourceFile);
     if (!typeDecl) return null;
-    if (ts10.isInterfaceDeclaration(typeDecl)) {
+    if (ts11.isInterfaceDeclaration(typeDecl)) {
       return fromMembers(typeDecl.members);
     }
-    if (ts10.isTypeAliasDeclaration(typeDecl) && ts10.isTypeLiteralNode(typeDecl.type)) {
+    if (ts11.isTypeAliasDeclaration(typeDecl) && ts11.isTypeLiteralNode(typeDecl.type)) {
       return fromMembers(typeDecl.type.members);
     }
   }
   return null;
 }
 function extractPropsFromType(typeNode, ctx2) {
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx2);
     return;
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx2.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx2.sourceFile);
     if (typeDecl) {
-      if (ts10.isInterfaceDeclaration(typeDecl)) {
+      if (ts11.isInterfaceDeclaration(typeDecl)) {
         extractPropsFromTypeMembers(typeDecl.members, ctx2);
-      } else if (ts10.isTypeAliasDeclaration(typeDecl) && ts10.isTypeLiteralNode(typeDecl.type)) {
+      } else if (ts11.isTypeAliasDeclaration(typeDecl) && ts11.isTypeLiteralNode(typeDecl.type)) {
         extractPropsFromTypeMembers(typeDecl.type.members, ctx2);
       }
     }
@@ -8489,7 +8630,7 @@ function extractPropsFromType(typeNode, ctx2) {
 }
 function extractPropsFromTypeMembers(members, ctx2) {
   for (const member of members) {
-    if (ts10.isPropertySignature(member) && member.name) {
+    if (ts11.isPropertySignature(member) && member.name) {
       const propName = member.name.getText(ctx2.sourceFile);
       const isOptional = !!member.questionToken;
       const propType = member.type ? typeNodeToTypeInfo(member.type, ctx2.sourceFile) : { kind: "unknown", raw: "unknown" };
@@ -8505,17 +8646,17 @@ function extractPropsFromTypeMembers(members, ctx2) {
 function findTypeDeclaration(typeName, sourceFile) {
   let result2;
   function visit3(node) {
-    if (ts10.isInterfaceDeclaration(node) && node.name.text === typeName) {
+    if (ts11.isInterfaceDeclaration(node) && node.name.text === typeName) {
       result2 = node;
       return;
     }
-    if (ts10.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+    if (ts11.isTypeAliasDeclaration(node) && node.name.text === typeName) {
       result2 = node;
       return;
     }
-    ts10.forEachChild(node, visit3);
+    ts11.forEachChild(node, visit3);
   }
-  ts10.forEachChild(sourceFile, visit3);
+  ts11.forEachChild(sourceFile, visit3);
   return result2;
 }
 function inferTypeFromValue(value2) {
@@ -8561,12 +8702,12 @@ function inferTypeFromValue(value2) {
 }
 function collectCalledIdentifiers(code) {
   const called = /* @__PURE__ */ new Set();
-  const sf = ts10.createSourceFile("__deps__.tsx", code, ts10.ScriptTarget.Latest, false, ts10.ScriptKind.TSX);
+  const sf = ts11.createSourceFile("__deps__.tsx", code, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
   const visit3 = (node) => {
-    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression)) {
+    if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression)) {
       called.add(node.expression.text);
     }
-    ts10.forEachChild(node, visit3);
+    ts11.forEachChild(node, visit3);
   };
   visit3(sf);
   return called;
@@ -8659,16 +8800,16 @@ function isResolvableComponentSource(source) {
 function collectJsxComponentTags(sourceFile) {
   const tags = /* @__PURE__ */ new Set();
   function visit3(node) {
-    if (ts10.isJsxOpeningElement(node) || ts10.isJsxSelfClosingElement(node)) {
+    if (ts11.isJsxOpeningElement(node) || ts11.isJsxSelfClosingElement(node)) {
       const tagName2 = node.tagName;
-      if (ts10.isIdentifier(tagName2)) {
+      if (ts11.isIdentifier(tagName2)) {
         const first = tagName2.text.charAt(0);
         if (first >= "A" && first <= "Z") {
           tags.add(tagName2.text);
         }
       }
     }
-    ts10.forEachChild(node, visit3);
+    ts11.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   return tags;
@@ -8737,23 +8878,23 @@ function fileHasUseClientDirective(filePath) {
   } catch {
     return true;
   }
-  const sf = ts10.createSourceFile(
+  const sf = ts11.createSourceFile(
     filePath,
     content2,
-    ts10.ScriptTarget.Latest,
+    ts11.ScriptTarget.Latest,
     false,
-    ts10.ScriptKind.TSX
+    ts11.ScriptKind.TSX
   );
   let found = false;
   function visit3(node) {
     if (found) return;
-    if (ts10.isExpressionStatement(node) && ts10.isStringLiteral(node.expression)) {
+    if (ts11.isExpressionStatement(node) && ts11.isStringLiteral(node.expression)) {
       if (node.expression.text === "use client") {
         found = true;
         return;
       }
     }
-    ts10.forEachChild(node, visit3);
+    ts11.forEachChild(node, visit3);
   }
   visit3(sf);
   return found;
@@ -8809,22 +8950,22 @@ function importsBrowserOnlyClientApi(ctx2) {
   return false;
 }
 function listComponentFunctions(source, filePath) {
-  const sourceFile = ts10.createSourceFile(
+  const sourceFile = ts11.createSourceFile(
     filePath,
     source,
-    ts10.ScriptTarget.Latest,
+    ts11.ScriptTarget.Latest,
     true,
-    ts10.ScriptKind.TSX
+    ts11.ScriptKind.TSX
   );
   return listComponentFunctionsFromSourceFile(sourceFile);
 }
 function scanComponentFile(source, filePath) {
-  const sourceFile = ts10.createSourceFile(
+  const sourceFile = ts11.createSourceFile(
     filePath,
     source,
-    ts10.ScriptTarget.Latest,
+    ts11.ScriptTarget.Latest,
     true,
-    ts10.ScriptKind.TSX
+    ts11.ScriptKind.TSX
   );
   return {
     exports: listComponentFunctionsFromSourceFile(sourceFile),
@@ -8834,12 +8975,12 @@ function scanComponentFile(source, filePath) {
 function listComponentFunctionsFromSourceFile(sourceFile) {
   const componentNames = [];
   const hasUseClient = sourceFile.statements.some(
-    (stmt) => ts10.isExpressionStatement(stmt) && ts10.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
+    (stmt) => ts11.isExpressionStatement(stmt) && ts11.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
   );
   const namedExports = collectNamedExports(sourceFile);
   function collectComponents(node) {
     if (isComponentFunction(node)) {
-      const hasInlineExport = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+      const hasInlineExport = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
       const hasNamedExport = namedExports.has(node.name.text);
       const isExported = hasInlineExport || hasNamedExport;
       if (!hasUseClient && !isExported && node.body && isMultiReturnJsxFunctionBody(node.body)) {
@@ -8850,25 +8991,25 @@ function listComponentFunctionsFromSourceFile(sourceFile) {
     if (isArrowComponentFunction(node)) {
       componentNames.push(node.name.text);
     }
-    ts10.forEachChild(node, collectComponents);
+    ts11.forEachChild(node, collectComponents);
   }
-  ts10.forEachChild(sourceFile, collectComponents);
+  ts11.forEachChild(sourceFile, collectComponents);
   return componentNames;
 }
 function prescanReactiveFactoriesInSource(source, filePath) {
-  const sourceFile = ts10.createSourceFile(
+  const sourceFile = ts11.createSourceFile(
     filePath + ".prescan",
     source,
-    ts10.ScriptTarget.Latest,
+    ts11.ScriptTarget.Latest,
     true,
-    ts10.ScriptKind.TSX
+    ts11.ScriptKind.TSX
   );
   const factories = /* @__PURE__ */ new Map();
   const declined = /* @__PURE__ */ new Map();
   const reactiveShaped = /* @__PURE__ */ new Set();
   const cleanFactoryImports = /* @__PURE__ */ new Set();
   function visitTop(node) {
-    if (ts10.isFunctionDeclaration(node) && node.name && node.body) {
+    if (ts11.isFunctionDeclaration(node) && node.name && node.body) {
       const det = detectReactiveFactory(node, sourceFile, filePath);
       if (!det) return;
       switch (det.kind) {
@@ -8884,7 +9025,7 @@ function prescanReactiveFactoriesInSource(source, filePath) {
       }
     }
   }
-  ts10.forEachChild(sourceFile, visitTop);
+  ts11.forEachChild(sourceFile, visitTop);
   const result2 = { factories, declined, reactiveShaped, cleanFactoryImports, sourceFile };
   prescanImportedReactiveFactories(sourceFile, filePath, result2);
   return result2;
@@ -8899,13 +9040,13 @@ function toComponentRelativeSpecifier(resolvedAbs, componentFilePath) {
 function buildEntryImportIndex(sf, filePath) {
   const index = /* @__PURE__ */ new Map();
   for (const stmt of sf.statements) {
-    if (!ts10.isImportDeclaration(stmt)) continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts11.isImportDeclaration(stmt)) continue;
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier)) continue;
     const src = stmt.moduleSpecifier.text;
     const targetKey = src.startsWith("./") || src.startsWith("../") ? resolveRelativeImportToFile(src, filePath) ?? "unresolved:" + src : src;
     const wholeTypeOnly = stmt.importClause?.isTypeOnly === true;
     const namedBindings = stmt.importClause?.namedBindings;
-    if (namedBindings && ts10.isNamedImports(namedBindings)) {
+    if (namedBindings && ts11.isNamedImports(namedBindings)) {
       for (const el of namedBindings.elements) {
         index.set(el.name.text, {
           targetKey,
@@ -8920,35 +9061,35 @@ function buildEntryImportIndex(sf, filePath) {
 function collectEntryBindingNames(sf) {
   const names = /* @__PURE__ */ new Set();
   function visit3(node) {
-    if (ts10.isImportDeclaration(node) && node.importClause) {
+    if (ts11.isImportDeclaration(node) && node.importClause) {
       if (node.importClause.name) names.add(node.importClause.name.text);
       const namedBindings = node.importClause.namedBindings;
-      if (namedBindings && ts10.isNamedImports(namedBindings)) {
+      if (namedBindings && ts11.isNamedImports(namedBindings)) {
         for (const el of namedBindings.elements) names.add(el.name.text);
       }
-      if (namedBindings && ts10.isNamespaceImport(namedBindings)) {
+      if (namedBindings && ts11.isNamespaceImport(namedBindings)) {
         names.add(namedBindings.name.text);
       }
     }
-    if (ts10.isVariableDeclaration(node)) {
+    if (ts11.isVariableDeclaration(node)) {
       const out = [];
       addBindingNames(node.name, out);
       for (const n of out) names.add(n);
     }
-    if ((ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node) || ts10.isEnumDeclaration(node)) && node.name) {
+    if ((ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node) || ts11.isEnumDeclaration(node)) && node.name) {
       names.add(node.name.text);
     }
-    if ((ts10.isTypeAliasDeclaration(node) || ts10.isInterfaceDeclaration(node)) && node.name) {
+    if ((ts11.isTypeAliasDeclaration(node) || ts11.isInterfaceDeclaration(node)) && node.name) {
       names.add(node.name.text);
     }
-    if (ts10.isFunctionLike(node)) {
+    if (ts11.isFunctionLike(node)) {
       for (const p of node.parameters) {
         const out = [];
         addBindingNames(p.name, out);
         for (const n of out) names.add(n);
       }
     }
-    ts10.forEachChild(node, visit3);
+    ts11.forEachChild(node, visit3);
   }
   visit3(sf);
   return names;
@@ -8956,22 +9097,22 @@ function collectEntryBindingNames(sf) {
 function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
   const candidateCallees = /* @__PURE__ */ new Set();
   function collectCandidates(node) {
-    if (ts10.isVariableDeclaration(node) && (ts10.isArrayBindingPattern(node.name) || ts10.isObjectBindingPattern(node.name)) && node.initializer && ts10.isCallExpression(node.initializer) && ts10.isIdentifier(node.initializer.expression)) {
+    if (ts11.isVariableDeclaration(node) && (ts11.isArrayBindingPattern(node.name) || ts11.isObjectBindingPattern(node.name)) && node.initializer && ts11.isCallExpression(node.initializer) && ts11.isIdentifier(node.initializer.expression)) {
       candidateCallees.add(node.initializer.expression.text);
     }
-    ts10.forEachChild(node, collectCandidates);
+    ts11.forEachChild(node, collectCandidates);
   }
   collectCandidates(entrySourceFile);
   if (candidateCallees.size === 0) return;
   const importsToCheck = [];
   for (const stmt of entrySourceFile.statements) {
-    if (!ts10.isImportDeclaration(stmt)) continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts11.isImportDeclaration(stmt)) continue;
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier)) continue;
     const src = stmt.moduleSpecifier.text;
     if (!src.startsWith("./") && !src.startsWith("../")) continue;
     if (stmt.importClause?.isTypeOnly) continue;
     const namedBindings = stmt.importClause?.namedBindings;
-    if (!namedBindings || !ts10.isNamedImports(namedBindings)) continue;
+    if (!namedBindings || !ts11.isNamedImports(namedBindings)) continue;
     const specs = [];
     for (const el of namedBindings.elements) {
       if (el.isTypeOnly) continue;
@@ -9003,14 +9144,14 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
       helperCache.set(abs, "clean");
       return "clean";
     }
-    const sf = ts10.createSourceFile(abs + ".prescan", content2, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+    const sf = ts11.createSourceFile(abs + ".prescan", content2, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
     const localFns = /* @__PURE__ */ new Map();
     const exportedFns = /* @__PURE__ */ new Map();
     for (const stmt of sf.statements) {
-      if (ts10.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
+      if (ts11.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
         localFns.set(stmt.name.text, stmt);
-        const hasExportModifier = stmt.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
-        const hasDefaultModifier = stmt.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DefaultKeyword) ?? false;
+        const hasExportModifier = stmt.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
+        const hasDefaultModifier = stmt.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DefaultKeyword) ?? false;
         if (hasExportModifier && !hasDefaultModifier) {
           exportedFns.set(stmt.name.text, stmt);
         }
@@ -9019,9 +9160,9 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
     const reexports = /* @__PURE__ */ new Map();
     let hasStarReexport = false;
     for (const stmt of sf.statements) {
-      if (!ts10.isExportDeclaration(stmt) || stmt.isTypeOnly) continue;
+      if (!ts11.isExportDeclaration(stmt) || stmt.isTypeOnly) continue;
       if (!stmt.moduleSpecifier) {
-        if (stmt.exportClause && ts10.isNamedExports(stmt.exportClause)) {
+        if (stmt.exportClause && ts11.isNamedExports(stmt.exportClause)) {
           for (const el of stmt.exportClause.elements) {
             if (el.isTypeOnly) continue;
             const fn = localFns.get((el.propertyName ?? el.name).text);
@@ -9030,8 +9171,8 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
         }
         continue;
       }
-      if (!ts10.isStringLiteral(stmt.moduleSpecifier)) continue;
-      if (stmt.exportClause && ts10.isNamedExports(stmt.exportClause)) {
+      if (!ts11.isStringLiteral(stmt.moduleSpecifier)) continue;
+      if (stmt.exportClause && ts11.isNamedExports(stmt.exportClause)) {
         for (const el of stmt.exportClause.elements) {
           if (el.isTypeOnly) continue;
           reexports.set(el.name.text, {
@@ -9167,7 +9308,7 @@ function collectHelperModuleValueBindings(sf) {
   const importedTypes = /* @__PURE__ */ new Map();
   const imported = /* @__PURE__ */ new Map();
   for (const stmt of sf.statements) {
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       const out = [];
       for (const decl of stmt.declarationList.declarations) {
         addBindingNames(decl.name, out);
@@ -9175,29 +9316,29 @@ function collectHelperModuleValueBindings(sf) {
       for (const n of out) local.add(n);
       continue;
     }
-    if ((ts10.isFunctionDeclaration(stmt) || ts10.isClassDeclaration(stmt) || ts10.isEnumDeclaration(stmt)) && stmt.name) {
+    if ((ts11.isFunctionDeclaration(stmt) || ts11.isClassDeclaration(stmt) || ts11.isEnumDeclaration(stmt)) && stmt.name) {
       local.add(stmt.name.text);
       continue;
     }
-    if ((ts10.isTypeAliasDeclaration(stmt) || ts10.isInterfaceDeclaration(stmt)) && stmt.name) {
+    if ((ts11.isTypeAliasDeclaration(stmt) || ts11.isInterfaceDeclaration(stmt)) && stmt.name) {
       localTypes.add(stmt.name.text);
       continue;
     }
-    if (ts10.isImportDeclaration(stmt)) {
-      if (!ts10.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (ts11.isImportDeclaration(stmt)) {
+      if (!ts11.isStringLiteral(stmt.moduleSpecifier)) continue;
       const src = stmt.moduleSpecifier.text;
       if (src === "@barefootjs/client" || src === "@barefootjs/client/runtime") continue;
       const wholeTypeOnly = stmt.importClause?.isTypeOnly === true;
       if (stmt.importClause?.name) (wholeTypeOnly ? localTypes : local).add(stmt.importClause.name.text);
       const namedBindings = stmt.importClause?.namedBindings;
-      if (namedBindings && ts10.isNamedImports(namedBindings)) {
+      if (namedBindings && ts11.isNamedImports(namedBindings)) {
         for (const el of namedBindings.elements) {
           const entry = { source: src, exportedName: (el.propertyName ?? el.name).text };
           if (wholeTypeOnly || el.isTypeOnly) importedTypes.set(el.name.text, entry);
           else imported.set(el.name.text, entry);
         }
       }
-      if (namedBindings && ts10.isNamespaceImport(namedBindings)) {
+      if (namedBindings && ts11.isNamespaceImport(namedBindings)) {
         (wholeTypeOnly ? localTypes : local).add(namedBindings.name.text);
       }
     }
@@ -9251,50 +9392,50 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   let hasReactiveCall = false;
   function checkForReactive(n) {
     if (hasReactiveCall) return;
-    if (ts10.isCallExpression(n) && ts10.isIdentifier(n.expression) && REACTIVE_PRIMITIVES.has(n.expression.text)) {
+    if (ts11.isCallExpression(n) && ts11.isIdentifier(n.expression) && REACTIVE_PRIMITIVES.has(n.expression.text)) {
       hasReactiveCall = true;
       return;
     }
-    ts10.forEachChild(n, checkForReactive);
+    ts11.forEachChild(n, checkForReactive);
   }
   checkForReactive(node.body);
   if (!hasReactiveCall) return null;
   const loc = getSourceLocation(node, sourceFile, filePath);
   let totalReturnCount = 0;
   function countReturns(n) {
-    if (ts10.isFunctionLike(n)) return;
-    if (ts10.isReturnStatement(n)) {
+    if (ts11.isFunctionLike(n)) return;
+    if (ts11.isReturnStatement(n)) {
       totalReturnCount++;
       return;
     }
-    ts10.forEachChild(n, countReturns);
+    ts11.forEachChild(n, countReturns);
   }
-  ts10.forEachChild(node.body, countReturns);
+  ts11.forEachChild(node.body, countReturns);
   let returnExpr = null;
   let returnCount = 0;
   for (const stmt of node.body.statements) {
-    if (!ts10.isReturnStatement(stmt)) continue;
+    if (!ts11.isReturnStatement(stmt)) continue;
     returnCount++;
     if (!stmt.expression) return { kind: "reactive-shaped" };
     let expr = stmt.expression;
-    while (ts10.isParenthesizedExpression(expr)) expr = expr.expression;
-    if (ts10.isAsExpression(expr)) expr = expr.expression;
-    if (ts10.isTypeAssertionExpression(expr)) expr = expr.expression;
+    while (ts11.isParenthesizedExpression(expr)) expr = expr.expression;
+    if (ts11.isAsExpression(expr)) expr = expr.expression;
+    if (ts11.isTypeAssertionExpression(expr)) expr = expr.expression;
     returnExpr = expr;
   }
   if (totalReturnCount !== 1 || returnCount !== 1 || !returnExpr) return { kind: "reactive-shaped" };
   const returnTupleIdentifiers = [];
   let returnKind;
-  if (ts10.isArrayLiteralExpression(returnExpr)) {
+  if (ts11.isArrayLiteralExpression(returnExpr)) {
     returnKind = "tuple";
     for (const el of returnExpr.elements) {
-      if (!ts10.isIdentifier(el)) return { kind: "reactive-shaped" };
+      if (!ts11.isIdentifier(el)) return { kind: "reactive-shaped" };
       returnTupleIdentifiers.push(el.text);
     }
     if (returnTupleIdentifiers.length === 0) return { kind: "reactive-shaped" };
-  } else if (ts10.isObjectLiteralExpression(returnExpr)) {
+  } else if (ts11.isObjectLiteralExpression(returnExpr)) {
     returnKind = "object";
-    const hasNonShorthand = returnExpr.properties.some((p) => !ts10.isShorthandPropertyAssignment(p));
+    const hasNonShorthand = returnExpr.properties.some((p) => !ts11.isShorthandPropertyAssignment(p));
     if (hasNonShorthand) {
       return {
         kind: "declined",
@@ -9314,7 +9455,7 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   }
   const params = [];
   for (const p of node.parameters) {
-    if (ts10.isIdentifier(p.name)) {
+    if (ts11.isIdentifier(p.name)) {
       params.push(p.name.text);
       continue;
     }
@@ -9322,11 +9463,11 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   }
   const localBindings = [];
   for (const stmt of node.body.statements) {
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
         addBindingNames(decl.name, localBindings);
       }
-    } else if (ts10.isFunctionDeclaration(stmt) && stmt.name) {
+    } else if (ts11.isFunctionDeclaration(stmt) && stmt.name) {
       localBindings.push(stmt.name.text);
     }
   }
@@ -9345,37 +9486,37 @@ function detectReactiveFactory(node, sourceFile, filePath) {
     function classify3(id2) {
       if (!relevantNames.has(id2.text)) return;
       const p = id2.parent;
-      if (ts10.isPropertyAccessExpression(p) && p.name === id2) return;
-      if (ts10.isPropertyAssignment(p) && p.name === id2) return;
-      if (ts10.isBindingElement(p) && p.propertyName === id2) return;
-      if ((ts10.isMethodDeclaration(p) || ts10.isGetAccessorDeclaration(p) || ts10.isSetAccessorDeclaration(p) || ts10.isPropertyDeclaration(p) || ts10.isEnumMember(p)) && p.name === id2) return;
-      if (ts10.isJsxAttribute(p) && p.name === id2) return;
-      if (ts10.isLabeledStatement(p) && p.label === id2 || (ts10.isBreakStatement(p) || ts10.isContinueStatement(p)) && p.label === id2) return;
-      if ((ts10.isJsxOpeningElement(p) || ts10.isJsxSelfClosingElement(p) || ts10.isJsxClosingElement(p)) && p.tagName === id2 && /^[a-z]/.test(id2.text)) return;
-      if (ts10.isShorthandPropertyAssignment(p) && p.name === id2) {
+      if (ts11.isPropertyAccessExpression(p) && p.name === id2) return;
+      if (ts11.isPropertyAssignment(p) && p.name === id2) return;
+      if (ts11.isBindingElement(p) && p.propertyName === id2) return;
+      if ((ts11.isMethodDeclaration(p) || ts11.isGetAccessorDeclaration(p) || ts11.isSetAccessorDeclaration(p) || ts11.isPropertyDeclaration(p) || ts11.isEnumMember(p)) && p.name === id2) return;
+      if (ts11.isJsxAttribute(p) && p.name === id2) return;
+      if (ts11.isLabeledStatement(p) && p.label === id2 || (ts11.isBreakStatement(p) || ts11.isContinueStatement(p)) && p.label === id2) return;
+      if ((ts11.isJsxOpeningElement(p) || ts11.isJsxSelfClosingElement(p) || ts11.isJsxClosingElement(p)) && p.tagName === id2 && /^[a-z]/.test(id2.text)) return;
+      if (ts11.isShorthandPropertyAssignment(p) && p.name === id2) {
         push(id2, "shorthand");
         return;
       }
-      if (ts10.isBindingElement(p) && p.name === id2 && !p.propertyName && ts10.isObjectBindingPattern(p.parent)) {
+      if (ts11.isBindingElement(p) && p.name === id2 && !p.propertyName && ts11.isObjectBindingPattern(p.parent)) {
         if (params.includes(id2.text)) shadowedParam = id2.text;
         push(id2, "shorthand");
         return;
       }
-      const isDecl = (ts10.isVariableDeclaration(p) || ts10.isParameter(p) || ts10.isBindingElement(p) || ts10.isFunctionDeclaration(p) || ts10.isFunctionExpression(p) || ts10.isClassDeclaration(p) || ts10.isClassExpression(p)) && p.name === id2;
+      const isDecl = (ts11.isVariableDeclaration(p) || ts11.isParameter(p) || ts11.isBindingElement(p) || ts11.isFunctionDeclaration(p) || ts11.isFunctionExpression(p) || ts11.isClassDeclaration(p) || ts11.isClassExpression(p)) && p.name === id2;
       if (isDecl && params.includes(id2.text)) shadowedParam = id2.text;
       push(id2, "plain");
     }
     function visit3(n) {
-      if (ts10.isTypeNode(n) || ts10.isTypeParameterDeclaration(n) || ts10.isTypeAliasDeclaration(n) || ts10.isInterfaceDeclaration(n)) return;
-      if (ts10.isIdentifier(n)) {
+      if (ts11.isTypeNode(n) || ts11.isTypeParameterDeclaration(n) || ts11.isTypeAliasDeclaration(n) || ts11.isInterfaceDeclaration(n)) return;
+      if (ts11.isIdentifier(n)) {
         classify3(n);
         return;
       }
-      ts10.forEachChild(n, visit3);
+      ts11.forEachChild(n, visit3);
     }
     visit3(root2);
   }
-  const keptStatements = node.body.statements.filter((s) => !ts10.isReturnStatement(s));
+  const keptStatements = node.body.statements.filter((s) => !ts11.isReturnStatement(s));
   const pieces = [];
   let base = 0;
   for (const stmt of keptStatements) {
@@ -9422,17 +9563,17 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   };
 }
 function addBindingNames(name2, out) {
-  if (ts10.isIdentifier(name2)) {
+  if (ts11.isIdentifier(name2)) {
     out.push(name2.text);
     return;
   }
-  if (ts10.isObjectBindingPattern(name2)) {
+  if (ts11.isObjectBindingPattern(name2)) {
     for (const el of name2.elements) addBindingNames(el.name, out);
     return;
   }
-  if (ts10.isArrayBindingPattern(name2)) {
+  if (ts11.isArrayBindingPattern(name2)) {
     for (const el of name2.elements) {
-      if (ts10.isOmittedExpression(el)) continue;
+      if (ts11.isOmittedExpression(el)) continue;
       addBindingNames(el.name, out);
     }
   }
@@ -9443,28 +9584,28 @@ function rewriteFactoryCallsInSource(source, prescan) {
   let callSiteIndex = 0;
   const inlinedFactories = /* @__PURE__ */ new Set();
   function visitStmt(node, inComponent) {
-    if (ts10.isVariableStatement(node) && inComponent) {
+    if (ts11.isVariableStatement(node) && inComponent) {
       for (const decl of node.declarationList.declarations) {
         maybeRewriteDecl(node, decl);
       }
     }
-    ts10.forEachChild(node, (child) => {
-      if (ts10.isFunctionDeclaration(child) && child.name && factories.has(child.name.text)) return;
+    ts11.forEachChild(node, (child) => {
+      if (ts11.isFunctionDeclaration(child) && child.name && factories.has(child.name.text)) return;
       visitStmt(child, inComponent || isPascalCaseComponentFn(child));
     });
   }
   function maybeRewriteDecl(stmt, decl) {
-    if (!decl.initializer || !ts10.isCallExpression(decl.initializer)) return;
-    if (!ts10.isIdentifier(decl.initializer.expression)) return;
+    if (!decl.initializer || !ts11.isCallExpression(decl.initializer)) return;
+    if (!ts11.isIdentifier(decl.initializer.expression)) return;
     const factoryName = decl.initializer.expression.text;
     const factory = factories.get(factoryName);
     if (!factory) return;
-    if (ts10.isArrayBindingPattern(decl.name)) {
+    if (ts11.isArrayBindingPattern(decl.name)) {
       if (factory.returnKind !== "tuple") return;
       rewriteTupleDecl(stmt, decl.name, decl.initializer, factory);
       return;
     }
-    if (ts10.isObjectBindingPattern(decl.name)) {
+    if (ts11.isObjectBindingPattern(decl.name)) {
       if (factory.returnKind !== "object") return;
       rewriteObjectDecl(stmt, decl.name, decl.initializer, factory);
       return;
@@ -9475,7 +9616,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
     if (elements2.length !== factory.returnTupleIdentifiers.length) return;
     const callerNames = [];
     for (const el of elements2) {
-      if (ts10.isOmittedExpression(el) || !ts10.isIdentifier(el.name)) return;
+      if (ts11.isOmittedExpression(el) || !ts11.isIdentifier(el.name)) return;
       callerNames.push(el.name.text);
     }
     const excludeFromSuffixRename = new Set(factory.params);
@@ -9492,7 +9633,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
       if (el.dotDotDotToken) return;
       if (el.propertyName) return;
       if (el.initializer) return;
-      if (!ts10.isIdentifier(el.name)) return;
+      if (!ts11.isIdentifier(el.name)) return;
       if (!factory.returnTupleIdentifiers.includes(el.name.text)) return;
       destructured.add(el.name.text);
     }
@@ -9585,21 +9726,21 @@ function factoryImportInsertionOffset(sf) {
   let lastImportEnd = -1;
   let directiveEnd = -1;
   for (const stmt of sf.statements) {
-    if (ts10.isImportDeclaration(stmt)) {
+    if (ts11.isImportDeclaration(stmt)) {
       lastImportEnd = stmt.getEnd();
       continue;
     }
-    if (directiveEnd === -1 && ts10.isExpressionStatement(stmt) && ts10.isStringLiteral(stmt.expression) && stmt.expression.text === "use client") {
+    if (directiveEnd === -1 && ts11.isExpressionStatement(stmt) && ts11.isStringLiteral(stmt.expression) && stmt.expression.text === "use client") {
       directiveEnd = stmt.getEnd();
     }
   }
   return lastImportEnd >= 0 ? lastImportEnd : directiveEnd >= 0 ? directiveEnd : 0;
 }
 function isPascalCaseComponentFn(node) {
-  if (ts10.isFunctionDeclaration(node) && node.name) {
+  if (ts11.isFunctionDeclaration(node) && node.name) {
     return /^[A-Z]/.test(node.name.text);
   }
-  if (ts10.isVariableDeclaration(node) && ts10.isIdentifier(node.name) && node.initializer && ts10.isArrowFunction(node.initializer)) {
+  if (ts11.isVariableDeclaration(node) && ts11.isIdentifier(node.name) && node.initializer && ts11.isArrowFunction(node.initializer)) {
     return /^[A-Z]/.test(node.name.text);
   }
   return false;
@@ -9627,16 +9768,16 @@ function declinedFactoryErrorCode(code) {
 }
 function validateReactiveFactoryCalls(ctx2) {
   if (!ctx2.componentNode) return;
-  const body2 = ts10.isFunctionDeclaration(ctx2.componentNode) ? ctx2.componentNode.body : ts10.isBlock(ctx2.componentNode.body) ? ctx2.componentNode.body : null;
+  const body2 = ts11.isFunctionDeclaration(ctx2.componentNode) ? ctx2.componentNode.body : ts11.isBlock(ctx2.componentNode.body) ? ctx2.componentNode.body : null;
   if (!body2) return;
   for (const stmt of body2.statements) {
-    if (!ts10.isVariableStatement(stmt)) continue;
+    if (!ts11.isVariableStatement(stmt)) continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts10.isCallExpression(decl.initializer)) continue;
-      if (!ts10.isIdentifier(decl.initializer.expression)) continue;
+      if (!decl.initializer || !ts11.isCallExpression(decl.initializer)) continue;
+      if (!ts11.isIdentifier(decl.initializer.expression)) continue;
       const callee = decl.initializer.expression.text;
       const loc = getSourceLocation(stmt, ctx2.sourceFile, ctx2.filePath);
-      if (ts10.isArrayBindingPattern(decl.name)) {
+      if (ts11.isArrayBindingPattern(decl.name)) {
         if (callee === "createSignal" || callee === "createMemo") continue;
         if (resolveEnvSignalKey(decl.initializer, ctx2)) continue;
         const declinedEntry = ctx2.declinedReactiveFactories.get(callee);
@@ -9671,7 +9812,7 @@ function validateReactiveFactoryCalls(ctx2) {
         );
         continue;
       }
-      if (ts10.isObjectBindingPattern(decl.name)) {
+      if (ts11.isObjectBindingPattern(decl.name)) {
         validateObjectFactoryDestructure(ctx2, decl.name, callee, loc);
       }
     }
@@ -9679,22 +9820,22 @@ function validateReactiveFactoryCalls(ctx2) {
 }
 function validateNamespaceQualifiedPrimitives(ctx2) {
   if (!ctx2.componentNode) return;
-  const body2 = ts10.isFunctionDeclaration(ctx2.componentNode) ? ctx2.componentNode.body : ts10.isBlock(ctx2.componentNode.body) ? ctx2.componentNode.body : null;
+  const body2 = ts11.isFunctionDeclaration(ctx2.componentNode) ? ctx2.componentNode.body : ts11.isBlock(ctx2.componentNode.body) ? ctx2.componentNode.body : null;
   if (!body2) return;
   for (const stmt of body2.statements) {
     const calls = [];
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
         let init = decl.initializer;
-        if (init && ts10.isElementAccessExpression(init)) init = init.expression;
-        if (init && ts10.isCallExpression(init)) calls.push(init);
+        if (init && ts11.isElementAccessExpression(init)) init = init.expression;
+        if (init && ts11.isCallExpression(init)) calls.push(init);
       }
-    } else if (ts10.isExpressionStatement(stmt) && ts10.isCallExpression(stmt.expression)) {
+    } else if (ts11.isExpressionStatement(stmt) && ts11.isCallExpression(stmt.expression)) {
       calls.push(stmt.expression);
     }
     for (const call of calls) {
       const callee = call.expression;
-      if (!ts10.isPropertyAccessExpression(callee) || !ts10.isIdentifier(callee.expression)) continue;
+      if (!ts11.isPropertyAccessExpression(callee) || !ts11.isIdentifier(callee.expression)) continue;
       const primitive = callee.name.text;
       if (!(primitive in PRIMITIVE_CANONICAL_NAMES)) continue;
       if (resolvePrimitiveKind(call, ctx2) !== null) continue;
@@ -9724,10 +9865,10 @@ function isNamespaceNameShadowedAtComponentTopLevel(name2, body2, ctx2) {
   if (ctx2.propsObjectName === name2) return true;
   if (ctx2.propsParams.some((p) => p.name === name2)) return true;
   for (const stmt of body2.statements) {
-    if (ts10.isFunctionDeclaration(stmt) && stmt.name?.text === name2) return true;
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isFunctionDeclaration(stmt) && stmt.name?.text === name2) return true;
+    if (ts11.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
-        if (ts10.isIdentifier(decl.name) && decl.name.text === name2) return true;
+        if (ts11.isIdentifier(decl.name) && decl.name.text === name2) return true;
       }
     }
   }
@@ -9744,7 +9885,7 @@ function validateObjectFactoryDestructure(ctx2, pattern, callee, loc) {
       return;
     }
     const hasUnsupportedElement = pattern.elements.some(
-      (el) => !!el.propertyName || !!el.initializer || !!el.dotDotDotToken || !ts10.isIdentifier(el.name)
+      (el) => !!el.propertyName || !!el.initializer || !!el.dotDotDotToken || !ts11.isIdentifier(el.name)
     );
     if (hasUnsupportedElement) {
       ctx2.errors.push(createError(ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED, loc, {
@@ -9753,7 +9894,7 @@ function validateObjectFactoryDestructure(ctx2, pattern, callee, loc) {
       }));
       return;
     }
-    const unknown = pattern.elements.map((el) => ts10.isIdentifier(el.name) ? el.name.text : "").filter((name2) => name2 && !factory.returnTupleIdentifiers.includes(name2));
+    const unknown = pattern.elements.map((el) => ts11.isIdentifier(el.name) ? el.name.text : "").filter((name2) => name2 && !factory.returnTupleIdentifiers.includes(name2));
     if (unknown.length > 0) {
       const label2 = unknown.length === 1 ? "property" : "properties";
       ctx2.errors.push(createError(ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY, loc, {
@@ -10013,7 +10154,7 @@ var init_types = __esm({
 });
 // ../jsx/src/module-exports.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function generateModuleExports(ir, extraInlineExported = /* @__PURE__ */ new Set(), rewriteRelativeImport, options2) {
   const lines = [];
   for (const constant of options2?.skipValueDeclarations ? [] : ir.metadata.localConstants) {
@@ -10104,28 +10245,28 @@ function findReachableNames(primaryRefs, declarations) {
 function findAssignedNames(bodyText, candidates) {
   const assigned = /* @__PURE__ */ new Set();
   if (candidates.size === 0) return assigned;
-  const sf = ts11.createSourceFile(
+  const sf = ts12.createSourceFile(
     "bf-assignment-scan.tsx",
     bodyText,
-    ts11.ScriptTarget.Latest,
+    ts12.ScriptTarget.Latest,
     /* setParentNodes */
     false,
-    ts11.ScriptKind.TSX
+    ts12.ScriptKind.TSX
   );
   const record = (target2) => {
-    if (ts11.isIdentifier(target2) && candidates.has(target2.text)) {
+    if (ts12.isIdentifier(target2) && candidates.has(target2.text)) {
       assigned.add(target2.text);
     }
   };
   const visit3 = (node) => {
-    if (ts11.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts12.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
       record(node.left);
-    } else if ((ts11.isPrefixUnaryExpression(node) || ts11.isPostfixUnaryExpression(node)) && (node.operator === ts11.SyntaxKind.PlusPlusToken || node.operator === ts11.SyntaxKind.MinusMinusToken)) {
+    } else if ((ts12.isPrefixUnaryExpression(node) || ts12.isPostfixUnaryExpression(node)) && (node.operator === ts12.SyntaxKind.PlusPlusToken || node.operator === ts12.SyntaxKind.MinusMinusToken)) {
       record(node.operand);
     }
-    ts11.forEachChild(node, visit3);
+    ts12.forEachChild(node, visit3);
   };
-  ts11.forEachChild(sf, visit3);
+  ts12.forEachChild(sf, visit3);
   return assigned;
 }
 function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
@@ -10145,7 +10286,7 @@ function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNam
   return reachable;
 }
 function isAssignmentOperator(kind2) {
-  return kind2 >= ts11.SyntaxKind.FirstAssignment && kind2 <= ts11.SyntaxKind.LastAssignment;
+  return kind2 >= ts12.SyntaxKind.FirstAssignment && kind2 <= ts12.SyntaxKind.LastAssignment;
 }
 function extractFunctionParams(value2) {
   const arrowMatch = value2.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
@@ -10198,111 +10339,6 @@ var init_builtins = __esm({
   }
 });
-// ../jsx/src/reactivity-checker.ts
-import ts12 from "typescript";
-function queryType(checker, node) {
-  incrementCounter("typeCheckerQueries");
-  return checker.getTypeAtLocation(node);
-}
-function isReactiveType(type2) {
-  return type2.getProperty(REACTIVE_BRAND) !== void 0;
-}
-function safeGetText(node) {
-  try {
-    return node.getText();
-  } catch {
-    return "";
-  }
-}
-function analyze(node, checker) {
-  if (ts12.isPropertyAccessExpression(node)) {
-    try {
-      const type2 = queryType(checker, node);
-      if (isReactiveType(type2)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {
-    }
-    const sub2 = analyze(node.expression, checker);
-    if (sub2.isReactive) {
-      return {
-        isReactive: true,
-        reason: {
-          kind: "child",
-          via: "property-access-object",
-          childText: safeGetText(node.expression),
-          childReason: sub2.reason
-        }
-      };
-    }
-    return NOT_REACTIVE;
-  }
-  if (ts12.isIdentifier(node)) {
-    try {
-      const type2 = queryType(checker, node);
-      if (isReactiveType(type2)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "identifier", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {
-    }
-    return NOT_REACTIVE;
-  }
-  if (ts12.isCallExpression(node)) {
-    try {
-      const calleeType = queryType(checker, node.expression);
-      if (isReactiveType(calleeType)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "callee", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {
-    }
-  }
-  let foundChild;
-  let foundChildText = "";
-  ts12.forEachChild(node, (child) => {
-    if (foundChild?.isReactive) return;
-    const result2 = analyze(child, checker);
-    if (result2.isReactive) {
-      foundChild = result2;
-      foundChildText = safeGetText(child);
-    }
-  });
-  if (foundChild?.isReactive) {
-    return {
-      isReactive: true,
-      reason: {
-        kind: "child",
-        via: "sub-expression",
-        childText: foundChildText,
-        childReason: foundChild.reason
-      }
-    };
-  }
-  return NOT_REACTIVE;
-}
-function containsReactiveExpression(node, checker) {
-  incrementCounter("reactivityChecks");
-  return brandTypeReactivityAnalyzer.analyze(node, checker).isReactive;
-}
-var REACTIVE_BRAND, NOT_REACTIVE, brandTypeReactivityAnalyzer;
-var init_reactivity_checker = __esm({
-  "../jsx/src/reactivity-checker.ts"() {
-    "use strict";
-    init_instrumentation();
-    REACTIVE_BRAND = "__reactive";
-    NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
-    brandTypeReactivityAnalyzer = { analyze };
-  }
-});
 // ../jsx/src/free-refs.ts
 import ts13 from "typescript";
 function buildBindingMap(env) {
@@ -11932,7 +11968,7 @@ function transformExpressionInner(expr, ctx2, node, isClientOnly) {
   }
   const ir = transformJsxExpression(expr, ctx2, isClientOnly);
   if (ir !== null) {
-    if ((isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx2)) && ir.type === "conditional") {
+    if (ir.type === "conditional" && (isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx2))) {
       ir.clientOnly = true;
       if (!ir.slotId) {
         ir.slotId = generateSlotId(ctx2);
@@ -14858,8 +14894,9 @@ function isReactiveExpression(expr, ctx2, astNode) {
 function shouldAutoDeferReactiveBrand(expr, ctx2) {
   const checker = ctx2.analyzer.checker;
   if (!checker) return false;
-  if (!containsReactiveExpression(expr, checker)) return false;
-  if (isSignalOrMemoReference(ctx2.getJS(expr), ctx2)) return false;
+  const leaves = collectReactiveBrandLeaves(expr, checker);
+  if (leaves.length === 0) return false;
+  if (leaves.some((leaf) => isSignalOrMemoReference(ctx2.getJS(leaf), ctx2))) return false;
   return true;
 }
 function isSignalOrMemoReference(expr, ctx2, visited) {
@@ -15250,9 +15287,9 @@ var init_prop_handling = __esm({
 });
 // ../jsx/src/ir-to-client-js/reactivity.ts
-function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex) {
+function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope) {
   if (!loopParam) return void 0;
-  return BindingScope.EMPTY.enterLoopRow({
+  return (parentScope ?? BindingScope.EMPTY).enterLoopRow({
     param: loopParam,
     paramBindings: loopParamBindings,
     index: loopIndex,
@@ -15314,16 +15351,20 @@ function needsEffectWrapperCore(expr, ctx2, freeIdentifiers2, visitedConstants)
   }
   return false;
 }
-function classifyReactivity(expr, ctx2, loopParam, loopParamBindings, freeIdentifiers2) {
+function classifyReactivity(expr, ctx2, scope, freeIdentifiers2) {
   const has = (name2) => freeIdentifiers2 ? freeIdentifiers2.has(name2) : tokenContainsIdent(expr, name2);
-  if (loopParamBindings && loopParamBindings.length > 0) {
-    for (const b of loopParamBindings) {
-      if (has(b.name)) {
-        return { kind: "loop-param", param: loopParam ?? b.name };
+  if (scope) {
+    let indexHit;
+    for (const name2 of scope.valueBoundNames()) {
+      if (!has(name2)) continue;
+      const source = scope.lookup(name2)?.binding.source;
+      if (source === "index") {
+        indexHit ??= name2;
+        continue;
       }
+      return { kind: "loop-param", param: name2 };
     }
-  } else if (loopParam && has(loopParam)) {
-    return { kind: "loop-param", param: loopParam };
+    if (indexHit) return { kind: "loop-index", param: indexHit };
   }
   if (needsEffectWrapper(expr, ctx2, freeIdentifiers2)) {
     return { kind: "signal-or-memo-or-prop" };
@@ -15494,9 +15535,9 @@ function traverseForComponents(node, components, skipConditionals = false) {
     }
   });
 }
-function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
+function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex, parentScope) {
   const texts = [];
-  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope);
   walkIR(node, false, {
     // Skip loop/async/if-statement subtrees — the original walker omitted
     // them; they have their own scopes (inner-loop reconciliation, async
@@ -15507,7 +15548,7 @@ function collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings,
       if (n.preambleRegion) return;
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
       const expanded = expandConstantForReactivity(n.expr, ctx2, originFreeIds, scope);
-      const reactive = classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
+      const reactive = classifyReactivity(expanded.expr, ctx2, scope, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
       if (!reactive) return;
       texts.push({
         slotId: n.slotId,
@@ -15526,9 +15567,9 @@ function anyNameIn(names, set) {
   for (const n of names) if (set.has(n)) return true;
   return false;
 }
-function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
+function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex, parentScope) {
   const attrs = [];
-  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope);
   traverseElements(node, (el) => {
     if (el.slotId) {
       for (const attr of el.attrs) {
@@ -15539,7 +15580,7 @@ function collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings,
         if (!valueStr) continue;
         const expanded = expandConstantForReactivity(valueStr, ctx2, attr.freeIdentifiers, scope);
         const readsPreamble = preambleNames !== void 0 && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
-        const reactive = classifyReactivity(expanded.expr, ctx2, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
+        const reactive = classifyReactivity(expanded.expr, ctx2, scope, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
         if (!attr.clientOnly && !reactive) continue;
         attrs.push({
           childSlotId: el.slotId,
@@ -15871,7 +15912,9 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
   const flat = options2?.flatBranchMode === true;
   const fixedDepth = options2?.templateDepth;
   const collectBindings = options2?.collectItemBindings === true;
-  const initialScope = { parentSlotId: null, depth: 0, insideCond: false };
+  const outerSpec = typeof outerLoopParam === "string" ? { param: outerLoopParam } : outerLoopParam;
+  const outerScope = buildLoopRowScope(outerSpec?.param, outerSpec?.bindings, void 0, outerSpec?.index);
+  const initialScope = { parentSlotId: null, depth: 0, insideCond: false, bindingScope: outerScope };
   for (const root2 of nodes) {
     walkIR(root2, initialScope, {
       element: ({ node: el, scope, descend }) => {
@@ -15886,15 +15929,14 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
       },
       loop: ({ node: n, scope, descend }) => {
         const emitDepth = fixedDepth ?? scope.depth + 1;
-        const loopParamsForTemplate = outerLoopParam ? [outerLoopParam, { param: n.param, bindings: n.paramBindings, index: n.index }] : void 0;
+        const loopParamsForTemplate = outerSpec ? [outerSpec, { param: n.param, bindings: n.paramBindings, index: n.index }] : void 0;
         const template = n.children.map((c) => irToPlaceholderTemplate(c, void 0, emitDepth, loopParamsForTemplate)).join("");
-        const refsOuter = outerLoopParam ? identifierPattern(outerLoopParam).test(n.array) : false;
         const bindings = emptyLoopChildBindings();
         const innerPreambleNames = preambleNamesOf(n);
         if (ctx2) {
           for (const child of n.children) {
-            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, n.param, n.paramBindings, true, innerPreambleNames, n.index));
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, n.param, n.paramBindings, true, innerPreambleNames, n.index));
+            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx2, n.param, n.paramBindings, true, innerPreambleNames, n.index, scope.bindingScope));
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx2, n.param, n.paramBindings, true, innerPreambleNames, n.index, scope.bindingScope));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
           bindings.conditionals.push(...collectLoopChildConditionals(
@@ -15904,7 +15946,13 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
             n.param,
             n.paramBindings,
             innerPreambleNames,
-            n.index
+            n.index,
+            // Render a branch's HTML against the FULL ancestor chain (outer
+            // loop(s) + this loop's own param), not just this loop's own
+            // param — an inner-loop conditional arm can read an outer
+            // loop's item/index too (#2868).
+            loopParamsForTemplate,
+            scope.bindingScope
           ));
         }
         let childComponents;
@@ -15947,14 +15995,17 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
           containerSlotId: scope.parentSlotId,
           template,
           preamble: n.preamble,
-          refsOuterParam: refsOuter,
           childComponents,
           insideConditional: !flat && scope.insideCond ? true : void 0,
           offset: flat ? void 0 : resolveLoopOffset(siblingOffsets.get(n)),
           bindings
         });
         if (!flat) {
-          descend({ ...scope, depth: scope.depth + 1 });
+          descend({
+            ...scope,
+            depth: scope.depth + 1,
+            bindingScope: buildLoopRowScope(n.param, n.paramBindings, innerPreambleNames, n.index, scope.bindingScope)
+          });
         }
       }
       // fragment / provider / async auto-descend with the same scope.
@@ -15964,7 +16015,12 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx2, options2
 }
 function decideLoopRendering(loop, siblingOffsets, ctx2) {
   const hasNestedComps = (loop.nestedComponents?.length ?? 0) > 0;
-  const innerLoops = collectInnerLoops(loop.children, siblingOffsets, loop.param, ctx2);
+  const innerLoops = collectInnerLoops(
+    loop.children,
+    siblingOffsets,
+    { param: loop.param, bindings: loop.paramBindings, index: loop.index },
+    ctx2
+  );
   const hasInnerLoops = (innerLoops?.length ?? 0) > 0;
   const useElementReconciliation = !loop.childComponent && !loop.isStaticArray && (hasNestedComps || hasInnerLoops);
   return { useElementReconciliation, innerLoops };
@@ -16117,6 +16173,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
       }
       const { useElementReconciliation, innerLoops } = projectionInner ? { useElementReconciliation: false, innerLoops: void 0 } : decideLoopRendering(l, siblingOffsets, ctx2);
       let template = "";
+      let templateIndexed;
       let staticItemTemplate;
       let skeletonTemplate;
       let skeletonPaths;
@@ -16128,6 +16185,10 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
       } else if (l.children[0] && !projectionInner) {
         const loopParamSpec = [{ param: l.param, bindings: l.paramBindings }];
         template = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx2), 0, loopParamSpec) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx2), 0, loopParamSpec);
+        if (l.index) {
+          const loopParamSpecIndexed = [{ param: l.param, bindings: l.paramBindings, index: l.index }];
+          templateIndexed = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx2), 0, loopParamSpecIndexed) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx2), 0, loopParamSpecIndexed);
+        }
         if (l.isStaticArray) {
           staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx2), 0) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx2), 0);
         } else if (!useElementReconciliation && !l.bodyIsMultiRoot && !l.bodyIsItemConditional) {
@@ -16156,6 +16217,7 @@ function collectElements(node, ctx2, siblingOffsets, insideConditional = false)
         iterationShape: l.iterationShape,
         objectIteration: l.objectIteration,
         template,
+        templateIndexed,
         staticItemTemplate,
         skeletonTemplate,
         skeletonPaths,
@@ -16344,6 +16406,7 @@ function collectBranchLoops(node, ctx2, siblingOffsets) {
       const projectionInner = n.method === "flatMap" && n.children.length === 1 && n.children[0].type === "loop" ? n.children[0] : void 0;
       const { useElementReconciliation, innerLoops: innerLoopsCollected } = projectionInner ? { useElementReconciliation: false, innerLoops: void 0 } : decideLoopRendering(n, siblingOffsets, void 0);
       let childTemplate;
+      let childTemplateIndexed;
       const branchLoopParamSpec = [{ param: n.param, bindings: n.paramBindings }];
       if (projectionInner) {
         childTemplate = "";
@@ -16352,6 +16415,10 @@ function collectBranchLoops(node, ctx2, siblingOffsets) {
       } else {
         childTemplate = n.children.map((c) => irToHtmlTemplate(c, void 0, 0, branchLoopParamSpec)).join("");
       }
+      if (n.index && !projectionInner) {
+        const branchLoopParamSpecIndexed = [{ param: n.param, bindings: n.paramBindings, index: n.index }];
+        childTemplateIndexed = useElementReconciliation && n.children[0] ? irToPlaceholderTemplate(n.children[0], restNames, 0, branchLoopParamSpecIndexed) : n.children.map((c) => irToHtmlTemplate(c, void 0, 0, branchLoopParamSpecIndexed)).join("");
+      }
       const branchBindings = ctx2 && !projectionInner ? collectLoopChildBindings(n.children, ctx2, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n), n.index) : emptyLoopChildBindings();
       loops.push({
         kind: "branch",
@@ -16367,6 +16434,7 @@ function collectBranchLoops(node, ctx2, siblingOffsets) {
         iterationShape: n.iterationShape,
         objectIteration: n.objectIteration,
         template: childTemplate,
+        templateIndexed: childTemplateIndexed,
         containerSlotId: containerSlot,
         preamble: n.preamble,
         preambleRegions: n.preambleRegions,
@@ -16449,18 +16517,10 @@ function collectLoopChildBindings(children2, ctx2, siblingOffsets, loopParam, lo
   }
   return bindings;
 }
-function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
+function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex, loopParams, parentScope) {
   const conditionals = [];
-  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex);
-  const refsAnyBindingViaFreeIds = (freeIds) => {
-    if (loopParamBindings && loopParamBindings.length > 0) {
-      for (const b of loopParamBindings) {
-        if (freeIds.has(b.name)) return true;
-      }
-      return false;
-    }
-    return loopParam ? freeIds.has(loopParam) : false;
-  };
+  const scope = buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope);
+  const refsAnyBindingViaFreeIds = (freeIds) => scope !== void 0 && anyNameIn(scope.valueBoundNames(), freeIds);
   walkIR(node, null, {
     // element / fragment / component / provider auto-descend with same scope.
     // loop / async / if-statement skipped — nested loops have their own
@@ -16473,8 +16533,8 @@ function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loo
       if (!n.reactive && !refsLoopParamInSource) return;
       const expanded = expandConstantForReactivity(n.condition, ctx2, sourceFreeIds, scope);
       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, index: loopIndex }] : void 0;
+      if (!readsPreamble && classifyReactivity(expanded.expr, ctx2, scope, expanded.freeIds).kind === "none") return;
+      const loopParamsForCond = loopParams ?? (loopParam ? [{ param: loopParam, bindings: loopParamBindings, index: loopIndex }] : void 0);
       const whenTrueHtml = irToHtmlTemplate(n.whenTrue, void 0, 0, loopParamsForCond, "__slots");
       const whenFalseHtml = irToHtmlTemplate(n.whenFalse, void 0, 0, loopParamsForCond, "__slots");
       conditionals.push({
@@ -16492,7 +16552,13 @@ function collectLoopChildConditionals(node, ctx2, siblingOffsets, loopParam, loo
   return conditionals;
 }
 function summarizeLoopChildBranch(node, ctx2, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
-  const inner = collectInnerLoops([node], siblingOffsets, loopParam, ctx2, branchInnerLoopOptions);
+  const inner = collectInnerLoops(
+    [node],
+    siblingOffsets,
+    loopParam ? { param: loopParam, bindings: loopParamBindings, index: loopIndex } : void 0,
+    ctx2,
+    branchInnerLoopOptions
+  );
   return {
     childComponents: collectConditionalBranchChildComponents(node),
     innerLoops: inner.length > 0 ? inner : void 0,
@@ -16567,7 +16633,6 @@ var init_collect_elements = __esm({
     init_csr_substitute();
     init_walker();
     init_loop_chain();
-    init_identifier_pattern();
     init_src();
     EMPTY_RENDER_EXPRS = /* @__PURE__ */ new Set(["null", "undefined", "false", "''", '""', "``"]);
     branchInnerLoopOptions = {
@@ -19825,13 +19890,14 @@ function buildBranchInnerLoopsPlan(args2) {
     condSlotId,
     outerLoopParam,
     outerLoopParamBindings,
+    outerLoopIndex,
     wrapOuter
   } = args2;
   if (!innerLoops || innerLoops.length === 0) return [];
   const plan = [];
   for (let i = 0; i < innerLoops.length; i++) {
     const inner = innerLoops[i];
-    if (!inner.refsOuterParam || !inner.template) continue;
+    if (!inner.template) continue;
     const wrapInner = (expr) => wrapLoopParamAsAccessor(expr, inner.param, inner.paramBindings, inner.index);
     const wrapBoth = (expr) => wrapLoopParamAsAccessor(wrapOuter(expr), inner.param, inner.paramBindings, inner.index);
     const csl = inner.containerSlotId;
@@ -19901,18 +19967,20 @@ function buildBranchInnerLoopsPlan(args2) {
         scopeVar: `__belbr_${i}`,
         wrap: wrapBoth,
         loopParam: inner.param,
-        loopParamBindings: inner.paramBindings
+        loopParamBindings: inner.paramBindings,
+        loopIndex: inner.index
       }),
       innerLoopParam: inner.param,
       innerLoopParamBindings: inner.paramBindings,
       outerLoopParam,
-      outerLoopParamBindings
+      outerLoopParamBindings,
+      outerLoopIndex
     });
   }
   return plan;
 }
 function buildLoopChildConditionalsPlan(args2) {
-  const { conditionals, scopeVar, wrap, loopParam, loopParamBindings } = args2;
+  const { conditionals, scopeVar, wrap, loopParam, loopParamBindings, loopIndex } = args2;
   if (!conditionals || conditionals.length === 0) return [];
   const plans = [];
   for (const cond of conditionals) {
@@ -19920,13 +19988,20 @@ function buildLoopChildConditionalsPlan(args2) {
       slotId: cond.slotId,
       scopeVar,
       wrappedCondition: wrap(cond.condition),
-      whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
-      whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
+      // whenTrueHtml/whenFalseHtml are already loop-param-wrapped for the
+      // full ancestor chain at IR render time (`irToHtmlTemplate`'s
+      // `loopParams`, collect-elements.ts) — do NOT re-wrap the rendered
+      // HTML string here (#2868: a word-boundary regex over assembled
+      // markup can match a bare tag name colliding with the param/index
+      // identifier, e.g. `<i>` -> `<i()>`).
+      whenTrueTemplateHtml: addCondAttrToTemplate(cond.whenTrueHtml, cond.slotId),
+      whenFalseTemplateHtml: addCondAttrToTemplate(cond.whenFalseHtml, cond.slotId),
       whenTrueArm: buildLoopChildArmPlan({
         branch: cond.whenTrue,
         wrap,
         loopParam,
         loopParamBindings,
+        loopIndex,
         condId: cond.slotId
       }),
       whenFalseArm: buildLoopChildArmPlan({
@@ -19934,8 +20009,10 @@ function buildLoopChildConditionalsPlan(args2) {
         wrap,
         loopParam,
         loopParamBindings,
+        loopIndex,
         condId: cond.slotId
-      })
+      }),
+      ...cond.readsPreamble && { readsPreamble: true }
     });
   }
   return plans;
@@ -19958,7 +20035,8 @@ function buildArmAttrsPlan(attrs, wrap) {
       attrs: slotAttrs.map((attr) => ({
         attrName: attr.attrName,
         wrappedExpression: wrap(attr.expression),
-        meta: pickAttrMeta(attr)
+        meta: pickAttrMeta(attr),
+        ...attr.readsPreamble && { readsPreamble: true }
       }))
     });
   }
@@ -19972,7 +20050,7 @@ function buildArmTextsPlan(texts, wrap) {
   }));
 }
 function buildLoopChildArmPlan(args2) {
-  const { branch, wrap, loopParam, loopParamBindings, condId } = args2;
+  const { branch, wrap, loopParam, loopParamBindings, loopIndex, condId } = args2;
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
@@ -19988,6 +20066,7 @@ function buildLoopChildArmPlan(args2) {
       condSlotId: condId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -19995,7 +20074,8 @@ function buildLoopChildArmPlan(args2) {
       scopeVar: "__branchScope",
       wrap,
       loopParam,
-      loopParamBindings
+      loopParamBindings,
+      loopIndex
     }),
     attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
     texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
@@ -20047,10 +20127,17 @@ function buildReactiveEffectsPlan(args2) {
       conditionalPlans.push({
         slotId: cond.slotId,
         wrappedCondition: wrap(cond.condition),
-        whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
-        whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
-        whenTrueArm: buildOuterArm(cond.whenTrue, wrap, loopParam, loopParamBindings, cond.slotId, profileComponentName),
-        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, cond.slotId, profileComponentName),
+        // whenTrueHtml/whenFalseHtml are already loop-param-wrapped at IR
+        // render time (`irToHtmlTemplate`'s `loopParams`, collect-elements.ts)
+        // — do NOT re-wrap the rendered HTML string here. A word-boundary
+        // regex over already-assembled markup matches a bare tag name that
+        // collides with the param/index identifier (`<i>` -> `<i()>`) just
+        // as readily as a real reference, since `<`/`>` are non-word
+        // characters (#2868).
+        whenTrueTemplateHtml: addCondAttrToTemplate(cond.whenTrueHtml, cond.slotId),
+        whenFalseTemplateHtml: addCondAttrToTemplate(cond.whenFalseHtml, cond.slotId),
+        whenTrueArm: buildOuterArm(cond.whenTrue, wrap, loopParam, loopParamBindings, loopIndex, cond.slotId, profileComponentName),
+        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, loopIndex, cond.slotId, profileComponentName),
         ...cond.readsPreamble && { readsPreamble: true }
       });
     }
@@ -20062,7 +20149,7 @@ function buildReactiveEffectsPlan(args2) {
     profileComponentName
   };
 }
-function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, profileComponentName) {
+function buildOuterArm(branch, wrap, loopParam, loopParamBindings, loopIndex, condSlotId, profileComponentName) {
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
@@ -20079,6 +20166,7 @@ function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, p
       condSlotId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -20086,7 +20174,8 @@ function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, p
       scopeVar: "__branchScope",
       wrap,
       loopParam,
-      loopParamBindings
+      loopParamBindings,
+      loopIndex
     }),
     attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
     texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
@@ -20135,8 +20224,8 @@ function wrapAttrValueExpression2(value2, wrap) {
   }
 }
 function buildInnerLoopsPlan(args2) {
-  const { levels, parentElVar, outerLoopParam, outerLoopParamBindings } = args2;
-  const wrapOuter = outerLoopParam ? (expr) => wrapLoopParamAsAccessor(expr, outerLoopParam, outerLoopParamBindings) : (expr) => expr;
+  const { levels, parentElVar, outerLoopParam, outerLoopParamBindings, outerLoopIndex } = args2;
+  const wrapOuter = outerLoopParam ? (expr) => wrapLoopParamAsAccessor(expr, outerLoopParam, outerLoopParamBindings, outerLoopIndex) : (expr) => expr;
   const plan = [];
   let i = 0;
   while (i < levels.length) {
@@ -20158,15 +20247,14 @@ function buildInnerLoopsPlan(args2) {
     }
     const uidSuffix = `${inner.depth}_${i}`;
     const containerExpr = inner.containerSlotId ? `qsa(${parentElVar}, '[bf="${inner.containerSlotId}"]')` : parentElVar;
-    const refsParent = !!outerLoopParam && (inner.arrayFreeIdentifiers?.has(outerLoopParam) ?? false);
-    const useReactive = refsParent && !!inner.template;
-    const emit = useReactive ? buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings) : buildStaticEmit(inner, level, uidSuffix);
-    const arrayExpr = useReactive ? wrapOuter(inner.array) : inner.array;
+    const emit = buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings, outerLoopIndex);
+    const arrayExpr = wrapOuter(inner.array);
     const childLevelsPlan = childLevels.length > 0 ? buildInnerLoopsPlan({
       levels: childLevels,
       parentElVar: `__innerEl${uidSuffix}`,
       outerLoopParam: inner.param,
-      outerLoopParamBindings: inner.paramBindings
+      outerLoopParamBindings: inner.paramBindings,
+      outerLoopIndex: inner.index
     }) : [];
     plan.push({
       uidSuffix,
@@ -20181,13 +20269,14 @@ function buildInnerLoopsPlan(args2) {
       emit,
       childLevels: childLevelsPlan,
       outerLoopParam,
-      outerLoopParamBindings
+      outerLoopParamBindings,
+      outerLoopIndex
     });
     i = j;
   }
   return plan;
 }
-function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings) {
+function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, outerLoopParamBindings, outerLoopIndex) {
   const wrapInner = (expr) => wrapLoopParamAsAccessor(expr, inner.param, inner.paramBindings, inner.index);
   const wrapBoth = (expr) => wrapLoopParamAsAccessor(wrapOuter(expr), inner.param, inner.paramBindings, inner.index);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(inner.param, inner.paramBindings);
@@ -20240,7 +20329,7 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
   if (paramUnwrap) preludeStatements.push(paramUnwrap);
   if (inner.preamble) {
     const leafLoopParams = outerLoopParam ? [
-      { param: outerLoopParam, bindings: outerLoopParamBindings },
+      { param: outerLoopParam, bindings: outerLoopParamBindings, index: outerLoopIndex },
       { param: inner.param, bindings: inner.paramBindings, index: inner.index }
     ] : [{ param: inner.param, bindings: inner.paramBindings, index: inner.index }];
     preludeStatements.push(renderPreamble(inner.preamble, {
@@ -20254,7 +20343,8 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
     scopeVar: `__innerEl${uidSuffix}`,
     wrap: wrapBoth,
     loopParam: inner.param,
-    loopParamBindings: inner.paramBindings
+    loopParamBindings: inner.paramBindings,
+    loopIndex: inner.index
   });
   return {
     mode: "reactive",
@@ -20272,24 +20362,6 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
     childRefs
   };
 }
-function buildStaticEmit(inner, level, uidSuffix) {
-  const preludeStatements = [];
-  const indexAlias = nestedLoopIndexAlias(inner, `__innerIdx${uidSuffix}`, inner.param, level.comps, level.events);
-  if (indexAlias) preludeStatements.push(indexAlias);
-  if (inner.preamble) {
-    preludeStatements.push(renderPreamble(inner.preamble, {
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, void 0, void 0)
-    }));
-  }
-  return {
-    mode: "static",
-    rawKey: inner.key ?? null,
-    preludeStatements,
-    components: level.comps,
-    events: level.events,
-    childRefs: buildStaticChildRefBindings(inner.bindings.refs)
-  };
-}
 var init_build_inner_loop = __esm({
   "../jsx/src/ir-to-client-js/control-flow/plan/build-inner-loop.ts"() {
     "use strict";
@@ -20331,7 +20403,8 @@ function buildTopLevelCompositePlan(elem, profileComponentName) {
       levels: depthLevels,
       parentElVar: "__el",
       outerLoopParam: elem.param,
-      outerLoopParamBindings: elem.paramBindings
+      outerLoopParamBindings: elem.paramBindings,
+      outerLoopIndex: elem.index
     }),
     loopParam: elem.param,
     loopParamBindings: elem.paramBindings,
@@ -20386,7 +20459,8 @@ function buildBranchCompositePlan(loop, cv, profileComponentName) {
       levels: depthLevels,
       parentElVar: "__el",
       outerLoopParam: loop.param,
-      outerLoopParamBindings: loop.paramBindings
+      outerLoopParamBindings: loop.paramBindings,
+      outerLoopIndex: loop.index
     }),
     loopParam: loop.param,
     loopParamBindings: loop.paramBindings,
@@ -20924,8 +20998,8 @@ function decideLazyRow(args2) {
   let conditionalRefusal = null;
   for (const cond of rawConditionals) {
     const verdict = analyzeLazyConditional(cond, {
-      whenTrueHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
-      whenFalseHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId)
+      whenTrueHtml: addCondAttrToTemplate(cond.whenTrueHtml, cond.slotId),
+      whenFalseHtml: addCondAttrToTemplate(cond.whenFalseHtml, cond.slotId)
     });
     if (!verdict.lazySafe) {
       conditionalRefusal = verdict.reason;
@@ -21162,7 +21236,7 @@ function buildPlainRowCore(inputs) {
     scope
   }) ?? void 0;
   const mapPreambleWrappedFinal = !lazyRow && loop.index ? wrapIndexParamAsAccessor(mapPreambleWrapped, loop.index) : mapPreambleWrapped;
-  const templateFinal = !lazyRow && loop.index ? wrapIndexParamAsAccessor(loop.template, loop.index) : loop.template;
+  const templateFinal = !lazyRow && loop.index ? loop.templateIndexed ?? loop.template : loop.template;
   return {
     indexParam,
     paramHead,
@@ -21396,6 +21470,22 @@ function emitAttrUpdate(target2, attrName, expression, meta) {
     `{ const __v = ${expression}; if (__v != null) ${target2}.setAttribute('${htmlName}', String(__v)); else ${target2}.removeAttribute('${htmlName}') }`
   ];
 }
+function dedupGuard(ordinal) {
+  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
+}
+function emitDedupedAttrUpdate(target2, attrName, expression, meta, ordinal, guard = dedupGuard(ordinal)) {
+  const write = emitAttrUpdate(target2, attrName, "__x", meta);
+  const lines = [`{ const __x = ${expression}`];
+  if (guard) {
+    lines.push(`if (${guard}) {`);
+    for (const stmt of write) lines.push(`  ${stmt}`);
+    lines.push(`}`);
+  } else {
+    lines.push(...write);
+  }
+  lines.push(`__l[${ordinal}] = __x }`);
+  return lines;
+}
 function rewriteDestructuredPropsInExpr(expr, ctx2) {
   if (ctx2.propsObjectName) return expr;
   const propNames = /* @__PURE__ */ new Set();
@@ -21598,16 +21688,18 @@ function emitReactiveAttributeUpdates(lines, ctx2) {
     }
     for (const [slotId, attrs] of attrsBySlot) {
       const v = varSlotId(slotId);
+      lines.push(`  { ${DEDUP_STORE_DECL}`);
       lines.push(`  createEffect(() => {`);
       lines.push(`    if (_${v}) {`);
+      let ordinal = 0;
       for (const attr of attrs) {
         const expression = rewriteDestructuredPropsInExpr(lower(attr.expression), ctx2);
-        for (const stmt of emitAttrUpdate(`_${v}`, attr.attrName, expression, attr)) {
+        for (const stmt of emitDedupedAttrUpdate(`_${v}`, attr.attrName, expression, attr, ordinal++)) {
           lines.push(`      ${stmt}`);
         }
       }
       lines.push(`    }`);
-      lines.push(`  }${bindingIdArg(ctx2, slotId)})`);
+      lines.push(`  }${bindingIdArg(ctx2, slotId)}) }`);
       lines.push("");
     }
   }
@@ -21659,6 +21751,7 @@ function emitReactiveChildProps(lines, ctx2) {
   if (ctx2.reactiveChildProps.length > 0) {
     lines.push("");
     lines.push(`  // Reactive child component props`);
+    lines.push(`  { ${DEDUP_STORE_DECL}`);
     lines.push(`  createEffect(() => {`);
     const propsByComponent = /* @__PURE__ */ new Map();
     for (const prop of ctx2.reactiveChildProps) {
@@ -21668,6 +21761,7 @@ function emitReactiveChildProps(lines, ctx2) {
       }
       propsByComponent.get(key).push(prop);
     }
+    let ordinal = 0;
     for (const [, props] of propsByComponent) {
       const first = props[0];
       const isCommentRoot = first.slotId !== null && first.slotId === ctx2.commentScopeRootSlotId;
@@ -21679,16 +21773,17 @@ function emitReactiveChildProps(lines, ctx2) {
       }
       lines.push(`    if (${varName}) {`);
       for (const prop of props) {
-        const stmts = toHTMLAttrName(prop.attrName) === "value" ? emitChildValueMirrorStatements(varName, prop.expression) : emitAttrUpdate(varName, prop.attrName, prop.expression, prop);
+        const stmts = toHTMLAttrName(prop.attrName) === "value" ? emitChildValueMirrorStatements(varName, prop.expression) : emitDedupedAttrUpdate(varName, prop.attrName, prop.expression, prop, ordinal++);
         for (const stmt of stmts) {
           lines.push(`      ${stmt}`);
         }
       }
       lines.push(`    }`);
     }
-    lines.push(`  }${bindingIdArg(ctx2, ctx2.reactiveChildProps[0]?.slotId ?? void 0)})`);
+    lines.push(`  }${bindingIdArg(ctx2, ctx2.reactiveChildProps[0]?.slotId ?? void 0)}) }`);
   }
 }
+var DEDUP_STORE_DECL;
 var init_emit_reactive = __esm({
   "../jsx/src/ir-to-client-js/emit-reactive.ts"() {
     "use strict";
@@ -21701,18 +21796,24 @@ var init_emit_reactive = __esm({
     init_to_locale_date_lowering();
     init_expression_parser();
     init_prop_rewrite();
+    DEDUP_STORE_DECL = "const __l = []";
   }
 });
 // ../jsx/src/ir-to-client-js/control-flow/stringify/loop-child-arm.ts
-function stringifyBranchReactiveAttrs(lines, plan, indent, pc) {
+function stringifyBranchReactiveAttrs(lines, plan, indent, pc, mapPreambleWrapped) {
   for (const slot of plan) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}{ const ${varName} = qsa(__branchScope, '[bf="${slot.slotId}"]')`);
+    lines.push(`${indent}${DEDUP_STORE_DECL}`);
     lines.push(`${indent}if (${varName}) {`);
+    let ordinal = 0;
     for (const attr of slot.attrs) {
       lines.push(`${indent}  __disposers.push(createDisposableEffect(() => {`);
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+      if (attr.readsPreamble && mapPreambleWrapped) {
+        lines.push(`${indent}    ${mapPreambleWrapped}`);
+      }
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
         lines.push(`${indent}    ${stmt}`);
       }
       lines.push(`${indent}  }${profileBindingId(pc, slot.slotId)}))`);
@@ -21762,7 +21863,9 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
         [...inner.legacyComponents],
         [...inner.legacyEvents],
         inner.outerLoopParam,
-        inner.outerLoopParamBindings
+        inner.outerLoopParamBindings,
+        false,
+        inner.outerLoopIndex
       );
     }
     const conditionalTexts = inner.reactiveTexts.filter((t) => t.insideConditional);
@@ -21780,42 +21883,45 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       }
     }
     if (inner.nestedConditionals.length > 0) {
-      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc);
+      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc, void 0);
     }
     lines.push(`${indent}  return __bel${uid}`);
     lines.push(`${indent}}, '${inner.markerId}'${mapArrayKeyArgs(profileBindingId(pc, inner.slotId), !!inner.wrappedKey, inner.keyDepth)}) }`);
   }
 }
-function stringifyLoopChildConditionals(lines, conditionals, indent, pc) {
+function stringifyLoopChildConditionals(lines, conditionals, indent, pc, mapPreambleWrapped) {
   for (const cond of conditionals) {
-    stringifyLoopChildConditional(lines, cond, indent, pc);
+    stringifyLoopChildConditional(lines, cond, indent, pc, mapPreambleWrapped);
   }
 }
-function stringifyLoopChildConditional(lines, cond, indent, pc) {
+function conditionGetterExpr(wrappedCondition, readsPreamble, mapPreambleWrapped) {
+  return readsPreamble && mapPreambleWrapped ? `() => { ${mapPreambleWrapped}; return (${wrappedCondition}) }` : `() => ${wrappedCondition}`;
+}
+function stringifyLoopChildConditional(lines, cond, indent, pc, mapPreambleWrapped) {
   const armIndent = `${indent}    `;
-  lines.push(`${indent}insert(${cond.scopeVar}, '${cond.slotId}', () => ${cond.wrappedCondition}, {`);
+  lines.push(`${indent}insert(${cond.scopeVar}, '${cond.slotId}', ${conditionGetterExpr(cond.wrappedCondition, cond.readsPreamble, mapPreambleWrapped)}, {`);
   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);
+  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenFalseTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`);
 }
-function stringifyLoopChildArm(lines, arm, armIndent, pc) {
+function stringifyLoopChildArm(lines, arm, armIndent, pc, mapPreambleWrapped) {
   stringifyBranchEventBindings(lines, arm.events, armIndent);
   stringifyBranchChildComponentInits(lines, arm.childComponents, armIndent);
   stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent, pc);
   const hasDisposables = arm.attrs.length > 0 || arm.texts.length > 0 || arm.nestedConditionals.length > 0;
   if (!hasDisposables) return;
   lines.push(`${armIndent}const __disposers = []`);
-  stringifyBranchReactiveAttrs(lines, arm.attrs, armIndent, pc);
+  stringifyBranchReactiveAttrs(lines, arm.attrs, armIndent, pc, mapPreambleWrapped);
   for (const cond of arm.nestedConditionals) {
     lines.push(`${armIndent}__disposers.push(createDisposableEffect(() => {`);
-    stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc);
+    stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc, mapPreambleWrapped);
     lines.push(`${armIndent}}))`);
   }
   if (arm.texts.length > 0) {
@@ -21877,13 +21983,15 @@ function emitAttrSlotsGranular(lines, indent, elVar, lookup, attrSlots, elementI
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     const lookupExpr = attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot);
     lines.push(`${indent}{ const ${varName} = ${lookupExpr}`);
+    lines.push(`${indent}${DEDUP_STORE_DECL}`);
     lines.push(`${indent}if (${varName}) {`);
+    let ordinal = 0;
     for (const attr of slot.attrs) {
       lines.push(`${indent}  createEffect(() => {`);
       if (attr.readsPreamble && mapPreambleWrapped) {
         lines.push(`${indent}    ${mapPreambleWrapped}`);
       }
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
         lines.push(`${indent}    ${stmt}`);
       }
       lines.push(`${indent}  }${bindingBfId(slot.slotId)})`);
@@ -21916,6 +22024,7 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}const ${varName} = ${attrLookupExpr(slot.slotId, varName, elVar, lookup, elementIndexBySlot)}`);
   }
+  if (attrSlots.length > 0) lines.push(`${indent}${DEDUP_STORE_DECL}`);
   const claimSlots = [
     ...outerTexts.map((t) => ({ id: t.slotId, kind: "text", path: [], pathExpr: textClaimPathExprs?.get(t.slotId) })),
     ...preambleRegions.map((r2) => ({ id: r2.slotId, kind: "markup", path: [] }))
@@ -21933,15 +22042,14 @@ function emitConsolidatedRowEffect(lines, indent, elVar, lookup, attrSlots, oute
   if (mapPreambleWrapped && (preambleRegions.length > 0 || attrsReadPreamble(attrSlots))) {
     lines.push(`${indent}  ${mapPreambleWrapped}`);
   }
+  let ordinal = 0;
   for (const slot of attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}  if (${varName}) {`);
     for (const attr of slot.attrs) {
-      lines.push(`${indent}    {`);
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
-        lines.push(`${indent}      ${stmt}`);
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta, ordinal++)) {
+        lines.push(`${indent}    ${stmt}`);
       }
-      lines.push(`${indent}    }`);
     }
     lines.push(`${indent}  }`);
   }
@@ -21969,16 +22077,16 @@ function emitOuterTexts(lines, indent, elVar, texts, bindingBfId, textClaimPathE
 }
 function emitOuterConditional(lines, indent, elVar, cond, pc, mapPreambleWrapped) {
   const armIndent = `${indent}    `;
-  const conditionGetter = cond.readsPreamble && mapPreambleWrapped ? `() => { ${mapPreambleWrapped}; return (${cond.wrappedCondition}) }` : `() => ${cond.wrappedCondition}`;
+  const conditionGetter = conditionGetterExpr(cond.wrappedCondition, cond.readsPreamble, mapPreambleWrapped);
   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);
+  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenFalseTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc, mapPreambleWrapped);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`);
 }
@@ -22244,22 +22352,14 @@ function emitConditional(lines, ind, mid, c, mode2) {
   lines.push(`${ind}  __l[${c.ordinal}] = __x`);
   lines.push(`${ind}} }`);
 }
-function dedupGuard(ordinal) {
-  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
-}
 function emitAttrBinding(lines, ind, a, mode2) {
   const target2 = mode2 === "create" ? `__r[${a.refIndex}]` : elementAccess(a);
+  const guard = mode2 === "create" ? null : mode2 === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
   lines.push(`${ind}{ const __t = ${target2}`);
   lines.push(`${ind}if (__t) {`);
-  lines.push(`${ind}  const __x = ${a.wrappedExpression}`);
-  const guard = mode2 === "create" ? null : mode2 === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
-  const writeIndent = guard ? `${ind}    ` : `${ind}  `;
-  if (guard) lines.push(`${ind}  if (${guard}) {`);
-  for (const stmt of emitAttrUpdate("__t", a.attrName, "__x", a.meta)) {
-    lines.push(`${writeIndent}${stmt}`);
+  for (const stmt of emitDedupedAttrUpdate("__t", a.attrName, a.wrappedExpression, a.meta, a.ordinal, guard)) {
+    lines.push(`${ind}  ${stmt}`);
   }
-  if (guard) lines.push(`${ind}  }`);
-  lines.push(`${ind}  __l[${a.ordinal}] = __x`);
   lines.push(`${ind}} }`);
 }
 function emitTextBinding(lines, ind, t, doorExpr, mode2, rwDoor) {
@@ -22546,13 +22646,15 @@ function stringifyStaticLoop(lines, plan) {
     lines.push(`      }`);
   }
   lines.push(`      if (__iterEl) {`);
+  if (attrsBySlot.length > 0) lines.push(`        ${DEDUP_STORE_DECL}`);
+  let ordinal = 0;
   for (const [slotId, attrs] of attrsBySlot) {
     const varName = `__t_${varSlotId(slotId)}`;
     lines.push(`        const ${varName} = qsa(__iterEl, '[bf="${slotId}"]')`);
     lines.push(`        if (${varName}) {`);
     for (const attr of attrs) {
       lines.push(`          createEffect(() => {`);
-      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.expression, attr)) {
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.expression, attr, ordinal++)) {
         lines.push(`            ${stmt}`);
       }
       lines.push(`          }${profileBindingId(pc, slotId)})`);
@@ -22591,17 +22693,12 @@ var init_loop = __esm({
 // ../jsx/src/ir-to-client-js/control-flow/stringify/inner-loop.ts
 function stringifyInnerLoops(lines, plan, indent, pc) {
   for (const inner of plan) {
-    if (inner.emit.mode === "reactive") {
-      emitReactive(lines, inner, indent, pc);
-    } else {
-      emitStatic(lines, inner, indent, pc);
-    }
+    emitReactive(lines, inner, indent, pc);
   }
 }
 function emitReactive(lines, inner, indent, pc) {
   const uid = inner.uidSuffix;
   const emit = inner.emit;
-  if (emit.mode !== "reactive") return;
   lines.push(`${indent}// Reactive inner loop: ${inner.arraySrc}`);
   lines.push(`${indent}{ const __ic${uid} = ${inner.containerExpr}`);
   lines.push(`${indent}if (__ic${uid}) mapArray(() => ${inner.arrayExpr} || [], __ic${uid}, ${emit.keyFn}, (${emit.paramHead}, __innerIdx${uid}, __existing) => {`);
@@ -22633,7 +22730,9 @@ function emitReactive(lines, inner, indent, pc) {
       [...emit.components],
       [...emit.events],
       inner.outerLoopParam,
-      inner.outerLoopParamBindings
+      inner.outerLoopParamBindings,
+      false,
+      inner.outerLoopIndex
     );
   }
   if (inner.childLevels.length > 0) {
@@ -22653,17 +22752,19 @@ function emitReactive(lines, inner, indent, pc) {
       lines.push(`${indent}  createEffect(() => { ${writer}('${text.slotId}', String(${text.wrappedExpression})) }${profileBindingId(pc, text.slotId)})`);
     }
   }
+  if (emit.reactiveAttrs.length > 0) lines.push(`${indent}  ${DEDUP_STORE_DECL}`);
+  let attrOrdinal = 0;
   for (const attr of emit.reactiveAttrs) {
     const targetVar = `__ta_${attr.slotId.replace(/[^a-zA-Z0-9]/g, "_")}`;
     lines.push(`${indent}  { const ${targetVar} = qsa(__innerEl${uid}, '[bf="${attr.slotId}"]')`);
     lines.push(`${indent}  if (${targetVar}) createEffect(() => {`);
-    for (const stmt of emitAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta)) {
+    for (const stmt of emitDedupedAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta, attrOrdinal++)) {
       lines.push(`${indent}    ${stmt}`);
     }
     lines.push(`${indent}  }${profileBindingId(pc, attr.slotId)}) }`);
   }
   if (emit.conditionals.length > 0) {
-    stringifyLoopChildConditionals(lines, emit.conditionals, `${indent}  `, pc);
+    stringifyLoopChildConditionals(lines, emit.conditionals, `${indent}  `, pc, void 0);
   }
   emitLoopChildRefs(lines, emit.childRefs, {
     indent: `${indent}  `,
@@ -22673,40 +22774,6 @@ function emitReactive(lines, inner, indent, pc) {
   lines.push(`${indent}  return __innerEl${uid}`);
   lines.push(`${indent}}, '${inner.markerId}'${mapArrayKeyArgs(profileBindingId(pc, inner.slotId), !!emit.wrappedKey, inner.keyDepth)}) }`);
 }
-function emitStatic(lines, inner, indent, pc) {
-  const uid = inner.uidSuffix;
-  const emit = inner.emit;
-  if (emit.mode !== "static") return;
-  lines.push(`${indent}// Initialize ${inner.arraySrc} loop components and events`);
-  lines.push(`${indent}{ const __ic${uid} = ${inner.containerExpr}`);
-  lines.push(`${indent}if (__ic${uid} && ${inner.arrayExpr}) ${inner.arrayExpr}.forEach((${inner.param}, __innerIdx${uid}) => {`);
-  lines.push(`${indent}  const __innerEl${uid} = __ic${uid}.children[__innerIdx${uid}]`);
-  lines.push(`${indent}  if (!__innerEl${uid}) return`);
-  for (const stmt of emit.preludeStatements) {
-    lines.push(`${indent}  ${stmt}`);
-  }
-  if (emit.rawKey) {
-    lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName2(inner.keyDepth)}', String(${emit.rawKey}))`);
-  }
-  emitComponentAndEventSetup(
-    lines,
-    `${indent}  `,
-    `__innerEl${uid}`,
-    [...emit.components],
-    [...emit.events],
-    inner.outerLoopParam,
-    inner.outerLoopParamBindings
-  );
-  if (inner.childLevels.length > 0) {
-    stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc);
-  }
-  emitLoopChildRefs(lines, emit.childRefs, {
-    indent: `${indent}  `,
-    elVar: `__innerEl${uid}`,
-    bodyIsMultiRoot: false
-  });
-  lines.push(`${indent}}) }`);
-}
 var init_inner_loop = __esm({
   "../jsx/src/ir-to-client-js/control-flow/stringify/inner-loop.ts"() {
     "use strict";
@@ -23156,10 +23223,12 @@ function emitArmBody(lines, body2, mode2, indent, profileComponentName) {
     const v = varSlotId(slotId);
     const elVar = `__ra_${v}`;
     lines.push(`${indent}{ const ${elVar} = qsa(__branchScope, '[bf="${slotId}"]')`);
+    lines.push(`${indent}${DEDUP_STORE_DECL}`);
     lines.push(`${indent}if (${elVar}) {`);
+    let ordinal = 0;
     for (const attr of attrs) {
       lines.push(`${indent}  __disposers.push(createDisposableEffect(() => {`);
-      for (const stmt of emitAttrUpdate(elVar, attr.attrName, attr.expression, attr)) {
+      for (const stmt of emitDedupedAttrUpdate(elVar, attr.attrName, attr.expression, attr, ordinal++)) {
         lines.push(`${indent}    ${stmt}`);
       }
       lines.push(`${indent}  }${bindingBfId(slotId)}))`);