@barefootjs/jsx 0.35.0 → 0.35.2

package/dist/index.js

@@ -180,7 +180,7 @@ function findTopLevelTemplateLiterals(code) {
 import ts25 from "typescript";
 
 // src/analyzer.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 
 // src/expression-parser.ts
 import ts2 from "typescript";
@@ -3966,7 +3966,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}`;
           }
         }
@@ -5151,7 +5151,7 @@ function incrementCounter(key) {
 }
 
 // src/analyzer-context.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // src/strip-types.ts
 import ts8 from "typescript";
@@ -5368,6 +5368,140 @@ function findAngleBracketAfter(lastTypeArg, fullText) {
   return -1;
 }
 
+// src/reactivity-checker.ts
+import ts9 from "typescript";
+var REACTIVE_BRAND = "__reactive";
+function queryType(checker, node) {
+  incrementCounter("typeCheckerQueries");
+  return checker.getTypeAtLocation(node);
+}
+function isReactiveType(type) {
+  return type.getProperty(REACTIVE_BRAND) !== undefined;
+}
+var NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
+function safeGetText(node) {
+  try {
+    return node.getText();
+  } catch {
+    return "";
+  }
+}
+function analyze(node, checker) {
+  if (ts9.isPropertyAccessExpression(node)) {
+    try {
+      const type = queryType(checker, node);
+      if (isReactiveType(type)) {
+        return {
+          isReactive: true,
+          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
+        };
+      }
+    } catch {}
+    const sub = analyze(node.expression, checker);
+    if (sub.isReactive) {
+      return {
+        isReactive: true,
+        reason: {
+          kind: "child",
+          via: "property-access-object",
+          childText: safeGetText(node.expression),
+          childReason: sub.reason
+        }
+      };
+    }
+    return NOT_REACTIVE;
+  }
+  if (ts9.isIdentifier(node)) {
+    try {
+      const type = queryType(checker, node);
+      if (isReactiveType(type)) {
+        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 result = analyze(child, checker);
+    if (result.isReactive) {
+      foundChild = result;
+      foundChildText = safeGetText(child);
+    }
+  });
+  if (foundChild?.isReactive) {
+    return {
+      isReactive: true,
+      reason: {
+        kind: "child",
+        via: "sub-expression",
+        childText: foundChildText,
+        childReason: foundChild.reason
+      }
+    };
+  }
+  return NOT_REACTIVE;
+}
+var brandTypeReactivityAnalyzer = { analyze };
+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 visit = (n) => {
+    if (ts9.isPropertyAccessExpression(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n))) {
+          leaves.push(n);
+          return;
+        }
+      } catch {}
+      visit(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, visit);
+  };
+  visit(node);
+  return leaves;
+}
+
 // src/analyzer-context.ts
 function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
   return {
@@ -5419,7 +5553,7 @@ function createAnalyzerContext(sourceFile, filePath, acceptsCallbackBody) {
       } catch {
         ownSourceFile = undefined;
       }
-      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 — raw JSX must never be spliced " + "into emitted output. Carry mixed content as structured segments " + "(MapCallbackPreamble / FlatMapCallback) instead.");
       }
       if (ownSourceFile && ownSourceFile !== sourceFile) {
@@ -5429,11 +5563,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 start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
   const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
@@ -5450,20 +5579,20 @@ 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",
       raw: "unknown"
     },
     optional: !!member.questionToken,
-    readonly: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword)
+    readonly: !!member.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ReadonlyKeyword)
   }));
 }
 function propertyNameText(name, sourceFile) {
   if (!name)
     return "";
-  if (ts9.isStringLiteral(name) || ts9.isNumericLiteral(name))
+  if (ts10.isStringLiteral(name) || ts10.isNumericLiteral(name))
     return name.text;
   return name.getText(sourceFile);
 }
@@ -5474,56 +5603,56 @@ 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,
       ...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]) };
     }
@@ -5532,7 +5661,7 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
       raw
     };
   }
-  if (ts9.isFunctionTypeNode(typeNode)) {
+  if (ts10.isFunctionTypeNode(typeNode)) {
     if (synthetic)
       return { kind: "function", raw };
     return {
@@ -5552,15 +5681,15 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   }
   return { kind: "unknown", raw };
 }
-var _typePrinter = ts9.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-var _blankTypeSourceFile = ts9.createSourceFile("__bf_types__.ts", "", ts9.ScriptTarget.Latest);
+var _typePrinter = ts10.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+var _blankTypeSourceFile = ts10.createSourceFile("__bf_types__.ts", "", ts10.ScriptTarget.Latest);
 function tsTypeToTypeInfo(type, checker) {
-  const node = checker.typeToTypeNode(type, undefined, ts9.NodeBuilderFlags.NoTruncation);
+  const node = checker.typeToTypeNode(type, undefined, 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";
     }
@@ -5571,16 +5700,16 @@ function isPascalCase(name) {
   return /^[A-Z][a-zA-Z0-9]*$/.test(name);
 }
 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))
+  if (!ts10.isVariableDeclaration(node))
     return false;
-  if (!ts9.isIdentifier(node.name))
+  if (!ts10.isIdentifier(node.name))
     return false;
   if (!isPascalCase(node.name.text))
     return false;
-  if (!node.initializer || !ts9.isArrowFunction(node.initializer))
+  if (!node.initializer || !ts10.isArrowFunction(node.initializer))
     return false;
   return true;
 }
@@ -6226,9 +6355,9 @@ function needsTypeBasedDetection(source) {
 }
 function findBrandPackageImportLoc(sourceFile, filePath) {
   for (const stmt of sourceFile.statements) {
-    if (!ts10.isImportDeclaration(stmt))
+    if (!ts11.isImportDeclaration(stmt))
       continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier))
       continue;
     if (!REACTIVE_BRAND_PACKAGES.includes(stmt.moduleSpecifier.text))
       continue;
@@ -6247,21 +6376,21 @@ function createProgramForFile(source, filePath) {
   try {
     const normalizedPath = path_default.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: path_default.dirname(normalizedPath)
     };
-    const defaultHost = ts10.createCompilerHost(compilerOptions);
+    const defaultHost = ts11.createCompilerHost(compilerOptions);
     const virtualHost = {
       ...defaultHost,
       getSourceFile(fileName, languageVersion) {
         if (path_default.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);
       },
@@ -6276,7 +6405,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;
@@ -6309,7 +6438,7 @@ function analyzeComponent(source, filePath, targetComponentName, program, accept
     }
   }
   if (!sourceFile) {
-    sourceFile = ts10.createSourceFile(filePath, source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+    sourceFile = ts11.createSourceFile(filePath, source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   }
   if (!checker && needsTypeBasedDetection(source)) {
     const result = createProgramForFile(source, filePath);
@@ -6355,23 +6484,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 = 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);
@@ -6381,22 +6510,22 @@ function collectNamedExports(sourceFile) {
   return exported;
 }
 function visit(node, ctx, 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'") {
       ctx.hasUseClientDirective = true;
     }
   }
-  if (ts10.isImportDeclaration(node)) {
+  if (ts11.isImportDeclaration(node)) {
     collectImport(node, ctx);
   }
-  if (ts10.isInterfaceDeclaration(node)) {
+  if (ts11.isInterfaceDeclaration(node)) {
     collectInterfaceDefinition(node, ctx);
   }
-  if (ts10.isTypeAliasDeclaration(node)) {
+  if (ts11.isTypeAliasDeclaration(node)) {
     collectTypeAliasDefinition(node, ctx);
   }
-  if (!ctx.hasUseClientDirective && ts10.isFunctionDeclaration(node) && node.name && node.body && isMultiReturnJsxFunctionBody(node.body)) {
-    const hasInlineExport = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+  if (!ctx.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, ctx, true, false);
@@ -6411,9 +6540,9 @@ function visit(node, ctx, targetComponentName, namedExports) {
       if (!ctx.componentName) {
         ctx.componentName = node.name.text;
         ctx.componentNode = node;
-        ctx.isExported = node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+        ctx.isExported = node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
         analyzeComponentBody(node, ctx);
-        if (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DefaultKeyword)) {
+        if (node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.DefaultKeyword)) {
           ctx.hasDefaultExport = true;
         }
       }
@@ -6427,10 +6556,10 @@ function visit(node, ctx, targetComponentName, namedExports) {
         ctx.componentName = node.name.text;
         ctx.componentNode = node.initializer;
         const parentStatement = node.parent;
-        if (ts10.isVariableDeclarationList(parentStatement)) {
+        if (ts11.isVariableDeclarationList(parentStatement)) {
           const varStatement = parentStatement.parent;
-          if (ts10.isVariableStatement(varStatement)) {
-            ctx.isExported = varStatement.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
+          if (ts11.isVariableStatement(varStatement)) {
+            ctx.isExported = varStatement.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ExportKeyword) ?? false;
           }
         }
         analyzeComponentBody(node.initializer, ctx);
@@ -6442,10 +6571,10 @@ function visit(node, ctx, targetComponentName, namedExports) {
   if (!ctx.componentNode) {
     collectAmbientGlobals(node, ctx);
   }
-  const isDeclareStatement = ts10.isVariableStatement(node) && (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.DeclareKeyword) ?? false);
-  if (ts10.isVariableStatement(node) && !ctx.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) && !ctx.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, ctx.sourceFile);
     for (const decl of node.declarationList.declarations) {
       if (declarationIsReactiveFactoryCall(decl, ctx)) {
@@ -6456,19 +6585,19 @@ function visit(node, ctx, 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, ctx, 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, ctx, 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,
@@ -6496,24 +6625,24 @@ function visit(node, ctx, 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 (ctx.componentName && expr.text === ctx.componentName) {
         ctx.hasDefaultExport = true;
         ctx.isExported = true;
       }
     }
   }
-  ts10.forEachChild(node, (child) => visit(child, ctx, targetComponentName, namedExports));
+  ts11.forEachChild(node, (child) => visit(child, ctx, targetComponentName, namedExports));
 }
 function analyzeComponentBody(node, ctx) {
   if (node.parameters.length > 0) {
     extractProps(node.parameters[0], ctx);
   }
-  const body = ts10.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
+  const body = ts11.isFunctionDeclaration(node) ? node.body : getArrowFunctionBody(node);
   if (body) {
-    ctx.componentBodyBlock = ts10.isBlock(body) ? body : null;
+    ctx.componentBodyBlock = ts11.isBlock(body) ? body : null;
     if (!ctx.componentBodyBlock) {
       ctx.jsxReturn = unwrapJsxTransparent(body);
     }
@@ -6523,14 +6652,14 @@ function analyzeComponentBody(node, ctx) {
   }
 }
 function getArrowFunctionBody(node) {
-  if (ts10.isBlock(node.body)) {
+  if (ts11.isBlock(node.body)) {
     return node.body;
   }
   return node.body;
 }
 function visitComponentBody(node, ctx) {
   const isTopLevel = ctx.componentBodyBlock !== null && node.parent === ctx.componentBodyBlock;
-  if (ts10.isVariableStatement(node)) {
+  if (ts11.isVariableStatement(node)) {
     for (const decl of node.declarationList.declarations) {
       if (isSignalDeclaration(decl, ctx)) {
         collectSignal(decl, ctx);
@@ -6553,16 +6682,16 @@ function visitComponentBody(node, ctx) {
         collectEffect(decl.initializer, ctx, 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, ctx, false, isLet ? "let" : "const");
-      } else if (ts10.isObjectBindingPattern(decl.name) && decl.initializer && ts10.isIdentifier(decl.initializer) && ctx.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) && ctx.propsObjectName === decl.initializer.text) {
+        const isLet = (node.declarationList.flags & ts11.NodeFlags.Let) !== 0;
         collectConstant(decl, ctx, false, isLet ? "let" : "const");
       }
     }
   }
-  if (ts10.isExpressionStatement(node)) {
+  if (ts11.isExpressionStatement(node)) {
     if (isEffectCall(node.expression, ctx)) {
       collectEffect(node.expression, ctx);
       return;
@@ -6576,10 +6705,10 @@ function visitComponentBody(node, ctx) {
       return;
     }
   }
-  if (ts10.isFunctionDeclaration(node) && node.name) {
+  if (ts11.isFunctionDeclaration(node) && node.name) {
     collectFunction(node, ctx, false);
   }
-  if (ts10.isIfStatement(node)) {
+  if (ts11.isIfStatement(node)) {
     const jsxReturn = findJsxReturnInBlock(node.thenStatement);
     if (jsxReturn) {
       const scopeVars = collectScopeVariables(node.thenStatement, ctx);
@@ -6598,8 +6727,8 @@ function visitComponentBody(node, ctx) {
       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 === ctx.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 === ctx.componentBodyBlock)) {
+    if (ts11.isBlock(node)) {
       const returnedLocal = findBlockBodyReturnedJsxLocalName(node);
       if (returnedLocal) {
         ctx.errors.push(createError(ErrorCodes.RETURN_VALUE_NOT_JSX, getSourceLocation(node, ctx.sourceFile, ctx.filePath), {
@@ -6610,34 +6739,34 @@ function visitComponentBody(node, ctx) {
     collectInitStatement(node, ctx);
     return;
   }
-  if (ts10.isReturnStatement(node) && node.expression) {
+  if (ts11.isReturnStatement(node) && node.expression) {
     ctx.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, ctx);
   });
 }
 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;
@@ -6645,22 +6774,22 @@ function unwrapJsxTransparent(expr) {
 function findBlockBodyReturnedJsxLocalName(block) {
   const stmts = block.statements;
   const last = stmts[stmts.length - 1];
-  if (!last || !ts10.isReturnStatement(last) || !last.expression)
+  if (!last || !ts11.isReturnStatement(last) || !last.expression)
     return null;
   const returned = unwrapJsxTransparent(last.expression);
-  if (!ts10.isIdentifier(returned))
+  if (!ts11.isIdentifier(returned))
     return null;
   const name = returned.text;
   for (const stmt of stmts) {
-    if (!ts10.isVariableStatement(stmt))
+    if (!ts11.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts10.isIdentifier(decl.name) || decl.name.text !== name || !decl.initializer)
+      if (!ts11.isIdentifier(decl.name) || decl.name.text !== name || !decl.initializer)
         continue;
       let init = decl.initializer;
-      while (ts10.isParenthesizedExpression(init))
+      while (ts11.isParenthesizedExpression(init))
         init = init.expression;
-      if (ts10.isJsxElement(init) || ts10.isJsxSelfClosingElement(init) || ts10.isJsxFragment(init) || initializerShapeContainsJsx(init) || isMapLikeCallWithJsx(init)) {
+      if (ts11.isJsxElement(init) || ts11.isJsxSelfClosingElement(init) || ts11.isJsxFragment(init) || initializerShapeContainsJsx(init) || isMapLikeCallWithJsx(init)) {
         return name;
       }
     }
@@ -6669,16 +6798,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, ctx) {
   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);
         }
@@ -6690,13 +6819,13 @@ function collectScopeVariables(node, ctx) {
 function collectParamBindingNames(params) {
   const out = new Set;
   const addBindingNames = (name) => {
-    if (ts10.isIdentifier(name)) {
+    if (ts11.isIdentifier(name)) {
       out.add(name.text);
-    } else if (ts10.isObjectBindingPattern(name)) {
+    } else if (ts11.isObjectBindingPattern(name)) {
       name.elements.forEach((e) => addBindingNames(e.name));
-    } else if (ts10.isArrayBindingPattern(name)) {
+    } else if (ts11.isArrayBindingPattern(name)) {
       name.elements.forEach((e) => {
-        if (!ts10.isOmittedExpression(e))
+        if (!ts11.isOmittedExpression(e))
           addBindingNames(e.name);
       });
     }
@@ -6713,7 +6842,7 @@ function collectEnclosingBranchVars(node, ctx) {
       if (cr.ifStatement.thenStatement !== current)
         continue;
       for (const decl of cr.scopeVariables) {
-        if (!ts10.isIdentifier(decl.name) || !decl.initializer)
+        if (!ts11.isIdentifier(decl.name) || !decl.initializer)
           continue;
         const varName = decl.name.text;
         if (result.has(varName))
@@ -6728,10 +6857,10 @@ function collectEnclosingBranchVars(node, ctx) {
   return result;
 }
 function collectBranchSignals(thenStatement, ctx, branchCondition) {
-  if (!ts10.isBlock(thenStatement))
+  if (!ts11.isBlock(thenStatement))
     return;
   for (const stmt of thenStatement.statements) {
-    if (!ts10.isVariableStatement(stmt))
+    if (!ts11.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
       if (!isSignalDeclaration(decl, ctx))
@@ -6757,13 +6886,13 @@ var ENV_SIGNAL_FACTORIES = {
   createSearchParams: "search"
 };
 function resolvePrimitiveKind(callExpr, ctx) {
-  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, ctx);
   }
-  if (ts10.isPropertyAccessExpression(callExpr.expression)) {
+  if (ts11.isPropertyAccessExpression(callExpr.expression)) {
     const propName = callExpr.expression.name.text;
     const hit = PRIMITIVE_CANONICAL_NAMES[propName];
     if (!hit)
@@ -6790,7 +6919,7 @@ function resolveCanonicalClientExportName(ident, ctx) {
   if (!symbol)
     return null;
   let target = symbol;
-  if (symbol.flags & ts10.SymbolFlags.Alias) {
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
     try {
       target = ctx.checker.getAliasedSymbol(symbol);
     } catch {
@@ -6806,14 +6935,14 @@ function resolveCanonicalClientExportName(ident, ctx) {
   return null;
 }
 function resolveEnvSignalKey(callExpr, ctx) {
-  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, ctx);
     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, ctx))
       return key;
@@ -6821,7 +6950,7 @@ function resolveEnvSignalKey(callExpr, ctx) {
   return null;
 }
 function isBarefootClientNamespace(expr, ctx) {
-  if (!ts10.isIdentifier(expr))
+  if (!ts11.isIdentifier(expr))
     return false;
   if (!ctx.checker)
     return false;
@@ -6834,22 +6963,22 @@ function isBarefootClientNamespace(expr, ctx) {
   if (!symbol)
     return false;
   for (const decl of symbol.declarations ?? []) {
-    if (!ts10.isNamespaceImport(decl))
+    if (!ts11.isNamespaceImport(decl))
       continue;
     const importDecl = decl.parent.parent;
-    if (!ts10.isImportDeclaration(importDecl))
+    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, ctx) {
-  if (!ts10.isArrayBindingPattern(node.name))
+  if (!ts11.isArrayBindingPattern(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  if (!node.initializer || !ts11.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "signal";
 }
@@ -6857,14 +6986,14 @@ function collectSignal(node, ctx) {
   const pattern = node.name;
   const callExpr = node.initializer;
   const elements = pattern.elements;
-  const getterElided = elements.length === 2 && ts10.isOmittedExpression(elements[0]);
-  if (elements.length < 1 || elements.length > 2 || !getterElided && (!ts10.isBindingElement(elements[0]) || !ts10.isIdentifier(elements[0].name))) {
+  const getterElided = elements.length === 2 && ts11.isOmittedExpression(elements[0]);
+  if (elements.length < 1 || elements.length > 2 || !getterElided && (!ts11.isBindingElement(elements[0]) || !ts11.isIdentifier(elements[0].name))) {
     return;
   }
-  if (elements.length === 2 && (!ts10.isBindingElement(elements[1]) || !ts10.isIdentifier(elements[1].name))) {
+  if (elements.length === 2 && (!ts11.isBindingElement(elements[1]) || !ts11.isIdentifier(elements[1].name))) {
     return;
   }
-  const setter = elements.length === 2 && ts10.isBindingElement(elements[1]) && ts10.isIdentifier(elements[1].name) ? elements[1].name.text : null;
+  const setter = elements.length === 2 && ts11.isBindingElement(elements[1]) && ts11.isIdentifier(elements[1].name) ? elements[1].name.text : null;
   if (getterElided && !setter)
     return;
   const getter = getterElided ? `__bfGet_${setter}` : elements[0].name.text;
@@ -6901,33 +7030,33 @@ function collectSignal(node, ctx) {
   });
 }
 function isSignalTupleDeclaration(node) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  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, ctx) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return null;
-  if (!node.initializer || !ts10.isElementAccessExpression(node.initializer))
+  if (!node.initializer || !ts11.isElementAccessExpression(node.initializer))
     return null;
   const access = node.initializer;
-  if (!ts10.isNumericLiteral(access.argumentExpression))
+  if (!ts11.isNumericLiteral(access.argumentExpression))
     return null;
   const indexValue = Number(access.argumentExpression.text);
   if (indexValue !== 0 && indexValue !== 1)
     return null;
   const index = indexValue;
-  if (ts10.isCallExpression(access.expression)) {
+  if (ts11.isCallExpression(access.expression)) {
     const call = access.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(access.expression)) {
+  if (ts11.isIdentifier(access.expression)) {
     const tupleName = access.expression.text;
     if (ctx.signalTupleRefs.has(tupleName)) {
       return { kind: "tupleRef", index, tupleName };
@@ -7022,30 +7151,30 @@ function flushPendingSignalTuples(ctx) {
   ctx.signalTupleRefs.clear();
 }
 function isMemoDeclaration(node, ctx) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  if (!node.initializer || !ts11.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "memo";
 }
 function memoBodyIsTemplateLiteral(memoArrow) {
   let node = memoArrow;
-  while (node && ts10.isParenthesizedExpression(node))
+  while (node && ts11.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts10.isArrowFunction(node))
+  if (!node || !ts11.isArrowFunction(node))
     return false;
   let body = node.body;
-  while (ts10.isParenthesizedExpression(body))
+  while (ts11.isParenthesizedExpression(body))
     body = body.expression;
-  if (ts10.isBlock(body)) {
-    const ret = body.statements.find(ts10.isReturnStatement);
+  if (ts11.isBlock(body)) {
+    const ret = body.statements.find(ts11.isReturnStatement);
     if (!ret || !ret.expression)
       return false;
     body = ret.expression;
-    while (ts10.isParenthesizedExpression(body))
+    while (ts11.isParenthesizedExpression(body))
       body = body.expression;
   }
-  return ts10.isTemplateExpression(body) || ts10.isNoSubstitutionTemplateLiteral(body);
+  return ts11.isTemplateExpression(body) || ts11.isNoSubstitutionTemplateLiteral(body);
 }
 function collectMemo(node, ctx) {
   const name = node.name.text;
@@ -7062,7 +7191,7 @@ function collectMemo(node, ctx) {
       type = inferTypeFromValue(arrowBody);
     }
   }
-  if (ctx.checker && (type.kind === "unknown" || type.kind === "object") && callExpr.arguments[0] && (ts10.isArrowFunction(callExpr.arguments[0]) || ts10.isFunctionExpression(callExpr.arguments[0]))) {
+  if (ctx.checker && (type.kind === "unknown" || type.kind === "object") && callExpr.arguments[0] && (ts11.isArrowFunction(callExpr.arguments[0]) || ts11.isFunctionExpression(callExpr.arguments[0]))) {
     const fnType = ctx.checker.getTypeAtLocation(callExpr.arguments[0]);
     const sig = fnType.getCallSignatures()[0];
     if (sig) {
@@ -7072,12 +7201,12 @@ function collectMemo(node, ctx) {
     }
   }
   const memoArrow = callExpr.arguments[0];
-  const parsedBody = memoArrow && ts10.isArrowFunction(memoArrow) && !ts10.isBlock(memoArrow.body) ? parseExpression(ctx.getJS(memoArrow.body)) : undefined;
+  const parsedBody = memoArrow && ts11.isArrowFunction(memoArrow) && !ts11.isBlock(memoArrow.body) ? parseExpression(ctx.getJS(memoArrow.body)) : undefined;
   const parsed = parsedBody && parsedBody.kind !== "unsupported" && parsedBody.kind !== "object-literal" ? parsedBody : undefined;
   let arrowNode = memoArrow;
-  while (arrowNode && ts10.isParenthesizedExpression(arrowNode))
+  while (arrowNode && ts11.isParenthesizedExpression(arrowNode))
     arrowNode = arrowNode.expression;
-  const blockBody = arrowNode && ts10.isArrowFunction(arrowNode) && ts10.isBlock(arrowNode.body) ? arrowNode.body : undefined;
+  const blockBody = arrowNode && ts11.isArrowFunction(arrowNode) && ts11.isBlock(arrowNode.body) ? arrowNode.body : undefined;
   const parsedBlock = blockBody ? parseBlockBodyTolerant(blockBody, ctx.sourceFile, (node2) => ctx.getJS(node2)) : undefined;
   const parsedBlockComplete = parsedBlock && blockBody ? parsedBlock.length === blockBody.statements.length : undefined;
   let templateComputation;
@@ -7104,14 +7233,14 @@ function collectMemo(node, ctx) {
   });
 }
 function isEffectCall(node, ctx) {
-  if (!ts10.isCallExpression(node))
+  if (!ts11.isCallExpression(node))
     return false;
   return resolvePrimitiveKind(node, ctx) === "effect";
 }
 function isEffectDisposerCapture(node, ctx) {
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return false;
-  if (!node.initializer || !ts10.isCallExpression(node.initializer))
+  if (!node.initializer || !ts11.isCallExpression(node.initializer))
     return false;
   return resolvePrimitiveKind(node.initializer, ctx) === "effect";
 }
@@ -7126,7 +7255,7 @@ function collectEffect(node, ctx, captureName) {
   });
 }
 function isOnMountCall(node, ctx) {
-  if (!ts10.isCallExpression(node))
+  if (!ts11.isCallExpression(node))
     return false;
   return resolvePrimitiveKind(node, ctx) === "onMount";
 }
@@ -7161,19 +7290,19 @@ function leadsWithAsiHazard(body) {
 function extractAssignedIdentifiersFromNode(node) {
   const ids = new Set;
   function addFromTarget(target) {
-    if (ts10.isIdentifier(target)) {
+    if (ts11.isIdentifier(target)) {
       ids.add(target.text);
       return;
     }
-    if (ts10.isParenthesizedExpression(target)) {
+    if (ts11.isParenthesizedExpression(target)) {
       addFromTarget(target.expression);
       return;
     }
-    if (ts10.isArrayLiteralExpression(target)) {
+    if (ts11.isArrayLiteralExpression(target)) {
       for (const el of target.elements) {
-        if (ts10.isOmittedExpression(el))
+        if (ts11.isOmittedExpression(el))
           continue;
-        if (ts10.isSpreadElement(el)) {
+        if (ts11.isSpreadElement(el)) {
           addFromTarget(el.expression);
           continue;
         }
@@ -7181,17 +7310,17 @@ function extractAssignedIdentifiersFromNode(node) {
       }
       return;
     }
-    if (ts10.isObjectLiteralExpression(target)) {
+    if (ts11.isObjectLiteralExpression(target)) {
       for (const prop of target.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;
         }
@@ -7200,21 +7329,21 @@ function extractAssignedIdentifiersFromNode(node) {
     }
   }
   function visit2(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, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   const localDecls = collectLocalDeclarations(node);
@@ -7225,30 +7354,30 @@ function extractAssignedIdentifiersFromNode(node) {
 function collectLocalDeclarations(root) {
   const names = new Set;
   function addBindingName(name) {
-    if (ts10.isIdentifier(name)) {
+    if (ts11.isIdentifier(name)) {
       names.add(name.text);
       return;
     }
-    if (ts10.isArrayBindingPattern(name)) {
+    if (ts11.isArrayBindingPattern(name)) {
       for (const el of name.elements) {
-        if (ts10.isBindingElement(el))
+        if (ts11.isBindingElement(el))
           addBindingName(el.name);
       }
       return;
     }
-    if (ts10.isObjectBindingPattern(name)) {
+    if (ts11.isObjectBindingPattern(name)) {
       for (const el of name.elements) {
         addBindingName(el.name);
       }
     }
   }
   function visit2(n) {
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n) || ts10.isFunctionDeclaration(n))
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n) || ts11.isFunctionDeclaration(n))
       return;
-    if (ts10.isVariableDeclaration(n)) {
+    if (ts11.isVariableDeclaration(n)) {
       addBindingName(n.name);
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(root);
   return names;
@@ -7283,35 +7412,35 @@ var CLIENT_EXPORTS = new Set([
   "Region"
 ]);
 function collectAmbientGlobals(node, ctx) {
-  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))
+      if (ts11.isIdentifier(decl.name))
         ctx.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)
       ctx.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))
+    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))
+          if (ts11.isIdentifier(decl.name))
             ctx.ambientGlobals.add(decl.name.text);
         }
-      } else if (ts10.isFunctionDeclaration(inner) && inner.name) {
+      } else if (ts11.isFunctionDeclaration(inner) && inner.name) {
         ctx.ambientGlobals.add(inner.name.text);
       }
     }
@@ -7322,7 +7451,7 @@ function collectImport(node, ctx) {
   const specifiers = [];
   const isTypeOnly = !!node.importClause?.isTypeOnly;
   const loc = getSourceLocation(node, ctx.sourceFile, ctx.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 element of node.importClause.namedBindings.elements) {
       const name = element.propertyName?.text ?? element.name.text;
@@ -7350,7 +7479,7 @@ function collectImport(node, ctx) {
       });
     }
     if (node.importClause.namedBindings) {
-      if (ts10.isNamedImports(node.importClause.namedBindings)) {
+      if (ts11.isNamedImports(node.importClause.namedBindings)) {
         for (const element of node.importClause.namedBindings.elements) {
           specifiers.push({
             name: element.propertyName?.text ?? element.name.text,
@@ -7361,7 +7490,7 @@ function collectImport(node, ctx) {
           });
         }
       }
-      if (ts10.isNamespaceImport(node.importClause.namedBindings)) {
+      if (ts11.isNamespaceImport(node.importClause.namedBindings)) {
         specifiers.push({
           name: node.importClause.namedBindings.name.text,
           alias: null,
@@ -7388,7 +7517,7 @@ function collectInterfaceDefinition(node, ctx) {
   });
 }
 function collectTypeAliasDefinition(node, ctx) {
-  const properties = ts10.isTypeLiteralNode(node.type) ? membersToProperties(node.type.members, ctx.sourceFile) : undefined;
+  const properties = ts11.isTypeLiteralNode(node.type) ? membersToProperties(node.type.members, ctx.sourceFile) : undefined;
   ctx.typeDefinitions.push({
     kind: "type",
     name: node.name.text,
@@ -7401,20 +7530,20 @@ function extractSingleJsxReturn(body) {
   let jsxReturn = null;
   let returnCount = 0;
   function visit2(node) {
-    if (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node))
+    if (ts11.isFunctionDeclaration(node) || ts11.isFunctionExpression(node) || ts11.isArrowFunction(node))
       return;
-    if (ts10.isReturnStatement(node)) {
+    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, visit2);
+    ts11.forEachChild(node, visit2);
   }
-  ts10.forEachChild(body, visit2);
+  ts11.forEachChild(body, visit2);
   if (returnCount !== 1)
     return null;
   return jsxReturn;
@@ -7431,9 +7560,9 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
   const stmts = body.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;
@@ -7443,7 +7572,7 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
           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;
           }
@@ -7465,18 +7594,18 @@ function extractMultiReturnJsxBranches(body, 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;
         }
@@ -7486,7 +7615,7 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
           return null;
         if (!caseClauseIsDirectReturn(clause))
           return null;
-        if (ts10.isCaseClause(clause)) {
+        if (ts11.isCaseClause(clause)) {
           branches.push({
             condition: clause.expression,
             jsxReturn: jsxReturn ?? null,
@@ -7507,18 +7636,18 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
         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 {
+      } 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;
@@ -7534,12 +7663,12 @@ function extractMultiReturnJsxBranches(body, allowPreamble = false) {
   return { branches, fallback, preamble };
 }
 function isDirectReturnBlock(node) {
-  if (ts10.isReturnStatement(node))
+  if (ts11.isReturnStatement(node))
     return true;
-  if (ts10.isBlock(node)) {
+  if (ts11.isBlock(node)) {
     let returnCount = 0;
     for (const stmt of node.statements) {
-      if (ts10.isReturnStatement(stmt)) {
+      if (ts11.isReturnStatement(stmt)) {
         returnCount++;
         continue;
       }
@@ -7550,25 +7679,25 @@ 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)
+        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)
+    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);
     }
   }
@@ -7578,12 +7707,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;
@@ -7594,9 +7723,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)
+      if (expr.kind === ts11.SyntaxKind.NullKeyword)
         return true;
     }
   }
@@ -7607,26 +7736,26 @@ function isMultiReturnJsxFunctionBody(body) {
   let hasJsxReturn = false;
   let allReturnsAreJsxOrNull = true;
   function visit2(node) {
-    if (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node))
+    if (ts11.isFunctionDeclaration(node) || ts11.isFunctionExpression(node) || ts11.isArrowFunction(node))
       return;
-    if (ts10.isReturnStatement(node)) {
+    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, visit2);
+    ts11.forEachChild(node, visit2);
   }
-  ts10.forEachChild(body, visit2);
+  ts11.forEachChild(body, visit2);
   return returnCount > 1 && hasJsxReturn && allReturnsAreJsxOrNull;
 }
 function collectFunction(node, ctx, _isModule, isExported = false) {
@@ -7696,7 +7825,7 @@ function collectFunction(node, ctx, _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;
   ctx.localFunctions.push({
     name,
@@ -7717,10 +7846,10 @@ function collectFunction(node, ctx, _isModule, isExported = false) {
   });
 }
 function extractValueBranches(node, ctx) {
-  if (ts10.isParenthesizedExpression(node)) {
+  if (ts11.isParenthesizedExpression(node)) {
     return extractValueBranches(node.expression, ctx);
   }
-  if (ts10.isConditionalExpression(node)) {
+  if (ts11.isConditionalExpression(node)) {
     return [
       ...extractValueBranches(node.whenTrue, ctx),
       ...extractValueBranches(node.whenFalse, ctx)
@@ -7732,46 +7861,46 @@ function extractFreeIdentifiersFromNode(node) {
   const ids = new Set;
   const boundNames = new Set;
   function addBindingNames(name, out) {
-    if (ts10.isIdentifier(name))
+    if (ts11.isIdentifier(name))
       out.push(name.text);
-    else if (ts10.isObjectBindingPattern(name))
+    else if (ts11.isObjectBindingPattern(name))
       name.elements.forEach((e) => addBindingNames(e.name, out));
-    else if (ts10.isArrayBindingPattern(name))
+    else if (ts11.isArrayBindingPattern(name))
       name.elements.forEach((e) => {
-        if (!ts10.isOmittedExpression(e))
+        if (!ts11.isOmittedExpression(e))
           addBindingNames(e.name, out);
       });
   }
   function visit2(n) {
-    if (ts10.isTypeNode(n))
+    if (ts11.isTypeNode(n))
       return;
-    if (ts10.isIdentifier(n)) {
+    if (ts11.isIdentifier(n)) {
       const parent = n.parent;
-      if (parent && ts10.isPropertyAccessExpression(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts10.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && ts10.isParameter(parent) && parent.name === n)
+      if (parent && ts11.isParameter(parent) && parent.name === n)
         return;
-      if (parent && ts10.isVariableDeclaration(parent) && parent.name === n)
+      if (parent && ts11.isVariableDeclaration(parent) && parent.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)
         addBindingNames(p.name, params);
       for (const name of params)
         boundNames.add(name);
-      ts10.forEachChild(n, visit2);
+      ts11.forEachChild(n, visit2);
       for (const name of params)
         boundNames.delete(name);
       return;
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return ids;
@@ -7780,29 +7909,29 @@ function extractFreeTypeIdentifiersFromNode(node) {
   const ids = new Set;
   const boundTypeParams = new Set;
   function rootName(name) {
-    return ts10.isQualifiedName(name) ? rootName(name.left) : name;
+    return ts11.isQualifiedName(name) ? rootName(name.left) : name;
   }
   function visit2(n) {
-    if (ts10.isTypeReferenceNode(n)) {
+    if (ts11.isTypeReferenceNode(n)) {
       const name = rootName(n.typeName).text;
       if (!boundTypeParams.has(name))
         ids.add(name);
     }
-    if (ts10.isTypeQueryNode(n)) {
+    if (ts11.isTypeQueryNode(n)) {
       const name = rootName(n.exprName).text;
       if (!boundTypeParams.has(name))
         ids.add(name);
     }
-    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, visit2);
+      ts11.forEachChild(n, visit2);
       for (const p of names)
         boundTypeParams.delete(p);
       return;
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return ids;
@@ -7812,22 +7941,22 @@ function initializerShapeContainsJsx(node) {
   function visit2(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, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return found;
 }
 function isMapLikeCallWithJsx(node) {
-  if (!ts10.isCallExpression(node))
+  if (!ts11.isCallExpression(node))
     return false;
-  if (!ts10.isPropertyAccessExpression(node.expression))
+  if (!ts11.isPropertyAccessExpression(node.expression))
     return false;
   const method = node.expression.name.text;
   if (method !== "map" && method !== "flatMap")
@@ -7835,12 +7964,12 @@ function isMapLikeCallWithJsx(node) {
   const callback = node.arguments[0];
   if (!callback)
     return false;
-  if (!ts10.isArrowFunction(callback) && !ts10.isFunctionExpression(callback))
+  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))
+  if (ts11.isJsxElement(node) || ts11.isJsxSelfClosingElement(node) || ts11.isJsxFragment(node))
     return true;
   let found = false;
   node.forEachChild((child) => {
@@ -7854,11 +7983,11 @@ function nodeContainsArrow(node) {
   function visit2(n) {
     if (found)
       return;
-    if (ts10.isArrowFunction(n) || ts10.isFunctionExpression(n)) {
+    if (ts11.isArrowFunction(n) || ts11.isFunctionExpression(n)) {
       found = true;
       return;
     }
-    ts10.forEachChild(n, visit2);
+    ts11.forEachChild(n, visit2);
   }
   visit2(node);
   return found;
@@ -7906,20 +8035,20 @@ function collectModuleScopeReactive(decl, ctx, isExported) {
   }));
 }
 function getSystemConstructKind(node) {
-  if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === "createContext")
+  if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === "createContext")
     return "createContext";
-  if (ts10.isNewExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === "WeakMap")
+  if (ts11.isNewExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === "WeakMap")
     return "weakMap";
   return;
 }
 function collectConstant(node, ctx, _isModule, declarationKind = "const", isExported = false) {
-  if (!_isModule && ts10.isObjectBindingPattern(node.name) && node.initializer && ts10.isIdentifier(node.initializer) && ctx.propsObjectName === node.initializer.text) {
+  if (!_isModule && ts11.isObjectBindingPattern(node.name) && node.initializer && ts11.isIdentifier(node.initializer) && ctx.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)
+      if (!ts11.isBindingElement(el) || !ts11.isIdentifier(el.name) || el.dotDotDotToken)
         continue;
       const localName = el.name.text;
-      const sourceKey = el.propertyName && ts10.isIdentifier(el.propertyName) ? el.propertyName.text : localName;
+      const sourceKey = el.propertyName && ts11.isIdentifier(el.propertyName) ? el.propertyName.text : localName;
       const defaultValueExpr = el.initializer ? ctx.getJS(el.initializer) : undefined;
       const baseValue = `${propsName}.${sourceKey}`;
       const value2 = defaultValueExpr ? `${baseValue} ?? ${defaultValueExpr}` : baseValue;
@@ -7941,7 +8070,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
     }
     return;
   }
-  if (!ts10.isIdentifier(node.name))
+  if (!ts11.isIdentifier(node.name))
     return;
   if (isSignalDeclaration(node, ctx) || isMemoDeclaration(node, ctx))
     return;
@@ -7959,9 +8088,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
   let isJsxFunction = false;
   if (node.initializer) {
     let init = node.initializer;
-    while (ts10.isParenthesizedExpression(init))
+    while (ts11.isParenthesizedExpression(init))
       init = init.expression;
-    if (ts10.isJsxElement(init) || ts10.isJsxSelfClosingElement(init) || ts10.isJsxFragment(init)) {
+    if (ts11.isJsxElement(init) || ts11.isJsxSelfClosingElement(init) || ts11.isJsxFragment(init)) {
       isJsx = true;
       ctx.jsxConstants.set(name, init);
     } else if (initializerShapeContainsJsx(init)) {
@@ -7969,9 +8098,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
     } else if (isMapLikeCallWithJsx(init)) {
       ctx.inlineableJsxConsts.set(name, 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;
@@ -7991,9 +8120,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
         }
       } else {
         let body = arrowBody;
-        while (ts10.isParenthesizedExpression(body))
+        while (ts11.isParenthesizedExpression(body))
           body = body.expression;
-        if (ts10.isJsxElement(body) || ts10.isJsxSelfClosingElement(body) || ts10.isJsxFragment(body)) {
+        if (ts11.isJsxElement(body) || ts11.isJsxSelfClosingElement(body) || ts11.isJsxFragment(body)) {
           isJsxFunction = true;
           ctx.jsxFunctions.set(name, {
             jsxReturn: body,
@@ -8006,9 +8135,9 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
   let valueBranches;
   if (node.initializer) {
     let inner = node.initializer;
-    while (ts10.isParenthesizedExpression(inner))
+    while (ts11.isParenthesizedExpression(inner))
       inner = inner.expression;
-    if (ts10.isConditionalExpression(inner)) {
+    if (ts11.isConditionalExpression(inner)) {
       valueBranches = extractValueBranches(node.initializer, ctx);
     }
   }
@@ -8086,7 +8215,7 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
 function hasIgnoreDirective(node, sourceFile, ruleId) {
   const checkComments = (targetNode) => {
     const fullStart = targetNode.getFullStart();
-    const leadingComments = ts10.getLeadingCommentRanges(sourceFile.getFullText(), fullStart);
+    const leadingComments = ts11.getLeadingCommentRanges(sourceFile.getFullText(), fullStart);
     if (!leadingComments)
       return false;
     for (const range of leadingComments) {
@@ -8099,10 +8228,10 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
   };
   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;
@@ -8113,7 +8242,7 @@ function hasIgnoreDirective(node, sourceFile, ruleId) {
   return false;
 }
 function extractProps(param, ctx) {
-  if (ts10.isObjectBindingPattern(param.name)) {
+  if (ts11.isObjectBindingPattern(param.name)) {
     const componentNode = ctx.componentNode;
     const ignored = !!(componentNode && hasIgnoreDirective(componentNode, ctx.sourceFile, "props-destructuring"));
     ctx.propsDestructuring = {
@@ -8122,14 +8251,14 @@ function extractProps(param, ctx) {
     };
     const memberTypes = param.type ? collectMemberTypes(param.type, ctx) : null;
     for (const element of param.name.elements) {
-      if (ts10.isBindingElement(element) && ts10.isIdentifier(element.name)) {
+      if (ts11.isBindingElement(element) && ts11.isIdentifier(element.name)) {
         const localName = element.name.text;
         const defaultValue = element.initializer ? ctx.getJS(element.initializer) : undefined;
         if (element.dotDotDotToken) {
           ctx.restPropsName = localName;
           continue;
         }
-        const sourcePropName = element.propertyName && ts10.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
+        const sourcePropName = element.propertyName && ts11.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
         const member = memberTypes?.get(sourcePropName);
         const resolvedType = member?.type ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false;
@@ -8153,7 +8282,7 @@ function extractProps(param, ctx) {
       }
     }
   }
-  if (ts10.isIdentifier(param.name)) {
+  if (ts11.isIdentifier(param.name)) {
     ctx.propsObjectName = param.name.text;
     if (param.type) {
       extractPropsFromType(param.type, ctx);
@@ -8164,24 +8293,24 @@ function extractProps(param, ctx) {
   }
 }
 function collectTypeKeys(typeNode, ctx) {
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     return collectKeysFromMembers(typeNode.members, ctx);
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.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, ctx);
     }
-    if (ts10.isTypeAliasDeclaration(typeDecl)) {
-      if (ts10.isTypeLiteralNode(typeDecl.type)) {
+    if (ts11.isTypeAliasDeclaration(typeDecl)) {
+      if (ts11.isTypeLiteralNode(typeDecl.type)) {
         return collectKeysFromMembers(typeDecl.type.members, ctx);
       }
-      if (ts10.isIntersectionTypeNode(typeDecl.type)) {
+      if (ts11.isIntersectionTypeNode(typeDecl.type)) {
         return null;
       }
     }
@@ -8191,9 +8320,9 @@ function collectTypeKeys(typeNode, ctx) {
 function collectKeysFromMembers(members, ctx) {
   const keys = [];
   for (const member of members) {
-    if (ts10.isIndexSignatureDeclaration(member))
+    if (ts11.isIndexSignatureDeclaration(member))
       return null;
-    if (ts10.isPropertySignature(member) && member.name) {
+    if (ts11.isPropertySignature(member) && member.name) {
       keys.push(member.name.getText(ctx.sourceFile));
     }
   }
@@ -8217,7 +8346,7 @@ function collectMemberTypes(typeNode, ctx) {
   const fromMembers = (members) => {
     const map = 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, ctx.sourceFile) : null;
         map.set(member.name.getText(ctx.sourceFile), {
           type: info && isResolvableMemberType(info) ? info : null,
@@ -8227,35 +8356,35 @@ function collectMemberTypes(typeNode, ctx) {
     }
     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(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.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, ctx) {
-  if (ts10.isTypeLiteralNode(typeNode)) {
+  if (ts11.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx);
     return;
   }
-  if (ts10.isTypeReferenceNode(typeNode)) {
+  if (ts11.isTypeReferenceNode(typeNode)) {
     const typeName = typeNode.typeName.getText(ctx.sourceFile);
     const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
     if (typeDecl) {
-      if (ts10.isInterfaceDeclaration(typeDecl)) {
+      if (ts11.isInterfaceDeclaration(typeDecl)) {
         extractPropsFromTypeMembers(typeDecl.members, ctx);
-      } else if (ts10.isTypeAliasDeclaration(typeDecl) && ts10.isTypeLiteralNode(typeDecl.type)) {
+      } else if (ts11.isTypeAliasDeclaration(typeDecl) && ts11.isTypeLiteralNode(typeDecl.type)) {
         extractPropsFromTypeMembers(typeDecl.type.members, ctx);
       }
     }
@@ -8263,7 +8392,7 @@ function extractPropsFromType(typeNode, ctx) {
 }
 function extractPropsFromTypeMembers(members, ctx) {
   for (const member of members) {
-    if (ts10.isPropertySignature(member) && member.name) {
+    if (ts11.isPropertySignature(member) && member.name) {
       const propName = member.name.getText(ctx.sourceFile);
       const isOptional = !!member.questionToken;
       const propType = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : { kind: "unknown", raw: "unknown" };
@@ -8279,17 +8408,17 @@ function extractPropsFromTypeMembers(members, ctx) {
 function findTypeDeclaration(typeName, sourceFile) {
   let result;
   function visit2(node) {
-    if (ts10.isInterfaceDeclaration(node) && node.name.text === typeName) {
+    if (ts11.isInterfaceDeclaration(node) && node.name.text === typeName) {
       result = node;
       return;
     }
-    if (ts10.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+    if (ts11.isTypeAliasDeclaration(node) && node.name.text === typeName) {
       result = node;
       return;
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
-  ts10.forEachChild(sourceFile, visit2);
+  ts11.forEachChild(sourceFile, visit2);
   return result;
 }
 function inferTypeFromValue(value) {
@@ -8335,12 +8464,12 @@ function inferTypeFromValue(value) {
 }
 function collectCalledIdentifiers(code) {
   const called = 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 visit2 = (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, visit2);
+    ts11.forEachChild(node, visit2);
   };
   visit2(sf);
   return called;
@@ -8438,16 +8567,16 @@ function isResolvableComponentSource(source) {
 function collectJsxComponentTags(sourceFile) {
   const tags = new Set;
   function visit2(node) {
-    if (ts10.isJsxOpeningElement(node) || ts10.isJsxSelfClosingElement(node)) {
+    if (ts11.isJsxOpeningElement(node) || ts11.isJsxSelfClosingElement(node)) {
       const tagName = node.tagName;
-      if (ts10.isIdentifier(tagName)) {
+      if (ts11.isIdentifier(tagName)) {
         const first = tagName.text.charAt(0);
         if (first >= "A" && first <= "Z") {
           tags.add(tagName.text);
         }
       }
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
   visit2(sourceFile);
   return tags;
@@ -8526,18 +8655,18 @@ function fileHasUseClientDirective(filePath) {
   } catch {
     return true;
   }
-  const sf = ts10.createSourceFile(filePath, content, ts10.ScriptTarget.Latest, false, ts10.ScriptKind.TSX);
+  const sf = ts11.createSourceFile(filePath, content, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
   let found = false;
   function visit2(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, visit2);
+    ts11.forEachChild(node, visit2);
   }
   visit2(sf);
   return found;
@@ -8615,11 +8744,11 @@ function importsBrowserOnlyClientApi(ctx) {
   return false;
 }
 function listComponentFunctions(source, filePath) {
-  const sourceFile = ts10.createSourceFile(filePath, source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+  const sourceFile = ts11.createSourceFile(filePath, source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   return listComponentFunctionsFromSourceFile(sourceFile);
 }
 function scanComponentFile(source, filePath) {
-  const sourceFile = ts10.createSourceFile(filePath, source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+  const sourceFile = ts11.createSourceFile(filePath, source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   return {
     exports: listComponentFunctionsFromSourceFile(sourceFile),
     referencedComponents: [...collectJsxComponentTags(sourceFile)]
@@ -8627,11 +8756,11 @@ 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'"));
+  const hasUseClient = sourceFile.statements.some((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)) {} else {
@@ -8641,9 +8770,9 @@ 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;
 }
 var REACTIVE_PRIMITIVES = new Set([
@@ -8655,13 +8784,13 @@ var REACTIVE_PRIMITIVES = new Set([
   "onCleanup"
 ]);
 function prescanReactiveFactoriesInSource(source, filePath) {
-  const sourceFile = ts10.createSourceFile(filePath + ".prescan", source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+  const sourceFile = ts11.createSourceFile(filePath + ".prescan", source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
   const factories = new Map;
   const declined = new Map;
   const reactiveShaped = new Set;
   const cleanFactoryImports = 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;
@@ -8678,7 +8807,7 @@ function prescanReactiveFactoriesInSource(source, filePath) {
       }
     }
   }
-  ts10.forEachChild(sourceFile, visitTop);
+  ts11.forEachChild(sourceFile, visitTop);
   const result = { factories, declined, reactiveShaped, cleanFactoryImports, sourceFile };
   prescanImportedReactiveFactories(sourceFile, filePath, result);
   return result;
@@ -8695,15 +8824,15 @@ function toComponentRelativeSpecifier(resolvedAbs, componentFilePath) {
 function buildEntryImportIndex(sf, filePath) {
   const index = new Map;
   for (const stmt of sf.statements) {
-    if (!ts10.isImportDeclaration(stmt))
+    if (!ts11.isImportDeclaration(stmt))
       continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+    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,
@@ -8718,31 +8847,31 @@ function buildEntryImportIndex(sf, filePath) {
 function collectEntryBindingNames(sf) {
   const names = new Set;
   function visit2(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);
@@ -8750,7 +8879,7 @@ function collectEntryBindingNames(sf) {
           names.add(n);
       }
     }
-    ts10.forEachChild(node, visit2);
+    ts11.forEachChild(node, visit2);
   }
   visit2(sf);
   return names;
@@ -8759,19 +8888,19 @@ var MAX_REEXPORT_HOPS = 1;
 function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
   const candidateCallees = 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))
+    if (!ts11.isImportDeclaration(stmt))
       continue;
-    if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts11.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const src = stmt.moduleSpecifier.text;
     if (!src.startsWith("./") && !src.startsWith("../"))
@@ -8779,7 +8908,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
     if (stmt.importClause?.isTypeOnly)
       continue;
     const namedBindings = stmt.importClause?.namedBindings;
-    if (!namedBindings || !ts10.isNamedImports(namedBindings))
+    if (!namedBindings || !ts11.isNamedImports(namedBindings))
       continue;
     const specs = [];
     for (const el of namedBindings.elements) {
@@ -8817,14 +8946,14 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
       helperCache.set(abs, "clean");
       return "clean";
     }
-    const sf = ts10.createSourceFile(abs + ".prescan", content, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
+    const sf = ts11.createSourceFile(abs + ".prescan", content, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TSX);
     const localFns = new Map;
     const exportedFns = 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);
         }
@@ -8833,10 +8962,10 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
     const reexports = new Map;
     let hasStarReexport = false;
     for (const stmt of sf.statements) {
-      if (!ts10.isExportDeclaration(stmt) || stmt.isTypeOnly)
+      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;
@@ -8847,9 +8976,9 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
         }
         continue;
       }
-      if (!ts10.isStringLiteral(stmt.moduleSpecifier))
+      if (!ts11.isStringLiteral(stmt.moduleSpecifier))
         continue;
-      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;
@@ -8999,7 +9128,7 @@ function collectHelperModuleValueBindings(sf) {
   const importedTypes = new Map;
   const imported = 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);
@@ -9008,16 +9137,16 @@ function collectHelperModuleValueBindings(sf) {
         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))
+    if (ts11.isImportDeclaration(stmt)) {
+      if (!ts11.isStringLiteral(stmt.moduleSpecifier))
         continue;
       const src = stmt.moduleSpecifier.text;
       if (src === "@barefootjs/client" || src === "@barefootjs/client/runtime")
@@ -9026,7 +9155,7 @@ function collectHelperModuleValueBindings(sf) {
       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)
@@ -9035,7 +9164,7 @@ function collectHelperModuleValueBindings(sf) {
             imported.set(el.name.text, entry);
         }
       }
-      if (namedBindings && ts10.isNamespaceImport(namedBindings)) {
+      if (namedBindings && ts11.isNamespaceImport(namedBindings)) {
         (wholeTypeOnly ? localTypes : local).add(namedBindings.name.text);
       }
     }
@@ -9102,11 +9231,11 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   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)
@@ -9114,29 +9243,29 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   const loc = getSourceLocation(node, sourceFile, filePath);
   let totalReturnCount = 0;
   function countReturns(n) {
-    if (ts10.isFunctionLike(n))
+    if (ts11.isFunctionLike(n))
       return;
-    if (ts10.isReturnStatement(n)) {
+    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))
+    if (!ts11.isReturnStatement(stmt))
       continue;
     returnCount++;
     if (!stmt.expression)
       return { kind: "reactive-shaped" };
     let expr = stmt.expression;
-    while (ts10.isParenthesizedExpression(expr))
+    while (ts11.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts10.isAsExpression(expr))
+    if (ts11.isAsExpression(expr))
       expr = expr.expression;
-    if (ts10.isTypeAssertionExpression(expr))
+    if (ts11.isTypeAssertionExpression(expr))
       expr = expr.expression;
     returnExpr = expr;
   }
@@ -9144,18 +9273,18 @@ function detectReactiveFactory(node, sourceFile, filePath) {
     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))
+      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",
@@ -9176,7 +9305,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;
     }
@@ -9184,11 +9313,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);
     }
   }
@@ -9208,47 +9337,47 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       if (!relevantNames.has(id.text))
         return;
       const p = id.parent;
-      if (ts10.isPropertyAccessExpression(p) && p.name === id)
+      if (ts11.isPropertyAccessExpression(p) && p.name === id)
         return;
-      if (ts10.isPropertyAssignment(p) && p.name === id)
+      if (ts11.isPropertyAssignment(p) && p.name === id)
         return;
-      if (ts10.isBindingElement(p) && p.propertyName === id)
+      if (ts11.isBindingElement(p) && p.propertyName === id)
         return;
-      if ((ts10.isMethodDeclaration(p) || ts10.isGetAccessorDeclaration(p) || ts10.isSetAccessorDeclaration(p) || ts10.isPropertyDeclaration(p) || ts10.isEnumMember(p)) && p.name === id)
+      if ((ts11.isMethodDeclaration(p) || ts11.isGetAccessorDeclaration(p) || ts11.isSetAccessorDeclaration(p) || ts11.isPropertyDeclaration(p) || ts11.isEnumMember(p)) && p.name === id)
         return;
-      if (ts10.isJsxAttribute(p) && p.name === id)
+      if (ts11.isJsxAttribute(p) && p.name === id)
         return;
-      if (ts10.isLabeledStatement(p) && p.label === id || (ts10.isBreakStatement(p) || ts10.isContinueStatement(p)) && p.label === id)
+      if (ts11.isLabeledStatement(p) && p.label === id || (ts11.isBreakStatement(p) || ts11.isContinueStatement(p)) && p.label === id)
         return;
-      if ((ts10.isJsxOpeningElement(p) || ts10.isJsxSelfClosingElement(p) || ts10.isJsxClosingElement(p)) && p.tagName === id && /^[a-z]/.test(id.text))
+      if ((ts11.isJsxOpeningElement(p) || ts11.isJsxSelfClosingElement(p) || ts11.isJsxClosingElement(p)) && p.tagName === id && /^[a-z]/.test(id.text))
         return;
-      if (ts10.isShorthandPropertyAssignment(p) && p.name === id) {
+      if (ts11.isShorthandPropertyAssignment(p) && p.name === id) {
         push(id, "shorthand");
         return;
       }
-      if (ts10.isBindingElement(p) && p.name === id && !p.propertyName && ts10.isObjectBindingPattern(p.parent)) {
+      if (ts11.isBindingElement(p) && p.name === id && !p.propertyName && ts11.isObjectBindingPattern(p.parent)) {
         if (params.includes(id.text))
           shadowedParam = id.text;
         push(id, "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 === id;
+      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 === id;
       if (isDecl && params.includes(id.text))
         shadowedParam = id.text;
       push(id, "plain");
     }
     function visit2(n) {
-      if (ts10.isTypeNode(n) || ts10.isTypeParameterDeclaration(n) || ts10.isTypeAliasDeclaration(n) || ts10.isInterfaceDeclaration(n))
+      if (ts11.isTypeNode(n) || ts11.isTypeParameterDeclaration(n) || ts11.isTypeAliasDeclaration(n) || ts11.isInterfaceDeclaration(n))
         return;
-      if (ts10.isIdentifier(n)) {
+      if (ts11.isIdentifier(n)) {
         classify(n);
         return;
       }
-      ts10.forEachChild(n, visit2);
+      ts11.forEachChild(n, visit2);
     }
     visit2(root);
   }
-  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) {
@@ -9296,18 +9425,18 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   };
 }
 function addBindingNames(name, out) {
-  if (ts10.isIdentifier(name)) {
+  if (ts11.isIdentifier(name)) {
     out.push(name.text);
     return;
   }
-  if (ts10.isObjectBindingPattern(name)) {
+  if (ts11.isObjectBindingPattern(name)) {
     for (const el of name.elements)
       addBindingNames(el.name, out);
     return;
   }
-  if (ts10.isArrayBindingPattern(name)) {
+  if (ts11.isArrayBindingPattern(name)) {
     for (const el of name.elements) {
-      if (ts10.isOmittedExpression(el))
+      if (ts11.isOmittedExpression(el))
         continue;
       addBindingNames(el.name, out);
     }
@@ -9319,33 +9448,33 @@ function rewriteFactoryCallsInSource(source, prescan) {
   let callSiteIndex = 0;
   const inlinedFactories = 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))
+    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))
+    if (!decl.initializer || !ts11.isCallExpression(decl.initializer))
       return;
-    if (!ts10.isIdentifier(decl.initializer.expression))
+    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);
@@ -9358,7 +9487,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
       return;
     const callerNames = [];
     for (const el of elements) {
-      if (ts10.isOmittedExpression(el) || !ts10.isIdentifier(el.name))
+      if (ts11.isOmittedExpression(el) || !ts11.isIdentifier(el.name))
         return;
       callerNames.push(el.name.text);
     }
@@ -9380,7 +9509,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
         return;
       if (el.initializer)
         return;
-      if (!ts10.isIdentifier(el.name))
+      if (!ts11.isIdentifier(el.name))
         return;
       if (!factory.returnTupleIdentifiers.includes(el.name.text))
         return;
@@ -9489,21 +9618,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;
@@ -9532,20 +9661,20 @@ function declinedFactoryErrorCode(code) {
 function validateReactiveFactoryCalls(ctx) {
   if (!ctx.componentNode)
     return;
-  const body = ts10.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts10.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
+  const body = ts11.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts11.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
   if (!body)
     return;
   for (const stmt of body.statements) {
-    if (!ts10.isVariableStatement(stmt))
+    if (!ts11.isVariableStatement(stmt))
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts10.isCallExpression(decl.initializer))
+      if (!decl.initializer || !ts11.isCallExpression(decl.initializer))
         continue;
-      if (!ts10.isIdentifier(decl.initializer.expression))
+      if (!ts11.isIdentifier(decl.initializer.expression))
         continue;
       const callee = decl.initializer.expression.text;
       const loc = getSourceLocation(stmt, ctx.sourceFile, ctx.filePath);
-      if (ts10.isArrayBindingPattern(decl.name)) {
+      if (ts11.isArrayBindingPattern(decl.name)) {
         if (callee === "createSignal" || callee === "createMemo")
           continue;
         if (resolveEnvSignalKey(decl.initializer, ctx))
@@ -9572,7 +9701,7 @@ function validateReactiveFactoryCalls(ctx) {
         }));
         continue;
       }
-      if (ts10.isObjectBindingPattern(decl.name)) {
+      if (ts11.isObjectBindingPattern(decl.name)) {
         validateObjectFactoryDestructure(ctx, decl.name, callee, loc);
       }
     }
@@ -9581,25 +9710,25 @@ function validateReactiveFactoryCalls(ctx) {
 function validateNamespaceQualifiedPrimitives(ctx) {
   if (!ctx.componentNode)
     return;
-  const body = ts10.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts10.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
+  const body = ts11.isFunctionDeclaration(ctx.componentNode) ? ctx.componentNode.body : ts11.isBlock(ctx.componentNode.body) ? ctx.componentNode.body : null;
   if (!body)
     return;
   for (const stmt of body.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))
+        if (init && ts11.isElementAccessExpression(init))
           init = init.expression;
-        if (init && ts10.isCallExpression(init))
+        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))
+      if (!ts11.isPropertyAccessExpression(callee) || !ts11.isIdentifier(callee.expression))
         continue;
       const primitive = callee.name.text;
       if (!(primitive in PRIMITIVE_CANONICAL_NAMES))
@@ -9632,11 +9761,11 @@ function isNamespaceNameShadowedAtComponentTopLevel(name, body, ctx) {
   if (ctx.propsParams.some((p) => p.name === name))
     return true;
   for (const stmt of body.statements) {
-    if (ts10.isFunctionDeclaration(stmt) && stmt.name?.text === name)
+    if (ts11.isFunctionDeclaration(stmt) && stmt.name?.text === name)
       return true;
-    if (ts10.isVariableStatement(stmt)) {
+    if (ts11.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
-        if (ts10.isIdentifier(decl.name) && decl.name.text === name)
+        if (ts11.isIdentifier(decl.name) && decl.name.text === name)
           return true;
       }
     }
@@ -9653,7 +9782,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
       }));
       return;
     }
-    const hasUnsupportedElement = pattern.elements.some((el) => !!el.propertyName || !!el.initializer || !!el.dotDotDotToken || !ts10.isIdentifier(el.name));
+    const hasUnsupportedElement = pattern.elements.some((el) => !!el.propertyName || !!el.initializer || !!el.dotDotDotToken || !ts11.isIdentifier(el.name));
     if (hasUnsupportedElement) {
       ctx.errors.push(createError(ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED, loc, {
         severity: "error",
@@ -9661,7 +9790,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
       }));
       return;
     }
-    const unknown = pattern.elements.map((el) => ts10.isIdentifier(el.name) ? el.name.text : "").filter((name) => name && !factory.returnTupleIdentifiers.includes(name));
+    const unknown = pattern.elements.map((el) => ts11.isIdentifier(el.name) ? el.name.text : "").filter((name) => name && !factory.returnTupleIdentifiers.includes(name));
     if (unknown.length > 0) {
       const label = unknown.length === 1 ? "property" : "properties";
       ctx.errors.push(createError(ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY, loc, {
@@ -9816,7 +9945,7 @@ var ESCAPE_SSR_COST = {
 };
 
 // src/module-exports.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function generateModuleExports(ir, extraInlineExported = new Set, rewriteRelativeImport, options) {
   const lines = [];
   for (const constant of options?.skipValueDeclarations ? [] : ir.metadata.localConstants) {
@@ -9917,21 +10046,21 @@ function findAssignedNames(bodyText, candidates) {
   const assigned = new Set;
   if (candidates.size === 0)
     return assigned;
-  const sf = ts11.createSourceFile("bf-assignment-scan.tsx", bodyText, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
+  const sf = ts12.createSourceFile("bf-assignment-scan.tsx", bodyText, ts12.ScriptTarget.Latest, false, ts12.ScriptKind.TSX);
   const record = (target) => {
-    if (ts11.isIdentifier(target) && candidates.has(target.text)) {
+    if (ts12.isIdentifier(target) && candidates.has(target.text)) {
       assigned.add(target.text);
     }
   };
   const visit2 = (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, visit2);
+    ts12.forEachChild(node, visit2);
   };
-  ts11.forEachChild(sf, visit2);
+  ts12.forEachChild(sf, visit2);
   return assigned;
 }
 function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
@@ -9954,7 +10083,7 @@ function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNam
   return reachable;
 }
 function isAssignmentOperator(kind) {
-  return kind >= ts11.SyntaxKind.FirstAssignment && kind <= ts11.SyntaxKind.LastAssignment;
+  return kind >= ts12.SyntaxKind.FirstAssignment && kind <= ts12.SyntaxKind.LastAssignment;
 }
 function extractFunctionParams(value) {
   const arrowMatch = value.match(/^(?:async\s*)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/);
@@ -9992,102 +10121,6 @@ function stripClientBuiltinImports(imports) {
   return result;
 }
 
-// src/reactivity-checker.ts
-import ts12 from "typescript";
-var REACTIVE_BRAND = "__reactive";
-function queryType(checker, node) {
-  incrementCounter("typeCheckerQueries");
-  return checker.getTypeAtLocation(node);
-}
-function isReactiveType(type) {
-  return type.getProperty(REACTIVE_BRAND) !== undefined;
-}
-var NOT_REACTIVE = { isReactive: false, reason: { kind: "not-reactive" } };
-function safeGetText(node) {
-  try {
-    return node.getText();
-  } catch {
-    return "";
-  }
-}
-function analyze(node, checker) {
-  if (ts12.isPropertyAccessExpression(node)) {
-    try {
-      const type = queryType(checker, node);
-      if (isReactiveType(type)) {
-        return {
-          isReactive: true,
-          reason: { kind: "brand", via: "property-access", nodeText: safeGetText(node) }
-        };
-      }
-    } catch {}
-    const sub = analyze(node.expression, checker);
-    if (sub.isReactive) {
-      return {
-        isReactive: true,
-        reason: {
-          kind: "child",
-          via: "property-access-object",
-          childText: safeGetText(node.expression),
-          childReason: sub.reason
-        }
-      };
-    }
-    return NOT_REACTIVE;
-  }
-  if (ts12.isIdentifier(node)) {
-    try {
-      const type = queryType(checker, node);
-      if (isReactiveType(type)) {
-        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 result = analyze(child, checker);
-    if (result.isReactive) {
-      foundChild = result;
-      foundChildText = safeGetText(child);
-    }
-  });
-  if (foundChild?.isReactive) {
-    return {
-      isReactive: true,
-      reason: {
-        kind: "child",
-        via: "sub-expression",
-        childText: foundChildText,
-        childReason: foundChild.reason
-      }
-    };
-  }
-  return NOT_REACTIVE;
-}
-var brandTypeReactivityAnalyzer = { analyze };
-function containsReactiveExpression(node, checker) {
-  incrementCounter("reactivityChecks");
-  return brandTypeReactivityAnalyzer.analyze(node, checker).isReactive;
-}
-
 // src/free-refs.ts
 import ts13 from "typescript";
 var _bindingMapCache = new WeakMap;
@@ -11765,7 +11798,7 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
   }
   const ir = transformJsxExpression(expr, ctx, isClientOnly);
   if (ir !== null) {
-    if ((isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx)) && ir.type === "conditional") {
+    if (ir.type === "conditional" && (isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx))) {
       ir.clientOnly = true;
       if (!ir.slotId) {
         ir.slotId = generateSlotId(ctx);
@@ -14712,9 +14745,10 @@ function shouldAutoDeferReactiveBrand(expr, ctx) {
   const checker = ctx.analyzer.checker;
   if (!checker)
     return false;
-  if (!containsReactiveExpression(expr, checker))
+  const leaves = collectReactiveBrandLeaves(expr, checker);
+  if (leaves.length === 0)
     return false;
-  if (isSignalOrMemoReference(ctx.getJS(expr), ctx))
+  if (leaves.some((leaf) => isSignalOrMemoReference(ctx.getJS(leaf), ctx)))
     return false;
   return true;
 }
@@ -15097,10 +15131,10 @@ function getControlledPropName(signal, propsParams, propsObjectName = null) {
 }
 
 // src/ir-to-client-js/reactivity.ts
-function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex) {
+function buildLoopRowScope(loopParam, loopParamBindings, preambleNames, loopIndex, parentScope) {
   if (!loopParam)
     return;
-  return BindingScope.EMPTY.enterLoopRow({
+  return (parentScope ?? BindingScope.EMPTY).enterLoopRow({
     param: loopParam,
     paramBindings: loopParamBindings,
     index: loopIndex,
@@ -15174,16 +15208,22 @@ function needsEffectWrapperCore(expr, ctx, freeIdentifiers2, visitedConstants) {
   }
   return false;
 }
-function classifyReactivity(expr, ctx, loopParam, loopParamBindings, freeIdentifiers2) {
+function classifyReactivity(expr, ctx, scope, freeIdentifiers2) {
   const has = (name) => freeIdentifiers2 ? freeIdentifiers2.has(name) : tokenContainsIdent(expr, name);
-  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 name of scope.valueBoundNames()) {
+      if (!has(name))
+        continue;
+      const source = scope.lookup(name)?.binding.source;
+      if (source === "index") {
+        indexHit ??= name;
+        continue;
       }
+      return { kind: "loop-param", param: name };
     }
-  } else if (loopParam && has(loopParam)) {
-    return { kind: "loop-param", param: loopParam };
+    if (indexHit)
+      return { kind: "loop-index", param: indexHit };
   }
   if (needsEffectWrapper(expr, ctx, freeIdentifiers2)) {
     return { kind: "signal-or-memo-or-prop" };
@@ -15346,9 +15386,9 @@ function traverseForComponents(node, components, skipConditionals = false) {
     }
   });
 }
-function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
+function collectLoopChildReactiveTexts(node, ctx, 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, {
     ...stopAt("loop", "async", "ifStatement"),
     expression: ({ node: n, scope: insideConditional }) => {
@@ -15358,7 +15398,7 @@ function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings,
         return;
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs);
       const expanded = expandConstantForReactivity(n.expr, ctx, originFreeIds, scope);
-      const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
+      const reactive = classifyReactivity(expanded.expr, ctx, scope, expanded.freeIds).kind !== "none" || decideWrapFromAstFlags(n).wrap;
       if (!reactive)
         return;
       texts.push({
@@ -15381,9 +15421,9 @@ function anyNameIn(names, set) {
       return true;
   return false;
 }
-function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false, preambleNames, loopIndex) {
+function collectLoopChildReactiveAttrs(node, ctx, 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) {
@@ -15398,7 +15438,7 @@ function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings,
           continue;
         const expanded = expandConstantForReactivity(valueStr, ctx, attr.freeIdentifiers, scope);
         const readsPreamble = preambleNames !== undefined && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
-        const reactive = classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
+        const reactive = classifyReactivity(expanded.expr, ctx, scope, expanded.freeIds).kind !== "none" || readsPreamble || attr.callsReactiveGetters || attr.hasFunctionCalls;
         if (!attr.clientOnly && !reactive)
           continue;
         attrs.push({
@@ -15738,7 +15778,9 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
   const flat = options?.flatBranchMode === true;
   const fixedDepth = options?.templateDepth;
   const collectBindings = options?.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, undefined, outerSpec?.index);
+  const initialScope = { parentSlotId: null, depth: 0, insideCond: false, bindingScope: outerScope };
   for (const root of nodes) {
     walkIR(root, initialScope, {
       element: ({ node: el, scope, descend }) => {
@@ -15754,18 +15796,17 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
       },
       loop: ({ node: n, scope, descend }) => {
         const emitDepth = fixedDepth ?? scope.depth + 1;
-        const loopParamsForTemplate = outerLoopParam ? [outerLoopParam, { param: n.param, bindings: n.paramBindings, index: n.index }] : undefined;
+        const loopParamsForTemplate = outerSpec ? [outerSpec, { param: n.param, bindings: n.paramBindings, index: n.index }] : undefined;
         const template = n.children.map((c) => irToPlaceholderTemplate(c, undefined, emitDepth, loopParamsForTemplate)).join("");
-        const refsOuter = outerLoopParam ? identifierPattern(outerLoopParam).test(n.array) : false;
         const bindings = emptyLoopChildBindings();
         const innerPreambleNames = preambleNamesOf(n);
         if (ctx) {
           for (const child of n.children) {
-            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index));
-            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index));
+            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index, scope.bindingScope));
+            bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings, true, innerPreambleNames, n.index, scope.bindingScope));
             bindings.refs.push(...collectLoopChildRefs(child));
           }
-          bindings.conditionals.push(...collectLoopChildConditionals({ type: "fragment", children: n.children, loc: n.loc }, ctx, siblingOffsets, n.param, n.paramBindings, innerPreambleNames, n.index));
+          bindings.conditionals.push(...collectLoopChildConditionals({ type: "fragment", children: n.children, loc: n.loc }, ctx, siblingOffsets, n.param, n.paramBindings, innerPreambleNames, n.index, loopParamsForTemplate, scope.bindingScope));
         }
         let childComponents;
         if (collectBindings) {
@@ -15807,14 +15848,17 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
           containerSlotId: scope.parentSlotId,
           template,
           preamble: n.preamble,
-          refsOuterParam: refsOuter,
           childComponents,
           insideConditional: !flat && scope.insideCond ? true : undefined,
           offset: flat ? undefined : 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)
+          });
         }
       }
     });
@@ -15823,7 +15867,7 @@ function collectInnerLoops(nodes, siblingOffsets, outerLoopParam, ctx, options)
 }
 function decideLoopRendering(loop, siblingOffsets, ctx) {
   const hasNestedComps = (loop.nestedComponents?.length ?? 0) > 0;
-  const innerLoops = collectInnerLoops(loop.children, siblingOffsets, loop.param, ctx);
+  const innerLoops = collectInnerLoops(loop.children, siblingOffsets, { param: loop.param, bindings: loop.paramBindings, index: loop.index }, ctx);
   const hasInnerLoops = (innerLoops?.length ?? 0) > 0;
   const useElementReconciliation = !loop.childComponent && !loop.isStaticArray && (hasNestedComps || hasInnerLoops);
   return { useElementReconciliation, innerLoops };
@@ -15991,6 +16035,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       }
       const { useElementReconciliation, innerLoops } = projectionInner ? { useElementReconciliation: false, innerLoops: undefined } : decideLoopRendering(l, siblingOffsets, ctx);
       let template = "";
+      let templateIndexed;
       let staticItemTemplate;
       let skeletonTemplate;
       let skeletonPaths;
@@ -16002,6 +16047,10 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
       } else if (l.children[0] && !projectionInner) {
         const loopParamSpec = [{ param: l.param, bindings: l.paramBindings }];
         template = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpec) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpec);
+        if (l.index) {
+          const loopParamSpecIndexed = [{ param: l.param, bindings: l.paramBindings, index: l.index }];
+          templateIndexed = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpecIndexed) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0, loopParamSpecIndexed);
+        }
         if (l.isStaticArray) {
           staticItemTemplate = useElementReconciliation ? irToPlaceholderTemplate(l.children[0], resolveRestSpreadNames(ctx), 0) : irToHtmlTemplate(l.children[0], resolveRestSpreadNames(ctx), 0);
         } else if (!useElementReconciliation && !l.bodyIsMultiRoot && !l.bodyIsItemConditional) {
@@ -16030,6 +16079,7 @@ function collectElements(node, ctx, siblingOffsets, insideConditional = false) {
         iterationShape: l.iterationShape,
         objectIteration: l.objectIteration,
         template,
+        templateIndexed,
         staticItemTemplate,
         skeletonTemplate,
         skeletonPaths,
@@ -16220,6 +16270,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
       const projectionInner = n.method === "flatMap" && n.children.length === 1 && n.children[0].type === "loop" ? n.children[0] : undefined;
       const { useElementReconciliation, innerLoops: innerLoopsCollected } = projectionInner ? { useElementReconciliation: false, innerLoops: undefined } : decideLoopRendering(n, siblingOffsets, undefined);
       let childTemplate;
+      let childTemplateIndexed;
       const branchLoopParamSpec = [{ param: n.param, bindings: n.paramBindings }];
       if (projectionInner) {
         childTemplate = "";
@@ -16228,6 +16279,10 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
       } else {
         childTemplate = n.children.map((c) => irToHtmlTemplate(c, undefined, 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, undefined, 0, branchLoopParamSpecIndexed)).join("");
+      }
       const branchBindings = ctx && !projectionInner ? collectLoopChildBindings(n.children, ctx, siblingOffsets, n.param, n.paramBindings, preambleNamesOf(n), n.index) : emptyLoopChildBindings();
       loops.push({
         kind: "branch",
@@ -16243,6 +16298,7 @@ function collectBranchLoops(node, ctx, siblingOffsets) {
         iterationShape: n.iterationShape,
         objectIteration: n.objectIteration,
         template: childTemplate,
+        templateIndexed: childTemplateIndexed,
         containerSlotId: containerSlot,
         preamble: n.preamble,
         preambleRegions: n.preambleRegions,
@@ -16325,19 +16381,10 @@ function collectLoopChildBindings(children, ctx, siblingOffsets, loopParam, loop
   }
   return bindings;
 }
-function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
+function collectLoopChildConditionals(node, ctx, 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 !== undefined && anyNameIn(scope.valueBoundNames(), freeIds);
   walkIR(node, null, {
     ...stopAt("loop", "async", "ifStatement"),
     conditional: ({ node: n }) => {
@@ -16349,9 +16396,9 @@ function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loop
         return;
       const expanded = expandConstantForReactivity(n.condition, ctx, sourceFreeIds, scope);
       const readsPreamble = preambleNames !== undefined && preambleNames.size > 0 && anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames);
-      if (!readsPreamble && classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind === "none")
+      if (!readsPreamble && classifyReactivity(expanded.expr, ctx, scope, expanded.freeIds).kind === "none")
         return;
-      const loopParamsForCond = loopParam ? [{ param: loopParam, bindings: loopParamBindings, index: loopIndex }] : undefined;
+      const loopParamsForCond = loopParams ?? (loopParam ? [{ param: loopParam, bindings: loopParamBindings, index: loopIndex }] : undefined);
       const whenTrueHtml = irToHtmlTemplate(n.whenTrue, undefined, 0, loopParamsForCond, "__slots");
       const whenFalseHtml = irToHtmlTemplate(n.whenFalse, undefined, 0, loopParamsForCond, "__slots");
       conditionals.push({
@@ -16369,7 +16416,7 @@ function collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loop
   return conditionals;
 }
 function summarizeLoopChildBranch(node, ctx, siblingOffsets, loopParam, loopParamBindings, preambleNames, loopIndex) {
-  const inner = collectInnerLoops([node], siblingOffsets, loopParam, ctx, branchInnerLoopOptions);
+  const inner = collectInnerLoops([node], siblingOffsets, loopParam ? { param: loopParam, bindings: loopParamBindings, index: loopIndex } : undefined, ctx, branchInnerLoopOptions);
   return {
     childComponents: collectConditionalBranchChildComponents(node),
     innerLoops: inner.length > 0 ? inner : undefined,
@@ -19518,6 +19565,7 @@ function buildBranchInnerLoopsPlan(args) {
     condSlotId,
     outerLoopParam,
     outerLoopParamBindings,
+    outerLoopIndex,
     wrapOuter
   } = args;
   if (!innerLoops || innerLoops.length === 0)
@@ -19525,7 +19573,7 @@ function buildBranchInnerLoopsPlan(args) {
   const plan = [];
   for (let i = 0;i < innerLoops.length; i++) {
     const inner = innerLoops[i];
-    if (!inner.refsOuterParam || !inner.template)
+    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);
@@ -19588,18 +19636,20 @@ function buildBranchInnerLoopsPlan(args) {
         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(args) {
-  const { conditionals, scopeVar, wrap, loopParam, loopParamBindings } = args;
+  const { conditionals, scopeVar, wrap, loopParam, loopParamBindings, loopIndex } = args;
   if (!conditionals || conditionals.length === 0)
     return [];
   const plans = [];
@@ -19608,13 +19658,14 @@ function buildLoopChildConditionalsPlan(args) {
       slotId: cond.slotId,
       scopeVar,
       wrappedCondition: wrap(cond.condition),
-      whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
-      whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
+      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({
@@ -19622,8 +19673,10 @@ function buildLoopChildConditionalsPlan(args) {
         wrap,
         loopParam,
         loopParamBindings,
+        loopIndex,
         condId: cond.slotId
-      })
+      }),
+      ...cond.readsPreamble && { readsPreamble: true }
     });
   }
   return plans;
@@ -19647,7 +19700,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 }
       }))
     });
   }
@@ -19662,7 +19716,7 @@ function buildArmTextsPlan(texts, wrap) {
   }));
 }
 function buildLoopChildArmPlan(args) {
-  const { branch, wrap, loopParam, loopParamBindings, condId } = args;
+  const { branch, wrap, loopParam, loopParamBindings, loopIndex, condId } = args;
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
@@ -19678,6 +19732,7 @@ function buildLoopChildArmPlan(args) {
       condSlotId: condId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -19685,7 +19740,8 @@ function buildLoopChildArmPlan(args) {
       scopeVar: "__branchScope",
       wrap,
       loopParam,
-      loopParamBindings
+      loopParamBindings,
+      loopIndex
     }),
     attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
     texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
@@ -19727,10 +19783,10 @@ function buildReactiveEffectsPlan(args) {
       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),
+        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 }
       });
     }
@@ -19742,7 +19798,7 @@ function buildReactiveEffectsPlan(args) {
     profileComponentName
   };
 }
-function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, profileComponentName) {
+function buildOuterArm(branch, wrap, loopParam, loopParamBindings, loopIndex, condSlotId, profileComponentName) {
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
@@ -19759,6 +19815,7 @@ function buildOuterArm(branch, wrap, loopParam, loopParamBindings, condSlotId, p
       condSlotId,
       outerLoopParam: loopParam,
       outerLoopParamBindings: loopParamBindings,
+      outerLoopIndex: loopIndex,
       wrapOuter: wrap
     }),
     nestedConditionals: buildLoopChildConditionalsPlan({
@@ -19766,7 +19823,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)
@@ -19806,8 +19864,8 @@ function wrapAttrValueExpression2(value, wrap) {
   }
 }
 function buildInnerLoopsPlan(args) {
-  const { levels, parentElVar, outerLoopParam, outerLoopParamBindings } = args;
-  const wrapOuter = outerLoopParam ? (expr) => wrapLoopParamAsAccessor(expr, outerLoopParam, outerLoopParamBindings) : (expr) => expr;
+  const { levels, parentElVar, outerLoopParam, outerLoopParamBindings, outerLoopIndex } = args;
+  const wrapOuter = outerLoopParam ? (expr) => wrapLoopParamAsAccessor(expr, outerLoopParam, outerLoopParamBindings, outerLoopIndex) : (expr) => expr;
   const plan = [];
   let i = 0;
   while (i < levels.length) {
@@ -19829,15 +19887,14 @@ function buildInnerLoopsPlan(args) {
     }
     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,
@@ -19851,13 +19908,14 @@ function buildInnerLoopsPlan(args) {
       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);
@@ -19912,7 +19970,7 @@ function buildReactiveEmit(inner, level, wrapOuter, uidSuffix, outerLoopParam, o
     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, {
@@ -19926,7 +19984,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",
@@ -19944,25 +20003,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, undefined, 1, undefined, undefined)
-    }));
-  }
-  return {
-    mode: "static",
-    rawKey: inner.key ?? null,
-    preludeStatements,
-    components: level.comps,
-    events: level.events,
-    childRefs: buildStaticChildRefBindings(inner.bindings.refs)
-  };
-}
 
 // src/ir-to-client-js/control-flow/plan/build-composite-loop.ts
 function buildTopLevelCompositePlan(elem, profileComponentName) {
@@ -19993,7 +20033,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,
@@ -20045,7 +20086,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,
@@ -20558,8 +20600,8 @@ function decideLazyRow(args) {
   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;
@@ -20775,7 +20817,7 @@ function buildPlainRowCore(inputs) {
     scope
   }) ?? undefined;
   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,
@@ -20964,6 +21006,24 @@ function emitAttrUpdate(target, attrName, expression, meta) {
     `{ const __v = ${expression}; if (__v != null) ${target}.setAttribute('${htmlName}', String(__v)); else ${target}.removeAttribute('${htmlName}') }`
   ];
 }
+var DEDUP_STORE_DECL = "const __l = []";
+function dedupGuard(ordinal) {
+  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
+}
+function emitDedupedAttrUpdate(target, attrName, expression, meta, ordinal, guard = dedupGuard(ordinal)) {
+  const write = emitAttrUpdate(target, 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, ctx) {
   if (ctx.propsObjectName)
     return expr;
@@ -21178,16 +21238,18 @@ function emitReactiveAttributeUpdates(lines, ctx) {
     }
     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), ctx);
-        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(ctx, slotId)})`);
+      lines.push(`  }${bindingIdArg(ctx, slotId)}) }`);
       lines.push("");
     }
   }
@@ -21240,6 +21302,7 @@ function emitReactiveChildProps(lines, ctx) {
   if (ctx.reactiveChildProps.length > 0) {
     lines.push("");
     lines.push(`  // Reactive child component props`);
+    lines.push(`  { ${DEDUP_STORE_DECL}`);
     lines.push(`  createEffect(() => {`);
     const propsByComponent = new Map;
     for (const prop of ctx.reactiveChildProps) {
@@ -21249,6 +21312,7 @@ function emitReactiveChildProps(lines, ctx) {
       }
       propsByComponent.get(key).push(prop);
     }
+    let ordinal = 0;
     for (const [, props] of propsByComponent) {
       const first = props[0];
       const isCommentRoot = first.slotId !== null && first.slotId === ctx.commentScopeRootSlotId;
@@ -21260,26 +21324,31 @@ function emitReactiveChildProps(lines, ctx) {
       }
       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(ctx, ctx.reactiveChildProps[0]?.slotId ?? undefined)})`);
+    lines.push(`  }${bindingIdArg(ctx, ctx.reactiveChildProps[0]?.slotId ?? undefined)}) }`);
   }
 }
 
 // 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)}))`);
@@ -21322,7 +21391,7 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       lines.push(`${indent}  __bel${uid}.setAttribute('${keyAttrName(inner.keyDepth)}', String(${inner.wrappedKey}))`);
     }
     if (inner.legacyComponents.length > 0 || inner.legacyEvents.length > 0) {
-      emitComponentAndEventSetup(lines, `${indent}  `, `__bel${uid}`, [...inner.legacyComponents], [...inner.legacyEvents], inner.outerLoopParam, inner.outerLoopParamBindings);
+      emitComponentAndEventSetup(lines, `${indent}  `, `__bel${uid}`, [...inner.legacyComponents], [...inner.legacyEvents], inner.outerLoopParam, inner.outerLoopParamBindings, false, inner.outerLoopIndex);
     }
     const conditionalTexts = inner.reactiveTexts.filter((t) => t.insideConditional);
     const plainTexts = inner.reactiveTexts.filter((t) => !t.insideConditional);
@@ -21339,32 +21408,35 @@ function stringifyBranchInnerLoops(lines, plan, indent, pc) {
       }
     }
     if (inner.nestedConditionals.length > 0) {
-      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc);
+      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc, undefined);
     }
     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);
@@ -21372,10 +21444,10 @@ function stringifyLoopChildArm(lines, arm, armIndent, pc) {
   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) {
@@ -21414,13 +21486,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)})`);
@@ -21456,6 +21530,8 @@ 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((r) => ({ id: r.slotId, kind: "markup", path: [] }))
@@ -21473,15 +21549,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}  }`);
   }
@@ -21510,16 +21585,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)})`);
 }
@@ -21788,24 +21863,14 @@ function emitConditional(lines, ind, mid, c, mode) {
   lines.push(`${ind}  __l[${c.ordinal}] = __x`);
   lines.push(`${ind}} }`);
 }
-function dedupGuard(ordinal) {
-  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
-}
 function emitAttrBinding(lines, ind, a, mode) {
   const target = mode === "create" ? `__r[${a.refIndex}]` : elementAccess(a);
+  const guard = mode === "create" ? null : mode === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
   lines.push(`${ind}{ const __t = ${target}`);
   lines.push(`${ind}if (__t) {`);
-  lines.push(`${ind}  const __x = ${a.wrappedExpression}`);
-  const guard = mode === "create" ? null : mode === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
-  const writeIndent = guard ? `${ind}    ` : `${ind}  `;
-  if (guard)
-    lines.push(`${ind}  if (${guard}) {`);
-  for (const stmt of emitAttrUpdate("__t", a.attrName, "__x", a.meta)) {
-    lines.push(`${writeIndent}${stmt}`);
-  }
-  if (guard)
-    lines.push(`${ind}  }`);
-  lines.push(`${ind}  __l[${a.ordinal}] = __x`);
+  for (const stmt of emitDedupedAttrUpdate("__t", a.attrName, a.wrappedExpression, a.meta, a.ordinal, guard)) {
+    lines.push(`${ind}  ${stmt}`);
+  }
   lines.push(`${ind}} }`);
 }
 function emitTextBinding(lines, ind, t, doorExpr, mode, rwDoor) {
@@ -22095,13 +22160,16 @@ 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)})`);
@@ -22126,18 +22194,12 @@ function stringifyStaticLoop(lines, plan) {
 // 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) => {`);
@@ -22163,7 +22225,7 @@ function emitReactive(lines, inner, indent, pc) {
     lines.push(`${indent}  __innerEl${uid}.setAttribute('${keyAttrName(inner.keyDepth)}', String(${emit.wrappedKey}))`);
   }
   if (emit.components.length > 0 || emit.events.length > 0) {
-    emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings);
+    emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings, false, inner.outerLoopIndex);
   }
   if (inner.childLevels.length > 0) {
     stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc);
@@ -22182,17 +22244,20 @@ 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, undefined);
   }
   emitLoopChildRefs(lines, emit.childRefs, {
     indent: `${indent}  `,
@@ -22202,33 +22267,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('${keyAttrName(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}}) }`);
-}
 
 // src/ir-to-client-js/control-flow/stringify/composite-loop.ts
 function stringifyCompositeLoop(lines, plan) {
@@ -22657,10 +22695,12 @@ function emitArmBody(lines, body, mode, 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)}))`);